@harness-mix/cli 0.1.3

package/src/main/adapters/dsh-web-host.js

@@ -0,0 +1,202 @@
+const { spawn } = require("node:child_process");
+const os = require("node:os");
+const path = require("node:path");
+const { terminateTree } = require("../native/process-utils");
+
+const DSH_ROOT = process.env.HARNESS_MIX_DSH_ROOT || (process.platform === 'win32' ? "E:\\dsh\\deepseek-harness" : null);
+
+/**
+ * DSH Web Remote 宿主管理器（协议见 packages/api/gateway + client/connection）：
+ * - 惰性拉起单个 `dsh web --no-open --port 0` 进程，全部会话共享（引用计数释放）。
+ * - 认证：GET /?token → 303 Set-Cookie，之后所有请求原样回放 Cookie（authority 绑定）。
+ * - 一元调用：POST /api/<namespace>/<method>，信封 { type:'client-request', rpcId, method, payload:{ args } }。
+ * - 流：WS /api/remote.mux，逻辑流帧 { type:'open'|'cancel' } / { type:'item'|'end'|'error' }。
+ * - 转发事件：$events 流（emit 通知 + waterfall 请求应答，应答走 POST /api/$events/result）。
+ * 信任边界：只发 loopback Host，不发 Origin/sec-fetch-site（DSH 信任栅栏要求）。
+ */
+class DshWebHost {
+  static #shared = null;
+  static #refs = 0;
+  static #starting = null;
+  static #stopping = null;
+
+  /** 获取共享宿主（必要时拉起）。配对调用 release()。 */
+  static async acquire(diagnostic = () => {}) {
+    if (DshWebHost.#stopping) await DshWebHost.#stopping;
+    if (!DshWebHost.#shared && !DshWebHost.#starting) {
+      DshWebHost.#starting = (async () => {
+        const host = new DshWebHost(diagnostic);
+        try { await host.#start(); DshWebHost.#shared = host; }
+        catch (error) { await host.stop(); throw error; }
+      })().finally(() => { DshWebHost.#starting = null; });
+    }
+    if (DshWebHost.#starting) await DshWebHost.#starting;
+    DshWebHost.#refs++;
+    return DshWebHost.#shared;
+  }
+
+  static async release() {
+    DshWebHost.#refs = Math.max(0, DshWebHost.#refs - 1);
+    if (DshWebHost.#refs === 0 && DshWebHost.#shared) {
+      const host = DshWebHost.#shared;
+      DshWebHost.#shared = null;
+      const stopping = host.stop();
+      DshWebHost.#stopping = stopping;
+      try { await stopping; }
+      finally { if (DshWebHost.#stopping === stopping) DshWebHost.#stopping = null; }
+    }
+  }
+
+  constructor(diagnostic) {
+    this.diagnostic = diagnostic;
+    this.base = null;
+    this.cookie = null;
+    this.rpcSeq = 1;
+    this.ws = null;
+    this.streams = new Map(); // streamId -> { onItem, onEnd, onError }
+    this.clientId = null;
+    this.eventListeners = new Set(); // $events 帧监听（waterfall/emit）
+    this.child = null;
+  }
+
+  async #start() {
+    if (!DSH_ROOT) throw new Error('Set HARNESS_MIX_DSH_ROOT to the DeepSeek Harness checkout for web mode');
+    const child = spawn(process.platform === 'win32' ? 'cmd.exe' : 'npm', process.platform === 'win32'
+      ? ["/d", "/s", "/c", "npm.cmd run dsh -- web --no-open --port 0"] : ['run', 'dsh', '--', 'web', '--no-open', '--port', '0'], {
+      cwd: DSH_ROOT, windowsHide: true, stdio: ["ignore", "pipe", "pipe"],
+    });
+    this.child = child;
+    child.stderr.on("data", (chunk) => {
+      const line = String(chunk).trim();
+      if (line) this.diagnostic(`[dsh-web] ${line.slice(0, 240)}`);
+    });
+    const url = await new Promise((resolve, reject) => {
+      let buf = "";
+      const timer = setTimeout(() => reject(new Error(`dsh web 启动超时：${buf.slice(-300) || "无输出"}`)), 120_000);
+      const onData = (chunk) => {
+        buf += chunk;
+        const match = buf.match(/dsh web: (http:\/\/\S+)/);
+        if (match) { clearTimeout(timer); child.stdout.off("data", onData); resolve(match[1]); }
+      };
+      child.stdout.on("data", onData);
+      child.on("error", (e) => { clearTimeout(timer); reject(e); });
+      child.on("exit", (code) => { clearTimeout(timer); reject(new Error(`dsh web 进程退出（${code}）`)); });
+    });
+    child.stdout.on("data", () => {}); // 持续排空，防止管道写满阻塞
+    this.base = new URL(url).origin;
+
+    // 认证交换：GET /?token=… → 303 + Set-Cookie（原样回放，绝不自行构造）
+    const res = await fetch(url, { redirect: "manual" });
+    const setCookie = res.headers.getSetCookie?.()[0] ?? res.headers.get("set-cookie");
+    const cookie = setCookie?.split(";")[0];
+    if (res.status !== 303 || !cookie) throw new Error(`dsh web 认证失败（HTTP ${res.status}）`);
+    this.cookie = cookie;
+
+    // WS mux + $events 流
+    await this.#openMux();
+    await this.#openEvents();
+  }
+
+  async #openMux() {
+    const ws = new WebSocket(`${this.base.replace(/^http/, "ws")}/api/remote.mux`, { headers: { cookie: this.cookie } });
+    await new Promise((resolve, reject) => {
+      ws.onopen = resolve;
+      ws.onerror = () => reject(new Error("dsh web WebSocket 连接失败"));
+    });
+    this.ws = ws;
+    ws.onmessage = (e) => {
+      let msg;
+      try { msg = JSON.parse(e.data); } catch { return; }
+      const stream = this.streams.get(msg.streamId);
+      if (!stream) return;
+      if (msg.type === "item") stream.onItem?.(msg.value);
+      else if (msg.type === "end") stream.onEnd?.();
+      else if (msg.type === "error") {
+        const error = new Error(msg.error?.message ?? "Remote 流错误");
+        error.code = msg.error?.code;
+        stream.onError?.(error);
+      }
+    };
+    ws.onclose = () => {
+      const error = new Error("dsh web 连接已断开");
+      for (const stream of this.streams.values()) stream.onError?.(error);
+      this.streams.clear();
+      for (const listener of this.eventListeners) listener({ type: "closed" });
+    };
+  }
+
+  #openEvents() {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("$events 流就绪超时")), 30_000);
+      this.openStream("$events", {}, {
+        onItem: (value) => {
+          if (value?.type === "ready") {
+            this.clientId = value.clientId;
+            clearTimeout(timer);
+            resolve();
+            return;
+          }
+          for (const listener of this.eventListeners) listener(value);
+        },
+        onError: (error) => { clearTimeout(timer); reject(error); },
+      });
+    });
+  }
+
+  /** 一元 Remote 调用 → result.value（业务错误抛出带 code 的 Error） */
+  async call(method, args = {}) {
+    const res = await fetch(`${this.base}/api/${method}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", cookie: this.cookie },
+      body: JSON.stringify({ type: "client-request", rpcId: String(this.rpcSeq++), method, payload: { args } }),
+    });
+    const text = await res.text();
+    let body;
+    try { body = JSON.parse(text); } catch { throw new Error(`dsh web HTTP ${res.status}: ${text.slice(0, 200)}`); }
+    const result = body.result ?? body;
+    if (result.ok === false) {
+      const error = new Error(result.error?.message ?? "Remote 调用失败");
+      error.code = result.error?.code;
+      throw error;
+    }
+    return result.value;
+  }
+
+  /** 打开逻辑流；返回 cancel()。onItem(value) 逐帧回调。 */
+  openStream(endpoint, args, handlers) {
+    const streamId = `s${this.rpcSeq++}-${Math.random().toString(36).slice(2, 8)}`;
+    this.streams.set(streamId, {
+      ...handlers,
+      onError: (error) => { this.streams.delete(streamId); handlers.onError?.(error); },
+      onEnd: () => { this.streams.delete(streamId); handlers.onEnd?.(); },
+    });
+    this.ws.send(JSON.stringify({ type: "open", streamId, endpoint, payload: { args } }));
+    return () => {
+      this.streams.delete(streamId);
+      try { this.ws.send(JSON.stringify({ type: "cancel", streamId })); } catch { /* 已断开 */ }
+    };
+  }
+
+  /** 订阅 $events 帧（waterfall / emit / closed） */
+  onEvent(listener) {
+    this.eventListeners.add(listener);
+    return () => this.eventListeners.delete(listener);
+  }
+
+  /** 应答 waterfall（审批/提问）：outcome = { kind:'result', value } | { kind:'next' } | { kind:'rejected', error } */
+  async answerWaterfall(eventId, outcome) {
+    await this.call("$events/result", { clientId: this.clientId, eventId, outcome });
+  }
+
+  async stop() {
+    for (const listener of this.eventListeners) listener({ type: "closed" });
+    this.eventListeners.clear();
+    try { this.ws?.close(); } catch { /* 已关闭 */ }
+    const child = this.child;
+    this.child = null;
+    // cmd.exe → npm → node 进程树需要整树终止
+    if (child && !child.killed) void terminateTree(child.pid);
+  }
+}
+
+module.exports = { DshWebHost, DSH_ROOT };

package/src/main/adapters/dsh.js

@@ -0,0 +1,446 @@
+const { randomUUID } = require("node:crypto");
+const { promises: fs } = require("node:fs");
+const path = require("node:path");
+const { DshWebHost, DSH_ROOT } = require("./dsh-web-host");
+const { recordNative } = require("../harness-adapter/fixture-recorder");
+const { nativeAcp } = require('./native-acp');
+const { cliSpawn } = require('../host/jsonl');
+
+const manifest = {
+  id: "dsh",
+  name: "DeepSeek Harness",
+  icon: "deepseek-color.svg",
+  aliases: ["dsh", "deepseek-harness"],
+  // 完整接入（对齐 codex-host）：官方 Web Remote 协议（Typert RPC + remote.mux 流），
+  // 审批/提问走 $events waterfall 原生应答；ACP 自动化面（无 fork/提问/plan）已弃用。
+  capabilities: { collaborationTools: true, plan: true, streaming: true, thinking: true, tools: true, approvals: true, questions: true, models: true, thinkingLevels: true, permissionModes: false, resume: true, fork: true, forkFromMessage: true, compaction: true, usage: true, contextUsage: true, attachments: true },
+};
+
+const MAX_TOOL_TEXT = 24_000;
+
+function textValue(value) {
+  if (value == null) return undefined;
+  if (typeof value === "string") return value.slice(0, MAX_TOOL_TEXT);
+  try { return JSON.stringify(value, null, 2).slice(0, MAX_TOOL_TEXT); }
+  catch { return String(value).slice(0, MAX_TOOL_TEXT); }
+}
+
+/** ToolResultMessage → 首个 tool-result 块（callId/文本/isError） */
+function toolResultBlock(message) {
+  const block = (Array.isArray(message?.content) ? message.content : []).find((b) => b?.type === "tool-result");
+  if (!block) return undefined;
+  const text = (Array.isArray(block.content) ? block.content : [])
+    .map((c) => (c?.type === "text" ? c.text : c?.text)).filter(Boolean).join("\n").trim();
+  return { toolCallId: block.toolCallId ?? message?.source?.callId, text: text ? text.slice(0, MAX_TOOL_TEXT) : undefined, isError: Boolean(block.isError) };
+}
+
+function summarizeArguments(raw) {
+  if (typeof raw !== "string" || !raw) return "";
+  try {
+    const input = JSON.parse(raw);
+    const value = input.command ?? input.file_path ?? input.path ?? input.pattern ?? input.description ?? Object.values(input)[0];
+    return typeof value === "string" ? value.split("\n")[0].slice(0, 120) : "";
+  } catch { return raw.split("\n")[0].slice(0, 120); }
+}
+
+function flattenCatalog(catalog) {
+  const models = [];
+  for (const group of catalog?.groups ?? []) {
+    for (const model of group.models ?? []) {
+      models.push({
+        id: model.id, name: model.name || model.id, provider: group.id, description: model.description,
+        efforts: Array.isArray(model.reasoning?.efforts) ? model.reasoning.efforts.map((e) => ({ id: e.id, label: e.name || e.id, hint: e.description })) : undefined,
+        defaultEffort: model.reasoning?.defaultEffort,
+      });
+    }
+  }
+  return models;
+}
+
+function selectionOf(projections) {
+  const value = projections?.values?.modelSelection;
+  const current = value?.next ?? value?.lastUsed;
+  return current ? { provider: current.provider, model: current.model, reasoningEffort: current.reasoningEffort } : undefined;
+}
+
+/**
+ * SessionWireEvent（session/follow 帧）→ 统一事件投影（纯映射，运行时与 fixture 回放共用）。
+ * session 参数用于跨事件积累（上下文窗口、检查点 seq），投影本身不写 Host 状态。
+ */
+function projectWireEvent(frame, session) {
+  const out = [];
+  const enrich = (value) => ({ ...value, nativeRef: { sessionId: session?.nativeSessionId, ...(value.toolCallId ? { toolCallId: value.toolCallId } : {}), ...(value.nativeRef ?? {}) } });
+  if (!frame || frame.type !== "event") return out;
+  const event = frame.event;
+  const data = event?.data ?? {};
+  const base = { seq: event.seq };
+  switch (event?.type) {
+    case "assistant/chunk": {
+      const chunk = data.chunk;
+      if (!chunk) break;
+      if (chunk.type === "text-delta" && chunk.text) {
+        if (session?.state?.turn) session.state.turn.answer = (session.state.turn.answer || '') + chunk.text;
+        out.push({ kind: "text-delta", text: chunk.text });
+      }
+      else if (chunk.type === "reasoning-delta" && chunk.text) out.push({ kind: "thinking-delta", text: chunk.text });
+      else if (chunk.type === "usage" && chunk.usage) {
+        const usage = usageFrom(chunk.usage, session?.state?.contextWindow);
+        if (usage) out.push({ kind: "usage", usage });
+      }
+      break;
+    }
+    // 正常情况下 chunk 已投影文本；若 Web Remote 丢失 chunk，则从已提交消息补齐未见后缀。
+    case "assistant/message": {
+      if (session) session.state.checkpointSeq = event.seq;
+      const answer = (Array.isArray(data.message?.content) ? data.message.content : [])
+        .filter(block => block?.type === 'text').map(block => block.text || '').join('\n');
+      const streamed = session?.state?.turn?.answer || '';
+      if (session?.state?.turn && answer && answer !== streamed) out.push({ kind: "text-delta", text: answer.startsWith(streamed) ? answer.slice(streamed.length) : answer });
+      if (session?.state?.turn && answer) session.state.turn.answer = answer;
+      if (data.message?.stopReason === 'error' || data.message?.errorMessage) out.push({ kind: 'error', message: data.message.errorMessage || 'DSH native model turn failed' });
+      const usage = usageFrom(data.usage, session?.state?.contextWindow);
+      if (usage) out.push({ kind: "usage", usage });
+      break;
+    }
+    case "tool/call":
+      out.push({ kind: "tool", toolCallId: data.callId, title: data.name || "DSH 工具", state: "running", detail: summarizeArguments(data.arguments), input: textValue(data.arguments) });
+      break;
+    case "tool/result": {
+      const result = toolResultBlock(data.message);
+      out.push({
+        kind: "tool", toolCallId: result?.toolCallId, state: (data.error || result?.isError) ? "error" : "done",
+        output: result?.text ?? (data.error ? `${data.error.name}: ${data.error.code}` : undefined),
+      });
+      break;
+    }
+    case "request/context":
+      if (session && Number.isFinite(data.contextWindow)) session.state.contextWindow = data.contextWindow;
+      if (data.model) {
+        const model = { id: data.model, name: data.model, provider: data.provider };
+        if (session) {
+          session.state.selection = { provider: data.provider, model: data.model, reasoningEffort: session.state.selection?.reasoningEffort };
+          session.model = model;
+        }
+        out.push({ kind: "session", model });
+      }
+      break;
+    case "model/selection":
+      if (data.selection ?? data.next) {
+        const sel = data.selection ?? data.next;
+        if (session) session.state.selection = { provider: sel.provider, model: sel.model, reasoningEffort: sel.reasoningEffort };
+        out.push({ kind: "session", model: { id: sel.model, name: sel.model, provider: sel.provider } });
+      }
+      break;
+    case "todo/write":
+      out.push({ kind: "plan", entries: data.todos ?? data.entries ?? [] });
+      break;
+    case "compaction/start":
+      out.push({ kind: "status", text: "DSH 正在压缩上下文…" });
+      break;
+    case "compaction/end":
+    case "compaction/summary":
+      out.push({ kind: "status", text: "DSH 上下文压缩完成。" });
+      break;
+    case "turn/end": {
+      const reason = data.reason?.kind ?? "completed";
+      if (reason === "error" || data.reason?.error) out.push({ kind: "error", message: data.reason?.error?.message ?? data.reason?.message ?? "DSH 回合失败" });
+      out.push({
+        kind: "completed",
+        finalAnswer: reason === "completed",
+        stopReason: reason === "interrupted" || reason === "cancelled" ? "cancelled" : "completed",
+        ...(session?.state?.checkpointSeq != null ? { nativeRef: { checkpointId: String(session.state.checkpointSeq) } } : {}),
+      });
+      break;
+    }
+    default:
+      break;
+  }
+  return out.map((mapped) => enrich({ ...base, ...mapped, nativeRef: { ...mapped.nativeRef } }));
+}
+
+function usageFrom(usage, contextWindow) {
+  if (!usage) return undefined;
+  const tokens = (usage.inputTokens ?? 0) + (usage.cacheReadTokens ?? 0) || null;
+  const window = contextWindow ?? 64_000;
+  if (!tokens && !window) return undefined;
+  return { tokens, contextWindow: window, contextPercent: tokens && window ? 100 * tokens / window : null };
+}
+
+/** approval/request waterfall → Host 审批卡片 */
+function projectApproval(frame, sessionId) {
+  const request = frame.request ?? {};
+  return {
+    kind: "approval", requestId: `dsh-${frame.eventId}`,
+    title: `${request.toolName ?? "工具"} 请求权限`,
+    message: request.reason,
+    options: [
+      { id: "allowed-once", label: "允许" },
+      { id: "rejected", label: "拒绝", kind: "reject" },
+    ],
+    nativeRef: { sessionId, interactionId: String(frame.eventId) },
+  };
+}
+
+/** user-questions/request waterfall → 提问卡片（首个问题；多问题 v1 顺序展示第一题） */
+function projectQuestion(frame, sessionId) {
+  const question = (Array.isArray(frame.request?.questions) ? frame.request.questions : [])[0] ?? {};
+  const options = Array.isArray(question.options) ? question.options : [];
+  return {
+    kind: "approval", requestId: `dsh-${frame.eventId}`,
+    method: options.length ? undefined : "input",
+    title: question.header || question.question || "DSH 提问",
+    message: question.detail ?? (options.length ? question.question : undefined),
+    placeholder: options.length ? undefined : "请输入…",
+    options: options.map((o) => ({ id: String(o.label), label: String(o.label), hint: o.description })),
+    nativeRef: { sessionId, interactionId: String(frame.eventId) },
+  };
+}
+
+/** DeepSeek Harness Adapter：dsh web（Web Remote）常驻宿主，会话/工具/权限全归原生 DSH */
+function create() {
+  const web = {
+    manifest,
+
+    async inspect() {
+      try {
+        const pkg = JSON.parse(await fs.readFile(path.join(DSH_ROOT, "package.json"), "utf8"));
+        if (typeof pkg.scripts?.dsh !== "string") throw new Error("根 package.json 未声明 dsh 脚本");
+        await fs.stat(path.join(DSH_ROOT, "node_modules"));
+        return { available: true, detail: `原生 Web Remote · ${DSH_ROOT}` };
+      } catch (error) {
+        return { available: false, detail: `DSH 原生运行时不可用（${DSH_ROOT}）：${error.message}；可用 HARNESS_MIX_DSH_ROOT 指定` };
+      }
+    },
+
+    async open({ thread, emit: emitEvent, diagnostic }) {
+      const host = await DshWebHost.acquire(diagnostic);
+      const session = {
+        host,
+        nativeSessionId: thread.restore ? thread.nativeSessionId : undefined,
+        cwd: thread.cwd,
+        model: undefined,
+        models: undefined,
+        thinkingLevels: undefined,
+        pendingApprovals: new Map(),
+        // runtime 浅拷贝 session：泵写入的可变状态放共享 state 容器
+        state: { turn: null, usage: undefined, contextWindow: undefined, checkpointSeq: undefined, selection: undefined },
+        unwatch: undefined,
+        cancelFollow: undefined,
+      };
+
+      const failTurn = (error) => {
+        if (session.state.turn) { session.state.turn.reject(error); session.state.turn = null; }
+        for (const pending of session.pendingApprovals.values()) pending.reject(error);
+        session.pendingApprovals.clear();
+      };
+
+      // restore：直接 follow 既有原生会话；否则 session/create 新建
+      if (!session.nativeSessionId) {
+        const created = await host.call("session/create", { request: { cwd: thread.cwd } });
+        session.nativeSessionId = created.sessionId;
+      }
+      const sessionId = session.nativeSessionId;
+
+      // 审批/提问 waterfall 路由（agentId = sessionId）
+      session.unwatch = host.onEvent((frame) => {
+        if (frame?.type === "closed") { failTurn(new Error("dsh web 连接已断开")); return; }
+        if (frame?.type !== "waterfall" || frame.agentId !== sessionId) return;
+        recordNative(manifest.id, frame);
+        const requestId = `dsh-${frame.eventId}`;
+        const isQuestion = frame.event === "user-questions/request";
+        if (frame.event !== "approval/request" && !isQuestion) return;
+        emitEvent(isQuestion ? projectQuestion(frame, sessionId) : projectApproval(frame, sessionId));
+        session.pendingApprovals.set(requestId, { eventId: frame.eventId, isQuestion, question: frame.request?.questions?.[0] });
+      });
+
+      // 会话跟随流：快照（投影基线）+ 实时事件
+      let snapshotSeen;
+      const snapshotReady = new Promise((resolve) => { snapshotSeen = resolve; });
+      session.cancelFollow = host.openStream("session/follow", {
+        request: { address: { kind: "session", sessionId } },
+      }, {
+        onItem: (value) => {
+          recordNative(manifest.id, value);
+          if (value?.type === "snapshot") {
+            const sel = selectionOf(value.projections);
+            if (sel) {
+              session.state.selection = sel;
+              session.model = { id: sel.model, name: sel.model, provider: sel.provider };
+              emitEvent({ kind: "session", nativeSessionId: sessionId, model: session.model });
+            } else {
+              emitEvent({ kind: "session", nativeSessionId: sessionId });
+            }
+            snapshotSeen();
+            return;
+          }
+          for (const mapped of projectWireEvent(value, session)) {
+            emitEvent(mapped);
+            if (mapped.kind === "completed") {
+              session.state.turn?.resolve();
+              session.state.turn = null;
+            }
+          }
+        },
+        onError: (error) => {
+          failTurn(error);
+          emitEvent({ kind: "error", message: `DSH 会话流中断：${error.message}` });
+        },
+      });
+
+      // 等首帧快照，让 open() 返回时即带有原生模型选择（超时无害，快照后续仍会到达）
+      await Promise.race([snapshotReady, new Promise((r) => setTimeout(r, 15_000))]);
+
+      // 草稿期选择的模型/思考档位：经原生 selectModel 应用（失败静默）
+      const wanted = thread.options?.model;
+      const current = session.state.selection;
+      if (wanted?.provider && wanted.id && (wanted.provider !== current?.provider || wanted.id !== current?.model)) {
+        await host.call("session/selectModel", { request: { sessionId, provider: wanted.provider, model: wanted.id, reasoningEffort: thread.options.thinking } }).catch(() => {});
+      } else if (thread.options?.thinking && current?.provider) {
+        await host.call("session/selectModel", { request: { sessionId, provider: current.provider, model: current.model, reasoningEffort: thread.options.thinking } }).catch(() => {});
+      }
+      return session;
+    },
+
+    async send(session, text, hooks, attachments) {
+      // 官方 slash 命令通道：/compact 由 commands/execute 原生执行（同 DSH Web UI），不进模型
+      if (text.trim() === "/compact" && hooks?.emit) return this.executeCommand(session, "compact", hooks);
+      // Web Remote：prompt 立即 accepted；回合结算以 turn/end 事件为准；图片走原生 PromptContentPart
+      const content = [
+        ...(text ? [{ type: "text", text }] : []),
+        ...(attachments?.images ?? []).map((a) => ({ type: "image", mediaType: a.mime, data: a.data, name: a.name })),
+      ];
+      await new Promise((resolve, reject) => {
+        session.state.turn = { resolve, reject, answer: '' };
+        session.host.call("session/prompt", {
+          request: { requestId: randomUUID(), sessionId: session.nativeSessionId, mode: "queue", content },
+        }).catch((error) => {
+          session.state.turn = null;
+          reject(error);
+        });
+      });
+    },
+
+    async cancel(session) {
+      await session.host.call("session/cancel", { request: { sessionId: session.nativeSessionId } }).catch(() => {});
+    },
+
+    async listCommands() {
+      return [{ id: "compact", label: "压缩上下文", description: "由 DSH 原生总结并压缩当前会话", action: "execute" }];
+    },
+    async executeCommand(session, id, { emit }) {
+      if (id !== "compact") throw new Error("未知 DSH 指令");
+      const execution = await session.host.call("commands/execute", { agentId: session.nativeSessionId, line: "/compact", images: [] });
+      if (execution?.result?.kind === "error") throw new Error(execution.result.text ?? "DSH 压缩失败");
+      emit({ kind: "text-delta", text: execution?.result?.text || "上下文已由 DSH 压缩。" });
+      emit({ kind: "completed", finalAnswer: true });
+    },
+
+    async listModelsFor(session) {
+      const catalog = await session.host.call("session/modelCatalog", {});
+      session.models = flattenCatalog(catalog);
+      return session.models;
+    },
+
+    async describe() {
+      const host = await DshWebHost.acquire(() => {});
+      try {
+        const catalog = await host.call("session/modelCatalog", {});
+        const models = flattenCatalog(catalog);
+        const current = models.find((m) => m.provider === catalog.default?.provider && m.id === catalog.default?.model) ?? models[0];
+        return { models, thinkingLevels: current?.efforts ?? null, permissionModes: [] };
+      } finally {
+        DshWebHost.release();
+      }
+    },
+
+    async describeFor(session) {
+      const models = await this.listModelsFor(session);
+      const current = models?.find((m) => m.provider === session.state?.selection?.provider && m.id === session.state?.selection?.model)
+        ?? models?.find((m) => m.id === session.model?.id);
+      return { models, thinkingLevels: current?.efforts ?? null, permissionModes: [] };
+    },
+
+    async setModel(session, model) {
+      await session.host.call("session/selectModel", {
+        request: { sessionId: session.nativeSessionId, provider: model.provider, model: model.id, reasoningEffort: session.state?.selection?.reasoningEffort },
+      });
+      session.model = { id: model.id, name: model.name ?? model.id, provider: model.provider };
+      session.state.selection = { provider: model.provider, model: model.id, reasoningEffort: session.state?.selection?.reasoningEffort };
+      return session.model;
+    },
+
+    async setThinkingLevel(session, level) {
+      const sel = session.state?.selection ?? session.model;
+      if (!sel?.provider) throw new Error("DSH 当前模型未知，无法设置思考档位");
+      await session.host.call("session/selectModel", {
+        request: { sessionId: session.nativeSessionId, provider: sel.provider, model: sel.model ?? sel.id, reasoningEffort: level },
+      });
+      session.state.selection = { provider: sel.provider, model: sel.model ?? sel.id, reasoningEffort: level };
+    },
+
+    async getContextUsage(session) { return session.state?.usage; },
+
+    /** 审批/提问应答：$events/result 原生回执 */
+    async respond(session, requestId, response) {
+      const pending = session.pendingApprovals.get(requestId);
+      if (!pending) return;
+      session.pendingApprovals.delete(requestId);
+      let outcome;
+      if (pending.isQuestion) {
+        const answer = response?.optionId ?? response?.value;
+        outcome = response?.cancelled
+          ? { kind: "rejected", error: { name: "Error", message: "用户取消" } }
+          : { kind: "result", value: { answers: [{ id: pending.question?.id ?? "question", selected: answer != null && pending.question?.options?.length ? [String(answer)] : [], ...(answer != null && !pending.question?.options?.length ? { custom: String(answer) } : {}) }] } };
+      } else {
+        const value = response?.cancelled ? "cancelled" : response?.optionId ?? (response?.confirmed === false ? "rejected" : "allowed-once");
+        outcome = { kind: "result", value };
+      }
+      await session.host.answerWaterfall(pending.eventId, outcome);
+    },
+
+    /** 任务 Fork：原生 session/fork（ACP 面不支持的能力），atSeq 定位分支边界 */
+    async fork(source, { emit, diagnostic, message }) {
+      const host = await DshWebHost.acquire(diagnostic);
+      try {
+        const atSeq = message?.coreTurn?.nativeTurnRef?.checkpointId;
+        const request = { sessionId: source.nativeSessionId };
+        if (atSeq != null) request.atSeq = Number(atSeq);
+        const result = await host.call("session/fork", { request });
+        // 新会话立即建立跟随流（与 open() 同路径），交由 runtime 登记
+        const session = await this.open({ thread: { cwd: source.cwd, restore: true, nativeSessionId: result.sessionId, options: source.options }, emit, diagnostic });
+        return { session };
+      } finally {
+        DshWebHost.release();
+      }
+    },
+
+    async close(session) {
+      for (const pending of session.pendingApprovals?.values() ?? []) pending.reject(new Error("会话已关闭"));
+      session.pendingApprovals?.clear();
+      try { session.cancelFollow?.(); } catch { /* 已断开 */ }
+      try { session.unwatch?.(); } catch { /* 已断开 */ }
+      await DshWebHost.release();
+    },
+  };
+  // Lead sessions use DSH's official ACP profile because it accepts session-scoped
+  // MCP declarations. Worker/direct sessions retain the richer Web Remote surface.
+  const acp = nativeAcp({
+    id: 'dsh', name: 'DeepSeek Harness', args: [],
+    command: argv => cliSpawn('npm', ['--prefix', DSH_ROOT, 'run', 'dsh', '--', '--profile', 'acp', ...argv]),
+    capabilities: { attachments: true, fork: false, compaction: false, permissionModes: false },
+  }).create();
+  const openWeb = web.open.bind(web);
+  web.open = async context => {
+    if (!context.collaboration) return openWeb(context);
+    const session = await acp.open(context);
+    session.dshAcpLead = true;
+    return session;
+  };
+  for (const method of ['describeFor', 'listModelsFor', 'send', 'cancel', 'listCommands', 'executeCommand', 'setModel', 'setThinkingLevel', 'getContextUsage', 'respond', 'close']) {
+    const original = web[method]?.bind(web);
+    web[method] = (session, ...args) => session?.dshAcpLead ? acp[method](session, ...args) : original(session, ...args);
+  }
+  return web;
+}
+
+module.exports = { manifest, create, projectWireEvent, flattenCatalog };