@openma/deepseek-harness-acp 0.4.6 → 0.4.7

package/dist/bridge.js

@@ -444,7 +444,7 @@ function extractMessageTexts(message) {
 }
 function planEntries(data) {
   const todos = data["todos"];
-  if (!Array.isArray(todos)) return [];
+  if (!Array.isArray(todos)) return void 0;
   const entries = [];
   for (const todo of todos) {
     if (todo === null || typeof todo !== "object") continue;
@@ -487,6 +487,27 @@ function emptyWindow() {
     error: void 0
   };
 }
+var TOOL_KINDS = /* @__PURE__ */ new Set([
+  "read",
+  "edit",
+  "delete",
+  "move",
+  "search",
+  "execute",
+  "think",
+  "fetch",
+  "switch_mode",
+  "other"
+]);
+function factsFromPresentCall(name3, rawArguments, presented) {
+  const fallback = classifyToolCall(name3, rawArguments);
+  const kind = presented.kind !== void 0 && TOOL_KINDS.has(presented.kind) ? presented.kind : fallback.kind;
+  const title = presented.title !== void 0 && presented.title.length > 0 ? presented.title : fallback.title;
+  const locations = presented.locations !== void 0 && presented.locations.length > 0 ? presented.locations.map(
+    (location) => location.line === void 0 ? { path: location.path } : { path: location.path, line: location.line }
+  ) : fallback.locations;
+  return { kind, title, locations, rawInput: fallback.rawInput };
+}
 var SessionProjection = class {
   /** Context capacity from the latest `request/context` event, when known. */
   contextWindow;
@@ -501,10 +522,14 @@ var SessionProjection = class {
   terminalOutput;
   /** Session working directory, advertised on display terminals. */
   cwd;
+  presentCall;
+  subagent;
   constructor(contextWindow, options) {
     this.contextWindow = contextWindow;
     this.terminalOutput = options?.terminalOutput ?? false;
     this.cwd = options?.cwd;
+    this.presentCall = options?.presentCall;
+    this.subagent = options?.subagent;
   }
   /** Reset per-prompt accumulators; call when a new `session/prompt` starts. */
   beginPrompt() {
@@ -539,6 +564,11 @@ var SessionProjection = class {
    * Project one session event onto zero or more ACP updates.
    */
   onEvent(event) {
+    const updates = this.projectEvent(event);
+    return this.subagent === void 0 ? updates : updates.map((update) => this.withSubagentAttribution(update));
+  }
+  /** Project one event before optional subagent attribution is attached. */
+  projectEvent(event) {
     const data = event.data ?? {};
     switch (event.type) {
       case "assistant/chunk":
@@ -549,9 +579,34 @@ var SessionProjection = class {
         return this.onToolCall(data);
       case "tool/result":
         return this.onToolResult(data);
+      case "subagent/start":
+        return this.onSubagentStart(data);
+      case "subagent/end":
+        return this.onSubagentEnd(data);
       case "todo/write": {
         const entries = planEntries(data);
-        return entries.length > 0 ? [{ sessionUpdate: "plan", entries }] : [];
+        return entries !== void 0 ? [{ sessionUpdate: "plan", entries }] : [];
+      }
+      case "user/message": {
+        const source = data["source"];
+        const kind = source !== null && typeof source === "object" ? asString(source["kind"]) : void 0;
+        if (kind === void 0 || kind === "user") return [];
+        const content = data["content"];
+        const text = Array.isArray(content) ? content.filter(
+          (block) => block !== null && typeof block === "object" && block["type"] === "text" && typeof block["text"] === "string"
+        ).map((block) => block["text"]).join("") : "";
+        return [
+          {
+            sessionUpdate: "session_info_update",
+            _meta: {
+              dsh: {
+                event: "user/message",
+                source: kind,
+                preview: Array.from(text).slice(0, 160).join("")
+              }
+            }
+          }
+        ];
       }
       case "turn/end":
         return this.onTurnEnd(data);
@@ -573,31 +628,117 @@ var SessionProjection = class {
   stepKey(data) {
     return `${String(data["turn"])}:${String(data["step"])}`;
   }
+  withSubagentAttribution(update) {
+    const value = update;
+    const meta = value["_meta"] !== null && typeof value["_meta"] === "object" ? value["_meta"] : {};
+    const dsh = meta["dsh"] !== null && typeof meta["dsh"] === "object" ? meta["dsh"] : {};
+    return {
+      ...value,
+      _meta: { ...meta, dsh: { ...dsh, subagent: this.subagent } }
+    };
+  }
+  subagentMeta(data, state) {
+    const runId = asString(data["runId"]);
+    const childSessionId = asString(data["id"]);
+    const provider = asString(data["provider"]);
+    if (runId === void 0 || childSessionId === void 0 || provider === void 0) return void 0;
+    const parentToolCallId = asString(data["parentToolCallId"]);
+    return {
+      state,
+      runId,
+      childSessionId,
+      provider,
+      local: data["local"] === true,
+      ...parentToolCallId !== void 0 ? { parentToolCallId } : {}
+    };
+  }
+  onSubagentStart(data) {
+    const subagent = this.subagentMeta(data, "started");
+    if (subagent === void 0) return [];
+    const runId = subagent["runId"];
+    const childSessionId = subagent["childSessionId"];
+    return [{
+      sessionUpdate: "tool_call",
+      toolCallId: `subagent:${runId}`,
+      title: `Start subagent ${childSessionId}`,
+      kind: "other",
+      status: "in_progress",
+      rawInput: {
+        childSessionId,
+        provider: subagent["provider"],
+        local: subagent["local"]
+      },
+      _meta: { dsh: { subagent } }
+    }];
+  }
+  onSubagentEnd(data) {
+    const subagent = this.subagentMeta(data, "finished");
+    if (subagent === void 0) return [];
+    const stopReason = asString(data["stopReason"]) ?? "error";
+    const lastAssistantMessage = data["lastAssistantMessage"];
+    return [{
+      sessionUpdate: "tool_call_update",
+      toolCallId: `subagent:${String(subagent["runId"])}`,
+      status: stopReason === "completed" ? "completed" : "failed",
+      rawOutput: {
+        stopReason,
+        ...Array.isArray(lastAssistantMessage) ? { lastAssistantMessage } : {}
+      },
+      _meta: { dsh: { subagent } }
+    }];
+  }
   onChunk(data) {
     const chunk = data["chunk"];
     if (chunk === null || typeof chunk === "undefined" || typeof chunk !== "object") return [];
     const c = chunk;
     const text = c["text"];
     if (typeof text !== "string" || text.length === 0) return [];
+    const messageId = this.stepKey(data);
     if (c["type"] === "text-delta") {
-      this.streamedText.add(this.stepKey(data));
-      return [{ sessionUpdate: "agent_message_chunk", content: { type: "text", text } }];
+      this.streamedText.add(messageId);
+      return [{ sessionUpdate: "agent_message_chunk", content: { type: "text", text }, messageId }];
     }
     if (c["type"] === "reasoning-delta") {
-      this.streamedReasoning.add(this.stepKey(data));
-      return [{ sessionUpdate: "agent_thought_chunk", content: { type: "text", text } }];
+      this.streamedReasoning.add(messageId);
+      return [{ sessionUpdate: "agent_thought_chunk", content: { type: "text", text }, messageId }];
     }
     return [];
   }
   onAssistantMessage(data) {
     const updates = [];
     const key = this.stepKey(data);
-    const { text, reasoning } = extractMessageTexts(data["message"]);
+    const message = data["message"];
+    const { text, reasoning } = extractMessageTexts(message);
+    const model = message !== null && typeof message === "object" ? asString(
+      message["source"] !== null && typeof message["source"] === "object" ? message["source"]["model"] : void 0
+    ) : void 0;
+    const completionMeta = {
+      dsh: {
+        event: "assistant_message",
+        ...model !== void 0 ? { model } : {}
+      }
+    };
     if (reasoning.length > 0 && !this.streamedReasoning.has(key)) {
-      updates.push({ sessionUpdate: "agent_thought_chunk", content: { type: "text", text: reasoning } });
+      updates.push({
+        sessionUpdate: "agent_thought_chunk",
+        content: { type: "text", text: reasoning },
+        messageId: key
+      });
     }
     if (text.length > 0 && !this.streamedText.has(key)) {
-      updates.push({ sessionUpdate: "agent_message_chunk", content: { type: "text", text } });
+      updates.push({
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text },
+        messageId: key,
+        _meta: completionMeta
+      });
+    } else {
+      updates.push({
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "" },
+        messageId: key,
+        _meta: completionMeta
+      });
     }
     this.streamedText.delete(key);
     this.streamedReasoning.delete(key);
@@ -631,7 +772,14 @@ var SessionProjection = class {
     const name3 = asString(data["name"]) ?? "tool";
     if (callId === void 0) return [];
     const rawArguments = typeof data["arguments"] === "string" ? data["arguments"] : "{}";
-    const facts = classifyToolCall(name3, rawArguments);
+    let parsedArgs = {};
+    try {
+      parsedArgs = JSON.parse(rawArguments);
+    } catch {
+      parsedArgs = { arguments: rawArguments };
+    }
+    const presented = this.presentCall?.(name3, parsedArgs);
+    const facts = presented !== void 0 ? factsFromPresentCall(name3, rawArguments, presented) : classifyToolCall(name3, rawArguments);
     this.toolCalls.set(callId, facts);
     const displayTerminal = this.terminalOutput && facts.kind === "execute";
     return [
@@ -736,7 +884,7 @@ ${text.replace(/\n+$/, "")}
 };
 
 // src/bridge/history.ts
-function userText(data) {
+function userMessage(data) {
   if (data === void 0) return void 0;
   const source = data["source"];
   const kind = source !== null && typeof source === "object" ? source["kind"] : void 0;
@@ -751,20 +899,28 @@ function userText(data) {
     }
   }
   const text = parts.join("");
-  return text.length > 0 ? text : void 0;
+  return text.length > 0 ? { text } : {};
 }
 function buildReplay(events) {
   const projection = new SessionProjection();
   const updates = [];
   let plan;
   let title;
+  let sawUserInteraction = false;
   for (const event of events) {
     if (event.type === "user/message") {
-      const text = userText(event.data);
-      if (text !== void 0) {
-        updates.push({ sessionUpdate: "user_message_chunk", content: { type: "text", text } });
+      const user = userMessage(event.data);
+      if (user !== void 0) {
+        projection.beginPrompt();
+        sawUserInteraction = true;
+        if (user.text !== void 0) {
+          updates.push({
+            sessionUpdate: "user_message_chunk",
+            content: { type: "text", text: user.text }
+          });
+        }
+        continue;
       }
-      continue;
     }
     if (event.type === "session/title") {
       const t = event.data?.["title"];
@@ -781,25 +937,132 @@ function buildReplay(events) {
     }
   }
   if (plan !== void 0) updates.push(plan);
+  const usage = sawUserInteraction ? projection.promptUsage() : void 0;
+  if (usage !== void 0) {
+    updates.push({
+      sessionUpdate: "session_info_update",
+      _meta: { dsh: { event: "prompt/usage", usage } }
+    });
+  }
   return { updates, title, contextWindow: projection.contextWindow };
 }
 
 // src/bridge/prompt.ts
+function deliverPrompt(target, message, running) {
+  if (running) {
+    target.steer(message);
+    return "steer";
+  }
+  target.followup(message);
+  return "followup";
+}
 var UnsupportedPromptContentError = class extends Error {
   constructor(contentType) {
     super(`unsupported prompt content type: ${contentType}`);
     this.contentType = contentType;
+    this.name = "UnsupportedPromptContentError";
   }
   contentType;
 };
+var PromptImageError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "PromptImageError";
+  }
+};
 function contextBlock(uri, text) {
   return `<context ref=${JSON.stringify(uri)}>
 ${text}
 </context>`;
 }
-function convertPrompt(prompt) {
+var IMAGE_MEDIA_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+function canonicalImageMediaType(mimeType) {
+  const lower = mimeType.trim().toLowerCase();
+  const mapped = lower === "image/jpg" ? "image/jpeg" : lower;
+  return IMAGE_MEDIA_TYPES.has(mapped) ? mapped : void 0;
+}
+function attachmentIngestOf(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const candidate = value;
+  if (typeof candidate.validateImage !== "function" || typeof candidate.saveImage !== "function") {
+    return void 0;
+  }
+  const limits = candidate.imageLimits;
+  if (limits === void 0 || typeof limits.maxImagesPerMessage !== "number" || typeof limits.maxMessageImageBytes !== "number" || typeof limits.maxImageBytes !== "number") {
+    return void 0;
+  }
+  return candidate;
+}
+function decodeImageData(data) {
+  if (data.length === 0) throw new PromptImageError("image data is empty");
+  const decoded = Buffer.from(data, "base64");
+  if (decoded.byteLength === 0) throw new PromptImageError("image data is empty");
+  return new Uint8Array(decoded);
+}
+function imageName(uri) {
+  if (typeof uri !== "string" || uri.length === 0) return void 0;
+  let leaf;
+  try {
+    leaf = new URL(uri).pathname.split("/").filter(Boolean).at(-1);
+  } catch {
+    leaf = uri.split(/[/\\]/).filter(Boolean).at(-1);
+  }
+  if (leaf === void 0 || leaf.length === 0) return void 0;
+  try {
+    return decodeURIComponent(leaf);
+  } catch {
+    return leaf;
+  }
+}
+function prepareImage(block) {
+  const mediaType = canonicalImageMediaType(block.mimeType);
+  if (mediaType === void 0) {
+    throw new PromptImageError(`unsupported image media type: ${block.mimeType}`);
+  }
+  const data = decodeImageData(block.data);
+  const name3 = imageName(block.uri);
+  return name3 === void 0 ? { data, mediaType } : { data, mediaType, name: name3 };
+}
+function saveInput(image) {
+  return image.name === void 0 ? { data: image.data, mediaType: image.mediaType } : { data: image.data, mediaType: image.mediaType, name: image.name };
+}
+function flushText(parts, blocks) {
+  const text = parts.join("");
+  parts.length = 0;
+  if (text.length > 0) blocks.push({ type: "text", text });
+}
+async function convertPrompt(prompt, attachments) {
+  const preparedImages = [];
+  for (const block of prompt) {
+    if (block.type !== "image") continue;
+    if (attachments === void 0) throw new UnsupportedPromptContentError("image");
+    preparedImages.push(prepareImage(block));
+  }
+  if (preparedImages.length > 0 && attachments !== void 0) {
+    const { maxImagesPerMessage, maxMessageImageBytes, maxImageBytes } = attachments.imageLimits;
+    if (preparedImages.length > maxImagesPerMessage) {
+      throw new PromptImageError("prompt exceeds the configured image-count limit");
+    }
+    const totalBytes = preparedImages.reduce((sum, image) => sum + image.data.byteLength, 0);
+    if (totalBytes > maxMessageImageBytes) {
+      throw new PromptImageError("prompt exceeds the configured aggregate image-byte limit");
+    }
+    for (const image of preparedImages) {
+      if (image.data.byteLength > maxImageBytes) {
+        throw new PromptImageError("image exceeds the configured encoded-byte limit");
+      }
+      try {
+        await attachments.validateImage(saveInput(image));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new PromptImageError(message, { cause: error });
+      }
+    }
+  }
   const parts = [];
   const display = [];
+  const blocks = [];
+  let imageIndex = 0;
   for (const block of prompt) {
     switch (block.type) {
       case "text":
@@ -823,20 +1086,535 @@ ${contextBlock(resource.uri, resource.text)}
         }
         throw new UnsupportedPromptContentError("resource (binary)");
       }
+      case "image": {
+        if (attachments === void 0) throw new UnsupportedPromptContentError("image");
+        const prepared = preparedImages[imageIndex];
+        imageIndex += 1;
+        if (prepared === void 0) throw new PromptImageError("image block was not prepared");
+        flushText(parts, blocks);
+        let attachment;
+        try {
+          attachment = await attachments.saveImage(saveInput(prepared));
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          throw new PromptImageError(message, { cause: error });
+        }
+        blocks.push({ type: "image", attachment });
+        break;
+      }
       default:
         throw new UnsupportedPromptContentError(block.type);
     }
   }
-  const text = parts.join("");
+  flushText(parts, blocks);
   return {
-    blocks: text.length > 0 ? [{ type: "text", text }] : [],
+    blocks,
     displayText: display.join(" ").trim()
   };
 }
 
+// src/bridge/rpc.ts
+var AcpRpc = class {
+  handlers = /* @__PURE__ */ new Map();
+  writeJson;
+  /**
+   * Bind the mux writer. Called once from {@link muxAcpStream}.
+   * @param writeJson - write one JSON-RPC message onto the ACP stream.
+   */
+  attachWriter(writeJson) {
+    this.writeJson = writeJson;
+  }
+  /**
+   * Register a bridge-owned request method intercepted before the ACP SDK.
+   * @param method - JSON-RPC method name (e.g. `tui/refresh`).
+   * @param handler - implementation.
+   * @returns disposer.
+   */
+  registerMethod(method, handler) {
+    if (this.handlers.has(method)) {
+      throw new Error(`acpRpc: method ${JSON.stringify(method)} is already registered`);
+    }
+    this.handlers.set(method, handler);
+    return () => {
+      this.handlers.delete(method);
+    };
+  }
+  /**
+   * @param method - JSON-RPC method name.
+   * @returns whether a TUI/extension handler owns this request.
+   */
+  has(method) {
+    return this.handlers.has(method);
+  }
+  /**
+   * Dispatch one intercepted request and write the JSON-RPC response.
+   * @param id - JSON-RPC id.
+   * @param method - method name.
+   * @param params - params object.
+   */
+  async dispatch(id, method, params) {
+    const handler = this.handlers.get(method);
+    const write = this.writeJson;
+    if (handler === void 0 || write === void 0) return;
+    try {
+      const result = await handler(params);
+      write({ jsonrpc: "2.0", id, result: result ?? null });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      write({ jsonrpc: "2.0", id, error: { code: -32e3, message } });
+    }
+  }
+  /**
+   * Send a JSON-RPC notification on the ACP stream (e.g. `tui/snapshot`).
+   * @param method - notification method.
+   * @param params - payload.
+   */
+  notify(method, params) {
+    const write = this.writeJson;
+    if (write === void 0) return;
+    write(params === void 0 ? { jsonrpc: "2.0", method } : { jsonrpc: "2.0", method, params });
+  }
+};
+function isInterceptedRequest(message, rpc) {
+  return "method" in message && typeof message.method === "string" && "id" in message && message.id !== void 0 && rpc.has(message.method);
+}
+function muxAcpStream(stream, rpc) {
+  const dest = stream.writable.getWriter();
+  const writeMessage = (value) => {
+    void dest.write(value).catch(() => {
+    });
+  };
+  rpc.attachWriter(writeMessage);
+  const acpWritable = new WritableStream({
+    write(chunk) {
+      return dest.write(chunk);
+    },
+    close() {
+      return dest.close();
+    },
+    abort(reason) {
+      return dest.abort(reason);
+    }
+  });
+  const { readable, writable } = new TransformStream({
+    transform(message, controller) {
+      if (isInterceptedRequest(message, rpc)) {
+        void rpc.dispatch(message.id, message.method, message.params);
+        return;
+      }
+      controller.enqueue(message);
+    }
+  });
+  void stream.readable.pipeTo(writable).catch(() => {
+  });
+  return { readable, writable: acpWritable };
+}
+
+// src/bridge/tui-client.ts
+function installTuiClientPlane(ctx, rpc, opts) {
+  const { findAgent, advertisement } = opts;
+  ctx.effect(
+    () => rpc.registerMethod("tui/inspect-sync", (params) => {
+      const inspect = optionalInspect(ctx);
+      if (inspect === void 0) {
+        throw new Error("this agent has no Cordis inspect registry");
+      }
+      const providers = readProviders(params);
+      inspect.syncClientManifest(providers);
+      advertisement.advertised = true;
+      return { ok: true };
+    }),
+    "acp-bridge: tui/inspect-sync"
+  );
+  ctx.effect(
+    () => rpc.registerMethod("tui/inspect-resolve", (params) => {
+      const inspect = optionalInspect(ctx);
+      if (inspect === void 0) {
+        throw new Error("this agent has no Cordis inspect registry");
+      }
+      const body = asObject(params);
+      const agent = requireAgent(findAgent, readString(body, "agentId"));
+      const requestId = readString(body, "requestId");
+      return inspect.resolveClientQuery(agent, requestId, body["resolution"]);
+    }),
+    "acp-bridge: tui/inspect-resolve"
+  );
+  ctx.effect(
+    () => rpc.registerMethod("tui/run-host-half", async (params) => {
+      const runner = optionalRunner(ctx);
+      if (runner === void 0) {
+        throw new Error("this agent has no dynamic Cordis runner");
+      }
+      const body = asObject(params);
+      const agent = requireAgent(findAgent, readString(body, "agentId"));
+      const requestId = body["requestId"];
+      return await runner.runHostHalf(
+        agent,
+        readString(body, "pluginId"),
+        readString(body, "packageId"),
+        readString(body, "mode"),
+        typeof requestId === "string" ? requestId : null,
+        body["approveFutureVersions"] === true
+      );
+    }),
+    "acp-bridge: tui/run-host-half"
+  );
+  ctx.effect(
+    () => rpc.registerMethod("tui/get-client-code", (params) => {
+      const runner = optionalRunner(ctx);
+      if (runner === void 0) {
+        throw new Error("this agent has no dynamic Cordis runner");
+      }
+      const body = asObject(params);
+      const agent = requireAgent(findAgent, readString(body, "agentId"));
+      return runner.getClientCode(
+        agent,
+        readString(body, "pluginId"),
+        readString(body, "pluginRunId")
+      );
+    }),
+    "acp-bridge: tui/get-client-code"
+  );
+  ctx.effect(
+    () => rpc.registerMethod("tui/resolve-request-run", async (params) => {
+      const runner = optionalRunner(ctx);
+      if (runner === void 0) {
+        throw new Error("this agent has no dynamic Cordis runner");
+      }
+      const body = asObject(params);
+      return await runner.resolveRequestRun(
+        readString(body, "requestId"),
+        body["resolution"]
+      );
+    }),
+    "acp-bridge: tui/resolve-request-run"
+  );
+  ctx.effect(
+    () => rpc.registerMethod("tui/invoke", async (params) => {
+      const runner = optionalRunner(ctx);
+      if (runner === void 0) {
+        throw new Error("this agent has no dynamic Cordis runner");
+      }
+      const body = asObject(params);
+      requireAgent(findAgent, readString(body, "agentId"));
+      return await runner.invoke(
+        readString(body, "pluginId"),
+        readString(body, "pluginRunId"),
+        readString(body, "method"),
+        body["args"] ?? null
+      );
+    }),
+    "acp-bridge: tui/invoke"
+  );
+  ctx.effect(
+    () => rpc.registerMethod("tui/list-plugins", (params) => {
+      const runner = requireRunnerMethod(ctx, "listPlugins");
+      const body = asObject(params);
+      const agent = requireAgent(findAgent, readString(body, "agentId"));
+      return runner.listPlugins(agent);
+    }),
+    "acp-bridge: tui/list-plugins"
+  );
+  ctx.effect(
+    () => rpc.registerMethod("tui/stop-plugin", async (params) => {
+      const runner = requireRunnerMethod(ctx, "stopFromPanel");
+      const body = asObject(params);
+      const agent = requireAgent(findAgent, readString(body, "agentId"));
+      return await runner.stopFromPanel(agent, readString(body, "pluginId"));
+    }),
+    "acp-bridge: tui/stop-plugin"
+  );
+  ctx.effect(
+    () => rpc.registerMethod("tui/start-plugin", async (params) => {
+      const runner = requireRunnerMethod(ctx, "listPlugins");
+      const body = asObject(params);
+      const agentId = readString(body, "agentId");
+      const agent = requireAgent(findAgent, agentId);
+      const pluginId = readString(body, "pluginId");
+      const plugin = runner.listPlugins(agent).find((row) => row.pluginId === pluginId);
+      if (plugin === void 0) throw new Error(`dynamic plugin "${pluginId}" does not exist`);
+      const packageId = plugin.currentPackageId;
+      if (packageId === void 0) {
+        throw new Error(`dynamic plugin "${pluginId}" has no current package to restore`);
+      }
+      const pkg = plugin.packages.find((row) => row.packageId === packageId);
+      if (pkg === void 0) {
+        throw new Error(`dynamic plugin "${pluginId}" current package "${packageId}" does not exist`);
+      }
+      const started = asObject(await runner.runHostHalf(
+        agent,
+        pluginId,
+        packageId,
+        "run",
+        null,
+        false
+      ));
+      if (started["ok"] !== true) return started;
+      const pluginRunId = readString(started, "pluginRunId");
+      const startedHere = started["startedHere"] !== false;
+      if (pkg.hasClientHalf) {
+        rpc.notify("tui/user-run", {
+          agentId,
+          pluginId,
+          packageId,
+          pluginRunId,
+          startedHere,
+          mode: "run",
+          hasClientHalf: true
+        });
+      }
+      return { ok: true, status: "starting", pluginId, packageId, pluginRunId };
+    }),
+    "acp-bridge: tui/start-plugin"
+  );
+  ctx.effect(
+    () => rpc.registerMethod("tui/settle-user-run", async (params) => {
+      const runner = requireRunnerMethod(ctx, "settleUserRun");
+      const body = asObject(params);
+      const agent = requireAgent(findAgent, readString(body, "agentId"));
+      return await runner.settleUserRun(
+        agent,
+        readString(body, "pluginId"),
+        body["resolution"]
+      );
+    }),
+    "acp-bridge: tui/settle-user-run"
+  );
+  ctx.on("cordis/inspect-query", (request) => {
+    if (!advertisement.advertised) return;
+    rpc.notify("tui/inspect-query", request);
+  });
+  ctx.on("cordis/inspect-query-resolved", (resolved) => {
+    if (!advertisement.advertised) return;
+    rpc.notify("tui/inspect-query-resolved", resolved);
+  });
+  ctx.on("cordis/request-run", (request) => {
+    if (!advertisement.advertised) return;
+    rpc.notify("tui/request-run", request);
+  });
+  ctx.on("cordis/request-run-resolved", (resolved) => {
+    if (!advertisement.advertised) return;
+    rpc.notify("tui/request-run-resolved", resolved);
+  });
+  ctx.on("cordis/dynamic-retract", (retracted) => {
+    if (!advertisement.advertised) return;
+    rpc.notify("tui/dynamic-retract", retracted);
+  });
+}
+function optionalInspect(ctx) {
+  try {
+    const value = ctx.get("cordisInspect");
+    return value !== void 0 && typeof value.syncClientManifest === "function" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function optionalRunner(ctx) {
+  try {
+    const value = ctx.get("dynamicCordisRunner");
+    return value !== void 0 && typeof value.runHostHalf === "function" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function requireRunnerMethod(ctx, method) {
+  const runner = optionalRunner(ctx);
+  if (runner === void 0 || typeof runner[method] !== "function") {
+    throw new Error(`this agent has no dynamic Cordis runner method ${String(method)}`);
+  }
+  return runner;
+}
+function requireAgent(findAgent, agentId) {
+  const agent = findAgent(agentId);
+  if (agent === void 0) throw new Error(`unknown agent: ${agentId}`);
+  return agent;
+}
+function asObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("params must be an object");
+  }
+  return value;
+}
+function readString(body, field) {
+  const value = body[field];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+function readProviders(params) {
+  const body = asObject(params);
+  const providers = body["providers"];
+  if (!Array.isArray(providers)) throw new Error("providers must be an array");
+  return providers.map((provider, index) => {
+    if (provider === null || typeof provider !== "object" || Array.isArray(provider)) {
+      throw new Error(`providers[${index}] must be an object`);
+    }
+    const row = provider;
+    if (typeof row["id"] !== "string" || row["id"].trim() === "") {
+      throw new Error(`providers[${index}].id must be a non-empty string`);
+    }
+    if (typeof row["description"] !== "string" || row["description"].trim() === "") {
+      throw new Error(`providers[${index}].description must be a non-empty string`);
+    }
+    if (!Array.isArray(row["methods"])) {
+      throw new Error(`providers[${index}].methods must be an array`);
+    }
+    return provider;
+  });
+}
+
+// src/bridge/user-questions.ts
+import {
+  UserQuestionError
+} from "@deepseek-ai/dsh-user-questions";
+var META_KEY = "dsh.userQuestions";
+function fieldName(index) {
+  return `question_${index}`;
+}
+function customFieldName(index) {
+  return `${fieldName(index)}_custom`;
+}
+function optionValue(index) {
+  return `option_${index}`;
+}
+function customValue(index) {
+  return `custom_${index}`;
+}
+function descriptionOf(question) {
+  const parts = [question.header === void 0 ? void 0 : question.question, question.detail].filter((part) => part !== void 0 && part.length > 0);
+  return parts.length === 0 ? void 0 : parts.join("\n\n");
+}
+function propertyOf(question, index) {
+  const title = question.header ?? question.question;
+  const description = descriptionOf(question);
+  const options = question.options ?? [];
+  if (options.length === 0) {
+    return {
+      type: "string",
+      title,
+      ...description === void 0 ? {} : { description }
+    };
+  }
+  const choices = [
+    ...options.map((option, optionIndex) => ({
+      const: optionValue(optionIndex),
+      title: option.label,
+      ...option.description === void 0 ? {} : { description: option.description }
+    })),
+    { const: customValue(index), title: "Other" }
+  ];
+  if (question.multiSelect === true) {
+    return {
+      type: "array",
+      title,
+      ...description === void 0 ? {} : { description },
+      minItems: 1,
+      items: { anyOf: choices }
+    };
+  }
+  return {
+    type: "string",
+    title,
+    ...description === void 0 ? {} : { description },
+    oneOf: choices
+  };
+}
+function questionsToElicitation(questions, sessionId) {
+  const properties = {};
+  const required = [];
+  questions.forEach((question, index) => {
+    const field = fieldName(index);
+    properties[field] = propertyOf(question, index);
+    if ((question.options?.length ?? 0) > 0) {
+      properties[customFieldName(index)] = {
+        type: "string",
+        title: "Other",
+        description: "Type a custom answer."
+      };
+    }
+  });
+  return {
+    mode: "form",
+    sessionId,
+    message: "The agent needs your input.",
+    requestedSchema: {
+      type: "object",
+      properties,
+      required
+    },
+    _meta: {
+      [META_KEY]: {
+        version: 1,
+        questions
+      }
+    }
+  };
+}
+function answerFromElicitation(questions, response) {
+  if (response.action !== "accept") return void 0;
+  const content = response.content ?? {};
+  return {
+    answers: questions.map((question, index) => {
+      const options = question.options ?? [];
+      const raw = content[fieldName(index)];
+      if (options.length === 0) {
+        const custom2 = typeof raw === "string" ? raw.trim() : "";
+        return {
+          id: question.id,
+          selected: [],
+          ...custom2.length === 0 ? {} : { custom: custom2 }
+        };
+      }
+      const values = Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
+      const selected = values.flatMap((value) => {
+        const match = /^option_(\d+)$/.exec(value);
+        if (match === null) return [];
+        const option = options[Number(match[1])];
+        return option === void 0 ? [] : [option.label];
+      });
+      const customRaw = content[customFieldName(index)];
+      const custom = typeof customRaw === "string" ? customRaw.trim() : "";
+      return {
+        id: question.id,
+        selected: custom.length > 0 && question.multiSelect !== true ? [] : selected,
+        ...custom.length === 0 ? {} : { custom }
+      };
+    })
+  };
+}
+async function askUserQuestionsOverAcp(request, sessionId, create) {
+  const response = await create(questionsToElicitation(request.questions, sessionId));
+  const answer = answerFromElicitation(request.questions, response);
+  if (answer === void 0) {
+    throw new UserQuestionError("the user cancelled ask_user_question", "ASK_CANCELLED");
+  }
+  return answer;
+}
+function installAcpUserQuestionProvider(service, options) {
+  return service.registerProvider({
+    async ask(request) {
+      if (!options.formSupported()) {
+        throw new UserQuestionError(
+          "the ACP client does not support form elicitation",
+          "CLIENT_UNSUPPORTED"
+        );
+      }
+      const sessionId = options.sessionIdForRequest(request);
+      if (sessionId === void 0) {
+        throw new UserQuestionError(
+          "ACP user interaction requires a live root session",
+          "ASK_MISSING_AGENT"
+        );
+      }
+      return askUserQuestionsOverAcp(request, sessionId, options.create);
+    }
+  });
+}
+
 // src/bridge/index.ts
 var name = "acp-bridge";
-var inject = ["agents", "credentials", "llm", "agentDefaultModel", "sessionPersistence", "approval", "permissionPresets", "commands", "agentPresets", "skills", "subagents"];
+var inject = ["agents", "credentials", "llm", "agentDefaultModel", "sessionPersistence", "approval", "permissionPresets", "commands", "agentPresets", "skills", "subagents", "userQuestions"];
 function invalidParams(detail) {
   return RequestError.invalidParams(void 0, detail);
 }
@@ -869,13 +1647,30 @@ async function apply(ctx, config = {}) {
   const agentPresets = ctx.agentPresets;
   const skillRegistry = ctx.skills;
   const subagents = ctx.subagents;
+  const userQuestions = ctx.userQuestions;
   const harness = config.harness ?? (await Promise.resolve().then(() => (init_self_harness(), self_harness_exports))).selfHarness();
   const { createUserMessage: createUserMessage2, errorChain: errorChain2, sessionId: SessionId2, foldSessionTitle: foldSessionTitle2, setSandboxMode: setSandboxMode2 } = harness;
   const SANDBOX_MODES2 = harness.sandboxModes;
   const sessions = /* @__PURE__ */ new Map();
+  const subagentByChild = /* @__PURE__ */ new Map();
+  const subagentByRun = /* @__PURE__ */ new Map();
+  const watchedSubagentParents = /* @__PURE__ */ new WeakSet();
   let closed = false;
   let conn;
   let clientTerminalOutput = false;
+  let clientSubagentTranscript = false;
+  let clientElicitationForm = false;
+  const tuiClient = { advertised: false };
+  const rpc = new AcpRpc();
+  const findAgent = (agentId) => {
+    const fromRegistry = agents.get(agentId);
+    if (fromRegistry !== void 0) return fromRegistry;
+    for (const record of sessions.values()) {
+      if (record.agent.id === agentId) return record.agent;
+    }
+    return void 0;
+  };
+  installTuiClientPlane(ctx, rpc, { findAgent, advertisement: tuiClient });
   const modelCandidates = () => {
     const seen = /* @__PURE__ */ new Set();
     if (config.model !== void 0) seen.add(config.model);
@@ -1062,9 +1857,9 @@ async function apply(ctx, config = {}) {
   };
   const listProviderRoutes = async () => {
     try {
-      const raw = llm.listProviders();
-      if (!Array.isArray(raw)) return [];
-      return raw.flatMap((entry) => {
+      const raw2 = llm.listProviders();
+      if (!Array.isArray(raw2)) return [];
+      return raw2.flatMap((entry) => {
         if (!entry || typeof entry !== "object") return [];
         const id = entry.id;
         if (typeof id !== "string" || id.length === 0) return [];
@@ -1201,13 +1996,78 @@ async function apply(ctx, config = {}) {
     record.inflight = void 0;
     inflight.resolve(reason);
   };
+  const watchSubagentParent = (parent) => {
+    if (watchedSubagentParents.has(parent)) return;
+    watchedSubagentParents.add(parent);
+    parent.ctx.on("subagent/start", (info) => {
+      const parentLink = subagentByChild.get(String(parent.id));
+      const rootSessionId = parentLink?.rootSessionId ?? String(parent.session.id);
+      const record = sessions.get(rootSessionId);
+      if (record === void 0) return;
+      const runId = String(info.runId);
+      const childSessionId = String(info.id);
+      const toolCallId = `subagent:${runId}`;
+      const payload = {
+        runId,
+        provider: info.provider,
+        id: childSessionId,
+        local: info.local,
+        ...parentLink !== void 0 ? { parentToolCallId: parentLink.toolCallId } : {}
+      };
+      for (const update of record.projection.onEvent({ type: "subagent/start", data: payload })) {
+        notify(rootSessionId, update);
+      }
+      const child = agents.get(info.id);
+      const link = {
+        rootSessionId,
+        childSessionId,
+        runId,
+        provider: info.provider,
+        toolCallId,
+        projection: new SessionProjection(void 0, {
+          terminalOutput: clientTerminalOutput,
+          ...child?.session.header.cwd !== void 0 ? { cwd: child.session.header.cwd } : {},
+          subagent: { childSessionId, parentToolCallId: toolCallId, provider: info.provider }
+        })
+      };
+      subagentByChild.set(childSessionId, link);
+      subagentByRun.set(runId, link);
+      if (child !== void 0) watchSubagentParent(child);
+    });
+    parent.ctx.on("subagent/end", (info) => {
+      const runId = String(info.runId);
+      const link = subagentByRun.get(runId);
+      if (link === void 0) return;
+      const record = sessions.get(link.rootSessionId);
+      if (record !== void 0) {
+        const parentLink = subagentByChild.get(String(parent.id));
+        const payload = {
+          runId,
+          provider: info.provider,
+          id: String(info.id),
+          local: info.local,
+          stopReason: info.stopReason,
+          ...info.lastAssistantMessage !== void 0 ? { lastAssistantMessage: info.lastAssistantMessage } : {},
+          ...parentLink !== void 0 ? { parentToolCallId: parentLink.toolCallId } : {}
+        };
+        for (const update of record.projection.onEvent({ type: "subagent/end", data: payload })) {
+          notify(link.rootSessionId, update);
+        }
+      }
+      subagentByRun.delete(runId);
+      if (subagentByChild.get(link.childSessionId)?.runId === runId) {
+        subagentByChild.delete(link.childSessionId);
+      }
+    });
+  };
   const presetsService = () => agentPresets;
   const presetSetup = (presets, presetId) => {
     if (presetId === void 0) return void 0;
     return async (agentCtx) => {
+      const started = performance.now();
       logDebug(`preset setup: mounting "${presetId}"`);
       await presets.mount(agentCtx, presetId);
-      logDebug(`preset setup: mounted "${presetId}"`);
+      logDebug(`preset setup: mounted "${presetId}" in ${(performance.now() - started).toFixed(1)}ms`);
     };
   };
   const presetFromLog = (header, events) => {
@@ -1363,6 +2223,19 @@ async function apply(ctx, config = {}) {
         options: levels
       });
     }
+    if (commandRuntime.list(record.agent).some((command) => command.name === "plan")) {
+      const active = [...record.agent.session.events].reverse().map((event) => event).find((event) => event.type === "plan/mode")?.data?.["active"] === true;
+      result.push({
+        type: "select",
+        id: "collaboration_mode",
+        name: "Collaboration mode",
+        currentValue: active ? "plan" : "default",
+        options: [
+          { value: "default", name: "Default" },
+          { value: "plan", name: "Plan" }
+        ]
+      });
+    }
     const models = await modelChoices(record);
     if (models.length >= 2) {
       result.push({
@@ -1442,7 +2315,18 @@ async function apply(ctx, config = {}) {
         list.push({
           name: descriptor.name,
           description: descriptor.description,
-          ...descriptor.input !== void 0 ? { input: { hint: descriptor.input.hint } } : {}
+          ...descriptor.input !== void 0 ? { input: { hint: descriptor.input.hint } } : {},
+          ...descriptor.name === "plan" ? {
+            _meta: {
+              commandAction: {
+                kind: "setConfigOption",
+                configId: "collaboration_mode",
+                value: "plan",
+                resetValue: "default",
+                presentation: "state"
+              }
+            }
+          } : {}
         });
       }
     } catch (error) {
@@ -1618,16 +2502,27 @@ async function apply(ctx, config = {}) {
       inflight: void 0
     };
     sessions.set(sessionId, record);
+    watchSubagentParent(agent);
     return record;
   };
   ctx.on("session/event", (session, event) => {
     const sessionId = String(session.header.id);
     const record = sessions.get(sessionId);
-    if (record === void 0 || record.agent.session !== session) return;
+    if (record === void 0 || record.agent.session !== session) {
+      const child = subagentByChild.get(sessionId);
+      if (child !== void 0 && clientSubagentTranscript) {
+        for (const update of child.projection.onEvent(event)) {
+          notify(child.rootSessionId, update);
+        }
+      }
+      return;
+    }
     try {
-      for (const update of record.projection.onEvent(event)) {
+      const harnessEvent = event;
+      for (const update of record.projection.onEvent(harnessEvent)) {
         notify(sessionId, update);
       }
+      if (harnessEvent.type === "plan/mode") publishConfigOptions(sessionId, record);
     } finally {
       const inflight = record.inflight;
       if (inflight !== void 0 && event.type === "turn/end" && inflight.turn === event.data.turn) {
@@ -1677,13 +2572,22 @@ async function apply(ctx, config = {}) {
         const requested = params.protocolVersion;
         const capsMeta = params.clientCapabilities?.["_meta"];
         clientTerminalOutput = capsMeta !== null && typeof capsMeta === "object" ? capsMeta["terminal_output"] === true : false;
+        clientSubagentTranscript = capsMeta !== null && typeof capsMeta === "object" ? capsMeta["subagent-transcript"] === true : false;
+        clientElicitationForm = params.clientCapabilities?.elicitation?.form !== void 0 && params.clientCapabilities.elicitation.form !== null;
+        if (capsMeta !== null && typeof capsMeta === "object" && capsMeta["tuiInspect"] === true) {
+          tuiClient.advertised = true;
+        }
         const providers = await listProviderRoutes();
         return {
           protocolVersion: typeof requested === "number" && requested >= 1 && requested < PROTOCOL_VERSION ? requested : PROTOCOL_VERSION,
           agentInfo: { name: "dsh-acp", title: "DeepSeek Harness", version: VERSION },
           agentCapabilities: {
             loadSession: true,
-            promptCapabilities: { image: false, audio: false, embeddedContext: true },
+            promptCapabilities: {
+              image: attachmentIngestOf(ctx.get("attachments")) !== void 0,
+              audio: false,
+              embeddedContext: true
+            },
             // Stdio servers always work; streamable HTTP maps onto
             // mcp-client's second transport. Legacy SSE does not.
             mcpCapabilities: { http: true, sse: false },
@@ -1738,18 +2642,29 @@ async function apply(ctx, config = {}) {
       },
       async newSession(params) {
         assertOpen();
+        const started = performance.now();
+        let checkpoint = started;
+        const mark = (name3) => {
+          const now = performance.now();
+          logDebug(`session/new ${name3}: ${(now - checkpoint).toFixed(1)}ms (+${(now - started).toFixed(1)}ms)`);
+          checkpoint = now;
+        };
         await requireCredential(config.provider);
+        mark("credential");
         validateCwd(params.cwd);
         syncMcpServers(params.mcpServers, params.cwd);
+        mark("request setup");
         const sessionId = SessionId2(randomUUID());
         const presets = presetsService();
         const presetId = (await presets.resolve(void 0)).id;
+        mark("preset resolve");
         const handle = await agents.create({
           sessionId,
           meta: { cwd: params.cwd, ...presetId !== void 0 ? { agentPreset: presetId } : {} },
           agentOptions: agentOptionsFor(config.model),
           ...presetSetup(presets, presetId) !== void 0 ? { setup: presetSetup(presets, presetId) } : {}
         });
+        mark("agent create");
         if (closed) {
           await handle.dispose();
           throw internalError("connection closed during session/new");
@@ -1765,6 +2680,7 @@ async function apply(ctx, config = {}) {
         ensureSelection(record);
         queueMicrotask(() => publishCommands(String(sessionId)));
         const options = await configOptions(record);
+        mark("response surface");
         return {
           sessionId: String(sessionId),
           modes: modeState(record),
@@ -1812,17 +2728,36 @@ async function apply(ctx, config = {}) {
       async prompt(params) {
         assertOpen();
         const record = await requireOrRestoreSession(params.sessionId);
-        if (record.inflight !== void 0) {
-          throw invalidParams("a prompt is already in flight for this session");
-        }
         let converted;
         try {
-          converted = convertPrompt(params.prompt);
+          converted = await convertPrompt(
+            params.prompt,
+            attachmentIngestOf(ctx.get("attachments"))
+          );
         } catch (error) {
-          if (error instanceof UnsupportedPromptContentError) throw invalidParams(error.message);
+          if (error instanceof UnsupportedPromptContentError || error instanceof PromptImageError) {
+            throw invalidParams(error.message);
+          }
           throw error;
         }
         if (converted.blocks.length === 0) throw invalidParams("empty prompt");
+        if (record.inflight !== void 0) {
+          await requireCredential(record.provider ?? config.provider);
+          if (agents.get(record.agent.id) !== record.agent) {
+            throw internalError("prompt was not steered: the agent was disposed outside the bridge");
+          }
+          const message2 = createUserMessage2({
+            content: converted.blocks,
+            source: { kind: "user" }
+          });
+          try {
+            deliverPrompt(record.agent, message2, true);
+          } catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw internalError(`prompt was not steered: ${detail}`);
+          }
+          return { stopReason: "end_turn" };
+        }
         const trimmed = converted.displayText.trim();
         const commandMatch = trimmed.match(/^\/(\w[\w-]*)\b/);
         const respond = (text) => {
@@ -1867,16 +2802,25 @@ async function apply(ctx, config = {}) {
           throw internalError("prompt was not queued: the agent was disposed outside the bridge");
         }
         record.cancelled = false;
-        record.projection.beginPrompt();
         const message = createUserMessage2({
           content: converted.blocks,
           source: { kind: "user" }
         });
+        if (record.inflight !== void 0) {
+          try {
+            deliverPrompt(record.agent, message, true);
+          } catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw internalError(`prompt was not steered: ${detail}`);
+          }
+          return { stopReason: "end_turn" };
+        }
+        record.projection.beginPrompt();
         const stopReason = await new Promise((resolve, reject) => {
           const inflight = { resolve, reject, messageId: message.id, turn: void 0 };
           record.inflight = inflight;
           try {
-            record.agent.followup(message);
+            deliverPrompt(record.agent, message, false);
           } catch (error) {
             record.inflight = void 0;
             const detail = error instanceof Error ? error.message : String(error);
@@ -1937,6 +2881,23 @@ async function apply(ctx, config = {}) {
             record.effort = value;
             break;
           }
+          case "collaboration_mode": {
+            if (value !== "default" && value !== "plan") {
+              throw invalidParams(`unknown collaboration mode: ${value}`);
+            }
+            const execution = await commandRuntime.execute(
+              record.agent,
+              value === "plan" ? "/plan" : "/plan off",
+              new AbortController().signal
+            );
+            if (execution === void 0) {
+              throw invalidParams("plan mode is unavailable on this session");
+            }
+            if (execution.result.kind === "error") {
+              throw invalidParams(execution.result.text);
+            }
+            break;
+          }
           case "model": {
             await switchModel(record, params.sessionId, value);
             break;
@@ -1974,8 +2935,8 @@ async function apply(ctx, config = {}) {
   }
   const mcpMounts = /* @__PURE__ */ new Map();
   let warnedNoMcpClient = false;
-  const sanitizeServerName = (raw) => {
-    const cleaned = raw.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 32);
+  const sanitizeServerName = (raw2) => {
+    const cleaned = raw2.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 32);
     return cleaned.length > 0 ? cleaned : "server";
   };
   const mcpConfigFor = (server, cwd, serverName) => {
@@ -2056,17 +3017,29 @@ async function apply(ctx, config = {}) {
       }
     }
   };
-  const stream = config.stream ?? ndJsonStream(
+  const raw = config.stream ?? ndJsonStream(
     Writable.toWeb(process.stdout),
     Readable.toWeb(process.stdin)
   );
+  const stream = muxAcpStream(raw, rpc);
   conn = new AgentSideConnection(makeAgent, stream);
+  const disposeUserQuestions = installAcpUserQuestionProvider(userQuestions, {
+    formSupported: () => clientElicitationForm,
+    sessionIdForRequest: (request) => {
+      if (request.agent === void 0) return void 0;
+      const record = ownedRecord(request.agent);
+      return record === void 0 ? void 0 : String(record.agent.session.id);
+    },
+    create: (request) => conn.unstable_createElicitation(request)
+  });
   let quiescing;
   const quiesce = () => {
     if (quiescing !== void 0) return quiescing;
     closed = true;
     const records = [...sessions.values()];
     sessions.clear();
+    subagentByChild.clear();
+    subagentByRun.clear();
     for (const record of records) {
       record.agent.cancel({ kind: "user" });
       settlePrompt(record, "cancelled");
@@ -2097,6 +3070,7 @@ async function apply(ctx, config = {}) {
     logWarn(`connection-close teardown failed: ${String(error)}`);
   });
   ctx.effect(() => quiesce, "acp-bridge.connection");
+  ctx.effect(() => disposeUserQuestions, "acp-bridge.user-questions");
 }
 
 // src/bundle.ts