harness-mix 0.1.0

package/src/main/adapters/openclaw.js

@@ -0,0 +1,337 @@
+const { execFile } = require("node:child_process");
+const { randomUUID } = require("node:crypto");
+const { cliSpawn } = require("../host/jsonl");
+const { OpenClawGatewayHost, readGatewayConfig } = require("./openclaw-gateway");
+const { recordNative } = require("../harness-adapter/fixture-recorder");
+
+// 静态思考档位仅作兜底；会话级权威目录来自 sessions.describe（thinkingLevels/thinkingDefault，随模型而变）
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "adaptive", "max"];
+const AGENT_TIMEOUT_MS = 600_000; // 与 openclaw agent --timeout 默认值一致
+
+const manifest = {
+  id: "openclaw",
+  name: "OpenClaw",
+  icon: "openclaw-color.svg",
+  aliases: ["openclaw"],
+  // 能力均按 Gateway 2026.5.12 实测声明；未逐字段验证的面（reasoning 流/plan/patch/图片）不声明。
+  // usage/contextUsage 取自 sessions.describe 的原生 token 统计与上下文窗口，不用累计输入量伪装。
+  capabilities: { streaming: true, thinking: false, tools: true, approvals: true, questions: false, models: true, thinkingLevels: true, permissionModes: false, resume: true, fork: false, forkFromMessage: false, compaction: false, usage: true, contextUsage: true, attachments: true },
+};
+
+const textOfContent = (result) => (result?.content ?? []).map((c) => (c?.type === "text" ? c.text : "")).filter(Boolean).join("\n");
+const stringifyArgs = (args) => {
+  if (args == null) return undefined;
+  if (typeof args === "string") return args;
+  try { return JSON.stringify(args, null, 2); } catch { return String(args); }
+};
+
+/**
+ * Gateway agent 广播事件（{runId, stream, data, sessionKey, seq, ts}）→ 统一事件投影。
+ * 纯映射（运行时与 fixture 回放共用）；session 仅用于跨事件累积（assistant 累计文本、生命周期错误）。
+ * item/plan/patch/approval/compaction 流形态未逐字段实测，v1 只投影已验证的流，不伪造。
+ */
+function projectAgentEvent(payload, session) {
+  const out = [];
+  if (!payload || typeof payload !== "object") return out;
+  const data = payload.data ?? {};
+  switch (payload.stream) {
+    case "assistant": {
+      let delta = typeof data.delta === "string" ? data.delta : "";
+      if (!delta && typeof data.text === "string") {
+        // 缺 delta 时按累计文本差分补齐
+        const last = session?.state?.lastAssistantText ?? "";
+        delta = data.text.startsWith(last) ? data.text.slice(last.length) : data.text;
+      }
+      if (typeof data.text === "string" && session) session.state.lastAssistantText = data.text;
+      if (delta) out.push({ kind: "text-delta", text: delta });
+      break;
+    }
+    case "tool": {
+      if (!data.toolCallId) break;
+      const title = data.meta ? `${data.name ?? "tool"} ${data.meta}` : (data.name ?? "tool");
+      if (data.phase === "start") {
+        out.push({ kind: "tool", toolCallId: data.toolCallId, title, state: "running", input: stringifyArgs(data.args) });
+      } else if (data.phase === "update") {
+        const output = textOfContent(data.partialResult);
+        if (output) out.push({ kind: "tool", toolCallId: data.toolCallId, title, state: "running", output });
+      } else if (data.phase === "result") {
+        out.push({ kind: "tool", toolCallId: data.toolCallId, title, state: data.isError ? "error" : "done", output: textOfContent(data.result) || (data.isError ? "原生工具执行失败" : undefined) });
+      }
+      break;
+    }
+    case "command_output": {
+      // 命令输出与工具卡片同一投影（toolCallId 归并）：delta 增量输出，end 携带退出码收尾
+      if (!data.toolCallId) break;
+      const title = data.title || data.name || "command";
+      if (data.phase === "delta") {
+        if (typeof data.output === "string" && data.output) out.push({ kind: "tool", toolCallId: data.toolCallId, title, state: "running", output: data.output });
+      } else if (data.phase === "end") {
+        out.push({ kind: "tool", toolCallId: data.toolCallId, title, state: data.status === "completed" ? "done" : "error", output: data.output, detail: data.exitCode != null ? `exit ${data.exitCode}` : undefined });
+      }
+      break;
+    }
+    case "lifecycle": {
+      if (session && data.phase === "error") session.state.lastError = typeof data.error === "string" ? data.error : data.error?.message;
+      break;
+    }
+    default:
+      break;
+  }
+  return out;
+}
+
+/** exec/plugin 审批请求广播 → 统一 approval 事件 */
+function projectApproval(eventName, payload, sessionKey) {
+  const id = String(payload?.id ?? "");
+  const request = payload?.request ?? {};
+  const isPlugin = eventName.startsWith("plugin.") || id.startsWith("plugin:");
+  const lines = [];
+  if (request.command) lines.push(`\`${request.command}\``);
+  if (request.cwd) lines.push(`工作目录：${request.cwd}`);
+  if (request.ask) lines.push(`原因：${request.ask}`);
+  return {
+    kind: "approval",
+    requestId: `openclaw-${id}`,
+    title: isPlugin ? "插件权限审批" : "命令执行审批",
+    message: lines.join("\n") || undefined,
+    options: [
+      { id: "allowed-once", label: "允许一次" },
+      { id: "allowed-always", label: "始终允许" },
+      { id: "rejected", label: "拒绝", kind: "reject" },
+    ],
+    nativeRef: { sessionId: sessionKey, interactionId: id },
+  };
+}
+
+/** sessions.describe 行 → 会话状态（生效模型、思考档位目录与当前值、原生用量）。字段随 turn 推进逐渐齐备。 */
+function applySessionDescription(session, row) {
+  if (!row || typeof row !== "object") return;
+  if (Array.isArray(row.thinkingLevels) && row.thinkingLevels.length) {
+    session.state.thinkingLevels = row.thinkingLevels.map((l) => ({ id: String(l.id ?? l), label: String(l.label ?? l.id ?? l) }));
+  }
+  if (typeof row.thinkingDefault === "string") session.state.thinkingDefault = row.thinkingDefault;
+  if (row.model) {
+    const id = row.modelProvider ? `${row.modelProvider}/${row.model}` : String(row.model);
+    session.model = session.models?.find((m) => m.id === id) ?? { id, name: String(row.model), provider: row.modelProvider };
+  }
+  if (Number.isFinite(row.totalTokens) && Number.isFinite(row.contextTokens) && row.contextTokens > 0) {
+    const usage = { tokens: row.totalTokens, contextWindow: row.contextTokens, contextPercent: Math.round((row.totalTokens / row.contextTokens) * 10000) / 100 };
+    if (typeof row.estimatedCostUsd === "number" && row.estimatedCostUsd > 0) usage.cost = row.estimatedCostUsd;
+    session.state.usage = usage;
+  }
+}
+
+/** 拉取并应用会话状态；返回是否有可用用量。 */
+async function refreshSessionState(session) {
+  const described = await session.host.call("sessions.describe", { key: session.nativeSessionId }).catch(() => null);
+  applySessionDescription(session, described?.session);
+  return session.state.usage;
+}
+function create() {
+  const adapter = {
+    manifest,
+
+    async inspect() {
+      const cli = cliSpawn("openclaw", ["--version"]);
+      const version = await new Promise((resolve) => execFile(cli.command, cli.args, { windowsHide: true, timeout: 10000 }, (error, out) => resolve(error ? null : out.trim())));
+      if (!version) return { available: false, detail: "OpenClaw CLI 不可用（npm i -g openclaw）" };
+      try {
+        const cfg = await readGatewayConfig();
+        return { available: true, detail: `${version} · Gateway 127.0.0.1:${cfg.port}` };
+      } catch (error) {
+        return { available: false, detail: `OpenClaw 配置不可读：${error.message}` };
+      }
+    },
+
+    async describe() {
+      // 全局模型目录：只读已有 Gateway（不为选择器拉起进程），不可达时交回空目录
+      try {
+        const host = await OpenClawGatewayHost.acquire(() => {}, { autostart: false });
+        try { return { models: await listModels(host), thinkingLevels: thinkingCatalog(), permissionModes: [] }; }
+        finally { await OpenClawGatewayHost.release(); }
+      } catch { return { models: null, thinkingLevels: [], permissionModes: [] }; }
+    },
+
+    async open({ thread, emit: emitEvent, diagnostic = () => {} }) {
+      const host = await OpenClawGatewayHost.acquire(diagnostic);
+      const session = {
+        host,
+        cwd: thread.cwd,
+        nativeSessionId: null,
+        state: { lastAssistantText: "", lastError: null, runId: null },
+        pendingApprovals: new Map(), // requestId -> approvalId
+        modelOverride: null,
+        thinkingOverride: null,
+        emit: emitEvent,
+        unwatch: null,
+      };
+
+      try {
+        // 新会话显式登记（携带工作目录与标题），恢复会话直接沿用原生 sessionKey
+        if (thread.restore && thread.nativeSessionId) {
+          session.nativeSessionId = thread.nativeSessionId;
+        } else {
+          const label = String(thread.title || "Harness Mix 任务").slice(0, 60);
+          const baseKey = `harness-mix-${thread.nativeSessionId || randomUUID()}`;
+          let created = await host.call("sessions.create", { key: baseKey, label, cwd: thread.cwd }).catch(() => null);
+          if (!created?.key) created = await host.call("sessions.create", { key: baseKey, label }).catch(() => null);
+          session.nativeSessionId = created?.key ?? `agent:main:${baseKey}`;
+        }
+
+        session.unwatch = host.onEvent((frame) => {
+          recordNative(manifest.id, frame);
+          if (frame?.type === "closed") {
+            for (const pending of session.pendingApprovals.values()) pending.reject?.(new Error("OpenClaw Gateway 连接已断开"));
+            session.pendingApprovals.clear();
+            return;
+          }
+          if (frame.type !== "event") return;
+          // agent 流：按 runId（本轮）或 sessionKey（本会话）归属
+          if (frame.event === "agent") {
+            const payload = frame.payload ?? {};
+            if (payload.runId !== session.state.runId && payload.sessionKey !== session.nativeSessionId) return;
+            for (const event of projectAgentEvent(payload, session)) emitEvent(event);
+            return;
+          }
+          // 审批广播：只归集显式携带本会话 sessionKey 的请求，不劫持其他客户端的审批
+          if (frame.event === "exec.approval.requested" || frame.event === "plugin.approval.requested") {
+            const payload = frame.payload ?? {};
+            if (payload.request?.sessionKey !== session.nativeSessionId) return;
+            const id = String(payload.id ?? "");
+            if (!id) return;
+            const projected = projectApproval(frame.event, payload, session.nativeSessionId);
+            session.pendingApprovals.set(projected.requestId, { approvalId: id });
+            emitEvent(projected);
+            return;
+          }
+          if (frame.event === "exec.approval.resolved" || frame.event === "plugin.approval.resolved") {
+            // 他端（如 OpenClaw 自有 UI）已处理的审批：同步收掉卡片
+            const requestId = `openclaw-${frame.payload?.id ?? ""}`;
+            if (session.pendingApprovals.delete(requestId)) emitEvent({ kind: "interaction-responded", requestId });
+          }
+        });
+
+        const models = await listModels(host).catch(() => []);
+        if (models.length) session.models = models;
+        // 生效模型/思考档位/用量以 sessions.describe 为准（恢复会话直接取到，新会话首个 turn 后齐备）
+        await refreshSessionState(session);
+        if (thread.options?.model) await adapter.setModel(session, thread.options.model);
+        if (thread.options?.thinking) await adapter.setThinkingLevel(session, thread.options.thinking);
+        emitEvent({ kind: "session", nativeSessionId: session.nativeSessionId, model: session.model });
+        return session;
+      } catch (error) {
+        try { session.unwatch?.(); } catch { /* 已断开 */ }
+        await OpenClawGatewayHost.release();
+        throw error;
+      }
+    },
+
+    async describeFor(session) {
+      const levels = session.state.thinkingLevels ?? thinkingCatalog();
+      // 原生 sessions.describe 上报的 thinkingDefault 即当前生效档，标记后由协议层作为安全预选秀下发
+      const marked = session.state.thinkingDefault
+        ? levels.map(l => ({ ...l, default: l.id === session.state.thinkingDefault }))
+        : levels;
+      return { models: session.models ?? null, thinkingLevels: marked, permissionModes: [] };
+    },
+
+    async listModelsFor(session) { return listModels(session.host); },
+
+    async send(session, text, hooks, attachments) {
+      const params = {
+        message: text,
+        sessionKey: session.nativeSessionId,
+        idempotencyKey: randomUUID(),
+        deliver: false, // 回复只走 Desktop 原生流，不向 OpenClaw 渠道投递
+      };
+      // 图片走 Gateway agent RPC 原生 attachments 字段：{ mimeType, content(base64), fileName }（协议 schema 见附件归一化实现）
+      const images = attachments?.images ?? [];
+      if (images.length) {
+        params.attachments = images.map((img) => ({
+          mimeType: img.mime || "image/png",
+          content: img.data,
+          fileName: img.name || undefined,
+        }));
+      }
+      if (session.modelOverride) params.model = session.modelOverride;
+      if (session.thinkingOverride) params.thinking = session.thinkingOverride;
+      const accepted = await session.host.call("agent", params);
+      if (accepted?.status === "in_flight") throw new Error("该会话已有进行中的原生任务，请稍候");
+      const runId = accepted?.runId;
+      if (!runId) throw new Error("OpenClaw Gateway 未返回 runId");
+      session.state.runId = runId;
+      session.state.lastAssistantText = "";
+      session.state.lastError = null;
+      try {
+        const result = await session.host.call("agent.wait", { runId, timeoutMs: AGENT_TIMEOUT_MS }, AGENT_TIMEOUT_MS + 30_000);
+        // turn 结束后回读原生会话状态：生效模型、思考目录、token 用量（真实统计，不用估计值冒充）
+        const modelBefore = session.model?.id;
+        await refreshSessionState(session);
+        if (session.state.usage) hooks.emit({ kind: "usage", usage: session.state.usage });
+        if (session.model && session.model.id !== modelBefore) hooks.emit({ kind: "session", nativeSessionId: session.nativeSessionId, model: session.model });
+        if (result?.status === "ok") { hooks.emit({ kind: "completed", finalAnswer: true }); return; }
+        if (result?.stopReason === "rpc") return; // 用户取消：runtime 已按取消结算
+        throw new Error(result?.error || session.state.lastError || `原生任务未正常结束（${result?.status ?? "未知"}）`);
+      } finally {
+        if (session.state.runId === runId) session.state.runId = null;
+      }
+    },
+
+    async cancel(session) {
+      const runId = session.state.runId;
+      await session.host.call("sessions.abort", runId ? { key: session.nativeSessionId, runId } : { key: session.nativeSessionId }).catch(() => {});
+    },
+
+    async respond(session, requestId, response) {
+      const pending = session.pendingApprovals.get(requestId);
+      if (!pending) throw new Error("未知或已过期的原生审批请求");
+      const decision = response?.confirmed === true || response?.optionId === "allowed-once" ? "allow-once"
+        : response?.optionId === "allowed-always" ? "allow-always"
+        : "deny"; // 拒绝/取消统一收敛为 deny，不替用户放行
+      const method = pending.approvalId.startsWith("plugin:") ? "plugin.approval.resolve" : "exec.approval.resolve";
+      await session.host.call(method, { id: pending.approvalId, decision });
+      session.pendingApprovals.delete(requestId);
+    },
+
+    async setModel(session, model) {
+      // Gateway 按 run 应用 model 覆盖（需 operator.admin，握手已声明）；逐轮生效，不写原生配置
+      session.modelOverride = model.id;
+      session.model = model;
+      return model;
+    },
+
+    async setThinkingLevel(session, level) {
+      const catalog = session.state.thinkingLevels?.map((l) => l.id) ?? THINKING_LEVELS;
+      if (!catalog.includes(level)) throw new Error(`OpenClaw 当前会话不支持思考档位 ${level}`);
+      session.thinkingOverride = level;
+    },
+
+    async getContextUsage(session) { return session.state.usage; },
+
+    async close(session) {
+      for (const pending of session.pendingApprovals.values()) pending.reject?.(new Error("会话已关闭"));
+      session.pendingApprovals.clear();
+      try { session.unwatch?.(); } catch { /* 已断开 */ }
+      await OpenClawGatewayHost.release();
+    },
+  };
+  return adapter;
+}
+
+/** models.list → 统一目录（id 带 provider 前缀，与 agent 的 model 覆盖参数同形） */
+async function listModels(host) {
+  const result = await host.call("models.list", {});
+  const rows = Array.isArray(result?.models) ? result.models : [];
+  return rows.filter((m) => m && m.id).map((m) => ({
+    id: m.provider ? `${m.provider}/${m.id}` : String(m.id),
+    name: m.name || String(m.id),
+    provider: m.provider,
+    description: m.contextWindow ? `上下文窗口 ${Math.round(m.contextWindow / 1000)}k` : undefined,
+  }));
+}
+
+function thinkingCatalog() {
+  return THINKING_LEVELS.map((id) => ({ id, label: id }));
+}
+
+module.exports = { manifest, create, projectAgentEvent, projectApproval, applySessionDescription, THINKING_LEVELS };

