@openma/deepseek-harness-acp 0.4.5 → 0.4.7

package/dist/bridge.js

@@ -22,7 +22,6 @@ import { createUserMessage, errorChain } from "@deepseek-ai/dsh-llm";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { foldSessionTitle } from "@deepseek-ai/dsh-session-title";
 import { SANDBOX_MODES, setSandboxMode } from "@deepseek-ai/dsh-sandbox-policy";
-import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import * as agentModule from "@deepseek-ai/dsh-agent";
 import * as mcpClient from "@deepseek-ai/dsh-mcp-client";
 function selfHarness() {
@@ -35,7 +34,6 @@ function selfHarness() {
     foldSessionTitle,
     setSandboxMode,
     sandboxModes: SANDBOX_MODES,
-    credentialRef,
     ...installModelSelection !== void 0 ? { installModelSelection } : {},
     mcpClient
   };
@@ -56,11 +54,245 @@ import {
   PROTOCOL_VERSION,
   RequestError
 } from "@agentclientprotocol/sdk";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
 
 // src/version.ts
 import { createRequire } from "node:module";
 var VERSION = createRequire(import.meta.url)("../package.json").version;
 
+// src/auth.ts
+var LOGIN_DESCRIPTION = "Save an API key to the harness credential store shared with the dsh Web UI";
+function isDeepseekRoute(provider) {
+  return provider === void 0 || provider === "deepseek-official" || provider === "deepseek";
+}
+function credentialEnvNames(provider) {
+  if (provider === void 0 || isDeepseekRoute(provider)) return ["DEEPSEEK_API_KEY", "DEEPSEEK_BASE_URL"];
+  if (provider === "anthropic") return ["ANTHROPIC_API_KEY"];
+  if (provider === "openai" || provider.startsWith("openai")) return ["OPENAI_API_KEY"];
+  return [`${provider.replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase()}_API_KEY`];
+}
+function primaryCredentialName(provider) {
+  return credentialEnvNames(provider)[0] ?? "DEEPSEEK_API_KEY";
+}
+function providerFromAuthMethodId(methodId) {
+  if (!methodId) return void 0;
+  for (const prefix of ["api-key:", "terminal-login:"]) {
+    if (methodId.startsWith(prefix)) return methodId.slice(prefix.length);
+  }
+  return void 0;
+}
+function apiKeyFromAuthenticate(params) {
+  const meta = params._meta;
+  const block = meta && typeof meta === "object" && !Array.isArray(meta) ? meta["api-key"] : void 0;
+  const record = block && typeof block === "object" && !Array.isArray(block) ? block : void 0;
+  const key = typeof record?.apiKey === "string" ? record.apiKey.trim() : void 0;
+  const providerFromMeta = typeof record?.provider === "string" ? record.provider : void 0;
+  const provider = providerFromMeta || providerFromAuthMethodId(params.methodId);
+  return {
+    ...provider && provider.length > 0 ? { provider } : {},
+    ...key && key.length > 0 ? { key } : {}
+  };
+}
+function gatewayFromAuthenticate(params) {
+  const meta = params._meta;
+  const block = meta && typeof meta === "object" && !Array.isArray(meta) ? meta.gateway : void 0;
+  const record = block && typeof block === "object" && !Array.isArray(block) ? block : void 0;
+  const baseUrl = typeof record?.baseUrl === "string" ? record.baseUrl.trim() : void 0;
+  const headers = stringRecord(record?.headers);
+  const providerName = typeof record?.providerName === "string" ? record.providerName.trim() : void 0;
+  const key = apiKeyFromHeaders(headers);
+  return {
+    ...baseUrl && baseUrl.length > 0 ? { baseUrl } : {},
+    ...headers ? { headers } : {},
+    ...providerName && providerName.length > 0 ? { providerName } : {},
+    ...key && key.length > 0 ? { key } : {}
+  };
+}
+function isBrowserAuthMethod(methodId) {
+  return methodId === "browser";
+}
+function isGatewayAuthMethod(methodId) {
+  return methodId === "gateway";
+}
+function credentialBaseUrlName(provider) {
+  if (isDeepseekRoute(provider) || provider === void 0) return "DEEPSEEK_BASE_URL";
+  if (provider === "anthropic") return "ANTHROPIC_BASE_URL";
+  if (provider === "openai" || provider.startsWith("openai")) return "OPENAI_BASE_URL";
+  return `${provider.replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase()}_BASE_URL`;
+}
+function advertisedAuthMethods(providers, clientCapabilities, env = process.env) {
+  const methods = [...apiKeyAuthMethods(providers)];
+  if (shouldOfferLocalAuthPage(env)) methods.push(browserAuthMethod());
+  if (clientCapabilities?.auth?._meta?.["gateway"] === true) methods.push(gatewayAuthMethod());
+  return methods;
+}
+function apiKeyAuthMethods(providers) {
+  if (providers.length <= 1) {
+    const provider = providers[0];
+    return [apiKeyAuthMethod(provider?.id, provider?.name, providers.length === 0)];
+  }
+  return providers.map((provider) => apiKeyAuthMethod(provider.id, provider.name, false));
+}
+function apiKeyAuthMethod(provider, name3, unscoped) {
+  const scoped = !unscoped && provider !== void 0;
+  return {
+    id: scoped ? `api-key:${provider}` : "api-key",
+    name: scoped ? `${name3 ?? provider} API key` : "API Key",
+    description: LOGIN_DESCRIPTION,
+    _meta: { "api-key": scoped ? { provider } : {} }
+  };
+}
+function shouldOfferLocalAuthPage(env = process.env) {
+  if (env["NO_BROWSER"]) return false;
+  if (env["NODE_ENV"] === "test" || env["CI"] === "true" || env["CI"] === "1") return false;
+  if (env["DSH_ACP_AUTH_PAGE"] === "0") return false;
+  return true;
+}
+function browserAuthMethod() {
+  return {
+    id: "browser",
+    name: "Browser",
+    description: "Open a local sign-in page to save an API key. The secret never travels over ACP."
+  };
+}
+function gatewayAuthMethod() {
+  return {
+    id: "gateway",
+    name: "Custom model gateway",
+    description: "Use a custom OpenAI-compatible gateway",
+    _meta: { gateway: { protocol: "openai", restartRequired: "false" } }
+  };
+}
+function stringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entries = Object.entries(value).filter(
+    (entry) => typeof entry[1] === "string" && entry[1].trim().length > 0
+  );
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function apiKeyFromHeaders(headers) {
+  if (!headers) return void 0;
+  const authorization = headers["Authorization"] ?? headers["authorization"];
+  if (authorization) {
+    const bearer = authorization.match(/^Bearer\s+(.+)$/i);
+    const token = (bearer?.[1] ?? authorization).trim();
+    if (token.length > 0) return token;
+  }
+  const first = Object.values(headers).find((value) => value.trim().length > 0);
+  return first?.trim();
+}
+
+// src/auth-page.ts
+import { createServer } from "node:http";
+import { execFile } from "node:child_process";
+function startLocalAuthPage(options) {
+  return new Promise((resolve, reject) => {
+    const server = createServer((request, response) => {
+      void handle(request, response);
+    });
+    let settle;
+    let fail;
+    const completed = new Promise((res, rej) => {
+      settle = res;
+      fail = rej;
+    });
+    const timeoutMs = options.timeoutMs ?? 10 * 6e4;
+    const timer = setTimeout(() => {
+      server.close();
+      fail?.(new Error("local auth page timed out"));
+    }, timeoutMs);
+    timer.unref?.();
+    const handle = async (request, response) => {
+      if (request.method === "GET" || request.method === void 0) {
+        response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        response.end(authPageHtml(options.credentialName));
+        return;
+      }
+      if (request.method === "POST") {
+        const body = await readBody(request);
+        const key = new URLSearchParams(body).get("api-key")?.trim() ?? "";
+        if (key.length === 0) {
+          response.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+          response.end(authPageHtml(options.credentialName, "Enter an API key."));
+          return;
+        }
+        response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        response.end(
+          "<!doctype html><html><body><p>Saved. You can return to the client.</p></body></html>"
+        );
+        clearTimeout(timer);
+        server.close();
+        settle?.(key);
+        return;
+      }
+      response.writeHead(405);
+      response.end();
+    };
+    server.once("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close();
+        reject(new Error("local auth page failed to bind"));
+        return;
+      }
+      const url = `http://127.0.0.1:${address.port}/`;
+      resolve({
+        url,
+        close: () => {
+          clearTimeout(timer);
+          server.close();
+        },
+        completed
+      });
+    });
+  });
+}
+function openLocalAuthPage(url) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    execFile("open", [url], () => void 0);
+    return;
+  }
+  if (platform === "win32") {
+    execFile("cmd", ["/c", "start", "", url], () => void 0);
+    return;
+  }
+  execFile("xdg-open", [url], () => void 0);
+}
+function authPageHtml(credentialName, error) {
+  const message = error ? `<p>${escapeHtml(error)}</p>` : "";
+  return `<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8"><title>DeepSeek Harness sign in</title></head>
+<body>
+  <h1>Save API key</h1>
+  <p>Stored as ${escapeHtml(credentialName)} in the harness credential store.</p>
+  ${message}
+  <form method="post">
+    <label>API key <input type="password" name="api-key" autocomplete="off" required></label>
+    <button type="submit">Save</button>
+  </form>
+</body>
+</html>`;
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[char] ?? char);
+}
+function readBody(request) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    request.on("data", (chunk) => {
+      chunks.push(Buffer.from(chunk));
+    });
+    request.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    request.on("error", reject);
+  });
+}
+
 // src/log.ts
 var PREFIX = "[dsh-acp]";
 function logWarn(message) {
@@ -212,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;
@@ -255,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;
@@ -269,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() {
@@ -307,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":
@@ -317,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);
@@ -341,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);
@@ -399,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 [
@@ -504,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;
@@ -519,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"];
@@ -549,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":
@@ -591,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"];
+var inject = ["agents", "credentials", "llm", "agentDefaultModel", "sessionPersistence", "approval", "permissionPresets", "commands", "agentPresets", "skills", "subagents", "userQuestions"];
 function invalidParams(detail) {
   return RequestError.invalidParams(void 0, detail);
 }
@@ -614,9 +1624,6 @@ function internalError(detail) {
 function authRequired(detail) {
   return RequestError.authRequired(void 0, detail);
 }
-function envCredentialPresent() {
-  return Boolean(process.env["DEEPSEEK_API_KEY"] || process.env["DEEPSEEK_BASE_URL"]);
-}
 var MODE_LABELS = {
   "read-only": { name: "Read-only", description: "Bash and file mutations are denied by the sandbox" },
   "workspace-write": {
@@ -630,13 +1637,40 @@ var MODE_LABELS = {
 };
 async function apply(ctx, config = {}) {
   const agents = ctx.agents;
+  const credentials = ctx.credentials;
+  const llm = ctx.llm;
+  const agentDefaultModel = ctx.agentDefaultModel;
+  const sessionPersistence = ctx.sessionPersistence;
+  const approval = ctx.approval;
+  const permissionPresets = ctx.permissionPresets;
+  const commandRuntime = ctx.commands;
+  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);
@@ -644,10 +1678,8 @@ async function apply(ctx, config = {}) {
     return [...seen];
   };
   const defaultSelection = () => {
-    const service = ctx.get("agentDefaultModel");
-    if (service === void 0) return {};
     try {
-      return service.currentSelection();
+      return agentDefaultModel.currentSelection();
     } catch (error) {
       logDebug(`agentDefaultModel.currentSelection failed: ${String(error)}`);
       return {};
@@ -664,28 +1696,25 @@ async function apply(ctx, config = {}) {
   const effortCache = /* @__PURE__ */ new Map();
   const discoverModels = async () => {
     if (liveCatalog !== void 0) return liveCatalog;
-    const llm = ctx.get("llm");
     const found = [];
-    if (llm !== void 0) {
-      try {
-        const providers = llm.listProviders();
-        const multi = providers.length > 1;
-        for (const provider of providers) {
-          const models = await llm.listModels(provider.id).catch((error) => {
-            logDebug(`listModels(${provider.id}) failed: ${String(error)}`);
-            return [];
+    try {
+      const providers = llm.listProviders();
+      const multi = providers.length > 1;
+      for (const provider of providers) {
+        const models = await llm.listModels(provider.id).catch((error) => {
+          logDebug(`listModels(${provider.id}) failed: ${String(error)}`);
+          return [];
+        });
+        for (const model of models) {
+          found.push({
+            provider: provider.id,
+            model: model.id,
+            label: multi ? `${model.name} (${provider.name})` : model.name
           });
-          for (const model of models) {
-            found.push({
-              provider: provider.id,
-              model: model.id,
-              label: multi ? `${model.name} (${provider.name})` : model.name
-            });
-          }
         }
-      } catch (error) {
-        logDebug(`model discovery failed: ${String(error)}`);
       }
+    } catch (error) {
+      logDebug(`model discovery failed: ${String(error)}`);
     }
     liveCatalog = found;
     return found;
@@ -721,10 +1750,9 @@ async function apply(ctx, config = {}) {
     if (provider === void 0 || model === void 0) return void 0;
     const key = `${provider}::${model}`;
     if (effortCache.has(key)) return effortCache.get(key);
-    const llm = ctx.get("llm");
     let catalog;
     try {
-      const reasoning = (await llm?.resolveModelInfo?.(provider, model))?.reasoning;
+      const reasoning = (await llm.resolveModelInfo(provider, model)).reasoning;
       if (reasoning !== void 0 && reasoning.efforts.length > 0) {
         catalog = {
           efforts: reasoning.efforts.map((effort) => ({
@@ -827,27 +1855,38 @@ async function apply(ctx, config = {}) {
     }
     setApprovalPolicy(record, record.approvals);
   };
-  const credentialPresent = async () => {
-    if (envCredentialPresent()) return true;
-    const brand = harness.credentialRef;
-    if (brand === void 0) return false;
-    const deadline = Date.now() + 5e3;
-    for (; ; ) {
-      const seam = ctx.get("credentials");
-      if (seam !== void 0) {
-        try {
-          return await seam.resolve(brand("DEEPSEEK_API_KEY")) !== void 0;
-        } catch (error) {
-          logWarn(`credential lookup failed: ${String(error)}`);
-          return false;
-        }
-      }
-      if (Date.now() >= deadline) {
-        logDebug("credential gate: no credentials service registered within 5s");
-        return false;
+  const listProviderRoutes = async () => {
+    try {
+      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 [];
+        const name3 = entry.name;
+        return [{ id, ...typeof name3 === "string" && name3.length > 0 ? { name: name3 } : {} }];
+      });
+    } catch (error) {
+      logDebug(`listProviders failed: ${String(error)}`);
+      return [];
+    }
+  };
+  const credentialPresent = async (provider) => {
+    const names = credentialEnvNames(provider).filter((name3) => !name3.endsWith("_BASE_URL"));
+    for (const name3 of names) {
+      try {
+        if (await credentials.resolve(credentialRef(name3)) !== void 0) return true;
+      } catch (error) {
+        logWarn(`credential lookup failed: ${String(error)}`);
       }
-      await new Promise((resolve) => setTimeout(resolve, 100));
     }
+    return false;
+  };
+  const requireCredential = async (provider) => {
+    if (await credentialPresent(provider)) return;
+    throw authRequired(
+      'no credential found for this provider: call authenticate with `_meta["api-key"].apiKey` or `_meta.gateway`, use the browser method, run `dsh-acp login`, or save a key in the dsh Web UI (Settings \u2192 Models)'
+    );
   };
   const agentOptionsFor = (model, provider) => ({
     ...provider !== void 0 ? { provider } : config.provider !== void 0 ? { provider: config.provider } : {},
@@ -866,7 +1905,6 @@ async function apply(ctx, config = {}) {
   const requireOrRestoreSession = async (sessionId) => {
     const record = sessions.get(sessionId);
     if (record !== void 0) return record;
-    if (ctx.get("sessionPersistence") === void 0) throw invalidParams(`unknown session: ${sessionId}`);
     logWarn(`restoring session ${sessionId} from the persisted log`);
     try {
       return await restoreSession(sessionId, { replay: false });
@@ -906,7 +1944,7 @@ async function apply(ctx, config = {}) {
     }
     const presets = presetsService();
     const storedPreset = presetFromLog(storedHeader, events);
-    const presetId = presets === void 0 ? void 0 : (await presets.resolve(storedPreset)).id;
+    const presetId = (await presets.resolve(storedPreset)).id;
     const handle = await agents.resume({
       resumeSessionId: SessionId2(sessionId),
       agentOptions: agentOptionsFor(config.model),
@@ -929,7 +1967,7 @@ async function apply(ctx, config = {}) {
     if (presetId !== void 0) record.preset = presetId;
     {
       const permission = permissionService();
-      const storedMode = permission?.current(events);
+      const storedMode = permission.current(events);
       if (storedMode !== void 0) record.modeId = storedMode;
       for (let index = events.length - 1; index >= 0; index -= 1) {
         const event = events[index];
@@ -958,13 +1996,78 @@ async function apply(ctx, config = {}) {
     record.inflight = void 0;
     inflight.resolve(reason);
   };
-  const presetsService = () => ctx.get("agentPresets");
+  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 (presets === void 0 || presetId === void 0) return void 0;
+    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) => {
@@ -979,7 +2082,7 @@ async function apply(ctx, config = {}) {
   const presetLabel = (id) => id.charAt(0).toUpperCase() + id.slice(1);
   const modeState = (record) => {
     const permission = permissionService();
-    if (permission !== void 0 && permission.names.length > 0) {
+    if (permission.names.length > 0) {
       return {
         currentModeId: record.modeId,
         availableModes: permission.names.map((name3) => {
@@ -1001,7 +2104,6 @@ async function apply(ctx, config = {}) {
       throw invalidParams("cannot switch presets while a prompt is running");
     }
     const presets = presetsService();
-    if (presets === void 0) throw invalidParams(`unknown mode: ${presetId}`);
     let resolved;
     try {
       resolved = (await presets.resolve(presetId)).id;
@@ -1009,29 +2111,44 @@ async function apply(ctx, config = {}) {
       throw invalidParams(`unknown preset: ${presetId} (${errorChain2(error)})`);
     }
     if (resolved === record.preset) return;
-    try {
-      record.agent.session.append("agent-preset/selected", { agentPreset: resolved });
-    } catch (error) {
-      logWarn(`recording preset selection failed: ${String(error)}`);
-    }
+    const previous = record.preset;
     const sessionId = record.agent.session.id;
+    const resumeWith = (id) => agents.resume({
+      resumeSessionId: sessionId,
+      agentOptions: agentOptionsFor(record.model ?? config.model, record.provider),
+      ...presetSetup(presets, id) !== void 0 ? { setup: presetSetup(presets, id) } : {}
+    });
     await record.dispose().catch((error) => {
       logWarn(`dispose during preset switch failed: ${String(error)}`);
     });
     let handle;
     try {
-      handle = await agents.resume({
-        resumeSessionId: sessionId,
-        agentOptions: agentOptionsFor(record.model ?? config.model, record.provider),
-        setup: presetSetup(presets, resolved)
-      });
+      handle = await resumeWith(resolved);
     } catch (error) {
-      sessions.delete(acpSessionId);
-      throw internalError(`preset switch failed: ${errorChain2(error)}`);
+      try {
+        handle = await resumeWith(previous);
+      } catch (restoreError) {
+        sessions.delete(acpSessionId);
+        throw internalError(
+          `preset switch failed: ${errorChain2(error)}; restore also failed: ${errorChain2(restoreError)}`
+        );
+      }
+      record.agent = handle.agent;
+      record.dispose = () => handle.dispose();
+      delete record.selection;
+      ensureSelection(record);
+      setApprovalPolicy(record, record.approvals);
+      publishCommands(acpSessionId, record);
+      throw invalidParams(`preset "${resolved}" failed to mount: ${errorChain2(error)}`);
     }
     record.agent = handle.agent;
     record.dispose = () => handle.dispose();
     record.preset = resolved;
+    try {
+      handle.agent.session.append("agent-preset/selected", { agentPreset: resolved });
+    } catch (error) {
+      logWarn(`recording preset selection failed: ${String(error)}`);
+    }
     delete record.selection;
     ensureSelection(record);
     setApprovalPolicy(record, record.approvals);
@@ -1039,16 +2156,16 @@ async function apply(ctx, config = {}) {
   };
   const setApprovalPolicy = (record, policy) => {
     try {
-      ctx.get("approval")?.setPolicy?.(record.agent, policy);
+      approval.setPolicy(record.agent, policy);
     } catch (error) {
       logWarn(`approval policy switch failed: ${String(error)}`);
     }
     record.approvals = policy;
   };
-  const permissionService = () => ctx.get("permissionPresets") ?? ctx.get("permission");
+  const permissionService = () => permissionPresets;
   const applyMode = (record, sessionId, modeId) => {
     const permission = permissionService();
-    if (permission !== void 0 && permission.names.includes(modeId)) {
+    if (permission.names.includes(modeId)) {
       let bundledApproval = record.approvals;
       permission.apply(record.agent.session, modeId, (policy) => {
         bundledApproval = policy;
@@ -1090,7 +2207,7 @@ async function apply(ctx, config = {}) {
     const result = [];
     {
       const permission = permissionService();
-      const levels = permission !== void 0 && permission.names.length > 0 ? permission.names.map((name3) => {
+      const levels = permission.names.length > 0 ? permission.names.map((name3) => {
         const spec = permission.resolve(name3);
         return { value: name3, name: spec.name, description: spec.description };
       }) : SANDBOX_MODES2.map((mode) => {
@@ -1106,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({
@@ -1145,14 +2275,14 @@ async function apply(ctx, config = {}) {
       });
     }
     const presets = presetsService();
-    if (presets !== void 0 && record.preset !== void 0) {
+    if (record.preset !== void 0) {
       try {
         const roster = await presets.list();
         if (roster.length >= 2) {
           result.push({
             type: "select",
-            id: "preset",
-            name: "Preset",
+            id: "agent",
+            name: "Agent",
             currentValue: record.preset,
             options: roster.map((preset) => ({
               value: preset.id,
@@ -1169,12 +2299,6 @@ async function apply(ctx, config = {}) {
   };
   const BUILTIN_COMMANDS = [
     { name: "status", description: "Show adapter, model, mode, and token status" },
-    {
-      name: "login",
-      description: "Save a DeepSeek API key into the harness credential store (~/.dsh/.credentials.yaml)",
-      input: { hint: "<api-key>" }
-    },
-    { name: "logout", description: "Remove the API key stored in the harness credential store" },
     {
       name: "model",
       description: "Select the model for this conversation",
@@ -1184,42 +2308,47 @@ async function apply(ctx, config = {}) {
   const availableCommandsFor = async (record) => {
     const list = [...BUILTIN_COMMANDS];
     const seen = new Set(list.map((command) => command.name));
-    const commandsSvc = ctx.get("commands");
-    if (commandsSvc !== void 0) {
-      try {
-        for (const descriptor of commandsSvc.list(record.agent)) {
-          if (seen.has(descriptor.name)) continue;
-          seen.add(descriptor.name);
-          list.push({
-            name: descriptor.name,
-            description: descriptor.description,
-            ...descriptor.input !== void 0 ? { input: { hint: descriptor.input.hint } } : {}
-          });
-        }
-      } catch (error) {
-        logWarn(`command listing failed: ${String(error)}`);
+    try {
+      for (const descriptor of commandRuntime.list(record.agent)) {
+        if (seen.has(descriptor.name)) continue;
+        seen.add(descriptor.name);
+        list.push({
+          name: descriptor.name,
+          description: descriptor.description,
+          ...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) {
+      logWarn(`command listing failed: ${String(error)}`);
     }
-    const skillsSvc = ctx.get("skills");
-    if (skillsSvc !== void 0) {
-      try {
-        const skills = await skillsSvc.list({
-          ...record.agent.session.header.cwd !== void 0 ? { cwd: record.agent.session.header.cwd } : {},
-          scope: record.agent
+    try {
+      const skills = await skillRegistry.list({
+        ...record.agent.session.header.cwd !== void 0 ? { cwd: record.agent.session.header.cwd } : {},
+        scope: record.agent
+      });
+      for (const skill of skills) {
+        if (skill.invocation.userInvocable !== true) continue;
+        if (seen.has(skill.name)) continue;
+        seen.add(skill.name);
+        list.push({
+          name: skill.name,
+          description: skill.description,
+          input: { hint: "instructions for the skill" }
         });
-        for (const skill of skills) {
-          if (skill.invocation.userInvocable !== true) continue;
-          if (seen.has(skill.name)) continue;
-          seen.add(skill.name);
-          list.push({
-            name: skill.name,
-            description: skill.description,
-            input: { hint: "instructions for the skill" }
-          });
-        }
-      } catch (error) {
-        logDebug(`skill listing failed: ${String(error)}`);
       }
+    } catch (error) {
+      logDebug(`skill listing failed: ${String(error)}`);
     }
     return list;
   };
@@ -1246,7 +2375,7 @@ async function apply(ctx, config = {}) {
     const events = record.agent.session.events;
     if (events === void 0) return;
     const permission = permissionService();
-    const storedMode = permission?.current(events);
+    const storedMode = permission.current(events);
     for (let index = events.length - 1; index >= 0; index -= 1) {
       const event = events[index];
       if (event?.type === "approval/policy") {
@@ -1263,69 +2392,35 @@ async function apply(ctx, config = {}) {
       });
     }
   };
-  const credentialStore = () => {
-    const brand = harness.credentialRef;
-    const store = ctx.get("credentials");
-    if (brand === void 0 || store === void 0) return void 0;
-    return { store, ref: brand("DEEPSEEK_API_KEY") };
-  };
-  const maskKey = (value) => value.length <= 8 ? "\u2026" : `${value.slice(0, 4)}\u2026${value.slice(-4)}`;
-  const describeCredential = async () => {
-    if (envCredentialPresent()) {
-      const viaEnv = process.env["DEEPSEEK_API_KEY"] !== void 0 ? "DEEPSEEK_API_KEY" : "DEEPSEEK_BASE_URL";
-      return `process environment (${viaEnv})`;
-    }
-    const cs = credentialStore();
-    if (cs === void 0) return "not configured";
-    try {
-      const info = await cs.store.describe(cs.ref);
-      if (!info.configured) return "not configured";
-      return info.source ?? "credential store";
-    } catch (error) {
-      logWarn(`credential describe failed: ${String(error)}`);
-      return "unknown";
+  const describeCredential = async (provider) => {
+    const names = credentialEnvNames(provider).filter((candidate) => !candidate.endsWith("_BASE_URL"));
+    for (const name3 of names) {
+      try {
+        const info = await credentials.describe(credentialRef(name3));
+        if (info.configured) return info.source ?? "credential store";
+      } catch (error) {
+        logWarn(`credential describe failed: ${String(error)}`);
+      }
     }
+    return "not configured";
   };
-  const loginText = async (rawArgument) => {
-    const key = rawArgument.trim();
-    const cs = credentialStore();
-    if (cs === void 0) {
-      return "This composition has no writable credential store; export DEEPSEEK_API_KEY in the environment that launches the agent instead.";
-    }
-    if (key.length === 0) {
-      return [
-        "Usage: `/login <api-key>` \u2014 stores the key in the harness credential store",
-        "(`~/.dsh/.credentials.yaml`, the same file the dsh Web UI writes; mode 600).",
-        "",
-        `Current credential source: ${await describeCredential()}.`,
-        "",
-        "Note: text entered here also lands in your client's chat history. If you",
-        "prefer to keep the key out of it, save the key in the dsh Web UI instead."
-      ].join("\n");
-    }
-    try {
-      await cs.store.set(cs.ref, key);
-    } catch (error) {
-      return [
-        `Could not store the key: ${error instanceof Error ? error.message : String(error)}`,
-        "",
-        "A read-only source (usually the process environment) is currently supplying",
-        "this credential, so a stored value would be shadowed. Unset DEEPSEEK_API_KEY",
-        "in the launching environment, or keep using it as the credential."
-      ].join("\n");
-    }
-    return `Saved DEEPSEEK_API_KEY (${maskKey(key)}) to the harness credential store \u2014 source now: ${await describeCredential()}. The dsh Web UI sees the same key.`;
+  const saveCredential = async (provider, key) => {
+    await credentials.set(credentialRef(primaryCredentialName(provider)), key);
   };
-  const logoutText = async () => {
-    const cs = credentialStore();
-    if (cs === void 0) return "This composition has no writable credential store; nothing to remove.";
-    try {
-      await cs.store.unset(cs.ref);
-    } catch (error) {
-      return `Could not remove the stored key: ${error instanceof Error ? error.message : String(error)}`;
+  const saveGateway = async (provider, key, baseUrl) => {
+    await saveCredential(provider, key);
+    await credentials.set(credentialRef(credentialBaseUrlName(provider)), baseUrl);
+  };
+  const logoutStored = async () => {
+    const routes = await listProviderRoutes();
+    const providers = routes.length > 0 ? routes.map((route) => route.id) : [config.provider];
+    for (const provider of providers) {
+      try {
+        await credentials.unset(credentialRef(primaryCredentialName(provider)));
+      } catch (error) {
+        logWarn(`credential unset failed: ${String(error)}`);
+      }
     }
-    const remaining = await describeCredential();
-    return remaining === "not configured" ? "Removed the stored DEEPSEEK_API_KEY. No credential is configured now." : `Removed the stored DEEPSEEK_API_KEY; requests now authenticate via: ${remaining}.`;
   };
   const modelCommandText = async (record, acpSessionId, query) => {
     const discovered = await discoverModels();
@@ -1382,7 +2477,7 @@ async function apply(ctx, config = {}) {
       `| Provider | ${route.provider ?? "(composition default)"} |`,
       `| Model | ${route.model ?? "(composition default)"} |`,
       `| Reasoning | ${effort ?? "(adapter default)"} |`,
-      `| Credential | ${await describeCredential()} |`,
+      `| Credential | ${await describeCredential(route.provider)} |`,
       ...record.preset !== void 0 ? [`| Preset | ${record.preset} |`] : [],
       `| Permission mode | ${record.modeId} |`,
       `| Approvals | ${record.approvals} |`,
@@ -1407,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) {
@@ -1453,11 +2559,7 @@ async function apply(ctx, config = {}) {
     }).then(({ outcome }) => {
       if (outcome.outcome === "cancelled") return "cancelled";
       if (outcome.optionId === "allow-always") {
-        try {
-          ctx.get("approval")?.setPolicy?.(record.agent, "never");
-        } catch (error) {
-          logWarn(`approval policy switch failed: ${String(error)}`);
-        }
+        setApprovalPolicy(record, "never");
         return "allowed-once";
       }
       return outcome.optionId === "allow-once" ? "allowed-once" : "rejected";
@@ -1466,56 +2568,103 @@ async function apply(ctx, config = {}) {
   const makeAgent = (connection) => {
     conn = connection;
     return {
-      initialize(params) {
-        const hasPersistence = ctx.get("sessionPersistence") !== void 0;
+      async initialize(params) {
         const requested = params.protocolVersion;
         const capsMeta = params.clientCapabilities?.["_meta"];
         clientTerminalOutput = capsMeta !== null && typeof capsMeta === "object" ? capsMeta["terminal_output"] === true : false;
-        return Promise.resolve({
+        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: hasPersistence,
-            promptCapabilities: { image: false, audio: false, embeddedContext: true },
+            loadSession: 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 },
-            ...hasPersistence ? { sessionCapabilities: { list: {} } } : {}
+            auth: { logout: {} },
+            sessionCapabilities: { list: {} }
           },
-          authMethods: [
-            // ACP Terminal Auth (see the registry's AUTHENTICATION.md):
-            // the client runs `dsh-acp login` in an interactive
-            // terminal; the key lands in the shared harness
-            // credential store (~/.dsh/.credentials.yaml).
-            {
-              id: "terminal-login",
-              name: "Log in with a DeepSeek API key",
-              description: "Interactive terminal setup \u2014 saves the key to the harness credential store shared with the dsh Web UI",
-              _meta: { "terminal-auth": { args: ["login"], env: {} } }
-            }
-          ]
-        });
+          authMethods: advertisedAuthMethods(
+            providers,
+            params.clientCapabilities
+          )
+        };
       },
-      async authenticate(_params) {
-        if (!await credentialPresent()) {
-          throw authRequired(
-            "no DeepSeek credential found: run `dsh-acp login`, save one in the dsh Web UI (Settings \u2192 Models), or set DEEPSEEK_API_KEY"
+      async authenticate(params) {
+        const gateway = gatewayFromAuthenticate(params);
+        if (isGatewayAuthMethod(params.methodId) || gateway.baseUrl) {
+          if (!gateway.baseUrl || !gateway.key) {
+            throw authRequired(
+              "authenticate gateway requires `_meta.gateway.baseUrl` and an Authorization header"
+            );
+          }
+          await saveGateway(
+            gateway.providerName ?? config.provider,
+            gateway.key,
+            gateway.baseUrl
           );
+          return;
         }
+        const submitted = apiKeyFromAuthenticate(params);
+        const provider = submitted.provider ?? providerFromAuthMethodId(params.methodId) ?? config.provider;
+        if (submitted.key) {
+          await saveCredential(provider, submitted.key);
+          return;
+        }
+        if (await credentialPresent(provider)) return;
+        if (isBrowserAuthMethod(params.methodId) && shouldOfferLocalAuthPage()) {
+          const page = await startLocalAuthPage({
+            credentialName: primaryCredentialName(provider)
+          });
+          openLocalAuthPage(page.url);
+          try {
+            const key = await page.completed;
+            await saveCredential(provider, key);
+            return;
+          } finally {
+            page.close();
+          }
+        }
+        await requireCredential(provider);
+      },
+      async logout(_params) {
+        await logoutStored();
       },
       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 = presets === void 0 ? void 0 : (await presets.resolve(void 0)).id;
+        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");
@@ -1531,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),
@@ -1539,6 +2689,7 @@ async function apply(ctx, config = {}) {
       },
       async loadSession(params) {
         assertOpen();
+        await requireCredential(config.provider);
         validateCwd(params.cwd);
         syncMcpServers(params.mcpServers, params.cwd);
         requirePersistence();
@@ -1577,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) => {
@@ -1598,10 +2768,6 @@ async function apply(ctx, config = {}) {
           return { stopReason: "end_turn" };
         };
         if (commandMatch?.[1] === "status") return respond(await statusText(record));
-        if (commandMatch?.[1] === "login") {
-          return respond(await loginText(trimmed.slice(commandMatch[0].length)));
-        }
-        if (commandMatch?.[1] === "logout") return respond(await logoutText());
         if (commandMatch?.[1] === "model") {
           return respond(
             await modelCommandText(
@@ -1612,54 +2778,49 @@ async function apply(ctx, config = {}) {
           );
         }
         if (commandMatch !== null && commandMatch[1] !== void 0) {
-          const commandsSvc = ctx.get("commands");
-          if (commandsSvc !== void 0) {
-            let execution;
-            try {
-              execution = await commandsSvc.execute(
-                record.agent,
-                trimmed,
-                new AbortController().signal
-              );
-            } catch (error) {
-              return respond(`\u26A0 /${commandMatch[1]} failed: ${errorChain2(error)}`);
-            }
-            if (execution !== void 0) {
-              const { result } = execution;
-              const text = result.text ?? (result.kind === "success" ? `/${commandMatch[1]} \u2713` : `/${commandMatch[1]} failed`);
-              syncPermissionState(record, params.sessionId);
-              publishCommands(params.sessionId, record);
-              publishConfigOptions(params.sessionId, record);
-              return respond(result.kind === "error" ? `\u26A0 ${text}` : text);
-            }
+          let execution;
+          try {
+            execution = await commandRuntime.execute(
+              record.agent,
+              trimmed,
+              new AbortController().signal
+            );
+          } catch (error) {
+            return respond(`\u26A0 /${commandMatch[1]} failed: ${errorChain2(error)}`);
+          }
+          if (execution !== void 0) {
+            const { result } = execution;
+            const text = result.text ?? (result.kind === "success" ? `/${commandMatch[1]} \u2713` : `/${commandMatch[1]} failed`);
+            syncPermissionState(record, params.sessionId);
+            publishCommands(params.sessionId, record);
+            publishConfigOptions(params.sessionId, record);
+            return respond(result.kind === "error" ? `\u26A0 ${text}` : text);
           }
         }
-        if (!await credentialPresent()) {
-          return respond(
-            [
-              "No DeepSeek credential is configured, so this prompt was not sent to the model.",
-              "",
-              "Configure one of:",
-              "- `/login <api-key>` \u2014 store a key in the harness credential store right here,",
-              "- the dsh Web UI (`dsh web`, Settings \u2192 Models),",
-              "- `DEEPSEEK_API_KEY` in the environment that launches this agent."
-            ].join("\n")
-          );
-        }
+        await requireCredential(record.provider ?? config.provider);
         if (agents.get(record.agent.id) !== record.agent) {
           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);
@@ -1697,6 +2858,7 @@ async function apply(ctx, config = {}) {
             applyMode(record, params.sessionId, value);
             break;
           }
+          case "agent":
           case "preset": {
             await switchPreset(record, params.sessionId, value);
             break;
@@ -1719,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;
@@ -1749,22 +2928,15 @@ async function apply(ctx, config = {}) {
     };
   };
   function requirePersistence() {
-    const persistence = getPersistence();
-    if (persistence === void 0) {
-      throw internalError("session persistence is not composed; session history is unavailable");
-    }
-    return persistence;
-  }
-  function getPersistence() {
-    return ctx.get("sessionPersistence");
+    return sessionPersistence;
   }
   function validateCwd(cwd) {
     if (!isAbsolute(cwd)) throw invalidParams(`cwd must be an absolute path: ${cwd}`);
   }
   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) => {
@@ -1845,29 +3017,38 @@ 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");
     }
     quiescing = (async () => {
-      const subagents = ctx.get("subagents");
-      if (subagents !== void 0) {
-        try {
-          await subagents.drainContinuableDescendants(records.map((record) => record.agent));
-        } catch (error) {
-          logWarn(`continuable subagent teardown failed: ${String(error)}`);
-        }
+      try {
+        await subagents.drainContinuableDescendants(records.map((record) => record.agent));
+      } catch (error) {
+        logWarn(`continuable subagent teardown failed: ${String(error)}`);
       }
       const disposals = await Promise.allSettled(records.map((record) => record.dispose()));
       const failures = disposals.filter(
@@ -1889,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