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

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

@@ -415,12 +415,16 @@ function isCanonicalGeneratedVerifyShell(task) {
         return false;
     if (shell.projectGovernanceGate)
         return false;
-    if (shell.frontendPrewriteGate)
+    if (shell.frontendDesignPolicy)
+        return false;
+    if (shell.frontendWriterAdmission)
         return false;
     if (shell.frontendVerificationBundle)
         return false;
     if (shell.frontendReviewContext)
         return false;
+    if (shell.frontendCloseout)
+        return false;
     if (shell.backendTestPipeline)
         return false;
     if (shell.nonZeroExitPolicy === "record")
@@ -444,15 +448,18 @@ function isCanonicalFrontendArtifactContinuationShell(task) {
     switch (task.id) {
         case "frontend-prewrite-gate-shell":
             return Boolean(shell.frontendPrewriteGate) && (shell.commands?.length ?? 0) === 0;
-        case "frontend-lint-baseline-shell":
-            return Boolean(shell.frontendLintBaseline &&
-                shell.commands?.length === shell.frontendLintBaseline.lintCommands.length &&
-                shell.commands.every((command, index) => command === shell.frontendLintBaseline.lintCommands[index]));
+        case "frontend-design-policy-shell":
+            return Boolean(shell.frontendDesignPolicy) && (shell.commands?.length ?? 0) === 0;
+        case "frontend-writer-admission-shell":
+            return Boolean(shell.frontendWriterAdmission) && (shell.commands?.length ?? 0) === 0;
         case "frontend-verify-assess-shell":
         case "frontend-reverify-shell":
+        case "frontend-verify-shell":
             return Boolean(shell.frontendVerificationBundle) && (shell.commands?.length ?? 0) === 0;
         case "frontend-review-context-shell":
             return Boolean(shell.frontendReviewContext) && (shell.commands?.length ?? 0) === 0;
+        case "frontend-closeout-shell":
+            return Boolean(shell.frontendCloseout) && (shell.commands?.length ?? 0) === 0;
         default:
             return false;
     }
@@ -474,12 +481,16 @@ function isSafeGateOnlyShell(task) {
         return false;
     if (shell.preset)
         return false;
-    if (shell.frontendPrewriteGate)
+    if (shell.frontendDesignPolicy)
+        return false;
+    if (shell.frontendWriterAdmission)
         return false;
     if (shell.frontendVerificationBundle)
         return false;
     if (shell.frontendReviewContext)
         return false;
+    if (shell.frontendCloseout)
+        return false;
     if (shell.backendTestPipeline)
         return false;
     if (shell.verifyEvidence)

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

@@ -13,6 +13,7 @@ import { prepareActiveRunDir, writeNodeRecord, writeRunSpec, writeRunState, } fr
 import { cloneParentSkillSnapshotForContinuation, readSkillSnapshot, } from "./skill-snapshot.js";
 import { topoSortToRanks } from "./topo.js";
 import { captureWorkspaceCheckpoint, readWorkspaceCheckpoint, WORKSPACE_CHECKPOINT_START_REL, WORKSPACE_CHECKPOINT_TERMINAL_REL, writeWorkspaceCheckpoint, } from "./workspace-checkpoint.js";
+import { acquireDagRecoveryLease, bindDagRecoveryLeaseExecution, } from "./recovery-lease.js";
 import { captureWriterBaseline, readJournalFile, recordWriterAttemptFromCurrent, restoreJournal, writeJournalFile, } from "./frontend-writer-rollback.js";
 export const RERUN_PLAN_REL_PATH = ".runtime/rerun-plan.json";
 export const IMPORT_MANIFEST_REL_PATH = ".runtime/import-manifest.json";
@@ -87,11 +88,18 @@ const operatorRequestEnvelopeSchema = z
 })
     .strict();
 async function readExistingOperatorRequest(cwd, requestId) {
+    const requestPath = operatorRequestPath(cwd, requestId);
     try {
-        const raw = JSON.parse(await readFile(operatorRequestPath(cwd, requestId), "utf-8"));
+        const raw = JSON.parse(await readFile(requestPath, "utf-8"));
         const parsed = operatorRequestEnvelopeSchema.safeParse(raw);
-        if (!parsed.success)
-            return undefined;
+        if (!parsed.success) {
+            throw new Error("REQUEST_ID_REUSE_CONFLICT: persisted operator request envelope is invalid or belongs to a different request kind");
+        }
+        if (parsed.data.requestId !== requestId ||
+            parsed.data.parentRunId !== parsed.data.result.plan.parentRunId ||
+            parsed.data.newRunId !== parsed.data.result.newRunId) {
+            throw new Error("REQUEST_ID_REUSE_CONFLICT: persisted operator request envelope binding mismatch");
+        }
         const result = parsed.data.result;
         return {
             ...result,
@@ -99,10 +107,18 @@ async function readExistingOperatorRequest(cwd, requestId) {
             idempotentReplay: true,
         };
     }
-    catch {
-        // not found or unreadable
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return undefined;
+        }
+        if (error instanceof Error && error.message.startsWith("REQUEST_ID_REUSE_CONFLICT:")) {
+            throw error;
+        }
+        throw new Error(`REQUEST_ID_REUSE_CONFLICT: invalid persisted operator request envelope: ${error instanceof Error ? error.message : String(error)}`);
     }
-    return undefined;
 }
 /**
  * Idempotent replay of a previously persisted operator request, if any.
@@ -970,6 +986,20 @@ export async function executeDagRerun(input) {
     }
     const parentSpec = await readDagRunSpec(located.runDir);
     const parentState = await readDagRunState(located.runDir);
+    const recoveryLease = await acquireDagRecoveryLease({
+        cwd: input.cwd,
+        parentRunId: input.parentRunId,
+        requestId: input.requestId,
+        kind: "rerun-from-node",
+    });
+    if (recoveryLease.kind === "held") {
+        return {
+            ok: false,
+            plan,
+            errorCode: "RECOVERY_LEASE_HELD",
+            message: `parent run recovery is already claimed by ${recoveryLease.lease.kind} request ${recoveryLease.lease.requestId}`,
+        };
+    }
     const staged = await stageContinuationRun({
         cwd: input.cwd,
         parentRunDir: located.runDir,
@@ -981,6 +1011,14 @@ export async function executeDagRerun(input) {
         requestId: input.requestId,
         promptOverrides: input.promptOverrides,
     });
+    // Stage is non-executing; bind the child identity immediately before handing
+    // it to the runner so no recovery DAG can start without durable parent
+    // lineage ownership.
+    await bindDagRecoveryLeaseExecution({
+        leasePath: recoveryLease.leasePath,
+        lease: recoveryLease.lease,
+        executionRef: staged.state.runId,
+    });
     const continuationOptions = {
         cwd: input.cwd,
         spec: staged.spec,

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;
 }