@openma/deepseek-harness-acp 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,1889 @@
+#!/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 mcpClient from "@deepseek-ai/dsh-mcp-client";
+function selfHarness() {
+  return {
+    createUserMessage,
+    errorChain,
+    sessionId: SessionId,
+    foldSessionTitle,
+    setSandboxMode,
+    sandboxModes: SANDBOX_MODES,
+    credentialRef,
+    mcpClient
+  };
+}
+var init_self_harness = __esm({
+  "src/bridge/self-harness.ts"() {
+    "use strict";
+  }
+});
+
+// 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
+var VERSION = "0.1.0";
+
+// 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}
+`);
+}
+function logDebug(message) {
+  if (process.env["DSH_ACP_DEBUG"]) process.stderr.write(`${PREFIX} debug: ${message}
+`);
+}
+
+// src/bridge/translate.ts
+var MAX_TITLE_LENGTH = 80;
+var MAX_RESULT_TEXT = 2e4;
+function firstLine(text, limit = MAX_TITLE_LENGTH) {
+  const line = text.split("\n", 1)[0] ?? "";
+  return line.length > limit ? `${line.slice(0, limit - 1)}\u2026` : line;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function pathLocations(args) {
+  const locations = [];
+  for (const key of ["path", "file_path", "filePath", "file"]) {
+    const path = asString(args[key]);
+    if (path !== void 0) {
+      locations.push({ path });
+      break;
+    }
+  }
+  return locations;
+}
+function classifyToolCall(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;
+  constructor(contextWindow) {
+    this.contextWindow = contextWindow;
+  }
+  /** 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);
+    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 } : {}
+      }
+    ];
+  }
+  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 { failed, text, diffs } = extractToolResult(data);
+    const content = diffs.map((diff) => ({
+      type: "diff",
+      path: diff.path,
+      ...diff.oldText !== null ? { oldText: diff.oldText } : {},
+      newText: diff.newText
+    }));
+    if (text.length > 0 && diffs.length === 0) {
+      const block = { type: "text", 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;
+  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 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;
+  });
+  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 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 modeState = (record) => ({
+    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 configOptions = 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);
+    if (options.length < 2) return [];
+    return [
+      {
+        type: "select",
+        id: "model",
+        name: "Model",
+        category: "model",
+        currentValue: current,
+        options
+      }
+    ];
+  };
+  const publishCommands = (sessionId) => {
+    notify(sessionId, {
+      sessionUpdate: "available_commands_update",
+      availableCommands: [
+        { 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" }
+      ]
+    });
+  };
+  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 statusText = async (record) => {
+    const used = record.projection.contextWindow;
+    const lines = [
+      `**dsh-acp** ${VERSION} \u2014 DeepSeek Harness ACP bridge`,
+      "",
+      `| | |`,
+      `|---|---|`,
+      `| Provider | ${record.provider ?? defaultProvider() ?? "(composition default)"} |`,
+      `| Model | ${record.model ?? config.model ?? defaultSelection().model ?? record.agent.options.model ?? "(composition default)"} |`,
+      `| Credential | ${await describeCredential()} |`,
+      `| Permission mode | ${record.modeId} |`,
+      `| 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(),
+      modeId,
+      model,
+      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;
+        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 handle = await agents.create({
+          sessionId,
+          meta: { cwd: params.cwd },
+          agentOptions: agentOptionsFor(config.model)
+        });
+        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"
+        );
+        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);
+        const persistence = requirePersistence();
+        const sessionId = params.sessionId;
+        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;
+        try {
+          ({ events } = await persistence.inspect(SessionId2(sessionId)));
+        } catch (error) {
+          throw invalidParams(`session not found: ${sessionId} (${errorChain2(error)})`);
+        }
+        const replay = buildReplay(events);
+        for (const update of replay.updates) notify(sessionId, update);
+        if (replay.title !== void 0) {
+          notify(sessionId, {
+            sessionUpdate: "session_info_update",
+            title: replay.title
+          });
+        }
+        const handle = await agents.resume({
+          resumeSessionId: SessionId2(sessionId),
+          agentOptions: agentOptionsFor(config.model)
+        });
+        const projection = new SessionProjection(replay.contextWindow);
+        projection.title = replay.title;
+        const record = registerRecord(
+          sessionId,
+          handle.agent,
+          () => handle.dispose(),
+          config.model,
+          config.permissionMode ?? "workspace-write",
+          projection
+        );
+        queueMicrotask(() => publishCommands(sessionId));
+        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 = requireSession(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 (!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 } : {} };
+      },
+      setSessionMode(params) {
+        const record = requireSession(params.sessionId);
+        const mode = SANDBOX_MODES2.find((candidate) => candidate === params.modeId);
+        if (mode === void 0) throw invalidParams(`unknown mode: ${params.modeId}`);
+        setSandboxMode2(record.agent.session, mode);
+        try {
+          ctx.get("approval")?.setPolicy?.(record.agent, mode === "danger-full-access" ? "never" : "ask");
+        } catch (error) {
+          logWarn(`approval policy switch failed: ${String(error)}`);
+        }
+        record.modeId = mode;
+        notify(params.sessionId, { sessionUpdate: "current_mode_update", currentModeId: mode });
+        return Promise.resolve({});
+      },
+      async setSessionConfigOption(params) {
+        const record = requireSession(params.sessionId);
+        if (params.configId !== "model") throw invalidParams(`unknown config option: ${params.configId}`);
+        if (record.inflight !== void 0) {
+          throw invalidParams("cannot switch models while a prompt is running");
+        }
+        const value = typeof params.value === "string" ? params.value : void 0;
+        if (value === void 0) throw invalidParams(`unknown model: ${String(params.value)}`);
+        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())) {
+          const sessionId = record.agent.session.id;
+          await record.dispose().catch((error) => {
+            logWarn(`dispose during model switch failed: ${String(error)}`);
+          });
+          let handle;
+          try {
+            handle = await agents.resume({
+              resumeSessionId: sessionId,
+              agentOptions: agentOptionsFor(choice.model, choice.provider)
+            });
+          } catch (error) {
+            sessions.delete(params.sessionId);
+            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;
+          }
+        }
+        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(
+      [
+        "could not find a DeepSeek Harness installation.",
+        "",
+        "Install it first:",
+        "    npm install -g @deepseek-ai/dsh",
+        "",
+        "or point dsh-acp at an existing installation:",
+        "    DSH_PATH=/path/to/dsh dsh-acp        (dsh binary, package dir, or npm root)",
+        "",
+        probed.length > 0 ? `Probed:
+${probed.map((p) => `    ${p}`).join("\n")}` : ""
+      ].join("\n").trimEnd()
+    );
+  }
+};
+var ANCHOR = "@deepseek-ai/dsh-agent";
+function packageDirFrom(base, name3) {
+  let dir = resolve(base);
+  for (; ; ) {
+    const candidate = join(dir, "node_modules", ...name3.split("/"));
+    if (existsSync(join(candidate, "package.json"))) return candidate;
+    const direct = join(dir, ...name3.split("/"));
+    if (dir.endsWith(`${sep}node_modules`) && existsSync(join(direct, "package.json"))) return direct;
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function versionOf(packageDir) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8"));
+    return typeof parsed.version === "string" ? parsed.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function hostAt(base, source) {
+  const anchor = packageDirFrom(base, ANCHOR);
+  if (anchor === void 0) return void 0;
+  return { base: resolve(base), version: versionOf(anchor), source };
+}
+function hostFromExplicit(explicit) {
+  const path = resolve(explicit);
+  const bases = [];
+  let stat;
+  try {
+    stat = realpathSync(path) !== void 0 && existsSync(join(path, ".")) ? "dir" : "file";
+  } catch {
+    stat = void 0;
+  }
+  if (existsSync(path)) {
+    try {
+      const real = realpathSync(path);
+      stat = real === path && existsSync(join(path, "package.json")) ? "dir" : stat;
+      bases.push(dirname(real));
+    } catch {
+      bases.push(dirname(path));
+    }
+    bases.push(path, join(path, "node_modules"), join(path, "lib", "node_modules"));
+  }
+  for (const base of bases) {
+    const host = hostAt(base, `--dsh-path/DSH_PATH (${explicit})`);
+    if (host !== void 0) return host;
+  }
+  return void 0;
+}
+function hostFromPathLookup() {
+  const pathEnv = process.env["PATH"] ?? "";
+  for (const dir of pathEnv.split(delimiter)) {
+    if (dir.length === 0) continue;
+    const candidate = join(dir, "dsh");
+    if (!existsSync(candidate)) continue;
+    try {
+      const real = realpathSync(candidate);
+      const host = hostAt(dirname(real), `dsh on PATH (${candidate})`);
+      if (host !== void 0) return host;
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+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})`);
+  } catch {
+  }
+  return void 0;
+}
+function resolveHost(explicit) {
+  const probed = [];
+  if (explicit !== void 0) {
+    const host = hostFromExplicit(explicit);
+    if (host !== void 0) return host;
+    probed.push(`--dsh-path/DSH_PATH: ${explicit}`);
+    throw new HarnessNotFoundError(probed);
+  }
+  const own = hostAt(dirname(fileURLToPath(import.meta.url)), "dsh-acp package tree");
+  if (own !== void 0) return own;
+  probed.push("dsh-acp package tree");
+  const local = hostAt(process.cwd(), `invoking directory (${process.cwd()})`);
+  if (local !== void 0) return local;
+  probed.push(`invoking directory: ${process.cwd()}`);
+  const onPath = hostFromPathLookup();
+  if (onPath !== void 0) return onPath;
+  probed.push("dsh on PATH");
+  const globalNpm = hostFromGlobalNpm();
+  if (globalNpm !== void 0) return globalNpm;
+  probed.push("npm root -g");
+  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 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,
+    ...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,
+      model: settings.model,
+      models: settings.models,
+      ...settings.maxTokens !== void 0 ? { maxTokens: settings.maxTokens } : {},
+      permissionMode: settings.permissionMode,
+      harness
+    });
+    await bridge;
+    yield bridge.dispose;
+  }, "dsh-acp-app.composition");
+}
+
+// src/settings.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+var DEFAULT_PERSONA = `You are a coding assistant powered by the {{model}} model, working inside an editor via the Agent Client Protocol. Your working directory is {{cwd}}. Your bash tool runs under a file sandbox \u2014 a \`[sandbox: file access denied \u2026]\` result is policy, not a command bug.
+
+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];
+  return value !== void 0 && value.length > 0 ? value : void 0;
+}
+function parseFlags(argv) {
+  const flags = /* @__PURE__ */ new Map();
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === void 0 || !arg.startsWith("--")) {
+      throw new SettingsError(`unexpected argument: ${String(arg)}`);
+    }
+    const eq = arg.indexOf("=");
+    if (eq >= 0) {
+      flags.set(arg.slice(2, eq), arg.slice(eq + 1));
+      continue;
+    }
+    const name3 = arg.slice(2);
+    const next = argv[i + 1];
+    if (next !== void 0 && !next.startsWith("--") && FLAGS_WITH_VALUES.has(name3)) {
+      flags.set(name3, next);
+      i += 1;
+    } else {
+      flags.set(name3, true);
+    }
+  }
+  return { flags };
+}
+var FLAGS_WITH_VALUES = /* @__PURE__ */ new Set([
+  "dsh-path",
+  "provider",
+  "model",
+  "models",
+  "max-tokens",
+  "permission-mode",
+  "session-root",
+  "persona",
+  "reasoning-effort",
+  "bash-timeout"
+]);
+function stringFlag(parsed, name3) {
+  const value = parsed.flags.get(name3);
+  if (value === void 0) return void 0;
+  if (value === true) throw new SettingsError(`--${name3} 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}`);
+    }
+  }
+  const model = stringFlag(parsed, "model") ?? envString("DSH_MODEL") ?? "deepseek-v4-flash";
+  const modelsRaw = stringFlag(parsed, "models") ?? envString("DSH_ACP_MODELS");
+  const models = (modelsRaw !== void 0 ? modelsRaw.split(",") : ["deepseek-v4-flash", "deepseek-v4-pro"]).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  const permissionModeRaw = stringFlag(parsed, "permission-mode") ?? envString("DSH_PERMISSION_MODE") ?? "workspace-write";
+  const permissionMode = PERMISSION_MODES.find((candidate) => candidate === permissionModeRaw);
+  if (permissionMode === void 0) {
+    throw new SettingsError(
+      `invalid --permission-mode: ${permissionModeRaw} (expected ${PERMISSION_MODES.join(" | ")})`
+    );
+  }
+  const maxTokensRaw = stringFlag(parsed, "max-tokens") ?? envString("DSH_MAX_TOKENS");
+  let maxTokens;
+  if (maxTokensRaw !== void 0) {
+    maxTokens = Number(maxTokensRaw);
+    if (!Number.isSafeInteger(maxTokens) || maxTokens <= 0) {
+      throw new SettingsError(`invalid --max-tokens: ${maxTokensRaw}`);
+    }
+  }
+  const reasoningRaw = stringFlag(parsed, "reasoning-effort") ?? envString("DSH_REASONING_EFFORT") ?? "high";
+  if (reasoningRaw !== "off" && reasoningRaw !== "high" && reasoningRaw !== "max") {
+    throw new SettingsError(`invalid --reasoning-effort: ${reasoningRaw} (expected off | high | max)`);
+  }
+  const bashTimeoutRaw = stringFlag(parsed, "bash-timeout") ?? envString("DSH_BASH_TIMEOUT_MS") ?? "60000";
+  const bashTimeoutMs = Number(bashTimeoutRaw);
+  if (!Number.isSafeInteger(bashTimeoutMs) || bashTimeoutMs <= 0) {
+    throw new SettingsError(`invalid --bash-timeout: ${bashTimeoutRaw}`);
+  }
+  return {
+    dshPath: stringFlag(parsed, "dsh-path") ?? envString("DSH_PATH"),
+    provider: stringFlag(parsed, "provider") ?? envString("DSH_PROVIDER") ?? "deepseek-official",
+    model,
+    models,
+    maxTokens,
+    permissionMode,
+    sessionRoot: stringFlag(parsed, "session-root") ?? envString("DSH_SESSION_ROOT") ?? join2(homedir(), ".dsh-acp", "sessions"),
+    persona: stringFlag(parsed, "persona") ?? envString("DSH_SYSTEM_PROMPT") ?? DEFAULT_PERSONA,
+    thinking: !parsed.flags.has("no-thinking"),
+    reasoningEffort: reasoningRaw,
+    bashTimeoutMs
+  };
+}
+var HELP_TEXT = `Usage: dsh-acp [options]
+
+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.
+
+Options:
+  --dsh-path <path>           DeepSeek Harness installation: the dsh binary, its
+                              package dir, or any dir carrying node_modules/@deepseek-ai
+                              (DSH_PATH; auto-detected when unset \u2014 own tree, ./node_modules,
+                              dsh on PATH, npm root -g)
+  --provider <route>          Provider route (DSH_PROVIDER, default deepseek-official)
+  --model <id>                Default model (DSH_MODEL, default deepseek-v4-flash)
+  --models <a,b,...>          Selectable models for the session "Model" option
+                              (DSH_ACP_MODELS, default deepseek-v4-flash,deepseek-v4-pro)
+  --max-tokens <n>            Per-request output-token cap (DSH_MAX_TOKENS)
+  --permission-mode <mode>    read-only | workspace-write | danger-full-access
+                              (DSH_PERMISSION_MODE, default workspace-write)
+  --session-root <dir>        JSONL session store (DSH_SESSION_ROOT, default ~/.dsh-acp/sessions)
+  --persona <text>            System-prompt persona (DSH_SYSTEM_PROMPT)
+  --reasoning-effort <level>  off | high | max (DSH_REASONING_EFFORT, default high)
+  --no-thinking               Disable model thinking output
+  --bash-timeout <ms>         Foreground bash timeout (DSH_BASH_TIMEOUT_MS, default 60000)
+  --version                   Print version and exit
+  --help                      Show this help
+
+Environment:
+  DSH_PATH                    DeepSeek Harness installation (see --dsh-path)
+  DEEPSEEK_API_KEY            DeepSeek (or compatible) API credential
+  DEEPSEEK_BASE_URL           OpenAI-compatible endpoint override
+  DSH_ACP_DEBUG               Verbose stderr diagnostics
+`;
+
+// src/index.ts
+var NAME = "@openma/deepseek-harness-acp";
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.includes("--version")) {
+    console.log(`${NAME} ${VERSION}`);
+    return;
+  }
+  if (argv.includes("--help")) {
+    console.log(HELP_TEXT.trimEnd());
+    return;
+  }
+  let settings;
+  try {
+    settings = resolveSettings(argv);
+  } catch (error) {
+    if (error instanceof SettingsError) {
+      logError(error.message);
+      process.stderr.write(`
+${HELP_TEXT}`);
+      process.exitCode = 2;
+      return;
+    }
+    throw error;
+  }
+  let kit;
+  try {
+    const host = resolveHost(settings.dshPath);
+    logDebug(`harness host: ${host.base} via ${host.source} (${host.version ?? "unknown version"})`);
+    kit = await loadKit(host);
+  } catch (error) {
+    if (error instanceof HarnessNotFoundError) {
+      logError(error.message);
+      process.exitCode = 1;
+      return;
+    }
+    throw error;
+  }
+  const ctx = new kit.cordis.Context();
+  await ctx.plugin(app_exports, { settings, kit });
+  let disposing = false;
+  const shutdown = (code) => {
+    if (disposing) return;
+    disposing = true;
+    void ctx.fiber.dispose().catch((error) => {
+      logError(`teardown failed: ${String(error)}`);
+    }).finally(() => {
+      process.exit(code);
+    });
+  };
+  process.stdin.on("end", () => shutdown(0));
+  process.stdin.on("close", () => shutdown(0));
+  process.on("SIGINT", () => shutdown(130));
+  process.on("SIGTERM", () => shutdown(143));
+}
+main().catch((error) => {
+  logError(error instanceof Error ? error.stack ?? error.message : String(error));
+  process.exit(1);
+});