@harness-mix/cli 0.2.3 → 0.3.0

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/openclaw-adapter-test.cjs

@@ -1,5 +1,5 @@
 const assert = require('node:assert/strict');
-const { manifest, create, projectAgentEvent, projectApproval, applySessionDescription } = require('../src/main/adapters/openclaw');
+const { manifest, create, projectAgentEvent, projectApproval, applySessionDescription, planMcpReconcile, toOpenClawServerEntry, MCP_OWNED_PREFIX, THINKING_LEVELS } = require('../src/main/adapters/openclaw');
 const hermes = require('../src/main/adapters/hermes');
 
 // OpenClaw Adapter 投影单元测试。帧形状以 Gateway 2026.5.12 实测捕获为准
@@ -54,6 +54,18 @@ const hermes = require('../src/main/adapters/hermes');
   assert.equal(projectAgentEvent({ stream: 'patch', data: {} }, session).length, 0, '未验证的流不伪造');
 }
 
+// 4b. thinking 流投影（形状取自上游 emitAgentEvent stream:"thinking" 的 {text,delta}，与 assistant 同构）
+{
+  const session = { state: {} };
+  const evts = [
+    ...projectAgentEvent({ stream: 'thinking', data: { text: '先列约束', delta: '先列约束' } }, session),
+    ...projectAgentEvent({ stream: 'thinking', data: { text: '先列约束，再枚举' } }, session),
+  ];
+  assert.deepEqual(evts, [{ kind: 'thinking-delta', text: '先列约束' }, { kind: 'thinking-delta', text: '，再枚举' }], 'delta 优先 + 累计差分');
+  assert.equal(session.state.lastThinkingText, '先列约束，再枚举', 'thinking 累计文本独立跟踪');
+  assert.equal(projectAgentEvent({ stream: 'thinking', data: { text: '' } }, session).length, 0, '空思考不投影');
+}
+
 // 5. 审批投影与应答路由（exec/plugin 分流；deny 为唯一拒绝决定）
 (async () => {
 {
@@ -154,10 +166,116 @@ const hermes = require('../src/main/adapters/hermes');
   assert.equal(empty.state.usage, undefined);
 }
 
-// 9. Manifest 能力声明（诚实面：reasoning 流/plan/patch/图片未实测不声明；usage 取自原生 token 统计）
+// 9. Manifest 能力声明（诚实面：thinking 投影已接线但无推理凭据完成端到端实测，能力位保持 false；
+//    compaction=true 以原生 /compact 实测为准；usage 取自原生 token 统计）
 {
   assert.equal(manifest.id, 'openclaw');
-  assert.deepEqual(manifest.capabilities, { streaming: true, thinking: false, tools: true, approvals: true, questions: false, models: true, thinkingLevels: true, permissionModes: false, resume: true, fork: false, forkFromMessage: false, compaction: false, usage: true, contextUsage: true, attachments: true });
+  assert.deepEqual(manifest.capabilities, { streaming: true, thinking: false, tools: true, approvals: true, questions: false, models: true, thinkingLevels: true, permissionModes: false, resume: true, fork: false, forkFromMessage: false, compaction: true, usage: true, contextUsage: true, attachments: true });
+  assert.equal(manifest.integrations.mcp, true, '托管 MCP 走 mcp.servers 注册表对账');
+}
+
+// 9a. 静态思考档位兜底 = Gateway 2026.5.12 实测目录（sessions.create 后首 turn 前 describe 即返回，
+//     见 output/openclaw-thinking-probe/*.json：thinkingLevels 5 档、thinkingDefault "off"）
+{
+  assert.deepEqual(THINKING_LEVELS, ['off', 'minimal', 'low', 'medium', 'high'], '兜底目录对齐实测 5 档，不夸大');
+  const withDefault = { state: { thinkingLevels: [{ id: 'off' }, { id: 'high' }], thinkingDefault: 'off' }, models: null };
+  const described = await create().describeFor(withDefault);
+  assert.deepEqual(described.thinkingLevels, [{ id: 'off', default: true }, { id: 'high', default: false }], '原生 thinkingDefault 标记预选');
+  const fallback = await create().describeFor({ state: {}, models: null });
+  assert.deepEqual(fallback.thinkingLevels, THINKING_LEVELS.map((id) => ({ id, label: id })), 'describe 缺席时回落静态兜底');
+  assert.deepEqual(fallback.permissionModes, [], 'OpenClaw 无原生权限模式，不虚构');
+}
+
+// 9b. 托管 MCP 对账：只动 harness-mix/* 自有键，用户键原样保留；条目形状对齐 openclaw mcp set
+{
+  assert.deepEqual(toOpenClawServerEntry({ command: 'node', args: ['server.js'], env: { A: '1' } }), { command: 'node', args: ['server.js'], env: { A: '1' } });
+  assert.deepEqual(toOpenClawServerEntry({ url: 'https://mcp.example/sse', http_headers: { Authorization: 'Bearer x' } }), { url: 'https://mcp.example/sse', headers: { Authorization: 'Bearer x' } });
+  assert.deepEqual(toOpenClawServerEntry({ command: 'uvx' }), { command: 'uvx' }, '空 args/env 不携带');
+
+  const current = {
+    'user-own': { command: 'uvx', args: ['context7-mcp'] },
+    [`${MCP_OWNED_PREFIX}old`]: { url: 'https://old/sse' },
+    [`${MCP_OWNED_PREFIX}keep`]: { command: 'node', args: ['k.js'] },
+  };
+  const managed = [
+    { name: 'keep', command: 'node', args: ['k.js'] },
+    { name: 'new', url: 'https://new/sse' },
+  ];
+  const plan = planMcpReconcile(current, managed);
+  assert.deepEqual(plan.kept, { 'user-own': { command: 'uvx', args: ['context7-mcp'] } }, '用户键不动');
+  assert.deepEqual(plan.unsets, [`${MCP_OWNED_PREFIX}old`], '托管集合里消失的自有键被移除');
+  assert.deepEqual(plan.sets, [[`${MCP_OWNED_PREFIX}new`, { url: 'https://new/sse' }]], '新增进集合；未变化的键不重写');
+
+  const update = planMcpReconcile({ [`${MCP_OWNED_PREFIX}keep`]: { command: 'node', args: ['old.js'] } }, [{ name: 'keep', command: 'node', args: ['k.js'] }]);
+  assert.deepEqual(update.sets, [[`${MCP_OWNED_PREFIX}keep`, { command: 'node', args: ['k.js'] }]], '内容漂移的自有键被更新');
+
+  const empty = planMcpReconcile(undefined, []);
+  assert.deepEqual(empty, { kept: {}, sets: [], unsets: [] }, '空状态零操作');
+}
+
+// 9c. 原生斜杠命令目录与执行：commands.list {scope:'text'}（行形状按 Gateway 2026.5.12 实测）
+// → UI 命令：compact 专用条目去重、无文本别名条目诚实跳过、参数提示与来源标注
+{
+  const payload = { commands: [
+    { name: 'help', nativeName: 'help', textAliases: ['/help'], description: 'Show available commands.', category: 'core', source: 'native', scope: 'both', acceptsArgs: false, args: [] },
+    { name: 'compact', nativeName: 'compact', textAliases: ['/compact'], description: 'Compact the session context.', category: 'core', source: 'native', scope: 'text', acceptsArgs: true, args: [{ name: 'instructions', type: 'string', required: false }] },
+    { name: 'skill:Code Review', nativeName: 'code-review', textAliases: ['/code-review'], description: 'Review recent changes.', source: 'skill', scope: 'text', acceptsArgs: true, args: [{ name: 'focus', type: 'string', required: true }] },
+    { name: 'Summarize Links', nativeName: 'summarize-links', textAliases: ['/summarize-links'], description: 'Summarize a page.', source: 'plugin', scope: 'text', args: [{ name: 'url', required: false }] },
+    { name: 'no-alias', nativeName: 'no-alias', textAliases: [], description: '不可经文本面执行', source: 'native', scope: 'text' },
+    { name: '无别名', nativeName: 'cn', description: 'textAliases 缺席', source: 'native' },
+    { name: 'DUPE', nativeName: 'dupe', textAliases: ['/dupe'], source: 'native' },
+    { name: 'dupe', nativeName: 'dupe-2', textAliases: ['/dupe-2'], source: 'native' },
+  ] };
+  const calls = [];
+  const session = { host: { call: async (method, params) => { calls.push({ method, params }); return payload; } }, state: {} };
+  const commands = await create().listCommands(session);
+  assert.deepEqual(calls, [{ method: 'commands.list', params: { scope: 'text' } }]);
+  assert.equal(commands[0].id, 'compact');
+  assert.equal(commands[0].action, 'execute');
+  assert.equal(commands.filter((c) => c.id === 'compact').length, 1, '原生 compact 与映射目录去重');
+  const help = commands.find((c) => c.id === 'help');
+  assert.deepEqual([help.label, help.text, help.action], ['/help', '/help ', 'insert']);
+  assert.ok(help.description.includes('原生'), '来源标注：原生');
+  const review = commands.find((c) => c.id === 'skill:code-review');
+  assert.ok(review, 'name slug 化（skill:Code Review → skill:code-review）');
+  assert.ok(review.description.includes('<focus>'), '必选参数以 <name> 提示');
+  assert.ok(review.description.includes('技能'), '来源标注：技能');
+  const summarize = commands.find((c) => c.id === 'summarize-links');
+  assert.ok(summarize.description.includes('[url]'), '可选参数以 [name] 提示');
+  assert.ok(summarize.description.includes('插件'), '来源标注：插件');
+  assert.ok(!commands.some((c) => c.id === 'no-alias' || c.id === 'cn'), '无文本别名条目跳过');
+  assert.equal(commands.filter((c) => c.id === 'dupe').length, 1, 'slug 撞名去重');
+  assert.ok(commands.every((c) => /^[A-Za-z0-9._:-]+$/.test(c.id)), 'id 满足 UI 契约字符集');
+  assert.ok(commands.every((c) => c.label && c.label.length <= 128 && c.description.length <= 512), 'label/description 长度满足 UI 契约');
+  assert.equal(session.state.commands, commands, '目录缓存进会话状态');
+
+  // 目录 RPC 失败：仅保留可执行的压缩指令
+  const failing = { host: { call: async () => { throw new Error('rpc down'); } }, state: {} };
+  assert.deepEqual((await create().listCommands(failing)).map((c) => c.id), ['compact']);
+
+  // executeCommand：未知指令拒绝；compact 经 send 以消息文本走 agent 管道
+  const emitted = [];
+  const agentCalls = [];
+  const compactSession = {
+    host: { call: async (method, params) => {
+      agentCalls.push({ method, params });
+      if (method === 'agent') return { runId: 'run-c', status: 'accepted' };
+      if (method === 'agent.wait') return { runId: 'run-c', status: 'ok' };
+      if (method === 'sessions.describe') return null;
+      throw new Error('unexpected ' + method);
+    } },
+    nativeSessionId: 'agent:main:hm-c', state: {},
+  };
+  const adapter = create();
+  await assert.rejects(adapter.executeCommand(compactSession, 'nope', { emit: () => {} }), /未知/);
+  await adapter.executeCommand(compactSession, 'compact', { emit: (e) => emitted.push(e) });
+  assert.deepEqual(agentCalls.map((c) => c.method), ['agent', 'agent.wait', 'sessions.describe'], 'send 全链路只触这三个 RPC');
+  assert.equal(agentCalls[0].params.message, '/compact', 'compact 以消息文本走 agent 运行管道');
+  assert.equal(agentCalls[0].params.sessionKey, 'agent:main:hm-c');
+  const compaction = emitted.find((e) => e.kind === 'compaction');
+  assert.equal(compaction.outcome, 'succeeded');
+  assert.ok(/OpenClaw 压缩/.test(compaction.summary));
+  assert.equal(compaction.tokensBefore, undefined, '压缩流形状未实测，不伪造 token 前后值');
 }
 
 // 10. Hermes 经 ACP 家族工厂接入，未文档化能力不声明

package/scripts/openclaw-mcp-probe.cjs

@@ -0,0 +1,100 @@
+// OpenClaw 托管 MCP 对账实测探针：
+// 备份 openclaw.json → 推送一个仓库内 stdio MCP 服务器（collaboration-mcp.cjs）→
+// 验证 openclaw mcp list / Gateway tools 面能看到 → 移除 → 断言用户键零变化。
+// 任何一步异常都会用备份还原配置。
+const fs = require("node:fs");
+const path = require("node:path");
+const { execFileSync } = require("node:child_process");
+const { OpenClawGatewayHost } = require("../src/main/adapters/openclaw-gateway");
+const { applyManagedMcpServers, MCP_OWNED_PREFIX } = require("../src/main/adapters/openclaw");
+const { OPENCLAW_CONFIG } = require("../src/main/adapters/openclaw-gateway");
+const { cliSpawn } = require("../src/main/host/jsonl");
+
+const OUT_DIR = path.join(__dirname, "..", "output", "openclaw-mcp-probe");
+const SERVER = path.join(__dirname, "..", "src", "main", "host", "collaboration-mcp.cjs");
+
+const readCfg = () => JSON.parse(fs.readFileSync(OPENCLAW_CONFIG, "utf8"));
+const stripOwned = (servers) => Object.fromEntries(Object.entries(servers ?? {}).filter(([k]) => !k.startsWith(MCP_OWNED_PREFIX)));
+// 键序无关的规范化序列化（CLI 规范化会重排键序）；meta.lastTouched* 是 CLI 自维护簿记，不计入
+const canonical = (value) => {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value && typeof value === "object") return Object.fromEntries(Object.keys(value).sort().map((k) => [k, canonical(value[k])]));
+  return value;
+};
+const userViewOf = (cfg) => {
+  const { meta, ...rest } = cfg;
+  const mcp = { ...rest.mcp, servers: stripOwned(rest.mcp?.servers) };
+  // CLI 规范化会删除空的 mcp/servers 键；空对象与键缺失视为等价（不含用户内容）
+  if (mcp.servers && Object.keys(mcp.servers).length === 0) delete mcp.servers;
+  if (Object.keys(mcp).length === 0) delete rest.mcp; else rest.mcp = mcp;
+  return rest;
+};
+const userView = (cfg) => JSON.stringify(canonical(userViewOf(cfg)));
+const diffViews = (beforeStr, nowStr) => {
+  const walk = (x, y, p) => {
+    for (const k of new Set([...Object.keys(x || {}), ...Object.keys(y || {})])) {
+      const q = p ? `${p}.${k}` : k;
+      if (JSON.stringify(x?.[k]) !== JSON.stringify(y?.[k])) {
+        if (x?.[k] && y?.[k] && typeof x[k] === "object" && typeof y[k] === "object" && !Array.isArray(x[k]) && !Array.isArray(y[k])) walk(x[k], y[k], q);
+        else console.error(`USERVIEW DIFF: ${q} | ${JSON.stringify(x?.[k])?.slice(0, 90)} -> ${JSON.stringify(y?.[k])?.slice(0, 90)}`);
+      }
+    }
+  };
+  walk(JSON.parse(beforeStr), JSON.parse(nowStr), "");
+};
+const mcpList = () => {
+  const cli = cliSpawn("openclaw", ["mcp", "list", "--json"]);
+  return JSON.parse(execFileSync(cli.command, cli.args, { encoding: "utf8", windowsHide: true, timeout: 20000 }));
+};
+
+(async () => {
+  fs.mkdirSync(OUT_DIR, { recursive: true });
+  const backup = path.join(OUT_DIR, `openclaw.json.backup-${Date.now()}`);
+  fs.copyFileSync(OPENCLAW_CONFIG, backup);
+  console.log("backup ->", backup);
+  const before = userView(readCfg());
+  let ok = false;
+  try {
+    // 1. 推送托管服务器（与适配器 open() 同路径）
+    await applyManagedMcpServers([{ name: "probe", command: process.execPath, args: [SERVER], env: {} }], (line) => console.log(line));
+    const listed = mcpList();
+    console.log("mcp list after push ->", JSON.stringify(Object.keys(listed)));
+    if (!listed[MCP_OWNED_PREFIX + "probe"]) throw new Error("自有键未出现在 mcp list");
+    const viewNow = userView(readCfg());
+    if (viewNow !== before) {
+      diffViews(before, viewNow);
+      throw new Error("用户键视图发生变化（不应发生）");
+    }
+
+    // 2. Gateway 侧确认注册表可读；tools 面尝试 catalog/effective（effective 需要 sessionKey）
+    const host = await OpenClawGatewayHost.acquire(() => {});
+    try {
+      const sessionKey = `harness-mix-mcp-probe-${Date.now()}`;
+      await host.call("sessions.create", { key: sessionKey, label: `Harness Mix MCP probe ${Date.now()}` });
+      const evidence = {};
+      evidence.catalog = await host.call("tools.catalog", {}).catch((e) => ({ error: e.message }));
+      evidence.effective = await host.call("tools.effective", { sessionKey }).catch((e) => ({ error: e.message }));
+      const text = JSON.stringify(evidence);
+      fs.writeFileSync(path.join(OUT_DIR, "tools-evidence.json"), JSON.stringify(evidence, null, 2));
+      const hitCount = (text.match(new RegExp(MCP_OWNED_PREFIX + "probe", "g")) || []).length;
+      console.log("tools evidence saved; owned-server mentions:", hitCount);
+      console.log("effective summary ->", JSON.stringify(evidence.effective).slice(0, 400));
+    } finally { await OpenClawGatewayHost.release(); }
+
+    // 3. 移除托管服务器，断言注册表回到初始用户视图
+    await applyManagedMcpServers([], (line) => console.log(line));
+    const after = mcpList();
+    console.log("mcp list after cleanup ->", JSON.stringify(Object.keys(after)));
+    if (after[MCP_OWNED_PREFIX + "probe"]) throw new Error("自有键未被移除");
+    const finalView = userView(readCfg());
+    if (finalView !== before) { diffViews(before, finalView); throw new Error("清理后用户键视图与初始不一致"); }
+    ok = true;
+    console.log("PROBE OK：推送/注册表可见/清理/用户键零变化 全部通过");
+  } finally {
+    if (!ok) {
+      fs.copyFileSync(backup, OPENCLAW_CONFIG);
+      console.error("已用备份还原 openclaw.json");
+    }
+  }
+  process.exit(ok ? 0 : 1);
+})().catch((e) => { console.error("FAILED:", e.message); process.exit(1); });