@zhushanwen/pi-plan 0.5.2 → 1.1.0

package/src/__tests__/tool.test.ts

@@ -15,22 +15,26 @@ vi.mock("@earendil-works/pi-ai", () => ({
   StringEnum: (values: readonly string[]) => ({ type: "string", enum: [...values] }),
 }));
 
-// Mock compact.js (statically imported since 06-u1)
-vi.mock("../compact.js", async () => {
+// Mock execution-notice.js (statically imported since 06-u1)
+vi.mock("../execution-notice.js", async () => {
   // GOAL_FAILURE_RECOVERY 与真实实现同文案——completeResultText 在 failure 断言里消费它
-  const { GOAL_FAILURE_RECOVERY } = await vi.importActual<typeof import("../compact.js")>("../compact.js");
+  const { GOAL_FAILURE_RECOVERY } = await vi.importActual<typeof import("../execution-notice.js")>("../execution-notice.js");
   return {
     handlePlanComplete: vi.fn(),
-    detectGoalCapability: vi.fn(() => false),
     GOAL_FAILURE_RECOVERY,
   };
 });
 
-// Mock exec-skills（D10 检测）：单测里不扫真实目录（~/.agents/skills 等本机路径），
-// skill 选项用例显式注入 fixture；专用 exec-skills.test.ts 覆盖真实扫描
-vi.mock("../exec-skills.js", () => ({
-  detectExecSkills: vi.fn(() => []),
-}));
+// Mock 执行方式检测（D10）：单测里不扫真实目录（~/.agents/skills 等本机路径），
+// skill 选项用例显式注入 fixture；专用 exec-skills.test.ts 覆盖真实扫描。
+// 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(() => []) };
+});
 
 // Mock widget (imported by abort)
 vi.mock("../widget.js", () => ({
@@ -44,11 +48,11 @@ import { join } from "node:path";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { UI_FORM_MARKER } from "@zhushanwen/extension-protocol";
+import { detectExecSkills } from "@zhushanwen/pi-exec-skills";
 
-import { detectGoalCapability, handlePlanComplete } from "../compact.js";
-import { detectExecSkills } from "../exec-skills.js";
-import { DEFAULT_PLAN_STATE } from "../state.js";
-import { loadTemplate } from "../templates.js";
+import { handlePlanComplete } from "../execution-notice.js";
+import { createPlanCtx, DEFAULT_PLAN_STATE } from "../state.js";
+import { listTemplates } from "../templates.js";
 import { PLAN_ACTIONS, registerPlanTool, validateAction } from "../tool.js";
 import { updatePlanWidget } from "../widget.js";
 
@@ -56,8 +60,8 @@ import { updatePlanWidget } from "../widget.js";
 const ALL_TOOL_NAMES = ["read", "bash", "grep", "find", "ls", "plan", "write", "edit"];
 
 function setup() {
-  const sessions = new Map();
-  const controllers = new Map<string, AbortController>();
+  // 单 ctx 对象（D-B4-3）：sessions/controllers 别名 = planCtx 两表（同对象），用例断言不变
+  const planCtx = createPlanCtx();
   let executeFn: (id: string, p: Record<string, unknown>, sig?: AbortSignal, upd?: unknown, ctx?: unknown) => Promise<unknown>;
   const pi = {
     registerTool: vi.fn((tool) => { executeFn = tool.execute; }),
@@ -65,7 +69,7 @@ function setup() {
     setActiveTools: vi.fn(),
     getAllTools: vi.fn(() => ALL_TOOL_NAMES.map((n) => ({ name: n }))),
   } as unknown as Parameters<typeof registerPlanTool>[0];
-  registerPlanTool(pi, sessions, controllers);
+  registerPlanTool(pi, planCtx);
 
   const ctx = {
     sessionId: "test-session",
@@ -74,13 +78,24 @@ function setup() {
     hasUI: true,
     mode: "tui" as const,
     isProjectTrusted: () => true,
-    sessionManager: { getSessionId: () => "test-session", getEntries: () => [] },
+    sessionManager: { getSessionId: () => "test-session", getLeafId: () => null, getEntries: () => [] },
     ui: { select: vi.fn(), notify: vi.fn() },
   };
 
+  // 默认前置：已批准态（approved --approve--> dispatching 重选执行方式，consumers.md §三B）——
+  // complete 的审批闸口（D1 边表）要求先过 review 流程；用例可在返回后覆写 sessions
+  planCtx.states.set("test-session", {
+    ...DEFAULT_PLAN_STATE,
+    isActive: true,
+    planFilePath: "/tmp/test-project/.tmp/plans/auth/plan.md",
+    requirement: "refactor auth",
+    state: "approved",
+    docs: [{ fileName: "design.md", absPath: "/tmp/test-project/.tmp/plans/auth/design.md", sourceSkill: "", version: 1 }],
+  });
+
   const exec = (params: Record<string, unknown>, signal?: AbortSignal) =>
     executeFn!("tc0", params, signal, undefined, ctx);
-  return { pi, sessions, controllers, ctx, exec };
+  return { pi, planCtx, sessions: planCtx.states, controllers: planCtx.controllers, ctx, exec };
 }
 
 describe("registerPlanTool", () => {
@@ -90,6 +105,12 @@ describe("registerPlanTool", () => {
     expect((pi.registerTool as ReturnType<typeof vi.fn>).mock.calls[0][0].name).toBe("plan");
   });
 
+  it("declares executionMode 'sequential'（D-B1-4：action 就地突变共享 PlanState，串行声明消除同批并行交错）", () => {
+    const { pi } = setup();
+    const tool = (pi.registerTool as ReturnType<typeof vi.fn>).mock.calls[0][0] as { executionMode?: string };
+    expect(tool.executionMode).toBe("sequential");
+  });
+
   it("tool description and promptSnippet no longer mention list-template (D1 删链不留兼容通道)", () => {
     const { pi } = setup();
     const tool = (pi.registerTool as ReturnType<typeof vi.fn>).mock.calls[0][0] as {
@@ -128,11 +149,13 @@ describe("registerPlanTool", () => {
     });
 
     it("content carries the winner file's full text and details has no content field (D7 全文通道唯一化)", async () => {
-      const { exec } = setup();
+      const { exec, ctx } = setup();
       const res = await exec({ action: "select-template", templateName: "feature-plan" });
       const text = res.content[0].text;
-      // 全文到达模型可见通道（对照 loadTemplate 的胜者内容，运行机用户级遮蔽时同样成立）
-      const winnerContent = loadTemplate("feature-plan");
+      // 全文到达模型可见通道（对照同参数合并视图胜者 path 的直读——与生产侧同一次
+      // 扫描语义，运行机用户级遮蔽时两轨拿同一胜者，断言同样成立）
+      const winner = listTemplates({ projectRoot: ctx.cwd }).find((t) => t.name === "feature-plan");
+      const winnerContent = winner ? fs.readFileSync(winner.path, "utf-8") : null;
       expect(winnerContent).not.toBeNull();
       expect(text).toContain(`<template>\n${winnerContent}\n</template>`);
       // details 收窄：仅 action + templateName，全文不再双份持久化
@@ -164,7 +187,7 @@ describe("registerPlanTool", () => {
         planFilePath: "/tmp/test-project/.tmp/plans/retro/plan.md",
         requirement: "retro",
         templateName: "retro-template",
-        templateProvidedPath: "/tmp/test-project/docs/retro-template.md",
+        templateProvided: true,
       });
       const error = await exec({ action: "select-template", templateName: "retro-template" }).then(
         () => new Error("expected rejection"),
@@ -180,21 +203,17 @@ describe("registerPlanTool", () => {
 
   // --- removed actions (D1 / D3) ---
   describe("removed action rejections", () => {
-    it("rejects plan(action='list-template') as an unknown action with the 6-action list (D1)", async () => {
-      const { exec } = setup();
-      await expect(exec({ action: "list-template" })).rejects.toThrow(
-        "Unknown plan action: list-template. Valid actions: enter, select-template, complete, abort, register-doc, submit-review",
-      );
-    });
-
-    it("rejects plan(action='create-template') as an unknown action (D3 / V4)", async () => {
-      const { exec } = setup();
-      await expect(
-        exec({ action: "create-template", templateName: "my-plan", templateContent: "# hello" }),
-      ).rejects.toThrow(
-        "Unknown plan action: create-template. Valid actions: enter, select-template, complete, abort, register-doc, submit-review",
-      );
-    });
+    it.each(["list-template", "create-template"] as const)(
+      "rejects plan(action='%s') as an unknown action with the 6-action list (D1/D3)",
+      async (removed) => {
+        const { exec } = setup();
+        await expect(
+          exec(removed === "create-template" ? { action: removed, templateName: "my-plan", templateContent: "# hello" } : { action: removed }),
+        ).rejects.toThrow(
+          `Unknown plan action: ${removed}. Valid actions: enter, select-template, complete, abort, register-doc, submit-review`,
+        );
+      },
+    );
   });
 
   // --- renderResult 兜底（MF-1-7 旧持久化 details 形态）---
@@ -220,43 +239,32 @@ describe("registerPlanTool", () => {
       return tool.renderResult;
     }
 
-    it("旧 action=list-template details（已删 action 的历史 entry）渲染不抛、回落 content 文本", () => {
+    it.each([
+      { action: "list-template", details: { action: "list-template", templates: ["feature-plan", "bugfix"] }, text: "Available templates: feature-plan, bugfix" },
+      { action: "create-template", details: { action: "create-template" }, text: "legacy entry" },
+    ])("legacy/unknown action details ($action) render without throwing, falling back to the content text", ({ details, text }) => {
       const { pi } = setup();
       const render = renderFn(pi);
-      // git 2ab33c46c 旧版形态：details.action="list-template" 不在现版 PlanDetails 联合内。
-      // 修复前 switch 落空返回 undefined → pi TUI 渲染循环对 undefined 调 .render() TypeError
+      // git 2ab33c46c 旧版形态：details.action 不在现版 PlanDetails 联合内（list-template 为
+      // 已删 action 的历史 entry 形态）。修复前 switch 落空返回 undefined → pi TUI 渲染循环
+      // 对 undefined 调 .render() TypeError；任意未知 action 同走 default 兜底（防御未来再删）。
       const result = {
-        content: [{ type: "text", text: "Available templates: feature-plan, bugfix" }],
-        details: { action: "list-template", templates: ["feature-plan", "bugfix"] },
+        content: [{ type: "text", text }],
+        details,
       };
 
       const component = render(result, { expanded: false }, renderTheme);
 
       expect(component).toBeInstanceOf(Text);
-      expect(component.render(400).join("\n")).toContain("Available templates: feature-plan, bugfix");
-    });
-
-    it("任意未知 action 形态同样回落 content 文本（防御未来再删 action）", () => {
-      const { pi } = setup();
-      const render = renderFn(pi);
-      const result = {
-        content: [{ type: "text", text: "legacy entry" }],
-        details: { action: "create-template" },
-      };
-
-      const component = render(result, { expanded: false }, renderTheme);
-
-      expect(component).toBeInstanceOf(Text);
-      expect(component.render(400).join("\n")).toContain("legacy entry");
+      expect(component.render(400).join("\n")).toContain(text);
     });
   });
 
   // --- complete ---
   describe("complete", () => {
     beforeEach(() => {
-      // detectGoalCapability 不在 complete 链上消费（execute 档 tryGoalInit 内部自理
-      // goal-unavailable 降级）；goal outcome 用例经 handlePlanComplete mock 构造结果
-      (detectGoalCapability as ReturnType<typeof vi.fn>).mockReturnValue(false);
+      // goal outcome 用例经 handlePlanComplete mock 构造结果（execute 档 tryGoalInit
+      // 在 execution-notice.ts 内部自理 goal-unavailable 降级，不在本文件消费面）
       (handlePlanComplete as ReturnType<typeof vi.fn>).mockReset();
       (detectExecSkills as ReturnType<typeof vi.fn>).mockReset();
       (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([]);
@@ -271,28 +279,40 @@ describe("registerPlanTool", () => {
       return ((pi.registerTool as ReturnType<typeof vi.fn>).mock.calls[0][0]) as Record<string, unknown>;
     }
 
-    it("rejects isolation='tree' at the schema level: enum is exactly compact|direct (D1 / V3①)", async () => {
+    it("schema carries no isolation field (D-B1-6: compact|direct 两档分发砍除，单一直接投递路径)", async () => {
       const { pi } = setup();
       const parameters = registeredTool(pi).parameters as {
-        properties: { isolation: { enum: string[] } };
+        properties: Record<string, unknown>;
       };
-      expect(parameters.properties.isolation.enum).toEqual(["compact", "direct"]);
-      expect(parameters.properties.isolation.enum).not.toContain("tree");
+      expect(parameters.properties.isolation).toBeUndefined();
     });
 
-    it("does not advance when user picks Not now", async () => {
+    it("does not advance when user picks Not now — later 边（dispatching→approved）+ later 文案，不进解散文案桶（A9 反向）", async () => {
       const { exec, ctx, pi } = setup();
+      // 有 plan-exec 技能才挂表单（D7②：空集直通，暂不执行档只存在于表单内）
+      (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([
+        { name: "dev-flow", description: "d", skillEntryPath: "/tmp/skills/dev-flow/SKILL.md" },
+      ]);
       (ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue("Not now");
       const res = await exec({ action: "complete" });
-      expect(res.details.action).toBe("complete-cancelled");
-      expect(res.details.reason).toBe("Not now");
-      // 用户主动暂不执行：留在 plan mode 是用户意图（区别于 abort 联动取消的文案）
-      expect(res.content[0].text).toContain("Staying in plan mode");
+      expect(res.details.action).toBe("complete-later");
+      expect(res.details.choice).toBe("Not now");
+      // later 档文案（D3 连带段）：已批准、未派发、可再调 complete——**不得**是外部解散文案
+      expect(res.content[0].text).toContain("NOT dispatched");
+      expect(res.content[0].text).toContain("plan(action='complete')");
+      expect(res.content[0].text).not.toContain("interrupted");
+      expect(res.content[0].text).not.toContain("exited");
+      // later 边落盘：approved（批准事实保留，留在 plan mode）
+      const entries = (pi.appendEntry as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[1] as { state?: string });
+      expect(entries.at(-1)?.state).toBe("approved");
       expect(pi.setActiveTools).not.toHaveBeenCalled();
     });
 
-    it("turn abort during the pending execution-method select dissolves the dialog → complete-cancelled (MF-1-8)", async () => {
+    it("turn abort during the pending execution-method select dissolves the dialog → 归口②外部解散（review_aborted→approved，MF-1-8）", async () => {
       const { exec, ctx, pi } = setup();
+      (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([
+        { name: "dev-flow", description: "d", skillEntryPath: "/tmp/skills/dev-flow/SKILL.md" },
+      ]);
       // select mock 对齐 pi 实装 createDialogPromise 语义（rpc-mode.js:48）：
       // signal 已 abort 首行短路 resolve undefined；挂起中 abort → resolve undefined
       (ctx.ui.select as ReturnType<typeof vi.fn>).mockImplementation(
@@ -309,12 +329,18 @@ describe("registerPlanTool", () => {
       const pending = exec({ action: "complete" }, turn.signal);
       turn.abort();
       const res = await pending;
+      // turn abort 级联（未经入口，不打标）→ 外部解散：dispatching --review_aborted--> approved
       expect(res.details.action).toBe("complete-cancelled");
       expect(res.details.reason).toBe("cancelled");
+      expect(res.details.source).toBe("external");
+      expect(res.content[0].text).toContain("interrupted");
+      expect(res.content[0].text).toContain("APPROVED");
       expect(pi.setActiveTools).not.toHaveBeenCalled();
+      const entries = (pi.appendEntry as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[1] as { state?: string });
+      expect(entries.at(-1)?.state).toBe("approved");
     });
 
-    it("resets state and restores tools on execute", async () => {
+    it("resets state and restores tools on execute — exec_chosen 边（dispatching→completed 终局）", async () => {
       const { exec, ctx, pi } = setup();
       (ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue("Execute");
       const res = await exec({ action: "complete" });
@@ -322,18 +348,28 @@ describe("registerPlanTool", () => {
       expect(res.details.execMode).toBe("execute");
       expect(pi.setActiveTools).toHaveBeenCalledWith(ALL_TOOL_NAMES);
       expect(handlePlanComplete).toHaveBeenCalled();
-      expect(res.details.planFilePath).toBeDefined();
+      // 内部路径显示为相对路径（A2 边界判断正向：projectDir 后紧随分隔符才切）
+      expect(res.details.planFilePath).toBe(".tmp/plans/auth/plan.md");
+      // 终局落盘：terminal='completed'（防 reset 覆写 completed，D3 连带段）
+      const entries = (pi.appendEntry as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[1] as { state?: string; isActive?: boolean });
+      expect(entries.at(-1)).toMatchObject({ state: "completed", isActive: false });
     });
 
-    it("dialog options = skills (max 2) + Execute + Not now, goal bridge availability irrelevant (选项集重排)", async () => {
-      const { exec, ctx } = setup();
+    it("A2 边界锚：兄弟前缀目录（/tmp/test-project-2）不被误切进 /tmp/test-project 的相对路径", async () => {
+      const { exec, ctx, sessions } = setup();
+      sessions.set("test-session", {
+        ...DEFAULT_PLAN_STATE,
+        isActive: true,
+        planFilePath: "/tmp/test-project-2/.tmp/plans/auth/plan.md",
+        requirement: "refactor auth",
+        state: "approved",
+        docs: [{ fileName: "design.md", absPath: "/tmp/test-project-2/.tmp/plans/auth/design.md", sourceSkill: "", version: 1 }],
+      });
       (ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue("Execute");
-      await exec({ action: "complete" });
-      const options = (ctx.ui.select as ReturnType<typeof vi.fn>).mock.calls[0][1] as string[];
-      expect(options).toEqual([
-        "Execute",
-        "Not now",
-      ]);
+      const res = await exec({ action: "complete" });
+      // 裸 startsWith 曾把 test-project-2 误吃进 test-project 前缀（错切为 2/.tmp/...）——
+      // 边界判断（分隔符或全等）后兄弟前缀原样显示
+      expect(res.details.planFilePath).toBe("/tmp/test-project-2/.tmp/plans/auth/plan.md");
     });
 
     it("execute choice maps to execMode execute (goal + auto-parallel 整合档)", async () => {
@@ -341,7 +377,7 @@ describe("registerPlanTool", () => {
       (ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue("Execute");
       const res = await exec({ action: "complete" });
       expect(res.details.execMode).toBe("execute");
-      expect(handlePlanComplete).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), "direct", "execute", undefined);
+      expect(handlePlanComplete).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), "execute", undefined);
     });
 
     it("headless (!hasUI) defaults to execute without any select (D4 三路分流第 1 路)", async () => {
@@ -353,7 +389,7 @@ describe("registerPlanTool", () => {
       expect(ctx.ui.select).not.toHaveBeenCalled(); // 不进任何 select（noOp 软门修复）
       expect(detectExecSkills).not.toHaveBeenCalled(); // 选择已预定，跳过 skill 扫描
       expect(pi.setActiveTools).toHaveBeenCalledWith(ALL_TOOL_NAMES);
-      expect(handlePlanComplete).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), "direct", "execute", undefined);
+      expect(handlePlanComplete).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), "execute", undefined);
     });
 
     it("detected plan-exec skills lead the option set (first + second) and map to skill:<name> with skillEntryPath (D10 重排)", async () => {
@@ -379,24 +415,36 @@ describe("registerPlanTool", () => {
       expect(res.details.action).toBe("complete");
       expect(res.details.execMode).toBe("skill:dev-flow");
       // skillEntryPath 数据通路：CompleteChoiceOutcome → handlePlanComplete（steer 文案的路径来源）
-      expect(handlePlanComplete).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), "direct", "skill:dev-flow", skillEntryPath);
+      expect(handlePlanComplete).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), "skill:dev-flow", skillEntryPath);
     });
 
-    it("empty detection set leaves no skill options (空集不误伤选项集)", async () => {
-      const { exec, ctx } = setup();
+    it("D7② 空集直通（TUI）：无 plan-exec 技能不挂任何选择器，直接走执行派发链 + 文案明示", async () => {
+      const { exec, ctx, pi } = setup();
       (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([]);
-      (ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue("Execute");
-      await exec({ action: "complete" });
-      const options = (ctx.ui.select as ReturnType<typeof vi.fn>).mock.calls[0][1] as string[];
-      expect(options.some((label) => label.startsWith("Execute via skill:"))).toBe(false);
+      const res = await exec({ action: "complete" });
+
+      // 不挂执行方式选择（恒两项死表单构造性消除，S4 通过标准）
+      expect(ctx.ui.select).not.toHaveBeenCalled();
+      expect(res.details.action).toBe("complete");
+      expect(res.details.execMode).toBe("execute");
+      expect(res.details.execModeSource).toBe("no-exec-skills");
+      // 仍现扫（直通判定依赖检测结果，不是跳过检测——rpc 形态与本形态同分支，原独立用例已合并）
+      expect(detectExecSkills).toHaveBeenCalled();
+      // 工具结果文案明示「无 plan-exec 技能，直接执行」（不静默吞掉没弹表单的事实）
+      expect(res.content[0].text).toContain("No plan-exec skill was detected");
+      expect(res.content[0].text).toContain("executed directly");
+      // 复用既有执行派发链（goal 桥/直执 steer）+ 终局 completed
+      expect(handlePlanComplete).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), "execute", undefined);
+      const entries = (pi.appendEntry as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[1] as { state?: string });
+      expect(entries.at(-1)?.state).toBe("completed");
     });
 
     it("execute tier carries the goal outcome into result content and details (整合档 D2)", async () => {
       const { exec, ctx } = setup();
       (ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue("Execute");
       (handlePlanComplete as ReturnType<typeof vi.fn>).mockReturnValue({ started: false, reason: "no-steps" });
-      const res = await exec({ action: "complete", isolation: "direct" });
-      expect(handlePlanComplete).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), "direct", "execute", undefined);
+      const res = await exec({ action: "complete" });
+      expect(handlePlanComplete).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), "execute", undefined);
       expect(res.content[0].text).toContain("Goal tracking was not started (no-steps)");
       expect(res.content[0].text).toContain("Implementation Steps"); // 恢复动作
       expect(res.details.goalOutcome).toEqual({ started: false, reason: "no-steps" });
@@ -406,20 +454,20 @@ describe("registerPlanTool", () => {
       const { exec, ctx } = setup();
       (ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue("Execute");
       (handlePlanComplete as ReturnType<typeof vi.fn>).mockReturnValue({ started: true });
-      const res = await exec({ action: "complete", isolation: "direct" });
+      const res = await exec({ action: "complete" });
       expect(res.content[0].text).toContain("Goal tracking started via /goal");
       expect(res.details.goalOutcome).toEqual({ started: true });
     });
 
-    it("compact tier outcome is deferred (undefined): result keeps the plain approved line", async () => {
+    it("no goal-bridge outcome (undefined): result keeps the plain approved line", async () => {
       const { exec, ctx } = setup();
       (ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue("Execute");
       (handlePlanComplete as ReturnType<typeof vi.fn>).mockReturnValue(undefined);
-      const res = await exec({ action: "complete", isolation: "compact" });
+      const res = await exec({ action: "complete" });
       expect(res.content[0].text).toMatch(/^Plan approved\. File: /);
       expect(res.content[0].text).not.toContain("Goal tracking");
       expect(res.details.goalOutcome).toBeUndefined();
-      expect(res.details.isolation).toBe("compact");
+      expect(res.details.isolation).toBeUndefined(); // isolation 字段随 D-B1-6 两档分发砍除退役
     });
   });
 
@@ -427,7 +475,6 @@ describe("registerPlanTool", () => {
   describe("complete via taiji form channel", () => {
     beforeEach(() => {
       vi.stubEnv("TAIJI_AGENT_EXT_LOG", "1");
-      (detectGoalCapability as ReturnType<typeof vi.fn>).mockReturnValue(false);
       (handlePlanComplete as ReturnType<typeof vi.fn>).mockReset();
       (detectExecSkills as ReturnType<typeof vi.fn>).mockReset();
       (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([]);
@@ -451,8 +498,11 @@ describe("registerPlanTool", () => {
       return payload.formQuestions[0].options;
     }
 
-    it("sends a single choice question via UI_FORM_MARKER and maps the execute answer (无 tab 条单视图)", async () => {
+    it("sends a single choice question via UI_FORM_MARKER and maps the execute answer (无 tab 条单视图；D7② 有技能才挂)", async () => {
       const { exec, ctx } = setupGui();
+      (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([
+        { name: "dev-flow", description: "d", skillEntryPath: "/tmp/skills/dev-flow/SKILL.md" },
+      ]);
       (ctx.ui.select as ReturnType<typeof vi.fn>)
         .mockResolvedValue(JSON.stringify({ "Execution method": "Execute" }));
       const res = await exec({ action: "complete" });
@@ -461,6 +511,7 @@ describe("registerPlanTool", () => {
       expect(title).toBe(UI_FORM_MARKER);
       const labels = formOptionLabels(ctx.ui.select as ReturnType<typeof vi.fn>).map((o) => o.label);
       expect(labels).toEqual([
+        "Execute via skill: dev-flow",
         "Execute",
         "Not now",
       ]);
@@ -482,66 +533,96 @@ describe("registerPlanTool", () => {
       const skillOption = options.find((o) => o.label === "Execute via skill: dev-flow");
       expect(skillOption?.description).toBe("Deliver a plan via dev-flow.");
       expect(res.details.execMode).toBe("skill:dev-flow");
-      expect(handlePlanComplete).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), "direct", "skill:dev-flow", skillEntryPath);
+      // 对话档来源标记 + 表单恰挂一次 + 无直通文案（原 rpc 非空独立用例的增量断言并入）
+      expect(res.details.execModeSource).toBe("dialog");
+      expect(ctx.ui.select).toHaveBeenCalledOnce();
+      expect(res.content[0].text).not.toContain("No plan-exec skill");
+      expect(handlePlanComplete).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), "skill:dev-flow", skillEntryPath);
     });
 
-    it("timeout via undefined resolve (signal not aborted) folds to complete-cancelled with exit wording (D4 四态折叠)", async () => {
+    it("timeout via undefined resolve (signal not aborted) folds to 归口②外部解散（构造点④，review_aborted→approved）", async () => {
       // rpc 模式 GUI 用户取消 resolve undefined，与超时不可区分（signal 未 abort 折叠
-      // timeout，库层 callMarkerRpc 判别），消费层 cancelled‖timeout 同折后 reason='cancelled'。
-      // choice 空 = abort 联动取消语义（P2-3）：文案不得声称「Staying in plan mode」
+      // timeout，库层 callMarkerRpc 判别），构造点③④同折 via 'dissolved' reason='cancelled'。
+      // 未经入口解散（不打标）→ 外部解散：批准事实保留，文案不得声称已退出
       const { exec, ctx, pi } = setupGui();
+      (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([
+        { name: "dev-flow", description: "d", skillEntryPath: "/tmp/skills/dev-flow/SKILL.md" },
+      ]);
       (ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
       const res = await exec({ action: "complete" });
       expect(res.details.action).toBe("complete-cancelled");
       expect(res.details.reason).toBe("cancelled");
-      expect(res.content[0].text).toContain("Plan mode was exited");
-      expect(res.content[0].text).not.toContain("Staying in plan mode");
+      expect(res.details.source).toBe("external");
+      expect(res.content[0].text).toContain("interrupted");
+      expect(res.content[0].text).toContain("plan(action='complete')");
+      expect(res.content[0].text).not.toContain("has been exited");
       expect(pi.setActiveTools).not.toHaveBeenCalled();
     });
 
-    it("cancelled (abort via controllers registry during pending select) folds to complete-cancelled with exit wording (D4 四态折叠)", async () => {
-      // 真实通道注入（command.ts handleAbort 同款 `controllers.get(sessionId)?.abort()`）：
-      // 挂起窗口内 session abort → pi 实装 resolve undefined → 库层以 signal.aborted 判
-      // reason='cancelled'（区别于上一例的 timeout 折叠源）
+    it("命令解散（handleAbort 全序列：markDissolved('self') + controller.abort() + reset 介入）→ 归口② no-op（dissolvedBy 判别，不落盘）", async () => {
+      // 真实通道注入 = command.ts exitPlanMode 的因果链：markDissolved('self') 与
+      // controller.abort() 后 resetPlanState 同步落盘（同步临界段，无让出点）——归口点
+      // 在微任务里运行时来源已置位
       const { exec, ctx, controllers, pi } = setupGui();
+      (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([
+        { name: "dev-flow", description: "d", skillEntryPath: "/tmp/skills/dev-flow/SKILL.md" },
+      ]);
       (ctx.ui.select as ReturnType<typeof vi.fn>).mockImplementation(async () => {
-        controllers.get("test-session")?.abort();
+        // 模拟 exitPlanMode 入口动作（真实序列：markDissolved 先于 abort）
+        const pending = controllers.get("test-session");
+        pending?.markDissolved("self");
+        pending?.controller.abort();
         return undefined;
       });
       const res = await exec({ action: "complete" });
       expect(res.details.action).toBe("complete-cancelled");
       expect(res.details.reason).toBe("cancelled");
-      expect(res.content[0].text).toContain("Plan mode was exited");
+      expect(res.details.source).toBe("self");
+      expect(res.content[0].text).toContain("has been exited");
+      expect(res.content[0].text).toContain("full tool set is restored");
+      // 归口 no-op：不追加任何落盘（reset 已由命令侧落终态）——最后一条仍是入函数时的 dispatching
+      const entries = (pi.appendEntry as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[1] as { state?: string });
+      expect(entries.at(-1)?.state).toBe("dispatching");
       expect(pi.setActiveTools).not.toHaveBeenCalled();
     });
 
-    it("channel-error (echo payload) folds to complete-cancelled with channel note, no throw (D4 四态折叠)", async () => {
+    it("channel-error (echo payload) folds to 归口②外部解散（构造点⑤）with channel note, no throw", async () => {
       const { exec, ctx, pi } = setupGui();
+      (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([
+        { name: "dev-flow", description: "d", skillEntryPath: "/tmp/skills/dev-flow/SKILL.md" },
+      ]);
       // echo 检测：宿主不识别 UI_FORM_MARKER 时 band 单选项 = payload 自身，点选即回显
       (ctx.ui.select as ReturnType<typeof vi.fn>).mockImplementation(async (_t: string, options: string[]) => options[0]);
       const res = await exec({ action: "complete" });
       expect(res.details.action).toBe("complete-cancelled");
       expect(res.details.reason).toBe("channel-error");
-      expect(res.content[0].text).toContain("Interaction channel failed");
+      expect(res.details.source).toBe("external");
+      expect(res.content[0].text).toContain("interrupted");
+      expect(res.content[0].text).toContain("channel-error"); // 构造点原因透出
       expect(res.content[0].text).toContain("upgrade taiji"); // echo 升级指引透出
       expect(pi.setActiveTools).not.toHaveBeenCalled();
     });
 
-    it("non-json response folds to complete-cancelled with channel note, no throw (D4 四态折叠)", async () => {
+    it("non-json response folds to 归口②外部解散（构造点⑤）with channel note, no throw", async () => {
       const { exec, ctx } = setupGui();
+      (detectExecSkills as ReturnType<typeof vi.fn>).mockReturnValue([
+        { name: "dev-flow", description: "d", skillEntryPath: "/tmp/skills/dev-flow/SKILL.md" },
+      ]);
       (ctx.ui.select as ReturnType<typeof vi.fn>).mockResolvedValue("not-json");
       const res = await exec({ action: "complete" });
       expect(res.details.action).toBe("complete-cancelled");
       expect(res.details.reason).toBe("non-json");
-      expect(res.content[0].text).toContain("Interaction channel failed");
+      expect(res.details.source).toBe("external");
+      expect(res.content[0].text).toContain("interrupted");
+      expect(res.content[0].text).toContain("non-json");
     });
   });
 
   // --- abort ---
   describe("abort", () => {
-    it("resets state and cleans up session", async () => {
-      const { exec, pi, sessions } = setup();
-      // Pre-populate a session（工具层 abort 走 resetPlanState——命令层 abort 联动的顺序断言在 command.test.ts）
+    it("resets state and cleans up session — exit 边（活跃族非终态→exited）", async () => {
+      const { exec, pi, sessions, ctx } = setup();
+      // Pre-populate a session（工具层 abort 走 exitPlanMode 单入口——命令层 abort 联动的顺序断言在 command.test.ts）
       sessions.set("test-session", {
         ...DEFAULT_PLAN_STATE,
         isActive: true,
@@ -550,19 +631,86 @@ describe("registerPlanTool", () => {
         templateName: "t",
         skills: ["tech-design"],
         docs: [{ fileName: "design.md", absPath: "/tmp/design.md", sourceSkill: "tech-design", version: 1 }],
-        reviewState: "awaiting",
+        state: "reviewing",
       });
       const res = await exec({ action: "abort" });
       expect(res.details.action).toBe("abort");
       expect(pi.setActiveTools).toHaveBeenCalledWith(ALL_TOOL_NAMES);
       expect(sessions.has("test-session")).toBe(false);
-      expect(updatePlanWidget).toHaveBeenCalled();
-      // 终态矩阵：reset entry 落 isActive=false + skills/reviewState 清空 + docs 保留
-      expect(pi.appendEntry).toHaveBeenCalledWith("plan-state", expect.objectContaining({ isActive: false }));
+      expect(updatePlanWidget).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ isActive: false, state: "exited" }));
+      // 终态矩阵：reset entry 落 isActive=false + state='exited' + skills/selfReview 清空 + docs 保留
+      expect(pi.appendEntry).toHaveBeenCalledWith("plan-state", expect.objectContaining({ isActive: false, state: "exited" }));
       const entry = (pi.appendEntry as ReturnType<typeof vi.fn>).mock.calls.at(-1)?.[1] as Record<string, unknown>;
       expect(entry.docs).toHaveLength(1);
       expect(entry.skills).toEqual([]);
-      expect(entry.reviewState).toBeUndefined();
+    });
+
+    it("终态上 abort → 幂等退出：warn 纠偏 + 不覆写 completed、不落盘 + ④工具集幂等恢复（D-B1-1 守卫极性）", async () => {
+      const { exec, pi, sessions } = setup();
+      sessions.set("test-session", {
+        ...DEFAULT_PLAN_STATE,
+        isActive: false,
+        state: "completed",
+        docs: [{ fileName: "design.md", absPath: "/tmp/design.md", sourceSkill: "", version: 1 }],
+      });
+      const res = await exec({ action: "abort" });
+      expect(res.details).toEqual({ action: "review-error", reason: "inactive" });
+      expect(res.content[0].text).toContain("Plan mode is not active");
+      // ok:false 不落盘（completed 终态不被覆写为 exited）
+      expect(pi.appendEntry).not.toHaveBeenCalled();
+      // ④ 工具集照常幂等恢复（D-B1-1：ok:false → ①③④⑤照常，已恢复则 no-op）
+      expect(pi.setActiveTools).toHaveBeenCalledWith(ALL_TOOL_NAMES);
+    });
+
+    it("idle 常态格 abort → warn 纠偏文案、不落盘（D-B1-1 行为变更：噪音 exited entry 消灭，V1 ⑧ 锚）", async () => {
+      const { exec, pi, sessions } = setup();
+      // idle 常态格：从未进 plan（isActive=false + state='idle'——删 exit 边后 ok:false）
+      sessions.set("test-session", { ...DEFAULT_PLAN_STATE });
+      const res = await exec({ action: "abort" });
+      expect(res.details).toEqual({ action: "review-error", reason: "inactive" });
+      expect(res.content[0].text).toBe("No active plan mode.");
+      // 行为变更核心断言：不落 exited 噪音 entry
+      expect(pi.appendEntry).not.toHaveBeenCalled();
+      // ④ 幂等恢复（idle 格工具集已全量，重设 = 可观察零变化）
+      expect(pi.setActiveTools).toHaveBeenCalledWith(ALL_TOOL_NAMES);
+      expect(sessions.has("test-session")).toBe(true); // 无 reset（缓存不动）
+    });
+
+    it("坏数据格·终态残留（isActive=true + state=completed）abort → 清洗 entry（终态值不变 + isActive=false，不覆写为 exited）", async () => {
+      const { exec, pi, sessions } = setup();
+      sessions.set("test-session", {
+        ...DEFAULT_PLAN_STATE,
+        isActive: true, // 坏格：伪 active 投影
+        planFilePath: "/tmp/plans/auth/plan.md",
+        state: "completed",
+        docs: [{ fileName: "design.md", absPath: "/tmp/plans/auth/design.md", sourceSkill: "", version: 1 }],
+      });
+      const res = await exec({ action: "abort" });
+      expect(res.details).toEqual({ action: "review-error", reason: "inactive" });
+      // 清洗例外：唯一保留的落盘——isActive 投影复位 + state 取当前终态值（completed 不被 exited 覆写）
+      expect(pi.appendEntry).toHaveBeenCalledWith(
+        "plan-state",
+        expect.objectContaining({ isActive: false, state: "completed" }),
+      );
+      expect(pi.setActiveTools).toHaveBeenCalledWith(ALL_TOOL_NAMES);
+      expect(sessions.has("test-session")).toBe(false); // 清洗后缓存清理（重开经 entry 恢复正常态）
+    });
+
+    it("坏数据格·idle 残留（isActive=true + state=idle）abort → 清洗 entry（exited + isActive=false）", async () => {
+      const { exec, pi, sessions } = setup();
+      sessions.set("test-session", {
+        ...DEFAULT_PLAN_STATE,
+        isActive: true, // 坏格：'idle' 是值域白名单合法值 + isActive=true → 重开复活伪 active
+        planFilePath: "/tmp/plans/auth/plan.md",
+        state: "idle",
+      });
+      const res = await exec({ action: "abort" });
+      expect(res.details).toEqual({ action: "review-error", reason: "inactive" });
+      // 清洗例外 idle 残留形态：abort 是用户显式退出意图，exited 是本次动作的真实记录
+      expect(pi.appendEntry).toHaveBeenCalledWith(
+        "plan-state",
+        expect.objectContaining({ isActive: false, state: "exited" }),
+      );
     });
   });
 });