@tea-agent/loop-agent 0.33.7-beta.0 → 0.34.1

package/CHANGELOG.md

@@ -2,38 +2,89 @@
 
 ## [Unreleased]
 
-## [0.33.7-beta.0] - 2026-08-11
+## [0.34.1] - 2026-08-11
 
 ### 重点更新
 
-- backend-test 收口 source-fidelity P0：绑定 source coverage、有界 Markdown/pytest 同步、item-level eligibility 与单次 eligible 业务执行；my-webapp R107 16 节点 finished
+- Console PRD Intake Bridge：统一粘贴、单文件与多文件 PRD 导入流程，复用确定性解析与 Semantic Intake，并回写真实 Console Draft
+- 引入工程边界表单，工程路径与验证命令仅接受人工输入，杜绝使用模板内容冒充需求事实
+- DAG 中断恢复增强：支持协作式 abortSignal，未启动节点明确标记为 controller-interrupted，避免粗暴终止
+- Console Recovery 提供直观的 reconcile CTA，按运行状态精准展示恢复入口，破坏性操作需经浏览器 Human Gate 确认
 
 ### 新增
 
-- backend-test 新增绑定 source references 的来源覆盖事实、Markdown 一轮增量同步和 pytest correspondence 一轮有界修复，在业务测试体执行前保留 initial/effective/residual 证据
-- backend-test 新增 item-level execution eligibility：只授权 payload-safe 的 pytest items，excluded items 与真实业务失败分开展示
+- Console PRD 导入桥接：支持将粘贴、单文件与多文件导入统一接入 task advance 的确定性解析，并映射产物至 DraftStore
+- Console 工程边界表单：在 PRD 导入时支持可选的 allowed/forbidden/verify 字段，并作为标志传递至 bootstrap intake
+- Console Recovery CTA：基于 effective status 与 liveness 展示 dag reconcile-run（supersede/abandon）入口
+- DAG runner 协作式 abortSignal：主控停止时允许已运行节点按 checkpoint 收尾，未启动节点标记 controller-interrupted
 
 ### 改进
 
-- 将 backend-test Markdown/pytest map 的默认总 token 预算从 `600000` 提升到 `3000000`，降低多模块生成时过早触发 `dynamic map token budget exhausted` 的概率；仍保持预算耗尽 fail-closed
-- Coverage Matrix 接受 `R400001` 等错误码 Rule Key，并保留单元格内 `ACTIVE|ARCHIVED` 未转义枚举管道符，避免合法行被拆成 10 列后整表丢弃
-- scenario-param 按 TP 精确匹配多行 `场景意图`，保留 `ACTIVE` 大小写字面量，识别 `"a" * N` 长度表达式与空白 `empty`，request-level `nominal` 允许 `None` 查询过滤；避免把合法 payload 误判为 MISMATCH 并错误排除 eligible items
-- backend-test 支持 evidence-only 元用例：Markdown 显式声明 `脚本/primary symbol=无` 且仅绑定 assertion/cross-cutting TP 时，不再强制 1:1 pytest 符号，也不再把其算作 MISSING_PYTEST/SCRIPT_MISMATCH
-- generated pytest 内的 `ScopeMismatch`/setup fixture 失败若完全归因于 `testcase/**` 映射脚本，则归为 REPAIRABLE 并进入唯一一轮 collection repair，不再直接 BLOCKED
-- scenario-param 观测跳过 `pytest.param("TP-...", value, id="TP-...")` 的前导 TP 标签，并支持长度意图用数字位置参数表达
+- dag reconcile-run 增加 --json 与 --action 参数，避免 operation runner 因期待 JSON 失败，并明确拒绝非法 action
+- task advance 生命周期优化：PRD 导入后默认进入仅导入阶段，确保多文件 bootstrap 完成后再执行 Semantic Intake
+- Console Recovery 状态映射细化：将 interrupted/orphaned 等状态映射为 needs-reconcile，suspected-stall 映射为 observe/doctor
+- task advance writeSet gate 输出附确定性 delta，清晰展示边界扩张来源，且不破坏既有 approve 流程
 
 ### 修复
 
