@harness-mix/cli 0.1.3

package/scripts/core-runtime-test.cjs

@@ -0,0 +1,104 @@
+const { ParityObserver } = require('./support/parity-observer.cjs');
+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 sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+async function until(fn) {
+  for (let i = 0; i < 200; i++) { if (fn()) return; await sleep(10); }
+  throw new Error('timed out');
+}
+(async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-core-runtime-'));
+  const root = path.join(directory, 'workspace'); await fs.mkdir(root);
+  const rt = new HostRuntime({ observer: new ParityObserver(), dataDirectory: directory });
+  await rt.store.load();
+  let emit, sent = 0, mode = 'hold', rejectResponse = false;
+  const adapter = {
+    manifest: { id: 'test-harness', name: 'Test', capabilities: {} },
+    async open(input) { emit = input.emit; return {}; },
+    async send() {
+      sent++;
+      const turn = rt.execution.lastTurn(thread.id);
+      assert.equal(turn.status, 'running', 'Core Turn exists before native send');
+      if (mode === 'failure') throw new Error('native failure');
+    },
+    async cancel() { emit({ kind: 'completed', finalAnswer: true }); emit({ kind: 'text-delta', text: 'LATE' }); },
+    async respond() { if (rejectResponse) throw new Error('response failed'); },
+    async close() {},
+  };
+  rt.adapters.set(adapter.manifest.id, adapter); rt.status[adapter.manifest.id] = { available: true };
+  const thread = await rt.createThread({ harnessId: adapter.manifest.id, cwd: root });
+  try {
+    await rt.send(thread.id, 'hello');
+    const first = thread.messages.at(-1).coreTurnId;
+    const notices = []; const unsubscribe = rt.subscribe(event => notices.push(event));
+    emit({ kind: 'status', text: 'native progress' });
+    assert.ok(notices.some(event => event.type === 'toast' && event.threadId === thread.id));
+    unsubscribe();
+    emit({ kind: 'approval', requestId: 'a', method: 'confirm', title: 'Allow?' });
+    emit({ kind: 'approval', requestId: 'q', method: 'input', title: 'Name?' });
+    assert.equal(rt.execution.lastTurn(thread.id).status, 'waiting_interaction');
+    rejectResponse = true;
+    await assert.rejects(rt.respondApproval(thread.id, 'a', {}), /response failed/);
+    assert.equal(rt.execution.lastTurn(thread.id).status, 'waiting_interaction');
+    rejectResponse = false;
+    await rt.respondApproval(thread.id, 'a', { confirmed: true });
+    assert.equal(rt.execution.lastTurn(thread.id).status, 'waiting_interaction');
+    await rt.respondApproval(thread.id, 'q', { value: 'test' });
+    assert.equal(rt.execution.lastTurn(thread.id).status, 'running');
+    emit({ kind: 'thinking-delta', text: 'think' });
+    emit({ kind: 'text-delta', text: 'answer' });
+    emit({ kind: 'usage', usage: { inputTokens: 10 } });
+    await fs.writeFile(path.join(root, 'change.txt'), 'Core review content');
+    emit({ kind: 'completed', finalAnswer: true });
+    await until(() => (thread.status === 'ready' && !thread.reviewPending));
+    assert.equal(thread.messages.at(-1).coreTurn.status, 'completed');
+    const completedMessage = thread.messages.at(-1);
+    const review = await rt.readReview(thread, completedMessage);
+    assert.equal(review.files[0].type, 'file_change');
+    assert.equal(review.files[0].source, 'snapshot');
+    assert.equal((await rt.readReview(thread, completedMessage, 'change.txt')).rows[0].kind, 'add');
+    await rt.undoFile(thread.id, completedMessage.id, 'change.txt');
+    assert.equal(completedMessage.coreReview.files[0].undone, true);
+    await assert.rejects(fs.access(path.join(root, 'change.txt')));
+    assert.ok(thread.messages.at(-1).coreItems.some(i => i.phase === 'final' && i.content === 'answer'));
+    assert.deepEqual(rt.shadowReport().mismatches, []);
+    await rt.send(thread.id, 'cancel');
+    assert.notEqual(thread.messages.at(-1).coreTurnId, first);
+    await rt.cancel(thread.id);
+    await until(() => (thread.status === 'ready' && !thread.reviewPending));
+    assert.equal(thread.messages.at(-1).coreTurn.status, 'cancelled');
+    assert.equal(thread.messages.at(-1).text, '');
+    mode = 'failure';
+    await rt.send(thread.id, 'fail');
+    await until(() => thread.status === 'error' && !thread.reviewPending);
+    assert.equal(thread.messages.at(-1).coreTurn.status, 'error');
+    mode = 'hold';
+    let release;
+    const begin = rt.reviews.begin.bind(rt.reviews);
+    rt.reviews.begin = () => new Promise(resolve => { release = resolve; });
+    const before = sent;
+    const pending = rt.send(thread.id, 'cancel during preparation');
+    await until(() => release);
+    await rt.cancel(thread.id);
+    release(undefined); await pending;
+    await until(() => (thread.status === 'ready' && !thread.reviewPending));
+    assert.equal(sent, before);
+    assert.equal(thread.messages.at(-1).coreTurn.status, 'cancelled');
+    rt.reviews.begin = begin;
+    assert.deepEqual(rt.shadowReport().errors, []);
+    await rt.close();
+    const saved = await rt.store.load();
+    assert.equal(saved[0].messages.find(m => m.coreTurnId === first).coreTurn.status, 'completed');
+    const restored = new HostRuntime({ dataDirectory: directory });
+    restored.threads = await restored.store.load();
+    for (const record of restored.threads) restored.execution.threadCreated(record);
+    assert.equal(restored.core.getTurn(first).status, 'completed');
+    assert.ok(restored.core.getItemsForTurn(first).some(i => i.type === 'file_change' && i.undone));
+    assert.equal(restored.shadowReport().enabled, false);
+    await restored.close();
+    console.log('core-runtime: independent turns, waiting/responses, failure, cancel races, persistence passed');
+  } finally { await rt.close(); }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/core-services-test.cjs

@@ -0,0 +1,50 @@
+const assert = require('node:assert/strict');
+const { ProtocolCore } = require('../src/main/protocol-core');
+const { ShadowMirror } = require('./support/shadow.cjs');
+const { CapabilityManager } = require('../src/main/protocol-core/capability-manager');
+const { normalizeCapabilities } = require('../src/main/harness-adapter/manifest');
+
+(async () => {
+  const core = new ProtocolCore();
+  const shadow = new ShadowMirror({ core });
+  const thread = { id: 't', cwd: '/test', messages: [{ role: 'assistant', at: 1 }] };
+  shadow.threadCreated(thread); shadow.turnStarted(thread, 'test');
+  const turn = shadow.lastTurn('t');
+  const emit = e => shadow.applyLegacyEvent(thread, e);
+  emit({ kind: 'approval', requestId: 'q', method: 'input', title: 'Question' });
+  assert.equal(core.interactions.pending('t').length, 1);
+  let release, calls = 0;
+  const response = core.interactions.respond('t', 'q', {}, async () => { calls++; await new Promise(resolve => { release = resolve; }); });
+  await assert.rejects(core.interactions.respond('t', 'q', {}, () => {}), /正在提交/);
+  await assert.rejects(core.interactions.respond('other', 'q', {}, () => {}), /过期/);
+  release(); await response;
+  assert.equal(calls, 1); assert.equal(turn.status, 'running');
+  assert.equal(core.interactions.pending('t').length, 0);
+  const files = (source, changes, replace = false) => core.dispatch({ threadId: 't', turnId: turn.id,
+    type: 'files.updated', payload: { source, changes, replace } });
+  files('snapshot', [{ path: 'a', before: 'x', after: 'y', complete: true }]);
+  files('native', [{ path: 'a', patch: 'incomplete', complete: false }]);
+  assert.equal(core.getItemsForTurn(turn.id).find(i => i.type === 'file_change').source, 'snapshot');
+  files('native', [{ path: 'a', before: 'x', after: 'y', complete: true }]);
+  files('snapshot', [{ path: 'a', after: 'other' }]);
+  const changes = core.getItemsForTurn(turn.id).filter(i => i.type === 'file_change');
+  assert.equal(changes.length, 1); assert.equal(changes[0].source, 'native');
+  files('git', [{ path: 'b', after: 'z' }]);
+  files('git', [], true);
+  assert.equal(core.getItemsForTurn(turn.id).filter(i => i.type === 'file_change').length, 1);
+  emit({ kind: 'plan', entries: [{ content: 'Inspect', status: 'in_progress' }] });
+  emit({ kind: 'plan', entries: [{ content: 'Inspect', status: 'completed' }] });
+  assert.equal(core.getItemsForTurn(turn.id).filter(i => i.type === 'plan').length, 1);
+  assert.equal(core.getItemsForTurn(turn.id).find(i => i.type === 'plan').entries[0].status, 'completed');
+  core.dispatch({ threadId: 't', turnId: turn.id, type: 'turn.completed' });
+  files('snapshot', [{ path: 'c', after: 'settled review' }]);
+  assert.ok(core.getItemsForTurn(turn.id).some(i => i.path === 'c'));
+  const caps = new CapabilityManager();
+  caps.register('new-harness', normalizeCapabilities({ fork: true, questions: true, plan: true }));
+  caps.require('new-harness', 'session', 'fork');
+  assert.throws(() => caps.require('new-harness', 'model', 'selection'));
+  const copy = caps.get('new-harness'); copy.session.fork = false;
+  assert.equal(caps.get('new-harness').session.fork, true);
+  assert.deepEqual(shadow.report().errors, []);
+  console.log('core-services: interaction race/ownership, capability negotiation, native precedence, file replacement and plan passed');
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/determinism-test.cjs

@@ -0,0 +1,36 @@
+const assert = require('node:assert/strict');
+const { ProtocolCore } = require('../src/main/protocol-core');
+
+// A captured CoreEvent stream must replay without pre-created objects or a clock.
+const events = [
+  { type: 'thread.created', payload: { workspaceId: '/fixture' } },
+  { type: 'turn.started', turnId: 'native-turn' },
+  { type: 'item.started', turnId: 'native-turn', itemId: 'answer', payload: { type: 'agent_message' } },
+  { type: 'item.delta', turnId: 'native-turn', itemId: 'answer', payload: { text: 'hello' } },
+  { type: 'usage.updated', turnId: 'native-turn', payload: { inputTokens: 12 } },
+  { type: 'usage.updated', turnId: 'native-turn', payload: { outputTokens: 3 } },
+  { type: 'turn.waiting', turnId: 'native-turn' },
+  { type: 'turn.completed', turnId: 'native-turn' },
+].map((e, index) => ({ ...e, threadId: 'thread', eventId: `e${index}`, timestamp: 1000 + index, sequence: index + 1 }));
+function replay(clock) {
+  const original = Date.now;
+  Date.now = () => clock;
+  try {
+    const core = new ProtocolCore();
+    for (const event of events) core.dispatch(structuredClone(event));
+    return structuredClone(core.snapshot());
+  } finally { Date.now = original; }
+}
+const first = replay(9000);
+assert.deepEqual(first, replay(999999));
+assert.equal(first.turns[0].id, 'native-turn');
+assert.equal(first.turns[0].startedAt, 1001);
+assert.equal(first.turns[0].completedAt, 1007);
+assert.equal(first.items[0].content, 'hello');
+assert.deepEqual(first.turns[0].itemIds, ['answer', 'usage_native-turn']);
+const core = new ProtocolCore();
+for (const event of events) core.dispatch(structuredClone(event));
+const settled = structuredClone(core.snapshot());
+core.dispatch({ threadId: 'thread', turnId: 'native-turn', itemId: 'answer', type: 'item.updated', payload: { content: 'late rewrite' } });
+assert.deepEqual(core.snapshot().items, settled.items, 'terminal items cannot be rewritten');
+console.log('determinism: exact snapshots and native turn identity passed');

package/scripts/diagnostics.cjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// Bundles versions, update/runtime state and redacted log tails into
+// output/diagnostics-<timestamp>.zip for bug reports. Read-only: touches
+// nothing in the desktop, host or install.
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { nativeEnvironment } = require('../src/main/native/config');
+const { redactText } = require('../src/main/native/redact');
+
+const root = path.resolve(__dirname, '..');
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+const stage = fs.mkdtempSync(path.join(os.tmpdir(), 'hm-diagnostics-'));
+const out = path.join(root, 'output');
+fs.mkdirSync(out, { recursive: true });
+
+const run = (command, args) => {
+  try { return execFileSync(command, args, { encoding: 'utf8', windowsHide: true, timeout: 30000 }).trim(); }
+  catch (error) { return `unavailable: ${error.message}`; }
+};
+const tail = (file, lines = 200) => {
+  try {
+    const rows = fs.readFileSync(file, 'utf8').split('\n');
+    return rows.slice(-lines).map(redactText).join('\n');
+  } catch { return '(missing)'; }
+};
+const write = (name, content) => fs.writeFileSync(path.join(stage, name), String(content));
+
+const env = nativeEnvironment();
+const data = env.CODEXHOST_DATA_DIR;
+write('versions.json', JSON.stringify({
+  'harness-mix': pkg.version,
+  node: process.version,
+  npm: run(process.platform === 'win32' ? 'npm.cmd' : 'npm', ['--version']),
+  cargo: run('cargo', ['--version']),
+  platform: process.platform,
+  os: os.release(),
+  check: run(process.execPath, [path.join(root, 'scripts', 'launch-codex.cjs'), '--check']),
+}, null, 2));
+write('update-state.json', tail(path.join(data, 'update-state.json'), 400));
+write('instance.json', tail(path.join(data, 'runtime', 'instance.json'), 400));
+write('host-traffic.tail.jsonl', tail(path.join(data, 'host-traffic.jsonl')));
+write('shim-invocations.tail.log', tail(path.join(root, 'output', 'native-build', 'shim-invocations.log')));
+const crashDir = path.join(data, 'runtime');
+if (fs.existsSync(crashDir)) {
+  for (const name of fs.readdirSync(crashDir).filter(entry => entry.startsWith('crash-')).slice(-3)) {
+    write(name, tail(path.join(crashDir, name), 400));
+  }
+}
+
+const zip = path.join(out, `diagnostics-${stamp}.${process.platform === 'win32' ? 'zip' : 'tar.gz'}`);
+// bsdtar treats "E:\..." as a remote host:path spec, so pack via PowerShell.
+if (process.platform === 'win32') {
+  const script = `Compress-Archive -Path '${path.join(stage, '*').replace(/'/g, "''")}' -DestinationPath '${zip.replace(/'/g, "''")}' -Force`;
+  run('pwsh.exe', ['-NoLogo', '-NoProfile', '-Command', script]);
+} else {
+  run('tar', ['-czf', zip, '-C', stage, '.']);
+}
+if (!fs.existsSync(zip)) throw new Error('诊断打包失败：需要 PowerShell 7 (Windows) 或 tar (macOS/Linux)');
+try { fs.rmSync(stage, { recursive: true, force: true }); } catch { /* leave for inspection */ }
+console.log(`[Harness Mix] 诊断包已生成：${zip}`);

package/scripts/docs-command-test.cjs

@@ -0,0 +1,49 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const root = path.resolve(__dirname, '..');
+const packageJson = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const scripts = new Set(Object.keys(packageJson.scripts || {}));
+const shellFence = /^(powershell|pwsh|bash|sh|shell|cmd|console)?$/i;
+
+function markdownFiles(directory) {
+  if (!fs.existsSync(directory)) return [];
+  return fs.readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const target = path.join(directory, entry.name);
+    if (entry.isDirectory()) return markdownFiles(target);
+    return entry.isFile() && entry.name.endsWith('.md') ? [target] : [];
+  });
+}
+
+const files = [path.join(root, 'README.md'), ...markdownFiles(path.join(root, 'docs'))];
+const missing = [];
+let checked = 0;
+
+for (const file of files) {
+  const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/);
+  let inShellFence = false;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const fence = line.match(/^\s*```([^`]*)\s*$/);
+    if (fence) {
+      if (inShellFence) inShellFence = false;
+      else inShellFence = shellFence.test(fence[1].trim());
+      continue;
+    }
+    if (!inShellFence || /^\s*#/.test(line)) continue;
+    for (const match of line.matchAll(/\bnpm(?:\.cmd)?\s+run\s+([A-Za-z0-9:_-]+)/g)) {
+      checked += 1;
+      if (!scripts.has(match[1])) {
+        missing.push(`${path.relative(root, file)}:${index + 1} npm run ${match[1]}`);
+      }
+    }
+  }
+}
+
+if (missing.length) {
+  console.error('Documented npm scripts missing from package.json:');
+  for (const item of missing) console.error(`- ${item}`);
+  process.exitCode = 1;
+} else {
+  console.log(`docs-command: ${checked} runnable npm commands verified across ${files.length} files`);
+}

