feat: port agent teams from PRs anomalyco#12730, anomalyco#12731, anomalyco#12732 to v1.3.0

Port the agent teams feature from the blog post three PRs onto the
latest OpenCode v1.3.0 codebase. Adapts to current architecture:
Effect patterns, branded IDs, and service refactoring.

Core (PR anomalyco#12730): Team state, messaging, recovery, events
Tools (PR anomalyco#12731): 9 MCP tools, HTTP routes, registry integration
TUI (PR anomalyco#12732): Team dialog, sync store extension

Gated behind OPENCODE_EXPERIMENTAL_AGENT_TEAMS flag.

Author: shabarkin

packages/opencode/src/cli/cmd/tui/component/dialog-team.tsx

@@ -0,0 +1,179 @@
+import { useDialog } from "@tui/ui/dialog"
+import { DialogSelect, type DialogSelectOption } from "@tui/ui/dialog-select"
+import { createMemo, onMount, Show } from "solid-js"
+import { useTheme } from "../context/theme"
+import { useSync } from "../context/sync"
+import { useRouteData } from "../context/route"
+import { useRoute } from "../context/route"
+import { useToast } from "../ui/toast"
+import { useSDK } from "../context/sdk"
+
+function statusIcon(status: string): string {
+  switch (status) {
+    case "busy":
+      return "*"
+    case "ready":
+      return "o"
+    case "shutdown_requested":
+      return "!"
+    case "shutdown":
+      return "x"
+    case "completed":
+      return "+"
+    case "in_progress":
+      return ">"
+    case "blocked":
+      return "#"
+    case "cancelled":
+      return "-"
+    case "pending":
+      return " "
+    default:
+      return "?"
+  }
+}
+
+function statusColor(status: string, theme: any): string {
+  switch (status) {
+    case "busy":
+      return theme.primary
+    case "ready":
+      return theme.textMuted
+    case "shutdown_requested":
+      return theme.warning
+    case "shutdown":
+      return theme.error
+    case "completed":
+      return theme.success
+    case "in_progress":
+      return theme.primary
+    case "blocked":
+      return theme.error
+    case "pending":
+      return theme.textMuted
+    default:
+      return theme.textMuted
+  }
+}
+
+export function DialogTeam() {
+  const dialog = useDialog()
+  const { theme } = useTheme()
+  const sync = useSync()
+  const route = useRouteData("session")
+  const nav = useRoute()
+  const toast = useToast()
+  const sdk = useSDK()
+
+  const teamInfo = createMemo(() => sync.data.team[route.sessionID])
+
+  // Refresh team data on open
+  onMount(() => {
+    dialog.setSize("large")
+    fetch(`${sdk.url}/team/by-session/${route.sessionID}`)
+      .then((r: Response) => r.json())
+      .then((data: any) => {
+        if (!data) return
+        sync.set("team", route.sessionID, {
+          teamName: data.team.name,
+          role: data.role,
+          memberName: data.memberName,
+          members: data.team.members ?? [],
+          tasks: data.tasks ?? [],
+        })
+      })
+      .catch(() => {})
+  })
+
+  const options = createMemo((): DialogSelectOption<string>[] => {
+    const info = teamInfo()
+    if (!info) return []
+
+    const memberOptions: DialogSelectOption<string>[] = info.members.map((m) => ({
+      title: `${m.name} (@${m.agent})`,
+      value: `member:${m.sessionID}`,
+      category: "Teammates",
+      footer: `Status: ${m.status}`,
+      gutter: <text fg={statusColor(m.status, theme)}>{statusIcon(m.status)}</text>,
+    }))
+
+    const taskOptions: DialogSelectOption<string>[] = (info.tasks ?? []).map((t) => ({
+      title: t.content,
+      value: `task:${t.id}`,
+      category: "Shared Tasks",
+      footer: [
+        t.status,
+        t.assignee ? `@${t.assignee}` : null,
+        t.depends_on?.length ? `depends: ${t.depends_on.join(", ")}` : null,
+      ]
+        .filter(Boolean)
+        .join(" | "),
+      gutter: <text fg={statusColor(t.status, theme)}>{statusIcon(t.status)}</text>,
+      disabled: t.status === "completed" || t.status === "cancelled",
+    }))
+
+    return [...memberOptions, ...taskOptions]
+  })
+
+  const handleSelect = (option: DialogSelectOption<string>) => {
+    const [type, id] = option.value.split(":", 2)
+    if (type === "member" && id) {
+      dialog.clear()
+      nav.navigate({ type: "session", sessionID: id })
+    }
+  }
+
+  return (
+    <Show
+      when={teamInfo()}
+      fallback={
+        <box paddingLeft={2} paddingRight={2} gap={1} paddingBottom={1}>
+          <box flexDirection="row" justifyContent="space-between">
+            <text fg={theme.text} attributes={1}>
+              Agent Team
+            </text>
+            <text fg={theme.textMuted}>esc</text>
+          </box>
+          <text fg={theme.textMuted}>No active team for this session.</text>
+          <text fg={theme.textMuted}>The lead agent can create a team using the team_create tool.</text>
+        </box>
+      }
+    >
+      <DialogSelect
+        title={`Team: ${teamInfo()!.teamName} (${teamInfo()!.role})`}
+        options={options()}
+        onSelect={handleSelect}
+        keybind={[
+          {
+            keybind: { name: "m", ctrl: false, meta: false, shift: false, leader: false },
+            title: "message",
+            onTrigger: (option) => {
+              const [type] = option.value.split(":", 2)
+              if (type === "member") {
+                toast.show({ message: "Use team_message tool from the prompt to message teammates", variant: "info" })
+              }
+            },
+          },
+          {
+            keybind: { name: "l", ctrl: false, meta: false, shift: false, leader: false },
+            title: "go to lead",
+            onTrigger: () => {
+              const info = teamInfo()
+              if (!info) return
+              // Find lead session: iterate members looking for the session that has role=lead
+              // Or look up from team data
+              for (const [sid, entry] of Object.entries(sync.data.team)) {
+                const e = entry as any
+                if (e?.teamName === info.teamName && e?.role === "lead") {
+                  dialog.clear()
+                  nav.navigate({ type: "session", sessionID: sid })
+                  return
+                }
+              }
+            },
+          },
+        ]}
+      />
+    </Show>
+  )
+}

packages/opencode/src/cli/cmd/tui/context/sync.tsx

@@ -75,6 +75,41 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       vcs: VcsInfo | undefined
       path: Path
       workspaceList: Workspace[]
+      team: {
+        [sessionID: string]: {
+          teamName: string
+          role: "lead" | "member"
+          memberName?: string
+          delegate?: boolean
+          members: Array<{
+            name: string
+            sessionID: string
+            agent: string
+            status: "ready" | "busy" | "shutdown_requested" | "shutdown" | "error"
+            execution_status:
+              | "idle"
+              | "starting"
+              | "running"
+              | "cancel_requested"
+              | "cancelling"
+              | "cancelled"
+              | "completing"
+              | "completed"
+              | "failed"
+              | "timed_out"
+            model?: string
+            planApproval?: "none" | "pending" | "approved" | "rejected"
+          }>
+          tasks: Array<{
+            id: string
+            content: string
+            status: string
+            priority: string
+            assignee?: string
+            depends_on?: string[]
+          }>
+        }
+      }
     }>({
       provider_next: {
         all: [],
@@ -103,6 +138,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       vcs: undefined,
       path: { state: "", config: "", worktree: "", directory: "" },
       workspaceList: [],
+      team: {},
     })
 
     const sdk = useSDK()
@@ -349,6 +385,24 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           setStore("vcs", { branch: event.properties.branch })
           break
         }
+
+      }
+
+      // Team events — handled outside the typed switch since team event types
+      // aren't in the SDK event union yet (they come from BusEvent.define in team/events.ts)
+      const type = (event as { type: string }).type
+      if (type.startsWith("team.")) {
+        // Refresh team data from the server for all active sessions
+        for (const sessionID of Object.keys(store.session_status)) {
+          fetch(`/team/by-session/${sessionID}`)
+            .then((res) => res.ok ? res.json() : null)
+            .then((data) => {
+              if (data) {
+                setStore("team", sessionID, reconcile(data as any))
+              }
+            })
+            .catch(() => {})
+        }
       }
     })
 