-- 修复 readiness 错误信息截断与无效 Coverage Matrix 状态语义，避免超长错误或 advisory 矩阵状态误阻断后续节点
-- 修复 scenario 排除项未绑定 payload 字段、request-level 不确定性被误升级为硬失败的问题
+- 修复追加 PRD 后两阶段 intake 未重新投影契约、Console 可能回读旧 Semantic Intake artifact 的问题
+- 修复 implement-pi 在 provider clean timeout 且明确零写入时直接终止的问题，现对标准 bounded writer 自动重试一次
+- 修复 grill-me 模板被误当作已解析需求的问题
+- 修复窄屏（<1100px）下 CHANGELOG 文档中尖括号导致的 MDX JSX 解析错误
 
-## [0.33.6-beta.0] - 2026-08-11
+## [0.34.0] - 2026-08-11
+
+### 重点更新
+
+- Operator Chat 会话创建实现即时响应，Landing 页面与创建请求延迟从秒级降至毫秒级
+- 新增桌面端紧凑响应式布局，根据工作区宽度自动适配 comfortable/compact/narrow 三档显示模式
+- 新增自动会话标题功能，基于首条用户消息生成临时标题，并在首轮对话完成后异步生成正式标题
+- 新增 local-jacoco-coverage 技能，将本地 Java 服务挂载、测试执行与覆盖率切片分析串成标准化链路
+
+### 新增
+
+- Operator Chat 桌面紧凑响应式布局：按工作区宽度切换 comfortable（≥1450px）/ compact（1100–1449px）/ narrow（<1100px）三档；compact 档使用图标窄栏与覆盖抽屉，narrow 档使用顶栏入口；会话与仓库面板支持拖拽分栏并记忆比例
+- Operator Chat 自动会话标题：首条用户消息持久化后生成清洗有界的临时标题，首轮对话成功完成后异步生成正式标题；手工重命名、归档和删除操作可拒绝迟到的自动标题覆盖
+- local-jacoco-coverage 技能：将本地启动 Java 服务挂载 jacocoagent、运行 backend-test DAG、按需求文档做覆盖率切片分析三步串联为可审计、可重复的本地链路，包含强制流程手册、runtime 对齐参考、需求映射规范与编排脚本
+
+### 改进
+
+- Operator Chat 会话创建改为即时响应：先落盘会话骨架与持久记录后立即返回成功，完整 AgentSession 在后台异步初始化，真实 Chrome 测试中 Landing 延迟从 1346ms 降至 22ms、创建请求从 1269ms 降至 16ms
+- 会话创建期间侧栏与 Landing 页共享 busy 状态反馈，抑制双击导致的重复创建
+- 删除正在初始化的会话不会被迟到的后台初始化任务复活，初始化失败统一返回 HTTP 503 错误码
+
+## [0.33.6] - 2026-08-11
+
+### 新增
+
+- stabilize PRD intake + add Semantic Intake fallback
+- Operator Chat 单事件流 + boot epoch fence（Task C）
+- gate writeSet delta + run summary（操作面增强）
+- supervise DAG runs autonomously
+- ChatEventStore 事件持久化压缩（coalescing + maxBytes 双限制）
+- reconcile(cursor_expired) 自动恢复而非全局致命错误
+- 接入 Operator Chat 实时运行时控制
+- open operator chat resource loading
+- enrich execution report and URL resolution
+
+### 改进
+
+- style(task-advance): biome autoformat 对齐（无功能变化）
+- style(console): apply biome formatting from pi-lens autoformat
 
 ### 修复
 
