@harness-mix/cli 0.1.3

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/harness-health-check.cjs

@@ -0,0 +1,72 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { HostRuntime } = require('../src/main/host/runtime');
+
+const option = name => process.argv.find(v => v.startsWith(`--${name}=`))?.slice(name.length + 3);
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+async function runTurn(rt, thread, text, attachments, timeoutMs) {
+  let done = false, failure;
+  const work = rt.send(thread.id, text, { attachments }).then(() => { done = true; }, error => { done = true; failure = error; });
+  const until = Date.now() + timeoutMs;
+  while ((!done || rt.execution.isRunning(thread.id) || thread.reviewPending) && Date.now() < until) {
+    const pending = thread.pendingApprovals?.[0];
+    if (pending) {
+      await rt.cancel(thread.id);
+      throw new Error(`waiting for native approval: ${pending.title || pending.requestId}`);
+    }
+    await delay(100);
+  }
+  if (!done || rt.execution.isRunning(thread.id)) {
+    await rt.cancel(thread.id).catch(() => {});
+    throw new Error(`turn did not settle within ${Math.ceil(timeoutMs / 1000)} seconds`);
+  }
+  await work;
+  if (failure) throw failure;
+  const turn = rt.execution.lastTurn(thread.id);
+  if (!turn || turn.status !== 'completed') throw new Error(`terminal status: ${turn?.status || 'missing'}`);
+  return rt.core.getItemsForTurn(turn.id).filter(i => i.type === 'agent_message').map(i => i.content || '').join('');
+}
+
+(async () => {
+  const directory = path.resolve('output', 'harness-health', String(Date.now()));
+  const workspace = path.join(directory, 'workspace');
+  await fs.mkdir(workspace, { recursive: true });
+  const rt = new HostRuntime({ dataDirectory: path.join(directory, 'data') });
+  const rows = [];
+  try {
+    await rt.initialize();
+    const selected = new Set((option('harness') || '').split(',').filter(Boolean));
+    const imagePath = option('image');
+    const imageOnly = process.argv.includes('--image-only');
+    const image = imagePath ? await fs.readFile(path.resolve(imagePath)) : null;
+    for (const adapter of rt.snapshot().adapters) {
+      const row = { harnessId: adapter.id, available: adapter.available, detail: adapter.detail,
+        declaredImage: adapter.capabilities.attachments === true, lead: adapter.capabilities.collaborationTools === true };
+      rows.push(row);
+      if (!process.argv.includes('--live') || !adapter.available || selected.size && !selected.has(adapter.id)) continue;
+      let thread;
+      try {
+        const runtimeAdapter = rt.adapters.get(adapter.id), nativeLead = runtimeAdapter.manifest.capabilities.collaborationTools;
+        runtimeAdapter.manifest.capabilities.collaborationTools = false;
+        try { thread = await rt.createThread({ harnessId: adapter.id, cwd: workspace, title: `Health ${adapter.id}` }); }
+        finally { runtimeAdapter.manifest.capabilities.collaborationTools = nativeLead; }
+        if (!imageOnly) {
+          const text = await runTurn(rt, thread, 'Reply exactly HARNESS_MIX_HEALTH_OK. Do not use tools or modify files.', [], 180000);
+          row.textSnippet = text.slice(0, 500);
+          row.textTurn = text.trim() === 'HARNESS_MIX_HEALTH_OK' ? 'passed' : 'unexpected_text';
+        }
+        if (image && row.declaredImage) {
+          const reply = await runTurn(rt, thread, 'Confirm that the attached image reached your native input, then reply exactly HARNESS_MIX_IMAGE_OK. Do not use tools or modify files.',
+            [{ kind: 'image', name: path.basename(imagePath), mime: 'image/png', data: image.toString('base64'), size: image.length }], 180000);
+          row.imageSnippet = reply.slice(0, 500);
+          row.imageTurn = reply.trim() === 'HARNESS_MIX_IMAGE_OK' ? 'passed' : 'unexpected_text';
+        }
+      } catch (error) { row.error = error.message; row.terminalError = thread?.error || null; }
+      finally { if (thread && rt.execution.isRunning(thread.id)) await rt.cancel(thread.id).catch(() => {}); }
+    }
+  } finally { await rt.close(); }
+  await fs.writeFile(path.join(directory, 'report.json'), JSON.stringify(rows, null, 2));
+  console.log(JSON.stringify(rows, null, 2));
+  console.log(`Report: ${directory}`);
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/kiro-cursor-adapters-test.cjs

@@ -0,0 +1,82 @@
+const assert = require('node:assert/strict');
+const { acpAdapter, catalog } = require('../src/main/adapters/acp');
+const { nativeCommand } = require('../src/main/adapters/native-acp-command');
+
+if (process.argv.includes('--fixture')) {
+  const readline = require('node:readline');
+  const write = value => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', ...value }) + '\n');
+  const configs = [{ id: 'model', currentValue: 'sonnet', options: [{ value: 'sonnet', name: 'Sonnet' }] }, { id: 'effortLevel', currentValue: 'medium', options: [{ value: 'high', name: 'High' }] }];
+  let prompt;
+  readline.createInterface({ input: process.stdin }).on('line', line => {
+    const r = JSON.parse(line);
+    if (r.id === 'permission') {
+      assert.equal(r.result.outcome.optionId, 'native-once');
+      write({ method: 'session/update', params: { update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'native reply' } } } });
+      write({ id: prompt, result: { stopReason: 'end_turn' } });
+      return;
+    }
+    let result = {};
+    if (r.method === 'initialize') result = { agentCapabilities: { loadSession: true } };
+    else if (r.method === 'session/new' || r.method === 'session/load') result = { sessionId: r.params.sessionId || 'native-session', configOptions: configs };
+    else if (r.method === 'session/set_config_option') { configs.find(c => c.id === r.params.configId).currentValue = r.params.value; result = { configOptions: configs }; }
+    else if (r.method === 'session/prompt') {
+      prompt = r.id;
+      write({ id: 'permission', method: 'session/request_permission', params: { toolCall: { title: 'Test native permission' }, options: [{ kind: 'allow_once', optionId: 'native-once' }] } });
+      return;
+    } else if (r.method === 'session/cancel') return;
+    if (r.id !== undefined) write({ id: r.id, result });
+  });
+} else {
+  (async () => {
+    for (const [id, key, argv] of [
+      ['qoder', 'HARNESS_MIX_QODER_EXECUTABLE', ['--acp']],
+      ['zcode', 'HARNESS_MIX_ZCODE_ACP_EXECUTABLE', []],
+      ['trae', 'HARNESS_MIX_TRAE_EXECUTABLE', []],
+    ]) {
+      const previous = process.env[key];
+      try {
+        delete process.env[key];
+        if (id !== 'qoder') assert.throws(() => nativeCommand(id, argv), /ACP/);
+        process.env[key] = __filename + '.missing';
+        assert.throws(() => nativeCommand(id, argv), /未安装/);
+        process.env[key] = __filename;
+        assert.deepEqual(nativeCommand(id, argv), { command: process.execPath, args: [__filename, ...argv] });
+      } finally { if (previous === undefined) delete process.env[key]; else process.env[key] = previous; }
+    }
+    for (const name of ['kiro', 'cursor']) {
+      const module = require('../src/main/adapters/' + name);
+      assert.equal(module.manifest.capabilities.fork, name === 'kiro');
+      assert.equal(module.manifest.capabilities.questions, true);
+      const key = name === 'kiro' ? 'HARNESS_MIX_KIRO_EXECUTABLE' : 'HARNESS_MIX_CURSOR_EXECUTABLE';
+      const previous = process.env[key];
+      try {
+        process.env[key] = __filename + '.missing';
+        assert.throws(() => nativeCommand(module.manifest.id, ['acp']), /未安装/);
+        assert.equal((await module.create().inspect()).available, false);
+        process.env[key] = process.execPath;
+        assert.deepEqual(nativeCommand(module.manifest.id, ['acp']), { command: process.execPath, args: ['acp'] });
+      } finally { if (previous === undefined) delete process.env[key]; else process.env[key] = previous; }
+    }
+    const adapter = acpAdapter({ id: 'fixture', name: 'Fixture', bin: () => ({ command: process.execPath, args: [__filename, '--fixture'] }), args: [], requestTimeoutMs: 5000 }).create();
+    const events = [];
+    let session;
+    const emit = event => {
+      events.push(event);
+      if (event.kind === 'approval') queueMicrotask(() => adapter.respond(session, event.requestId, { confirmed: true }));
+    };
+    try {
+      session = await adapter.open({ thread: { cwd: process.cwd() }, emit });
+      assert.equal(catalog(session).models[0].id, 'sonnet');
+      await adapter.setThinkingLevel(session, 'high');
+      assert.equal(session.state.configOptions[1].currentValue, 'high');
+      await adapter.send(session, 'hello', { emit });
+      assert.ok(events.some(e => e.text === 'native reply'));
+      assert.equal(events.filter(e => e.kind === 'completed').length, 1);
+      await adapter.close(session);
+      session = await adapter.open({ thread: { cwd: process.cwd(), restore: true, nativeSessionId: 'native-session' }, emit });
+      assert.equal(session.nativeSessionId, 'native-session');
+      await adapter.cancel(session);
+    } finally { if (session) await adapter.close(session); }
+    console.log('Kiro/Cursor: discovery isolation, config, native approval, streaming, resume and cancel PASS (fixture, not live model)');
+  })().catch(error => { console.error(error); 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-acp-depth-test.cjs

@@ -0,0 +1,189 @@
+const assert = require('node:assert/strict');
+const { nativeAcp, project } = require('../src/main/adapters/native-acp');
+const { AcpInteractions } = require('../src/main/adapters/acp-interactions');
+const { historyUsage, branch, latestAssistantAfterUser } = require('../src/main/adapters/codebuddy-history');
+const { projectUsage } = require('../src/main/native/usage');
+const { randomUUID } = require('node:crypto');
+
+if (process.argv.includes('--fixture')) {
+  const write = value => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', ...value }) + '\n');
+  let sid, pending, cancelled = false;
+  const heartbeat = process.argv.includes('--heartbeat');
+  const ignorePrompt = process.argv.includes('--ignore-prompt');
+  const delayedFinal = process.argv.includes('--delayed-final');
+  if (heartbeat) setInterval(() => { if (sid) write({ method: 'session/update', params: { sessionId: sid, update: { sessionUpdate: 'usage_update', used: 1, size: 100 } } }); }, 20).unref();
+  let configs = [{ id: 'model', currentValue: 'native[variant]', options: [{ value: 'native[variant]', name: 'Native' }, { value: 'other' }] },
+    { id: 'thought_level', currentValue: 'medium', options: [{ value: 'high', name: 'High' }, { value: 'medium' }] },
+    { id: 'mode', currentValue: 'default', options: [{ value: 'default' }, { value: 'plan' }] }];
+  require('node:readline').createInterface({ input: process.stdin }).on('line', line => {
+    const r = JSON.parse(line); let result = {};
+    if (r.method === 'initialize') result = { agentCapabilities: { loadSession: true, promptCapabilities: { image: !process.argv.includes('--no-images') }, sessionCapabilities: { fork: {} }, _meta: { kiro: { extensionMethods: ['_kiro/session/compact', '_kiro/session/context'] } } } };
+    if (r.method === 'session/new' || r.method === 'session/load') {
+      sid = r.params.sessionId || randomUUID();
+      // Replay and foreign sessions must never leak into the parent turn.
+      write({ method: 'session/update', params: { sessionId: sid, update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'REPLAY' } } } });
+      result = { sessionId: sid, configOptions: configs };
+    }
+    if (r.method === 'session/set_config_option') {
+      configs = configs.map(c => c.id === r.params.configId ? { ...c, currentValue: r.params.value } : c);
+      result = { configOptions: configs };
+    }
+    if (r.method === 'session/fork') { assert.equal(r.params._meta?.kiro?.messageId, 'native-end'); result = { sessionId: randomUUID() }; }
+    if (r.method === '_kiro/session/context') result = { usagePercentage: 23 };
+    if (r.method === 'session/prompt') {
+      if (r.params.prompt[0].text === 'image') assert.deepEqual(r.params.prompt[1], { type: 'image', data: 'AA==', mimeType: 'image/png' });
+      if (cancelled) { write({ id: r.id, error: { message: 'Old CodeBuddy connection still cancelled' } }); return; }
+      if (r.params.prompt[0].text === 'wait') { pending = r.id; return; }
+      if (ignorePrompt) return; // 模拟 agent 完全不响应、心跳单独存活
+      result = { stopReason: 'end_turn', userMessageId: 'native-user' };
+      if (delayedFinal) setTimeout(() => write({ method: 'session/update', params: { sessionId: sid, update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'LATE_OK' } } } }), 400);
+      else {
+        write({ method: 'session/update', params: { sessionId: sid + '-other', update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'FOREIGN' } } } });
+        write({ method: 'session/update', params: { sessionId: sid, update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'OK' } } } });
+      }
+    }
+    if (r.method === 'session/cancel') { if (process.argv.includes('--ignore-cancel')) return; cancelled = true; write({ id: pending, result: { stopReason: 'cancelled' } }); return; }
+    if (r.id !== undefined) write({ id: r.id, result });
+  });
+} else {
+  (async () => {
+    for (const vendor of ['codebuddy', 'kiro-cli', 'cursor-cli', 'qoder', 'zcode', 'trae']) {
+      const module = nativeAcp({ id: vendor, name: vendor, args: [], timeoutMs: 2000, command: () => ({ command: process.execPath, args: [__filename, '--fixture'] }) });
+      const adapter = module.create(), events = [];
+      let s;
+      try {
+        s = await adapter.open({ thread: { cwd: process.cwd() }, emit: e => events.push(e) });
+        assert.equal((await adapter.listModelsFor(s))[0].id, 'native[variant]');
+        await adapter.send(s, 'image', { emit: e => events.push(e) }, { images: [{ data: 'AA==', mime: 'image/png' }] });
+        events.length = 0;
+        await adapter.setModel(s, { id: 'other' });
+        if (vendor !== 'cursor-cli') await adapter.setThinkingLevel(s, 'high');
+        const first = adapter.send(s, 'wait', { emit: e => events.push(e) });
+        await assert.rejects(adapter.send(s, 'busy', { emit: () => {} }), /busy/);
+        await assert.rejects(adapter.setModel(s, { id: 'other' }), /busy/);
+        await adapter.cancel(s); await first;
+        if (vendor === 'codebuddy') {
+          assert.equal(s.model.id, 'other');
+          assert.equal(s.state.configOptions.find(c => c.id === 'thought_level').currentValue, 'high');
+          await adapter.send(s, 'after cancel', { emit: e => events.push(e) });
+          assert.equal(events.filter(e => e.kind === 'text-delta').map(e => e.text).join(''), 'OK');
+        }
+        if (vendor === 'kiro-cli') {
+          assert.equal((await adapter.getContextUsage(s)).contextUsagePercent, 23);
+          const fs = require('node:fs/promises'), path = require('node:path');
+          const saved = process.env.KIRO_HOME;
+          process.env.KIRO_HOME = path.resolve('output', 'kiro-history-test-' + randomUUID());
+          try {
+            const dir = path.join(process.env.KIRO_HOME, 'sessions', 'workspace', s.nativeSessionId);
+            await fs.mkdir(dir, { recursive: true });
+            await fs.writeFile(path.join(dir, 'session.json'), JSON.stringify({ id: s.nativeSessionId, workspacePaths: [process.cwd()] }));
+            await fs.writeFile(path.join(dir, 'messages.jsonl'), JSON.stringify({ id: 'native-user', payload: { type: 'user' } }) + '\n' + JSON.stringify({ id: 'native-end', payload: { type: 'turn_end' } }));
+            const fork = await adapter.fork({ cwd: process.cwd(), nativeSessionId: s.nativeSessionId }, { emit: () => {} });
+            assert.notEqual(fork.session.nativeSessionId, s.nativeSessionId); await adapter.close(fork.session);
+            await fs.appendFile(path.join(dir, 'messages.jsonl'), '\n' + JSON.stringify({ id: 'rewritten', payload: { type: 'tombstone' } }));
+            await assert.rejects(adapter.fork({ cwd: process.cwd(), nativeSessionId: s.nativeSessionId }, { emit: () => {} }), /Compacted/);
+          } finally { if (saved === undefined) delete process.env.KIRO_HOME; else process.env.KIRO_HOME = saved; }
+        }
+      } finally { await adapter.close(s); }
+    }
+    const events = [], s = { active: true, nativeSessionId: 's', emit: e => events.push(e) };
+    const noImages = nativeAcp({ id: 'qoder', name: 'Qoder', args: [],
+      command: () => ({ command: process.execPath, args: [__filename, '--fixture', '--no-images'] }) }).create();
+    const textOnly = await noImages.open({ thread: { cwd: process.cwd() }, emit: () => {} });
+    try {
+      await assert.rejects(noImages.send(textOnly, 'image', { emit: () => {} }, { images: [{ data: 'AA==', mime: 'image/png' }] }), /not supported/);
+      assert.equal(textOnly.active, false);
+      await noImages.send(textOnly, 'text still works', { emit: () => {} });
+    } finally { await noImages.close(textOnly); }
+    const unresponsive = nativeAcp({ id: 'cursor-cli', name: 'Cursor', args: [], timeoutMs: 500,
+      command: () => ({ command: process.execPath, args: [__filename, '--fixture', '--ignore-cancel'] }) }).create();
+    const stalled = await unresponsive.open({ thread: { cwd: process.cwd() }, emit: () => {} });
+    const stalledTurn = unresponsive.send(stalled, 'wait', { emit: () => {} });
+    const failedTurn = assert.rejects(stalledTurn);
+    await assert.rejects(unresponsive.cancel(stalled)); await failedTurn;
+    assert.ok(stalled.fault); await assert.rejects(unresponsive.send(stalled, 'again', { emit: () => {} }));
+    await unresponsive.close(stalled);
+    const idle = nativeAcp({ id: 'codebuddy', name: 'CodeBuddy', args: [], timeoutMs: 1000, turnIdleTimeoutMs: 100,
+      command: () => ({ command: process.execPath, args: [__filename, '--fixture'] }) }).create();
+    const idleSession = await idle.open({ thread: { cwd: process.cwd() }, emit: () => {} });
+    try {
+      await assert.rejects(idle.send(idleSession, 'wait', { emit: () => {} }), /no progress/);
+      assert.match(idleSession.fault.message, /no progress/);
+    } finally { await idle.close(idleSession); }
+    const cursor = new AcpInteractions(s, 'cursor-cli');
+    const plan = cursor.request('cursor/create_plan', { sessionId: 's', plan: 'Native plan' });
+    await assert.rejects(cursor.respond(events.at(-1).requestId, { value: 'invented' }));
+    await cursor.respond(events.at(-1).requestId, { value: 'reject' });
+    assert.equal((await plan).outcome.outcome, 'rejected');
+    const questions = cursor.request('cursor/ask_question', { questions: [{ id: 'q', prompt: 'Choose', options: [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }], allowMultiple: true }] });
+    await assert.rejects(cursor.respond(events.at(-1).requestId, { value: '["fake"]' }));
+    await cursor.respond(events.at(-1).requestId, { value: '["a","b"]' });
+    assert.deepEqual((await questions).outcome.answers, [{ questionId: 'q', selectedOptionIds: ['a', 'b'] }]);
+    const kiro = new AcpInteractions(s, 'kiro-cli');
+    const question = kiro.request('_kiro/userInput', { question: 'Why?' });
+    await kiro.respond(events.at(-1).requestId, { value: 'Because' });
+    assert.deepEqual(await question, { action: 'answered', answer: 'Because' });
+    let failures = 1, nativeAnswers;
+    s.request = async (method, p) => { assert.equal(method, '_codebuddy.ai/resolveInterruption'); if (failures--) throw new Error('retry'); nativeAnswers = p; return { resolved: true }; };
+    const buddy = new AcpInteractions(s, 'codebuddy');
+    const answer = buddy.request('session/request_permission', { toolCall: { toolCallId: 'tool', _meta: { 'codebuddy.ai/toolName': 'AskUserQuestion' }, rawInput: { questions: [{ question: 'Choose', options: [{ label: 'yes' }] }] } } });
+    const requestId = events.at(-1).requestId;
+    await assert.rejects(buddy.respond(requestId, { value: 'yes' }), /retry/);
+    await buddy.respond(requestId, { value: 'yes' });
+    assert.equal((await answer).outcome.outcome, 'cancelled');
+    assert.deepEqual(nativeAnswers.answers, { q_0: ['yes'] });
+    const permission = buddy.request('session/request_permission', { toolCall: {}, options: [{ optionId: 'native-always', name: 'Always', kind: 'allow_always' }] });
+    await buddy.respond(events.at(-1).requestId, { optionId: 'native-always' });
+    assert.equal((await permission).outcome.optionId, 'native-always');
+    const pending = kiro.request('_kiro/userInput', { question: 'Cancel?' }); kiro.close();
+    assert.deepEqual(await pending, { action: 'dismissed' });
+    const emitted = [], ps = { nativeSessionId: 's', active: true, vendor: 'cursor-cli', state: { usage: {} }, tools: new Map(), charges: new Map(), emit: e => emitted.push(e) };
+    const update = u => project(ps, { method: 'session/update', params: { sessionId: 's', update: u } });
+    const tool = { sessionUpdate: 'tool_call', toolCallId: 't', status: 'completed', content: [{ type: 'diff', path: 'a', oldText: 'old', newText: 'new' }] };
+    update(tool); update(tool);
+    assert.equal(emitted.filter(e => e.kind === 'file-change').length, 1);
+    // CodeBuddy Bash output: start has description content, completed update has rawOutput with stdout:
+    update({ sessionUpdate: 'tool_call', toolCallId: 'bash-1', title: '`ls`', status: 'in_progress', rawInput: { command: 'ls' }, content: [{ type: 'content', content: { type: 'text', text: 'List files' } }] });
+    update({ sessionUpdate: 'tool_call_update', toolCallId: 'bash-1', status: 'completed', rawOutput: { type: 'text', text: 'Command: ls\nStdout: a.js\nb.js\nExit Code: 0' } });
+    const bashTool = emitted.filter(e => e.kind === 'tool' && e.toolCallId === 'bash-1').at(-1);
+    assert.equal(bashTool?.state, 'completed');
+    assert.equal(bashTool?.output, 'Command: ls\nStdout: a.js\nb.js\nExit Code: 0');
+    update({ sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'CHILD' }, _meta: { 'codebuddy.ai/parentToolCallId': 't' } });
+    assert.equal(emitted.filter(e => e.kind === 'text-delta').length, 0);
+    const usage = historyUsage([{ providerData: { messageId: 'one', rawUsage: { credit: 2, prompt_tokens: 3 } } }, { providerData: { messageId: 'one', rawUsage: { credit: 2, prompt_tokens: 3 } } }]);
+    assert.equal(usage.totalCredits, 2); assert.equal(projectUsage(usage).totalCredits, 2); assert.equal(projectUsage(usage).totalCostUsd, undefined);
+    assert.equal(latestAssistantAfterUser([{ type: 'message', id: 'old-u', role: 'user', content: 'old' }, { type: 'message', id: 'old-a', role: 'assistant', content: 'old answer' },
+      { type: 'message', id: 'new-u', role: 'user', content: 'new' }, { type: 'function_call_result' }], 'new-u'), '', 'Do not replay an earlier answer when the current turn has none');
+    assert.equal(latestAssistantAfterUser([{ type: 'message', id: 'new-u', role: 'user', content: [{ type: 'input_text', text: 'new' }] },
+      { type: 'message', id: 'new-a', role: 'assistant', content: [{ type: 'output_text', text: 'native final' }] }], 'new-u'), 'native final');
+    assert.throws(() => branch([{ type: 'message', id: 'a', parentId: 'a' }]), /parent chain/);
+    // 进度事件重置 idle，heartbeat-only 不重置：心跳场景下 idle 应当照常起效。
+    const heartbeatOnly = nativeAcp({ id: 'codebuddy', name: 'CodeBuddy', args: [], timeoutMs: 1000, turnIdleTimeoutMs: 80, turnPromptTimeoutMs: 60_000, cancelGraceMs: 1000,
+      command: () => ({ command: process.execPath, args: [__filename, '--fixture', '--ignore-prompt', '--heartbeat'] }) }).create();
+    const heartbeatSession = await heartbeatOnly.open({ thread: { cwd: process.cwd() }, emit: () => {} });
+    try {
+      await assert.rejects(heartbeatOnly.send(heartbeatSession, 'alive', { emit: () => {} }), /no progress/);
+      assert.match(heartbeatSession.fault.message, /no progress/);
+    } finally { await heartbeatOnly.close(heartbeatSession); }
+    // 硬上限：即使心跳/usage_update 持续到天荒地老，turnPromptTimeoutMs 一定上到。
+    const hardCeiling = nativeAcp({ id: 'codebuddy', name: 'CodeBuddy', args: [], timeoutMs: 1000, turnIdleTimeoutMs: 5 * 60_000, turnPromptTimeoutMs: 80, cancelGraceMs: 1000,
+      command: () => ({ command: process.execPath, args: [__filename, '--fixture', '--ignore-prompt', '--heartbeat'] }) }).create();
+    const ceilingSession = await hardCeiling.open({ thread: { cwd: process.cwd() }, emit: () => {} });
+    try {
+      const t0 = Date.now();
+      await assert.rejects(hardCeiling.send(ceilingSession, 'forever', { emit: () => {} }), /hard ceiling/);
+      assert.ok(Date.now() - t0 < 2000, '硬上限应接近 80ms 触发，而不是被心跳重置');
+    } finally { await hardCeiling.close(ceilingSession); }
+    // Prompt receipt may precede the final ACP message notification. The
+    // bounded drain keeps the Core turn active long enough to project it.
+    const delayed = nativeAcp({ id: 'dsh', name: 'DSH', args: [], timeoutMs: 1000, turnEventDrainMs: 100, turnEventDrainMaxMs: 900,
+      command: () => ({ command: process.execPath, args: [__filename, '--fixture', '--delayed-final'] }) }).create();
+    const delayedEvents = [];
+    const delayedSession = await delayed.open({ thread: { cwd: process.cwd() }, emit: e => delayedEvents.push(e) });
+    try {
+      await delayed.send(delayedSession, 'late', { emit: () => {} });
+      assert.equal(delayedEvents.filter(e => e.kind === 'text-delta').map(e => e.text).join(''), 'LATE_OK');
+    } finally { await delayed.close(delayedSession); }
+    console.log('Native ACP depth: cancel/reconnect, session isolation, exact approvals, question retry/multi-select, plan, Kiro context/fork, diff dedup and credits PASS');
+  })().catch(error => { console.error(error); process.exitCode = 1; });
+}

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, 'win32');
+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, 'win32').state, 'verified');
+assert.equal(evaluateDesktopCompatibility('26.999.2.0', manifest, 'win32').state, 'unverified');
+assert.throws(() => evaluateDesktopCompatibility('latest', manifest, 'win32'), /Invalid/);
+
+const blockedManifest = { ...manifest, blockedDesktopVersions: ['26.999.3.0'] };
+const blocked = evaluateDesktopCompatibility('26.999.3.0', blockedManifest, 'win32');
+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;
+});