@zhushanwen/pi-subagent-workflow 7.3.4 → 8.0.0

package/src/execution/__tests__/subagent-service-parent-guard.test.ts

@@ -0,0 +1,180 @@
+// src/execution/__tests__/subagent-service-parent-guard.test.ts
+//
+// [v4 A-5 / P7] getRecordForAction 直接父校验单元测试。
+//
+// 背景：递归 subagent 场景下，孙级 record（parentRecordId = 某子进程的 self recordId）
+// 的子进程句柄只存在于其直接父进程内存。SP-8 后全树 record 的 rootSessionId 贯穿真 ROOT，
+// 旧实现 getRecordForAction 仅校验 rootSessionId → 主进程可凭 rootSessionId 通过 message 孙级，
+// 但孙级 B 的子进程句柄只在 A 进程里 → 主进程走冷路径重新 spawn → 双写同一 session 文件（P7）。
+//
+// 修复：rootSessionId 校验之后增加直接父校验——record.parentRecordId 必须等于本进程
+// execCtxBaseline.recordId（主进程 baseline=null → 只能操作根层 record）。
+//
+// 本测试 mock execCtxBaseline 三种身份（undefined=主进程 / sa-A=直接父 / sa-B=兄弟进程），
+// 断言对 record B（parentRecordId=sa-A）及顶层 record 的操作权限矩阵。
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// mock logger（import 链需要 getLogger 存在）
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn(), info: vi.fn() },
+}));
+vi.mock("@zhushanwen/pi-extension-logger", () => ({ getLogger: () => loggerMock }));
+
+// mock session-runner（import 链需要 runSpawn/killAllSpawnedChildren/getChildByRecord 存在）
+vi.mock("../session-runner.ts", () => ({
+  runSpawn: vi.fn(),
+  killAllSpawnedChildren: vi.fn(),
+  getChildByRecord: vi.fn(() => undefined),
+}));
+
+import { createRecord } from "../execution-record.ts";
+import { ModelConfigService } from "../model-config-service.ts";
+import { RecordStore } from "../record-store.ts";
+import { SubagentService } from "../subagent-service.ts";
+import type { PiLike } from "../subagent-service.ts";
+import type { ExecutionRecord } from "../types.ts";
+
+type Baseline = { recordId: string | undefined; depth: number } | null;
+const MAIN_PROCESS: Baseline = null;
+const PARENT_A: Baseline = { recordId: "sa-A", depth: 1 };
+const SIBLING_B: Baseline = { recordId: "sa-B", depth: 1 };
+
+function makeTmpAgentDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "parent-guard-"));
+}
+
+function makePi(): PiLike {
+  return {
+    appendEntry: vi.fn(),
+    events: { emit: vi.fn() },
+    sendMessage: vi.fn(),
+  } as unknown as PiLike;
+}
+
+/** 暴露私有字段供测试注入身份。 */
+interface ServiceInternals {
+  store: RecordStore;
+  sessionRootId: string | null;
+  execCtxBaseline: { recordId: string | undefined; depth: number } | null;
+}
+
+/** 构造一个 chatMode idle record（message/close action 的典型目标态）。 */
+function makeRecord(
+  id: string,
+  sessionRootId: string,
+  overrides: Partial<ExecutionRecord> = {},
+): ExecutionRecord {
+  return createRecord(id, {
+    agent: "general-purpose",
+    model: "test/model",
+    mode: "background",
+    task: "test",
+    slug: "test",
+    startedAt: 1000,
+    rootSessionId: sessionRootId,
+    chatMode: true,
+    controller: new AbortController(),
+    ...overrides,
+  });
+}
+
+describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
+  let agentDir: string;
+  let service: SubagentService;
+  let store: RecordStore;
+  let sessionRootId: string;
+  let internals: ServiceInternals;
+
+  beforeEach(() => {
+    agentDir = makeTmpAgentDir();
+    const modelService = new ModelConfigService({ agentDir });
+    service = new SubagentService({ cwd: agentDir, modelService });
+    // initSession 建立 sessionRootId=sessionId（本 session 树的根）。execCtxBaseline 的
+    // 真实值由 initSession 从 env 读取（见 recursive-visibility-baseline.test.ts），但本测试
+    // 聚焦守卫逻辑，故每例直接注入身份（mock），不依赖进程 env（测试进程可能继承 subagent env）。
+    service.initSession({ pi: makePi(), sessionId: "root-session" });
+    internals = service as unknown as ServiceInternals;
+    store = internals.store;
+    sessionRootId = internals.sessionRootId!;
+  });
+
+  afterEach(() => {
+    service.dispose();
+    fs.rmSync(agentDir, { recursive: true, force: true });
+  });
+
+  // ---------- 身份 sa-A：直接父，放行孙级 B ----------
+
+  it("身份=sa-A（直接父）→ 放行操作孙级 record B（parentRecordId=sa-A）", () => {
+    const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "idle" });
+    store.register(recordB);
+    internals.execCtxBaseline = PARENT_A;
+
+    expect(service.getRecordForAction("sa-B")).toBe(recordB);
+  });
+
+  // ---------- 身份 undefined（主进程）：拒绝孙级，放行根层 ----------
+
+  it("身份=undefined（主进程）拒绝孙级 record B，错误含 'direct parent' + 'parent=sa-A'", () => {
+    const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "idle" });
+    store.register(recordB);
+    internals.execCtxBaseline = MAIN_PROCESS;
+
+    expect(() => service.getRecordForAction("sa-B")).toThrow(/direct parent/);
+    expect(() => service.getRecordForAction("sa-B")).toThrow(/see \/subagents list, parent=sa-A/);
+  });
+
+  it("身份=undefined（主进程）放行顶层 record（parentRecordId=undefined 视为根层）", () => {
+    const topRecord = makeRecord("sa-top", sessionRootId, { parentRecordId: undefined, depth: 0, status: "idle" });
+    store.register(topRecord);
+    internals.execCtxBaseline = MAIN_PROCESS;
+
+    expect(service.getRecordForAction("sa-top")).toBe(topRecord);
+  });
+
+  // ---------- 身份 sa-B（兄弟进程）：拒绝孙级 ----------
+
+  it("身份=sa-B（兄弟进程）拒绝孙级 record B（parentRecordId=sa-A ≠ baseline sa-B）", () => {
+    const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "idle" });
+    store.register(recordB);
+    internals.execCtxBaseline = SIBLING_B;
+
+    expect(() => service.getRecordForAction("sa-B")).toThrow(/direct parent/);
+    expect(() => service.getRecordForAction("sa-B")).toThrow(/see \/subagents list, parent=sa-A/);
+  });
+
+  // ---------- 身份缺省语义 + 更深递归 ----------
+
+  it("子进程（baseline=sa-A）拒绝顶层 record（身份缺省视为根层，仅主进程可操作）", () => {
+    const topRecord = makeRecord("sa-top", sessionRootId, { parentRecordId: undefined, depth: 0, status: "idle" });
+    store.register(topRecord);
+    internals.execCtxBaseline = PARENT_A;
+
+    expect(() => service.getRecordForAction("sa-top")).toThrow(/direct parent/);
+  });
+
+  it("P7 场景：主进程拒绝曾孙 record C（parentRecordId=sa-B），错误含 baseline=root + parent=sa-B", () => {
+    const recordC = makeRecord("sa-C", sessionRootId, { parentRecordId: "sa-B", depth: 3, status: "idle" });
+    store.register(recordC);
+    internals.execCtxBaseline = MAIN_PROCESS;
+
+    const fn = () => service.getRecordForAction("sa-C");
+    expect(fn).toThrow(/direct parent/);
+    expect(fn).toThrow(/see \/subagents list, parent=sa-B/);
+    expect(fn).toThrow(/baseline=\(root\)/);
+  });
+
+  it("rootSessionId 不匹配仍优先拒绝（直接父校验在 rootSessionId 校验之后，不绕过归属守卫）", () => {
+    // 跨 session 树的 record：rootSessionId 不匹配 → 走首个 throw（not found or not owned）
+    const foreignRecord = makeRecord("sa-foreign", "other-session", { parentRecordId: "sa-A", depth: 2, status: "idle" });
+    store.register(foreignRecord);
+    internals.execCtxBaseline = PARENT_A;
+
+    expect(() => service.getRecordForAction("sa-foreign")).toThrow(/not found or not owned/);
+  });
+});

