harness-mix 0.1.0

package/scripts/dsh-adapter-test.cjs

@@ -0,0 +1,87 @@
+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 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-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,58 @@
+// 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 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' });
+    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 { 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; });

package/scripts/e2e-core-fork.cjs

@@ -0,0 +1,49 @@
+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 () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-core-fork-'));
+  const root = path.join(directory, 'project'); await fs.mkdir(root);
+  const rt = new HostRuntime({ observer: new ParityObserver(), dataDirectory: directory });
+  async function send(thread, text) {
+    await rt.send(thread.id, text);
+    for (let i = 0; i < 600 && (thread.status === 'working' || thread.reviewPending); i++) await sleep(200);
+    assert.equal(thread.status, 'ready', thread.error);
+    assert.equal(thread.messages.at(-1).coreTurn.status, 'completed');
+  }
+  try {
+    await rt.initialize();
+    const source = await rt.createThread({ harnessId: 'pi', cwd: root });
+    const models = await rt.listModels(source.id);
+    assert.ok(models.length);
+    await send(source, 'Remember FORK-5921. Reply OK. Do not use tools.');
+    const boundary = source.messages.at(-1);
+    assert.ok(boundary.coreTurn.nativeTurnRef.checkpointId, 'native checkpoint captured');
+    await send(source, 'Remember LATER-9386 too. Reply OK. Do not use tools.');
+    const fork = await rt.forkThread(source.id, boundary.id);
+    assert.ok(fork.nativeSessionId);
+    assert.notEqual(fork.nativeSessionId, source.nativeSessionId);
+    assert.equal(fork.messages.length, 2, 'UI history ends at the selected reply');
+    const nativeHistory = await rt.sessions.get(fork.id).process.command({ type: 'get_messages' });
+    assert.ok(JSON.stringify(nativeHistory).includes('FORK-5921'));
+    assert.ok(!JSON.stringify(nativeHistory).includes('LATER-9386'), 'native history excludes later turns');
+    await send(fork, 'What token did I ask you to remember? Reply only that token. Do not use tools.');
+    assert.ok(fork.messages.at(-1).text.includes('FORK-5921'));
+    assert.equal(source.messages.length, 4);
+    const usage = await rt.refreshUsage(fork.id);
+    const stats = await rt.sessions.get(fork.id).process.command({ type: 'get_session_stats' });
+    assert.equal(usage.tokens, stats.contextUsage.tokens);
+    assert.equal(usage.contextWindow, stats.contextUsage.contextWindow);
+    assert.ok(Math.abs(usage.contextPercent - 100 * stats.contextUsage.tokens / stats.contextUsage.contextWindow) < 0.00001);
+    assert.deepEqual(rt.shadowReport().errors, []);
+    assert.deepEqual(rt.shadowReport().mismatches, []);
+    await fs.mkdir('output/verification', { recursive: true });
+    await fs.writeFile('output/verification/core-fork-pi.json', JSON.stringify({ at: new Date().toISOString(), models: models.length,
+      replyBoundaryVerified: true, laterTurnsExcluded: true, contextUsage: { tokens: usage.tokens, contextWindow: usage.contextWindow, percent: usage.contextPercent }, report: rt.shadowReport() }, null, 2));
+    console.log('pi: real model listing, fork identity, inherited history, fork event routing and shadow parity passed');
+  } finally { await rt.close(); }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/e2e-core-resume.cjs

