@openma/deepseek-harness-acp 0.4.4 → 0.4.6

package/dist/index.js

@@ -1,89 +1,16 @@
 #!/usr/bin/env node
-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 name3 in all)
-    __defProp(target, name3, { get: all[name3], 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 { credentialRef } from "@deepseek-ai/dsh-credentials";
-import * as agentModule from "@deepseek-ai/dsh-agent";
-import * as mcpClient from "@deepseek-ai/dsh-mcp-client";
-function selfHarness() {
-  const agents = agentModule;
-  const installModelSelection = agents.installModelSelection ?? agents.ln;
-  return {
-    createUserMessage,
-    errorChain,
-    sessionId: SessionId,
-    foldSessionTitle,
-    setSandboxMode,
-    sandboxModes: SANDBOX_MODES,
-    credentialRef,
-    ...installModelSelection !== void 0 ? { installModelSelection } : {},
-    mcpClient
-  };
-}
-var init_self_harness = __esm({
-  "src/bridge/self-harness.ts"() {
-    "use strict";
-  }
-});
 
 // src/index.ts
 import { spawnSync } from "node:child_process";
 
-// src/app.ts
-var app_exports = {};
-__export(app_exports, {
-  apply: () => apply2,
-  name: () => name2
-});
-
-// src/bridge/index.ts
-var bridge_exports = {};
-__export(bridge_exports, {
-  apply: () => apply,
-  inject: () => inject,
-  name: () => name
-});
-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";
-
-// src/version.ts
-import { createRequire } from "node:module";
-var VERSION = createRequire(import.meta.url)("../package.json").version;
+// src/harness.ts
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { delimiter, dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { pathToFileURL, fileURLToPath } from "node:url";
 
 // src/log.ts
 var PREFIX = "[dsh-acp]";
-function logWarn(message) {
-  process.stderr.write(`${PREFIX} warn: ${message}
-`);
-}
 function logError(message) {
   process.stderr.write(`${PREFIX} error: ${message}
 `);
@@ -97,1819 +24,7 @@ function logInfo(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(name3, 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 (name3) {
-    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 = name3.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)}'` : name3);
-  }
-  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)}` : name3);
-  }
-  if (/(job|task|run|exec)/.test(lowered)) return facts("execute", name3);
-  return facts("other", name3);
-}
-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 [];
-  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 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;
-  constructor(contextWindow, options) {
-    this.contextWindow = contextWindow;
-    this.terminalOutput = options?.terminalOutput ?? false;
-    this.cwd = options?.cwd;
-  }
-  /** 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 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 "todo/write": {
-        const entries = planEntries(data);
-        return entries.length > 0 ? [{ sessionUpdate: "plan", entries }] : [];
-      }
-      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"])}`;
-  }
-  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 [];
-    if (c["type"] === "text-delta") {
-      this.streamedText.add(this.stepKey(data));
-      return [{ sessionUpdate: "agent_message_chunk", content: { type: "text", text } }];
-    }
-    if (c["type"] === "reasoning-delta") {
-      this.streamedReasoning.add(this.stepKey(data));
-      return [{ sessionUpdate: "agent_thought_chunk", content: { type: "text", text } }];
-    }
-    return [];
-  }
-  onAssistantMessage(data) {
-    const updates = [];
-    const key = this.stepKey(data);
-    const { text, reasoning } = extractMessageTexts(data["message"]);
-    if (reasoning.length > 0 && !this.streamedReasoning.has(key)) {
-      updates.push({ sessionUpdate: "agent_thought_chunk", content: { type: "text", text: reasoning } });
-    }
-    if (text.length > 0 && !this.streamedText.has(key)) {
-      updates.push({ sessionUpdate: "agent_message_chunk", content: { type: "text", text } });
-    }
-    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 name3 = asString(data["name"]) ?? "tool";
-    if (callId === void 0) return [];
-    const rawArguments = typeof data["arguments"] === "string" ? data["arguments"] : "{}";
-    const facts = classifyToolCall(name3, rawArguments);
-    this.toolCalls.set(callId, facts);
-    const displayTerminal = this.terminalOutput && facts.kind === "execute";
-    return [
-      {
-        sessionUpdate: "tool_call",
-        toolCallId: callId,
-        title: facts.title,
-        name: name3,
-        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 userText(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 : void 0;
-}
-function buildReplay(events) {
-  const projection = new SessionProjection();
-  const updates = [];
-  let plan;
-  let title;
-  for (const event of events) {
-    if (event.type === "user/message") {
-      const text = userText(event.data);
-      if (text !== void 0) {
-        updates.push({ sessionUpdate: "user_message_chunk", content: { type: "text", text } });
-      }
-      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);
-  return { updates, title, contextWindow: projection.contextWindow };
-}
-
-// src/bridge/prompt.ts
-var UnsupportedPromptContentError = class extends Error {
-  constructor(contentType) {
-    super(`unsupported prompt content type: ${contentType}`);
-    this.contentType = contentType;
-  }
-  contentType;
-};
-function contextBlock(uri, text) {
-  return `<context ref=${JSON.stringify(uri)}>
-${text}
-</context>`;
-}
-function convertPrompt(prompt) {
-  const parts = [];
-  const display = [];
-  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)");
-      }
-      default:
-        throw new UnsupportedPromptContentError(block.type);
-    }
-  }
-  const text = parts.join("");
-  return {
-    blocks: text.length > 0 ? [{ type: "text", text }] : [],
-    displayText: display.join(" ").trim()
-  };
-}
-
-// src/bridge/index.ts
-var name = "acp-bridge";
-var inject = ["agents"];
-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);
-}
-function envCredentialPresent() {
-  return Boolean(process.env["DEEPSEEK_API_KEY"] || process.env["DEEPSEEK_BASE_URL"]);
-}
-var MODE_LABELS = {
-  "read-only": { name: "Read-only", description: "Bash and file mutations are denied by the sandbox" },
-  "workspace-write": {
-    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 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();
-  let closed = false;
-  let conn;
-  let clientTerminalOutput = false;
-  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 = () => {
-    const service = ctx.get("agentDefaultModel");
-    if (service === void 0) return {};
-    try {
-      return service.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 llm = ctx.get("llm");
-    const found = [];
-    if (llm !== void 0) {
-      try {
-        const providers = llm.listProviders();
-        const multi = providers.length > 1;
-        for (const provider of providers) {
-          const models = await llm.listModels(provider.id).catch((error) => {
-            logDebug(`listModels(${provider.id}) failed: ${String(error)}`);
-            return [];
-          });
-          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);
-    const llm = ctx.get("llm");
-    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 credentialPresent = async () => {
-    if (envCredentialPresent()) return true;
-    const brand = harness.credentialRef;
-    if (brand === void 0) return false;
-    const deadline = Date.now() + 5e3;
-    for (; ; ) {
-      const seam = ctx.get("credentials");
-      if (seam !== void 0) {
-        try {
-          return await seam.resolve(brand("DEEPSEEK_API_KEY")) !== void 0;
-        } catch (error) {
-          logWarn(`credential lookup failed: ${String(error)}`);
-          return false;
-        }
-      }
-      if (Date.now() >= deadline) {
-        logDebug("credential gate: no credentials service registered within 5s");
-        return false;
-      }
-      await new Promise((resolve2) => setTimeout(resolve2, 100));
-    }
-  };
-  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;
-    if (ctx.get("sessionPersistence") === void 0) throw invalidParams(`unknown session: ${sessionId}`);
-    logWarn(`restoring session ${sessionId} from the persisted log`);
-    try {
-      return await restoreSession(sessionId, { replay: false });
-    } 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 = presets === void 0 ? void 0 : (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 presetsService = () => ctx.get("agentPresets");
-  const presetSetup = (presets, presetId) => {
-    if (presets === void 0 || presetId === void 0) return void 0;
-    return async (agentCtx) => {
-      logDebug(`preset setup: mounting "${presetId}"`);
-      await presets.mount(agentCtx, presetId);
-      logDebug(`preset setup: mounted "${presetId}"`);
-    };
-  };
-  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 presetLabel = (id) => id.charAt(0).toUpperCase() + id.slice(1);
-  const modeState = (record) => {
-    const permission = permissionService();
-    if (permission !== void 0 && permission.names.length > 0) {
-      return {
-        currentModeId: record.modeId,
-        availableModes: permission.names.map((name3) => {
-          const spec = permission.resolve(name3);
-          return { id: name3, 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();
-    if (presets === void 0) throw invalidParams(`unknown mode: ${presetId}`);
-    let resolved;
-    try {
-      resolved = (await presets.resolve(presetId)).id;
-    } catch (error) {
-      throw invalidParams(`unknown preset: ${presetId} (${errorChain2(error)})`);
-    }
-    if (resolved === record.preset) return;
-    try {
-      record.agent.session.append("agent-preset/selected", { agentPreset: resolved });
-    } catch (error) {
-      logWarn(`recording preset selection failed: ${String(error)}`);
-    }
-    const sessionId = record.agent.session.id;
-    await record.dispose().catch((error) => {
-      logWarn(`dispose during preset switch failed: ${String(error)}`);
-    });
-    let handle;
-    try {
-      handle = await agents.resume({
-        resumeSessionId: sessionId,
-        agentOptions: agentOptionsFor(record.model ?? config.model, record.provider),
-        setup: presetSetup(presets, resolved)
-      });
-    } catch (error) {
-      sessions.delete(acpSessionId);
-      throw internalError(`preset switch failed: ${errorChain2(error)}`);
-    }
-    record.agent = handle.agent;
-    record.dispose = () => handle.dispose();
-    record.preset = resolved;
-    delete record.selection;
-    ensureSelection(record);
-    setApprovalPolicy(record, record.approvals);
-    publishCommands(acpSessionId, record);
-  };
-  const setApprovalPolicy = (record, policy) => {
-    try {
-      ctx.get("approval")?.setPolicy?.(record.agent, policy);
-    } catch (error) {
-      logWarn(`approval policy switch failed: ${String(error)}`);
-    }
-    record.approvals = policy;
-  };
-  const permissionService = () => ctx.get("permissionPresets") ?? ctx.get("permission");
-  const applyMode = (record, sessionId, modeId) => {
-    const permission = permissionService();
-    if (permission !== void 0 && 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, name3) => {
-      if (seen.has(value)) return;
-      seen.add(value);
-      options.push({ value, name: name3 });
-    };
-    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 !== void 0 && permission.names.length > 0 ? permission.names.map((name3) => {
-        const spec = permission.resolve(name3);
-        return { value: name3, name: spec.name, description: spec.description };
-      }) : SANDBOX_MODES2.map((mode) => {
-        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
-      });
-    }
-    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 (presets !== void 0 && record.preset !== void 0) {
-      try {
-        const roster = await presets.list();
-        if (roster.length >= 2) {
-          result.push({
-            type: "select",
-            id: "preset",
-            name: "Preset",
-            currentValue: record.preset,
-            options: roster.map((preset) => ({
-              value: preset.id,
-              name: presetLabel(preset.id),
-              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: "login",
-      description: "Save a DeepSeek API key into the harness credential store (~/.dsh/.credentials.yaml)",
-      input: { hint: "<api-key>" }
-    },
-    { name: "logout", description: "Remove the API key stored in the harness credential store" },
-    {
-      name: "model",
-      description: "Select the model for this conversation",
-      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));
-    const commandsSvc = ctx.get("commands");
-    if (commandsSvc !== void 0) {
-      try {
-        for (const descriptor of commandsSvc.list(record.agent)) {
-          if (seen.has(descriptor.name)) continue;
-          seen.add(descriptor.name);
-          list.push({
-            name: descriptor.name,
-            description: descriptor.description,
-            ...descriptor.input !== void 0 ? { input: { hint: descriptor.input.hint } } : {}
-          });
-        }
-      } catch (error) {
-        logWarn(`command listing failed: ${String(error)}`);
-      }
-    }
-    const skillsSvc = ctx.get("skills");
-    if (skillsSvc !== void 0) {
-      try {
-        const skills = await skillsSvc.list({
-          ...record.agent.session.header.cwd !== void 0 ? { cwd: record.agent.session.header.cwd } : {},
-          scope: record.agent
-        });
-        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 credentialStore = () => {
-    const brand = harness.credentialRef;
-    const store = ctx.get("credentials");
-    if (brand === void 0 || store === void 0) return void 0;
-    return { store, ref: brand("DEEPSEEK_API_KEY") };
-  };
-  const maskKey = (value) => value.length <= 8 ? "\u2026" : `${value.slice(0, 4)}\u2026${value.slice(-4)}`;
-  const describeCredential = async () => {
-    if (envCredentialPresent()) {
-      const viaEnv = process.env["DEEPSEEK_API_KEY"] !== void 0 ? "DEEPSEEK_API_KEY" : "DEEPSEEK_BASE_URL";
-      return `process environment (${viaEnv})`;
-    }
-    const cs = credentialStore();
-    if (cs === void 0) return "not configured";
-    try {
-      const info = await cs.store.describe(cs.ref);
-      if (!info.configured) return "not configured";
-      return info.source ?? "credential store";
-    } catch (error) {
-      logWarn(`credential describe failed: ${String(error)}`);
-      return "unknown";
-    }
-  };
-  const loginText = async (rawArgument) => {
-    const key = rawArgument.trim();
-    const cs = credentialStore();
-    if (cs === void 0) {
-      return "This composition has no writable credential store; export DEEPSEEK_API_KEY in the environment that launches the agent instead.";
-    }
-    if (key.length === 0) {
-      return [
-        "Usage: `/login <api-key>` \u2014 stores the key in the harness credential store",
-        "(`~/.dsh/.credentials.yaml`, the same file the dsh Web UI writes; mode 600).",
-        "",
-        `Current credential source: ${await describeCredential()}.`,
-        "",
-        "Note: text entered here also lands in your client's chat history. If you",
-        "prefer to keep the key out of it, save the key in the dsh Web UI instead."
-      ].join("\n");
-    }
-    try {
-      await cs.store.set(cs.ref, key);
-    } catch (error) {
-      return [
-        `Could not store the key: ${error instanceof Error ? error.message : String(error)}`,
-        "",
-        "A read-only source (usually the process environment) is currently supplying",
-        "this credential, so a stored value would be shadowed. Unset DEEPSEEK_API_KEY",
-        "in the launching environment, or keep using it as the credential."
-      ].join("\n");
-    }
-    return `Saved DEEPSEEK_API_KEY (${maskKey(key)}) to the harness credential store \u2014 source now: ${await describeCredential()}. The dsh Web UI sees the same key.`;
-  };
-  const logoutText = async () => {
-    const cs = credentialStore();
-    if (cs === void 0) return "This composition has no writable credential store; nothing to remove.";
-    try {
-      await cs.store.unset(cs.ref);
-    } catch (error) {
-      return `Could not remove the stored key: ${error instanceof Error ? error.message : String(error)}`;
-    }
-    const remaining = await describeCredential();
-    return remaining === "not configured" ? "Removed the stored DEEPSEEK_API_KEY. No credential is configured now." : `Removed the stored DEEPSEEK_API_KEY; requests now authenticate via: ${remaining}.`;
-  };
-  const modelCommandText = async (record, acpSessionId, query) => {
-    const discovered = await discoverModels();
-    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()} |`,
-      ...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);
-    return record;
-  };
-  ctx.on("session/event", (session, event) => {
-    const sessionId = String(session.header.id);
-    const record = sessions.get(sessionId);
-    if (record === void 0 || record.agent.session !== session) return;
-    try {
-      for (const update of record.projection.onEvent(event)) {
-        notify(sessionId, update);
-      }
-    } 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") {
-        try {
-          ctx.get("approval")?.setPolicy?.(record.agent, "never");
-        } catch (error) {
-          logWarn(`approval policy switch failed: ${String(error)}`);
-        }
-        return "allowed-once";
-      }
-      return outcome.optionId === "allow-once" ? "allowed-once" : "rejected";
-    });
-  });
-  const makeAgent = (connection) => {
-    conn = connection;
-    return {
-      initialize(params) {
-        const hasPersistence = ctx.get("sessionPersistence") !== void 0;
-        const requested = params.protocolVersion;
-        const capsMeta = params.clientCapabilities?.["_meta"];
-        clientTerminalOutput = capsMeta !== null && typeof capsMeta === "object" ? capsMeta["terminal_output"] === true : false;
-        return Promise.resolve({
-          protocolVersion: typeof requested === "number" && requested >= 1 && requested < PROTOCOL_VERSION ? requested : PROTOCOL_VERSION,
-          agentInfo: { name: "dsh-acp", title: "DeepSeek Harness", version: VERSION },
-          agentCapabilities: {
-            loadSession: hasPersistence,
-            promptCapabilities: { image: false, audio: false, embeddedContext: true },
-            // Stdio servers always work; streamable HTTP maps onto
-            // mcp-client's second transport. Legacy SSE does not.
-            mcpCapabilities: { http: true, sse: false },
-            ...hasPersistence ? { sessionCapabilities: { list: {} } } : {}
-          },
-          authMethods: []
-        });
-      },
-      async authenticate(_params) {
-        if (!await credentialPresent()) {
-          throw authRequired(
-            "no DeepSeek credential found: save one in the dsh Web UI (Settings \u2192 Models) or set DEEPSEEK_API_KEY"
-          );
-        }
-      },
-      async newSession(params) {
-        assertOpen();
-        validateCwd(params.cwd);
-        syncMcpServers(params.mcpServers, params.cwd);
-        const sessionId = SessionId2(randomUUID());
-        const presets = presetsService();
-        const presetId = presets === void 0 ? void 0 : (await presets.resolve(void 0)).id;
-        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) } : {}
-        });
-        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);
-        return {
-          sessionId: String(sessionId),
-          modes: modeState(record),
-          ...options.length > 0 ? { configOptions: options } : {}
-        };
-      },
-      async loadSession(params) {
-        assertOpen();
-        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);
-        if (record.inflight !== void 0) {
-          throw invalidParams("a prompt is already in flight for this session");
-        }
-        let converted;
-        try {
-          converted = convertPrompt(params.prompt);
-        } catch (error) {
-          if (error instanceof UnsupportedPromptContentError) throw invalidParams(error.message);
-          throw error;
-        }
-        if (converted.blocks.length === 0) throw invalidParams("empty prompt");
-        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] === "login") {
-          return respond(await loginText(trimmed.slice(commandMatch[0].length)));
-        }
-        if (commandMatch?.[1] === "logout") return respond(await logoutText());
-        if (commandMatch?.[1] === "model") {
-          return respond(
-            await modelCommandText(
-              record,
-              params.sessionId,
-              trimmed.slice(commandMatch[0].length).trim()
-            )
-          );
-        }
-        if (commandMatch !== null && commandMatch[1] !== void 0) {
-          const commandsSvc = ctx.get("commands");
-          if (commandsSvc !== void 0) {
-            let execution;
-            try {
-              execution = await commandsSvc.execute(
-                record.agent,
-                trimmed,
-                new AbortController().signal
-              );
-            } catch (error) {
-              return respond(`\u26A0 /${commandMatch[1]} failed: ${errorChain2(error)}`);
-            }
-            if (execution !== void 0) {
-              const { result } = execution;
-              const text = result.text ?? (result.kind === "success" ? `/${commandMatch[1]} \u2713` : `/${commandMatch[1]} failed`);
-              syncPermissionState(record, params.sessionId);
-              publishCommands(params.sessionId, record);
-              publishConfigOptions(params.sessionId, record);
-              return respond(result.kind === "error" ? `\u26A0 ${text}` : text);
-            }
-          }
-        }
-        if (!await credentialPresent()) {
-          return respond(
-            [
-              "No DeepSeek credential is configured, so this prompt was not sent to the model.",
-              "",
-              "Configure one of:",
-              "- `/login <api-key>` \u2014 store a key in the harness credential store right here,",
-              "- the dsh Web UI (`dsh web`, Settings \u2192 Models),",
-              "- `DEEPSEEK_API_KEY` in the environment that launches this agent."
-            ].join("\n")
-          );
-        }
-        if (agents.get(record.agent.id) !== record.agent) {
-          throw internalError("prompt was not queued: the agent was disposed outside the bridge");
-        }
-        record.cancelled = false;
-        record.projection.beginPrompt();
-        const message = createUserMessage2({
-          content: converted.blocks,
-          source: { kind: "user" }
-        });
-        const stopReason = await new Promise((resolve2, reject) => {
-          const inflight = { resolve: resolve2, reject, messageId: message.id, turn: void 0 };
-          record.inflight = inflight;
-          try {
-            record.agent.followup(message);
-          } 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) {
-              resolve2("cancelled");
-              return;
-            }
-            const end = inflight.turn !== void 0 ? record.projection.turnEndFor(inflight.turn) ?? record.projection.lastTurnEnd : record.projection.lastTurnEnd;
-            resolve2(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 "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 "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() {
-    const persistence = getPersistence();
-    if (persistence === void 0) {
-      throw internalError("session persistence is not composed; session history is unavailable");
-    }
-    return persistence;
-  }
-  function getPersistence() {
-    return ctx.get("sessionPersistence");
-  }
-  function validateCwd(cwd) {
-    if (!isAbsolute(cwd)) throw invalidParams(`cwd must be an absolute path: ${cwd}`);
-  }
-  const mcpMounts = /* @__PURE__ */ new Map();
-  let warnedNoMcpClient = false;
-  const sanitizeServerName = (raw) => {
-    const cleaned = raw.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 32);
-    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 stream = config.stream ?? ndJsonStream(
-    Writable.toWeb(process.stdout),
-    Readable.toWeb(process.stdin)
-  );
-  conn = new AgentSideConnection(makeAgent, stream);
-  let quiescing;
-  const quiesce = () => {
-    if (quiescing !== void 0) return quiescing;
-    closed = true;
-    const records = [...sessions.values()];
-    sessions.clear();
-    for (const record of records) {
-      record.agent.cancel({ kind: "user" });
-      settlePrompt(record, "cancelled");
-    }
-    quiescing = (async () => {
-      const subagents = ctx.get("subagents");
-      if (subagents !== void 0) {
-        try {
-          await subagents.drainContinuableDescendants(records.map((record) => record.agent));
-        } catch (error) {
-          logWarn(`continuable subagent teardown failed: ${String(error)}`);
-        }
-      }
-      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");
-}
-
 // src/harness.ts
-import { execFileSync } from "node:child_process";
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { delimiter, dirname, isAbsolute as isAbsolute2, join, resolve, sep } from "node:path";
-import { pathToFileURL, fileURLToPath } from "node:url";
 var HarnessNotFoundError = class extends Error {
   constructor(probed) {
     super(
@@ -1929,12 +44,12 @@ ${probed.map((p) => `    ${p}`).join("\n")}` : ""
   }
 };
 var ANCHOR = "@deepseek-ai/dsh-agent";
-function packageDirFrom(base, name3) {
+function packageDirFrom(base, name) {
   let dir = resolve(base);
   for (; ; ) {
-    const candidate = join(dir, "node_modules", ...name3.split("/"));
+    const candidate = join(dir, "node_modules", ...name.split("/"));
     if (existsSync(join(candidate, "package.json"))) return candidate;
-    const direct = join(dir, ...name3.split("/"));
+    const direct = join(dir, ...name.split("/"));
     if (dir.endsWith(`${sep}node_modules`) && existsSync(join(direct, "package.json"))) return direct;
     const parent = dirname(dir);
     if (parent === dir) return void 0;
@@ -1998,7 +113,7 @@ function hostFromPathLookup() {
 function hostFromGlobalNpm() {
   try {
     const root = execFileSync("npm", ["root", "-g"], { encoding: "utf8", timeout: 1e4 }).trim();
-    if (root.length > 0 && isAbsolute2(root)) return hostAt(root, `npm root -g (${root})`);
+    if (root.length > 0 && isAbsolute(root)) return hostAt(root, `npm root -g (${root})`);
   } catch {
   }
   return void 0;
@@ -2025,260 +140,15 @@ function resolveHost(explicit) {
   probed.push("dsh-acp package tree (vendored)");
   throw new HarnessNotFoundError(probed);
 }
-function entryFile(packageDir, subpath) {
-  const manifest = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8"));
-  const key = subpath === void 0 ? "." : `./${subpath}`;
-  const exportsMap = manifest.exports;
-  let target;
-  if (typeof exportsMap === "string") {
-    if (key === ".") target = exportsMap;
-  } else if (exportsMap !== null && typeof exportsMap === "object") {
-    const entry = exportsMap[key];
-    target = entry;
-  }
-  if (target !== null && typeof target === "object") {
-    const conditions = target;
-    target = conditions["import"] ?? conditions["default"] ?? conditions["node"];
-    if (target !== null && typeof target === "object") {
-      const nested = target;
-      target = nested["default"] ?? nested["import"];
-    }
-  }
-  if (typeof target !== "string" && key === "." && typeof manifest.main === "string") {
-    target = manifest.main;
-  }
-  if (typeof target !== "string") {
-    throw new Error(`cannot resolve entry ${key} of ${packageDir}`);
-  }
-  return join(packageDir, target);
-}
-async function loadHostModule(host, specifier) {
-  const [scope, packageName, ...rest] = specifier.split("/");
-  if (scope === void 0 || packageName === void 0) throw new Error(`invalid specifier: ${specifier}`);
-  const name3 = `${scope}/${packageName}`;
-  const packageDir = packageDirFrom(host.base, name3);
-  if (packageDir === void 0) {
-    throw new Error(
-      `the DeepSeek Harness installation at ${host.base} (${host.source}) does not provide ${name3}; update it with: npm install -g @deepseek-ai/dsh`
-    );
-  }
-  const file = entryFile(packageDir, rest.length > 0 ? rest.join("/") : void 0);
-  logDebug(`loading ${specifier} from ${file}`);
-  return await import(pathToFileURL(file).href);
-}
-var PLUGIN_SPECIFIERS = {
-  timer: "@deepseek-ai/cordis-plugin-timer",
-  llmRuntime: "@deepseek-ai/dsh-llm",
-  sessionStore: "@deepseek-ai/dsh-session",
-  sessionTitle: "@deepseek-ai/dsh-session-title",
-  systemPrompt: "@deepseek-ai/dsh-system-prompt",
-  tools: "@deepseek-ai/dsh-tools",
-  agents: "@deepseek-ai/dsh-agent",
-  agentLoop: "@deepseek-ai/dsh-agent-loop",
-  llmRetry: "@deepseek-ai/dsh-llm-retry",
-  jobs: "@deepseek-ai/dsh-jobs-local",
-  invariants: "@deepseek-ai/dsh-invariants",
-  sessionInvariant: "@deepseek-ai/dsh-session/invariant",
-  agentInvariant: "@deepseek-ai/dsh-agent/invariant",
-  scopeInvariant: "@deepseek-ai/dsh-scope/invariant",
-  agentLoopInvariant: "@deepseek-ai/dsh-agent-loop/invariant",
-  homePaths: "@deepseek-ai/dsh-home-paths",
-  bashEnv: "@deepseek-ai/dsh-shell-env",
-  toolBash: "@deepseek-ai/dsh-tool-bash",
-  workspaceContext: "@deepseek-ai/dsh-agent-instructions",
-  llmDeepseek: "@deepseek-ai/dsh-llm-deepseek",
-  persistence: "@deepseek-ai/dsh-session-persistence-jsonl",
-  checkpoints: "@deepseek-ai/dsh-session-checkpoint-policy",
-  sandbox: "@deepseek-ai/dsh-sandbox-local",
-  sandboxPolicy: "@deepseek-ai/dsh-sandbox-policy",
-  subprocess: "@deepseek-ai/dsh-subprocess-local",
-  bash: "@deepseek-ai/dsh-bash-sandbox",
-  approval: "@deepseek-ai/dsh-user-approval",
-  fs: "@deepseek-ai/dsh-fs-sandbox",
-  fsObservationPolicy: "@deepseek-ai/dsh-fs-observation-policy",
-  toolFs: "@deepseek-ai/dsh-tool-fs",
-  toolTodo: "@deepseek-ai/dsh-tool-todo",
-  tokenMeter: "@deepseek-ai/dsh-token-meter",
-  compaction: "@deepseek-ai/dsh-compaction-basic"
-};
-var OPTIONAL_PLUGIN_SPECIFIERS = {
-  credentials: "@deepseek-ai/dsh-credentials-local",
-  credentialsSeam: "@deepseek-ai/dsh-credentials",
-  mcpClient: "@deepseek-ai/dsh-mcp-client"
-};
-async function loadKit(host) {
-  const keys = Object.keys(PLUGIN_SPECIFIERS);
-  const optionalKeys = Object.keys(OPTIONAL_PLUGIN_SPECIFIERS);
-  const [cordis, ...pluginModules] = await Promise.all([
-    loadHostModule(host, "@deepseek-ai/cordis"),
-    ...keys.map((key) => loadHostModule(host, PLUGIN_SPECIFIERS[key])),
-    ...optionalKeys.map(
-      (key) => loadHostModule(host, OPTIONAL_PLUGIN_SPECIFIERS[key]).catch((error) => {
-        logDebug(`optional module ${OPTIONAL_PLUGIN_SPECIFIERS[key]} unavailable: ${String(error)}`);
-        return void 0;
-      })
-    )
-  ]);
-  const plugins = {};
-  [...keys, ...optionalKeys].forEach((key, index) => {
-    const module = pluginModules[index];
-    if (module !== void 0) plugins[key] = module;
-  });
-  return {
-    host,
-    cordis,
-    llm: plugins["llmRuntime"],
-    session: plugins["sessionStore"],
-    sessionTitle: plugins["sessionTitle"],
-    sandboxPolicy: plugins["sandboxPolicy"],
-    plugins
-  };
-}
-function pluginOf(module) {
-  return module["default"] ?? module;
-}
-
-// src/app.ts
-var name2 = "dsh-acp-app";
-var SESSION_TITLE_CONFIG = { fallbackMaxWords: 5, fallbackMaxBytes: 40, maxTitleBytes: 80 };
-function applySpine(ctx, kit, settings) {
-  const p = kit.plugins;
-  const anyCtx = ctx;
-  const resolveDshHome = p["homePaths"].resolveDshHome;
-  const dshHome = resolveDshHome?.();
-  anyCtx.plugin(pluginOf(p["timer"]));
-  anyCtx.plugin(pluginOf(p["llmRuntime"]));
-  anyCtx.plugin(pluginOf(p["sessionStore"]));
-  anyCtx.plugin(pluginOf(p["sessionTitle"]), SESSION_TITLE_CONFIG);
-  anyCtx.plugin(pluginOf(p["systemPrompt"]), {
-    includeHarnessIdentity: true,
-    includeRuntimeContext: true,
-    persona: settings.persona
-  });
-  anyCtx.plugin(pluginOf(p["tools"]), {});
-  anyCtx.plugin(pluginOf(p["agents"]));
-  anyCtx.plugin(p["llmRetry"]);
-  anyCtx.plugin(pluginOf(p["jobs"]), {});
-  anyCtx.plugin(pluginOf(p["invariants"]), {});
-  anyCtx.plugin(p["sessionInvariant"]);
-  anyCtx.plugin(p["agentInvariant"]);
-  anyCtx.plugin(p["scopeInvariant"]);
-  anyCtx.plugin(p["agentLoopInvariant"]);
-  anyCtx.plugin(p["bashEnv"], dshHome !== void 0 ? { dshHome } : {});
-  anyCtx.plugin(p["toolBash"], {});
-  anyCtx.plugin(p["workspaceContext"], { maxBytes: 65536 });
-  anyCtx.plugin(pluginOf(p["agentLoop"]), { agents: [] });
-}
-async function apply2(ctx, config) {
-  const { settings, kit } = config;
-  const p = kit.plugins;
-  const anyCtx = ctx;
-  const credentialsSeam = p["credentialsSeam"];
-  const agentsModule = p["agents"];
-  const installModelSelection = agentsModule.installModelSelection ?? agentsModule.ln;
-  const harness = {
-    createUserMessage: kit.llm.createUserMessage,
-    errorChain: kit.llm.errorChain,
-    sessionId: kit.session.SessionId,
-    foldSessionTitle: kit.sessionTitle.foldSessionTitle,
-    setSandboxMode: kit.sandboxPolicy.setSandboxMode,
-    sandboxModes: kit.sandboxPolicy.SANDBOX_MODES,
-    ...installModelSelection !== void 0 ? { installModelSelection } : {},
-    ...credentialsSeam?.credentialRef !== void 0 ? { credentialRef: credentialsSeam.credentialRef } : {},
-    ...p["mcpClient"] !== void 0 ? { mcpClient: p["mcpClient"] } : {}
-  };
-  await ctx.effect(async function* () {
-    const spine = anyCtx.plugin(
-      { name: "dsh-acp-spine", apply: (child) => applySpine(child, kit, settings) },
-      {}
-    );
-    await spine;
-    yield spine.dispose;
-    const credentialsModule = p["credentials"];
-    if (credentialsModule !== void 0) {
-      const credentials = anyCtx.plugin(pluginOf(credentialsModule), {});
-      await credentials;
-      yield credentials.dispose;
-    }
-    const llm = anyCtx.plugin(p["llmDeepseek"], {
-      thinking: settings.thinking ? "enabled" : "disabled",
-      reasoningEffort: settings.reasoningEffort
-    });
-    await llm;
-    yield llm.dispose;
-    const persistence = anyCtx.plugin(pluginOf(p["persistence"]), {
-      root: settings.sessionRoot,
-      compression: "none"
-    });
-    await persistence;
-    yield persistence.dispose;
-    const checkpoints = anyCtx.plugin(p["checkpoints"]);
-    await checkpoints;
-    yield checkpoints.dispose;
-    const sandbox = anyCtx.plugin(pluginOf(p["sandbox"]), {});
-    await sandbox;
-    yield sandbox.dispose;
-    const sandboxPolicy = anyCtx.plugin(pluginOf(p["sandboxPolicy"]), {
-      mode: settings.permissionMode,
-      workspaceRoot: process.cwd()
-    });
-    await sandboxPolicy;
-    yield sandboxPolicy.dispose;
-    const subprocess = anyCtx.plugin(pluginOf(p["subprocess"]));
-    await subprocess;
-    yield subprocess.dispose;
-    const bash = anyCtx.plugin(pluginOf(p["bash"]), { timeoutMs: settings.bashTimeoutMs });
-    await bash;
-    yield bash.dispose;
-    const approval = anyCtx.plugin(pluginOf(p["approval"]), {
-      policy: settings.permissionMode === "danger-full-access" ? "never" : "ask"
-    });
-    await approval;
-    yield approval.dispose;
-    const fs = anyCtx.plugin(pluginOf(p["fs"]), {});
-    await fs;
-    yield fs.dispose;
-    const fsPolicy = anyCtx.plugin(p["fsObservationPolicy"]);
-    await fsPolicy;
-    yield fsPolicy.dispose;
-    const fsTools = anyCtx.plugin(p["toolFs"], {});
-    await fsTools;
-    yield fsTools.dispose;
-    const todo = anyCtx.plugin(p["toolTodo"], { allowParallelInProgress: true });
-    await todo;
-    yield todo.dispose;
-    const meter = anyCtx.plugin(pluginOf(p["tokenMeter"]));
-    await meter;
-    yield meter.dispose;
-    const compaction = anyCtx.plugin(pluginOf(p["compaction"]), {
-      thresholdRatio: 0.8,
-      retainRatio: 0.08,
-      maxTokens: 8192,
-      compactionRetries: 1
-    });
-    await compaction;
-    yield compaction.dispose;
-    const bridge = anyCtx.plugin(bridge_exports, {
-      provider: settings.provider ?? "deepseek-official",
-      model: settings.model ?? "deepseek-v4-flash",
-      models: settings.models,
-      ...settings.maxTokens !== void 0 ? { maxTokens: settings.maxTokens } : {},
-      permissionMode: settings.permissionMode,
-      harness
-    });
-    await bridge;
-    yield bridge.dispose;
-  }, "dsh-acp-app.composition");
-}
 
 // src/profile-boot.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire } from "node:module";
 import { dirname as dirname2, join as join2, sep as sep2 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 var BIN = "dsh-acp";
 function ownRoot() {
-  return dirname2(createRequire2(import.meta.url).resolve("../package.json"));
+  return dirname2(createRequire(import.meta.url).resolve("../package.json"));
 }
 var OWN_BRIDGE_SPECIFIER = "@openma/deepseek-harness-acp/bridge";
 function rewriteBridgeRows(row, absoluteEntry) {
@@ -2301,7 +171,7 @@ function bundlePatchPath(packageJsonPath) {
   return join2(dirname2(packageJsonPath), declared);
 }
 async function bootAcpProfile(host, overrides) {
-  const req = createRequire2(join2(host.base, "noop.js"));
+  const req = createRequire(join2(host.base, "noop.js"));
   const dshPkgPath = req.resolve("@deepseek-ai/dsh/package.json");
   const dshDir = dirname2(dshPkgPath);
   const appBoot = await import(pathToFileURL2(req.resolve("@deepseek-ai/dsh-app-boot")).href);
@@ -2356,6 +226,9 @@ async function bootAcpProfile(host, overrides) {
     overlays.push({ id: "session-telemetry-otel", disabled: true });
   }
   const bridgeRow = rows.get("acp-bridge");
+  if (overrides?.serve === false && bridgeRow !== void 0) {
+    overlays.push({ id: "acp-bridge", disabled: true });
+  }
   if (overrides !== void 0 && bridgeRow !== void 0) {
     const patch = {};
     if (overrides.provider !== void 0) patch["provider"] = overrides.provider;
@@ -2392,6 +265,113 @@ async function bootAcpProfile(host, overrides) {
   return ctx;
 }
 
+// src/auth.ts
+function parseLoginArgv(argv) {
+  let provider;
+  const rest = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === void 0) continue;
+    if (arg === "--provider") {
+      provider = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--provider=")) {
+      provider = arg.slice("--provider=".length);
+      continue;
+    }
+    rest.push(arg);
+  }
+  const key = rest[0];
+  return {
+    ...provider && provider.length > 0 ? { provider } : {},
+    ...key && key.length > 0 ? { key } : {}
+  };
+}
+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";
+}
+
+// src/login.ts
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+async function readSecret(promptText) {
+  const stdin = process.stdin;
+  if (!stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of stdin) {
+      chunks.push(Buffer.from(chunk));
+      const text = Buffer.concat(chunks).toString("utf8");
+      const newline = text.indexOf("\n");
+      if (newline >= 0) return text.slice(0, newline).trim();
+    }
+    return Buffer.concat(chunks).toString("utf8").trim();
+  }
+  process.stderr.write(promptText);
+  return await new Promise((resolve2) => {
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let buffer = "";
+    const onData = (chunk) => {
+      for (const char of chunk) {
+        if (char === "\n" || char === "\r" || char === "") {
+          stdin.setRawMode(false);
+          stdin.pause();
+          stdin.off("data", onData);
+          process.stderr.write("\n");
+          resolve2(buffer.trim());
+          return;
+        }
+        if (char === "") {
+          stdin.setRawMode(false);
+          process.stderr.write("^C\n");
+          process.exit(130);
+        }
+        if (char === "\x7F" || char === "\b") {
+          buffer = buffer.slice(0, -1);
+          continue;
+        }
+        buffer += char;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function runLogin(ctx, argv) {
+  const parsed = parseLoginArgv(argv);
+  const name = primaryCredentialName(parsed.provider);
+  const credentials = ctx.credentials;
+  const ref = credentialRef(name);
+  const before = await credentials.describe(ref);
+  if (before.configured && before.source !== void 0) {
+    process.stderr.write(`A key is already configured for ${name} (source: ${before.source}).
+`);
+  }
+  const key = parsed.key ?? await readSecret(`${name} (input hidden): `);
+  if (key.length === 0) {
+    process.stderr.write("No key entered; nothing saved.\n");
+    return 1;
+  }
+  await credentials.set(ref, key);
+  const masked = key.length <= 8 ? "\u2026" : `${key.slice(0, 4)}\u2026${key.slice(-4)}`;
+  process.stderr.write(
+    `Saved ${masked} as ${name} in the harness credential store (~/.dsh/.credentials.yaml, mode 600).
+The dsh Web UI and every dsh surface share this credential.
+`
+  );
+  return 0;
+}
+
 // src/settings.ts
 import { homedir } from "node:os";
 import { join as join3 } from "node:path";
@@ -2401,8 +381,8 @@ Verify your work by running the code or tests. Keep answers brief and factual.`;
 var PERMISSION_MODES = ["read-only", "workspace-write", "danger-full-access"];
 var SettingsError = class extends Error {
 };
-function envString(name3) {
-  const value = process.env[name3];
+function envString(name) {
+  const value = process.env[name];
   return value !== void 0 && value.length > 0 ? value : void 0;
 }
 function parseFlags(argv) {
@@ -2417,13 +397,13 @@ function parseFlags(argv) {
       flags.set(arg.slice(2, eq), arg.slice(eq + 1));
       continue;
     }
-    const name3 = arg.slice(2);
+    const name = arg.slice(2);
     const next = argv[i + 1];
-    if (next !== void 0 && !next.startsWith("--") && FLAGS_WITH_VALUES.has(name3)) {
-      flags.set(name3, next);
+    if (next !== void 0 && !next.startsWith("--") && FLAGS_WITH_VALUES.has(name)) {
+      flags.set(name, next);
       i += 1;
     } else {
-      flags.set(name3, true);
+      flags.set(name, true);
     }
   }
   return { flags };
@@ -2440,17 +420,17 @@ var FLAGS_WITH_VALUES = /* @__PURE__ */ new Set([
   "reasoning-effort",
   "bash-timeout"
 ]);
-function stringFlag(parsed, name3) {
-  const value = parsed.flags.get(name3);
+function stringFlag(parsed, name) {
+  const value = parsed.flags.get(name);
   if (value === void 0) return void 0;
-  if (value === true) throw new SettingsError(`--${name3} requires a value`);
+  if (value === true) throw new SettingsError(`--${name} requires a value`);
   return value;
 }
 function resolveSettings(argv) {
   const parsed = parseFlags(argv);
-  for (const name3 of parsed.flags.keys()) {
-    if (!FLAGS_WITH_VALUES.has(name3) && name3 !== "no-thinking") {
-      throw new SettingsError(`unknown flag: --${name3}`);
+  for (const name of parsed.flags.keys()) {
+    if (!FLAGS_WITH_VALUES.has(name) && name !== "no-thinking") {
+      throw new SettingsError(`unknown flag: --${name}`);
     }
   }
   const model = stringFlag(parsed, "model") ?? envString("DSH_MODEL");
@@ -2495,6 +475,9 @@ function resolveSettings(argv) {
   };
 }
 var HELP_TEXT = `Usage: dsh-acp [options]
+       dsh-acp login [--provider <route>] [api-key]
+                                 Save a provider API key (interactive when omitted)
+       dsh-acp update            Self-update via npm
 
 Agent Client Protocol (ACP) stdio server for DeepSeek Harness. Speak ACP on
 stdin/stdout from an ACP client such as Zed; diagnostics go to stderr.
@@ -2526,6 +509,10 @@ Environment:
   DSH_ACP_DEBUG               Verbose stderr diagnostics
 `;
 
+// src/version.ts
+import { createRequire as createRequire2 } from "node:module";
+var VERSION = createRequire2(import.meta.url)("../package.json").version;
+
 // src/index.ts
 var NAME = "@openma/deepseek-harness-acp";
 async function main() {
@@ -2538,6 +525,29 @@ async function main() {
     console.log(HELP_TEXT.trimEnd());
     return;
   }
+  if (argv[0] === "login") {
+    let booted;
+    try {
+      const host = resolveHost(void 0);
+      booted = await bootAcpProfile(host, { serve: false });
+    } catch (error) {
+      if (error instanceof HarnessNotFoundError) {
+        logError(error.message);
+        process.exitCode = 1;
+        return;
+      }
+      throw error;
+    }
+    try {
+      process.exitCode = await runLogin(
+        booted,
+        argv.slice(1)
+      );
+    } finally {
+      await booted.fiber.dispose().catch(() => void 0);
+    }
+    return;
+  }
   if (argv[0] === "update") {
     logInfo(`updating ${NAME} (npm install -g ${NAME}@latest)\u2026`);
     const result = spawnSync("npm", ["install", "-g", `${NAME}@latest`], { stdio: ["ignore", 2, 2] });
@@ -2568,19 +578,19 @@ ${HELP_TEXT}`);
     const host = resolveHost(settings.dshPath);
     logDebug(`harness host: ${host.base} via ${host.source} (${host.version ?? "unknown version"})`);
     if (process.env["DSH_ACP_COMPOSE"] === "spine") {
-      const kit = await loadKit(host);
-      const spineCtx = new kit.cordis.Context();
-      await spineCtx.plugin(app_exports, { settings, kit });
-      ctx = spineCtx;
-    } else {
-      const booted = await bootAcpProfile(host, {
-        ...settings.provider !== void 0 ? { provider: settings.provider } : {},
-        ...settings.model !== void 0 ? { model: settings.model } : {},
-        ...settings.permissionMode !== void 0 ? { permissionMode: settings.permissionMode } : {},
-        ...settings.maxTokens !== void 0 ? { maxTokens: settings.maxTokens } : {}
-      });
-      ctx = booted;
+      logError(
+        "DSH_ACP_COMPOSE=spine is no longer supported: the ACP bridge injects dsh-base services (credentials, models, permissions, presets). Unset DSH_ACP_COMPOSE to use the profile engine."
+      );
+      process.exitCode = 1;
+      return;
     }
+    const booted = await bootAcpProfile(host, {
+      ...settings.provider !== void 0 ? { provider: settings.provider } : {},
+      ...settings.model !== void 0 ? { model: settings.model } : {},
+      ...settings.permissionMode !== void 0 ? { permissionMode: settings.permissionMode } : {},
+      ...settings.maxTokens !== void 0 ? { maxTokens: settings.maxTokens } : {}
+    });
+    ctx = booted;
   } catch (error) {
     if (error instanceof HarnessNotFoundError) {
       logError(error.message);