@harness-mix/cli 0.2.2 → 0.2.4

package/scripts/native-vendor-adapters-test.cjs

@@ -1,154 +1,196 @@
-const assert = require('node:assert/strict');
-const oc = require('../src/main/adapters/opencode');
-const grok = require('../src/main/adapters/grok');
-const pi = require('../src/main/adapters/pi');
-(async () => {
-  const events = [], calls = [];
-  const session = { nativeSessionId: 's', emit: e => events.push(e), state: { active: true, userMessages: new Set(), parts: new Map(), text: new Map(), permissions: new Map(), questions: new Map() } };
-  const event = (type, properties) => oc.projectEvent(session, { type, properties: { sessionID: 's', ...properties } }, session.emit);
-  event('message.updated', { info: { role: 'user', id: 'u' } });
-  event('message.part.updated', { part: { id: 'up', messageID: 'u', type: 'text', text: 'do not echo' } });
-  event('message.part.updated', { part: { id: 'p', messageID: 'a', type: 'text', text: 'A' } });
-  event('message.part.delta', { partID: 'p', field: 'text', delta: 'B' });
-  oc.projectPart(session, { id: 'p', messageID: 'a', type: 'text', text: 'AB' }, session.emit);
-  assert.equal(events.filter(e => e.kind === 'text-delta').map(e => e.text).join(''), 'AB');
-  event('question.asked', { id: 'q', questions: [{ question: 'Choose', options: [{ label: 'yes' }] }] });
-  assert.equal(events.at(-1).kind, 'approval');
-  let fail = true;
-  session.host = { request: async (...args) => { if (fail) throw new Error('network'); calls.push(args); } };
-  const adapter = oc.create();
-  await assert.rejects(adapter.respond(session, 'q:0', { value: 'yes' }));
-  assert.equal(session.state.questions.get('q').index, 0);
-  fail = false;
-  await adapter.respond(session, 'q:0', { value: 'yes' });
-  assert.deepEqual(calls.at(-1)[2], { answers: [['yes']] });
-  event('permission.asked', { id: 'perm', permission: 'shell', patterns: ['test'] });
-  await assert.rejects(adapter.respond(session, 'perm', { value: 'invented' }));
-  await adapter.respond(session, 'perm', { optionId: 'always' });
-  assert.deepEqual(calls.at(-1)[2], { reply: 'always' });
-  assert.deepEqual(grok.projectUsage({ input_tokens: 12, outputTokens: 3, signature: 'private', costUsdTicks: 5 }), { inputTokens: 12, outputTokens: 3 });
-  const piFailure = pi.project({ type: 'agent_end', willRetry: false, messages: [{ role: 'assistant', stopReason: 'error', errorMessage: 'native quota exhausted' }] });
-  assert.equal(piFailure.kind, 'error'); assert.match(piFailure.message, /quota exhausted/);
-  let answer;
-  const gs = { pendingApprovals: new Map([['r', { options: [{ optionId: 'native-always', kind: 'allow_always' }], resolve: v => { answer = v; } }]]) };
-  await assert.rejects(grok.create().respond(gs, 'r', { optionId: 'fake' }));
-  await grok.create().respond(gs, 'r', { optionId: 'native-always' });
-  assert.equal(grok.manifest.capabilities.attachments, true);
-  const grokCalls = [];
-  const grokSession = { nativeSessionId: 'grok-1', state: { agentCapabilities: {} }, process: { request: async (method, params) => { grokCalls.push({ method, params }); return { stopReason: 'end_turn', _meta: { promptId: 'p1' } }; } } };
-  await grok.create().send(grokSession, 'hi', { emit: () => {} }, { images: [{ data: 'AA==', mime: 'image/png' }] });
-  assert.equal(grokCalls[0].method, 'session/prompt');
-  assert.deepEqual(grokCalls[0].params.prompt, [{ type: 'text', text: 'hi' }, { type: 'image', data: 'AA==', mimeType: 'image/png' }]);
-
-  // Grok auto-compaction update parsing
-  const updateStarted = grok.parseGrokCompactionUpdate({ sessionUpdate: 'auto_compact_started', tokens_used: 400000, context_window: 500000 });
-  assert.deepEqual(updateStarted, { type: 'started', tokensUsed: 400000, contextWindowTokens: 500000 });
-  const updateCompleted = grok.parseGrokCompactionUpdate({ sessionUpdate: 'auto_compact_completed', tokens_before: 400000, tokens_after: 12000, context_window: 500000 });
-  assert.deepEqual(updateCompleted, { type: 'completed', outcome: 'succeeded', tokensBefore: 400000, tokensAfter: 12000, contextWindowTokens: 500000 });
-  const updateFailed = grok.parseGrokCompactionUpdate({ sessionUpdate: 'auto_compact_failed', error_message: 'compaction error' });
-  assert.deepEqual(updateFailed, { type: 'completed', outcome: 'failed', errorMessage: 'compaction error' });
-  const updateCancelled = grok.parseGrokCompactionUpdate({ sessionUpdate: 'auto_compact_cancelled' });
-  assert.deepEqual(updateCancelled, { type: 'completed', outcome: 'cancelled' });
-
-  // Grok commands & manual compact
-  const grokAdapterInst = grok.create();
-  const grokCmds = await grokAdapterInst.listCommands(grokSession);
-  assert.ok(grokCmds.some(c => c.id === 'compact' && c.action === 'execute'));
-
-  // Test /compact interception in send()
-  const grokCompactEmits = [];
-  grokCalls.length = 0;
-  grokSession.process.request = async (method, params) => {
-    grokCalls.push({ method, params });
-    return { outcome: 'succeeded', tokensBefore: 50000, tokensAfter: 5000 };
-  };
-  await grokAdapterInst.send(grokSession, '/compact keep recent tests', { emit: e => grokCompactEmits.push(e) });
-  assert.equal(grokCalls[0].method, 'x.ai/compact_conversation');
-  assert.deepEqual(grokCalls[0].params, { sessionId: 'grok-1', userContext: 'keep recent tests' });
-  assert.ok(grokCompactEmits.some(e => e.kind === 'compaction' && e.state === 'completed' && e.outcome === 'succeeded'));
-  assert.ok(grokCompactEmits.some(e => e.kind === 'usage' && e.usage.tokens === 5000));
-
-  // Test EventNormalizer compaction mapping
-  const { EventNormalizer } = require('../src/main/harness-adapter/event-normalizer');
-  const normalizer = new EventNormalizer({ threadId: 't-comp' });
-  normalizer.beginTurn('turn-c', 'test compact');
-  const normEvents = normalizer.normalize({ kind: 'compaction', tokensBefore: 50000, tokensAfter: 5000 });
-  assert.equal(normEvents.length, 2);
-  assert.equal(normEvents[0].type, 'item.started');
-  assert.equal(normEvents[0].payload.type, 'context_compaction');
-  assert.equal(normEvents[0].payload.tokensBefore, 50000);
-  assert.equal(normEvents[1].type, 'item.completed');
-
-  // Test projectItem mapping
-  const { projectItem } = require('../src/main/native/protocol');
-  const projected = projectItem({ id: 'norm-item-1', type: 'context_compaction' });
-  assert.deepEqual(projected, { id: 'norm-item-1', type: 'contextCompaction' });
-
-  // Pi 自动重试（stream 错误如 "Anthropic stream ended without a stop reason"）：
-  // message_end 的 error 不得提前定论为 Turn 失败——agent_end 携带 willRetry，
-  // 重试成功的回答必须完整落地，全程零 error 事件（否则 Host 提前结算，
-  // 重试结果被丢弃，用户重发还会撞上原生 "Agent is already processing"）。
-  {
-    const emitted = [];
-    const fakeProc = { harnessMixAnswer: '', command: async () => ({ leafId: 'leaf-1' }) };
-    const fwd = (event) => pi.forwardEvent(fakeProc, event, e => emitted.push(e));
-    const failedMsg = { role: 'assistant', content: [], stopReason: 'error', errorMessage: 'Anthropic stream ended without a stop reason' };
-    fwd({ type: 'message_end', message: failedMsg });
-    assert.equal(emitted.filter(e => e.kind === 'error').length, 0, 'message_end 不得提前报错');
-    fwd({ type: 'agent_end', willRetry: true, messages: [{ role: 'user', content: [{ type: 'text', text: '登录好了' }] }, failedMsg] });
-    assert.equal(emitted.at(-1).kind, 'status');
-    fwd({ type: 'auto_retry_start', attempt: 1, maxAttempts: 3, delayMs: 2000, errorMessage: failedMsg.errorMessage });
-    assert.equal(emitted.at(-1).kind, 'status');
-    fwd({ type: 'message_update', assistantMessageEvent: { type: 'text_delta', contentIndex: 0, delta: '好的，' } });
-    fwd({ type: 'message_update', assistantMessageEvent: { type: 'text_delta', contentIndex: 0, delta: '开始执行。' } });
-    fwd({ type: 'message_end', message: { role: 'assistant', content: [{ type: 'text', text: '好的，开始执行。' }], stopReason: 'stop' } });
-    assert.equal(emitted.filter(e => e.kind === 'text-delta').map(e => e.text).join(''), '好的，开始执行。', '已流式回答不得重复补发');
-    fwd({ type: 'auto_retry_end', success: true, attempt: 1 });
-    fwd({ type: 'agent_end', willRetry: false, messages: [{ role: 'assistant', content: [{ type: 'text', text: '好的，开始执行。' }], stopReason: 'stop' }] });
-    fwd({ type: 'agent_settled', sessionId: 's-retry' });
-    await new Promise(resolve => setImmediate(resolve));
-    assert.equal(emitted.at(-1).kind, 'completed');
-    assert.equal(emitted.at(-1).nativeRef.checkpointId, 'leaf-1');
-    assert.equal(emitted.filter(e => e.kind === 'error').length, 0, '重试成功全程不得出现 error');
-  }
-  // Pi 重试耗尽/不可重试：error 在 agent_end（willRetry:false）处恰好结算一次
-  {
-    const emitted = [];
-    const fwd = (event) => pi.forwardEvent({ harnessMixAnswer: '', command: async () => ({}) }, event, e => emitted.push(e));
-    const failedMsg = { role: 'assistant', content: [], stopReason: 'error', errorMessage: 'native quota exhausted' };
-    fwd({ type: 'message_end', message: failedMsg });
-    assert.equal(emitted.filter(e => e.kind === 'error').length, 0);
-    fwd({ type: 'agent_end', willRetry: false, messages: [failedMsg] });
-    assert.equal(emitted.filter(e => e.kind === 'error').length, 1);
-    assert.match(emitted.find(e => e.kind === 'error').message, /quota exhausted/);
-  }
-  // Pi 未流式回答的 message_end 回退补发仍然有效
-  {
-    const emitted = [];
-    pi.forwardEvent({ harnessMixAnswer: '', command: async () => ({}) },
-      { type: 'message_end', message: { role: 'assistant', content: [{ type: 'text', text: '非流式回答' }], stopReason: 'stop' } },
-      e => emitted.push(e));
-    assert.ok(emitted.some(e => e.kind === 'text-delta' && e.text === '非流式回答'));
-  }
-  // Pi send()：原生拒绝 "already processing"（Host 与原生状态偶发分叉，如取消竞态）时
-  // 按原生协议提示以 followUp 排队重发；其他错误原样抛出
-  {
-    const calls = [];
-    let rejectOnce = true;
-    const busySession = { process: { harnessMixAnswer: '', command: async (payload) => {
-      calls.push(payload);
-      if (rejectOnce && payload.type === 'prompt') { rejectOnce = false; throw new Error("Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message."); }
-      return {};
-    } } };
-    await pi.create().send(busySession, '登录好了', { emit: () => {} }, { images: [{ data: 'AA==', mime: 'image/png' }] });
-    assert.equal(calls.length, 2);
-    assert.equal(calls[0].streamingBehavior, undefined);
-    assert.equal(calls[1].streamingBehavior, 'followUp');
-    assert.equal(calls[1].message, '登录好了');
-    assert.deepEqual(calls[1].images, [{ type: 'image', data: 'AA==', mimeType: 'image/png' }]);
-    const failingSession = { process: { harnessMixAnswer: '', command: async () => { throw new Error('Authentication failed'); } } };
-    await assert.rejects(pi.create().send(failingSession, 'hi', { emit: () => {} }, {}), /Authentication failed/);
-  }
-
-  console.log('Native adapters: streaming deduplication, user suppression, question retry, exact native approvals, sanitized usage, grok images, grok compaction & UI projection PASS');
-})().catch(error => { console.error(error); process.exitCode = 1; });
+const assert = require('node:assert/strict');
+const oc = require('../src/main/adapters/opencode');
+const grok = require('../src/main/adapters/grok');
+const pi = require('../src/main/adapters/pi');
+(async () => {
+  const events = [], calls = [];
+  const session = { nativeSessionId: 's', emit: e => events.push(e), state: { active: true, userMessages: new Set(), parts: new Map(), text: new Map(), permissions: new Map(), questions: new Map() } };
+  const event = (type, properties) => oc.projectEvent(session, { type, properties: { sessionID: 's', ...properties } }, session.emit);
+  event('message.updated', { info: { role: 'user', id: 'u' } });
+  event('message.part.updated', { part: { id: 'up', messageID: 'u', type: 'text', text: 'do not echo' } });
+  event('message.part.updated', { part: { id: 'p', messageID: 'a', type: 'text', text: 'A' } });
+  event('message.part.delta', { partID: 'p', field: 'text', delta: 'B' });
+  oc.projectPart(session, { id: 'p', messageID: 'a', type: 'text', text: 'AB' }, session.emit);
+  assert.equal(events.filter(e => e.kind === 'text-delta').map(e => e.text).join(''), 'AB');
+  event('question.asked', { id: 'q', questions: [{ question: 'Choose', options: [{ label: 'yes' }] }] });
+  assert.equal(events.at(-1).kind, 'approval');
+  let fail = true;
+  session.host = { request: async (...args) => { if (fail) throw new Error('network'); calls.push(args); } };
+  const adapter = oc.create();
+  await assert.rejects(adapter.respond(session, 'q:0', { value: 'yes' }));
+  assert.equal(session.state.questions.get('q').index, 0);
+  fail = false;
+  await adapter.respond(session, 'q:0', { value: 'yes' });
+  assert.deepEqual(calls.at(-1)[2], { answers: [['yes']] });
+  event('permission.asked', { id: 'perm', permission: 'shell', patterns: ['test'] });
+  await assert.rejects(adapter.respond(session, 'perm', { value: 'invented' }));
+  await adapter.respond(session, 'perm', { optionId: 'always' });
+  assert.deepEqual(calls.at(-1)[2], { reply: 'always' });
+  assert.deepEqual(grok.projectUsage({ input_tokens: 12, outputTokens: 3, signature: 'private', costUsdTicks: 5 }), { inputTokens: 12, outputTokens: 3 });
+  const piFailure = pi.project({ type: 'agent_end', willRetry: false, messages: [{ role: 'assistant', stopReason: 'error', errorMessage: 'native quota exhausted' }] });
+  assert.equal(piFailure.kind, 'error'); assert.match(piFailure.message, /quota exhausted/);
+  let answer;
+  const gs = { pendingApprovals: new Map([['r', { options: [{ optionId: 'native-always', kind: 'allow_always' }], resolve: v => { answer = v; } }]]) };
+  await assert.rejects(grok.create().respond(gs, 'r', { optionId: 'fake' }));
+  await grok.create().respond(gs, 'r', { optionId: 'native-always' });
+  assert.equal(grok.manifest.capabilities.attachments, true);
+  const grokCalls = [];
+  const grokSession = { nativeSessionId: 'grok-1', state: { agentCapabilities: {} }, process: { request: async (method, params) => { grokCalls.push({ method, params }); return { stopReason: 'end_turn', _meta: { promptId: 'p1' } }; } } };
+  await grok.create().send(grokSession, 'hi', { emit: () => {} }, { images: [{ data: 'AA==', mime: 'image/png' }] });
+  assert.equal(grokCalls[0].method, 'session/prompt');
+  assert.deepEqual(grokCalls[0].params.prompt, [{ type: 'text', text: 'hi' }, { type: 'image', data: 'AA==', mimeType: 'image/png' }]);
+
+  // Grok auto-compaction update parsing
+  const updateStarted = grok.parseGrokCompactionUpdate({ sessionUpdate: 'auto_compact_started', tokens_used: 400000, context_window: 500000 });
+  assert.deepEqual(updateStarted, { type: 'started', tokensUsed: 400000, contextWindowTokens: 500000 });
+  const updateCompleted = grok.parseGrokCompactionUpdate({ sessionUpdate: 'auto_compact_completed', tokens_before: 400000, tokens_after: 12000, context_window: 500000 });
+  assert.deepEqual(updateCompleted, { type: 'completed', outcome: 'succeeded', tokensBefore: 400000, tokensAfter: 12000, contextWindowTokens: 500000 });
+  const updateFailed = grok.parseGrokCompactionUpdate({ sessionUpdate: 'auto_compact_failed', error_message: 'compaction error' });
+  assert.deepEqual(updateFailed, { type: 'completed', outcome: 'failed', errorMessage: 'compaction error' });
+  const updateCancelled = grok.parseGrokCompactionUpdate({ sessionUpdate: 'auto_compact_cancelled' });
+  assert.deepEqual(updateCancelled, { type: 'completed', outcome: 'cancelled' });
+
+  // Grok commands & manual compact
+  const grokAdapterInst = grok.create();
+  const grokCmds = await grokAdapterInst.listCommands(grokSession);
+  assert.ok(grokCmds.some(c => c.id === 'compact' && c.action === 'execute'));
+
+  // Test /compact interception in send()
+  const grokCompactEmits = [];
+  grokCalls.length = 0;
+  grokSession.process.request = async (method, params) => {
+    grokCalls.push({ method, params });
+    return { outcome: 'succeeded', tokensBefore: 50000, tokensAfter: 5000 };
+  };
+  await grokAdapterInst.send(grokSession, '/compact keep recent tests', { emit: e => grokCompactEmits.push(e) });
+  assert.equal(grokCalls[0].method, 'x.ai/compact_conversation');
+  assert.deepEqual(grokCalls[0].params, { sessionId: 'grok-1', userContext: 'keep recent tests' });
+  assert.ok(grokCompactEmits.some(e => e.kind === 'compaction' && e.state === 'completed' && e.outcome === 'succeeded'));
+  assert.ok(grokCompactEmits.some(e => e.kind === 'usage' && e.usage.tokens === 5000));
+
+  // Test EventNormalizer compaction mapping
+  const { EventNormalizer } = require('../src/main/harness-adapter/event-normalizer');
+  const normalizer = new EventNormalizer({ threadId: 't-comp' });
+  normalizer.beginTurn('turn-c', 'test compact');
+  const normEvents = normalizer.normalize({ kind: 'compaction', tokensBefore: 50000, tokensAfter: 5000 });
+  assert.equal(normEvents.length, 2);
+  assert.equal(normEvents[0].type, 'item.started');
+  assert.equal(normEvents[0].payload.type, 'context_compaction');
+  assert.equal(normEvents[0].payload.tokensBefore, 50000);
+  assert.equal(normEvents[1].type, 'item.completed');
+
+  // Test projectItem mapping
+  const { projectItem } = require('../src/main/native/protocol');
+  const projected = projectItem({ id: 'norm-item-1', type: 'context_compaction' });
+  assert.deepEqual(projected, { id: 'norm-item-1', type: 'contextCompaction' });
+
+  // Pi 自动重试（stream 错误如 "Anthropic stream ended without a stop reason"）：
+  // message_end 的 error 不得提前定论为 Turn 失败——agent_end 携带 willRetry，
+  // 重试成功的回答必须完整落地，全程零 error 事件（否则 Host 提前结算，
+  // 重试结果被丢弃，用户重发还会撞上原生 "Agent is already processing"）。
+  {
+    const emitted = [];
+    const fakeProc = { harnessMixAnswer: '', command: async () => ({ leafId: 'leaf-1' }) };
+    const fwd = (event) => pi.forwardEvent(fakeProc, event, e => emitted.push(e));
+    const failedMsg = { role: 'assistant', content: [], stopReason: 'error', errorMessage: 'Anthropic stream ended without a stop reason' };
+    fwd({ type: 'message_end', message: failedMsg });
+    assert.equal(emitted.filter(e => e.kind === 'error').length, 0, 'message_end 不得提前报错');
+    fwd({ type: 'agent_end', willRetry: true, messages: [{ role: 'user', content: [{ type: 'text', text: '登录好了' }] }, failedMsg] });
+    assert.equal(emitted.at(-1).kind, 'status');
+    fwd({ type: 'auto_retry_start', attempt: 1, maxAttempts: 3, delayMs: 2000, errorMessage: failedMsg.errorMessage });
+    assert.equal(emitted.at(-1).kind, 'status');
+    fwd({ type: 'message_update', assistantMessageEvent: { type: 'text_delta', contentIndex: 0, delta: '好的，' } });
+    fwd({ type: 'message_update', assistantMessageEvent: { type: 'text_delta', contentIndex: 0, delta: '开始执行。' } });
+    fwd({ type: 'message_end', message: { role: 'assistant', content: [{ type: 'text', text: '好的，开始执行。' }], stopReason: 'stop' } });
+    assert.equal(emitted.filter(e => e.kind === 'text-delta').map(e => e.text).join(''), '好的，开始执行。', '已流式回答不得重复补发');
+    fwd({ type: 'auto_retry_end', success: true, attempt: 1 });
+    fwd({ type: 'agent_end', willRetry: false, messages: [{ role: 'assistant', content: [{ type: 'text', text: '好的，开始执行。' }], stopReason: 'stop' }] });
+    fwd({ type: 'agent_settled', sessionId: 's-retry' });
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(emitted.at(-1).kind, 'completed');
+    assert.equal(emitted.at(-1).nativeRef.checkpointId, 'leaf-1');
+    assert.equal(emitted.filter(e => e.kind === 'error').length, 0, '重试成功全程不得出现 error');
+  }
+  // Pi 重试耗尽/不可重试：error 在 agent_end（willRetry:false）处恰好结算一次
+  {
+    const emitted = [];
+    const fwd = (event) => pi.forwardEvent({ harnessMixAnswer: '', command: async () => ({}) }, event, e => emitted.push(e));
+    const failedMsg = { role: 'assistant', content: [], stopReason: 'error', errorMessage: 'native quota exhausted' };
+    fwd({ type: 'message_end', message: failedMsg });
+    assert.equal(emitted.filter(e => e.kind === 'error').length, 0);
+    fwd({ type: 'agent_end', willRetry: false, messages: [failedMsg] });
+    assert.equal(emitted.filter(e => e.kind === 'error').length, 1);
+    assert.match(emitted.find(e => e.kind === 'error').message, /quota exhausted/);
+  }
+  // Pi 未流式回答的 message_end 回退补发仍然有效
+  {
+    const emitted = [];
+    pi.forwardEvent({ harnessMixAnswer: '', command: async () => ({}) },
+      { type: 'message_end', message: { role: 'assistant', content: [{ type: 'text', text: '非流式回答' }], stopReason: 'stop' } },
+      e => emitted.push(e));
+    assert.ok(emitted.some(e => e.kind === 'text-delta' && e.text === '非流式回答'));
+  }
+  // Pi send()：原生拒绝 "already processing"（Host 与原生状态偶发分叉，如取消竞态）时
+  // 按原生协议提示以 followUp 排队重发；其他错误原样抛出
+  {
+    const calls = [];
+    let rejectOnce = true;
+    const busySession = { process: { harnessMixAnswer: '', command: async (payload) => {
+      calls.push(payload);
+      if (rejectOnce && payload.type === 'prompt') { rejectOnce = false; throw new Error("Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message."); }
+      return {};
+    } } };
+    await pi.create().send(busySession, '登录好了', { emit: () => {} }, { images: [{ data: 'AA==', mime: 'image/png' }] });
+    assert.equal(calls.length, 2);
+    assert.equal(calls[0].streamingBehavior, undefined);
+    assert.equal(calls[1].streamingBehavior, 'followUp');
+    assert.equal(calls[1].message, '登录好了');
+    assert.deepEqual(calls[1].images, [{ type: 'image', data: 'AA==', mimeType: 'image/png' }]);
+    const failingSession = { process: { harnessMixAnswer: '', command: async () => { throw new Error('Authentication failed'); } } };
+    await assert.rejects(pi.create().send(failingSession, 'hi', { emit: () => {} }, {}), /Authentication failed/);
+  }
+
+  // qoder 解析不得回退到 PATH 上的裸 `qoder`（IDE 启动器）：它能通过 --version 可用性
+  // 探测，却把每次 --acp 会话打开变成完整 GUI 启动且永远完不成 ACP 握手。
+  // 只有无头 qodercli 或显式 HARNESS_MIX_QODER_EXECUTABLE 覆盖是合法入口。
+  {
+    const fs = require('node:fs');
+    const os = require('node:os');
+    const path = require('node:path');
+    const { nativeCommand } = require('../src/main/adapters/native-acp-command');
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'hm-qoder-path-'));
+    fs.writeFileSync(path.join(dir, process.platform === 'win32' ? 'qoder.cmd' : 'qoder'), '');
+    const originalPath = process.env.PATH;
+    const originalOverride = process.env.HARNESS_MIX_QODER_EXECUTABLE;
+    // nativeCommand 在 PATH 之外还探测固定根（APPDATA/npm、LOCALAPPDATA/Kiro-Cli、
+    // ~/.local/bin）：本机真实安装的 qodercli 会从这些根解析成功，让“必须抛错”的
+    // 断言失效。测试期间把这几个根全部沙箱到临时目录。
+    const sandbox = { APPDATA: process.env.APPDATA, LOCALAPPDATA: process.env.LOCALAPPDATA, USERPROFILE: process.env.USERPROFILE, HOME: process.env.HOME };
+    process.env.APPDATA = dir;
+    process.env.LOCALAPPDATA = dir;
+    process.env.USERPROFILE = dir;
+    process.env.HOME = dir;
+    delete process.env.HARNESS_MIX_QODER_EXECUTABLE;
+    const pathWithoutQodercli = originalPath.split(path.delimiter).filter(Boolean).filter(entry => {
+      try { return !fs.existsSync(path.join(entry, process.platform === 'win32' ? 'qodercli.cmd' : 'qodercli')); } catch { return true; }
+    }).join(path.delimiter);
+    try {
+      process.env.PATH = `${dir}${path.delimiter}${pathWithoutQodercli}`;
+      assert.throws(() => nativeCommand('qoder', ['--acp']), /qodercli 未安装/, '裸 qoder（IDE 启动器）不得作为 ACP 回退');
+      const override = path.join(dir, 'custom-acp.exe');
+      fs.writeFileSync(override, '');
+      process.env.HARNESS_MIX_QODER_EXECUTABLE = override;
+      assert.equal(nativeCommand('qoder', ['--acp']).command, override, '显式覆盖仍然生效');
+    } finally {
+      process.env.PATH = originalPath;
+      for (const [key, value] of Object.entries(sandbox)) {
+        if (value === undefined) delete process.env[key];
+        else process.env[key] = value;
+      }
+      if (originalOverride === undefined) delete process.env.HARNESS_MIX_QODER_EXECUTABLE;
+      else process.env.HARNESS_MIX_QODER_EXECUTABLE = originalOverride;
+    }
+  }
+
+  console.log('Native adapters: streaming deduplication, user suppression, question retry, exact native approvals, sanitized usage, grok images, grok compaction & UI projection, qoder ACP resolution PASS');
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/salvage-rollout-writes.cjs

