@tea-agent/loop-agent 0.33.6 → 0.33.7-beta.1

package/CHANGELOG.md

@@ -2,38 +2,54 @@
 
 ## [Unreleased]
 
-## [0.33.6] - 2026-08-11
+### 改进
+
+- scenario-param 观测识别 `_OMIT`/omit sentinel 为合法 `missing`，跳过 `"2xx"`/`"400"` 期望码位置参数，解码 Python `\t`/`\n` 空白字面量，识别 `_TITLE_LEN1` 等长度 helper 名，支持 `custom-literal:whitespace-only|whitespace-padded` 语义标签，`enum-invalid` 接受具体非法字面量，并在 `min`/`LEN1` 意图下优先读取 TP 编码长度与 `minLength` 边界
+- scenario-param 兼容 `empty` 意图下的 omit/`missing-key`，规范化 `custom-literal` 外包引号与可见空白符，并把 `max+1`/`min`/`max` 的裸数字位置参数按长度 token 比较（含 oversized 数字本身）；`custom-literal:trim` 视为 padded whitespace 语义标签
+- backend-test writer 合同明确：`enum-invalid` 必须使用具体非法字面量且禁止 `_OMIT`/missing-key；`custom-literal:trim|ACTIVE|ARCHIVED` 必须使用真实 padded/enum 字面量，禁止 `filter-active` 类描述性伪值
+- scenario-param 识别 `_*_MAX_LENGTH` / `_*_OVER_LENGTH` 等长度 helper 名，明确 `custom-literal:trim` 不能是全空白，并把无 pytest.param 的 request-level/health nominal 记为 MATCH 以免污染 eligibility
+
+## [0.33.7-beta.1] - 2026-08-12
+
+### Fixed
+- scenario-param 识别 `_*_MAX_LENGTH` / `_*_OVER_LENGTH` 等长度 helper 名，明确 `custom-literal:trim` 不能是全空白，并把无 pytest.param 的 request-level/health nominal 记为 MATCH 以免污染 eligibility
+- backend-test writer 合同明确：`enum-invalid` 必须使用具体非法字面量且禁止 `_OMIT`/missing-key；`custom-literal:trim|ACTIVE|ARCHIVED` 必须使用真实 padded/enum 字面量；max/min/max+1 应用长度表达式/helper
+
+### Changed
+- 归档 R108–R110 live campaign 证据与 residual 收紧结果
+
+## [0.33.7-beta.0] - 2026-08-11
+
+### 重点更新
+
+- backend-test 收口 source-fidelity P0：绑定 source coverage、有界 Markdown/pytest 同步、item-level eligibility 与单次 eligible 业务执行；my-webapp R107 16 节点 finished
 
 ### 新增
 
-- 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
+- backend-test 新增绑定 source references 的来源覆盖事实、Markdown 一轮增量同步和 pytest correspondence 一轮有界修复，在业务测试体执行前保留 initial/effective/residual 证据
+- backend-test 新增 item-level execution eligibility：只授权 payload-safe 的 pytest items，excluded items 与真实业务失败分开展示
 
 ### 改进
 
-- style(task-advance): biome autoformat 对齐（无功能变化）
-- style(console): apply biome formatting from pi-lens autoformat
+- 将 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 标签，并支持长度意图用数字位置参数表达
+
+### 修复
+
+- 修复 readiness 错误信息截断与无效 Coverage Matrix 状态语义，避免超长错误或 advisory 矩阵状态误阻断后续节点
+- 修复 scenario 排除项未绑定 payload 字段、request-level 不确定性被误升级为硬失败的问题
+
+## [0.33.6-beta.0] - 2026-08-11
 
 ### 修复
 
-- 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
+- 修复 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 事实
 
 ## [0.33.5] - 2026-08-11
 

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