package/src/main/adapters/opencode-server.js

@@ -0,0 +1,72 @@
+const { spawn, execFile } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const { cliSpawn } = require('../host/jsonl');
+function executable(args) {
+  const local = process.env.HARNESS_MIX_OPENCODE_EXECUTABLE || path.join(process.env.APPDATA || '', 'npm/node_modules/opencode-ai/bin/opencode.exe');
+  return fs.existsSync(local) ? { command: local, args } : cliSpawn('opencode', args);
+}
+class OpenCodeServer {
+  constructor(cwd, options = {}) { this.cwd = cwd; this.env = options.env; this.controllers = new Set(); this.closed = false; }
+  async start() {
+    const cli = executable(['serve', '--hostname', '127.0.0.1', '--port', '0']);
+    this.child = spawn(cli.command, cli.args, { cwd: this.cwd, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'], ...(this.env ? { env: { ...process.env, ...this.env } } : {}) });
+    try {
+      this.url = await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('OpenCode Server startup timed out')), 30000);
+        let buffer = '';
+        const data = chunk => { buffer = (buffer + chunk).slice(-8192); const m = buffer.match(/http:\/\/127\.0\.0\.1:\d+/); if (m) { clearTimeout(timer); resolve(m[0]); } };
+        this.child.stdout.on('data', data); this.child.stderr.on('data', data);
+        this.child.once('error', error => { clearTimeout(timer); reject(error); });
+        this.child.once('exit', () => { clearTimeout(timer); reject(new Error('OpenCode Server exited')); });
+      });
+      return this;
+    } catch (error) { await this.close(); throw error; }
+  }
+  address(route) { const url = new URL(route, this.url); url.searchParams.set('directory', this.cwd); url.searchParams.set('location[directory]', this.cwd); return url; }
+  async request(method, route, body, timeout = 30000) {
+    if (this.closed) throw new Error('OpenCode Server is closed');
+    const controller = new AbortController(); this.controllers.add(controller);
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(this.address(route), { method, signal: controller.signal, headers: { 'content-type': 'application/json' }, ...(body === undefined ? {} : { body: JSON.stringify(body) }) });
+      if (!response.ok) throw new Error(`OpenCode ${method} ${route}: HTTP ${response.status}`);
+      return response.status === 204 ? null : await response.json();
+    } finally { clearTimeout(timer); this.controllers.delete(controller); }
+  }
+  async subscribe(onEvent, onError) {
+    const controller = new AbortController(); this.controllers.add(controller);
+    const timer = setTimeout(() => controller.abort(), 30000);
+    let response;
+    try { response = await fetch(this.address('/event'), { signal: controller.signal }); } finally { clearTimeout(timer); }
+    if (!response.ok || !response.body) throw new Error('OpenCode event stream unavailable');
+    const reader = response.body.getReader();
+    this.readerTask = (async () => {
+      const decoder = new TextDecoder(); let buffer = '';
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) { if (!this.closed) throw new Error('OpenCode event stream ended'); break; }
+          buffer += decoder.decode(value, { stream: true }).replace(/\r/g, '');
+          let boundary;
+          while ((boundary = buffer.indexOf('\n\n')) >= 0) {
+            const frame = buffer.slice(0, boundary); buffer = buffer.slice(boundary + 2);
+            const data = frame.split('\n').filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n');
+            if (data) onEvent(JSON.parse(data));
+          }
+        }
+      } catch (error) { if (!this.closed) onError(error); }
+      finally { reader.releaseLock(); this.controllers.delete(controller); }
+    })();
+  }
+  async close() {
+    this.closed = true;
+    for (const controller of this.controllers) controller.abort();
+    if (this.child && this.child.exitCode === null) {
+      if (process.platform === 'win32') await new Promise(resolve => execFile('taskkill.exe', ['/pid', String(this.child.pid), '/t', '/f'], { windowsHide: true }, () => resolve()));
+      else this.child.kill();
+    }
+    await this.readerTask;
+  }
+}
+module.exports = { OpenCodeServer, executable };

