@tea-agent/loop-agent 0.39.3 → 0.40.0-beta.1

package/dist/workflows/dag/node-execution.js

@@ -10,6 +10,7 @@ import { writeNodeRecord, writeNodeSkillArtifacts } from "./run-store.js";
 import { resolveContextPolicy } from "./context-policy.js";
 import { buildDagNodePromptEnvelope, formatConvergenceFeedbackBlock, } from "./prompt.js";
 import { persistLongNodeOutputArtifacts } from "./upstream-artifacts.js";
+import { materializeDeclaredArtifactFacts } from "./artifact-bindings.js";
 import { buildOutputLimitRecoverySection, loadBackendTestWriterProgressForRetry, } from "./backend-test-writer-completeness.js";
 import { computeBackoffDelayMs, isCanonicalFinalVerifyShellRetryCandidate, isRetryablePiFailureCategory, isSafeReadOnlyPiRetryCandidate, isTargetTemplateTransientRetryNode, isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, VERIFY_SHELL_RETRY_POLICY, } from "./retry-policy.js";
 import { applyNodeActivity, evaluateNodeLiveness, resolveLivenessPolicy, } from "./liveness-policy.js";
@@ -42,7 +43,11 @@ function canonicalApprovalJson(value) {
 export function parseAndValidateFinalWriteSetApproval(input) {
     const binding = input.task.finalWriteSetApproval;
     if (!binding) {
-        return { ok: false, reason: "missing final write-set approval binding", approvalSourceNodeId: "(missing)" };
+        return {
+            ok: false,
+            reason: "missing final write-set approval binding",
+            approvalSourceNodeId: "(missing)",
+        };
     }
     const source = input.state.nodes[binding.approvalSourceNodeId];
     if (source?.status !== "FINISHED" || parseProcessVerdict(source) !== "pass") {
@@ -53,20 +58,44 @@ export function parseAndValidateFinalWriteSetApproval(input) {
         };
     }
     const raw = canonicalNodeOutput(source);
-    const blocks = [...raw.matchAll(/```FINAL_WRITE_SET_APPROVAL_JSON\s*\r?\n([\s\S]*?)\r?\n```/g)];
+    const blocks = [
+        ...raw.matchAll(/```FINAL_WRITE_SET_APPROVAL_JSON\s*\r?\n([\s\S]*?)\r?\n```/g),
+    ];
     if (blocks.length !== 1) {
-        return { ok: false, reason: `expected exactly one FINAL_WRITE_SET_APPROVAL_JSON block, found ${blocks.length}`, approvalSourceNodeId: binding.approvalSourceNodeId };
+        return {
+            ok: false,
+            reason: `expected exactly one FINAL_WRITE_SET_APPROVAL_JSON block, found ${blocks.length}`,
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     let approval;
     try {
         approval = JSON.parse(blocks[0][1]);
     }
     catch {
-        return { ok: false, reason: "final write-set approval is not valid JSON", approvalSourceNodeId: binding.approvalSourceNodeId };
+        return {
+            ok: false,
+            reason: "final write-set approval is not valid JSON",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
-    const required = ["schemaVersion", "writerNodeId", "approvalSourceNodeId", "auditedPlanNodeId", "approvedWriteSet", "taskContractSha256", "auditedPlanSha256", "approvalDigest"];
-    if (Object.keys(approval).length !== required.length || required.some((key) => !(key in approval))) {
-        return { ok: false, reason: "final write-set approval has an invalid schema", approvalSourceNodeId: binding.approvalSourceNodeId };
+    const required = [
+        "schemaVersion",
+        "writerNodeId",
+        "approvalSourceNodeId",
+        "auditedPlanNodeId",
+        "approvedWriteSet",
+        "taskContractSha256",
+        "auditedPlanSha256",
+        "approvalDigest",
+    ];
+    if (Object.keys(approval).length !== required.length ||
+        required.some((key) => !(key in approval))) {
+        return {
+            ok: false,
+            reason: "final write-set approval has an invalid schema",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     const approved = approval.approvedWriteSet;
     if (approval.schemaVersion !== 1 ||
@@ -79,12 +108,20 @@ export function parseAndValidateFinalWriteSetApproval(input) {
         typeof approval.taskContractSha256 !== "string" ||
         typeof approval.auditedPlanSha256 !== "string" ||
         typeof approval.approvalDigest !== "string") {
-        return { ok: false, reason: "final write-set approval binding or field types are invalid", approvalSourceNodeId: binding.approvalSourceNodeId };
+        return {
+            ok: false,
+            reason: "final write-set approval binding or field types are invalid",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     if (!/^[a-f0-9]{64}$/.test(approval.taskContractSha256) ||
         !/^[a-f0-9]{64}$/.test(approval.auditedPlanSha256) ||
         !/^[a-f0-9]{64}$/.test(approval.approvalDigest)) {
-        return { ok: false, reason: "final write-set approval digest fields are invalid", approvalSourceNodeId: binding.approvalSourceNodeId };
+        return {
+            ok: false,
+            reason: "final write-set approval digest fields are invalid",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     const canonicalPayload = { ...approval };
     delete canonicalPayload.approvalDigest;
@@ -92,33 +129,70 @@ export function parseAndValidateFinalWriteSetApproval(input) {
         .update(canonicalApprovalJson(canonicalPayload))
         .digest("hex");
     if (approval.approvalDigest !== expectedDigest) {
-        return { ok: false, reason: "final write-set approval digest mismatch", approvalSourceNodeId: binding.approvalSourceNodeId };
+        return {
+            ok: false,
+            reason: "final write-set approval digest mismatch",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     const expectedTaskDigest = input.spec.taskContractBinding?.canonicalHash;
     const plan = input.state.nodes[binding.auditedPlanNodeId];
     const expectedPlanDigest = createHash("sha256")
         .update(canonicalNodeOutput(plan))
         .digest("hex");
-    if (!expectedTaskDigest || approval.taskContractSha256 !== expectedTaskDigest || approval.auditedPlanSha256 !== expectedPlanDigest) {
-        return { ok: false, reason: "final write-set approval is stale for the task contract or audited plan", approvalSourceNodeId: binding.approvalSourceNodeId };
+    if (!expectedTaskDigest ||
+        approval.taskContractSha256 !== expectedTaskDigest ||
+        approval.auditedPlanSha256 !== expectedPlanDigest) {
+        return {
+            ok: false,
+            reason: "final write-set approval is stale for the task contract or audited plan",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     const effectiveWriteSet = approved;
-    if (effectiveWriteSet.length === 0 || new Set(effectiveWriteSet).size !== effectiveWriteSet.length) {
-        return { ok: false, reason: "final write-set approval must contain a non-empty ordered unique path set", approvalSourceNodeId: binding.approvalSourceNodeId };
+    if (effectiveWriteSet.length === 0 ||
+        new Set(effectiveWriteSet).size !== effectiveWriteSet.length) {
+        return {
+            ok: false,
+            reason: "final write-set approval must contain a non-empty ordered unique path set",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     for (const entry of effectiveWriteSet) {
         const normalized = entry.replace(/\\/g, "/").replace(/^\.\//, "");
-        if (!normalized || normalized === "." || normalized === ".." || normalized.includes("*") || normalized.includes("?") || normalized.includes("REPLACE/") || normalized.includes("PLACEHOLDER")) {
-            return { ok: false, reason: `final write-set approval contains a broad or placeholder path: ${entry}`, approvalSourceNodeId: binding.approvalSourceNodeId };
+        if (!normalized ||
+            normalized === "." ||
+            normalized === ".." ||
+            normalized.includes("*") ||
+            normalized.includes("?") ||
+            normalized.includes("REPLACE/") ||
+            normalized.includes("PLACEHOLDER")) {
+            return {
+                ok: false,
+                reason: `final write-set approval contains a broad or placeholder path: ${entry}`,
+                approvalSourceNodeId: binding.approvalSourceNodeId,
+            };
         }
         if (!input.task.allowedPaths.some((allowed) => pathMatchesPattern(normalized, allowed))) {
-            return { ok: false, reason: `final write-set approval exceeds allowedPaths: ${entry}`, approvalSourceNodeId: binding.approvalSourceNodeId };
+            return {
+                ok: false,
+                reason: `final write-set approval exceeds allowedPaths: ${entry}`,
+                approvalSourceNodeId: binding.approvalSourceNodeId,
+            };
         }
         if (input.task.forbiddenPaths.some((forbidden) => pathMatchesPattern(normalized, forbidden))) {
-            return { ok: false, reason: `final write-set approval overlaps forbiddenPaths: ${entry}`, approvalSourceNodeId: binding.approvalSourceNodeId };
+            return {
+                ok: false,
+                reason: `final write-set approval overlaps forbiddenPaths: ${entry}`,
+                approvalSourceNodeId: binding.approvalSourceNodeId,
+            };
         }
     }
-    return { ok: true, effectiveWriteSet, approvalDigest: approval.approvalDigest };
+    return {
+        ok: true,
+        effectiveWriteSet,
+        approvalDigest: approval.approvalDigest,
+    };
 }
 export function buildNodePrompt(spec, task, upstream, options) {
     const policy = resolveContextPolicy(spec);
@@ -126,6 +200,7 @@ export function buildNodePrompt(spec, task, upstream, options) {
         spec,
         task,
         upstream,
+        runDir: options?.runDir,
         resolvedSkills: policy.resolveSkills(spec, task),
         maxUpstreamChars: policy.resolveMaxUpstreamChars(task),
         projectGovernanceContext: options?.projectGovernanceContext,
@@ -314,10 +389,7 @@ function promptRestartCandidateForAttempt(input) {
     }
     const appendedPrefix = `${input.baseRuntimePrompt}\n\n`;
     if (input.attemptPrompt.startsWith(appendedPrefix)) {
-        return [
-            input.taskPrompt,
-            input.attemptPrompt.slice(appendedPrefix.length),
-        ]
+        return [input.taskPrompt, input.attemptPrompt.slice(appendedPrefix.length)]
             .filter(Boolean)
             .join("\n\n");
     }
@@ -353,6 +425,7 @@ export async function buildNodePromptWithResolvedSkillInstructions(spec, task, u
             spec,
             task,
             upstream,
+            runDir: options?.runDir,
             resolvedSkills: skillNames,
             resolvedSkillInstructions,
             maxUpstreamChars: policy.resolveMaxUpstreamChars(task),
@@ -533,7 +606,11 @@ export async function executeDagNode(input) {
         await notifyNodeObserver(input.observer, "onNodeFinish", nodeId, state);
     };
     if (task.finalWriteSetApproval) {
-        const authorization = parseAndValidateFinalWriteSetApproval({ task, spec, state });
+        const authorization = parseAndValidateFinalWriteSetApproval({
+            task,
+            spec,
+            state,
+        });
         if (!authorization.ok) {
             node.runtimeWriteAuthorization = {
                 schemaVersion: 1,
@@ -622,6 +699,7 @@ export async function executeDagNode(input) {
                     spec,
                     task,
                     upstream: state.nodes,
+                    runDir,
                     snapshot: skillSnapshot,
                     projectGovernanceContext,
                 });
@@ -712,6 +790,7 @@ export async function executeDagNode(input) {
         else {
             ({ prompt, resolvedSkills } =
                 await buildNodePromptWithResolvedSkillInstructions(spec, task, state.nodes, cwd, {
+                    runDir,
                     projectGovernanceContext,
                     convergenceFeedback: deriveConvergenceFeedback(state),
                 }));
@@ -875,6 +954,7 @@ export async function executeDagNode(input) {
                 model,
                 ...(thinking ? { thinking } : {}),
                 prompt: attemptPrompt,
+                resolvedSkills: resolvedSkills.map((skill) => skill.name),
                 attempt: attemptNumber,
                 reportActivity,
                 timeoutMs: livenessPolicy.absoluteMaxWallClockMs,
@@ -912,9 +992,7 @@ export async function executeDagNode(input) {
                         ...result,
                         ok: false,
                         failureCategory: GOVERNANCE_BLOCKED_CATEGORY,
-                        stderr: [result.stderr, audit.reason]
-                            .filter(Boolean)
-                            .join("\n"),
+                        stderr: [result.stderr, audit.reason].filter(Boolean).join("\n"),
                     };
                 }
             }
@@ -1237,6 +1315,13 @@ export async function executeDagNode(input) {
             node.structuredArtifactSha256 = pendingStructuredArtifact.sha256;
             node.structuredArtifactSchemaId = pendingStructuredArtifact.schemaId;
         }
+        if ((task.producesArtifacts?.length ?? 0) > 0) {
+            node.declaredArtifacts = await materializeDeclaredArtifactFacts({
+                runDir,
+                task,
+                node,
+            });
+        }
     }
     const finishedAt = new Date().toISOString();
     node.finishedAt = finishedAt;

package/dist/workflows/dag/path-safety.js

@@ -0,0 +1 @@
+export { assertReadableRegularFile, assertRealPathInsideBoundary, readFileBoundarySafe, } from "../../shared/path-safety.js";

package/dist/workflows/dag/prompt.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { DEFAULT_DAG_OUTPUT_LANGUAGE, } from "./types.js";
 import { formatStdoutPreview, formatUpstreamArtifactPointerMap, } from "./upstream-artifacts.js";
 export const MAX_UPSTREAM_CHARS = 2_000;
@@ -62,9 +63,10 @@ export function formatOutputLanguageBlock(language = DEFAULT_DAG_OUTPUT_LANGUAGE
         "如果当前节点任务明确要求其他语言，以节点的明确要求为准。",
     ].join("\n");
 }
-export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHARS) {
+export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHARS, runDir) {
     const sections = [];
     const toleratedFailures = new Set(task.failureAwareDependsOn ?? []);
+    const consumedArtifactIds = new Set((task.consumesArtifacts ?? []).map((binding) => binding.artifactId));
     for (const depId of task.depends_on) {
         const record = upstream[depId];
         const stdout = record?.stdout?.trim() ? record.stdout : "";
@@ -118,6 +120,22 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
         }
         if (!record || record.status !== "FINISHED")
             continue;
+        const consumedArtifacts = (record.declaredArtifacts ?? []).filter((artifact) => consumedArtifactIds.has(artifact.artifactId));
+        const consumedArtifactSection = runDir && consumedArtifacts.length > 0
+            ? [
+                "Declared artifact bindings (read-only run evidence — use the exact paths below; do not edit):",
+                ...consumedArtifacts.flatMap((artifact) => {
+                    const absolutePath = path.resolve(runDir, ...artifact.path.split("/"));
+                    return [
+                        `- artifactId: ${artifact.artifactId}`,
+                        `  path: ${absolutePath}`,
+                        `  status: ${artifact.status}`,
+                        `  sha256: ${artifact.sha256 ?? "unknown"}`,
+                        `  mediaType: ${artifact.mediaType}`,
+                    ];
+                }),
+            ].join("\n")
+            : "";
         if (record.structuredArtifactPath &&
             record.structuredArtifactSchemaId ===
                 "frontend-implementation-contract-v1") {
@@ -130,8 +148,12 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
             ].join("\n"));
             continue;
         }
-        if (!upstreamText)
+        if (!upstreamText) {
+            if (consumedArtifactSection) {
+                sections.push(`## Upstream output: ${depId}\n${consumedArtifactSection}`);
+            }
             continue;
+        }
         const artifactKind = stdout ? "stdout" : "assistant";
         const artifactPath = stdout
             ? record.stdoutArtifactPath
@@ -147,6 +169,9 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
                 `- sha256: ${record.structuredArtifactSha256 ?? "unknown"}`,
             ].join("\n");
         }
+        if (consumedArtifactSection) {
+            section += `\n\n${consumedArtifactSection}`;
+        }
         if (truncated && artifactPath) {
             section += formatUpstreamArtifactPointerMap(record, artifactKind);
         }
@@ -329,7 +354,7 @@ function formatProjectGovernanceContext(ctx) {
     return lines.join("\n");
 }
 export function buildDagNodePromptEnvelope(input) {
-    const { spec, task, upstream, resolvedSkills = [], resolvedSkillInstructions = [], maxUpstreamChars = MAX_UPSTREAM_CHARS, projectGovernanceContext, convergenceFeedback, } = input;
+    const { spec, task, upstream, runDir, resolvedSkills = [], resolvedSkillInstructions = [], maxUpstreamChars = MAX_UPSTREAM_CHARS, projectGovernanceContext, convergenceFeedback, } = input;
     const objective = spec.objective ?? spec.title;
     const successCriteria = formatBulletList(spec.successCriteria, "(none specified)");
     const globalConstraints = formatBulletList(spec.globalConstraints, "(none specified)");
@@ -339,7 +364,7 @@ export function buildDagNodePromptEnvelope(input) {
         ? resolvedSkills.map((skill) => `- ${skill}`).join("\n")
         : "(none)";
     const skillInstructionsSection = formatResolvedSkillInstructions(resolvedSkillInstructions);
-    const upstreamContext = buildUpstreamContext(task, upstream, maxUpstreamChars);
+    const upstreamContext = buildUpstreamContext(task, upstream, maxUpstreamChars, runDir);
     const readOnlyBoundary = buildReadOnlyBoundary(writePolicy);
     const sections = [
         `<dag_objective>\n${objective}\n</dag_objective>`,

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

@@ -1,9 +1,138 @@
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
+import { z } from "zod";
 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";
+import { artifactOverrideSetV1Schema, workerContinuationAuthorityV1Schema, } from "../../shared/context-transfer.js";
+import { buildArtifactBindingGraph, computeArtifactImpact, } from "./artifact-bindings.js";
+const rerunBindingsV1Schema = z
+    .object({
+    sourceBindingMatched: z.boolean(),
+    taskContractBindingMatched: z.boolean(),
+    controllerIdentityMatched: z.boolean(),
+    skillSnapshotVerified: z.boolean(),
+    workspaceMatched: z.boolean(),
+})
+    .strict();
+const rerunPlanCommonSchema = {
+    eligible: z.boolean(),
+    parentRunId: z.string().min(1),
+    parentLifecycle: z.enum(["completed", "dry-run", "init-only"]),
+    selectedNodeId: z.string().min(1),
+    effectiveFromNodeId: z.string().min(1).optional(),
+    rewriteApplied: z.boolean(),
+    resetNodeIds: z.array(z.string().min(1)),
+    importedNodeIds: z.array(z.string().min(1)),
+    blockingNodes: z.array(z.object({ nodeId: z.string().min(1), reasonCode: z.string().min(1) }).strict()),
+    reasonCodes: z.array(z.string().min(1)),
+    blockedReasons: z.array(z.string().min(1)),
+    risk: z.enum(["low", "medium", "high"]),
+    verificationPolicy: z
+        .object({
+        mode: z.enum(["inherited", "rerun"]),
+        nodeIds: z.array(z.string().min(1)),
+        inheritedFromRunId: z.string().min(1).optional(),
+    })
+        .strict()
+        .optional(),
+    workerAssociation: z.discriminatedUnion("kind", [
+        z.object({ kind: z.literal("standalone") }).strict(),
+        z
+            .object({
+            kind: z.literal("worker-managed"),
+            featureId: z.string().min(1).optional(),
+            taskId: z.string().min(1).optional(),
+            workerRunId: z.string().min(1).optional(),
+        })
+            .strict(),
+    ]),
+    estimatedExecution: z
+        .object({
+        nodeCount: z.number().int().nonnegative(),
+        piCallCount: z.number().int().nonnegative(),
+        shellNodeCount: z.number().int().nonnegative(),
+        avoidedNodeCount: z.number().int().nonnegative(),
+        avoidedPiCallCount: z.number().int().nonnegative(),
+    })
+        .strict(),
+    suggestedAction: z.enum([
+        "dag-rerun",
+        "standalone-task-rerun",
+        "worker-task-retry",
+        "regenerate",
+        "resume",
+        "reconcile",
+        "manual",
+    ]),
+    promptOverrides: z
+        .array(z
+        .object({
+        nodeId: z.string().min(1),
+        mode: z.enum(["replace", "append"]),
+        basePromptSha256: z.string().regex(/^[a-f0-9]{64}$/),
+        promptSha256: z.string().regex(/^[a-f0-9]{64}$/),
+    })
+        .strict())
+        .optional(),
+    workerContinuationAuthority: workerContinuationAuthorityV1Schema.optional(),
+};
+export const dagRerunPlanV2Schema = z
+    .object({
+    schemaVersion: z.literal(2),
+    ...rerunPlanCommonSchema,
+    trigger: z.enum(["node-rerun", "prompt-override", "artifact-override"]),
+    artifactOverrides: artifactOverrideSetV1Schema.optional(),
+    impact: z
+        .object({
+        producerNodeId: z.string().min(1).optional(),
+        directConsumerNodeIds: z.array(z.string().min(1)),
+        effectiveFromNodeId: z.string().min(1),
+        affectedNodeIds: z.array(z.string().min(1)),
+        importedNodeIds: z.array(z.string().min(1)),
+        blockedNodeIds: z.array(z
+            .object({ nodeId: z.string().min(1), reasonCode: z.string().min(1) })
+            .strict()),
+    })
+        .strict(),
+    bindings: rerunBindingsV1Schema
+        .extend({
+        artifactGraphSha256: z.string().regex(/^[a-f0-9]{64}$/),
+        overrideSetHash: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+        stagingRevisionSha256: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    })
+        .strict(),
+    planHash: z.string().regex(/^[a-f0-9]{64}$/),
+})
+    .strict()
+    .superRefine((plan, ctx) => {
+    const artifactTrigger = plan.trigger === "artifact-override";
+    if (artifactTrigger !== Boolean(plan.artifactOverrides)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["artifactOverrides"],
+            message: "artifact override trigger and override set must appear together",
+        });
+    }
+    if (plan.artifactOverrides &&
+        (plan.bindings.overrideSetHash !== plan.artifactOverrides.overrideSetHash ||
+            !plan.bindings.stagingRevisionSha256)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["bindings"],
+            message: "artifact override bindings must match the override set and revision",
+        });
+    }
+    if (plan.workerContinuationAuthority &&
+        plan.workerAssociation.kind !== "worker-managed") {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["workerContinuationAuthority"],
+            message: "Worker continuation authority requires a Worker-managed parent",
+        });
+    }
+});
 const REVIEW_VERDICT_RECOVERY_NODE_ID = "review-verdict-recovery-pi";
 const SAFE_SHELL_GATE_KEYS = [
     "verdictGate",
@@ -480,6 +609,149 @@ export function computePlanHash(planWithoutHash) {
     const canonical = JSON.stringify(sortKeysDeep(planWithoutHash));
     return createHash("sha256").update(canonical, "utf8").digest("hex");
 }
+export function evaluateArtifactOverrideRerunPlan(input) {
+    const graph = buildArtifactBindingGraph(input.parentSpec);
+    const declaration = graph.artifacts.find((artifact) => artifact.artifactId === input.artifactId);
+    const impact = computeArtifactImpact(input.parentSpec, input.artifactId);
+    const reasonCodes = [];
+    const blockedReasons = [];
+    const blockingNodes = [];
+    const workerAssociation = input.workerAssociation ?? { kind: "standalone" };
+    const block = (code, nodeId) => {
+        reasonCodes.push(code);
+        blockedReasons.push(code);
+        if (nodeId)
+            blockingNodes.push({ nodeId, reasonCode: code });
+    };
+    if (!graph.available)
+        block("ARTIFACT_BINDING_UNAVAILABLE");
+    if (!declaration)
+        block("ARTIFACT_IDENTITY_AMBIGUOUS");
+    if (!impact)
+        block("ARTIFACT_CONSUMER_UNKNOWN", declaration?.producerNodeId);
+    if (input.parentLifecycle !== "completed")
+        block("parent-lifecycle-ineligible");
+    const overrideRevisionId = input.artifactOverrides.overrides[0]?.revisionId;
+    const authority = input.workerContinuationAuthority;
+    if (workerAssociation.kind === "worker-managed") {
+        if (!authority) {
+            block("WORKER_MANAGED_CONTINUATION_UNSUPPORTED");
+        }
+        else if (!workerAssociation.workerRunId ||
+            !workerAssociation.featureId ||
+            !workerAssociation.taskId ||
+            authority.parentWorkerRunId !== workerAssociation.workerRunId ||
+            authority.featureId !== workerAssociation.featureId ||
+            authority.taskId !== workerAssociation.taskId ||
+            authority.revisionId !== overrideRevisionId) {
+            block("WORKER_CONTINUATION_AUTHORITY_MISMATCH");
+        }
+    }
+    else if (authority) {
+        block("WORKER_CONTINUATION_AUTHORITY_MISMATCH");
+    }
+    if (input.parentSpec.convergence?.enabled || input.parentState.convergence?.enabled) {
+        block("convergence-rerun-unsupported");
+    }
+    if (input.parentSpec.evaluation || input.parentState.evaluation) {
+        block("evaluation-rerun-unsupported");
+    }
+    if ((input.parentSpec.budget?.mode ?? input.parentState.budget?.mode) === "hard") {
+        block("budget-rerun-unsupported");
+    }
+    for (const [name, matched] of Object.entries(input.bindings)) {
+        if (!matched)
+            block(`${name}-drift`);
+    }
+    const override = input.artifactOverrides.overrides[0];
+    const parentFact = declaration
+        ? input.parentState.nodes[declaration.producerNodeId]?.declaredArtifacts?.find((fact) => fact.artifactId === input.artifactId)
+        : undefined;
+    if (!declaration ||
+        declaration.revisionPolicy !== "replace-file" ||
+        parentFact?.status !== "materialized" ||
+        parentFact.revisionEligible !== true ||
+        !parentFact.sha256) {
+        block("ARTIFACT_NOT_REVISION_ELIGIBLE", declaration?.producerNodeId);
+    }
+    if (!override ||
+        override.parentArtifact.runId !== input.parentRunId ||
+        override.parentArtifact.nodeId !== declaration?.producerNodeId ||
+        override.parentArtifact.path !== declaration?.path ||
+        override.parentArtifact.sha256 !== parentFact?.sha256 ||
+        override.supersedes !== parentFact?.sha256 ||
+        override.replacement.sha256 !== input.stagingRevisionSha256) {
+        block("ARTIFACT_REVISION_DRIFT", declaration?.producerNodeId);
+    }
+    const affectedNodeIds = impact?.affectedNodeIds ?? [];
+    const importedNodeIds = impact?.importedNodeIds ?? [];
+    const closureSafety = assessResetClosureSafety(input.parentSpec, affectedNodeIds, {
+        parentNodes: input.parentState.nodes,
+    });
+    for (const entry of closureSafety.blockingNodes) {
+        blockingNodes.push(entry);
+        block("ARTIFACT_IMPACT_UNSAFE");
+    }
+    for (const nodeId of importedNodeIds) {
+        const status = input.parentState.nodes[nodeId]?.status;
+        if (status !== "FINISHED" && status !== "SKIPPED") {
+            block("parent-facts-invalid", nodeId);
+        }
+    }
+    const uniqueReasons = [...new Set(reasonCodes)];
+    const uniqueBlocked = [...new Set(blockedReasons)];
+    const eligible = uniqueBlocked.length === 0;
+    const shellNodeIds = affectedNodeIds.filter((nodeId) => taskById(input.parentSpec).get(nodeId)?.executor === "shell");
+    const piCallCount = affectedNodeIds.filter((nodeId) => taskById(input.parentSpec).get(nodeId)?.executor === "pi").length;
+    const planWithoutHash = {
+        schemaVersion: 2,
+        eligible,
+        parentRunId: input.parentRunId,
+        parentLifecycle: input.parentLifecycle,
+        selectedNodeId: declaration?.producerNodeId ?? input.artifactId,
+        effectiveFromNodeId: impact?.effectiveFromNodeId,
+        rewriteApplied: false,
+        resetNodeIds: affectedNodeIds,
+        importedNodeIds,
+        blockingNodes,
+        reasonCodes: uniqueReasons,
+        blockedReasons: uniqueBlocked,
+        risk: !eligible ? "high" : affectedNodeIds.length <= 2 ? "low" : "medium",
+        bindings: {
+            ...input.bindings,
+            artifactGraphSha256: graph.artifactGraphSha256,
+            overrideSetHash: input.artifactOverrides.overrideSetHash,
+            stagingRevisionSha256: input.stagingRevisionSha256,
+        },
+        ...(shellNodeIds.length > 0
+            ? { verificationPolicy: { mode: "rerun", nodeIds: shellNodeIds } }
+            : {}),
+        workerAssociation,
+        ...(authority ? { workerContinuationAuthority: authority } : {}),
+        estimatedExecution: {
+            nodeCount: affectedNodeIds.length,
+            piCallCount,
+            shellNodeCount: shellNodeIds.length,
+            avoidedNodeCount: importedNodeIds.length,
+            avoidedPiCallCount: importedNodeIds.filter((nodeId) => taskById(input.parentSpec).get(nodeId)?.executor === "pi").length,
+        },
+        suggestedAction: eligible ? "dag-rerun" : workerAssociation.kind === "worker-managed" ? "worker-task-retry" : "manual",
+        trigger: "artifact-override",
+        artifactOverrides: input.artifactOverrides,
+        impact: {
+            ...(impact ? { producerNodeId: impact.producerNodeId } : {}),
+            directConsumerNodeIds: impact?.directConsumerNodeIds ?? [],
+            effectiveFromNodeId: impact?.effectiveFromNodeId ?? declaration?.producerNodeId ?? input.artifactId,
+            affectedNodeIds,
+            importedNodeIds,
+            blockedNodeIds: blockingNodes,
+        },
+    };
+    return dagRerunPlanV2Schema.parse({
+        ...planWithoutHash,
+        planHash: computePlanHash(planWithoutHash),
+    });
+}
 function countExecutorNodes(spec, nodeIds, executor) {
     const tasks = taskById(spec);
     return nodeIds.filter((nodeId) => tasks.get(nodeId)?.executor === executor)