refactor(tui): break plugin registry cycle

packages/cli/src/acp/event.ts

@@ -1,4 +1,4 @@
-import type { AgentSideConnection, PromptResponse, SessionUpdate } from "@agentclientprotocol/sdk"
+import type { AgentSideConnection, PromptResponse } from "@agentclientprotocol/sdk"
 import type {
   EventSubscribeOutput,
   OpenCodeClient,
@@ -37,34 +37,6 @@ export type TurnStart =
   | { readonly type: "skill"; readonly id: string }
   | { readonly type: "compaction"; readonly id: string }
 
-export const ChildSessionUpdatesCapability = "opencode/child-session-updates"
-export const ChildSessionUpdateMethod = "opencode/session/child_update"
-
-type ChildSessionUpdateBase = {
-  readonly rootSessionId: string
-  readonly childSessionId: string
-  readonly parentSessionId: string
-  readonly depth: number
-  readonly title?: string
-}
-
-export type ChildSessionUpdate = ChildSessionUpdateBase &
-  (
-    | { readonly type: "update"; readonly update: SessionUpdate }
-    | {
-        readonly type: "status"
-        readonly status: "created" | "running" | "completed" | "failed" | "interrupted"
-        readonly error?: { readonly type: string; readonly message: string }
-      }
-  )
-
-type ChildSession = {
-  readonly id: string
-  readonly parentID: string
-  readonly depth: number
-  readonly title?: string
-}
-
 function emptyToolState(): ToolState {
   return { name: "tool", input: {}, metadata: {}, content: [] }
 }
@@ -78,13 +50,8 @@ export async function streamTurn(input: {
   readonly writeTextFile: boolean
   readonly submit: (signal: AbortSignal) => Promise<unknown>
   readonly control: TurnControl
-  readonly childSessionUpdate?: (update: ChildSessionUpdate) => Promise<void>
-  readonly connectionSignal?: AbortSignal
-  readonly sessionSignal?: AbortSignal
 }): Promise<PromptResponse> {
   const streamController = new AbortController()
-  const connectionAbort = () => streamController.abort()
-  input.connectionSignal?.addEventListener("abort", connectionAbort, { once: true })
   const stream = input.client.event.subscribe({ signal: streamController.signal })[Symbol.asyncIterator]()
   const connected = await stream.next()
   if (connected.done) throw new Error("event stream disconnected before prompt admission")
@@ -95,113 +62,47 @@ export async function streamTurn(input: {
   let finish: SessionMessageAssistant["finish"]
   let executionError: { readonly type: string; readonly message: string } | undefined
   const tools = new Map<string, ToolState>()
-  const children = new Map<string, ChildSession>()
-  const openChildren = new Set<string>()
-  let standard = true
-  let handedOff = false
 
-  const notifyChild = async (
-    child: ChildSession,
-    value:
-      | { readonly type: "update"; readonly update: SessionUpdate }
-      | {
-          readonly type: "status"
-          readonly status: "created" | "running" | "completed" | "failed" | "interrupted"
-          readonly error?: { readonly type: string; readonly message: string }
-        },
-  ) => {
-    if (!input.childSessionUpdate) return
-    await input
-      .childSessionUpdate({
-        rootSessionId: input.sessionID,
-        childSessionId: child.id,
-        parentSessionId: child.parentID,
-        depth: child.depth,
-        ...(child.title ? { title: child.title } : {}),
-        ...value,
-      })
-      .catch(() => {})
-  }
+  const update = (value: Parameters<Connection["sessionUpdate"]>[0]["update"]) =>
+    input.connection.sessionUpdate({ sessionId: input.sessionID, update: value })
 
-  const updateSession = async (value: SessionUpdate, child?: ChildSession) => {
-    const projected = child ? projectChildUpdate(value, child) : value
-    if (standard && (!child || !input.childSessionUpdate)) {
-      await input.connection.sessionUpdate({ sessionId: input.sessionID, update: projected })
-    }
-    if (child) await notifyChild(child, { type: "update", update: projected })
-  }
-
-  const consume = async (mode: "turn" | "background") => {
+  const consume = async () => {
     while (!streamController.signal.aborted) {
       const next = await stream.next()
       if (next.done) throw new Error("event stream disconnected during prompt execution")
       const event = next.value
-      if (event.type === "session.created") {
-        const parentID = event.data.info.parentID
-        if (!parentID) continue
-        const parent = parentID === input.sessionID ? undefined : children.get(parentID)
-        if ((mode === "turn" && parentID === input.sessionID) || parent) {
-          const child = {
-            id: event.data.sessionID,
-            parentID,
-            depth: parent ? parent.depth + 1 : 1,
-            title: event.data.info.title,
-          }
-          children.set(child.id, child)
-          openChildren.add(child.id)
-          await notifyChild(child, { type: "status", status: "created" })
-        }
-        continue
-      }
-
-      const eventSessionID = sessionID(event)
-      const child = eventSessionID ? children.get(eventSessionID) : undefined
-      const send = (update: SessionUpdate) => updateSession(update, child)
-      if (mode === "background" && !child) continue
-
-      if (event.type === "permission.asked" && (event.data.sessionID === input.sessionID || child)) {
-        const tool = event.data.source?.callID
-          ? tools.get(toolKey(event.data.sessionID, event.data.source.callID))
-          : undefined
+      if (event.type === "permission.asked" && event.data.sessionID === input.sessionID) {
+        const tool = event.data.source?.callID ? tools.get(event.data.source.callID) : undefined
         await replyPermission({
           client: input.client,
           connection: input.connection,
           event,
-          sessionID: event.data.sessionID,
-          clientSessionID: input.sessionID,
+          sessionID: input.sessionID,
           cwd: input.cwd,
           tool,
-          ...(child ? { toolCallPrefix: child.id, titlePrefix: child.title } : {}),
         })
         continue
       }
-      if (event.type === "form.created" && (event.data.form.sessionID === input.sessionID || child)) {
+      if (event.type === "form.created" && event.data.form.sessionID === input.sessionID) {
         await input.client.form
-          .cancel({ sessionID: event.data.form.sessionID, formID: event.data.form.id })
-          .catch(() => input.client.session.interrupt({ sessionID: event.data.form.sessionID }).catch(() => {}))
+          .cancel({ sessionID: input.sessionID, formID: event.data.form.id })
+          .catch(() => input.client.session.interrupt({ sessionID: input.sessionID }).catch(() => {}))
         continue
       }
-      if (!eventSessionID || (eventSessionID !== input.sessionID && !child)) continue
+      if (!("sessionID" in event.data) || event.data.sessionID !== input.sessionID) continue
       if (matchesStart(event, input.start)) {
         started = true
         continue
       }
       if (!started) continue
 
-      if (event.type === "session.execution.started") {
-        if (child) {
-          await notifyChild(child, { type: "status", status: "running" })
-        }
-        continue
-      }
-
       if (event.type === "session.step.started") {
-        if (!child) assistantMessageID = event.data.assistantMessageID
+        assistantMessageID = event.data.assistantMessageID
         continue
       }
       if (event.type === "session.text.delta") {
-        if (!child) assistantMessageID = event.data.assistantMessageID
-        await send({
+        assistantMessageID = event.data.assistantMessageID
+        await update({
           sessionUpdate: "agent_message_chunk",
           messageId: event.data.assistantMessageID,
           content: { type: "text", text: event.data.delta },
@@ -209,8 +110,8 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.reasoning.delta") {
-        if (!child) assistantMessageID = event.data.assistantMessageID
-        await send({
+        assistantMessageID = event.data.assistantMessageID
+        await update({
           sessionUpdate: "agent_thought_chunk",
           messageId: event.data.assistantMessageID,
           content: { type: "text", text: event.data.delta },
@@ -218,14 +119,9 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.input.started") {
-        if (!child) assistantMessageID = event.data.assistantMessageID
-        tools.set(toolKey(event.data.sessionID, event.data.callID), {
-          name: event.data.name,
-          input: {},
-          metadata: {},
-          content: [],
-        })
-        await send({
+        assistantMessageID = event.data.assistantMessageID
+        tools.set(event.data.callID, { name: event.data.name, input: {}, metadata: {}, content: [] })
+        await update({
           sessionUpdate: "tool_call",
           ...pendingToolCall({
             toolCallId: event.data.callID,
@@ -237,12 +133,11 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.called") {
-        if (!child) assistantMessageID = event.data.assistantMessageID
-        const key = toolKey(event.data.sessionID, event.data.callID)
-        const current = tools.get(key) ?? emptyToolState()
+        assistantMessageID = event.data.assistantMessageID
+        const current = tools.get(event.data.callID) ?? emptyToolState()
         current.input = event.data.input
-        tools.set(key, current)
-        await send({
+        tools.set(event.data.callID, current)
+        await update({
           sessionUpdate: "tool_call_update",
           ...runningToolUpdate({
             toolCallId: event.data.callID,
@@ -254,10 +149,10 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.progress") {
-        const current = tools.get(toolKey(event.data.sessionID, event.data.callID))
+        const current = tools.get(event.data.callID)
         if (!current) continue
         current.metadata = event.data.metadata
-        await send({
+        await update({
           sessionUpdate: "tool_call_update",
           ...runningToolUpdate({
             toolCallId: event.data.callID,
@@ -269,9 +164,8 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.success") {
-        const key = toolKey(event.data.sessionID, event.data.callID)
-        const current = tools.get(key) ?? emptyToolState()
-        tools.delete(key)
+        const current = tools.get(event.data.callID) ?? emptyToolState()
+        tools.delete(event.data.callID)
         await syncEditedFiles({
           connection: input.connection,
           writeTextFile: input.writeTextFile,
@@ -281,7 +175,7 @@ export async function streamTurn(input: {
           toolInput: current.input,
           metadata: event.data.metadata ?? {},
         }).catch(() => {})
-        await send({
+        await update({
           sessionUpdate: "tool_call_update",
           ...completedToolUpdate({
             toolCallId: event.data.callID,
@@ -294,10 +188,9 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.failed") {
-        const key = toolKey(event.data.sessionID, event.data.callID)
-        const current = tools.get(key) ?? emptyToolState()
-        tools.delete(key)
-        await send({
+        const current = tools.get(event.data.callID) ?? emptyToolState()
+        tools.delete(event.data.callID)
+        await update({
           sessionUpdate: "tool_call_update",
           ...errorToolUpdate({
             toolCallId: event.data.callID,
@@ -312,33 +205,13 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.step.ended") {
-        if (!child) {
-          assistantMessageID = event.data.assistantMessageID
-          finish = event.data.finish
-        }
-        continue
-      }
-      if (event.type === "session.execution.succeeded") {
-        if (!child) return "succeeded" as const
-        openChildren.delete(child.id)
-        await notifyChild(child, { type: "status", status: "completed" })
-        if (mode === "background" && openChildren.size === 0) return "succeeded" as const
-        continue
-      }
-      if (event.type === "session.execution.interrupted") {
-        if (!child) return "interrupted" as const
-        openChildren.delete(child.id)
-        await notifyChild(child, { type: "status", status: "interrupted" })
-        if (mode === "background" && openChildren.size === 0) return "interrupted" as const
+        assistantMessageID = event.data.assistantMessageID
+        finish = event.data.finish
         continue
       }
+      if (event.type === "session.execution.succeeded") return "succeeded" as const
+      if (event.type === "session.execution.interrupted") return "interrupted" as const
       if (event.type === "session.execution.failed") {
-        if (child) {
-          openChildren.delete(child.id)
-          await notifyChild(child, { type: "status", status: "failed", error: event.data.error })
-          if (mode === "background" && openChildren.size === 0) return "failed" as const
-          continue
-        }
         executionError = event.data.error
         return "failed" as const
       }
@@ -346,13 +219,7 @@ export async function streamTurn(input: {
     return "interrupted" as const
   }
 
-  const completed = consume("turn")
-  const closeStream = async () => {
-    streamController.abort()
-    input.connectionSignal?.removeEventListener("abort", connectionAbort)
-    input.sessionSignal?.removeEventListener("abort", connectionAbort)
-    await stream.return?.(undefined).catch(() => {})
-  }
+  const completed = consume()
   try {
     await input.submit(control.admission.signal).catch((error) => {
       if (!control.cancelled) throw error
@@ -366,14 +233,6 @@ export async function streamTurn(input: {
       }
     }
     const terminal = await completed
-    if (input.childSessionUpdate && openChildren.size > 0 && !input.sessionSignal?.aborted) {
-      standard = false
-      handedOff = true
-      input.sessionSignal?.addEventListener("abort", connectionAbort, { once: true })
-      void consume("background")
-        .catch(() => {})
-        .finally(closeStream)
-    }
     const assistant = assistantMessageID
       ? await input.client.session
           .message({ sessionID: input.sessionID, messageID: assistantMessageID })
@@ -391,37 +250,11 @@ export async function streamTurn(input: {
     await completed.catch(() => {})
     throw error
   } finally {
-    if (!handedOff) await closeStream()
+    streamController.abort()
+    await stream.return?.(undefined).catch(() => {})
   }
 }
 
-function sessionID(event: EventSubscribeOutput) {
-  if ("sessionID" in event.data && typeof event.data.sessionID === "string") return event.data.sessionID
-  if (event.type === "form.created") return event.data.form.sessionID
-  return undefined
-}
-
-function toolKey(sessionID: string, callID: string) {
-  return `${sessionID}:${callID}`
-}
-
-function projectChildUpdate(update: SessionUpdate, child: ChildSession) {
-  update._meta = {
-    ...update._meta,
-    "opencode/child-session": {
-      id: child.id,
-      parentID: child.parentID,
-      depth: child.depth,
-      ...(child.title ? { title: child.title } : {}),
-    },
-  }
-  if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") {
-    update.toolCallId = `${child.id}:${update.toolCallId}`
-    if (update.title && child.title) update.title = `${child.title}: ${update.title}`
-  }
-  return update
-}
-
 export async function replayMessages(
   connection: Pick<AgentSideConnection, "sessionUpdate">,
   sessionID: string,

packages/cli/src/acp/permission.ts

@@ -20,30 +20,20 @@ export async function replyPermission(input: {
   readonly connection: Connection
   readonly event: PermissionEvent
   readonly sessionID: string
-  readonly clientSessionID?: string
   readonly cwd: string
   readonly tool?: Tool
-  readonly toolCallPrefix?: string
-  readonly titlePrefix?: string
 }) {
   const toolName = input.tool?.name ?? input.event.data.action
   const toolInput = { ...input.event.data.metadata, ...input.tool?.input }
   const previews = await permissionPreviews(toolName, toolInput, input.cwd)
   const result = await input.connection
     .requestPermission({
-      sessionId: input.clientSessionID ?? input.sessionID,
+      sessionId: input.sessionID,
       toolCall: {
         ...pendingToolCall({
-          toolCallId: [input.toolCallPrefix, input.event.data.source?.callID ?? input.event.data.id]
-            .filter((value) => value !== undefined)
-            .join(":"),
+          toolCallId: input.event.data.source?.callID ?? input.event.data.id,
           toolName,
-          state: {
-            input: toolInput,
-            title: [input.titlePrefix, permissionTitle(toolName, toolInput, previews)]
-              .filter((value) => value !== undefined)
-              .join(": "),
-          },
+          state: { input: toolInput, title: permissionTitle(toolName, toolInput, previews) },
           cwd: input.cwd,
         }),
         locations: permissionLocations(toolName, toolInput, input.event.data.resources, input.cwd, previews),

packages/cli/src/acp/service.ts

@@ -43,21 +43,13 @@ import { OPENCODE_VERSION } from "../version"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import { buildConfigOptions, parseModelSelection, type ConfigOptionProvider } from "./config-option"
 import { promptContentToParts } from "./content"
-import {
-  ChildSessionUpdateMethod,
-  ChildSessionUpdatesCapability,
-  replayMessages,
-  streamTurn,
-  type ChildSessionUpdate,
-  type TurnControl,
-  type TurnStart,
-} from "./event"
+import { replayMessages, streamTurn, type TurnControl, type TurnStart } from "./event"
 import { ACPError } from "./error"
 
 export const AuthMethodID = "opencode-login"
 
 type Connection = Pick<AgentSideConnection, "sessionUpdate" | "requestPermission"> &
-  Partial<Pick<AgentSideConnection, "writeTextFile" | "extNotification" | "signal">>
+  Partial<Pick<AgentSideConnection, "writeTextFile">>
 
 type Catalog = {
   readonly providers: ConfigOptionProvider[]
@@ -72,7 +64,6 @@ type Catalog = {
 type Attached = {
   readonly id: string
   readonly cwd: string
-  readonly abort: AbortController
   catalog: Catalog
   model: ModelRef
   modeID: string
@@ -109,7 +100,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
   const catalogs = new Map<string, Promise<Catalog>>()
   const registeredMcp = new Map<string, Set<string>>()
   const active = new Map<string, TurnControl>()
-  const capabilities = { writeTextFile: false, childSessionUpdates: false }
+  const capabilities = { writeTextFile: false }
 
   const catalog = (cwd: string) => {
     const cached = catalogs.get(cwd)
@@ -130,11 +121,9 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
 
   const attach = async (session: SessionInfo, cwd: string, mcpServers: readonly McpServer[]) => {
     const currentCatalog = await catalog(cwd)
-    sessions.get(session.id)?.abort.abort()
     const state: Attached = {
       id: session.id,
       cwd,
-      abort: new AbortController(),
       catalog: currentCatalog,
       model: session.model ?? currentCatalog.defaultModel,
       modeID: session.agent ?? currentCatalog.defaultModeID,
@@ -172,7 +161,6 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
   return {
     initialize: async (params) => {
       capabilities.writeTextFile = params.clientCapabilities?.fs?.writeTextFile === true
-      capabilities.childSessionUpdates = params.clientCapabilities?._meta?.[ChildSessionUpdatesCapability] === true
       const authMethod: AuthMethod = {
         description: "Run `opencode auth login` in the terminal",
         name: "Login with opencode",
@@ -190,7 +178,6 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
           mcpCapabilities: { http: true, sse: false },
           promptCapabilities: { embeddedContext: true, image: true },
           sessionCapabilities: { close: {}, delete: {}, fork: {}, list: {}, resume: {} },
-          _meta: { [ChildSessionUpdatesCapability]: true },
         },
         authMethods: [authMethod],
         agentInfo: { name: "OpenCode", version: OPENCODE_VERSION },
@@ -237,7 +224,6 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
       await input.client.session.remove({ sessionID: params.sessionId }).catch((error) => {
         if (!isSessionNotFoundError(error)) throw error
       })
-      sessions.get(params.sessionId)?.abort.abort()
       sessions.delete(params.sessionId)
       registeredMcp.delete(params.sessionId)
       return {}
@@ -248,7 +234,6 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
       return { configOptions: configOptions(state) }
     },
     closeSession: async (params) => {
-      sessions.get(params.sessionId)?.abort.abort()
       sessions.delete(params.sessionId)
       registeredMcp.delete(params.sessionId)
       const turn = active.get(params.sessionId)
@@ -311,7 +296,6 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
       const messageID = SessionMessage.ID.create()
       const prepared = preparePrompt(state.catalog, params.prompt, messageID)
       const control: TurnControl = { cancelled: false, admission: new AbortController() }
-      const extNotification = input.connection.extNotification
       active.set(state.id, control)
       const response = await streamTurn({
         client: input.client,
@@ -321,15 +305,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
         start: prepared.start,
         writeTextFile: capabilities.writeTextFile,
         control,
-        connectionSignal: input.connection.signal,
-        sessionSignal: state.abort.signal,
         submit: (signal) => submitPrompt(input.client, state, prepared, signal),
-        ...(capabilities.childSessionUpdates && extNotification
-          ? {
-              childSessionUpdate: (update: ChildSessionUpdate) =>
-                extNotification(ChildSessionUpdateMethod, update).then(() => {}),
-            }
-          : {}),
       }).finally(() => {
         if (active.get(state.id) === control) active.delete(state.id)
       })

packages/cli/test/acp/event-behavior.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test"
 import type { AgentSideConnection } from "@agentclientprotocol/sdk"
 import type { SessionMessageInfo } from "@opencode-ai/client/promise"
 import { resolve } from "node:path"
-import { replayMessages, streamTurn, type ChildSessionUpdate, type TurnControl } from "../../src/acp/event"
+import { replayMessages, streamTurn, type TurnControl } from "../../src/acp/event"
 import { createSseFixture, durableEvent, ephemeralEvent, withTimeout } from "./sse-fixture"
 
 type SessionUpdateParams = Parameters<AgentSideConnection["sessionUpdate"]>[0]
@@ -191,181 +191,6 @@ describe("acp event behavior", () => {
     }
   })
 
-  test("projects foreground child session updates onto the parent turn", async () => {
-    const updates: SessionUpdateParams[] = []
-    const fixture = createSseFixture({
-      onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_parent", inputID: id }))
-        send(
-          durableEvent("session.created", {
-            sessionID: "ses_child",
-            info: childSession("ses_child", "ses_parent", "Explore code"),
-          }),
-        )
-        send(durableEvent("session.execution.started", { sessionID: "ses_child" }))
-        send(
-          durableEvent("session.tool.input.started", {
-            sessionID: "ses_child",
-            assistantMessageID: "msg_child",
-            callID: "call_read",
-            name: "read",
-          }),
-        )
-        send(
-          durableEvent("session.tool.called", {
-            sessionID: "ses_child",
-            assistantMessageID: "msg_child",
-            callID: "call_read",
-            input: { path: "/workspace/src/index.ts" },
-            executed: false,
-          }),
-        )
-        send(
-          durableEvent("session.tool.success", {
-            sessionID: "ses_child",
-            assistantMessageID: "msg_child",
-            callID: "call_read",
-            metadata: {},
-            content: [{ type: "text", text: "source" }],
-            executed: true,
-          }),
-        )
-        send(durableEvent("session.execution.succeeded", { sessionID: "ses_child" }))
-        send(durableEvent("session.execution.succeeded", { sessionID: "ses_parent" }))
-      },
-    })
-
-    try {
-      const response = await turn({
-        fixture,
-        connection: recordingConnection(updates),
-        sessionID: "ses_parent",
-        inputID: "input_parent",
-      })
-
-      expect(updates.map((item) => [item.sessionId, item.update.sessionUpdate])).toEqual([
-        ["ses_parent", "tool_call"],
-        ["ses_parent", "tool_call_update"],
-        ["ses_parent", "tool_call_update"],
-      ])
-      expect(updates.map((item) => ("toolCallId" in item.update ? item.update.toolCallId : undefined))).toEqual([
-        "ses_child:call_read",
-        "ses_child:call_read",
-        "ses_child:call_read",
-      ])
-      expect(updates[0]?.update).toMatchObject({
-        title: "Explore code: read",
-        _meta: {
-          "opencode/child-session": {
-            id: "ses_child",
-            parentID: "ses_parent",
-            depth: 1,
-            title: "Explore code",
-          },
-        },
-      })
-      expect(response.stopReason).toBe("end_turn")
-    } finally {
-      await fixture.stop()
-    }
-  })
-
-  test("continues child extension updates after the parent turn ends", async () => {
-    const updates: SessionUpdateParams[] = []
-    const childUpdates: ChildSessionUpdate[] = []
-    const completed = Promise.withResolvers<void>()
-    const fixture = createSseFixture({
-      onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_parent", inputID: id }))
-        send(
-          durableEvent("session.created", {
-            sessionID: "ses_background",
-            info: childSession("ses_background", "ses_parent", "Background research"),
-          }),
-        )
-        send(durableEvent("session.execution.succeeded", { sessionID: "ses_parent" }))
-      },
-    })
-
-    try {
-      const response = await turn({
-        fixture,
-        connection: recordingConnection(updates),
-        sessionID: "ses_parent",
-        inputID: "input_parent",
-        childSessionUpdate: async (update) => {
-          childUpdates.push(update)
-          if (update.type === "status" && update.status === "completed") completed.resolve()
-        },
-      })
-      expect(response.stopReason).toBe("end_turn")
-
-      fixture.send(
-        durableEvent("session.created", {
-          sessionID: "ses_future",
-          info: childSession("ses_future", "ses_parent", "Later turn child"),
-        }),
-      )
-      fixture.send(durableEvent("session.execution.started", { sessionID: "ses_future" }))
-      fixture.send(durableEvent("session.execution.started", { sessionID: "ses_background" }))
-      fixture.send(
-        durableEvent("session.tool.input.started", {
-          sessionID: "ses_background",
-          assistantMessageID: "msg_background",
-          callID: "call_shell",
-          name: "shell",
-        }),
-      )
-      fixture.send(
-        durableEvent("session.tool.called", {
-          sessionID: "ses_background",
-          assistantMessageID: "msg_background",
-          callID: "call_shell",
-          input: { command: "pwd" },
-          executed: false,
-        }),
-      )
-      fixture.send(
-        durableEvent("session.tool.success", {
-          sessionID: "ses_background",
-          assistantMessageID: "msg_background",
-          callID: "call_shell",
-          metadata: { exit: 0 },
-          content: [{ type: "text", text: "/workspace" }],
-          executed: true,
-        }),
-      )
-      fixture.send(durableEvent("session.execution.succeeded", { sessionID: "ses_background" }))
-      await withTimeout(completed.promise, "background child completion was not delivered")
-
-      expect(updates).toEqual([])
-      expect(
-        childUpdates.map((update) =>
-          update.type === "status" ? [update.type, update.status] : [update.type, update.update.sessionUpdate],
-        ),
-      ).toEqual([
-        ["status", "created"],
-        ["status", "running"],
-        ["update", "tool_call"],
-        ["update", "tool_call_update"],
-        ["update", "tool_call_update"],
-        ["status", "completed"],
-      ])
-      expect(childUpdates[2]).toMatchObject({
-        rootSessionId: "ses_parent",
-        childSessionId: "ses_background",
-        parentSessionId: "ses_parent",
-        depth: 1,
-        title: "Background research",
-        type: "update",
-        update: { toolCallId: "ses_background:call_shell" },
-      })
-      expect(childUpdates.some((update) => update.childSessionId === "ses_future")).toBe(false)
-    } finally {
-      await fixture.stop()
-    }
-  })
-
   test("streams tool pending, progress, success, and failure updates", async () => {
     const updates: SessionUpdateParams[] = []
     const fixture = createSseFixture({
@@ -731,7 +556,6 @@ function turn(input: {
   readonly connection: Connection
   readonly sessionID: string
   readonly inputID: string
-  readonly childSessionUpdate?: (update: ChildSessionUpdate) => Promise<void>
 }) {
   return streamTurn({
     client: input.fixture.client,
@@ -741,25 +565,11 @@ function turn(input: {
     start: { type: "input", id: input.inputID },
     writeTextFile: false,
     control: { cancelled: false, admission: new AbortController() },
-    childSessionUpdate: input.childSessionUpdate,
     submit: (signal) =>
       input.fixture.client.session.prompt({ sessionID: input.sessionID, id: input.inputID, text: "hello" }, { signal }),
   })
 }
 
-function childSession(id: string, parentID: string, title: string) {
-  return {
-    id,
-    slug: id,
-    projectID: "project",
-    directory: "/workspace",
-    parentID,
-    title,
-    version: "test",
-    time: { created: 1, updated: 1 },
-  }
-}
-
 function tokens() {
   return { input: 1, output: 1, reasoning: 0, cache: { read: 0, write: 0 } }
 }

packages/cli/test/acp/permission-behavior.test.ts

@@ -153,68 +153,6 @@ describe("acp permission behavior", () => {
     }
   })
 
-  test("routes foreground child permissions through the parent ACP session", async () => {
-    const permissionRequests: RequestPermissionRequest[] = []
-    const fixture = createSseFixture({
-      onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_parent", inputID: id }))
-        send(
-          durableEvent("session.created", {
-            sessionID: "ses_child",
-            info: {
-              id: "ses_child",
-              slug: "ses_child",
-              projectID: "project",
-              directory: "/workspace",
-              parentID: "ses_parent",
-              title: "Review code",
-              version: "test",
-              time: { created: 1, updated: 1 },
-            },
-          }),
-        )
-        send(durableEvent("session.execution.started", { sessionID: "ses_child" }))
-        send(
-          permissionAsked("ses_child", "perm_child", {
-            action: "read",
-            metadata: { path: "/workspace/child.ts" },
-            source: { type: "tool", messageID: "msg_child", callID: "call_child" },
-          }),
-        )
-        send(durableEvent("session.execution.succeeded", { sessionID: "ses_child" }))
-        send(durableEvent("session.execution.succeeded", { sessionID: "ses_parent" }))
-      },
-    })
-    const connection = {
-      sessionUpdate: async () => {},
-      requestPermission: async (request) => {
-        permissionRequests.push(request)
-        return { outcome: { outcome: "selected", optionId: "once" } } as const
-      },
-    } satisfies Connection
-
-    try {
-      await startTurn(fixture, connection, "ses_parent", "input_parent")
-
-      expect(permissionRequests).toHaveLength(1)
-      expect(permissionRequests[0]).toMatchObject({
-        sessionId: "ses_parent",
-        toolCall: {
-          toolCallId: "ses_child:call_child",
-          title: "Review code: /workspace/child.ts",
-        },
-      })
-      expect(fixture.requests).toContainEqual(
-        expect.objectContaining({
-          method: "POST",
-          path: "/api/session/ses_child/permission/perm_child/reply",
-        }),
-      )
-    } finally {
-      await fixture.stop()
-    }
-  })
-
   test("previews edits during approval and syncs the completed file", async () => {
     const cwd = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-acp-permission-"))
     const file = path.join(cwd, "file.ts")

packages/cli/test/acp/service.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test"
 import type { AgentSideConnection } from "@agentclientprotocol/sdk"
 import { OpenCode } from "@opencode-ai/client/promise"
 import { ACPService } from "../../src/acp/service"
-import { ChildSessionUpdatesCapability } from "../../src/acp/event"
 
 describe("acp service", () => {
   test("creates a v2 session, registers mcp, and publishes commands", async () => {
@@ -40,17 +39,11 @@ describe("acp service", () => {
     })
 
     try {
-      const initialized = await service.initialize({
-        protocolVersion: 1,
-        clientCapabilities: { _meta: { [ChildSessionUpdatesCapability]: true } },
-        clientInfo: { name: "test", version: "1" },
-      })
       const result = await service.newSession({
         cwd: "/workspace",
         mcpServers: [{ name: "docs", command: "bun", args: ["docs.ts"], env: [{ name: "TOKEN", value: "x" }] }],
       })
       expect(result.sessionId).toBe("ses_acp")
-      expect(initialized.agentCapabilities?._meta).toEqual({ [ChildSessionUpdatesCapability]: true })
       expect(result.configOptions?.map((option) => option.id)).toEqual(["model", "effort", "mode"])
       expect(requests).toContainEqual({
         method: "PUT",

packages/tui/src/app.tsx

@@ -83,7 +83,8 @@ import { ArgsProvider, useArgs, type Args } from "./context/args"
 import open from "open"
 import { PromptRefProvider, usePromptRef } from "./context/prompt"
 import { Config, ConfigProvider, useConfig } from "./config"
-import { PluginProvider, usePlugin, type PackageResolver } from "./plugin/context"
+import { PluginProvider, type PackageResolver } from "./plugin/context"
+import { usePlugin } from "./plugin/use-plugin"
 import { tuiPluginDirectories } from "./plugin/discovery"
 import { PluginRoute, PluginSlot } from "./plugin/render"
 import { CommandPaletteDialog } from "./component/command-palette"

packages/tui/src/component/devtools-bar.tsx

@@ -13,7 +13,7 @@ import { useRoute } from "../context/route"
 import { Keymap } from "../context/keymap"
 import { useTheme, useThemes } from "../context/theme"
 import { DevTools } from "../devtools"
-import { usePlugin } from "../plugin/context"
+import { usePlugin } from "../plugin/use-plugin"
 import { errorMessage } from "../util/error"
 
 const graphWidth = 23

packages/tui/src/feature-plugins/system/plugins.tsx

@@ -1,6 +1,6 @@
 import { Plugin } from "@opencode-ai/plugin/tui"
 import { createMemo, createSignal } from "solid-js"
-import { usePlugin } from "../../plugin/context"
+import { usePlugin } from "../../plugin/use-plugin"
 import { DialogSelect, type DialogSelectOption } from "../../ui/dialog-select"
 
 const id = "opencode.plugins"

packages/tui/src/plugin/context.tsx

@@ -1,9 +1,9 @@
 import type { Plugin } from "@opencode-ai/plugin/tui"
-import { batch, createContext, createEffect, on, onCleanup, onMount, useContext, type ParentProps } from "solid-js"
+import { batch, createEffect, on, onCleanup, onMount, type ParentProps } from "solid-js"
 import path from "path"
 import { stat } from "fs/promises"
 import { fileURLToPath, pathToFileURL } from "url"
-import type { Page, Slot, SlotName } from "@opencode-ai/plugin/tui/context"
+import type { Page, Slot } from "@opencode-ai/plugin/tui/context"
 import { createStore, produce, reconcile as reconcileStore } from "solid-js/store"
 import { isDeepEqual } from "remeda"
 import "#runtime-plugin-support"
@@ -14,32 +14,12 @@ import { builtins } from "./builtins"
 import { createPluginContext, usePluginHost, type Dispose } from "./api"
 import { createSourceWatcher } from "./watch"
 import { discoverTuiPlugins, freshSpecifier, localSource } from "./discovery"
+import { PluginContext, type PluginState, type RegisteredPlugin } from "./use-plugin"
 
 export interface PackageResolver {
   readonly resolve: (spec: string) => Promise<string | undefined>
 }
 
-type State =
-  | { readonly target: string; readonly id: string; readonly status: "active" | "inactive" }
-  | { readonly target: string; readonly status: "unsupported" }
-  | { readonly target: string; readonly status: "failed"; readonly error: string }
-
-type RegisteredPlugin = {
-  readonly id: string
-  readonly source: "builtin" | "external"
-  readonly active: boolean
-}
-
-type Value = {
-  readonly ready: () => boolean
-  readonly list: () => ReadonlyArray<State>
-  readonly registered: () => ReadonlyArray<RegisteredPlugin>
-  readonly route: (id: string, name: string) => Page["render"] | undefined
-  readonly slot: <Name extends SlotName>(name: Name) => ReadonlyArray<{ readonly id: string; readonly render: Slot<Name> }>
-  readonly activate: (id: string) => Promise<boolean>
-  readonly deactivate: (id: string) => Promise<boolean>
-}
-
 type Registration = {
   plugin: Plugin.Definition
   source: RegisteredPlugin["source"]
@@ -55,8 +35,6 @@ type Registration = {
 // One entry of the desired plugin generation produced by the resolve phase.
 type Desired = Pick<Registration, "plugin" | "source" | "target" | "version" | "options"> & { enabled: boolean }
 
-const PluginContext = createContext<Value>()
-
 export function PluginProvider(props: ParentProps<{ packages: PackageResolver; directories: string[] }>) {
   const host = usePluginHost()
   const config = useConfig()
@@ -64,7 +42,7 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
   const directory = config.path ? path.dirname(config.path) : process.cwd()
   const [store, setStore] = createStore({
     ready: false,
-    states: [] as ReadonlyArray<State>,
+    states: [] as ReadonlyArray<PluginState>,
     registrations: {} as Record<string, Registration>,
   })
 
@@ -194,7 +172,7 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
     // to import keeps its running previous version and only reports failure.
     const desired = new Map<string, Desired>()
     for (const plugin of builtins) desired.set(plugin.id, { plugin, source: "builtin", version: "builtin", enabled: true })
-    const failures: State[] = []
+    const failures: PluginState[] = []
     for (const entry of entries) {
       const target = typeof entry === "string" ? entry : entry.package
       if (target.startsWith("-")) {
@@ -326,8 +304,8 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
     }
 
     const failedTargets = new Set(failures.map((failure) => failure.target))
-    const states: State[] = [
-      ...[...desired.values()].flatMap((item): State[] => {
+    const states: PluginState[] = [
+      ...[...desired.values()].flatMap((item): PluginState[] => {
         if (item.target === undefined) return []
         // A failed reload keeps this item running; the failure entry covers it.
         if (failedTargets.has(item.target)) return []
@@ -502,9 +480,3 @@ function isPlugin(value: unknown): value is Plugin.Definition {
     typeof value.setup === "function"
   )
 }
-
-export function usePlugin() {
-  const value = useContext(PluginContext)
-  if (!value) throw new Error("PluginProvider is missing")
-  return value
-}

packages/tui/src/plugin/render.tsx

@@ -3,7 +3,7 @@ import type { SlotMap, SlotName } from "@opencode-ai/plugin/tui/context"
 import { useRoute } from "../context/route"
 import { useToast } from "../ui/toast"
 import { errorMessage } from "../util/error"
-import { usePlugin } from "./context"
+import { usePlugin } from "./use-plugin"
 
 // Contain render-time plugin crashes: a throwing slot or route must not take
 // down the app or the other plugins. The crash surfaces as one error toast.

packages/tui/src/plugin/use-plugin.tsx

@@ -0,0 +1,33 @@
+import type { Page, Slot, SlotName } from "@opencode-ai/plugin/tui/context"
+import { createContext, useContext } from "solid-js"
+
+export type RegisteredPlugin = {
+  readonly id: string
+  readonly source: "builtin" | "external"
+  readonly active: boolean
+}
+
+export type PluginState =
+  | { readonly target: string; readonly id: string; readonly status: "active" | "inactive" }
+  | { readonly target: string; readonly status: "unsupported" }
+  | { readonly target: string; readonly status: "failed"; readonly error: string }
+
+type Value = {
+  readonly ready: () => boolean
+  readonly list: () => ReadonlyArray<PluginState>
+  readonly registered: () => ReadonlyArray<RegisteredPlugin>
+  readonly route: (id: string, name: string) => Page["render"] | undefined
+  readonly slot: <Name extends SlotName>(
+    name: Name,
+  ) => ReadonlyArray<{ readonly id: string; readonly render: Slot<Name> }>
+  readonly activate: (id: string) => Promise<boolean>
+  readonly deactivate: (id: string) => Promise<boolean>
+}
+
+export const PluginContext = createContext<Value>()
+
+export function usePlugin() {
+  const value = useContext(PluginContext)
+  if (!value) throw new Error("PluginProvider is missing")
+  return value
+}