@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/workflows/dag/validate.js

@@ -0,0 +1,998 @@
+import { DEFAULT_DAG_EXECUTOR_MODELS, ENV_VAR_NAME_PATTERN, dagCommandPolicyAllows, resolveDagCommandPolicy, } from "./types.js";
+import { resolveShellCommands } from "../../executors/shell-executor.js";
+import { pathMatchesPattern } from "../../shared/git-progress.js";
+import { resolveRepairTaskForGate } from "./repair-artifact.js";
+import { topoSortToRanks } from "./topo.js";
+import { isSafeReadOnlyPiRetryCandidate, isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "./retry-policy.js";
+import { isBackendTestCompletenessRetryCandidate } from "./backend-test-writer-completeness.js";
+const GOVERNANCE_WARNING_TYPES = new Set([
+    "read-only-missing-artifacts-forbidden",
+    "read-only-prompt-mentions-artifact-writes",
+    "shell-dag-active-check-repo-without-env",
+    "shell-verdict-gate-summary-md-source",
+    "shell-verdict-gate-grep-pattern",
+    "shell-verdict-gate-multi-command-state",
+    "shell-verdict-gate-handwritten-inline",
+    "orphan-writer-source-binding",
+    "advisory",
+]);
+const ROOT_ARTIFACT_PATH_PROBES = [
+    "artifacts/修改记录.md",
+    "artifacts/验证结果.md",
+    "artifacts/_probe_.md",
+];
+const ARTIFACT_WRITE_SIGNAL_PATTERNS = [
+    "artifacts/",
+    "修改记录.md",
+    "验证结果.md",
+];
+function isGovernanceWarning(issue) {
+    return GOVERNANCE_WARNING_TYPES.has(issue.type);
+}
+export function collectGovernanceWarnings(issues) {
+    return issues.filter(isGovernanceWarning);
+}
+function collectBlockingIssues(issues, options = {}) {
+    const nonAdvisory = issues.filter((issue) => issue.type !== "advisory");
+    if (options.strictGovernance) {
+        return nonAdvisory;
+    }
+    return nonAdvisory.filter((issue) => !isGovernanceWarning(issue));
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function probePathsForWriteSetEntry(entry) {
+    const normalized = normalizePath(entry);
+    if (!normalized.includes("*")) {
+        return [normalized];
+    }
+    const concrete = normalized
+        .replace(/\/\*\*$/, "/_probe_")
+        .replace(/\*\*$/, "_probe_")
+        .replace(/\*/g, "_");
+    return Array.from(new Set([normalized, concrete]));
+}
+function writeSetEntryWithinAllowed(entry, allowedPaths) {
+    const probes = probePathsForWriteSetEntry(entry);
+    return probes.some((probe) => allowedPaths.some((allowed) => pathMatchesPattern(probe, allowed)));
+}
+function writeSetEntryHitsForbidden(entry, forbiddenPaths) {
+    const probes = probePathsForWriteSetEntry(entry);
+    return probes.some((probe) => forbiddenPaths.some((forbidden) => pathMatchesPattern(probe, forbidden)));
+}
+function forbiddenPathsExcludeRootArtifacts(forbiddenPaths) {
+    return ROOT_ARTIFACT_PATH_PROBES.some((probe) => forbiddenPaths.some((forbidden) => pathMatchesPattern(probe, forbidden)));
+}
+function promptMentionsRootArtifactWrite(prompt) {
+    const lower = prompt.toLowerCase();
+    for (const signal of ARTIFACT_WRITE_SIGNAL_PATTERNS) {
+        const normalizedSignal = signal.toLowerCase();
+        const index = lower.indexOf(normalizedSignal);
+        if (index === -1)
+            continue;
+        const context = lower.slice(Math.max(0, index - 48), index + 96);
+        const negated = /(do not|don't|must not|should not|禁止|不得|不要|不应).{0,48}(write|edit|modify|create|update|artifacts|修改记录|验证结果)/i.test(context) ||
+            /不(改|写|更新|创建|编辑).{0,48}(artifacts|修改记录|验证结果)/i.test(context);
+        if (negated)
+            continue;
+        const hasWriteVerb = /(write|update|create|edit|modify|save|append|record|output).{0,64}(artifacts|修改记录|验证结果)/i.test(context) ||
+            /(artifacts|修改记录|验证结果).{0,64}(write|update|create|edit|modify|save|append|record|output)/i.test(context) ||
+            /(写入|写|更新|修改|保存|追加|记录|输出).{0,64}(artifacts|修改记录|验证结果)/i.test(context) ||
+            /(artifacts|修改记录|验证结果).{0,64}(写入|写|更新|修改|保存|追加|记录|输出)/i.test(context);
+        if (hasWriteVerb) {
+            return signal;
+        }
+    }
+    return undefined;
+}
+function shellCommandRunsCheckRepo(command) {
+    return /(^|[\s/])check-repo\.sh(\s|$)|(^|\s)bash\s+scripts\/check-repo\.sh(\s|$)/.test(command);
+}
+function shellCommandSetsActiveDagEnv(command) {
+    return /(^|[^A-Za-z0-9_])HARNESS_ALLOW_ACTIVE_DAG_RUNS=1(\s|;|&&|$)/.test(command);
+}
+function shellCommandUsesSummaryMdVerdictSource(command) {
+    return (/result\.summary\.md/.test(command) &&
+        (/\bVERDICT\b/i.test(command) ||
+            /\.harness\/dag-runs\/active/.test(command) ||
+            /\bgate\b/i.test(command)));
+}
+function shellCommandUsesGrepVerdictSearch(command) {
+    return (/\bgrep\b/.test(command) &&
+        (/\bVERDICT\b/.test(command) || /grep.*VERDICT|VERDICT.*grep/.test(command)));
+}
+function shellCommandReadsActiveOrCurrentRunJson(command) {
+    return (/\.harness\/dag-runs\/active/.test(command) ||
+        /\bHARNESS_DAG_RUN_DIR\b/.test(command) ||
+        /find\s+\.harness\/dag-runs\/active/.test(command));
+}
+function shellCommandUsesVerdictJsonParser(command) {
+    return (/assistantText\s*\?\?\s*raw\.stdout/.test(command) ||
+        /raw\.assistantText\s*\|\|\s*raw\.stdout/.test(command) ||
+        /raw\.assistantText\s*\?\?\s*raw\.stdout/.test(command) ||
+        /assistantText\s*\|\|\s*raw\.stdout/.test(command) ||
+        /assistantText\s*\|\|\s*stdout/.test(command));
+}
+function shellCommandLooksLikeHandWrittenVerdictGate(command) {
+    return (shellCommandReadsActiveOrCurrentRunJson(command) &&
+        (/\bVERDICT\b/i.test(command) ||
+            shellCommandUsesVerdictJsonParser(command)));
+}
+function shellCommandsLookLikeMultiCommandVerdictGate(commands) {
+    if (commands.length <= 1)
+        return false;
+    const combined = commands.join("\n");
+    return (shellCommandReadsActiveOrCurrentRunJson(combined) &&
+        (/\bVERDICT\b/i.test(combined) ||
+            shellCommandUsesVerdictJsonParser(combined)));
+}
+function validateVerdictGateConfig(task, spec, issues) {
+    const verdictGate = task.shell?.verdictGate;
+    if (!verdictGate) {
+        return;
+    }
+    if (task.executor !== "shell") {
+        issues.push({
+            type: "invalid-verdict-gate-config",
+            message: `task ${task.id} shell.verdictGate requires executor=shell`,
+        });
+        return;
+    }
+    const upstreamIds = new Set(task.depends_on);
+    const sourceNodeIds = [
+        verdictGate.fromNodeId,
+        ...(verdictGate.fallbackFromNodeIds ?? []),
+    ];
+    for (const sourceId of sourceNodeIds) {
+        if (!upstreamIds.has(sourceId)) {
+            issues.push({
+                type: "invalid-verdict-gate-config",
+                message: `task ${task.id} shell.verdictGate source "${sourceId}" must appear in depends_on`,
+            });
+        }
+        const upstreamTask = spec.tasks.find((candidate) => candidate.id === sourceId);
+        if (upstreamTask && upstreamTask.executor === "shell") {
+            issues.push({
+                type: "invalid-verdict-gate-config",
+                message: `task ${task.id} shell.verdictGate source "${sourceId}" must reference a non-shell upstream verdict node`,
+            });
+        }
+    }
+    for (const accepted of verdictGate.accept) {
+        if (accepted.trim().length === 0) {
+            issues.push({
+                type: "invalid-verdict-gate-config",
+                message: `task ${task.id} shell.verdictGate.accept entries must be non-empty`,
+            });
+            break;
+        }
+    }
+}
+function validateRepairArtifactGateConfig(task, spec, issues) {
+    const repairArtifactGate = task.shell?.repairArtifactGate;
+    if (!repairArtifactGate)
+        return;
+    if (task.executor !== "shell") {
+        issues.push({
+            type: "invalid-repair-artifact-gate-config",
+            message: `task ${task.id} shell.repairArtifactGate requires executor=shell`,
+        });
+        return;
+    }
+    const upstreamIds = new Set(task.depends_on);
+    if (!upstreamIds.has(repairArtifactGate.fromNodeId)) {
+        issues.push({
+            type: "invalid-repair-artifact-gate-config",
+            message: `task ${task.id} shell.repairArtifactGate.fromNodeId "${repairArtifactGate.fromNodeId}" must appear in depends_on`,
+        });
+    }
+    const upstream = spec.tasks.find((candidate) => candidate.id === repairArtifactGate.fromNodeId);
+    if (upstream && upstream.executor === "shell") {
+        issues.push({
+            type: "invalid-repair-artifact-gate-config",
+            message: `task ${task.id} shell.repairArtifactGate.fromNodeId "${repairArtifactGate.fromNodeId}" must reference a non-shell upstream artifact node`,
+        });
+    }
+    const resolution = resolveRepairTaskForGate({
+        tasks: spec.tasks,
+        gateTask: task,
+    });
+    if (!resolution.ok) {
+        issues.push({
+            type: "invalid-repair-artifact-gate-config",
+            message: `task ${task.id} ${resolution.reason}`,
+        });
+        return;
+    }
+    const hardVerifyCandidates = spec.tasks.filter((candidate) => candidate.depends_on.includes(resolution.repairTask.id) &&
+        candidate.executor === "shell" &&
+        candidate.role === "verifier" &&
+        candidate.shell?.verifyEvidence?.phase === "final" &&
+        candidate.shell.verifyEvidence.quota === "full" &&
+        candidate.shell.verifyEvidence.finalFullRequired === true);
+    if (hardVerifyCandidates.length !== 1) {
+        issues.push({
+            type: "invalid-repair-artifact-gate-config",
+            message: hardVerifyCandidates.length === 0
+                ? `task ${task.id} repair node "${resolution.repairTask.id}" must have one direct downstream final/full hard verification shell node with finalFullRequired=true`
+                : `task ${task.id} repair node "${resolution.repairTask.id}" has multiple hard verification shell nodes (${hardVerifyCandidates.map((candidate) => candidate.id).join(", ")})`,
+        });
+        return;
+    }
+    const hardVerify = hardVerifyCandidates[0];
+    const descendantIds = new Set();
+    const queue = [hardVerify.id];
+    while (queue.length > 0) {
+        const parentId = queue.shift();
+        for (const candidate of spec.tasks) {
+            if (candidate.depends_on.includes(parentId) &&
+                !descendantIds.has(candidate.id)) {
+                descendantIds.add(candidate.id);
+                queue.push(candidate.id);
+            }
+        }
+    }
+    const reviewCandidates = spec.tasks.filter((candidate) => descendantIds.has(candidate.id) &&
+        candidate.executor === "pi" &&
+        candidate.role === "reviewer" &&
+        !candidate.decisionGate?.enabled &&
+        candidate.writePolicy === "read-only" &&
+        ((candidate.outputContract?.includes("VERDICT:") ?? false) ||
+            candidate.outputProtocol?.type === "json-review-verdict") &&
+        // Format recovery / write-set format-repair nodes also emit VERDICT but
+        // are not the primary content review after hard verification.
+        !/(?:-format-repair-pi|-verdict-recovery-pi)$/.test(candidate.id));
+    if (reviewCandidates.length !== 1) {
+        issues.push({
+            type: "invalid-repair-artifact-gate-config",
+            message: reviewCandidates.length === 0
+                ? `task ${task.id} hard verification node "${hardVerify.id}" must reach one read-only Pi reviewer with a VERDICT or JSON review output contract`
+                : `task ${task.id} hard verification node "${hardVerify.id}" has multiple Pi reviewer nodes (${reviewCandidates.map((candidate) => candidate.id).join(", ")})`,
+        });
+    }
+}
+function validateRequirementCoverageGateConfig(task, spec, issues) {
+    const gate = task.shell?.requirementCoverageGate;
+    if (!gate)
+        return;
+    if (task.executor !== "shell") {
+        issues.push({ type: "invalid-requirement-coverage-gate-config", message: `task ${task.id} shell.requirementCoverageGate requires executor=shell` });
+        return;
+    }
+    if (gate.fallbackFromNodeIds?.length && gate.fromNodeIds.length !== 1) {
+        issues.push({
+            type: "invalid-requirement-coverage-gate-config",
+            message: `task ${task.id} shell.requirementCoverageGate with fallbackFromNodeIds requires exactly one fromNodeIds entry`,
+        });
+    }
+    const dependencyIds = new Set(task.depends_on);
+    const sourceNodeIds = [
+        ...gate.fromNodeIds,
+        ...(gate.fallbackFromNodeIds ?? []),
+    ];
+    for (const fromNodeId of new Set(sourceNodeIds)) {
+        if (!dependencyIds.has(fromNodeId)) {
+            issues.push({ type: "invalid-requirement-coverage-gate-config", message: `task ${task.id} shell.requirementCoverageGate source "${fromNodeId}" must appear in depends_on` });
+        }
+        const upstream = spec.tasks.find((candidate) => candidate.id === fromNodeId);
+        if (upstream?.executor === "shell") {
+            issues.push({ type: "invalid-requirement-coverage-gate-config", message: `task ${task.id} shell.requirementCoverageGate source "${fromNodeId}" must be a non-shell node` });
+        }
+    }
+}
+function validateShellVerdictGateGovernance(task, commands, issues) {
+    if (task.executor !== "shell") {
+        return;
+    }
+    const explicitCommands = (task.shell?.commands ?? []).filter((command) => command.trim().length > 0);
+    for (const command of commands) {
+        if (shellCommandUsesSummaryMdVerdictSource(command)) {
+            issues.push({
+                type: "shell-verdict-gate-summary-md-source",
+                message: `task ${task.id} shell command reads result.summary.md for verdict gating; use shell.verdictGate and canonical <fromNodeId>.json instead`,
+            });
+        }
+        if (shellCommandUsesGrepVerdictSearch(command)) {
+            issues.push({
+                type: "shell-verdict-gate-grep-pattern",
+                message: `task ${task.id} shell command uses grep-based VERDICT search; use shell.verdictGate with exact accept matching instead`,
+            });
+        }
+    }
+    if (shellCommandsLookLikeMultiCommandVerdictGate(explicitCommands)) {
+        issues.push({
+            type: "shell-verdict-gate-multi-command-state",
+            message: `task ${task.id} spreads verdict gate state across multiple shell.commands entries; use shell.verdictGate so the gate is a single command`,
+        });
+    }
+    if (!task.shell?.verdictGate &&
+        explicitCommands.some(shellCommandLooksLikeHandWrittenVerdictGate)) {
+        issues.push({
+            type: "shell-verdict-gate-handwritten-inline",
+            message: `task ${task.id} uses fragile inline verdict gate shell; prefer shell.verdictGate with fromNodeId and accept`,
+        });
+    }
+}
+function writeSetEntriesOverlap(a, b) {
+    if (pathMatchesPattern(a, b) || pathMatchesPattern(b, a)) {
+        return true;
+    }
+    const probesA = probePathsForWriteSetEntry(a);
+    const probesB = probePathsForWriteSetEntry(b);
+    return probesA.some((probeA) => probesB.some((probeB) => probeA === probeB ||
+        pathMatchesPattern(probeA, b) ||
+        pathMatchesPattern(probeB, a)));
+}
+function shouldValidateWritePolicy(spec, task) {
+    return (spec.version >= 2 ||
+        task.writePolicy !== undefined ||
+        task.writeSet !== undefined);
+}
+function resolveWritePolicy(task, spec) {
+    return task.writePolicy ?? spec.defaults?.writePolicy;
+}
+function validateTaskWritePolicy(task, spec, issues) {
+    if (!shouldValidateWritePolicy(spec, task)) {
+        return;
+    }
+    const writePolicy = resolveWritePolicy(task, spec);
+    const writeSet = task.writeSet ?? [];
+    const allowedPaths = task.allowedPaths ?? [];
+    const forbiddenPaths = task.forbiddenPaths ?? [];
+    if (writePolicy === "read-only") {
+        if (!forbiddenPathsExcludeRootArtifacts(forbiddenPaths)) {
+            issues.push({
+                type: "read-only-missing-artifacts-forbidden",
+                message: `task ${task.id} is read-only but forbiddenPaths does not exclude artifacts/**; root artifacts are not per-node scratchpads`,
+            });
+        }
+        const artifactWriteSignal = promptMentionsRootArtifactWrite(task.subtask_prompt);
+        if (artifactWriteSignal) {
+            issues.push({
+                type: "read-only-prompt-mentions-artifact-writes",
+                message: `task ${task.id} is read-only but subtask_prompt mentions root artifact write target "${artifactWriteSignal}"; return findings in node output instead`,
+            });
+        }
+    }
+    if (writePolicy === "exclusive" && writeSet.length === 0) {
+        issues.push({
+            type: "missing-write-set",
+            message: `task ${task.id} (exclusive) requires a non-empty writeSet`,
+        });
+        return;
+    }
+    if (writeSet.length === 0) {
+        return;
+    }
+    for (const entry of writeSet) {
+        const normalizedEntry = entry.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+        if (writePolicy === "exclusive" &&
+            (normalizedEntry === "**" ||
+                normalizedEntry === "./**" ||
+                normalizedEntry === "*")) {
+            issues.push({
+                type: "write-set-unbounded",
+                message: `task ${task.id} writeSet entry "${entry}" is unbounded; exclusive writers must use concrete paths or limited globs`,
+            });
+            continue;
+        }
+        if (forbiddenPaths.length > 0 &&
+            writeSetEntryHitsForbidden(entry, forbiddenPaths)) {
+            issues.push({
+                type: "write-set-forbidden",
+                message: `task ${task.id} writeSet entry "${entry}" matches forbiddenPaths`,
+            });
+            continue;
+        }
+        if (allowedPaths.length > 0 &&
+            !writeSetEntryWithinAllowed(entry, allowedPaths)) {
+            issues.push({
+                type: "write-set-out-of-scope",
+                message: `task ${task.id} writeSet entry "${entry}" is outside allowedPaths`,
+            });
+        }
+    }
+}
+function validateSameRankWriteSetConflicts(spec, ranks, issues) {
+    const taskById = new Map(spec.tasks.map((task) => [task.id, task]));
+    for (const rank of ranks) {
+        const exclusiveWriters = rank
+            .map((id) => taskById.get(id))
+            .filter((task) => {
+            if (!task)
+                return false;
+            if (!shouldValidateWritePolicy(spec, task))
+                return false;
+            return resolveWritePolicy(task, spec) === "exclusive";
+        });
+        for (let i = 0; i < exclusiveWriters.length; i += 1) {
+            for (let j = i + 1; j < exclusiveWriters.length; j += 1) {
+                const left = exclusiveWriters[i];
+                const right = exclusiveWriters[j];
+                const leftSet = left.writeSet ?? [];
+                const rightSet = right.writeSet ?? [];
+                for (const leftEntry of leftSet) {
+                    for (const rightEntry of rightSet) {
+                        if (writeSetEntriesOverlap(leftEntry, rightEntry)) {
+                            issues.push({
+                                type: "write-set-overlap",
+                                message: `tasks ${left.id} and ${right.id} have overlapping writeSet entries at same rank: "${leftEntry}" and "${rightEntry}"`,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+function isAgentTask(task) {
+    return task?.executor === "pi";
+}
+function validateSameRankAgentAttributionRisks(spec, ranks, issues) {
+    const taskById = new Map(spec.tasks.map((task) => [task.id, task]));
+    for (const rank of ranks) {
+        const agentTasks = rank.map((id) => taskById.get(id)).filter(isAgentTask);
+        const hasExclusiveWriter = agentTasks.some((task) => resolveWritePolicy(task, spec) === "exclusive");
+        if (!hasExclusiveWriter)
+            continue;
+        for (const task of agentTasks) {
+            const policy = resolveWritePolicy(task, spec) ?? "read-only";
+            if (policy === "read-only" || policy === "none") {
+                issues.push({
+                    type: "same-rank-writer-attribution-risk",
+                    message: `same rank mixes read-only ${task.executor} task ${task.id} with a write-capable agent; add depends_on or run serially to avoid write attribution risk`,
+                });
+            }
+        }
+    }
+}
+function validateShellTaskConfig(task, spec, issues) {
+    if (task.executor !== "shell") {
+        return;
+    }
+    const shell = task.shell;
+    if (!shell) {
+        issues.push({
+            type: "missing-shell-commands",
+            message: `shell task ${task.id} requires shell.preset, shell.verdictGate, and/or shell.commands`,
+        });
+        return;
+    }
+    const commands = resolveShellCommands(shell);
+    if (commands.length === 0 &&
+        !shell.jsonArtifactGate &&
+        !shell.backendTestPipeline &&
+        !shell.frontendPrewriteGate &&
+        !shell.frontendBrowserToolPreflight &&
+        !shell.frontendVerificationBundle &&
+        !shell.frontendReviewContext &&
+        !shell.frontendTestCaseChecklist &&
+        !shell.frontendTestEvidenceValidation &&
+        !shell.frontendTestL5Report &&
+        !shell.frontendTestHtmlReport &&
+        !shell.frontendTestCaseManifest &&
+        !shell.frontendTestResultFinalize &&
+        !shell.frontendTestReports) {
+        issues.push({
+            type: "missing-shell-commands",
+            message: `shell task ${task.id} requires a supported shell operation or non-empty shell.commands`,
+        });
+    }
+    if (commands.some((command) => command.trim().length === 0)) {
+        issues.push({
+            type: "missing-shell-commands",
+            message: `shell task ${task.id} requires non-empty shell command strings`,
+        });
+    }
+    const envAllowlist = shell.envAllowlist ?? [];
+    const runsRepoGovernance = commands.some(shellCommandRunsCheckRepo);
+    const hasActiveDagEnv = envAllowlist.includes("HARNESS_ALLOW_ACTIVE_DAG_RUNS") ||
+        commands.some(shellCommandSetsActiveDagEnv);
+    if (runsRepoGovernance && !hasActiveDagEnv) {
+        issues.push({
+            type: "shell-dag-active-check-repo-without-env",
+            message: `shell task ${task.id} runs check-repo.sh but does not set HARNESS_ALLOW_ACTIVE_DAG_RUNS=1; this can fail inside an active DAG`,
+        });
+    }
+    for (const envName of envAllowlist) {
+        if (!ENV_VAR_NAME_PATTERN.test(envName)) {
+            issues.push({
+                type: "invalid-shell-env",
+                message: `shell task ${task.id} envAllowlist entry "${envName}" is not a valid env var name`,
+            });
+        }
+    }
+    const timeoutMs = shell.timeoutMs;
+    if (timeoutMs !== undefined && !Number.isInteger(timeoutMs)) {
+        issues.push({
+            type: "invalid-shell-timeout",
+            message: `shell task ${task.id} timeoutMs must be an integer`,
+        });
+    }
+    const cwd = shell.cwd;
+    if (cwd &&
+        (cwd.startsWith("/") || normalizePath(cwd).split("/").includes(".."))) {
+        issues.push({
+            type: "shell-cwd-out-of-scope",
+            message: `shell task ${task.id} cwd must be relative to the DAG cwd and stay within it`,
+        });
+    }
+    validateVerdictGateConfig(task, spec, issues);
+    validateRequirementCoverageGateConfig(task, spec, issues);
+    if (shell.jsonArtifactGate) {
+        const sourceNodeIds = [
+            shell.jsonArtifactGate.fromNodeId,
+            ...(shell.jsonArtifactGate.fallbackFromNodeIds ?? []),
+        ];
+        for (const sourceNodeId of new Set(sourceNodeIds)) {
+            if (!task.depends_on.includes(sourceNodeId)) {
+                issues.push({
+                    type: "missing-dependency",
+                    message: `shell task ${task.id} jsonArtifactGate source ${sourceNodeId} must be a direct dependency`,
+                });
+            }
+        }
+    }
+    if (shell.frontendPrewriteGate) {
+        const sourceNodeIds = [
+            shell.frontendPrewriteGate.planFromNodeId,
+            ...shell.frontendPrewriteGate.planFallbackFromNodeIds,
+            shell.frontendPrewriteGate.reviewFromNodeId,
+            ...shell.frontendPrewriteGate.reviewFallbackFromNodeIds,
+        ];
+        for (const sourceNodeId of new Set(sourceNodeIds)) {
+            if (!task.depends_on.includes(sourceNodeId)) {
+                issues.push({
+                    type: "missing-dependency",
+                    message: `shell task ${task.id} frontendPrewriteGate source ${sourceNodeId} must be a direct dependency`,
+                });
+            }
+        }
+    }
+    validateRepairArtifactGateConfig(task, spec, issues);
+    validateShellVerdictGateGovernance(task, commands, issues);
+}
+function hasReadOnlyPlannerAncestor(spec, writer) {
+    const taskById = new Map(spec.tasks.map((task) => [task.id, task]));
+    const pending = [...writer.depends_on];
+    const visited = new Set();
+    while (pending.length > 0) {
+        const id = pending.shift();
+        if (visited.has(id))
+            continue;
+        visited.add(id);
+        const task = taskById.get(id);
+        if (!task)
+            continue;
+        if (task.executor === "pi" && task.role === "planner" && resolveWritePolicy(task, spec) === "read-only")
+            return true;
+        pending.push(...task.depends_on);
+    }
+    return false;
+}
+function validateWriterSourceBinding(spec, issues) {
+    if (spec.version < 3 || spec.sourceBinding)
+        return;
+    for (const task of spec.tasks) {
+        if (resolveWritePolicy(task, spec) !== "exclusive" || hasReadOnlyPlannerAncestor(spec, task))
+            continue;
+        issues.push({
+            type: "orphan-writer-source-binding",
+            message: `task ${task.id} is an exclusive writer without source binding or a read-only planner ancestor; recovery/partial writer DAGs must bind authoritative task sources`,
+        });
+    }
+}
+function validateStaticTaskConfig(task, issues) {
+    if (task.executor !== "static") {
+        return;
+    }
+    const staticConfig = task.static;
+    if (!staticConfig?.resultMarkdown?.trim()) {
+        issues.push({
+            type: "missing-static-config",
+            message: `static task ${task.id} requires static.resultMarkdown`,
+        });
+    }
+}
+function validateRetryPolicyTaskConfig(task, issues) {
+    if (task.retryPolicy === undefined)
+        return;
+    const isReadOnlyCandidate = isSafeReadOnlyPiRetryCandidate(task);
+    const isWriterEmptyDiffCandidate = isWriterEmptyDiffRetryCandidate(task);
+    const isWriterTransportCandidate = isWriterTransportRetryCandidate(task);
+    const isBackendCompletenessCandidate = isBackendTestCompletenessRetryCandidate(task);
+    if (!isReadOnlyCandidate &&
+        !isWriterEmptyDiffCandidate &&
+        !isWriterTransportCandidate &&
+        !isBackendCompletenessCandidate) {
+        issues.push({
+            type: "invalid-retry-policy",
+            message: `task ${task.id} declares retryPolicy but is neither a safe read-only non-dynamic Pi node, an exclusive bounded Pi implementer with writerOutcomePolicy.requireChangedFiles=true, nor a standard exclusive implementer transport-retry candidate`,
+        });
+        return;
+    }
+    if (isBackendCompletenessCandidate) {
+        const categories = new Set(task.retryPolicy.retryCategories);
+        const allowed = new Set([
+            WRITER_EMPTY_DIFF_RETRY_CATEGORY,
+            INCOMPLETE_WRITE_SET_RETRY_CATEGORY,
+        ]);
+        const unsupported = task.retryPolicy.retryCategories.filter((category) => !allowed.has(category));
+        if (task.retryPolicy.maxAttempts < 2 ||
+            task.retryPolicy.maxAttempts > 3 ||
+            unsupported.length > 0 ||
+            !categories.has(WRITER_EMPTY_DIFF_RETRY_CATEGORY)) {
+            issues.push({
+                type: "invalid-retry-policy",
+                message: `task ${task.id} backend-test writer retryPolicy must use 2..3 total attempts and only ${WRITER_EMPTY_DIFF_RETRY_CATEGORY} and/or ${INCOMPLETE_WRITE_SET_RETRY_CATEGORY}`,
+            });
+        }
+        return;
+    }
+    if (isWriterEmptyDiffCandidate &&
+        (task.retryPolicy.maxAttempts !== 2 ||
+            task.retryPolicy.retryCategories.length !== 1 ||
+            task.retryPolicy.retryCategories[0] !==
+                WRITER_EMPTY_DIFF_RETRY_CATEGORY)) {
+        issues.push({
+            type: "invalid-retry-policy",
+            message: `task ${task.id} writer retryPolicy must use exactly two total attempts and only ${WRITER_EMPTY_DIFF_RETRY_CATEGORY}`,
+        });
+        return;
+    }
+    if (isWriterTransportCandidate) {
+        const categories = new Set(task.retryPolicy.retryCategories);
+        if (task.retryPolicy.maxAttempts !== 2 ||
+            categories.size !== 1 ||
+            !categories.has(WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY)) {
+            issues.push({
+                type: "invalid-retry-policy",
+                message: `task ${task.id} writer transport retryPolicy must use exactly two total attempts and only ${WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY}`,
+            });
+        }
+    }
+}
+function validateOutputProtocolTaskConfig(task, issues) {
+    if (task.outputProtocol === undefined)
+        return;
+    if (!isSafeReadOnlyPiRetryCandidate(task)) {
+        issues.push({
+            type: "invalid-output-protocol",
+            message: `task ${task.id} declares outputProtocol but is not a safe read-only non-dynamic Pi node; output protocol retry is only allowed for read-only/none Pi planner/scout/reviewer/verifier/closeout nodes`,
+        });
+    }
+}
+function validateWriterOutcomePolicyTaskConfig(task, issues) {
+    if (task.writerOutcomePolicy === undefined)
+        return;
+    const isBoundedPiWriter = task.executor === "pi" &&
+        task.toolProfile === "write" &&
+        task.role === "implementer" &&
+        task.writePolicy === "exclusive" &&
+        (task.writeSet?.length ?? 0) > 0;
+    if (!isBoundedPiWriter) {
+        issues.push({
+            type: "invalid-writer-outcome-policy",
+            message: `task ${task.id} declares writerOutcomePolicy but is not a bounded exclusive Pi implementer writer`,
+        });
+    }
+}
+function isFrontendEvidenceWriteSet(writeSet) {
+    const entries = writeSet ?? [];
+    if (entries.length === 0)
+        return false;
+    return entries.every((entry) => {
+        const normalized = entry.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+        return (normalized === "testcase/frontend/evidence/**" ||
+            normalized.startsWith("testcase/frontend/evidence/"));
+    });
+}
+function isFrontendBrowserExecutorTask(task) {
+    const skills = task.skills ?? [];
+    return (task.executor === "pi" &&
+        task.toolProfile === "write" &&
+        skills.includes("playwright-cli") &&
+        isFrontendEvidenceWriteSet(task.writeSet));
+}
+function taskMentionsPlaywrightCliContract(task) {
+    const prompt = `${task.subtask_prompt}\n${task.outputContract ?? ""}`;
+    return /playwright[_-]?cli/i.test(prompt);
+}
+/**
+ * Command capability is orthogonal to file write. Fail closed when:
+ * - frontend browser executors lack playwright-cli capability
+ * - capability is granted without skill/prompt contract or outside evidence writeSet
+ * - non-browser nodes receive command capability
+ */
+function validateCommandPolicyTaskConfig(task, issues) {
+    const policy = resolveDagCommandPolicy(task.commandPolicy);
+    const allowsPlaywright = dagCommandPolicyAllows(task.commandPolicy, "playwright-cli");
+    const isBrowserExecutor = isFrontendBrowserExecutorTask(task);
+    if (isBrowserExecutor && !allowsPlaywright) {
+        issues.push({
+            type: "invalid-command-policy",
+            message: `frontend-test browser executor requires playwright-cli command capability (task ${task.id})`,
+        });
+    }
+    if (policy.mode === "deny") {
+        return;
+    }
+    if (task.executor !== "pi") {
+        issues.push({
+            type: "invalid-command-policy",
+            message: `task ${task.id} commandPolicy requires executor=pi`,
+        });
+        return;
+    }
+    if (allowsPlaywright) {
+        const skills = task.skills ?? [];
+        if (!skills.includes("playwright-cli")) {
+            issues.push({
+                type: "invalid-command-policy",
+                message: `task ${task.id} playwright-cli command capability requires skills to include playwright-cli`,
+            });
+        }
+        if (!taskMentionsPlaywrightCliContract(task)) {
+            issues.push({
+                type: "invalid-command-policy",
+                message: `task ${task.id} playwright-cli command capability requires prompt/outputContract to reference playwright_cli`,
+            });
+        }
+        if (!isFrontendEvidenceWriteSet(task.writeSet)) {
+            issues.push({
+                type: "invalid-command-policy",
+                message: `task ${task.id} playwright-cli command capability requires frontend evidence writeSet under testcase/frontend/evidence/`,
+            });
+        }
+        if (task.toolProfile !== "write") {
+            issues.push({
+                type: "invalid-command-policy",
+                message: `task ${task.id} playwright-cli command capability requires toolProfile=write for evidence mutation`,
+            });
+        }
+    }
+}
+function validateDynamicChildCommandPolicy(task, issues) {
+    const expansion = task.dynamicExpansion;
+    if (!expansion)
+        return;
+    const child = expansion.childTask;
+    const synthetic = {
+        id: `${task.id}-child-template`,
+        depends_on: [],
+        complexity: child.complexity,
+        subtask_prompt: child.subtaskPromptTemplate,
+        executor: child.executor,
+        role: child.role,
+        skills: child.skills,
+        toolProfile: child.toolProfile,
+        commandPolicy: child.commandPolicy,
+        writePolicy: child.writePolicy,
+        allowedPaths: child.allowedPaths,
+        forbiddenPaths: child.forbiddenPaths,
+        writeSet: child.writeSet,
+        outputContract: child.outputContract,
+    };
+    validateCommandPolicyTaskConfig(synthetic, issues);
+}
+function validateDecisionGateTaskConfig(task, issues) {
+    if (!task.decisionGate?.enabled) {
+        return;
+    }
+    if (task.executor !== "pi") {
+        issues.push({
+            type: "invalid-decision-gate-executor",
+            message: `task ${task.id} decisionGate requires executor=pi`,
+        });
+    }
+}
+/**
+ * AC1: failure-aware dependencies are an explicit, narrow opt-in. Only
+ * read-only Pi nodes acting as recovery/diagnosis/supervision/closeout
+ * (reviewer, verifier, supervisor, closeout roles) may tolerate an upstream
+ * ERROR. Writers, shell verifiers, hard/decision gates, dynamic nodes, and any
+ * node with write capability must remain fail-closed.
+ */
+const FAILURE_AWARE_SAFE_ROLES = new Set([
+    "reviewer",
+    "verifier",
+    "supervisor",
+    "closeout",
+]);
+function validateFailureAwareDependsOn(task, spec, issues) {
+    const tolerated = task.failureAwareDependsOn;
+    if (!tolerated || tolerated.length === 0)
+        return;
+    const isReadOnlyPiRecoveryNode = task.executor === "pi" &&
+        FAILURE_AWARE_SAFE_ROLES.has(task.role ?? "") &&
+        task.toolProfile !== "write" &&
+        (task.writePolicy === undefined ||
+            task.writePolicy === "read-only" ||
+            task.writePolicy === "none") &&
+        (task.writeSet ?? []).length === 0 &&
+        !task.decisionGate?.enabled &&
+        !task.dynamicExpansion &&
+        !task.dynamicReduction &&
+        !task.dynamicCondition &&
+        !task.dynamicLoopUntil;
+    if (!isReadOnlyPiRecoveryNode) {
+        issues.push({
+            type: "invalid-failure-aware-dependency",
+            message: `task ${task.id} declares failureAwareDependsOn but failure-aware dependencies are allowed only for read-only recovery/diagnosis/supervision/closeout-equivalent Pi nodes (reviewer, verifier, supervisor, closeout); writer and shell verification nodes may not tolerate upstream ERROR or failure-derived SKIPPED`,
+        });
+        return;
+    }
+    const dependsOn = new Set(task.depends_on);
+    const knownIds = new Set(spec.tasks.map((entry) => entry.id));
+    for (const upstreamId of tolerated) {
+        if (!knownIds.has(upstreamId)) {
+            issues.push({
+                type: "invalid-failure-aware-dependency",
+                message: `task ${task.id} failureAwareDependsOn references unknown task id ${upstreamId}`,
+            });
+            continue;
+        }
+        if (!dependsOn.has(upstreamId)) {
+            issues.push({
+                type: "invalid-failure-aware-dependency",
+                message: `task ${task.id} failure-aware dependency ${upstreamId} must be listed in depends_on`,
+            });
+        }
+    }
+}
+export function collectExecutorModelWarnings(spec, expectedMatrices = DEFAULT_DAG_EXECUTOR_MODELS) {
+    const warnings = [];
+    const executors = Object.keys(DEFAULT_DAG_EXECUTOR_MODELS);
+    for (const executor of executors) {
+        const actualByComplexity = spec.executorModels?.[executor];
+        if (!actualByComplexity) {
+            continue;
+        }
+        const expectedByComplexity = expectedMatrices[executor] ?? DEFAULT_DAG_EXECUTOR_MODELS[executor];
+        for (const [complexityKey, actual] of Object.entries(actualByComplexity)) {
+            if (actual === undefined) {
+                continue;
+            }
+            const expected = expectedByComplexity[complexityKey];
+            if (actual !== expected) {
+                warnings.push({
+                    executor,
+                    complexity: complexityKey,
+                    expected,
+                    actual,
+                });
+            }
+        }
+    }
+    return warnings;
+}
+export function collectForbiddenExecutorIssues(spec, forbiddenExecutors) {
+    if (forbiddenExecutors.length === 0)
+        return [];
+    const forbidden = new Set(forbiddenExecutors);
+    const rawTasks = spec.tasks ?? [];
+    return spec.tasks
+        .filter((task) => forbidden.has(task.executor))
+        .map((task, index) => ({
+        executor: task.executor,
+        taskId: task.id,
+        implicitDefault: rawTasks[index]?.executor === undefined,
+    }));
+}
+/** Revalidate a rendered dynamic child before it enters state or executes. */
+export function assertValidMaterializedDagTask(task) {
+    const issues = [];
+    // A minimal v2 carrier makes write-policy validation strict while avoiding
+    // unrelated parent graph/rank checks.  Dynamic templates are validated at
+    // init; this guards values introduced by {{item}} rendering.
+    const spec = { version: 2, tasks: [task] };
+    validateTaskWritePolicy(task, spec, issues);
+    validateShellTaskConfig(task, spec, issues);
+    validateStaticTaskConfig(task, issues);
+    validateDecisionGateTaskConfig(task, issues);
+    validateRetryPolicyTaskConfig(task, issues);
+    validateOutputProtocolTaskConfig(task, issues);
+    validateWriterOutcomePolicyTaskConfig(task, issues);
+    validateCommandPolicyTaskConfig(task, issues);
+    if (issues.length > 0) {
+        throw new Error(`invalid materialized dynamic child ${task.id}: ${issues.map((issue) => issue.message).join("; ")}`);
+    }
+}
+export function validateDagSpec(spec) {
+    const issues = [];
+    if (spec.tasks.length === 0) {
+        issues.push({
+            type: "empty-tasks",
+            message: "DAG must contain at least one task",
+        });
+        return issues;
+    }
+    const ids = new Set();
+    for (const task of spec.tasks) {
+        if (ids.has(task.id)) {
+            issues.push({
+                type: "duplicate-id",
+                message: `duplicate task id: ${task.id}`,
+            });
+        }
+        ids.add(task.id);
+    }
+    for (const task of spec.tasks) {
+        for (const dep of task.depends_on) {
+            if (dep === task.id) {
+                issues.push({
+                    type: "self-dependency",
+                    message: `task ${task.id} depends on itself`,
+                });
+            }
+            if (!ids.has(dep)) {
+                issues.push({
+                    type: "missing-dependency",
+                    message: `task ${task.id} depends on unknown id: ${dep}`,
+                });
+            }
+        }
+    }
+    const { hasCycle, cycleNodes, ranks } = topoSortToRanks(spec);
+    if (hasCycle) {
+        issues.push({
+            type: "cycle",
+            message: `cycle detected involving: ${cycleNodes.join(", ")}`,
+        });
+        return issues;
+    }
+    for (const task of spec.tasks) {
+        validateTaskWritePolicy(task, spec, issues);
+        validateShellTaskConfig(task, spec, issues);
+        validateStaticTaskConfig(task, issues);
+        validateDecisionGateTaskConfig(task, issues);
+        validateRetryPolicyTaskConfig(task, issues);
+        validateOutputProtocolTaskConfig(task, issues);
+        validateWriterOutcomePolicyTaskConfig(task, issues);
+        validateCommandPolicyTaskConfig(task, issues);
+        validateDynamicChildCommandPolicy(task, issues);
+        validateProjectGovernanceTaskConfig(task, spec, issues);
+        validateFailureAwareDependsOn(task, spec, issues);
+    }
+    validateSameRankWriteSetConflicts(spec, ranks, issues);
+    validateSameRankAgentAttributionRisks(spec, ranks, issues);
+    validateWriterSourceBinding(spec, issues);
+    for (const advisory of spec.advisories ?? []) {
+        issues.push({ type: "advisory", message: advisory });
+    }
+    return issues;
+}
+function validateProjectGovernanceTaskConfig(task, spec, issues) {
+    if (task.governanceStandardReview) {
+        if (task.executor !== "pi" ||
+            task.toolProfile === "write" ||
+            !["read-only", "none"].includes((task.writePolicy ?? "read-only"))) {
+            issues.push({
+                type: "invalid-project-governance-config",
+                message: `task ${task.id} governanceStandardReview requires a read-only Pi node`,
+            });
+        }
+    }
+    if (!task.shell?.projectGovernanceGate)
+        return;
+    const verdictGate = task.shell.verdictGate;
+    const source = verdictGate
+        ? spec.tasks.find((candidate) => candidate.id === verdictGate.fromNodeId)
+        : undefined;
+    if (task.executor !== "shell" ||
+        !verdictGate ||
+        !task.depends_on.includes(verdictGate.fromNodeId) ||
+        !source?.governanceStandardReview) {
+        issues.push({
+            type: "invalid-project-governance-config",
+            message: `task ${task.id} projectGovernanceGate requires verdictGate over a directly-dependent governanceStandardReview node`,
+        });
+    }
+}
+export function assertValidDagSpec(spec, options = {}) {
+    const issues = collectBlockingIssues(options.issues ?? validateDagSpec(spec), options);
+    if (issues.length > 0) {
+        throw new Error(`invalid DAG: ${issues.map((issue) => issue.message).join("; ")}`);
+    }
+}