package/src/execution/__tests__/subagent-service.test.ts

@@ -25,6 +25,7 @@ import type { UiRequest, UiRequestHandler } from "../dialog-queue.ts";
 import type { PiLike } from "../subagent-service.ts";
 import { getSubagentService, setSubagentService,SubagentService } from "../subagent-service.ts";
 import type { ExecutionRecord } from "../types.ts";
+import type { WorktreeManager } from "../worktree-manager.ts";
 
 // ── 工具:建临时 agentDir + 真实 ModelConfigService ──
 
@@ -468,11 +469,49 @@ describe("SubagentService", () => {
         expect((err as Error).message).not.toMatch(/requires fork/);
       }
     });
-  });
 
-  // ============================================================
-  // pending-notifications emit 断言 (H4)
-  // ============================================================
+    // ============================================================
+    // create-await 竞态守卫（Phase 2）：create 的 await 窗口内 dispose/cancel
+    // 可把 record CAS 成 closed——守卫须主动 cleanup + early-failed 返回，不 kickOff。
+    // 实现约束固化：「赋值 record.worktreeHandle → 终态检查 → kickOffBackground」
+    // 必须同一同步段（中间禁止 await），本用例即该不变量的回归锚点。
+    // ============================================================
+    it("守卫：create await 窗口内 dispose 抢先 → cleanup 被调 + early-failed 返回（不 kickOff）", async () => {
+      const service = makeReadyService();
+      const wtm = Reflect.get(service, "worktreeManager") as WorktreeManager;
+      const handle = Object.freeze({
+        path: "/tmp/wt-guard",
+        branch: "pi-sub-guard",
+        baseCommit: "abc123",
+        mainCwd: "/repo",
+      }) as Parameters<WorktreeManager["cleanup"]>[0];
+      let resolveCreate!: (h: unknown) => void;
+      vi.spyOn(wtm, "create").mockImplementation(
+        () => new Promise((r) => { resolveCreate = r; }) as ReturnType<WorktreeManager["create"]>,
+      );
+      const cleanupSpy = vi.spyOn(wtm, "cleanup").mockResolvedValue(undefined);
+
+      const execP = service.execute({
+        task: "guard test",
+        worktree: true,
+        fork: false,
+        ctxModel: { id: "ctx-model", name: "Ctx", provider: "p", reasoning: false },
+      });
+      // 微任务推进：record 已建 + execute 挂在 pending create 上
+      await new Promise((r) => { setTimeout(r, 0); });
+      // dispose 抢先（无需 record id）：CAS running → closed，此时 worktreeHandle 仍
+      // undefined（dispose 的 fire-and-forget cleanup 跳过）——守卫是唯一的清理点
+      service.disposeAllRecords("parent-shutdown");
+      resolveCreate(handle);
+
+      const ret = await execP;
+      // 守卫生效：handle 被主动清理（不等 60s reaper）
+      expect(cleanupSpy).toHaveBeenCalledWith(handle);
+      // 返回 early-failed 形态（details.status 已 closed），而非 kickOff 的 running 形态
+      expect(ret.mode).toBe("background");
+      expect(ret.details).toMatchObject({ status: "closed" });
+    });
+  });
   //
   // [背景] PR #82 在 subagent-service.ts 新增 emitPendingRegister/Unregister 调用，
   // 5 个 emit 点：register（execute L309）、unregister(failed)（finalizeFailed 经
