@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.11

package/dist/workflows/dag/frontend-recovery-run.js

@@ -3,10 +3,10 @@ import path from "node:path";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { sha256Hex } from "./frontend-implementation-contract.js";
 import { FRONTEND_RECOVERY_IMPORT_MANIFEST_REL_PATH, FRONTEND_RECOVERY_INTENT_REL_DIR, FRONTEND_RECOVERY_STAGING_PREFIX, computeFrontendRecoveryPlan, computeFrontendRecoveryPlanForSource, } from "./frontend-recovery-plan.js";
-import { dagRunDirExists, getDagRunDir, readDagRunSpec, readDagRunState, transferDagRunDir, writeDagRunState, } from "./lifecycle.js";
+import { dagRunDirExists, getDagRunDir, locateDagRun, readDagRunSpec, readDagRunState, transferDagRunDir, writeDagRunState, } from "./lifecycle.js";
 import { buildDagRunId } from "./runner.js";
 import { prepareRunDir, writeNodeRecord } from "./run-store.js";
-import { FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT, readFrontendPrewriteResult, } from "./scheduler.js";
+import { FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT, readFrontendWriterAdmissionResult, } from "./scheduler.js";
 import { topoSortToRanks } from "./topo.js";
 /**
  * Candidate-continuation child creation kernel (phase 3b).
@@ -19,8 +19,8 @@ import { topoSortToRanks } from "./topo.js";
  * phase=child-running. Scheduling/execution of the child is phase 3c and out
  * of scope here.
  */