package/scripts/dsh-adapter-test.cjs

@@ -0,0 +1,90 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { projectWireEvent, flattenCatalog } = require('../src/main/adapters/dsh');
+
+// DSH Web Remote 投影单元测试：session/follow 帧 + $events waterfall + 模型目录。
+// 帧形状以 fixtures/dsh/*.jsonl（真实捕获）为准。
+
+function fixture(name) {
+  return fs.readFileSync(path.join(__dirname, '..', 'fixtures', 'dsh', name), 'utf8')
+    .split('\n').filter(Boolean).map(JSON.parse);
+}
+
+// 1. 真实 fixture：tool-call 全链路投影
+const toolEvents = fixture('tool-call.jsonl').flatMap((frame) => projectWireEvent(frame).filter(Boolean));
+assert.ok(toolEvents.some((e) => e.kind === 'tool' && e.state === 'running'), 'tool/call → running');
+assert.ok(toolEvents.some((e) => e.kind === 'tool' && e.state === 'done' && /harness-mix-fixture/.test(e.output ?? '')), 'tool/result → done + 输出');
+assert.ok(toolEvents.some((e) => e.kind === 'completed' && e.finalAnswer === true), 'turn/end → completed');
+assert.ok(toolEvents.some((e) => e.kind === 'usage'), 'usage 事件');
+
+// 2. text-delta 流式增量（真实 fixture 的 chunk 序列）
+const deltas = fixture('simple-message.jsonl').flatMap((frame) => projectWireEvent(frame)).filter((e) => e.kind === 'text-delta');
+assert.ok(deltas.length >= 1 && deltas.map((d) => d.text).join('').includes('收到'), 'assistant/chunk text-delta 流式投影');
+
+// 3. assistant/message 只记检查点不重复投影文本（chunk 已覆盖）
+const messageFrames = fixture('simple-message.jsonl').filter((f) => f.event?.type === 'assistant/message');
+const session = { nativeSessionId: 'session-x', state: {} };
+const fromMessage = messageFrames.flatMap((f) => projectWireEvent(f, session));
+assert.ok(!fromMessage.some((e) => e.kind === 'text-delta'), 'assistant/message 不产生重复文本');
+assert.equal(session.state.checkpointSeq, messageFrames.at(-1).event.seq, '检查点 seq 记录');
+const fallbackSession = { nativeSessionId: 'session-fallback', state: { turn: { answer: '' } } };
+const fallback = messageFrames.flatMap((f) => projectWireEvent(f, fallbackSession));
+assert.equal(fallback.filter(e => e.kind === 'text-delta').map(e => e.text).join(''), '收到', '缺失 chunk 时从 committed assistant/message 补齐文本');
+const end = fixture('simple-message.jsonl').filter((f) => f.event?.type === 'turn/end').flatMap((f) => projectWireEvent(f, session));
+assert.equal(end.find((e) => e.kind === 'completed').nativeRef.checkpointId, String(session.state.checkpointSeq), 'completed 携带 fork 边界');
+
+// 4. request/context 更新上下文窗口与模型
+const ctx = projectWireEvent({ type: 'event', event: { type: 'request/context', seq: 9, time: 0, data: { provider: 'deepseek-official', model: 'deepseek-v4-flash', contextWindow: 1000000 } } }, session);
+assert.equal(session.state.contextWindow, 1000000);
+assert.ok(ctx.some((e) => e.kind === 'session' && e.model?.id === 'deepseek-v4-flash'), 'request/context → 模型更新');
+
+// 5. usage chunk → contextPercent 计算
+const withUsage = projectWireEvent({ type: 'event', event: { type: 'assistant/chunk', seq: 10, time: 0, data: { turn: 1, step: 1, chunk: { type: 'usage', usage: { inputTokens: 50000, outputTokens: 100, totalTokens: 50100, cacheReadTokens: 0, reasoningTokens: 0 } } } } }, session);
+const usage = withUsage.find((e) => e.kind === 'usage').usage;
+assert.equal(usage.tokens, 50000);
+assert.equal(usage.contextWindow, 1000000);
+assert.ok(Math.abs(usage.contextPercent - 5) < 0.01, 'contextPercent 由原生窗口计算');
+
+// 6. 审批 waterfall → approval 卡片；应答 → allowed-once / rejected / cancelled
+(async () => {
+const { manifest, create } = require('../src/main/adapters/dsh');
+assert.equal(manifest.capabilities.approvals, true);
+assert.equal(manifest.capabilities.fork, true);
+assert.equal(manifest.capabilities.questions, true);
+const adapter = create();
+const answered = [];
+const fakeSession = {
+  nativeSessionId: 'session-1',
+  pendingApprovals: new Map(),
+  host: { answerWaterfall: async (eventId, outcome) => answered.push({ eventId, outcome }) },
+};
+fakeSession.pendingApprovals.set('dsh-evt-1', { eventId: 'evt-1', isQuestion: false });
+await adapter.respond(fakeSession, 'dsh-evt-1', { optionId: 'allowed-once' });
+assert.deepEqual(answered.at(-1), { eventId: 'evt-1', outcome: { kind: 'result', value: 'allowed-once' } }, '允许 → allowed-once');
+fakeSession.pendingApprovals.set('dsh-evt-2', { eventId: 'evt-2', isQuestion: false });
+await adapter.respond(fakeSession, 'dsh-evt-2', { cancelled: true });
+assert.deepEqual(answered.at(-1), { eventId: 'evt-2', outcome: { kind: 'result', value: 'cancelled' } }, '取消 → cancelled');
+
+// 7. 提问 waterfall（无选项 → 自由文本 custom；有选项 → selected）
+fakeSession.pendingApprovals.set('dsh-evt-3', { eventId: 'evt-3', isQuestion: true, question: { id: 'q1' } });
+await adapter.respond(fakeSession, 'dsh-evt-3', { value: '自由回答' });
+assert.deepEqual(answered.at(-1).outcome.value, { answers: [{ id: 'q1', selected: [], custom: '自由回答' }] }, '自由文本提问 → custom');
+fakeSession.pendingApprovals.set('dsh-evt-4', { eventId: 'evt-4', isQuestion: true, question: { id: 'q2', options: [{ label: '红色' }] } });
+await adapter.respond(fakeSession, 'dsh-evt-4', { optionId: '红色' });
+assert.deepEqual(answered.at(-1).outcome.value, { answers: [{ id: 'q2', selected: ['红色'] }] }, '选项提问 → selected');
+
+// 8. 模型目录展平（provider 分组 + reasoning efforts）
+const models = flattenCatalog({
+  default: { provider: 'p1', model: 'm1' },
+  groups: [{ id: 'p1', name: 'P1', models: [
+    { id: 'm1', name: 'M1', reasoning: { efforts: [{ id: 'low' }, { id: 'high' }], defaultEffort: 'low' } },
+    { id: 'm2', name: 'M2' },
+  ] }],
+});
+assert.equal(models.length, 2);
+assert.deepEqual(models[0], { id: 'm1', name: 'M1', provider: 'p1', description: undefined, efforts: [{ id: 'low', label: 'low', hint: undefined }, { id: 'high', label: 'high', hint: undefined }], defaultEffort: 'low' });
+assert.equal(models[1].efforts, undefined);
+
+console.log('dsh-adapter: Web Remote 工具/diff 边界/用量/审批/提问/目录投影 passed');
+})().catch((error) => { console.error(error); process.exitCode = 1; });

