@harness-mix/cli 0.2.2 → 0.2.4

package/scripts/core-review-test.cjs

@@ -0,0 +1,68 @@
+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 { projectReview } = require('../src/main/workspace/core-review');
+
+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');
+}
+
+// 审查归属（core-review foreignPaths）：foreign 集合扫描同目录其他会话的历史全部轮次，
+// 旧会话碰过的路径会永久滞留其中。本轮工具已明确触碰的文件属本会话自身的正向事实，
+// 不得被 foreign 误剔——否则本轮编辑从审查卡片与撤回列表中消失。
+(async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-core-review-'));
+  const root = path.join(directory, 'workspace');
+  await fs.mkdir(root);
+
+  const rt = new HostRuntime({ dataDirectory: directory });
+  await rt.store.load();
+
+  const emitters = new Map();
+  rt.adapters.set('test', {
+    manifest: { id: 'test', name: 'Test', capabilities: {} },
+    async open(input) { emitters.set(input.thread.id, input.emit); return {}; },
+    async send() {}, async cancel() {}, async close() {},
+  });
+  rt.status.test = { available: true };
+
+  try {
+    // 线程 B（同目录旧会话）：历史上编辑过 src/index.js 与 other.js
+    const threadB = await rt.createThread({ harnessId: 'test', cwd: root });
+    await rt.send(threadB.id, 'B 的历史编辑');
+    emitters.get(threadB.id)({ kind: 'tool', toolCallId: 'b1', title: 'Edit', state: 'completed', path: 'src/index.js', input: '{}' });
+    emitters.get(threadB.id)({ kind: 'tool', toolCallId: 'b2', title: 'Edit', state: 'completed', path: 'other.js', input: '{}' });
+    emitters.get(threadB.id)({ kind: 'completed', finalAnswer: true });
+    await until(() => !rt.execution.isRunning(threadB.id));
+
+    // 线程 A：本轮自己用工具编辑了 src/index.js（正向触碰证据），未碰 other.js
+    const threadA = await rt.createThread({ harnessId: 'test', cwd: root });
+    await rt.send(threadA.id, 'A 的本轮编辑');
+    const messageA = threadA.messages.at(-1);
+    assert.ok(messageA.coreTurnId, '本轮消息携带 Core Turn');
+    emitters.get(threadA.id)({ kind: 'tool', toolCallId: 'a1', title: 'Edit', state: 'completed', path: 'src/index.js', input: '{}' });
+    emitters.get(threadA.id)({ kind: 'completed', finalAnswer: true });
+    await until(() => !rt.execution.isRunning(threadA.id));
+
+    // 目录级快照同时捕到两个文件的变化（含 B 的历史编辑残留）
+    const record = { id: 'synthetic', at: Date.now(), endedAt: Date.now(), skipped: 0, concurrent: false, changes: [
+      { path: 'src/index.js', before: { text: 'old index\n' }, after: { text: 'new index\n' }, added: 1, removed: 1 },
+      { path: 'other.js', before: { text: 'old other\n' }, after: { text: 'new other\n' }, added: 1, removed: 1 },
+    ] };
+    const summary = await projectReview(rt, threadA, messageA, record);
+    const paths = summary.files.map(f => f.path);
+    assert.ok(paths.includes('src/index.js'), '本轮触碰的文件不被 foreign 历史归属误剔');
+    assert.ok(!paths.includes('other.js'), '本轮未触碰的 foreign 文件仍被剔除');
+
+    console.log('core-review-test: this-turn touched paths win over historical foreign attribution; untouched foreign paths stay excluded');
+  } finally {
+    await rt.close();
+  }
+})().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/scripts/delegation-await-test.cjs

@@ -0,0 +1,76 @@
+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 < 500; i++) { if (fn()) return; await sleep(10); }
+  throw new Error(`timed out: ${label}`);
+}
+
+// /delegate 委派等待链（#awaitDelegation）：
+// 非阻塞适配器（Pi 家族收到 prompt ack 即返回）的回合由异步事件流结算，
+// 旧实现只兜底 30 秒——子任务超过 30 秒父线程就被误判成功且丢失结果。
+// 修复后：等待至子任务真正结算（上限 delegationTimeoutMs，对齐协作编排 30 分钟），
+// 超时主动取消子任务并向父线程回报错误。
+(async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-delegation-await-'));
+  const root = path.join(directory, 'workspace');
+  await fs.mkdir(root);
+
+  const rt = new HostRuntime({ dataDirectory: directory, delegationTimeoutMs: 600 });
+  await rt.store.load();
+
+  const emits = new Map();
+  const cancels = new Map();
+  const adapter = {
+    manifest: { id: 'test-harness', name: 'Test', capabilities: {} },
+    async open(input) { emits.set(input.thread.id, input.emit); return {}; },
+    // 非阻塞：ack 即返回，Turn 结算完全由后续 emit 驱动（Pi 家族形态）
+    async send(session) {},
+    async cancel(session) { cancels.set(session.threadId, (cancels.get(session.threadId) ?? 0) + 1); },
+    async close() {},
+  };
+  rt.adapters.set(adapter.manifest.id, adapter);
+  rt.status[adapter.manifest.id] = { available: true };
+
+  try {
+    // 1. 正常路径：adapter.send 早已返回，子任务经异步事件结算后答案回投父线程
+    const parent = await rt.createThread({ harnessId: 'test-harness', cwd: root });
+    const { child, turn } = await rt.delegateTask({ fromThreadId: parent.id, harnessId: 'test-harness', task: '干活' });
+    assert.equal(rt.execution.isRunning(parent.id), true, '父线程协作 Turn 运行中');
+    await sleep(150); // adapter.send 已返回而子任务未结算：父线程必须继续等待
+    assert.equal(rt.execution.isRunning(parent.id), true, '子任务未结算时父线程不得提前收尾');
+    emits.get(child.id)({ kind: 'text-delta', text: '子任务结论' });
+    emits.get(child.id)({ kind: 'completed', finalAnswer: true });
+    await until(() => !rt.execution.isRunning(parent.id), 'parent settles after child completes');
+    const doneItem = rt.core.getItemsForTurn(turn.id).find(i => i.type === 'tool_call');
+    assert.equal(doneItem.status, 'completed', '子任务成功后父线程协作工具项结算为完成');
+    assert.match(JSON.stringify(doneItem), /子任务结论/, '子任务最终文本回投到父线程');
+    assert.equal(cancels.get(child.id) ?? 0, 0, '正常结算不触发取消');
+
+    // 2. 超时路径：子任务永不结算且持续有事件（看门狗管不到），超过 delegationTimeoutMs
+    //    父线程报错收尾且子任务被主动取消（旧实现 30s 后误判成功、子任务成孤儿）
+    const parent2 = await rt.createThread({ harnessId: 'test-harness', cwd: root });
+    const d2 = await rt.delegateTask({ fromThreadId: parent2.id, harnessId: 'test-harness', task: '长跑任务' });
+    const heartbeat = setInterval(() => emits.get(d2.child.id)?.({ kind: 'text-delta', text: '.' }), 100);
+    try {
+      await until(() => !rt.execution.isRunning(parent2.id), 'parent settles on delegation timeout');
+    } finally {
+      clearInterval(heartbeat);
+    }
+    const failItem = rt.core.getItemsForTurn(d2.turn.id).find(i => i.type === 'tool_call');
+    assert.equal(failItem.status, 'error', '超时后父线程协作工具项结算为错误');
+    assert.match(JSON.stringify(failItem), /超时|未结算/, '错误说明包含超时原因');
+    assert.ok((cancels.get(d2.child.id) ?? 0) >= 1, '超时主动取消子任务，不留孤儿进程');
+
+    console.log('delegation-await-test: parent awaits async child settlement; timeout cancels the child and reports an error');
+  } finally {
+    await rt.close();
+  }
+})().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/scripts/jsonl-stdin-test.cjs

@@ -0,0 +1,40 @@
+const assert = require('node:assert/strict');
+const { JsonlProcess } = require('../src/main/host/jsonl');
+
+// JsonlProcess stdin EPIPE 防护：子进程异常退出/管道破裂后，迟到的 stdin.write 会在
+// 流上异步抛 'error'（EPIPE）；Writable 无 error 监听时 Node 将其当作未捕获异常直接
+// crash 宿主进程。修复后错误进入诊断通道，真实失败仍由 exit/error 路径统一结算。
+(async () => {
+  let crashed = null;
+  const onCrash = error => { crashed = error; };
+  process.on('uncaughtException', onCrash);
+  const diags = [];
+  try {
+    const proc = new JsonlProcess(process.execPath, ['-e', 'process.exit(0)'], {}, {
+      onDiagnostic(line) { diags.push(String(line)); },
+    });
+    await new Promise(resolve => proc.child.on('exit', resolve));
+    // 迟到写入（管道已破）+ 直接注入流错误：两种形态都不得成为未捕获异常
+    proc.notify('late.notify', {});
+    proc.send({ type: 'late' });
+    proc.child.stdin.emit('error', Object.assign(new Error('write EPIPE'), { code: 'EPIPE' }));
+    await new Promise(resolve => setTimeout(resolve, 100));
+    assert.equal(crashed, null, `stdin EPIPE 不得成为未捕获异常: ${crashed?.message ?? ''}`);
+    assert.ok(diags.some(line => /stdin/.test(line)), 'stdin 流错误进入诊断通道');
+    console.log('jsonl-stdin-test: late writes and EPIPE after child exit are swallowed as diagnostics');
+  } finally {
+    process.removeListener('uncaughtException', onCrash);
+  }
+
+  // 子进程退出时，挂起中的请求必须以带 harnessExited 标记的错误结算——
+  // protocol.inspect 依赖该标记把确定性失败标为不可重试，抑制渲染层的重开循环。
+  {
+    const proc = new JsonlProcess(process.execPath, ['-e', 'setTimeout(() => process.exit(0), 50)'], {}, {});
+    const pending = proc.request('never/answered', {});
+    await assert.rejects(pending, error => error.harnessExited === true && /进程已退出/.test(error.message));
+    console.log('jsonl-stdin-test: pending requests reject with the harnessExited marker');
+  }
+})().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/scripts/kiro-cursor-adapters-test.cjs

