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

package/CHANGELOG.md

@@ -1,6 +1,12 @@
 # 更新日志
 
 ## [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。
+
+- 修复前端 review 修订无法稳定收敛的问题：`decision=new` 的组件选型除关联 `sourceRequirementIds` 外，必须显式选择该需求绑定的冻结 `sourceFragmentId`；runtime 校验隶属关系后物化 `specReference`，并覆盖模型提交的任意路径/章节/行号，避免同一需求含多个来源片段时引用错误章节。同步明确 `purpose` 是与 interaction/UI state 对齐的稳定覆盖键，组件职责由 `expectedBehavior` 与 rationale 表达，review 不再仅因标识符相同而误判。
 
 - 收敛前端 `frontend-plan-pi` 的职责与上下文：Plan 只把 Contract/Scout 的冻结事实映射为 typed decision patch（需求→实现/验证、组件/状态/Mock/依赖与真实证据缺口），不再重复任务源、完整 JSON Schema、受保护 skeleton、逐 AC 回显模板或 bad/good 教学示例。Schema、字段别名、路径与命令校验继续由 typed tools 和 deterministic runtime 持有；Plan 的同名 `record_target_surface` 改为只接受 routes 的 `record_route_selection`，文件归属仍只来自 Scout/runtime。初始 prompt 不再教学别名，validator 失败重试才附加对应 canonical 字段指引；保留冻结验证命令、Mock 约束、字段摘要和组件选型约束，并新增回归断言防止大段 Schema 回注。
 
@@ -26,10 +32,19 @@
 - 前端 review findings PRD 草稿携带修复范围路由信号（方向 A 补充）：`deriveFrontendReviewFixScope` 从 committed findings 确定性推导建议 shape（单文件无远程 API→micro、同目录集中多文件→small、跨目录/API 信号→standard）与建议 complexity、目标文件、建议 allowedPaths；PRD 标题改为「修复 review 发现（<shape>）：<目标文件>」，正文新增「修复范围（供下一轮任务生成路由）」段（含 small 信号词，如「单文件局部修复」「无远程接口」），下一轮任务以该 PRD 生成 DAG 时，`resolveFrontendTaskShape` 能把小修复路由到 micro=7/small=10 节点拓扑，而非默认 11 节点 standard 全流程。
 - 前端 shape 分类 API 否定词覆盖中文空格形式（冒烟暴露边界）：`无 API/网络调用`、`无 API` 等表述不再被误判为远程 API 信号（原 `\b(...)\b` 对 CJK 开头无词边界），`resolveFrontendTaskShape` 与 `deriveFrontendReviewFixScope` 的 hasApiSignal 判定同步修正——带「无 API/无接口」声明的单文件小修复正确路由 micro/small，而非误升级 standard。
 - 深度合入 origin/main（source e68dfbe1）：以 frontend-node typed-tools 拓扑为基底移植 main 硬化——canonical artifact 消费、fail-closed 无验证 marker、风险分级细化（DEPENDENCY_INSTALL_LANGUAGE）、`HARNESS_DAG_RERUN_PROMPT_OVERRIDE` prompt override、Pi SDK 运行时依赖 0.83.0 与 `engines node>=22.19.0`、next-release scripts 入包；废弃节点（verify-assess/reverify/repair-pi/plan-revision/final-design-review/lint-baseline shell）能力确认被当前流程覆盖后裁剪对应实现（repair-gate 机制、lint-baseline shell 类型），plan retry 文案对齐 committed ledger；affected 392 + M2-M9 303 测试全绿，fast 3909/3910、integration 397/398（各 1 个 fn 既有失败）。
+- 修复 Console 轨迹视图引用未声明 CSS 自定义属性导致仓库发布门禁失败的问题，补齐品牌色、警告色与字体别名并保持现有视觉回退值。
 
 ### 重点更新
 
