@zhushanwen/pi-goal 0.12.2 → 0.13.0

package/src/adapters/command-adapter.ts

@@ -31,7 +31,7 @@ import { updateWidget } from "../projection/widget";
 import { finalizeAndPersist, persistState, tickState } from "../service";
 import type { GoalHistoryEntry } from "../ports";
 import type { GoalSession } from "../session";
-import { clearGoalSession } from "../session";
+import { clearGoalSession, cancelContinuationTimer } from "../session";
 import { buildPorts } from "./ports";
 import { CRITERIA_HINTS_SLASH, validateSuccessCriteriaItems } from "./success-criteria";
 
@@ -122,6 +122,9 @@ function handlePause(pi: ExtensionAPI, session: GoalSession, ctx: ExtensionConte
 	// 先 tickState 累加当前运行段（此时 status 仍为 active）
 	tickState(state);
 	state.status = transitionStatus(state.status, "paused");
+	// W5：用户主动叫停 → 取消待发的退避 continuation（paused 期间不自动续跑；
+	// resume 后由其触发的 user message 重新驱动循环）
+	cancelContinuationTimer(session);
 
 	const ports = buildPorts(pi, ctx);
 	persistState(session, ports);
@@ -141,13 +144,27 @@ function handleResume(pi: ExtensionAPI, session: GoalSession, ctx: ExtensionCont
 		ctx.ui.notify(`Goal is in terminal state (${state.status}), cannot resume.`, "warning");
 		return;
 	}
+	// W5 恢复通道②：active 且 continuation 已封顶停发 → resume 重置熔断计数续跑
+	// （goal 封顶时刻意保持 active 不转终态，续跑决策权在用户）。
+	// 未封顶的普通 active goal 无需 resume（保持原语义）。
+	const cappedActive = state.status === "active" && state.continuationCapNotified;
 	// FR-3: resume 支持 paused→active 和 blocked→active（两者对称，都做 budget 重检 + 触发 AI）
-	if (state.status !== "paused" && state.status !== "blocked") {
+	if (state.status !== "paused" && state.status !== "blocked" && !cappedActive) {
 		ctx.ui.notify("Goal is not paused or blocked, no need to resume.", "info");
 		return;
 	}
-	state.status = "active";
-	state.timeStartedAt = Date.now();
+	if (state.status !== "active") {
+		state.status = "active";
+		state.timeStartedAt = Date.now();
+	}
+	// W5：resume = 新激活周期——熔断计数清零。主判据总次数（continuationsSent）只经
+	// 用户显式 resume 重置，agent 侧任何行为（含每轮调工具）都不可清零（正交性）。
+	state.continuationsSent = 0;
+	state.noProgressTurns = 0;
+	state.continuationCapNotified = false;
+	state.lastDeferredPendingIds = [];
+	// toolCallsSeen 不清零：entries 差分口径跨周期连续（清零会让首轮差分把历史
+	// 调用全算成本轮进展，虚高一次无害但无意义）
 
 	const ports = buildPorts(pi, ctx);
 
@@ -171,8 +188,11 @@ function handleResume(pi: ExtensionAPI, session: GoalSession, ctx: ExtensionCont
 	const blockerNote = state.lastBlockerReason
 		? `\n\nPrevious blocker: ${state.lastBlockerReason}. Try a different approach.`
 		: "";
+	const capNote = cappedActive
+		? "\n\nContinuation circuit breaker was reached — pursue the objective with concrete tool-backed progress."
+		: "";
 	pi.sendUserMessage(
-		`Goal resumed. Continuing toward the objective.${blockerNote}\n\nObjective: ${state.objective}`,
+		`Goal resumed. Continuing toward the objective.${blockerNote}${capNote}\n\nObjective: ${state.objective}`,
 		{ deliverAs: "followUp" },
 	);
 }
@@ -299,6 +319,11 @@ function handleUpdate(
 	state.budgetLimitSteeringSent = false;
 	state.tokenWarning70Sent = false;
 	state.tokenWarning90Sent = false;
+	// W5：重塑 = 新激活周期，熔断计数与 budget flag 同类（cycle-scoped 记账）一并重置
+	state.continuationsSent = 0;
+	state.noProgressTurns = 0;
+	state.continuationCapNotified = false;
+	state.lastDeferredPendingIds = [];
 	// GAP-6: update 是重塑，旧 slug 已不匹配新 objective → 置空（widget fallback objective 截断）
 	state.slug = undefined;
 	// update 重塑后旧 successCriteria 可能不再完全匹配新 objective，但语义内容仍可部分适用。

package/src/adapters/event-adapter.ts

@@ -1,7 +1,7 @@
 /**
  * Event adapter — 薄路由（#4 拆分后）。
  *
- * 5 个事件 handler + 1 个共享辅助拆在 event-handlers/，本文件只做 re-export。
+ * 6 个事件 handler + 1 个共享辅助拆在 event-handlers/，本文件只做 re-export。
  * handler 逻辑见各自文件。pi.on 注册在 index.ts（保持不变）。
  *
  * 行为等价（#4 验收）：handler 逻辑原样搬迁，仅 persistAndUpdate 签名 ports 化
@@ -12,5 +12,6 @@ export { handleAgentEnd } from "./event-handlers/agent-end";
 export { handleBeforeAgentStart } from "./event-handlers/before-agent-start";
 export type { MessageEndLikeEvent } from "./event-handlers/message-end";
 export { handleMessageEnd } from "./event-handlers/message-end";
+export { handleSessionShutdown } from "./event-handlers/session-shutdown";
 export { handleSessionStart } from "./event-handlers/session-start";
 export { handleTurnEnd } from "./event-handlers/turn-end";

package/src/adapters/event-handlers/agent-end.ts

@@ -7,7 +7,8 @@
  * - FR-6.7 ESC 守卫（最关键）：ctx.signal?.aborted → 不发 continuation、不做 budget 检查、
  *   不做任何状态变更，goal 保持 active，等用户下次输入恢复
  *
- * #8 后流程：budget 预警/steering → continuation 去抖。
+ * #8 后流程：budget 预警/steering → continuation 去抖 + 轮次活性熔断（W5：
+ * 连发总次数封顶 + 无进展退避 + defer 通知去重，见 handleContinuation 头注）。
  * agent_end 只做提醒（warning + steering），不做终态转换。
  * 终态转换不在 agent_end——由 persistAndUpdate 兜底（#5 范围，单一检查点）。
  *
@@ -23,12 +24,23 @@ import { countActiveFromEntries } from "@zhushanwen/pi-pending-notifications";
 
 import { checkBudgetOnTurnEnd } from "../../engine/budget";
 import { isActiveStatus, isTerminalStatus } from "../../engine/goal";
+import {
+	type LivenessConfig,
+	continuationBackoffDelayMs,
+	countToolCallBlocks,
+	isContinuationCapped,
+	isProgressSignal,
+	nextNoProgressTurns,
+	pendingSetChanged,
+	resolveLivenessConfig,
+} from "../../engine/liveness";
 import {
 	budgetLimitPrompt,
 	continuationPrompt,
 } from "../../projection/prompts";
 import { persistAndUpdate, tickState } from "../../service";
-import type { GoalSession } from "../../session";
+import { serializeState } from "../../persistence";
+import { cancelContinuationTimer, type GoalSession } from "../../session";
 import type { ServicePorts } from "../../service";
 import { buildPorts } from "../ports";
 import { makeStaleChecker } from "./shared";
@@ -135,13 +147,19 @@ async function handleBudgetChecks(
 }
 
 /**
- * continuation 去抖（budget 预警未拦截时的尾部逻辑）。
+ * continuation 去抖 + 轮次活性熔断（budget 预警未拦截时的尾部逻辑）。
  *
  * - continuation 去抖：tokenDelta=0（空 turn）不发，只 persist
- * - 否则 persist + 发 continuationPrompt
+ * - W5 主判据：continuation 连发总次数封顶（默认 50，PI_GOAL_CONTINUATION_CAP）——
+ *   封顶必停发 + notify 用户 + goal 保持 active（不擅自终态）。与「是否调工具」
+ *   正交：计数只在 deliverContinuation 实发时 +1，绝不被工具调用清零
+ *   （2026-09-08 事故：pending 守卫击穿后 64 分钟 ~320 turn 空转，无任何熔断）。
+ * - W5 辅判据：连续 N 轮（默认 5）无工具调用且 tokenDelta 低于阈值 → continuation
+ *   延迟 base×2^level 发出（间隔 ×2 递增）；真实进展清零退避计数（不动总次数）。
+ * - W5 defer 通知去重：pending 集合不变的连续 defer 轮不重复 notify。
  *
  * 注：maxTurnsReached / stall 自动终态分支随 #6 删除；budget terminal 分支随 #8 删除。
- * 终态转换由 persistAndUpdate 兑底（#5 范围，单一检查点）。
+ * 终态转换由 persistAndUpdate 兜底（#5 范围，单一检查点）。
  */
 async function handleContinuation(
 	pi: ExtensionAPI,
@@ -153,20 +171,24 @@ async function handleContinuation(
 	const state = session.state!;
 	if (checkStale()) return;
 
+	const cfg = resolveLivenessConfig();
+	const entries = ctx.sessionManager.getEntries();
+
 	// FR-8.6: continuation 去抖（空 turn 不发）
 	const tokenDelta = state.tokensUsed - state.lastTurnTokensUsed;
 	state.lastTurnTokensUsed = state.tokensUsed;
-	// 单次 persist（H2 合并：原空 turn/非空 turn 两处重复 persistAndUpdate 提到 if 前统一调用）。
-	// budget 终态检查点在 persistAndUpdate 内部（#5 单一检查点），与调用位置无关——
-	// 合并不影响预算终态触发时机（explorer 论证）。
-	persistAndUpdate(session, ports);
-	if (tokenDelta <= 0) {
-		// 空 turn：已 persist，不发 continuation
-		return;
-	}
-	// 终态守卫：persistAndUpdate 可能把 goal 转为 budget_limited 终态。
-	// 此时不应发 continuation（deliverAs:"followUp" 会触发新 turn，让已耗尽预算的 agent 再跑一轮）。
-	if (isTerminalStatus(state.status)) return;
+
+	// W5 辅判据记账：本 turn（自上次 agent_end 以来）真实工具活动 = toolCall 块差分。
+	// 无进展 → 计数 +1；有进展（工具调用或 tokenDelta 越阈值）→ 清零退避计数
+	// （主判据 continuationsSent 不在此处触碰——正交性）。
+	const toolCallsTotal = countToolCallBlocks(entries);
+	const toolDelta = toolCallsTotal - state.toolCallsSeen;
+	state.toolCallsSeen = toolCallsTotal;
+	state.noProgressTurns = nextNoProgressTurns(
+		state.noProgressTurns,
+		isProgressSignal(toolDelta, tokenDelta, cfg),
+	);
+
 	// pending 守卫：有活跃 background subagent/workflow 时不发 continuation。
 	// 靠 subagent/workflow 完成时 sendMessage({triggerTurn:true,deliverAs:"steer"}) 自然唤醒主 agent；
 	// goal 抢先催会与异步任务完成通知叠加，形成“停不下来”的死循环——continuation 排入
@@ -174,8 +196,15 @@ async function handleContinuation(
 	// 新 turn → 又 agent_end → 又 continuation。
 	// 刻意不校验 expiresAt：长任务 subagent（>1h TTL）完成时仍 triggerTurn 唤醒主 agent，
 	// 按 TTL 判非活跃会让死循环在长任务场景复现。
-	const pendingOps = countActiveFromEntries(ctx.sessionManager.getEntries());
+	// [W4 读侧过滤①消费口] 传当前 session 基准：fork 继承的父级注册残留不进差集
+	// （守卫不幻 defer）；设计 D4「读侧过滤一刀」在本消费口的落地（W6 探针实测
+	// registry-fork-filter.test.ts 证不传则虚增，A9② 验收口径）。
+	const pendingOps = countActiveFromEntries(entries, {
+		currentSessionId: ctx.sessionManager.getSessionId(),
+	});
+	let deferred = false;
 	if (pendingOps.count > 0) {
+		deferred = true;
 		pi.appendEntry("goal:log", {
 			timestamp: Date.now(),
 			level: "debug",
@@ -183,17 +212,144 @@ async function handleContinuation(
 			message: `continuation deferred: ${pendingOps.count} active pending operation(s)`,
 			data: { activePending: pendingOps.count, ids: pendingOps.ids },
 		});
-		// 用户可见反馈：goal 在等待后台任务完成而非卡死（deferred 无反馈时用户只看到
-		// goal active 但无产出，无法区分等待 vs 死循环）。
-		ctx.ui.notify(
-			`Goal waiting for ${pendingOps.count} background task(s) to complete.`,
-			"info",
-		);
+		// W5 defer 通知去重：状态变化（pending 集合变化或首次进入 defer）才 notify——
+		// 事故中每轮 agent_end 都发「Goal waiting for N…」，集合不变时是纯噪音。
+		// 用户可见反馈保留：deferred 无反馈时用户只看到 goal active 但无产出，
+		// 无法区分等待 vs 死循环。
+		if (pendingSetChanged(pendingOps.ids, state.lastDeferredPendingIds)) {
+			ctx.ui.notify(
+				`Goal waiting for ${pendingOps.count} background task(s) to complete.`,
+				"info",
+			);
+			state.lastDeferredPendingIds = [...pendingOps.ids].sort();
+		}
+	} else {
+		// 非 defer 轮清空去重锚：每个等待 episode 的首次 defer 都会通知一次
+		state.lastDeferredPendingIds = [];
+	}
+
+	// 单次 persist（H2 合并）：熔断计数（noProgressTurns / toolCallsSeen /
+	// lastDeferredPendingIds）随同一快照落盘。budget 终态检查点在 persistAndUpdate
+	// 内部（#5 单一检查点），与调用位置无关——合并不影响预算终态触发时机（explorer 论证）。
+	persistAndUpdate(session, ports);
+	if (deferred) {
+		// defer 轮：已 persist + 已去重通知，不发 continuation
 		return;
 	}
-	// 发 continuation（FR-8.7: 去 debounce 后才发）
-	ports.messaging.sendContextMessage(
-		continuationPrompt(state),
-		"followUp",
-	);
+	if (tokenDelta <= 0) {
+		// 空 turn：已 persist，不发 continuation
+		return;
+	}
+	// 终态守卫：persistAndUpdate 可能把 goal 转为 budget_limited 终态。
+	// 此时不应发 continuation（deliverAs:"followUp" 会触发新 turn，让已耗尽预算的 agent 再跑一轮）。
+	if (isTerminalStatus(state.status)) return;
+
+	// W5 主判据：连发总次数封顶（与是否调工具正交——toolDelta 只影响辅判据退避）。
+	// 封顶必停发 + 通知一次（含恢复指引）+ goal 保持 active（不擅自终态）。
+	if (isContinuationCapped(state, cfg)) {
+		if (!state.continuationCapNotified) {
+			state.continuationCapNotified = true;
+			ports.ui.notify(
+				`Goal continuation stopped: ${cfg.continuationCap} continuations sent this cycle without completing (no-progress circuit breaker). The goal stays active. Use /goal resume to continue with a fresh allowance, or /goal clear to stop.`,
+				"warning",
+			);
+			pi.appendEntry("goal:log", {
+				timestamp: Date.now(),
+				level: "info",
+				component: "goal:agent-end",
+				message: `continuation capped: ${state.continuationsSent}/${cfg.continuationCap} sent, stopping (goal stays active; /goal resume resets)`,
+				data: { continuationsSent: state.continuationsSent, cap: cfg.continuationCap },
+			});
+			// 停发标志单独落盘（罕见路径——每激活周期至多一次）：否则下次 persist 前
+			// 进程重启会让停发通知重发一次
+			ports.persistence.appendState(serializeState(state));
+		}
+		return;
+	}
+
+	// W5 辅判据：无进展退避。到决策点先取消旧的待发退避 continuation——等待期内若
+	// 有外部驱动的 turn（用户输入 / 后台任务通知唤醒）到达这里，按最新状态重算：
+	// 有进展 → 立即发；仍无进展 → 按当前等级重排。保证任意时刻至多一个待发。
+	cancelContinuationTimer(session);
+
+	const delayMs = continuationBackoffDelayMs(state.noProgressTurns, cfg);
+	if (delayMs <= 0) {
+		deliverContinuation(ports, session);
+		return;
+	}
+	pi.appendEntry("goal:log", {
+		timestamp: Date.now(),
+		level: "debug",
+		component: "goal:agent-end",
+		message: `continuation delayed by backoff: ${delayMs}ms (no-progress turns: ${state.noProgressTurns})`,
+		data: { delayMs, noProgressTurns: state.noProgressTurns },
+	});
+	const goalId = state.goalId;
+	session.continuationTimer = setTimeout(() => {
+		session.continuationTimer = null;
+		// MF-6②：timer 回调跨生命周期持有本次 agent_end 的 ctx/ports 闭包，且不在
+		// pi runner 的 handler 错误隔离范围内——回调内同步异常 = uncaughtException，
+		// 可能带崩 pi 进程。整体 try/catch：stale ctx（session 关闭/替换后 ctx 的
+		// isIdle / sessionManager getter 走 assertActive 抛错，development-guide
+		// §11.1）等异常降级为一条 goal:log 记录后放弃，goal 状态仍在盘上，后续任意
+		// agent_end 会重新决策。（正常运行时路径的兜底：session_shutdown 已在
+		// invalidate 前取消旧 timer，stale 到期属极端残留场景。）
+		try {
+			fireBackoffContinuation(session, ports, ctx, cfg, goalId);
+		} catch (err) {
+			// MF-R2-1 兜底：pi.appendEntry 与 ctx 同生命周期（loader.js appendEntry
+			// 首行 assertActive，0.84.4 实装核对）——stale 场景此调用同样必抛，
+			// 故降级日志自包 try/catch，保证 catch 块自身零抛出。放弃日志无害：
+			// goal 状态在盘上，后续任意 agent_end 会重新决策。
+			try {
+				pi.appendEntry("goal:log", {
+					timestamp: Date.now(),
+					level: "warn",
+					component: "goal:agent-end",
+					message: `backoff continuation dropped after error: ${String(err)}`,
+				});
+			} catch (logErr) {
+				// 刻意放弃：appendEntry（goal:log 落盘通道）自身失效的场景（stale /
+				// runtime 失效）下再调任何 runtime 方法都会二次抛出——本 catch 存在的
+				// 意义即阻断该 uncaughtException 路径。void 显式忽略，对齐
+				// extension-logger 内部 appendEntry 失败兜底的既定惯例。
+				void logErr;
+			}
+		}
+	}, delayMs);
+}
+
+/**
+ * 退避 timer 到期后的发射前守卫 + 实发（延迟期间状态可能已变）：
+ * - goal 未被覆盖/清除（goalId 比对）、仍 active
+ * - MF-6① idle 守卫：ctx.signal 为实时求值（pi-agent-core agent.js get signal 返回
+ *   activeRun?.abortController.signal），agent idle 后恒 undefined，`signal?.aborted`
+ *   恒放行、不可作守卫；改用 ctx.isIdle()（SDK types.d.ts L232）——延迟窗内有活动
+ *   turn 时不发，该轮 agent_end 会按最新状态重新决策
+ * - 未封顶、无活跃 pending（等待期新出现的后台任务由其完成通知唤醒，goal 不抢先催）
+ */
+function fireBackoffContinuation(
+	session: GoalSession,
+	ports: ServicePorts,
+	ctx: ExtensionContext,
+	cfg: LivenessConfig,
+	goalId: string,
+): void {
+	if (!session.state || session.state.goalId !== goalId) return;
+	if (!isActiveStatus(session.state.status)) return;
+	if (!ctx.isIdle()) return;
+	if (isContinuationCapped(session.state, cfg)) return;
+	if (countActiveFromEntries(ctx.sessionManager.getEntries(), { currentSessionId: ctx.sessionManager.getSessionId() }).count > 0) return;
+	deliverContinuation(ports, session);
+}
+
+/**
+ * 发出一次 continuation 并立即落盘计数（主判据只在实发时 +1，发出即持久化——
+ * 崩溃后封顶计数不从零开始）。
+ */
+function deliverContinuation(ports: ServicePorts, session: GoalSession): void {
+	const state = session.state!;
+	state.continuationsSent += 1;
+	ports.messaging.sendContextMessage(continuationPrompt(state), "followUp");
+	ports.persistence.appendState(serializeState(state));
 }

package/src/adapters/event-handlers/before-agent-start.ts

@@ -22,7 +22,7 @@ import { isActiveStatus, isTerminalStatus } from "../../engine/goal";
 import { contextInjectionPrompt } from "../../projection/prompts";
 import { asTheme, renderTerminalStatusLine } from "../../projection/widget";
 import type { GoalSession } from "../../session";
-import { clearGoalSession } from "../../session";
+import { cancelContinuationTimer, clearGoalSession } from "../../session";
 import { buildPorts } from "../ports";
 
 interface BeforeAgentStartResult {
@@ -38,6 +38,10 @@ export async function handleBeforeAgentStart(
 	session: GoalSession,
 	ctx: ExtensionContext,
 ): Promise<BeforeAgentStartResult | undefined> {
+	// MF-6③：新用户活动（新 turn 开始）使旧的退避 continuation 作废——该轮
+	// agent_end 会按最新状态重新决策。放在 state 检查之前：即使 goal 已清，
+	// 旧 timer 也不该在新 turn 开始后仍存活
+	cancelContinuationTimer(session);
 	if (!session.state) return;
 
 	pi.appendEntry("goal:log", {

package/src/adapters/event-handlers/session-shutdown.ts

@@ -0,0 +1,23 @@
+/**
+ * 事件 7: session_shutdown（MF-R2-1 根修：invalidate 前取消旧退避 timer）。
+ *
+ * SDK 触发序（@earendil-works/pi-coding-agent 0.84.4 实装核对）——所有使旧
+ * runner 失效的路径都先 emit session_shutdown 再 invalidate，此刻 pi/ctx 仍可用：
+ * - reload：agent-session.js（emit → oldRunner.invalidate()）
+ * - new / resume / fork 替换：agent-session-runtime.js teardownCurrent
+ *   （emit → session.dispose() 内 invalidate）
+ * - quit：agent-session-runtime.js dispose（emit → session.dispose()）
+ *
+ * 此处取消待发的退避 continuation timer。不清理则旧 timer 携旧 ctx/ports 闭包
+ * 存活到至多 600s：stale 后回调内访问 ctx（isIdle / sessionManager getter 走
+ * assertActive）必抛，catch 内降级日志 pi.appendEntry 同生命周期（loader.js
+ * appendEntry 首行 assertActive）二次必抛——timer 回调不在 pi runner handler
+ * 错误隔离范围内，同步异常 = uncaughtException，可能带崩 pi 进程。
+ */
+
+import type { GoalSession } from "../../session";
+import { cancelContinuationTimer } from "../../session";
+
+export async function handleSessionShutdown(session: GoalSession): Promise<void> {
+	cancelContinuationTimer(session);
+}

package/src/adapters/event-handlers/session-start.ts

@@ -8,7 +8,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 
 import { updateWidget } from "../../projection/widget";
 import type { GoalSession } from "../../session";
-import { reconstructGoalState } from "../../session";
+import { cancelContinuationTimer, reconstructGoalState } from "../../session";
 import { buildPorts } from "../ports";
 
 export async function handleSessionStart(
@@ -16,6 +16,9 @@ export async function handleSessionStart(
 	session: GoalSession,
 	ctx: ExtensionContext,
 ): Promise<void> {
+	// MF-6③：session 句柄跨 session 复用，新 session 生命周期开始时上一 session
+	// 遗留的退避 timer 作废（不清理则旧 timer 携旧 ctx 闭包存活至多 600s）
+	cancelContinuationTimer(session);
 	const ports = buildPorts(pi, ctx);
 	reconstructGoalState(session, ports.session);
 	if (session.state) {

package/src/constants.ts

@@ -35,3 +35,16 @@ export const TOKEN_K_THRESHOLD = 1000;     // token 数 ≥ 此值时缩写为 k
 
 export const AUTO_CLEAR_TURNS = 2;				// 终态后自动清理轮数
 export const MAX_HISTORY_ENTRIES = 20;			// goal-history entry GC 上限
+
+// ── 轮次活性熔断（chat-domain-v1x D4 / W5）─────────────
+//
+// 事故背景（2026-09-08，64 分钟 ~320 turn 空转烧 2.93M token）：pending 守卫被
+// 「等待已注销的后台任务」击穿后，goal 每轮注入 continuation、主 agent 每轮回一句
+// 等待，无任何无进展熔断。双维度封顶：主判据总量上限（与是否调工具正交，不可被
+// 任何目标行为绕过）+ 辅判据无进展退避（间隔 ×2 递增）。全部可经 PI_GOAL_* env 覆盖。
+
+export const DEFAULT_CONTINUATION_CAP = 50;              // 主判据：单激活周期 continuation 连发总次数上限（封顶必停发）
+export const DEFAULT_NO_PROGRESS_TURNS = 5;              // 辅判据：连续无进展轮数阈值（第 N 轮起退避间隔翻倍）
+export const DEFAULT_NO_PROGRESS_TOKEN_THRESHOLD = 1000; // 辅判据：tokenDelta 低于此值视为低产出（一句「等待」量级）
+export const DEFAULT_BACKOFF_BASE_MS = 10_000;           // 辅判据：退避基础间隔（×2 递增的基数）
+export const DEFAULT_BACKOFF_MAX_MS = 600_000;           // 辅判据：退避间隔上限（指数天花板，防止级数失控）

package/src/engine/goal.ts

@@ -58,5 +58,11 @@ export function createGoalState(
 		tokenWarning90Sent: false,
 		lastTurnTokensUsed: 0,
 		currentTurnIndex: 0,
+		// W5 熔断计数从零开始（chat-domain-v1x D4）
+		continuationsSent: 0,
+		noProgressTurns: 0,
+		continuationCapNotified: false,
+		lastDeferredPendingIds: [],
+		toolCallsSeen: 0,
 	};
 }

package/src/engine/liveness.ts

@@ -0,0 +1,150 @@
+/**
+ * 轮次活性熔断 — 纯函数（chat-domain-v1x 设计 §3.2 D4 / W5）
+ *
+ * 双维度互补（非二选一，职责不同）：
+ * - 主判据：continuation 连发总次数独立上限。与「是否调工具」正交——计数绝不能被
+ *   工具调用清零（设计 R1 击穿记录：旧提案「任何一轮有工具调用即清零」可被
+ *   「每轮调一次 subagents list + 回一句等待」打成永不熔断）。清零只经用户显式
+ *   /goal resume（新激活周期）。
+ * - 辅判据：无进展退避。连续 N 轮无工具调用且 tokenDelta 低于阈值 → continuation
+ *   间隔 ×2 递增；恢复 = 真实工具调用或 tokenDelta 越阈值（只清零退避计数）。
+ *
+ * 零 Pi 依赖（engine 层契约）。所有判定输入由调用方（agent-end）采集传入。
+ */
+
+import {
+	DEFAULT_BACKOFF_BASE_MS,
+	DEFAULT_BACKOFF_MAX_MS,
+	DEFAULT_CONTINUATION_CAP,
+	DEFAULT_NO_PROGRESS_TOKEN_THRESHOLD,
+	DEFAULT_NO_PROGRESS_TURNS,
+} from "../constants";
+import type { GoalRuntimeState } from "./types";
+
+// ── 配置（env 可覆盖）─────────────────────────────────
+
+export interface LivenessConfig {
+	/** 主判据：单激活周期 continuation 连发总次数上限 */
+	continuationCap: number;
+	/** 辅判据：连续无进展轮数阈值（第 N 轮起退避） */
+	noProgressTurnsThreshold: number;
+	/** 辅判据：tokenDelta 低于此值视为低产出 */
+	noProgressTokenThreshold: number;
+	/** 辅判据：退避基础间隔 ms（×2 递增的基数） */
+	backoffBaseMs: number;
+	/** 辅判据：退避间隔上限 ms（指数天花板） */
+	backoffMaxMs: number;
+}
+
+/**
+ * 从 env 解析熔断配置（PI_GOAL_* 前缀，对齐 subagent-workflow 的 PI_SUBAGENT_* 风格）。
+ *
+ * 非法值（非数字 / 非正整数）一律回退默认值——熔断参数是安全网，坏配置降级为
+ * 默认而非抛错挂掉 goal 循环。env 参数注入便于单测，不 mock 全局 process.env。
+ */
+export function resolveLivenessConfig(env: NodeJS.ProcessEnv = process.env): LivenessConfig {
+	return {
+		continuationCap: positiveIntEnv(env.PI_GOAL_CONTINUATION_CAP, DEFAULT_CONTINUATION_CAP),
+		noProgressTurnsThreshold: positiveIntEnv(
+			env.PI_GOAL_NO_PROGRESS_TURNS,
+			DEFAULT_NO_PROGRESS_TURNS,
+		),
+		noProgressTokenThreshold: positiveIntEnv(
+			env.PI_GOAL_NO_PROGRESS_TOKEN_THRESHOLD,
+			DEFAULT_NO_PROGRESS_TOKEN_THRESHOLD,
+		),
+		backoffBaseMs: positiveIntEnv(env.PI_GOAL_BACKOFF_BASE_MS, DEFAULT_BACKOFF_BASE_MS),
+		backoffMaxMs: positiveIntEnv(env.PI_GOAL_BACKOFF_MAX_MS, DEFAULT_BACKOFF_MAX_MS),
+	};
+}
+
+function positiveIntEnv(raw: string | undefined, fallback: number): number {
+	if (raw === undefined) return fallback;
+	// Number + isInteger（而非 parseInt）：parseInt 会把 "2.7" 截断成 2 静默放行
+	const parsed = Number(raw);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+// ── 工具活动检测（辅判据输入）─────────────────────────
+
+/** 退避乘数：间隔 = base × MULTIPLIER^level（设计语义「×2 递增」）。 */
+const BACKOFF_MULTIPLIER = 2;
+
+/**
+ * 统计 session entries 中 assistant message content 里的 toolCall 块总数。
+ *
+ * pi 的工具调用落在 type="message"、role="assistant" 的 entry，content 数组内
+ * `{type:"toolCall", id, name, arguments}` block（session-reader probe 实测 519/519，
+ * message.toolCalls 顶层字段从未存在）。这里只数块个数——调用方以「相邻两次
+ * agent_end 的差分」判定本 turn 是否有真实工具活动，不需要 name/arguments。
+ *
+ * duck-typed 逐层守卫（对齐 pending-notifications state.ts 的 EntryLike 风格），
+ * 不依赖 SDK 具体类型；畸形 entry 跳过不计。
+ */
+export function countToolCallBlocks(entries: unknown[]): number {
+	let count = 0;
+	for (const raw of entries) {
+		if (!raw || typeof raw !== "object") continue;
+		// 断言目标带必填 unknown 字段（typeof object 已守卫），非全可选形状
+		const entry = raw as { type: unknown; message: unknown };
+		if (entry.type !== "message") continue;
+		if (!entry.message || typeof entry.message !== "object") continue;
+		const message = entry.message as { role: unknown; content: unknown };
+		if (message.role !== "assistant") continue;
+		if (!Array.isArray(message.content)) continue;
+		for (const block of message.content) {
+			if (block && typeof block === "object" && (block as { type: unknown }).type === "toolCall") {
+				count++;
+			}
+		}
+	}
+	return count;
+}
+
+// ── 辅判据：无进展判定与退避 ─────────────────────────
+
+/**
+ * 本轮是否有真实进展：出现工具调用（toolDelta>0）或 tokenDelta 越阈值。
+ *
+ * 两者任一即进展——纯文本迭代型任务（长文起草）每轮合法无工具调用，但 tokenDelta
+ * 高（整段重写），不应被退避拖慢；事故形态（每轮回一句「等待」）则两者皆无。
+ */
+export function isProgressSignal(toolDelta: number, tokenDelta: number, cfg: LivenessConfig): boolean {
+	return toolDelta > 0 || tokenDelta >= cfg.noProgressTokenThreshold;
+}
+
+/** 无进展 → 计数 +1；有进展 → 清零（只清退避计数，主判据总数不动）。 */
+export function nextNoProgressTurns(current: number, progress: boolean): number {
+	return progress ? 0 : current + 1;
+}
+
+/**
+ * 退避等级：连续无进展轮数达到阈值（默认 5）的第 N 轮起 level=1，此后每多一轮 +1。
+ * 间隔 = base × 2^level（第 5 轮起 ×2，第 6 轮 ×4，…），封顶 backoffMaxMs。
+ */
+export function continuationBackoffDelayMs(noProgressTurns: number, cfg: LivenessConfig): number {
+	const level = Math.max(0, noProgressTurns - cfg.noProgressTurnsThreshold + 1);
+	if (level <= 0) return 0;
+	return Math.min(cfg.backoffBaseMs * BACKOFF_MULTIPLIER ** level, cfg.backoffMaxMs);
+}
+
+// ── 主判据：连发总次数封顶 ───────────────────────────
+
+/** 是否已达连发总次数上限（封顶后必停发，goal 保持 active 等用户 /goal resume）。 */
+export function isContinuationCapped(state: GoalRuntimeState, cfg: LivenessConfig): boolean {
+	return state.continuationsSent >= cfg.continuationCap;
+}
+
+// ── defer 通知去重 ───────────────────────────────────
+
+/**
+ * 活跃 pending 集合是否发生变化（顺序无关）。
+ *
+ * defer 分支的用户通知只在「集合变化或首次进入 defer」时发——事故中每轮 agent_end
+ * 都 notify「Goal waiting for N task(s)」，pending 集合不变时是纯噪音。
+ */
+export function pendingSetChanged(current: readonly string[], last: readonly string[]): boolean {
+	if (current.length !== last.length) return true;
+	const lastSet = new Set(last);
+	return current.some((id) => !lastSet.has(id));
+}

package/src/engine/types.ts

@@ -81,4 +81,25 @@ export interface GoalRuntimeState {
 	lastTurnTokensUsed: number;
 	currentTurnIndex: number;
 	completedAtTurnIndex?: number;
+	// ── 轮次活性熔断计数（chat-domain-v1x D4 / W5，随 state 持久化）──
+	/**
+	 * 主判据：本激活周期累计发出的 continuation 次数。封顶（LivenessConfig.continuationCap）
+	 * 必停发。与「是否调工具」正交——任何路径不得因工具调用清零；唯一重置点 = 用户
+	 * 显式 /goal resume（新激活周期）。旧持久化数据无此字段，deserialize 默认 0。
+	 */
+	continuationsSent: number;
+	/**
+	 * 辅判据：连续无进展轮数（无工具调用且 tokenDelta 低于阈值）。达到阈值起退避
+	 * 间隔 ×2 递增；出现真实进展即清零（只清退避计数，不动 continuationsSent）。
+	 */
+	noProgressTurns: number;
+	/** 封顶停发通知只发一次的锚点（resume 时复位）。 */
+	continuationCapNotified: boolean;
+	/** defer 通知去重锚：最近一次 defer 时的活跃 pending id 集合（排序后快照）。 */
+	lastDeferredPendingIds: string[];
+	/**
+	 * session entries 内 assistant toolCall 块的累计数。相邻两次 agent_end 的差分 =
+	 * 本 turn 的真实工具活动（辅判据输入）。随 state 持久化以在重启后保持差分口径。
+	 */
+	toolCallsSeen: number;
 }