@tea-agent/loop-agent 0.40.0-next.9 → 0.41.0-beta.1

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,202 @@
 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";
+import { assertValidMaterializedDagTask } from "./validate.js";
+const rerunBindingsV1Schema = z
+    .object({
+    sourceBindingMatched: z.boolean(),
+    taskContractBindingMatched: z.boolean(),
+    controllerIdentityMatched: z.boolean(),
+    skillSnapshotVerified: z.boolean(),
+    workspaceMatched: z.boolean(),
+})
+    .strict();
+const hash64Schema = z.string().regex(/^[a-f0-9]{64}$/);
+const highRiskContinuationAuthorityV1Schema = z
+    .object({
+    schemaVersion: z.literal(1),
+    workspaceFingerprint: hash64Schema,
+    writer: z
+        .object({
+        nodeIds: z.array(z.string().min(1)).min(1),
+        writeSet: z.array(z.string().min(1)).min(1),
+        writeSetSha256: hash64Schema,
+    })
+        .strict()
+        .optional(),
+    dynamic: z
+        .object({
+        nodeIds: z.array(z.string().min(1)).min(1),
+        graphSha256: hash64Schema,
+    })
+        .strict()
+        .optional(),
+    budget: z
+        .object({
+        parentLedgerSha256: hash64Schema,
+        inheritedConsumed: z
+            .object({
+            tokens: z.number().int().nonnegative().nullable(),
+            wallTimeMs: z.number().nonnegative(),
+            executorCalls: z.number().int().nonnegative(),
+            repairPasses: z.number().int().nonnegative(),
+            peakContextChars: z.number().int().nonnegative(),
+            missingTokenNodeIds: z.array(z.string()),
+        })
+            .strict(),
+    })
+        .strict()
+        .optional(),
+})
+    .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(),
+    highRiskAuthority: highRiskContinuationAuthorityV1Schema.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: hash64Schema,
+        overrideSetHash: hash64Schema.optional(),
+        stagingRevisionSha256: hash64Schema.optional(),
+        parentWorkspaceFingerprint: hash64Schema.optional(),
+        currentWorkspaceFingerprint: hash64Schema.optional(),
+        budgetLedgerSha256: hash64Schema.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",
+        });
+    }
+    if (plan.highRiskAuthority) {
+        if (plan.bindings.parentWorkspaceFingerprint !==
+            plan.highRiskAuthority.workspaceFingerprint ||
+            plan.bindings.currentWorkspaceFingerprint !==
+                plan.highRiskAuthority.workspaceFingerprint) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["highRiskAuthority", "workspaceFingerprint"],
+                message: "high-risk authority must bind the matching workspace fingerprints",
+            });
+        }
+        if (plan.highRiskAuthority.budget &&
+            plan.bindings.budgetLedgerSha256 !==
+                plan.highRiskAuthority.budget.parentLedgerSha256) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["bindings", "budgetLedgerSha256"],
+                message: "budget ledger binding must match high-risk authority",
+            });
+        }
+    }
+});
 const REVIEW_VERDICT_RECOVERY_NODE_ID = "review-verdict-recovery-pi";
 const SAFE_SHELL_GATE_KEYS = [
     "verdictGate",
@@ -117,6 +310,68 @@ function isWriterTask(task, spec) {
     const writePolicy = resolveWritePolicy(task, spec);
     return writePolicy === "exclusive" || writePolicy === "docs-only";
 }
+function passesWriterBoundaryValidation(task, parentSpec) {
+    try {
+        assertValidMaterializedDagTask(task, parentSpec);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isBoundedArtifactContinuationWriter(task, parentSpec) {
+    return (task.executor === "pi" &&
+        task.toolProfile === "write" &&
+        task.writePolicy === "exclusive" &&
+        (task.writeSet?.length ?? 0) > 0 &&
+        (task.allowedPaths?.length ?? 0) > 0 &&
+        (task.forbiddenPaths?.length ?? 0) > 0 &&
+        passesWriterBoundaryValidation(task, parentSpec));
+}
+function isDynamicWriterTemplate(task) {
+    return (task.toolProfile === "write" ||
+        task.writePolicy === "exclusive" ||
+        task.writePolicy === "docs-only");
+}
+function isBoundedDynamicWriterTemplate(task, parentSpec) {
+    if (!(task.executor === "pi" &&
+        task.toolProfile === "write" &&
+        task.writePolicy === "exclusive" &&
+        (task.writeSet?.length ?? 0) > 0 &&
+        (task.allowedPaths?.length ?? 0) > 0 &&
+        (task.forbiddenPaths?.length ?? 0) > 0))
+        return false;
+    return passesWriterBoundaryValidation({
+        id: "continuation-dynamic-writer-template",
+        depends_on: [],
+        executor: task.executor,
+        role: task.role,
+        complexity: task.complexity,
+        subtask_prompt: task.subtaskPromptTemplate,
+        toolProfile: task.toolProfile,
+        writePolicy: task.writePolicy,
+        allowedPaths: task.allowedPaths,
+        forbiddenPaths: task.forbiddenPaths,
+        writeSet: task.writeSet,
+        outputContract: task.outputContract,
+    }, parentSpec);
+}
+function collectDynamicWriterTemplates(task) {
+    const writers = [];
+    const expansionChild = task.dynamicExpansion?.childTask;
+    if (expansionChild && isDynamicWriterTemplate(expansionChild)) {
+        writers.push({ id: `${task.id}#child`, task: expansionChild });
+    }
+    for (const bodyTask of task.dynamicLoopUntil?.bodyTasks ?? []) {
+        if (isDynamicWriterTemplate(bodyTask)) {
+            writers.push({ id: `${task.id}#${bodyTask.id}`, task: bodyTask });
+        }
+    }
+    return writers;
+}
+function hasOnlyBoundedDynamicWriters(task, parentSpec) {
+    return collectDynamicWriterTemplates(task).every(({ task: writer }) => isBoundedDynamicWriterTemplate(writer, parentSpec));
+}
 function hasDynamicRuntime(task) {
     return Boolean(task.dynamicExpansion ||
         task.dynamicReduction ||
@@ -174,6 +429,34 @@ function isCanonicalGeneratedVerifyShell(task) {
         return false;
     return true;
 }
+/**
+ * Frozen frontend workflow shells are deterministic runtime adapters. They may
+ * materialize run-owned evidence or run the already-frozen verification
+ * commands, but they do not receive a generic shell-continuation exemption.
+ */
+function isCanonicalFrontendArtifactContinuationShell(task) {
+    if (task.executor !== "shell" || task.writePolicy !== "read-only" || !task.shell) {
+        return false;
+    }
+    const shell = task.shell;
+    if (shell.envAllowlist?.length || shell.nonZeroExitPolicy === "record")
+        return false;
+    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-verify-assess-shell":
+        case "frontend-reverify-shell":
+            return Boolean(shell.frontendVerificationBundle) && (shell.commands?.length ?? 0) === 0;
+        case "frontend-review-context-shell":
+            return Boolean(shell.frontendReviewContext) && (shell.commands?.length ?? 0) === 0;
+        default:
+            return false;
+    }
+}
 function isSafeGateOnlyShell(task) {
     if (task.executor !== "shell")
         return false;
@@ -323,6 +606,10 @@ export function assessResetClosureSafety(spec, resetNodeIds, options = {}) {
             continue;
         }
         if (isWriterTask(task, spec)) {
+            if (options.artifactContinuation === true &&
+                isBoundedArtifactContinuationWriter(task, spec)) {
+                continue;
+            }
             if (nodeId === options.allowedTransportWriterNodeId)
                 continue;
             if (nodeId === options.allowedExclusiveShellFromNodeId &&
@@ -345,6 +632,10 @@ export function assessResetClosureSafety(spec, resetNodeIds, options = {}) {
             continue;
         }
         if (hasDynamicRuntime(task)) {
+            if (options.artifactContinuation === true &&
+                hasOnlyBoundedDynamicWriters(task, spec)) {
+                continue;
+            }
             blockingNodes.push({
                 nodeId,
                 reasonCode: "dynamic-rerun-unsupported",
@@ -367,7 +658,9 @@ export function assessResetClosureSafety(spec, resetNodeIds, options = {}) {
         }
         if (task.executor === "shell") {
             if (!isSafeGateOnlyShell(task) &&
-                !isCanonicalGeneratedVerifyShell(task)) {
+                !isCanonicalGeneratedVerifyShell(task) &&
+                !(options.artifactContinuation === true &&
+                    isCanonicalFrontendArtifactContinuationShell(task))) {
                 blockingNodes.push({
                     nodeId,
                     reasonCode: "restart-subgraph-contains-unsafe-shell",
@@ -480,6 +773,267 @@ export function computePlanHash(planWithoutHash) {
     const canonical = JSON.stringify(sortKeysDeep(planWithoutHash));
     return createHash("sha256").update(canonical, "utf8").digest("hex");
 }
+function hashCanonicalValue(value) {
+    return createHash("sha256")
+        .update(JSON.stringify(sortKeysDeep(value)), "utf8")
+        .digest("hex");
+}
+function collectHighRiskContinuationAuthority(input) {
+    const tasks = taskById(input.parentSpec);
+    const writerNodeIds = [];
+    const writeSet = new Set();
+    const dynamicNodeIds = [];
+    for (const nodeId of input.affectedNodeIds) {
+        const task = tasks.get(nodeId);
+        if (!task)
+            continue;
+        if (isBoundedArtifactContinuationWriter(task, input.parentSpec)) {
+            writerNodeIds.push(nodeId);
+            for (const pattern of task.writeSet ?? [])
+                writeSet.add(pattern);
+        }
+        if (hasDynamicRuntime(task)) {
+            dynamicNodeIds.push(nodeId);
+            for (const writer of collectDynamicWriterTemplates(task)) {
+                writerNodeIds.push(writer.id);
+                for (const pattern of writer.task.writeSet ?? [])
+                    writeSet.add(pattern);
+            }
+        }
+    }
+    const ledger = input.parentState.budgetLedger;
+    const hasHardBudget = (input.parentSpec.budget?.mode ?? input.parentState.budget?.mode) === "hard";
+    const highRisk = writerNodeIds.length > 0 || dynamicNodeIds.length > 0 || hasHardBudget;
+    if (!highRisk || !input.workspaceFingerprint)
+        return undefined;
+    const normalizedWriters = [...new Set(writerNodeIds)].sort();
+    const normalizedWriteSet = [...writeSet].sort();
+    const normalizedDynamic = [...new Set(dynamicNodeIds)].sort();
+    return {
+        schemaVersion: 1,
+        workspaceFingerprint: input.workspaceFingerprint,
+        ...(normalizedWriters.length > 0
+            ? {
+                writer: {
+                    nodeIds: normalizedWriters,
+                    writeSet: normalizedWriteSet,
+                    writeSetSha256: hashCanonicalValue(normalizedWriteSet),
+                },
+            }
+            : {}),
+        ...(normalizedDynamic.length > 0
+            ? {
+                dynamic: {
+                    nodeIds: normalizedDynamic,
+                    graphSha256: hashCanonicalValue(normalizedDynamic.map((nodeId) => tasks.get(nodeId))),
+                },
+            }
+            : {}),
+        ...(hasHardBudget && ledger
+            ? {
+                budget: {
+                    parentLedgerSha256: hashCanonicalValue(ledger),
+                    inheritedConsumed: structuredClone(ledger.consumed),
+                },
+            }
+            : {}),
+    };
+}
+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");
+    }
+    const hardBudget = (input.parentSpec.budget?.mode ?? input.parentState.budget?.mode) === "hard";
+    if (hardBudget) {
+        const ledger = input.parentState.budgetLedger;
+        if (!ledger) {
+            block("budget-lineage-missing");
+        }
+        else if (ledger.status === "breached" || ledger.breaches.length > 0) {
+            block("budget-lineage-breached");
+        }
+        else if (ledger.mode !== "hard" ||
+            JSON.stringify(ledger.limits) !==
+                JSON.stringify(input.parentSpec.budget?.limits ?? input.parentState.budget?.limits)) {
+            block("budget-lineage-drift");
+        }
+    }
+    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,
+        artifactContinuation: true,
+    });
+    for (const entry of closureSafety.blockingNodes) {
+        blockingNodes.push(entry);
+        block("ARTIFACT_IMPACT_UNSAFE");
+    }
+    for (const nodeId of importedNodeIds) {
+        const importedTask = taskById(input.parentSpec).get(nodeId);
+        if (importedTask?.decisionGate?.enabled) {
+            const code = "restart-subgraph-contains-decision-gate";
+            blockingNodes.push({ nodeId, reasonCode: code });
+            block(code);
+        }
+        const status = input.parentState.nodes[nodeId]?.status;
+        if (status !== "FINISHED" && status !== "SKIPPED") {
+            block("parent-facts-invalid", nodeId);
+        }
+    }
+    const highRiskAuthority = collectHighRiskContinuationAuthority({
+        parentSpec: input.parentSpec,
+        parentState: input.parentState,
+        affectedNodeIds,
+        workspaceFingerprint: input.parentTerminalWorkspaceFingerprint,
+    });
+    const highRiskExpected = affectedNodeIds.some((nodeId) => {
+        const task = taskById(input.parentSpec).get(nodeId);
+        return Boolean(task && (isWriterTask(task, input.parentSpec) || hasDynamicRuntime(task)));
+    }) || hardBudget;
+    if (highRiskExpected) {
+        if (!input.parentTerminalWorkspaceFingerprint ||
+            !input.currentWorkspaceFingerprint) {
+            block("workspace-checkpoint-missing");
+        }
+        else if (input.parentTerminalWorkspaceFingerprint !==
+            input.currentWorkspaceFingerprint) {
+            block("workspace-drift");
+        }
+        else if (!highRiskAuthority) {
+            block("HIGH_RISK_AUTHORITY_MISSING");
+        }
+    }
+    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,
+            ...(input.parentTerminalWorkspaceFingerprint
+                ? { parentWorkspaceFingerprint: input.parentTerminalWorkspaceFingerprint }
+                : {}),
+            ...(input.currentWorkspaceFingerprint
+                ? { currentWorkspaceFingerprint: input.currentWorkspaceFingerprint }
+                : {}),
+            ...(highRiskAuthority?.budget
+                ? { budgetLedgerSha256: highRiskAuthority.budget.parentLedgerSha256 }
+                : {}),
+        },
+        ...(shellNodeIds.length > 0
+            ? { verificationPolicy: { mode: "rerun", nodeIds: shellNodeIds } }
+            : {}),
+        workerAssociation,
+        ...(authority ? { workerContinuationAuthority: authority } : {}),
+        ...(highRiskAuthority ? { highRiskAuthority } : {}),
+        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)