@tea-agent/loop-agent 0.20.1-beta.0 → 0.21.0

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

@@ -0,0 +1,611 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { getTaskPaths } from "../../task/runtime.js";
+import { assertTaskContractBindingFresh } from "./task-contract-binding.js";
+import { isSafeReadOnlyPiRetryCandidate } from "./retry-policy.js";
+const REVIEW_VERDICT_RECOVERY_NODE_ID = "review-verdict-recovery-pi";
+const SAFE_SHELL_GATE_KEYS = [
+    "verdictGate",
+    "jsonArtifactGate",
+    "requirementCoverageGate",
+    "repairArtifactGate",
+];
+function taskById(spec) {
+    return new Map(spec.tasks.map((task) => [task.id, task]));
+}
+function buildChildrenByParent(spec) {
+    const childrenByParent = new Map();
+    for (const task of spec.tasks) {
+        for (const parent of task.depends_on) {
+            const children = childrenByParent.get(parent) ?? [];
+            children.push(task.id);
+            childrenByParent.set(parent, children);
+        }
+    }
+    return childrenByParent;
+}
+function collectReachableDescendants(spec, rootNodeId) {
+    const childrenByParent = buildChildrenByParent(spec);
+    const descendants = [];
+    const queue = [...(childrenByParent.get(rootNodeId) ?? [])];
+    const seen = new Set();
+    while (queue.length > 0) {
+        const nodeId = queue.shift();
+        if (seen.has(nodeId))
+            continue;
+        seen.add(nodeId);
+        descendants.push(nodeId);
+        queue.push(...(childrenByParent.get(nodeId) ?? []));
+    }
+    return descendants.sort();
+}
+function isUpstreamOf(spec, ancestorId, nodeId) {
+    if (ancestorId === nodeId)
+        return true;
+    const tasks = taskById(spec);
+    const visited = new Set();
+    let frontier = [nodeId];
+    while (frontier.length > 0) {
+        const next = [];
+        for (const id of frontier) {
+            const task = tasks.get(id);
+            if (!task)
+                continue;
+            for (const dep of task.depends_on) {
+                if (dep === ancestorId)
+                    return true;
+                if (!visited.has(dep)) {
+                    visited.add(dep);
+                    next.push(dep);
+                }
+            }
+        }
+        frontier = next;
+    }
+    return false;
+}
+function preferVerdictGateEffectiveNode(spec, fromNodeId, selectedNodeId) {
+    const ids = new Set(spec.tasks.map((task) => task.id));
+    if (!ids.has(REVIEW_VERDICT_RECOVERY_NODE_ID)) {
+        return fromNodeId;
+    }
+    const recoveryId = REVIEW_VERDICT_RECOVERY_NODE_ID;
+    if (isUpstreamOf(spec, recoveryId, selectedNodeId) &&
+        (recoveryId === fromNodeId || isUpstreamOf(spec, fromNodeId, recoveryId))) {
+        return recoveryId;
+    }
+    return fromNodeId;
+}
+function findNearestUpstreamErrorNodeIds(spec, state, nodeId) {
+    const tasks = taskById(spec);
+    const visited = new Set();
+    let frontier = [nodeId];
+    while (frontier.length > 0) {
+        const nextFrontier = [];
+        const errorsAtLevel = [];
+        for (const id of frontier) {
+            const task = tasks.get(id);
+            if (!task)
+                continue;
+            for (const dep of task.depends_on) {
+                if (visited.has(dep))
+                    continue;
+                visited.add(dep);
+                const status = state?.nodes[dep]?.status;
+                if (status === "ERROR") {
+                    errorsAtLevel.push(dep);
+                }
+                else {
+                    nextFrontier.push(dep);
+                }
+            }
+        }
+        if (errorsAtLevel.length > 0) {
+            return [...new Set(errorsAtLevel)].sort();
+        }
+        frontier = nextFrontier;
+    }
+    return [];
+}
+function resolveWritePolicy(task, spec) {
+    return task.writePolicy ?? spec.defaults?.writePolicy;
+}
+function isWriterTask(task, spec) {
+    if (task.toolProfile === "write")
+        return true;
+    const writePolicy = resolveWritePolicy(task, spec);
+    return writePolicy === "exclusive" || writePolicy === "docs-only";
+}
+function hasDynamicRuntime(task) {
+    return Boolean(task.dynamicExpansion ||
+        task.dynamicReduction ||
+        task.dynamicCondition ||
+        task.dynamicLoopUntil);
+}
+function shellHasDisallowedConfig(shell) {
+    if ((shell.commands?.length ?? 0) > 0)
+        return true;
+    if (shell.preset)
+        return true;
+    if (shell.projectGovernanceGate)
+        return true;
+    if (shell.frontendPrewriteGate)
+        return true;
+    if (shell.frontendVerificationBundle)
+        return true;
+    if (shell.frontendReviewContext)
+        return true;
+    if (shell.backendTestPipeline)
+        return true;
+    if (shell.verifyEvidence)
+        return true;
+    if (shell.nonZeroExitPolicy)
+        return true;
+    if (shell.envAllowlist?.length)
+        return true;
+    if (shell.timeoutMs !== undefined)
+        return true;
+    if (shell.cwd)
+        return true;
+    return false;
+}
+function isSafeGateOnlyShell(task) {
+    if (task.executor !== "shell")
+        return false;
+    const shell = task.shell;
+    if (!shell)
+        return false;
+    if (shellHasDisallowedConfig(shell))
+        return false;
+    return SAFE_SHELL_GATE_KEYS.some((key) => shell[key] !== undefined);
+}
+function isStaticTask(task) {
+    return task.executor === "static";
+}
+function isConditionSkip(node, skippedReason) {
+    if (node !== "SKIPPED")
+        return false;
+    if (!skippedReason)
+        return false;
+    return (skippedReason.includes("condition") ||
+        skippedReason.includes("runIf") ||
+        skippedReason.includes("run-if"));
+}
+function sortKeysDeep(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sortKeysDeep(item));
+    }
+    if (value !== null && typeof value === "object") {
+        const record = value;
+        const sorted = {};
+        for (const key of Object.keys(record).sort()) {
+            sorted[key] = sortKeysDeep(record[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+export function rewriteEffectiveFromNode(spec, selectedNodeId, state) {
+    const tasks = taskById(spec);
+    const selected = tasks.get(selectedNodeId);
+    if (!selected) {
+        return {
+            rewriteApplied: false,
+            reasonCodes: ["selected-node-missing"],
+        };
+    }
+    if (selected.executor === "shell") {
+        const shell = selected.shell;
+        if (shell?.verdictGate?.fromNodeId) {
+            const effective = preferVerdictGateEffectiveNode(spec, shell.verdictGate.fromNodeId, selectedNodeId);
+            return {
+                effectiveFromNodeId: effective,
+                rewriteApplied: effective !== selectedNodeId,
+                reasonCodes: [],
+            };
+        }
+        if (shell?.repairArtifactGate?.fromNodeId) {
+            const effective = shell.repairArtifactGate.fromNodeId;
+            return {
+                effectiveFromNodeId: effective,
+                rewriteApplied: effective !== selectedNodeId,
+                reasonCodes: [],
+            };
+        }
+        if (shell?.jsonArtifactGate?.fromNodeId) {
+            const effective = shell.jsonArtifactGate.fromNodeId;
+            return {
+                effectiveFromNodeId: effective,
+                rewriteApplied: effective !== selectedNodeId,
+                reasonCodes: [],
+            };
+        }
+    }
+    const selectedStatus = state?.nodes[selectedNodeId]?.status;
+    if (selectedStatus === "SKIPPED") {
+        const upstreamErrors = findNearestUpstreamErrorNodeIds(spec, state, selectedNodeId);
+        if (upstreamErrors.length === 1) {
+            const effective = upstreamErrors[0];
+            return {
+                effectiveFromNodeId: effective,
+                rewriteApplied: effective !== selectedNodeId,
+                reasonCodes: [],
+            };
+        }
+        if (upstreamErrors.length > 1) {
+            return {
+                rewriteApplied: false,
+                reasonCodes: ["ambiguous-skipped-rewrite"],
+            };
+        }
+        return {
+            rewriteApplied: false,
+            reasonCodes: ["skipped-without-upstream-error"],
+        };
+    }
+    return {
+        effectiveFromNodeId: selectedNodeId,
+        rewriteApplied: false,
+        reasonCodes: [],
+    };
+}
+export function computeResetClosure(spec, effectiveFromNodeId) {
+    const tasks = taskById(spec);
+    if (!tasks.has(effectiveFromNodeId)) {
+        return [];
+    }
+    return [effectiveFromNodeId, ...collectReachableDescendants(spec, effectiveFromNodeId)].sort();
+}
+export function assessResetClosureSafety(spec, resetNodeIds) {
+    const tasks = taskById(spec);
+    const blockingNodes = [];
+    const reasonCodes = [];
+    for (const nodeId of resetNodeIds) {
+        const task = tasks.get(nodeId);
+        if (!task)
+            continue;
+        if (isWriterTask(task, spec)) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "restart-subgraph-contains-writer",
+            });
+            reasonCodes.push("restart-subgraph-contains-writer");
+            continue;
+        }
+        if (task.decisionGate?.enabled) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "restart-subgraph-contains-decision-gate",
+            });
+            reasonCodes.push("restart-subgraph-contains-decision-gate");
+            continue;
+        }
+        if (hasDynamicRuntime(task)) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "dynamic-rerun-unsupported",
+            });
+            reasonCodes.push("dynamic-rerun-unsupported");
+            continue;
+        }
+        if (task.executor === "pi") {
+            if (!isSafeReadOnlyPiRetryCandidate(task)) {
+                blockingNodes.push({
+                    nodeId,
+                    reasonCode: "restart-subgraph-contains-writer",
+                });
+                reasonCodes.push("restart-subgraph-contains-writer");
+            }
+            continue;
+        }
+        if (isStaticTask(task)) {
+            continue;
+        }
+        if (task.executor === "shell") {
+            if (!isSafeGateOnlyShell(task)) {
+                blockingNodes.push({
+                    nodeId,
+                    reasonCode: "restart-subgraph-contains-unsafe-shell",
+                });
+                reasonCodes.push("restart-subgraph-contains-unsafe-shell");
+            }
+        }
+    }
+    return {
+        safe: blockingNodes.length === 0,
+        blockingNodes,
+        reasonCodes: [...new Set(reasonCodes)],
+    };
+}
+export function computePlanHash(planWithoutHash) {
+    const canonical = JSON.stringify(sortKeysDeep(planWithoutHash));
+    return createHash("sha256").update(canonical, "utf8").digest("hex");
+}
+function countExecutorNodes(spec, nodeIds, executor) {
+    const tasks = taskById(spec);
+    return nodeIds.filter((nodeId) => tasks.get(nodeId)?.executor === executor)
+        .length;
+}
+function computeVerificationPolicy(spec, parentRunId, resetNodeIds, importedNodeIds) {
+    const tasks = taskById(spec);
+    const shellNodeIds = [...resetNodeIds, ...importedNodeIds].filter((nodeId) => tasks.get(nodeId)?.executor === "shell");
+    if (shellNodeIds.length === 0)
+        return undefined;
+    const rerunShellIds = resetNodeIds.filter((nodeId) => tasks.get(nodeId)?.executor === "shell");
+    const importedShellIds = importedNodeIds.filter((nodeId) => tasks.get(nodeId)?.executor === "shell");
+    if (rerunShellIds.length > 0 && importedShellIds.length > 0) {
+        return {
+            mode: "rerun",
+            nodeIds: shellNodeIds.sort(),
+            inheritedFromRunId: parentRunId,
+        };
+    }
+    if (rerunShellIds.length > 0) {
+        return {
+            mode: "rerun",
+            nodeIds: rerunShellIds.sort(),
+        };
+    }
+    return {
+        mode: "inherited",
+        nodeIds: importedShellIds.sort(),
+        inheritedFromRunId: parentRunId,
+    };
+}
+function deriveSuggestedAction(input) {
+    if (input.eligible)
+        return "dag-rerun";
+    if (input.workerManaged || input.reasonCodes.includes("worker-managed-rerun-unsupported")) {
+        return "worker-task-retry";
+    }
+    if (input.parentLifecycle === "paused")
+        return "resume";
+    if (input.reasonCodes.includes("binding-drift") ||
+        input.reasonCodes.includes("controller-drift") ||
+        input.reasonCodes.includes("skill-snapshot-invalid")) {
+        return "regenerate";
+    }
+    if (input.reasonCodes.includes("restart-subgraph-contains-writer") ||
+        input.reasonCodes.includes("restart-subgraph-contains-unsafe-shell") ||
+        input.reasonCodes.includes("workspace-drift") ||
+        input.reasonCodes.includes("workspace-checkpoint-missing") ||
+        input.reasonCodes.includes("unresolved-errors-outside-reset-closure") ||
+        input.reasonCodes.includes("convergence-rerun-unsupported") ||
+        input.reasonCodes.includes("evaluation-rerun-unsupported") ||
+        input.reasonCodes.includes("budget-rerun-unsupported")) {
+        return "standalone-task-rerun";
+    }
+    if (input.reasonCodes.includes("restart-subgraph-contains-decision-gate")) {
+        return "resume";
+    }
+    if (input.reasonCodes.includes("parent-lifecycle-ineligible")) {
+        if (input.parentLifecycle === "active")
+            return "reconcile";
+        return "manual";
+    }
+    return "manual";
+}
+function deriveRisk(reasonCodes, resetCount) {
+    if (reasonCodes.includes("restart-subgraph-contains-writer") ||
+        reasonCodes.includes("restart-subgraph-contains-unsafe-shell") ||
+        reasonCodes.includes("dynamic-rerun-unsupported")) {
+        return "high";
+    }
+    if (resetCount <= 2)
+        return "low";
+    if (resetCount <= 5)
+        return "medium";
+    return "high";
+}
+export async function evaluateLiveDagRerunBindings(input) {
+    const sourceBinding = input.parentSpec.sourceBinding;
+    let sourceBindingMatched = true;
+    if (sourceBinding) {
+        try {
+            const taskPaths = getTaskPaths(input.cwd, sourceBinding.taskId);
+            for (const source of sourceBinding.sources) {
+                const sourcePath = path.resolve(taskPaths.taskDir, source.path);
+                const sourceRoot = path.resolve(taskPaths.sourceDir);
+                if (sourcePath !== sourceRoot &&
+                    !sourcePath.startsWith(`${sourceRoot}${path.sep}`)) {
+                    sourceBindingMatched = false;
+                    break;
+                }
+                const bytes = await readFile(sourcePath);
+                if (createHash("sha256").update(bytes).digest("hex") !== source.sha256) {
+                    sourceBindingMatched = false;
+                    break;
+                }
+            }
+        }
+        catch {
+            sourceBindingMatched = false;
+        }
+    }
+    const taskContract = await assertTaskContractBindingFresh({
+        repoRoot: input.cwd,
+        spec: input.parentSpec,
+        action: "dag rerun",
+    });
+    return {
+        sourceBindingMatched,
+        taskContractBindingMatched: taskContract.ok,
+    };
+}
+export async function evaluateDagRerunPlan(input) {
+    void input.cwd;
+    void input.parentRunDir;
+    const reasonCodes = [];
+    const blockedReasons = [];
+    const blockingNodes = [];
+    const allNodeIds = input.parentSpec.tasks.map((task) => task.id).sort();
+    const rewrite = rewriteEffectiveFromNode(input.parentSpec, input.selectedNodeId, input.parentState);
+    reasonCodes.push(...rewrite.reasonCodes);
+    const effectiveFromNodeId = rewrite.effectiveFromNodeId;
+    const resetNodeIds = effectiveFromNodeId !== undefined
+        ? computeResetClosure(input.parentSpec, effectiveFromNodeId)
+        : [];
+    const resetSet = new Set(resetNodeIds);
+    const importedNodeIds = allNodeIds.filter((nodeId) => !resetSet.has(nodeId));
+    const controllerIdentityMatched = input.currentControllerFingerprint === undefined ||
+        input.parentControllerFingerprint === undefined ||
+        input.currentControllerFingerprint === input.parentControllerFingerprint;
+    const workspaceMatched = input.parentTerminalWorkspace?.fingerprint !== undefined &&
+        input.currentWorkspace?.fingerprint !== undefined &&
+        input.parentTerminalWorkspace.fingerprint === input.currentWorkspace.fingerprint;
+    const skillSnapshotVerified = input.skillSnapshotOk !== false;
+    const sourceBindingMatched = input.bindingStatus?.sourceBindingMatched ?? true;
+    const taskContractBindingMatched = input.bindingStatus?.taskContractBindingMatched ?? true;
+    const bindings = {
+        sourceBindingMatched,
+        taskContractBindingMatched,
+        controllerIdentityMatched,
+        skillSnapshotVerified,
+        workspaceMatched,
+    };
+    if (!sourceBindingMatched || !taskContractBindingMatched) {
+        reasonCodes.push("binding-drift");
+        blockedReasons.push("binding-drift");
+    }
+    if (input.workerManaged) {
+        reasonCodes.push("worker-managed-rerun-unsupported");
+        blockedReasons.push("worker-managed-rerun-unsupported");
+    }
+    if (input.parentLifecycle !== "completed") {
+        reasonCodes.push("parent-lifecycle-ineligible");
+        blockedReasons.push("parent-lifecycle-ineligible");
+    }
+    else if (input.parentState.status !== "failed" &&
+        input.parentState.status !== "partial_failed") {
+        reasonCodes.push("parent-lifecycle-ineligible");
+        blockedReasons.push("parent-lifecycle-ineligible");
+    }
+    if (input.parentSpec.convergence?.enabled) {
+        reasonCodes.push("convergence-rerun-unsupported");
+        blockedReasons.push("convergence-rerun-unsupported");
+    }
+    if (input.parentState.convergence?.enabled) {
+        reasonCodes.push("convergence-rerun-unsupported");
+        blockedReasons.push("convergence-rerun-unsupported");
+    }
+    if (input.parentSpec.evaluation || input.parentState.evaluation) {
+        reasonCodes.push("evaluation-rerun-unsupported");
+        blockedReasons.push("evaluation-rerun-unsupported");
+    }
+    const budgetMode = input.parentSpec.budget?.mode ?? input.parentState.budget?.mode;
+    if (budgetMode === "hard") {
+        reasonCodes.push("budget-rerun-unsupported");
+        blockedReasons.push("budget-rerun-unsupported");
+    }
+    if (!input.parentTerminalWorkspace?.fingerprint) {
+        reasonCodes.push("workspace-checkpoint-missing");
+        blockedReasons.push("workspace-checkpoint-missing");
+    }
+    else if (input.currentWorkspace?.fingerprint &&
+        input.parentTerminalWorkspace.fingerprint !== input.currentWorkspace.fingerprint) {
+        reasonCodes.push("workspace-drift");
+        blockedReasons.push("workspace-drift");
+    }
+    else if (!input.currentWorkspace?.fingerprint) {
+        reasonCodes.push("workspace-checkpoint-missing");
+        blockedReasons.push("workspace-checkpoint-missing");
+    }
+    if (!controllerIdentityMatched) {
+        reasonCodes.push("controller-drift");
+        blockedReasons.push("controller-drift");
+    }
+    if (input.skillSnapshotOk === false) {
+        reasonCodes.push("skill-snapshot-invalid");
+        blockedReasons.push("skill-snapshot-invalid");
+    }
+    if (effectiveFromNodeId === undefined || resetNodeIds.length === 0) {
+        if (!reasonCodes.includes("ambiguous-skipped-rewrite")) {
+            reasonCodes.push("selected-node-missing");
+            blockedReasons.push("selected-node-missing");
+        }
+        else {
+            blockedReasons.push("ambiguous-skipped-rewrite");
+        }
+    }
+    const closureSafety = assessResetClosureSafety(input.parentSpec, resetNodeIds);
+    blockingNodes.push(...closureSafety.blockingNodes);
+    for (const code of closureSafety.reasonCodes) {
+        reasonCodes.push(code);
+        blockedReasons.push(code);
+    }
+    for (const [nodeId, record] of Object.entries(input.parentState.nodes)) {
+        if (record.status === "ERROR" && !resetSet.has(nodeId)) {
+            reasonCodes.push("unresolved-errors-outside-reset-closure");
+            blockedReasons.push("unresolved-errors-outside-reset-closure");
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "unresolved-errors-outside-reset-closure",
+            });
+        }
+    }
+    for (const nodeId of importedNodeIds) {
+        const record = input.parentState.nodes[nodeId];
+        if (!record)
+            continue;
+        if (record.status === "ERROR") {
+            reasonCodes.push("parent-facts-invalid");
+            blockedReasons.push("parent-facts-invalid");
+            blockingNodes.push({ nodeId, reasonCode: "parent-facts-invalid" });
+            continue;
+        }
+        if (record.status === "SKIPPED" &&
+            !isConditionSkip(record.status, record.skippedReason)) {
+            reasonCodes.push("parent-facts-invalid");
+            blockedReasons.push("parent-facts-invalid");
+            blockingNodes.push({ nodeId, reasonCode: "parent-facts-invalid" });
+        }
+    }
+    const uniqueReasonCodes = [...new Set(reasonCodes)];
+    const uniqueBlockedReasons = [...new Set(blockedReasons)];
+    const eligible = uniqueBlockedReasons.length === 0 &&
+        effectiveFromNodeId !== undefined &&
+        resetNodeIds.length > 0 &&
+        closureSafety.safe;
+    const totalPi = countExecutorNodes(input.parentSpec, allNodeIds, "pi");
+    const resetPi = countExecutorNodes(input.parentSpec, resetNodeIds, "pi");
+    const resetShell = countExecutorNodes(input.parentSpec, resetNodeIds, "shell");
+    const workerAssociation = input.workerAssociation ?? (input.workerManaged
+        ? { kind: "worker-managed" }
+        : { kind: "standalone" });
+    const planWithoutHash = {
+        schemaVersion: 1,
+        eligible,
+        parentRunId: input.parentRunId,
+        parentLifecycle: "completed",
+        selectedNodeId: input.selectedNodeId,
+        effectiveFromNodeId,
+        rewriteApplied: rewrite.rewriteApplied,
+        resetNodeIds,
+        importedNodeIds,
+        blockingNodes,
+        reasonCodes: uniqueReasonCodes,
+        blockedReasons: uniqueBlockedReasons,
+        risk: deriveRisk(uniqueReasonCodes, resetNodeIds.length),
+        bindings,
+        verificationPolicy: computeVerificationPolicy(input.parentSpec, input.parentRunId, resetNodeIds, importedNodeIds),
+        workerAssociation,
+        estimatedExecution: {
+            nodeCount: resetNodeIds.length,
+            piCallCount: resetPi,
+            shellNodeCount: resetShell,
+            avoidedNodeCount: allNodeIds.length - resetNodeIds.length,
+            avoidedPiCallCount: totalPi - resetPi,
+        },
+        suggestedAction: deriveSuggestedAction({
+            eligible,
+            reasonCodes: uniqueReasonCodes,
+            parentLifecycle: input.parentLifecycle,
+            workerManaged: input.workerManaged,
+        }),
+    };
+    return {
+        ...planWithoutHash,
+        planHash: computePlanHash(planWithoutHash),
+    };
+}