@tea-agent/loop-agent 0.39.0-beta.1 → 0.39.0-beta.11

package/dist/workflows/dag/prompt.js

@@ -45,9 +45,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 [
@@ -67,7 +100,6 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
     const toleratedFailures = new Set(task.failureAwareDependsOn ?? []);
     for (const depId of task.depends_on) {
         const record = upstream[depId];
-        const artifactFirst = task.artifactFirstUpstreamNodeIds?.includes(depId);
         const stdout = record?.stdout?.trim() ? record.stdout : "";
         const assistantText = record?.assistantText?.trim()
             ? record.assistantText
@@ -119,23 +151,16 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
         }
         if (!record || record.status !== "FINISHED")
             continue;
-        if (artifactFirst) {
-            const lines = [
-                `## Upstream artifact: ${depId}`,
-                "Artifact-first input: do not infer fields from a preview. Read the hash-bound payload only when a field is required; do not edit runner evidence.",
-            ];
-            if (record.structuredArtifactPath &&
-                record.structuredArtifactSha256 &&
-                record.structuredArtifactSchemaId) {
-                lines.push(`- payload: ${record.structuredArtifactPath}`, `- schema: ${record.structuredArtifactSchemaId}`, `- sha256: ${record.structuredArtifactSha256}`);
-                if (record.frontendPlanOutput) {
-                    lines.push(`- payload kind: ${record.frontendPlanOutput.payloadKind}`, `- citations: ${record.frontendPlanOutput.citationsArtifactPath}`, `- citations sha256: ${record.frontendPlanOutput.citationsArtifactSha256}`);
-                }
-            }
-            else {
-                lines.push("- artifact: unavailable (do not reconstruct the contract from node prose; treat this as an upstream artifact integrity failure)");
-            }
-            sections.push(lines.join("\n"));
+        if (record.structuredArtifactPath &&
+            record.structuredArtifactSchemaId ===
+                "frontend-implementation-contract-v1") {
+            sections.push([
+                `## Upstream output: ${depId}`,
+                "Validated structured artifact (read-only runner evidence — use read tool to fetch; do not edit). Do not infer the contract from stdout.",
+                `- path: ${record.structuredArtifactPath}`,
+                `- schema: ${record.structuredArtifactSchemaId}`,
+                `- sha256: ${record.structuredArtifactSha256 ?? "unknown"}`,
+            ].join("\n"));
             continue;
         }
         if (!upstreamText)

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,7 @@ 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";
 export const MAX_RERUN_FEEDBACK_CHARS = 12_000;
 const RERUN_FEEDBACK_TRUNCATION_MARKER = "\n\n...[上一轮反馈已按长度上限截断]...\n\n";
 const MAX_EVIDENCE_REFS = 8;
@@ -35,6 +36,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 +166,41 @@ 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,
+        },
+    };
+}
 /**
  * Derive only the latest unresolved verify/review feedback from canonical
  * parent-run facts. Provider-only failures intentionally return undefined.
@@ -144,8 +218,57 @@ 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).
+        const typedFact = (await readTypedReviewRequestFact(input.runDir)) ??
+            (await readTypedDesignRequestFact(input.runDir));
+        if (typedFact) {
+            const parentSourceBindingHash = sourceBindingHash(input.spec);
+            return withDigest({
+                schemaVersion: 1,
+                kind: "unresolved-terminal-feedback",
+                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

@@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises";
 import { assertTaskContractBindingFresh } from "./task-contract-binding.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";
 const REVIEW_VERDICT_RECOVERY_NODE_ID = "review-verdict-recovery-pi";
 const SAFE_SHELL_GATE_KEYS = [
     "verdictGate",
@@ -159,12 +160,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")
@@ -190,12 +195,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)
@@ -306,6 +315,9 @@ export function computeResetClosure(spec, effectiveFromNodeId) {
         ...collectReachableDescendants(spec, effectiveFromNodeId),
     ].sort();
 }
+function isNeverStartedNodeStatus(status) {
+    return status === undefined || status === "SKIPPED" || status === "PENDING";
+}
 export function assessResetClosureSafety(spec, resetNodeIds, options = {}) {
     const tasks = taskById(spec);
     const blockingNodes = [];
@@ -314,9 +326,17 @@ export function assessResetClosureSafety(spec, resetNodeIds, options = {}) {
         const task = tasks.get(nodeId);
         if (!task)
             continue;
+        if (options.parentNodes !== undefined &&
+            isNeverStartedNodeStatus(options.parentNodes[nodeId]?.status)) {
+            continue;
+        }
         if (isWriterTask(task, spec)) {
             if (nodeId === options.allowedTransportWriterNodeId)
                 continue;
+            if (nodeId === options.allowedExclusiveShellFromNodeId &&
+                task.executor === "shell") {
+                continue;
+            }
             blockingNodes.push({
                 nodeId,
                 reasonCode: "restart-subgraph-contains-writer",
@@ -370,6 +390,100 @@ export function assessResetClosureSafety(spec, resetNodeIds, options = {}) {
         reasonCodes: [...new Set(reasonCodes)],
     };
 }
+/**
+ * Experimental prompt-override admission (fail-closed):
+ * - requires the internal switch (see shared/dag-prompt-override.ts);
+ * - the target must be a failed (ERROR) node inside the reset closure, so an
+ *   override can only adjust how an already-failed node retries — never a
+ *   finished, skipped, or not-yet-started node;
+ * - only `subtask_prompt` semantics change: "append" keeps the frozen base
+ *   and adds a marked addendum block, "replace" swaps the whole prompt;
+ *   base/final sha256 are recorded for provenance and bound into planHash.
+ */
+function assessPromptOverrides(input) {
+    const blockingNodes = [];
+    const reasonCodes = [];
+    const tasks = taskById(input.spec);
+    const resetSet = new Set(input.resetNodeIds);
+    const seen = new Set();
+    const entries = [];
+    if (!input.enabled) {
+        reasonCodes.push("prompt-override-disabled");
+    }
+    for (const override of input.overrides) {
+        const nodeId = override.nodeId?.trim() ?? "";
+        if (seen.has(nodeId)) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "prompt-override-duplicate-node",
+            });
+            reasonCodes.push("prompt-override-duplicate-node");
+            continue;
+        }
+        seen.add(nodeId);
+        const task = tasks.get(nodeId);
+        if (!task) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "prompt-override-node-missing",
+            });
+            reasonCodes.push("prompt-override-node-missing");
+            continue;
+        }
+        if (!resetSet.has(nodeId)) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "prompt-override-outside-reset-closure",
+            });
+            reasonCodes.push("prompt-override-outside-reset-closure");
+            continue;
+        }
+        if (input.state.nodes[nodeId]?.status !== "ERROR") {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "prompt-override-node-not-failed",
+            });
+            reasonCodes.push("prompt-override-node-not-failed");
+            continue;
+        }
+        const mode = override.mode === "append" ? "append" : "replace";
+        const prompt = override.prompt ?? "";
+        if (!prompt.trim() ||
+            prompt.length > MAX_DAG_RERUN_PROMPT_OVERRIDE_CHARS) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "prompt-override-invalid-prompt",
+            });
+            reasonCodes.push("prompt-override-invalid-prompt");
+            continue;
+        }
+        const basePromptSha256 = createHash("sha256")
+            .update(task.subtask_prompt, "utf8")
+            .digest("hex");
+        const finalPrompt = composeDagPromptOverridePrompt({
+            basePrompt: task.subtask_prompt,
+            text: prompt,
+            mode,
+        });
+        const promptSha256 = createHash("sha256")
+            .update(finalPrompt, "utf8")
+            .digest("hex");
+        if (promptSha256 === basePromptSha256) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "prompt-override-unchanged",
+            });
+            reasonCodes.push("prompt-override-unchanged");
+            continue;
+        }
+        entries.push({ nodeId, mode, basePromptSha256, promptSha256 });
+    }
+    return {
+        entries: entries.length > 0 ? entries : undefined,
+        blockingNodes,
+        reasonCodes: [...new Set(reasonCodes)],
+    };
+}
 export function computePlanHash(planWithoutHash) {
     const canonical = JSON.stringify(sortKeysDeep(planWithoutHash));
     return createHash("sha256").update(canonical, "utf8").digest("hex");
@@ -594,9 +708,17 @@ export async function evaluateDagRerunPlan(input) {
             blockedReasons.push("ambiguous-skipped-rewrite");
         }
     }
