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

package/dist/workflows/dag/rerun-task.js

@@ -1,14 +1,19 @@
 import { access, readFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
 import path from "node:path";
 import { generateTaskDagUseCase } from "../../application/dag/generate-task-dag.js";
+import { buildDefaultFrontendRecoveryDeps, } from "../../application/dag/run-dag.js";
+import { runDagContinuation, } from "./runner.js";
+import { stageRecoveryChild } from "./frontend-recovery-run.js";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { DAG_RUNS_DIR, isTerminalDagRunStatus, locateDagRun, readDagRunSpec, readDagRunState, } from "./lifecycle.js";
 import { deriveDagRerunFeedback } from "./rerun-feedback.js";
+import { acquireDagRecoveryLease, bindDagRecoveryLeaseExecution, } from "./recovery-lease.js";
 import { parseDagSpec, } from "./types.js";
 export const RERUN_TASK_LINEAGE_REL_PATH = ".runtime/rerun-task-lineage.json";
 export function parseDagRerunTaskArgs(args) {
     if (args.length === 0) {
-        throw new Error("usage: dag rerun-task --run-id <id> --reason <text> --request-id <key> [--profile auto|minimal|standard|reviewed|supervised] [--task-id <id>] [--json]");
+        throw new Error("usage: dag rerun-task --run-id <id> --reason <text> --request-id <key> [--profile auto|minimal|standard|reviewed|supervised] [--task-id <id>] [--frontend-recovery --recovery-operation-id <id>] [--json]");
     }
     let parentRunId;
     let reason;
@@ -17,6 +22,8 @@ export function parseDagRerunTaskArgs(args) {
     let profileExplicit = false;
     let taskIdOverride;
     let execute = true;
+    let frontendRecovery = false;
+    let recoveryOperationId;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--run-id")
@@ -47,6 +54,12 @@ export function parseDagRerunTaskArgs(args) {
             continue;
         else if (arg === "--no-execute")
             execute = false;
+        else if (arg === "--frontend-recovery")
+            frontendRecovery = true;
+        else if (arg === "--recovery-operation-id")
+            recoveryOperationId = args[++index];
+        else if (arg.startsWith("--recovery-operation-id="))
+            recoveryOperationId = arg.slice("--recovery-operation-id=".length);
         else if (arg.startsWith("-"))
             throw new Error(`unknown dag rerun-task flag: ${arg}`);
         else
@@ -69,6 +82,48 @@ export function parseDagRerunTaskArgs(args) {
         profileExplicit,
         ...(taskIdOverride?.trim() ? { taskIdOverride: taskIdOverride.trim() } : {}),
         execute,
+        frontendRecovery,
+        ...(recoveryOperationId ? { recoveryOperationId } : {}),
+    };
+}
+const frontendRecoveryDescriptorPath = (runDir, requestId) => path.join(runDir, ".runtime", "frontend-recovery", `${requestId}.json`);
+async function readFrontendRecoveryDescriptor(runDir, parentRunId, requestId) {
+    const raw = JSON.parse(await readFile(frontendRecoveryDescriptorPath(runDir, requestId), "utf8"));
+    const plan = raw.plan;
+    if (raw.schemaVersion !== 1 ||
+        raw.parentRunId !== parentRunId ||
+        raw.requestId !== requestId ||
+        typeof raw.failureSource !== "string" ||
+        typeof raw.recoveryMode !== "string" ||
+        typeof raw.planHash !== "string" ||
+        !plan ||
+        plan.schemaVersion !== 1 ||
+        plan.parentRunId !== parentRunId ||
+        plan.requestId !== requestId ||
+        !Array.isArray(plan.resetNodeIds) ||
+        !Array.isArray(plan.importedNodeIds)) {
+        throw new Error("frontend recovery descriptor is invalid or unbound");
+    }
+    const expectedHash = createHash("sha256")
+        .update(JSON.stringify(plan))
+        .digest("hex");
+    if (raw.planHash !== expectedHash) {
+        throw new Error("frontend recovery descriptor plan hash mismatch");
+    }
+    return raw;
+}
+function buildFrontendRecoveryIntent(input) {
+    return {
+        schemaVersion: 1,
+        phase: "child-staging",
+        requestId: input.requestId,
+        recoveryRootRunId: input.parentRecovery?.recoveryRootRunId ?? input.parentRunId,
+        parentRunId: input.parentRunId,
+        attemptId: input.requestId,
+        attemptIndex: input.parentRecovery?.attemptIndex ?? 0,
+        continuationCount: input.parentRecovery?.continuationCount ?? 0,
+        failureSource: input.failureSource,
+        revision: 0,
     };
 }
 function parseDagRerunTaskProfile(value) {
@@ -135,6 +190,21 @@ function resolveTaskIdForRerun(spec, taskIdOverride) {
 function operatorRequestPath(cwd, requestId) {
     return path.join(cwd, DAG_RUNS_DIR, ".operator-requests", `${requestId}.json`);
 }
+function computeRerunTaskRequestHash(input) {
+    return createHash("sha256")
+        .update(JSON.stringify({
+        parentRunId: input.parentRunId,
+        reason: input.reason,
+        requestId: input.requestId,
+        profile: input.profile ?? "auto",
+        profileExplicit: input.profileExplicit ?? false,
+        taskIdOverride: input.taskIdOverride ?? null,
+        execute: input.execute ?? true,
+        frontendRecovery: input.frontendRecovery ?? false,
+        recoveryOperationId: input.recoveryOperationId ?? null,
+    }))
+        .digest("hex");
+}
 async function fileExists(filePath) {
     try {
         await access(filePath);
@@ -184,23 +254,45 @@ export async function assessGeneratedOutputConflict(spec, cwd) {
     }
     return conflictPaths;
 }
-async function readExistingOperatorRequest(cwd, requestId) {
+async function readExistingOperatorRequest(cwd, requestId, expected) {
+    let raw;
     try {
-        const raw = JSON.parse(await readFile(operatorRequestPath(cwd, requestId), "utf-8"));
-        if (raw.result && typeof raw.result === "object") {
-            return { ...raw.result, idempotentReplay: true };
+        raw = JSON.parse(await readFile(operatorRequestPath(cwd, requestId), "utf-8"));
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return undefined;
         }
+        throw new Error(`invalid persisted rerun-task operator request: ${error instanceof Error ? error.message : String(error)}`);
     }
-    catch {
-        // not found or unreadable
+    if (raw.schemaVersion !== 1 ||
+        raw.kind !== "standalone-task-rerun-request" ||
+        raw.requestId !== requestId) {
+        throw new Error("REQUEST_ID_REUSE_CONFLICT: operator request id belongs to a different request kind");
+    }
+    if (raw.parentRunId !== expected.parentRunId ||
+        raw.requestHash !== expected.requestHash) {
+        throw new Error("REQUEST_ID_REUSE_CONFLICT: rerun-task operator request payload drifted");
     }
-    return undefined;
+    const result = raw.result;
+    if (!result ||
+        typeof result !== "object" ||
+        Array.isArray(result) ||
+        result.parentRunId !== expected.parentRunId ||
+        result.requestId !== requestId) {
+        throw new Error("invalid persisted rerun-task operator request result");
+    }
+    return { ...result, idempotentReplay: true };
 }
-async function persistOperatorRequest(cwd, result) {
+async function persistOperatorRequest(cwd, result, requestHash) {
     await writeJsonAtomic(operatorRequestPath(cwd, result.requestId), {
         schemaVersion: 1,
         kind: "standalone-task-rerun-request",
         parentRunId: result.parentRunId,
+        requestHash,
         newRunId: result.newRunId,
         taskId: result.taskId,
         reason: result.reason,
@@ -263,8 +355,106 @@ function extractNewRunId(generateResult) {
     const runSummary = extractRunSummary(generateResult);
     return runSummary?.runId;
 }
+async function executeFrontendRecoveryContinuation(input) {
+    const located = await locateDagRun(input.cwd, input.parentRunId);
+    if (!located || located.lifecycle !== "active") {
+        throw new Error(`frontend recovery parent run must remain active: ${input.parentRunId}`);
+    }
+    const lease = await acquireDagRecoveryLease({
+        cwd: input.cwd,
+        parentRunId: input.parentRunId,
+        requestId: input.requestId,
+        kind: "standalone-task-rerun",
+    });
+    if (lease.kind !== "held" ||
+        lease.lease.kind !== "auto-frontend-recovery" ||
+        lease.lease.requestId !== input.requestId ||
+        !input.recoveryOperationId ||
+        lease.lease.executionRef !== input.recoveryOperationId) {
+        return blockedResult({
+            parentRunId: input.parentRunId,
+            reason: input.reason,
+            requestId: input.requestId,
+            blockedReason: "recovery-lease-held",
+            note: "frontend recovery operation is not the owner of the parent recovery lease",
+        });
+    }
+    const descriptor = await readFrontendRecoveryDescriptor(located.runDir, input.parentRunId, input.requestId);
+    const parentState = await readDagRunState(located.runDir);
+    const staged = await stageRecoveryChild({
+        cwd: input.cwd,
+        parentRunId: input.parentRunId,
+        recoveryIntent: buildFrontendRecoveryIntent({
+            parentRunId: input.parentRunId,
+            requestId: input.requestId,
+            failureSource: descriptor.failureSource,
+            parentRecovery: parentState.frontendRecoveryState,
+        }),
+        recoveryPlan: descriptor.plan,
+    });
+    const locatedChild = await locateDagRun(input.cwd, staged.childRunId);
+    if (!locatedChild || locatedChild.runDir !== staged.childRunDir) {
+        throw new Error(`frontend recovery child lifecycle drift: ${staged.childRunId}`);
+    }
+    const childSpec = await readDagRunSpec(locatedChild.runDir);
+    const childState = await readDagRunState(locatedChild.runDir);
+    let runSummary;
+    if (locatedChild.lifecycle === "completed" ||
+        locatedChild.lifecycle === "paused") {
+        runSummary = {
+            title: childState.title,
+            runId: childState.runId,
+            status: childState.status,
+            ranks: childState.ranks,
+            nodes: childState.nodes,
+            runDir: locatedChild.runDir,
+        };
+    }
+    else {
+        const childRecovery = childSpec.tasks.some((task) => task.id === "frontend-implement-pi")
+            ? input.recovery ?? await buildDefaultFrontendRecoveryDeps(input.cwd)
+            : undefined;
+        runSummary = await runDagContinuation({
+            cwd: input.cwd,
+            spec: childSpec,
+            state: childState,
+            runDir: locatedChild.runDir,
+            ...(childRecovery ? { recovery: childRecovery } : {}),
+        });
+    }
+    const settledChild = await locateDagRun(input.cwd, staged.childRunId);
+    const settledChildState = settledChild
+        ? await readDagRunState(settledChild.runDir)
+        : childState;
+    const feedback = summarizeFeedback(childSpec.rerunFeedback, "no-unresolved-verify-review-feedback");
+    const result = {
+        ok: runSummary.status === "finished" ||
+            settledChildState.frontendRecoveryResult?.outcome === "recovered",
+        parentRunId: input.parentRunId,
+        newRunId: staged.childRunId,
+        taskId: childSpec.taskContractBinding?.taskId ??
+            childSpec.sourceBinding?.taskId,
+        reason: input.reason,
+        requestId: input.requestId,
+        mode: "generate+validate+execute",
+        feedback,
+        runSummary,
+    };
+    await writeRerunTaskLineage(input.cwd, staged.childRunId, {
+        parentRunId: input.parentRunId,
+        reason: input.reason,
+        requestId: input.requestId,
+        feedback,
+    });
+    await persistOperatorRequest(input.cwd, result, input.requestHash);
+    return result;
+}
 export async function rerunStandaloneTask(input) {
-    const existing = await readExistingOperatorRequest(input.cwd, input.requestId);
+    const requestHash = computeRerunTaskRequestHash(input);
+    const existing = await readExistingOperatorRequest(input.cwd, input.requestId, {
+        parentRunId: input.parentRunId,
+        requestHash,
+    });
     if (existing) {
         return existing;
     }
@@ -297,6 +487,17 @@ export async function rerunStandaloneTask(input) {
             note: eligibility.note,
         });
     }
+    if (input.frontendRecovery) {
+        return executeFrontendRecoveryContinuation({
+            cwd: input.cwd,
+            parentRunId: input.parentRunId,
+            reason: input.reason,
+            requestId: input.requestId,
+            requestHash,
+            recoveryOperationId: input.recoveryOperationId,
+            recovery: input.recovery,
+        });
+    }
     let parentFeedback;
     let missingFeedbackReason = "no-unresolved-verify-review-feedback";
     try {
@@ -308,12 +509,18 @@ export async function rerunStandaloneTask(input) {
             state,
         });
     }
-    catch {
+    catch (error) {
+        if (state.terminalReason === "design-request-changes") {
+            throw new Error(`frontend design recovery feedback unavailable: ${error instanceof Error ? error.message : String(error)}`);
+        }
         // Feedback is additive recovery context. A corrupt/missing historical
         // artifact must be reported honestly but must not block an otherwise
         // eligible full rerun.
         missingFeedbackReason = "feedback-unavailable";
     }
+    if (state.terminalReason === "design-request-changes" && !parentFeedback) {
+        throw new Error("frontend design recovery feedback unavailable: no typed findings were found");
+    }
     const execute = input.execute ?? true;
     let effectiveFeedback;
     let expectedRerunFeedbackDigest;
@@ -369,6 +576,34 @@ export async function rerunStandaloneTask(input) {
             }
         }
     }
+    const recoveryLease = execute
+        ? await acquireDagRecoveryLease({
+            cwd: input.cwd,
+            parentRunId: input.parentRunId,
+            requestId: input.requestId,
+            kind: "standalone-task-rerun",
+        })
+        : undefined;
+    if (recoveryLease?.kind === "held") {
+        return blockedResult({
+            parentRunId: input.parentRunId,
+            reason: input.reason,
+            requestId: input.requestId,
+            blockedReason: "recovery-lease-held",
+            note: `parent run recovery is already claimed by ${recoveryLease.lease.kind} request ${recoveryLease.lease.requestId}`,
+            taskId: taskResolution.taskId,
+        });
+    }
+    if (recoveryLease?.kind === "acquired") {
+        // Persist a non-empty execution identity before generateTaskDagUseCase can
+        // execute its new DAG. The generated run id is not available yet, so the
+        // request id is the stable lineage handle for this entry point.
+        await bindDagRecoveryLeaseExecution({
+            leasePath: recoveryLease.leasePath,
+            lease: recoveryLease.lease,
+            executionRef: `standalone-task-rerun:${input.requestId}`,
+        });
+    }
     const generateResult = await generateTaskDagUseCase({
         repoRoot: input.cwd,
         taskId: taskResolution.taskId,
@@ -420,10 +655,13 @@ export async function rerunStandaloneTask(input) {
         ...(runSummary ? { runSummary } : {}),
     };
     if (await fileExists(operatorRequestPath(input.cwd, input.requestId))) {
-        const replay = await readExistingOperatorRequest(input.cwd, input.requestId);
+        const replay = await readExistingOperatorRequest(input.cwd, input.requestId, {
+            parentRunId: input.parentRunId,
+            requestHash,
+        });
         if (replay)
             return replay;
     }
-    await persistOperatorRequest(input.cwd, result);
+    await persistOperatorRequest(input.cwd, result, requestHash);
     return result;
 }