@tea-agent/loop-agent 0.41.1 → 0.42.0-next.10

package/dist/adapters/context-transfer/optional-pi-handoff.js

@@ -0,0 +1,31 @@
+/**
+ * Probe only. pi-handoff is an interactive Pi extension, not a renderer API,
+ * so Context Bundle generation never imports or executes it. This isolation
+ * keeps the authoritative export path deterministic when the optional package
+ * is absent, broken, or changes its private Pi dependencies.
+ */
+export async function probeOptionalPiHandoff(input = {}) {
+    const resolve = input.resolve ?? (async (specifier) => import.meta.resolve(specifier));
+    try {
+        await resolve("@nicknisi/pi-handoff");
+        return {
+            schemaVersion: 1,
+            packageName: "@nicknisi/pi-handoff",
+            status: "available-interactive-only",
+            coreBundleUnaffected: true,
+            detail: "extension can be used after Pi import, but does not expose a Context Bundle renderer API",
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            schemaVersion: 1,
+            packageName: "@nicknisi/pi-handoff",
+            status: /cannot find|not found|resolve/i.test(message)
+                ? "not-installed"
+                : "incompatible",
+            coreBundleUnaffected: true,
+            detail: "optional extension unavailable; use generic or Pi session adapter",
+        };
+    }
+}

package/dist/adapters/context-transfer/pi-session.js

@@ -0,0 +1,61 @@
+import { createHash } from "node:crypto";
+function sha256(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+export function evaluatePiSessionCapability(receipt) {
+    const limitations = [
+        "Pi JSONL import does not restore the captured system prompt as a system message",
+        "provider authentication and external tool state are intentionally not exported",
+    ];
+    if (receipt.runtime.executor !== "pi") {
+        return {
+            schemaVersion: 1,
+            compatible: false,
+            reproducibility: "semantic-handoff",
+            reasonCodes: ["PI_EXECUTOR_NOT_CAPTURED"],
+            limitations,
+        };
+    }
+    return {
+        schemaVersion: 1,
+        compatible: true,
+        reproducibility: "semantic-handoff",
+        reasonCodes: ["PI_IMPORT_SEMANTIC_ONLY"],
+        limitations,
+    };
+}
+/**
+ * Build a minimal Pi v3 JSONL session that can be opened with `/import`.
+ * It deliberately references the sibling bundle materials instead of
+ * duplicating a potentially large prompt inside the session file.
+ */
+export function renderPiSessionJsonl(input) {
+    const capability = evaluatePiSessionCapability(input.receipt);
+    const seed = `${input.runId}:${input.nodeId}:${input.attempt}:${input.receipt.contextDigest}`;
+    const sessionId = sha256(`session:${seed}`).slice(0, 32);
+    const messageId = sha256(`message:${seed}`).slice(0, 16);
+    const timestamp = input.receipt.identity.capturedAt;
+    const header = {
+        type: "session",
+        version: 3,
+        id: sessionId,
+        timestamp,
+        cwd: ".",
+    };
+    const message = {
+        type: "message",
+        id: messageId,
+        parentId: null,
+        timestamp,
+        message: {
+            role: "user",
+            content: [
+                "This session was imported from a loop-agent Context Bundle.",
+                "Read and follow context/system-prompt.md, then continue the request in context/user-message.md.",
+                `Context digest: ${input.receipt.contextDigest}`,
+                `Reproducibility: ${capability.reproducibility}. ${capability.limitations.join("; ")}.`,
+            ].join("\n\n"),
+        },
+    };
+    return `${JSON.stringify(header)}\n${JSON.stringify(message)}\n`;
+}

package/dist/application/dag/generate-task-dag.js

@@ -13,6 +13,8 @@ import { runDagUseCase } from "./run-dag.js";
 import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { writeTaskConfig } from "../../infrastructure/harness/task-store.js";
 import { runFrontendPreflight } from "../../task/frontend-preflight.js";
+import { discoverFrontendProjectCapability } from "../../task/frontend-project-capability.js";
+import { classifyTaskDemand } from "../../task/task-demand-routing.js";
 import { observeTaskContract } from "../../task/contract/observe.js";
 import { adoptTaskContract } from "../../task/contract/adopt.js";
 const PLACEHOLDER_WRITESET_MARKER = "REPLACE/WITH";
@@ -88,6 +90,63 @@ function buildBasicValidationLevel(outputPath) {
         note: "Internal generation validation is basic only; standalone strict governance validation must be confirmed separately.",
     };
 }