@@ -0,0 +1,72 @@
+// One-off salvage: extract Write/Edit tool-call payloads for out/ paths from a
+// ZCode model-io rollout journal and replay the write+edit chain to rebuild
+// final file contents. Used to recover the promo-video generation scripts
+// after the workspace out/ tree was deleted. Not part of any suite.
+const fs = require('node:fs');
+const path = require('node:path');
+
+const journal = process.argv[2];
+const destRoot = process.argv[3];
+if (!journal || !destRoot) {
+  console.error('usage: node salvage-rollout-writes.cjs <rollout.jsonl> <destRoot>');
+  process.exit(1);
+}
+
+const lines = fs.readFileSync(journal, 'utf8').split('\n').filter(Boolean);
+const occurrences = []; // {fp, tool, lineIdx, content?, old?, new?} in journal order
+
+const normalize = fp => String(fp).replace(/\\/g, '/').replace(/^[A-Za-z]:\/+/, '').replace(new RegExp(`^${path.basename(process.cwd())}/`), '');
+
+function scan(node, lineIdx) {
+  if (Array.isArray(node)) { for (const x of node) scan(x, lineIdx); return; }
+  if (!node || typeof node !== 'object') return;
+  const isToolCall = (node.type === 'tool_use') || (typeof node.id === 'string' && node.id.startsWith('call_') && typeof node.name === 'string' && node.input && typeof node.input === 'object');
+  if (isToolCall && node.input && typeof node.input.file_path === 'string') {
+    const fp = normalize(node.input.file_path);
+    if (/(^|\/)out\//.test(fp)) {
+      occurrences.push({
+        fp, tool: node.name, lineIdx,
+        content: node.input.content != null ? String(node.input.content) : null,
+        old: node.input.old_string != null ? String(node.input.old_string) : null,
+        next: node.input.new_string != null ? String(node.input.new_string) : null,
+        replaceAll: node.input.replace_all === true,
+      });
+    }
+  }
+  for (const v of Object.values(node)) scan(v, lineIdx);
+}
+
+let idx = 0;
+for (const line of lines) {
+  idx += 1;
+  try { scan(JSON.parse(line), idx); } catch { /* malformed line */ }
+}
+
+// Replay: last Write wins as the base, then Edits that appear AFTER it in order.
+// Edits before the last Write are already baked into that Write's content.
+const byPath = new Map();
+for (const occ of occurrences) {
+  if (!byPath.has(occ.fp)) byPath.set(occ.fp, []);
+  byPath.get(occ.fp).push(occ);
+}
+
+const summary = [];
+for (const [fp, chain] of byPath) {
+  const lastWriteIdx = chain.map(o => o.tool === 'Write').lastIndexOf(true);
+  if (lastWriteIdx === -1) { summary.push(`SKIP (no Write captured)\t${fp}`); continue; }
+  let text = chain[lastWriteIdx].content;
+  let applied = 0, skipped = 0;
+  for (const occ of chain.slice(lastWriteIdx + 1)) {
+    if (occ.tool !== 'Edit' || occ.old == null || occ.next == null) continue;
+    const count = text.split(occ.old).length - 1;
+    if (count === 0 || (!occ.replaceAll && count > 1)) { skipped += 1; continue; }
+    text = occ.replaceAll ? text.split(occ.old).join(occ.next) : text.replace(occ.old, occ.next);
+    applied += 1;
+  }
+  const abs = path.join(destRoot, fp);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, text);
+  summary.push(`OK\tline ${chain[lastWriteIdx].lineIdx} (+${applied}edits, ${skipped}skipped)\t${fp}\t${text.length} chars`);
+}
+console.log(summary.join('\n'));
+console.log(`FILES ${summary.filter(s => s.startsWith('OK')).length} / paths ${byPath.size}`);

