@zhushanwen/pi-goal 0.12.2 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-goal",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "description": "Codex-style /goal command for Pi — persistent goal-driven autonomous loop with evidence-based completion, token budget, agent-reported blocking, and steering templates.",
   "type": "module",
   "main": "src/index.ts",
@@ -29,7 +29,7 @@
     "@earendil-works/pi-coding-agent": "^0.84.4",
     "@earendil-works/pi-tui": "^0.84.4",
     "typebox": "*",
-    "@zhushanwen/pi-pending-notifications": "0.5.3"
+    "@zhushanwen/pi-pending-notifications": "0.6.0"
   },
   "dependencies": {
     "@xyz-agent/extension-protocol": "0.8.2"

package/src/__tests__/circuit-breaker.test.ts

@@ -0,0 +1,449 @@
+/**
+ * 轮次活性熔断行为测试（chat-domain-v1x 设计 §3.2 D4 / W5，验收 §4 A10 的单测面）
+ *
+ * 四断言（对齐 impl-plan W5 验收条款②）：
+ * a. 主判据 50 次封顶必停发——含「每轮调一次工具」序列同样被封顶（正交性：
+ *    工具调用只清零退避计数，绝不清零总次数——设计 R1 击穿记录的反向锁定）；
+ * b. 连续 5 轮无工具调用且低 tokenDelta → 第 5 轮起间隔翻倍（×2 递增）；
+ * c. 恢复（真实工具调用）清零退避计数但不重置主判据总次数；
+ * d. defer 通知：pending 集合不变的连续 defer 轮中通知条数不增长。
+ *
+ * 另覆盖：停发通知含 /goal resume 恢复指引 + goal 保持 active；/goal resume
+ * 恢复通道重置计数；未封顶 active goal 的 resume 语义不变。
+ *
+ * fake timers + fake pi/ctx（不 import Pi SDK 真实实现，harness 对齐 event-adapter.test.ts）。
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { handleAgentEnd } from "../adapters/event-handlers/agent-end";
+import { handleBeforeAgentStart } from "../adapters/event-handlers/before-agent-start";
+import { handleSessionShutdown } from "../adapters/event-handlers/session-shutdown";
+import { handleSessionStart } from "../adapters/event-handlers/session-start";
+import { handleGoalCommand } from "../adapters/command-adapter";
+import { createGoalState } from "../engine/goal";
+import type { GoalRuntimeState } from "../engine/types";
+import { createGoalSession, type GoalSession } from "../session";
+
+// ── Fake pi / ctx（entries 数组可变，模拟 append-only 会话流）──
+
+interface RecordedCall {
+	kind: "appendState" | "appendHistory" | "notify" | "sendContext" | "sendUser";
+	payload?: unknown;
+	text?: string;
+	level?: string;
+	content?: unknown;
+}
+
+interface FakeHarness {
+	pi: ExtensionAPI;
+	ctx: ExtensionContext;
+	entries: unknown[];
+	piCalls: RecordedCall[];
+	ctxCalls: RecordedCall[];
+	/** 可控 isIdle（MF-6① 守卫断言用：延迟窗内有活动 turn 时置 false） */
+	isIdle: { value: boolean };
+	/**
+	 * 可控 appendEntry 抛错（MF-R2-1 测试前提修正）：pi.appendEntry 与 ctx 同生命周期
+	 * （loader.js appendEntry 首行 assertActive，0.84.4 实装核对）——模拟全量 stale
+	 * 时必须置 true 按 SDK 契约抛错，否则测试默许了真实场景必抛的调用
+	 */
+	appendEntryFails: { value: boolean };
+}
+
+/** runner.js invalidate 默认 stale 文案首句（0.84.4 实装），assertActive 据此抛出 */
+const STALE_CTX_MESSAGE = "This extension ctx is stale after session replacement or reload.";
+
+function makeHarness(): FakeHarness {
+	const piCalls: RecordedCall[] = [];
+	const ctxCalls: RecordedCall[] = [];
+	const entries: unknown[] = [];
+	const isIdle = { value: true };
+	const appendEntryFails = { value: false };
+
+	const pi = {
+		appendEntry(customType: string, data?: unknown): void {
+			if (appendEntryFails.value) {
+				throw new Error(STALE_CTX_MESSAGE);
+			}
+			piCalls.push({ kind: customType === "goal-history" ? "appendHistory" : "appendState", payload: data });
+		},
+		sendMessage(message: unknown, options?: unknown): void {
+			const msg = message as { content?: unknown };
+			piCalls.push({ kind: "sendContext", content: msg.content, payload: options });
+		},
+		sendUserMessage(content: string | unknown[], _options?: unknown): void {
+			piCalls.push({ kind: "sendUser", content });
+		},
+	} as unknown as ExtensionAPI;
+
+	const ctx = {
+		hasUI: true,
+		signal: { aborted: false } as AbortSignal,
+		// MF-6①：SDK ExtensionContext.isIdle（types.d.ts L232），agent_end 后为 true
+		isIdle: () => isIdle.value,
+		getContextUsage: () => null,
+		ui: {
+			notify: (text: string, level: string) => ctxCalls.push({ kind: "notify", text, level }),
+			setStatus: () => {},
+			setWidget: () => {},
+			theme: { fg: (_c: string, t: string) => t, bold: (t: string) => t },
+		},
+		sessionManager: {
+			getEntries: () => entries,
+			getBranch: () => undefined,
+			// W4 读侧过滤①消费口（agent-end 两处 countActiveFromEntries 传基准）
+			getSessionId: () => "test-session",
+		},
+	} as unknown as ExtensionContext;
+
+	return { pi, ctx, entries, piCalls, ctxCalls, isIdle, appendEntryFails };
+}
+
+// ── 辅助 ─────────────────────────────────────────────
+
+function makeRunningState(overrides?: Partial<GoalRuntimeState>): GoalRuntimeState {
+	return {
+		...createGoalState("test objective"),
+		timeStartedAt: 0, // 关闭时间累计口径（本文件不断言耗时）
+		...overrides,
+	};
+}
+
+/** assistant message entry，content 含 1 个 toolCall 块（pi 实测形态：toolCall 在 content 数组） */
+function assistantToolCallEntry(id: string): unknown {
+	return {
+		type: "message",
+		message: {
+			role: "assistant",
+			content: [{ type: "text", text: "working" }, { type: "toolCall", id, name: "bash", arguments: {} }],
+		},
+	};
+}
+
+/** pending:register custom entry（对齐 countActiveFromEntries 读取契约） */
+function pendingRegisterEntry(id: string): unknown {
+	return { type: "custom", customType: "pending:register", data: { id, type: "subagent", name: "worker" } };
+}
+
+/** 实际发出的 continuation（followUp custom message）计数 */
+function followUpSends(h: FakeHarness): RecordedCall[] {
+	return h.piCalls.filter(
+		(c) => c.kind === "sendContext" && (c.payload as { deliverAs?: string } | undefined)?.deliverAs === "followUp",
+	);
+}
+
+function notifyTexts(h: FakeHarness, level?: string): string[] {
+	return h.ctxCalls.filter((c) => c.kind === "notify" && (!level || c.level === level)).map((c) => c.text!);
+}
+
+/** 模拟一个 turn 结束：tokenDelta 注入 + 可选工具调用 + agent_end */
+async function runTurn(
+	h: FakeHarness,
+	session: GoalSession,
+	opts: { tokenDelta: number; toolCallId?: string },
+): Promise<void> {
+	const state = session.state!;
+	state.tokensUsed += opts.tokenDelta;
+	if (opts.toolCallId) h.entries.push(assistantToolCallEntry(opts.toolCallId));
+	await handleAgentEnd(h.pi, session, h.ctx);
+}
+
+beforeEach(() => {
+	vi.useFakeTimers();
+});
+
+afterEach(() => {
+	vi.useRealTimers();
+});
+
+// ── 断言 a：主判据 50 次封顶（正交性）─────────────────
+
+describe("主判据：continuation 连发总次数封顶", () => {
+	it("每轮调一次工具（R1 击穿形态）连续 50 轮后必停发；停发通知含恢复指引；goal 保持 active", async () => {
+		const h = makeHarness();
+		const session = createGoalSession();
+		session.state = makeRunningState();
+
+		for (let i = 1; i <= 50; i++) {
+			await runTurn(h, session, { tokenDelta: 200, toolCallId: `tc-${i}` });
+		}
+		expect(followUpSends(h)).toHaveLength(50);
+		expect(session.state!.continuationsSent).toBe(50);
+		// 每轮都有工具调用 → 有进展 → 从未进入退避（无待发定时器）
+		expect(session.continuationTimer).toBeNull();
+
+		// 第 51 轮：同样有工具调用、tokenDelta>0，仍被封顶拦截（正交：工具调用绕不过封顶）
+		await runTurn(h, session, { tokenDelta: 200, toolCallId: "tc-51" });
+		expect(followUpSends(h)).toHaveLength(50); // 停发
+		expect(session.state!.continuationsSent).toBe(50); // 总数封在 50
+		expect(session.state!.status).toBe("active"); // goal 保持 active（不擅自终态）
+
+		const warnings = notifyTexts(h, "warning");
+		expect(warnings).toHaveLength(1);
+		expect(warnings[0]).toContain("circuit breaker");
+		expect(warnings[0]).toContain("/goal resume"); // 恢复指引
+
+		// 第 52 轮：停发通知不重复
+		await runTurn(h, session, { tokenDelta: 200, toolCallId: "tc-52" });
+		expect(followUpSends(h)).toHaveLength(50);
+		expect(notifyTexts(h, "warning")).toHaveLength(1);
+	});
+});
+
+// ── 断言 b：辅判据无进展退避 ─────────────────────────
+
+describe("辅判据：无进展退避（间隔 ×2 递增）", () => {
+	it("连续 5 轮无工具调用且低 tokenDelta → 第 5 轮起间隔翻倍（5 轮 2×base、6 轮 4×base）", async () => {
+		const h = makeHarness();
+		const session = createGoalSession();
+		session.state = makeRunningState();
+
+		// 轮 1-4：未达阈值 → 立即发出
+		for (let i = 1; i <= 4; i++) {
+			await runTurn(h, session, { tokenDelta: 200 });
+			expect(followUpSends(h)).toHaveLength(i); // 同步发出，无延迟
+		}
+
+		// 轮 5：noProgressTurns=5 → 延迟 2×base = 20s（base 默认 10s）
+		await runTurn(h, session, { tokenDelta: 200 });
+		expect(followUpSends(h)).toHaveLength(4); // 未立即发
+		expect(session.continuationTimer).not.toBeNull(); // 已排定退避定时器
+		vi.advanceTimersByTime(19_999);
+		expect(followUpSends(h)).toHaveLength(4); // 20s 边界前不发
+		vi.advanceTimersByTime(1);
+		expect(followUpSends(h)).toHaveLength(5); // 20s 整点发出
+		expect(session.state!.continuationsSent).toBe(5);
+
+		// 轮 6：间隔再翻倍 → 4×base = 40s
+		await runTurn(h, session, { tokenDelta: 200 });
+		expect(followUpSends(h)).toHaveLength(5);
+		vi.advanceTimersByTime(39_999);
+		expect(followUpSends(h)).toHaveLength(5);
+		vi.advanceTimersByTime(1);
+		expect(followUpSends(h)).toHaveLength(6);
+	});
+});
+
+// ── 断言 c：恢复清零退避但不重置总数 ─────────────────
+
+describe("恢复条件：真实工具调用", () => {
+	it("清零退避计数（下一轮立即发），但不重置主判据总次数", async () => {
+		const h = makeHarness();
+		const session = createGoalSession();
+		session.state = makeRunningState();
+
+		// 进入退避：5 轮无进展（4 立即 + 1 延迟）
+		for (let i = 0; i < 4; i++) await runTurn(h, session, { tokenDelta: 200 });
+		await runTurn(h, session, { tokenDelta: 200 });
+		vi.advanceTimersByTime(20_000);
+		expect(followUpSends(h)).toHaveLength(5);
+		expect(session.state!.noProgressTurns).toBe(5);
+
+		// 轮 6：真实工具调用 → 进展 → noProgressTurns 清零，立即发（无定时器）
+		await runTurn(h, session, { tokenDelta: 200, toolCallId: "tc-recover" });
+		expect(session.state!.noProgressTurns).toBe(0);
+		expect(session.continuationTimer).toBeNull();
+		expect(followUpSends(h)).toHaveLength(6); // 同步发出
+		expect(session.state!.continuationsSent).toBe(6); // 总次数不重置（正交性）
+
+		// 轮 7：再次无进展 → 计数从 1 重新累计，间隔回到立即
+		await runTurn(h, session, { tokenDelta: 200 });
+		expect(session.state!.noProgressTurns).toBe(1);
+		expect(followUpSends(h)).toHaveLength(7);
+	});
+});
+
+// ── 断言 d：defer 通知去重 ───────────────────────────
+
+describe("defer 通知去重", () => {
+	it("pending 集合不变的连续 defer 轮中通知条数不增长；集合变化才再发", async () => {
+		const h = makeHarness();
+		const session = createGoalSession();
+		session.state = makeRunningState();
+		h.entries.push(pendingRegisterEntry("bg-1"));
+
+		for (let i = 0; i < 3; i++) {
+			await runTurn(h, session, { tokenDelta: 200 });
+		}
+		expect(followUpSends(h)).toHaveLength(0); // defer 轮不发 continuation
+		const waitNotifies = () => notifyTexts(h).filter((t) => t.includes("waiting"));
+		expect(waitNotifies()).toHaveLength(1); // 集合不变 → 3 轮只通知 1 次
+		expect(waitNotifies()[0]).toContain("1 background task");
+
+		// 集合变化（新增 bg-2）→ 再通知一次（含新计数）
+		h.entries.push(pendingRegisterEntry("bg-2"));
+		await runTurn(h, session, { tokenDelta: 200 });
+		expect(waitNotifies()).toHaveLength(2);
+		expect(waitNotifies()[1]).toContain("2 background task");
+
+		// 集合再次不变 → 不增长
+		await runTurn(h, session, { tokenDelta: 200 });
+		expect(waitNotifies()).toHaveLength(2);
+	});
+});
+
+// ── 恢复通道：/goal resume ───────────────────────────
+
+describe("/goal resume 恢复通道", () => {
+	it("封顶停发后 resume → 熔断计数清零 + 触发 AI + 后续 agent_end 恢复发送", async () => {
+		const h = makeHarness();
+		const session = createGoalSession();
+		// 直接构造封顶临界态（continuationsSent=50），经一次 agent_end 触发停发分支
+		session.state = makeRunningState({ continuationsSent: 50 });
+		await runTurn(h, session, { tokenDelta: 200 });
+		expect(session.state!.continuationCapNotified).toBe(true);
+		expect(followUpSends(h)).toHaveLength(0);
+
+		await handleGoalCommand(h.pi, session, "resume", h.ctx);
+		expect(session.state!.continuationsSent).toBe(0); // 新激活周期
+		expect(session.state!.continuationCapNotified).toBe(false);
+		expect(session.state!.status).toBe("active");
+		const userSends = h.piCalls.filter((c) => c.kind === "sendUser");
+		expect(userSends).toHaveLength(1); // FR-8.12 触发 AI
+
+		// 恢复后：下一次 agent_end 正常发 continuation（新周期额度）
+		await runTurn(h, session, { tokenDelta: 200 });
+		expect(followUpSends(h)).toHaveLength(1);
+	});
+
+	it("未封顶的普通 active goal → resume 提示无需恢复（原语义不变）", async () => {
+		const h = makeHarness();
+		const session = createGoalSession();
+		session.state = makeRunningState();
+
+		await handleGoalCommand(h.pi, session, "resume", h.ctx);
+
+		expect(notifyTexts(h).some((t) => t.includes("no need to resume"))).toBe(true);
+		expect(h.piCalls.filter((c) => c.kind === "sendUser")).toHaveLength(0);
+	});
+});
+
+// ── MF-6（round1 review）：退避 timer 回调跨生命周期防护 ──
+
+/** 进入退避态：4 轮立即发 + 第 5 轮延迟 20s 排定 timer（base 默认 10s ×2） */
+async function enterBackoff(): Promise<{ h: FakeHarness; session: GoalSession }> {
+	const h = makeHarness();
+	const session = createGoalSession();
+	session.state = makeRunningState();
+	for (let i = 0; i < 4; i++) await runTurn(h, session, { tokenDelta: 200 });
+	await runTurn(h, session, { tokenDelta: 200 });
+	expect(session.continuationTimer).not.toBeNull();
+	return { h, session };
+}
+
+describe("MF-6① idle 守卫：ctx.signal 实时求值失效场景由 isIdle 拦截", () => {
+	it("延迟窗内有活动 turn（isIdle=false、signal=undefined）→ 到期不误发", async () => {
+		const { h, session } = await enterBackoff();
+
+		// agent idle 后 SDK get signal 实时求值为 undefined（旧 signal?.aborted 守卫恒放行）；
+		// 用户在延迟窗内发新消息 → 活动 turn 占用 → isIdle=false
+		h.ctx.signal = undefined;
+		h.isIdle.value = false;
+		vi.advanceTimersByTime(20_000);
+
+		expect(followUpSends(h)).toHaveLength(4); // 不误发（该轮 agent_end 会重新决策）
+		expect(session.state!.continuationsSent).toBe(4);
+	});
+
+	it("延迟窗内 idle（isIdle=true、signal=undefined）→ 正常发出（守卫不误伤退避路径）", async () => {
+		const { h, session } = await enterBackoff();
+
+		h.ctx.signal = undefined;
+		vi.advanceTimersByTime(20_000);
+
+		expect(followUpSends(h)).toHaveLength(5);
+		expect(session.state!.continuationsSent).toBe(5);
+	});
+});
+
+describe("MF-6② stale 保护：timer 回调内异常不冒泡（catch 块自身零抛出）", () => {
+	it("全量 stale（isIdle / getEntries / appendEntry 均按 SDK 契约抛错）→ 不崩、不发、不产生任何调用", async () => {
+		const { h, session } = await enterBackoff();
+
+		// SDK 契约（0.84.4 实装核对）：invalidate 后 isIdle / sessionManager getter
+		// （runner.js assertActive）与 pi.appendEntry（loader.js appendEntry 首行
+		// assertActive）全部抛错——旧 fake appendEntry 永不抛，默许了真实场景必抛的调用
+		h.ctx.isIdle = () => {
+			throw new Error(STALE_CTX_MESSAGE);
+		};
+		(h.ctx.sessionManager as { getEntries: () => unknown }).getEntries = () => {
+			throw new Error(STALE_CTX_MESSAGE);
+		};
+		h.appendEntryFails.value = true;
+		const callsBefore = h.piCalls.length;
+
+		expect(() => vi.advanceTimersByTime(20_000)).not.toThrow();
+
+		expect(followUpSends(h)).toHaveLength(4); // 不发 continuation
+		expect(session.state!.continuationsSent).toBe(4);
+		expect(h.piCalls).toHaveLength(callsBefore); // 降级日志 stale 下同样必抛 → 放弃
+	});
+
+	it("回调内非 stale 异常（getEntries 抛运行时错误、appendEntry 可用）→ 降级 warn 落一条", async () => {
+		const { h, session } = await enterBackoff();
+
+		(h.ctx.sessionManager as { getEntries: () => unknown }).getEntries = () => {
+			throw new Error("entries read failed");
+		};
+		expect(() => vi.advanceTimersByTime(20_000)).not.toThrow();
+
+		expect(followUpSends(h)).toHaveLength(4); // 不发 continuation
+		expect(session.state!.continuationsSent).toBe(4);
+		// 降级诊断：非 stale 异常时 pi.appendEntry 可用，goal:log 落一条 warn
+		const dropLogs = h.piCalls.filter(
+			(c) => c.kind === "appendState" && (c.payload as { message?: string } | undefined)?.message?.includes("dropped after error"),
+		);
+		expect(dropLogs).toHaveLength(1);
+		expect((dropLogs[0]!.payload as { level?: string }).level).toBe("warn");
+	});
+});
+
+describe("MF-R2-1 根修：session_shutdown 取消旧退避 timer", () => {
+	it("session_shutdown（invalidate 前触发）后旧 timer 到期不发；全量 stale 下不崩、不冒泡", async () => {
+		const { h, session } = await enterBackoff();
+
+		// SDK 触发序：所有失效路径（reload / new / resume / fork / quit）先 emit
+		// session_shutdown 再 runner.invalidate——此刻 pi/ctx 仍可用
+		await handleSessionShutdown(session);
+		expect(session.continuationTimer).toBeNull();
+
+		// 全量 stale 注入：若 timer 未被取消，回调在 isIdle 首查即抛、catch 内
+		// appendEntry 二次抛出 → advanceTimersByTime 冒泡（本用例即红）
+		h.ctx.isIdle = () => {
+			throw new Error(STALE_CTX_MESSAGE);
+		};
+		(h.ctx.sessionManager as { getEntries: () => unknown }).getEntries = () => {
+			throw new Error(STALE_CTX_MESSAGE);
+		};
+		h.appendEntryFails.value = true;
+		const callsBefore = h.piCalls.length;
+
+		expect(() => vi.advanceTimersByTime(20_000)).not.toThrow();
+		expect(followUpSends(h)).toHaveLength(4); // 不发 continuation
+		expect(session.state!.continuationsSent).toBe(4);
+		expect(h.piCalls).toHaveLength(callsBefore); // 到期零回调（timer 已取消）
+	});
+});
+
+describe("MF-6③ timer 清理面：session_start / before_agent_start 取消旧 timer", () => {
+	it("session_start 重建 → 旧退避 timer 被取消，到期不发", async () => {
+		const { h, session } = await enterBackoff();
+
+		await handleSessionStart(h.pi, session, h.ctx);
+
+		expect(session.continuationTimer).toBeNull();
+		vi.advanceTimersByTime(20_000);
+		expect(followUpSends(h)).toHaveLength(4);
+	});
+
+	it("before_agent_start（新用户活动）→ 旧退避 timer 被取消，到期不发", async () => {
+		const { h, session } = await enterBackoff();
+
+		await handleBeforeAgentStart(h.pi, session, h.ctx);
+
+		expect(session.continuationTimer).toBeNull();
+		vi.advanceTimersByTime(20_000);
+		expect(followUpSends(h)).toHaveLength(4);
+	});
+});