+async function promoteAutomaticFrontendTaskKind(input) {
+    if (input.taskConfig.taskKind !== "standard" ||
+        input.taskConfig.taskKindExplicit) {
+        return false;
+    }
+    let requirementMarkdown = "";
+    try {
+        requirementMarkdown = await readFile(path.join(getTaskPaths(input.repoRoot, input.taskId).sourceDir, "需求.md"), "utf8");
+    }
+    catch {
+        return false;
+    }
+    if (!requirementMarkdown.trim())
+        return false;
+    let frontendProject;
+    try {
+        frontendProject = await discoverFrontendProjectCapability(input.repoRoot);
+    }
+    catch {
+        // The existing standard route remains the safe fallback when capability
+        // discovery is unavailable.
+    }
+    const classification = classifyTaskDemand({
+        title: input.taskConfig.title,
+        requirementMarkdown,
+        allowedPaths: input.taskConfig.allowedPaths,
+        frontendProject: frontendProject
+            ? {
+                framework: frontendProject.framework,
+                evidencePaths: frontendProject.evidencePaths,
+            }
+            : undefined,
+    });
+    if (classification.kind !== "frontend")
+        return false;
+    await writeTaskConfig(input.repoRoot, input.taskId, {
+        ...input.taskConfig,
+        taskKind: "frontend-implementation",
+        dagFallbackReason: "Automatically classified as a high-confidence frontend implementation task.",
+    });
+    const state = await observeTaskContract({
+        repoRoot: input.repoRoot,
+        taskId: input.taskId,
+    });
+    if (!state.ref || !state.observedCanonicalHash) {
+        throw new Error("automatic frontend routing could not reconcile the managed Task Contract");
+    }
+    await adoptTaskContract({
+        repoRoot: input.repoRoot,
+        taskId: input.taskId,
+        expectedRevision: state.ref.revision,
+        expectedObservedHash: state.observedCanonicalHash,
+        requestId: `automatic-frontend-route-${input.taskId}-${randomUUID()}`,
+        requestPayloadSha256: randomUUID().replaceAll("-", "").padEnd(64, "0"),
+    });
+    return true;
+}
 function isBroadWriteSetEntryForPacket(entry) {
     const normalized = entry.trim().replace(/\\/g, "/").replace(/^\.\//, "");
     if (!normalized || normalized === "." || normalized === "./")
@@ -280,12 +339,25 @@ export async function generateTaskDagUseCase(input) {
             requestPayloadSha256: randomUUID().replaceAll("-", "").padEnd(64, "0"),
         });
     }