package/scripts/dsh-collaboration-acp-test.cjs

@@ -0,0 +1,19 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { HostRuntime } = require('../src/main/host/runtime');
+
+(async () => {
+  const directory = await fs.mkdtemp(path.resolve('output/dsh-collaboration-acp-'));
+  const rt = new HostRuntime({ dataDirectory: path.join(directory, 'data') });
+  try {
+    await rt.initialize();
+    const thread = await rt.createThread({ harnessId: 'dsh', cwd: directory, title: 'DSH ACP lead probe' });
+    const session = rt.sessions.get(thread.id);
+    assert.equal(session.dshAcpLead, true);
+    assert.equal(session.collaborationEnabled, true);
+    assert.ok(session.mcpServers.some(server => server.name === 'harness-mix'));
+    assert.ok(session.nativeSessionId);
+    console.log('DSH lead: official ACP session accepted the session-scoped Harness Mix MCP server PASS');
+  } finally { await rt.close(); }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/dsh-native.cjs

@@ -0,0 +1,9 @@
+const { spawn } = require('node:child_process');
+const path = require('node:path');
+const root = process.env.HARNESS_MIX_DSH_ROOT;
+const entry = root ? ['--import', 'tsx/esm', path.join(root, 'apps/cli/src/bin.ts')] : [require.resolve('@deepseek-ai/dsh/lib/bin.js')];
+const child = spawn(process.execPath, [...entry, ...process.argv.slice(2)], {
+  cwd: root || process.cwd(), env: process.env, stdio: 'inherit', windowsHide: true,
+});
+child.on('error', error => { console.error(error.message); process.exitCode = 1; });
+child.on('exit', code => { process.exitCode = code ?? 1; });

package/scripts/dsh-native.cmd

@@ -0,0 +1,2 @@
+@echo off
+"%HARNESS_MIX_NODE_PATH%" "%~dp0dsh-native.cjs" %*

package/scripts/e2e-codex.cjs

@@ -0,0 +1,82 @@
+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 { CodexAppServer } = require('../src/main/adapters/codex-app-server');
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+async function settle(thread) {
+  for (let i = 0; i < 900 && (thread.status === 'working' || thread.reviewPending); i++) await sleep(200);
+  assert.equal(thread.status, 'ready', thread.error);
+}
+
+(async () => {
+  const dataDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-codex-e2e-data-'));
+  const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-codex-e2e-work-'));
+  const nativeIds = new Set();
+  let runtime;
+  try {
+    runtime = new HostRuntime({ dataDirectory });
+    await runtime.initialize();
+    const source = await runtime.createThread({
+      harnessId: 'codex', cwd, title: 'Codex native E2E',
+      options: { permissionMode: ':danger-full-access' },
+    });
+    assert.notEqual(source.status, 'error', source.error);
+    nativeIds.add(source.nativeSessionId);
+    const catalog = await runtime.describe('codex');
+    assert.ok(catalog.models.length > 0 && catalog.thinkingLevels.length > 0);
+    const selectedModel = catalog.models.find(model => model.isDefault) ?? catalog.models[0];
+    await runtime.setModel(source.id, selectedModel);
+    await runtime.setThinking(source.id, selectedModel.defaultEffort ?? selectedModel.efforts[0].id);
+
+    await runtime.send(source.id, 'Remember CODEX-FORK-4172. Reply exactly READY-4172. Do not use tools.');
+    await settle(source);
+    const boundary = source.messages.at(-1);
+    assert.match(boundary.text, /READY-4172/);
+    assert.ok(boundary.coreTurn.nativeTurnRef.turnId, 'native Codex turn id captured');
+
+    await runtime.send(source.id, 'Remember LATER-9386 too. Reply exactly LATER-OK. Do not use tools.');
+    await settle(source);
+    const fork = await runtime.forkThread(source.id, boundary.id);
+    nativeIds.add(fork.nativeSessionId);
+    assert.notEqual(fork.nativeSessionId, source.nativeSessionId);
+    assert.equal(fork.messages.length, 2, 'fork UI history ends at selected reply');
+
+    const forkNativeId = fork.nativeSessionId;
+    await runtime.close();
+    runtime = new HostRuntime({ dataDirectory });
+    await runtime.initialize();
+    const resumed = runtime.threads.find(thread => thread.nativeSessionId === forkNativeId);
+    assert.ok(resumed?.restore, 'persisted Codex task is lazily resumable');
+    await runtime.send(resumed.id, 'What CODEX-FORK token did I ask you to remember? Reply only the token.');
+    await settle(resumed);
+    assert.match(resumed.messages.at(-1).text, /CODEX-FORK-4172/);
+    assert.doesNotMatch(resumed.messages.at(-1).text, /LATER-9386/);
+    const usage = await runtime.refreshUsage(resumed.id);
+    assert.ok(usage.tokens > 0 && usage.contextWindow > 0 && usage.contextPercent > 0);
+    await runtime.executeCommand(resumed.id, 'compact');
+    await settle(resumed);
+    assert.match(resumed.messages.at(-1).text, /Codex 压缩/);
+
+    await fs.mkdir('output/verification', { recursive: true });
+    await fs.writeFile('output/verification/codex-native.json', JSON.stringify({
+      at: new Date().toISOString(), sourceId: source.nativeSessionId, forkId: forkNativeId,
+      boundaryTurnId: boundary.coreTurn.nativeTurnRef.turnId,
+      streamingReply: boundary.text, resumedReply: resumed.messages.at(-1).text,
+      laterTurnsExcluded: true, nativeCompact: true, models: catalog.models.length, usage,
+    }, null, 2));
+    console.log('codex: native app-server streaming, usage, reply fork and cold resume passed');
+  } finally {
+    if (nativeIds.size) {
+      const host = await CodexAppServer.acquire().catch(() => null);
+      if (host) {
+        for (const threadId of nativeIds) await host.request('thread/delete', { threadId }).catch(() => {});
+        host.release();
+      }
+    }
+    await runtime?.close().catch(() => {});
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/e2e-collaboration.cjs

@@ -0,0 +1,60 @@
+// Real model-driven collaboration. Arguments: --lead=pi --worker=pi
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+const { HostRuntime } = require('../src/main/host/runtime');
+const { git } = require('../src/main/host/collaboration-worktree');
+const recorder = require('../src/main/harness-adapter/fixture-recorder');
+const arg = (name, fallback) => process.argv.find(a => a.startsWith(`--${name}=`))?.slice(name.length + 3) || fallback;
+async function main() {
+  await fs.mkdir('output', { recursive: true });
+  const root = await fs.mkdtemp(path.resolve('output/collaboration-live-'));
+  const rt = new HostRuntime({ dataDirectory: path.join(root, 'data') });
+  const project = path.join(root, 'project'); await fs.mkdir(project);
+  await git(project, ['init']); await fs.writeFile(path.join(project, 'README.md'), 'Isolated collaboration verification.\n');
+  await git(project, ['add', '.']); await git(project, ['-c', 'user.name=Test', '-c', 'user.email=test@example.invalid', 'commit', '-m', 'fixture']);
+  const from = arg('lead', 'pi'), worker = arg('worker', 'pi');
+  const cycle = process.argv.includes('--cycle');
+  rt.subscribe(e => { if (e.type === 'toast') console.log(e.level, String(e.text).slice(0, 220)); });
+  try {
+    await rt.initialize();
+    const lead = await rt.createThread({ harnessId: from, cwd: project, title: 'Native collaboration verification' });
+    if (process.argv.includes('--record')) recorder.startRecording(from, 'collaboration-lead', path.join(root, 'recording'));
+    const prompt = cycle
+      ? `这是一个协作流程验收夹具，所有文件只在当前测试目录内。你是协调者，禁止自己编写或修复文件。先用 update_agent_plan 建立计划。用 delegate_to_agent 委派 @${worker} 创建 answer.cjs，内容为 module.exports = 41;（这是故意准备的错误样本，供下一步审查）。等待完成后，另委派 @pi 作为独立只读审查者：读取 answer.cjs，检查导出值是否严格等于 42，不符合时回复 REVIEW_FAIL 和原因。两位协作者均使用默认共享工作目录，不要指定 isolation。收齐审查后通过 message_agent 把问题交回原开发者，要求修为 42。等待修复完成，再通过 message_agent 让原审查者重新读取并执行检查，正确时回复 REVIEW_PASS。必须复用原来的两个子会话。全部完成后更新计划，汇总结果，最终包含 COLLAB_CYCLE_VERIFIED。`
+      : `使用 Harness Mix 的 delegate_to_agent，显式指定 isolation=worktree，委派两个独立任务给 @${worker}。任务一只回复 COLLAB_ALPHA，任务二只回复 COLLAB_BETA。不要执行 shell 或编辑文件。请使用 get_delegation_status 等待两个结果，然后你自己最终回复两条结果和 COLLAB_VERIFIED。`;
+    let done = false, failure;
+    void rt.send(lead.id, prompt).then(() => { done = true; }, error => { done = true; failure = error; });
+    const until = Date.now() + (cycle ? 480000 : 180000);
+    while ((!done || rt.execution.isRunning(lead.id) || lead.reviewPending) && Date.now() < until) {
+      const approval = rt.threads.flatMap(t => t.pendingApprovals ?? [])[0];
+      if (approval) throw new Error(`Native approval required: ${approval.title ?? approval.requestId}. Verification does not auto-approve.`);
+      await new Promise(r => setTimeout(r, 200));
+    }
+    if (failure) throw failure;
+    if (rt.execution.isRunning(lead.id)) throw new Error(cycle ? 'Live review cycle did not finish within eight minutes' : 'Live model did not finish within three minutes');
+    const jobs = [...rt.collaboration.jobs.values()].filter(j => j.owner === lead.id);
+    const final = rt.core.getItemsForTurn(rt.execution.lastTurn(lead.id).id).filter(i => i.type === 'agent_message').map(i => i.content).join('\n');
+    console.log(JSON.stringify({ lead: from, worker, jobs: jobs.map(j => rt.collaboration.view(j)), final }, null, 2));
+    assert.equal(jobs.length, 2);
+    assert.ok(jobs.every(j => j.status === 'completed'));
+    if (cycle) {
+      assert.ok(jobs.every(j => j.workspace.mode === 'shared' && j.workspace.cwd === project));
+      assert.equal(require(path.join(project, 'answer.cjs')), 42);
+      assert.match(final, /COLLAB_CYCLE_VERIFIED/);
+      const children = jobs.map(j => rt.threads.find(t => t.id === j.childId));
+      assert.ok(children.every(t => t.messages.filter(m => m.role === 'user').length >= 2), 'Both native sessions were followed up');
+      const transcript = children.flatMap(t => t.messages.filter(m => m.role === 'assistant').map(m => m.text || '')).join('\n');
+      assert.match(transcript, /REVIEW_FAIL/); assert.match(transcript, /REVIEW_PASS/);
+      const items = rt.core.getItemsForTurn(rt.execution.lastTurn(lead.id).id);
+      assert.ok(items.some(i => i.type === 'plan' && i.entries.every(e => e.status === 'completed')));
+      assert.ok(items.filter(i => i.collaboration).length >= 4);
+    } else {
+      assert.ok(jobs.every(j => j.workspace.mode === 'worktree' && j.workspace.cwd !== project));
+      assert.notEqual(jobs[0].workspace.cwd, jobs[1].workspace.cwd);
+      assert.match(final, /COLLAB_ALPHA/); assert.match(final, /COLLAB_BETA/); assert.match(final, /COLLAB_VERIFIED/);
+    }
+    console.log('PASS: native lead called tools, spawned two native workers, collected results and synthesized its final answer');
+  } finally { recorder.stopRecording(); await rt.close(); }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/e2e-core-files.cjs

@@ -0,0 +1,58 @@
+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 { ParityObserver } = require('./support/parity-observer.cjs');
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+(async () => {
+  for (const harnessId of process.argv[2] ? [process.argv[2]] : ['codex', 'pi', 'claude', 'dsh']) {
+    const data = await fs.mkdtemp(path.join(os.tmpdir(), `hm-core-files-${harnessId}-`));
+    const root = path.join(data, 'workspace'); await fs.mkdir(root);
+    const rt = new HostRuntime({ observer: new ParityObserver(), dataDirectory: data });
+    try {
+      await rt.initialize();
+      const thread = await rt.createThread({ harnessId, cwd: root, options: { permissionMode: harnessId === 'codex' ? ':danger-full-access' : 'acceptEdits' } });
+      assert.notEqual(thread.status, 'error', thread.error);
+      let ended = false, sendError;
+      const sending = rt.send(thread.id, 'Only in this temporary working directory: use your native file editing tool to create acceptance.txt containing exactly HARNESS-CORE-OK. Do not access other folders. Then reply done.')
+        .catch(error => { sendError = error; }).finally(() => { ended = true; });
+      for (let i = 0; i < 600; i++) {
+        for (const item of [...thread.interactions ?? []]) {
+          const allow = item.options?.find(option => option.kind === 'allow_once');
+          if (!allow) throw new Error('No one-time native file-edit approval option');
+          await rt.respondApproval(thread.id, item.requestId, { optionId: allow.id });
+        }
+        if (ended && !rt.execution.isRunning(thread.id) && !thread.reviewPending) break;
+        await sleep(250);
+      }
+      assert.equal(ended, true, 'native send timed out'); await sending;
+      if (sendError) throw sendError;
+      assert.equal(thread.status, 'ready', thread.error);
+      assert.equal(await fs.readFile(path.join(root, 'acceptance.txt'), 'utf8').then(text => text.trim()), 'HARNESS-CORE-OK');
+      const message = thread.messages.at(-1);
+      const review = await rt.readReview(thread, message);
+      const file = review.files.find(item => item.path === 'acceptance.txt');
+      assert.ok(file); assert.equal(file.type, 'file_change');
+      assert.ok(file.after.includes('HARNESS-CORE-OK'));
+      assert.ok(message.coreItems.some(item => item.type === 'tool_call'));
+      assert.ok((await rt.readReview(thread, message, file.path)).rows.some(row => row.kind === 'add'));
+      const report = rt.shadowReport();
+      assert.ok(report.comparisons > 0); assert.deepEqual(report.errors, []); assert.deepEqual(report.mismatches, []);
+      await rt.undoFile(thread.id, message.id, file.path);
+      await assert.rejects(fs.access(path.join(root, file.path)));
+      assert.ok(message.coreReview.files.find(item => item.path === file.path).undone);
+      await fs.mkdir('output/verification', { recursive: true });
+      await fs.writeFile(`output/verification/core-files-${harnessId}.json`, JSON.stringify({ harnessId, at: new Date().toISOString(), source: file.source, nativeRef: file.nativeRef, fileVerified: true, undoVerified: true, report }, null, 2));
+      console.log(`${harnessId}: real file edit -> ${file.source} FileChange -> diff -> undo; zero parity mismatch PASSED`);
+    } finally {
+      if (harnessId === 'codex') {
+        for (const session of rt.sessions.values()) {
+          await session.host?.request('thread/delete', { threadId: session.nativeSessionId }).catch(() => {});
+        }
+      }
+      await rt.close();
+    }
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });