@harness-mix/cli 0.2.1 → 0.2.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.2.3 — 2026-09-18
+
+- Turn transcripts now fold correctly again: the wire `phase` for `agentMessage` items uses Codex's own vocabulary — `commentary` / `final_answer` — which the Desktop matches literally when extracting the final answer and collapsing the execution zone into the elapsed-time bar. 0.2.1/0.2.2 sent the internal `progress` / `final` values, which the Desktop does not recognize, so completed turns stayed expanded. The internal vocabulary is unchanged and translated at the projection boundary (historic persisted items map through the same function), and the final message segment is explicitly closed at turn settle so its phase reaches the Desktop on the wire. 修复回合转录折叠：agentMessage 的 phase 改用 Codex 原生词表（commentary/final_answer），完成后过程内容正确折叠进「用时」栏。
+
+- Send/cancel race hardening: the per-thread send lock is now ticket-owned. Stopping a turn mid-stream frees the thread for an immediate resend, but the old send's exit path can no longer delete the newer send's lock (which previously let a third submission run concurrently and trip the native harness's "already processing" error); pending cancel requests are likewise scoped to the send generation they target. 取消-重发竞态修复：发送锁改为票据所有制，旧发送退出时不再误删新发送的锁。
+- Stuck-turn watchdog now cancels the native session when it settles a wedged turn, instead of only settling the UI: a zombie native process no longer blocks the thread's next turn with an occupancy error. 卡死回合看门狗结算时级联取消原生会话，避免僵尸进程占用后续回合。
+- `/delegate` waits for the child task to actually settle (up to 30 minutes, aligned with collaboration orchestration, injectable as `delegationTimeoutMs`) and cancels the child on timeout with an explicit parent-side error — previously a non-blocking harness child (e.g. Pi) running longer than 30 seconds was silently reported as done with its result dropped. 委派等待修复：子任务异步结算前父线程不再提前误判成功。
+- Forked threads now broadcast `thread/started`, so a fork appears in the Desktop sidebar immediately instead of only after a reload. Fork 分支会话即时显示在侧边栏。
+- Multi-select question answers from the Desktop are preserved in full (JSON-encoded) instead of being truncated to the first option, fixing `JSON.parse` crashes on OpenCode multiple-choice questions; empty answer arrays now resolve to `''` rather than `undefined`. 多选答案全量保留，空数组回退为空字符串。
+- Workspace review attribution: files this turn's own tools touched win over historical "foreign session" attribution, so same-directory sessions' old edits no longer hide this turn's legitimate changes from the review card and undo list. 审查归属修复：本轮触碰的文件不再被历史 foreign 归属误剔。
+- Child-process stdin streams (`jsonl` transports, the DPAPI secure-store helper, the Antigravity CLI, and the official app-server pipe) now swallow asynchronous EPIPE stream errors instead of crashing the host process with an unhandled exception. 子进程 stdin 管道错误不再导致宿主崩溃。
+
+## 0.2.2 — 2026-09-18
+
+- Aligns all six `@harness-mix/native-*` runtime packages at 0.2.2 with the CLI and pins `optionalDependencies` to the same version. 0.2.1 shipped with pins still at 0.1.11, so a fresh install's postinstall could overwrite the bundled fresh Shim binaries with the old-contract 0.1.11 ones; supersedes 0.2.1. Native binaries are rebuilt from unchanged Rust sources.
+
 ## 0.2.1 — 2026-09-18
 
 - Turn transcripts now match Codex's native three-stage experience: opening remarks and inter-tool commentary stream live as progress-phase agent messages alongside command rows while the turn runs, and on completion Codex Desktop folds every progress segment and tool item under the elapsed-time bar, leaving only the final-phase conclusion visible. The previous buffer-and-reclassify-as-reasoning approach (which hid narration while running) is removed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-mix/cli",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "license": "(Apache-2.0 OR MIT)",
   "description": "Harness Mix native Codex UI bridge for Codex, Pi, Claude Code, DeepSeek Harness, Antigravity, CodeBuddy, Kiro CLI, Cursor CLI and other native coding harnesses.",
   "keywords": [
@@ -123,7 +123,7 @@
     "test:core-concurrency": "node scripts/core-concurrency-test.cjs",
     "test:thread-title": "node scripts/thread-title-test.cjs",
     "test:handoff": "node scripts/handoff-checkpoint-test.cjs && node scripts/switch-harness-test.cjs",
-    "test:core-all": "node scripts/contracts-test.cjs && node scripts/projector-test.cjs && node scripts/turn-manager-test.cjs && node scripts/sequence-test.cjs && node scripts/shadow-test.cjs && node scripts/architecture-test.cjs && node scripts/adapters-test.cjs && node scripts/dsh-adapter-test.cjs && node scripts/codex-adapter-test.cjs && node scripts/codex-accounts-test.cjs && node scripts/antigravity-adapter-test.cjs && node scripts/openclaw-adapter-test.cjs && node scripts/core-replay-test.cjs && node scripts/determinism-test.cjs && node scripts/core-runtime-test.cjs && node scripts/core-services-test.cjs && node scripts/native-file-change-test.cjs && node scripts/native-updater-test.cjs && node scripts/native-update-apply-test.cjs && node scripts/native-vendor-adapters-test.cjs && node scripts/core-concurrency-test.cjs && node scripts/concurrency-layers-test.cjs && node scripts/tool-concurrency-regression-test.cjs && node scripts/handoff-checkpoint-test.cjs && node scripts/switch-harness-test.cjs && node scripts/native-acp-depth-test.cjs && node scripts/thread-title-test.cjs && node scripts/native-job-object-test.cjs && node scripts/integrations-test.cjs && node scripts/storage-verification-test.cjs && node scripts/stuck-turn-test.cjs && node scripts/pi-cancel-race-test.cjs",
+    "test:core-all": "node scripts/contracts-test.cjs && node scripts/projector-test.cjs && node scripts/turn-manager-test.cjs && node scripts/sequence-test.cjs && node scripts/shadow-test.cjs && node scripts/architecture-test.cjs && node scripts/adapters-test.cjs && node scripts/dsh-adapter-test.cjs && node scripts/codex-adapter-test.cjs && node scripts/codex-accounts-test.cjs && node scripts/antigravity-adapter-test.cjs && node scripts/openclaw-adapter-test.cjs && node scripts/core-replay-test.cjs && node scripts/determinism-test.cjs && node scripts/core-runtime-test.cjs && node scripts/core-services-test.cjs && node scripts/native-file-change-test.cjs && node scripts/native-updater-test.cjs && node scripts/native-update-apply-test.cjs && node scripts/native-vendor-adapters-test.cjs && node scripts/core-concurrency-test.cjs && node scripts/concurrency-layers-test.cjs && node scripts/tool-concurrency-regression-test.cjs && node scripts/handoff-checkpoint-test.cjs && node scripts/switch-harness-test.cjs && node scripts/native-acp-depth-test.cjs && node scripts/thread-title-test.cjs && node scripts/native-job-object-test.cjs && node scripts/integrations-test.cjs && node scripts/storage-verification-test.cjs && node scripts/stuck-turn-test.cjs && node scripts/pi-cancel-race-test.cjs && node scripts/send-cancel-race-test.cjs && node scripts/delegation-await-test.cjs && node scripts/core-review-test.cjs && node scripts/jsonl-stdin-test.cjs && node scripts/send-pre-turn-cancel-test.cjs",
     "test:codex-accounts": "node scripts/codex-accounts-test.cjs",
     "smoke:codex-accounts-ui": "electron scripts/codex-accounts-ui-smoke.cjs",
     "test:transcript": "node scripts/transcript-test.cjs",
@@ -166,7 +166,12 @@
     "test:shim": "node scripts/native-shim-test.cjs",
     "publish:native": "node scripts/publish-native-package.cjs",
     "test:stuck-turn": "node scripts/stuck-turn-test.cjs",
-    "test:pi-cancel-race": "node scripts/pi-cancel-race-test.cjs"
+    "test:pi-cancel-race": "node scripts/pi-cancel-race-test.cjs",
+    "test:send-cancel-race": "node scripts/send-cancel-race-test.cjs",
+    "test:delegation-await": "node scripts/delegation-await-test.cjs",
+    "test:core-review": "node scripts/core-review-test.cjs",
+    "test:jsonl-stdin": "node scripts/jsonl-stdin-test.cjs",
+    "test:send-pre-turn-cancel": "node scripts/send-pre-turn-cancel-test.cjs"
   },
   "devDependencies": {
     "@types/node": "24.13.3",
@@ -182,11 +187,11 @@
     "zod": "4.4.3"
   },
   "optionalDependencies": {
-    "@harness-mix/native-win32-x64": "0.1.11",
-    "@harness-mix/native-win32-arm64": "0.1.11",
-    "@harness-mix/native-darwin-x64": "0.1.11",
-    "@harness-mix/native-darwin-arm64": "0.1.11",
-    "@harness-mix/native-linux-x64": "0.1.11",
-    "@harness-mix/native-linux-arm64": "0.1.11"
+    "@harness-mix/native-win32-x64": "0.2.2",
+    "@harness-mix/native-win32-arm64": "0.2.2",
+    "@harness-mix/native-darwin-x64": "0.2.2",
+    "@harness-mix/native-darwin-arm64": "0.2.2",
+    "@harness-mix/native-linux-x64": "0.2.2",
+    "@harness-mix/native-linux-arm64": "0.2.2"
   }
 }

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,31 @@
+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);
+  }
+})().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});

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'));

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;
+});

package/scripts/stuck-turn-test.cjs

@@ -21,11 +21,12 @@ async function until(fn) {
   await rt.store.load();
 
   const emits = new Map();
+  const cancels = new Map(); // threadId -> adapter.cancel 次数（看门狗级联取消断言）
   const adapter = {
     manifest: { id: 'test-harness', name: 'Test', capabilities: {} },
     async open(input) { emits.set(input.thread.id, input.emit); return {}; },
     async send(session) {},
-    async cancel(session) {},
+    async cancel(session) { cancels.set(session.threadId, (cancels.get(session.threadId) ?? 0) + 1); },
     async close() {},
   };
   rt.adapters.set(adapter.manifest.id, adapter);
@@ -57,11 +58,15 @@ async function until(fn) {
     await rt.send(stuck.id, 'wedged session');
     await until(() => stuck.status === 'error');
     assert.match(stuck.error, /卡死/);
+    // 结算的同时级联取消原生会话：否则僵尸进程常驻，下一回合撞上原生侧占用报错
+    await until(() => (cancels.get(stuck.id) ?? 0) >= 1);
     const turn = rt.execution.lastTurn(stuck.id);
     assert.equal(turn.status, 'error');
     await until(() => !stuck.reviewPending);
     const open = rt.core.getItemsForTurn(turn.id).filter(item => !['completed', 'error', 'cancelled'].includes(item.status));
     assert.equal(open.length, 0, 'watchdog settlement finalizes every open item');
+    assert.equal(cancels.get(active.id) ?? 0, 0, '正常完成的活跃回合不触发 adapter.cancel');
+    assert.equal(cancels.get(approval.id) ?? 0, 0, '审批等待后正常完成的回合不触发 adapter.cancel');
 
     console.log('stuck-turn-test: active/approval-waiting turns survive; wedged zero-event turn auto-settles and finalizes items');
   } finally {

package/src/main/adapters/antigravity.js

@@ -920,6 +920,9 @@ function create(emit, options = {}) {
           windowsHide: true,
           stdio: ['pipe', 'pipe', 'pipe'],
         });
+        // 进程崩溃/提前退出时，迟到的 stdin.write/end 在流上异步抛 EPIPE；
+        // 无 error 监听的 Writable 会被 Node 当作未捕获异常 crash 宿主进程
+        child.stdin.on('error', () => {});
 
         let turnResolve, turnReject;
         const settled = new Promise((resolve, reject) => {

package/src/main/harness-adapter/event-normalizer.js

@@ -92,16 +92,19 @@ class EventNormalizer {
         // 原生流仍送达 agent_settled / result），防止影子侧出现非法状态迁移。
         if (!this.turnActive) return [];
         this.turnActive = false;
-        // 最后一段 agent_message 标记 phase:'final'：Desktop 回合结算后把此前所有
-        // progress 段与工具项折叠进「用时」栏，仅保留该段作为唯一正式结论。
+        // 最后一段 agent_message 标记 phase:'final'并显式闭合：投影边界将其译为
+        // final_answer 随 item/completed 上线，Desktop 据此把它识别为回合唯一正式结论；
+        // 其余 progress（commentary）段与工具项折叠进「用时 XXm XXs」栏。
         return [
           ...(!legacy.finalAnswer || legacy.stopReason && legacy.stopReason !== 'completed' || !this.currentMessageItemId ? [] : [this.#event({ type: 'item.updated', itemId: this.currentMessageItemId, payload: { phase: 'final' } })]),
+          ...this.#closeSegment(),
           this.#event({ type: 'turn.completed', payload: { stopReason: legacy.stopReason ?? 'completed' } }),
         ];
       case 'error':
         if (!this.turnActive) return [];
         this.turnActive = false;
         return [
+          ...this.#closeSegment(),
           this.#event({ type: 'turn.failed', payload: {
             message: String(legacy.message ?? 'unknown error'),
             errorKind: classifyError(legacy),

package/src/main/host/jsonl.js

@@ -16,6 +16,10 @@ class JsonlProcess {
     this.nextId = 1;
     this.hooks = hooks;
     this.child = spawn(command, args, { windowsHide: true, ...options, stdio: ["pipe", "pipe", "pipe"] });
+    // 子进程异常退出/管道破裂时，迟到的 stdin.write 会在流上异步抛 EPIPE；
+    // Writable 无 error 监听会被 Node 当作未捕获异常直接 crash 宿主进程。
+    // 真实失败由 exit/error 路径统一结算，这里仅吞掉管道噪声。
+    this.child.stdin.on("error", (error) => this.hooks.onDiagnostic?.(`stdin: ${error.message}`));
     this.#attachReader(this.child.stdout, (line) => this.#dispatch(line));
     this.#attachReader(this.child.stderr, (line) => hooks.onDiagnostic?.(line));
     this.child.on("error", (error) => this.#failAll(error));

package/src/main/host/runtime.js

@@ -26,7 +26,7 @@ const { createWorkspace, inspectWorkspace, reviewWorkspace, applyWorkspace, remo
  * 仍由其原生程序维护，Adapter 只负责原生协议接入与事件转换。
  */
 class HostRuntime {
-  constructor({ dataDirectory, observer = null, stuckTurnMs = 15 * 60 * 1000, stuckSweepMs = 60 * 1000 }) {
+  constructor({ dataDirectory, observer = null, stuckTurnMs = 15 * 60 * 1000, stuckSweepMs = 60 * 1000, delegationTimeoutMs = 30 * 60 * 1000 }) {
     this.store = new ThreadStore(dataDirectory);
     this.threads = [];
     this.sessions = new Map(); // threadId -> { adapter, ...session }
@@ -41,9 +41,14 @@ class HostRuntime {
     this.reviewTasks = new Set();
     this.openings = new Map();
     this.sending = new Set();
-    // send 进行中被 cancel 的线程：Turn 尚未开始或 prompt 尚未投递时 abort 无从生效，
-    // 由 #send 在 Turn 启动后/投递前据此结算取消，避免用户看不见的僵尸运行
-    this.cancelRequests = new Set();
+    // threadId -> 在途 send 的票据：cancel 会提前放锁让新发送进入，
+    // 旧 send 退出时凭票据比对，避免其 finally 误删新发送的锁
+    this.sendTickets = new Map();
+    this.sendTicketSeq = 0;
+    // send 进行中被 cancel 的线程（threadId -> 被取消 send 的票据）：Turn 尚未开始或
+    // prompt 尚未投递时 abort 无从生效，由 #send 在 Turn 启动后/投递前据此结算取消，
+    // 避免用户看不见的僵尸运行；票据不匹配的陈旧登记属上一代发送，由 #send 入口清理
+    this.cancelRequests = new Map();
     this.switching = new Set();
     // 同目录并发会话警告的去重记录：threadId -> 上次提醒时间
     this.concurrentCwdNotified = new Map();
@@ -52,6 +57,8 @@ class HostRuntime {
     // 即按超时结算，让 UI 停转、审查快照收尾。等待用户审批的回合属合法静默。
     this.turnActivity = new Map();
     this.stuckTurnMs = stuckTurnMs;
+    // /delegate 委派等待子任务结算的上限（对齐协作编排的 30 分钟），注入以便测试
+    this.delegationTimeoutMs = delegationTimeoutMs;
     this.watchdogTimer = setInterval(() => this.#sweepStuckTurns(), stuckSweepMs);
     this.watchdogTimer.unref?.();
     // 跨 Harness 协作：parentThreadId -> { childId, toolCallId, cancelled }
@@ -320,14 +327,27 @@ class HostRuntime {
     // Reserve before opening a native session: two submissions can otherwise both
     // pass isRunning() while awaiting the same opening promise.
     if (this.sending.has(threadId)) throw new Error('任务正在执行，请先停止或等待完成');
+    const ticket = ++this.sendTicketSeq;
     this.sending.add(threadId);
-    try { return await this.#send(threadId, text, { commandId, attachments, delegateOf, collaborationOf, isolated, turnPermissions }); }
-    finally { this.sending.delete(threadId); this.cancelRequests.delete(threadId); }
+    this.sendTickets.set(threadId, ticket);
+    try { return await this.#send(threadId, text, { commandId, attachments, delegateOf, collaborationOf, isolated, turnPermissions, ticket }); }
+    // cancel() 会提前放锁并让新发送进入：仅当票据仍归本次发送时才回收，否则
+    // 这里的 delete 会误删新发送的锁，使第三个发送与在途发送并发撞车
+    finally {
+      if (this.sendTickets.get(threadId) === ticket) {
+        this.sending.delete(threadId);
+        this.sendTickets.delete(threadId);
+        this.cancelRequests.delete(threadId);
+      }
+    }
   }
 
-  async #send(threadId, text, { commandId, attachments, delegateOf, collaborationOf, isolated, turnPermissions }) {
+  async #send(threadId, text, { commandId, attachments, delegateOf, collaborationOf, isolated, turnPermissions, ticket }) {
     const thread = this.#requireThread(threadId);
     if (this.execution.isRunning(thread.id)) throw new Error("任务正在执行，请先停止或等待完成");
+    // 不得在此按票据清理 cancelRequests：登记可能属于仍停留在 Turn 启动前阶段（会话
+    // 打开/prompt 组装）的在途旧 send——删掉会让旧 send 错过下方的取消结算而继续投递，
+    // 与新发送双双进入原生会话。陈旧登记由本次 send 的 finally（票据匹配时）回收。
     const prepared = this.#prepareAttachments(thread, attachments);
     const typed = typeof text === "string" ? text.trim() : "";
     if (!typed && !prepared.images.length && !prepared.texts.length) throw new Error("请输入消息");
@@ -428,9 +448,19 @@ class HostRuntime {
     thread.updatedAt = Date.now();
     delete thread.error;
     delete thread.errorKind;
-    this.execution.turnStarted(thread, displayPrompt);
-    // 会话打开/prompt 组装期间用户已按停止（cancel 时 Turn 尚未开始，原生侧无从 abort）：直接结算取消，不再投递
-    if (this.cancelRequests.delete(thread.id)) this.#applyEvent({ threadId, event: { kind: 'completed', stopReason: 'cancelled' } });
+    // 会话打开/prompt 组装期间用户已按停止（cancel 时 Turn 尚未开始，原生侧无从 abort）：
+    // 本代发送直接结算取消、不再投递。若取消后用户已重发且新回合已在运行，旧 send 不得
+    // 再 turnStarted——那会把新回合挤出 lastTurn，使新发送在投递前自查时误判空闲而丢消息；
+    // 此时静默退出，把投影权交给新回合。
+    const cancelledBeforeTurn = this.cancelRequests.get(thread.id) === ticket;
+    if (cancelledBeforeTurn) this.cancelRequests.delete(thread.id);
+    if (cancelledBeforeTurn && this.execution.isRunning(thread.id)) {
+      await this.#save();
+      this.#broadcast();
+      return;
+    }
+    const turn = this.execution.turnStarted(thread, displayPrompt);
+    if (cancelledBeforeTurn) this.#applyEvent({ threadId, event: { kind: 'completed', stopReason: 'cancelled' } });
     this.turnActivity.set(thread.id, Date.now());
     const message = thread.messages.at(-1);
     if (hasConcurrentTurn) message.concurrent = true;
@@ -438,8 +468,12 @@ class HostRuntime {
     this.#syncCore(thread);
     try { if (!collaborationOf || isolated) message.reviewId = await this.reviews.begin(thread.cwd); else message.reviewOwnerThreadId = collaborationOf; }
     catch (e) { message.reviewError = '本轮未建立文件快照：' + e.message; }
-    if (!this.execution.isRunning(thread.id)) {
-      if (message.reviewId) await this.#settleReview(thread, message);
+    // 本代回合已结算（含上方的取消结算）时退出。注意 isRunning 反映的是最新回合：
+    // 取消后用户重发的新回合一旦启动，这里会被重新置真——必须再按回合身份核验，
+    // 否则被取消的旧发送会把 review 快照与后续 prompt 投递错误地挂到新回合上。
+    const superseded = this.execution.lastTurn(thread.id)?.id !== turn.id;
+    if (!this.execution.isRunning(thread.id) || superseded) {
+      if (message.reviewId && !superseded) await this.#settleReview(thread, message);
       return;
     }
     this.startReviewUpdates(thread, message);
@@ -455,14 +489,16 @@ class HostRuntime {
           await this.#save();
           this.#broadcast();
         }
-        // 投递前最后检查：Turn 可能在 review 快照/保存期间被取消（cancel 已结算）。
+        // 投递前最后检查：Turn 可能在 review 快照/保存期间被取消（cancel 已结算），
+        // 或已被取消后重发的新回合取代（lastTurn 易主时 isRunning 仍为真）。
         // 此时再投递，先到的 abort 会在原生侧落空，形成用户看不见的僵尸运行
-        if (!this.execution.isRunning(thread.id)) {
+        const outdated = this.execution.lastTurn(thread.id)?.id !== turn.id;
+        if (!this.execution.isRunning(thread.id) || outdated) {
           if (handoff?.checkpointId) {
             handoff.phase = 'failed';
             await this.handoffs.mark(thread.id, handoff.checkpointId, 'failed').catch(() => {});
           }
-          if (message.reviewId) await this.#settleReview(thread, message);
+          if (message.reviewId && !outdated) await this.#settleReview(thread, message);
           return;
         }
         await session.adapter.send(session, promptText, hooks, { images: prepared.images, turnPermissions });
@@ -476,8 +512,10 @@ class HostRuntime {
         handoff.phase = 'failed';
         await this.handoffs.mark(thread.id, handoff.checkpointId, 'failed').catch(() => {});
       }
-      // 用户取消造成的 reject 已由 cancel() 结算，不再标错
-      if (this.execution.isRunning(thread.id)) this.#applyEvent({ threadId, event: { kind: "error", message: error.message } });
+      // 用户取消造成的 reject 已由 cancel() 结算，不再标错。若回合已易主（取消后重发 /
+      // 外部转向启动了新回合），旧发送迟到的 reject 不得击中正在运行的新回合——
+      // 仅当本代回合仍是 lastTurn 时才把错误投到它上面。
+      if (this.execution.isRunning(thread.id) && this.execution.lastTurn(thread.id)?.id === turn?.id) this.#applyEvent({ threadId, event: { kind: "error", message: error.message } });
       await this.#save().catch(() => {});
       this.#broadcast();
     }
@@ -548,12 +586,23 @@ class HostRuntime {
     let answer = '';
     try {
       await this.send(child.id, task, { delegateOf: parent.id });
-      // Adapter 返回≠原生 Turn 完全结算，兜底等待至子任务真正空闲
-      const grace = Date.now() + 30_000;
-      while (this.execution.isRunning(child.id) && Date.now() < grace) await new Promise(resolve => setTimeout(resolve, 100));
-      const lastTurn = this.execution.lastTurn(child.id);
-      if (lastTurn?.status === 'error') failure = new Error(lastTurn.error || '子任务执行失败');
-      else answer = this.#turnFinalText(child.id);
+      // Adapter 返回≠原生 Turn 完全结算（Pi 等非阻塞适配器收到 prompt ack 即返回，实际
+      // 执行由异步流驱动），有界等待至子任务真正空闲——对齐协作编排的 30 分钟上限，
+      // 超时主动取消子任务；已 wedge 的子任务由看门狗（stuckTurnMs）提前按 error 结算。
+      const until = Date.now() + this.delegationTimeoutMs;
+      while (this.execution.isRunning(child.id) && !delegation?.cancelled) {
+        if (Date.now() > until) {
+          await this.cancel(child.id);
+          failure = new Error(`子任务超过 ${Math.round(this.delegationTimeoutMs / 60000)} 分钟未结算，已自动取消`);
+          break;
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+      if (!failure) {
+        const lastTurn = this.execution.lastTurn(child.id);
+        if (lastTurn?.status === 'error') failure = new Error(lastTurn.error || '子任务执行失败');
+        else answer = this.#turnFinalText(child.id);
+      }
     } catch (error) { failure = error; }
     const cancelled = delegation?.cancelled;
     this.delegations.delete(parent.id);
@@ -615,8 +664,8 @@ class HostRuntime {
 
   async cancel(threadId) {
     const thread = this.threads.find(t => t.id === threadId);
-    // send 进行中（会话恢复 / prompt 尚未投递）时 abort 可能落空：登记取消请求，由 #send 在投递前结算
-    if (this.sending.has(threadId)) this.cancelRequests.add(threadId);
+    // send 进行中（会话恢复 / prompt 尚未投递）时 abort 可能落空：按票据登记取消请求，由 #send 在投递前结算
+    if (this.sending.has(threadId)) this.cancelRequests.set(threadId, this.sendTickets.get(threadId));
     // If this thread is a collaboration child task, mark the collaboration job as cancelled immediately
     const childJob = [...this.collaboration.jobs.values()].find(j => j.childId === threadId && j.status === 'running');
     if (childJob) {
@@ -625,7 +674,9 @@ class HostRuntime {
     }
     // Record the user's cancellation immediately so UI and Core become idle without waiting on subtasks
     if (thread && this.execution.isRunning(thread.id)) this.#applyEvent({ threadId, event: { kind: 'completed', stopReason: 'cancelled' } });
+    // 立即放锁让用户可以重发；同时作废旧 send 的票据，其 finally 不得误删新发送的锁
     this.sending.delete(threadId);
+    this.sendTickets.delete(threadId);
     // Cancel child collaboration tasks with a hard timeout to prevent child hangs
     try {
       await Promise.race([
@@ -765,6 +816,8 @@ class HostRuntime {
     } else this.sessions.set(thread.id, attachSession(adapter, session, thread.id));
     await this.#save();
     this.#broadcast();
+    // 与 createThread 同一契约：通知 Desktop 侧边栏实时挂载分支会话（protocol.js 据此发 thread/started）
+    for (const listener of this.listeners) listener({ type: 'thread-created', thread });
     return thread;
   }
 
@@ -1179,6 +1232,11 @@ class HostRuntime {
       const last = this.turnActivity.get(thread.id) ?? this.execution.lastTurn(thread.id)?.createdAt ?? now;
       if (now - last < this.stuckTurnMs) continue;
       this.turnActivity.delete(thread.id);
+      // 级联取消原生会话：仅结算 Turn 而不 abort，原生进程（死循环脚本/挂起的长连接）会
+      // 常驻后台，下一次发送直接撞上原生侧的会话占用报错（如 Pi 的 already processing），
+      // 该 Thread 永久无法恢复。fire-and-forget 不阻塞扫描；迟到事件由 execution.apply 忽略。
+      const session = this.sessions.get(thread.id);
+      if (session) void Promise.race([session.adapter.cancel(session), new Promise(r => setTimeout(r, 2000))]).catch(() => {});
       this.#applyEvent({ threadId: thread.id, event: { kind: 'error', timestamp: now,
         message: `原生会话超过 ${Math.round(this.stuckTurnMs / 60000)} 分钟未产生任何事件，判定为卡死并已自动结算。如原生进程仍在运行，可手动取消或开启新回合。` } });
     }

package/src/main/native/host.js

@@ -83,6 +83,8 @@ async function runNativeHost() {
   const passthrough = process.argv.slice(2);
   const officialArgs = passthrough.includes('--listen') ? passthrough : [...passthrough, '--listen', 'stdio://'];
   const official = spawn(stock, officialArgs, { env, windowsHide: true, stdio: ['pipe', 'pipe', 'inherit'] });
+  // official 异常退出后迟到的 stdin.write 会异步抛 EPIPE，无监听即 crash 宿主；退出由 close() 路径处理
+  official.stdin.on('error', () => {});
   const forwarded = new Map();
   const lines = readline.createInterface({ input: official.stdout });
   lines.on('line', line => {

package/src/main/native/protocol.js

@@ -199,6 +199,16 @@ function pickTurnPermissions(params = {}) {
   return Object.keys(picked).length ? picked : null;
 }
 
+// Desktop 渲染层按字面量匹配 agentMessage 的 phase 词表（commentary / final_answer）：
+// split-items-into-render-groups 只在 phase==='final_answer' 时把末段提取为回合结论，
+// 其余 assistant-message 随执行区折叠进「用时」栏。内部 CoreEvent 词表是 progress / final，
+// 在此 Codex 投影边界翻译；历史持久化数据（progress/final）也经此映射，无需迁移。
+function agentMessagePhase(phase) {
+  if (phase === 'progress' || phase === 'commentary') return 'commentary';
+  if (phase === 'final' || phase === 'final_answer' || phase == null) return 'final_answer';
+  return phase;
+}
+
 function projectItem(item) {
   const base = { id: item.id };
   if (item.type === 'user_message') return { ...base, type: 'userMessage', content: [
@@ -207,7 +217,7 @@ function projectItem(item) {
       ? { type: 'image', url: `data:${a.mime || 'image/png'};base64,${a.data}` }
       : a.path ? { type: 'localImage', path: a.path } : { type: 'text', text: `[图片：${a.name}]`, text_elements: [] }),
   ] };
-  if (item.type === 'agent_message' || item.type === 'notice') return { ...base, type: 'agentMessage', text: item.content || '', phase: item.phase || 'final' };
+  if (item.type === 'agent_message' || item.type === 'notice') return { ...base, type: 'agentMessage', text: item.content || '', phase: agentMessagePhase(item.phase) };
   if (item.type === 'reasoning') return { ...base, type: 'reasoning', summary: [item.content || ''], content: [] };
   if (item.type === 'tool_call' && item.collaboration) {
     const job = item.collaboration;
@@ -1154,7 +1164,11 @@ class NativeProtocol {
     const pending = this.approvals.get(message.id);
     if (!pending) return false;
     if (message.error) throw new Error(message.error.message || 'Approval UI error');
-    const answer = message.result?.answers?.[pending.requestId]?.answers?.[0];
+    // Desktop 的 answers 为 string[]：多选提问（如 ACP/OpenCode multiple）勾选多项时
+    // 只取 [0] 会无声吞掉其余选项，且 opencode 对 multiple 题执行 JSON.parse(response.value)，
+    // 单值字符串会直接抛 SyntaxError——多答案 JSON 编码全量保留，单答案维持原字符串。
+    const rawAnswers = message.result?.answers?.[pending.requestId]?.answers;
+    const answer = Array.isArray(rawAnswers) && rawAnswers.length > 1 ? JSON.stringify(rawAnswers) : (rawAnswers?.[0] ?? '');
     const decision = message.result?.decision;
     const response = pending.item.type === 'question' ? { value: answer || '' } : pending.item.method === 'select' ? { value: answer || '' } : { confirmed: decision === 'accept' || decision === 'acceptForSession' };
     await this.runtime.respondApproval(pending.threadId, pending.requestId, response);

package/src/main/native/secure-store.js

@@ -33,6 +33,8 @@ function run(args, input) {
       }
       resolve({ missing: false, stdout: Buffer.from(stdout || '') });
     });
+    // helper 进程提前退出时 stdin.end 会异步抛 EPIPE，无监听即 crash 宿主；真实错误由 execFile 回调覆盖
+    if (child.stdin) child.stdin.on('error', () => {});
     if (input !== undefined && child.stdin) child.stdin.end(Buffer.from(input));
   });
 }

package/src/main/workspace/core-review.js

@@ -75,6 +75,9 @@ async function projectReview(runtime, thread, message, record) {
   );
 
   let changes = record.changes;
+  // 本轮触碰路径惰性计算一次：供并发收窄与 foreign 过滤两处共用
+  let touched = null;
+  const touchedThisTurn = () => (touched ??= touchedPaths(runtime, thread, message));
   if (hasNativePatch && record.concurrent) {
     // 同目录并发时，原生 patch 是唯一能归属到本轮的边界。无并发时始终
     // 保留 Host 最终快照，补齐原生 Harness 没有上报或漏报的文件。
@@ -85,14 +88,19 @@ async function projectReview(runtime, thread, message, record) {
     // 无原生 patch 的 Harness（如 Pi）：并发同目录时用本轮工具触碰路径收窄全量快照，
     // 避免同项目其他会话的改动出现在本回合卡片里。本轮没有任何可归因路径时
     // （纯 shell 会话等）保留全量快照，不虚报归属。
-    const touched = touchedPaths(runtime, thread, message);
-    if (touched.size) changes = changes.filter(change => touched.has(change.path.toLowerCase()));
+    const touchedSet = touchedThisTurn();
+    if (touchedSet.size) changes = changes.filter(change => touchedSet.has(change.path.toLowerCase()));
   }
 
-  // 正向归属于其他会话的改动无条件剔除（不依赖 concurrent 标记：对方可能
-  // 在本回合开始后才启动）。无归属证据的改动保持原样，不虚报归属。
+  // 正向归属于其他会话的改动剔除（不依赖 concurrent 标记：对方可能在本回合开始后
+  // 才启动）。但本轮工具已明确触碰的文件属本会话自身的正向事实——foreign 集合扫描的是
+  // 其他会话的历史全部轮次，同目录旧会话碰过的路径会永久滞留其中，不得据此误剔本轮编辑，
+  // 否则该文件会从审查卡片与撤回列表中消失。无归属证据的改动保持原样，不虚报归属。
   const foreign = foreignPaths(runtime, thread, message);
-  if (foreign.size) changes = changes.filter(change => !foreign.has(change.path.toLowerCase()));
+  if (foreign.size) {
+    const touchedSet = touchedThisTurn();
+    changes = changes.filter(change => touchedSet.has(change.path.toLowerCase()) || !foreign.has(change.path.toLowerCase()));
+  }
 
   core.dispatch({ threadId: thread.id, turnId: message.coreTurnId, type: 'files.updated', payload: {
     source: 'snapshot', replace: true,