-- 修复 backend-test correspondence scanner 将下一 Case 的分隔注释误归入前一个 pytest function region，造成虚假的 `MULTIPLE_PYTEST`、script mismatch 和额外 Test Point；现在按函数实际缩进边界隔离 body，并只从精确 `Case-ID:` 元数据或 primary symbol 绑定 Case
-- 修复 backend-test 将 README 其他区域的 Markdown 链接误提取为业务模块、允许 `a401606` 等 opaque/hash-like stem 和异常多模块进入 map 的问题；现在只解析唯一 `## Module Index`，非法、mixed 或超过 8 个模块时 README-only 有界重试并由 manifest fail-closed
-- 修复 backend-test map 总 token 预算耗尽后只生成部分 Markdown/pytest 资产但 parent 仍可能显示成功的问题；budget-blocked child 现在使 backend map 明确 ERROR，并保留 expected/finished/blocked/token 事实
+- unify resilient read-only command execution
+- preserve user-owned Pi model routing
+- show installed package metadata
+- escape preflight backtick matcher
+- align chat streaming reliability with pi-web
+- split rerun defaults and repair selector escaping
+- ignore delimiters inside pytest strings
+- resolve target URL from runtime context
+- reject priority-only module stems
+- stop desiredSha256 mechanical checks from blocking generated-content upgrades
+- use mobius header brand icon
 
 ## [0.33.5] - 2026-08-11
 

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

@@ -3,6 +3,9 @@ import path from "node:path";
 import { createTask, getTaskPaths, loadTaskConfig, } from "../../task/runtime.js";
 import { importPrdDocument } from "../../task/source-references.js";
 import { prepareTaskSource } from "../../task/source-prepare/index.js";
+import { isIntakeSoftGapCode, resolvePrdImportRole, } from "../../task/source-prepare/artifact-meta.js";
+import { evaluateSemanticIntakeEligibility, isSemanticIntakeDisabled, readSemanticIntakeAttempted, runSemanticIntake, } from "../../task/source-prepare/semantic-intake.js";
+import { validateImportedPrdReferences } from "../../task/source-prepare/reference-integrity.js";
 import { logicalRevisionForState, observeTaskContractState, recoverTaskContract, } from "../../task/contract/index.js";
 import { generateTaskDagUseCase } from "../dag/generate-task-dag.js";
 import { validateDagUseCase } from "../dag/validate-dag.js";
@@ -10,7 +13,7 @@ import { runDagUseCase } from "../dag/run-dag.js";
 import { promoteRunEvidence, closeoutTask } from "../../records/promotion.js";
 import { resolveRunningControllerIdentity } from "../../shared/package-metadata.js";
 import { assessDagRunLiveness, locateDagRun, readDagRunState, } from "../../workflows/dag/lifecycle.js";
-import { buildGateBinding, buildWriteSetGate, controllerIdentityAnchor, gateMatches, hashCanonicalPayload, parseGateToken, } from "./gates.js";
+import { buildGateBinding, buildWriteSetGate, buildWriteSetGateDelta, controllerIdentityAnchor, gateMatches, hashCanonicalPayload, parseGateToken, } from "./gates.js";
 import { appendTransition, emptyLifecycleRecord, loadLifecycleRecord, recordRunAssociation, saveLifecycleRecord, } from "./record.js";
 import { collectNormalizedWriteSetFromSpec, hashDagSpecFileContent, observeTaskLifecycle, } from "./observe.js";
 import { planTransitions, } from "./plan-transitions.js";
