harness-mix 0.1.0

package/scripts/e2e-native-host.cjs

@@ -0,0 +1,144 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { JsonlProcess } = require('../src/main/host/jsonl');
+const { nativePaths, nativeEnvironment } = require('../src/main/native/config');
+
+async function main() {
+  const paths = nativePaths();
+  const installation = execFileSync(process.execPath, [paths.cli, '--check'], { encoding: 'utf8', windowsHide: true });
+  const stock = installation.match(/^executable_codex_cli=(.+)$/m)?.[1].trim();
+  assert.ok(stock && fs.existsSync(stock), 'Official Codex executable must exist');
+  const directory = path.resolve('output/native-host', `run-${Date.now()}`);
+  fs.mkdirSync(directory, { recursive: true });
+  const env = nativeEnvironment({ ...process.env, CODEXHOST_DATA_DIR: path.join(directory, 'data') });
+  Object.assign(env, {
+    CODEXHOST_STOCK_CODEX_PATH: stock,
+    CODEXHOST_HOST_NODE_PATH: process.execPath,
+    CODEXHOST_HOST_RUNTIME_PATH: paths.wrapper,
+    CODEXHOST_DEFAULT_AGENT: 'codex',
+  });
+  const events = [];
+  const diagnostics = [];
+  const transport = new JsonlProcess(paths.shim, ['app-server', '--listen', 'stdio://'], { env }, {
+    onEvent: event => events.push(event),
+    onDiagnostic: line => diagnostics.push(line),
+    onRequest: () => { throw new Error('Unexpected interactive request in native-host test'); },
+  });
+  const request = (method, params) => {
+    let timer;
+    return Promise.race([
+      transport.request(method, params),
+      new Promise((_, reject) => { timer = setTimeout(() => reject(new Error(`${method} timed out`)), 60000); }),
+    ]).finally(() => clearTimeout(timer));
+  };
+  const report = { stock, checks: [] };
+  try {
+    await request('initialize', { clientInfo: { name: 'harness-mix-native-test', version: '0.1.0' }, capabilities: { experimentalApi: true } });
+    transport.notify('initialized', {});
+    report.checks.push('official initialize passthrough');
+    const ownership = await request('harness-mix/runtime/inspect', {});
+    assert.equal(ownership.owner, 'harness-mix');
+    assert.equal(ownership.core, 'src/main/protocol-core/protocol-core.js');
+    report.checks.push('Harness Mix HostRuntime and ProtocolCore own external execution');
+    const plugins = await request('codexhost/harness/plugins/list', {});
+    assert.ok(plugins.plugins.some(plugin => (plugin.id || plugin.manifest?.id) === 'pi'), 'Pi plugin registered');
+    report.checks.push('external harness plugins registered');
+    for (const harnessId of ['pi', 'claude-code', 'deepseek-harness']) {
+      const inspection = await request('codexhost/harness/inspect', { harnessId, cwd: directory });
+      report[harnessId] = inspection;
+      console.log(`${harnessId}: ${inspection.status}; models=${inspection.catalog?.models?.length || 0}${inspection.error ? `; ${inspection.error.message}` : ''}`);
+      assert.equal(inspection.status, 'ready', `${harnessId} must be ready`);
+    }
+    const officialModels = await request('model/list', {});
+    assert.ok(Array.isArray(officialModels.data), 'Official model/list passes through');
+    report.checks.push('official model/list passthrough');
+    // Real Host + stock-server section catalog, with test threads isolated in output/.
+    const sidebarThread = await request('thread/start', { cwd: directory, model: 'codexhost/pi-native' });
+    const sidebarId = sidebarThread.thread.id;
+    assert.equal(sidebarThread.thread.sessionId, sidebarId);
+    const descendants = await request('thread/list', { ancestorThreadId: sidebarId, sourceKinds: ['subAgentThreadSpawn'] });
+    assert.equal(descendants.data.some(thread => thread.id === sidebarId), false);
+    const sections = await request('threadSection/list', { limit: 100 });
+    const section = sections.data[0];
+    assert.ok(section, 'Desktop has a section available for pin/unpin verification');
+    const inSection = async () => (await request('thread/list', { sectionId: section.id, sortKey: 'section_position' })).data.filter(thread => thread.id === sidebarId);
+    assert.equal((await inSection()).length, 0, 'New external thread is not auto-pinned');
+    await request('thread/section/move', { threadId: sidebarId, sectionId: section.id });
+    assert.equal((await inSection()).length, 1, 'Pinned external thread appears exactly once');
+    await request('thread/section/move', { threadId: sidebarId, sectionId: null });
+    assert.equal((await inSection()).length, 0, 'Unpin stays removed on the next list query');
+    const resumed = await request('thread/resume', { threadId: sidebarId });
+    assert.equal(resumed.model, 'codexhost/pi-native');
+    const inspected = await request('codexhost/thread/inspect', { threadId: sidebarId });
+    assert.equal(inspected.harnessId, 'pi');
+    assert.equal(inspected.transportModelId, resumed.model);
+    report.checks.push('external identity, no self-descendants, pin/unpin and resume ownership');
+    if (process.argv.includes('--live')) {
+      const harnessId = process.argv.find(arg => arg.startsWith('--harness='))?.split('=')[1] || 'pi';
+      const started = await request('thread/start', { cwd: directory, model: `codexhost/${harnessId}-native` });
+      assert.ok(started.thread?.id, 'Native external thread created');
+      const threadId = started.thread.id;
+      const turn = await request('turn/start', {
+        threadId, input: [{ type: 'text', text: 'Reply with exactly HARNESS_MIX_NATIVE_OK. Do not use any tools.' }],
+      });
+      const deadline = Date.now() + 120000;
+      while (Date.now() < deadline && !events.some(event => event.method === 'turn/completed' && event.params?.threadId === threadId)) {
+        await new Promise(resolve => setTimeout(resolve, 250));
+      }
+      const completed = events.find(event => event.method === 'turn/completed' && event.params?.threadId === threadId);
+      assert.ok(completed, 'Native turn completion projected');
+      assert.equal(completed.params.turn.status, 'completed');
+      const reply = events.filter(event => event.method === 'item/agentMessage/delta' && event.params?.threadId === threadId)
+        .map(event => event.params.delta || '').join('');
+      const finalReply = events.filter(event => event.method === 'item/completed' && event.params?.threadId === threadId && event.params?.item?.type === 'agentMessage')
+        .map(event => event.params.item.text || '').join('');
+      assert.ok(`${reply}${finalReply}`.includes('HARNESS_MIX_NATIVE_OK'), 'Agent output, not echoed user input, must contain the marker');
+      const history = await request('thread/read', { threadId, includeTurns: true });
+      assert.equal(history.thread.id, threadId, 'External thread history is readable through native protocol');
+      report.live = { harnessId, threadId, turnId: turn.turn?.id, status: completed.params.turn.status, reply: finalReply || reply };
+      report.checks.push(`real ${harnessId} turn through Shim and Desktop protocol`);
+      // Live external steering: a slow Turn is replaced mid-flight by turn/steer.
+      const slow = await request('turn/start', {
+        threadId, input: [{ type: 'text', text: 'Count from 1 to 30, one number per line. No commentary.' }],
+      });
+      await new Promise(resolve => setTimeout(resolve, 1500));
+      const steered = await request('turn/steer', {
+        threadId,
+        expectedTurnId: slow.turn.id,
+        clientUserMessageId: `e2e-steer-${Date.now()}`,
+        input: [{ type: 'text', text: 'Reply with exactly HARNESS_MIX_STEER_OK. Do not use any tools.' }],
+      });
+      assert.ok(steered.turnId && steered.turnId !== slow.turn.id, 'Steering allocates a new Turn identity');
+      const steerDeadline = Date.now() + 120000;
+      while (Date.now() < steerDeadline && !events.some(event => event.method === 'turn/completed' && event.params?.turn?.id === steered.turnId)) {
+        await new Promise(resolve => setTimeout(resolve, 250));
+      }
+      const steerCompleted = events.find(event => event.method === 'turn/completed' && event.params?.turn?.id === steered.turnId);
+      assert.ok(steerCompleted, 'Steered turn completion projected');
+      const oldTurn = events.filter(event => event.method === 'turn/completed' && event.params?.turn?.id === slow.turn.id).at(-1);
+      assert.ok(oldTurn && ['interrupted', 'completed'].includes(oldTurn.params.turn.status), 'Replaced Turn reached a terminal state');
+      const steerReply = events.filter(event => event.method === 'item/agentMessage/delta' && event.params?.turnId === steered.turnId)
+        .map(event => event.params.delta || '').join('');
+      const steerFinal = events.filter(event => event.method === 'item/completed' && event.params?.turnId === steered.turnId && event.params?.item?.type === 'agentMessage')
+        .map(event => event.params.item.text || '').join('');
+      assert.ok(`${steerReply}${steerFinal}`.includes('HARNESS_MIX_STEER_OK'), 'Steered turn output contains the marker');
+      report.live.steer = { replacedTurnId: slow.turn.id, turnId: steered.turnId, replacedStatus: oldTurn.params.turn.status };
+      report.checks.push(`real ${harnessId} external steering through turn/steer`);
+    }
+    fs.writeFileSync(path.join(directory, 'report.json'), JSON.stringify(report, null, 2));
+    console.log(`PASS: ${report.checks.join('; ')}\nReport: ${directory}`);
+  } catch (error) {
+    console.error(diagnostics.slice(-8).join('\n'));
+    throw error;
+  } finally {
+    transport.child.stdin.end();
+    await new Promise(resolve => {
+      if (transport.child.exitCode !== null) return resolve();
+      const timer = setTimeout(() => { transport.stop(); resolve(); }, 5000);
+      transport.child.once('exit', () => { clearTimeout(timer); resolve(); });
+    });
+  }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/e2e-openclaw-image.cjs

@@ -0,0 +1,59 @@
+// 真实 OpenClaw 图片链路自检：经 Gateway agent RPC attachments 字段发送一张纯红 PNG
+const { HostRuntime } = require("../src/main/host/runtime");
+const os = require("node:os");
+const path = require("node:path");
+const zlib = require("node:zlib");
+
+// 最小合法 PNG：8x8 纯红（手工构造 IHDR+IDAT+IEND）
+function redPng() {
+  const crcTable = Array.from({ length: 256 }, (_, n) => {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    return c >>> 0;
+  });
+  const crc32 = (buf) => {
+    let c = 0xffffffff;
+    for (const b of buf) c = crcTable[(c ^ b) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+  };
+  const chunk = (type, data) => {
+    const len = Buffer.alloc(4); len.writeUInt32BE(data.length);
+    const body = Buffer.concat([Buffer.from(type), data]);
+    const crc = Buffer.alloc(4); crc.writeUInt32BE(crc32(body));
+    return Buffer.concat([len, body, crc]);
+  };
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(8, 0); ihdr.writeUInt32BE(8, 4); ihdr[8] = 8; ihdr[9] = 2; // 8bit RGB
+  const raw = Buffer.alloc(8 * (1 + 8 * 3));
+  for (let y = 0; y < 8; y++) for (let x = 0; x < 8; x++) {
+    const o = y * 25 + 1 + x * 3; raw[o] = 255; raw[o + 1] = 0; raw[o + 2] = 0;
+  }
+  return Buffer.concat([
+    Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+    chunk("IHDR", ihdr), chunk("IDAT", zlib.deflateSync(raw)), chunk("IEND", Buffer.alloc(0)),
+  ]);
+}
+
+(async () => {
+  const rt = new HostRuntime({ dataDirectory: path.join(os.tmpdir(), "hm-e2e-openclaw-img") });
+  rt.subscribe((e) => { if (e.type === "toast") console.log("  [toast]", e.text); });
+  await rt.initialize();
+  const thread = await rt.createThread({ harnessId: "openclaw", cwd: "E:\\harness-mix", title: "E2E 图片自检" });
+  if (thread.status === "error") throw new Error("open failed: " + thread.error);
+  const caps = rt.getCapabilities("openclaw");
+  console.log("attachments capability:", caps.conversation.attachments);
+  console.log("opened, native session:", thread.nativeSessionId);
+  const png = redPng();
+  await rt.send(thread.id, "这张图片是什么颜色？用一个词回答。", {
+    attachments: [{ kind: "image", name: "red.png", mime: "image/png", data: png.toString("base64") }],
+  });
+  for (let i = 0; i < 120 && rt.threads.find((t) => t.id === thread.id).status === "working"; i++) await new Promise((r) => setTimeout(r, 1000));
+  const t = rt.threads.find((t) => t.id === thread.id);
+  const answer = t.messages.at(-1)?.text ?? "";
+  console.log("status:", t.status, "| error:", t.error ?? "(none)", "| assistant:", JSON.stringify(answer.slice(0, 300)));
+  console.log("messages:", JSON.stringify(t.messages.map((m) => ({ role: m.role, text: (m.text ?? "").slice(0, 120) }))));
+  await rt.close();
+  const ok = t.status === "ready" && /红|red/i.test(answer);
+  console.log(ok ? "PASS: OpenClaw 收到并识别了图片" : "WARN: 回答未明确提到红色（可能模型/会话不支持视觉，需人工看回答）");
+  process.exit(t.status === "ready" ? 0 : 1);
+})().catch((e) => { console.error("E2E FAILED:", e.message); process.exit(1); });

package/scripts/e2e-openclaw.cjs

@@ -0,0 +1,21 @@
+// 真实 OpenClaw 链路自检（经本机 Gateway 发起一次最小 agent turn；Gateway 未运行时自动拉起）
+const { HostRuntime } = require("../src/main/host/runtime");
+const os = require("node:os");
+const path = require("node:path");
+
+(async () => {
+  const rt = new HostRuntime({ dataDirectory: path.join(os.tmpdir(), "hm-e2e-openclaw") });
+  rt.subscribe((e) => { if (e.type === "toast") console.log("  [toast]", e.text); });
+  await rt.initialize();
+  const thread = await rt.createThread({ harnessId: "openclaw", cwd: "E:\\harness-mix", title: "E2E 自检" });
+  if (thread.status === "error") throw new Error("open failed: " + thread.error);
+  console.log("opened, native session:", thread.nativeSessionId, "| model:", JSON.stringify(thread.model));
+  const models = await rt.listModels(thread.id).catch((e) => "listModels: " + e.message);
+  console.log("models:", Array.isArray(models) ? `${models.length} 个（首个 ${JSON.stringify(models[0])}）` : models);
+  await rt.send(thread.id, "只回复两个字：收到");
+  for (let i = 0; i < 90 && rt.threads.find((t) => t.id === thread.id).status === "working"; i++) await new Promise((r) => setTimeout(r, 1000));
+  const t = rt.threads.find((t) => t.id === thread.id);
+  console.log("status:", t.status, "| assistant:", JSON.stringify(t.messages.at(-1)?.text));
+  await rt.close();
+  process.exit(t.status === "ready" && t.messages.at(-1)?.text ? 0 : 1);
+})().catch((e) => { console.error("E2E FAILED:", e.message); process.exit(1); });

package/scripts/e2e-pi.cjs

@@ -0,0 +1,23 @@
+const { ParityObserver } = require('./support/parity-observer.cjs');
+// 真实 Pi 链路自检（会发起一次最小模型请求）
+const { HostRuntime } = require("../src/main/host/runtime");
+const os = require("node:os");
+const path = require("node:path");
+
+(async () => {
+  const rt = new HostRuntime({ observer: new ParityObserver(), dataDirectory: path.join(os.tmpdir(), "hm-e2e-pi") });
+  rt.subscribe((e) => { if (e.type === "toast") console.log("  [toast]", e.text); });
+  await rt.initialize();
+  const thread = await rt.createThread({ harnessId: "pi", cwd: "E:\\harness-mix", title: "E2E 自检" });
+  if (thread.status === "error") throw new Error("open failed: " + thread.error);
+  console.log("opened, native session:", thread.nativeSessionId, "| model:", JSON.stringify(thread.model));
+  const models = await rt.listModels(thread.id).catch((e) => "listModels: " + e.message);
+  console.log("models:", Array.isArray(models) ? `${models.length} 个（首个 ${JSON.stringify(models[0])}）` : models);
+  await rt.send(thread.id, "只回复两个字：收到");
+  for (let i = 0; i < 90 && rt.threads.find((t) => t.id === thread.id).status === "working"; i++) await new Promise((r) => setTimeout(r, 1000));
+  const t = rt.threads.find((t) => t.id === thread.id);
+  console.log("status:", t.status, "| assistant:", JSON.stringify(t.messages.at(-1)?.text));
+  console.log("usage:", JSON.stringify(t.usage));
+  await rt.close();
+  process.exit(t.status === "ready" && t.messages.at(-1)?.text ? 0 : 1);
+})().catch((e) => { console.error("E2E FAILED:", e.message); process.exit(1); });

package/scripts/e2e-shadow.cjs

@@ -0,0 +1,52 @@
+const { ParityObserver } = require('./support/parity-observer.cjs');
+// §64 验收：真实 Harness 链路 + Protocol Core Shadow（通用版）。
+// 用法：node scripts/e2e-shadow.cjs <pi|claude|dsh>
+const { HostRuntime } = require("../src/main/host/runtime");
+const os = require("node:os");
+const path = require("node:path");
+
+const harnessId = process.argv[2];
+if (!harnessId) { console.error("usage: node scripts/e2e-shadow.cjs <harnessId>"); process.exit(2); }
+
+(async () => {
+  const rt = new HostRuntime({ observer: new ParityObserver(), dataDirectory: path.join(os.tmpdir(), `hm-e2e-shadow-${harnessId}`) });
+  rt.subscribe((e) => { if (e.type === "toast") console.log("  [toast]", e.text); });
+  await rt.initialize();
+  if (!rt.status[harnessId]?.available) throw new Error(`harness unavailable: ${rt.status[harnessId]?.detail}`);
+  const thread = await rt.createThread({ harnessId, cwd: path.resolve(__dirname, ".."), title: "Shadow E2E 自检" });
+  if (thread.status === "error") throw new Error("open failed: " + thread.error);
+  await rt.send(thread.id, "只回复两个字：收到");
+  for (let i = 0; i < 90 && rt.threads.find((t) => t.id === thread.id).status === "working"; i++) await new Promise((r) => setTimeout(r, 1000));
+  const t = rt.threads.find((t) => t.id === thread.id);
+
+  // 1) Legacy 路径完全正常
+  console.log("[legacy] status:", t.status, "| assistant:", JSON.stringify(t.messages.at(-1)?.text));
+  if (t.status !== "ready" || !t.messages.at(-1)?.text) throw new Error("legacy path broken");
+
+  // 2) Core Shadow 快照
+  const snap = rt.coreSnapshot();
+  const coreThread = snap.threads.find((x) => x.id === thread.id);
+  const coreTurn = snap.turns.find((x) => x.threadId === thread.id);
+  const items = snap.items.filter((x) => x.turnId === coreTurn?.id);
+  const types = [...new Set(items.map((x) => x.type))];
+  console.log("[core] thread:", coreThread?.status, "| turn:", coreTurn?.status, "| item types:", types.join(","));
+  console.log("[core] agent_message:", JSON.stringify(items.filter((x) => x.type === "agent_message").map((x) => x.content).join("")));
+
+  const problems = [];
+  if (!coreThread) problems.push("missing core thread");
+  if (coreTurn?.status !== "completed") problems.push(`core turn status=${coreTurn?.status}`);
+  if (!items.some((x) => x.type === "user_message")) problems.push("missing user_message item");
+  if (!items.some((x) => x.type === "agent_message" && x.content)) problems.push("missing agent_message content");
+
+  // 3) Shadow 对照报告
+  const report = rt.shadowReport();
+  console.log("[shadow] errors:", JSON.stringify(report.errors), "| warnings:", JSON.stringify(report.warnings));
+  console.log("[shadow] mismatches:", JSON.stringify(report.mismatches, null, 2));
+  if (report.errors.length) problems.push("shadow internal errors");
+  if (report.mismatches.length) problems.push("shadow mismatch");
+
+  await rt.close();
+  if (problems.length) { console.error("SHADOW E2E FAILED:", problems.join("; ")); process.exit(1); }
+  console.log("SHADOW E2E PASSED");
+  process.exit(0);
+})().catch((e) => { console.error("SHADOW E2E FAILED:", e.message); process.exit(1); });

package/scripts/fixture-capture.cjs

@@ -0,0 +1,103 @@
+const { ParityObserver } = require('./support/parity-observer.cjs');
+// PR 4：捕获真实 Harness 原生事件为 fixtures（§16/§17）。
+// 用法：node scripts/fixture-capture.cjs [pi|claude|dsh|all]
+// 保存的是 Native Event（Adapter 转换前），回放链路覆盖 Native→Normalize→Core→State。
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs');
+const { HostRuntime } = require('../src/main/host/runtime');
+const recorder = require('../src/main/harness-adapter/fixture-recorder');
+
+const FIXTURES_DIR = path.join(__dirname, '..', 'fixtures');
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// 场景清单（§16）。各 Harness 能力不同，不适用的场景会明确跳过并说明。
+const SCENARIOS = {
+  'simple-message': { prompt: '只回复两个字：收到' },
+  'reasoning': { prompt: '请先简要推理，再回答：17 乘以 23 等于多少？', options: { thinking: 'medium' } },
+  'tool-call': { prompt: '请运行 shell 命令 `echo harness-mix-fixture`，然后把命令输出原样告诉我。', autoApprove: true },
+  'file-edit': { prompt: 'Only in this temporary working directory: use your native file editing tool to create fixture-edit.txt containing exactly harness-mix-fixture. Do not access other folders. Then reply done.', autoApprove: true, options: { permissionMode: 'acceptEdits' } },
+  'cancel': { prompt: '请逐行输出从 1 到 100000 的所有数字，中间不要停。', cancelAfterMs: 3000 },
+};
+
+async function capture(harnessId, label, scenario) {
+  const workspace = fs.mkdtempSync(path.join(os.tmpdir(), 'hm-fixture-work-'));
+  const recordingDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hm-fixture-record-'));
+  const rt = new HostRuntime({ observer: new ParityObserver(), dataDirectory: path.join(os.tmpdir(), `hm-fixture-${harnessId}-${label}-${Date.now()}`) });
+  try {
+    await rt.initialize();
+    if (!rt.status[harnessId]?.available) {
+      console.log(`skip [${harnessId}/${label}] harness unavailable: ${rt.status[harnessId]?.detail}`);
+      return false;
+    }
+    const thread = await rt.createThread({ harnessId, cwd: workspace, title: `fixture ${label}`, options: scenario.options });
+    if (thread.status === 'error') {
+      console.log(`skip [${harnessId}/${label}] open failed: ${thread.error}`);
+      return false;
+    }
+    recorder.startRecording(harnessId, label, recordingDir);
+    void rt.send(thread.id, scenario.prompt).catch(() => {});
+    if (scenario.cancelAfterMs) {
+      await sleep(scenario.cancelAfterMs);
+      recorder.recordControl(harnessId, 'cancel'); // 标记 cancel 在事件流中的真实位置
+      await rt.cancel(thread.id).catch(() => {});
+    }
+    // 先等 send() 完成异步准备进入 working，再等执行结束
+    const startDeadline = Date.now() + 30_000;
+    while (Date.now() < startDeadline) {
+      const t = rt.threads.find((x) => x.id === thread.id);
+      if (t.status === 'working' || t.status === 'error') break;
+      await sleep(200);
+    }
+    const deadline = Date.now() + 120_000;
+    while (Date.now() < deadline) {
+      const t = rt.threads.find((x) => x.id === thread.id);
+      // 自动应答审批/权限请求，避免捕获卡住（同时留下 approval 原生事件）
+      for (const a of [...(t.pendingApprovals ?? [])]) {
+        if (!scenario.autoApprove) throw new Error("unexpected approval in read-only scenario");
+        await rt.respondApproval(t.id, a.requestId, { confirmed: true, optionId: a.options?.find(o => o.kind === 'allow_once' || /allow|允许/i.test(o.id ?? o.optionId ?? o.label ?? ''))?.id }).catch(() => {});
+      }
+      if (t.status !== 'working') break;
+      await sleep(500);
+    }
+    recorder.stopRecording();
+    const file = path.join(recordingDir, harnessId, `${label}.jsonl`);
+    const lines = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).length;
+    const t = rt.threads.find((x) => x.id === thread.id);
+    console.log(`captured [${harnessId}/${label}] ${lines} native events | legacy status=${t.status} | answer=${JSON.stringify((t.messages.at(-1)?.text ?? '').slice(0, 40))}`);
+    if (t.status !== 'ready' || !lines) throw new Error(`capture not successful: ${t.error ?? t.status}`);
+    const report = rt.shadowReport();
+    if (report.errors.length || report.mismatches.length) throw new Error(`shadow mismatch: ${JSON.stringify(report)}`);
+    if (label === 'file-edit' && fs.readFileSync(path.join(workspace, 'fixture-edit.txt'), 'utf8').trim() !== 'harness-mix-fixture') throw new Error('file edit did not happen');
+    fs.mkdirSync(path.join(FIXTURES_DIR, harnessId), { recursive: true });
+    fs.copyFileSync(file, path.join(FIXTURES_DIR, harnessId, `${label}.jsonl`));
+    fs.writeFileSync(path.join(FIXTURES_DIR, harnessId, `${label}.capture.json`), JSON.stringify({ capturedAt: new Date().toISOString(), harnessId, label, nativeEvents: lines, fileVerified: label === 'file-edit', report }, null, 2));
+    return true;
+  } catch (error) {
+    recorder.stopRecording();
+    console.log(`skip [${harnessId}/${label}] ${error.message}`);
+    return false;
+  } finally {
+    await rt.close().catch(() => {});
+  }
+}
+
+(async () => {
+  const target = process.argv[2] ?? 'all';
+  const harnesses = target === 'all' ? ['pi', 'claude', 'dsh'] : [target];
+  for (const harnessId of harnesses) {
+    for (const [label, scenario] of Object.entries(SCENARIOS)) {
+      // 能力裁剪：claude 不投影 thinking，跳过 reasoning 场景
+      if (process.argv[3] && label !== process.argv[3]) continue;
+      if (!await capture(harnessId, label, scenario)) process.exitCode = 1;
+    }
+    // usage fixture：任何包含 usage 原生事件的 run 都可充当；从 simple-message 派生，避免额外模型调用
+    const usageFile = path.join(FIXTURES_DIR, harnessId, 'usage.jsonl');
+    const simpleFile = path.join(FIXTURES_DIR, harnessId, 'simple-message.jsonl');
+    if (!fs.existsSync(usageFile) && fs.existsSync(simpleFile)) {
+      const hasUsage = fs.readFileSync(simpleFile, 'utf8').includes('message_end') || fs.readFileSync(simpleFile, 'utf8').includes('usage_update');
+      if (hasUsage) { fs.copyFileSync(simpleFile, usageFile); console.log(`derived [${harnessId}/usage] from simple-message`); }
+    }
+  }
+  console.log('capture done');
+})().catch((e) => { console.error('CAPTURE FAILED:', e); process.exit(1); });

package/scripts/git-test.cjs

@@ -0,0 +1,33 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const service = require('../src/main/workspace/git');
+(async () => {
+  const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-git-'));
+  await service.mutate(cwd, 'init', {});
+  const git = args => execFileSync('git', args, { cwd, windowsHide: true, encoding: 'utf8' });
+  git(['config', 'user.name', 'Harness Mix Test']); git(['config', 'user.email', 'test@example.invalid']);
+  const file = '中文 空格.txt';
+  await fs.writeFile(path.join(cwd, file), 'before\n');
+  assert.equal((await service.status(cwd)).files[0].path, file);
+  await service.mutate(cwd, 'stage', { path: file });
+  assert.match((await service.diff(cwd, file, true)).item.patch.text, /before/);
+  await service.mutate(cwd, 'unstage', { path: file });
+  assert.equal((await service.status(cwd)).files[0].untracked, true);
+  await service.mutate(cwd, 'stage', { path: file });
+  await service.mutate(cwd, 'commit', { message: 'fixture initial' });
+  await fs.writeFile(path.join(cwd, file), 'after\n');
+  assert.match((await service.diff(cwd, file, false)).item.patch.text, /\+after/);
+  await service.mutate(cwd, 'stage', { path: file });
+  await service.mutate(cwd, 'unstage', { path: file });
+  assert.equal(await fs.readFile(path.join(cwd, file), 'utf8'), 'after\n');
+  await assert.rejects(service.mutate(cwd, 'stage', { path: '../escape' }), /无效/);
+  git(['mv', file, 'rename.txt']);
+  const renamed = (await service.status(cwd)).files.find(f => f.from);
+  assert.equal(renamed.from, file);
+  await service.mutate(cwd, 'unstage', { path: renamed.path });
+  assert.equal((await service.status(cwd)).log.length, 1);
+  console.log('real Git init, unicode paths, staged/unstaged diff, commit, unborn unstage, rename and traversal checks passed');
+})().catch(e => { console.error(e); process.exitCode = 1; });

package/scripts/launch-codex.cjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+const { launch } = require('../src/main/native/launcher');
+function main(args = process.argv.slice(2)) { return launch(args); }
+if (require.main === module) main().catch(error => { console.error(error.message); process.exitCode = 1; });
+module.exports = { main };

package/scripts/native-compatibility-test.cjs

@@ -0,0 +1,42 @@
+const assert = require('node:assert/strict');
+const {
+  loadCompatibilityManifest,
+  evaluateDesktopCompatibility,
+  enforceDesktopCompatibility,
+} = require('../src/main/native/compatibility');
+
+const manifest = loadCompatibilityManifest();
+assert.deepEqual(manifest.contractVersions, {
+  rendererBinding: 1,
+  controllerReadiness: 2,
+  protocolFixture: 1,
+});
+
+const observed = evaluateDesktopCompatibility('26.901.2854.0', manifest);
+assert.equal(observed.state, 'observed');
+assert.equal(observed.evidence.level, 'protocol-and-smoke');
+assert.doesNotThrow(() => enforceDesktopCompatibility(observed, {}));
+assert.throws(
+  () => enforceDesktopCompatibility(observed, { HARNESS_MIX_STRICT_COMPATIBILITY: '1' }),
+  /full Desktop E2E/,
+);
+
+const verifiedManifest = {
+  ...manifest,
+  evidence: [...manifest.evidence, {
+    desktopVersion: '26.999.1.0',
+    level: 'desktop-e2e',
+    checkedAt: '2026-09-11',
+    notes: 'Synthetic verified version for policy testing.',
+  }],
+};
+assert.equal(evaluateDesktopCompatibility('26.999.1.0', verifiedManifest).state, 'verified');
+assert.equal(evaluateDesktopCompatibility('26.999.2.0', manifest).state, 'unverified');
+assert.throws(() => evaluateDesktopCompatibility('latest', manifest), /Invalid/);
+
+const blockedManifest = { ...manifest, blockedDesktopVersions: ['26.999.3.0'] };
+const blocked = evaluateDesktopCompatibility('26.999.3.0', blockedManifest);
+assert.equal(blocked.state, 'blocked');
+assert.throws(() => enforceDesktopCompatibility(blocked, {}), /explicitly blocked/);
+
+console.log('PASS: Codex Desktop compatibility evidence, strict mode and explicit block policy');

package/scripts/native-config-test.cjs

@@ -0,0 +1,25 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { nativeEnvironment, nativePaths, saveNativeSettings } = require('../src/main/native/config');
+
+const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-mix-config-'));
+try {
+  const source = { CODEXHOST_DATA_DIR: directory, CODEXHOST_PI_COMMAND: 'C:\\Native tools\\pi.cmd', PRIVATE_TEST_VALUE: 'do-not-persist' };
+  const env = nativeEnvironment(source);
+  assert.equal(source.CODEXHOST_DEFAULT_AGENT, undefined, 'Input environment is not mutated');
+  assert.equal(env.CODEXHOST_DEFAULT_AGENT, 'codex');
+  saveNativeSettings(env);
+  const saved = JSON.parse(fs.readFileSync(path.join(directory, 'harness-mix-settings.json'), 'utf8'));
+  assert.deepEqual(saved, { CODEXHOST_PI_COMMAND: source.CODEXHOST_PI_COMMAND });
+  assert.equal(nativeEnvironment({ CODEXHOST_DATA_DIR: directory }).CODEXHOST_PI_COMMAND, source.CODEXHOST_PI_COMMAND,
+    'AppX child recovers command settings from the data directory');
+  assert.equal(nativeEnvironment({ CODEXHOST_DATA_DIR: directory, CODEXHOST_PI_COMMAND: 'D:\\other\\pi.cmd' }).CODEXHOST_PI_COMMAND,
+    'D:\\other\\pi.cmd', 'Explicit environment takes priority');
+  for (const file of Object.values(nativePaths())) assert.ok(fs.statSync(file).isFile(), file);
+  console.log('Native configuration, AppX environment recovery, credential exclusion and packaged resources passed');
+} finally {
+  fs.rmSync(path.join(directory, 'harness-mix-settings.json'), { force: true });
+  fs.rmdirSync(directory);
+}

package/scripts/native-file-change-test.cjs

@@ -0,0 +1,94 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { HostRuntime } = require('../src/main/host/runtime');
+const { projectEvent } = require('../src/main/adapters/claude');
+const { canonicalChanges } = require('../src/main/workspace/file-changes');
+
+(async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-native-files-'));
+  const root = path.join(directory, 'workspace'); await fs.mkdir(root);
+  const rt = new HostRuntime({ dataDirectory: directory });
+  await rt.store.load();
+  let emit;
+  rt.adapters.set('test', { manifest: { id: 'test', name: 'Test', capabilities: {} },
+    async open(input) { emit = input.emit; return {}; }, async send() {}, async close() {} });
+  rt.status.test = { available: true };
+  const apply = events => { for (const event of [events].flat().filter(Boolean)) emit(event); };
+  try {
+    const thread = await rt.createThread({ harnessId: 'test', cwd: root });
+    await fs.writeFile(path.join(root, 'a.txt'), 'original\n');
+    await rt.send(thread.id, 'edit');
+    const message = thread.messages.at(-1);
+    // DSH Web Remote 的 tool/result meta.diffs 为 hunk 级（非完整文件），原生 diff 路径
+    // 由 Claude（tool_use_result 全量 before/after）与直接 emit 腿覆盖。
+    const edit = async (before, after, id) => {
+      await fs.writeFile(path.join(root, 'a.txt'), after);
+      apply(projectEvent({ type: 'user', session_id: 'native-session',
+        tool_use_result: { filePath: path.join(root, 'a.txt'), type: 'update', content: after, originalFile: before },
+        message: { content: [{ type: 'tool_result', tool_use_id: id }] } }));
+    };
+    await edit('original\n', 'middle\n', 'edit-1');
+    const preview = rt.reviews.preview.bind(rt.reviews);
+    const stale = await preview(message.reviewId);
+    let release;
+    rt.reviews.preview = async id => {
+      rt.reviews.preview = preview;
+      await new Promise(resolve => { release = resolve; });
+      return stale;
+    };
+    const reading = rt.readReview(thread, message);
+    assert.equal(typeof release, 'function');
+    await edit('middle\n', 'final\n', 'edit-2');
+    release();
+    let files = (await reading).files;
+    assert.equal(files.length, 1);
+    assert.equal(files[0].source, 'native');
+    assert.equal(files[0].before, 'original\n');
+    assert.equal(files[0].after, 'final\n');
+    assert.equal(files[0].nativeRef.toolCallId, 'edit-2');
+    assert.equal(files[0].patch.rows.find(row => row.kind === 'remove').text, 'original');
+    await fs.writeFile(path.join(root, 'b.txt'), 'created\n');
+    apply(projectEvent({ type: 'user', session_id: 'native-session',
+      tool_use_result: { filePath: path.join(root, 'b.txt'), type: 'create', content: 'created\n' },
+      message: { content: [{ type: 'tool_result', tool_use_id: 'create-1' }] } }));
+    files = (await rt.readReview(thread, message)).files;
+    assert.equal(files.find(file => file.path === 'b.txt').source, 'native');
+    // A later shell edit has no native patch: the complete snapshot must win.
+    await fs.writeFile(path.join(root, 'a.txt'), 'shell edit\n');
+    files = (await rt.readReview(thread, message)).files;
+    assert.equal(files.find(file => file.path === 'a.txt').source, 'snapshot');
+    assert.equal(files.find(file => file.path === 'a.txt').after, 'shell edit\n');
+    assert.equal(files.find(file => file.path === 'a.txt').nativeRef.toolCallId, 'edit-2');
+    await fs.mkdir(path.join(root, 'nested'));
+    await fs.writeFile(path.join(root, 'nested', 'c.txt'), 'nested\n');
+    emit({ kind: 'file-change', source: 'native', changes: [{ path: path.join(root, 'nested', 'c.txt'), before: '', after: 'nested\n', complete: true }] });
+    files = (await rt.readReview(thread, message)).files;
+    assert.equal(files.filter(file => file.path === 'nested/c.txt').length, 1);
+    assert.equal(files.find(file => file.path === 'nested/c.txt').source, 'native');
+    // Antigravity 式：原生事件只携带路径、不携带内容（complete: false，与 codex.js 同一约定），
+    // 必须由工作区快照接管，否则回合结算后仍无增删统计（UI 显示 +0 -0）。
+    await fs.writeFile(path.join(root, 'd.txt'), 'disk\n');
+    emit({ kind: 'file-change', source: 'native', changes: [{ path: path.join(root, 'd.txt'), changeType: 'added', complete: false }] });
+    files = (await rt.readReview(thread, message)).files;
+    const incomplete = files.find(file => file.path === 'd.txt');
+    assert.equal(incomplete.source, 'snapshot', 'contentless native hint must not block the workspace snapshot');
+    assert.equal(incomplete.after, 'disk\n');
+    emit({ kind: 'completed', finalAnswer: true });
+    for (let i = 0; i < 200 && thread.reviewPending; i++) await new Promise(resolve => setTimeout(resolve, 10));
+    assert.equal(thread.reviewPending, false);
+    await rt.undoFile(thread.id, message.id, 'nested/c.txt');
+    await assert.rejects(fs.access(path.join(root, 'nested', 'c.txt')));
+    await rt.undoFile(thread.id, message.id, 'b.txt');
+    assert.equal(message.coreReview.files.find(file => file.path === 'b.txt').undone, true);
+    await assert.rejects(fs.access(path.join(root, 'b.txt')));
+    const beforeLate = structuredClone(message.coreItems);
+    emit({ kind: 'file-change', changes: [{ path: 'late.txt', before: '', after: 'late' }] });
+    assert.deepEqual(message.coreItems, beforeLate, 'late native diff cannot mutate a settled turn');
+    assert.throws(() => canonicalChanges(root, [{ path: '../escape.txt' }]), /outside/);
+    await rt.undoFile(thread.id, message.id, 'a.txt');
+    assert.equal(await fs.readFile(path.join(root, 'a.txt'), 'utf8'), 'original\n');
+    console.log('native-file-change: native adapters -> Core -> review, repeated edits, snapshot fallback, undo, late events passed');
+  } finally { await rt.close(); }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/native-host.cjs

@@ -0,0 +1,8 @@
+// AppX activation does not inherit arbitrary launcher environment variables.
+// Reapply project defaults in the actual app-server process, before loading Host.
+const { nativeEnvironment } = require('../src/main/native/config');
+Object.assign(process.env, nativeEnvironment());
+require('../src/main/native/host').runNativeHost().catch(error => {
+  console.error('[Harness Mix native host]', error.message);
+  process.exitCode = 1;
+});