@openma/deepseek-harness-acp 0.4.8 → 0.4.10-beta.1

package/dist/plugin.js

@@ -0,0 +1,3217 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name4 in all)
+    __defProp(target, name4, { get: all[name4], enumerable: true });
+};
+
+// src/bridge/self-harness.ts
+var self_harness_exports = {};
+__export(self_harness_exports, {
+  selfHarness: () => selfHarness
+});
+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 * as agentModule from "@deepseek-ai/dsh-agent";
+import * as mcpClient from "@deepseek-ai/dsh-mcp-client";
+function selfHarness() {
+  const agents = agentModule;
+  const installModelSelection = agents.installModelSelection ?? agents.ln;
+  return {
+    createUserMessage,
+    errorChain,
+    sessionId: SessionId,
+    foldSessionTitle,
+    setSandboxMode,
+    sandboxModes: SANDBOX_MODES,
+    ...installModelSelection !== void 0 ? { installModelSelection } : {},
+    mcpClient
+  };
+}
+var init_self_harness = __esm({
+  "src/bridge/self-harness.ts"() {
+    "use strict";
+  }
+});
+
+// src/plugin.ts
+import { existsSync } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname, join } from "node:path";
+
+// src/bridge/index.ts
+var bridge_exports = {};
+__export(bridge_exports, {
+  answerFromElicitation: () => answerFromElicitation,
+  apply: () => apply,
+  askUserQuestionsOverAcp: () => askUserQuestionsOverAcp,
+  inject: () => inject,
+  installAcpUserQuestionProvider: () => installAcpUserQuestionProvider,
+  name: () => name,
+  questionsToElicitation: () => questionsToElicitation
+});
+import { randomUUID } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { Readable, Writable } from "node:stream";
+import {
+  AgentSideConnection,
+  ndJsonStream,
+  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, name4, unscoped) {
+  const scoped = !unscoped && provider !== void 0;
+  return {
+    id: scoped ? `api-key:${provider}` : "api-key",
+    name: scoped ? `${name4 ?? 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) {
+  process.stderr.write(`${PREFIX} warn: ${message}
+`);
+}
+function logDebug(message) {
+  if (process.env["DSH_ACP_DEBUG"]) process.stderr.write(`${PREFIX} debug: ${message}
+`);
+}
+
+// src/bridge/translate.ts
+var MAX_TITLE_LENGTH = 80;
+var MAX_RESULT_TEXT = 2e4;
+function firstLine(text, limit = MAX_TITLE_LENGTH) {
+  const line = text.split("\n", 1)[0] ?? "";
+  return line.length > limit ? `${line.slice(0, limit - 1)}\u2026` : line;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function pathLocations(args) {
+  const locations = [];
+  for (const key of ["path", "file_path", "filePath", "file"]) {
+    const path = asString(args[key]);
+    if (path !== void 0) {
+      locations.push({ path });
+      break;
+    }
+  }
+  return locations;
+}
+function classifyToolCall(name4, rawArguments) {
+  let args = {};
+  try {
+    const parsed = JSON.parse(rawArguments);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      args = parsed;
+    }
+  } catch {
+    args = { arguments: rawArguments };
+  }
+  const locations = pathLocations(args);
+  const path = locations[0]?.path;
+  const facts = (kind, title) => ({
+    kind,
+    title,
+    locations,
+    rawInput: args
+  });
+  switch (name4) {
+    case "bash": {
+      const command = asString(args["command"]);
+      const restart = args["restart"] === true;
+      return facts("execute", command !== void 0 ? firstLine(command) : restart ? "Restart bash" : "bash");
+    }
+    case "read":
+      return facts("read", path !== void 0 ? `Read ${path}` : "Read file");
+    case "write":
+      return facts("edit", path !== void 0 ? `Write ${path}` : "Write file");
+    case "edit":
+      return facts("edit", path !== void 0 ? `Edit ${path}` : "Edit file");
+    case "str_replace_editor": {
+      const command = asString(args["command"]) ?? "edit";
+      const kind = command === "view" ? "read" : "edit";
+      return facts(kind, path !== void 0 ? `${command} ${path}` : command);
+    }
+    case "todo_write":
+      return facts("think", "Update plan");
+    case "subagent":
+    case "subagent_fork": {
+      const task = asString(args["task"]) ?? asString(args["prompt"]);
+      return facts("other", task !== void 0 ? `Subagent: ${firstLine(task, 60)}` : "Subagent");
+    }
+    case "skill": {
+      const skillName = asString(args["name"]) ?? asString(args["skill"]);
+      return facts("other", skillName !== void 0 ? `Skill: ${skillName}` : "Skill");
+    }
+    default:
+      break;
+  }
+  const lowered = name4.toLowerCase();
+  if (/(^|_)(grep|glob|find|search|ls|list)($|_)/.test(lowered)) {
+    const query = asString(args["query"]) ?? asString(args["pattern"]);
+    return facts("search", query !== void 0 ? `Search for '${firstLine(query, 50)}'` : name4);
+  }
+  if (/(fetch|web|http|browse)/.test(lowered)) {
+    const url = asString(args["url"]) ?? asString(args["query"]);
+    return facts("fetch", url !== void 0 ? `Fetch ${firstLine(url, 60)}` : name4);
+  }
+  if (/(job|task|run|exec)/.test(lowered)) return facts("execute", name4);
+  return facts("other", name4);
+}
+function diffsFromToolMeta(meta) {
+  if (meta === null || typeof meta !== "object") return [];
+  const diffs = meta["diffs"];
+  if (!Array.isArray(diffs)) return [];
+  const result = [];
+  for (const entry of diffs) {
+    if (entry === null || typeof entry !== "object") continue;
+    const diff = entry;
+    const path = asString(diff["path"]);
+    const newText = diff["newText"];
+    const oldText = diff["oldText"];
+    if (path === void 0 || typeof newText !== "string") continue;
+    result.push({ path, oldText: typeof oldText === "string" ? oldText : null, newText });
+  }
+  return result;
+}
+function extractToolResult(data) {
+  let failed = data["error"] !== void 0 && data["error"] !== null;
+  const parts = [];
+  const message = data["message"];
+  const content = message !== null && typeof message === "object" ? message["content"] : void 0;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block === null || typeof block !== "object") continue;
+      const b = block;
+      if (b["type"] !== "tool-result") continue;
+      if (b["isError"] === true) failed = true;
+      const inner = b["content"];
+      if (!Array.isArray(inner)) continue;
+      for (const innerBlock of inner) {
+        if (innerBlock === null || typeof innerBlock !== "object") continue;
+        const ib = innerBlock;
+        if (ib["type"] === "text" && typeof ib["text"] === "string") parts.push(ib["text"]);
+      }
+    }
+  }
+  let text = parts.join("");
+  if (text.length > MAX_RESULT_TEXT) text = `${text.slice(0, MAX_RESULT_TEXT)}
+\u2026 (truncated)`;
+  return { failed, text, diffs: diffsFromToolMeta(data["meta"]) };
+}
+function extractMessageTexts(message) {
+  const texts = [];
+  const reasoning = [];
+  const content = message !== null && typeof message === "object" ? message["content"] : void 0;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block === null || typeof block !== "object") continue;
+      const b = block;
+      if (b["type"] === "text" && typeof b["text"] === "string") texts.push(b["text"]);
+      else if (b["type"] === "reasoning" && typeof b["text"] === "string") reasoning.push(b["text"]);
+      else if (b["type"] === "image") texts.push("[image attachment]");
+    }
+  }
+  return { text: texts.join(""), reasoning: reasoning.join("") };
+}
+function planEntries(data) {
+  const todos = data["todos"];
+  if (!Array.isArray(todos)) return void 0;
+  const entries = [];
+  for (const todo of todos) {
+    if (todo === null || typeof todo !== "object") continue;
+    const t = todo;
+    const content = asString(t["content"]);
+    const status = t["status"];
+    if (content === void 0) continue;
+    entries.push({
+      content,
+      priority: "medium",
+      status: status === "in_progress" || status === "completed" ? status : "pending"
+    });
+  }
+  return entries;
+}
+function turnEndToStopReason(reason) {
+  switch (reason?.kind) {
+    case "completed":
+      return "end_turn";
+    case "max-tokens":
+      return "max_tokens";
+    case "blocked":
+      return "refusal";
+    case "interrupted":
+      return "cancelled";
+    case "aborted": {
+      const cause = reason.reason?.kind;
+      return cause === "user" || cause === "disposed" ? "cancelled" : "end_turn";
+    }
+    default:
+      return "end_turn";
+  }
+}
+function emptyWindow() {
+  return {
+    usage: { input: 0, output: 0, cachedRead: 0, cachedWrite: 0, thought: 0 },
+    sawUsage: false,
+    turnEnds: /* @__PURE__ */ new Map(),
+    lastTurnEnd: void 0,
+    error: void 0
+  };
+}
+var TOOL_KINDS = /* @__PURE__ */ new Set([
+  "read",
+  "edit",
+  "delete",
+  "move",
+  "search",
+  "execute",
+  "think",
+  "fetch",
+  "switch_mode",
+  "other"
+]);
+function factsFromPresentCall(name4, rawArguments, presented) {
+  const fallback = classifyToolCall(name4, 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;
+  /** Latest `session/title` text observed on the log. */
+  title;
+  streamedText = /* @__PURE__ */ new Set();
+  streamedReasoning = /* @__PURE__ */ new Set();
+  toolCalls = /* @__PURE__ */ new Map();
+  window = emptyWindow();
+  lastContextUse;
+  /** Client renders `_meta.terminal_output` display terminals (Zed extension). */
+  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() {
+    this.window = emptyWindow();
+  }
+  /** The captured ending for a specific turn, when it already ended. */
+  turnEndFor(turn) {
+    return this.window.turnEnds.get(turn);
+  }
+  /** The last turn ending inside the current prompt window. */
+  get lastTurnEnd() {
+    return this.window.lastTurnEnd;
+  }
+  /** The first failed-turn error inside the current prompt window. */
+  get turnError() {
+    return this.window.error;
+  }
+  /** Accumulated ACP usage for the current prompt window. */
+  promptUsage() {
+    if (!this.window.sawUsage) return void 0;
+    const { input, output, cachedRead, cachedWrite, thought } = this.window.usage;
+    return {
+      totalTokens: input + output + cachedRead + cachedWrite,
+      inputTokens: input,
+      outputTokens: output,
+      ...thought > 0 ? { thoughtTokens: thought } : {},
+      ...cachedRead > 0 ? { cachedReadTokens: cachedRead } : {},
+      ...cachedWrite > 0 ? { cachedWriteTokens: cachedWrite } : {}
+    };
+  }
+  /**
+   * 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":
+        return this.onChunk(data);
+      case "assistant/message":
+        return this.onAssistantMessage(data);
+      case "tool/call":
+        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 !== 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);
+      case "request/context": {
+        const contextWindow = data["contextWindow"];
+        if (typeof contextWindow === "number" && contextWindow > 0) this.contextWindow = contextWindow;
+        return [];
+      }
+      case "session/title": {
+        const title = asString(data["title"]);
+        if (title === void 0 || title === this.title) return [];
+        this.title = title;
+        return [{ sessionUpdate: "session_info_update", title, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }];
+      }
+      default:
+        return [];
+    }
+  }
+  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(messageId);
+      return [{ sessionUpdate: "agent_message_chunk", content: { type: "text", text }, messageId }];
+    }
+    if (c["type"] === "reasoning-delta") {
+      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 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 },
+        messageId: key
+      });
+    }
+    if (text.length > 0 && !this.streamedText.has(key)) {
+      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);
+    const usage = data["usage"];
+    if (usage !== null && typeof usage === "object") {
+      const u = usage;
+      const num = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+      const input = num(u["inputTokens"]);
+      const output = num(u["outputTokens"]);
+      const cachedRead = num(u["cacheReadTokens"]);
+      const cachedWrite = num(u["cacheWriteTokens"]);
+      this.window.usage.input += input;
+      this.window.usage.output += output;
+      this.window.usage.cachedRead += cachedRead;
+      this.window.usage.cachedWrite += cachedWrite;
+      this.window.usage.thought += num(u["reasoningTokens"]);
+      this.window.sawUsage = true;
+      this.lastContextUse = input + cachedRead + cachedWrite + output;
+      if (this.contextWindow !== void 0 && this.lastContextUse > 0) {
+        updates.push({
+          sessionUpdate: "usage_update",
+          used: this.lastContextUse,
+          size: this.contextWindow
+        });
+      }
+    }
+    return updates;
+  }
+  onToolCall(data) {
+    const callId = asString(data["callId"]);
+    const name4 = asString(data["name"]) ?? "tool";
+    if (callId === void 0) return [];
+    const rawArguments = typeof data["arguments"] === "string" ? data["arguments"] : "{}";
+    let parsedArgs = {};
+    try {
+      parsedArgs = JSON.parse(rawArguments);
+    } catch {
+      parsedArgs = { arguments: rawArguments };
+    }
+    const presented = this.presentCall?.(name4, parsedArgs);
+    const facts = presented !== void 0 ? factsFromPresentCall(name4, rawArguments, presented) : classifyToolCall(name4, rawArguments);
+    this.toolCalls.set(callId, facts);
+    const displayTerminal = this.terminalOutput && facts.kind === "execute";
+    return [
+      {
+        sessionUpdate: "tool_call",
+        toolCallId: callId,
+        title: facts.title,
+        name: name4,
+        kind: facts.kind,
+        status: "in_progress",
+        rawInput: facts.rawInput,
+        ...facts.locations.length > 0 ? { locations: facts.locations } : {},
+        ...displayTerminal ? {
+          content: [{ type: "terminal", terminalId: callId }],
+          _meta: {
+            terminal_info: {
+              terminal_id: callId,
+              ...this.cwd !== void 0 ? { cwd: this.cwd } : {}
+            }
+          }
+        } : {}
+      }
+    ];
+  }
+  onToolResult(data) {
+    const message = data["message"];
+    const callId = asString(
+      message !== null && typeof message === "object" ? (() => {
+        const content2 = message["content"];
+        if (!Array.isArray(content2)) return void 0;
+        const block = content2.find(
+          (b) => b !== null && typeof b === "object" && b["type"] === "tool-result"
+        );
+        return block === void 0 ? void 0 : block["toolCallId"];
+      })() : void 0
+    ) ?? asString(data["callId"]);
+    if (callId === void 0) return [];
+    const facts = this.toolCalls.get(callId);
+    const { failed, text, diffs } = extractToolResult(data);
+    const content = diffs.map((diff) => ({
+      type: "diff",
+      path: diff.path,
+      ...diff.oldText !== null ? { oldText: diff.oldText } : {},
+      newText: diff.newText
+    }));
+    const isCommand = facts?.kind === "execute";
+    if (this.terminalOutput && isCommand) {
+      this.toolCalls.delete(callId);
+      return [
+        ...text.length > 0 ? [
+          {
+            sessionUpdate: "tool_call_update",
+            toolCallId: callId,
+            _meta: { terminal_output: { terminal_id: callId, data: text } }
+          }
+        ] : [],
+        {
+          sessionUpdate: "tool_call_update",
+          toolCallId: callId,
+          status: failed ? "failed" : "completed",
+          ...text.length > 0 ? { rawOutput: { output: text, isError: failed } } : {},
+          _meta: {
+            terminal_exit: { terminal_id: callId, exit_code: failed ? 1 : 0, signal: null }
+          }
+        }
+      ];
+    }
+    if (text.length > 0 && diffs.length === 0) {
+      const block = {
+        type: "text",
+        text: isCommand ? `\`\`\`sh
+${text.replace(/\n+$/, "")}
+\`\`\`
+` : text
+      };
+      content.push({ type: "content", content: block });
+    }
+    this.toolCalls.delete(callId);
+    return [
+      {
+        sessionUpdate: "tool_call_update",
+        toolCallId: callId,
+        status: failed ? "failed" : "completed",
+        ...content.length > 0 ? { content } : {},
+        ...text.length > 0 ? { rawOutput: { output: text, isError: failed } } : {}
+      }
+    ];
+  }
+  onTurnEnd(data) {
+    const reason = data["reason"];
+    const turn = data["turn"];
+    if (reason !== null && typeof reason === "object") {
+      const r = reason;
+      if (typeof turn === "number") this.window.turnEnds.set(turn, r);
+      this.window.lastTurnEnd = r;
+      if (r.kind === "error" && this.window.error === void 0) {
+        this.window.error = { message: r.error?.message ?? "model turn failed" };
+      }
+    }
+    return [];
+  }
+};
+
+// src/bridge/history.ts
+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;
+  if (kind !== "user") return void 0;
+  const content = data["content"];
+  if (!Array.isArray(content)) return void 0;
+  const parts = [];
+  for (const block of content) {
+    if (block !== null && typeof block === "object") {
+      const b = block;
+      if (b["type"] === "text" && typeof b["text"] === "string") parts.push(b["text"]);
+    }
+  }
+  const text = parts.join("");
+  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 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;
+      }
+    }
+    if (event.type === "session/title") {
+      const t = event.data?.["title"];
+      if (typeof t === "string" && t.length > 0) title = t;
+      continue;
+    }
+    for (const update of projection.onEvent(event)) {
+      if (update.sessionUpdate === "usage_update") continue;
+      if (update.sessionUpdate === "plan") {
+        plan = update;
+        continue;
+      }
+      updates.push(update);
+    }
+  }
+  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>`;
+}
+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 name4 = imageName(block.uri);
+  return name4 === void 0 ? { data, mediaType } : { data, mediaType, name: name4 };
+}
+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":
+        parts.push(block.text);
+        display.push(block.text);
+        break;
+      case "resource_link":
+        parts.push(`
+[resource_link name=${JSON.stringify(block.name)} uri=${JSON.stringify(block.uri)}]
+`);
+        display.push(`@${block.name}`);
+        break;
+      case "resource": {
+        const resource = block.resource;
+        if ("text" in resource && typeof resource.text === "string") {
+          parts.push(`
+${contextBlock(resource.uri, resource.text)}
+`);
+          display.push(`@${resource.uri}`);
+          break;
+        }
+        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);
+    }
+  }
+  flushText(parts, blocks);
+  return {
+    blocks,
+    displayText: display.join(" ").trim()
+  };
+}
+
+// src/bridge/cordis-protocol.ts
+var CORDIS_PROTOCOL = 0;
+var CORDIS_CAPABILITY = Object.freeze({ protocol: CORDIS_PROTOCOL });
+var CORDIS_METHODS = Object.freeze({
+  inspectSync: "_dsh/cordis/inspect/sync",
+  inspectResolve: "_dsh/cordis/inspect/resolve",
+  inspectQuery: "_dsh/cordis/inspect/query",
+  inspectQueryResolved: "_dsh/cordis/inspect/query-resolved",
+  runHost: "_dsh/cordis/run/host",
+  getClientCode: "_dsh/cordis/run/client-code",
+  resolveRequestRun: "_dsh/cordis/run/resolve",
+  requestRun: "_dsh/cordis/run/request",
+  requestRunResolved: "_dsh/cordis/run/request-resolved",
+  userRun: "_dsh/cordis/run/user",
+  settleUserRun: "_dsh/cordis/run/settle",
+  pluginInvoke: "_dsh/cordis/plugin/invoke",
+  pluginsList: "_dsh/cordis/plugins/list",
+  pluginStart: "_dsh/cordis/plugins/start",
+  pluginStop: "_dsh/cordis/plugins/stop",
+  pluginRetract: "_dsh/cordis/plugins/retract"
+});
+function advertisesCordis(meta) {
+  if (meta === null || typeof meta !== "object" || Array.isArray(meta)) return false;
+  const dsh = meta["dsh"];
+  if (dsh === null || typeof dsh !== "object" || Array.isArray(dsh)) return false;
+  const cordis = dsh["cordis"];
+  if (cordis === null || typeof cordis !== "object" || Array.isArray(cordis)) return false;
+  return cordis["protocol"] === CORDIS_PROTOCOL;
+}
+
+// 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 extension method (e.g. `_dsh/cordis/inspect/sync`).
+   * @param handler - implementation.
+   * @returns disposer.
+   */
+  registerMethod(method, handler) {
+    if (!method.startsWith("_")) {
+      throw new Error(`acpRpc: extension method ${JSON.stringify(method)} must start with "_"`);
+    }
+    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 extension notification on the ACP stream.
+   * @param method - notification method.
+   * @param params - payload.
+   */
+  notify(method, params) {
+    if (!method.startsWith("_")) {
+      throw new Error(`acpRpc: extension notification ${JSON.stringify(method)} must start with "_"`);
+    }
+    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(CORDIS_METHODS.inspectSync, (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);
+      return { ok: true };
+    }),
+    "acp-bridge: cordis/inspect-sync"
+  );
+  ctx.effect(
+    () => rpc.registerMethod(CORDIS_METHODS.inspectResolve, (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: cordis/inspect-resolve"
+  );
+  ctx.effect(
+    () => rpc.registerMethod(CORDIS_METHODS.runHost, 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: cordis/run-host-half"
+  );
+  ctx.effect(
+    () => rpc.registerMethod(CORDIS_METHODS.getClientCode, (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: cordis/get-client-code"
+  );
+  ctx.effect(
+    () => rpc.registerMethod(CORDIS_METHODS.resolveRequestRun, 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: cordis/resolve-request-run"
+  );
+  ctx.effect(
+    () => rpc.registerMethod(CORDIS_METHODS.pluginInvoke, 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: cordis/invoke"
+  );
+  ctx.effect(
+    () => rpc.registerMethod(CORDIS_METHODS.pluginsList, (params) => {
+      const runner = requireRunnerMethod(ctx, "listPlugins");
+      const body = asObject(params);
+      const agent = requireAgent(findAgent, readString(body, "agentId"));
+      return runner.listPlugins(agent);
+    }),
+    "acp-bridge: cordis/list-plugins"
+  );
+  ctx.effect(
+    () => rpc.registerMethod(CORDIS_METHODS.pluginStop, 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: cordis/stop-plugin"
+  );
+  ctx.effect(
+    () => rpc.registerMethod(CORDIS_METHODS.pluginStart, 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(CORDIS_METHODS.userRun, {
+          agentId,
+          pluginId,
+          packageId,
+          pluginRunId,
+          startedHere,
+          mode: "run",
+          hasClientHalf: true
+        });
+      }
+      return { ok: true, status: "starting", pluginId, packageId, pluginRunId };
+    }),
+    "acp-bridge: cordis/start-plugin"
+  );
+  ctx.effect(
+    () => rpc.registerMethod(CORDIS_METHODS.settleUserRun, 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: cordis/settle-user-run"
+  );
+  ctx.on("cordis/inspect-query", (request) => {
+    if (!advertisement.advertised) return;
+    rpc.notify(CORDIS_METHODS.inspectQuery, request);
+  });
+  ctx.on("cordis/inspect-query-resolved", (resolved) => {
+    if (!advertisement.advertised) return;
+    rpc.notify(CORDIS_METHODS.inspectQueryResolved, resolved);
+  });
+  ctx.on("cordis/request-run", (request) => {
+    if (!advertisement.advertised) return;
+    rpc.notify(CORDIS_METHODS.requestRun, request);
+  });
+  ctx.on("cordis/request-run-resolved", (resolved) => {
+    if (!advertisement.advertised) return;
+    rpc.notify(CORDIS_METHODS.requestRunResolved, resolved);
+  });
+  ctx.on("cordis/dynamic-retract", (retracted) => {
+    if (!advertisement.advertised) return;
+    rpc.notify(CORDIS_METHODS.pluginRetract, 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 { Service } from "@deepseek-ai/cordis";
+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;
+}
+var ROUTERS_KEY = /* @__PURE__ */ Symbol.for("@openma/deepseek-harness-acp/user-question-routers");
+var routers = globalThis[ROUTERS_KEY] ??= /* @__PURE__ */ new WeakMap();
+function installAcpUserQuestionProvider(service, options) {
+  const tracked = service[Service.tracker];
+  const owner = typeof tracked === "object" && tracked !== null ? tracked : service;
+  let router = routers.get(owner);
+  if (router === void 0) {
+    const routes = [];
+    const disposeProvider = service.registerProvider({
+      async ask(request) {
+        for (let index = routes.length - 1; index >= 0; index -= 1) {
+          const route = routes[index];
+          const sessionId = route?.sessionIdForRequest(request);
+          if (route === void 0 || sessionId === void 0) continue;
+          if (!route.formSupported()) {
+            throw new UserQuestionError(
+              "the ACP client does not support form elicitation",
+              "CLIENT_UNSUPPORTED"
+            );
+          }
+          return askUserQuestionsOverAcp(request, sessionId, route.create);
+        }
+        throw new UserQuestionError(
+          "ACP user interaction requires a live root session",
+          "ASK_MISSING_AGENT"
+        );
+      }
+    });
+    router = { routes, disposeProvider };
+    routers.set(owner, router);
+  }
+  router.routes.push(options);
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    const index = router.routes.indexOf(options);
+    if (index >= 0) router.routes.splice(index, 1);
+    if (router.routes.length !== 0) return;
+    routers.delete(owner);
+    router.disposeProvider();
+  };
+}
+
+// src/bridge/presets.ts
+function presetDisplayName(preset) {
+  if (preset.id === "cordis") return "Creator";
+  if (preset.id === "code") return "Code";
+  const name4 = preset.name?.trim();
+  return name4 !== void 0 && name4.length > 0 ? name4 : preset.id;
+}
+
+// src/bridge/index.ts
+var name = "acp-bridge";
+var inject = ["agents", "credentials", "llm", "agentDefaultModel", "sessionPersistence", "approval", "permissionPresets", "commands", "agentPresets", "skills", "subagents", "userQuestions"];
+function invalidParams(detail) {
+  return RequestError.invalidParams(void 0, detail);
+}
+function internalError(detail) {
+  return RequestError.internalError(void 0, detail);
+}
+function authRequired(detail) {
+  return RequestError.authRequired(void 0, detail);
+}
+var MODE_LABELS = {
+  "read-only": { name: "Read-only", description: "Bash and file mutations are denied by the sandbox" },
+  "workspace-write": {
+    name: "Workspace write",
+    description: "Writes are confined to the session workspace; wider access asks for permission"
+  },
+  "danger-full-access": {
+    name: "Full access",
+    description: "No sandbox confinement and no permission prompts"
+  }
+};
+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);
+    for (const model of config.models ?? []) if (model.trim().length > 0) seen.add(model.trim());
+    return [...seen];
+  };
+  const defaultSelection = () => {
+    try {
+      return agentDefaultModel.currentSelection();
+    } catch (error) {
+      logDebug(`agentDefaultModel.currentSelection failed: ${String(error)}`);
+      return {};
+    }
+  };
+  const defaultProvider = () => config.provider ?? defaultSelection().provider;
+  const encodeChoice = (provider, model) => provider === void 0 || provider === defaultProvider() ? model : `${provider}::${model}`;
+  const decodeChoice = (value) => {
+    const i = value.indexOf("::");
+    if (i <= 0) return { provider: defaultProvider(), model: value };
+    return { provider: value.slice(0, i), model: value.slice(i + 2) };
+  };
+  let liveCatalog;
+  const effortCache = /* @__PURE__ */ new Map();
+  const discoverModels = async () => {
+    if (liveCatalog !== void 0) return liveCatalog;
+    const found = [];
+    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
+          });
+        }
+      }
+    } catch (error) {
+      logDebug(`model discovery failed: ${String(error)}`);
+    }
+    liveCatalog = found;
+    return found;
+  };
+  ctx.on("llm/adapters-updated", () => {
+    liveCatalog = void 0;
+    effortCache.clear();
+  });
+  const routeOf = (record) => {
+    const logged = loggedConfig(record);
+    const provider = record.provider ?? defaultProvider() ?? logged?.provider;
+    const model = record.model ?? config.model ?? defaultSelection().model ?? logged?.model ?? record.agent.options.model;
+    return {
+      ...provider !== void 0 ? { provider } : {},
+      ...model !== void 0 ? { model } : {}
+    };
+  };
+  const loggedConfig = (record) => {
+    try {
+      const header = record.agent.session.requestHeader?.();
+      const cfg = header?.config;
+      if (cfg === void 0) return void 0;
+      return {
+        provider: cfg.provider,
+        model: cfg.model,
+        ...cfg.reasoningEffort !== void 0 ? { reasoningEffort: String(cfg.reasoningEffort) } : {}
+      };
+    } catch {
+      return void 0;
+    }
+  };
+  const effortCatalog = async (provider, model) => {
+    if (provider === void 0 || model === void 0) return void 0;
+    const key = `${provider}::${model}`;
+    if (effortCache.has(key)) return effortCache.get(key);
+    let catalog;
+    try {
+      const reasoning = (await llm.resolveModelInfo(provider, model)).reasoning;
+      if (reasoning !== void 0 && reasoning.efforts.length > 0) {
+        catalog = {
+          efforts: reasoning.efforts.map((effort) => ({
+            id: String(effort.id),
+            name: effort.name,
+            ...effort.description !== void 0 ? { description: effort.description } : {}
+          })),
+          ...reasoning.defaultEffort !== void 0 ? { defaultEffort: String(reasoning.defaultEffort) } : {}
+        };
+      }
+    } catch (error) {
+      logDebug(`resolveModelInfo(${key}) failed: ${String(error)}`);
+    }
+    effortCache.set(key, catalog);
+    return catalog;
+  };
+  const ensureSelection = (record) => {
+    const install = harness.installModelSelection;
+    if (install === void 0) return void 0;
+    if (record.selection !== void 0) return record.selection;
+    let picked;
+    const selection = {
+      get current() {
+        if (picked !== void 0) return picked;
+        const logged = loggedConfig(record);
+        if (logged !== void 0) return logged;
+        const { provider, model } = routeOf(record);
+        if (provider === void 0 || model === void 0) return void 0;
+        const defaults = defaultSelection();
+        const effort = defaults.model === void 0 || defaults.model === model ? defaults.reasoningEffort : void 0;
+        return { provider, model, ...effort !== void 0 ? { reasoningEffort: effort } : {} };
+      },
+      set current(next) {
+        picked = next;
+      },
+      assembled: void 0
+    };
+    try {
+      install(record.agent.ctx, selection);
+    } catch (error) {
+      logWarn(`installModelSelection failed: ${String(error)}`);
+      return void 0;
+    }
+    record.selection = selection;
+    return selection;
+  };
+  const switchModel = async (record, acpSessionId, value) => {
+    if (record.inflight !== void 0) {
+      throw invalidParams("cannot switch models while a prompt is running");
+    }
+    const choice = decodeChoice(value);
+    const known = /* @__PURE__ */ new Set([
+      ...modelCandidates().map((model) => encodeChoice(void 0, model)),
+      ...(await discoverModels()).map((entry) => encodeChoice(entry.provider, entry.model)),
+      encodeChoice(record.provider, record.model ?? "")
+    ]);
+    if (!known.has(value)) throw invalidParams(`unknown model: ${value}`);
+    if (choice.model === record.model && choice.provider === (record.provider ?? defaultProvider())) return;
+    const sessionId = record.agent.session.id;
+    await record.dispose().catch((error) => {
+      logWarn(`dispose during model switch failed: ${String(error)}`);
+    });
+    let handle;
+    try {
+      const presets = presetsService();
+      handle = await agents.resume({
+        resumeSessionId: sessionId,
+        agentOptions: agentOptionsFor(choice.model, choice.provider),
+        ...presetSetup(presets, record.preset) !== void 0 ? { setup: presetSetup(presets, record.preset) } : {}
+      });
+    } catch (error) {
+      sessions.delete(acpSessionId);
+      throw internalError(`model switch failed: ${errorChain2(error)}`);
+    }
+    record.agent = handle.agent;
+    record.dispose = () => handle.dispose();
+    record.model = choice.model;
+    if (choice.provider !== void 0 && choice.provider !== defaultProvider()) {
+      record.provider = choice.provider;
+    } else {
+      delete record.provider;
+    }
+    delete record.selection;
+    ensureSelection(record);
+    if (record.effort !== void 0) {
+      const route = routeOf(record);
+      const catalog = await effortCatalog(route.provider, route.model);
+      if (catalog?.efforts.some((effort) => effort.id === record.effort) === true && route.provider !== void 0 && route.model !== void 0) {
+        const selection = ensureSelection(record);
+        if (selection !== void 0) {
+          selection.current = {
+            provider: route.provider,
+            model: route.model,
+            reasoningEffort: record.effort
+          };
+        }
+      } else {
+        delete record.effort;
+      }
+    }
+    setApprovalPolicy(record, record.approvals);
+  };
+  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 name4 = entry.name;
+        return [{ id, ...typeof name4 === "string" && name4.length > 0 ? { name: name4 } : {} }];
+      });
+    } catch (error) {
+      logDebug(`listProviders failed: ${String(error)}`);
+      return [];
+    }
+  };
+  const credentialPresent = async (provider) => {
+    const names = credentialEnvNames(provider).filter((name4) => !name4.endsWith("_BASE_URL"));
+    for (const name4 of names) {
+      try {
+        if (await credentials.resolve(credentialRef(name4)) !== void 0) return true;
+      } catch (error) {
+        logWarn(`credential lookup failed: ${String(error)}`);
+      }
+    }
+    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 } : {},
+    ...model !== void 0 ? { model } : {},
+    ...config.maxTokens !== void 0 ? { maxTokens: config.maxTokens } : {}
+  });
+  const ownedRecord = (agent) => {
+    const record = sessions.get(String(agent.session.id));
+    return record?.agent === agent ? record : void 0;
+  };
+  const requireSession = (sessionId) => {
+    const record = sessions.get(sessionId);
+    if (record === void 0) throw invalidParams(`unknown session: ${sessionId}`);
+    return record;
+  };
+  const requireOrRestoreSession = async (sessionId) => {
+    const record = sessions.get(sessionId);
+    if (record !== void 0) return record;
+    logWarn(`restoring session ${sessionId} from the persisted log`);
+    try {
+      return await restoreSession(sessionId, { replay: false });
+    } catch (error) {
+      throw invalidParams(`unknown session: ${sessionId} (${errorChain2(error)})`);
+    }
+  };
+  const restoreSession = async (sessionId, options) => {
+    const persistence = requirePersistence();
+    const existing = sessions.get(sessionId);
+    if (existing !== void 0) {
+      sessions.delete(sessionId);
+      existing.agent.cancel({ kind: "user" });
+      settlePrompt(existing, "cancelled");
+      await existing.dispose().catch((error) => {
+        logWarn(`dispose before reload failed: ${String(error)}`);
+      });
+    }
+    let events;
+    let storedHeader;
+    try {
+      const inspected = await persistence.inspect(SessionId2(sessionId));
+      events = inspected.events;
+      storedHeader = inspected.header;
+    } catch (error) {
+      throw invalidParams(`session not found: ${sessionId} (${errorChain2(error)})`);
+    }
+    const replay = buildReplay(events);
+    if (options.replay) {
+      for (const update of replay.updates) notify(sessionId, update);
+      if (replay.title !== void 0) {
+        notify(sessionId, {
+          sessionUpdate: "session_info_update",
+          title: replay.title
+        });
+      }
+    }
+    const presets = presetsService();
+    const storedPreset = presetFromLog(storedHeader, events);
+    const presetId = (await presets.resolve(storedPreset)).id;
+    const handle = await agents.resume({
+      resumeSessionId: SessionId2(sessionId),
+      agentOptions: agentOptionsFor(config.model),
+      ...presetSetup(presets, presetId) !== void 0 ? { setup: presetSetup(presets, presetId) } : {}
+    });
+    const cwd = options.cwd ?? storedHeader?.cwd;
+    const projection = new SessionProjection(replay.contextWindow, {
+      terminalOutput: clientTerminalOutput,
+      ...cwd !== void 0 ? { cwd } : {}
+    });
+    projection.title = replay.title;
+    const record = registerRecord(
+      sessionId,
+      handle.agent,
+      () => handle.dispose(),
+      config.model,
+      config.permissionMode ?? "workspace-write",
+      projection
+    );
+    if (presetId !== void 0) record.preset = presetId;
+    {
+      const permission = permissionService();
+      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];
+        if (event?.type === "approval/policy") {
+          const policy = event.data?.policy;
+          if (policy === "ask" || policy === "never") record.approvals = policy;
+          break;
+        }
+      }
+    }
+    ensureSelection(record);
+    queueMicrotask(() => publishCommands(sessionId));
+    return record;
+  };
+  const assertOpen = () => {
+    if (closed) throw internalError("the ACP bridge has been disposed");
+  };
+  const notify = (sessionId, update) => {
+    void conn.sessionUpdate({ sessionId, update }).catch((error) => {
+      logWarn(`session/update failed: ${String(error)}`);
+    });
+  };
+  const settlePrompt = (record, reason) => {
+    const inflight = record.inflight;
+    if (inflight === void 0) return;
+    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}" in ${(performance.now() - started).toFixed(1)}ms`);
+    };
+  };
+  const presetFromLog = (header, events) => {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      const event = events[index];
+      if (event?.type === "agent-preset/selected") {
+        return event.data?.agentPreset;
+      }
+    }
+    return header?.agentPreset;
+  };
+  const modeState = (record) => {
+    const permission = permissionService();
+    if (permission.names.length > 0) {
+      return {
+        currentModeId: record.modeId,
+        availableModes: permission.names.map((name4) => {
+          const spec = permission.resolve(name4);
+          return { id: name4, name: spec.name, description: spec.description };
+        })
+      };
+    }
+    return {
+      currentModeId: record.modeId,
+      availableModes: SANDBOX_MODES2.map((mode) => {
+        const label = MODE_LABELS[mode] ?? { name: mode, description: "" };
+        return { id: mode, name: label.name, description: label.description };
+      })
+    };
+  };
+  const switchPreset = async (record, acpSessionId, presetId) => {
+    if (record.inflight !== void 0) {
+      throw invalidParams("cannot switch presets while a prompt is running");
+    }
+    const presets = presetsService();
+    let resolved;
+    try {
+      resolved = (await presets.resolve(presetId)).id;
+    } catch (error) {
+      throw invalidParams(`unknown preset: ${presetId} (${errorChain2(error)})`);
+    }
+    if (resolved === record.preset) return;
+    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 resumeWith(resolved);
+    } catch (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);
+    publishCommands(acpSessionId, record);
+  };
+  const setApprovalPolicy = (record, policy) => {
+    try {
+      approval.setPolicy(record.agent, policy);
+    } catch (error) {
+      logWarn(`approval policy switch failed: ${String(error)}`);
+    }
+    record.approvals = policy;
+  };
+  const permissionService = () => permissionPresets;
+  const applyMode = (record, sessionId, modeId) => {
+    const permission = permissionService();
+    if (permission.names.includes(modeId)) {
+      let bundledApproval = record.approvals;
+      permission.apply(record.agent.session, modeId, (policy) => {
+        bundledApproval = policy;
+      });
+      setApprovalPolicy(record, bundledApproval);
+      record.modeId = permission.resolve(modeId).sandbox;
+      notify(sessionId, { sessionUpdate: "current_mode_update", currentModeId: modeId });
+      return;
+    }
+    const mode = SANDBOX_MODES2.find((candidate) => candidate === modeId);
+    if (mode === void 0) throw invalidParams(`unknown mode: ${modeId}`);
+    setSandboxMode2(record.agent.session, mode);
+    setApprovalPolicy(record, mode === "danger-full-access" ? "never" : "ask");
+    record.modeId = mode;
+    notify(sessionId, { sessionUpdate: "current_mode_update", currentModeId: mode });
+  };
+  const modelChoices = async (record) => {
+    const seen = /* @__PURE__ */ new Set();
+    const options = [];
+    const push = (value, name4) => {
+      if (seen.has(value)) return;
+      seen.add(value);
+      options.push({ value, name: name4 });
+    };
+    const current = encodeChoice(
+      record.provider,
+      record.model ?? config.model ?? defaultSelection().model ?? record.agent.options.model ?? ""
+    );
+    if (current.length === 0) return [];
+    const discovered = await discoverModels();
+    push(current, discovered.find((c) => encodeChoice(c.provider, c.model) === current)?.label ?? current);
+    for (const choice of discovered) {
+      push(encodeChoice(choice.provider, choice.model), choice.label);
+    }
+    for (const model of modelCandidates()) push(encodeChoice(void 0, model), model);
+    return options;
+  };
+  const configOptions = async (record) => {
+    const result = [];
+    {
+      const permission = permissionService();
+      const levels = permission.names.length > 0 ? permission.names.map((name4) => {
+        const spec = permission.resolve(name4);
+        return { value: name4, name: spec.name, description: spec.description };
+      }) : SANDBOX_MODES2.map((mode) => {
+        const label = MODE_LABELS[mode] ?? { name: mode, description: "" };
+        return { value: mode, name: label.name, description: label.description };
+      });
+      result.push({
+        type: "select",
+        id: "mode",
+        name: "Permissions",
+        category: "mode",
+        currentValue: record.modeId,
+        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({
+        type: "select",
+        id: "model",
+        name: "Model",
+        category: "model",
+        currentValue: models[0].value,
+        options: models
+      });
+    }
+    const route = routeOf(record);
+    const efforts = await effortCatalog(route.provider, route.model);
+    if (efforts !== void 0 && efforts.efforts.length >= 2) {
+      const known = new Set(efforts.efforts.map((effort) => effort.id));
+      const preferred = [
+        record.effort,
+        loggedConfig(record)?.reasoningEffort,
+        // The user's saved product default (Web UI → settings.yaml),
+        // e.g. reasoningEffort: max, outranks the adapter's default.
+        defaultSelection().reasoningEffort,
+        efforts.defaultEffort
+      ].find(
+        (candidate) => candidate !== void 0 && known.has(candidate)
+      );
+      result.push({
+        type: "select",
+        id: "effort",
+        name: "Reasoning",
+        category: "thought_level",
+        currentValue: preferred ?? efforts.efforts[0].id,
+        options: efforts.efforts.map((effort) => ({
+          value: effort.id,
+          name: effort.name,
+          ...effort.description !== void 0 ? { description: effort.description } : {}
+        }))
+      });
+    }
+    const presets = presetsService();
+    if (record.preset !== void 0) {
+      try {
+        const roster = await presets.list();
+        if (roster.length >= 2) {
+          result.push({
+            type: "select",
+            id: "agent",
+            name: "Agent",
+            currentValue: record.preset,
+            options: roster.map((preset) => ({
+              value: preset.id,
+              name: presetDisplayName(preset),
+              description: `Agent preset \u201C${preset.id}\u201D`
+            }))
+          });
+        }
+      } catch (error) {
+        logWarn(`preset roster unavailable: ${String(error)}`);
+      }
+    }
+    return result;
+  };
+  const BUILTIN_COMMANDS = [
+    { name: "status", description: "Show adapter, model, mode, and token status" },
+    {
+      name: "model",
+      description: "Select the model for this conversation",
+      input: { hint: "[model] \u2014 blank lists available models" }
+    }
+  ];
+  const availableCommandsFor = async (record) => {
+    const list = [...BUILTIN_COMMANDS];
+    const seen = new Set(list.map((command) => command.name));
+    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)}`);
+    }
+    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" }
+        });
+      }
+    } catch (error) {
+      logDebug(`skill listing failed: ${String(error)}`);
+    }
+    return list;
+  };
+  const publishCommands = (sessionId, record) => {
+    const target = record ?? sessions.get(sessionId);
+    if (target === void 0) return;
+    void availableCommandsFor(target).then((availableCommands) => {
+      notify(sessionId, { sessionUpdate: "available_commands_update", availableCommands });
+    }).catch((error) => {
+      logWarn(`publishing commands failed: ${String(error)}`);
+    });
+  };
+  const publishConfigOptions = (sessionId, record) => {
+    void configOptions(record).then((options) => {
+      notify(sessionId, {
+        sessionUpdate: "config_option_update",
+        configOptions: options
+      });
+    }).catch((error) => {
+      logWarn(`publishing config options failed: ${String(error)}`);
+    });
+  };
+  const syncPermissionState = (record, sessionId) => {
+    const events = record.agent.session.events;
+    if (events === void 0) return;
+    const permission = permissionService();
+    const storedMode = permission.current(events);
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      const event = events[index];
+      if (event?.type === "approval/policy") {
+        const policy = event.data?.policy;
+        if (policy === "ask" || policy === "never") record.approvals = policy;
+        break;
+      }
+    }
+    if (storedMode !== void 0 && storedMode !== record.modeId) {
+      record.modeId = storedMode;
+      notify(sessionId, {
+        sessionUpdate: "current_mode_update",
+        currentModeId: record.modeId
+      });
+    }
+  };
+  const describeCredential = async (provider) => {
+    const names = credentialEnvNames(provider).filter((candidate) => !candidate.endsWith("_BASE_URL"));
+    for (const name4 of names) {
+      try {
+        const info = await credentials.describe(credentialRef(name4));
+        if (info.configured) return info.source ?? "credential store";
+      } catch (error) {
+        logWarn(`credential describe failed: ${String(error)}`);
+      }
+    }
+    return "not configured";
+  };
+  const saveCredential = async (provider, key) => {
+    await credentials.set(credentialRef(primaryCredentialName(provider)), key);
+  };
+  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 modelCommandText = async (record, acpSessionId, query) => {
+    const discovered = await discoverModels();
+    const catalog = [
+      ...discovered.map((entry) => ({
+        value: encodeChoice(entry.provider, entry.model),
+        label: entry.label
+      })),
+      ...modelCandidates().filter((model) => !discovered.some((entry) => entry.model === model)).map((model) => ({ value: encodeChoice(void 0, model), label: model }))
+    ];
+    const route = routeOf(record);
+    const currentValue = encodeChoice(record.provider, record.model ?? route.model ?? "");
+    if (query === "") {
+      const lines = catalog.map(
+        (entry) => `${entry.value === currentValue ? "\u2192" : " "} ${entry.label} \u2014 ${entry.value}`
+      );
+      return [
+        `model: ${route.model ?? "(product default)"}${record.effort !== void 0 ? ` (effort ${record.effort})` : ""}`,
+        "",
+        ...lines.length > 0 ? lines : ["no models discovered \u2014 check credentials with /status"],
+        "",
+        "switch with /model <name>"
+      ].join("\n");
+    }
+    const lowered = query.toLowerCase();
+    const exact = catalog.filter(
+      (entry) => entry.value.toLowerCase() === lowered || decodeChoice(entry.value).model.toLowerCase() === lowered
+    );
+    const matches = exact.length > 0 ? exact : catalog.filter(
+      (entry) => entry.value.toLowerCase().includes(lowered) || entry.label.toLowerCase().includes(lowered)
+    );
+    if (matches.length === 0) return `no model matches "${query}" \u2014 see /model`;
+    if (matches.length > 1) {
+      return [`"${query}" is ambiguous:`, ...matches.map((entry) => `  ${entry.label} \u2014 ${entry.value}`)].join(
+        "\n"
+      );
+    }
+    const target = matches[0];
+    if (target.value === currentValue) return `already on ${target.label}`;
+    await switchModel(record, acpSessionId, target.value);
+    publishCommands(acpSessionId, record);
+    publishConfigOptions(acpSessionId, record);
+    return `model \u2192 ${target.label}`;
+  };
+  const statusText = async (record) => {
+    const used = record.projection.contextWindow;
+    const route = routeOf(record);
+    const effort = record.effort ?? loggedConfig(record)?.reasoningEffort;
+    const lines = [
+      `**dsh-acp** ${VERSION} \u2014 DeepSeek Harness ACP bridge`,
+      "",
+      `| | |`,
+      `|---|---|`,
+      `| Provider | ${route.provider ?? "(composition default)"} |`,
+      `| Model | ${route.model ?? "(composition default)"} |`,
+      `| Reasoning | ${effort ?? "(adapter default)"} |`,
+      `| Credential | ${await describeCredential(route.provider)} |`,
+      ...record.preset !== void 0 ? [`| Preset | ${record.preset} |`] : [],
+      `| Permission mode | ${record.modeId} |`,
+      `| Approvals | ${record.approvals} |`,
+      `| Workspace | ${record.agent.session.header.cwd ?? process.cwd()} |`,
+      `| Session | ${String(record.agent.session.id)} |`,
+      ...used !== void 0 ? [`| Context window | ${used.toLocaleString()} tokens |`] : []
+    ];
+    return lines.join("\n");
+  };
+  const registerRecord = (sessionId, agent, dispose, model, modeId, projection) => {
+    const record = {
+      agent,
+      dispose,
+      projection: projection ?? new SessionProjection(void 0, {
+        terminalOutput: clientTerminalOutput,
+        ...agent.session.header.cwd !== void 0 ? { cwd: agent.session.header.cwd } : {}
+      }),
+      modeId,
+      model,
+      approvals: modeId === "danger-full-access" ? "never" : "ask",
+      cancelled: false,
+      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) {
+      const child = subagentByChild.get(sessionId);
+      if (child !== void 0 && clientSubagentTranscript) {
+        for (const update of child.projection.onEvent(event)) {
+          notify(child.rootSessionId, update);
+        }
+      }
+      return;
+    }
+    try {
+      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) {
+        if (event.data.reason.kind === "error") {
+          record.inflight = void 0;
+          inflight.reject(internalError(`turn failed: ${event.data.reason.error.message}`));
+        }
+      }
+    }
+  });
+  ctx.on("agent/inbox/claimed", ({ agent, message, turn }) => {
+    const record = ownedRecord(agent);
+    const inflight = record?.inflight;
+    if (inflight !== void 0 && inflight.messageId === message.id) inflight.turn = turn;
+  });
+  ctx.on("agent/error", ({ agent, turn, error }) => {
+    const record = ownedRecord(agent);
+    const inflight = record?.inflight;
+    if (record === void 0 || inflight === void 0 || inflight.turn === turn) return;
+    record.inflight = void 0;
+    inflight.reject(internalError(`turn failed: ${errorChain2(error)}`));
+  });
+  ctx.on("approval/request", (request, next) => {
+    const record = ownedRecord(request.agent);
+    if (record === void 0 || request.callId === void 0) return next();
+    return conn.requestPermission({
+      sessionId: String(record.agent.session.id),
+      toolCall: { toolCallId: request.callId },
+      options: [
+        { optionId: "allow-once", name: "Allow once", kind: "allow_once" },
+        { optionId: "allow-always", name: "Always allow (this session)", kind: "allow_always" },
+        { optionId: "reject-once", name: "Reject", kind: "reject_once" }
+      ]
+    }).then(({ outcome }) => {
+      if (outcome.outcome === "cancelled") return "cancelled";
+      if (outcome.optionId === "allow-always") {
+        setApprovalPolicy(record, "never");
+        return "allowed-once";
+      }
+      return outcome.optionId === "allow-once" ? "allowed-once" : "rejected";
+    });
+  });
+  const makeAgent = (connection) => {
+    conn = connection;
+    return {
+      async initialize(params) {
+        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;
+        tuiClient.advertised = advertisesCordis(capsMeta);
+        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: {
+            _meta: { dsh: { cordis: { ...CORDIS_CAPABILITY } } },
+            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 },
+            auth: { logout: {} },
+            sessionCapabilities: { list: {} }
+          },
+          authMethods: advertisedAuthMethods(
+            providers,
+            params.clientCapabilities
+          )
+        };
+      },
+      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 = (name4) => {
+          const now = performance.now();
+          logDebug(`session/new ${name4}: ${(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");
+        }
+        const record = registerRecord(
+          String(sessionId),
+          handle.agent,
+          () => handle.dispose(),
+          config.model,
+          config.permissionMode ?? "workspace-write"
+        );
+        if (presetId !== void 0) record.preset = presetId;
+        ensureSelection(record);
+        queueMicrotask(() => publishCommands(String(sessionId)));
+        const options = await configOptions(record);
+        mark("response surface");
+        return {
+          sessionId: String(sessionId),
+          modes: modeState(record),
+          ...options.length > 0 ? { configOptions: options } : {}
+        };
+      },
+      async loadSession(params) {
+        assertOpen();
+        await requireCredential(config.provider);
+        validateCwd(params.cwd);
+        syncMcpServers(params.mcpServers, params.cwd);
+        requirePersistence();
+        const record = await restoreSession(params.sessionId, { replay: true, cwd: params.cwd });
+        const options = await configOptions(record);
+        return {
+          modes: modeState(record),
+          ...options.length > 0 ? { configOptions: options } : {}
+        };
+      },
+      async listSessions(params) {
+        assertOpen();
+        const persistence = requirePersistence();
+        const headers = await persistence.list();
+        headers.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+        const filtered = params.cwd !== void 0 && params.cwd !== null ? headers.filter((header) => header.cwd === params.cwd) : headers;
+        const page = filtered.slice(0, 100);
+        const withTitles = await Promise.allSettled(
+          page.slice(0, 20).map(async (header) => {
+            const { events } = await persistence.inspect(header.id);
+            return foldSessionTitle2(events)?.title;
+          })
+        );
+        const sessionsInfo = page.map((header, index) => {
+          const settled = withTitles[index];
+          const title = settled !== void 0 && settled.status === "fulfilled" ? settled.value : void 0;
+          return {
+            sessionId: String(header.id),
+            cwd: header.cwd ?? "",
+            ...title !== void 0 ? { title } : {},
+            ...header.createdAt !== void 0 ? { updatedAt: new Date(header.createdAt).toISOString() } : {}
+          };
+        });
+        return { sessions: sessionsInfo };
+      },
+      async prompt(params) {
+        assertOpen();
+        const record = await requireOrRestoreSession(params.sessionId);
+        let converted;
+        try {
+          converted = await convertPrompt(
+            params.prompt,
+            attachmentIngestOf(ctx.get("attachments"))
+          );
+        } catch (error) {
+          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) => {
+          notify(params.sessionId, {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text }
+          });
+          return { stopReason: "end_turn" };
+        };
+        if (commandMatch?.[1] === "status") return respond(await statusText(record));
+        if (commandMatch?.[1] === "model") {
+          return respond(
+            await modelCommandText(
+              record,
+              params.sessionId,
+              trimmed.slice(commandMatch[0].length).trim()
+            )
+          );
+        }
+        if (commandMatch !== null && commandMatch[1] !== void 0) {
+          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);
+          }
+        }
+        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;
+        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 {
+            deliverPrompt(record.agent, message, false);
+          } catch (error) {
+            record.inflight = void 0;
+            const detail = error instanceof Error ? error.message : String(error);
+            throw internalError(`prompt was not queued: ${detail}`);
+          }
+          void record.agent.whenIdle().then(() => {
+            if (record.inflight !== inflight) return;
+            record.inflight = void 0;
+            if (record.cancelled) {
+              resolve("cancelled");
+              return;
+            }
+            const end = inflight.turn !== void 0 ? record.projection.turnEndFor(inflight.turn) ?? record.projection.lastTurnEnd : record.projection.lastTurnEnd;
+            resolve(end === void 0 ? "cancelled" : turnEndToStopReason(end));
+          });
+        });
+        const usage = record.projection.promptUsage();
+        return { stopReason, ...usage !== void 0 ? { usage } : {} };
+      },
+      async setSessionMode(params) {
+        const record = await requireOrRestoreSession(params.sessionId);
+        applyMode(record, params.sessionId, params.modeId);
+        notify(params.sessionId, {
+          sessionUpdate: "config_option_update",
+          configOptions: await configOptions(record)
+        });
+        return {};
+      },
+      async setSessionConfigOption(params) {
+        const record = await requireOrRestoreSession(params.sessionId);
+        const value = typeof params.value === "string" ? params.value : void 0;
+        if (value === void 0) throw invalidParams(`invalid value: ${String(params.value)}`);
+        switch (params.configId) {
+          case "mode": {
+            applyMode(record, params.sessionId, value);
+            break;
+          }
+          case "agent":
+          case "preset": {
+            await switchPreset(record, params.sessionId, value);
+            break;
+          }
+          case "effort": {
+            const route = routeOf(record);
+            const catalog = await effortCatalog(route.provider, route.model);
+            if (catalog === void 0 || !catalog.efforts.some((effort) => effort.id === value)) {
+              throw invalidParams(`unknown effort: ${value}`);
+            }
+            const selection = ensureSelection(record);
+            if (selection === void 0 || route.provider === void 0 || route.model === void 0) {
+              throw invalidParams("reasoning effort switching is unavailable on this host");
+            }
+            selection.current = {
+              provider: route.provider,
+              model: route.model,
+              reasoningEffort: value
+            };
+            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;
+          }
+          default:
+            throw invalidParams(`unknown config option: ${params.configId}`);
+        }
+        return { configOptions: await configOptions(record) };
+      },
+      async closeSession(params) {
+        const record = sessions.get(params.sessionId);
+        if (record === void 0) return;
+        sessions.delete(params.sessionId);
+        record.agent.cancel({ kind: "user" });
+        settlePrompt(record, "cancelled");
+        await record.dispose().catch((error) => {
+          logWarn(`session close failed: ${String(error)}`);
+        });
+      },
+      cancel(params) {
+        const record = sessions.get(params.sessionId);
+        if (record === void 0) return Promise.resolve();
+        record.cancelled = true;
+        record.agent.cancel({ kind: "user" });
+        settlePrompt(record, "cancelled");
+        return Promise.resolve();
+      }
+    };
+  };
+  function requirePersistence() {
+    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 = (raw2) => {
+    const cleaned = raw2.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 32);
+    return cleaned.length > 0 ? cleaned : "server";
+  };
+  const mcpConfigFor = (server, cwd, serverName) => {
+    const envList = (list) => Object.fromEntries(
+      (Array.isArray(list) ? list : []).map((e) => [
+        e.name,
+        e.value
+      ])
+    );
+    if (typeof server["command"] === "string") {
+      return {
+        transport: "stdio",
+        serverName,
+        command: server["command"],
+        args: Array.isArray(server["args"]) ? server["args"] : [],
+        env: envList(server["env"]),
+        cwd: typeof server["cwd"] === "string" ? server["cwd"] : cwd,
+        // A dead or misconfigured server must not take the session
+        // down; the client surfaces missing tools on its own.
+        failOnStartupError: false
+      };
+    }
+    if (server["type"] === "http" && typeof server["url"] === "string") {
+      return {
+        transport: "streamable-http",
+        serverName,
+        url: server["url"],
+        headers: envList(server["headers"]),
+        failOnStartupError: false
+      };
+    }
+    return void 0;
+  };
+  const syncMcpServers = (servers, cwd) => {
+    if (servers === void 0 || servers.length === 0) return;
+    const mcpClient2 = harness.mcpClient;
+    if (mcpClient2 === void 0) {
+      if (!warnedNoMcpClient) {
+        warnedNoMcpClient = true;
+        logWarn(
+          `ignoring ${servers.length} MCP server(s): this DeepSeek Harness installation lacks @deepseek-ai/dsh-mcp-client`
+        );
+      }
+      return;
+    }
+    const taken = /* @__PURE__ */ new Set();
+    for (const entry of servers) {
+      const server = entry;
+      const base = sanitizeServerName(typeof server["name"] === "string" ? server["name"] : "server");
+      let serverName = base;
+      for (let n = 2; taken.has(serverName); n += 1) serverName = `${base.slice(0, 28)}_${n}`;
+      const cfg = mcpConfigFor(server, cwd, serverName);
+      if (cfg === void 0) {
+        logWarn(`skipping MCP server "${serverName}": unsupported transport`);
+        continue;
+      }
+      const configJson = JSON.stringify(cfg);
+      const existing = mcpMounts.get(serverName);
+      if (existing !== void 0) {
+        if (existing.configJson === configJson) {
+          taken.add(serverName);
+          continue;
+        }
+        try {
+          void existing.fiber.dispose();
+        } catch (error) {
+          logWarn(`disposing MCP server "${serverName}": ${String(error)}`);
+        }
+        mcpMounts.delete(serverName);
+      }
+      try {
+        const fiber = ctx.plugin(mcpClient2, cfg);
+        mcpMounts.set(serverName, { configJson, fiber });
+        taken.add(serverName);
+        logDebug(`mounted MCP server "${serverName}" (${String(cfg["transport"])})`);
+      } catch (error) {
+        logWarn(`failed to mount MCP server "${serverName}": ${String(error)}`);
+      }
+    }
+  };
+  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 () => {
+      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(
+        (result) => result.status === "rejected"
+      );
+      if (failures.length > 0) {
+        const detail = failures.map((failure) => errorChain2(failure.reason)).join("; ");
+        throw new AggregateError(
+          failures.map((failure) => failure.reason),
+          `ACP agent teardown failed for ${failures.length} session(s): ${detail}`
+        );
+      }
+    })();
+    return quiescing;
+  };
+  void conn.closed.catch((error) => {
+    logWarn(`connection closed with an error: ${String(error)}`);
+  }).then(quiesce).catch((error) => {
+    logWarn(`connection-close teardown failed: ${String(error)}`);
+  });
+  ctx.effect(() => quiesce, "acp-bridge.connection");
+  ctx.effect(() => disposeUserQuestions, "acp-bridge.user-questions");
+}
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  apply: () => apply2,
+  inject: () => inject2,
+  name: () => name2
+});
+init_self_harness();
+var name2 = "acp-server";
+var inject2 = inject;
+function apply2(ctx, config = {}) {
+  if (ctx.get("acpServer") !== void 0) return;
+  const harness = selfHarness();
+  const server = {
+    connect(stream) {
+      return ctx.plugin(bridge_exports, { ...config, stream, harness });
+    }
+  };
+  ctx.provide("acpServer", server);
+}
+
+// src/plugin.ts
+var name3 = "dsh-acp-plugin";
+var inject3 = [.../* @__PURE__ */ new Set([...inject.filter((service) => service !== "agentPresets"), "loader"])];
+function shippedPresetRoot(ctx) {
+  const anchors = [ctx.baseUrl, import.meta.url].filter((value) => typeof value === "string");
+  for (const anchor of anchors) {
+    try {
+      const manifest = createRequire2(anchor).resolve("@deepseek-ai/dsh/package.json");
+      const root = join(dirname(manifest), "config", "agent-presets");
+      if (existsSync(root)) return root;
+    } catch {
+    }
+  }
+  throw new Error("dsh-acp-plugin: cannot resolve the dsh shipped agent presets");
+}
+async function mountService(ctx, service, specifier, config) {
+  if (ctx.get(service) !== void 0) return;
+  const exports = await ctx.loader.import(specifier);
+  const plugin = ctx.loader.unwrapExports(exports);
+  await ctx.plugin(plugin, config);
+  if (ctx.get(service) === void 0) {
+    throw new Error(`dsh-acp-plugin: ${specifier} did not provide ${service}`);
+  }
+}
+async function apply3(ctx, config = {}) {
+  if (ctx.get("acpServer") !== void 0) return;
+  await mountService(ctx, "agentPresets", "@deepseek-ai/dsh-agent-presets", {
+    default: "standard",
+    roots: [{ path: shippedPresetRoot(ctx), trust: "system" }]
+  });
+  await mountService(ctx, "dynamicCordisRunner", "@deepseek-ai/dsh-cordis-host-runner");
+  await ctx.plugin(server_exports, config);
+  if (ctx.get("acpServer") === void 0) {
+    throw new Error("dsh-acp-plugin: ACP server did not activate");
+  }
+}
+export {
+  apply3 as apply,
+  inject3 as inject,
+  name3 as name
+};