package/scripts/send-cancel-race-test.cjs

@@ -0,0 +1,80 @@
+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 < 300; i++) { if (fn()) return; await sleep(10); }
+  throw new Error('timed out');
+}
+
+// 取消-重发竞态（票据所有制发送锁）：
+// 流式进行中 cancel 会提前放锁让新发送进入（设计如此，避免卡死的 adapter.send 永久锁线程），
+// 但旧 send 退出时的 finally 不得误删新发送的锁——否则第三个发送会与在途发送并发，
+// 撞上原生侧 "Agent is already processing"。cancelRequests  likewise 按票据隔离，
+// 上一代发送遗留的取消登记不得被新发送的消费点误吞。
+(async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-send-cancel-race-'));
+  const root = path.join(directory, 'workspace');
+  await fs.mkdir(root);
+
+  const rt = new HostRuntime({ dataDirectory: directory });
+  await rt.store.load();
+
+  const emits = new Map();
+  const pendingSends = new Map(); // threadId -> resolve：adapter.send 阻塞至 cancel（模拟原生 abort 才结算）
+  const adapter = {
+    manifest: { id: 'test-harness', name: 'Test', capabilities: {} },
+    async open(input) { emits.set(input.thread.id, input.emit); return {}; },
+    async send(session) { await new Promise(resolve => pendingSends.set(session.threadId, resolve)); },
+    async cancel(session) { pendingSends.get(session.threadId)?.(); pendingSends.delete(session.threadId); },
+    async close() {},
+  };
+  rt.adapters.set(adapter.manifest.id, adapter);
+  rt.status[adapter.manifest.id] = { available: true };
+
+  try {
+    const thread = await rt.createThread({ harnessId: 'test-harness', cwd: root });
+
+    // A 进入流式（adapter.send 阻塞中）
+    const sendA = rt.send(thread.id, 'first');
+    await until(() => pendingSends.has(thread.id));
+
+    // 流式中 cancel：立即放锁 + 作废旧票据；adapter.cancel 让 A 的 send 返回
+    await rt.cancel(thread.id);
+    await sendA; // A 的 finally 在此执行——票据已作废，不得触碰锁
+
+    // 立即重发 B：cancel 已放锁，必须能进入
+    const sendB = rt.send(thread.id, 'second');
+    await until(() => pendingSends.has(thread.id));
+
+    // 关键回归断言 1：B 在途时第三个发送必须被拒（若 A 的 finally 误删锁，这里会漏成并发）
+    await assert.rejects(rt.send(thread.id, 'third'), /正在执行/);
+
+    // 关键回归断言 2：B 的回合仍在运行——A 遗留的取消登记不得被 B 的消费点误吞
+    await sleep(50);
+    assert.equal(rt.execution.isRunning(thread.id), true, 'B 的回合不得被上一代取消登记误结算');
+    assert.equal(thread.error, undefined, 'B 不得携带取消/错误状态');
+
+    // 收尾：取消 B，B 的 send 返回；锁由 B 自己的 finally（或 cancel）正常回收
+    await rt.cancel(thread.id);
+    await sendB;
+    await until(() => !rt.sending.has(thread.id));
+
+    // 完整结算后新发送 C 可用：线程没有因竞态永久锁定
+    const sendC = rt.send(thread.id, 'third after settle');
+    await until(() => pendingSends.has(thread.id));
+    await rt.cancel(thread.id);
+    await sendC;
+    await until(() => !rt.sending.has(thread.id));
+
+    console.log('send-cancel-race-test: stale send finally cannot clobber the newer send lock; stale cancel requests are ticket-scoped');
+  } finally {
+    await rt.close();
+  }
+})().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/scripts/send-pre-turn-cancel-test.cjs