@@ -1,100 +1,124 @@
-const assert = require('node:assert/strict');
-const { acpAdapter, catalog } = require('../src/main/adapters/acp');
-const { nativeCommand } = require('../src/main/adapters/native-acp-command');
-
-if (process.argv.includes('--fixture')) {
-  const readline = require('node:readline');
-  const write = value => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', ...value }) + '\n');
-  const configs = [{ id: 'model', currentValue: 'sonnet', options: [{ value: 'sonnet', name: 'Sonnet' }] }, { id: 'effortLevel', currentValue: 'medium', options: [{ value: 'high', name: 'High' }] }];
-  let prompt;
-  readline.createInterface({ input: process.stdin }).on('line', line => {
-    const r = JSON.parse(line);
-    if (r.id === 'permission') {
-      assert.equal(r.result.outcome.optionId, 'native-once');
-      write({ method: 'session/update', params: { update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'native reply' } } } });
-      write({ id: prompt, result: { stopReason: 'end_turn' } });
-      return;
-    }
-    let result = {};
-    if (r.method === 'initialize') result = { agentCapabilities: { loadSession: true } };
-    else if (r.method === 'session/new' || r.method === 'session/load') result = { sessionId: r.params.sessionId || 'native-session', configOptions: configs };
-    else if (r.method === 'session/set_config_option') { configs.find(c => c.id === r.params.configId).currentValue = r.params.value; result = { configOptions: configs }; }
-    else if (r.method === 'session/prompt') {
-      prompt = r.id;
-      write({ id: 'permission', method: 'session/request_permission', params: { toolCall: { title: 'Test native permission' }, options: [{ kind: 'allow_once', optionId: 'native-once' }] } });
-      return;
-    } else if (r.method === 'session/cancel') return;
-    if (r.id !== undefined) write({ id: r.id, result });
-  });
-} else {
-  (async () => {
-    for (const [id, key, argv] of [
-      ['qoder', 'HARNESS_MIX_QODER_EXECUTABLE', ['--acp']],
-      ['zcode', 'HARNESS_MIX_ZCODE_ACP_EXECUTABLE', []],
-      ['trae', 'HARNESS_MIX_TRAE_EXECUTABLE', []],
-    ]) {
-      const previous = process.env[key];
-      try {
-        delete process.env[key];
-        if (id !== 'qoder') assert.throws(() => nativeCommand(id, argv), /ACP/);
-        process.env[key] = __filename + '.missing';
-        assert.throws(() => nativeCommand(id, argv), /未安装/);
-        process.env[key] = __filename;
-        assert.deepEqual(nativeCommand(id, argv), { command: process.execPath, args: [__filename, ...argv] });
-      } finally { if (previous === undefined) delete process.env[key]; else process.env[key] = previous; }
-    }
-    for (const name of ['kiro', 'cursor']) {
-      const module = require('../src/main/adapters/' + name);
-      assert.equal(module.manifest.capabilities.fork, name === 'kiro');
-      assert.equal(module.manifest.capabilities.questions, true);
-      const key = name === 'kiro' ? 'HARNESS_MIX_KIRO_EXECUTABLE' : 'HARNESS_MIX_CURSOR_EXECUTABLE';
-      const previous = process.env[key];
-      try {
-        process.env[key] = __filename + '.missing';
-        assert.throws(() => nativeCommand(module.manifest.id, ['acp']), /未安装/);
-        assert.equal((await module.create().inspect()).available, false);
-        process.env[key] = process.execPath;
-        assert.deepEqual(nativeCommand(module.manifest.id, ['acp']), { command: process.execPath, args: ['acp'] });
-      } finally { if (previous === undefined) delete process.env[key]; else process.env[key] = previous; }
-    }
-    // Cline：官方 `cline --acp`；诚实能力声明（无 plan/原生 diff/thinking 档/独立提问），
-    // 保留 resume 与 plan/act 权限模式；命令只认 cline 与 HARNESS_MIX_CLINE_EXECUTABLE。
-    {
-      const module = require('../src/main/adapters/cline');
-      const caps = module.manifest.capabilities;
-      assert.deepEqual(module.manifest.integrations.skills, { global: ['.cline/skills'], project: ['.cline/skills'] });
-      for (const [capability, expected] of [['fork', false], ['questions', false], ['thinkingLevels', false], ['plan', false], ['nativeDiff', false], ['usage', false], ['resume', true], ['permissionModes', true], ['models', true], ['attachments', true], ['approvals', true]])
-        assert.equal(caps[capability], expected, `cline ${capability}`);
-      const previous = process.env.HARNESS_MIX_CLINE_EXECUTABLE;
-      try {
-        delete process.env.HARNESS_MIX_CLINE_EXECUTABLE;
-        process.env.HARNESS_MIX_CLINE_EXECUTABLE = __filename + '.missing';
-        assert.throws(() => nativeCommand('cline', ['--acp']), /未安装/);
-        assert.equal((await module.create().inspect()).available, false);
-        process.env.HARNESS_MIX_CLINE_EXECUTABLE = process.execPath;
-        assert.deepEqual(nativeCommand('cline', ['--acp']), { command: process.execPath, args: ['--acp'] });
-      } finally { if (previous === undefined) delete process.env.HARNESS_MIX_CLINE_EXECUTABLE; else process.env.HARNESS_MIX_CLINE_EXECUTABLE = previous; }
-    }
-    const adapter = acpAdapter({ id: 'fixture', name: 'Fixture', bin: () => ({ command: process.execPath, args: [__filename, '--fixture'] }), args: [], requestTimeoutMs: 5000 }).create();
-    const events = [];
-    let session;
-    const emit = event => {
-      events.push(event);
-      if (event.kind === 'approval') queueMicrotask(() => adapter.respond(session, event.requestId, { confirmed: true }));
-    };
-    try {
-      session = await adapter.open({ thread: { cwd: process.cwd() }, emit });
-      assert.equal(catalog(session).models[0].id, 'sonnet');
-      await adapter.setThinkingLevel(session, 'high');
-      assert.equal(session.state.configOptions[1].currentValue, 'high');
-      await adapter.send(session, 'hello', { emit });
-      assert.ok(events.some(e => e.text === 'native reply'));
-      assert.equal(events.filter(e => e.kind === 'completed').length, 1);
-      await adapter.close(session);
-      session = await adapter.open({ thread: { cwd: process.cwd(), restore: true, nativeSessionId: 'native-session' }, emit });
-      assert.equal(session.nativeSessionId, 'native-session');
-      await adapter.cancel(session);
-    } finally { if (session) await adapter.close(session); }
-    console.log('Kiro/Cursor: discovery isolation, config, native approval, streaming, resume and cancel PASS (fixture, not live model)');
-  })().catch(error => { console.error(error); process.exitCode = 1; });
-}
+const assert = require('node:assert/strict');
+const { acpAdapter, catalog } = require('../src/main/adapters/acp');
+const { nativeCommand } = require('../src/main/adapters/native-acp-command');
+
+if (process.argv.includes('--fixture')) {
+  const readline = require('node:readline');
+  const write = value => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', ...value }) + '\n');
+  const configs = [{ id: 'model', currentValue: 'sonnet', options: [{ value: 'sonnet', name: 'Sonnet' }] }, { id: 'effortLevel', currentValue: 'medium', options: [{ value: 'high', name: 'High' }] }];
+  let prompt;
+  readline.createInterface({ input: process.stdin }).on('line', line => {
+    const r = JSON.parse(line);
+    if (r.id === 'permission') {
+      assert.equal(r.result.outcome.optionId, 'native-once');
+      write({ method: 'session/update', params: { update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'native reply' } } } });
+      write({ id: prompt, result: { stopReason: 'end_turn' } });
+      return;
+    }
+    let result = {};
+    if (r.method === 'initialize') result = { agentCapabilities: { loadSession: true } };
+    else if (r.method === 'session/new' || r.method === 'session/load') result = { sessionId: r.params.sessionId || 'native-session', configOptions: configs };
+    else if (r.method === 'session/set_config_option') { configs.find(c => c.id === r.params.configId).currentValue = r.params.value; result = { configOptions: configs }; }
+    else if (r.method === 'session/prompt') {
+      prompt = r.id;
+      write({ id: 'permission', method: 'session/request_permission', params: { toolCall: { title: 'Test native permission' }, options: [{ kind: 'allow_once', optionId: 'native-once' }] } });
+      return;
+    } else if (r.method === 'session/cancel') return;
+    if (r.id !== undefined) write({ id: r.id, result });
+  });
+} else {
+  (async () => {
+    for (const [id, key, argv] of [
+      ['qoder', 'HARNESS_MIX_QODER_EXECUTABLE', ['--acp']],
+      ['trae', 'HARNESS_MIX_TRAE_EXECUTABLE', []],
+    ]) {
+      const previous = process.env[key];
+      try {
+        delete process.env[key];
+        if (id !== 'qoder') assert.throws(() => nativeCommand(id, argv), /ACP/);
+        process.env[key] = __filename + '.missing';
+        assert.throws(() => nativeCommand(id, argv), /未安装/);
+        process.env[key] = __filename;
+        assert.deepEqual(nativeCommand(id, argv), { command: process.execPath, args: [__filename, ...argv] });
+      } finally { if (previous === undefined) delete process.env[key]; else process.env[key] = previous; }
+    }
+    // ZCode 走原生 app-server 适配器，不再是 ACP；解析只认无头 zcode.cjs /
+    // HARNESS_MIX_ZCODE_EXECUTABLE，旧 ACP 键与 nativeCommand('zcode') 已移除。
+    assert.throws(() => nativeCommand('zcode', []), /Unknown native CLI/);
+    {
+      const zcode = require('../src/main/adapters/zcode');
+      assert.equal(zcode.manifest.capabilities.approvals, true);
+      assert.equal(zcode.manifest.capabilities.fork, false);
+      assert.deepEqual(zcode.manifest.integrations.skills, { global: ['.zcode/skills', '.agents/skills'], project: ['.zcode/skills', '.agents/skills'] });
+      const previous = process.env.HARNESS_MIX_ZCODE_EXECUTABLE;
+      try {
+        delete process.env.HARNESS_MIX_ZCODE_EXECUTABLE;
+        process.env.HARNESS_MIX_ZCODE_EXECUTABLE = __filename;
+        assert.deepEqual(zcode.resolveLaunch(), { command: process.execPath, args: [__filename, 'app-server', '--stdio'] });
+        // 无覆盖且无桌面版捆绑 CLI 时必须明确报错（有的机器装有桌面版，此时允许回退）
+      } finally { if (previous === undefined) delete process.env.HARNESS_MIX_ZCODE_EXECUTABLE; else process.env.HARNESS_MIX_ZCODE_EXECUTABLE = previous; }
+    }
+    for (const name of ['kiro', 'cursor']) {
+      const module = require('../src/main/adapters/' + name);
+      assert.equal(module.manifest.capabilities.fork, name === 'kiro');
+      assert.equal(module.manifest.capabilities.questions, true);
+      const key = name === 'kiro' ? 'HARNESS_MIX_KIRO_EXECUTABLE' : 'HARNESS_MIX_CURSOR_EXECUTABLE';
+      const previous = process.env[key];
+      try {
+        process.env[key] = __filename + '.missing';
+        assert.throws(() => nativeCommand(module.manifest.id, ['acp']), /未安装/);
+        assert.equal((await module.create().inspect()).available, false);
+        process.env[key] = process.execPath;
+        assert.deepEqual(nativeCommand(module.manifest.id, ['acp']), { command: process.execPath, args: ['acp'] });
+      } finally { if (previous === undefined) delete process.env[key]; else process.env[key] = previous; }
+    }
+    // Qoder：官方 qodercli --acp。能力按 1.1.58 实测声明（fork 走标准 Zed 参数，
+    // 思考档位是 reasoning_effort 配置项；CLI 从不发送 usage_update）。
+    {
+      const module = require('../src/main/adapters/qoder');
+      const caps = module.manifest.capabilities;
+      assert.deepEqual(module.manifest.integrations.skills, { global: ['.qoder/skills'], project: ['.qoder/skills'] });
+      for (const [capability, expected] of [['fork', true], ['questions', false], ['thinkingLevels', true], ['usage', false], ['contextUsage', false], ['resume', true], ['permissionModes', true], ['models', true], ['attachments', true], ['approvals', true], ['compaction', false]])
+        assert.equal(caps[capability], expected, `qoder ${capability}`);
+    }
+    // Cline：官方 `cline --acp`；诚实能力声明（无 plan/原生 diff/thinking 档/独立提问），
+    // 保留 resume 与 plan/act 权限模式；命令只认 cline 与 HARNESS_MIX_CLINE_EXECUTABLE。
+    {
+      const module = require('../src/main/adapters/cline');
+      const caps = module.manifest.capabilities;
+      assert.deepEqual(module.manifest.integrations.skills, { global: ['.cline/skills'], project: ['.cline/skills'] });
+      for (const [capability, expected] of [['fork', false], ['questions', false], ['thinkingLevels', false], ['plan', false], ['nativeDiff', false], ['usage', false], ['resume', true], ['permissionModes', true], ['models', true], ['attachments', true], ['approvals', true]])
+        assert.equal(caps[capability], expected, `cline ${capability}`);
+      const previous = process.env.HARNESS_MIX_CLINE_EXECUTABLE;
+      try {
+        delete process.env.HARNESS_MIX_CLINE_EXECUTABLE;
+        process.env.HARNESS_MIX_CLINE_EXECUTABLE = __filename + '.missing';
+        assert.throws(() => nativeCommand('cline', ['--acp']), /未安装/);
+        assert.equal((await module.create().inspect()).available, false);
+        process.env.HARNESS_MIX_CLINE_EXECUTABLE = process.execPath;
+        assert.deepEqual(nativeCommand('cline', ['--acp']), { command: process.execPath, args: ['--acp'] });
+      } finally { if (previous === undefined) delete process.env.HARNESS_MIX_CLINE_EXECUTABLE; else process.env.HARNESS_MIX_CLINE_EXECUTABLE = previous; }
+    }
+    const adapter = acpAdapter({ id: 'fixture', name: 'Fixture', bin: () => ({ command: process.execPath, args: [__filename, '--fixture'] }), args: [], requestTimeoutMs: 5000 }).create();
+    const events = [];
+    let session;
+    const emit = event => {
+      events.push(event);
+      if (event.kind === 'approval') queueMicrotask(() => adapter.respond(session, event.requestId, { confirmed: true }));
+    };
+    try {
+      session = await adapter.open({ thread: { cwd: process.cwd() }, emit });
+      assert.equal(catalog(session).models[0].id, 'sonnet');
+      await adapter.setThinkingLevel(session, 'high');
+      assert.equal(session.state.configOptions[1].currentValue, 'high');
+      await adapter.send(session, 'hello', { emit });
+      assert.ok(events.some(e => e.text === 'native reply'));
+      assert.equal(events.filter(e => e.kind === 'completed').length, 1);
+      await adapter.close(session);
+      session = await adapter.open({ thread: { cwd: process.cwd(), restore: true, nativeSessionId: 'native-session' }, emit });
+      assert.equal(session.nativeSessionId, 'native-session');
+      await adapter.cancel(session);
+    } finally { if (session) await adapter.close(session); }
+    console.log('Kiro/Cursor: discovery isolation, config, native approval, streaming, resume and cancel PASS (fixture, not live model)');
+  })().catch(error => { console.error(error); process.exitCode = 1; });
+}

