@zhushanwen/pi-goal 0.7.1 → 0.8.0

package/src/__tests__/event-adapter.test.ts

@@ -260,7 +260,6 @@ describe("handleAgentEnd — continuation", () => {
 				(s as { component?: string } | undefined)?.component === "goal:agent-end" &&
 				/continuation deferred/.test(String((s as { message?: string } | undefined)?.message ?? "")),
 		);
-		expect(deferredLog).toBeDefined();
 		const data = (deferredLog as { data?: { activePending?: number; ids?: string[] } } | undefined)?.data;
 		expect(data?.activePending).toBe(2); // 多元素计数（替代原 >=1 弱断言）
 		expect(data?.ids).toEqual(["bg-1", "bg-2"]); // ids 透出
@@ -390,15 +389,13 @@ describe("handleBeforeAgentStart", () => {
 
 		const result = await handleBeforeAgentStart(pi, session, ctx);
 
-		expect(result).toBeDefined();
 		expect(result!.message.customType).toBe("goal-context");
 		expect(result!.message.content).toContain("[GOAL mode activated]");
 		expect(result!.message.display).toBe(false);
 	});
 
-	// 全解耦后：planAvailable 恒 true（不再运行时探测 pi.__planStart）。
-	// contextInjectionPrompt 恒定注入 plan mode 建议段落，AI 自行判断是否用。
-	it("恒定注入 plan mode 建议段落（全解耦：不再探测 plan extension）", async () => {
+	// contextInjection 精简（planAvailable 参数已删，plan 提示收敛到 continuationPrompt）
+	it("context injection 不含 plan mode 提示（收敛到 continuation）", async () => {
 		const { pi } = makeFakePi();
 		const { ctx } = makeFakeCtx();
 		const session = createGoalSession();
@@ -406,9 +403,10 @@ describe("handleBeforeAgentStart", () => {
 
 		const result = await handleBeforeAgentStart(pi, session, ctx);
 
-		expect(result).toBeDefined();
 		expect(result!.message.customType).toBe("goal-context");
-		expect(result!.message.content).toContain("plan mode");
+		// plan 引导段已删（收敛到 continuationPrompt，agent_end 发）
+		expect(result!.message.content).not.toContain("plan mode");
+		expect(result!.message.content).not.toContain("__planStart");
 	});
 
 	// FR-8.1 G-007: AUTO_CLEAR_TURNS=2
@@ -444,7 +442,7 @@ describe("handleBeforeAgentStart", () => {
 		expect(result).toBeUndefined();
 		expect(session.state).not.toBeNull(); // 未清理
 		// setStatus 触发（折叠为终态单行）
-		expect(all.filter((c) => c.kind === "setStatus" && c.key === "goal").length).toBeGreaterThan(0);
+		expect(all.filter((c) => c.kind === "setStatus" && c.key === "goal")).toHaveLength(1);
 	});
 
 	// ADR-002 context usage 提示（CONTEXT_USAGE_RATIO_LIMIT=0.85，保持 active）
@@ -456,7 +454,6 @@ describe("handleBeforeAgentStart", () => {
 
 		const result = await handleBeforeAgentStart(pi, session, ctx);
 
-		expect(result).toBeDefined();
 		expect(result!.message.customType).toBe("goal-context-exceeded");
 		// ADR-002：goal 保持 active（不转 paused）
 		expect(session.state!.status).toBe("active");
@@ -487,34 +484,24 @@ describe("handleBeforeAgentStart", () => {
 
 	// ── pending-notifications（W2 跨扩展集成）───────────────────
 
-	it("有活跃 pending entries → 注入 content 不含 pending 提示（pendingHint 已移除）", async () => {
-		const { pi } = makeFakePi();
-		const { ctx } = makeFakeCtx({
-			entries: [
-				{ type: "custom", customType: "pending:register", data: { id: "wf-1", type: "workflow", name: "test-wf" } },
-				{ type: "custom", customType: "pending:register", data: { id: "bg-1", type: "subagent", name: "worker" } },
-			],
-		});
-		const session = createGoalSession();
-		session.state = makeRunningState();
-
-		const result = await handleBeforeAgentStart(pi, session, ctx);
-
-		expect(result).toBeDefined();
-		expect(result!.message.customType).toBe("goal-context");
-		// pendingHint 已删除：pending 感知交给 LLM 调 pending_notifications tool（mandatory）
-		expect(result!.message.content).not.toContain("pending async operation");
-	});
-
-	it("无 pending entries → 正常注入（不含 pending 提示）", async () => {
-		const { pi } = makeFakePi();
-		const { ctx } = makeFakeCtx(); // 默认 getEntries: () => []
-		const session = createGoalSession();
-		session.state = makeRunningState();
-
-		const result = await handleBeforeAgentStart(pi, session, ctx);
-
-		expect(result).toBeDefined();
-		expect(result!.message.content).not.toContain("pending async operation");
-	});
+	// pendingHint 已删除（pending 感知交给 LLM 调 pending_notifications tool），
+	// 无论是否有活跃 pending entries，content 都不含 pending 提示——轻量回归保护。
+	const PENDING_HINT_CASES: Array<[string, unknown[]]> = [
+		["有活跃 pending", [{ type: "custom", customType: "pending:register", data: { id: "wf-1" } }]],
+		["无 pending", []],
+	];
+	it.each(PENDING_HINT_CASES)(
+		"pendingHint 已移除：%s → content 不含 pending 提示",
+		async (_label, entries) => {
+			const { pi } = makeFakePi();
+			const { ctx } = makeFakeCtx({ entries });
+			const session = createGoalSession();
+			session.state = makeRunningState();
+
+			const result = await handleBeforeAgentStart(pi, session, ctx);
+
+			expect(result!.message.customType).toBe("goal-context");
+			expect(result!.message.content).not.toContain("pending async operation");
+		},
+	);
 });

package/src/__tests__/goal-control-adapter.test.ts

@@ -17,7 +17,7 @@ import {
 	handleCreate,
 	handleReportBlocked,
 } from "../adapters/goal-control-adapter";
-import { createGoalState, transitionStatus } from "../engine/goal";
+import { createGoalState } from "../engine/goal";
 import type { GoalRuntimeState } from "../engine/types";
 import type { UiPort } from "../ports";
 import type { ServicePorts } from "../service";
@@ -106,14 +106,6 @@ describe("handleComplete — active 守卫 + evidence + finalizeAndPersist", ()
 			handleComplete({ action: "complete", evidence: "   " }, session, makeFakePorts()),
 		).toThrow(/evidence/);
 	});
-
-	it("completedTasks 写入 history", () => {
-		const session = createGoalSession();
-		session.state = activeState();
-		const ports = makeFakePorts();
-		handleComplete({ action: "complete", evidence: "done", completedTasks: 5 }, session, ports);
-		expect((ports.history[0] as { completedTasks?: number }).completedTasks).toBe(5);
-	});
 });
 
 // ── handleCreate ─────────────────────────────────────
@@ -143,27 +135,13 @@ describe("handleCreate — slug+objective 必填 + 非终态守卫 + createGoal"
 		expect(ports.notifications[0]?.text).toContain("ship feature X");
 	});
 
-	it("objective 空 → throw（即使有 slug）", () => {
+	it("objective 空 → throw", () => {
 		const session = createGoalSession();
 		expect(() =>
-			handleCreate({ action: "create", slug: "x", objective: "   " }, session, makeFakePorts()),
+			handleCreate({ action: "create", slug: "x", objective: "   ", successCriteria: "done" }, session, makeFakePorts()),
 		).toThrow(/objective/);
 	});
 
-	it("slug 空 → throw（即使有 objective）", () => {
-		const session = createGoalSession();
-		expect(() =>
-			handleCreate({ action: "create", slug: "   ", objective: "do thing" }, session, makeFakePorts()),
-		).toThrow(/slug/);
-	});
-
-	it("slug 缺省 → throw", () => {
-		const session = createGoalSession();
-		expect(() =>
-			handleCreate({ action: "create", objective: "do thing" }, session, makeFakePorts()),
-		).toThrow(/slug/);
-	});
-
 	it("successCriteria 空 → throw（即使有 slug + objective）", () => {
 		const session = createGoalSession();
 		expect(() =>
@@ -175,33 +153,10 @@ describe("handleCreate — slug+objective 必填 + 非终态守卫 + createGoal"
 		).toThrow(/successCriteria/);
 	});
 
-	it("已有 active goal → throw（D25 非终态守卫）", () => {
-		const session = createGoalSession();
-		session.state = activeState({ status: "active" });
-		expect(() =>
-			handleCreate(
-				{ action: "create", slug: "new", objective: "new obj", successCriteria: "done" },
-				session,
-				makeFakePorts(),
-			),
-		).toThrow(/already active/i);
-	});
-
-	it("已有 paused goal → throw（paused 也是非终态）", () => {
-		const session = createGoalSession();
-		session.state = activeState({ status: "paused" });
-		expect(() =>
-			handleCreate(
-				{ action: "create", slug: "new", objective: "new obj", successCriteria: "done" },
-				session,
-				makeFakePorts(),
-			),
-		).toThrow(/already active/i);
-	});
-
-	it("已有 blocked goal → throw（blocked 也是非终态）", () => {
+	const NON_TERMINAL_STATUSES: GoalRuntimeState["status"][] = ["active", "paused", "blocked"];
+	it.each(NON_TERMINAL_STATUSES)("已有 %s goal → throw（D25 非终态守卫）", (status) => {
 		const session = createGoalSession();
-		session.state = activeState({ status: "blocked" });
+		session.state = activeState({ status });
 		expect(() =>
 			handleCreate(
 				{ action: "create", slug: "new", objective: "new obj", successCriteria: "done" },
@@ -240,29 +195,17 @@ describe("handleCreate — slug+objective 必填 + 非终态守卫 + createGoal"
 		).toThrow(/tokenBudget/);
 	});
 
-	it("timeBudgetMinutes <= 0 → throw", () => {
-		const session = createGoalSession();
-		expect(() =>
-			handleCreate(
-				{ action: "create", slug: "x", objective: "x", successCriteria: "done", timeBudgetMinutes: -5 },
-				session,
-				makeFakePorts(),
-			),
-		).toThrow(/timeBudgetMinutes/);
-	});
-
 	it("合法 budget → 合并进新 state", () => {
 		const session = createGoalSession();
 		const ports = makeFakePorts();
 
 		handleCreate(
-			{ action: "create", slug: "x", objective: "x", successCriteria: "done", tokenBudget: 8000, timeBudgetMinutes: 30 },
+			{ action: "create", slug: "x", objective: "x", successCriteria: "done", tokenBudget: 8000 },
 			session,
 			ports,
 		);
 
 		expect(session.state!.budget.tokenBudget).toBe(8000);
-		expect(session.state!.budget.timeBudgetMinutes).toBe(30);
 	});
 });
 
@@ -307,9 +250,4 @@ describe("handleReportBlocked — active 守卫 + tick + transition + persist",
 			handleReportBlocked({ action: "report_blocked", reason: "" }, session, makeFakePorts()),
 		).toThrow(/reason/);
 	});
-
-	it("active→blocked 是合法转换", () => {
-		// transitionStatus 自身已由 engine 测试覆盖，此处验证集成不破坏
-		expect(transitionStatus("active", "blocked")).toBe("blocked");
-	});
 });

package/src/__tests__/goal-control-prompt.test.ts

@@ -1,17 +1,14 @@
 // 提示词质量回归：goal_control tool description + runtime 错误文案必须是
 // "可纠正的行为约束器"，而非干巴巴的错误。
 //
-// agent（LLM）唯一能看到的 tool 元信息就是 description + 报错文案。弱模型
-// （如 step-3.7-flash）会在首次调用时省略条件必填字段（create 漏 slug、
-// complete 漏 evidence——complete 需模型主动生成内容，省略动因最强）。
-// description 补完整 JSON 正例 + 结构反例，runtime throw 补 "Correct:" 纠正
-// 正例，能让弱模型在首轮或报错后无需猜测即可对齐。
+// agent（LLM）唯一能看到的 tool 元信息就是 description + 报错文案。description 用中文
+// 重写（动作 create/complete/report_blocked + 规则 + §2.5 终态语义），删除英文 Examples/Don't
+// 段；runtime throw 保留 .trim() 空串校验 + 'Correct:' 纠正正例（缺失必填已前移到 schema
+// discriminated union 层拒绝，C3）。
 //
-// 本测试用源码断言（读 .ts 文件文本）锁定这些约束，防止后续重构把正例/反例
-// 或纠错文案删掉。读源码而非 import，避免 mock 链（goal-control-adapter.ts
-// 依赖 pi-ai/typebox/pi-tui/ExtensionAPI 等值导入）。
-//
-// 模式参考：subagent-workflow/src/interface/__tests__/subagent-tool-prompt.test.ts。
+// 本测试用源码断言（读 .ts 文件文本）锁定这些约束，防止后续重构把中文语义/纠错文案/
+// union 结构删掉。读源码而非 import，避免 mock 链（goal-control-adapter.ts 依赖
+// pi-ai/typebox/pi-tui/ExtensionAPI 等值导入）。
 
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -34,62 +31,64 @@ function extractDescription(src: string): string {
 
 const DESCRIPTION = extractDescription(ADAPTER_SRC);
 
-describe("goal_control description — 含完整 JSON 正例（弱模型首轮误用防御）", () => {
-	it("含 create 正例子串", () => {
-		// create 是弱模型最易漏 slug 的 action；完整 JSON 正例给出可直接复用的形态。
-		expect(DESCRIPTION).toContain('{"action":"create"');
-	});
-
-	it("含 complete 正例子串", () => {
-		// complete 需模型主动生成 evidence，省略动因最强；正例锁定必填字段。
-		expect(DESCRIPTION).toContain('{"action":"complete"');
+describe("goal_control description — 中文化 + 动作覆盖", () => {
+	it("含管理目标总述 + complete 须满足每条 successCriteria 条件", () => {
+		expect(DESCRIPTION).toContain("管理当前会话的目标");
+		expect(DESCRIPTION).toContain("满足每条 successCriteria 条件");
 	});
+});
 
-	it("含 report_blocked 正例子串", () => {
-		expect(DESCRIPTION).toContain('{"action":"report_blocked"');
+describe("goal_control description — §2.5 终态语义", () => {
+	it("create 失败提示 / complete 报告 token / pause-resume-budget 归用户 / 不反复报告阻塞", () => {
+		expect(DESCRIPTION).toContain("请让用户运行 /goal resume 或 /goal clear");
+		expect(DESCRIPTION).toContain("报告最终 token 用量");
+		expect(DESCRIPTION).toContain("pause/resume 和 budget 变更由用户经 /goal 命令控制");
+		expect(DESCRIPTION).toContain("不要反复报告同一阻塞");
 	});
 });
 
-describe("goal_control description — 含参数结构反例（Don't 段）", () => {
-	it("含 Don't 段", () => {
-		expect(DESCRIPTION).toMatch(/Don't/);
+describe("goal_control description — 删除 Examples/Don't 英文段", () => {
+	it("不含 Examples JSON 正例段 + 不含 Don't 段", () => {
+		// Examples 段已删，description 不再含裸 JSON 正例
+		expect(DESCRIPTION).not.toContain('{"action":"create"');
+		expect(DESCRIPTION).not.toMatch(/Don't/);
 	});
+});
 
-	it("Don't 段含 evidence 结构反例关键词（complete 漏 evidence）", () => {
-		// complete 漏 evidence 是核心失败模式之一；反例文案必须提及 evidence。
-		expect(DESCRIPTION).toMatch(/evidence/);
+describe("goal_control schema — discriminated union（C3）", () => {
+	it("Type.Union + 各分支 additionalProperties:false + 无 timeBudgetMinutes", () => {
+		expect(ADAPTER_SRC).toMatch(/Type\.Union\(/);
+		expect(ADAPTER_SRC).toContain("additionalProperties: false");
+		expect(ADAPTER_SRC).not.toMatch(/timeBudgetMinutes/);
 	});
 });
 
-describe("goal_control promptGuidelines — complete/report_blocked 主动触发引导（防不主动收尾）", () => {
-	// promptGuidelines 进 system prompt guidelines 段（强信号），是修复 complete/report_blocked
-	// 「该主动调但不调」的核心载体。用源码断言锁定两条正向触发引导，防止后续重构删掉。
-	it("源码含 promptGuidelines 字段", () => {
+describe("goal_control promptGuidelines — complete/report_blocked 主动触发引导", () => {
+	it("含 promptGuidelines 字段 + complete/report_blocked 主动触发信号", () => {
 		expect(ADAPTER_SRC).toMatch(/promptGuidelines:\s*\[/);
-	});
-
-	it("promptGuidelines 含 complete 主动触发信号（proactively + objective is actually achieved）", () => {
 		expect(ADAPTER_SRC).toMatch(/complete:.*proactively call.*objective is actually achieved/s);
-	});
-
-	it("promptGuidelines 含 report_blocked 主动触发信号（proactively + ≥3 approaches）", () => {
 		expect(ADAPTER_SRC).toMatch(/report_blocked:.*proactively call.*≥3 distinct alternative approaches/s);
+		expect(ADAPTER_SRC).toContain("do not repeatedly report the same blocker");
 	});
 });
 
-describe("goal_control runtime 错误文案 — 含 'Correct:' 纠正正例（≥4 处）", () => {
-	it("源码含 ≥4 处 'Correct:' 纠错文案（4 条 required throw 各一带正例）", () => {
-		// objective/slug/evidence/reason 四条必填 throw 各应带完整 JSON 正例，
+describe("goal_control runtime 错误文案 — 含 'Correct:' 纠正正例", () => {
+	it("≥4 处 'Correct:'（4 条空串 throw 各一带正例）+ objective/evidence 报错带正例", () => {
+		// objective/successCriteria/evidence/reason 四条空串 throw 各应带完整 JSON 正例，
 		// 让弱模型在报错后无需猜测即可纠正。读整份源码统计出现次数。
 		const matches = ADAPTER_SRC.match(/Correct:/g) || [];
 		expect(matches.length).toBeGreaterThanOrEqual(4);
+		expect(ADAPTER_SRC).toMatch(/'objective' must not be empty[\s\S]*?Correct:/);
+		expect(ADAPTER_SRC).toMatch(/'evidence' must not be empty[\s\S]*?Correct:/);
 	});
+});
 
-	it("objective 报错带 Correct 正例", () => {
-		expect(ADAPTER_SRC).toMatch(/'objective' is required[\s\S]*?Correct:/);
-	});
-
-	it("evidence 报错带 Correct 正例", () => {
-		expect(ADAPTER_SRC).toMatch(/'evidence' is required[\s\S]*?Correct:/);
+describe("goal_control 描述修正（A1/slug optional）", () => {
+	it("无 'at least 3 approaches' + reason throw 含 'what you tried' + slug 真 optional", () => {
+		// A1: reason schema desc/throw 已删强制 ≥3 声明
+		expect(ADAPTER_SRC).not.toMatch(/at least 3 approaches/);
+		expect(ADAPTER_SRC).toMatch(/'reason' must not be empty[\s\S]*?what you tried/);
+		expect(ADAPTER_SRC).toContain("可选。");
+		expect(ADAPTER_SRC).not.toMatch(/'slug' is required/);
 	});
 });

package/src/__tests__/goal-control-rpc.test.ts

@@ -104,7 +104,7 @@ function createViaHandler(
 	tool: CapturedTool,
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
-	params: { slug: string; objective: string; tokenBudget?: number; timeBudgetMinutes?: number },
+	params: { slug: string; objective: string; tokenBudget?: number },
 ): Promise<ExecuteResult> {
 	return tool.execute(
 		"call-1",
@@ -127,7 +127,6 @@ describe("goal_control execute — RPC __gui__ 注入分支", () => {
 			objective: "rpc card goal",
 			tokenBudget: 10000,
 		});
-		expect(result.details.__gui__).toBeDefined();
 		const gui = result.details.__gui__!;
 		expect(gui.component.type).toBe("card");
 		// card body 含 progress-bar（tokenBudget）+ stats-line
@@ -145,7 +144,6 @@ describe("goal_control execute — RPC __gui__ 注入分支", () => {
 			slug: "rpc-stats",
 			objective: "rpc stats goal",
 		});
-		expect(result.details.__gui__).toBeDefined();
 		const gui = result.details.__gui__!;
 		expect(gui.component.type).toBe("stats-line");
 		// stats-line items 含 goal/status/turn/tokens
@@ -182,20 +180,6 @@ describe("goal_control execute — RPC __gui__ 注入分支", () => {
 		).rejects.toThrow(/not active/i);
 	});
 
-	it("TUI 模式 → __gui__ 不附加（即使有 state）", async () => {
-		const { pi, ctx } = makeFixture("tui");
-		const tool = captureTool(pi);
-		const result = await createViaHandler(tool, pi, ctx, {
-			slug: "tui-no-gui",
-			objective: "tui goal",
-			tokenBudget: 5000,
-		});
-		// TUI 模式不注入 __gui__
-		expect(result.details.__gui__).toBeUndefined();
-		// 但 content 仍正常
-		expect(result.content[0]!.text).toContain("Goal created");
-	});
-
 	it("RPC + complete 动作 → __gui__ 也附加（用终态 state 渲染）", async () => {
 		// 验证 __gui__ 注入不限于 create：complete 后 session.state 仍非 null（status=complete）
 		const { pi, ctx } = makeFixture("rpc");
@@ -210,7 +194,6 @@ describe("goal_control execute — RPC __gui__ 注入分支", () => {
 			undefined,
 			ctx,
 		);
-		expect(result.details.__gui__).toBeDefined();
 		expect(result.details.status).toBe("complete");
 		const gui = result.details.__gui__!;
 		// 无 budget → stats-line
@@ -231,7 +214,6 @@ describe("goal_control execute — RPC __gui__ 注入分支", () => {
 			undefined,
 			ctx,
 		);
-		expect(result.details.__gui__).toBeDefined();
 		expect(result.details.status).toBe("blocked");
 		// 无 budget → stats-line；blocked status severity=danger
 		const gui = result.details.__gui__!;
@@ -241,44 +223,21 @@ describe("goal_control execute — RPC __gui__ 注入分支", () => {
 		expect(statusItem!.severity).toBe("danger");
 	});
 
-	it("RPC + 有 time budget → __gui__ card 含 time progress-bar", async () => {
-		const { pi, ctx } = makeFixture("rpc");
-		const tool = captureTool(pi);
-		const result = await createViaHandler(tool, pi, ctx, {
-			slug: "time-budget",
-			objective: "time boxed",
-			timeBudgetMinutes: 30,
-		});
-		const gui = result.details.__gui__!;
-		expect(gui.component.type).toBe("card");
-		const body = gui.component.props.body as Array<{ type: string; props: { label?: string } }>;
-		const timeBar = body.find((c) => c.type === "progress-bar" && c.props.label === "time");
-		expect(timeBar).toBeDefined();
-	});
 });
 
-// ── 边界：非 RPC 模式（json/print）也不注入 __gui__ ──
+// ── 边界：非 RPC 模式（tui/json/print）也不注入 __gui__ ──
 
 describe("goal_control execute — 非 RPC 模式不注入 __gui__", () => {
-	it("json 模式 → __gui__ 不附加", async () => {
-		const { pi, ctx } = makeFixture("json");
+	const NON_RPC_MODES: Array<"tui" | "json" | "print"> = ["tui", "json", "print"];
+	it.each(NON_RPC_MODES)("%s 模式 → __gui__ 不附加（content 仍正常）", async (mode) => {
+		const { pi, ctx } = makeFixture(mode);
 		const tool = captureTool(pi);
 		const result = await createViaHandler(tool, pi, ctx, {
-			slug: "json-mode",
-			objective: "json goal",
-			tokenBudget: 1000,
-		});
-		expect(result.details.__gui__).toBeUndefined();
-	});
-
-	it("print 模式 → __gui__ 不附加", async () => {
-		const { pi, ctx } = makeFixture("print");
-		const tool = captureTool(pi);
-		const result = await createViaHandler(tool, pi, ctx, {
-			slug: "print-mode",
-			objective: "print goal",
+			slug: `${mode}-mode`,
+			objective: `${mode} goal`,
 			tokenBudget: 1000,
 		});
 		expect(result.details.__gui__).toBeUndefined();
+		expect(result.content[0]!.text).toContain("Goal created");
 	});
 });

package/src/__tests__/gui.test.ts

@@ -9,9 +9,9 @@
  */
 import { describe, expect, it } from "vitest";
 
-import { buildGoalGui } from "../adapters/goal-control-adapter";
+import { buildGoalGui } from "../projection/gui";
 import { createGoalState } from "../engine/goal";
-import type { GoalRuntimeState } from "../engine/types";
+import type { GoalRuntimeState, GoalStatus } from "../engine/types";
 
 function makeState(overrides: Partial<GoalRuntimeState> = {}): GoalRuntimeState {
 	return {
@@ -20,6 +20,15 @@ function makeState(overrides: Partial<GoalRuntimeState> = {}): GoalRuntimeState
 	};
 }
 
+/** 从 card 分支的 body 中按 type 取组件（hasBudget 分支只有一个 progress-bar / 一个 stats-line 组合）。 */
+function findBodyComp(
+	gui: ReturnType<typeof buildGoalGui>,
+	type: string,
+): { type: string; props: Record<string, unknown> } {
+	const body = gui.component.props.body as { type: string; props: Record<string, unknown> }[];
+	return body.find((c) => c.type === type)!;
+}
+
 describe("buildGoalGui", () => {
 	it("有 tokenBudget → card 含 progress-bar + stats-line", () => {
 		const gui = buildGoalGui(
@@ -31,36 +40,21 @@ describe("buildGoalGui", () => {
 		);
 		expect(gui.v).toBe(1);
 		expect(gui.component.type).toBe("card");
-		const body = gui.component.props.body as { type: string; props: Record<string, unknown> }[];
-		// body[0] = progress-bar(tokens), body[1] = stats-line
-		const tokenBar = body.find((c) => c.type === "progress-bar")!;
+		const tokenBar = findBodyComp(gui, "progress-bar");
 		expect(tokenBar.props).toMatchObject({ current: 4200, total: 10000, severity: "ok" });
-		const stats = body.find((c) => c.type === "stats-line")!;
+		const stats = findBodyComp(gui, "stats-line");
 		expect(stats.props.items).toContainEqual(expect.objectContaining({ label: "status", value: "active" }));
 	});
 
-	it("token 消耗 ≥90% → severity danger", () => {
-		const gui = buildGoalGui(
-			makeState({
-				tokensUsed: 9500,
-				budget: { tokenBudget: 10000 },
-			}),
-		);
-		const body = gui.component.props.body as { type: string; props: Record<string, unknown> }[];
-		const tokenBar = body.find((c) => c.type === "progress-bar")!;
-		expect(tokenBar.props.severity).toBe("danger");
-	});
-
-	it("token 消耗 ≥70% → severity warn", () => {
-		const gui = buildGoalGui(
-			makeState({
-				tokensUsed: 7500,
-				budget: { tokenBudget: 10000 },
-			}),
-		);
-		const body = gui.component.props.body as { type: string; props: Record<string, unknown> }[];
-		const tokenBar = body.find((c) => c.type === "progress-bar")!;
-		expect(tokenBar.props.severity).toBe("warn");
+	it.each([
+		["9500/10000 ≥90%", 9500, "danger"],
+		["9000/10000 =90%", 9000, "danger"],
+		["7500/10000 ≥70%", 7500, "warn"],
+		["7000/10000 =70%", 7000, "warn"],
+	])("token 消耗 %s → severity %s（S#14 边界 ≥）", (_label, used, severity) => {
+		const gui = buildGoalGui(makeState({ tokensUsed: used, budget: { tokenBudget: 10000 } }));
+		const tokenBar = findBodyComp(gui, "progress-bar");
+		expect(tokenBar.props.severity).toBe(severity);
 	});
 
 	it("无 budget → stats-line 摘要", () => {
@@ -101,18 +95,6 @@ describe("buildGoalGui", () => {
 		expect(gui.component.props.variant).toBe("success");
 	});
 
-	it("time 进度条：≥90% → danger", () => {
-		const gui = buildGoalGui(
-			makeState({
-				timeUsedSeconds: 5 * 60 + 1, // 5.01 min / 5 min budget
-				budget: { timeBudgetMinutes: 5 },
-			}),
-		);
-		const body = gui.component.props.body as { type: string; props: { label?: string; severity?: string } }[];
-		const timeBar = body.find((c) => c.type === "progress-bar" && c.props.label === "time")!;
-		expect(timeBar.props.severity).toBe("danger");
-	});
-
 	it("slug 缺省 → header 用 goalId 前 8 字符", () => {
 		const state = makeState({ slug: undefined, budget: { tokenBudget: 10000 } });
 		const gui = buildGoalGui(state);
@@ -121,59 +103,16 @@ describe("buildGoalGui", () => {
 
 	// ── S#2: statusSeverity 完整覆盖 ──
 
-	it("budget_limited 状态 → status severity danger（S#2）", () => {
-		const gui = buildGoalGui(makeState({ status: "budget_limited", budget: { tokenBudget: 10000 } }));
-		const body = gui.component.props.body as { type: string; props: { items: Array<{ label: string; severity: string }> } }[];
-		const stats = body.find((c) => c.type === "stats-line")!;
-		const statusItem = stats.props.items.find((i) => i.label === "status")!;
-		expect(statusItem.severity).toBe("danger");
-	});
-
-	it("time_limited 状态 → status severity danger（S#2）", () => {
-		const gui = buildGoalGui(makeState({ status: "time_limited", budget: { tokenBudget: 10000 } }));
-		const body = gui.component.props.body as { type: string; props: { items: Array<{ label: string; severity: string }> } }[];
-		const stats = body.find((c) => c.type === "stats-line")!;
-		const statusItem = stats.props.items.find((i) => i.label === "status")!;
-		expect(statusItem.severity).toBe("danger");
-	});
-
-	it("cancelled 状态 → status severity danger（S#2）", () => {
-		const gui = buildGoalGui(makeState({ status: "cancelled", budget: { tokenBudget: 10000 } }));
-		const body = gui.component.props.body as { type: string; props: { items: Array<{ label: string; severity: string }> } }[];
-		const stats = body.find((c) => c.type === "stats-line")!;
-		const statusItem = stats.props.items.find((i) => i.label === "status")!;
-		expect(statusItem.severity).toBe("danger");
-	});
-
-	it("paused 状态 → status severity warn（S#2）", () => {
-		const gui = buildGoalGui(makeState({ status: "paused", budget: { tokenBudget: 10000 } }));
-		const body = gui.component.props.body as { type: string; props: { items: Array<{ label: string; severity: string }> } }[];
-		const stats = body.find((c) => c.type === "stats-line")!;
-		const statusItem = stats.props.items.find((i) => i.label === "status")!;
-		expect(statusItem.severity).toBe("warn");
-	});
-
-	// ── S#14: 阈值边界精确值 ──
-
-	it("token 消耗正好 90% → severity danger（边界 ≥，S#14）", () => {
-		const gui = buildGoalGui(makeState({ tokensUsed: 9000, budget: { tokenBudget: 10000 } }));
-		const body = gui.component.props.body as { type: string; props: { label?: string; severity?: string } }[];
-		const tokenBar = body.find((c) => c.type === "progress-bar" && c.props.label === "tokens")!;
-		expect(tokenBar.props.severity).toBe("danger");
-	});
-
-	it("token 消耗正好 70% → severity warn（边界 ≥，S#14）", () => {
-		const gui = buildGoalGui(makeState({ tokensUsed: 7000, budget: { tokenBudget: 10000 } }));
-		const body = gui.component.props.body as { type: string; props: { label?: string; severity?: string } }[];
-		const tokenBar = body.find((c) => c.type === "progress-bar" && c.props.label === "tokens")!;
-		expect(tokenBar.props.severity).toBe("warn");
-	});
-
-	it("time 消耗正好 70% → severity warn（边界 ≥，S#14）", () => {
-		const gui = buildGoalGui(makeState({ timeUsedSeconds: 7 * 60, budget: { timeBudgetMinutes: 10 } }));
-		const body = gui.component.props.body as { type: string; props: { label?: string; severity?: string } }[];
-		const timeBar = body.find((c) => c.type === "progress-bar" && c.props.label === "time")!;
-		expect(timeBar.props.severity).toBe("warn");
+	it.each([
+		["budget_limited", "danger"],
+		["cancelled", "danger"],
+		["paused", "warn"],
+	])("status %s → stats-line status severity %s（S#2）", (status, severity) => {
+		const gui = buildGoalGui(makeState({ status: status as GoalStatus, budget: { tokenBudget: 10000 } }));
+		const stats = findBodyComp(gui, "stats-line");
+		const items = stats.props.items as Array<{ label: string; severity?: string }>;
+		const statusItem = items.find((i) => i.label === "status")!;
+		expect(statusItem.severity).toBe(severity);
 	});
 
 	// ── I#1: tokenBudget=0 口径统一 ──