@@ -0,0 +1,100 @@
+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, label = 'condition') {
+  for (let i = 0; i < 300; i++) { if (fn()) return; await sleep(10); }
+  throw new Error(`timed out: ${label}`);
+}
+
+// 「Turn 启动前」取消-重发竞态（send-cancel-race 的前半段窗口）：
+// 旧 send 仍停留在会话打开/prompt 组装阶段时用户 cancel 并立即重发——
+// 1) 旧 send 恢复后必须命中取消登记、不得投递 prompt（否则与新发送双双进入原生会话，
+//    撞上原生侧 "Agent is already processing"）；
+// 2) 旧 send 不得再 turnStarted 挤占 lastTurn（否则新发送的投递前自查会误判空闲而丢消息）；
+// 3) 旧 send 迟到的 reject/事件不得击中正在运行的新回合（按回合身份核验）。
+(async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-send-pre-turn-cancel-'));
+  const root = path.join(directory, 'workspace');
+  await fs.mkdir(root);
+
+  const rt = new HostRuntime({ dataDirectory: directory });
+  await rt.store.load();
+
+  const delivered = [];
+  const adapter = {
+    manifest: { id: 'test-harness', name: 'Test', capabilities: {} },
+    async open() { return {}; },
+    async send(session, text) { delivered.push(text); /* 非阻塞 ack，回合由事件流结算 */ },
+    async cancel() {},
+    async close() {},
+  };
+  rt.adapters.set(adapter.manifest.id, adapter);
+  rt.status[adapter.manifest.id] = { available: true };
+
+  try {
+    const thread = await rt.createThread({ harnessId: 'test-harness', cwd: root });
+    await until(() => rt.sessions.has(thread.id), 'session open');
+
+    // 制造「下次发送需重新打开原生会话」的慢窗口：关掉会话并标记惰性恢复
+    const session = rt.sessions.get(thread.id);
+    await session.adapter.close(session);
+    rt.sessions.delete(thread.id);
+    thread.restore = true;
+    let openGate;
+    const openBarrier = new Promise(resolve => { openGate = resolve; });
+    const realOpen = adapter.open;
+    adapter.open = async () => { await openBarrier; return realOpen(); };
+
+    // A 进入 #send，悬挂在 #ensureOpen（Turn 尚未启动）
+    const sendA = rt.send(thread.id, 'first');
+    await until(() => rt.openings.has(thread.id), 'A suspended in native open');
+
+    // Turn 未启动时 cancel：登记取消（A 的票据）并提前放锁
+    await rt.cancel(thread.id);
+
+    // 用户立即重发 B：放锁后必须能进入；B 不得误吞 A 的取消登记
+    const sendB = rt.send(thread.id, 'second');
+
+    // 原生会话打开完成：A 的 continuation 先恢复，随后 B
+    openGate();
+    await Promise.allSettled([sendA, sendB]);
+    await until(() => delivered.length > 0, 'B delivered');
+
+    // 核心断言 1：只有 B 投递；A 在恢复后命中取消登记，不再投递
+    assert.deepEqual(delivered, ['second'], '被取消的旧发送不得投递 prompt');
+
+    // 核心断言 2：A 的取消以取消卡片闭环（lastTurn 曾是 A 的取消回合），随后 B 的回合接管
+    const assistant = thread.messages.find(m => m.role === 'assistant');
+    assert.ok(assistant, 'A 的取消应留下助手回合卡片');
+    assert.equal(assistant.stopReason, 'cancelled', 'A 的回合以取消结算');
+    assert.equal(thread.error, undefined, '线程不得携带错误状态');
+
+    // B 的回合正常运行中（非阻塞适配器：ack 即返回，回合等事件流结算）
+    assert.equal(rt.execution.isRunning(thread.id), true, 'B 的回合应正常运行');
+
+    // B 的回合经事件流正常结算，线程回到空闲，后续发送不受影响
+    const sessionB = rt.sessions.get(thread.id);
+    // 通过 adapter emit 结算 B：模拟原生 completed
+    //（createThread 时记录的是旧 emit， reopen 后需取最新会话的 emit——
+    //   本测试 adapter.open 未保存 emit，直接用 execution 事件路径验证空闲后可发）
+    await rt.cancel(thread.id); // 用户停止 B
+    await until(() => !rt.execution.isRunning(thread.id), 'B settled by cancel');
+    const sendC = rt.send(thread.id, 'third after settle');
+    await until(() => delivered.length === 2, 'C delivered');
+    assert.deepEqual(delivered, ['second', 'third after settle']);
+    await rt.cancel(thread.id);
+    await sendC;
+    assert.ok(sessionB, 'session exists');
+
+    console.log('send-pre-turn-cancel: cancelled pre-turn send never delivers; resend owns the turn; late events cannot hit the newer turn');
+  } finally {
+    await rt.close();
+  }
+})().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});