+- Console 对话页「轨迹」视图响应式优化：轨迹列宽跟随面板实际宽度收缩（`.oc-trajectory` 加 `width:100%`、`.oc-trajectory-turn/.step` 加 `min-width:0` 修 flex 收缩链），窄窗口（≤720px）自动隐藏耗时列，避免工具行被固定项挤爆。
+- Console 对话页新增「轨迹」视图（详情侧栏 tab）：仿 DSH ui-trajectory，用本仓库 turnGroups 数据把对话按「用户 → 过程 → AI 回复」渲染成统一单元格列表，每行带 kind 标签 + 图标（用户/ AI / 思考 / 工具 / 活动 / 错误 / 压缩）；用户与 AI 用标签颜色 + 图标区分，AI 中间文本也标注；思考、工具、以及超长用户/AI 消息默认单行截断、可展开/收起看全文（含工具参数与结果、状态与耗时）。支持一键「导出 HTML」自包含文件（长内容用 `<details>` 折叠，短内容内联）。主会话思考块标签由英文 Think 改为「思考」。
+- DAG 检查器节点「执行过程」的「导出 HTML」改为复用页面真实渲染与样式，导出的独立 HTML 排版与页面一致；Pi 会话节点导出会带上原始协议事件，左上角提供「展开/隐藏原始协议事件」按钮（默认隐藏，每项仍可单独展开），shell/静态节点导出同样与页面一致。
 - backend-test 的 pytest repair 现在继续使用 run-owned plan，不再搜索测试目录 README；correspondence finding 会直接指向 docstring、参数 ID、符号、脚本或 payload 的修复位置，collection/scenario repair 与 generated-local Python 写边界保持一致，并在单次 Pi 会话达到 24 轮或 80K 最大 usage snapshot 前受控返回 partial failure。
+- Operator Chat 现在可以在同一个页面管理多个工作区；每个会话始终使用创建它的工作区，切换对话时地址栏保持简洁稳定。
+- 对话消息流整体调整为更紧凑、清晰的布局，思考过程、工具执行、阶段性结果和最终回答会按真实发生顺序展示。
+- 上下文过大时会自动压缩并继续原请求，消息流会依次展示触发原因、压缩进度和压缩结果；手动压缩也使用同一套展示方式。
+- Operator Chat 与 DAG Pi 节点默认开启上下文压力处理：发送前接近窗口时压缩一次、识别网关「请求上下文过大」后压缩续跑，并对 OpenAI 格式的大工具输出做线路压缩；可用环境变量关闭，不必改会话记录。
+- 对话进行中可以连续提交多条消息，并支持编辑、删除或立即插入当前回复；刷新页面或重启 Console 后，未发送内容仍会保留。
 
 - Operator Chat 多次输入排队对齐 DSH Web：运行中的连续输入改为持久化 FIFO 队列，不再用后一条覆盖前一条；单条直接展示，多条默认折叠为数量栏，展开后逐行提供内联编辑、删除和插话发送。队列 Dock 使用与 DSH 一致的外层定位与内层面板结构，标题固定、仅消息列表滚动，并在编辑或请求期间锁定折叠操作。编辑/删除以消息 ID + revision 做并发保护，插话复用 Pi `steer` 注入当前回合，其余消息继续按顺序在回合结束后自动发送；队列通过会话快照与 SSE 权威数组恢复，刷新或 Console 重启不丢失。
 - Operator Chat 右侧辅助栏统一上下文与调用记录：输入框的上下文环、调用记录入口现在复用文件/DAG 侧栏；「文件」常驻，「上下文 / 调用记录」按入口临时添加并支持独立 `×` 关闭，关闭后回到文件 Tab；点击已选入口可收起侧栏，切换到上下文时同步开启注入状态，收起时仅关闭注入而保留上下文数据。上下文与工具调用内容改为内嵌布局，不再叠加独立弹窗、遮罩、焦点陷阱或重复关闭按钮，并补充 Tab 切换与侧栏开合动画；修复折叠态右侧展开按钮无法恢复侧栏的问题。
@@ -164,6 +179,9 @@
 - Operator Chat 的命令说明和参数提示与实际能力保持一致，减少选错恢复入口或误用占位参数。
 - 测试套件按 CPU、内存、平台和当前 DAG 压力动态分配资源，并减少重复启动进程，完整验证耗时更稳定。
 
+- Operator Chat 发送前会在接近模型窗口时主动压缩，压缩失败仍发送当前输入，不会把消息丢掉。DAG 节点同步启用 overflow 识别与线路压缩，但不在 streaming 中主动 compact。
+- 网关「请求上下文过大」及常见包装/嵌套 JSON 由共享分类器识别；目标项目 `loop-agent init` 生成的 Pi overflow extension 与控制器使用同一套短语表。
+- `@agent-context/sift@0.0.1-alpha.6` 作为可选依赖接入 Console 与 DAG：默认开启，`HARNESS_CONSOLE_SIFT` / `HARNESS_DAG_SIFT` 设为 `0`、`false` 或 `off` 即可关闭。Anthropic 缺省 prompt cache 形态保持 no-op，避免破坏缓存。
 - 后端测试的计划与生成阶段只读取任务明确绑定的需求、环境报告和本轮产物，减少无关仓库内容干扰结果，并让后续步骤继续使用同一份已确认计划。
 - Operator Chat 的任务清单工具描述补齐多步骤与 DAG 使用纪律：开始前按具体步骤规划、保持进行中约束、完成后立即更新完整列表，并用面向用户的阶段呈现 DAG 进度，简单任务自动跳过。
 - 正式发布会自动同步更新版本日志和文档站摘要；发布说明优先生成简洁自然的中文，生成服务不可用时也能安全完成发布。
