@zhushanwen/pi-plan 0.5.2 → 1.1.0

package/src/__tests__/{compact.test.ts → extract-plan-steps.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect,it } from "vitest";
 
-import { extractPlanSteps } from "../compact.js";
+import { extractPlanSteps } from "../execution-notice.js";
 
 describe("extractPlanSteps", () => {
   it("extracts numbered steps from 实现步骤 section", () => {
@@ -8,6 +8,7 @@ describe("extractPlanSteps", () => {
 
 ## 背景
 Some context
+1. Background numbered line that must not leak
 
 ## 实现步骤
 1. Create the user model
@@ -27,7 +28,10 @@ Run tests`;
   it("extracts numbered steps from 实施步骤 section", () => {
     const plan = `## 实施步骤
 1. Step one
-2. Step two`;
+2. Step two
+
+## 验证
+1. Verification line that must not leak`;
     const steps = extractPlanSteps(plan);
     expect(steps).toEqual(["Step one", "Step two"]);
   });
@@ -35,7 +39,10 @@ Run tests`;
   it("extracts steps from English Steps section", () => {
     const plan = `## Steps
 1. First step
-2. Second step`;
+2. Second step
+
+## Notes
+1. Notes line that must not leak`;
     const steps = extractPlanSteps(plan);
     expect(steps).toEqual(["First step", "Second step"]);
   });
@@ -43,7 +50,10 @@ Run tests`;
   it("extracts steps from Implementation section", () => {
     const plan = `## Implementation Steps
 1. Create file
-2. Add exports`;
+2. Add exports
+
+## Validation
+1. Validation line that must not leak`;
     const steps = extractPlanSteps(plan);
     expect(steps).toEqual(["Create file", "Add exports"]);
   });
@@ -72,16 +82,6 @@ Run tests`;
     ]);
   });
 
-  it("returns empty array when no steps section and no numbered items", () => {
-    const plan = `## 背景
-Some context
-
-## 方案
-Option A is preferred`;
-    const steps = extractPlanSteps(plan);
-    expect(steps).toEqual([]);
-  });
-
   it("fallback: collects numbered items when no steps section header", () => {
     const plan = `# Plan
 1. First thing
@@ -95,8 +95,17 @@ Option A is preferred`;
     const plan = `## 实现步骤
 1. Valid step
 
-2. Another valid step`;
+2. Another valid step
+3.
+4. ${"   "}`;
     const steps = extractPlanSteps(plan);
     expect(steps).toEqual(["Valid step", "Another valid step"]);
   });
+
+  it("fallback cap: collects at most the first 10 numbered items when no steps section header", () => {
+    const plan = Array.from({ length: 12 }, (_, i) => `${i + 1}. step ${i + 1}`).join("\n");
+    const steps = extractPlanSteps(plan);
+    expect(steps).toHaveLength(10);
+    expect(steps[9]).toBe("step 10");
+  });
 });

package/src/__tests__/fsm-consumption.test.ts