@@ -3,9 +3,6 @@ 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";
@@ -13,7 +10,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, buildWriteSetGateDelta, controllerIdentityAnchor, gateMatches, hashCanonicalPayload, parseGateToken, } from "./gates.js";
+import { buildGateBinding, buildWriteSetGate, 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";
@@ -101,42 +98,6 @@ 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)))
@@ -152,7 +113,6 @@ 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);
@@ -162,18 +122,6 @@ 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),
@@ -193,12 +141,7 @@ async function buildCurrentGate(repoRoot, taskId) {
             }
             : null),
     });
-    const delta = buildWriteSetGateDelta({
-        writeSet,
-        contractAllowedPaths,
-        writers,
-    });
-    return buildWriteSetGate({ taskId, bound, delta });
+    return buildWriteSetGate({ taskId, bound });
 }
 async function monitorRun(input) {
     const started = Date.now();
@@ -270,7 +213,6 @@ 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;
@@ -284,7 +226,6 @@ 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);
@@ -516,25 +457,11 @@ export async function advanceTaskLifecycle(input) {
         }
         if (action.type === "import-prd") {
             for (const prd of input.prdPaths ?? []) {
-                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,
-                });
                 await importPrdDocument({
                     repoRoot: input.repoRoot,
                     taskId: input.taskId,
                     filePath: prd.filePath,
-                    role,
-                    // Prefer basename-aligned names for multi-file product suites.
-                    name: path.basename(prd.filePath).replace(/\.(md|markdown|txt)$/iu, "") || undefined,
+                    role: prd.role,
                 });
             }
             // Latch even when prdPaths is empty so a mis-planned import cannot loop.
@@ -567,7 +494,7 @@ export async function advanceTaskLifecycle(input) {
                     break;
                 }
             }
-            let prepareResult = await prepareTaskSource({
+            const prepareResult = await prepareTaskSource({
                 repoRoot: input.repoRoot,
                 taskId: input.taskId,
                 mode: "apply",
@@ -593,153 +520,12 @@ 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");
-                                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)));
-                if (softIntakeAfter && completed.includes("prd-imported")) {
-                    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;
@@ -1028,22 +814,6 @@ 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;
@@ -1099,25 +869,6 @@ 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,
@@ -1127,7 +878,6 @@ export async function advanceTaskLifecycle(input) {
         warnings,
         next: snapshot.next,
         run,
-        runSummary,
         promotion,
         closeout,
         recommendations,

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

@@ -1,5 +1,4 @@
 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)),
@@ -43,54 +42,6 @@ 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";
@@ -103,7 +54,6 @@ 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) {

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

@@ -5,7 +5,7 @@ import { logicalRevisionForState, observeTaskContractState, } from "../../task/c
 import { assessDagRunLiveness, listAllDagRunEntries, readDagRunSpec, readDagRunState, } from "../../workflows/dag/lifecycle.js";
 import { resolveRunningControllerIdentity } from "../../shared/package-metadata.js";
 import { loadLifecycleRecord } from "./record.js";
-import { buildGateBinding, buildWriteSetGate, buildWriteSetGateDelta, controllerIdentityAnchor, hashCanonicalPayload, normalizeWriteSet, sha256Hex, } from "./gates.js";
+import { buildGateBinding, buildWriteSetGate, controllerIdentityAnchor, hashCanonicalPayload, normalizeWriteSet, sha256Hex, } from "./gates.js";
 async function exists(filePath) {
     try {
         await access(filePath);
@@ -263,15 +263,6 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
                 : null),
         })
         : null;
-    const gateDelta = gateBound != null
-        ? buildWriteSetGateDelta({
-            writeSet: gateBound.writeSet,
-            contractAllowedPaths: taskConfigAllowed,
-            writers: (parsedSpec?.tasks ?? [])
-                .filter((task) => task.writePolicy === "exclusive")
-                .map((task) => ({ id: task.id, writeSet: task.writeSet ?? [] })),
-        })
-        : null;
     const lastGate = record?.lastGate;
     const currentDigest = gateBound != null
         ? buildWriteSetGate({ taskId, bound: gateBound }).digest
@@ -286,7 +277,7 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
     // not already approved/rejected. Rejected same-digest gates stay closed
     // until contract/source/DAG/writeSet/controller binding changes.
     const gate = gateBound && strictValidated && !approvedCurrent && !rejectedCurrent