@@ -186,6 +204,15 @@
 - Windows 上执行后端测试场景参数的 Python 语法检查时，会跳过不可用的 Microsoft Store 占位程序，避免错误回滚合法改动。
 - 旧版前端 DAG 也能识别增量计划修订，不再因契约格式差异反复重试；无法合并的修订会提示重新生成 DAG。
 
+- 修复 backend-test 的 Scenario Partition 计划表只提示 `each-value`/`omitted`、却由下游确定性门禁强制要求 `not-in-set` 的合同漂移；计划、Markdown Case 与 pytest 现在统一明确唯一补集槽位，避免 PI 因表格指令遗漏 `TP-<Partition ID>-NOT-IN-SET` 后触发 `MISSING_COMPLEMENT_SLOT`。
+- 修复文档审计扫描本地 `.scratch/` 临时证据与打包目录、导致仓库 preflight 和发布前验证被非治理文件阻断的问题。
+- 修复 backend-test 把 Markdown 明确声明的 enum-invalid、wrong-type、null、empty 和精确非法 custom literal 当作 payload enum 契约漂移、错误消耗唯一一次 pytest repair 的问题；豁免现在按 pytest parameter ID、目标字段和值逐 TP 绑定，positive/nominal drift 与 path 缺陷仍严格阻断。
+- 修复 backend-test 无法从同一生成模块的安全 payload helper 中绑定 field-target positional/keyword/default 参数，以及无法识别精确 `_without(payload, field)` 删除语义的问题；computed、动态、二层、跨模块和危险 helper 仍保持 `UNDETERMINED`。
+- 修复 backend-test 无法静态证明同一生成模块内安全 payload helper、导致 request-level nominal 场景长期停留在 `UNDETERMINED` 的问题；超长边界 observed 现在持久化为有界摘要并保留真实长度，空白修复建议也明确使用真实空格而非字面 escape 文本。
+- 修复 backend-test 把 Markdown 中 `\\u0020`/`\\x20` 空白表示与 pytest 真实空白字符串误判为 scenario-param 不一致的问题；readiness 的逐项排除现在携带有界的 TP、字段、expected/observed raw/normalized 和源码位置诊断，同时不对普通业务字符做 trim、大小写折叠或宽松解码。
+- 修复 Console 把 backend-test writer 的局部保护文件误判为整个 writeSet 越界的问题；任务级禁止路径仍保持硬阻断，合法 DAG 可继续取得 autonomous execution receipt。
+- 修复 backend-test 对 `resource_client.call(..., payload=...)` 一类本地 transport 的 payload AST 假阴性；readiness 新增固定分类/Case 排除汇总和 pytest 启动事实，payload repair finding 同时携带 expected/observed/missing path 清单。
+- 修复后端测试在 payload、fixture 与 Markdown→pytest 对应关系同时异常时只修复其中一类问题的问题；pytest 侧缺陷现在通过结构化 `repairFindings` 合并进入唯一一次有界 repair，Markdown Test Point 未分类或重复分类则在生成阶段定向重试并禁止下游猜修。
 - 修复重命名会话时输入框没有回显当前标题的问题。
 - 修复停止回复后输入区恢复迟缓、排队消息偶发丢失，以及切换会话后旧状态残留的问题。
 - 修复宽表格、文件预览、滚动条和窄屏布局中的多处显示异常。

package/dist/application/dag/generate-task-dag.js