package/scripts/native-acp-depth-test.cjs

@@ -1,5 +1,5 @@
 const assert = require('node:assert/strict');
-const { nativeAcp, project } = require('../src/main/adapters/native-acp');
+const { nativeAcp, project, catalog } = require('../src/main/adapters/native-acp');
 const { AcpInteractions } = require('../src/main/adapters/acp-interactions');
 const { historyUsage, branch, latestAssistantAfterUser } = require('../src/main/adapters/codebuddy-history');
 const { projectUsage } = require('../src/main/native/usage');
@@ -25,10 +25,11 @@ if (process.argv.includes('--fixture')) {
       result = { sessionId: sid, configOptions: configs };
     }
     if (r.method === 'session/set_config_option') {
-      configs = configs.map(c => c.id === r.params.configId ? { ...c, currentValue: r.params.value } : c);
+      // 模拟 qodercli 的模型切换重置思考档位（Max→Flash 实测重置回默认档）
+      configs = configs.map(c => c.id === r.params.configId ? { ...c, currentValue: r.params.value } : (r.params.configId === 'model' && c.id === 'thought_level' ? { ...c, currentValue: 'medium' } : c));
       result = { configOptions: configs };
     }
-    if (r.method === 'session/fork') { assert.equal(r.params._meta?.kiro?.messageId, 'native-end'); result = { sessionId: randomUUID() }; }
+    if (r.method === 'session/fork') { if (r.params._meta) assert.equal(r.params._meta?.kiro?.messageId, 'native-end'); result = { sessionId: randomUUID() }; }
     if (r.method === '_kiro/session/context') result = { usagePercentage: 23 };
     if (r.method === 'session/prompt') {
       if (r.params.prompt[0].text === 'image') assert.deepEqual(r.params.prompt[1], { type: 'image', data: 'AA==', mimeType: 'image/png' });
@@ -48,7 +49,7 @@ if (process.argv.includes('--fixture')) {
 } else {
   (async () => {
     for (const vendor of ['codebuddy', 'kiro-cli', 'cursor-cli', 'qoder', 'zcode', 'trae', 'cline']) {
-      const module = nativeAcp({ id: vendor, name: vendor, args: [], timeoutMs: 2000, command: () => ({ command: process.execPath, args: [__filename, '--fixture'] }) });
+      const module = nativeAcp({ id: vendor, name: vendor, args: [], timeoutMs: 2000, command: () => ({ command: process.execPath, args: [__filename, '--fixture'] }), ...(vendor === 'qoder' ? { capabilities: { fork: true } } : {}) });
       const adapter = module.create(), events = [];
       let s;
       try {
@@ -58,6 +59,11 @@ if (process.argv.includes('--fixture')) {
         events.length = 0;
         await adapter.setModel(s, { id: 'other' });
         if (vendor !== 'cursor-cli') await adapter.setThinkingLevel(s, 'high');
+        if (vendor === 'qoder') {
+          // 模型切换重置原生 effort 后，已确认的思考档位必须重放（fixture 模拟了重置）
+          await adapter.setModel(s, { id: 'native[variant]' });
+          assert.equal(s.state.configOptions.find(c => c.id === 'thought_level').currentValue, 'high', '模型切换后确认的思考档位必须重放');
+        }
         const first = adapter.send(s, 'wait', { emit: e => events.push(e) });
         await assert.rejects(adapter.send(s, 'busy', { emit: () => {} }), /busy/);
         await assert.rejects(adapter.setModel(s, { id: 'other' }), /busy/);
@@ -84,6 +90,12 @@ if (process.argv.includes('--fixture')) {
             await assert.rejects(adapter.fork({ cwd: process.cwd(), nativeSessionId: s.nativeSessionId }, { emit: () => {} }), /Compacted/);
           } finally { if (saved === undefined) delete process.env.KIRO_HOME; else process.env.KIRO_HOME = saved; }
         }
+        if (vendor === 'qoder') {
+          // qoder fork 走标准 Zed 参数（无 kiro checkpoint _meta）
+          const forked = await adapter.fork({ cwd: process.cwd(), nativeSessionId: s.nativeSessionId }, { emit: () => {} });
+          assert.notEqual(forked.session.nativeSessionId, s.nativeSessionId);
+          await adapter.close(forked.session);
+        }
       } finally { await adapter.close(s); }
     }
     const events = [], s = { active: true, nativeSessionId: 's', emit: e => events.push(e) };
@@ -98,10 +110,15 @@ if (process.argv.includes('--fixture')) {
     const unresponsive = nativeAcp({ id: 'cursor-cli', name: 'Cursor', args: [], timeoutMs: 500,
       command: () => ({ command: process.execPath, args: [__filename, '--fixture', '--ignore-cancel'] }) }).create();
     const stalled = await unresponsive.open({ thread: { cwd: process.cwd() }, emit: () => {} });
+    const stalledSid = stalled.nativeSessionId;
     const stalledTurn = unresponsive.send(stalled, 'wait', { emit: () => {} });
     const failedTurn = assert.rejects(stalledTurn);
     await assert.rejects(unresponsive.cancel(stalled)); await failedTurn;
-    assert.ok(stalled.fault); await assert.rejects(unresponsive.send(stalled, 'again', { emit: () => {} }));
+    assert.ok(stalled.fault);
+    // 进程死后下一次 send 透明重连（restore 同一原生会话），不再永久毒化线程
+    await unresponsive.send(stalled, 'again', { emit: () => {} });
+    assert.equal(stalled.nativeSessionId, stalledSid);
+    assert.equal(stalled.fault, null);
     await unresponsive.close(stalled);
     const idle = nativeAcp({ id: 'codebuddy', name: 'CodeBuddy', args: [], timeoutMs: 1000, turnIdleTimeoutMs: 100,
       command: () => ({ command: process.execPath, args: [__filename, '--fixture'] }) }).create();
@@ -157,6 +174,14 @@ if (process.argv.includes('--fixture')) {
     assert.equal(latestAssistantAfterUser([{ type: 'message', id: 'new-u', role: 'user', content: [{ type: 'input_text', text: 'new' }] },
       { type: 'message', id: 'new-a', role: 'assistant', content: [{ type: 'output_text', text: 'native final' }] }], 'new-u'), 'native final');
     assert.throws(() => branch([{ type: 'message', id: 'a', parentId: 'a' }]), /parent chain/);
+    // qoder 的思考档位 id 是 reasoning_effort（category=model），必须照常映射
+    const qoderCatalog = catalog({ vendor: 'qoder', state: { configOptions: [
+      { id: 'model', currentValue: 'qfmodel', options: [{ value: 'qfmodel', name: 'Qwen3.8-Flash' }] },
+      { id: 'reasoning_effort', category: 'model', currentValue: 'xhigh', options: [{ value: 'xhigh', name: 'Extra High' }, { value: 'none', name: 'None' }] },
+      { id: 'mode', currentValue: 'default', options: [{ value: 'default' }, { value: 'yolo' }] },
+    ], models: null, modes: null } });
+    assert.deepEqual(qoderCatalog.thinkingLevels.map(o => o.id), ['xhigh', 'none']);
+    assert.deepEqual(qoderCatalog.permissionModes.map(o => o.id), ['default', 'yolo']);
     // 进度事件重置 idle，heartbeat-only 不重置：心跳场景下 idle 应当照常起效。
     const heartbeatOnly = nativeAcp({ id: 'codebuddy', name: 'CodeBuddy', args: [], timeoutMs: 1000, turnIdleTimeoutMs: 80, turnPromptTimeoutMs: 60_000, cancelGraceMs: 1000,
       command: () => ({ command: process.execPath, args: [__filename, '--fixture', '--ignore-prompt', '--heartbeat'] }) }).create();

package/scripts/native-protocol-test.cjs

@@ -13,10 +13,11 @@ async function main() {
   let emit;
   const emits = [];
   const answers = [];
-  const adapter = { manifest: { id: 'pi', name: 'Pi', capabilities: { streaming: true, models: true, approvals: true, questions: true, resume: true } },
+  const adapter = { manifest: { id: 'pi', name: 'Pi', capabilities: { streaming: true, models: true, approvals: true, questions: true, resume: true, fork: true } },
     async open(input) { emits.push(input.emit); emit = input.emit; return {}; },
     async describe() { return { models: [{ id: 'demo', name: 'Demo', provider: 'test' }], thinkingLevels: [{ id: 'high', label: 'High', default: true }, { id: 'low', label: 'Low' }], permissionModes: [] }; },
     async send(session, text, hooks, extras) { sendExtras.push(extras); }, async cancel() {}, async close() {},
+    async fork(source) { return { session: {}, nativeSessionId: `forked-${source.id}` }; },
     async respond(session, id, answer) { answers.push({ id, answer }); } };
   const sendExtras = [];
   runtime.adapters.set('pi', adapter); runtime.status.pi = { available: true };
@@ -183,9 +184,21 @@ async function main() {
     const question = events.find(e => e.method === 'item/tool/requestUserInput');
     await bridge.respond({ id: question.id, result: { answers: { question: { answers: ['Alice'] } } } });
     assert.equal(answers[1].answer.value, 'Alice');
+    // 多选提问：answers 数组必须全量保留（JSON 编码），只取 [0] 会无声吞掉其余选项
+    emit({ kind: 'approval', requestId: 'multi', method: 'input', title: 'Pick many?' });
+    const multi = events.filter(e => e.method === 'item/tool/requestUserInput').at(-1);
+    await bridge.respond({ id: multi.id, result: { answers: { multi: { answers: ['a', 'b'] } } } });
+    assert.equal(answers[2].answer.value, '["a","b"]', '多选答案 JSON 编码全量保留');
+    emit({ kind: 'approval', requestId: 'empty', method: 'input', title: 'Empty?' });
+    const emptyQ = events.filter(e => e.method === 'item/tool/requestUserInput').at(-1);
+    await bridge.respond({ id: emptyQ.id, result: { answers: { empty: { answers: [] } } } });
+    assert.equal(answers[3].answer.value, '', '空答案数组回退为空字符串而非 undefined');
     emit({ kind: 'file-change', changes: [{ path: 'a.txt', changeType: 'added', before: '', after: 'hello', complete: true }] });
     emit({ kind: 'completed', finalAnswer: true });
     await wait(() => !runtime.threads.find(t => t.id === threadId).reviewPending && !runtime.sending.has(threadId));
+    // Fork：Host 侧新建分支线程必须广播 thread/started，否则 Desktop 侧边栏不显示分支
+    const forked = await bridge.request('thread/fork', { threadId });
+    assert.ok(events.some(e => e.method === 'thread/started' && e.params.thread.id === forked.thread.id), 'Fork 后 Desktop 收到分支线程的 thread/started');
     assert.equal(events.filter(e => e.method === 'item/agentMessage/delta').map(e => e.params.delta).join(''), 'hello world');
     // 非终端工具投影为 dynamicToolCall（摘要显示真实工具名），终端命令投影为原生 commandExecution
     assert.ok(events.some(e => e.method === 'item/completed' && e.params.item.type === 'dynamicToolCall' && e.params.item.tool === 'Read'));