@@ -0,0 +1,49 @@
+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 harnessId = process.argv[2];
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+const timeout = promise => Promise.race([promise, new Promise((_, reject) => {
+  const timer = setTimeout(() => reject(new Error('native request timeout')), 120000); timer.unref();
+})]);
+(async () => {
+  const data = await fs.mkdtemp(path.join(os.tmpdir(), `hm-core-resume-${harnessId}-`));
+  const root = path.join(data, 'workspace'); await fs.mkdir(root);
+  let rt = new HostRuntime({ observer: new ParityObserver(), dataDirectory: data });
+  const reports = [];
+  async function send(id, prompt) {
+    await timeout(rt.send(id, prompt));
+    const thread = rt.threads.find(t => t.id === id);
+    for (let i = 0; i < 600 && (thread.status === 'working' || thread.reviewPending); i++) await sleep(200);
+    assert.equal(thread.status, 'ready', thread.error);
+    const message = thread.messages.at(-1);
+    assert.equal(message.coreTurn.status, 'completed');
+    assert.ok(message.coreItems.some(i => i.phase === 'final' && i.content));
+    assert.deepEqual(rt.shadowReport().errors, []);
+    assert.deepEqual(rt.shadowReport().mismatches, []);
+    reports.push({ turnId: message.coreTurnId, status: message.coreTurn.status, report: structuredClone(rt.shadowReport()) });
+    return message;
+  }
+  try {
+    await rt.initialize();
+    const thread = await rt.createThread({ harnessId, cwd: root, title: 'Core resume acceptance' });
+    await send(thread.id, 'Remember the token HM-4827. Reply only OK. Do not use tools.');
+    const nativeSessionId = thread.nativeSessionId;
+    await rt.close();
+    rt = new HostRuntime({ observer: new ParityObserver(), dataDirectory: data });
+    await rt.initialize();
+    const restored = rt.threads.find(t => t.id === thread.id);
+    assert.equal(restored.restore, true);
+    assert.equal(restored.messages.at(-1).coreTurn.status, 'completed');
+    const reply = await send(thread.id, 'What token did I ask you to remember? Reply only with the token. Do not use tools.');
+    assert.ok(reply.coreItems.some(i => i.phase === 'final' && i.content.includes('HM-4827')), 'native history was not restored');
+    assert.equal(restored.nativeSessionId, nativeSessionId);
+    assert.notEqual(reports[0].turnId, reports[1].turnId);
+    await fs.mkdir('output/verification', { recursive: true });
+    await fs.writeFile(`output/verification/core-resume-${harnessId}.json`, JSON.stringify({ harnessId, at: new Date().toISOString(), reports }, null, 2));
+    console.log(`${harnessId}: native reopen + memory recall + Core final + zero shadow mismatch PASSED`);
+  } finally { await rt.close(); }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/e2e-delegate.cjs

@@ -0,0 +1,38 @@
+// 真实跨 Harness 协作自检（会发起真实的子任务模型请求）：
+// 父线程 → /delegate 委派子任务到目标 Harness → 等待结算 → 协作工具项回收最终答复。
+// 用法：node scripts/e2e-delegate.cjs [--from=pi] [--to=pi]
+const { HostRuntime } = require("../src/main/host/runtime");
+const os = require("node:os");
+const path = require("node:path");
+
+const arg = (name, fallback) => process.argv.find(a => a.startsWith(`--${name}=`))?.split("=")[1] ?? fallback;
+const from = arg("from", "pi");
+const to = arg("to", "pi");
+
+(async () => {
+  const rt = new HostRuntime({ dataDirectory: path.join(os.tmpdir(), "hm-e2e-delegate") });
+  rt.subscribe((e) => { if (e.type === "toast") console.log("  [toast]", e.text); });
+  await rt.initialize();
+  if (!rt.status[from]?.available) throw new Error(`父 Harness 不可用：${from}`);
+  if (!rt.status[to]?.available) throw new Error(`子 Harness 不可用：${to}`);
+
+  const parent = await rt.createThread({ harnessId: from, cwd: "E:\\harness-mix", title: "E2E 协作" });
+  if (parent.status === "error") throw new Error("parent open failed: " + parent.error);
+  console.log(`parent: ${parent.id.slice(0, 8)} (${from})`);
+
+  const { child, turn } = await rt.delegateTask({ fromThreadId: parent.id, harnessId: to, task: "只回复两个字：收到" });
+  console.log(`child:  ${child.id.slice(0, 8)} (${child.harnessId}) parentThreadId=${child.parentThreadId === parent.id ? "ok" : "MISSING"}`);
+
+  for (let i = 0; i < 180 && rt.execution.isRunning(parent.id); i++) await new Promise((r) => setTimeout(r, 1000));
+  const settled = rt.threads.find((t) => t.id === parent.id);
+  const items = rt.core.getItemsForTurn(turn.id);
+  const tool = items.find((i) => i.type === "tool_call");
+  console.log("parent status:", settled.status, "| tool:", tool?.title, "→", tool?.status);
+  console.log("tool output:", JSON.stringify(String(tool?.output ?? "").slice(0, 120)));
+  const childThread = rt.threads.find((t) => t.id === child.id);
+  console.log("child status:", childThread.status, "| child reply:", JSON.stringify(childThread.messages.at(-1)?.text?.slice(0, 60)));
+  await rt.close();
+  const ok = settled.status === "ready" && tool?.status === "completed" && String(tool?.output ?? "").includes("收到");
+  console.log(ok ? "PASS: 委派 → 等待 → 答复回收" : "FAIL");
+  process.exit(ok ? 0 : 1);
+})().catch((e) => { console.error("E2E FAILED:", e.message); process.exit(1); });

package/scripts/e2e-dsh.cjs

@@ -0,0 +1,23 @@
+const { ParityObserver } = require('./support/parity-observer.cjs');
+// 真实 DSH(ACP) 链路自检（会发起一次最小模型请求；DSH 启动较慢，耐心等）
+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-dsh") });
+  rt.subscribe((e) => { if (e.type === "toast") console.log("  [toast]", e.text.slice(0, 200)); });
+  await rt.initialize();
+  const t0 = Date.now();
+  const thread = await rt.createThread({ harnessId: "dsh", cwd: "E:\\harness-mix", title: "DSH E2E 自检" });
+  console.log(`open 耗时 ${((Date.now() - t0) / 1000).toFixed(1)}s`);
+  if (thread.status === "error") throw new Error("open failed: " + thread.error);
+  console.log("opened, native session:", thread.nativeSessionId, "| models:", JSON.stringify(thread.models?.slice(0, 3)), "| current:", JSON.stringify(thread.model));
+  await rt.send(thread.id, "只回复两个字：收到");
+  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);
+  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-native-commands.cjs

@@ -0,0 +1,54 @@
+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 () => {
+  const hid = process.argv[2] || 'claude';
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-commands-'));
+  const cwd = path.join(dir, 'project'); await fs.mkdir(cwd);
+  if (hid === 'pi') {
+    await fs.mkdir(path.join(cwd, '.pi'));
+    await fs.writeFile(path.join(cwd, '.pi', 'settings.json'), JSON.stringify({ compaction: { keepRecentTokens: 1000, reserveTokens: 1000 } }));
+  }
+  const rt = new HostRuntime({ dataDirectory: dir });
+  async function settle(t) {
+    for (let i = 0; i < 900 && (t.status === 'working' || t.reviewPending); i++) await sleep(200);
+    assert.equal(t.status, 'ready', t.error);
+  }
+  async function send(t, text) { await rt.send(t.id, text); await settle(t); }
+  try {
+    await rt.initialize();
+    const source = await rt.createThread({ harnessId: hid, cwd, options: hid === 'pi' ? { permissionMode: 'approve' } : {} });
+    await send(source, 'Remember FIRST-5921. Reply OK. Do not use tools.');
+    const boundary = source.messages.at(-1);
+    let target = source;
+    if (hid === 'claude') {
+      assert.ok(boundary.coreTurn.nativeTurnRef.checkpointId);
+      await send(source, 'Remember LATER-9386. Reply OK. Do not use tools.');
+      target = await rt.forkThread(source.id, boundary.id);
+      const { getSessionMessages } = await import('@anthropic-ai/claude-agent-sdk');
+      const history = await getSessionMessages(target.nativeSessionId, { dir: cwd });
+      assert.ok(JSON.stringify(history).includes('FIRST-5921'));
+      assert.ok(!JSON.stringify(history).includes('LATER-9386'));
+      assert.equal(target.messages.length, 2);
+      // A branch of a branch must retain remapped native checkpoints.
+      const second = await rt.forkThread(target.id, target.messages.at(-1).id);
+      assert.notEqual(second.nativeSessionId, target.nativeSessionId);
+      await send(target, 'Which token did I ask you to remember? Reply only the token. Do not use tools.');
+      assert.ok(target.messages.at(-1).text.includes('FIRST-5921'));
+      assert.ok(!target.messages.at(-1).text.includes('LATER-9386'));
+      assert.equal(source.messages.length, 4);
+    }
+    const commands = await rt.listCommands({ threadId: target.id });
+    assert.ok(commands.some(c => c.id === 'compact'));
+    if (hid === 'pi') await send(target, 'Keep FIRST-5921 as the important token. The following is disposable test data. Reply OK without tools.\n' + Array.from({ length: 500 }, (_, i) => `Test record ${i}: alpha beta gamma delta epsilon zeta eta theta.`).join('\n'));
+    await rt.executeCommand(target.id, 'compact'); await settle(target);
+    await send(target, 'Which token did I first ask you to remember? Reply only the token. Do not use tools.');
+    assert.ok(target.messages.at(-1).text.includes('FIRST-5921'));
+    await fs.mkdir('output/verification', { recursive: true });
+    await fs.writeFile(`output/verification/commands-${hid}.json`, JSON.stringify({ at: new Date().toISOString(), hid, nativeCompact: true, retainedContext: true, replyFork: hid === 'claude', sourceId: source.nativeSessionId, targetId: target.nativeSessionId }, null, 2));
+    console.log(hid + ': native commands, retained context and fork boundaries passed');
+  } finally { await rt.close(); }
+})().catch(e => { console.error(e); process.exitCode = 1; });