@@ -109,8 +109,12 @@ function findForbiddenOverlapsForPacket(task) {
     const overlaps = [];
     for (const writeSetEntry of task.writeSet ?? []) {
         for (const forbiddenPath of task.forbiddenPaths ?? []) {
-            if (pathMatchesPattern(writeSetEntry, forbiddenPath) ||
-                pathMatchesPattern(forbiddenPath, writeSetEntry)) {
+            // A narrower forbidden child may intentionally carve a protected
+            // file out of a broader node writeSet. The runtime write guard gives
+            // forbiddenPaths precedence; report a packet conflict only when the
+            // writeSet entry itself is inside the forbidden boundary. Console G2
+            // separately rechecks task-global forbidden paths with live scope.
+            if (pathMatchesPattern(writeSetEntry, forbiddenPath)) {
                 overlaps.push({ writeSetEntry, forbiddenPath });
             }
         }

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.12",
-  "gitSha": "f6c24c6c6eaacfcc975732dec41df6ef5027f16c",
-  "builtAt": "2026-08-28T08:40:28.786Z"
+  "version": "0.39.0-beta.14",
+  "gitSha": "9d8bebca76a2608d9b38a1af1f379fd5fe5b04b0",
+  "builtAt": "2026-08-30T09:13:51.707Z"
 }

package/dist/commands/client-recovery.js

@@ -19,36 +19,11 @@ export const MAX_SESSION_RETRIES = 5;
 /** Hard cap for OpenCode overflow compact+resume recoveries (≤ 2). */
 export const MAX_OVERFLOW_RECOVERIES = 1;
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
+import { CONTEXT_OVERFLOW_PHRASES, buildGeneratedOverflowClassifierSource, isContextOverflow as classifySharedOverflow, } from "../shared/pi-context-pressure/overflow.js";
 export { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY };
-/**
- * Shared overflow phrase sources used by isContextOverflow and generated plugins.
- * Keep English + Chinese intranet gateway messages in one place to avoid drift.
- */
-export const CONTEXT_OVERFLOW_PHRASES = [
-    "请求上下文过大",
-    "context_length_exceeded",
-    "context overflow",
-    "context length overflow",
-    "too many tokens",
-    "maximum context",
-    "prompt is too long",
-    "request_too_large",
-    "context window",
-];
-function escapeRegExpLiteral(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-const CONTEXT_OVERFLOW_PATTERN = new RegExp(CONTEXT_OVERFLOW_PHRASES.map(escapeRegExpLiteral).join("|"), "i");
+export { CONTEXT_OVERFLOW_PHRASES };
 function buildGeneratedContextOverflowPatternSource() {
-    return `const CONTEXT_OVERFLOW_PHRASES = ${JSON.stringify([
-        ...CONTEXT_OVERFLOW_PHRASES,
-    ])};
-const OVERFLOW_PATTERN = new RegExp(
-  CONTEXT_OVERFLOW_PHRASES.map((phrase) =>
-    phrase.replace(/[.*+?^\${}()|[\\]\\\\]/g, "\\\\$&"),
-  ).join("|"),
-  "i",
-);`;
+    return buildGeneratedOverflowClassifierSource();
 }
 const PERMANENT_MESSAGE_PATTERNS = [
     {
@@ -65,7 +40,7 @@ const PERMANENT_MESSAGE_PATTERNS = [
     },
     {
         reason: "context-overflow",
-        pattern: CONTEXT_OVERFLOW_PATTERN,
+        pattern: /context_length_exceeded|请求上下文过大/i,
     },
     {
         reason: "cancelled",
@@ -180,6 +155,8 @@ function permanentReason(error) {
         return "api-error";
     }
     const text = collectErrorText(error);
+    if (isContextOverflow(error))
+        return "context-overflow";
     for (const entry of PERMANENT_MESSAGE_PATTERNS) {
         if (entry.pattern.test(text))
             return entry.reason;
@@ -192,7 +169,7 @@ function permanentReason(error) {
  * business validation, or standard 502/LLMRequestError as overflow.
  */
 export function isContextOverflow(error) {
-    return CONTEXT_OVERFLOW_PATTERN.test(collectErrorText(error));
+    return classifySharedOverflow(error);
 }
 function looksTransient(error) {
     const text = collectErrorText(error);
@@ -887,7 +864,7 @@ function textOf(error) {
 }
 
 function isContextOverflow(error) {
-  return OVERFLOW_PATTERN.test(textOf(error));
+  return isOverflowMessage(textOf(error));
 }
 
 function buildOverflowResumePrompt(sessionId, error, attempt) {
@@ -1163,11 +1140,6 @@ const EXTENSION_PATH = ${JSON.stringify(PI_CONTEXT_OVERFLOW_EXTENSION_PATH)};
 ${buildGeneratedContextOverflowPatternSource()}
 const NORMALIZED_PREFIX = "context_length_exceeded:";
 
-function isOverflowMessage(text) {
-  if (typeof text !== "string" || !text) return false;
-  return OVERFLOW_PATTERN.test(text);
-}
-
 export default function loopAgentContextOverflowExtension(pi) {
   void EXTENSION_PATH;
   pi.on("message_end", (event) => {