@tea-agent/loop-agent 0.39.0-beta.2 → 0.39.0-beta.3

package/dist/workflows/dag/frontend-repair.js

@@ -1,9 +1,5 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
 import { z } from "zod";
-import { pathMatchesPattern } from "../../shared/git-progress.js";
-import { FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, frontendImplementationContractSchema, } from "./frontend-implementation-contract.js";
-export const FRONTEND_REPAIR_ASSESSMENT_SCHEMA_ID = "frontend-repair-assessment-v1";
+import { FRONTEND_NO_VERIFICATION_MARKER_TEXT, } from "./frontend-verification-trace.js";
 export const frontendRepairFailureClassSchema = z.enum([
     "typecheck",
     "build",
@@ -28,60 +24,17 @@ export const frontendCommandCategorySchema = z.enum([
     "unit-test",
     "trace",
 ]);
-const REPAIRABLE = new Set([
-    "typecheck",
-    "build",
-    "lint",
-    "component-test",
-    "unit-test",
-    "trace",
-]);
-export function isFrontendRepairable(failureClass) {
-    return REPAIRABLE.has(failureClass);
-}
-/**
- * Deterministic commandLabel → commandCategory mapping (AC-3).
- * `targetType` comes from the contract verificationTargets[].type
- * (static | unit | component | integration | mock); the literal commandLabel
- * wins over type so a `static` typecheck target is never misread as a test.
- */
-export function mapCommandLabelToCategory(commandLabel, targetType) {
-    const label = commandLabel.toLowerCase();
-    if (/(?:typecheck|check-types|type-check|\btsc\b)/.test(label))
-        return "typecheck";
-    if (/(?:vite\s+build|next\s+build|webpack|rollup|\bbuild\b)/.test(label))
-        return "build";
-    if (/(?:eslint|\blint\b)/.test(label))
-        return "lint";
-    if (targetType === "component")
-        return "component-test";
-    if (targetType === "unit")
-        return "unit-test";
-    if (/(?:component|testing-library|render\()/.test(label))
-        return "component-test";
-    return "unit-test";
-}
-export function isReviewRepairable(finding, implementWriteSet) {
-    const hasFile = Boolean(finding.file && finding.file.trim().length > 0);
-    const hasLocation = Boolean((finding.line !== undefined && finding.line > 0) ||
-        (finding.symbol && finding.symbol.trim().length > 0));
-    const hasRequirement = Boolean((finding.requirementId && finding.requirementId.trim().length > 0) ||
-        (finding.acceptanceCriteriaId &&
-            finding.acceptanceCriteriaId.trim().length > 0));
-    const fixScope = finding.fixScope ?? (hasFile ? [finding.file] : []);
-    const fixScopeSubset = fixScope.length > 0 &&
-        fixScope.every((entry) => isPathWithinWriteSet(entry, implementWriteSet));
-    return (hasFile &&
-        hasLocation &&
-        hasRequirement &&
-        fixScopeSubset &&
-        finding.requiresContractReplan !== true);
-}
 export function classifyFrontendFailure(input) {
     // AC-2: structured evidence takes priority over string-blob heuristics.
     if (input.failureCategory === "write-guard") {
         return "path";
     }
+    if (`${input.stderr ?? ""}\n${input.stdout ?? ""}`.includes(FRONTEND_NO_VERIFICATION_MARKER_TEXT)) {
+        // Verification unavailability is a generation-time contract gap: no
+        // authorized verification command exists. Bounded repair cannot fix it;
+        // the operator must declare commands and regenerate the DAG.
+        return "contract";
+    }
     if (input.traceTarget || input.commandCategory === "trace") {
         return "trace";
     }
@@ -169,373 +122,3 @@ export function classifyFrontendFailure(input) {
         return "path";
     return "unknown";
 }
-export const frontendRepairAssessmentSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    schemaId: z.literal(FRONTEND_REPAIR_ASSESSMENT_SCHEMA_ID),
-    contract: z
-        .object({
-        relativePath: z.string().min(1),
-        schemaId: z.string().min(1),
-    })
-        .strict(),
-    failedNodeIds: z.array(z.string().min(1)),
-    failureClass: frontendRepairFailureClassSchema,
-    eligible: z.boolean(),
-    reason: z.string().min(1),
-    attempt: z.number().int().min(1).max(2),
-    maxAttempts: z.literal(1),
-    allowedRepairWriteSet: z.array(z.string().min(1)),
-    evidenceRefs: z.array(z.string().min(1)),
-    browserStatus: z.literal("not-run"),
-    // AC-5 structured evidence fields (all optional so existing minimal
-    // fixtures and frontend-review-context safeParse stay compatible).
-    verificationTargetId: z.string().min(1).optional(),
-    commandLabel: z.string().min(1).optional(),
-    exitCode: z.number().int().optional(),
-    commandCategory: frontendCommandCategorySchema.optional(),
-    requirementIds: z.array(z.string().min(1)).optional(),
-    acceptanceCriteriaIds: z.array(z.string().min(1)).optional(),
-    fixScope: z.array(z.string().min(1)).optional(),
-    changedPaths: z.array(z.string().min(1)).optional(),
-    traceRef: z
-        .object({
-        relativePath: z.string().min(1),
-        schemaId: z.string().min(1),
-    })
-        .strict()
-        .optional(),
-})
-    .strict();
-function nodeHadFailure(record) {
-    if (record.status === "ERROR")
-        return true;
-    if (recordIndicatesCommandFailure(record))
-        return true;
-    const results = record.commandResults ?? [];
-    if (results.some((item) => item.ok === false))
-        return true;
-    return false;
-}
-function normalize(value) {
-    return value.replace(/\\/g, "/").replace(/^\.\//, "");
-}
-/**
- * Whether a concrete path or glob entry is contained by the implement writeSet.
- * Exact glob equality is the norm (repair writeSet === implement writeSet);
- * concrete (non-glob) paths may also be covered by an implement glob.
- */
-export function isPathWithinWriteSet(entry, implementWriteSet) {
-    const normalizedEntry = normalize(entry);
-    const normalizedImplement = implementWriteSet.map(normalize);
-    if (normalizedImplement.includes(normalizedEntry))
-        return true;
-    if (!normalizedEntry.includes("*")) {
-        return implementWriteSet.some((pattern) => pathMatchesPattern(normalizedEntry, pattern));
-    }
-    return false;
-}
-export function assertWriteSetSubset(repairWriteSet, implementWriteSet) {
-    for (const entry of repairWriteSet) {
-        if (!isPathWithinWriteSet(entry, implementWriteSet)) {
-            throw new Error(`repair writeSet entry "${entry}" is not ⊆ implement writeSet`);
-        }
-    }
-}
-async function loadImplementWriteSet(runDir, fallback) {
-    if (fallback.length > 0)
-        return fallback;
-    const candidates = ["run.json", "dag.json", "spec.json"];
-    for (const name of candidates) {
-        try {
-            const raw = JSON.parse(await readFile(path.join(runDir, name), "utf8"));
-            const tasks = raw.spec?.tasks ?? raw.tasks ?? [];
-            const implement = tasks.find((task) => task.id === "frontend-implement-pi");
-            if (implement?.writeSet?.length)
-                return implement.writeSet;
-        }
-        catch {
-            // continue
-        }
-    }
-    return fallback;
-}
-function matchVerificationTarget(contract, commandLabel, command) {
-    for (const target of contract.verificationTargets) {
-        if (commandLabel && target.commandLabel === commandLabel)
-            return target;
-        if (command &&
-            (command.includes(target.commandLabel) ||
-                target.commandLabel.includes(command))) {
-            return target;
-        }
-    }
-    return undefined;
-}
-function deriveFailureEvidence(input) {
-    const evidence = {};
-    for (const { record } of input.failed) {
-        const results = record.commandResults ?? [];
-        const failedResult = results.find((item) => item.ok === false) ?? results[0];
-        if (failedResult &&
-            evidence.exitCode === undefined &&
-            typeof failedResult.exitCode === "number") {
-            evidence.exitCode = failedResult.exitCode;
-        }
-        if (failedResult?.commandLabel && !evidence.commandLabel) {
-            evidence.commandLabel = failedResult.commandLabel;
-        }
-        // Structured trace facts passed by the verification bundle / trace gate.
-        const failedTraceTarget = (record.traceTargets ?? []).find((target) => target.status === "failed");
-        if (failedTraceTarget && !evidence.verificationTargetId) {
-            evidence.verificationTargetId = failedTraceTarget.id;
-            if (!evidence.commandLabel)
-                evidence.commandLabel = failedTraceTarget.commandLabel;
-            evidence.traceTarget = failedTraceTarget;
-            evidence.traceRef = {
-                relativePath: "contracts/frontend-verification-trace.json",
-                schemaId: "frontend-verification-trace-v1",
-            };
-        }
-        if (record.changedPaths?.length && !evidence.changedPaths) {
-            evidence.changedPaths = [...record.changedPaths];
-        }
-    }
-    // Resolve commandLabel → contract verification target → category + scope.
-    const target = matchVerificationTarget(input.contract, evidence.commandLabel);
-    if (target) {
-        if (!evidence.verificationTargetId)
-            evidence.verificationTargetId = target.id;
-        if (!evidence.commandLabel)
-            evidence.commandLabel = target.commandLabel;
-        evidence.requirementIds ??= [...target.requirementIds];
-        evidence.acceptanceCriteriaIds ??= [...target.requirementIds];
-        evidence.fixScope ??= [target.file];
-    }
-    if (evidence.commandLabel) {
-        evidence.commandCategory ??= mapCommandLabelToCategory(evidence.commandLabel, target?.type);
-    }
-    return evidence;
-}
-export async function runFrontendFailureAssessGate(input) {
-    const attempt = input.attempt ?? 1;
-    const implementWriteSet = await loadImplementWriteSet(input.runDir, input.implementWriteSet ?? []);
-    if (implementWriteSet.length === 0) {
-        throw new Error("assess: implement writeSet unavailable");
-    }
-    const contractRel = "contracts/frontend-implementation-contract.json";
-    const contractPath = path.join(input.runDir, contractRel);
-    let contractSchemaId = FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID;
-    let contract;
-    try {
-        const raw = JSON.parse(await readFile(contractPath, "utf8"));
-        const parsed = frontendImplementationContractSchema.safeParse(raw);
-        if (!parsed.success) {
-            throw new Error("invalid frontend implementation contract");
-        }
-        contract = parsed.data;
-        contractSchemaId = FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID;
-    }
-    catch {
-        // still allow assessment of failures without contract? fail-closed to contract
-        throw new Error("assess: missing or invalid contracts/frontend-implementation-contract.json");
-    }
-    const candidateNodeIds = [
-        "frontend-verify-assess-shell",
-        "frontend-reverify-shell",
-        "frontend-static-verify-shell",
-        "frontend-behavior-verify-shell",
-        "frontend-verification-trace-shell",
-        "frontend-static-reverify-shell",
-        "frontend-behavior-reverify-shell",
-        "frontend-verification-retrace-shell",
-    ];
-    const failed = [
-        ...(input.failureFacts ?? []).filter(({ record }) => nodeHadFailure(record) || recordIndicatesCommandFailure(record)),
-    ];
-    for (const nodeId of candidateNodeIds) {
-        if (failed.some((item) => item.nodeId === nodeId))
-            continue;
-        const nodePath = path.join(input.runDir, `${nodeId}.json`);
-        try {
-            const record = JSON.parse(await readFile(nodePath, "utf8"));
-            if (nodeHadFailure(record) || recordIndicatesCommandFailure(record)) {
-                failed.push({ nodeId, record });
-            }
-        }
-        catch {
-            // missing optional nodes ok
-        }
-    }
-    if (failed.length === 0) {
-        const assessment = {
-            schemaVersion: 1,
-            schemaId: FRONTEND_REPAIR_ASSESSMENT_SCHEMA_ID,
-            contract: {
-                relativePath: contractRel,
-                schemaId: contractSchemaId,
-            },
-            failedNodeIds: [],
-            failureClass: "unknown",
-            eligible: false,
-            reason: "no failed frontend verify/trace nodes in current run",
-            attempt,
-            maxAttempts: 1,
-            allowedRepairWriteSet: [...implementWriteSet],
-            evidenceRefs: [contractRel],
-            browserStatus: "not-run",
-        };
-        await writeAssessment(input.runDir, assessment);
-        return assessment;
-    }
-    const primary = failed[0];
-    const evidence = deriveFailureEvidence({ contract, failed });
-    const failureClass = classifyFrontendFailure({
-        nodeId: primary.nodeId,
-        failureCategory: primary.record.failureCategory,
-        stdout: primary.record.stdout,
-        stderr: primary.record.stderr,
-        commandLabel: evidence.commandLabel,
-        commandCategory: evidence.commandCategory,
-        exitCode: evidence.exitCode,
-        traceTarget: evidence.traceTarget ?? null,
-        changedPaths: evidence.changedPaths,
-    });
-    // AC-5: repairable=true requires structured evidence (a resolved exitCode,
-    // commandCategory, or trace-bound verification target). review has its own
-    // stricter gate (AC-4) and is never unconditionally repairable.
-    const baseEligible = isFrontendRepairable(failureClass) && attempt <= 1;
-    let eligible;
-    let reason;
-    if (failureClass === "review") {
-        const finding = primary.record.reviewFinding ?? {};
-        eligible = attempt <= 1 && isReviewRepairable(finding, implementWriteSet);
-        reason = eligible
-            ? `repairable review finding on ${primary.nodeId}`
-            : `review finding lacks file/line-symbol/requirement evidence or is outside writeSet on ${primary.nodeId}`;
-    }
-    else {
-        const hasStructuredEvidence = evidence.exitCode !== undefined ||
-            evidence.commandCategory !== undefined ||
-            Boolean(evidence.verificationTargetId);
-        eligible = baseEligible && hasStructuredEvidence;
-        reason = eligible
-            ? `repairable failureClass=${failureClass} on ${primary.nodeId}`
-            : !baseEligible
-                ? `non-repairable or ineligible: failureClass=${failureClass} attempt=${attempt}`
-                : `missing structured evidence for failureClass=${failureClass} on ${primary.nodeId}`;
-    }
-    // fixScope and changedPaths must stay inside the implement writeSet.
-    if (evidence.fixScope?.length) {
-        assertWriteSetSubset(evidence.fixScope, implementWriteSet);
-    }
-    if (evidence.changedPaths?.length) {
-        assertWriteSetSubset(evidence.changedPaths, implementWriteSet);
-    }
-    const assessment = {
-        schemaVersion: 1,
-        schemaId: FRONTEND_REPAIR_ASSESSMENT_SCHEMA_ID,
-        contract: {
-            relativePath: contractRel,
-            schemaId: contractSchemaId,
-        },
-        failedNodeIds: failed.map((item) => item.nodeId),
-        failureClass,
-        eligible,
-        reason,
-        attempt,
-        maxAttempts: 1,
-        allowedRepairWriteSet: [...implementWriteSet],
-        evidenceRefs: [contractRel, ...failed.map((item) => `${item.nodeId}.json`)],
-        browserStatus: "not-run",
-        ...(evidence.verificationTargetId
-            ? { verificationTargetId: evidence.verificationTargetId }
-            : {}),
-        ...(evidence.commandLabel ? { commandLabel: evidence.commandLabel } : {}),
-        ...(evidence.exitCode !== undefined ? { exitCode: evidence.exitCode } : {}),
-        ...(evidence.commandCategory
-            ? { commandCategory: evidence.commandCategory }
-            : {}),
-        ...(evidence.requirementIds?.length
-            ? { requirementIds: evidence.requirementIds }
-            : {}),
-        ...(evidence.acceptanceCriteriaIds?.length
-            ? { acceptanceCriteriaIds: evidence.acceptanceCriteriaIds }
-            : {}),
-        ...(evidence.fixScope?.length ? { fixScope: evidence.fixScope } : {}),
-        ...(evidence.changedPaths?.length
-            ? { changedPaths: evidence.changedPaths }
-            : {}),
-        ...(evidence.traceRef ? { traceRef: evidence.traceRef } : {}),
-    };
-    await writeAssessment(input.runDir, assessment);
-    return assessment;
-}
-function recordIndicatesCommandFailure(record) {
-    // Prefer explicit commandResults when present
-    if (record.commandResults?.some((item) => item.ok === false))
-        return true;
-    // Node may be FINISHED with nonZeroExitPolicy=record; look for harness markers
-    const stdout = record.stdout ?? "";
-    if (/nonZeroExitPolicy=record/.test(stdout) &&
-        /exitCode=[1-9]/.test(stdout)) {
-        return true;
-    }
-    if (record.failureCategory && record.failureCategory !== "success") {
-        // recorded failures may still be FINISHED
-        if (record.status === "FINISHED") {
-            return (record.failureCategory === "nonzero-exit" ||
-                record.failureCategory === "invalid-output" ||
-                record.failureCategory === "timeout");
-        }
-    }
-    return false;
-}
-async function writeAssessment(runDir, assessment) {
-    const relative = "contracts/frontend-repair-assessment.json";
-    const absolute = path.join(runDir, relative);
-    await mkdir(path.dirname(absolute), { recursive: true });
-    await writeFile(absolute, `${JSON.stringify(assessment, null, 2)}\n`, "utf8");
-    return absolute;
-}
-export async function runFrontendRepairContractGate(input) {
-    const relative = "contracts/frontend-repair-assessment.json";
-    const absolute = path.join(input.runDir, relative);
-    const raw = JSON.parse(await readFile(absolute, "utf8"));
-    const parsed = frontendRepairAssessmentSchema.safeParse(raw);
-    if (!parsed.success) {
-        throw new Error(`repair-contract: invalid assessment: ${parsed.error.issues
-            .map((i) => i.message)
-            .join("; ")}`);
-    }
-    const assessment = parsed.data;
-    const implementWriteSet = await loadImplementWriteSet(input.runDir, input.implementWriteSet ?? []);
-    assertWriteSetSubset(assessment.allowedRepairWriteSet, implementWriteSet.length
-        ? implementWriteSet
-        : assessment.allowedRepairWriteSet);
-    if (assessment.attempt > assessment.maxAttempts) {
-        throw new Error("repair-contract: attempt exceeds maxAttempts");
-    }
-    if (assessment.failedNodeIds.length === 0) {
-        return { ok: true, assessment };
-    }
-    if (!assessment.eligible) {
-        throw new Error(`repair-contract: non-repairable failure (${assessment.failureClass}): ${assessment.reason}`);
-    }
-    if (!isFrontendRepairable(assessment.failureClass) &&
-        assessment.failureClass !== "review") {
-        throw new Error(`repair-contract: failureClass ${assessment.failureClass} is not repairable`);
-    }
-    return { ok: true, assessment };
-}
-export function formatFrontendFailureAssessStdout(assessment) {
-    return JSON.stringify(assessment);
-}
-export function formatFrontendRepairContractStdout(assessment) {
-    return [
-        "Frontend repair contract: pass",
-        `eligible=${assessment.eligible}`,
-        `failureClass=${assessment.failureClass}`,
-        `writeSetSize=${assessment.allowedRepairWriteSet.length}`,
-    ].join("\n");
-}

package/dist/workflows/dag/frontend-review-context.js

@@ -1,11 +1,159 @@
+import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { formatFrontendWorktreeDiffStdout, runFrontendWorktreeDiffGate, } from "./frontend-worktree-diff.js";
 import { frontendLintAssessmentArtifactSchema } from "./frontend-lint-baseline.js";
-import { frontendImplementationContractSchema } from "./frontend-implementation-contract.js";
-import { frontendRepairAssessmentSchema } from "./frontend-repair.js";
+import { deterministicSha256, frontendImplementationContractSchema, } from "./frontend-implementation-contract.js";
 export const FRONTEND_REVIEW_CONTEXT_SCHEMA_ID = "frontend-review-context-v1";
+/**
+ * Deterministically assemble the cumulative diff from a task baseline and the
+ * current candidate snapshot. Same input always yields the same output:
+ * paths are sorted, statuses are derived from a fixed decision table, and both
+ * digests use canonical JSON hashing.
+ */
+export function assembleCumulativeDiffContext(input) {
+    const baselineByPath = new Map(input.baselineEntries.map((entry) => [entry.path, entry.sha256]));
+    const currentByPath = new Map(input.currentEntries.map((entry) => [entry.path, entry.sha256]));
+    const allPaths = new Set([
+        ...baselineByPath.keys(),
+        ...currentByPath.keys(),
+    ]);
+    const sortedPaths = [...allPaths].sort();
+    const perPath = sortedPaths.map((p) => {
+        const baselineSha256 = baselineByPath.get(p) ?? null;
+        const hasCurrent = currentByPath.has(p);
+        const currentSha256 = hasCurrent
+            ? (currentByPath.get(p) ?? null)
+            : null;
+        let status;
+        if (baselineSha256 === null) {
+            status = currentSha256 === null ? "deleted" : "added";
+        }
+        else if (currentSha256 === null) {
+            status = hasCurrent ? "deleted" : "unchanged";
+        }
+        else {
+            status = currentSha256 === baselineSha256 ? "unchanged" : "modified";
+        }
+        return { path: p, status, baselineSha256, currentSha256 };
+    });
+    const baselineDigest = deterministicSha256([...input.baselineEntries].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    const cumulativeDigest = deterministicSha256(perPath);
+    return {
+        schemaId: "frontend-cumulative-diff-context-v1",
+        baselineDigest,
+        perPath,
+        cumulativeDigest,
+        empty: perPath.every((entry) => entry.status === "unchanged"),
+    };
+}
+async function sha256File(filePath) {
+    try {
+        const bytes = await readFile(filePath);
+        return createHash("sha256").update(bytes).digest("hex");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Capture the cumulative diff from the frozen worktree baseline and the
+ * run-owned diff gate output. Pure status/digest logic lives in
+ * `assembleCumulativeDiffContext`; this wrapper only does IO.
+ */
+export async function captureCumulativeDiffContext(input) {
+    const root = path.resolve(input.workspaceRoot);
+    let baselineEntries = [];
+    try {
+        const raw = JSON.parse(await readFile(path.join(input.runDir, "contracts/frontend-worktree-baseline.json"), "utf8"));
+        baselineEntries = (raw.files ?? [])
+            .map((file) => ({ path: file, sha256: raw.hashes?.[file] ?? null }))
+            .filter((entry) => entry.sha256 !== null);
+    }
+    catch {
+        // Missing baseline → empty baseline entries (still deterministic).
+    }
+    const candidatePaths = [
+        ...new Set([...input.diff.changedFiles, ...input.diff.untrackedFiles]),
+    ];
+    const currentEntries = [];
+    for (const file of candidatePaths) {
+        currentEntries.push({
+            path: file,
+            sha256: await sha256File(path.join(root, file)),
+        });
+    }
+    return assembleCumulativeDiffContext({ baselineEntries, currentEntries });
+}
+const TYPED_TO_LEGACY = {
+    approve_review: "pass",
+    request_review_changes: "request-revision",
+};
+function isTypedReviewTerminalVerdict(value) {
+    return value === "approve_review" || value === "request_review_changes";
+}
+function isLegacyReviewVerdict(value) {
+    return value === "pass" || value === "request-revision";
+}
+/**
+ * Deterministic, fail-closed equivalence between the typed review terminal
+ * verdict(s) observed in the attempt and the legacy JSON verdict.
+ *
+ * Fail-closed cases (all yield `match: false` with an explicit reason):
+ *   - no typed terminal fact;
+ *   - more than one typed terminal fact (conflicting);
+ *   - an unknown typed terminal kind;
+ *   - a missing/illegal legacy JSON verdict.
+ */
+export function compareTypedReviewToLegacyJsonVerdict(input) {
+    const kinds = [...input.typedKinds];
+    const legacyVerdict = isLegacyReviewVerdict(input.legacyVerdict ?? "")
+        ? input.legacyVerdict
+        : undefined;
+    if (kinds.length === 0) {
+        return {
+            typedVerdict: undefined,
+            legacyVerdict,
+            match: false,
+            reason: "typed review terminal fact missing",
+        };
+    }
+    if (kinds.length > 1) {
+        return {
+            typedVerdict: undefined,
+            legacyVerdict,
+            match: false,
+            reason: `conflicting typed review terminal facts: ${[...new Set(kinds)].join(",")}`,
+        };
+    }
+    const typedVerdict = kinds[0];
+    if (!isTypedReviewTerminalVerdict(typedVerdict)) {
+        return {
+            typedVerdict: undefined,
+            legacyVerdict,
+            match: false,
+            reason: `unknown typed review terminal fact kind: ${typedVerdict}`,
+        };
+    }
+    if (!legacyVerdict) {
+        return {
+            typedVerdict,
+            legacyVerdict: undefined,
+            match: false,
+            reason: "legacy JSON verdict missing or not pass|request-revision",
+        };
+    }
+    const expected = TYPED_TO_LEGACY[typedVerdict];
+    return {
+        typedVerdict,
+        legacyVerdict,
+        match: expected === legacyVerdict,
+        reason: expected === legacyVerdict
+            ? "typed review verdict matches legacy JSON verdict"
+            : `typed review verdict ${typedVerdict} maps to ${expected} but legacy JSON verdict is ${legacyVerdict}`,
+    };
+}
 async function readRequiredJson(runDir, relativePath) {
     try {
         return JSON.parse(await readFile(path.join(runDir, relativePath), "utf8"));
@@ -30,6 +178,37 @@ async function readOptionalLintAssessment(runDir) {
         throw new Error(`frontend review context invalid ${relativePath}`);
     }
 }
+async function readOptionalRepairAssessment(runDir) {
+    const relativePath = "contracts/frontend-repair-assessment.json";
+    try {
+        return JSON.parse(await readFile(path.join(runDir, relativePath), "utf8"));
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return undefined;
+        }
+        throw new Error(`frontend review context invalid ${relativePath}`);
+    }
+}
+/** M8: verify failure ownership facts written by frontend-verify-shell. */
+async function readOptionalVerifyFailure(runDir) {
+    const relativePath = "contracts/frontend-verify-failure.json";
+    try {
+        return JSON.parse(await readFile(path.join(runDir, relativePath), "utf8"));
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return undefined;
+        }
+        throw new Error(`frontend review context invalid ${relativePath}`);
+    }
+}
 function assertReviewEvidence(input) {
     const contract = frontendImplementationContractSchema.safeParse(input.contract);
     if (!contract.success)
@@ -71,9 +250,9 @@ function assertReviewEvidence(input) {
         trace.mockStrategy !== contract.data.mockApi.strategy) {
         throw new Error("frontend review context verification trace is not bound to a passing contract");
     }
-    const assessment = frontendRepairAssessmentSchema.safeParse(input.repairAssessment);
-    if (!assessment.success)
-        throw new Error("frontend review context invalid repair assessment");
+    // M8: no repair-assessment hard requirement. When the artifact exists it must
+    // be schema-valid; when absent the verify failure capsule (if any) is
+    // already surfaced through the payload as verifyFailure.
 }
 export async function runFrontendReviewContextGate(input) {
     const contract = await readRequiredJson(input.runDir, "contracts/frontend-implementation-contract.json");
@@ -85,15 +264,22 @@ export async function runFrontendReviewContextGate(input) {
         authorizedChangedPaths: parsedContract.data.targets.files,
     });
     const verificationTrace = await readRequiredJson(input.runDir, "contracts/frontend-verification-trace.json");
-    const repairAssessment = await readRequiredJson(input.runDir, "contracts/frontend-repair-assessment.json");
+    const repairAssessment = await readOptionalRepairAssessment(input.runDir);
+    const verifyFailure = await readOptionalVerifyFailure(input.runDir);
     const lintAssessment = await readOptionalLintAssessment(input.runDir);
-    assertReviewEvidence({ contract, verificationTrace, repairAssessment });
+    assertReviewEvidence({ contract, verificationTrace });
+    const cumulativeDiff = await captureCumulativeDiffContext({
+        runDir: input.runDir,
+        workspaceRoot: input.workspaceRoot,
+        diff,
+    });
     const payload = {
         schemaVersion: 1,
         schemaId: FRONTEND_REVIEW_CONTEXT_SCHEMA_ID,
         contract,
         verificationTrace,
-        repairAssessment,
+        ...(repairAssessment ? { repairAssessment } : {}),
+        ...(verifyFailure ? { verifyFailure } : {}),
         ...(lintAssessment ? { lintAssessment } : {}),
         diff: {
             schemaId: diff.schemaId,
@@ -103,6 +289,7 @@ export async function runFrontendReviewContextGate(input) {
             untrackedFiles: diff.untrackedFiles,
             empty: diff.empty,
         },
+        cumulativeDiff,
     };
     const artifactPath = await writeDagRunJsonArtifact(input.runDir, "contracts/frontend-review-context.json", payload);
     return { ok: true, artifactPath, diff };