@tea-agent/loop-agent 0.41.1-beta.0 → 0.41.1

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

@@ -260,10 +260,6 @@ async function monitorRun(input) {
         failureCategory: "monitor-timeout",
     });
 }
-function isStartupGateEligible(snapshot) {
-    const status = snapshot.source?.sourceFidelityStartup?.status;
-    return status === undefined || status === "complete" || status === "not-applicable";
-}
 function nextMutationAction(actions) {
     for (const action of actions) {
         if (action.type !== "stop")
@@ -383,10 +379,7 @@ export async function advanceTaskLifecycle(input) {
             };
         }
         const token = parseGateToken(input.rejectGateToken);
-        const currentGate = snapshot.gate ??
-            (isStartupGateEligible(snapshot)
-                ? await buildCurrentGate(input.repoRoot, input.taskId)
-                : null);
+        const currentGate = snapshot.gate ?? (await buildCurrentGate(input.repoRoot, input.taskId));
         if (!currentGate || !gateMatches(currentGate, token)) {
             return {
                 taskId: input.taskId,
@@ -450,12 +443,11 @@ export async function advanceTaskLifecycle(input) {
         dryRun,
         skipFinalize: Boolean(input.skipFinalize),
         forcePrepareContract: Boolean(input.fromDraftPath) && !preparedContractThisCall,
-        startupRepairAttempted: preparedContractThisCall,
     });
     if (dryRun) {
         const plan = planOnce(snapshot);
         const plannedGate = snapshot.gate ??
-            (isStartupGateEligible(snapshot) && snapshot.dagDraft?.exists
+            (snapshot.dagDraft?.exists
                 ? await buildCurrentGate(input.repoRoot, input.taskId)
                 : null);
         return {
@@ -507,10 +499,7 @@ export async function advanceTaskLifecycle(input) {
         }
         if (action.type === "create-task") {
             if (!snapshot.exists) {
-                await createTask(input.repoRoot, input.taskId, input.title, {
-                    taskKind: input.taskKind,
-                    taskKindExplicit: input.taskKindExplicit,
-                });
+                await createTask(input.repoRoot, input.taskId, input.title);
                 record = appendTransition(record, "task-created");
                 completed.push("task-created");
                 await saveLifecycleRecord(input.repoRoot, record);
@@ -597,10 +586,6 @@ export async function advanceTaskLifecycle(input) {
             continue;
         }
         if (action.type === "prepare-contract") {
-            const startupStatus = snapshot.source?.sourceFidelityStartup?.status;
-            const startupRepairAction = startupStatus === "missing" ||
-                startupStatus === "invalid" ||
-                startupStatus === "coverage-incomplete";
             // 生产 source fidelity Pi 接线（AC-PROD-001/005）：仅 frontend-implementation
             // 任务注入 reconcile executor + 独立 reviewer；ineligible 返回 undefined 不接线。
             // 主路径与 semantic-intake retry 路径共用同一接线，保证任意一条生产路径都实际
@@ -746,9 +731,7 @@ export async function advanceTaskLifecycle(input) {
                                     message: "structured requirement draft via semantic intake; projected managed source",
                                 });
                                 preparedContractThisCall = true;
-                                if (startupRepairAction ||
-                                    refreshManagedContractThisCall ||
-                                    input.fromDraftPath) {
+                                if (refreshManagedContractThisCall || input.fromDraftPath) {
                                     refreshManagedContractThisCall = false;
                                     regenerateDagThisCall = true;
                                 }
@@ -842,9 +825,7 @@ export async function advanceTaskLifecycle(input) {
                 break;
             }
             preparedContractThisCall = true;
-            if (startupRepairAction ||
-                refreshManagedContractThisCall ||
-                input.fromDraftPath) {
+            if (refreshManagedContractThisCall || input.fromDraftPath) {
                 // The old DAG and gate were bound to the pre-mutation contract.
                 refreshManagedContractThisCall = false;
                 regenerateDagThisCall = true;

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

@@ -1,11 +1,9 @@
-import { access, readFile, readdir } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 import { getTaskDir, getTaskPaths, getTaskStatus, loadTaskConfig, } from "../../task/runtime.js";
 import { logicalRevisionForState, observeTaskContractState, } from "../../task/contract/index.js";
 import { assessDagRunLiveness, listAllDagRunEntries, readDagRunSpec, readDagRunState, } from "../../workflows/dag/lifecycle.js";
 import { resolveRunningControllerIdentity } from "../../shared/package-metadata.js";
-import { parseLedgerJson, validateRequirementLedger, } from "../../task/source-prepare/ledger.js";
-import { REQUIREMENT_LEDGER_FILE_NAME } from "../../task/source-prepare/types.js";
 import { loadLifecycleRecord } from "./record.js";
 import { buildGateBinding, buildWriteSetGate, buildWriteSetGateDelta, controllerIdentityAnchor, hashCanonicalPayload, normalizeWriteSet, sha256Hex, } from "./gates.js";
 async function exists(filePath) {
@@ -49,140 +47,6 @@ async function taskExists(repoRoot, taskId) {
     const paths = getTaskPaths(repoRoot, taskId);
     return exists(paths.taskConfigPath);
 }
-async function assessReferenceEvidence(referencesDir) {
-    try {
-        const entries = await readdir(referencesDir);
-        const importedPrdCount = entries.filter((name) => name.endsWith(".md")).length;
-        return importedPrdCount > 0
-            ? { status: "present", importedPrdCount }
-            : { status: "absent-or-empty", importedPrdCount: 0 };
-    }
-    catch (error) {
-        if (error &&
-            typeof error === "object" &&
-            "code" in error &&
-            error.code === "ENOENT") {
-            return { status: "absent-or-empty", importedPrdCount: 0 };
-        }
-        return {
-            status: "unknown",
-            importedPrdCount: 0,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-function hasLedgerStructure(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const ledger = value;
-    return (typeof ledger.taskId === "string" &&
-        typeof ledger.inputDigest === "string" &&
-        typeof ledger.requirementSha256 === "string" &&
-        Array.isArray(ledger.sourcePaths) &&
-        Array.isArray(ledger.fragments) &&
-        Array.isArray(ledger.canonicalRequirements) &&
-        Boolean(ledger.stats && typeof ledger.stats === "object") &&
-        Array.isArray(ledger.unresolved) &&
-        Array.isArray(ledger.conflicts) &&
-        Array.isArray(ledger.sourceResolutions) &&
-        typeof ledger.schemaReconcilerVersion === "string" &&
-        typeof ledger.builtAt === "string");
-}
-async function assessSourceFidelityStartup(input) {
-    if (!input.applicable) {
-        return {
-            status: "not-applicable",
-            ledgerPath: input.ledgerPath,
-            diagnostics: [],
-        };
-    }
-    if (input.referenceEvidenceError) {
-        return {
-            status: "invalid",
-            ledgerPath: input.ledgerPath,
-            diagnostics: [
-                {
-                    code: "SOURCE_FIDELITY_LEDGER_STALE",
-                    message: `imported PRD reference evidence is unreadable: ${input.referenceEvidenceError}`,
-                },
-            ],
-        };
-    }
-    let raw;
-    try {
-        raw = await readFile(input.ledgerPath, "utf-8");
-    }
-    catch (error) {
-        const missing = !(await exists(input.ledgerPath));
-        return {
-            status: missing ? "missing" : "invalid",
-            ledgerPath: input.ledgerPath,
-            diagnostics: [
-                {
-                    code: missing
-                        ? "SOURCE_FIDELITY_LEDGER_MISSING"
-                        : "SOURCE_FIDELITY_LEDGER_STALE",
-                    message: missing
-                        ? "managed frontend task has no requirement-ledger.json"
-                        : `requirement ledger is unreadable: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-        };
-    }
-    try {
-        const ledger = parseLedgerJson(raw);
-        if (!hasLedgerStructure(ledger)) {
-            return {
-                status: "invalid",
-                ledgerPath: input.ledgerPath,
-                diagnostics: [
-                    {
-                        code: "SOURCE_FIDELITY_LEDGER_STALE",
-                        message: "requirement ledger is missing required structural fields",
-                    },
-                ],
-            };
-        }
-        const nonDecisionErrors = validateRequirementLedger(ledger, {
-            allowedUnresolved: true,
-            allowedConflicts: true,
-        });
-        if (nonDecisionErrors.length > 0) {
-            const coverageCodes = new Set([
-                "SOURCE_FIDELITY_HIGH_RISK_UNCOVERED",
-                "SOURCE_FIDELITY_REQUIREMENT_NOT_COVERED",
-            ]);
-            return {
-                status: nonDecisionErrors.every((error) => coverageCodes.has(error.code))
-                    ? "coverage-incomplete"
-                    : "invalid",
-                ledgerPath: input.ledgerPath,
-                diagnostics: nonDecisionErrors,
-            };
-        }
-        const decisionErrors = validateRequirementLedger(ledger);
-        if (decisionErrors.length > 0) {
-            return {
-                status: "human-decision-blocked",
-                ledgerPath: input.ledgerPath,
-                diagnostics: decisionErrors,
-            };
-        }
-        return { status: "complete", ledgerPath: input.ledgerPath, diagnostics: [] };
-    }
-    catch (error) {
-        return {
-            status: "invalid",
-            ledgerPath: input.ledgerPath,
-            diagnostics: [
-                {
-                    code: "SOURCE_FIDELITY_LEDGER_STALE",
-                    message: error instanceof Error ? error.message : String(error),
-                },
-            ],
-        };
-    }
-}
 /**
  * Explicit Task↔DAG association only:
  * - lifecycle.json recorded runAssociations
@@ -318,12 +182,10 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
     const record = await loadLifecycleRecord(repoRoot, taskId);
     const contractState = await observeTaskContractState(repoRoot, taskId);
     let title;
-    let taskKind;
     let taskConfigAllowed = [];
     try {
         const config = await loadTaskConfig(repoRoot, taskId);
         title = config.title;
-        taskKind = config.taskKind;
         taskConfigAllowed = config.allowedPaths ?? [];
     }
     catch {
@@ -337,22 +199,19 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
         ...(requirementReady ? [] : [requirementPath]),
         ...(constraintsReady ? [] : [constraintsPath]),
     ];
-    const contractManaged = contractState.effectiveStatus === "managed" || Boolean(contractState.ref);
+    let importedPrdCount = 0;
     const referencesDir = path.join(paths.sourceDir, "references");
-    const referenceEvidence = await assessReferenceEvidence(referencesDir);
-    const importedPrdCount = referenceEvidence.importedPrdCount;
-    const ledgerPath = path.join(paths.sourceDir, REQUIREMENT_LEDGER_FILE_NAME);
-    const sourceFidelityStartup = await assessSourceFidelityStartup({
-        ledgerPath,
-        applicable: contractManaged &&
-            taskKind === "frontend-implementation" &&
-            referenceEvidence.status !== "absent-or-empty",
-        referenceEvidenceError: referenceEvidence.status === "unknown"
-            ? referenceEvidence.error
-            : undefined,
-    });
-    const sourceFidelityReady = sourceFidelityStartup.status === "complete" ||
-        sourceFidelityStartup.status === "not-applicable";
+    if (await exists(referencesDir)) {
+        // Count is best-effort; absence is fine.
+        try {
+            const { readdir } = await import("node:fs/promises");
+            const entries = await readdir(referencesDir);
+            importedPrdCount = entries.filter((name) => name.endsWith(".md")).length;
+        }
+        catch {
+            importedPrdCount = 0;
+        }
+    }
     const dagDraftPath = paths.dagDraftPath;
     const dagDraftExists = await exists(dagDraftPath);
     let specHash = null;
@@ -426,11 +285,7 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
     // Open gate only when draft is strict-validated and the current binding is
     // not already approved/rejected. Rejected same-digest gates stay closed
     // until contract/source/DAG/writeSet/controller binding changes.
-    const gate = gateBound &&
-        strictValidated &&
-        sourceFidelityReady &&
-        !approvedCurrent &&
-        !rejectedCurrent
+    const gate = gateBound && strictValidated && !approvedCurrent && !rejectedCurrent
         ? buildWriteSetGate({ taskId, bound: gateBound, delta: gateDelta })
         : null;
     const gateOpen = Boolean(gate);
@@ -455,10 +310,11 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
                 activeRun.failureCategory === "needs-attention" ||
                 activeRun.failureCategory === "suspected-stall" ||
                 activeRun.failureCategory === "monitor-timeout"));
+    const contractManaged = contractState.effectiveStatus === "managed" || Boolean(contractState.ref);
     const lifecycleState = deriveLifecycleState({
         exists: true,
         contractManaged,
-        sourceReady: requirementReady && sourceFidelityReady,
+        sourceReady: requirementReady,
         dagValidated: strictValidated,
         gateOpen: Boolean(gate),
         activeRun,
@@ -496,7 +352,6 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
             constraintsReady,
             importedPrdCount,
             missing,
-            sourceFidelityStartup,
         },
         dagDraft: {
             path: dagDraftPath,
@@ -520,16 +375,7 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
             exists: closeoutExists || Boolean(record?.closeout),
         },
         completedTransitions: record?.completedTransitions ?? [],
-        blockers: sourceFidelityReady
-            ? []
-            : sourceFidelityStartup.diagnostics.map((diagnostic) => ({
-                code: diagnostic.code,
-                message: diagnostic.message,
-                details: {
-                    startupStatus: sourceFidelityStartup.status,
-                    ledgerPath: sourceFidelityStartup.ledgerPath,
-                },
-            })),
+        blockers: [],
         warnings: [],
         next,
     };

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

@@ -46,37 +46,6 @@ export function planTransitions(input) {
         actions.push({ type: "recover-contract" });
         expectedTransitions.push("contract-recovered");
     }
-    const startupStatus = snapshot.source?.sourceFidelityStartup?.status;
-    const startupRepairDetected = startupStatus === "missing" ||
-        startupStatus === "invalid" ||
-        startupStatus === "coverage-incomplete";
-    if (startupRepairDetected && input.startupRepairAttempted) {
-        actions.push({ type: "stop", reason: "blocker" });
-        return {
-            actions,
-            gate: null,
-            blockers,
-            next: {
-                kind: "advance",
-                command: `loop-agent task advance ${snapshot.taskId} --json`,
-            },
-            expectedTransitions,
-        };
-    }
-    const startupRepairRequired = startupRepairDetected;
-    if (startupStatus === "human-decision-blocked") {
-        actions.push({ type: "stop", reason: "blocker" });
-        return {
-            actions,
-            gate: null,
-            blockers,
-            next: {
-                kind: "external-action",
-                description: "Requirement ledger requires an existing human source decision; preserve sourceResolutions, resolve the blocker, then advance again.",
-            },
-            expectedTransitions,
-        };
-    }
     const sourceReady = snapshot.source?.requirementReady === true;
     const contractManaged = snapshot.contract?.effectiveStatus === "managed" ||
         Boolean(snapshot.contract?.revision && snapshot.contract.revision > 0);
@@ -84,9 +53,7 @@ export function planTransitions(input) {
     // Prefer prepare once PRDs are on disk; re-import only when caller still
     // signals hasPrdInput (advance.ts latches this after one import per call).
     const shouldImportPrd = input.hasPrdInput;
-    if (input.forcePrepareContract ||
-        input.refreshManagedContract ||
-        startupRepairRequired) {
+    if (input.forcePrepareContract || input.refreshManagedContract) {
         if (shouldImportPrd) {
             actions.push({ type: "import-prd" });
             expectedTransitions.push("prd-imported");
@@ -157,8 +124,7 @@ export function planTransitions(input) {
     const strictValidated = snapshot.dagDraft?.strictValidated === true;
     const dagRefreshRequired = Boolean(input.forceDagRefresh ||
         input.refreshManagedContract ||
-        input.forcePrepareContract ||
-        startupRepairRequired);
+        input.forcePrepareContract);
     if (!dagExists || dagRefreshRequired) {
         actions.push({ type: "generate-dag" });
         expectedTransitions.push("dag-generated");
@@ -179,11 +145,10 @@ export function planTransitions(input) {
         snapshot.lifecycleState === "evidence-closed" ||
         snapshot.lifecycleState === "needs-attention" ||
         snapshot.lifecycleState === "awaiting-decision";
-    const approveCurrentGate = input.approveGate && !dagRefreshRequired;
-    const approvedForCurrent = postRunState || (approveCurrentGate && gate !== null);
+    const approvedForCurrent = postRunState || (input.approveGate && gate !== null);
     if (!approvedForCurrent && (strictValidated || !dagExists || dagRefreshRequired)) {
         // Gate opens after generate+validate in the advance loop; plan includes open.
-        if (!approveCurrentGate) {
+        if (!input.approveGate) {
             actions.push({ type: "open-write-set-gate" });
             expectedTransitions.push("write-set-gate-opened");
             if (input.dryRun) {
@@ -212,14 +177,14 @@ export function planTransitions(input) {
         (snapshot.lifecycleState === "run-failed" && !failedRecoverable) ||
         snapshot.lifecycleState === "evidence-closed";
     if (!alreadyTerminalRun) {
-        if (approveCurrentGate && !postRunState) {
+        if (input.approveGate && !postRunState) {
             expectedTransitions.push("write-set-approved");
             actions.push({ type: "start-or-monitor-run" });
             expectedTransitions.push("dag-run-started", "dag-run-monitored");
         }
         else if (snapshot.lifecycleState === "running" ||
             snapshot.activeRun ||
-            (approveCurrentGate && Boolean(snapshot.activeRun))) {
+            (input.approveGate && Boolean(snapshot.activeRun))) {
             actions.push({ type: "start-or-monitor-run" });
             expectedTransitions.push("dag-run-monitored");
         }
@@ -253,7 +218,7 @@ export function planTransitions(input) {
         actions,
         gate,
         blockers,
-        next: deriveNext(snapshot, gate, approveCurrentGate),
+        next: deriveNext(snapshot, gate, input.approveGate),
         expectedTransitions,
     };
 }

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

@@ -42,7 +42,6 @@ export async function buildTaskLifecycleRecommendations(input) {
     const allowedPaths = [];
     const verifyCommands = [];
     // 1) managed task config
-    let hasDeclaredManagedVerify = false;
     try {
         const config = await loadTaskConfig(input.repoRoot, input.taskId);
         for (const glob of config.allowedPaths ?? []) {
@@ -54,9 +53,7 @@ export async function buildTaskLifecycleRecommendations(input) {
                 source: "managed-task-config",
             });
         }
-        const managedVerify = (config.verifyCommands ?? []).filter((cmd) => Boolean(cmd.command?.trim()));
-        hasDeclaredManagedVerify = managedVerify.length > 0;
-        for (const cmd of managedVerify) {
+        for (const cmd of config.verifyCommands ?? []) {
             const label = cmd.label?.trim() || "verify";
             const command = cmd.command?.trim();
             if (!command)
@@ -73,22 +70,14 @@ export async function buildTaskLifecycleRecommendations(input) {
         // task may not exist yet
     }
     // 2) package.json scripts (only if not already covered by managed config)
-    // The full-suite `test` script is recommended only when the task declares
-    // NO managed verifyCommands at all. Once a task configures a targeted
-    // verify set (e.g. per-change typecheck + a scoped vitest run), the full
-    // `npm run test` must never be auto-added: it validates the whole repo,
-    // costs far more than the change under review, and can fail on unrelated
-    // pre-existing breakage, turning a targeted verify green into a hard fail.
     const scripts = await readPackageScripts(input.repoRoot);
     const hasVerifyLabel = (label) => verifyCommands.some((entry) => entry.label === label);
     const scriptCandidates = [
         { label: "typecheck", script: "typecheck" },
+        { label: "test", script: "test" },
         { label: "check-repo", script: "check:repo" },
         { label: "check-repo", script: "check-repo" },
     ];
-    if (!hasDeclaredManagedVerify) {
-        scriptCandidates.push({ label: "test", script: "test" });
-    }
     for (const candidate of scriptCandidates) {
         const scriptBody = scripts[candidate.script];
         if (!scriptBody)

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.41.1-beta.0",
-  "gitSha": "fbc12f26a410e65b74cb259639de202885609c15",
-  "builtAt": "2026-08-31T10:40:48.916Z"
+  "version": "0.41.1",
+  "gitSha": "d5dec271d8ae9c579c423d9ea7b98fb0270baa5a",
+  "builtAt": "2026-09-02T04:40:44.741Z"
 }

package/dist/cli/command-definitions.js

@@ -36,7 +36,6 @@ import { runDagReconcileTasks } from "../commands/dag-reconcile-tasks.js";
 import { runDagReconcileRun } from "../commands/dag-reconcile-run.js";
 import { runDagRequestInterrupt } from "../commands/dag-request-interrupt.js";
 import { runDagRerunTask } from "../commands/dag-rerun-task.js";
-import { runDagFollowUp } from "../commands/dag-follow-up.js";
 import { runDagRerun } from "../commands/dag-rerun.js";
 import { runDagResume } from "../commands/dag-resume.js";
 import { runDagDecisionInspect, runDagDecisionValidate, } from "../workflows/dag/decision-envelope.js";
@@ -136,7 +135,6 @@ const DAG_SUBCOMMANDS = [
     "request-interrupt",
     "rerun",
     "rerun-task",
-    "follow-up",
     "reconcile-tasks",
     "final-verification",
     "decision",
@@ -583,11 +581,6 @@ export const COMMAND_DEFINITIONS = [
                 await runDagRerunTask(repoRoot, rerunTaskArgs);
                 return;
             }
-            if (subcommand === "follow-up") {
-                const followUpArgs = rest.filter((arg) => Boolean(arg));
-                await runDagFollowUp(repoRoot, followUpArgs);
-                return;
-            }
             if (subcommand === "reconcile-tasks") {
                 const reconcileArgs = rest.filter((arg) => Boolean(arg));
                 await runDagReconcileTasks(repoRoot, reconcileArgs);

package/dist/cli/program.js

@@ -13,7 +13,6 @@ import { runDagReconcileTasks } from "../commands/dag-reconcile-tasks.js";
 import { runDagReconcileRun } from "../commands/dag-reconcile-run.js";
 import { runDagRequestInterrupt } from "../commands/dag-request-interrupt.js";
 import { runDagRerunTask } from "../commands/dag-rerun-task.js";
-import { runDagFollowUp } from "../commands/dag-follow-up.js";
 import { runDagRerun } from "../commands/dag-rerun.js";
 import { runDagReject } from "../commands/dag-reject.js";
 import { runDagCloseoutDraft, runDagReport } from "../commands/dag-report.js";
@@ -358,9 +357,6 @@ async function runDagAction(repoRoot, subcommand, rest) {
         case "rerun-task":
             await runDagRerunTask(repoRoot, args);
             return;
-        case "follow-up":
-            await runDagFollowUp(repoRoot, args);
-            return;
         case "reconcile-tasks":
             await runDagReconcileTasks(repoRoot, args);
             return;
@@ -549,7 +545,6 @@ function addDagCommand(program, defaultRepoRoot) {
         "request-interrupt",
         "rerun",
         "rerun-task",
-        "follow-up",
         "reconcile-tasks",
         "final-verification",
     ], defaultRepoRoot);

package/dist/commands/client-recovery.js

@@ -1328,15 +1328,12 @@ export async function runClientRecovery(input) {
     }
     const plugin = await installProjectOpenCodePlugin({
         repoRoot: input.repoRoot,
-        onlyIfMissing: true,
     });
     const overflowPlugin = await installProjectOpenCodeOverflowCompactPlugin({
         repoRoot: input.repoRoot,
-        onlyIfMissing: true,
     });
     const piExtension = await installProjectPiContextOverflowExtension({
         repoRoot: input.repoRoot,
-        onlyIfMissing: true,
     });
     const pi = await applyProjectPiSettingsMerge({ repoRoot: input.repoRoot });
     if (mode !== "user") {

package/dist/commands/init.js

@@ -14,19 +14,6 @@ const GITIGNORE_BLOCK_START = "# LOOP_AGENT_INIT_START";
 const GITIGNORE_BLOCK_END = "# LOOP_AGENT_INIT_END";
 const INIT_SURFACE_STATE_PATH = ".harness/init-surface.json";
 const DEFAULT_GOVERNANCE_ROOT = "ai_workspace/loop-agent";
-function buildSpecRegistry() {
-    return `${JSON.stringify({
-        version: 1,
-        roots: [],
-        discovery: {
-            enabled: true,
-            maxDepth: 3,
-            maxFiles: 100,
-            maxBytes: 1048576,
-            timeoutMs: 2000,
-        },
-    }, null, 2)}\n`;
-}
 const CORE_DOC_FILES = [
     { source: "README.md", target: "README.md" },
     {
@@ -623,7 +610,7 @@ if (
   (assessment.status === "passed" && assessment.currentExitCode !== 0) ||
   (assessment.status === "baseline-debt" && assessment.currentExitCode === 0)
 ) fail();
-if (!assessment.baselineRef || assessment.baselineRef.nodeId !== "frontend-writer-admission-shell") fail();
+if (!assessment.baselineRef || assessment.baselineRef.nodeId !== "frontend-lint-baseline-shell") fail();
 const baselineRaw = readContained(assessment.baselineRef.path);
 if (sha256(baselineRaw) !== assessment.baselineRef.sha256) fail();
 let baseline;
@@ -1325,9 +1312,6 @@ async function buildDesiredSurfaceContent(input) {
             }), null, 2)}\n`,
         };
     }
-    if (manifestPath === "docs/spec-registry.json") {
-        return { content: buildSpecRegistry() };
-    }
     if (manifestPath === OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH) {
         return { content: buildOpenCodeTransientRetryPluginSource() };
     }
@@ -1725,8 +1709,6 @@ async function listRelativeFiles(rootPath) {
 async function expectedLegacyInitFileSha(input) {
     if (input.legacyPath.startsWith("docs/")) {
         const doc = input.legacyPath.slice("docs/".length);
-        if (doc === "spec-registry.json")
-            return sha256Text(buildSpecRegistry());
         const generated = buildGeneratedCoreDoc({
             doc,
             projectName: input.projectName,
@@ -2725,14 +2707,6 @@ export async function initializeLoopAgentProject(options) {
         targetRelativePath: path.join(governanceRoot, "templates"),
         written,
     });
-    await writeTextIfMissing({
-        repoRoot,
-        relativePath: path.join(governanceRoot, "spec-registry.json"),
-        content: buildSpecRegistry(),
-        merge,
-        written,
-        skipped,
-    });
     if (profile === "full") {
         // Project repo-local skills live only under `.agents/skills/`.
         // The package still ships `skills/` as the built-in fallback source.

package/dist/commands/task-advance.js

@@ -377,25 +377,6 @@ export async function runTaskAdvance(repoRoot, args) {
                 intervalMs: options.progressIntervalMs,
             });
         }
-        // Idempotent client-recovery surface install before any DAG run: the Pi
-        // context-overflow extension / OpenCode plugins / project .pi settings
-        // are normally installed by `loop-agent init`, but an upgraded or
-        // non-init-created project may lack them. Installing here (missing-only)
-        // ensures the overflow compact+retry recovery path is always present,
-        // independent of how the project was created. Best-effort: a failure to
-        // install never blocks the run.
-        if (options.approveGate && !options.dryRun) {
-            try {
-                const { runClientRecovery } = await import("./client-recovery.js");
-                // mode "project" installs only project-owned surfaces
-                // (.pi/extensions + .opencode/plugins + .pi/settings.json),
-                // never the user home; installs are missing-only.
-                await runClientRecovery({ repoRoot, mode: "project" });
-            }
-            catch {
-                // best-effort; do not fail the run over a recovery-surface install
-            }
-        }
         const result = await advanceTaskLifecycle(toUseCaseInput(repoRoot, taskId, options, progress?.observer));
         const outcome = mapOutcome(result);
         const gateStop = result.lifecycleState === "awaiting-write-set-approval" &&