package/src/main/adapters/opencode.js

@@ -0,0 +1,166 @@
+const { execFile } = require('node:child_process');
+const { OpenCodeServer, executable } = require('./opencode-server');
+const manifest = { id: 'opencode', name: 'OpenCode', icon: 'opencode-color.svg', aliases: ['opencode'], capabilities: {
+  collaborationTools: true, streaming: true, thinking: true, tools: true, approvals: true, questions: true, models: true, thinkingLevels: true,
+  permissionModes: true, resume: true, fork: true, forkFromMessage: true, compaction: true, usage: true, contextUsage: false, attachments: true,
+} };
+const enc = encodeURIComponent;
+const route = (s, suffix = '') => `/session/${enc(s.nativeSessionId)}${suffix}`;
+function projectPart(session, part, emit) {
+  const state = session.state;
+  if (state.userMessages.has(part.messageID)) return;
+  if (part.type === 'text' || part.type === 'reasoning') {
+    const previous = state.text.get(part.id) || '', text = part.text || '';
+    if (text.startsWith(previous) && text.length > previous.length) emit({ kind: part.type === 'text' ? 'text-delta' : 'thinking-delta', text: text.slice(previous.length), nativeRef: { itemId: part.id } });
+    state.text.set(part.id, text);
+  } else if (part.type === 'tool') {
+    const tool = part.state;
+    emit({ kind: 'tool', toolCallId: part.callID, title: tool.title || part.tool, input: tool.input, output: tool.output || tool.error,
+      state: tool.status === 'completed' ? 'completed' : tool.status === 'error' ? 'error' : 'running', nativeRef: { itemId: part.id, toolCallId: part.callID } });
+  }
+}
+function askNext(session, id) {
+  const pending = session.state.questions.get(id), q = pending.questions[pending.index];
+  session.emit({ kind: 'approval', method: q.multiple || !q.options?.length ? 'input' : 'select', requestId: `${id}:${pending.index}`, title: q.header, message: q.question + (q.multiple ? '\n可多选，请以 JSON 数组填写选项名称。' : ''),
+    options: q.multiple ? undefined : q.options?.map(o => ({ id: o.label, label: o.label, description: o.description })) });
+}
+function projectEvent(session, event, emit) {
+  const p = event.properties || {};
+  if ((p.sessionID || p.part?.sessionID || p.info?.sessionID) !== session.nativeSessionId) return;
+  const state = session.state;
+  if (event.type === 'message.updated' && p.info?.role === 'user') state.userMessages.add(p.info.id);
+  if (!state.active) return;
+  if (event.type === 'message.part.updated') { state.parts.set(p.part.id, p.part); projectPart(session, p.part, emit); }
+  if (event.type === 'message.part.delta') {
+    const part = state.parts.get(p.partID);
+    if (part && p.field === 'text') { part.text = (part.text || '') + p.delta; projectPart(session, part, emit); }
+  }
+  if (event.type === 'session.diff') emit({ kind: 'file-change', source: 'native', changes: p.diff.filter(d => d.file && d.patch).map(d => ({ path: d.file, patch: d.patch, changeType: d.status || 'modified', complete: true })) });
+  if (event.type === 'permission.asked') {
+    state.permissions.set(p.id, p);
+    emit({ kind: 'approval', requestId: p.id, method: 'select', title: p.permission, message: (p.patterns || []).join('\n'),
+      options: [{ id: 'once', label: '允许一次' }, { id: 'always', label: '始终允许' }, { id: 'reject', label: '拒绝' }] });
+  }
+  if (event.type === 'question.asked') { state.questions.set(p.id, { ...p, index: 0, answers: [] }); askNext(session, p.id); }
+}
+function describeSession(s) {
+  const model = s.state.models.find(m => m.id === s.model?.id && m.provider === s.model?.provider);
+  return { models: s.state.models, thinkingLevels: (model?.efforts || []).map(id => ({ id, label: id })), permissionModes: s.state.agents.map(a => ({ id: a.name, label: a.name, description: a.description, default: a.name === s.state.agent })) };
+}
+function create() {
+  const adapter = {
+    async inspect() {
+      const cli = executable(['--version']);
+      return new Promise(resolve => execFile(cli.command, cli.args, { windowsHide: true, timeout: 10000 }, (error, stdout) => resolve({ available: !error, detail: error ? 'OpenCode Server CLI unavailable' : `OpenCode ${stdout.trim()} · native HTTP/SSE` })));
+    },
+    async describe() { return { models: null, thinkingLevels: [], permissionModes: [] }; },
+    async open({ thread, emit, collaboration }) {
+      // L2 注入：OPENCODE_CONFIG_CONTENT 是最高优先级的运行时内联配置，合并而非覆盖用户配置，会话结束即失效，不污染任何配置文件
+      const overlay = collaboration ? { env: { OPENCODE_CONFIG_CONTENT: JSON.stringify({ mcp: { servers: { 'harness-mix': { type: 'local', command: [collaboration.command, ...collaboration.args], environment: collaboration.env } } } }) } } : undefined;
+      const host = await new OpenCodeServer(thread.cwd, overlay).start();
+      try {
+        // Read the model catalog, never provider credentials or auth files.
+        const [catalog, agents] = await Promise.all([host.request('GET', '/api/model'), host.request('GET', '/agent')]);
+        const models = catalog.data.filter(m => m.enabled).map(m => ({ id: m.id, provider: m.providerID, name: m.name, contextWindow: m.limit.context, images: m.capabilities.input.includes('image'), efforts: m.variants.map(v => v.id) }));
+        const info = thread.restore ? await host.request('GET', `/session/${enc(thread.nativeSessionId)}`) : await host.request('POST', '/session', { title: thread.title });
+        const session = { host, emit, nativeSessionId: info.id, cwd: thread.cwd, collaborationEnabled: !!collaboration, model: info.model ? { id: info.model.id, provider: info.model.providerID } : undefined,
+          state: { active: false, agent: info.agent, models, agents: agents.filter(a => !a.hidden && a.mode !== 'subagent'), text: new Map(), parts: new Map(), userMessages: new Set(), permissions: new Map(), questions: new Map() } };
+        await host.subscribe(e => projectEvent(session, e, emit), error => { if (session.state.active) { void adapter.cancel(session).catch(() => {}); emit({ kind: 'error', message: error.message }); } });
+        if (thread.options?.model) await adapter.setModel(session, thread.options.model);
+        if (thread.options?.thinking) await adapter.setThinkingLevel(session, thread.options.thinking);
+        if (thread.options?.permissionMode) await adapter.setPermissionMode(session, thread.options.permissionMode);
+        emit({ kind: 'session', nativeSessionId: info.id, model: session.model });
+        return session;
+      } catch (error) { await host.close(); throw error; }
+    },
+    async describeFor(session) { return describeSession(session); },
+    async listModelsFor(session) { return session.state.models; },
+    async setModel(session, model) {
+      const selected = session.state.models.find(m => m.id === model.id && m.provider === model.provider);
+      if (!selected) throw new Error('OpenCode model unavailable');
+      await session.host.request('POST', `/api/session/${enc(session.nativeSessionId)}/model`, { model: { id: model.id, providerID: model.provider } });
+      session.model = selected; session.state.effort = undefined; return selected;
+    },
+    async setThinkingLevel(session, level) {
+      if (!describeSession(session).thinkingLevels.some(l => l.id === level)) throw new Error('OpenCode model variant unavailable');
+      await session.host.request('POST', `/api/session/${enc(session.nativeSessionId)}/model`, { model: { id: session.model.id, providerID: session.model.provider, variant: level } });
+      session.state.effort = level;
+    },
+    async setPermissionMode(session, agent) {
+      if (!session.state.agents.some(a => a.name === agent)) throw new Error('OpenCode agent mode unavailable');
+      await session.host.request('POST', `/api/session/${enc(session.nativeSessionId)}/agent`, { agent }); session.state.agent = agent;
+    },
+    async send(session, text, hooks, attachments) {
+      if (session.state.active) throw new Error('OpenCode turn already active');
+      const parts = [...(text ? [{ type: 'text', text }] : []), ...(attachments?.images || []).map(i => ({ type: 'file', mime: i.mime, filename: i.name, url: `data:${i.mime};base64,${i.data}` }))];
+      const commands = text.startsWith('/') ? await adapter.listCommands(session) : [];
+      const matched = commands.slice().sort((a, b) => b.nativeName.length - a.nativeName.length).find(c => text === '/' + c.nativeName || text.startsWith('/' + c.nativeName + ' '));
+      const command = matched ? [text, matched.nativeName, text.slice(matched.nativeName.length + 1).trimStart()] : null;
+      let body = { parts }, suffix = '/message';
+      if (command) {
+        if (command[1] === 'compact') return adapter.executeCommand(session, 'compact', hooks);
+        if (matched) { suffix = '/command'; body = { command: command[1], arguments: command[2] || '', parts: parts.filter(p => p.type === 'file') }; }
+      }
+      session.state.active = true; session.state.text.clear(); session.state.parts.clear();
+      try {
+        const result = await session.host.request('POST', route(session, suffix), body, 30 * 60 * 1000);
+        if (result.info?.error) throw new Error(result.info.error.data?.message || result.info.error.name || 'OpenCode turn failed');
+        for (const part of result.parts || []) projectPart(session, part, hooks.emit);
+        hooks.emit({ kind: 'usage', usage: await adapter.getContextUsage(session) });
+        hooks.emit({ kind: 'completed', finalAnswer: true, nativeRef: { checkpointId: result.info?.id } });
+      } finally { session.state.active = false; }
+    },
+    async cancel(session) { await session.host.request('POST', route(session, '/abort')); },
+    async respond(session, requestId, response) {
+      if (session.state.permissions.has(requestId)) {
+        const value = response.optionId ?? response.value;
+        const choice = ({ '允许一次': 'once', '始终允许': 'always', '拒绝': 'reject' })[value] || value;
+        const reply = response.cancelled ? 'reject' : choice;
+        if (!['once', 'always', 'reject'].includes(reply)) throw new Error('Invalid OpenCode permission response');
+        await session.host.request('POST', `/permission/${enc(requestId)}/reply`, { reply }); session.state.permissions.delete(requestId); return;
+      }
+      const split = requestId.lastIndexOf(':'), id = requestId.slice(0, split), pending = session.state.questions.get(id);
+      if (!pending || String(pending.index) !== requestId.slice(split + 1)) throw new Error('Unknown OpenCode question');
+      if (response.cancelled) { await session.host.request('POST', `/question/${enc(id)}/reject`); session.state.questions.delete(id); return; }
+      const q = pending.questions[pending.index];
+      const answers = q.multiple ? JSON.parse(response.value) : [response.optionId ?? response.value];
+      if (!Array.isArray(answers) || !answers.length || answers.some(a => typeof a !== 'string')) throw new Error('Invalid OpenCode answers');
+      if (pending.index + 1 < pending.questions.length) { pending.answers.push(answers); pending.index++; askNext(session, id); }
+      else { await session.host.request('POST', `/question/${enc(id)}/reply`, { answers: [...pending.answers, answers] }); session.state.questions.delete(id); }
+    },
+    async listCommands(session) {
+      const commands = session ? await session.host.request('GET', '/command') : [];
+      return [{ id: 'compact', nativeName: 'compact', label: '压缩上下文', action: 'execute' }, ...commands.filter(c => c.name !== 'compact').map(c => ({ id: 'native-' + Buffer.from(c.name).toString('hex'), nativeName: c.name, label: '/' + c.name, description: c.description, action: 'insert', text: '/' + c.name + ' ' }))];
+    },
+    async executeCommand(session, id, hooks) {
+      if (id !== 'compact') throw new Error('Unknown OpenCode command');
+      const info = await session.host.request('GET', route(session)), model = session.model || (info.model && { id: info.model.id, provider: info.model.providerID });
+      if (!model) throw new Error('Select an OpenCode model before compacting');
+      if (session.state.active) throw new Error('OpenCode turn already active');
+      session.state.active = true;
+      try { await session.host.request('POST', route(session, '/summarize'), { providerID: model.provider, modelID: model.id }, 30 * 60 * 1000); hooks.emit({ kind: 'completed', finalAnswer: false }); }
+      finally { session.state.active = false; }
+    },
+    async getContextUsage(session) {
+      const info = await session.host.request('GET', route(session)), t = info.tokens || {};
+      return { inputTokens: t.input, outputTokens: t.output, reasoningOutputTokens: t.reasoning, cacheRead: t.cache?.read, cacheWrite: t.cache?.write, cost: info.cost };
+    },
+    async fork(source, context) {
+      const host = await new OpenCodeServer(source.cwd).start();
+      try {
+        const history = await host.request('GET', `/session/${enc(source.nativeSessionId)}/message`), boundary = context.message?.coreTurn?.nativeTurnRef?.checkpointId;
+        if (context.message && !boundary) throw new Error('OpenCode reply has no native message boundary');
+        const index = boundary ? history.findIndex(m => m.info.id === boundary) : -1;
+        if (boundary && index < 0) throw new Error('OpenCode fork boundary no longer exists');
+        const next = boundary && history[index + 1]?.info.id;
+        const info = await host.request('POST', `/session/${enc(source.nativeSessionId)}/fork`, next ? { messageID: next } : {});
+        const copied = await host.request('GET', `/session/${enc(info.id)}/message`);
+        const checkpointMap = Object.fromEntries(copied.map((m, i) => [history[i].info.id, m.info.id]));
+        return { checkpointMap, session: await adapter.open({ thread: { ...source, nativeSessionId: info.id, restore: true }, emit: context.emit }) };
+      } finally { await host.close(); }
+    },
+    async close(session) { if (session.state.active) await adapter.cancel(session).catch(() => {}); await session.host.close(); },
+  };
+  return adapter;
+}
+module.exports = { manifest, create, projectEvent, projectPart, describeSession };