@harness-mix/cli 0.1.3

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-acp.cjs

@@ -0,0 +1,42 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+(async () => {
+  const directory = path.resolve('output', 'native-acp-live', String(Date.now()));
+  fs.mkdirSync(directory, { recursive: true });
+  const reports = [];
+  const selected = process.argv.find(a => a.startsWith('--harness='))?.slice(10);
+  for (const file of (selected ? selected.split(',') : ['codebuddy', 'kiro', 'cursor', 'qoder', 'zcode', 'trae'])) {
+    const mod = require('../src/main/adapters/' + file), adapter = mod.create();
+    const report = { harnessId: mod.manifest.id, inspection: await adapter.inspect(), live: false };
+    reports.push(report);
+    if (!report.inspection.available) continue;
+    let s;
+    const texts = [];
+    const emit = e => { if (e.kind === 'text-delta') texts.push(e.text); if (e.kind === 'approval') report.approvalRequired = true; };
+    const deadline = setTimeout(() => adapter.close(s).catch(() => {}), 60000);
+    try {
+      s = await adapter.open({ thread: { cwd: directory }, emit });
+      const catalog = await adapter.describeFor(s);
+      report.models = catalog.models.length;
+      report.thinkingLevels = catalog.thinkingLevels.map(v => v.id);
+      report.modes = catalog.permissionModes.map(v => v.id);
+      if (process.argv.includes('--live')) {
+        await adapter.send(s, 'Reply exactly HARNESS_MIX_ACP_OK. Do not use tools or modify files.', { emit });
+        report.live = texts.join('').trim() === 'HARNESS_MIX_ACP_OK';
+        report.text = texts.join('').slice(0, 500);
+        const nativeSessionId = s.nativeSessionId;
+        await adapter.close(s);
+        s = await adapter.open({ thread: { cwd: directory, nativeSessionId, restore: true }, emit });
+        texts.length = 0;
+        await adapter.send(s, 'Reply exactly HARNESS_MIX_RESUME_OK. Do not use tools or modify files.', { emit });
+        report.resume = s.nativeSessionId === nativeSessionId && texts.join('').trim() === 'HARNESS_MIX_RESUME_OK';
+      }
+    } catch (error) { report.error = error.message; }
+    finally { clearTimeout(deadline); await adapter.close(s); }
+  }
+  fs.writeFileSync(path.join(directory, 'report.json'), JSON.stringify(reports, null, 2));
+  console.log(JSON.stringify(reports, null, 2));
+  console.log('Report: ' + directory);
+  if (reports.some(r => r.error || (process.argv.includes('--live') && r.inspection.available && (!r.live || !r.resume)))) process.exitCode = 1;
+})().catch(error => { console.error(error); process.exitCode = 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; });

package/scripts/e2e-native-host.cjs

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

package/scripts/e2e-openclaw-image.cjs

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

package/scripts/e2e-openclaw.cjs

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

package/scripts/e2e-pi.cjs

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

package/scripts/e2e-shadow.cjs

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