@tea-agent/loop-agent 0.42.0-next.9 → 0.43.0-next.1

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

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { z } from "zod";
 import { assertTaskContractBindingFresh } from "./task-contract-binding.js";
+import { workspaceDriftedPaths, } from "./workspace-checkpoint.js";
 import { isSafeReadOnlyPiRetryCandidate, isTransportCrashedExclusiveWriter } from "./retry-policy.js";
 import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
 import { composeDagPromptOverridePrompt, MAX_DAG_RERUN_PROMPT_OVERRIDE_CHARS, } from "../../shared/dag-prompt-override.js";
@@ -1110,6 +1111,46 @@ function deriveSuggestedAction(input) {
     }
     return "manual";
 }
+/**
+ * Gitignore-style-lite matcher for readSet/writeSet path patterns in scoped
+ * workspace-drift evaluation: literal paths match exactly; `**` spans path
+ * segments (a trailing `/**` also matches when nothing follows), `*` stays
+ * within one segment, `?` is one non-separator char.
+ */
+function pathMatchesWorkspacePattern(pathValue, pattern) {
+    const normalizedPath = pathValue.replace(/\\/g, "/").replace(/^\.\//, "");
+    const trimmed = pattern.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+    if (!trimmed || trimmed === "/")
+        return false;
+    if (trimmed === normalizedPath)
+        return true;
+    let source = "";
+    for (let index = 0; index < trimmed.length; index += 1) {
+        const char = trimmed[index];
+        if (char === "*") {
+            if (trimmed[index + 1] === "*") {
+                if (trimmed[index + 2] === "/") {
+                    source += "(?:.*/)?";
+                    index += 2;
+                }
+                else {
+                    source += ".*";
+                    index += 1;
+                }
+            }
+            else {
+                source += "[^/]*";
+            }
+        }
+        else if (char === "?") {
+            source += "[^/]";
+        }
+        else {
+            source += char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        }
+    }
+    return new RegExp(`^${source}$`).test(normalizedPath);
+}
 function deriveRisk(reasonCodes, resetCount) {
     if (reasonCodes.includes("restart-subgraph-contains-writer") ||
         reasonCodes.includes("restart-subgraph-contains-unsafe-shell") ||
@@ -1213,7 +1254,14 @@ export async function evaluateDagRerunPlan(input) {
         blockedReasons.push("parent-lifecycle-ineligible");
     }
     else if (input.parentState.status !== "failed" &&
-        input.parentState.status !== "partial_failed") {
+        input.parentState.status !== "partial_failed" &&
+        // A superseded parent is a terminal operator judgment about the run as
+        // a whole, not about its deterministic read-only compute: its FINISHED
+        // upstream nodes are still valid fact donors for the imported set, and
+        // every unsafe case (writers in the reset subgraph, decision gates,
+        // stale checkpoints, unresolved ERROR nodes outside the closure) keeps
+        // its own dedicated block below.
+        input.parentState.status !== "superseded") {
         reasonCodes.push("parent-lifecycle-ineligible");
         blockedReasons.push("parent-lifecycle-ineligible");
     }
@@ -1241,8 +1289,36 @@ export async function evaluateDagRerunPlan(input) {
     else if (input.currentWorkspace?.fingerprint &&
         input.parentTerminalWorkspace.fingerprint !==
             input.currentWorkspace.fingerprint) {
-        reasonCodes.push("workspace-drift");
-        blockedReasons.push("workspace-drift");
+        // Whole-fingerprint drift is refined to content-level paths: the rerun
+        // re-derives (readSet) and rewrites (writeSet) the reset subgraph's own
+        // paths, so drift confined to those paths is recomputed by the rerun
+        // itself and must not force a full standalone rerun. Drift anywhere
+        // else — especially inputs of imported fact-reuse nodes — keeps the
+        // strict block. Indeterminate checkpoints fail closed.
+        const driftedPaths = workspaceDriftedPaths(input.parentTerminalWorkspace, input.currentWorkspace);
+        const importedReadPaths = importedNodeIds.flatMap((nodeId) => {
+            const task = tasksByIdForPlan.get(nodeId);
+            return task?.readSet ?? [];
+        });
+        const scopedDrift = driftedPaths !== undefined &&
+            driftedPaths.length > 0 &&
+            driftedPaths.every((driftPath) => !importedReadPaths.some((pattern) => pathMatchesWorkspacePattern(driftPath, pattern)) &&
+                resetNodeIds.some((nodeId) => {
+                    const task = tasksByIdForPlan.get(nodeId);
+                    if (!task)
+                        return false;
+                    return [
+                        ...(task.writeSet ?? []),
+                        ...(task.readSet ?? []),
+                    ].some((pattern) => pathMatchesWorkspacePattern(driftPath, pattern));
+                }));
+        if (scopedDrift) {
+            reasonCodes.push("workspace-drift-scoped");
+        }
+        else {
+            reasonCodes.push("workspace-drift");
+            blockedReasons.push("workspace-drift");
+        }
     }
     else if (!input.currentWorkspace?.fingerprint) {
         reasonCodes.push("workspace-checkpoint-missing");
@@ -1293,8 +1369,18 @@ export async function evaluateDagRerunPlan(input) {
     }
     for (const nodeId of importedNodeIds) {
         const record = input.parentState.nodes[nodeId];
-        if (!record)
+        if (!record) {
+            reasonCodes.push("parent-facts-invalid");
+            blockedReasons.push("parent-facts-invalid");
+            blockingNodes.push({ nodeId, reasonCode: "parent-facts-invalid" });
             continue;
+        }
+        if (record.status === "PENDING" || record.status === "RUNNING") {
+            reasonCodes.push("parent-facts-invalid");
+            blockedReasons.push("parent-facts-invalid");
+            blockingNodes.push({ nodeId, reasonCode: "parent-facts-invalid" });
+            continue;
+        }
         if (record.status === "ERROR") {
             reasonCodes.push("parent-facts-invalid");
             blockedReasons.push("parent-facts-invalid");

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

@@ -88,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,
@@ -100,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.
@@ -769,6 +784,13 @@ async function stageContinuationRun(input) {
         if (!parentRecord) {
             throw new Error(`parent node record missing for imported node: ${nodeId}`);
         }
+        if (parentRecord.status !== "FINISHED" &&
+            !(parentRecord.status === "SKIPPED" &&
+                (parentRecord.skippedReason?.includes("condition") ||
+                    parentRecord.skippedReason?.includes("runIf") ||
+                    parentRecord.skippedReason?.includes("run-if")))) {
+            throw new Error(`parent node is not a settled fact donor for imported node: ${nodeId}`);
+        }
         const { manifestNode, importedRecord } = await importNodeFacts({
             parentRunDir: input.parentRunDir,
             newRunDir: runDir,

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

@@ -1,6 +1,10 @@
 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";
@@ -9,7 +13,7 @@ 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;
@@ -18,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")
@@ -48,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
@@ -70,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) {
@@ -136,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);
@@ -185,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 };
-        }
-    }
-    catch {
-        // not found or unreadable
+        raw = JSON.parse(await readFile(operatorRequestPath(cwd, requestId), "utf-8"));
     }
-    return undefined;
+    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)}`);
+    }
+    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");
+    }
+    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,
@@ -264,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;
     }
@@ -298,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 {
@@ -318,6 +518,9 @@ export async function rerunStandaloneTask(input) {
         // 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;
@@ -381,10 +584,7 @@ export async function rerunStandaloneTask(input) {
             kind: "standalone-task-rerun",
         })
         : undefined;
-    const nestedAutoRecoveryLease = recoveryLease?.kind === "held" &&
-        recoveryLease.lease.kind === "auto-frontend-recovery" &&
-        recoveryLease.lease.requestId === input.requestId;
-    if (recoveryLease?.kind === "held" && !nestedAutoRecoveryLease) {
+    if (recoveryLease?.kind === "held") {
         return blockedResult({
             parentRunId: input.parentRunId,
             reason: input.reason,
@@ -455,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;
 }

package/dist/workflows/dag/retry-policy.js

@@ -7,8 +7,8 @@ import { TYPED_EVENT_FACT_KINDS } from "./frontend-typed-event-store.js";
  * is re-exported here unchanged so retry-policy stays the single import
  * surface for retry policies and helpers.
  */
-export { ALL_DAG_RETRY_CATEGORIES, CONTEXT_OVERFLOW_RETRY_CATEGORY, DEFAULT_DAG_RETRY_CATEGORIES, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, PROTOCOL_AWARE_DAG_RETRY_CATEGORIES, PROTOCOL_INVALID_RETRY_CATEGORY, READ_BURST_RETRY_CATEGORY, REVIEW_TERMINAL_MISSING_RETRY_CATEGORY, STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY, STRUCTURED_OUTPUT_RETRY_CATEGORY, STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY, STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES, TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE, WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, dagRetryBackoffSchema, dagRetryCategorySchema, dagRetryPolicySchema, } from "./dag-retry-schema.js";
-import { CONTEXT_OVERFLOW_RETRY_CATEGORY, DEFAULT_DAG_RETRY_CATEGORIES, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, PROTOCOL_AWARE_DAG_RETRY_CATEGORIES, READ_BURST_RETRY_CATEGORY, REVIEW_TERMINAL_MISSING_RETRY_CATEGORY, STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY, STRUCTURED_OUTPUT_RETRY_CATEGORY, STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES, TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE, WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "./dag-retry-schema.js";
+export { ALL_DAG_RETRY_CATEGORIES, CONTEXT_OVERFLOW_RETRY_CATEGORY, DEFAULT_DAG_RETRY_CATEGORIES, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, OUTPUT_LIMIT_RETRY_CATEGORY, PROTOCOL_AWARE_DAG_RETRY_CATEGORIES, PROTOCOL_INVALID_RETRY_CATEGORY, READ_BURST_RETRY_CATEGORY, REVIEW_TERMINAL_MISSING_RETRY_CATEGORY, STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY, STRUCTURED_OUTPUT_RETRY_CATEGORY, STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY, STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES, TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE, WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, dagRetryBackoffSchema, dagRetryCategorySchema, dagRetryPolicySchema, } from "./dag-retry-schema.js";
+import { CONTEXT_OVERFLOW_RETRY_CATEGORY, DEFAULT_DAG_RETRY_CATEGORIES, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, OUTPUT_LIMIT_RETRY_CATEGORY, PROTOCOL_AWARE_DAG_RETRY_CATEGORIES, READ_BURST_RETRY_CATEGORY, REVIEW_TERMINAL_MISSING_RETRY_CATEGORY, STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY, STRUCTURED_OUTPUT_RETRY_CATEGORY, STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES, TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE, WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "./dag-retry-schema.js";
 const RETRY_SAFE_PI_ROLES = new Set([
     "planner",
     "scout",
@@ -19,7 +19,7 @@ const RETRY_SAFE_PI_ROLES = new Set([
 ]);
 /**
  * The default retry policy applied to safe generated read-only Pi nodes.
- * Total attempts: 3, exponential backoff with cap.
+ * Total attempts: 5, exponential backoff with cap.
  *
  * Includes `context-overflow`: a read-only node that blew the context window
  * (400 request too large, e.g. a review node accumulating too many reads) is a
@@ -29,7 +29,7 @@ const RETRY_SAFE_PI_ROLES = new Set([
  * design-review/review fell straight to ERROR without a retry attempt.
  */
 export const DEFAULT_READ_ONLY_PI_RETRY_POLICY = {
-    maxAttempts: 3,
+    maxAttempts: 5,
     backoff: "exponential",
     initialDelayMs: 2000,
     maxDelayMs: 30000,
@@ -80,6 +80,17 @@ export const PLANNER_OUTPUT_LIMIT_RETRY_POLICY = {
         CONTEXT_OVERFLOW_RETRY_CATEGORY,
     ],
 };
+/** Backend-test N2 emits a mandatory run-owned Markdown protocol, so both
+ * provider length truncation and deterministic protocol validation failures
+ * are safe producer-local retries. */
+export const BACKEND_TEST_MD_PLAN_RETRY_POLICY = {
+    ...STRUCTURED_REQUIRED_PI_RETRY_POLICY,
+    retryCategories: [
+        ...STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES,
+        READ_BURST_RETRY_CATEGORY,
+        CONTEXT_OVERFLOW_RETRY_CATEGORY,
+    ],
+};
 /**
  * Default retry for reviewer / recovery nodes that declare outputProtocol.
  * Includes protocol-invalid so missing VERDICT lines are corrected in-node.
@@ -114,7 +125,10 @@ export const WRITER_EMPTY_DIFF_RETRY_POLICY = {
     backoff: "exponential",
     initialDelayMs: 2000,
     maxDelayMs: 30000,
-    retryCategories: [WRITER_EMPTY_DIFF_RETRY_CATEGORY],
+    retryCategories: [
+        WRITER_EMPTY_DIFF_RETRY_CATEGORY,
+        OUTPUT_LIMIT_RETRY_CATEGORY,
+    ],
 };
 /**
  * Bounded transport retry for standard exclusive implementers when a provider
@@ -129,6 +143,7 @@ export const WRITER_TRANSPORT_RETRY_POLICY = {
     retryCategories: [
         WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY,
         CONTEXT_OVERFLOW_RETRY_CATEGORY,
+        OUTPUT_LIMIT_RETRY_CATEGORY,
     ],
 };
 /**
@@ -164,6 +179,7 @@ export const TARGET_TEMPLATE_WRITER_TRANSPORT_RETRY_POLICY = {
     retryCategories: [
         WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY,
         CONTEXT_OVERFLOW_RETRY_CATEGORY,
+        OUTPUT_LIMIT_RETRY_CATEGORY,
     ],
 };
 /**
@@ -171,13 +187,14 @@ export const TARGET_TEMPLATE_WRITER_TRANSPORT_RETRY_POLICY = {
  * recovery attempts driven by Completeness Gate (missing/broken target files).
  */
 export const BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY = {
-    maxAttempts: 3,
+    maxAttempts: 5,
     backoff: "exponential",
     initialDelayMs: 2000,
     maxDelayMs: 30000,
     retryCategories: [
         WRITER_EMPTY_DIFF_RETRY_CATEGORY,
         INCOMPLETE_WRITE_SET_RETRY_CATEGORY,
+        OUTPUT_LIMIT_RETRY_CATEGORY,
     ],
 };
 /** Markdown shard writers use one full attempt plus at most one bounded binding repair. */
@@ -461,9 +478,9 @@ function reasonMandatedFrontendPlanRetryStep(reason) {
     }
 }
 /**
- * Opt-in retry policy mounted on the frontend-plan-pi node. maxAttempts=3
- * bounds plan retry cost: the four-rung ladder is only partially traversable
- * before the run fails non-converging (rungs: normal → bounded-tool-only →
+ * Opt-in retry policy mounted on the frontend-plan-pi node. maxAttempts=5
+ * lets the producer validate and repair each generated increment while still
+ * bounding the four-rung ladder (normal → bounded-tool-only →
  * compact-terminal-first → backup-model). `invalid-output` (typed-fact schema
  * violations, e.g. verification targets referencing undeclared UI states)
  * retries at the `normal` rung with the contractCheck reason injected via
@@ -474,7 +491,7 @@ export const FRONTEND_PLAN_LADDER_RETRY_POLICY = {
     // incremental record_* calls; dense call bursts hit provider rate limits
     // whose windows exceed the old 30s cap. Longer backoff gives the limit
     // window time to expire before the next attempt.
-    maxAttempts: 3,
+    maxAttempts: 5,
     backoff: "exponential",
     initialDelayMs: 5000,
     maxDelayMs: 60000,