@tea-agent/loop-agent 0.42.0-next.9 → 0.42.1

package/CHANGELOG.md

@@ -2,41 +2,75 @@
 
 ## [Unreleased]
 
+## [0.42.1] - 2026-09-09
+
+### 新增
+
+- 新增了本发布周期内已经完成并通过验证的功能。
+
+### 改进
+
+- 完善了日常使用体验和运行稳定性。
+
+### 修复
+
+- 修复了影响使用体验或运行稳定性的问题。
+
+## [0.42.0] - 2026-09-07
+
+### 重点更新
+
+- **Operator Chat 内置只读 Explore 子 Agent**：主会话可通过 `Agent` 工具委派代码库搜索、符号查找和调用链追踪；子会话 Fresh、one-shot，只暴露 `find`/`ls`/`safe-*`/git 只读工具，父 Turn 停止时一并中止。工具目录中的 Explore 条目改由服务端 `builtinSubagents` 能力字段驱动，后端调整内置子代理时前端自动跟随。
+- **前端实现 DAG 稳定性集中修复**：修复 Plan coverage 会话提前停止导致会话数翻倍（切片穷尽才算完成）；修复重试梯级遮蔽修复指令（账本修复指引优先于 compact-terminal-first 话术）；修复 Plan 按 AC 分片重复发明同一批需求（UX registry 先全局提交再单一会话建模）；修复 design 拒绝后自动恢复子 run 无法启动（staging 正确物化拓扑绑定并继承 committed shape facts）；修复自动恢复实际重跑整棵 DAG、忽略冻结 reset plan 的问题；`stopReason=length` 截断改判为专门的 `output-limit` 可重试类别，不再误判 `empty-output`；重试额度默认从 3 次提升到 5 次。
+- **前端 verification contract v2**：plan 不再手写五值 `type`，改为引用生成期冻结命令目录的 `commandId`，`type: component + npm run build` 这类非法组合在 Plan 工具边界即被拒绝；冻结验证命令引用的基建文件（如 vitest 配置）确定性并入 writeSet admission 边界，writer 不再被具体 writeSet 拦住；Verify bundle 按工作目录和冻结命令去重，static/behavior/Mock/lint lane 复用相同命令结果。
+- **backend-test 判定链修复**：N2 不再把 provider 长度截断的 Markdown 计划误判为 `FINISHED`（截断归 `output-too-large`、缺 heading 归 `invalid-output`，均有界 artifact-first retry）；N3 以唯一合法 Markdown Path 为 canonical 模块身份（Stem 展示单元格只作冗余展示）；唯一 pytest collection repair 缺 `IMPLEMENTATION_OUTCOME` 不再阻断整条执行链（确定性恢复为候选 changed 后仍走全部门禁）。
+- **契约幂等与 DAG 恢复强化**：契约重复 prepare 做内容级 no-op 短路（投影与已记录契约及磁盘哈希一致时不递增 revision、不写事务、writeSet gate digest 绑定 hash 不变则继续有效——实测 8.6 小时流水线 7 次修订只有 3 个不同 hash）；workspace-drift 细化为内容级逐路径对比（漂移全落在重跑子图自身 readSet/writeSet 内时放行）；superseded run 可作为 `dag rerun --from-node` 的事实供体；DAG 退出诊断改用只读异常监视器。
+- **工具入参预览放宽**：工具入参预览从 1200 字放宽到 4000 字（与会话结果落盘上限对齐），详情栏支持「展开全部」（可视高度最多 720px），Explore 等长 brief 不再被预览截断误导。
+
+### 改进
+
+
+
+- DAG 退出诊断改用只读异常监视器，避免诊断逻辑改变宿主异常策略或中断其他并发 run 的取证；退出码使用实际 exit 事件参数。
+- 前端分片 VT 归一化同步处理 `replaces` 引用，避免重试修正因分片前缀不同而无法覆盖旧事实。
+- 强化 DAG 恢复与契约幂等：重跑计划不会复用 imported 节点读取的漂移输入、缺失/未完成节点，并且仅在 Git HEAD 相同、rename 与治理输入清单可完整判定时放行 scoped drift；`stopReason=length` 的 transport 别名可正确重试。契约 no-op 写入 request ledger 但不伪造事务，重复请求携带新 payload 会被拒绝，且 no-op prepare 不再无谓刷新 DAG。
+- 修复契约重复 prepare 空转的问题（实测一次 8.6 小时的流水线里 7 次契约修订只有 3 个不同内容 hash，无内容变化的重复提交每次都走完整事务提交 → 契约投影 → DAG spec 生成 → strict validation → writeSet gate 审查）：apply 现在做内容级 no-op 短路——投影结果与已记录契约及磁盘观测哈希完全一致时直接返回当前 ref，不递增 revision、不写日志化事务；writeSet gate digest 绑定 contractRevision+canonicalHash，hash 不变则已批准的 gate 继续有效，不再重复审批。磁盘漂移（observed ≠ ref）不走短路，仍是修复投影。
+- 修复 workspace-drift 一刀切阻断 `dag rerun --from-node` 的问题：整指纹对比细化为内容级逐路径对比，漂移全部落在重跑子图自身 readSet/writeSet 内时放行（`workspace-drift-scoped`，重跑本就会重读/重写这些路径）；其余情况（导入事实复用节点的输入漂移、无法判定路径的旧 checkpoint）保持严格阻断，高风险写者续跑路径维持整指纹严格判定不变。契约同 hash 重投影不再改写文件，与此叠加后恢复路径不再被无意义漂移阻断。
+- superseded run 现在可作为 `dag rerun --from-node` 的事实供体：操作员取代的是 run 整体，其 FINISHED 只读上游节点（contract/scout 等）经既有导入机制继承，不再因父 run 被取代就强制全量重跑；writer 进重跑子图、决策门禁、未解决 ERROR 在闭包外等不安全场景各自的原有阻断不变。
+- 修复前端 Plan coverage 会话提前停止导致会话数翻倍的问题（run 3 实测每会话平均仅 1.7 个 record 调用即写结论，把一个切片的活摊到两个会话）：coverage 段指令与 COVERAGE BATCH 提示现在明确「切片穷尽才算完成」——本会话分配到的每个需求都必须有已提交的 coverage facts（verification targets 或 evidence gap）才能收尾，批量提交直至穷尽，提前停止会把剩余项拖成 MISSING-FACT 修复会话；MISSING-FACT 队列降级为校验兜底而非主要补齐机制。
+- 修复前端 Plan 重试梯级遮蔽修复指令的问题：invalid-output / structured-output-truncated 的账本修复指引现在优先于 compact-terminal-first 等梯级话术。此前 length 失败把重试梯级单调升到 compact-terminal-first 后，后续 invalid-output 重试拿到的是「保持已提交账本完整」的档位指令，与「重提交修正后的 record_* facts」这一唯一治愈动作正面冲突，修复指引成为死代码；修复指引同步补上 duplicate/replace 语义（duplicate 收据是修正邀请而非禁令，replace=true 为同 id 全量替换，回填反向引用不属于重推导已提交事实）。`skills/frontend-plan` 新增跨段引用规则与 Bidirectional VT cross-reference invariant 小节：跨切片引用已提交 VT 时当场以同 id + replace=true 回填，双向引用在提交时即闭合，不再拖到 attempt 末尾的双向检查才暴露。
+- 修复 DAG Pi 节点把 provider `stopReason=length` 的输出/上下文截断误判为 `empty-output` 失败的问题：仅 `empty-output` 基础上的长度截断会改判为专门的 `output-limit` 可重试类别（raw 类别保留诊断），已有精确修复指令的类别（output-too-large / invalid-output / protocol-invalid / structured-output-truncated / writer 类）原样保留，避免通用指令遮蔽任务专属修复提示；`output-limit` 通用增量指令（从已提交 typed facts 与现有工作区只补未完成部分、每个生成单元产出后立即校验格式并在当节点修复）作为兜底排在所有精确分支之后，前端规划梯级（compact-terminal-first 正是 length 场景的领域档位）与结构化冻结修复路径优先。只读/结构化/前端规划/后端测试补全策略的默认重试额度从 3 次提升到 5 次；旧 artifact 中的 `writer-thinking-exhausted` / `planner-thinking-exhausted` 终态标签仅作历史保留（Console/报告展示映射同步归入 executor 容量类），新执行不再产生。
+- 前端 Scout 在中高复杂度任务中并行收集 target surface 与 design evidence；大型 Plan 将 requirement coverage 按批次并行映射，再按固定顺序归并到唯一 reducer，保持 Contract → Scout → Plan 依赖与确定性终态，同时缩短最长串行等待。
+- 前端 Verify bundle 会在同一次执行中按工作目录和冻结命令去重：static、behavior、Mock、lint lane 复用相同命令结果，同时为每个 lane 保留独立证据，避免重复启动耗时的 typecheck/test/build 进程。
+- 前端 Micro/Small shape 路由不再把 `test/`、`e2e/`、`docs/` 等验证或文档根目录误计为业务跨域；`src/**` + `test/**` 的局部 UI 改动现在可以正确命中轻量拓扑，真实跨包路径仍保持升级。
+- 修复前端 Plan 漏读独立行为证据、重试丢失已重新录入的 UX 名称的问题；必交付文件改由 Contract 显式声明并绑定原始来源，避免把允许修改或参考路径误判为交付义务。缺失交付物和 UX 名称冲突现在可在 Plan 提交前发现并修正，发布 schema 同步支持组件覆盖与复用证据字段。
+- 修复前端 DAG 的 Plan 按 AC 分片重复发明同一批需求、交互和 UI 状态的问题：Contract 的 canonical requirement 文本与来源片段改由 runtime 从冻结 ledger 写入，Plan 先基于全部需求提交一次全局 UX registry，再在单一全局 UX 会话中建模组件、状态和交互；来源声明的 UI 状态必须完整闭合，复用既有组件必须提供真实存在的文件证据，交付文件完整性与逐状态/交互组件覆盖由确定性 gate 校验。
+- 修复顶部一级「观测」入口被恢复工作区残留的 DAG 或上次观测对象劫持的问题：现在点击该入口始终回到当前 Workspace 的运行总览，具体 DAG 仍通过「全屏观测」等显式入口打开。
+- 修复节点检查器通俗字段旁的问号只有图标、悬浮时看不到具体说明的问题；问号现在支持鼠标悬浮和键盘聚焦，并显示对应字段含义及原技术字段。
+- Next 发布测试升级到 Vitest 4.1.11，采用上游 worker RPC 修复，避免所有断言通过后仍因 `onTaskUpdate` 通讯超时阻断发包；同时隔离会改写构建产物的 package-surface 测试，并恢复两条此前被错误嵌套、实际未执行的 Console 更新回归；发布门禁继续严格检查 unhandled errors。
+- 前端计划契约新增确定性锚定校验（恶劣网关冒烟 4 轮 design 拒绝的主因）：behavior 验证目标必须至少引用一个 requirement，且在契约声明了 UI 状态或交互时必须引用至少一个已声明的 UI 状态（纯逻辑契约豁免）。校验位于共享 schema refine，plan 节点的自修阶梯当场拿到精确到字段的报错并修复，不再烧一整轮 design-review 才发现映射缺失；`skills/frontend-plan` 决策契约参考同步补充 canonical 示例（behavior target 形态、状态名逐字引用、stylingStrategy 禁止承诺任务源非目标能力）。
+- 修复前端 design 拒绝后自动恢复子 run 无法启动的问题（恶劣网关前端冒烟三轮复现）：staging 物化 child state 时现在按 child spec 写入 `frontendShapeState` 冻结拓扑绑定（此前 execute 前的绑定断言以 `frontend topology binding is missing` 在 398ms 内 fail-closed），并把父 run 中已导入边界节点（contract/scout 等 FINISHED 导入节点）的 committed shape facts 一并继承——否则 child 会在首个 shape 门禁以 `frontend-shape-fact-invalid` 整体 SKIPPED；reset 边界由重跑节点重新提交。同时修复 recovery child runId 派生误传参导致碰撞安全后缀失效、可与已归档 run 同名的问题（默认 `buildDagRunId` 现在正确收到 `{ cwd }` options）。
+- 修复 backend-test N2 把 provider `stopReason=length` 的截断 Markdown 计划误判为 `FINISHED`、继而延迟到 N3 `missing-module-index` 的问题：长度截断现在在 producer 节点归类为 `output-too-large`；正常结束但缺少必需 heading、Module Index 八列表/模块行或使用代码围栏时归类为 `invalid-output`。两类失败均使用有界 artifact-first retry，下一 attempt 只携带控制器生成的限长协议诊断；N3 ownership/path/模块数门禁与业务 pytest 单次执行不放宽。
+- 可选依赖 `@agent-context/sift` 从 `0.0.1-alpha.6` 精确 pin 升级到 `0.0.1-alpha.7`：新增 `retrieveLines` 行级分片取回与省略点内联 stash 路径/起始行号（模型可直接换算 read 行号），纯文本压缩策略更保守（不同编号/状态的内容不因句式相似而合并）；桥接层沿用既有 `createSift`/`siftRequest`/`retrieve` API，行为与回退开关不变，仍不投影 init。
+- 修复后端实现 DAG Pi 扩展 resolver 无法解析版本 pin spec 的问题：`packageNameFromSpec` 现在剥除尾部 `@<version>`/`@<dist-tag>`（保留 scoped 包名开头的 `@`），与 Console 插件面语义对齐。此前 settings 中的 `npm:pi-lens@3.8.72`（Console 升级插件写入的形式）会被当作包名 `pi-lens@3.8.72`，永远匹配不上别名表，读侧节点（contract/scout/plan/verify）的 `pi-lens` 全部静默降级为 `not-installed`；`pi-extensions.json` 观测产物可鉴别此场景。
+- 修复前端自动恢复实际重跑整棵 DAG、忽略已冻结 reset plan 的问题：恢复 operation 现在校验 operationId/lease 归属，按 parent recovery plan 导入已完成事实并只执行 reset 子图；设计拒绝缺少 typed findings 时 fail-closed；多轮 continuation 会继续注入共享 recovery controller、递增并校验完整 lineage；崩溃重放会复用 completed child；缺少已绑定 child lineage 的伪成功 operation 不再标记 recovered；rerun-task 的全局 requestId 重放会校验请求类型、父 run 与完整 payload，避免串用其它请求结果。
 - 冒烟再暴露 writeSet 授权缺口：冻结验证命令引用的基建文件（如 `--config` 的 vitest 配置）不在 plan verification targets 内时，writer 被具体 writeSet 拦住无法创建、verify-shell 必然失败。现在 admission 生效边界确定性并入冻结命令引用的文件（机械提取、仍受 allowedPaths/forbiddenPaths 约束），writer 聚焦检查失败后可自行补齐基建文件。