-/** Canonical contract artifact default location; overridden by the prewrite
- * gate's configured outputDir/artifactName when present. */
+/** Canonical contract artifact default location; overridden by the design
+ * policy shell's configured outputDir/artifactName when present. */
 const FRONTEND_CANONICAL_CONTRACT_DEFAULT_REL_PATH = "contracts/frontend-implementation-contract.json";
 function resolveDeps(deps) {
     return {
@@ -62,6 +62,9 @@ function isValidFrontendRecoveryMarker(raw) {
  * Read + validate the activation marker. Missing or invalid markers return
  * `undefined` so the phase-3c gate and tests can treat an unmarked active
  * child as not executable (AC-2 / AC-5d).
+ *
+ * @deprecated Read-only/scheduler compatibility only; the runner no longer
+ * uses activation markers as the authoritative recovery entry point.
  */
 export async function readFrontendRecoveryMarker(parentRunDir, requestId) {
     let raw;
@@ -79,8 +82,8 @@ export async function readFrontendRecoveryMarker(parentRunDir, requestId) {
     return raw;
 }
 function classifyFrontendFactKind(nodeId) {
-    if (/prewrite/i.test(nodeId))
-        return "prewrite";
+    if (/admission|design-policy|verify|policy/i.test(nodeId))
+        return "gate";
     if (/scout/i.test(nodeId))
         return "scout";
     if (/contract/i.test(nodeId))
@@ -91,9 +94,9 @@ function classifyFrontendFactKind(nodeId) {
 }
 function resolveCanonicalContractRelPath(spec) {
     for (const task of spec.tasks) {
-        const gate = task.shell?.frontendPrewriteGate;
-        if (gate) {
-            return path.posix.join(gate.outputDir, gate.artifactName);
+        const policy = task.shell?.frontendDesignPolicy;
+        if (policy) {
+            return path.posix.join(policy.outputDir, policy.artifactName);
         }
     }
     return FRONTEND_CANONICAL_CONTRACT_DEFAULT_REL_PATH;
@@ -270,14 +273,63 @@ async function casUpdateFrontendRecoveryState(parentRunDir, expectedRevision, de
     await deps.writeParentState(parentRunDir, state);
 }
 async function materializeChildStaging(input) {
-    const { cwd, parentRunDir, parentRunId, parentSpec, parentState, recovery, requestId, childRunId, stagingDir, createdAt, } = input;
+    const { cwd, parentRunDir, parentRunId, parentSpec, parentState, recovery, recoveryPlan, requestId, childRunId, stagingDir, createdAt, } = input;
     await prepareRunDir(stagingDir);
-    await writeJsonVerified(stagingDir, "run.json", parentSpec);
+    // Design-review rejection must be visible to the reset planner. Recovery
+    // children otherwise copy the old spec and only rerun design review, which
+    // deterministically re-rejects the unchanged plan. Bind the parent's typed
+    // findings into the child spec as ordinary rerun feedback.
+    let childSpec = parentSpec;
+    if (recovery.failureSource === "frontend-plan-pi" ||
+        recovery.failureSource === "frontend-review-pi") {
+        const designRecovery = parentState.terminalReason === "design-request-changes";
+        const reviewRecovery = recovery.failureSource === "frontend-review-pi" ||
+            parentState.terminalReason === "review-request-changes";
+        let feedback;
+        try {
+            const { deriveDagRerunFeedback } = await import("./rerun-feedback.js");
+            const taskId = parentSpec.taskContractBinding?.taskId ??
+                parentSpec.sourceBinding?.taskId ??
+                parentRunId;
+            feedback = await deriveDagRerunFeedback({
+                parentRunId,
+                taskId,
+                runDir: parentRunDir,
+                spec: parentSpec,
+                state: parentState,
+            });
+            if (reviewRecovery &&
+                feedback &&
+                feedback.sourceNodeId !== "frontend-review-pi") {
+                // Do not accidentally carry an older design/verify finding when a
+                // review-triggered continuation has lost its typed review fact.
+                feedback = undefined;
+            }
+        }
+        catch (error) {
+            if (designRecovery || reviewRecovery) {
+                throw new Error(`frontend recovery feedback unavailable: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (feedback) {
+            childSpec = { ...parentSpec, rerunFeedback: feedback };
+        }
+        else if (designRecovery || reviewRecovery) {
+            // A design/review rejection cannot be safely retried without its typed
+            // findings. Fail closed instead of deterministically re-running the
+            // unchanged plan and producing another rejection.
+            throw new Error(`frontend recovery feedback unavailable: no typed ${reviewRecovery ? "review" : "design"} findings were found for recovery`);
+        }
+    }
+    await writeJsonVerified(stagingDir, "run.json", childSpec);
     // Phase 5: writer transient partial-write recovery resets the writer subtree
     // (frontend-implement-pi) instead of the candidate producer; everything
     // upstream is imported as verified parent facts.
     let plan;
-    if (recovery.failureSource) {
+    if (recoveryPlan) {
+        plan = recoveryPlan;
+    }
+    else if (recovery.failureSource) {
         plan = computeFrontendRecoveryPlanForSource({
             spec: parentSpec,
             parentRunId,
@@ -286,21 +338,21 @@ async function materializeChildStaging(input) {
         });
     }
     else {
-        const prewriteRead = await readFrontendPrewriteResult(parentRunDir);
-        if (!prewriteRead.ok) {
-            throw new Error(prewriteRead.reason);
+        const admissionRead = await readFrontendWriterAdmissionResult(parentRunDir);
+        if (!admissionRead.ok) {
+            throw new Error(admissionRead.reason);
         }
         plan = computeFrontendRecoveryPlan({
             spec: parentSpec,
             parentRunId,
             requestId,
-            result: prewriteRead.result,
+            result: admissionRead.result,
         });
     }
-    const { ranks } = topoSortToRanks(parentSpec);
+    const { ranks } = topoSortToRanks(childSpec);
     const resetSet = new Set(plan.resetNodeIds);
     const importedSet = new Set(plan.importedNodeIds);
-    const tasksById = new Map(parentSpec.tasks.map((task) => [task.id, task]));
+    const tasksById = new Map(childSpec.tasks.map((task) => [task.id, task]));
     const nodes = {};
     const importedFacts = [];
     for (const nodeId of plan.importedNodeIds) {
@@ -325,22 +377,22 @@ async function materializeChildStaging(input) {
         }
         nodes[nodeId] = buildPendingNodeRecord(task);
     }
-    for (const task of parentSpec.tasks) {
+    for (const task of childSpec.tasks) {
         if (!resetSet.has(task.id) && !importedSet.has(task.id)) {
             throw new Error(`node ${task.id} missing from frontend recovery plan partition`);
         }
     }
-    // Canonical contract + prewrite-result identity facts are copied alongside
+    // Canonical contract + writer-admission identity facts are copied alongside
     // the per-node facts so reset nodes can re-read them (AC-4).
     const canonicalContract = await copyArtifactVerified({
         parentRunDir,
         newRunDir: stagingDir,
-        relativePath: resolveCanonicalContractRelPath(parentSpec),
+        relativePath: resolveCanonicalContractRelPath(childSpec),
     });
-    const prewriteResult = await copyArtifactVerified({
+    const writerAdmissionResult = await copyArtifactVerified({
         parentRunDir,
         newRunDir: stagingDir,
-        relativePath: FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT,
+        relativePath: FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT,
     });
     const childState = {
         version: 1,
@@ -359,8 +411,11 @@ async function materializeChildStaging(input) {
             parentRunId,
             childRunId,
             attemptId: recovery.attemptId,
-            attemptIndex: 1,
-            continuationCount: 1,
+            attemptIndex: recovery.attemptIndex + 1,
+            continuationCount: recovery.continuationCount + 1,
+            ...(recovery.failureSource
+                ? { failureSource: recovery.failureSource }
+                : {}),
             revision: 0,
         },
         ...(parentState.evaluation
@@ -377,9 +432,9 @@ async function materializeChildStaging(input) {
             relativePath: canonicalContract.destinationRelativePath,
             sha256: canonicalContract.sha256,
         },
-        prewriteResult: {
-            relativePath: prewriteResult.destinationRelativePath,
-            sha256: prewriteResult.sha256,
+        writerAdmissionResult: {
+            relativePath: writerAdmissionResult.destinationRelativePath,
+            sha256: writerAdmissionResult.sha256,
         },
         importedFacts,
     };
@@ -417,6 +472,9 @@ async function verifyThreeWayConsistency(input) {
  * intent. Single-writer: the recovery coordinator is the only caller.
  * Fail-closed on revision drift, missing intent, unreadable prewrite result,
  * hash mismatch, marker-write failure, or consistency failure.
+ *
+ * @deprecated The M6 operation controller is the authoritative recovery loop;
+ * this kernel is retained only for read-only/scheduler compatibility.
  */
 export async function stageRecoveryChild(options) {
     const { cwd, parentRunId } = options;
@@ -426,7 +484,41 @@ export async function stageRecoveryChild(options) {
     const parentRunDir = getDagRunDir(cwd, "active", parentRunId);
     const parentState = await deps.readParentState(parentRunDir);
     const parentSpec = await readDagRunSpec(parentRunDir);
-    const recovery = parentState.frontendRecoveryState;
+    let recovery = parentState.frontendRecoveryState;
+    if (options.recoveryIntent) {
+        const intent = options.recoveryIntent;
+        if (intent.parentRunId !== parentRunId ||
+            intent.requestId.length === 0 ||
+            intent.phase !== "child-staging" ||
+            intent.childRunId !== undefined ||
+            intent.revision !== 0) {
+            throw new Error("frontend recovery intent binding mismatch");
+        }
+        if (recovery?.requestId === intent.requestId) {
+            if (recovery.parentRunId !== intent.parentRunId ||
+                recovery.recoveryRootRunId !== intent.recoveryRootRunId ||
+                recovery.attemptIndex !== intent.attemptIndex ||
+                recovery.continuationCount !== intent.continuationCount ||
+                recovery.failureSource !== intent.failureSource) {
+                throw new Error("frontend recovery intent replay binding mismatch");
+            }
+        }
+        else {
+            const previousAttemptIndex = recovery?.attemptIndex ?? 0;
+            const previousContinuationCount = recovery?.continuationCount ?? 0;
+            const expectedRoot = recovery?.recoveryRootRunId ?? parentRunId;
+            if (intent.recoveryRootRunId !== expectedRoot ||
+                intent.attemptIndex !== previousAttemptIndex ||
+                intent.continuationCount !== previousContinuationCount) {
+                throw new Error("frontend recovery intent lineage mismatch");
+            }
+            recovery = structuredClone(intent);
+            await deps.writeParentState(parentRunDir, {
+                ...parentState,
+                frontendRecoveryState: recovery,
+            });
+        }
+    }
     if (!recovery) {
         throw new Error(`parent run ${parentRunId} has no frontend recovery intent`);
     }
@@ -434,17 +526,49 @@ export async function stageRecoveryChild(options) {
     if (!requestId) {
         throw new Error(`parent run ${parentRunId} recovery intent has no requestId`);
     }
+    if (options.recoveryPlan) {
+        if (options.recoveryPlan.parentRunId !== parentRunId ||
+            options.recoveryPlan.requestId !== requestId ||
+            options.recoveryPlan.failureSource !== recovery.failureSource) {
+            throw new Error("frontend recovery plan binding mismatch");
+        }
+        const expectedPlan = computeFrontendRecoveryPlanForSource({
+            spec: parentSpec,
+            parentRunId,
+            requestId,
+            failureSource: recovery.failureSource,
+        });
+        if (JSON.stringify(expectedPlan.resetNodeIds) !==
+            JSON.stringify(options.recoveryPlan.resetNodeIds) ||
+            JSON.stringify(expectedPlan.importedNodeIds) !==
+                JSON.stringify(options.recoveryPlan.importedNodeIds)) {
+            throw new Error("frontend recovery plan drifted from parent DAG");
+        }
+    }
     // Idempotent short-circuit (D4.2): reserved childRunId + activated marker +
     // existing child dir means the request was already fully committed.
     if (recovery.childRunId) {
         const existingMarker = await readFrontendRecoveryMarker(parentRunDir, requestId);
         if (existingMarker) {
-            const existingChildDir = getDagRunDir(cwd, "active", existingMarker.childRunId);
-            if (await dagRunDirExists(existingChildDir)) {
+            const existingChild = await locateDagRun(cwd, existingMarker.childRunId);
+            if (existingChild &&
+                (existingChild.lifecycle === "active" ||
+                    existingChild.lifecycle === "paused" ||
+                    existingChild.lifecycle === "completed")) {
+                await verifyThreeWayConsistency({
+                    parentRunDir,
+                    activeChildDir: existingChild.runDir,
+                    marker: existingMarker,
+                    parentRunId,
+                    requestId,
+                    recoveryRootRunId: recovery.recoveryRootRunId,
+                    childRunId: existingMarker.childRunId,
+                    deps,
+                });
                 return {
                     ok: true,
                     childRunId: existingMarker.childRunId,
-                    childRunDir: existingChildDir,
+                    childRunDir: existingChild.runDir,
                     marker: existingMarker,
                     idempotentReplay: true,
                 };
@@ -452,8 +576,15 @@ export async function stageRecoveryChild(options) {
         }
     }
     // Derive the childRunId exactly once; replay always reuses a reserved id.
-    const childRunId = recovery.childRunId ??
-        (await (options.buildChildRunId ?? buildDagRunId)(parentSpec, cwd));
+    // buildDagRunId is deterministic for the same task title on the same day. A
+    // recovery child must never reuse its still-active parent directory, or the
+    // staging path aliases the parent and the required import manifest is absent.
+    const childRunId = recovery.childRunId ?? await (async () => {
+        const generatedChildRunId = await (options.buildChildRunId ?? buildDagRunId)(parentSpec, cwd);
+        return generatedChildRunId === parentRunId
+            ? `${generatedChildRunId}-recovery-${requestId.slice(0, 8)}`
+            : generatedChildRunId;
+    })();
     // Orphan staging cleanup (D4.3): remove any in-flight staging dir for this id.
     const activeRootDir = getDagRunDir(cwd, "active", "");
     const stagingDir = path.join(activeRootDir, `${FRONTEND_RECOVERY_STAGING_PREFIX}${childRunId}`);
@@ -487,6 +618,7 @@ export async function stageRecoveryChild(options) {
             parentSpec,
             parentState,
             recovery,
+            recoveryPlan: options.recoveryPlan,
             requestId,
             childRunId,
             stagingDir,