@@ -39,7 +42,8 @@ function hasEngineeringBoundary(input) {
 }
 /** Inputs that must produce a new managed-contract revision when explicit. */
 function hasContractChangingInput(input) {
-    return Boolean(hasEngineeringBoundary(input) ||
+    return Boolean((input.prdPaths?.length ?? 0) > 0 ||
+        hasEngineeringBoundary(input) ||
         input.title ||
         input.taskKind ||
         input.featureId);
@@ -98,6 +102,42 @@ function toRunAssociation(input) {
         source: input.source ?? "lifecycle-record",
     };
 }
+/** Compact run completion summary for the advance result (AC-005/AC-006):
+ *  per-node status, first VERDICT line found in any node stdout, and nodes
+ *  flagged with a write-guard / out-of-bounds failure category. */
+function buildRunSummary(state) {
+    const nodes = Object.entries(state.nodes ?? {}).map(([id, node]) => ({
+        id,
+        status: node.status,
+    }));
+    const ordered = (state.ranks ?? []).flat();
+    nodes.sort((a, b) => {
+        const ai = ordered.indexOf(a.id);
+        const bi = ordered.indexOf(b.id);
+        return ((ai === -1 ? ordered.length : ai) - (bi === -1 ? ordered.length : bi));
+    });
+    let verdict = null;
+    const outOfBounds = [];
+    for (const [id, node] of Object.entries(state.nodes ?? {})) {
+        if (!verdict && typeof node.stdout === "string") {
+            const match = node.stdout.match(/^\s*VERDICT:\s*(.+)$/im);
+            if (match)
+                verdict = match[1].trim();
+        }
+        if (node.failureCategory &&
+            /^write-guard|out-of-bounds|write-set|boundary/i.test(node.failureCategory)) {
+            outOfBounds.push({ nodeId: id, failureCategory: node.failureCategory });
+        }
+    }
+    return {
+        runId: state.runId,
+        status: state.status,
+        nodes,
+        ...(verdict ? { verdict } : { verdict: null }),
+        ...(outOfBounds.length > 0 ? { outOfBounds } : {}),
+        failureCategory: state.failureCategory ?? null,
+    };
+}
 async function buildCurrentGate(repoRoot, taskId) {
     const paths = getTaskPaths(repoRoot, taskId);
     if (!(await pathExists(paths.dagDraftPath)))
@@ -113,6 +153,7 @@ async function buildCurrentGate(repoRoot, taskId) {
     const contractState = await observeTaskContractState(repoRoot, taskId);
     const identity = resolveRunningControllerIdentity();
     let writeSet = collectNormalizedWriteSetFromSpec(spec);
+    let contractAllowedPaths = [];
     if (writeSet.length === 0) {
         try {
             const config = await loadTaskConfig(repoRoot, taskId);
@@ -122,6 +163,18 @@ async function buildCurrentGate(repoRoot, taskId) {
             // leave empty
         }
     }
+    else {
+        try {
+            const config = await loadTaskConfig(repoRoot, taskId);
+            contractAllowedPaths = config.allowedPaths ?? [];
+        }
+        catch {
+            // leave empty
+        }
+    }
+    const writers = spec.tasks
+        .filter((task) => task.writePolicy === "exclusive")
+        .map((task) => ({ id: task.id, writeSet: task.writeSet ?? [] }));
     const bound = buildGateBinding({
         taskId,
         contractRevision: logicalRevisionForState(contractState),
@@ -141,7 +194,12 @@ async function buildCurrentGate(repoRoot, taskId) {
             }
             : null),
     });
-    return buildWriteSetGate({ taskId, bound });
+    const delta = buildWriteSetGateDelta({
+        writeSet,
+        contractAllowedPaths,
+        writers,
+    });
+    return buildWriteSetGate({ taskId, bound, delta });
 }
 async function monitorRun(input) {
     const started = Date.now();
@@ -213,6 +271,7 @@ export async function advanceTaskLifecycle(input) {
     let promotion = null;
     let closeout = null;
     let run = null;
+    let runSummary = null;
     let consumeApproveGate = Boolean(input.approveGateToken);
     /** After a successful approve, keep approve intent for finalize replan only. */
     let approvedThisCall = false;
@@ -226,6 +285,7 @@ export async function advanceTaskLifecycle(input) {
     let preparedContractThisCall = false;
     /** A successful managed-contract mutation invalidates the prior DAG/gate. */
     let regenerateDagThisCall = false;
+    let semanticIntakeAttemptedThisCall = false;
     let snapshot = await observeTaskLifecycle(input.repoRoot, input.taskId);
     let record = (await loadLifecycleRecord(input.repoRoot, input.taskId)) ??
         emptyLifecycleRecord(input.taskId);
@@ -280,7 +340,7 @@ export async function advanceTaskLifecycle(input) {
         verifyCommands: applied.verifyCommands ?? input.verifyCommands,
     };
     const hasBoundary = hasEngineeringBoundary(effectiveInput);
-    let refreshManagedContractThisCall = Boolean(hasContractChangingInput(effectiveInput) &&
+    let refreshManagedContractThisCall = Boolean((hasContractChangingInput(effectiveInput) || record.pendingPrdRefresh) &&
         (snapshot.contract?.effectiveStatus === "managed" ||
             Boolean(snapshot.contract?.revision && snapshot.contract.revision > 0)));
     if (applied.accepted) {
@@ -456,22 +516,70 @@ export async function advanceTaskLifecycle(input) {
             continue;
         }
         if (action.type === "import-prd") {
+            const importedMaterializedPaths = [];
             for (const prd of input.prdPaths ?? []) {
-                await importPrdDocument({
+                let markdown;
+                try {
+                    markdown = await readFile(path.resolve(prd.filePath), "utf-8");
+                }
+                catch {
+                    markdown = undefined;
+                }
+                const role = resolvePrdImportRole({
+                    filePath: prd.filePath,
+                    explicitRole: prd.role,
+                    markdown,
+                });
+                const imported = await importPrdDocument({
                     repoRoot: input.repoRoot,
                     taskId: input.taskId,
                     filePath: prd.filePath,
-                    role: prd.role,
+                    role,
+                    // Prefer basename-aligned names for multi-file product suites.
+                    name: path.basename(prd.filePath).replace(/\.(md|markdown|txt)$/iu, "") || undefined,
                 });
+                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) {
-                record = appendTransition(record, "prd-imported");
+                record = {
+                    ...appendTransition(record, "prd-imported"),
+                    pendingPrdRefresh: true,
+                    pendingPrdRefreshPaths: Array.from(new Set([
+                        ...(record.pendingPrdRefreshPaths ?? []),
+                        ...importedMaterializedPaths,
+                    ])),
+                };
                 completed.push("prd-imported");
                 await saveLifecycleRecord(input.repoRoot, record);
             }
             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) {
+                return {
+                    taskId: input.taskId,
+                    lifecycleState: "intake-incomplete",
+                    completedTransitions: uniqueTransitions(record.completedTransitions, completed),
+                    gate: null,
+                    blockers: [],
+                    warnings: [
+                        ...warnings,
+                        {
+                            code: "BOUNDARY_REQUIRED",
+                            message: "PRD imported; re-run task advance (optionally with --allowed-path / --verify) to prepare contract / semantic intake",
+                        },
+                    ],
+                    next: {
+                        kind: "advance",
+                        command: `loop-agent task advance ${input.taskId} --json`,
+                    },
+                    recommendations,
+                };
+            }
             continue;
         }
         if (action.type === "prepare-contract") {
@@ -494,7 +602,7 @@ export async function advanceTaskLifecycle(input) {
                     break;
                 }
             }
-            const prepareResult = await prepareTaskSource({
+            let prepareResult = await prepareTaskSource({
                 repoRoot: input.repoRoot,
                 taskId: input.taskId,
                 mode: "apply",
@@ -507,6 +615,8 @@ export async function advanceTaskLifecycle(input) {
                     : {
                         kind: "facts",
                         useImportedPrd: hasPrd || (snapshot.source?.importedPrdCount ?? 0) > 0,
+                        replaceManagedRequirement: record.pendingPrdRefresh === true,
+                        importedPrdPaths: record.pendingPrdRefreshPaths,
                         text: input.fromText,
                         textLabel: input.fromText ? "from-text" : undefined,
                     },
@@ -520,12 +630,162 @@ export async function advanceTaskLifecycle(input) {
                 },
             });
             if (!prepareResult.ok) {
+                const gapCodes = (prepareResult.gaps ?? [])
+                    .filter((gap) => gap.level === "blocking")
+                    .map((gap) => gap.code);
+                const softIntake = Boolean(prepareResult.error?.details?.softIntake) ||
+                    (gapCodes.length > 0 &&
+                        gapCodes.every((code) => isIntakeSoftGapCode(code)));
+                // P2: one-shot semantic intake when structure failed but sources exist.
+                if (softIntake &&
+                    (completed.includes("prd-imported") ||
+                        (snapshot.source?.importedPrdCount ?? 0) > 0) &&
+                    !semanticIntakeAttemptedThisCall) {
+                    const already = await readSemanticIntakeAttempted(input.repoRoot, input.taskId);
+                    const eligibility = evaluateSemanticIntakeEligibility({
+                        hasImportedPrd: true,
+                        gaps: prepareResult.gaps ?? [],
+                        alreadyAttempted: already,
+                        disabled: isSemanticIntakeDisabled(),
+                    });
+                    if (eligibility.eligible) {
+                        semanticIntakeAttemptedThisCall = true;
+                        warnings.push({
+                            code: "SEMANTIC_INTAKE_STARTING",
+                            message: eligibility.reason,
+                        });
+                        const integrity = await validateImportedPrdReferences({
+                            repoRoot: input.repoRoot,
+                            taskId: input.taskId,
+                            requireParseableRequirement: false,
+                        });
+                        const documents = integrity.documents
+                            .filter((doc) => doc.content)
+                            .map((doc) => ({
+                            role: doc.role,
+                            materializedPath: doc.materializedPath,
+                            absolutePath: doc.absolutePath,
+                            content: doc.content,
+                        }));
+                        const semantic = await runSemanticIntake({
+                            repoRoot: input.repoRoot,
+                            taskId: input.taskId,
+                            title: input.title ?? prepareResult.title ?? input.taskId,
+                            taskKind: input.taskKind ?? prepareResult.taskKind,
+                            featureId: input.featureId,
+                            documents,
+                            flags: {
+                                title: input.title,
+                                taskKind: input.taskKind,
+                                featureId: input.featureId,
+                                allowedPaths: effectiveInput.allowedPaths,
+                                forbiddenPaths: input.forbiddenPaths,
+                                verifyCommands: effectiveInput.verifyCommands,
+                            },
+                        });
+                        if (semantic.ok) {
+                            const retry = await prepareTaskSource({
+                                repoRoot: input.repoRoot,
+                                taskId: input.taskId,
+                                mode: "apply",
+                                intent: {
+                                    kind: "draft",
+                                    draft: semantic.draft,
+                                    sourcePath: semantic.artifactPath,
+                                },
+                                flags: {
+                                    title: input.title,
+                                    taskKind: input.taskKind,
+                                    featureId: input.featureId,
+                                    allowedPaths: effectiveInput.allowedPaths,
+                                    forbiddenPaths: input.forbiddenPaths,
+                                    verifyCommands: effectiveInput.verifyCommands,
+                                },
+                            });
+                            if (retry.ok) {
+                                warnings.push({
+                                    code: "SEMANTIC_INTAKE_APPLIED",
+                                    message: "structured requirement draft via semantic intake; projected managed source",
+                                });
+                                preparedContractThisCall = true;
+                                if (refreshManagedContractThisCall || input.fromDraftPath) {
+                                    refreshManagedContractThisCall = false;
+                                    regenerateDagThisCall = true;
+                                }
+                                record = {
+                                    ...appendTransition(record, "contract-managed"),
+                                    pendingPrdRefresh: false,
+                                    pendingPrdRefreshPaths: [],
+                                };
+                                completed.push("contract-managed");
+                                await saveLifecycleRecord(input.repoRoot, record);
+                                snapshot = await observeTaskLifecycle(input.repoRoot, input.taskId);
+                                continue;
+                            }
+                            prepareResult = retry;
+                            // fall through with retry gaps
+                        }
+                        else {
+                            warnings.push({
+                                code: semantic.code,
+                                message: semantic.message,
+                            });
+                        }
+                    }
+                    else if (!already) {
+                        warnings.push({
+                            code: "SEMANTIC_INTAKE_SKIPPED",
+                            message: eligibility.reason,
+                        });
+                    }
+                }
+                // Soft intake: PRD may already be imported; stop before DAG without
+                // treating the whole advance as a hard parse failure.
+                const gapCodesAfter = (prepareResult.gaps ?? [])
+                    .filter((gap) => gap.level === "blocking")
+                    .map((gap) => gap.code);
+                const softIntakeAfter = Boolean(prepareResult.error?.details?.softIntake) ||
+                    (gapCodesAfter.length > 0 &&
+                        gapCodesAfter.every((code) => isIntakeSoftGapCode(code)));
+                // Soft-stop when PRD is on disk (this call or prior import).
+                // Console two-phase bootstrap: import first, then advance intake
+                // without re-passing --prd — still must soft-stop, not hard-fail.
+                const hasImportedPrdOnDisk = completed.includes("prd-imported") ||
+                    (snapshot.source?.importedPrdCount ?? 0) > 0;
+                if (softIntakeAfter && hasImportedPrdOnDisk) {
+                    warnings.push({
+                        code: "INTAKE_INCOMPLETE",
+                        message: prepareResult.error?.message ??
+                            "PRD imported but intake incomplete; DAG not generated",
+                    });
+                    for (const gap of prepareResult.gaps ?? []) {
+                        if (gap.level === "blocking") {
+                            warnings.push({ code: gap.code, message: gap.message });
+                        }
+                    }
+                    snapshot = await observeTaskLifecycle(input.repoRoot, input.taskId);
+                    return {
+                        taskId: input.taskId,
+                        lifecycleState: "intake-incomplete",
+                        completedTransitions: uniqueTransitions(record.completedTransitions, completed),
+                        gate: null,
+                        blockers: [],
+                        warnings,
+                        next: {
+                            kind: "advance",
+                            command: prepareResult.next?.[0] ??
+                                `loop-agent task advance ${input.taskId} --prd <product-requirement.md> --allowed-path <glob> --json`,
+                        },
+                        recommendations,
+                    };
+                }
                 blockers.push({
                     code: prepareResult.error?.code ?? "PREPARE_FAILED",
                     message: prepareResult.error?.message ?? "task source prepare failed",
                     details: {
                         gaps: prepareResult.gaps,
                         outcome: prepareResult.outcome,
+                        softIntake: softIntakeAfter,
                     },
                 });
                 break;
@@ -536,7 +796,11 @@ export async function advanceTaskLifecycle(input) {
                 refreshManagedContractThisCall = false;
                 regenerateDagThisCall = true;
             }
-            record = appendTransition(record, "contract-managed");
+            record = {
+                ...appendTransition(record, "contract-managed"),
+                pendingPrdRefresh: false,
+                pendingPrdRefreshPaths: [],
+            };
             completed.push("contract-managed");
             await saveLifecycleRecord(input.repoRoot, record);
             snapshot = await observeTaskLifecycle(input.repoRoot, input.taskId);
@@ -814,6 +1078,22 @@ export async function advanceTaskLifecycle(input) {
                 }
                 await saveLifecycleRecord(input.repoRoot, record);
             }
+            // Build the compact run summary (AC-005/AC-006) from the settled run
+            // state so the operator sees node statuses/verdict/outOfBounds without
+            // reading state.json. Best-effort: skip when the run dir is unavailable.
+            if (run?.runDir) {
+                try {
+                    const settledState = await readDagRunState(run.runDir);
+                    const summary = buildRunSummary(settledState);
+                    if (summary) {
+                        summary.next = snapshot.next;
+                        runSummary = summary;
+                    }
+                }
+                catch {
+                    // leave runSummary null
+                }
+            }
             snapshot = await observeTaskLifecycle(input.repoRoot, input.taskId);
             // Re-plan so promote/closeout can run in the same call after success.
             continue;
@@ -869,6 +1149,25 @@ export async function advanceTaskLifecycle(input) {
             (await buildCurrentGate(input.repoRoot, input.taskId)))
         : snapshot.gate;
     await exportDagDraftIfRequested(input.repoRoot, input.taskId, input.dagOutputPath);
+    // Fall back to the latest associated run state when this call did not
+    // itself monitor/start a run (e.g. re-observe after a previously settled
+    // run): the operator still wants the compact summary in the result.
+    if (!runSummary) {
+        const settledRun = run ?? snapshot.latestRun ?? snapshot.activeRun;
+        if (settledRun?.runDir) {
+            try {
+                const settledState = await readDagRunState(settledRun.runDir);
+                const summary = buildRunSummary(settledState);
+                if (summary) {
+                    summary.next = snapshot.next;
+                    runSummary = summary;
+                }
+            }
+            catch {
+                // leave runSummary null
+            }
+        }
+    }
     return {
         taskId: input.taskId,
         lifecycleState: snapshot.lifecycleState,
@@ -878,6 +1177,7 @@ export async function advanceTaskLifecycle(input) {
         warnings,
         next: snapshot.next,
         run,
+        runSummary,
         promotion,
         closeout,
         recommendations,

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

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { pathMatchesPattern } from "../../shared/git-progress.js";
 export function normalizeWriteSet(writeSet) {
     return [
         ...new Set(writeSet.map((entry) => entry.replace(/\\/g, "/").trim()).filter(Boolean)),
@@ -42,6 +43,54 @@ export function computeGateDigest(bound) {
         writeSet: normalizeWriteSet(bound.writeSet),
     });
 }
+/**
+ * Deterministic writeSet vs contract allowedPaths delta (2026-08-11).
+ *
+ * Classifies every normalized writeSet entry against the task contract's
+ * allowedPaths:
+ *  - exactMatch:          entry equals a contract allowedPath
+ *  - narrowerThanContract: entry is covered by a broader contract glob
+ *                          (e.g. writeSet `src/worker/console/chat/**` under
+ *                          contract `src/**`)
+ *  - additions:           entry outside the contract, attributed to the
+ *                          exclusive writer node(s) that declared it
+ *
+ * `writers` is the list of { id, writeSet } from the DAG spec's exclusive
+ * writer tasks. The delta is a read-only field on the gate output and is
+ * NEVER included in the gate digest (AC-004: digest stays stable).
+ */
+export function buildWriteSetGateDelta(input) {
+    const writeSet = normalizeWriteSet(input.writeSet);
+    const contract = normalizeWriteSet(input.contractAllowedPaths);
+    const exactMatch = [];
+    const narrowerThanContract = [];
+    const additions = [];
+    for (const entry of writeSet) {
+        if (contract.includes(entry)) {
+            exactMatch.push(entry);
+            continue;
+        }
+        // Covered by a broader contract glob? Use the entry itself as a probe
+        // path against each contract pattern (pathMatchesPattern treats a
+        // non-glob entry as an exact-or-prefix match and glob entries via
+        // globToRegExp).
+        const covered = contract.some((contractEntry) => pathMatchesPattern(entry, contractEntry));
+        if (covered) {
+            narrowerThanContract.push(entry);
+            continue;
+        }
+        const source = (input.writers ?? [])
+            .filter((writer) => normalizeWriteSet(writer.writeSet).includes(entry))
+            .map((writer) => writer.id)
+            .sort((a, b) => a.localeCompare(b));
+        additions.push({
+            entry,
+            source,
+            coveredByContract: false,
+        });
+    }
+    return { exactMatch, narrowerThanContract, additions };
+}
 export function buildWriteSetGate(input) {
     const digest = computeGateDigest(input.bound);
     const id = "write-set-review";
@@ -54,6 +103,7 @@ export function buildWriteSetGate(input) {
         approveCommand: `loop-agent task advance ${input.taskId} --approve-gate ${id}:${digest} --json`,
         rejectCommand: `loop-agent task advance ${input.taskId} --reject-gate ${id}:${digest} --reason <text> --json`,
         bound: input.bound,
+        delta: input.delta ?? null,
     };
 }
 export function parseGateToken(token) {