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

package/dist/workflows/dag/types.js

@@ -0,0 +1,1145 @@
+import { z } from "zod";
+import { isOpenspecSpecFilePath } from "../../shared/openspec-spec.js";
+import { campaignBudgetSchema, } from "../../application/evaluation/budget.js";
+import { assertDagPromptSourceRule } from "./prompt-source.js";
+import { dagRetryPolicySchema } from "./retry-policy.js";
+import { dagLivenessPolicySchema, } from "./liveness-policy.js";
+import { dagOutputProtocolSchema } from "./output-protocol.js";
+export const dagComplexitySchema = z.enum(["HIGH", "MED", "LOW"]);
+export const dagNodeExecutorSchema = z.enum(["pi", "shell", "static"]);
+export const CURSOR_DAG_EXECUTOR_REMOVED_ERROR = 'executor "cursor" is no longer supported; regenerate the DAG with Pi-only writers (implement-pi / repair-pi)';
+export const CURSOR_EXECUTOR_MODELS_REMOVED_ERROR = "executorModels.cursor is no longer supported; use executorModels.pi only";
+export const dagToolProfileSchema = z.enum(["read-only", "write"]);
+/** Static command capabilities only; tasks cannot inject executables or shell prefixes. */
+export const dagCommandCapabilitySchema = z.enum(["playwright-cli"]);
+export const dagCommandPolicySchema = z.discriminatedUnion("mode", [
+    z.object({ mode: z.literal("deny") }).strict(),
+    z
+        .object({
+        mode: z.literal("capability-allowlist"),
+        capabilities: z.array(dagCommandCapabilitySchema).min(1),
+    })
+        .strict(),
+]);
+/** Undefined / omitted commandPolicy is treated as deny by executors and validators. */
+export function resolveDagCommandPolicy(policy) {
+    return policy ?? { mode: "deny" };
+}
+export function dagCommandPolicyAllows(policy, capability) {
+    const resolved = resolveDagCommandPolicy(policy);
+    if (resolved.mode !== "capability-allowlist")
+        return false;
+    return resolved.capabilities.includes(capability);
+}
+export const dagOutputModeSchema = z.enum(["default", "structured-required"]);
+export const dagShellPresetSchema = z.enum(["loop-agent-standard-verify"]);
+export const dagVerifyQuotaSchema = z.enum(["1", "3", "full"]);
+export const dagVerifyStrategySchema = z
+    .object({
+    intermediateQuota: dagVerifyQuotaSchema.optional(),
+    finalQuota: z.literal("full").optional().default("full"),
+    focusedCommandSource: z.literal("adapter").optional().default("adapter"),
+})
+    .optional();
+export const dagShellVerifyEvidenceSchema = z.object({
+    phase: z.enum(["intermediate", "final"]),
+    quota: dagVerifyQuotaSchema,
+    commandSource: z.enum(["adapter", "inline"]),
+    commandCount: z.number().int().nonnegative(),
+    commandLabels: z.array(z.string()).default([]),
+    commandTexts: z.array(z.string()).default([]),
+    /** Semantic command identities in the same deterministic order as commandTexts. */
+    canonicalKeys: z.array(z.string()).default([]),
+    /** Commands merged into a retained semantic command, keyed by canonical identity. */
+    mergedCommands: z
+        .array(z.object({
+        canonicalKey: z.string(),
+        keptLabel: z.string(),
+        mergedLabels: z.array(z.string()),
+        /** Retained timeout after semantic duplicates merge, or null when unspecified. */
+        effectiveTimeoutMs: z.number().int().positive().nullable(),
+    }))
+        .default([]),
+    /** Commands omitted only because a retained aggregate is known to cover them. */
+    coveredCommands: z
+        .array(z.object({ aggregateLabel: z.string(), coveredLabel: z.string() }))
+        .default([]),
+    /** Why a command was retained or deferred from the intermediate verify node. */
+    selectionReasons: z.array(z.string()).default([]),
+    /** Non-executing generation-time cwd/local-script validation evidence. */
+    preflight: z
+        .array(z.object({ label: z.string(), status: z.enum(["ok", "future-delivery-script"]) }))
+        .default([]),
+    /** Effective timeout applied independently to each shell command. */
+    commandTimeoutMs: z.number().int().positive().optional(),
+    /** Worst-case serial budget: commandCount * commandTimeoutMs. */
+    totalTimeoutBudgetMs: z.number().int().nonnegative().optional(),
+    finalFullRequired: z.boolean().optional(),
+});
+export const dagRepairArtifactGateSchema = z.object({
+    fromNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "fromNodeId must be kebab-case"),
+    /**
+     * Explicit reference to the governed Pi repair writer this gate feeds.
+     * New generated supervised DAGs must set this. Legacy DAGs without it are
+     * only accepted when a unique safe downstream Pi writer can be derived.
+     */
+    repairNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "repairNodeId must be kebab-case")
+        .optional(),
+});
+export const DAG_RUNTIME_CONTRACT_SCHEMA_VERSION = 1;
+export const DAG_AGENT_RUNTIME_PI_ONLY = "pi-only";
+export const DAG_REPAIR_WRITER_PROTOCOL_EXPLICIT_NODE_V1 = "explicit-node-v1";
+export const dagRuntimeContractSchema = z.object({
+    schemaVersion: z.literal(DAG_RUNTIME_CONTRACT_SCHEMA_VERSION),
+    agentRuntime: z.literal(DAG_AGENT_RUNTIME_PI_ONLY),
+    repairWriterProtocol: z.literal(DAG_REPAIR_WRITER_PROTOCOL_EXPLICIT_NODE_V1),
+    /**
+     * Optional minimum controller version for diagnosis / fail-below. Capability
+     * fields above are primary; semver is only used for guidance when the
+     * controller is otherwise compatible.
+     */
+    minimumControllerVersion: z
+        .string()
+        .regex(/^\d+\.\d+\.\d+([-+].+)?$/, "minimumControllerVersion must be semver")
+        .optional(),
+});
+export const dagVerdictGateSchema = z.object({
+    fromNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "fromNodeId must be kebab-case"),
+    /**
+     * Optional fallback node ids when the primary `fromNodeId` JSON is absent
+     * (e.g. exclusive condition branch skip). Tried in order after primary.
+     * Prefer listing the post-revision / final reviewer first when both may exist.
+     */
+    fallbackFromNodeIds: z
+        .array(z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "fallbackFromNodeIds must be kebab-case"))
+        .optional(),
+    accept: z.array(z.string().min(1)).min(1),
+    routingAccept: z.array(z.string().min(1)).optional(),
+    source: z.enum(["verdict-line", "json-review-verdict"]).optional(),
+    lineMode: z.enum(["first-non-empty", "first-verdict-line"]).optional(),
+    label: z.string().min(1).optional(),
+});
+export const dagRequirementCoverageGateSchema = z.object({
+    fromNodeIds: z
+        .array(z.string().regex(/^[a-z][a-z0-9-]*$/, "fromNodeIds must be kebab-case"))
+        .min(1),
+    fallbackFromNodeIds: z
+        .array(z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "fallbackFromNodeIds must be kebab-case"))
+        .min(1)
+        .optional(),
+    requiredIds: z
+        .array(z
+        .string()
+        .regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/, "requiredIds must use REQ-*, BR-*, or AC-* identifiers"))
+        .min(1),
+    label: z.string().min(1).optional(),
+});
+export const dagJsonArtifactSchemaIdSchema = z.enum([
+    "backend-test-analysis-v1",
+    "backend-test-analysis-v2",
+    "backend-test-execution-v1",
+    "backend-test-result-v1",
+    "backend-test-classification-v1",
+    "backend-test-semantic-review-v1",
+    "backend-test-case-manifest-v1",
+    "frontend-implementation-contract-v1",
+    "frontend-test-result-v1",
+]);
+export const dagJsonArtifactGateSchema = z.object({
+    fromNodeId: z.string().regex(/^[a-z][a-z0-9-]*$/),
+    fallbackFromNodeIds: z
+        .array(z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "fallbackFromNodeIds must be kebab-case"))
+        .min(1)
+        .optional(),
+    schemaId: dagJsonArtifactSchemaIdSchema,
+    artifactName: z.string().regex(/^[a-z0-9][a-z0-9._-]*\.json$/),
+    outputDir: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/),
+    junitRelativePath: z.string().min(1).optional(),
+});
+const dagFrontendNodeIdSchema = z
+    .string()
+    .regex(/^[a-z][a-z0-9-]*$/, "frontend node id must be kebab-case");
+const openspecCandidatePathSchema = z
+    .string()
+    .refine((candidate) => !candidate.includes("\\") && isOpenspecSpecFilePath(candidate), "openspec candidate must be a repo-relative supported file under openspec/schemas/, openspec/project-specs/, or ai_workspace/");
+export const dagFrontendPrewriteGateSchema = z.object({
+    schemaVersion: z.literal(1),
+    planFromNodeId: dagFrontendNodeIdSchema,
+    planFallbackFromNodeIds: z.array(dagFrontendNodeIdSchema).default([]),
+    reviewFromNodeId: dagFrontendNodeIdSchema,
+    reviewFallbackFromNodeIds: z.array(dagFrontendNodeIdSchema).default([]),
+    requiredRequirementIds: z
+        .array(z.string().regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/))
+        .default([]),
+    allowedMockStrategies: z
+        .array(z.enum(["native", "browser-intercept", "request-adapter", "not-needed"]))
+        .min(1),
+    /** Frozen Mock verification command labels the DAG will actually execute. */
+    mockCommandLabels: z.array(z.string()).default([]),
+    artifactName: z.string().regex(/^[a-z0-9][a-z0-9._-]*\.json$/),
+    outputDir: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/),
+    requireSourceFreshness: z.literal(true),
+    implementationWriteSet: z.array(z.string().min(1)).min(1).optional(),
+    openspecCandidatePaths: z.array(openspecCandidatePathSchema).default([]),
+    /**
+     * Generation-frozen component/theme specification bucket. Derived from
+     * `designEvidence.classified.component ∪ theme ∪ rule.components` at DAG
+     * generation. When non-empty and the canonical contract has UI-visible
+     * work, the prewrite gate requires a non-empty `uiComponentChoices` and
+     * cross-checks each `specReference.path` against this set + the effective
+     * plan openspec-citations block. Legacy DAGs without this field keep the
+     * field-absent semantics (component-choices-missing is not enforced).
+     */
+    componentSpecCandidatePaths: z.array(openspecCandidatePathSchema).optional(),
+    /**
+     * OpenSpec gate policy. Omitted on legacy DAGs: the runtime treats
+     * undefined as scan-strict so pre-existing full-read semantics are
+     * preserved. Generation always writes it explicitly for new DAGs.
+     */
+    openspecPolicy: z.enum(["cited", "scan-strict"]).optional(),
+    /**
+     * When true, the effective plan node (planFromNodeId when it is selected
+     * over the fallback) emits an RFC 7386 merge-patch delta instead of a full
+     * contract. The gate applies it on the original contract node
+     * (planFallbackFromNodeIds[0]) before analysis/materialization. Legacy DAGs
+     * without this field keep full-contract semantics.
+     */
+    revisionPatch: z.boolean().optional(),
+    /**
+     * Deterministically rendered plan.md artifact name (same outputDir as the
+     * contract). Defaults to frontend-plan.md at runtime.
+     */
+    planMdArtifactName: z
+        .string()
+        .regex(/^[a-z0-9][a-z0-9._-]*\.md$/)
+        .optional(),
+    /**
+     * Generation-frozen candidate source metadata (diagnostic). cited mode
+     * candidates are declared ∪ taskSourceCited; scan-strict candidates are
+     * scanStrict (auto-discovered designEvidence.normativePaths).
+     */
+    openspecCandidateSources: z
+        .object({
+        declared: z.array(openspecCandidatePathSchema).default([]),
+        taskSourceCited: z.array(openspecCandidatePathSchema).default([]),
+        scanStrict: z.array(openspecCandidatePathSchema).default([]),
+    })
+        .optional(),
+});
+export const dagFrontendLintBaselineSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    lintCommands: z.array(z.string().min(1)).min(1),
+    lintEvidence: dagShellVerifyEvidenceSchema,
+})
+    .strict();
+export const dagFrontendVerificationBundleSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    mockCommands: z.array(z.string()).default([]),
+    lintCommands: z.array(z.string().min(1)).optional(),
+    staticCommands: z.array(z.string()).min(1),
+    behaviorCommands: z.array(z.string()).default([]),
+    mockEvidence: dagShellVerifyEvidenceSchema.optional(),
+    lintEvidence: dagShellVerifyEvidenceSchema.optional(),
+    staticEvidence: dagShellVerifyEvidenceSchema,
+    behaviorEvidence: dagShellVerifyEvidenceSchema,
+    lintBaselineNodeId: dagFrontendNodeIdSchema.optional(),
+    writerNodeIds: z.array(dagFrontendNodeIdSchema).optional(),
+    mode: z.enum(["initial", "repair"]),
+})
+    .superRefine((bundle, context) => {
+    const groups = [
+        ["mock", bundle.mockCommands, bundle.mockEvidence],
+        ["lint", bundle.lintCommands ?? [], bundle.lintEvidence],
+        ["static", bundle.staticCommands, bundle.staticEvidence],
+        ["behavior", bundle.behaviorCommands, bundle.behaviorEvidence],
+    ];
+    for (const [name, commands, evidence] of groups) {
+        if ((name === "mock" || name === "lint") &&
+            commands.length === 0 &&
+            !evidence)
+            continue;
+        if (!evidence) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [`${name}Evidence`],
+                message: `${name} evidence is required when commands are configured`,
+            });
+            continue;
+        }
+        if (evidence.commandCount !== commands.length) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [`${name}Evidence`, "commandCount"],
+                message: `${name} commandCount must match commands`,
+            });
+        }
+        if (evidence.commandLabels.length !== commands.length) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [`${name}Evidence`, "commandLabels"],
+                message: `${name} commandLabels must match commands`,
+            });
+        }
+        if (evidence.commandTexts.length !== commands.length ||
+            evidence.commandTexts.some((command, index) => command !== commands[index])) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [`${name}Evidence`, "commandTexts"],
+                message: `${name} commandTexts must exactly match commands`,
+            });
+        }
+        if (new Set(evidence.commandLabels).size !==
+            evidence.commandLabels.length ||
+            evidence.commandLabels.some((label) => !label.trim())) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [`${name}Evidence`, "commandLabels"],
+                message: `${name} commandLabels must be non-empty and unique`,
+            });
+        }
+    }
+    if ((bundle.lintCommands?.length ?? 0) > 0) {
+        if (!bundle.lintBaselineNodeId) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["lintBaselineNodeId"],
+                message: "lintBaselineNodeId is required when lintCommands are present",
+            });
+        }
+        if (!bundle.writerNodeIds || bundle.writerNodeIds.length === 0) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["writerNodeIds"],
+                message: "writerNodeIds are required when lintCommands are present",
+            });
+        }
+    }
+});
+export const dagFrontendReviewContextSchema = z.object({
+    schemaVersion: z.literal(1),
+    requireBaseline: z.literal(true),
+});
+export const ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
+export const dagVersionSchema = z
+    .union([z.literal(1), z.literal(2), z.literal(3), z.literal(4)])
+    .default(1);
+/** DagSpec v4 binding to managed TaskContractRefV1 (design §5.3.10). */
+export const dagTaskContractBindingSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    taskId: z.string().min(1),
+    revision: z.number().int().nonnegative(),
+    projectionVersion: z.literal(1),
+    canonicalizerVersion: z.literal(1),
+    taskConfigSchemaVersion: z.literal(1),
+    canonicalHash: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/, "canonicalHash must be lowercase hex"),
+    taskConfigSha256: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/, "taskConfigSha256 must be lowercase hex"),
+})
+    .strict();
+export const dagRoleSchema = z.enum([
+    "planner",
+    "scout",
+    "implementer",
+    "reviewer",
+    "supervisor",
+    "verifier",
+    "closeout",
+]);
+export const dagWritePolicySchema = z.enum([
+    "read-only",
+    "docs-only",
+    "exclusive",
+    "none",
+]);
+/** Git/post-diff write guard intensity for exclusive Pi writers. */
+export const dagWriteGuardPolicySchema = z.enum(["full", "tools-only"]);
+/**
+ * Fail-closed outcome/diff consistency contract for bounded Pi writers.
+ * The writer must begin with IMPLEMENTATION_OUTCOME: changed,
+ * already-satisfied, or blocked; the executor checks it against the
+ * run-attributed diff. Declared before the dynamic child schema so the
+ * child writerOutcomePolicy optional field can reuse it without a TDZ.
+ */
+export const dagWriterOutcomePolicySchema = z
+    .object({
+    type: z.literal("implementation-outcome-v1"),
+    /** Generation writers may forbid already-satisfied/no-diff completion. */
+    requireChangedFiles: z.boolean().optional(),
+})
+    .strict();
+export const contextPolicyIdSchema = z.enum([
+    "baseline-v1",
+    "role-specialized-v1",
+]);
+export const dagDefaultsSchema = z
+    .object({
+    executor: dagNodeExecutorSchema.optional(),
+    model: z.string().optional(),
+    piBackend: z.enum(["sdk-first", "cli-only"]).optional(),
+    contextProfile: z.string().optional(),
+    /** Eval Lab ContextPolicy seam; default baseline-v1 when omitted. */
+    contextPolicyId: contextPolicyIdSchema.optional(),
+    skills: z.array(z.string()).optional(),
+    writePolicy: dagWritePolicySchema.optional(),
+    /** Adaptive liveness thresholds for Pi node supervision. */
+    livenessPolicy: dagLivenessPolicySchema,
+})
+    .optional();
+export const dagNodeStatusSchema = z.enum([
+    "PENDING",
+    "RUNNING",
+    "FINISHED",
+    "ERROR",
+    "SKIPPED",
+]);
+export const dagBackendTestPipelineSchema = z.enum([
+    "contracts",
+    "semantic-initial",
+    "execute-parse-initial",
+    "classification-result-context",
+    "markdown-environment",
+    "markdown-cases",
+    "markdown-collection-assess",
+    "markdown-collection-effective",
+    "markdown-traceability",
+    "markdown-scenario-param",
+    "markdown-execute-html",
+    "markdown-manifest",
+    "markdown-report",
+    "ingest-backend-test-gap",
+]);
+export const dagFrontendBrowserToolPreflightSchema = z.object({}).strict();
+export const dagFrontendTestEvidenceValidationSchema = z.object({}).strict();
+export const dagFrontendTestCaseChecklistSchema = z.object({}).strict();
+export const dagFrontendTestHtmlReportSchema = z.object({}).strict();
+/**
+ * Combined checklist + manifest materialization gate (lean frontend-test DAG).
+ * Runs the mechanical frontend case checklist first, then atomically
+ * materializes testcase/frontend/cases/manifest.json from manifest.draft.json.
+ * Stdout is exactly one final JSON line {cases}.
+ */
+export const dagFrontendTestCaseManifestSchema = z
+    .object({
+    maxCases: z.number().int().min(1).optional(),
+    declaredAcIds: z.array(z.string()).optional(),
+})
+    .strict();
+/**
+ * Combined evidence validation + result materialization gate (lean frontend-test DAG).
+ * Runs deterministic evidence validation first (advisory on missing/malformed,
+ * hard-fail on path escape), then materializes frontend-test-result-v1.
+ */
+export const dagFrontendTestResultFinalizeSchema = z
+    .object({
+    declaredAcIds: z.array(z.string()).optional(),
+})
+    .strict();
+/**
+ * Combined reports gate (lean frontend-test DAG). Renders the deterministic
+ * frontend L-5 dashboard (when l5 is true, the default) and then the main
+ * frontend-test Markdown + self-contained HTML report from frontend-test-result-v1.
+ */
+export const dagFrontendTestReportsSchema = z
+    .object({
+    l5: z.boolean().optional(),
+})
+    .strict();
+export const dagFinalWriteSetApprovalGateSchema = z
+    .object({
+    writerNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "writerNodeId must be kebab-case"),
+})
+    .strict();
+export const dagMavenWorkspaceManifestSchema = z.object({
+    files: z.array(z.object({
+        path: z.string(),
+        size: z.number(),
+        mtimeMs: z.number(),
+    })),
+    directories: z.array(z.object({
+        path: z.string(),
+        entryNames: z.array(z.string()),
+    })),
+});
+export const dagMavenVerificationPlanSchema = z.object({
+    schemaVersion: z.number().int().positive(),
+    plannerVersion: z.string().min(1),
+    fingerprint: z.string().min(1),
+    inputDigest: z.string().min(1),
+    targets: z.array(z.object({
+        pomPath: z.string().min(1),
+        artifactId: z.string().min(1),
+        reactorRootPomPath: z.string().min(1).optional(),
+        moduleCoordinate: z.string().min(1).optional(),
+    })),
+    commandDigests: z.array(z.string()),
+    plannedCommands: z.array(z.object({
+        label: z.string(),
+        args: z.array(z.string()),
+    })),
+    workspaceManifest: dagMavenWorkspaceManifestSchema.optional(),
+    shellCommandDigests: z.array(z.string()).optional(),
+});
+export const dagShellConfigSchema = z.object({
+    commands: z.array(z.string()).default([]),
+    preset: dagShellPresetSchema.optional(),
+    verdictGate: dagVerdictGateSchema.optional(),
+    projectGovernanceGate: z
+        .object({
+        contextPath: z.literal(".runtime/project-governance-context.json"),
+    })
+        .strict()
+        .optional(),
+    requirementCoverageGate: dagRequirementCoverageGateSchema.optional(),
+    jsonArtifactGate: dagJsonArtifactGateSchema.optional(),
+    frontendPrewriteGate: dagFrontendPrewriteGateSchema.optional(),
+    frontendLintBaseline: dagFrontendLintBaselineSchema.optional(),
+    frontendVerificationBundle: dagFrontendVerificationBundleSchema.optional(),
+    frontendReviewContext: dagFrontendReviewContextSchema.optional(),
+    frontendTestCaseChecklist: dagFrontendTestCaseChecklistSchema.optional(),
+    frontendBrowserToolPreflight: dagFrontendBrowserToolPreflightSchema.optional(),
+    frontendTestEvidenceValidation: dagFrontendTestEvidenceValidationSchema.optional(),
+    finalWriteSetApprovalGate: dagFinalWriteSetApprovalGateSchema.optional(),
+    frontendTestL5Report: z.object({}).strict().optional(),
+    frontendTestHtmlReport: dagFrontendTestHtmlReportSchema.optional(),
+    frontendTestCaseManifest: dagFrontendTestCaseManifestSchema.optional(),
+    frontendTestResultFinalize: dagFrontendTestResultFinalizeSchema.optional(),
+    frontendTestReports: dagFrontendTestReportsSchema.optional(),
+    backendTestPipeline: dagBackendTestPipelineSchema.optional(),
+    /** JaCoCo coverage collection for backend-test (Java services). When set, node 7 dumps coverage over TCP from a JaCoCo tcpserver agent and feeds it to the L-5 dashboard. */
+    jacocoCoverage: z
+        .object({
+        /** JaCoCo tcpserver endpoint, e.g. "host:6300". */
+        endpoint: z.string().min(1),
+        /** Absolute path to jacococli.jar on this machine, used to convert .exec → jacoco.xml. */
+        cliJarPath: z.string().min(1),
+        /** Business package filter passed to JaCoCo includes, e.g. "com.example.*". Defaults to "*". */
+        includes: z.string().min(1).optional().default("*"),
+        /** TCP connect timeout in ms. Defaults to 5000. */
+        connectTimeoutMs: z.number().int().positive().optional().default(5000),
+    })
+        .strict()
+        .optional(),
+    verifyEvidence: dagShellVerifyEvidenceSchema.optional(),
+    repairArtifactGate: dagRepairArtifactGateSchema.optional(),
+    /** fail (default): any nonzero command fails the node. record: finish node FINISHED with failure facts for downstream assess/repair. */
+    nonZeroExitPolicy: z.enum(["fail", "record"]).optional(),
+    /**
+     * When true/omitted, stop after the first failed command (runtime default true).
+     * When false, continue executing remaining commands and aggregate failures.
+     * Optional on the schema so existing shell literals stay valid; executor applies default.
+     */
+    failFast: z.boolean().optional(),
+    envAllowlist: z.array(z.string()).optional(),
+    timeoutMs: z.number().optional(),
+    cwd: z.string().optional(),
+    /** Frozen Maven verification plan; shell executor re-checks fingerprint before running. */
+    mavenVerificationPlan: dagMavenVerificationPlanSchema.optional(),
+});
+export const dagStaticConfigSchema = z.object({
+    resultMarkdown: z.string().min(1),
+    status: z.enum(["success", "error"]).optional(),
+});
+export const dagDynamicExpansionChildTaskSchema = z.object({
+    executor: dagNodeExecutorSchema.default("pi"),
+    role: dagRoleSchema.optional(),
+    skills: z.array(z.string()).optional(),
+    complexity: dagComplexitySchema.default("LOW"),
+    subtaskPromptTemplate: z.string().min(1),
+    outputContract: z.string().optional(),
+    staticResultTemplate: z.string().optional(),
+    toolProfile: dagToolProfileSchema.optional(),
+    commandPolicy: dagCommandPolicySchema.optional(),
+    writePolicy: dagWritePolicySchema.optional(),
+    allowedPaths: z.array(z.string()).optional().default([]),
+    forbiddenPaths: z.array(z.string()).optional().default([]),
+    writeSet: z.array(z.string()).optional(),
+    /**
+     * Materialized-child pass-through fields for bounded Pi writer children
+     * (backend-test md/pytest case sharding). All optional so legacy
+     * read-only/frontend map children (which never set these) keep parsing.
+     */
+    writerOutcomePolicy: dagWriterOutcomePolicySchema.optional(),
+    writeGuardPolicy: dagWriteGuardPolicySchema.optional(),
+    retryPolicy: dagRetryPolicySchema.optional(),
+});
+export const dagDynamicExpansionSchema = z.object({
+    type: z.enum(["map_agent", "verify_agent"]),
+    workflowNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "workflowNodeId must be kebab-case"),
+    itemsFrom: z.string().min(1),
+    itemName: z.string().min(1).default("item"),
+    maxItems: z.number().int().positive(),
+    maxExpandedNodes: z.number().int().positive(),
+    workspaceTemplate: z.string().min(1).optional(),
+    childIdPrefix: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "childIdPrefix must be kebab-case"),
+    childTask: dagDynamicExpansionChildTaskSchema,
+    tokenBudget: z
+        .object({
+        maxTokensPerCase: z.number().int().positive().optional(),
+        maxTotalTokens: z.number().int().positive().optional(),
+    })
+        .optional(),
+    /**
+     * When true, any child blocked by the aggregate token budget fails the map
+     * barrier instead of being retained as a case-level blocked outcome.
+     * Backend-test enables this because partial Markdown/pytest module sets are
+     * invalid generation assets; frontend-test keeps the default false.
+     */
+    failOnTokenBudgetExhaustion: z.boolean().optional(),
+    /**
+     * When true, map child ERROR/auth/timeout is recorded as case-level
+     * failed/blocked evidence and the map barrier still succeeds (frontend-test).
+     * Default false: any non-budget child failure fails the map aggregate
+     * (sharded migration and other map_agent workflows).
+     */
+    tolerateChildFailures: z.boolean().optional(),
+});
+export const dagDynamicReductionSchema = z.object({
+    type: z.literal("verified_findings_report"),
+    workflowNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "workflowNodeId must be kebab-case"),
+    findingsFrom: z.string().min(1),
+    verificationsFrom: z.string().min(1),
+    refutedFindingsArtifactName: z
+        .string()
+        .min(1)
+        .default("refuted-findings.json"),
+});
+export const dagDynamicConditionSchema = z.object({
+    workflowNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "workflowNodeId must be kebab-case"),
+    cases: z.array(z.object({
+        when: z.string().min(1),
+        then: z
+            .string()
+            .regex(/^[a-z][a-z0-9-]*$/, "then must be a kebab-case task id"),
+    })),
+    default: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "default must be a kebab-case task id")
+        .optional(),
+});
+export const dagDynamicLoopBodyTaskSchema = z.object({
+    id: z.string().regex(/^[a-z][a-z0-9-]*$/, "body task id must be kebab-case"),
+    dependsOn: z.array(z.string()).default([]),
+    executor: dagNodeExecutorSchema.default("pi"),
+    role: dagRoleSchema.optional(),
+    skills: z.array(z.string()).optional(),
+    complexity: dagComplexitySchema.default("LOW"),
+    subtaskPromptTemplate: z.string().min(1),
+    outputContract: z.string().optional(),
+    staticResultTemplate: z.string().optional(),
+    toolProfile: dagToolProfileSchema.optional(),
+    commandPolicy: dagCommandPolicySchema.optional(),
+    writePolicy: dagWritePolicySchema.optional(),
+    allowedPaths: z.array(z.string()).optional().default([]),
+    forbiddenPaths: z.array(z.string()).optional().default([]),
+    writeSet: z.array(z.string()).optional(),
+});
+export const dagDynamicLoopUntilSchema = z.object({
+    workflowNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "workflowNodeId must be kebab-case"),
+    maxIterations: z.number().int().positive(),
+    stopWhenAny: z.array(z.string().min(1)).default([]),
+    bodyTasks: z.array(dagDynamicLoopBodyTaskSchema).min(1),
+});
+export const dagDecisionGateModeSchema = z.enum([
+    "record-only",
+    "pause-on-human",
+]);
+export const dagDecisionGateSchema = z.object({
+    enabled: z.boolean(),
+    schemaVersion: z.literal(1).optional(),
+    mode: dagDecisionGateModeSchema.optional().default("record-only"),
+});
+/**
+ * The final supervised audit is the sole runtime write authority for its
+ * writer. `allowedPaths` remains a ceiling; it is never a writer fallback.
+ */
+export const dagFinalWriteSetApprovalBindingSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    writerNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "writerNodeId must be kebab-case"),
+    approvalSourceNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "approvalSourceNodeId must be kebab-case"),
+    auditedPlanNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "auditedPlanNodeId must be kebab-case"),
+})
+    .strict();
+export const dagConvergenceSpecSchema = z
+    .object({
+    enabled: z.boolean().optional().default(false),
+    maxPasses: z.number().int().positive().optional().default(3),
+    stopOnVerdictPass: z.boolean().optional().default(true),
+    stopOnHardVerifyPass: z.boolean().optional().default(true),
+    pauseOnRegression: z.boolean().optional().default(true),
+    chainNodeIds: z.array(z.string()).optional(),
+})
+    .optional();
+/**
+ * Schema ids that may opt a node into producing-node structured contract
+ * self-validation. Validators are registered in the contract output registry
+ * (src/workflows/dag/contract-output-registry.ts).
+ */
+export const structuredContractOutputSchemaIds = [
+    "frontend-implementation-contract-v1",
+    "frontend-implementation-contract-plan-patch-v1",
+    "frontend-implementation-contract-revision-patch-v1",
+];
+export const dagTaskSchema = z.object({ id: z.string().regex(/^[a-z][a-z0-9-]*$/, "task id must be kebab-case"),
+    depends_on: z.array(z.string()).default([]),
+    /**
+     * How SKIPPED upstreams affect readiness.
+     * - all (default): any SKIPPED/ERROR dependency blocks (cascade exclusive branches)
+     * - all-or-condition-skip: condition-branch SKIPPED tips count as soft; node runs when
+     *   every dep is FINISHED or soft condition-skip and at least one is FINISHED (OR-join)
+     */
+    dependsPolicy: z.enum(["all", "all-or-condition-skip"]).optional(),
+    /**
+     * Explicit opt-in: upstream node ids whose ERROR terminal state, or whose
+     * failure-derived SKIPPED state, this read-only node may consume as settled
+     * failure evidence. Validation
+     * restricts this to read-only Pi recovery/diagnosis/closeout nodes; writers,
+     * shell verifiers, hard gates, and dynamic/decision nodes remain fail-closed.
+     * Every id must also appear in depends_on.
+     */
+    failureAwareDependsOn: z.array(z.string()).optional(),
+    /** Execute only when this fail-closed condition resolves true after dependencies settle. */
+    runIf: z.string().min(1).optional(),
+    complexity: dagComplexitySchema,
+    subtask_prompt: z.string().min(1),
+    subtask_prompt_source: z
+        .object({
+        type: z.literal("markdown"),
+        path: z.string().min(1),
+        sha256: z.string().min(1),
+    })
+        .optional(),
+    executor: dagNodeExecutorSchema.optional().default("pi"),
+    role: dagRoleSchema.optional(),
+    skills: z.array(z.string()).optional(),
+    toolProfile: dagToolProfileSchema.optional(),
+    /** Default deny: file write (toolProfile=write) does not grant command execution. */
+    commandPolicy: dagCommandPolicySchema.optional(),
+    writePolicy: dagWritePolicySchema.optional(),
+    writeSet: z.array(z.string()).optional(),
+    piStep: z.string().optional(),
+    shell: dagShellConfigSchema.optional(),
+    static: dagStaticConfigSchema.optional(),
+    outputContract: z.string().optional(),
+    outputMode: dagOutputModeSchema.optional(),
+    firstProtocolLine: z.string().min(1).optional(),
+    /**
+     * Machine-readable output protocol (phase 1: first-line-enum).
+     * When set with retryOnInvalid, protocol-invalid failures may auto-retry
+     * on safe read-only Pi nodes before the node becomes ERROR.
+     */
+    outputProtocol: dagOutputProtocolSchema.optional(),
+    /**
+     * Node-level structured contract self-check: after the Pi output is
+     * produced, validate it against the named contract schema at the node so
+     * schema/typo/null violations become invalid-output (retryable on the node)
+     * instead of failing later at a downstream deterministic gate. Validators
+     * are resolved via the contract output registry keyed by schemaId.
+     */
+    structuredContractOutput: z
+        .object({
+        schemaId: z.enum(structuredContractOutputSchemaIds),
+        retryOnInvalid: z.boolean().default(true),
+        /**
+         * Optional deterministic base object for patch-producing structured
+         * nodes. The frontend plan patch validator applies the model delta to
+         * this run-owned skeleton before strict contract validation.
+         */
+        skeleton: z.record(z.string(), z.unknown()).optional(),
+    })
+        .strict()
+        .superRefine((value, ctx) => {
+        if (value.schemaId ===
+            "frontend-implementation-contract-plan-patch-v1" &&
+            !value.skeleton) {
+            ctx.addIssue({
+                code: "custom",
+                message: "frontend plan patch output requires a runtime skeleton",
+                path: ["skeleton"],
+            });
+        }
+    })
+        .optional(),
+    /**
+     * Fail-closed outcome/diff consistency contract for bounded Pi writers.
+     * The writer must begin with IMPLEMENTATION_OUTCOME: changed,
+     * already-satisfied, or blocked; the executor checks it against the
+     * run-attributed diff.
+     */
+    writerOutcomePolicy: dagWriterOutcomePolicySchema.optional(),
+    /** full (default): git baseline + post-diff write-guard. tools-only: keep tool sandbox, skip git baseline/post-diff hard fail (frontend-test). */
+    writeGuardPolicy: dagWriteGuardPolicySchema.optional(),
+    /** Required for supervised writers that consume a final audited writeSet. */
+    finalWriteSetApproval: dagFinalWriteSetApprovalBindingSchema.optional(),
+    /** Runtime-only authorization facts injected after final approval validation. */
+    resolvedFinalWriteSetApproval: z
+        .object({
+        approvalDigest: z.string().regex(/^[a-f0-9]{64}$/),
+        approvalSourceNodeId: z.string().min(1),
+    })
+        .strict()
+        .optional(),
+    /**
+     * Explicit opt-in for the deterministic project governance context resolver
+     * (AGENTS.md chain + referenced code standards). Only tasks that set this
+     * to `true` receive a `<project_governance_context>` prompt section and
+     * closeout-blocking gate behavior. Never inferred from role/name.
+     */
+    governanceStandardReview: z.boolean().optional(),
+    allowedPaths: z.array(z.string()).optional().default([]),
+    forbiddenPaths: z.array(z.string()).optional().default([]),
+    decisionGate: dagDecisionGateSchema.optional(),
+    retryPolicy: dagRetryPolicySchema.optional(),
+    /** Optional per-node adaptive liveness override (merged over defaults). */
+    livenessPolicy: dagLivenessPolicySchema,
+    dynamicExpansion: dagDynamicExpansionSchema.optional(),
+    dynamicReduction: dagDynamicReductionSchema.optional(),
+    dynamicCondition: dagDynamicConditionSchema.optional(),
+    dynamicLoopUntil: dagDynamicLoopUntilSchema.optional(),
+});
+export const dagModelsSchema = z
+    .object({
+    HIGH: z.string().optional(),
+    MED: z.string().optional(),
+    LOW: z.string().optional(),
+})
+    .partial();
+export const dagExecutorModelsSchema = z
+    .object({
+    pi: dagModelsSchema.optional(),
+})
+    .strict();
+export const dagOutputLanguageSchema = z.enum(["zh-CN", "en"]);
+export const DEFAULT_DAG_OUTPUT_LANGUAGE = "zh-CN";
+export const dagEvaluationBindingSchema = z
+    .object({
+    campaignId: z.string().min(1),
+    candidateId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
+    bundleHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    seed: z.number().int().nonnegative(),
+    split: z.enum(["public", "private", "held_out"]).optional(),
+    taskRef: z.string().min(1).optional(),
+})
+    .strict();
+/** Eval Lab Campaign Budget (W3.4); enforced by runner ledger when mode=hard. */
+export const dagBudgetSchema = campaignBudgetSchema;
+export const dagSourceBindingSchema = z.object({
+    schemaVersion: z.literal(1),
+    taskId: z.string().min(1),
+    sources: z
+        .array(z.object({
+        kind: z.enum(["requirement", "constraint", "reference"]),
+        path: z.string().min(1),
+        sha256: z
+            .string()
+            .regex(/^[a-f0-9]{64}$/, "sha256 must be lowercase hex"),
+    }))
+        .min(1),
+    requirementIds: z.array(z.string().regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/)),
+});
+export const dagSpecSchema = z
+    .object({
+    version: dagVersionSchema,
+    title: z.string().min(1),
+    runtimeContract: dagRuntimeContractSchema.optional(),
+    evaluation: dagEvaluationBindingSchema.optional(),
+    /** Optional hard/record-only budget; requires version 3 or 4. */
+    budget: dagBudgetSchema.optional(),
+    sourceBinding: dagSourceBindingSchema.optional(),
+    /** v4 managed Task Contract binding; only valid on version 4. */
+    taskContractBinding: dagTaskContractBindingSchema.optional(),
+    /** Frozen backend-test artifact layout (plan A); absent = historical default testcase/ layout. */
+    backendTestLayout: z
+        .object({
+        testRoot: z.string(),
+        markdownRel: z.string(),
+        scriptRel: z.string(),
+        markdownDir: z.string(),
+        scriptDir: z.string(),
+        readmePath: z.string(),
+        isDefault: z.boolean(),
+    })
+        .optional(),
+    /** Bound user shared-setup document (plan B); absent = no shared setup references expected. */
+    backendTestSharedSetup: z
+        .object({
+        path: z.string(),
+        readPath: z.string(),
+        sha256: z.string(),
+    })
+        .optional(),
+    outputLanguage: dagOutputLanguageSchema.optional(),
+    objective: z.string().optional(),
+    successCriteria: z.array(z.string()).optional(),
+    globalConstraints: z.array(z.string()).optional(),
+    convergence: dagConvergenceSpecSchema,
+    verifyStrategy: dagVerifyStrategySchema,
+    defaults: dagDefaultsSchema,
+    skillsByRole: z.record(z.string(), z.array(z.string())).optional(),
+    executorModels: dagExecutorModelsSchema.optional(),
+    /** Generation-time advisories surfaced as machine-visible warnings. */
+    advisories: z.array(z.string()).optional(),
+    tasks: z.array(dagTaskSchema).min(1),
+})
+    .superRefine((spec, ctx) => {
+    const supportsV3Fields = spec.version === 3 || spec.version === 4;
+    if (spec.evaluation && !supportsV3Fields) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "evaluation requires DagSpec version 3 or 4",
+            path: ["evaluation"],
+        });
+    }
+    if (spec.budget && !supportsV3Fields) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "budget requires DagSpec version 3 or 4",
+            path: ["budget"],
+        });
+    }
+    if (spec.runtimeContract && !supportsV3Fields) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "runtimeContract requires DagSpec version 3 or 4",
+            path: ["version"],
+        });
+    }
+    if (supportsV3Fields && !spec.runtimeContract) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `DagSpec version ${spec.version} requires runtimeContract`,
+            path: ["runtimeContract"],
+        });
+    }
+    if (spec.taskContractBinding && spec.version !== 4) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "taskContractBinding requires DagSpec version 4",
+            path: ["taskContractBinding"],
+        });
+    }
+    if (spec.version === 4) {
+        if (!spec.sourceBinding) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "DagSpec version 4 requires sourceBinding",
+                path: ["sourceBinding"],
+            });
+        }
+        if (!spec.taskContractBinding) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "DagSpec version 4 requires taskContractBinding",
+                path: ["taskContractBinding"],
+            });
+        }
+        if (!spec.runtimeContract) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "DagSpec version 4 requires runtimeContract",
+                path: ["runtimeContract"],
+            });
+        }
+    }
+    // Catch raw cursor keys that Zod .strict() on nested objects already rejects when parsed
+    // via parseDagSpec; this refine covers typed object construction paths.
+    const models = spec.executorModels;
+    if (models && "cursor" in models) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: CURSOR_EXECUTOR_MODELS_REMOVED_ERROR,
+            path: ["executorModels", "cursor"],
+        });
+    }
+});
+export const FRONTEND_RECOVERY_STATE_SCHEMA_VERSION = 1;
+export const FRONTEND_RECOVERY_RESULT_SCHEMA_VERSION = 1;
+/**
+ * Frontend candidate-continuation recovery phase (decision B, phase-3 subset).
+ * Phase 3a parents converge first, so `rollback-pending` is not produced and
+ * was removed by AC-1; the phase starts at `child-staging` and ends at
+ * `settled`.
+ */
+export const frontendRecoveryPhaseSchema = z.enum([
+    "child-staging",
+    "child-activating",
+    "child-running",
+    "settled",
+]);
+/**
+ * Single-writer recovery intent/lineage stored on `DagRunState`. The parent run
+ * owns the authoritative copy and advances it via revision-guarded CAS writes;
+ * the child carries a frozen lineage snapshot so the activation gate can prove
+ * it is the reserved child of a child-running parent.
+ *
+ * Invariants: `attemptIndex ∈ {0,1}`; `continuationCount ∈ {0,1}`; a child's
+ * `recoveryRootRunId` always equals the root runId; `revision` is the CAS
+ * pre-comparison counter. `revision` monotonicity is enforced at runtime by the
+ * runner's `(existing?.revision ?? 0) + 1` CAS write (the schema only bounds it
+ * non-negative). `childRunId` may be absent through `child-activating` and must
+ * be non-empty from `child-running` onward.
+ */
+export const frontendRecoveryStateSchema = z
+    .object({
+    schemaVersion: z.literal(FRONTEND_RECOVERY_STATE_SCHEMA_VERSION),
+    phase: frontendRecoveryPhaseSchema,
+    requestId: z.string().min(1),
+    recoveryRootRunId: z.string().min(1),
+    parentRunId: z.string().min(1),
+    childRunId: z.string().min(1).optional(),
+    attemptId: z.string().min(1),
+    attemptIndex: z.number().int().min(0).max(1),
+    continuationCount: z.number().int().min(0).max(1),
+    /** Node id of the reset-closure root: frontend-plan-pi /
+     *  frontend-plan-revision-pi / frontend-prewrite-gate-shell /
+     *  frontend-implement-pi (writer partial write). */
+    failureSource: z.string().min(1).optional(),
+    revision: z.number().int().nonnegative(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    const requiresChild = value.phase === "child-running" || value.phase === "settled";
+    if (requiresChild && !value.childRunId) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `phase ${value.phase} requires a non-empty childRunId`,
+            path: ["childRunId"],
+        });
+    }
+});
+export const frontendRecoveryOutcomeSchema = z.enum([
+    "none",
+    "recovered",
+    "candidate-contract-invalid",
+    "prewrite-blocked",
+    "repair-exhausted",
+    "auto-recovery-blocked",
+]);
+export const frontendRecoveryOriginSchema = z
+    .object({
+    kind: z.enum(["frontend-prewrite-gate", "frontend-writer"]),
+    parentRunId: z.string().min(1),
+    childRunId: z.string().min(1).optional(),
+    requestId: z.string().min(1),
+    failedNodeId: z.string(),
+})
+    .strict();
+export const frontendRecoveryFailureClassSchema = z
+    .object({
+    code: z.enum([
+        "candidate-contract-invalid",
+        "prewrite-blocked",
+        "staging-failed",
+        "writer-transient-partial-write",
+    ]),
+    classification: z.string(),
+    reason: z.string(),
+})
+    .strict();
+export const frontendRecoveryEvidenceRefSchema = z
+    .object({
+    runId: z.string().min(1),
+    relativePath: z.string().min(1),
+    sha256: z.string().min(1),
+})
+    .strict();
+/**
+ * Terminal frontend recovery result. `failureClass` is absent for `none`,
+ * `recovered` and `auto-recovery-blocked` outcomes. The schema intentionally
+ * stays permissive (failureClass optional, evidenceRefs may be empty) so it
+ * accepts the runner's actual phase-3a products, which do not always carry a
+ * failure class or evidence reference.
+ */
+export const frontendRecoveryResultSchema = z
+    .object({
+    schemaVersion: z.literal(FRONTEND_RECOVERY_RESULT_SCHEMA_VERSION),
+    outcome: frontendRecoveryOutcomeSchema,
+    origin: frontendRecoveryOriginSchema,
+    failureClass: frontendRecoveryFailureClassSchema.optional(),
+    evidenceRefs: z.array(frontendRecoveryEvidenceRefSchema),
+})
+    .strict();
+export const DEFAULT_DAG_EXECUTOR_MODELS = {
+    pi: {
+        LOW: "gpt-5.3-codex-spark",
+        MED: "gpt-5.5",
+        HIGH: "gpt-5.5",
+    },
+};
+export const DEFAULT_DAG_PI_MODELS = DEFAULT_DAG_EXECUTOR_MODELS.pi;
+export const LEGACY_TOP_LEVEL_MODELS_ERROR = 'top-level "models" is no longer supported; use "executorModels"';
+export function parseDagSpec(raw) {
+    assertDagPromptSourceRule(raw, { allowMarkdown: false });
+    if (typeof raw === "object" && raw !== null && "models" in raw) {
+        throw new Error(LEGACY_TOP_LEVEL_MODELS_ERROR);
+    }
+    if (typeof raw === "object" && raw !== null) {
+        const obj = raw;
+        const executorModels = obj.executorModels;
+        if (typeof executorModels === "object" &&
+            executorModels !== null &&
+            "cursor" in executorModels) {
+            throw new Error(CURSOR_EXECUTOR_MODELS_REMOVED_ERROR);
+        }
+        const tasks = obj.tasks;
+        if (Array.isArray(tasks)) {
+            for (const task of tasks) {
+                if (typeof task === "object" &&
+                    task !== null &&
+                    task.executor === "cursor") {
+                    throw new Error(CURSOR_DAG_EXECUTOR_REMOVED_ERROR);
+                }
+            }
+        }
+        const defaults = obj.defaults;
+        if (typeof defaults === "object" &&
+            defaults !== null &&
+            defaults.executor === "cursor") {
+            throw new Error(CURSOR_DAG_EXECUTOR_REMOVED_ERROR);
+        }
+    }
+    return dagSpecSchema.parse(raw);
+}
+export function resolveModelForTask(task, executorModels) {
+    if (task.executor === "shell" || task.executor === "static") {
+        return undefined;
+    }
+    return (executorModels?.[task.executor]?.[task.complexity] ??
+        DEFAULT_DAG_EXECUTOR_MODELS[task.executor][task.complexity]);
+}