packages/opencode/src/flag/flag.ts

@@ -66,6 +66,7 @@ export namespace Flag {
     Config.withDefault(false),
   )
   export const OPENCODE_EXPERIMENTAL_PLAN_MODE = OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_PLAN_MODE")
+  export declare const OPENCODE_EXPERIMENTAL_AGENT_TEAMS: boolean
   export const OPENCODE_EXPERIMENTAL_WORKSPACES = OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_WORKSPACES")
   export const OPENCODE_EXPERIMENTAL_MARKDOWN = !falsy("OPENCODE_EXPERIMENTAL_MARKDOWN")
   export const OPENCODE_MODELS_URL = process.env["OPENCODE_MODELS_URL"]
@@ -126,3 +127,14 @@ Object.defineProperty(Flag, "OPENCODE_CLIENT", {
   enumerable: true,
   configurable: false,
 })
+
+// Dynamic getter for OPENCODE_EXPERIMENTAL_AGENT_TEAMS
+// This must be evaluated at access time, not module load time,
+// because integration tests and external tooling may set this env var at runtime
+Object.defineProperty(Flag, "OPENCODE_EXPERIMENTAL_AGENT_TEAMS", {
+  get() {
+    return Flag.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_AGENT_TEAMS")
+  },
+  enumerable: true,
+  configurable: false,
+})

packages/opencode/src/id/id.ts

@@ -12,6 +12,7 @@ export namespace Identifier {
     pty: "pty",
     tool: "tool",
     workspace: "wrk",
+    team: "tea",
   } as const
 
   export function schema(prefix: keyof typeof prefixes) {

packages/opencode/src/project/bootstrap.ts

@@ -11,6 +11,7 @@ import { Command } from "../command"
 import { Instance } from "./instance"
 import { Log } from "@/util/log"
 import { ShareNext } from "@/share/share-next"
+import { Flag } from "@/flag/flag"
 
 export async function InstanceBootstrap() {
   Log.Default.info("bootstrapping", { directory: Instance.directory })
@@ -28,4 +29,25 @@ export async function InstanceBootstrap() {
       Project.setInitialized(Instance.project.id)
     }
   })
+
+  // Team features — order matters:
+  // 1. onCleanedRestorePermissions() registers synchronously so it's ready
+  //    before recover(), which could trigger cleanup if all members are shutdown.
+  // 2. recover() marks stale busy executions as cancelled, transitions members to ready, and notifies leads.
+  // 3. autoCleanup() subscribes AFTER recover finishes (.finally()) to avoid
+  //    spurious MemberStatusChanged events during recovery triggering premature cleanup.
+  // Fire-and-forget: don't block bootstrap completion.
+  if (Flag.OPENCODE_EXPERIMENTAL_AGENT_TEAMS) {
+    // Dynamic import — only load team module when the feature flag is enabled
+    import("../team").then(({ Team }) => {
+      Team.onCleanedRestorePermissions()
+      Team.recover()
+        .catch((err) => {
+          Log.Default.warn("team recovery failed", { error: err instanceof Error ? err.message : err })
+        })
+        .finally(() => {
+          Team.autoCleanup()
+        })
+    })
+  }
 }