@tea-agent/loop-agent 0.33.5 → 0.33.6

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## [Unreleased]
 
+## [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
+
+### 修复
+
+- 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";
@@ -98,6 +101,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 +152,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 +162,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 +193,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 +270,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 +284,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);
@@ -457,11 +516,25 @@ 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: prd.role,
+                    role,
+                    // Prefer basename-aligned names for multi-file product suites.
+                    name: path.basename(prd.filePath).replace(/\.(md|markdown|txt)$/iu, "") || undefined,
                 });
             }
             // Latch even when prdPaths is empty so a mis-planned import cannot loop.
@@ -494,7 +567,7 @@ export async function advanceTaskLifecycle(input) {
                     break;
                 }
             }
-            const prepareResult = await prepareTaskSource({
+            let prepareResult = await prepareTaskSource({
                 repoRoot: input.repoRoot,
                 taskId: input.taskId,
                 mode: "apply",
@@ -520,12 +593,153 @@ 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;
@@ -814,6 +1028,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 +1099,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 +1127,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) {

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, controllerIdentityAnchor, hashCanonicalPayload, normalizeWriteSet, sha256Hex, } from "./gates.js";
+import { buildGateBinding, buildWriteSetGate, buildWriteSetGateDelta, controllerIdentityAnchor, hashCanonicalPayload, normalizeWriteSet, sha256Hex, } from "./gates.js";
 async function exists(filePath) {
     try {
         await access(filePath);
@@ -263,6 +263,15 @@ 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
@@ -277,7 +286,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 })
+        ? buildWriteSetGate({ taskId, bound: gateBound, delta: gateDelta })
         : null;
     const gateOpen = Boolean(gate);
     let legacyState;

package/dist/commands/init-upgrade.js

@@ -1023,6 +1023,7 @@ 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;
@@ -1039,6 +1040,9 @@ 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 ||
@@ -1076,6 +1080,9 @@ 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 };
 }
@@ -1210,6 +1217,7 @@ 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;
@@ -1263,6 +1271,9 @@ async function recordAcceptedMerge(input) {
                 allowedPaths: [canonicalPath],
                 currentSha256: input.currentSha256,
                 desiredSha256,
+                ...(sourceAnchorSha256 !== undefined
+                    ? { sourceAnchorSha256 }
+                    : {}),
             },
             receipt,
             transition: {
@@ -2412,7 +2423,27 @@ async function executeUpgrade(directory, state, input) {
     });
     state.actionReceipts.push(...safe.applied);
     await writeJsonAtomic(path.join(directory, "change-manifest.json"), state.actionReceipts);
-    const post = await checkInitUpdate({ repoRoot: state.repoRoot });
+    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;
+        }
+    }
     state.humanDecisions = post.humanDecisions;
     if (post.humanDecisions.length > 0) {
         state.mergeTasks = [];