package/src/__tests__/deserialize-state.test.ts

@@ -41,6 +41,12 @@ const goalStateArb = fc.record({
 	lastTurnTokensUsed: fc.nat(),
 	currentTurnIndex: fc.nat(),
 	completedAtTurnIndex: fc.option(fc.nat()),
+	// W5 熔断计数（chat-domain-v1x D4）：round-trip 双向一致性覆盖
+	continuationsSent: fc.nat(),
+	noProgressTurns: fc.nat(),
+	continuationCapNotified: fc.boolean(),
+	lastDeferredPendingIds: fc.array(fc.string()),
+	toolCallsSeen: fc.nat(),
 }) as unknown as fc.Arbitrary<GoalRuntimeState>;
 
 // 旧 entry 模拟（含已废弃 tasks 字段，验证向后兼容忽略）
@@ -115,6 +121,26 @@ describe("deserializeState — optional 字段向后兼容（GAP-4 旧数据）"
 	it("缺 successCriteria → undefined", () => {
 		expect(deserializeState(FULL_DATA).successCriteria).toBeUndefined();
 	});
+	// W5：旧持久化数据（熔断字段引入前）缺 5 个熔断字段 → 归零/空集/false（新周期语义）
+	it("缺 W5 熔断字段 → 计数归零 / 空集合 / flag false", () => {
+		const state = deserializeState(FULL_DATA);
+		expect(state.continuationsSent).toBe(0);
+		expect(state.noProgressTurns).toBe(0);
+		expect(state.continuationCapNotified).toBe(false);
+		expect(state.lastDeferredPendingIds).toEqual([]);
+		expect(state.toolCallsSeen).toBe(0);
+	});
+	it("W5 熔断字段为脏值（负数/非数组）→ 同样归零/空集（防御性默认）", () => {
+		const state = deserializeState({
+			...FULL_DATA,
+			continuationsSent: -3,
+			noProgressTurns: "many" as unknown as number,
+			lastDeferredPendingIds: [1, null] as unknown as string[],
+		});
+		expect(state.continuationsSent).toBe(0);
+		expect(state.noProgressTurns).toBe(0);
+		expect(state.lastDeferredPendingIds).toEqual([]);
+	});
 });
 
 describe("deserializeState — 旧数据迁移（time_limited → budget_limited，MF-1）", () => {

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

@@ -88,7 +88,7 @@ function makeFakeCtx(overrides?: {
 				bold: (text: string) => text,
 			},
 		},
-		sessionManager: { getEntries: () => overrides?.entries ?? [], getBranch: () => undefined },
+		sessionManager: { getEntries: () => overrides?.entries ?? [], getBranch: () => undefined, getSessionId: () => "test-session" },
 	} as unknown as ExtensionContext;
 	return { ctx, calls };
 }