@@ -572,11 +611,11 @@ describe("SubagentService", () => {
       // unregister(failed) 只记 registry 状态（通知由 BgNotifier 发，不在这条事件里）
       expect(pi.events.emit).toHaveBeenCalledWith(
         "pending:unregister",
-        expect.objectContaining({ reason: "failed" }),
+        expect.objectContaining({ reason: "closed" }),
       );
     });
 
-    it("cancel(background) → unregister(reason=cancelled) 被 emit，register 未被 emit", () => {
+    it("cancel(background) → unregister(reason=closed) 被 emit，register 未被 emit（v4 B-1 cancelled 折入 closed）", () => {
       const { service, pi } = makeReadyServiceWithPi();
       const record = injectRunningBackground(service, "bg-cancel-1");
       expect(record.status).toBe("running");
@@ -587,7 +626,7 @@ describe("SubagentService", () => {
       expect(ok).toBe(true);
       expect(pi.events.emit).toHaveBeenCalledWith(
         "pending:unregister",
-        expect.objectContaining({ id: "bg-cancel-1", reason: "cancelled" }),
+        expect.objectContaining({ id: "bg-cancel-1", reason: "closed" }),
       );
       // record 手动注入（未走 execute）→ register 不应被 emit
       expect(pi.events.emit).not.toHaveBeenCalledWith("pending:register", expect.anything());
@@ -613,15 +652,15 @@ describe("SubagentService", () => {
       // 每个 running record 都 emit 了 pending:unregister(reason=failed)
       expect(pi.events.emit).toHaveBeenCalledWith(
         "pending:unregister",
-        expect.objectContaining({ id: "bg-dispose-1", reason: "failed" }),
+        expect.objectContaining({ id: "bg-dispose-1", reason: "closed" }),
       );
       expect(pi.events.emit).toHaveBeenCalledWith(
         "pending:unregister",
-        expect.objectContaining({ id: "bg-dispose-2", reason: "failed" }),
+        expect.objectContaining({ id: "bg-dispose-2", reason: "closed" }),
       );
       expect(pi.events.emit).toHaveBeenCalledWith(
         "pending:unregister",
-        expect.objectContaining({ id: "bg-dispose-3", reason: "failed" }),
+        expect.objectContaining({ id: "bg-dispose-3", reason: "closed" }),
       );
     });
 
@@ -746,5 +785,4 @@ describe("ModelConfigService ctxModel 缓存", () => {
 //   - run() 事件累积（turn_end / message_end usage / tool_start+end / error stopReason）
 //   - sync signal abort → cancelled
 //   - schema enforcement steer（漏调 structured-output）
-//   - onUpdate 回流（TRIGGERING_EVENT_TYPES）
 // 同时覆盖 session-runner.run() —— event-bridge 合并进 run() 后的事件处理回归。

package/src/execution/__tests__/timeout-integration.test.ts

@@ -15,7 +15,8 @@
 //
 // mock 策略（与 run-spawn-integration.test.ts / run-spawn-edges.test.ts 一致）：
 //   - node:child_process.spawn → 返回 FakeChild（EventEmitter + PassThrough）。
-//   - node:child_process.execFileSync → 返回空串（buildEnvBlock git branch 兜底）。
+//   - node:child_process.execFile → err-first callback 默认兜底（buildEnvBlock git branch
+//     失败 → catch → branch=""）。
 //   - node:fs 同步方法 → mock（避免触碰真实文件系统），promises 保留真实实现。
 //   - temp-prompt → mock（返回固定路径，消除 fake-timers flaky）。
 //   - alive-store.writeAliveMarker → mock。
@@ -35,6 +36,7 @@ vi.mock("node:child_process", async () => {
   class FakeChild extends EventEmitter {
     pid = 12345;
     stdout = new PassThrough();
+    stdin = new PassThrough(); // runSpawn 注册 stdin EPIPE handler（session-runner），FakeChild 必须提供
     stderr = new PassThrough();
     killed = false;
     killSignal: string | undefined;
@@ -47,7 +49,15 @@ vi.mock("node:child_process", async () => {
 
   return {
     spawn: vi.fn(() => new FakeChild()),
-    execFileSync: vi.fn(() => ""),
+    // buildEnvBlock 用 execFile 异步取 git branch：默认 err-first 兜底（catch → branch=""）
+    execFile: vi.fn(
+      (
+        _cmd: string,
+        _args: readonly string[],
+        _opts: unknown,
+        cb: (err: Error | null, stdout?: string, stderr?: string) => void,
+      ) => cb(new Error("execFile not configured in this test")),
+    ),
   };
 });
 
@@ -83,14 +93,13 @@ vi.mock("../temp-prompt.ts", () => ({
   cleanupTempPrompt: vi.fn(async () => {}),
 }));
 
-import { execFileSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 
 import { createRecord } from "../execution-record.ts";
 import { type RunOptions, runSpawn, type SessionRunnerContext } from "../session-runner.ts";
 
 const mockSpawn = vi.mocked(spawn);
-const mockExec = vi.mocked(execFileSync);
 const mockExistsSync = vi.mocked(fs.existsSync);
 
 /**
@@ -186,33 +195,39 @@ function makeCtx(overrides: Partial<SessionRunnerContext> = {}): SessionRunnerCo
 }
 
 /**
- * fake timers 下推进时间直到 spawn 被调用。
+ * fake timers 下推进时间直到 spawn 被调用（返回 child 控制器，与共享 helper 的 void 返回
+ * 不同，故就地维护）。
+ *
+ * [快照语义] 同 helpers/spawn-mock.ts 的 waitForSpawn：记调用时 baseline，等待其后的
+ * **新** spawn——支持同一测试/文件内多次 runSpawn（旧 `length === 0` 只对首次有效）。
  *
  * runSpawn 在 mkdirSync + writePromptToTempFile（mock 的 async I/O）之后才调 spawn。
  * 每次推进 10ms 让轮询 setTimeout 触发，advanceTimersByTimeAsync 同时 flush 已 resolve
  * 的 I/O promise，使 runSpawn 继续走到 spawn。
  */
 async function waitForSpawnFake(timeoutSteps = 200): Promise<FakeChild> {
+  const baseline = mockSpawn.mock.results.length;
   for (let i = 0; i < timeoutSteps; i++) {
-    if (mockSpawn.mock.results.length > 0) break;
+    if (mockSpawn.mock.results.length > baseline) break;
     await vi.advanceTimersByTimeAsync(10);
   }
-  if (mockSpawn.mock.results.length === 0) {
+  if (mockSpawn.mock.results.length <= baseline) {
     throw new Error("spawn was not called (fake timers did not progress to spawn)");
   }
   return lastSpawnedChild();
 }
 
 /**
- * 真实 timers 下轮询直到 spawn 被调用（用于 signal abort 测试——不需要推进 watchdog，
- * 用 queueMicrotask 触发 abort，真实 timers 下 mock I/O 正常 resolve）。
+ * 真实 timers 下轮询直到 spawn 被调用（返回 child 控制器；用于 signal abort 测试——
+ * 不需要推进 watchdog，用 queueMicrotask 触发 abort，真实 timers 下 mock I/O 正常 resolve）。
  *
- * 与 run-spawn-edges.test.ts 的 waitForSpawn 同模式：setInterval 轮询 mockSpawn.mock.results，
- * 比 vi.waitFor 在该 vitest 版本下更可靠（偶发过早 resolve）。
+ * [快照语义] 同 helpers/spawn-mock.ts 的 waitForSpawn：记 baseline 等**新** spawn，
+ * 支持同文件多次 runSpawn。
  */
 async function waitForSpawnReal(timeoutMs = 1000): Promise<FakeChild> {
   const start = Date.now();
-  while (mockSpawn.mock.results.length === 0) {
+  const baseline = mockSpawn.mock.results.length;
+  while (mockSpawn.mock.results.length <= baseline) {
     if (Date.now() - start > timeoutMs) {
       throw new Error(`spawn was not called within ${timeoutMs}ms`);
     }
@@ -228,7 +243,6 @@ async function waitForSpawnReal(timeoutMs = 1000): Promise<FakeChild> {
 describe("timeoutMs / signal abort → child.kill 端到端路径", () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    mockExec.mockReturnValue("");
     mockExistsSync.mockReturnValue(false);
   });
 

package/src/execution/__tests__/tool-action.test.ts

@@ -18,7 +18,7 @@ import type {
 
 function makeDetails(over: Partial<SubagentToolDetails> = {}): SubagentToolDetails {
   return {
-    status: "done",
+    status: "closed",
     mode: "background",
     agent: "worker",
     model: "test/model",
@@ -42,7 +42,7 @@ function makeSnapshot(over: Partial<RecordSnapshot> = {}): RecordSnapshot {
     mode: "background",
     task: "t",
     slug: "test-slug",
-    status: "done",
+    status: "closed",
     eventLog: [],
     turns: 1,
     totalTokens: 10,
@@ -61,6 +61,8 @@ function makeService(over: Partial<SubagentService> = {}): SubagentService {
     findRecord: vi.fn(() => undefined),
     cancel: vi.fn(() => false),
     collectRecords: vi.fn(() => [] as SubagentRecord[]),
+    // [perf] listHandler 逐项 enrich 会调 getFullRecord；mock 回 undefined → 调用方回退 light record
+    getFullRecord: vi.fn(() => undefined as SubagentRecord | undefined),
     ...over,
   } as SubagentService;
 }
@@ -171,13 +173,13 @@ describe("listHandler", () => {
 
   it("item 8 字段齐全（含 duration 实时计算）", () => {
     const records: SubagentRecord[] = [
-      { id: "r1", agent: "w", status: "done", mode: "background", startedAt: 1000, endedAt: 2500, turns: 2, totalTokens: 50, model: "m", thinkingLevel: "high", eventLog: [], sessionFile: "x.jsonl" },
+      { id: "r1", agent: "w", status: "closed", mode: "background", startedAt: 1000, endedAt: 2500, turns: 2, totalTokens: 50, model: "m", thinkingLevel: "high", eventLog: [], sessionFile: "x.jsonl" },
     ];
     const svc = makeService({ collectRecords: vi.fn(() => records) });
     const r = listHandler(svc, { includeFinished: true });
     const item = r.response.items[0];
     expect(item).toMatchObject({
-      subagentId: "r1", agent: "w", status: "done", mode: "background",
+      subagentId: "r1", agent: "w", status: "closed", mode: "background",
       duration: 1, model: "m", totalTokens: 50, sessionFile: "x.jsonl",
     });
   });
@@ -263,7 +265,7 @@ describe("cancelHandler", () => {
 
   it("[S-19] id 在树内但已终态（磁盘可见 done）→ 仍用 may have finished 消息", async () => {
     const done: SubagentRecord = {
-      id: "bg-done", agent: "w", status: "done", mode: "background", startedAt: 1,
+      id: "bg-done", agent: "w", status: "closed", mode: "background", startedAt: 1,
       endedAt: 2, turns: 0, totalTokens: 0, model: "m", thinkingLevel: undefined, eventLog: [],
     };
     const svc = makeService({
@@ -275,10 +277,10 @@ describe("cancelHandler", () => {
 
   it("已终态（cancel 返回 false）→ throw could not be cancelled", async () => {
     const svc = makeService({
-      findRecord: vi.fn(() => makeSnapshot({ id: "bg-1", mode: "background", status: "done" })),
+      findRecord: vi.fn(() => makeSnapshot({ id: "bg-1", mode: "background", status: "closed" })),
       cancel: vi.fn(() => false),
     });
-    await expect(cancelHandler(svc, { subagentId: "bg-1" })).rejects.toThrow(/could not be cancelled.*status: done/);
+    await expect(cancelHandler(svc, { subagentId: "bg-1" })).rejects.toThrow(/could not be cancelled.*status: closed/);
   });
 
   it("成功 → cancelled:true", async () => {
@@ -295,7 +297,7 @@ describe("cancelHandler", () => {
   // re-query 到终态。覆盖 cancelHandler 的 re-query 分支（subagent-actions.ts:267-272）。
   it("并发 CAS：两次 cancel 同一 id，第二次 CAS 失败 re-query 到终态", async () => {
     const running = makeSnapshot({ id: "bg-cas", mode: "background", status: "running" });
-    const done = makeSnapshot({ id: "bg-cas", mode: "background", status: "done" });
+    const done = makeSnapshot({ id: "bg-cas", mode: "background", status: "closed" });
 
     let cancelCalls = 0;
     const svc = makeService({
@@ -317,9 +319,9 @@ describe("cancelHandler", () => {
     const r1 = await cancelHandler(svc, { subagentId: "bg-cas" });
     expect(r1.response.cancelled).toBe(true);
 
-    // 第二次 cancel：CAS 失败，re-query 返回 done（不是初始的 running）
+    // 第二次 cancel：CAS 失败，re-query 返回 closed（不是初始的 running）
     await expect(cancelHandler(svc, { subagentId: "bg-cas" }))
-      .rejects.toThrow(/could not be cancelled.*status: done/);
+      .rejects.toThrow(/could not be cancelled.*status: closed/);
 
     // 验证 re-query 确实发生（3 次 findRecord：1 初始 + 1 初始 + 1 re-query）
     expect(svc.findRecord).toHaveBeenCalledTimes(3);

package/src/execution/__tests__/truncline-snapshot.test.ts

@@ -0,0 +1,81 @@
+/**
+ * truncLine — indexOf 化（IF12/#18）byte-identical 快照 + 非 SGR ESC 行为锚定。
+ *
+ * fixture（__fixtures__/truncline.snapshot.json）由**改造前实现**生成落盘
+ * （本文件同 commit），断言重构后输出逐字节一致——含 OSC / 裸 \x1b / \x1b[K
+ * 非 SGR ESC 用例（等价定义点：非 SGR ESC 不构成文本段边界，按文本计宽进 result）。
+ */
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import { truncLine } from "../../interface/format.ts";
+
+interface SnapshotCase {
+  label: string;
+  maxWidth: number;
+  text: string;
+  expected: string;
+}
+
+function loadCases(): SnapshotCase[] {
+  const here = dirname(fileURLToPath(import.meta.url));
+  return JSON.parse(
+    readFileSync(join(here, "__fixtures__", "truncline.snapshot.json"), "utf8"),
+  ) as SnapshotCase[];
+}
+
+describe("truncLine — indexOf 化 byte-identical 快照（IF12）", () => {
+  it("全部 fixture 用例（10k ANSI 混合行 / CJK / OSC / 裸 ESC / CSI-K / emoji）与改造前输出逐字节一致", () => {
+    const cases = loadCases();
+    expect(cases.length).toBeGreaterThanOrEqual(10);
+    for (const c of cases) {
+      expect(truncLine(c.text, c.maxWidth)).toBe(c.expected);
+    }
+  });
+
+  it("10k 混合长行在多个截断宽度下均一致（fixture 内 maxWidth 之外再加宽度扫描）", () => {
+    const mixed = loadCases().find((c) => c.label === "sgr-mixed-10k")!;
+    for (const w of [8, 15, 30, 61, 100]) {
+      const expected = mixed.expected; // fixture 锁 maxWidth=60；其他宽度靠 oracle 断言
+      void expected;
+      // 非 fixture 宽度用行为断言：输出含省略号且无裸换行
+      const out = truncLine(mixed.text, w);
+      expect(out).toContain("…");
+      expect(out).not.toContain("\n");
+    }
+  });
+});
+
+describe("truncLine — 非 SGR ESC 行为（等价定义点，显式锚定）", () => {
+  it("OSC 序列（\\x1b]0;title\\x07）按文本计宽进 result（不作为样式捕获/段边界）", () => {
+    // OSC 计入可见宽度（\x1b]0;title\x07 各字符占宽），随后文本继续同段累加
+    const out = truncLine("AB\x1b]0;title\x07CDEFGHIJKLMNOP", 10);
+    expect(out.endsWith("…")).toBe(true);
+    expect(out).not.toContain("\x1b]0;title\x07"); // 截断点在 OSC 之内或之前——
+    // 逐字节形态由 fixture（osc-title / osc-inside-truncation 用例）锚定
+  });
+
+  it("裸 \\x1b 后跟非 [ 字符：不匹配 SGR、并入文本段（不丢字符不死循环）", () => {
+    const out = truncLine("before \x1bZ after bare esc tail", 12);
+    expect(out.endsWith("…")).toBe(true);
+    // 输出是输入前缀（前 11 可见列 + …），未吞字符
+    expect(out.startsWith("before ")).toBe(true);
+  });
+
+  it("非 SGR CSI（\\x1b[K）与 SGR 混排且触发截断：\x1b[K 不进 activeStyles（无错位 reset）", () => {
+    const out = truncLine("\x1b[31mred\x1b[K\x1b[32mgreen tail past width", 10);
+    // SGR（31m/32m）被捕获；\x1b[K 按文本进 result——逐字节形态由 fixture
+    //（csi-k-mixed-sgr 用例）锚定；此处断言 SGR 样式重应用语义未回归
+    expect(out).toMatch(/\x1b\[31m/);
+    expect(out.endsWith("…\x1b[0m")).toBe(true);
+  });
+
+  it("ESC 恰在串尾：无后续字符可判 SGR，按文本并入（end=flat.length）", () => {
+    const out = truncLine("text almost at width limit\x1b", 22);
+    expect(out.endsWith("…")).toBe(true);
+    expect(out).not.toContain("\x1b["); // 末尾裸 ESC 未触发 SGR 捕获
+  });
+});