fix(acp): forward subagent session events to ACP client

Child sessions created by the Task tool have their own session IDs
that are not registered in ACPSessionManager. This caused all
message.part.updated, message.part.delta, and permission.asked
events from subagents to be silently dropped in handleEvent().

Add resolveRootSession() which walks the parentID chain via the SDK
to find the nearest ACP-tracked ancestor session. Events from child
sessions are now forwarded to the ACP client attributed to the root
session ID, making subagent activity visible in clients like
agent-shell.

A childToRootSession cache avoids repeated SDK calls for the same
child session across multiple events.

Author: jasonmj

packages/opencode/src/acp/agent.ts

@@ -36,7 +36,7 @@ import { pathToFileURL } from "url"
 import { Filesystem } from "../util/filesystem"
 import { Hash } from "../util/hash"
 import { ACPSessionManager } from "./session"
-import type { ACPConfig } from "./types"
+import type { ACPConfig, ACPSessionState } from "./types"
 import { Provider } from "../provider/provider"
 import { ModelID, ProviderID } from "../provider/schema"
 import { Agent as AgentModule } from "../agent/agent"
@@ -145,6 +145,8 @@ export namespace ACP {
     private bashSnapshots = new Map<string, string>()
     private toolStarts = new Set<string>()
     private permissionQueues = new Map<string, Promise<void>>()
+    // Maps child session IDs to their root ACP-tracked session ID
+    private childToRootSession = new Map<string, string>()
     private permissionOptions: PermissionOption[] = [
       { optionId: "once", kind: "allow_once", name: "Allow once" },
       { optionId: "always", kind: "allow_always", name: "Always allow" },
@@ -185,11 +187,55 @@ export namespace ACP {
       }
     }
 
+    /**
+     * Given a session ID, returns the ACPSessionState for that session or the
+     * nearest ACP-tracked ancestor. Child sessions created by the Task tool
+     * have a parentID chain leading back to the root ACP session. We cache
+     * the mapping so we only traverse the chain once per child session.
+     */
+    private async resolveRootSession(sessionID: string): Promise<ACPSessionState | undefined> {
+      // Fast path: directly tracked by ACP session manager
+      const direct = this.sessionManager.tryGet(sessionID)
+      if (direct) return direct
+
+      // Check cache
+      const cached = this.childToRootSession.get(sessionID)
+      if (cached) return this.sessionManager.tryGet(cached)
+
+      // Walk the parentID chain via the SDK until we find a known root session
+      let currentID = sessionID
+      const visited: string[] = []
+      while (true) {
+        visited.push(currentID)
+        const info = await this.sdk.session
+          .get({ sessionID: currentID, directory: "" }, { throwOnError: false })
+          .then((x) => x.data)
+          .catch(() => undefined)
+
+        if (!info) break
+
+        const parentID = info.parentID
+        if (!parentID) break
+
+        const root = this.sessionManager.tryGet(parentID)
+        if (root) {
+          // Cache the mapping for all visited IDs
+          for (const id of visited) {
+            this.childToRootSession.set(id, root.id)
+          }
+          return root
+        }
+        currentID = parentID
+      }
+
+      return undefined
+    }
+
     private async handleEvent(event: Event) {
       switch (event.type) {
         case "permission.asked": {
           const permission = event.properties
-          const session = this.sessionManager.tryGet(permission.sessionID)
+          const session = await this.resolveRootSession(permission.sessionID)
           if (!session) return
 
           const prev = this.permissionQueues.get(permission.sessionID) ?? Promise.resolve()
@@ -272,7 +318,7 @@ export namespace ACP {
           log.info("message part updated", { event: event.properties })
           const props = event.properties
           const part = props.part
-          const session = this.sessionManager.tryGet(part.sessionID)
+          const session = await this.resolveRootSession(part.sessionID)
           if (!session) return
           const sessionId = session.id
 
@@ -464,16 +510,19 @@ export namespace ACP {
 
         case "message.part.delta": {
           const props = event.properties
-          const session = this.sessionManager.tryGet(props.sessionID)
+          const session = await this.resolveRootSession(props.sessionID)
           if (!session) return
           const sessionId = session.id
+          // Use the child session's own cwd for SDK lookups (may differ from root)
+          const childSession = this.sessionManager.tryGet(props.sessionID)
+          const directory = childSession?.cwd ?? session.cwd
 
           const message = await this.sdk.session
             .message(
               {
                 sessionID: props.sessionID,
                 messageID: props.messageID,
-                directory: session.cwd,
+                directory,
               },
               { throwOnError: true },
             )