-    const candidateResult = await initHybridDagFromTask(repoRoot, parsed.taskId, {
+    const routingTaskConfig = await loadTaskConfig(repoRoot, parsed.taskId);
+    let initialTemplate = routingTaskConfig.taskKind === "frontend-implementation"
+        ? "frontend-implementation"
+        : "standard-dag";
+    if (initialTemplate === "standard-dag") {
+        const promoted = await promoteAutomaticFrontendTaskKind({
+            repoRoot,
+            taskId: parsed.taskId,
+            taskConfig: routingTaskConfig,
+        });
+        if (promoted)
+            initialTemplate = "frontend-implementation";
+    }
+    let candidateResult = await initHybridDagFromTask(repoRoot, parsed.taskId, {
         outputPath: parsed.outputPath,
-        template: "standard-dag",
+        template: initialTemplate,
         rerunFeedback: parsed.rerunFeedback,
     });
-    const candidateValidateSummary = await validateDagUseCase(buildValidateInput(repoRoot, candidateResult.outputPath, parsed));
+    let candidateValidateSummary = await validateDagUseCase(buildValidateInput(repoRoot, candidateResult.outputPath, parsed));
     const profileRouting = await resolveProfileRouting(repoRoot, parsed, candidateValidateSummary.governanceProfile ?? {
         profile: "standard",
         process: [],
@@ -308,22 +380,6 @@ export async function generateTaskDagUseCase(input) {
             profileRouting.selectedByProfile = parsed.profile;
         }
     }
-    // Persist the automatic business workflow route while preserving the
-    // governance profile as a separate routing dimension.
-    if (hasAutomaticTaskSourceRoute &&
-        candidateResult.template === "frontend-implementation") {
-        const taskConfig = await loadTaskConfig(repoRoot, parsed.taskId);
-        // Human-explicit taskKind (incl. explicit standard) is a hard contract:
-        // never rewrite task.json taskKind via semantic classification.
-        if (!taskConfig.taskKindExplicit &&
-            (!taskConfig.taskKind || taskConfig.taskKind === "standard")) {
-            await writeTaskConfig(repoRoot, parsed.taskId, {
-                ...taskConfig,
-                taskKind: "frontend-implementation",
-                dagFallbackReason: "Automatically classified as a high-confidence frontend implementation task.",
-            });
-        }
-    }
     const initResult = profileRouting.selectedTemplate === candidateResult.template
         ? candidateResult
         : await initHybridDagFromTask(repoRoot, parsed.taskId, {

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

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { createDagEventObserver } from "../../workflows/dag/event-observer.js";
 import { composeDagRunObservers } from "../../workflows/dag/observer-compose.js";
 import { createDagCanvasObserver, resolveCanvasPath, } from "../../workflows/dag/canvas-observer.js";
@@ -28,6 +29,41 @@ function buildRunDagNextSteps(runId) {
         `loop-agent dag report --run-id ${runId} --markdown  # advanced forensic`,
     ];
 }
+/** Shared production recovery seam for fresh runs and recovery continuations. */
+export async function buildDefaultFrontendRecoveryDeps(repoRoot) {
+    // Keep the application layer free of a static worker→application cycle. The
+    // recovery controller is only needed after a frontend terminal failure.
+    const [{ openConsoleAppData }, { OperationStore }, { createOperationEventStore }, { LoopAgentClient }, { resolveSiblingLoopAgentBin },] = await Promise.all([
+        import("../../infrastructure/console/app-data.js"),
+        import("../../infrastructure/console/operation-store.js"),
+        import("../../worker/console/operation-sse.js"),
+        import("../../worker/loop-agent/loop-agent-client.js"),
+        import("../../worker/console/sibling-controller.js"),
+    ]);
+    const appData = openConsoleAppData({ repoRoot });
+    const store = new OperationStore(appData);
+    const events = createOperationEventStore({
+        persistenceDir: path.join(appData.operations, "events"),
+    });
+    const client = new LoopAgentClient({
+        loopAgentBin: resolveSiblingLoopAgentBin(),
+        artifactRoot: path.join(appData.root, "client-artifacts", appData.fingerprint),
+        resolveIdentity: true,
+    });
+    return {
+        store,
+        operationRunnerDeps: {
+            store,
+            events,
+            client,
+            repoRoot,
+            env: {
+                ...process.env,
+                LOOP_CONSOLE_APP_DATA: appData.root,
+            },
+        },
+    };
+}
 export async function runDagUseCase(input) {
     const spec = await loadDagSpecFromFile(input.dagPath);
     assertValidDagSpec(spec);
@@ -80,6 +116,10 @@ export async function runDagUseCase(input) {
             ...(canvasError ? { canvasError } : {}),
         };
     }
+    const recovery = input.recovery ??
+        (!input.initOnly && spec.tasks.some((task) => task.id === "frontend-implement-pi")
+            ? await buildDefaultFrontendRecoveryDeps(input.cwd)
+            : undefined);
     const summary = await runDag(spec, {
         cwd: input.cwd,
         initOnly: input.initOnly,
@@ -90,6 +130,7 @@ export async function runDagUseCase(input) {
         ...(input.workerAssociation
             ? { workerAssociation: input.workerAssociation }
             : {}),
+        ...(recovery ? { recovery } : {}),
     });
     const canvasError = await flushCanvasSafely(canvas);
     if (resolvedCanvasPath) {

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

@@ -260,6 +260,10 @@ 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")
@@ -379,7 +383,10 @@ export async function advanceTaskLifecycle(input) {
             };
         }
         const token = parseGateToken(input.rejectGateToken);
-        const currentGate = snapshot.gate ?? (await buildCurrentGate(input.repoRoot, input.taskId));
+        const currentGate = snapshot.gate ??
+            (isStartupGateEligible(snapshot)
+                ? await buildCurrentGate(input.repoRoot, input.taskId)
+                : null);
         if (!currentGate || !gateMatches(currentGate, token)) {
             return {
                 taskId: input.taskId,
@@ -443,11 +450,12 @@ 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 ??
-            (snapshot.dagDraft?.exists
+            (isStartupGateEligible(snapshot) && snapshot.dagDraft?.exists
                 ? await buildCurrentGate(input.repoRoot, input.taskId)
                 : null);
         return {
@@ -499,7 +507,10 @@ export async function advanceTaskLifecycle(input) {
         }
         if (action.type === "create-task") {
             if (!snapshot.exists) {
-                await createTask(input.repoRoot, input.taskId, input.title);
+                await createTask(input.repoRoot, input.taskId, input.title, {
+                    taskKind: input.taskKind,
+                    taskKindExplicit: input.taskKindExplicit,
+                });
                 record = appendTransition(record, "task-created");
                 completed.push("task-created");
                 await saveLifecycleRecord(input.repoRoot, record);
@@ -586,6 +597,10 @@ 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 路径共用同一接线，保证任意一条生产路径都实际
@@ -731,7 +746,9 @@ export async function advanceTaskLifecycle(input) {
                                     message: "structured requirement draft via semantic intake; projected managed source",
                                 });
                                 preparedContractThisCall = true;
-                                if (refreshManagedContractThisCall || input.fromDraftPath) {
+                                if (startupRepairAction ||
+                                    refreshManagedContractThisCall ||
+                                    input.fromDraftPath) {
                                     refreshManagedContractThisCall = false;
                                     regenerateDagThisCall = true;
                                 }
@@ -825,7 +842,9 @@ export async function advanceTaskLifecycle(input) {
                 break;
             }
             preparedContractThisCall = true;
-            if (refreshManagedContractThisCall || input.fromDraftPath) {
+            if (startupRepairAction ||
+                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,9 +1,11 @@
-import { access, readFile } from "node:fs/promises";
+import { access, readFile, readdir } 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) {
@@ -47,6 +49,140 @@ 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
@@ -182,10 +318,12 @@ 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 {
@@ -199,19 +337,22 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
         ...(requirementReady ? [] : [requirementPath]),
         ...(constraintsReady ? [] : [constraintsPath]),
     ];
-    let importedPrdCount = 0;
+    const contractManaged = contractState.effectiveStatus === "managed" || Boolean(contractState.ref);
     const referencesDir = path.join(paths.sourceDir, "references");
-    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 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";
     const dagDraftPath = paths.dagDraftPath;
     const dagDraftExists = await exists(dagDraftPath);
     let specHash = null;
@@ -285,7 +426,11 @@ 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 && !approvedCurrent && !rejectedCurrent
+    const gate = gateBound &&
+        strictValidated &&
+        sourceFidelityReady &&
+        !approvedCurrent &&
+        !rejectedCurrent
         ? buildWriteSetGate({ taskId, bound: gateBound, delta: gateDelta })
         : null;
     const gateOpen = Boolean(gate);
@@ -310,11 +455,10 @@ 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,
+        sourceReady: requirementReady && sourceFidelityReady,
         dagValidated: strictValidated,
         gateOpen: Boolean(gate),
         activeRun,
@@ -352,6 +496,7 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
             constraintsReady,
             importedPrdCount,
             missing,
+            sourceFidelityStartup,
         },
         dagDraft: {
             path: dagDraftPath,
@@ -375,7 +520,16 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
             exists: closeoutExists || Boolean(record?.closeout),
         },
         completedTransitions: record?.completedTransitions ?? [],
-        blockers: [],
+        blockers: sourceFidelityReady
+            ? []
+            : sourceFidelityStartup.diagnostics.map((diagnostic) => ({
+                code: diagnostic.code,
+                message: diagnostic.message,
+                details: {
+                    startupStatus: sourceFidelityStartup.status,
+                    ledgerPath: sourceFidelityStartup.ledgerPath,
+                },
+            })),
         warnings: [],
         next,
     };