package/src/__tests__/liveness.test.ts

@@ -0,0 +1,162 @@
+/**
+ * engine/liveness.ts 纯函数测试 — 轮次活性熔断判定单元（chat-domain-v1x D4 / W5）
+ *
+ * 覆盖：env 配置解析（合法/非法/缺省）、退避等级数学（第 N 轮起 ×2、指数天花板）、
+ * 进展信号边界、toolCall 块计数（duck-typed 守卫）、pending 集合变化判定。
+ * 行为级四断言（封顶/退避/恢复/defer 去重经 handleAgentEnd）见 circuit-breaker.test.ts。
+ */
+import { describe, expect, it } from "vitest";
+
+import {
+	continuationBackoffDelayMs,
+	countToolCallBlocks,
+	isProgressSignal,
+	nextNoProgressTurns,
+	pendingSetChanged,
+	resolveLivenessConfig,
+	type LivenessConfig,
+} from "../engine/liveness";
+import { createGoalState } from "../engine/goal";
+
+const CFG: LivenessConfig = resolveLivenessConfig({});
+
+// ── resolveLivenessConfig（env 覆盖）──────────────────
+
+describe("resolveLivenessConfig", () => {
+	it("缺省 env → 全默认值（50 / 5 / 1000 / 10s / 10min）", () => {
+		const cfg = resolveLivenessConfig({});
+		expect(cfg.continuationCap).toBe(50);
+		expect(cfg.noProgressTurnsThreshold).toBe(5);
+		expect(cfg.noProgressTokenThreshold).toBe(1000);
+		expect(cfg.backoffBaseMs).toBe(10_000);
+		expect(cfg.backoffMaxMs).toBe(600_000);
+	});
+
+	it("PI_GOAL_* 合法正整数 → 覆盖默认值", () => {
+		const cfg = resolveLivenessConfig({
+			PI_GOAL_CONTINUATION_CAP: "10",
+			PI_GOAL_NO_PROGRESS_TURNS: "3",
+			PI_GOAL_NO_PROGRESS_TOKEN_THRESHOLD: "500",
+			PI_GOAL_BACKOFF_BASE_MS: "1000",
+			PI_GOAL_BACKOFF_MAX_MS: "30000",
+		});
+		expect(cfg.continuationCap).toBe(10);
+		expect(cfg.noProgressTurnsThreshold).toBe(3);
+		expect(cfg.noProgressTokenThreshold).toBe(500);
+		expect(cfg.backoffBaseMs).toBe(1000);
+		expect(cfg.backoffMaxMs).toBe(30000);
+	});
+
+	it.each([
+		["非数字", "abc"],
+		["零", "0"],
+		["负数", "-5"],
+		["小数", "2.7"],
+	])("非法值（%s）→ 回退默认（安全网不因坏配置挂掉）", (_label, raw) => {
+		const cfg = resolveLivenessConfig({ PI_GOAL_CONTINUATION_CAP: raw });
+		expect(cfg.continuationCap).toBe(50);
+	});
+});
+
+// ── 进展信号 + 无进展计数 ────────────────────────────
+
+describe("isProgressSignal / nextNoProgressTurns", () => {
+	it("有工具调用（toolDelta>0）即进展，即使 tokenDelta 低", () => {
+		expect(isProgressSignal(1, 100, CFG)).toBe(true);
+	});
+
+	it("tokenDelta 越阈值即进展，即使无工具调用（纯文本迭代型任务豁免退避）", () => {
+		expect(isProgressSignal(0, 1000, CFG)).toBe(true);
+		expect(isProgressSignal(0, 999, CFG)).toBe(false);
+	});
+
+	it("无进展 → 计数 +1；进展 → 清零", () => {
+		expect(nextNoProgressTurns(4, false)).toBe(5);
+		expect(nextNoProgressTurns(4, true)).toBe(0);
+	});
+});
+
+// ── 退避等级数学 ─────────────────────────────────────
+
+describe("continuationBackoffDelayMs", () => {
+	it("未达阈值（1~4 轮）→ 0（立即发）", () => {
+		expect(continuationBackoffDelayMs(0, CFG)).toBe(0);
+		expect(continuationBackoffDelayMs(4, CFG)).toBe(0);
+	});
+
+	it("第 5 轮起 ×2 递增：5 轮 → 2×base，6 轮 → 4×base，7 轮 → 8×base", () => {
+		expect(continuationBackoffDelayMs(5, CFG)).toBe(20_000);
+		expect(continuationBackoffDelayMs(6, CFG)).toBe(40_000);
+		expect(continuationBackoffDelayMs(7, CFG)).toBe(80_000);
+	});
+
+	it("指数封顶：delay 永不超过 backoffMaxMs", () => {
+		expect(continuationBackoffDelayMs(50, CFG)).toBe(600_000);
+		expect(continuationBackoffDelayMs(1000, CFG)).toBe(600_000);
+	});
+});
+
+// ── toolCall 块计数 ──────────────────────────────────
+
+describe("countToolCallBlocks", () => {
+	it("assistant content 内 toolCall 块计数（多个 entry 累计）", () => {
+		const entries = [
+			{ type: "message", message: { role: "user", content: "hi" } },
+			{
+				type: "message",
+				message: {
+					role: "assistant",
+					content: [
+						{ type: "text", text: "thinking..." },
+						{ type: "toolCall", id: "tc-1", name: "bash" },
+						{ type: "toolCall", id: "tc-2", name: "read" },
+					],
+				},
+			},
+			{
+				type: "message",
+				message: { role: "assistant", content: [{ type: "toolCall", id: "tc-3", name: "bash" }] },
+			},
+			{ type: "message", message: { role: "toolResult", content: [], toolName: "bash", toolCallId: "tc-1" } },
+			{ type: "custom", customType: "goal-state", data: {} },
+		];
+		expect(countToolCallBlocks(entries)).toBe(3);
+	});
+
+	it("畸形 entry（null/非对象/缺 message/content 非数组）→ 跳过不计数", () => {
+		expect(
+			countToolCallBlocks([null, 42, "x", { type: "message" }, { type: "message", message: null }, {
+				type: "message",
+				message: { role: "assistant", content: "plain-string" },
+			}]),
+		).toBe(0);
+	});
+});
+
+// ── pending 集合变化 ─────────────────────────────────
+
+describe("pendingSetChanged", () => {
+	it("集合相同（含顺序不同）→ 无变化", () => {
+		expect(pendingSetChanged(["a", "b"], ["b", "a"])).toBe(false);
+		expect(pendingSetChanged([], [])).toBe(false);
+	});
+
+	it("首次进入 defer（last 为空）或有增删 → 变化", () => {
+		expect(pendingSetChanged(["a"], [])).toBe(true);
+		expect(pendingSetChanged(["a"], ["a", "b"])).toBe(true);
+		expect(pendingSetChanged(["a", "c"], ["a", "b"])).toBe(true);
+	});
+});
+
+// ── createGoalState 初始化 ───────────────────────────
+
+describe("createGoalState — W5 计数初始化", () => {
+	it("新 goal 熔断计数全部从零开始", () => {
+		const state = createGoalState("obj");
+		expect(state.continuationsSent).toBe(0);
+		expect(state.noProgressTurns).toBe(0);
+		expect(state.continuationCapNotified).toBe(false);
+		expect(state.lastDeferredPendingIds).toEqual([]);
+		expect(state.toolCallsSeen).toBe(0);
+	});
+});