-        ? buildWriteSetGate({ taskId, bound: gateBound, delta: gateDelta })
+        ? buildWriteSetGate({ taskId, bound: gateBound })
         : null;
     const gateOpen = Boolean(gate);
     let legacyState;

package/dist/commands/init-upgrade.js

@@ -1023,7 +1023,6 @@ function assertPendingAcceptance(value, state, task) {
     }
     const pending = value;
     const desiredSha256 = task.evidence.desiredSha256;
-    const sourceAnchorSha256 = task.evidence.sourceAnchorSha256;
     const guard = pending.guard;
     const receipt = pending.receipt;
     const transition = pending.transition;
@@ -1040,9 +1039,6 @@ function assertPendingAcceptance(value, state, task) {
         !isSha256(guard.desiredSha256) ||
         !isSha256(desiredSha256) ||
         guard.desiredSha256 !== desiredSha256 ||
-        (sourceAnchorSha256 === undefined
-            ? guard.sourceAnchorSha256 !== undefined
-            : guard.sourceAnchorSha256 !== sourceAnchorSha256) ||
         !isMergeReceipt(receipt) ||
         receipt.taskId !== guard.taskId ||
         receipt.path !== guard.path ||
@@ -1080,9 +1076,6 @@ function acceptedSurface(input) {
     acceptedEntry.acceptedMerge = {
         currentSha256: input.currentSha256,
         desiredSha256: input.desiredSha256,
-        ...(typeof input.task.evidence.sourceAnchorSha256 === "string"
-            ? { sourceAnchorSha256: input.task.evidence.sourceAnchorSha256 }
-            : {}),
     };
     return { beforeEntry: cloneJson(entry), accepted };
 }
@@ -1217,7 +1210,6 @@ async function recordAcceptedMerge(input) {
     if (!desiredSha256) {
         throw new Error(`init upgrade cannot accept ${input.task.path}: desired hash evidence is missing`);
     }
-    const sourceAnchorSha256 = input.task.evidence.sourceAnchorSha256;
     const canonicalPath = normalizeAllowedPath(input.task.path);
     const surfacePath = path.join(input.state.repoRoot, INIT_SURFACE_STATE_PATH);
     let pending = input.pending;
@@ -1271,9 +1263,6 @@ async function recordAcceptedMerge(input) {
                 allowedPaths: [canonicalPath],
                 currentSha256: input.currentSha256,
                 desiredSha256,
-                ...(sourceAnchorSha256 !== undefined
-                    ? { sourceAnchorSha256 }
-                    : {}),
             },
             receipt,
             transition: {
@@ -2423,27 +2412,7 @@ async function executeUpgrade(directory, state, input) {
     });
     state.actionReceipts.push(...safe.applied);
     await writeJsonAtomic(path.join(directory, "change-manifest.json"), state.actionReceipts);
-    let post = await checkInitUpdate({ repoRoot: state.repoRoot });
-    // Converge remaining safe deterministic init actions before the final check.
-    // Project/governance-derived drift (e.g. a personalized project rename after
-    // an accepted merge) settles here instead of failing finalCheck. Model merge
-    // tasks and human decisions are never auto-applied.
-    while (post.deterministicActions.length > 0) {
-        const converged = await applyInitUpdate({
-            repoRoot: state.repoRoot,
-            applySafe: true,
-            clientRecovery: "project",
-        });
-        state.actionReceipts.push(...converged.applied);
-        await writeJsonAtomic(path.join(directory, "change-manifest.json"), state.actionReceipts);
-        if (converged.applied.length === 0)
-            break;
-        post = await checkInitUpdate({ repoRoot: state.repoRoot });
-        if (post.humanDecisions.length > 0 ||
-            post.modelMergeTasks.length > 0) {
-            break;
-        }
-    }
+    const post = await checkInitUpdate({ repoRoot: state.repoRoot });
     state.humanDecisions = post.humanDecisions;
     if (post.humanDecisions.length > 0) {
         state.mergeTasks = [];