@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.11

package/dist/workflows/dag/scheduler.js

@@ -3,7 +3,8 @@ import path from "node:path";
 import { isPauseOnHumanDecisionGate } from "./decision-envelope.js";
 import { evaluateConditionExpression } from "./dynamic-runtime/condition.js";
 import { sha256Hex } from "./frontend-implementation-contract.js";
-import { frontendPrewriteResultV1Schema, FRONTEND_PREWRITE_RESULT_ARTIFACT_NAME, } from "./frontend-prewrite-gate.js";
+import { boundaryForTargetNode, computeFrontendShapeNodeDigest, evaluateFrontendShapeBoundary, } from "./frontend-shape-facts.js";
+import { FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT, frontendWriterAdmissionResultV1Schema, normalizeConcreteWriteSetPath, } from "./frontend-writer-admission.js";
 import { FRONTEND_RECOVERY_IMPORT_MANIFEST_REL_PATH, FRONTEND_RECOVERY_INTENT_REL_DIR, } from "./frontend-recovery-plan.js";
 export function isConditionSkippedReason(reason) {
     return Boolean(reason?.startsWith("condition "));
@@ -111,16 +112,25 @@ async function mapConcurrent(items, limit, fn) {
 }
 export const FRONTEND_WRITER_NODE_IDS = [
     "frontend-implement-pi",
-    "frontend-repair-pi",
 ];
-/** Run-relative artifact location written by the prewrite gate generator. */
-export const FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT = path.posix.join("contracts", FRONTEND_PREWRITE_RESULT_ARTIFACT_NAME);
 /**
- * Read and validate the frontend-prewrite-result-v1 artifact. Fail-closed:
- * a missing file or invalid payload returns ok:false and never throws.
+ * Run-relative artifact location read by the frontend writer admission gate.
+ * M8 re-pointed the legacy prewrite-result source at the new
+ * frontend-writer-admission-result.json artifact (written by the
+ * frontend-writer-admission-shell); the exported name is retained because
+ * runner.ts / node-execution.ts reference it as the admission evidence source.
+ */
+export const FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT = FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT;
+export { FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT };
+/**
+ * Read and validate the writer admission result artifact.
+ * Fail-closed: a missing file or invalid payload returns ok:false and never
+ * throws. This is the M8 write authorization source (replaces the legacy
+ * frontend-prewrite-result-v1 for dispatch; the legacy artifact remains
+ * produced only by the shadow `runFrontendPrewriteGate` library export).
  */
 export async function readFrontendPrewriteResult(runDir) {
-    const artifactPath = path.join(runDir, "contracts", FRONTEND_PREWRITE_RESULT_ARTIFACT_NAME);
+    const artifactPath = path.join(runDir, FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT);
     let raw;
     try {
         raw = await readFile(artifactPath, "utf8");
@@ -129,7 +139,7 @@ export async function readFrontendPrewriteResult(runDir) {
         if (error.code === "ENOENT") {
             return {
                 ok: false,
-                reason: `frontend prewrite result artifact missing: ${artifactPath}`,
+                reason: `frontend writer admission artifact missing: ${artifactPath}`,
             };
         }
         throw error;
@@ -142,24 +152,29 @@ export async function readFrontendPrewriteResult(runDir) {
     catch (error) {
         return {
             ok: false,
-            reason: `frontend prewrite result artifact is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+            reason: `frontend writer admission artifact is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
-    const result = frontendPrewriteResultV1Schema.safeParse(parsed);
+    const result = frontendWriterAdmissionResultV1Schema.safeParse(parsed);
     if (!result.success) {
         return {
             ok: false,
-            reason: "frontend prewrite result artifact failed schema validation",
+            reason: "frontend writer admission artifact failed schema validation",
         };
     }
     return { ok: true, result: result.data, artifactHash };
 }
-/** Authorize only accepted / accepted-normalized classifications. */
+/**
+ * M8 alias: read the writer admission result artifact under the explicit name.
+ * Same fail-closed semantics as `readFrontendPrewriteResult`.
+ */
+export async function readFrontendWriterAdmissionResult(runDir) {
+    return readFrontendPrewriteResult(runDir);
+}
+/** Authorize only the `accepted` classification (four-state admission).
+ * `requires-human-approval`, `blocked`, and `stale` are all denied. */
 export function isFrontendWriterAuthorized(result) {
-    return result.classification === "accepted" ||
-        result.classification === "accepted-normalized"
-        ? "authorized"
-        : "denied";
+    return result.classification === "accepted" ? "authorized" : "denied";
 }
 /** Fail-closed: leave no PENDING nodes that look "still scheduled" after abort. */
 export function markPendingNodesControllerInterrupted(state, reason = "run aborted by controller (abortSignal)") {
@@ -399,6 +414,12 @@ export async function executeDagRanksOnce(input) {
                     continue;
                 }
                 const decision = isFrontendWriterAuthorized(admission.result);
+                const normalizedWriteSet = admission.result.writeSet
+                    .map(normalizeConcreteWriteSetPath)
+                    .filter((entry) => entry !== undefined);
+                const concreteWriteSetValid = (admission.result.writeSet.length > 0 &&
+                    normalizedWriteSet.length === admission.result.writeSet.length &&
+                    new Set(normalizedWriteSet).size === normalizedWriteSet.length);
                 node.frontendWriterAdmission = {
                     schemaVersion: 1,
                     writerNodeId: id,
@@ -410,18 +431,110 @@ export async function executeDagRanksOnce(input) {
                         ? `classification: ${admission.result.classification}`
                         : null,
                 };
-                if (decision === "denied") {
+                if (decision === "denied" || !concreteWriteSetValid) {
+                    node.frontendWriterAdmission.reason = decision === "denied"
+                        ? `classification: ${admission.result.classification}`
+                        : "admission writeSet is not a concrete unique path set";
                     node.status = "SKIPPED";
                     node.skippedReason = "frontend-prewrite-not-authorized";
                     node.finishedAt = checkedAt;
                     frontendAdmissionSettled.push(id);
                 }
+                else {
+                    node.runtimeWriteAuthorization = {
+                        schemaVersion: 1,
+                        status: "validated",
+                        approvalSourceNodeId: FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT,
+                        approvalDigest: admission.result.admissionDigest,
+                        effectiveWriteSet: normalizedWriteSet,
+                    };
+                }
             }
             if (frontendAdmissionSettled.length > 0)
                 await input.persistState();
         }
         const frontendAdmissionSkippedSet = new Set(frontendAdmissionSettled);
         const runnableAfterAdmission = actuallyRunnable.filter((id) => !frontendAdmissionSkippedSet.has(id));
+        // Shape boundaries are rank gates: evaluate every protected candidate
+        // before creating an executor or starting any sibling in the rank.
+        const shapeBlocked = new Set();
+        const checkedBoundaries = new Set();
+        let shapeTerminalCommitted = false;
+        for (const id of runnableAfterAdmission) {
+            const mapping = boundaryForTargetNode(id);
+            if (!mapping || checkedBoundaries.has(mapping.boundary))
+                continue;
+            checkedBoundaries.add(mapping.boundary);
+            const sourceNode = input.state.nodes[mapping.sourceNodeId];
+            const fact = input.state.frontendShapeState?.committedFacts[mapping.boundary];
+            const outcome = evaluateFrontendShapeBoundary({
+                boundary: mapping.boundary,
+                sourceNode: sourceNode
+                    ? { status: sourceNode.status, digest: computeFrontendShapeNodeDigest(sourceNode) }
+                    : undefined,
+                fact,
+            });
+            if (outcome.kind === "continue") {
+                if (input.state.frontendShapeState) {
+                    input.state.frontendShapeState.lastBoundary = mapping.boundary;
+                    input.state.frontendShapeState.lastOutcome = outcome.kind;
+                    await input.persistState();
+                }
+                continue;
+            }
+            if (outcome.kind === "blocked") {
+                if (input.state.frontendShapeState) {
+                    input.state.frontendShapeState.lastBoundary = mapping.boundary;
+                    input.state.frontendShapeState.lastOutcome = outcome.kind;
+                }
+                const finishedAt = new Date().toISOString();
+                for (const targetId of mapping.targetNodeIds) {
+                    if (!runnableAfterAdmission.includes(targetId))
+                        continue;
+                    const node = input.state.nodes[targetId];
+                    if (!node || node.status !== "PENDING")
+                        continue;
+                    node.status = "SKIPPED";
+                    node.skippedReason = outcome.reason;
+                    node.finishedAt = finishedAt;
+                    shapeBlocked.add(targetId);
+                }
+                await input.persistState();
+                continue;
+            }
+            if (!fact || !input.commitFrontendShapeTransition) {
+                const finishedAt = new Date().toISOString();
+                for (const targetId of mapping.targetNodeIds) {
+                    const node = input.state.nodes[targetId];
+                    if (!node || node.status !== "PENDING")
+                        continue;
+                    node.status = "SKIPPED";
+                    node.skippedReason = "frontend-shape-transition-cas-unavailable";
+                    node.finishedAt = finishedAt;
+                    shapeBlocked.add(targetId);
+                }
+                await input.persistState();
+                continue;
+            }
+            const committed = await input.commitFrontendShapeTransition({
+                boundary: mapping.boundary,
+                outcome: outcome.kind,
+                reason: outcome.reason,
+                expectedRevision: input.state.frontendShapeState?.revision ?? 0,
+                fact,
+            });
+            if (committed.ok) {
+                shapeTerminalCommitted = true;
+                break;
+            }
+            // A failed transition CAS must remain zero-write. Stop the controller
+            // before any executor starts; never compensate with a capsule-less
+            // terminal state or mutate pending descendants.
+            throw new Error(`frontend shape transition CAS failed at ${mapping.boundary}: ${committed.reason}`);
+        }
+        if (shapeTerminalCommitted)
+            break;
+        const runnableAfterShape = runnableAfterAdmission.filter((id) => !shapeBlocked.has(id));
         const blocked = pending.filter((id) => {
             const task = input.tasksById.get(id);
             return (dependencyReadiness(task, input.state.nodes, input.tasksById) === "skip");
@@ -436,12 +549,12 @@ export async function executeDagRanksOnce(input) {
         if (blocked.length > 0) {
             await input.persistState();
         }
-        const pauseGateRunnable = runnableAfterAdmission.filter((id) => {
+        const pauseGateRunnable = runnableAfterShape.filter((id) => {
             const task = input.tasksById.get(id);
             return isPauseOnHumanDecisionGate(task);
         });
-        const regularRunnable = runnableAfterAdmission.filter((id) => !pauseGateRunnable.includes(id));
-        const rankWriterNodeIds = runnableAfterAdmission.filter((id) => {
+        const regularRunnable = runnableAfterShape.filter((id) => !pauseGateRunnable.includes(id));
+        const rankWriterNodeIds = runnableAfterShape.filter((id) => {
             const task = input.tasksById.get(id);
             return (task?.executor === "pi" &&
                 task.toolProfile === "write" &&

package/dist/workflows/dag/types.js

@@ -1,8 +1,13 @@
 import { z } from "zod";
-import { isOpenspecSpecFilePath } from "../../shared/openspec-spec.js";
+import { DEFAULT_FRONTEND_SPEC_ROOTS, isFrontendSpecFilePath, isValidFrontendSpecRoot, OPENSPEC_SPEC_EXT_RE, } from "../../shared/openspec-spec.js";
 import { campaignBudgetSchema, } from "../../application/evaluation/budget.js";
 import { assertDagPromptSourceRule } from "./prompt-source.js";
-import { dagRetryPolicySchema, TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE, } from "./retry-policy.js";
+// Leaf-module import: dagRetryPolicySchema must be defined by a module that
+// never transitively reaches types.ts during init (retry-policy does, via
+// frontend-recovery-capsule → frontend-recovery-lineage →
+// frontend-implementation-contract), or a run whose entry module initializes
+// retry-policy first reads an undefined schema here.
+import { dagRetryPolicySchema, TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE, } from "./dag-retry-schema.js";
 import { dagLivenessPolicySchema, } from "./liveness-policy.js";
 import { dagOutputProtocolSchema } from "./output-protocol.js";
 export const dagComplexitySchema = z.enum(["HIGH", "MED", "LOW"]);
@@ -82,7 +87,7 @@ export const dagShellVerifyEvidenceSchema = z.object({
     preflight: z
         .array(z.object({
         label: z.string(),
-        status: z.enum(["ok", "future-delivery-script"]),
+        status: z.enum(["ok", "future-delivery-script", "future-test-target"]),
     }))
         .default([]),
     /** Effective timeout applied independently to each shell command. */
@@ -188,7 +193,16 @@ const dagFrontendNodeIdSchema = z
     .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/");
+    .refine((candidate) => !candidate.includes("\\") &&
+    !candidate.startsWith("/") &&
+    !candidate.split("/").includes("..") &&
+    OPENSPEC_SPEC_EXT_RE.test(candidate), "openspec candidate must be a repo-relative supported specification file");
+const openspecCandidateSnapshotSchema = z
+    .object({
+    path: openspecCandidatePathSchema,
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+})
+    .strict();
 export const dagFrontendPrewriteGateSchema = z.object({
     schemaVersion: z.literal(1),
     planFromNodeId: dagFrontendNodeIdSchema,
@@ -207,7 +221,24 @@ export const dagFrontendPrewriteGateSchema = z.object({
     outputDir: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/),
     requireSourceFreshness: z.literal(true),
     implementationWriteSet: z.array(z.string().min(1)).min(1).optional(),
+    /**
+     * Generation-frozen roots that bound custom normative directories. Omitted
+     * legacy DAGs retain the canonical OpenSpec + ai_workspace roots.
+     */
+    openspecSpecRoots: z
+        .array(z.string().refine((root) => isValidFrontendSpecRoot(root), "openspec spec root must be a normalized repo-relative directory"))
+        .optional(),
     openspecCandidatePaths: z.array(openspecCandidatePathSchema).default([]),
+    /** Read-only selector output; omitted for scan-strict and legacy DAGs. */
+    openspecSelectionNodeId: dagFrontendNodeIdSchema.optional(),
+    /** Contract-declared and source-explicit paths that cannot be downgraded. */
+    openspecMandatoryPaths: z.array(openspecCandidatePathSchema).optional(),
+    /**
+     * Content fingerprints frozen with the generation-time OpenSpec scope. New
+     * DAGs use these to reject a plan whose cited specification changed after it
+     * was read; legacy DAGs without the field retain existence-only drift checks.
+     */
+    openspecCandidateSnapshots: z.array(openspecCandidateSnapshotSchema).optional(),
     /**
      * Generation-frozen component/theme specification bucket. Derived from
      * `designEvidence.classified.component ∪ theme ∪ rule.components` at DAG
@@ -252,14 +283,28 @@ export const dagFrontendPrewriteGateSchema = z.object({
         scanStrict: z.array(openspecCandidatePathSchema).default([]),
     })
         .optional(),
+}).superRefine((gate, context) => {
+    const roots = gate.openspecSpecRoots ?? DEFAULT_FRONTEND_SPEC_ROOTS;
+    const candidateGroups = [
+        ["openspecCandidatePaths", gate.openspecCandidatePaths],
+        ["openspecMandatoryPaths", gate.openspecMandatoryPaths],
+        ["componentSpecCandidatePaths", gate.componentSpecCandidatePaths],
+        ["openspecCandidateSources.declared", gate.openspecCandidateSources?.declared],
+        ["openspecCandidateSources.taskSourceCited", gate.openspecCandidateSources?.taskSourceCited],
+        ["openspecCandidateSources.scanStrict", gate.openspecCandidateSources?.scanStrict],
+    ];
+    for (const [field, paths] of candidateGroups) {
+        for (const [index, candidate] of (paths ?? []).entries()) {
+            if (!isFrontendSpecFilePath(candidate, roots)) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: [...field.split("."), index],
+                    message: "openspec candidate must be a supported file under the generation-frozen openspec spec roots",
+                });
+            }
+        }
+    }
 });
-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),
@@ -273,6 +318,10 @@ export const dagFrontendVerificationBundleSchema = z
     behaviorEvidence: dagShellVerifyEvidenceSchema,
     lintBaselineNodeId: dagFrontendNodeIdSchema.optional(),
     writerNodeIds: z.array(dagFrontendNodeIdSchema).optional(),
+    /** "initial" = first-pass assess bundle; "repair" = the convergence
+     * loop's post-repair reverify, which re-runs the same frozen commands
+     * and fails on any failure (still no same-run repair branch inside the
+     * node itself). */
     mode: z.enum(["initial", "repair"]),
 })
     .superRefine((bundle, context) => {
@@ -348,6 +397,135 @@ export const dagFrontendReviewContextSchema = z.object({
     schemaVersion: z.literal(1),
     requireBaseline: z.literal(true),
 });
+/**
+ * Deterministic frontend contract-import shell (micro topology). Re-validates
+ * the generation-frozen managed Contract's source/binding/schema freshness and
+ * emits a digest. It never invokes a model and never rewrites requirements —
+ * micro requires a pre-validated managed Contract, not natural-language intake.
+ */
+export const dagFrontendContractImportSchema = z.object({
+    schemaVersion: z.literal(1),
+    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),
+});
+/**
+ * Deterministic frontend design-policy shell (M8). Materializes the canonical
+ * implementation contract from the plan node and evaluates the design policy
+ * (Mock strategy, source freshness, component spec candidates, writeSet
+ * patterns, allowed dependencies). Runs BEFORE frontend-design-review-pi, so it
+ * never consumes a design verdict; the verdict is enforced by the writer
+ * admission shell instead. Replaces the prewrite-gate authorization path.
+ */
+export const dagFrontendDesignPolicySchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    planFromNodeId: dagFrontendNodeIdSchema,
+    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(),
+    /** Generation-frozen roots that bound custom normative directories. */
+    openspecSpecRoots: z
+        .array(z.string().refine((root) => isValidFrontendSpecRoot(root), "openspec spec root must be a normalized repo-relative directory"))
+        .optional(),
+    openspecCandidatePaths: z.array(openspecCandidatePathSchema).default([]),
+    /** Read-only selector output; omitted for scan-strict and legacy DAGs. */
+    openspecSelectionNodeId: dagFrontendNodeIdSchema.optional(),
+    /** Contract-declared and source-explicit paths that cannot be downgraded. */
+    openspecMandatoryPaths: z.array(openspecCandidatePathSchema).optional(),
+    openspecCandidateSnapshots: z
+        .array(openspecCandidateSnapshotSchema)
+        .optional(),
+    /**
+     * 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 design policy requires a non-empty `uiComponentChoices` and
+     * cross-checks each `specReference.path` against this set + the effective
+     * plan openspec-citations block.
+     */
+    componentSpecCandidatePaths: z.array(openspecCandidatePathSchema).optional(),
+    /** OpenSpec gate policy (cited | scan-strict); generation always writes it. */
+    openspecPolicy: z.enum(["cited", "scan-strict"]).optional(),
+    /** Generation-frozen candidate source metadata (diagnostic). */
+    openspecCandidateSources: z
+        .object({
+        declared: z.array(openspecCandidatePathSchema).default([]),
+        taskSourceCited: z.array(openspecCandidatePathSchema).default([]),
+        scanStrict: z.array(openspecCandidatePathSchema).default([]),
+    })
+        .optional(),
+    /** Dependency identifiers authorized at generation time (empty = none). */
+    allowedDependencies: z.array(z.string()).default([]),
+})
+    .superRefine((gate, context) => {
+    const roots = gate.openspecSpecRoots ?? DEFAULT_FRONTEND_SPEC_ROOTS;
+    const candidateGroups = [
+        ["openspecCandidatePaths", gate.openspecCandidatePaths],
+        ["openspecMandatoryPaths", gate.openspecMandatoryPaths],
+        ["componentSpecCandidatePaths", gate.componentSpecCandidatePaths],
+        ["openspecCandidateSources.declared", gate.openspecCandidateSources?.declared],
+        ["openspecCandidateSources.taskSourceCited", gate.openspecCandidateSources?.taskSourceCited],
+        ["openspecCandidateSources.scanStrict", gate.openspecCandidateSources?.scanStrict],
+    ];
+    for (const [field, paths] of candidateGroups) {
+        for (const [index, candidate] of (paths ?? []).entries()) {
+            if (!isFrontendSpecFilePath(candidate, roots)) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: [...field.split("."), index],
+                    message: "openspec candidate must be a supported file under the generation-frozen openspec spec roots",
+                });
+            }
+        }
+    }
+});
+/**
+ * Deterministic frontend writer-admission shell (M8). Runs after
+ * frontend-design-review-pi: freezes the writer baseline, derives the concrete
+ * writeSet, folds the design-policy result + design verdict into admission,
+ * and writes contracts/frontend-writer-admission-result.json
+ * (schemaId frontend-writer-admission-shell-v1).
+ */
+export const dagFrontendWriterAdmissionShellSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    /** Design verdict source (frontend-design-review-pi); pass is enforced.
+     * Omitted in small topology, which has no design review node. */
+    designReviewFromNodeId: dagFrontendNodeIdSchema.optional(),
+    /** Frozen command labels the verification bundle will execute. */
+    frozenCommandLabels: z.array(z.string()).default([]),
+    allowedMockStrategies: z
+        .array(z.enum(["native", "browser-intercept", "request-adapter", "not-needed"]))
+        .min(1),
+    /** Writer-preceding lint commands; baseline is materialized here (R5). */
+    lintCommands: z.array(z.string().min(1)).optional(),
+    lintEvidence: dagShellVerifyEvidenceSchema.optional(),
+})
+    .superRefine((admission, context) => {
+    if ((admission.lintCommands?.length ?? 0) > 0 && !admission.lintEvidence) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["lintEvidence"],
+            message: "lintEvidence is required when lintCommands are present",
+        });
+    }
+});
+/** Deterministic frontend closeout shell (M8). Renders the closeout from
+ * committed facts only (review context + typed review terminal + trace). */
+export const dagFrontendCloseoutSchema = z.object({
+    schemaVersion: z.literal(1),
+    reviewFromNodeId: dagFrontendNodeIdSchema,
+});
 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)])
@@ -395,7 +573,14 @@ export const dagWriteGuardPolicySchema = z.enum(["full", "tools-only", "filesyst
  */
 export const dagWriterOutcomePolicySchema = z
     .object({
-    type: z.literal("implementation-outcome-v1"),
+    /**
+     * Protocol face: `implementation-outcome-v1` keeps the legacy
+     * IMPLEMENTATION_OUTCOME first-line protocol (backend/README/module
+     * writers + frontend-repair-pi); `frontend-facts-v1` derives the status
+     * from mechanical facts (write-tool events / run delta / write guard /
+     * requirement coverage / focused-check) and never reads the first line.
+     */
+    type: z.enum(["implementation-outcome-v1", "frontend-facts-v1"]),
     /** Generation writers may forbid already-satisfied/no-diff completion. */
     requireChangedFiles: z.boolean().optional(),
 })
@@ -528,10 +713,13 @@ export const dagShellConfigSchema = z.object({
         .optional(),
     requirementCoverageGate: dagRequirementCoverageGateSchema.optional(),
     jsonArtifactGate: dagJsonArtifactGateSchema.optional(),
+    frontendDesignPolicy: dagFrontendDesignPolicySchema.optional(),
+    frontendWriterAdmission: dagFrontendWriterAdmissionShellSchema.optional(),
     frontendPrewriteGate: dagFrontendPrewriteGateSchema.optional(),
-    frontendLintBaseline: dagFrontendLintBaselineSchema.optional(),
     frontendVerificationBundle: dagFrontendVerificationBundleSchema.optional(),
     frontendReviewContext: dagFrontendReviewContextSchema.optional(),
+    frontendContractImport: dagFrontendContractImportSchema.optional(),
+    frontendCloseout: dagFrontendCloseoutSchema.optional(),
     frontendTestCaseChecklist: dagFrontendTestCaseChecklistSchema.optional(),
     frontendBrowserToolPreflight: dagFrontendBrowserToolPreflightSchema.optional(),
     frontendTestStandardScenarios: dagFrontendTestStandardScenariosSchema.optional(),
@@ -821,6 +1009,19 @@ export const dagTaskSchema = z.object({
     role: dagRoleSchema.optional(),
     skills: z.array(z.string()).optional(),
     toolProfile: dagToolProfileSchema.optional(),
+    /** Bounded read-only discovery budget for nodes that inspect a repository. */
+    readBudget: z
+        .object({
+        maxFiles: z.number().int().positive(),
+        maxBytes: z.number().int().positive(),
+        maxMs: z.number().int().positive().optional(),
+        /** Maximum read/grep/find/ls calls. */
+        maxOperations: z.number().int().positive().optional(),
+        /** On any read budget exhaustion, return concise completion guidance instead of failing the node. */
+        onExhaustion: z.enum(["return-guidance"]).optional(),
+    })
+        .strict()
+        .optional(),
     /**
      * Explicit Pi extension allowlist (backend implementation DAGs only):
      * frozen short ids resolved at run time against the Pi settings package
@@ -1189,6 +1390,22 @@ export const dagSpecSchema = z
     taskContractBinding: dagTaskContractBindingSchema.optional(),
     /** Optional unresolved parent-run feedback for a full task rerun. */
     rerunFeedback: dagRerunFeedbackSchema.optional(),
+    /** Frontend recovery continuation quota (frozen at generation time from
+     * task.json frontendRecovery.maxContinuations). Bounds how many times a
+     * failed frontend run may auto-recover via M6 recovery operations before
+     * the run stays failed and needs human intervention. */
+    frontendRecovery: z
+        .object({
+        maxContinuations: z
+            .number()
+            .int()
+            .min(1)
+            .max(5)
+            .optional()
+            .default(1),
+    })
+        .strict()
+        .optional(),
     /** Backend-test-only workspace mutation control; absent means Git. */
     backendTestWorkspaceControl: z.enum(["git", "filesystem-only"]).optional(),
     /** Frozen backend-test artifact layout (plan A); absent = historical default testcase/ layout. */
@@ -1315,6 +1532,9 @@ export const FRONTEND_RECOVERY_RESULT_SCHEMA_VERSION = 1;
  * 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`.
+ *
+ * @deprecated Read-only compatibility only; the M6 operation controller no
+ * longer uses this phase as the authoritative recovery entry point.
  */
 export const frontendRecoveryPhaseSchema = z.enum([
     "child-staging",
@@ -1328,12 +1548,16 @@ export const frontendRecoveryPhaseSchema = z.enum([
  * 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
+ * Invariants: `attemptIndex` and `continuationCount` are bounded by the frozen
+ * frontend recovery quota (currently 1-5); 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.
+ *
+ * @deprecated Read-only compatibility only; the runner no longer writes this
+ * intent (the M6 operation controller supervises recovery instead).
  */
 export const frontendRecoveryStateSchema = z
     .object({
@@ -1344,8 +1568,8 @@ export const frontendRecoveryStateSchema = z
     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),
+    attemptIndex: z.number().int().min(0).max(5),
+    continuationCount: z.number().int().min(0).max(5),
     /** Node id of the reset-closure root: frontend-plan-pi /
      *  frontend-plan-revision-pi / frontend-prewrite-gate-shell /
      *  frontend-implement-pi (writer partial write). */
@@ -1405,6 +1629,10 @@ export const frontendRecoveryEvidenceRefSchema = z
  * 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.
+ *
+ * @deprecated Read-only compatibility only; the M6 operation controller writes
+ * `recovered`/`auto-recovery-blocked` results directly and never uses this
+ * schema as the authoritative recovery settlement.
  */
 export const frontendRecoveryResultSchema = z
     .object({