@tea-agent/loop-agent 0.39.0-beta.13 → 0.39.0-beta.14

package/CHANGELOG.md

@@ -1,6 +1,7 @@
 # 更新日志
 
 ## [Unreleased]
+- 0.39.0-beta.14（frontend-node dogfood）：plan-pi 三段分段会话 + coverage 需求批次切片（4/批、零进度减半）、finalize 收据修复环（聚合诊断+修复 JSON）、record_* 边界校验左移（VT 重复/writeSet/交互 VT 引用/规范需求 id/可疑 symbol）、编译装配 last-wins（组件按 purpose 去重修正）、review-context 授权面扩展至 VT 测试文件、设计评审修订降级为 admission advisory。
 - 前端 DAG 极端环境加固（16KB 输出 / 120KB 上下文真实冒烟，r2-r5 验证）：`frontend-contract-pi` 改为消费编译后的 ledger 输入块（`<frontend_contract_input>`，12KB 上限、cap ladder、requirement id 永不丢）并移除 read 工具，以增量 `record_*` 提交为唯一输出模式（OUTPUT BUDGET DISCIPLINE），修复极端小输出窗口下模型反复 read 源文件空转 1h54m 超时的问题（r3 起 contract 3m54s 正常完成、37 次 record_* / 0 次 read）；plan/contract 的 `record_*` 工具支持每 message 最多 5 条批量提交并加 1s 调用间隔，rate-limit 退避上限提高到 60s，缓解密集小调用触发第三方网关限流；修复 fragment-inventory 对 V4 标题式 AC（`#### AC-NNN`）的双重 emit 缺陷（同一标题行被 section 入口与正文 heading 分支各切一次，30 个 AC 结构性产生 30 个 duplicate）。
 
 - 修复连续 `dag rerun-task` 丢失前代评审意见的问题：直接父 run 未走到 review/design review 时，`deriveDagRerunFeedback` 沿 run-owned lineage 有界追溯最近 5 层并继承最近的 committed typed findings；较近的 `approve_review` / `approve_design` 作为对应 resolution barrier，防止已解决 finding 被复活。lineage run ID、生命周期目录与 `state.json.runId` 必须一致，损坏、越界、循环或超深链路 fail closed。

package/dist/application/task-lifecycle/advance.js

@@ -260,6 +260,10 @@ async function monitorRun(input) {
         failureCategory: "monitor-timeout",
     });
 }