@@ -0,0 +1,388 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// Mock node:fs 破坏性写（形态照 command.test.ts 的思路，读透传真实实现）：enter/abort 会碰
+// mkdir/rmdir/readdir——vitest fs-guard 红线，测试不得写非白名单目录；模板发现等读路径保留真实
+vi.mock("node:fs", async () => {
+  const actual = await vi.importActual<typeof import("node:fs")>("node:fs");
+  return {
+    ...actual,
+    mkdirSync: vi.fn(),
+    rmdirSync: vi.fn(),
+  };
+});
+
+// Mock typebox / pi-ai before importing tool（形态照 review.test.ts）
+vi.mock("typebox", () => ({
+  Type: {
+    Object: (props: Record<string, unknown>) => ({ type: "object", properties: props }),
+    String: (opts?: Record<string, unknown>) => ({ type: "string", ...opts }),
+    Optional: (schema: unknown) => schema,
+    Array: (item: unknown, opts?: Record<string, unknown>) => ({ type: "array", items: item, ...opts }),
+  },
+  Static: class {},
+}));
+
+vi.mock("@earendil-works/pi-ai", () => ({
+  StringEnum: (values: readonly string[]) => ({ type: "string", enum: [...values] }),
+}));
+
+vi.mock("../execution-notice.js", async () => {
+  const { GOAL_FAILURE_RECOVERY } = await vi.importActual<typeof import("../execution-notice.js")>("../execution-notice.js");
+  return {
+    handlePlanComplete: vi.fn(),
+    GOAL_FAILURE_RECOVERY,
+  };
+});
+
+vi.mock("../widget.js", () => ({ updatePlanWidget: vi.fn() }));
+// importActual 展开：只覆写 detectExecSkills（不扫真实目录），其余导出（含 enter.ts
+// re-export 的 resolveSkills 执行门禁）走真实现——mock 罩全模块会把它一并变 undefined
+vi.mock("@zhushanwen/pi-exec-skills", async () => {
+  const actual = await vi.importActual<typeof import("@zhushanwen/pi-exec-skills")>(
+    "@zhushanwen/pi-exec-skills",
+  );
+  return { ...actual, detectExecSkills: vi.fn(() => []) };
+});
+
+import { PLAN_REVIEW_MARKER } from "@zhushanwen/extension-protocol";
+import { detectExecSkills } from "@zhushanwen/pi-exec-skills";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { registerPlanCommand } from "../command.js";
+import type { PlanState } from "../state.js";
+import { createPlanCtx, DEFAULT_PLAN_STATE } from "../state.js";
+import { registerPlanTool } from "../tool.js";
+
+const ALL_TOOL_NAMES = ["read", "bash", "grep", "find", "ls", "plan", "ask_user", "write", "edit"];
+const SR = "3 requirements covered; 2 assumptions verified.";
+
+/** 规划中 + 一份文档（submit-review 合法前置） */
+function planningState(): PlanState {
+  return {
+    ...DEFAULT_PLAN_STATE,
+    isActive: true,
+    planFilePath: "/tmp/test-project/.tmp/plans/auth/plan.md",
+    requirement: "refactor auth",
+    docs: [{ fileName: "design.md", absPath: "/tmp/test-project/.tmp/plans/auth/design.md", sourceSkill: "", version: 1 }],
+    state: "planning",
+    selfReview: SR,
+    lastSubmitReviewDocsFingerprint: "design.md:1",
+  };
+}
+
+/**
+ * 组合 harness：tool + command 共享单 ctx 对象两注册表
+ * （跨入口解散判别需要真实共享——exitPlanMode 与等待归口经同一 controllers 表传递
+ * dissolvedBy 直传来源，D-B1-2；sessions/controllers 别名 = planCtx 两表，D-B4-3）。
+ */
+function setup(initialState?: PlanState) {
+  const planCtx = createPlanCtx();
+  let executeFn: (id: string, p: Record<string, unknown>, sig?: AbortSignal, upd?: unknown, ctx?: unknown) => Promise<unknown>;
+  let commandHandler: (args: string, ctx: ExtensionContext) => Promise<void>;
+
+  const pi = {
+    registerTool: vi.fn((tool) => { executeFn = tool.execute; }),
+    registerCommand: vi.fn((_name: string, def: { handler: (args: string, ctx: ExtensionContext) => Promise<void> }) => {
+      commandHandler = def.handler;
+    }),
+    appendEntry: vi.fn(),
+    setActiveTools: vi.fn(),
+    sendMessage: vi.fn(),
+    notify: vi.fn(),
+    getCommands: vi.fn(() => []),
+    getAllTools: vi.fn(() => ALL_TOOL_NAMES.map((n) => ({ name: n }))),
+  } as unknown as Parameters<typeof registerPlanTool>[0];
+  registerPlanTool(pi, planCtx);
+  registerPlanCommand(pi as unknown as Parameters<typeof registerPlanCommand>[0], planCtx);
+
+  const ctx = {
+    sessionId: "test-session",
+    cwd: "/tmp/test-project",
+    hasUI: true,
+    mode: "tui" as const,
+    isProjectTrusted: () => true,
+    sessionManager: { getSessionId: () => "test-session", getEntries: () => [] },
+    ui: { select: vi.fn(), notify: vi.fn(), setWidget: vi.fn(), setStatus: vi.fn() },
+  };
+
+  if (initialState) planCtx.states.set("test-session", initialState);
+
+  const exec = (params: Record<string, unknown>, signal?: AbortSignal) =>
+    executeFn!("tc0", params, signal, undefined, ctx);
+  return {
+    pi, planCtx, sessions: planCtx.states, controllers: planCtx.controllers, ctx, exec,
+    handleCommand: (args: string) => commandHandler(args, ctx as unknown as ExtensionContext),
+  };
+}
+
+/** select mock 对齐 pi 实装 createDialogPromise 语义（rpc-mode.js:48）：signal 生效即 resolve undefined */
+function selectHonoringSignal(ctx: { ui: { select: unknown } }): void {
+  (ctx.ui.select as ReturnType<typeof vi.fn>).mockImplementation(
+    (_title: string, _options: string[], opts: { signal?: AbortSignal }) =>
+      new Promise<string | undefined>((resolve) => {
+        if (opts.signal?.aborted) {
+          resolve(undefined);
+          return;
+        }
+        opts.signal?.addEventListener("abort", () => resolve(undefined), { once: true });
+      }),
+  );
+}
+
+function entries(pi: { appendEntry: unknown }): PlanState[] {
+  return (pi.appendEntry as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[1] as PlanState);
+}
+
+beforeEach(() => {
+  vi.stubEnv("TAIJI_AGENT_EXT_LOG", "1"); // taiji 形态（marker select 链路）
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  // exec-skills 模块 mock 归位空集（D7②：空集直通是缺省形态，用例内显式注入技能的覆写不跨用例泄漏）
+  (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([]);
+});
+
+// ── dissolvedBy 直传断言组（D-B1-2，单测锚定，零 token）──
+
+describe("dissolvedBy① 入口解散同步临界段（markDissolved 先于 abort、无让出点——归口点必读到 'self'）", () => {
+  it("挂起审批中 /plan abort：归口①判命令解散 no-op（不落 review_aborted），reset 终态是唯一新落盘", async () => {
+    const h = setup(planningState());
+    h.ctx.mode = "rpc";
+    selectHonoringSignal(h.ctx);
+
+    // exec() 同步推进到 ctx.ui.select 挂起（首个 await 即 select）
+    const pending = h.exec({ action: "submit-review", selfReview: SR });
+    // 挂起已登记（PendingSelect 在表内且未打标——外部解散前的缺省形态）
+    const hang = h.controllers.get("test-session");
+    expect(hang?.dissolvedBy).toBeUndefined();
+    // exitPlanMode 体内无 await：整段（markDissolved('self') → controller.abort() →
+    // resetPlanState）同步执行完毕，abort 触发的 promise 解析是微任务——归口点必在其后
+    // 运行、dissolvedBy 已置位（同步临界段不变量）
+    void h.handleCommand("abort");
+    // 打标来源随挂起闭包直达等待处（原独立中途断言用例内联）
+    expect(hang?.dissolvedBy).toBe("self");
+    const res = await pending;
+
+    // 归口①：dissolvedBy === 'self'（入口直传）→ 命令解散 no-op
+    expect(res.details).toEqual({ action: "review-error", reason: "cancelled" });
+    expect((res as { content: Array<{ text: string }> }).content[0].text).toContain("has been exited");
+    // 归口 no-op：无 review_aborted 落盘（不出现把 exited 打回 planning 的 entry）
+    const all = entries(h.pi);
+    expect(all.map((e) => e.state)).toEqual(["reviewing", "exited"]);
+  });
+
+  it("反向对照：同形态若仅 controller.abort()（不打标）则判外部解散（断言有效性的负向探针对照）", async () => {
+    const h = setup(planningState());
+    h.ctx.mode = "rpc";
+    selectHonoringSignal(h.ctx);
+
+    const pending = h.exec({ action: "submit-review", selfReview: SR });
+    // 只 abort controller 不经 exitPlanMode（turn abort 级联形态）——不打标，缺省即外部
+    h.controllers.get("test-session")?.controller.abort();
+    const res = await pending;
+
+    expect(res.details).toEqual({ action: "review-error", reason: "review-interrupted" });
+    const all = entries(h.pi);
+    expect(all.at(-1)?.state).toBe("planning"); // review_aborted 边落盘
+  });
+});
+
+describe("S15② 新鲜度门拒收后重试仍触发（gate 判定先于一切写入、拒收不更新任何快照）", () => {
+  it("文档已变 + selfReview 照抄 → 连续两次拒收 stale-self-review，零状态写入", async () => {
+    // 前置：上次提交后又登记了新版本（指纹 design.md:1 → design.md:2），自审对象已变——
+    // incoming selfReview 与 state.selfReview 逐字节相同 → 防照抄门命中
+    const h = setup({
+      ...planningState(),
+      docs: [{ fileName: "design.md", absPath: "/tmp/test-project/.tmp/plans/auth/design.md", sourceSkill: "", version: 2 }],
+      lastSubmitReviewDocsFingerprint: "design.md:1",
+      selfReview: SR,
+    });
+    const first = await h.exec({ action: "submit-review", selfReview: SR });
+    expect(first.details).toEqual({ action: "review-error", reason: "stale-self-review" });
+    expect((first as { content: Array<{ text: string }> }).content[0].text).toContain("redo the self-review");
+    expect(h.pi.appendEntry).not.toHaveBeenCalled();
+
+    // 重试（agent 未改自审直接重调）→ 仍触发（拒收不更新任何快照：指纹/selfReview 均未被写）
+    const second = await h.exec({ action: "submit-review", selfReview: SR });
+    expect(second.details).toEqual({ action: "review-error", reason: "stale-self-review" });
+    expect(h.pi.appendEntry).not.toHaveBeenCalled();
+
+    // 换新 selfReview → 过门（对照）
+    const third = await h.exec({ action: "submit-review", selfReview: "v2 self-review redone." });
+    expect(third.details).toMatchObject({ action: "submit-review" });
+    expect(h.pi.appendEntry).toHaveBeenCalled();
+  });
+});
+
+describe("dissolvedBy② 跨轮无挂起退出 → 新一轮外部解散正常转移（闭包身份天然隔离，无残留回归）", () => {
+  it("上一轮 abort（无挂起 select）不污染本轮归口：新一轮外部解散仍走 review_aborted", async () => {
+    const h = setup(planningState());
+    // 第一轮：无挂起 select 的退出（规划期退出——旧世代标记机制会在此形态下残留的病根）
+    await h.exec({ action: "abort" });
+
+    // 第二轮：同 turn enter → 登记文档 → 挂新 select → 外部解散（新 PendingSelect，
+    // 闭包来源变量独立于上一轮）
+    await h.exec({ action: "enter", requirement: "round two" });
+    await h.exec({ action: "register-doc", fileName: "design.md" });
+    h.ctx.mode = "rpc";
+    selectHonoringSignal(h.ctx);
+    const turn = new AbortController();
+    const pending = h.exec({ action: "submit-review", selfReview: SR }, turn.signal);
+    // execute 的 turn signal 级联解散（外部解散源，cascadeTurnAbort——只 abort 不打标）
+    turn.abort();
+    const res = await pending;
+
+    // 新挂起的来源变量未被污染（undefined）→ 外部解散正常转移，不被误判为命令解散
+    expect(res.details).toEqual({ action: "review-error", reason: "review-interrupted" });
+    const all = entries(h.pi);
+    expect(all.at(-1)).toMatchObject({ state: "planning", isActive: true });
+  });
+});
+
+describe("resumeHint 清除断言（不变量：只描述当前降级等待的原因，不跨轮残留）", () => {
+  it("① reset 清除 / ② enter 进入重置组清除（③ submit-review 重挂起点清除归 review.test「重挂起点清 resumeHint」保留者）", async () => {
+    // ① reset
+    const a = setup({ ...planningState(), state: "reviewing", resumeHint: "resubmit" });
+    await a.exec({ action: "abort" });
+    expect(entries(a.pi).at(-1)?.resumeHint).toBeUndefined();
+
+    // ② enter 新轮次重置组
+    const b = setup({ ...DEFAULT_PLAN_STATE, isActive: false, state: "exited", resumeHint: "resubmit", selfReview: "stale" });
+    await b.exec({ action: "enter", requirement: "fresh" });
+    expect(entries(b.pi).at(-1)?.resumeHint).toBeUndefined();
+    expect(entries(b.pi).at(-1)?.selfReview).toBeUndefined();
+  });
+});
+
+// ── 状态写全走 transition()（consumers.md 三A/三B 接线断言）──
+
+describe("六 action 状态写走 transition()（D1 边表接线）", () => {
+  it("enter：idle|completed|exited --enter--> planning 三源全落 planning", async () => {
+    for (const from of ["idle", "completed", "exited"] as const) {
+      const h = setup({ ...DEFAULT_PLAN_STATE, isActive: false, state: from });
+      await h.exec({ action: "enter", requirement: `from ${from}` });
+      expect(entries(h.pi).at(-1)?.state).toBe("planning");
+    }
+  });
+
+  it("submit-review：planning|revising --submit--> reviewing 两源；approve 决策 --approve--> dispatching", async () => {
+    for (const from of ["planning", "revising"] as const) {
+      const h = setup({ ...planningState(), state: from });
+      h.ctx.mode = "rpc";
+      (h.ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue(JSON.stringify({ decision: "dismiss" }));
+      await h.exec({ action: "submit-review", selfReview: "fresh review." });
+      const states = entries(h.pi).map((e) => e.state);
+      expect(states).toContain("reviewing"); // submit 边
+      expect(states.at(-1)).toBe("planning"); // dismiss 边
+    }
+
+    const g = setup(planningState());
+    g.ctx.mode = "rpc";
+    (g.ctx.ui.select as ReturnType<typeof vi.fn>)
+      .mockResolvedValueOnce(JSON.stringify({ decision: "approve" }))
+      .mockResolvedValueOnce(JSON.stringify({ "Execution method": "Execute" }));
+    await g.exec({ action: "submit-review", selfReview: "fresh review." });
+    const states = entries(g.pi).map((e) => e.state);
+    expect(states).toContain("dispatching"); // approve 边（reviewing → dispatching）
+    expect(states.at(-1)).toBe("completed"); // exec_chosen 边 + terminal='completed'
+  });
+
+  it("complete：reviewing --approve--> dispatching（文本流转直调 complete 同边，§三B）→ later --> approved", async () => {
+    const h = setup(planningState());
+    // 有技能才挂表单（D7②）——later 边只存在于表单的「暂不执行」档
+    (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([
+      { name: "dev-flow", description: "d", skillEntryPath: "/tmp/skills/dev-flow/SKILL.md" },
+    ]);
+    // 文本流：submit-review 软门后用户口头确认 → agent 直调 complete
+    await h.exec({ action: "submit-review", selfReview: SR });
+    (h.ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue("Not now");
+    const res = await h.exec({ action: "complete" });
+    expect(res.details).toMatchObject({ action: "complete-later" });
+    const states = entries(h.pi).map((e) => e.state);
+    expect(states).toContain("dispatching");
+    expect(states.at(-1)).toBe("approved"); // later 边
+  });
+
+  it("complete later 档转移被拒（挂起窗口内 exit 交错已落终态）→ 中性 state-changed 出口，不落 approved", async () => {
+    const h = setup({ ...planningState(), state: "approved" });
+    (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([
+      { name: "dev-flow", description: "d", skillEntryPath: "/tmp/skills/dev-flow/SKILL.md" },
+    ]);
+    // select 应答受控（忽略 signal，解散不代答）：挂起窗口内先让 /plan abort 介入
+    //（fresh-read 后已非 dispatching），再以「Not now」落定——later 选择与交错退出
+    // 同窗到达的真实竞态形态
+    let settleSelect: (label: string | undefined) => void = () => {};
+    (h.ctx.ui.select as ReturnType<typeof vi.fn>).mockImplementation(
+      () => new Promise<string | undefined>((resolve) => { settleSelect = resolve; }),
+    );
+    const pending = h.exec({ action: "complete" });
+    void h.handleCommand("abort");
+    settleSelect("Not now");
+    const res = await pending;
+
+    // later 边被 FSM 拒（现值已落 exited）：中性 state-changed 出口（与 exec_chosen
+    // ok:false 同型），不复用 APPROVED 成功文案——与真实退出态相反会误导 agent 下一步
+    expect(res.details).toEqual({ action: "review-error", reason: "out-of-order" });
+    const text = (res as { content: Array<{ text: string }> }).content[0].text;
+    expect(text).toContain("state changed");
+    expect(text).not.toContain("APPROVED");
+    // 落盘终态：dispatching（complete 入口 approve 边）→ exited（abort 介入）——无 approved 新落盘
+    const states = entries(h.pi).map((e) => e.state);
+    expect(states).toEqual(["dispatching", "exited"]);
+  });
+
+  it("complete 未经审批闸口（planning 直调）→ out-of-order 纠偏，不落盘（执行前用户审批结构性保证）", async () => {
+    const h = setup(planningState());
+    const res = await h.exec({ action: "complete" });
+    expect(res.details).toEqual({ action: "review-error", reason: "out-of-order" });
+    expect((res as { content: Array<{ text: string }> }).content[0].text).toContain("submit-review");
+    expect(h.pi.appendEntry).not.toHaveBeenCalled();
+  });
+
+  it("abort：活跃族非终态 --exit--> exited；select-template/register-doc 无生命周期事件（persist 携带现值）", async () => {
+    const h = setup(planningState());
+    await h.exec({ action: "select-template", templateName: "feature-plan" });
+    await h.exec({ action: "register-doc", fileName: "design.md" });
+    // 两 action 均无转移写：state 现值原样落盘
+    for (const e of entries(h.pi)) expect(e.state).toBe("planning");
+
+    await h.exec({ action: "abort" });
+    expect(entries(h.pi).at(-1)?.state).toBe("exited");
+  });
+
+  it("reviewing 重挂自环（D-B1-8：reviewing --submit--> reviewing）：重提交照常落盘回 reviewing，前后等价，接续 approve 正常", async () => {
+    const h = setup({ ...planningState(), state: "reviewing" });
+    h.ctx.mode = "rpc";
+    // reviewing 态重提交（E3 恢复 steer / D8 重新提交按钮的 agent 侧形态）
+    (h.ctx.ui.select as ReturnType<typeof vi.fn>)
+      .mockResolvedValueOnce(JSON.stringify({ decision: "approve" }))
+      .mockResolvedValueOnce(JSON.stringify({ "Execution method": "Execute" }));
+    const res = await h.exec({ action: "submit-review", selfReview: SR });
+    // 自环锚：旧特判形态（ok:false 且现值 reviewing 放行）与自环形态落盘产物等价——
+    // state 值不变、重挂回 reviewing（单一记录点照常落盘）
+    const states = entries(h.pi).map((e) => e.state);
+    expect(states[0]).toBe("reviewing"); // 重挂落盘（自环 ok:true）
+    expect(states).toContain("dispatching"); // 接续 approve 边正常
+    expect(states.at(-1)).toBe("completed"); // exec_chosen 终局
+    expect(res.details.action).toBe("complete");
+  });
+});
+
+// ── CompleteChoiceOutcome 显式 via 五构造点补齐（①later/⑤channel 已在 tool.test 锚定）──
+
+describe("CompleteChoiceOutcome via 构造点（D3 连带段：显式枚举，归口直读）", () => {
+  // 构造点③（rpc cancel：select 解散 + signal aborted）已并入 tool.test.ts「turn abort
+  // during the pending execution-method select」（controller-abort→select-解散接线保留者）；
+  // 「signal aborted → reason cancelled」的库层判别由 extension-protocol ui-form 测试归属。
+  it("构造点④（rpc timeout：undefined resolve 且 signal 未 abort）→ 折叠 reason 'cancelled' 外部解散（review_aborted→approved）", async () => {
+    const h = setup({ ...planningState(), state: "approved" });
+    (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([
+      { name: "dev-flow", description: "d", skillEntryPath: "/tmp/skills/dev-flow/SKILL.md" },
+    ]);
+    (h.ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+    const res = await h.exec({ action: "complete" });
+    expect(res.details).toMatchObject({ action: "complete-cancelled", source: "external" });
+    expect(entries(h.pi).at(-1)?.state).toBe("approved"); // review_aborted：dispatching → approved
+  });
+});