+- 前端 verification contract v2：plan 不再手写五值 `type`，改为引用生成期冻结命令目录的 `commandId`，`mode（static|behavior）` 与 `commandLabel` 由 runtime 在物化时解析——`type: component + npm run build` 这类非法组合在 Plan 工具边界（`verification-target-unknown-command`）与物化校验（`verification-target-phase-mismatch`，behavior 命令必须绑定测试文件）即被拒绝，不再拖到 writer focused-check 才以 `invalid-output` 失败；展示用的 `scope` 不参与控制流。
 - 修复 /inspect/* 静态资源（operator-chrome.js/css、观测文档）缺少 Cache-Control 的问题：现在与 Console SPA 一律 `no-store`。此前浏览器启发式缓存会让 Console 更新/重启后继续挂旧版导航模块，表现为顶部导航「回退」到只有操作/观测、缺少对话入口的旧版布局。
-
-- 冻结验证命令引用的文件（如 `--config` 的 vitest 配置）现在必须在 plan 阶段就有 verification target 覆盖：缺失会作为缺失事实驱动 coverage/compact/finalize 会话当轮补记并进入 admission writeSet，无法补齐则在 plan 阶段确定性失败，不再等到 verify-shell 才以 missing config 失败。
-- 修复 writer 终态失败 run 无法重跑的问题：rerun 反馈的 writer 失败通道把 `attemptSummary.completedPasses` 硬编码为 0，被 `dagRerunFeedbackSchema` 的 positive 校验拒绝，导致 `dag rerun-task` 在解析父 run 反馈时崩溃；现与相邻通道一致取 1。
-- 冒烟再暴露并修复 planner 思考烧尽：compact Plan 首会话因 `stopReason=length` 只思考零提交时，先做一次 tool-first 同 scope 重试，仍失败则机械降级为按需求减半的 coverage 分批会话；耗尽后归类为 `planner-thinking-exhausted` 并给出 thinking=off/换模型建议，不再原样重放同一 prompt 烧完修复预算。
-- 继续加固前端恢复：生产 `runDag` 现在使用共享 Console operation store 执行带反馈的 `dag rerun-task`，避免恢复 descriptor 无法解析；compact Plan 仅在单 target surface 生效，finalize 提示与 concrete writeSet 路径统一规范化。
-- 修复前端冒烟暴露的 P0/P1 流程问题：设计评审 `request_design_changes` 现在 fail-closed 阻断 writer，自动恢复从 Plan 重启并携带 findings/evidence；admission 冻结的 concrete writeSet 同时成为 writer 的实际授权边界，legacy `admitted` 不再放行；长度耗尽且零写入的 provider 结果按 `writer-thinking-exhausted` 归类。生产小型 Plan（≤8 个需求且估算调用量受控）合并为两次 Pi session，并在 session 间刷新 typed ledger 上下文；Scout 重试仅补 unresolved 路径，减少重复侦查与上下文消耗。
-- 修复 backend-test 对 `payload = {...}` 经 `dict(payload)` 和 `**kwargs` wrapper 透传时漏观测请求字段的问题：保守传播 wrapper 参数别名与浅拷贝 payload，并按分支实际赋值观察 scenario 字段；继续保持 payload SAFE、EXACT_1_TO_1、scenario MATCH 与 fail-closed 门禁。计划生成提示词同时明确无有限分区域时省略整个 `## Scenario Partitions` 章节，避免生成 prose-only 空节触发 N3 阻断。
-- 修复 Operator Chat 打开已丢失会话时把孤儿 JSONL 升级成 503、以及删会话后残留 workspace 选择被误报为跨工作区冲突的问题：缺失会话文件现在自愈为 404 并清掉记录，前端恢复路径安静忘记该会话。
-- 修复前端 `--from-text` 任务缺少 source-fidelity ledger、DAG 生成后降级为 v1 并在 `frontend-contract-pi` 0ms 失败的问题：文本入口现在持久化可校验的 v2 绑定输入，init-hybrid 复用任务自有需求源；Console 默认模型与 Pi readiness 同时排除无凭据 provider，避免把不可执行模型误报为可用。
-- 常规回归 `npm test` 默认跳过约 6 分钟的 I/O-heavy 测试池（仍跑 fast + integration）；完整三池改为 `npm run test:full` / `LOOP_AGENT_FULL_TEST=1`。本地 `ci.sh`、GitHub PR 与 release/next 发布门禁仍跑全量，不降低交付验证。
-- 修复 backend-test 把 `pytest.param({"title": ""})` 整段 dict 当成 empty 观察、且 `example=` 空值导致 `target=body.title` 解析失败的问题：空 example 仍解析 field，dict 内空字符串按字段 MATCH。
-- 修复 backend-test 把自动化映射多写的横切测试点当成 Markdown BLOCKED、挡住 N11 修 docstring 的问题：只拦 `### 测试点` 未恰好绑定一次。
-- 修复 backend-test 把 pytest `_MISSING` 哨兵当成普通 Name、可选 `min; bound=0` UNDETERMINED 的问题：`_MISSING` 与 `_OMIT` 同为省略键。
-- 修复 backend-test 把可选字段 `min; bound=0` 的 `_OMIT` 判成 UNDETERMINED 的问题：省略键视为空最小；`OMITTED` TP 视为 missing。
-- 修复 backend-test 对 `http_client(operation, json_body=dict)` 观察不到 payload 的问题：http-like Name-call 的第一参是参数化 method 变量时仍计入 `json_body`。
-- 修复 backend-test 把 Markdown `Payload Required Paths: false` 当成路径、GET filter 整 Case UNSAFE 的问题：`true`/`false` 与 `none` 一样不是 path。
-- 修复 backend-test 把列表反引号里的 `场景意图: ... bound=0` 解析失败、并把 `max+1` 的数字 1 当成 minLength 的问题：围栏行可解析，`+/-` 后缀数字不进 prose 窗。
-- 修复 backend-test 把 fixture `http("POST", path, json_body={"title": ...})` 当成无 payload、整 Case PAYLOAD_SHAPE_MISMATCH 的问题：首参为 HTTP method 的 Name-call 进入 observedPaths。eligibility 门禁不放宽。
-- 修复 backend-test 把 `intent=min; bound=0` 当成缺 bound 并落到 `maxLength`、导致空 content MISMATCH 的问题：无 `minLength=` / TP LEN 时保留 0；`max; bound=0` 仍是哨兵。
-- 修复 backend-test 把 evidence-only pytest stub（模块 docstring + Case-ID、无 `def test_`）当成截断脚本、N9 `incomplete-write-set` 的问题：闭合 stub 可通过 completeness，半截 `def (` 仍 fail-closed。
-- 修复 backend-test 把 Markdown 机器行 `intent=max-1; bound=99` 当成契约 max、导致 `x*99` MISMATCH 的问题：`max-1`/`max+1`/`min-1` 优先 `maxLength=` 与文案三元组。eligibility 门禁不放宽。
-- 修复 backend-test 把 pytest 多写、Markdown 没有的 `0:1` extra symbol 当成 Markdown Test Point binding 缺陷并 BLOCKED 的问题：这类条目进入 N11 删除多余函数，不再清空 pytest repair。
-- 修复 backend-test N12 只读 effective collection 再次跑 scenario-param 确定性写回、在 `filesystem-only` 下 `write-guard` 失败的问题：N12 只复验，不再改 pytest。N10 仍可修一次。
-- 修复 backend-test 把 `脚本：无` 的 evidence-only Case 当成缺 pytest 符号送进 N11 的问题：精确 1:0 元用例不再触发 `missing-pytest-symbol` repair，N11 不得发明业务函数。真缺符号的 1:0 仍可修。eligibility 门禁不放宽。
-- 修复 backend-test 把 Scenario Partitions 数据行的 exact `TP-SP-...` 清单写成第 8 列、导致 N6 `MISSING_PARTITION` 的问题：仅当尾列全是该 Partition 的 slot ID 时确定性裁成 7 列并写回 run-owned plan。7 列契约与非 slot 多余列 fail-closed 不放宽。
-- 修复 backend-test scenario 把 `intent=max-1` 当成 unknown、以及 Markdown 只写「100 个字符的最大 / 1999、2000、2001」时解析不到 bound 的问题：`max-1` 进入 closed set，长度清单三元组与「N 个字符的最大」可得到 MATCH。eligibility 门禁不放宽。
-- 修复 backend-test correspondence 把前面函数的 `pytest.param(..., id="TP-...")` 叠进后续 Case `parameterIds` 的问题：decorator 区域遇到上一 `def`/`class` 或非 decorator 续行即停，不再把整组打成 `TEST_POINT_BINDING_EXTRA`。eligibility 门禁不放宽。
-- 修复 backend-test scenario facts 把内部 max/min/oversize helper 哨兵 `-1/-2/-3` 写成 `observedLength`、导致 N10 在 schema `min(0)` 上 `invalid-output` 的问题：这些 helper 仍按 Markdown bound MATCH，持久化长度只保留非负值。
-- 修复 backend-test 把 GET `params=`/`query=` 过滤字段、Python `True`/`False` 布尔字面量和混合大小写 `pytest.param` 列表漏出 correspondence/payload/scenario 观察的问题：这些 variant 现在可以按 item 授权，而不再把整 Case 打成 `PAYLOAD_SHAPE_MISMATCH` / `VARIANT_PARAMETER_MISSING`。eligibility 门禁不放宽。
-- 修复 backend-test 计划协议标题被翻译成中文后 N3 直接 `missing-module-index`、以及 Markdown writer 漏写精确 Scenario Partition slot 只能等到 N6 才失败的问题：N3 现在把 `## 模块索引/覆盖范围/覆盖矩阵/场景分区` 确定性改写成英文 canonical heading 并最多写回一次 run-owned `plan.md`，同时展开 slot 清单写入 `contracts/backend-test-scenario-partition-slots.json` 并注入 map child `requiredVariantSlots`。Markdown shard completeness 对缺失精确 `TP-SP-...` variant 报 `incomplete-partition-slot-set` 并允许一次有界补写。覆盖语义按方案 A：Case 数量可以少于枚举数量，但每个 slot 仍须独立 variant Test Point；`SINGLE`/`MULTIPLE` 不计覆盖。N6 fail-closed 不放宽。
-- 修复 backend-test strict Markdown map writer 的 upstream artifact pointer 泄漏：当长上游输出的 `stdout.md` 不在当前节点 `readSet` 时，不再向 Pi 注入不可读取的 artifact 路径，避免模型触发 `read-outside-read-set` 后进入 pending；保留有界 preview，并新增回归覆盖严格 writer 边界。
+- 新建、删除和切换对话的反馈更及时；会话列表默认展示 5 条，“展开其余会话”和“收起”也更整齐易用。
+- 发送消息后会立即显示在对话流中，完成回合的过程摘要也更清晰，长时间等待连接时不会让输入内容消失。
+- 文件预览支持页面内交互和独立窗口阅读，大型 HTML 内容也能完整打开。
+- 模型配置更新后，继续使用旧会话时会自动采用最新认证信息，消息流顺序也更加稳定。
+- 执行记录默认跟随最新内容，也可以暂停自动滚动并保留当前阅读位置。
+- 任务执行、恢复和结果查看更加稳定，工作区和滚动区域的使用体验得到改进。
+
+<details>
+<summary>实现细节（开发者参考）</summary>
+
+- Operator Chat 会话列表默认收敛为最近 5 条；展开与收起控件采用稳定的整行布局，折叠工作区后恢复默认列表；长历史会话改为分页加载，并在加载更早消息后保持原有滚动位置。
+- Operator Chat 长会话增量构建活动 turn、复用已完成过程节点，并支持对已完成且无错误的历史 turn 进行 Compact，降低长消息流的渲染开销。
 - 修复 backend-test Manifest 把模型生成的 Module Stem 展示单元格当成模块身份真源、导致 low-tier 输出（缺 `test_` 前缀或整段 Markdown 链接）在 N3 `module-markdown-path-mismatch` 反复失败的问题：N3 现在先解析唯一合法 Markdown Path 与 `<stem>.md` 相对链接作为 canonical 身份，再校验业务 ownership/split 与路径安全；Stem 单元格只作冗余展示并能确定性重写为 canonical 文件名 stem。strict `backendTest.moduleLayout` 改为先按唯一 required Markdown Path 定位模块，再恢复冻结 Markdown/Pytest path pair，避免错误 stem 提前丢弃整行，同时保留 Plan-only pytest path 修复。Markdown Path 缺失/多候选/越界或与 strict path pair 冲突、以及多行 canonicalize 后同 identity（`duplicate-canonical-module-stem`）继续 fail-closed，不再静默去重。同步加强 N2 prompt（Stem 单元格仅允许纯文件名 stem）。
-- 修复 Next Release 的 io-heavy 测试并发不稳定：发布 workflow 将该池固定为单 worker，避免全部测试已通过后触发 Vitest `onTaskUpdate` RPC settlement timeout，并消除 controller identity/package fingerprint 测试之间的共享状态竞态；不跳过或删除任何测试。
+- 修复 Next Release 的 io-heavy 测试不稳定：在保留发布单 worker、完整测试集合和严格 unhandled-error 门禁的同时，将 Vitest 升级到包含上游 RPC settlement 修复的 4.1.11，避免全绿测试因 `onTaskUpdate` timeout 退出 1；会重建共享 `dist/**` 的 package-surface 测试改由单 worker integration 池持有，避免与 controller identity 指纹检查竞态；并把误嵌套在 `dagDoctor` stub 中的 `consoleUpdateAndInit` suite 移回顶层、补齐 `workspaceId` 契约，使两条回归重新进入真实执行。
 - 修复 backend-test 唯一 pytest collection repair 已产生受控非空修改、却因模型遗漏 `IMPLEMENTATION_OUTCOME` 而阻断整条执行链的问题：仅 N11 exact repair writer 可把完全缺失的 outcome 确定性恢复为候选 changed，随后仍必须由 N12 重新通过 scenario、correspondence、payload、collection、fixture 和 readiness 门禁；unknown/conflicting/blocked、空 diff、越界写入及 provider/context failure 继续 fail-closed。
 - 新建和删除对话现在会立即在侧栏中反馈：新建时先显示“正在创建”，删除时平滑淡出；网络失败会自动恢复原会话，不再需要等待整张会话列表刷新后才看到变化。
 - 新建对话会优先复用当前工作区中真正的空白会话，避免重复创建；有历史消息、工具调用、待发送内容或正在运行的会话不会被复用。
@@ -49,6 +83,50 @@
 - 修复 Operator Chat 长工具链的消息错序：模型过程文字、思考和工具卡片现在按服务端事件顺序稳定交替展示，刷新历史会话后也保持相同顺序。
 - 修复 Operator Chat 旧会话继续使用过期模型认证的问题：模型配置变化后，下一轮发送或手动重新加载会自动刷新模型目录和当前模型认证。
 
+</details>
+
+## [0.41.3] - 2026-09-04
+
+### 改进
+
+- 完善了本发布周期内的日常使用体验和运行稳定性。
+
+### 修复
+
+- 修复了部分功能在特定环境下无法正常使用的问题。
+
+## [0.41.2] - 2026-09-04
+
+### 修复
+
+- 修复了 DAG 扩展解析、会话恢复和观测页面资源缓存等问题，让任务执行和对话页面在更新后更加可靠。
+- 修复了孤儿会话和观测入口偶发失效的问题，重启或刷新后可以继续使用原有会话。
+
+## [0.41.1] - 2026-09-02
+
+### 修复
+
+- 修复发布流程中的测试并发稳定性问题。
+- 修复旧会话继续使用过期模型认证的问题，配置更新后会自动采用最新认证信息。
+- 修复长工具链消息错序，历史会话也保持正确顺序。
+- 统一工作区、Todo 和其他滚动区域的滚动条样式。
+- 改进 HTML 文件预览，支持页面内交互和独立窗口完整阅读。
+
+### 测试
+
+- Pi MED 档测试改为校验模型档位形状，避免具体模型切换造成误报。
+
+## [0.41.1-beta.0] - 2026-08-31
+
+### 用户可见更新
+
+- 前端自动化任务的规划、执行和结果检查更加稳定，失败后更容易继续处理。
+- 长任务和复杂工作区的进度、文件和运行结果展示更加清晰。
+- 插件管理、文件预览和任务详情等常用操作得到改进。
+
+<details>
+<summary>实现细节（开发者参考）</summary>
+
 - 0.41.1-beta.0（frontend-node dogfood）：将前端 DAG 的 Contract、Scout、Plan 切换为节点专属 skill/reference，bounded implement 仅注入有界代码规范；在保留默认 3K/12K 上下文预算的同时，避免 `frontend-plan-pi` 的必需 stable-id 追踪合同被静默截断。
 - 拆分前端 DAG 的大一统 skill 注入：`frontend-contract-pi`、`frontend-scout-pi`、`frontend-plan-pi` 分别使用阶段专属 skill/reference，默认 12K runtime 预算内完整加载关键合同，不再让三个节点重复携带整份 node lifecycle、设计与代码规范；bounded implement 单独接收不授权扩展侦察的代码规范。新增真实默认预算回归断言，防 required reference 再次静默截断或因预算遗漏。
 - 修复 frontend behavior verification 的伪 symbol 追踪：Plan 不再提交自由文本 `symbol`，改以非 static `verificationTarget.id` 作为稳定 token，并允许一个行为级 VT 覆盖多个相关 requirement；Implement 必须把 token 写入真实 `describe` / `it` / `test` 字面量标题。writer 完成边界新增轻量 trace preflight，缺失 token 时以 `needs-repair` 在 full verify 前失败；最终 trace gate 保留复验，并排除注释、普通字符串与 `VT-0010`/`VT-001` 前缀误命中。
@@ -269,19 +347,7 @@
 - 右侧辅助栏统一承载文件、上下文、调用记录、运行活动和当前 DAG；点击消息流中的运行状态即可在同一侧栏查看运行、门禁与产物，并可自由调整侧栏宽度。
 - 新增任务清单与结构化提问卡片，让长任务的进度和需要用户选择的内容更容易理解。
 - 「对话 / 操作 / 观测」使用统一导航；操作和观测页面可以切换工作区查看对应数据。
-## [0.41.1] - 2026-09-02
-
-### 修复
-
-- 修复 Next Release 发布 workflow 的 io-heavy 测试并发不稳定：将该测试池固定为单 worker，避免全部测试通过后因过高并发触发 Vitest `onTaskUpdate` RPC settlement timeout，并消除 controller identity / package fingerprint 测试之间的共享状态竞态。
-- 修复 Operator Chat 旧会话继续使用过期模型认证的问题：模型配置变化后，下一轮发送或手动重新加载会自动刷新模型目录和当前模型认证。
-- 修复 Operator Chat 长工具链的消息错序：模型过程文字、思考和工具卡片现在按服务端事件顺序稳定交替展示，刷新历史会话后也保持相同顺序。
-- 统一工作区、Todo 和其他滚动区域的滚动条样式，默认更轻巧，鼠标悬浮时也更容易辨认。
-- HTML 文件预览现在支持页面内的标签切换等交互；较大的自包含 HTML 可以在新窗口中直接完整加载，不再受源码摘要长度限制。
-
-### 测试
-
-- `harness.json` Pi MED 档测试不再 pin 具体模型 id，改为校验 tier 形状，避免每次 dogfood 档位切换都造成测试失败。
+</details>
 
 ## [0.41.0] - 2026-08-31
 

package/dist/application/dag/run-dag.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { DAG_ABSOLUTE_MAX_WALL_CLOCK_MS } from "../../shared/timeout-policy.js";
 import { createDagEventObserver } from "../../workflows/dag/event-observer.js";
 import { composeDagRunObservers } from "../../workflows/dag/observer-compose.js";
 import { createDagCanvasObserver, resolveCanvasPath, } from "../../workflows/dag/canvas-observer.js";
@@ -29,10 +30,11 @@ function buildRunDagNextSteps(runId) {
         `loop-agent dag report --run-id ${runId} --markdown  # advanced forensic`,
     ];
 }
-async function buildDefaultFrontendRecoveryDeps(repoRoot) {
+/** Shared production recovery seam for fresh runs and recovery continuations. */
+export async function buildDefaultFrontendRecoveryDeps(repoRoot) {
     // Keep the application layer free of a static worker→application cycle. The
     // recovery controller is only needed after a frontend terminal failure.
-    const [{ openConsoleAppData }, { OperationStore }, { createOperationEventStore }, { LoopAgentClient }, { resolveSiblingLoopAgentBin }] = await Promise.all([
+    const [{ openConsoleAppData }, { OperationStore }, { createOperationEventStore }, { LoopAgentClient }, { resolveSiblingLoopAgentBin },] = await Promise.all([
         import("../../infrastructure/console/app-data.js"),
         import("../../infrastructure/console/operation-store.js"),
         import("../../worker/console/operation-sse.js"),
@@ -46,6 +48,9 @@ async function buildDefaultFrontendRecoveryDeps(repoRoot) {
     });
     const client = new LoopAgentClient({
         loopAgentBin: resolveSiblingLoopAgentBin(),
+        // rerun-task awaits the entire continuation, not just task preparation.
+        // Use the same hard ceiling as the DAG runner and Console entry point.
+        defaultTimeoutMs: DAG_ABSOLUTE_MAX_WALL_CLOCK_MS,
         artifactRoot: path.join(appData.root, "client-artifacts", appData.fingerprint),
         resolveIdentity: true,
     });
@@ -53,6 +58,7 @@ async function buildDefaultFrontendRecoveryDeps(repoRoot) {
         store,
         operationRunnerDeps: {
             store,
+            defaultTimeoutMs: DAG_ABSOLUTE_MAX_WALL_CLOCK_MS,
             events,
             client,
             repoRoot,

package/dist/application/evaluation/budget.js

@@ -13,6 +13,7 @@ export const campaignBudgetLimitsSchema = z
     maxTokens: z.number().int().positive().optional(),
     maxWallTimeMs: z.number().int().positive().optional(),
     maxExecutorCalls: z.number().int().positive().optional(),
+    maxProviderRequests: z.number().int().positive().optional(),
     maxRepairPasses: z.number().int().nonnegative().optional(),
     maxConcurrency: z.number().int().positive().optional(),
     maxContextChars: z.number().int().positive().optional(),
@@ -22,12 +23,13 @@ export const campaignBudgetLimitsSchema = z
     const hasHardDim = limits.maxTokens !== undefined ||
         limits.maxWallTimeMs !== undefined ||
         limits.maxExecutorCalls !== undefined ||
+        limits.maxProviderRequests !== undefined ||
         limits.maxRepairPasses !== undefined ||
         limits.maxContextChars !== undefined;
     if (!hasHardDim) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: "budget.limits requires at least one of maxTokens, maxWallTimeMs, maxExecutorCalls, maxRepairPasses, maxContextChars",
+            message: "budget.limits requires at least one of maxTokens, maxWallTimeMs, maxExecutorCalls, maxProviderRequests, maxRepairPasses, maxContextChars",
         });
     }
 });
@@ -47,6 +49,7 @@ export function createBudgetLedger(budget) {
             tokens: null,
             wallTimeMs: 0,
             executorCalls: 0,
+            ...(budget.mode === "hard" && budget.limits.maxProviderRequests !== undefined ? { providerRequests: 0 } : {}),
             repairPasses: 0,
             peakContextChars: 0,
             missingTokenNodeIds: [],
@@ -136,6 +139,19 @@ export function recordNodeBudgetSample(ledger, sample) {
 export function isHardBudgetBreached(ledger) {
     return Boolean(ledger && ledger.mode === "hard" && ledger.status === "breached");
 }
+/** Reserve before dispatch. The caller must persist the shared ledger before granting admission. */
+export function reserveProviderBudget(ledger, nodeId) {
+    if (ledger.limits.maxProviderRequests === undefined)
+        return undefined;
+    const used = ledger.consumed.providerRequests;
+    if (used === undefined || !Number.isInteger(used) || used < 0)
+        throw Error("FRONTEND_PROVIDER_BUDGET_INVALID: missing consumed provider requests");
+    const breach = checkLimit(ledger, "providerRequests", used, ledger.limits.maxProviderRequests, { nodeId, inclusive: true });
+    if (breach && ledger.mode === "hard")
+        return breach;
+    ledger.consumed.providerRequests = used + 1;
+    return undefined;
+}
 /** Mark all PENDING nodes as SKIPPED due to budget breach (fail closed). */
 export function skipPendingNodesForBudgetBreach(nodes, breach) {
     const skipped = [];
@@ -165,6 +181,7 @@ export function formatBudgetReportMarkdown(ledger) {
         `| maxTokens | ${limits.maxTokens ?? "n/a"} |`,
         `| maxWallTimeMs | ${limits.maxWallTimeMs ?? "n/a"} |`,
         `| maxExecutorCalls | ${limits.maxExecutorCalls ?? "n/a"} |`,
+        `| maxProviderRequests | ${limits.maxProviderRequests ?? "n/a"} |`,
         `| maxRepairPasses | ${limits.maxRepairPasses ?? "n/a"} |`,
         `| maxConcurrency | ${limits.maxConcurrency ?? "n/a"} |`,
         `| maxContextChars | ${limits.maxContextChars ?? "n/a"} |`,
@@ -176,6 +193,7 @@ export function formatBudgetReportMarkdown(ledger) {
         `| tokens | ${c.tokens ?? "n/a (missing)"} |`,
         `| wallTimeMs | ${c.wallTimeMs} |`,
         `| executorCalls | ${c.executorCalls} |`,
+        `| providerRequests | ${c.providerRequests ?? "n/a"} |`,
         `| repairPasses | ${c.repairPasses} |`,
         `| peakContextChars | ${c.peakContextChars} |`,
         `| missingTokenNodes | ${c.missingTokenNodeIds.join(", ") || "none"} |`,

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

@@ -552,11 +552,13 @@ export async function advanceTaskLifecycle(input) {
                     // Prefer basename-aligned names for multi-file product suites.
                     name: path.basename(prd.filePath).replace(/\.(md|markdown|txt)$/iu, "") || undefined,
                 });
-                importedMaterializedPaths.push(imported.materializedRelativePath);
+                if (imported.changed) {
+                    importedMaterializedPaths.push(imported.materializedRelativePath);
+                }
             }
             // Latch even when prdPaths is empty so a mis-planned import cannot loop.
             importedPrdThisCall = true;
-            if ((input.prdPaths?.length ?? 0) > 0) {
+            if (importedMaterializedPaths.length > 0) {
                 record = {
                     ...appendTransition(record, "prd-imported"),
                     pendingPrdRefresh: true,
@@ -568,12 +570,15 @@ export async function advanceTaskLifecycle(input) {
                 completed.push("prd-imported");
                 await saveLifecycleRecord(input.repoRoot, record);
             }
+            refreshManagedContractThisCall = Boolean(record.pendingPrdRefresh ||
+                hasContractChangingInput({ ...effectiveInput, prdPaths: undefined }));
             snapshot = await observeTaskLifecycle(input.repoRoot, input.taskId);
             // Two-phase Console bridge: when this call only had --prd and no
             // engineering boundary, stop after archive. Re-plan would otherwise
             // immediately prepare (hasPrdInput latched false + alreadyImported)
             // and burn one-shot Semantic Intake before multi-file imports finish.
-            if (!hasBoundary && (input.prdPaths?.length ?? 0) > 0) {
+            if (!hasBoundary && record.pendingPrdRefresh &&
+                (input.prdPaths?.length ?? 0) > 0) {
                 return {
                     taskId: input.taskId,
                     lifecycleState: "intake-incomplete",
@@ -842,13 +847,18 @@ export async function advanceTaskLifecycle(input) {
                 break;
             }
             preparedContractThisCall = true;
-            if (startupRepairAction ||
-                refreshManagedContractThisCall ||
-                input.fromDraftPath) {
+            const contractChanged = prepareResult.apply?.noOp !== true;
+            if (contractChanged &&
+                (startupRepairAction ||
+                    refreshManagedContractThisCall ||
+                    Boolean(input.fromDraftPath))) {
                 // The old DAG and gate were bound to the pre-mutation contract.
-                refreshManagedContractThisCall = false;
                 regenerateDagThisCall = true;
             }
+            // Consume the refresh request even when projection was a content no-op;
+            // otherwise the re-plan would invoke prepare-contract repeatedly in this
+            // advance call and eventually hit the step limit.
+            refreshManagedContractThisCall = false;
             record = {
                 ...appendTransition(record, "contract-managed"),
                 pendingPrdRefresh: false,
@@ -1153,7 +1163,7 @@ export async function advanceTaskLifecycle(input) {
             continue;
         }
         if (action.type === "promote") {
-            const runId = run?.runId ?? snapshot.latestRun?.runId ?? snapshot.activeRun?.runId;
+            const runId = snapshot.currentRun?.runId;
             if (!runId) {
                 blockers.push({
                     code: "PROMOTE_RUN_MISSING",
@@ -1181,6 +1191,13 @@ export async function advanceTaskLifecycle(input) {
             continue;
         }
         if (action.type === "closeout") {
+            if (!snapshot.promotion?.ready || !snapshot.currentRun) {
+                blockers.push({
+                    code: "CLOSEOUT_EVIDENCE_STALE",
+                    message: "closeout requires promoted evidence for the current contract run",
+                });
+                break;
+            }
             const closed = await closeoutTask(input.repoRoot, input.taskId);
             closeout = { path: closed.progressPath };
             record = appendTransition(record, "closeout-completed");
@@ -1188,6 +1205,7 @@ export async function advanceTaskLifecycle(input) {
                 ...record,
                 closeout: {
                     path: closed.progressPath,
+                    runId: snapshot.currentRun.runId,
                     completedAt: new Date().toISOString(),
                 },
             };

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

@@ -1,6 +1,7 @@
 import { access, readFile, readdir } from "node:fs/promises";
 import path from "node:path";
-import { getTaskDir, getTaskPaths, getTaskStatus, loadTaskConfig, } from "../../task/runtime.js";
+import { getTaskDir, getTaskPaths, loadTaskConfig, } from "../../task/runtime.js";
+import { getArtifactPath } from "../../shared/artifacts-core.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";
@@ -202,6 +203,7 @@ export async function listExplicitlyAssociatedRuns(repoRoot, taskId) {
         let stateStatus;
         let failureCategory;
         let lastMeaningfulProgressAt;
+        let contractBinding = null;
         try {
             const state = await readDagRunState(entry.runDir);
             stateStatus = state.status;
@@ -238,20 +240,19 @@ export async function listExplicitlyAssociatedRuns(repoRoot, taskId) {
         catch {
             // state unreadable; may still match via binding
         }
-        if (!source) {
-            try {
-                const spec = await readDagRunSpec(entry.runDir);
-                if (spec.taskContractBinding?.taskId === taskId) {
-                    source = "task-contract-binding";
-                }
-                else if (spec.sourceBinding?.taskId === taskId) {
-                    source = "source-binding";
-                }
+        try {
+            const spec = await readDagRunSpec(entry.runDir);
+            contractBinding = spec.taskContractBinding ?? null;
+            if (!source && spec.taskContractBinding?.taskId === taskId) {
+                source = "task-contract-binding";
             }
-            catch {
-                // ignore
+            else if (!source && spec.sourceBinding?.taskId === taskId) {
+                source = "source-binding";
             }
         }
+        catch {
+            // Association may remain visible, but unreadable identity cannot prove completion.
+        }
         if (!source)
             continue;
         related.push({
@@ -262,6 +263,7 @@ export async function listExplicitlyAssociatedRuns(repoRoot, taskId) {
             failureCategory,
             lastMeaningfulProgressAt,
             source,
+            contractBinding,
         });
     }
     return related.sort((a, b) => a.runId.localeCompare(b.runId));
@@ -277,9 +279,10 @@ function deriveLifecycleState(input) {
         return "running";
     if (input.closeoutExists && input.promotionReady)
         return "evidence-closed";
-    if (input.latestRun?.lifecycle === "completed") {
-        if (input.latestRun.status === "finished")
-            return "run-succeeded";
+    if (input.currentRun?.lifecycle === "completed" &&
+        input.currentRun.status === "finished")
+        return "run-succeeded";
+    if (input.latestRun?.lifecycle === "completed" && input.latestRun.status !== "finished") {
         // A newly opened current writeSet gate supersedes an older failed run so
         // operators can approve and start the next DAG run. Success stays terminal
         // here so promote/closeout is not hijacked by a residual open gate.
@@ -381,6 +384,19 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
     const runs = await listExplicitlyAssociatedRuns(repoRoot, taskId);
     const activeRun = runs.find((run) => run.lifecycle === "active" || run.lifecycle === "paused") ?? null;
     const latestRun = runs.length > 0 ? runs[runs.length - 1] : null;
+    const ref = contractState.ref;
+    const currentRun = contractState.effectiveStatus === "managed" && ref
+        ? runs.filter((run) => {
+            const binding = run.contractBinding;
+            return (binding?.taskId === taskId &&
+                binding.revision === ref.revision &&
+                binding.canonicalHash === ref.canonicalHash &&
+                binding.taskConfigSha256 === ref.taskConfigSha256 &&
+                binding.projectionVersion === ref.projectionVersion &&
+                binding.canonicalizerVersion === ref.canonicalizerVersion &&
+                binding.taskConfigSchemaVersion === ref.taskConfigSchemaVersion);
+        }).at(-1) ?? null
+        : null;
     const strictValidated = Boolean(record?.strictValidatedAt) &&
         Boolean(record?.lastDagSpecHash) &&
         record?.lastDagSpecHash === specHash;
@@ -433,17 +449,13 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
         !rejectedCurrent
         ? buildWriteSetGate({ taskId, bound: gateBound, delta: gateDelta })
         : null;
-    const gateOpen = Boolean(gate);
-    let legacyState;
-    try {
-        legacyState = await getTaskStatus(repoRoot, taskId);
-    }
-    catch {
-        legacyState = null;
-    }
-    const promotionReady = Boolean(legacyState?.artifacts.modifyLog && legacyState?.artifacts.verifyResult);
+    const currentSucceeded = currentRun?.lifecycle === "completed" && currentRun.status === "finished";
+    const promotionReady = Boolean(currentSucceeded && record?.promotion?.runId === currentRun?.runId &&
+        await exists(getArtifactPath(taskDir, "implement")) &&
+        await exists(getArtifactPath(taskDir, "verify")));
     const closeout = closeoutPath(repoRoot, taskId);
-    const closeoutExists = await exists(closeout);
+    const closeoutExists = Boolean(promotionReady && record?.closeout?.runId === currentRun?.runId &&
+        record?.closeout?.path === closeout && await exists(closeout));
     const awaitingDecision = activeRun?.lifecycle === "paused" ||
         activeRun?.status === "paused" ||
         Boolean(activeRun?.status === "waiting-for-human");
@@ -463,8 +475,9 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
         gateOpen: Boolean(gate),
         activeRun,
         latestRun,
+        currentRun,
         promotionReady,
-        closeoutExists: closeoutExists || Boolean(record?.closeout),
+        closeoutExists,
         needsAttention: Boolean(needsAttention),
         awaitingDecision: Boolean(awaitingDecision),
     });
@@ -510,14 +523,15 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
         gate,
         activeRun,
         latestRun,
+        currentRun,
         runs,
         promotion: {
-            required: Boolean(latestRun && latestRun.lifecycle === "completed"),
-            ready: promotionReady || Boolean(record?.promotion),
+            required: Boolean(currentSucceeded),
+            ready: promotionReady,
         },
         closeout: {
             path: closeout,
-            exists: closeoutExists || Boolean(record?.closeout),
+            exists: closeoutExists,
         },
         completedTransitions: record?.completedTransitions ?? [],
         blockers: sourceFidelityReady

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

@@ -225,9 +225,9 @@ export function planTransitions(input) {
         }
     }
     if (!input.skipFinalize &&
-        (snapshot.lifecycleState === "run-succeeded" ||
-            (snapshot.latestRun?.lifecycle === "completed" &&
-                snapshot.latestRun.status === "finished"))) {
+        !dagRefreshRequired &&
+        !shouldImportPrd &&
+        snapshot.lifecycleState === "run-succeeded") {
         if (!snapshot.promotion?.ready) {
             actions.push({ type: "promote" });
             expectedTransitions.push("promotion-completed");
@@ -237,7 +237,8 @@ export function planTransitions(input) {
             expectedTransitions.push("closeout-completed");
         }
     }
-    if (snapshot.lifecycleState === "evidence-closed") {
+    if (snapshot.lifecycleState === "evidence-closed" &&
+        !dagRefreshRequired && !shouldImportPrd) {
         return {
             actions: [{ type: "stop", reason: "terminal" }],
             gate: null,

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.42.0-next.9",
-  "gitSha": "13597aa31afc1faccb9a5eaca296d57d7ab93c2e",
-  "builtAt": "2026-09-03T05:18:16.410Z"
+  "version": "0.42.1",
+  "gitSha": "c5b2a591968093ab6ec1b62d7be6fc6c02b4ade7",
+  "builtAt": "2026-09-09T13:13:47.201Z"
 }

package/dist/cli/program.js

@@ -440,7 +440,7 @@ const RAW_SUBCOMMAND_USAGE = {
     "dag approve": 'usage: dag approve --run-id <id> --option <A|B|...> [--notes "..."]',
     "dag reject": 'usage: dag reject --run-id <id> --reason "..."',
     "dag rerun": "usage: dag rerun --run-id <id> --from-node <node-id> --plan [--json] | dag rerun --run-id <id> --from-node <node-id> --plan-hash <hash> --request-id <key> --reason <text> [--json]",
-    "dag rerun-task": "usage: dag rerun-task --run-id <id> --reason <text> --request-id <key> [--profile auto|minimal|standard|reviewed|supervised] [--task-id <id>] [--json]",
+    "dag rerun-task": "usage: dag rerun-task --run-id <id> --reason <text> --request-id <key> [--profile auto|minimal|standard|reviewed|supervised] [--task-id <id>] [--frontend-recovery --recovery-operation-id <id>] [--json]",
     "dag reconcile-run": "usage: dag reconcile-run --run-id <id> [--action supersede|abandon] [--reason <text>]",
     "dag doctor": "usage: dag doctor [--run-id <id>]\nInspect health issues before approve/reject/resume; no --json (output is already structured JSON).",
     "dag report": "usage: dag report [--run-id <id>] [--lifecycle active|paused|completed|all] [--json|--markdown] [--failed-only] [--latest] [--paused-latest]\nRead-only run report; --json gives structured facts (canonical: `dag report --run-id <id> --lifecycle completed --json`).",

package/dist/commands/dag-rerun-task.js

@@ -11,6 +11,8 @@ export async function runDagRerunTask(repoRoot, rawArgs) {
         profileExplicit: parsed.profileExplicit,
         taskIdOverride: parsed.taskIdOverride,
         execute: parsed.execute,
+        frontendRecovery: parsed.frontendRecovery,
+        recoveryOperationId: parsed.recoveryOperationId,
     });
     console.log(JSON.stringify(result, null, 2));
     if (!result.ok) {

package/dist/commands/task-source-prepare.js

@@ -373,7 +373,9 @@ function printHuman(result) {
         }
     }
     if (result.apply) {
-        lines.push(`  apply: revision=${result.apply.ref.revision} txId=${result.apply.txId}`);
+        lines.push(result.apply.noOp
+            ? `  apply: revision=${result.apply.ref.revision} (unchanged; identical content, no new transaction)`
+            : `  apply: revision=${result.apply.ref.revision} txId=${result.apply.txId ?? "n/a"}`);
     }
     if (result.error) {
         lines.push(`  error: ${result.error.code}: ${result.error.message}`);