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

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)