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

package/dist/workflows/dag/prompt.js

@@ -46,9 +46,42 @@ function formatResolvedSkillInstructions(instructions) {
     if (!instructions || instructions.length === 0)
         return "(none)";
     return instructions
-        .map((instruction) => instruction.promptText)
+        .map((instruction) => formatSkillChecklist(instruction))
         .join("\n\n---\n\n");
 }
+/** Keep skill provenance, but turn bounded inline manuals into a small action list. */
+function formatSkillChecklist(instruction) {
+    const metadata = [
+        `Skill: ${instruction.name}`,
+        `Resolution: ${instruction.resolution}`,
+        ...(instruction.path ? [`Path: ${instruction.path}`] : []),
+        ...(instruction.sha256 ? [`Sha256: ${instruction.sha256}`] : []),
+        "Injection mode: checklist",
+    ];
+    if (instruction.resolution !== "resolved")
+        return [...metadata, instruction.promptText].join("\n");
+    const source = instruction.promptText.split("Instructions:\n")[1] ?? "";
+    const candidates = source
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /^(?:#{1,3}\s+|[-*]\s+|\d+[.)]\s+)/.test(line) || line.length > 0)
+        .map((line) => line.replace(/^#{1,3}\s+/, "").replace(/^[-*]\s+/, "").replace(/^\d+[.)]\s+/, ""))
+        .filter((line) => line.length > 0);
+    const checklist = [];
+    let chars = 0;
+    for (const item of candidates) {
+        const bounded = item.slice(0, 240);
+        if (checklist.length >= 10 || chars + bounded.length > 1_600)
+            break;
+        checklist.push(`- ${bounded}`);
+        chars += bounded.length;
+    }
+    return [
+        ...metadata,
+        "Checklist (apply these actions; consult the immutable resolved file only when a listed action requires detail):",
+        ...(checklist.length > 0 ? checklist : ["- Follow the resolved skill's declared workflow."]),
+    ].join("\n");
+}
 export function formatOutputLanguageBlock(language = DEFAULT_DAG_OUTPUT_LANGUAGE) {
     if (language === "en") {
         return [

package/dist/workflows/dag/recovery-lease.js

@@ -0,0 +1,80 @@
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { DAG_RUNS_DIR } from "./lifecycle.js";
+function recoveryLeasePath(cwd, parentRunId) {
+    // Never derive a filesystem name directly from an externally supplied legacy
+    // run id. The content remains auditable while the filename is traversal-safe.
+    const key = createHash("sha256").update(parentRunId).digest("hex");
+    return path.join(cwd, DAG_RUNS_DIR, ".recovery-leases", `${key}.json`);
+}
+function parseLease(raw, parentRunId) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("invalid dag recovery lease: expected object");
+    }
+    const record = raw;
+    if (record.schemaVersion !== 1 ||
+        record.parentRunId !== parentRunId ||
+        typeof record.requestId !== "string" ||
+        record.requestId.length === 0 ||
+        (record.kind !== "auto-frontend-recovery" &&
+            record.kind !== "rerun-from-node" &&
+            record.kind !== "standalone-task-rerun") ||
+        typeof record.leaseToken !== "string" ||
+        record.leaseToken.length === 0 ||
+        typeof record.acquiredAt !== "string" ||
+        typeof record.executionRef !== "undefined" &&
+            typeof record.executionRef !== "string") {
+        throw new Error("invalid dag recovery lease: schema mismatch");
+    }
+    return record;
+}
+export async function acquireDagRecoveryLease(input) {
+    const leasePath = recoveryLeasePath(input.cwd, input.parentRunId);
+    const lease = {
+        schemaVersion: 1,
+        parentRunId: input.parentRunId,
+        requestId: input.requestId,
+        kind: input.kind,
+        leaseToken: randomBytes(16).toString("hex"),
+        acquiredAt: (input.now ?? (() => new Date()))().toISOString(),
+    };
+    await mkdir(path.dirname(leasePath), { recursive: true });
+    try {
+        // `wx` is the cross-process compare-and-create primitive. The lease is
+        // deliberately immutable for a parent run: a later recovery must follow
+        // the committed child lineage rather than fork another DAG.
+        await writeFile(leasePath, `${JSON.stringify(lease, null, 2)}\n`, {
+            encoding: "utf8",
+            flag: "wx",
+        });
+        return { kind: "acquired", leasePath, lease };
+    }
+    catch (error) {
+        if (!(error && typeof error === "object" && "code" in error && error.code === "EEXIST")) {
+            throw error;
+        }
+        const existing = parseLease(JSON.parse(await readFile(leasePath, "utf8")), input.parentRunId);
+        return { kind: "held", leasePath, lease: existing };
+    }
+}
+/** Persist the operation/run identity before the caller is allowed to execute it. */
+export async function bindDagRecoveryLeaseExecution(input) {
+    if (!input.executionRef.trim()) {
+        throw new Error("dag recovery lease executionRef is required");
+    }
+    const existing = parseLease(JSON.parse(await readFile(input.leasePath, "utf8")), input.lease.parentRunId);
+    if (existing.leaseToken !== input.lease.leaseToken) {
+        throw new Error("dag recovery lease ownership drift");
+    }
+    if (existing.executionRef && existing.executionRef !== input.executionRef) {
+        throw new Error("dag recovery lease execution identity drift");
+    }
+    const bound = {
+        ...existing,
+        executionRef: input.executionRef,
+    };
+    await writeJsonAtomic(input.leasePath, bound);
+    return bound;
+}

package/dist/workflows/dag/report.js

@@ -125,6 +125,8 @@ const dagNodeArtifactsReportSchema = z
     humanEscalationMd: dagArtifactRefSchema,
     humanApproval: dagArtifactRefSchema,
     humanRejection: dagArtifactRefSchema,
+    changeManifest: dagArtifactRefSchema,
+    changeManifestChangedFiles: z.array(z.string()).optional(),
 })
     .strict();
 const dagNodeReportRowSchema = z
@@ -259,6 +261,20 @@ export async function probeArtifact(filePath) {
 export async function buildNodeArtifactsReport(runDir, nodeId) {
     const nodeDir = path.join(runDir, nodeId);
     const artifact = (name) => probeArtifact(path.join(nodeDir, name));
+    const changeManifestRef = await artifact("change-manifest.json");
+    let changeManifestChangedFiles;
+    if (changeManifestRef.exists) {
+        try {
+            const manifest = JSON.parse(await readFile(path.join(nodeDir, "change-manifest.json"), "utf-8"));
+            changeManifestChangedFiles = Array.isArray(manifest.changedFiles)
+                ? manifest.changedFiles
+                    .filter((item) => typeof item === "string")
+                : undefined;
+        }
+        catch {
+            // unreadable manifest → leave undefined
+        }
+    }
     return {
         resultSummary: await artifact("result.summary.md"),
         promptRedacted: await artifact("prompt.redacted.md"),
@@ -270,6 +286,8 @@ export async function buildNodeArtifactsReport(runDir, nodeId) {
         humanEscalationMd: await artifact("human-escalation.md"),
         humanApproval: await artifact("human-approval.json"),
         humanRejection: await artifact("human-rejection.json"),
+        changeManifest: changeManifestRef,
+        changeManifestChangedFiles,
     };
 }
 function taskById(spec) {
@@ -726,6 +744,12 @@ function formatArtifactFlags(artifacts) {
         flags.push("approval");
     if (artifacts.humanRejection.exists)
         flags.push("rejection");
+    if (artifacts.changeManifest.exists) {
+        const count = artifacts.changeManifestChangedFiles?.length;
+        flags.push(count !== undefined
+            ? `changed:${count}`
+            : "change-manifest");
+    }
     return flags.length > 0 ? flags.join(",") : "-";
 }
 function formatTimestamp(value) {
@@ -749,7 +773,19 @@ function summarizeNodeStatuses(nodes) {
     return `${total} total / ${finished} finished / ${failed} failed / ${skipped} skipped / ${pending} pending`;
 }
 function hasArtifact(artifacts) {
-    return Object.values(artifacts).some((artifact) => artifact.exists);
+    return [
+        artifacts.resultSummary,
+        artifacts.promptRedacted,
+        artifacts.skills,
+        artifacts.nodeRecord,
+        artifacts.decisionEnvelope,
+        artifacts.decisionEnvelopeValidation,
+        artifacts.humanEscalationJson,
+        artifacts.humanEscalationMd,
+        artifacts.humanApproval,
+        artifacts.humanRejection,
+        artifacts.changeManifest,
+    ].some((artifact) => artifact.exists);
 }
 function failureRows(run) {
     return run.nodes.filter((node) => node.status === "ERROR" ||

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

@@ -2,6 +2,8 @@ import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { parseJsonReviewVerdict } from "./output-protocol.js";
+import { FRONTEND_DESIGN_REVIEW_NODE_ID, FRONTEND_REVIEW_NODE_ID, readCommittedDesignRequestFact, readCommittedReviewRequestFact, } from "./frontend-review-findings.js";
+import { readTypedEventStoreFromJsonl } from "./frontend-typed-event-store.js";
 export const MAX_RERUN_FEEDBACK_CHARS = 12_000;
 const RERUN_FEEDBACK_TRUNCATION_MARKER = "\n\n...[上一轮反馈已按长度上限截断]...\n\n";
 const MAX_EVIDENCE_REFS = 8;
@@ -35,6 +37,44 @@ function requestRevision(text) {
         return (emphasized?.[1] ?? trimmed).trim() === "VERDICT: request-revision";
     });
 }
+/**
+ * Deterministically render a typed `request_review_changes` fact into feedback
+ * text. Unlike the legacy text channel (VERDICT: request-revision), the
+ * frontend review terminal is a committed typed fact; the findings are the
+ * actionable body the next round must consume.
+ */
+export function formatTypedReviewRequestFeedback(fact) {
+    const lines = [];
+    lines.push(`frontend review committed request_review_changes (issueCategory=${typeof fact.issueCategory === "string" ? fact.issueCategory : "unknown"})`);
+    if (Array.isArray(fact.findings) && fact.findings.length > 0) {
+        lines.push("review findings:");
+        for (const finding of fact.findings) {
+            if (!finding || typeof finding !== "object")
+                continue;
+            const record = finding;
+            const severity = typeof record.severity === "string" ? record.severity : "";
+            const issue = typeof record.issue === "string" ? record.issue : "";
+            const location = [
+                typeof record.file === "string" ? record.file : "",
+                typeof record.line === "number" ? String(record.line) : "",
+            ]
+                .filter(Boolean)
+                .join(":");
+            const prefix = location ? `[${location}] ` : "";
+            const requiredChange = typeof record.requiredChange === "string" &&
+                record.requiredChange.length > 0
+                ? ` (requiredChange: ${record.requiredChange})`
+                : "";
+            lines.push(`- ${prefix}${severity}: ${issue}${requiredChange}`);
+        }
+    }
+    if (Array.isArray(fact.evidenceRefs) && fact.evidenceRefs.length > 0) {
+        lines.push(`evidenceRefs: ${fact.evidenceRefs
+            .filter((ref) => typeof ref === "string")
+            .join(", ")}`);
+    }
+    return lines.join("\n");
+}
 function pathInside(root, candidate) {
     const relative = path.relative(root, candidate);
     return (relative === "" ||
@@ -127,6 +167,162 @@ function evidenceRefs(repoRoot, runDir, pass, sourceNodeId) {
     }
     return result;
 }
+/**
+ * Read the committed frontend review request fact (typed terminal channel).
+ * Returns { nodeId, fact } when the review node committed `request_review_changes`.
+ */
+async function readTypedReviewRequestFact(runDir) {
+    const fact = await readCommittedReviewRequestFact({ runDir });
+    if (!fact)
+        return undefined;
+    return {
+        nodeId: FRONTEND_REVIEW_NODE_ID,
+        fact: {
+            issueCategory: fact.issueCategory,
+            evidenceRefs: fact.evidenceRefs,
+            findings: fact.findings,
+        },
+    };
+}
+/**
+ * Read the committed frontend design request fact (typed terminal channel).
+ * Returns { nodeId, fact } when the design review node committed
+ * `request_design_changes` — the design analog of request_review_changes.
+ */
+async function readTypedDesignRequestFact(runDir) {
+    const fact = await readCommittedDesignRequestFact({ runDir });
+    if (!fact)
+        return undefined;
+    return {
+        nodeId: FRONTEND_DESIGN_REVIEW_NODE_ID,
+        fact: {
+            issueCategory: fact.issueCategory,
+            evidenceRefs: fact.evidenceRefs,
+            findings: fact.findings,
+        },
+    };
+}
+const RERUN_FEEDBACK_LINEAGE_MAX_DEPTH = 5;
+const RERUN_FEEDBACK_LINEAGE_LIFECYCLES = [
+    "active",
+    "paused",
+    "completed",
+];
+function safeLineageRunId(value) {
+    if (typeof value !== "string" || !value || value !== value.trim())
+        return undefined;
+    if (value === "." ||
+        value === ".." ||
+        value.includes("/") ||
+        value.includes("\\") ||
+        value.includes("\0"))
+        return undefined;
+    return value;
+}
+async function readCommittedTerminalKind(input) {
+    try {
+        const records = await readTypedEventStoreFromJsonl(path.join(input.runDir, input.nodeId, input.factsFile));
+        for (const record of records) {
+            if (record.phase !== "committed")
+                continue;
+            const kind = record.fact.kind;
+            if (typeof kind === "string" && input.kinds.includes(kind))
+                return kind;
+        }
+    }
+    catch {
+        // A missing/unreadable terminal store means this run did not establish a
+        // usable resolution barrier; lineage lookup may continue.
+    }
+    return undefined;
+}
+async function readReviewTerminalKind(runDir) {
+    return readCommittedTerminalKind({
+        runDir,
+        nodeId: FRONTEND_REVIEW_NODE_ID,
+        factsFile: "review-typed-facts.jsonl",
+        kinds: ["request_review_changes", "approve_review"],
+    });
+}
+async function readDesignTerminalKind(runDir) {
+    return readCommittedTerminalKind({
+        runDir,
+        nodeId: FRONTEND_DESIGN_REVIEW_NODE_ID,
+        factsFile: "design-typed-facts.jsonl",
+        kinds: ["request_design_changes", "approve_design"],
+    });
+}
+/**
+ * Walk the rerun-task lineage chain (`<runDir>/.runtime/rerun-task-lineage.json`
+ * → parentRunId) looking for the nearest ancestor run with a committed review
+ * or design request fact. A nearer final-review approval resolves all older
+ * findings; a nearer design approval resolves older design findings while
+ * still allowing an older final-review request to survive. Bounded depth;
+ * unsafe ids, mismatched state identities, cycles, and unreadable lineage
+ * files terminate the walk with undefined.
+ */
+async function readAncestorTypedRequestFact(runDir) {
+    let currentRunDir = runDir;
+    let currentRunId;
+    let designResolved = false;
+    const dagRunsRoot = path.resolve(runDir, "..", "..");
+    const visitedRunDirs = new Set([path.resolve(runDir)]);
+    for (let depth = 0; depth <= RERUN_FEEDBACK_LINEAGE_MAX_DEPTH; depth += 1) {
+        const reviewTerminalKind = await readReviewTerminalKind(currentRunDir);
+        if (currentRunId && reviewTerminalKind === "request_review_changes") {
+            const fact = await readTypedReviewRequestFact(currentRunDir);
+            if (fact)
+                return { ...fact, parentRunId: currentRunId };
+        }
+        if (reviewTerminalKind === "approve_review")
+            return undefined;
+        const designTerminalKind = await readDesignTerminalKind(currentRunDir);
+        if (currentRunId &&
+            !designResolved &&
+            designTerminalKind === "request_design_changes") {
+            const fact = await readTypedDesignRequestFact(currentRunDir);
+            if (fact)
+                return { ...fact, parentRunId: currentRunId };
+        }
+        if (designTerminalKind === "approve_design")
+            designResolved = true;
+        if (depth === RERUN_FEEDBACK_LINEAGE_MAX_DEPTH)
+            return undefined;
+        let parentRunId;
+        try {
+            const lineage = JSON.parse(await readFile(path.join(currentRunDir, ".runtime", "rerun-task-lineage.json"), "utf8"));
+            parentRunId = safeLineageRunId(lineage.parentRunId);
+        }
+        catch {
+            return undefined;
+        }
+        if (!parentRunId)
+            return undefined;
+        let ancestorRunDir;
+        for (const lifecycle of RERUN_FEEDBACK_LINEAGE_LIFECYCLES) {
+            const candidate = path.join(dagRunsRoot, lifecycle, parentRunId);
+            try {
+                const ancestorState = JSON.parse(await readFile(path.join(candidate, "state.json"), "utf8"));
+                if (ancestorState.runId === parentRunId) {
+                    ancestorRunDir = candidate;
+                    break;
+                }
+            }
+            catch {
+                // try next lifecycle
+            }
+        }
+        if (!ancestorRunDir)
+            return undefined;
+        const resolvedAncestorRunDir = path.resolve(ancestorRunDir);
+        if (visitedRunDirs.has(resolvedAncestorRunDir))
+            return undefined;
+        visitedRunDirs.add(resolvedAncestorRunDir);
+        currentRunDir = ancestorRunDir;
+        currentRunId = parentRunId;
+    }
+    return undefined;
+}
 /**
  * Derive only the latest unresolved verify/review feedback from canonical
  * parent-run facts. Provider-only failures intentionally return undefined.
@@ -144,8 +340,67 @@ export async function deriveDagRerunFeedback(input) {
             break;
         }
     }
-    if (!sourceNodeId || !sourceNode)
+    if (!sourceNodeId || !sourceNode) {
+        // Typed terminal channel: the frontend review/design review commit their
+        // verdicts as typed facts (request_review_changes / request_design_changes)
+        // instead of VERDICT text, and the frontend DAG has no convergence
+        // passHistory. Fall back to reading the typed event stores so findings
+        // still flow into the next round as unresolved feedback. Prefer review;
+        // if absent, fall through to the design review (a design rejection also
+        // carries actionable findings the next plan round must consume). When
+        // the direct parent has neither because it failed before review, walk the
+        // rerun-task lineage chain — chained
+        // reruns otherwise lose the grandparent's code-review findings and the
+        // reviewer re-flags them as "unresolved previous-round feedback" (r18).
+        // A committed approval is a resolution barrier and prevents older
+        // findings from being resurrected.
+        const typedFact = (await readTypedReviewRequestFact(input.runDir)) ??
+            (await readTypedDesignRequestFact(input.runDir)) ??
+            (await readAncestorTypedRequestFact(input.runDir));
+        if (typedFact) {
+            const parentSourceBindingHash = sourceBindingHash(input.spec);
+            return withDigest({
+                schemaVersion: 1,
+                kind: "unresolved-terminal-feedback",
+                parentRunId: "parentRunId" in typedFact &&
+                    typeof typedFact.parentRunId === "string"
+                    ? typedFact.parentRunId
+                    : input.parentRunId,
+                taskId: input.taskId,
+                sourceNodeId: typedFact.nodeId,
+                verdict: "request-revision",
+                failureCategory: typedFact.nodeId === FRONTEND_REVIEW_NODE_ID
+                    ? "review-request-changes"
+                    : "design-request-changes",
+                feedbackText: scrubAndBoundFeedbackText(formatTypedReviewRequestFeedback(typedFact.fact), input.runDir, input.state.cwd),
+                evidenceRefs: [
+                    {
+                        nodeId: typedFact.nodeId,
+                        preservedNodeRecordPath: `${typedFact.nodeId}.json`,
+                    },
+                ],
+                attemptSummary: {
+                    completedPasses: 1,
+                    maxPasses: 1,
+                    ...(input.state.terminalReason
+                        ? { terminalReason: input.state.terminalReason }
+                        : {}),
+                },
+                binding: {
+                    ...(parentSourceBindingHash
+                        ? { sourceCanonicalHash: parentSourceBindingHash }
+                        : {}),
+                    ...(input.spec.taskContractBinding?.canonicalHash
+                        ? {
+                            taskContractCanonicalHash: input.spec.taskContractBinding.canonicalHash,
+                        }
+                        : {}),
+                    status: "unknown",
+                },
+            });
+        }
         return undefined;
+    }
     const completedPasses = pass?.pass ?? Math.max(1, input.state.convergence?.currentPass ?? 1);
     const maxPasses = Math.max(completedPasses, input.state.convergence?.maxPasses ?? 1);
     const parentSourceBindingHash = sourceBindingHash(input.spec);

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";
@@ -970,6 +971,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 +996,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

@@ -4,6 +4,7 @@ import { generateTaskDagUseCase } from "../../application/dag/generate-task-dag.
 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) {
@@ -369,6 +370,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,