-    const closureSafety = assessResetClosureSafety(input.parentSpec, resetNodeIds, transportWriterRestart && effectiveFromNodeId
-        ? { allowedTransportWriterNodeId: effectiveFromNodeId }
-        : {});
+    const closureSafety = assessResetClosureSafety(input.parentSpec, resetNodeIds, {
+        ...(transportWriterRestart && effectiveFromNodeId
+            ? { allowedTransportWriterNodeId: effectiveFromNodeId }
+            : {}),
+        parentNodes: input.parentState.nodes,
+        ...(effectiveFromNodeId &&
+            effectiveTask?.executor === "shell" &&
+            effectiveRecord?.status === "ERROR"
+            ? { allowedExclusiveShellFromNodeId: effectiveFromNodeId }
+            : {}),
+    });
     blockingNodes.push(...closureSafety.blockingNodes);
     for (const code of closureSafety.reasonCodes) {
         reasonCodes.push(code);
@@ -629,6 +751,22 @@ export async function evaluateDagRerunPlan(input) {
             blockingNodes.push({ nodeId, reasonCode: "parent-facts-invalid" });
         }
     }
+    let promptOverrideEntries;
+    if (input.promptOverrides !== undefined && input.promptOverrides.length > 0) {
+        const overrideAssessment = assessPromptOverrides({
+            spec: input.parentSpec,
+            state: input.parentState,
+            resetNodeIds,
+            overrides: input.promptOverrides,
+            enabled: input.promptOverrideEnabled === true,
+        });
+        blockingNodes.push(...overrideAssessment.blockingNodes);
+        for (const code of overrideAssessment.reasonCodes) {
+            reasonCodes.push(code);
+            blockedReasons.push(code);
+        }
+        promptOverrideEntries = overrideAssessment.entries;
+    }
     const uniqueReasonCodes = [...new Set(reasonCodes)];
     const uniqueBlockedReasons = [...new Set(blockedReasons)];
     const eligible = uniqueBlockedReasons.length === 0 &&
@@ -672,6 +810,7 @@ export async function evaluateDagRerunPlan(input) {
             parentLifecycle: input.parentLifecycle,
             workerManaged: input.workerManaged,
         }),
+        ...(promptOverrideEntries ? { promptOverrides: promptOverrideEntries } : {}),
     };
     return {
         ...planWithoutHash,