+function isStartupGateEligible(snapshot) {
+    const status = snapshot.source?.sourceFidelityStartup?.status;
+    return status === undefined || status === "complete" || status === "not-applicable";
+}
 function nextMutationAction(actions) {
     for (const action of actions) {
         if (action.type !== "stop")
@@ -379,7 +383,10 @@ export async function advanceTaskLifecycle(input) {
             };
         }
         const token = parseGateToken(input.rejectGateToken);
-        const currentGate = snapshot.gate ?? (await buildCurrentGate(input.repoRoot, input.taskId));
+        const currentGate = snapshot.gate ??
+            (isStartupGateEligible(snapshot)
+                ? await buildCurrentGate(input.repoRoot, input.taskId)
+                : null);
         if (!currentGate || !gateMatches(currentGate, token)) {
             return {
                 taskId: input.taskId,
@@ -443,11 +450,12 @@ export async function advanceTaskLifecycle(input) {
         dryRun,
         skipFinalize: Boolean(input.skipFinalize),
         forcePrepareContract: Boolean(input.fromDraftPath) && !preparedContractThisCall,
+        startupRepairAttempted: preparedContractThisCall,
     });
     if (dryRun) {
         const plan = planOnce(snapshot);
         const plannedGate = snapshot.gate ??
-            (snapshot.dagDraft?.exists
+            (isStartupGateEligible(snapshot) && snapshot.dagDraft?.exists
                 ? await buildCurrentGate(input.repoRoot, input.taskId)
                 : null);
         return {
@@ -586,6 +594,10 @@ export async function advanceTaskLifecycle(input) {
             continue;
         }
         if (action.type === "prepare-contract") {
+            const startupStatus = snapshot.source?.sourceFidelityStartup?.status;
+            const startupRepairAction = startupStatus === "missing" ||
+                startupStatus === "invalid" ||
+                startupStatus === "coverage-incomplete";
             // 生产 source fidelity Pi 接线（AC-PROD-001/005）：仅 frontend-implementation
             // 任务注入 reconcile executor + 独立 reviewer；ineligible 返回 undefined 不接线。
             // 主路径与 semantic-intake retry 路径共用同一接线，保证任意一条生产路径都实际
@@ -731,7 +743,9 @@ export async function advanceTaskLifecycle(input) {
                                     message: "structured requirement draft via semantic intake; projected managed source",
                                 });
                                 preparedContractThisCall = true;
-                                if (refreshManagedContractThisCall || input.fromDraftPath) {
+                                if (startupRepairAction ||
+                                    refreshManagedContractThisCall ||
+                                    input.fromDraftPath) {
                                     refreshManagedContractThisCall = false;
                                     regenerateDagThisCall = true;
                                 }
@@ -825,7 +839,9 @@ export async function advanceTaskLifecycle(input) {
                 break;
             }
             preparedContractThisCall = true;
-            if (refreshManagedContractThisCall || input.fromDraftPath) {
+            if (startupRepairAction ||
+                refreshManagedContractThisCall ||
+                input.fromDraftPath) {
                 // The old DAG and gate were bound to the pre-mutation contract.
                 refreshManagedContractThisCall = false;
                 regenerateDagThisCall = true;

package/dist/application/task-lifecycle/observe.js

@@ -1,9 +1,11 @@
-import { access, readFile } from "node:fs/promises";
+import { access, readFile, readdir } from "node:fs/promises";
 import path from "node:path";
 import { getTaskDir, getTaskPaths, getTaskStatus, loadTaskConfig, } from "../../task/runtime.js";
 import { logicalRevisionForState, observeTaskContractState, } from "../../task/contract/index.js";
 import { assessDagRunLiveness, listAllDagRunEntries, readDagRunSpec, readDagRunState, } from "../../workflows/dag/lifecycle.js";
 import { resolveRunningControllerIdentity } from "../../shared/package-metadata.js";
+import { parseLedgerJson, validateRequirementLedger, } from "../../task/source-prepare/ledger.js";
+import { REQUIREMENT_LEDGER_FILE_NAME } from "../../task/source-prepare/types.js";
 import { loadLifecycleRecord } from "./record.js";
 import { buildGateBinding, buildWriteSetGate, buildWriteSetGateDelta, controllerIdentityAnchor, hashCanonicalPayload, normalizeWriteSet, sha256Hex, } from "./gates.js";
 async function exists(filePath) {
@@ -47,6 +49,140 @@ async function taskExists(repoRoot, taskId) {
     const paths = getTaskPaths(repoRoot, taskId);
     return exists(paths.taskConfigPath);
 }
+async function assessReferenceEvidence(referencesDir) {
+    try {
+        const entries = await readdir(referencesDir);
+        const importedPrdCount = entries.filter((name) => name.endsWith(".md")).length;
+        return importedPrdCount > 0
+            ? { status: "present", importedPrdCount }
+            : { status: "absent-or-empty", importedPrdCount: 0 };
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return { status: "absent-or-empty", importedPrdCount: 0 };
+        }
+        return {
+            status: "unknown",
+            importedPrdCount: 0,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function hasLedgerStructure(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const ledger = value;
+    return (typeof ledger.taskId === "string" &&
+        typeof ledger.inputDigest === "string" &&
+        typeof ledger.requirementSha256 === "string" &&
+        Array.isArray(ledger.sourcePaths) &&
+        Array.isArray(ledger.fragments) &&
+        Array.isArray(ledger.canonicalRequirements) &&
+        Boolean(ledger.stats && typeof ledger.stats === "object") &&
+        Array.isArray(ledger.unresolved) &&
+        Array.isArray(ledger.conflicts) &&
+        Array.isArray(ledger.sourceResolutions) &&
+        typeof ledger.schemaReconcilerVersion === "string" &&
+        typeof ledger.builtAt === "string");
+}
+async function assessSourceFidelityStartup(input) {
+    if (!input.applicable) {
+        return {
+            status: "not-applicable",
+            ledgerPath: input.ledgerPath,
+            diagnostics: [],
+        };
+    }
+    if (input.referenceEvidenceError) {
+        return {
+            status: "invalid",
+            ledgerPath: input.ledgerPath,
+            diagnostics: [
+                {
+                    code: "SOURCE_FIDELITY_LEDGER_STALE",
+                    message: `imported PRD reference evidence is unreadable: ${input.referenceEvidenceError}`,
+                },
+            ],
+        };
+    }
+    let raw;
+    try {
+        raw = await readFile(input.ledgerPath, "utf-8");
+    }
+    catch (error) {
+        const missing = !(await exists(input.ledgerPath));
+        return {
+            status: missing ? "missing" : "invalid",
+            ledgerPath: input.ledgerPath,
+            diagnostics: [
+                {
+                    code: missing
+                        ? "SOURCE_FIDELITY_LEDGER_MISSING"
+                        : "SOURCE_FIDELITY_LEDGER_STALE",
+                    message: missing
+                        ? "managed frontend task has no requirement-ledger.json"
+                        : `requirement ledger is unreadable: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+        };
+    }
+    try {
+        const ledger = parseLedgerJson(raw);
+        if (!hasLedgerStructure(ledger)) {
+            return {
+                status: "invalid",
+                ledgerPath: input.ledgerPath,
+                diagnostics: [
+                    {
+                        code: "SOURCE_FIDELITY_LEDGER_STALE",
+                        message: "requirement ledger is missing required structural fields",
+                    },
+                ],
+            };
+        }
+        const nonDecisionErrors = validateRequirementLedger(ledger, {
+            allowedUnresolved: true,
+            allowedConflicts: true,
+        });
+        if (nonDecisionErrors.length > 0) {
+            const coverageCodes = new Set([
+                "SOURCE_FIDELITY_HIGH_RISK_UNCOVERED",
+                "SOURCE_FIDELITY_REQUIREMENT_NOT_COVERED",
+            ]);
+            return {
+                status: nonDecisionErrors.every((error) => coverageCodes.has(error.code))
+                    ? "coverage-incomplete"
+                    : "invalid",
+                ledgerPath: input.ledgerPath,
+                diagnostics: nonDecisionErrors,
+            };
+        }
+        const decisionErrors = validateRequirementLedger(ledger);
+        if (decisionErrors.length > 0) {
+            return {
+                status: "human-decision-blocked",
+                ledgerPath: input.ledgerPath,
+                diagnostics: decisionErrors,
+            };
+        }
+        return { status: "complete", ledgerPath: input.ledgerPath, diagnostics: [] };
+    }
+    catch (error) {
+        return {
+            status: "invalid",
+            ledgerPath: input.ledgerPath,
+            diagnostics: [
+                {
+                    code: "SOURCE_FIDELITY_LEDGER_STALE",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            ],
+        };
+    }
+}
 /**
  * Explicit Task↔DAG association only:
  * - lifecycle.json recorded runAssociations
@@ -182,10 +318,12 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
     const record = await loadLifecycleRecord(repoRoot, taskId);
     const contractState = await observeTaskContractState(repoRoot, taskId);
     let title;
+    let taskKind;
     let taskConfigAllowed = [];
     try {
         const config = await loadTaskConfig(repoRoot, taskId);
         title = config.title;
+        taskKind = config.taskKind;
         taskConfigAllowed = config.allowedPaths ?? [];
     }
     catch {
@@ -199,19 +337,22 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
         ...(requirementReady ? [] : [requirementPath]),
         ...(constraintsReady ? [] : [constraintsPath]),
     ];
-    let importedPrdCount = 0;
+    const contractManaged = contractState.effectiveStatus === "managed" || Boolean(contractState.ref);
     const referencesDir = path.join(paths.sourceDir, "references");
-    if (await exists(referencesDir)) {
-        // Count is best-effort; absence is fine.
-        try {
-            const { readdir } = await import("node:fs/promises");
-            const entries = await readdir(referencesDir);
-            importedPrdCount = entries.filter((name) => name.endsWith(".md")).length;
-        }
-        catch {
-            importedPrdCount = 0;
-        }
-    }
+    const referenceEvidence = await assessReferenceEvidence(referencesDir);
+    const importedPrdCount = referenceEvidence.importedPrdCount;
+    const ledgerPath = path.join(paths.sourceDir, REQUIREMENT_LEDGER_FILE_NAME);
+    const sourceFidelityStartup = await assessSourceFidelityStartup({
+        ledgerPath,
+        applicable: contractManaged &&
+            taskKind === "frontend-implementation" &&
+            referenceEvidence.status !== "absent-or-empty",
+        referenceEvidenceError: referenceEvidence.status === "unknown"
+            ? referenceEvidence.error
+            : undefined,
+    });
+    const sourceFidelityReady = sourceFidelityStartup.status === "complete" ||
+        sourceFidelityStartup.status === "not-applicable";
     const dagDraftPath = paths.dagDraftPath;
     const dagDraftExists = await exists(dagDraftPath);
     let specHash = null;
@@ -285,7 +426,11 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
     // Open gate only when draft is strict-validated and the current binding is
     // not already approved/rejected. Rejected same-digest gates stay closed
     // until contract/source/DAG/writeSet/controller binding changes.
-    const gate = gateBound && strictValidated && !approvedCurrent && !rejectedCurrent
+    const gate = gateBound &&
+        strictValidated &&
+        sourceFidelityReady &&
+        !approvedCurrent &&
+        !rejectedCurrent
         ? buildWriteSetGate({ taskId, bound: gateBound, delta: gateDelta })
         : null;
     const gateOpen = Boolean(gate);
@@ -310,11 +455,10 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
                 activeRun.failureCategory === "needs-attention" ||
                 activeRun.failureCategory === "suspected-stall" ||
                 activeRun.failureCategory === "monitor-timeout"));
-    const contractManaged = contractState.effectiveStatus === "managed" || Boolean(contractState.ref);
     const lifecycleState = deriveLifecycleState({
         exists: true,
         contractManaged,
-        sourceReady: requirementReady,
+        sourceReady: requirementReady && sourceFidelityReady,
         dagValidated: strictValidated,
         gateOpen: Boolean(gate),
         activeRun,
@@ -352,6 +496,7 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
             constraintsReady,
             importedPrdCount,
             missing,
+            sourceFidelityStartup,
         },
         dagDraft: {
             path: dagDraftPath,
@@ -375,7 +520,16 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
             exists: closeoutExists || Boolean(record?.closeout),
         },
         completedTransitions: record?.completedTransitions ?? [],
-        blockers: [],
+        blockers: sourceFidelityReady
+            ? []
+            : sourceFidelityStartup.diagnostics.map((diagnostic) => ({
+                code: diagnostic.code,
+                message: diagnostic.message,
+                details: {
+                    startupStatus: sourceFidelityStartup.status,
+                    ledgerPath: sourceFidelityStartup.ledgerPath,
+                },
+            })),
         warnings: [],
         next,
     };

package/dist/application/task-lifecycle/plan-transitions.js

@@ -46,6 +46,37 @@ export function planTransitions(input) {
         actions.push({ type: "recover-contract" });
         expectedTransitions.push("contract-recovered");
     }
+    const startupStatus = snapshot.source?.sourceFidelityStartup?.status;
+    const startupRepairDetected = startupStatus === "missing" ||
+        startupStatus === "invalid" ||
+        startupStatus === "coverage-incomplete";
+    if (startupRepairDetected && input.startupRepairAttempted) {
+        actions.push({ type: "stop", reason: "blocker" });
+        return {
+            actions,
+            gate: null,
+            blockers,
+            next: {
+                kind: "advance",
+                command: `loop-agent task advance ${snapshot.taskId} --json`,
+            },
+            expectedTransitions,
+        };
+    }
+    const startupRepairRequired = startupRepairDetected;
+    if (startupStatus === "human-decision-blocked") {
+        actions.push({ type: "stop", reason: "blocker" });
+        return {
+            actions,
+            gate: null,
+            blockers,
+            next: {
+                kind: "external-action",
+                description: "Requirement ledger requires an existing human source decision; preserve sourceResolutions, resolve the blocker, then advance again.",
+            },
+            expectedTransitions,
+        };
+    }
     const sourceReady = snapshot.source?.requirementReady === true;
     const contractManaged = snapshot.contract?.effectiveStatus === "managed" ||
         Boolean(snapshot.contract?.revision && snapshot.contract.revision > 0);
@@ -53,7 +84,9 @@ export function planTransitions(input) {
     // Prefer prepare once PRDs are on disk; re-import only when caller still
     // signals hasPrdInput (advance.ts latches this after one import per call).
     const shouldImportPrd = input.hasPrdInput;
-    if (input.forcePrepareContract || input.refreshManagedContract) {
+    if (input.forcePrepareContract ||
+        input.refreshManagedContract ||
+        startupRepairRequired) {
         if (shouldImportPrd) {
             actions.push({ type: "import-prd" });
             expectedTransitions.push("prd-imported");
@@ -124,7 +157,8 @@ export function planTransitions(input) {
     const strictValidated = snapshot.dagDraft?.strictValidated === true;
     const dagRefreshRequired = Boolean(input.forceDagRefresh ||
         input.refreshManagedContract ||
-        input.forcePrepareContract);
+        input.forcePrepareContract ||
+        startupRepairRequired);
     if (!dagExists || dagRefreshRequired) {
         actions.push({ type: "generate-dag" });
         expectedTransitions.push("dag-generated");
@@ -145,10 +179,11 @@ export function planTransitions(input) {
         snapshot.lifecycleState === "evidence-closed" ||
         snapshot.lifecycleState === "needs-attention" ||
         snapshot.lifecycleState === "awaiting-decision";
-    const approvedForCurrent = postRunState || (input.approveGate && gate !== null);
+    const approveCurrentGate = input.approveGate && !dagRefreshRequired;
+    const approvedForCurrent = postRunState || (approveCurrentGate && gate !== null);
     if (!approvedForCurrent && (strictValidated || !dagExists || dagRefreshRequired)) {
         // Gate opens after generate+validate in the advance loop; plan includes open.
-        if (!input.approveGate) {
+        if (!approveCurrentGate) {
             actions.push({ type: "open-write-set-gate" });
             expectedTransitions.push("write-set-gate-opened");
             if (input.dryRun) {
@@ -177,14 +212,14 @@ export function planTransitions(input) {
         (snapshot.lifecycleState === "run-failed" && !failedRecoverable) ||
         snapshot.lifecycleState === "evidence-closed";
     if (!alreadyTerminalRun) {
-        if (input.approveGate && !postRunState) {
+        if (approveCurrentGate && !postRunState) {
             expectedTransitions.push("write-set-approved");
             actions.push({ type: "start-or-monitor-run" });
             expectedTransitions.push("dag-run-started", "dag-run-monitored");
         }
         else if (snapshot.lifecycleState === "running" ||
             snapshot.activeRun ||
-            (input.approveGate && Boolean(snapshot.activeRun))) {
+            (approveCurrentGate && Boolean(snapshot.activeRun))) {
             actions.push({ type: "start-or-monitor-run" });
             expectedTransitions.push("dag-run-monitored");
         }
@@ -218,7 +253,7 @@ export function planTransitions(input) {
         actions,
         gate,
         blockers,
-        next: deriveNext(snapshot, gate, input.approveGate),
+        next: deriveNext(snapshot, gate, approveCurrentGate),
         expectedTransitions,
     };
 }

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.39.0-beta.13",
-  "gitSha": "5d72ad152e1f52f7001782af509a53f11c330aa4",
-  "builtAt": "2026-08-29T13:28:15.172Z"
+  "version": "0.39.0-beta.14",
+  "gitSha": "9d8bebca76a2608d9b38a1af1f379fd5fe5b04b0",
+  "builtAt": "2026-08-30T09:13:51.707Z"
 }

package/dist/executors/dag-pi-executor.js

@@ -16,6 +16,7 @@ import { redactPromptForLog, truncateOutput, } from "../shared/output-truncation
 import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelain, recoverRootNulArtifact, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
 import { captureWorkspaceWriteSnapshot, diffWorkspaceWriteSnapshots, } from "./workspace-write-snapshot.js";
 import { pathMatchesPattern } from "../shared/git-progress.js";
+import { isSuspiciousVerificationSymbol } from "../workflows/dag/frontend-implementation-contract.js";
 import { isTargetTemplateTransientRetryNode, isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "../workflows/dag/retry-policy.js";
 import { assessBackendTestMdPlanCompleteness, assessBackendTestMdWriterCompleteness, assessBackendTestPytestPlanCompleteness, assessBackendTestPytestWriterCompleteness, assessBackendTestShardChildCompleteness, backendTestWriterProgressRoleForTask, classifyBackendTestWriterCompletenessFailure, isBackendTestCompletenessRetryCandidate, isBackendTestMdPlanTask, isBackendTestPytestPlanTask, isBackendTestShardChildTask, writeBackendTestWriterProgressArtifacts, } from "../workflows/dag/backend-test-writer-completeness.js";
 import { resolveBackendTestLayout } from "../workflows/dag/backend-test-layout.js";
@@ -236,16 +237,6 @@ export const FRONTEND_PLAN_RECORD_TOOL_NAMES = [
 ];
 export const FRONTEND_PLAN_TERMINAL_TOOL_NAMES = ["finalize_plan"];
 export const FRONTEND_PLAN_ADOPT_TOOL_NAMES = ["adopt_staged_fact"];
-/**
- * Inter-call delay for high-frequency frontend record_* tools. Incremental
- * submission (one model response per 1-5 entries) means dozens of sequential
- * API round trips in a few minutes; third-party gateways (huu.dqy.ink) trip
- * rate limits whose windows exceed normal API RPM even at ~13 calls/min. A
- * short fixed delay before each tool body keeps the sustained rate under
- * typical thresholds while batching cuts the total call count.
- */
-const FRONTEND_RECORD_TOOL_THROTTLE_MS = 1000;
-const sleepRecordThrottle = () => new Promise((resolve) => setTimeout(resolve, FRONTEND_RECORD_TOOL_THROTTLE_MS));
 /** M5: `frontend-review-pi` emits its authoritative terminal verdict through
  * committed typed tools instead of the legacy JSON verdict parse. */
 export function isFrontendReviewTypedTerminalNode(task) {
@@ -395,10 +386,6 @@ export function scanReviewTerminalKindsFromSessionEvents(content) {
     }
     return kinds;
 }
-/** Read-only discovery tool budget for frontend-plan-pi. Exceeding it means
- * the plan re-read upstream outputs/sources instead of trusting typed facts,
- * which blows up the context window (400 request-too-large). */
-const PLAN_READ_TOOL_BUDGET = 40;
 const READ_ONLY_TOOL_NAMES = new Set(["read", "grep", "ls", "find"]);
 function readEventPath(event) {
     const candidates = [event.path, event.readPath, event.input];
@@ -483,45 +470,6 @@ export async function detectNodeReadBudget(input) {
         issues.push(`frontend ${input.nodeId} read budget exceeded: ${stats.elapsedMs}ms (budget ${input.budget.maxMs}ms)`);
     return issues;
 }
-/** Deterministic read-burst guard for frontend-plan-pi: count read-only
- * discovery tool calls (read/grep/ls/find) from the session log. Over budget →
- * read-burst, retried with a reduced-reading instruction. Pure scan; a
- * successful plan under budget is never blocked. */
-export async function detectPlanReadBurst(input) {
-    const sessionEventsPath = path.join(input.runDir, input.nodeId, "session-events.jsonl");
-    let count = 0;
-    try {
-        const content = await readFile(sessionEventsPath, "utf8");
-        for (const line of content.split("\n")) {
-            if (!line.trim())
-                continue;
-            try {
-                const event = JSON.parse(line);
-                if (event.type === "tool_execution_start" &&
-                    typeof event.toolName === "string" &&
-                    (event.toolName === "read" ||
-                        event.toolName === "grep" ||
-                        event.toolName === "ls" ||
-                        event.toolName === "find")) {
-                    count += 1;
-                }
-            }
-            catch {
-                // skip unparseable line
-            }
-        }
-    }
-    catch {
-        // Missing/unreadable session log → no burst detection
-        return [];
-    }
-    if (count > PLAN_READ_TOOL_BUDGET) {
-        return [
-            `frontend plan read-burst: ${count} read-only tool calls (budget ${PLAN_READ_TOOL_BUDGET}). Trust the upstream contract/scout typed facts; do not re-read contract/scout outputs or source files already captured. Minimize discovery reads, commit record_* facts directly, then finalize_plan.`,
-        ];
-    }
-    return [];
-}
 export const FRONTEND_DESIGN_TERMINAL_TOOL_NAMES = new Set([
     "approve_design",
     "request_design_changes",
@@ -932,11 +880,27 @@ export async function createFrontendPlanLedgerTools(input) {
         import("typebox"),
         import("@earendil-works/pi-coding-agent"),
     ]);
-    const { readCommittedEvents, writeTypedEventStoreJsonl } = await import("../workflows/dag/frontend-typed-event-store.js");
+    const { loadTypedEventStore, readCommittedEvents, writeTypedEventStoreJsonl, } = await import("../workflows/dag/frontend-typed-event-store.js");
     const { adoptStagedFact, adoptTypedEventFact, stageTypedEventFact } = await import("../workflows/dag/frontend-typed-event-transaction.js");
     const { assemblePlanPatchFromCommittedFacts } = await import("../workflows/dag/frontend-shadow-dual-write.js");
     const store = input.store;
     const attemptId = input.attemptId;
+    // A retry creates a fresh executor-local store, but the plan ledger is the
+    // cross-attempt authority. Restore the committed prefix before registering
+    // tools; otherwise the first flush of a retry can overwrite facts that the
+    // previous attempt had already committed. The on-disk file contains only
+    // committed records, so loading it is also fail-closed with respect to
+    // staged/quarantined facts.
+    const persisted = await loadTypedEventStore(path.join(input.runDir, input.nodeId, "plan-typed-facts.jsonl"));
+    if (persisted.records.length > 0) {
+        const existingEventIds = new Set(store.records.map((record) => record.eventId));
+        for (const record of persisted.records) {
+            if (!existingEventIds.has(record.eventId)) {
+                store.records.push(record);
+            }
+        }
+        store.revision = Math.max(store.revision, persisted.revision);
+    }
     const stringArray = Type.Array(Type.String({}));
     const optionalString = Type.Optional(Type.String({}));
     const optionalStringArray = Type.Optional(stringArray);
@@ -1127,7 +1091,6 @@ export async function createFrontendPlanLedgerTools(input) {
             stylingStrategy: optionalString,
         }, { additionalProperties: false }),
         async execute(_toolCallId, params) {
-            await sleepRecordThrottle();
             const rawChoice = params?.choice;
             if (!isRecordObject(rawChoice)) {
                 return planToolReceipt({
@@ -1180,7 +1143,16 @@ export async function createFrontendPlanLedgerTools(input) {
                     ? { stylingStrategy: params.stylingStrategy }
                     : {}),
             });
-            return planToolReceipt(result);
+            // Echo the frozen citation the runtime derived: the model sees the
+            // purpose↔citation mapping it just committed and can re-record the
+            // choice (last-wins per purpose at compile) when it mismatches.
+            const echo = {
+                ...result,
+                ...(choice.specReference
+                    ? { derivedSpecReference: choice.specReference }
+                    : {}),
+            };
+            return planToolReceipt(echo);
         },
     });
     const recordStateFlowTool = defineTool({
@@ -1264,6 +1236,26 @@ export async function createFrontendPlanLedgerTools(input) {
                         error: "record_state_flow requires non-empty interaction.name (id is accepted only as a legacy alias)",
                     });
                 }
+                // Interaction -> VT forward references are legal only against
+                // already-committed VT facts. In the segmented flow every VT
+                // commits in the coverage segment before state flows run, so a
+                // dangling reference here is a real defect (r20: *-BEHAVIOR
+                // refs reached the final review untraceable).
+                const interactionVtIds = stringList(interaction.verificationTargetIds);
+                const committedVtIds = new Set(readCommittedEvents(store, attemptId)
+                    .map((event) => event.fact)
+                    .filter((fact) => fact.kind === "plan-verification-target")
+                    .map((fact) => fact.entry
+                    ?.id)
+                    .filter((id) => typeof id === "string"));
+                const unknownVtIds = interactionVtIds.filter((id) => !committedVtIds.has(id));
+                if (unknownVtIds.length > 0) {
+                    return planToolReceipt({
+                        ok: false,
+                        kind: "state-flow",
+                        error: `record_state_flow interaction "${resolvedName}" references verification targets that are not recorded yet: ${unknownVtIds.join(", ")}; record them with record_plan_verification_target first, then re-record this state flow`,
+                    });
+                }
                 interactions.push({ ...interaction, name: resolvedName });
             }
             const states = uiStates
@@ -1359,7 +1351,6 @@ export async function createFrontendPlanLedgerTools(input) {
             entry: requirementSchema,
         }, { additionalProperties: false }),
         async execute(_toolCallId, params) {
-            await sleepRecordThrottle();
             const rawEntry = params?.entry;
             if (!isRecordObject(rawEntry)) {
                 return planToolReceipt({
@@ -1387,11 +1378,26 @@ export async function createFrontendPlanLedgerTools(input) {
                 void _omittedGap;
                 entry = rest;
             }
+            // Canonical-identity check: a requirement id outside the frozen
+            // canonical list (e.g. a BR-* business rule picked up from the PRD
+            // prose) would commit an immutable fact that finalize's
+            // canonical-coverage gate rejects with no in-node cure. Reject here
+            // and name the allowed ids.
+            const id = typeof entry.id === "string" ? entry.id : "";
+            if (id &&
+                input.requirementIds &&
+                input.requirementIds.length > 0 &&
+                !input.requirementIds.includes(id)) {
+                return planToolReceipt({
+                    ok: false,
+                    kind: "plan-requirement",
+                    error: `record_plan_requirement id "${id}" is not a frozen canonical requirement; canonical ids are: ${input.requirementIds.join(", ")}`,
+                });
+            }
             // A requirement id is a canonical identity: recording it twice would
             // compile a duplicate requirements[] entry and fail design review.
             // Reject duplicates at the tool boundary so the model can fix them
             // in-node instead of burning the attempt on a later validation error.
-            const id = typeof entry.id === "string" ? entry.id : "";
             if (id) {
                 const existing = readCommittedEvents(store, attemptId).find((event) => {
                     const fact = event.fact;
@@ -1422,7 +1428,6 @@ export async function createFrontendPlanLedgerTools(input) {
             entry: verificationTargetSchema,
         }, { additionalProperties: false }),
         async execute(_toolCallId, params) {
-            await sleepRecordThrottle();
             const rawEntry = params?.entry;
             if (!isRecordObject(rawEntry)) {
                 return planToolReceipt({
@@ -1477,6 +1482,18 @@ export async function createFrontendPlanLedgerTools(input) {
                     error: `record_plan_verification_target file is outside the writeSet patterns [${input.writeSetPatterns.join(", ")}]: ${rawEntry.file}; verification targets must point inside the task writeSet`,
                 });
             }
+            // Symbol shape check at the boundary: a fabricated symbol committed
+            // here is immutable (duplicate ids are rejected), and while the
+            // compile drops it, catching it now lets the model fix the target
+            // in one receipt-free step.
+            if (typeof rawEntry.symbol === "string" &&
+                isSuspiciousVerificationSymbol(rawEntry.symbol)) {
+                return planToolReceipt({
+                    ok: false,
+                    kind: "plan-verification-target",
+                    error: `record_plan_verification_target symbol "${rawEntry.symbol}" looks fabricated; use a real exported/describe/it symbol from ${rawEntry.file ?? "the target file"} or omit the symbol entirely (the trace gate verifies file+command)`,
+                });
+            }
             // uiStates: [] means this verification target is intentionally not
             // bound to a named UI state. Keep that canonical representation even
             // when a model omits the optional tool-boundary field.
@@ -1539,7 +1556,6 @@ export async function createFrontendPlanLedgerTools(input) {
             entry: evidenceGapSchema,
         }, { additionalProperties: false }),
         async execute(_toolCallId, params) {
-            await sleepRecordThrottle();
             const rawEntry = params?.entry;
             if (!isRecordObject(rawEntry)) {
                 return planToolReceipt({
@@ -1732,6 +1748,19 @@ export async function createFrontendPlanLedgerTools(input) {
             const committed = readCommittedEvents(store, attemptId);
             await writeTypedEventStoreJsonl(path.join(input.runDir, input.nodeId, "plan-typed-facts.jsonl"), committed);
         },
+        committedFactCount: () => readCommittedEvents(store, attemptId).length,
+        committedRequirementIds: () => {
+            const ids = new Set();
+            for (const event of readCommittedEvents(store, attemptId)) {
+                const fact = event.fact;
+                if (!fact || fact.kind !== "plan-requirement")
+                    continue;
+                const entryFact = fact.entry;
+                if (typeof entryFact?.id === "string")
+                    ids.add(entryFact.id);
+            }
+            return ids;
+        },
     };
 }
 function isRecordObject(value) {
@@ -1869,7 +1898,6 @@ export async function createFrontendContractTools(input) {
         promptSnippet: `Commit 1-5 origin=contract ${kind} facts (up to 5 per message).`,
         parameters: Type.Object({}, { additionalProperties: true }),
         async execute(_toolCallId, params) {
-            await sleepRecordThrottle();
             const result = await adoptContractFact(kind, {
                 kind,
                 origin: "contract",
@@ -2524,6 +2552,171 @@ async function runFrontendDesignTerminalShadow(input) {
     }
     return input.mapped;
 }
+/** Tool subsets for the three frontend plan sessions (r17 split design). */
+const FRONTEND_PLAN_SEGMENTS = [
+    {
+        id: "coverage",
+        toolNames: new Set([
+            "record_plan_requirement",
+            "record_plan_verification_target",
+            "adopt_staged_fact",
+        ]),
+        instruction: [
+            "PLAN SEGMENT 1/3 — coverage mapping only.",
+            "Your ONLY job: for every frozen requirement, emit record_plan_requirement (requirement → implementation files) and record_plan_verification_target (verification target bound to requirement ids and files). Do NOT record components, UI states, mock, dependency, or routes — a follow-up session owns those.",
+            "Do not call finalize_plan; it is not available in this segment.",
+        ].join(" "),
+    },
+    {
+        id: "ux-decisions",
+        toolNames: new Set([
+            "record_component_choice",
+            "record_state_flow",
+            "record_data_flow",
+            "record_mock_api",
+            "record_design_deviation",
+            "record_dependency",
+            "record_route_selection",
+            "adopt_staged_fact",
+        ]),
+        instruction: [
+            "PLAN SEGMENT 2/3 — UX decisions.",
+            "Requirements and verification targets are already committed in the ledger (do NOT re-record them; duplicates are rejected). Your ONLY job: record component choices (decision=new requires sourceRequirementIds per the citation table), state flows, data flow, mock strategy, design deviation, dependency policy, and route selection.",
+            "Do not call finalize_plan; it is not available in this segment.",
+        ].join(" "),
+    },
+    {
+        id: "finalize",
+        toolNames: null,
+        instruction: [
+            "PLAN SEGMENT 3/3 — finalize.",
+            "All record_* tools are available: if a finalize_plan receipt reports missing or invalid facts, fix them with the named record_* tool and call finalize_plan again. Otherwise call finalize_plan exactly once with no extra fields.",
+        ].join(" "),
+    },
+];
+/**
+ * Coverage-batch slicing for the frontend plan split (options 1+5): the
+ * coverage segment becomes one session per requirement slice (default 4
+ * requirements), so a small output budget can never be exhausted by
+ * upfront reasoning about the whole requirement list. Zero-progress
+ * batches are split in half and retried (option 5); single-requirement
+ * zero-progress failures short-circuit to the retry ladder.
+ */
+const FRONTEND_PLAN_COVERAGE_BATCH_SIZE = 4;
+const FRONTEND_PLAN_BATCH_MAX_SESSIONS = 32;
+export async function runFrontendPlanSegmentedSessions(input) {
+    const queue = [];
+    // An empty list means "ledger unreadable / unknown" and must fall back to
+    // one unscoped coverage session — only a non-empty list batches.
+    const requirementIdsProvided = input.requirementIds !== undefined && input.requirementIds.length > 0;
+    const pending = (input.requirementIds ?? []).filter((id) => !input.committedRequirementIds?.().has(id));
+    for (const segment of FRONTEND_PLAN_SEGMENTS) {
+        if (segment.id !== "coverage") {
+            queue.push({
+                id: segment.id,
+                toolNames: segment.toolNames,
+                prompt: `${input.basePrompt}\n\n${segment.instruction}`,
+            });
+            continue;
+        }
+        // No requirement list (unreadable ledger) -> one unscoped coverage
+        // session. A provided list with everything committed (resume) skips
+        // coverage entirely.
+        if (!requirementIdsProvided || pending.length > 0) {
+            if (!requirementIdsProvided) {
+                queue.push({
+                    id: segment.id,
+                    toolNames: segment.toolNames,
+                    prompt: `${input.basePrompt}\n\n${segment.instruction}`,
+                });
+                continue;
+            }
+            for (let i = 0; i < pending.length; i += FRONTEND_PLAN_COVERAGE_BATCH_SIZE) {
+                const slice = pending.slice(i, i + FRONTEND_PLAN_COVERAGE_BATCH_SIZE);
+                queue.push({
+                    id: `coverage-batch-${i / FRONTEND_PLAN_COVERAGE_BATCH_SIZE + 1}`,
+                    toolNames: segment.toolNames,
+                    coverageSlice: slice,
+                    prompt: `${input.basePrompt}\n\n${segment.instruction}\n\nCOVERAGE BATCH: process ONLY these requirements in this session: ${slice.join(", ")}. Other requirements are handled by separate sessions; do not record them.`,
+                });
+            }
+        }
+    }
+    let last;
+    let index = 0;
+    while (index < queue.length && index < FRONTEND_PLAN_BATCH_MAX_SESSIONS) {
+        const session = queue[index];
+        const remaining = (session.coverageSlice ?? []).filter((id) => !input.committedRequirementIds?.().has(id));
+        // Resume/earlier-batch commits may already cover this slice.
+        if (session.coverageSlice && remaining.length === 0) {
+            index += 1;
+            continue;
+        }
+        let prompt = session.prompt;
+        if (session.coverageSlice) {
+            prompt = prompt.replace(/COVERAGE BATCH: process ONLY these requirements in this session: .*/, `COVERAGE BATCH: process ONLY these requirements in this session: ${remaining.join(", ")}. Other requirements are handled by separate sessions; do not record them.`);
+        }
+        const committedBefore = input.committedFactCount();
+        const customTools = input.segmentCustomTools(session.toolNames);
+        const result = await input.piStepFn({
+            ...input.sessionOptions,
+            prompt,
+            ...(customTools.length > 0
+                ? {
+                    writerToolPolicy: {
+                        requireSdk: true,
+                        customTools,
+                    },
+                }
+                : {}),
+        });
+        last = result;
+        try {
+            await input.flushLedger();
+        }
+        catch {
+            // best-effort: the node-level flush runs again after the attempt
+        }
+        const committedAfter = input.committedFactCount();
+        if (result.ok) {
+            index += 1;
+            continue;
+        }
+        const committedFactsOnlySuccess = session.id !== "finalize" &&
+            !(result.assistantText ?? "").trim() &&
+            !result.stderr.trim() &&
+            !result.timedOut &&
+            committedAfter > committedBefore;
+        if (committedFactsOnlySuccess) {
+            // The session died but banked facts: keep the progress and move on.
+            index += 1;
+            continue;
+        }
+        // Option 5: a multi-requirement coverage batch that failed with ZERO
+        // new facts and no provider stderr is the upfront-reasoning burn —
+        // halve the slice and retry instead of failing the attempt.
+        const coverageSlice = session.coverageSlice;
+        const zeroProgressBurn = coverageSlice !== undefined &&
+            coverageSlice.length > 1 &&
+            committedAfter === committedBefore &&
+            !(result.assistantText ?? "").trim() &&
+            !result.stderr.trim() &&
+            !result.timedOut;
+        if (zeroProgressBurn && coverageSlice) {
+            const half = Math.ceil(coverageSlice.length / 2);
+            queue.splice(index, 1, { ...session, coverageSlice: coverageSlice.slice(0, half) }, { ...session, coverageSlice: coverageSlice.slice(half) });
+            continue;
+        }
+        return result;
+    }
+    return (last ?? {
+        ok: false,
+        stdout: "",
+        stderr: "frontend plan segmentation produced no session",
+        failureCategory: "empty-output",
+        durationMs: 0,
+    });
+}
 export async function executeDagPiNode(input, meta, piStepFn = executePiStep, writeGuardDependencies = DEFAULT_DAG_PI_WRITE_GUARD_DEPENDENCIES) {
     const started = Date.now();
     const persona = resolveDagPiPersona(input.task);
@@ -2906,10 +3099,9 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         const piExtensionPaths = piExtensionsResolution && resolvePiBackend() !== "cli-only"
             ? piExtensionsResolution.resolved.flatMap((entry) => entry.entryPaths)
             : undefined;
-        result = await piStepFn({
+        const piSessionOptions = {
             attachedFiles: [],
             modelConfig: resolveDagPiModelConfig(input.model, input.thinking ? { thinking: input.thinking } : undefined),
-            prompt: input.prompt,
             repoRoot: input.cwd,
             step,
             toolNames: resolveDagPiToolNames(input.task),
@@ -2922,7 +3114,6 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             ...(input.task.contextBudget
                 ? { contextBudget: input.task.contextBudget }
                 : {}),
-            ...(writerToolPolicy ? { writerToolPolicy } : {}),
             ...(piExtensionPaths && piExtensionPaths.length > 0
                 ? { piExtensionPaths }
                 : {}),
@@ -2935,7 +3126,55 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                     bridgeActivity(activity.kind, activity.at);
                 }
                 : undefined,
-        });
+        };
+        if (isFrontendPlanLedgerNode(input.task) && planLedgerTools) {
+            // Frontend-only split: three sequential sessions with independent
+            // output budgets (coverage -> UX decisions -> finalize), mirroring the
+            // backend-test template's module sharding. Every other template keeps
+            // the single-session path below.
+            let planRequirementIds = [];
+            try {
+                const { readCommittedOriginFacts } = await import("../workflows/dag/frontend-shadow-dual-write.js");
+                const contractFacts = await readCommittedOriginFacts(meta.runDir, "frontend-contract-pi", "contract-typed-facts.jsonl");
+                // Only requirement facts: the contract ledger also carries
+                // constraints (CON-*), evidence expectations (EV-*), handoff
+                // intents (HND-*), open questions (OQ-*) and split proposals
+                // (SPLIT-*) that all have ids — feeding those into the coverage
+                // batches made the model record non-frozen plan-requirement ids
+                // that finalize's canonical-coverage gate then rejected (r-ext2).
+                planRequirementIds = contractFacts
+                    .filter((record) => record.fact
+                    ?.kind === "requirement")
+                    .map((record) => record.fact?.id)
+                    .filter((id) => typeof id === "string")
+                    .sort();
+            }
+            catch {
+                // Unreadable ledger falls back to a single coverage session.
+            }
+            result = await runFrontendPlanSegmentedSessions({
+                piStepFn,
+                sessionOptions: piSessionOptions,
+                basePrompt: input.prompt,
+                attempt: input.attempt ?? 1,
+                committedFactCount: () => planLedgerTools.committedFactCount(),
+                requirementIds: planRequirementIds,
+                committedRequirementIds: () => planLedgerTools.committedRequirementIds(),
+                segmentCustomTools: (toolNames) => toolNames === null
+                    ? planLedgerTools.customTools
+                    : planLedgerTools.customTools.filter((tool) => typeof tool === "object" &&
+                        tool !== null &&
+                        toolNames.has(tool.name)),
+                flushLedger: () => planLedgerTools.flush(),
+            });
+        }
+        else {
+            result = await piStepFn({
+                ...piSessionOptions,
+                prompt: input.prompt,
+                ...(writerToolPolicy ? { writerToolPolicy } : {}),
+            });
+        }
     }
     catch (error) {
         if (playwrightToolContext) {
@@ -3072,25 +3311,10 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         catch {
             // best-effort flush; missing ledger still fails at the node validator
         }
-        // Read-burst guard: a plan that burned dozens of read/grep/ls/find
-        // calls (re-reading upstream outputs and source files it should trust
-        // from typed facts) blows up the context window and eventually fails
-        // with 400 request-too-large. Detect it deterministically from the
-        // session log and retry with a reduced-reading instruction.
-        const readBurstIssues = input.task.readBudget?.onExhaustion === "return-guidance"
-            ? []
-            : await detectPlanReadBurst({
-                runDir: meta.runDir,
-                nodeId: input.task.id,
-            });
-        if (readBurstIssues.length > 0) {
-            return {
-                ...mapped,
-                ok: false,
-                failureCategory: "read-burst",
-                stderr: [mapped.stderr, ...readBurstIssues].filter(Boolean).join("\n\n"),
-            };
-        }
+        // NOTE: the legacy plan read-burst guard lived here. It is dead code
+        // since the plan node went tool-only (resolveDagPiToolNames grants no
+        // read/grep/ls/find), so a read burst is structurally impossible; the
+        // read-budget path (scout etc.) keeps its own guard.
     }
     if (!isWriteTask) {
         if (!mapped.ok &&

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -539,6 +539,18 @@ export const frontendImplementationContractSchema = z
                     message: `unknown verification target ${targetId}`,
                     path: ["requirements"],
                 });
+        // Interactions bind to VTs too: an interaction whose behavior
+        // verification points at an unmaterialized VT is untraceable —
+        // r20 review finding (dangling *-BEHAVIOR references sailed
+        // through plan/design/implement to the final review).
+        for (const interaction of value.interactions)
+            for (const targetId of interaction.verificationTargetIds)
+                if (!verificationIds.includes(targetId))
+                    ctx.addIssue({
+                        code: "custom",
+                        message: `interaction "${interaction.name}" references unknown verification target ${targetId}`,
+                        path: ["interactions"],
+                    });
         // Source fidelity ledger binding (AC-005/AC-006): 绑定携带
         // requirementToFragments（ledger v2）时，每个 requirement 必须携带
         // 非空 sourceFragmentIds，否则 fail closed（防引用伪造/缺失）。
@@ -570,12 +582,23 @@ export const frontendImplementationContractSchema = z
         if (state.applicable &&
             (!state.expectedBehavior ||
                 !state.implementationTargets?.length ||
-                !state.verificationTargetIds?.length))
+                !state.verificationTargetIds?.length)) {
+            // Name the state and the exact missing fields: the fixer is a
+            // model iterating on finalize receipts — it cannot fix a
+            // defect it cannot locate (r18: 39 blind finalize retries).
+            const missing = [];
+            if (!state.expectedBehavior)
+                missing.push("expectedBehavior");
+            if (!state.implementationTargets?.length)
+                missing.push("implementationTargets");
+            if (!state.verificationTargetIds?.length)
+                missing.push("verificationTargetIds");
             ctx.addIssue({
                 code: "custom",
-                message: "applicable UI state requires behavior, implementation, and verification",
+                message: `applicable UI state "${state.name}" is missing: ${missing.join(", ")} — record_state_flow it again with those fields filled`,
                 path: ["uiStates"],
             });
+        }
         if (!state.applicable && !state.notApplicableReason)
             ctx.addIssue({
                 code: "custom",
@@ -1826,12 +1849,25 @@ export async function analyzeFrontendImplementationContract(input) {
     if (parsedTargetFiles.some((file) => file.startsWith("/") || file.includes("\\")))
         fail("blocked", "invalid-output: frontend contract target paths must be relative POSIX paths", candidateJsonSha256);
     const parsedStates = asRecord(parsed)?.uiStates;
-    if (Array.isArray(parsedStates) && parsedStates.some((item) => {
-        const state = asRecord(item);
-        return state?.applicable === true &&
-            (!asString(state.expectedBehavior) || asStringArray(state.implementationTargets).length === 0 || asStringArray(state.verificationTargetIds).length === 0);
-    }))
-        fail("retryable-invalid", "invalid-output: applicable UI state requires behavior, implementation, and verification", candidateJsonSha256);
+    if (Array.isArray(parsedStates)) {
+        const incompleteStates = [];
+        for (const item of parsedStates) {
+            const state = asRecord(item);
+            if (!state || state.applicable !== true)
+                continue;
+            const missing = [];
+            if (!asString(state.expectedBehavior))
+                missing.push("expectedBehavior");
+            if (asStringArray(state.implementationTargets).length === 0)
+                missing.push("implementationTargets");
+            if (asStringArray(state.verificationTargetIds).length === 0)
+                missing.push("verificationTargetIds");
+            if (missing.length > 0)
+                incompleteStates.push(`"${asString(state.name)}": missing ${missing.join(", ")}`);
+        }
+        if (incompleteStates.length > 0)
+            fail("retryable-invalid", `invalid-output: applicable UI states incomplete — re-record each with record_state_flow filling the named fields: ${incompleteStates.join("; ")}`, candidateJsonSha256);
+    }
     const parsedMockApi = asRecord(parsed)?.mockApi;
     if (asRecord(parsedMockApi) &&
         typeof asRecord(parsedMockApi)?.strategy === "string" &&
@@ -2079,7 +2115,7 @@ const VERIFICATION_SYMBOL_MAX_CHARS = 60;
  * loading") and `describe(...)` / `it(...)` forms stay valid — a real symbol
  * may be a function name, a dotted path, or a describe/it title.
  */
-function isSuspiciousVerificationSymbol(symbol) {
+export function isSuspiciousVerificationSymbol(symbol) {
     const trimmed = symbol.trim();
     if (!trimmed)
         return false;
@@ -2126,6 +2162,17 @@ export class PlanPolicyPrecheckFailure extends Error {
  */
 export async function analyzeFrontendPlanPatchCandidate(input) {
     const analysis = await analyzeFrontendImplementationContract(input);
+    // A committed VT with a fabricated symbol is an immutable ledger fact —
+    // the record boundary rejects duplicate ids, so the model cannot overwrite
+    // it and throwing here deadlocks the receipt loop (r19: VT-AC006-BEHAVIOR).
+    // Drop suspicious symbols deterministically instead: the VT stays valid and
+    // the deterministic trace gate verifies file+command (and resolvability)
+    // after verification. Mirrors the shell materialization's drop semantics.
+    for (const target of analysis.canonical.verificationTargets) {
+        if (target.symbol && isSuspiciousVerificationSymbol(target.symbol)) {
+            target.symbol = undefined;
+        }
+    }
     // Front-load the verification-symbol shape check so fabricated symbols
     // are fixed by the plan retry ladder in-node instead of failing the
     // verify trace gate at the end of the run.

package/dist/workflows/dag/frontend-review-context.js

@@ -287,9 +287,20 @@ export async function runFrontendReviewContextGate(input) {
     if (!parsedContract.success) {
         throw new FrontendReviewContextFailure("review-context-invalid-contract", "frontend review context invalid implementation contract");
     }
+    // Authorized diff surface = deliverable files + every verification-target
+    // file the contract references. The writer legitimately writes VT test
+    // artifacts (behavior verification), and the reviewer must audit their
+    // diffs; scoping this to targets.files alone failed the baseline-overlap
+    // check on app.test.js (r19 extreme smoke).
+    const authorizedChangedPaths = [
+        ...new Set([
+            ...parsedContract.data.targets.files,
+            ...parsedContract.data.verificationTargets.map((target) => target.file),
+        ]),
+    ];
     const diff = await runFrontendWorktreeDiffGate({
         ...input,
-        authorizedChangedPaths: parsedContract.data.targets.files,
+        authorizedChangedPaths,
     });
     const verificationTrace = await readRequiredJson(input.runDir, "contracts/frontend-verification-trace.json");
     const repairAssessment = await readOptionalRepairAssessment(input.runDir);

package/dist/workflows/dag/frontend-shadow-dual-write.js

@@ -260,7 +260,12 @@ export function restorePlanPatchFromCommittedFacts(records) {
         if (isRecord(fact.patch))
             return fact.patch;
     }
-    return undefined;
+    // No finalize-published snapshot: the receipt fix loop can end an attempt
+    // before any finalize_plan succeeds while dozens of record_* facts are
+    // already committed. Assemble the patch from those record facts instead of
+    // declaring the ledger missing (r19: "ledger missing" discarded a ledger
+    // with 92 committed facts).
+    return assemblePlanPatchFromCommittedFacts(records);
 }
 /**
  * A+B (AC-004): reverse of `planLedgerFactsFromPatch` for the incremental
@@ -280,12 +285,33 @@ export function assemblePlanPatchFromCommittedFacts(records, contractRequirement
         PLAN_LEDGER_FACT_KINDS.includes(fact.kind));
     if (facts.length === 0)
         return undefined;
-    for (const fact of facts) {
-        if (isRecord(fact.patch))
-            return fact.patch;
-    }
+    // Singleton record facts: the LAST committed fact wins. The model corrects
+    // a rejected plan by re-recording the fact (r18: 39 finalize retries never
+    // converged because the first state-flow fact kept shadowing the
+    // corrections). Requirements / verification targets / evidence gaps stay
+    // additive (aggregated below); component choices accumulate; singletons
+    // supersede.
+    const lastByKind = (kind) => {
+        let found;
+        for (const fact of facts) {
+            if (fact.kind === kind)
+                found = fact;
+        }
+        return found;
+    };
+    // Patch snapshots (published by earlier finalize calls) carry no routes;
+    // exclude them so a snapshot cannot shadow the model's route selection.
+    const routeSurface = (() => {
+        let found;
+        for (const fact of facts) {
+            if (fact.kind !== "target-surface" || isRecord(fact.patch))
+                continue;
+            found = fact;
+        }
+        return found;
+    })();
     const patch = {};
-    const targetSurface = facts.find((fact) => fact.kind === "target-surface");
+    const targetSurface = routeSurface;
     if (targetSurface) {
         const routes = canonicalStringSet(asStringArray(targetSurface.routes));
         if (routes.length > 0)
@@ -295,14 +321,34 @@ export function assemblePlanPatchFromCommittedFacts(records, contractRequirement
     const collectedChoices = componentChoices.flatMap((fact) => Array.isArray(fact.uiComponentChoices)
         ? fact.uiComponentChoices.filter(isRecord)
         : []);
+    // Later corrections supersede earlier submissions per purpose: without
+    // this, a re-recorded choice (fixing a wrong specReference) would appear
+    // twice and the reviewer would still audit the stale entry (r19).
+    const choicesByPurpose = new Map();
+    const dedupedChoices = [];
+    for (const choice of collectedChoices) {
+        const purpose = asString(choice.purpose);
+        if (!purpose) {
+            dedupedChoices.push(choice);
+            continue;
+        }
+        if (choicesByPurpose.has(purpose)) {
+            const at = dedupedChoices.findIndex((existing) => asString(existing.purpose) === purpose);
+            dedupedChoices[at] = choice;
+        }
+        else {
+            choicesByPurpose.set(purpose, choice);
+            dedupedChoices.push(choice);
+        }
+    }
     const stylingStrategy = componentChoices
         .map((fact) => asString(fact.stylingStrategy))
         .find((value) => value.length > 0);
-    if (collectedChoices.length > 0)
-        patch.uiComponentChoices = collectedChoices;
+    if (dedupedChoices.length > 0)
+        patch.uiComponentChoices = dedupedChoices;
     if (stylingStrategy)
         patch.stylingStrategy = stylingStrategy;
-    const stateFlow = facts.find((fact) => fact.kind === "state-flow");
+    const stateFlow = lastByKind("state-flow");
     if (stateFlow) {
         if (Array.isArray(stateFlow.uiStates)) {
             patch.uiStates = stateFlow.uiStates.filter(isRecord);
@@ -311,17 +357,17 @@ export function assemblePlanPatchFromCommittedFacts(records, contractRequirement
             patch.interactions = stateFlow.interactions.filter(isRecord);
         }
     }
-    const mockApi = facts.find((fact) => fact.kind === "mock-api");
+    const mockApi = lastByKind("mock-api");
     if (mockApi && isRecord(mockApi.mockApi)) {
         patch.mockApi = mockApi.mockApi;
     }
-    const deviation = facts.find((fact) => fact.kind === "design-deviation");
+    const deviation = lastByKind("design-deviation");
     if (deviation) {
         const conflicts = canonicalStringSet(asStringArray(deviation.conflicts));
         if (conflicts.length > 0)
             patch.designEvidence = { conflicts };
     }
-    const dependency = facts.find((fact) => fact.kind === "dependency");
+    const dependency = lastByKind("dependency");
     const dependencyPolicy = asString(dependency?.policy);
     if (dependencyPolicy)
         patch.dependencyPolicy = dependencyPolicy;

package/dist/workflows/dag/init-hybrid.js

@@ -3210,6 +3210,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     ...(requiresOpenspecClassification ? ["When a component choice uses an OpenSpec selection, cite that selection; otherwise do not classify unrelated candidates."] : []),
                     "Call finalize_plan exactly once after the necessary typed facts. Return no Markdown narrative.",
                     "TOOL-ONLY PLAN: Do not read Contract/Scout stdout, task sources, or Scout-confirmed target files. Contract and Scout already own evidence discovery; use the injected upstream facts, record a genuine evidence gap when those facts are insufficient, and start committing record_* facts immediately. For decision=new, pass sourceRequirementIds to record_component_choice; runtime derives the exact PRD citation from the frozen ledger.",
+                    "Output budget protocol (hard, max output <=16K per turn): never enumerate-reason the whole requirement list before your first record_* call — that reasoning burns the entire output budget and the attempt dies with zero committed facts. Process requirements in order: think about ONE requirement briefly, immediately emit its record calls (up to 5 per message), then move to the next. If your budget runs low, stop recording and call finalize_plan with what is committed — the retry ladder continues the remainder in a fresh session.",
                     fixedVerificationContext,
                     scopedOpenspecContext,
                     mockContextBlock,

package/dist/workflows/dag/types.js

@@ -315,9 +315,11 @@ export const dagFrontendVerificationBundleSchema = z
     behaviorEvidence: dagShellVerifyEvidenceSchema,
     lintBaselineNodeId: dagFrontendNodeIdSchema.optional(),
     writerNodeIds: z.array(dagFrontendNodeIdSchema).optional(),
-    /** M8: verify-shell only ever runs in initial mode; a failure is terminal
-     * (routes to recovery) and never selects a same-run repair branch. */
-    mode: z.literal("initial"),
+    /** "initial" = first-pass assess bundle; "repair" = the convergence
+     * loop's post-repair reverify, which re-runs the same frozen commands
+     * and fails on any failure (still no same-run repair branch inside the
+     * node itself). */
+    mode: z.enum(["initial", "repair"]),
 })
     .superRefine((bundle, context) => {
     const groups = [

package/harness.json

@@ -83,8 +83,8 @@
     "pi": {
       "description": "Pi 负责规划、评审、诊断；当 DAG toolProfile=write 时也可做有界写入。模型按复杂度三档配置，支持 provider/model 字符串或带 thinking 的对象；斜杠前为 Pi provider，后为 modelId，勿只写裸 modelId。",
       "LOW": "wizard-local/minimax-m3",
-      "MED": "wizard-local/gpt-5.6-sol",
-      "HIGH": "wizard-local/gpt-5.6-sol"
+      "MED": "wizard-local/gpt-5.5",
+      "HIGH": "wizard-local/gpt-5.5"
     }
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.39.0-beta.13",
+  "version": "0.39.0-beta.14",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",