@tea-agent/loop-agent 0.38.2 → 0.38.4

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -8,6 +8,7 @@ import { writeTextArtifactFile } from "../../infrastructure/harness/artifact-sto
 import { findPackageRoot } from "../../shared/package-metadata.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
+import { canonicalContractRel, classifyStructuredContractFailure, formatStructuredArtifactPointer, openspecCitationsRel, parseOpenspecCitationsBlock, persistRuntimeSkeleton, } from "./structured-output-repair.js";
 export const frontendNormalizationActionSchema = z.enum([
     "remove-trailing-commas",
     "strip-comments",
@@ -1485,7 +1486,13 @@ export async function analyzeFrontendImplementationContract(input) {
         rawOutput = input.rawContractText;
     }
     else if (input.fromNodeId !== undefined) {
-        const record = JSON.parse(await readFile(path.join(input.runDir, `${input.fromNodeId}.json`), "utf8"));
+        let record;
+        try {
+            record = JSON.parse(await readFile(path.join(input.runDir, `${input.fromNodeId}.json`), "utf8"));
+        }
+        catch (error) {
+            throw new Error(`cannot parse node record ${input.fromNodeId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
         rawOutput = record.assistantText ?? record.stdout ?? "";
     }
     else {
@@ -1716,7 +1723,11 @@ async function dropUnresolvedVerificationSymbols(input) {
     return changed;
 }
 function extractSingleOpenspecCitationsBlock(text) {
-    const blocks = text.match(/```openspec-citations[ \t]*\r?\n[\s\S]*?\r?\n```/g) ?? [];
+    // Line-anchored so a directly closed empty fence (no candidate rows) still
+    // counts as the one required block instead of "found 0" retry loops.
+    const blocks = [
+        ...text.matchAll(/^```openspec-citations[ \t]*\r?\n([\s\S]*?)^```[ \t]*$/gim),
+    ].map((match) => match[0]);
     if (blocks.length !== 1) {
         throw new Error(`frontend plan patch output must include exactly one fenced openspec-citations block (found ${blocks.length})`);
     }
@@ -1731,7 +1742,7 @@ async function writeFrontendPlanCandidateRaw(input) {
  * Compile the planner's editable RFC 7386 patch against the deterministic
  * runtime skeleton. Every attempt is preserved under contracts/candidates so
  * format/schema failures can be inspected and replayed without trusting model
- * prose. A successful result returns canonical full-contract text for all
+ * prose. A successful result returns a path-only pointer plus the hash-bound canonical artifact for
  * downstream review and prewrite nodes.
  */
 export async function validateFrontendPlanPatchNodeOutput(input) {
@@ -1804,27 +1815,60 @@ export async function validateFrontendPlanPatchNodeOutput(input) {
             ],
             errors: [],
         });
+        const canonicalRel = canonicalContractRel(nodeId);
+        const canonicalArtifact = await writeDeterministicJsonArtifact(input.runDir, canonicalRel, analysis.canonical);
+        const parsedCitations = parseOpenspecCitationsBlock(citationsBlock);
+        await writeDeterministicJsonArtifact(input.runDir, openspecCitationsRel(nodeId), {
+            citations: parsedCitations.citations,
+            block: citationsBlock,
+        });
+        await persistRuntimeSkeleton({
+            runDir: input.runDir,
+            nodeId,
+            skeleton,
+        });
+        const artifact = {
+            path: canonicalArtifact.path,
+            sha256: canonicalArtifact.sha256,
+            schemaId: FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
+        };
         return {
             ok: true,
             contract: analysis.canonical,
-            normalizedText: [
-                "Frontend implementation contract compiled from the runtime skeleton.",
-                "",
-                "```json",
-                serializeDeterministicJson(analysis.canonical),
-                "```",
-                citationsBlock,
-            ].join("\n"),
+            artifact,
+            normalizedText: formatStructuredArtifactPointer(artifact),
         };
     }
     catch (error) {
         const reason = error instanceof Error ? error.message : String(error);
+        const classified = classifyStructuredContractFailure({
+            reason,
+            kind: error instanceof FrontendContractFailure ? error.kind : undefined,
+        });
         await writeReport({
-            classification: "retryable-invalid",
+            classification: classified.classification,
             normalizationActions: [],
-            errors: [{ path: "$", code: "invalid-output", message: reason }],
+            errors: classified.errors,
         });
-        return { ok: false, reason };
+        return {
+            ok: false,
+            reason,
+            classification: classified.classification,
+            errors: classified.errors,
+        };
+    }
+}
+export async function readFrontendCanonicalCandidate(runDir, nodeId) {
+    const candidatePath = path.join(runDir, canonicalContractRel(nodeId));
+    try {
+        const raw = await readFile(candidatePath, "utf8");
+        const parsed = frontendImplementationContractSchema.safeParse(JSON.parse(raw));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        return undefined;
     }
 }
 /**
@@ -1845,60 +1889,121 @@ export async function validateFrontendContractNodeOutput(input) {
         return { ok: true, contract: analysis.canonical };
     }
     catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        const classified = classifyStructuredContractFailure({
+            reason,
+            kind: error instanceof FrontendContractFailure ? error.kind : undefined,
+        });
         return {
             ok: false,
-            reason: error instanceof Error ? error.message : String(error),
+            reason,
+            classification: classified.classification,
+            errors: classified.errors,
         };
     }
 }
 /**
- * Node-output self-check for the plan revision node, which emits an RFC 7386
- * merge-patch delta against the original contract instead of a full contract.
- * Deliberately loose and format-level: the output must contain exactly one
- * ```openspec-citations fenced block and must extract (after the citations
- * blocks are stripped) to exactly one JSON object. The delta carries no
- * schemaVersion/targets, so no full-contract schema/semantic checks run here;
- * content parsing, patch application, and merged-contract validation stay with
- * the prewrite gate, which remains the only authority.
+ * Node-output self-check for the plan revision node. Format-level checks still
+ * require one openspec-citations fence and one JSON object. When the original
+ * canonical contract and sourceBinding are present, this node is the merge
+ * authority: it applies the RFC 7386 patch, validates the full contract, and
+ * writes the revision node's own hash-bound canonical artifact.
  */
 export async function validateFrontendRevisionPatchNodeOutput(input) {
+    const fail = (reason) => {
+        const classified = classifyStructuredContractFailure({ reason });
+        return {
+            ok: false,
+            reason,
+            classification: classified.classification,
+            errors: classified.errors,
+        };
+    };
+    const nodeId = input.nodeId ?? "frontend-plan-revision-pi";
+    const attempt = input.attempt ?? 1;
+    await writeFrontendPlanCandidateRaw({
+        runDir: input.runDir,
+        nodeId,
+        attempt,
+        text: input.text,
+    });
     let citationsBlock;
     try {
         citationsBlock = extractSingleOpenspecCitationsBlock(input.text);
     }
     catch (error) {
-        return {
-            ok: false,
-            reason: error instanceof Error ? error.message : String(error),
-        };
+        return fail(error instanceof Error ? error.message : String(error));
     }
-    // Strip the citation blocks before extraction: their per-row JSON objects
-    // would otherwise count as competing balanced objects in the extractor.
     const textWithoutCitations = input.text.replace(citationsBlock, "");
     let patch;
     try {
         patch = extractFrontendImplementationJson(textWithoutCitations);
     }
     catch (error) {
-        return {
-            ok: false,
-            reason: `revision patch output must contain exactly one valid JSON object: ${error instanceof Error ? error.message : String(error)}`,
-        };
+        return fail(`revision patch output must contain exactly one valid JSON object: ${error instanceof Error ? error.message : String(error)}`);
     }
     if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
-        return {
-            ok: false,
-            reason: "revision patch output must extract to exactly one JSON object (RFC 7386 merge-patch delta)",
-        };
+        return fail("revision patch output must extract to exactly one JSON object (RFC 7386 merge-patch delta)");
     }
     const protectedViolations = frontendPlanPatchProtectedPathViolations(patch);
     if (protectedViolations.length > 0) {
+        return fail(`frontend revision patch must not modify runtime-protected paths: ${protectedViolations.join(", ")}`);
+    }
+    const original = (await readFrontendCanonicalCandidate(input.runDir, "frontend-plan-pi")) ??
+        (await readFrontendCanonicalCandidate(input.runDir, nodeId));
+    if (!input.sourceBinding) {
+        return { ok: true, contract: patch };
+    }
+    if (!original) {
+        return fail("frontend revision patch requires the original frontend-plan-pi canonical contract");
+    }
+    try {
+        const merged = applyFrontendContractMergePatch(original, patch);
+        const droppedUnresolvedSymbols = await dropUnresolvedVerificationSymbols({
+            runDir: input.runDir,
+            contract: merged,
+        });
+        const analysis = await analyzeFrontendImplementationContract({
+            runDir: input.runDir,
+            rawContractText: serializeDeterministicJson(merged),
+            sourceBinding: input.sourceBinding,
+        });
+        const candidateDir = path.posix.join("contracts", "candidates", nodeId);
+        await writeDeterministicJsonArtifact(input.runDir, path.posix.join(candidateDir, `attempt-${attempt}.extracted.json`), patch);
+        await writeDeterministicJsonArtifact(input.runDir, path.posix.join(candidateDir, `attempt-${attempt}.normalized.json`), analysis.canonical);
+        await writeDeterministicJsonArtifact(input.runDir, path.posix.join(candidateDir, `attempt-${attempt}.validation.json`), {
+            classification: "accepted-normalized",
+            normalizationActions: [
+                "apply-original-canonical",
+                ...(droppedUnresolvedSymbols
+                    ? ["drop-unresolved-verification-symbols"]
+                    : []),
+                ...analysis.normalizationActions,
+            ],
+            errors: [],
+        });
+        const canonicalArtifact = await writeDeterministicJsonArtifact(input.runDir, canonicalContractRel(nodeId), analysis.canonical);
+        const parsedCitations = parseOpenspecCitationsBlock(citationsBlock);
+        await writeDeterministicJsonArtifact(input.runDir, openspecCitationsRel(nodeId), {
+            citations: parsedCitations.citations,
+            block: citationsBlock,
+        });
+        const artifact = {
+            path: canonicalArtifact.path,
+            sha256: canonicalArtifact.sha256,
+            schemaId: FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
+        };
         return {
-            ok: false,
-            reason: `frontend revision patch must not modify runtime-protected paths: ${protectedViolations.join(", ")}`,
+            ok: true,
+            contract: analysis.canonical,
+            artifact,
+            normalizedText: formatStructuredArtifactPointer(artifact),
         };
     }
-    return { ok: true, contract: patch };
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return fail(reason);
+    }
 }
 export async function materializeFrontendImplementationContract(input) {
     const analysis = await analyzeFrontendImplementationContract(input);

package/dist/workflows/dag/frontend-prewrite-gate.js

@@ -1,10 +1,11 @@
+import { createHash } from "node:crypto";
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import { isOpenspecSpecFilePath } from "../../shared/openspec-spec.js";
 import { writeTextArtifactFile } from "../../infrastructure/harness/artifact-store.js";
 import { countExcludedGovernanceSpecFiles, resolveOpenspecGovernanceRoot, } from "../../task/frontend-project-capability.js";
-import { analyzeFrontendImplementationContract, writeFrontendImplementationContractArtifact, writeDeterministicJsonArtifact, assertFrontendSourceBindingFresh, deterministicSha256, sha256Hex, serializeDeterministicJson, applyFrontendImplementationContractPatch, extractFrontendImplementationJson, FrontendContractFailure, frontendNormalizationActionSchema, } from "./frontend-implementation-contract.js";
+import { analyzeFrontendImplementationContract, writeFrontendImplementationContractArtifact, writeDeterministicJsonArtifact, assertFrontendSourceBindingFresh, deterministicSha256, sha256Hex, serializeDeterministicJson, FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, FrontendContractFailure, frontendNormalizationActionSchema, } from "./frontend-implementation-contract.js";
 import { renderFrontendPlanMarkdown } from "./frontend-plan-render.js";
 import { captureFrontendWorktreeBaseline } from "./frontend-worktree-diff.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
@@ -157,60 +158,68 @@ async function selectNode(runDir, primary, fallbacks) {
     }
     throw new Error(`frontend prewrite gate no FINISHED candidate: ${rejections.join("; ")}`);
 }
-async function readNodeText(runDir, nodeId) {
-    const record = JSON.parse(await readFile(path.join(runDir, `${nodeId}.json`), "utf8"));
+async function readFinishedNodeRecord(runDir, nodeId) {
+    let record;
+    try {
+        record = JSON.parse(await readFile(path.join(runDir, `${nodeId}.json`), "utf8"));
+    }
+    catch (error) {
+        throw new Error(`frontend prewrite gate cannot parse node record ${nodeId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
     if (record.status !== "FINISHED") {
         throw new Error(`frontend prewrite gate requires FINISHED node ${nodeId} (got ${String(record.status)})`);
     }
-    // Pi execution mirrors a successful structured-contract normalization into
-    // both assistantText and stdout. Treat node output the same way as the DAG
-    // runtime's canonicalNodeOutput(): assistantText is authoritative and stdout
-    // is only a fallback. Concatenating the two duplicate fields makes a single
-    // canonical plan appear as two complete JSON contracts to the prewrite gate.
+    return record;
+}
+async function readNodeText(runDir, nodeId) {
+    const record = await readFinishedNodeRecord(runDir, nodeId);
     const text = record.assistantText?.trim() || record.stdout?.trim() || "";
     if (!text)
         throw new Error(`frontend prewrite gate empty output from ${nodeId}`);
     return text;
 }
-async function readNodeRawText(runDir, nodeId) {
-    const record = JSON.parse(await readFile(path.join(runDir, `${nodeId}.json`), "utf8"));
-    return record.assistantText ?? record.stdout ?? "";
-}
-/**
- * Same shape predicate as the internal `isContract` inside
- * `extractFrontendImplementationJson` (frontend-implementation-contract.ts):
- * schemaVersion 1 + a plain `targets` object + `requirements` and
- * `verificationTargets` arrays. A merge-patch delta does not carry these
- * fields, so this is the deterministic boundary between a full contract and a
- * patch. Keep the two predicates in sync.
- */
-function isFullContractShape(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        return false;
-    }
-    const record = value;
-    const targets = record.targets;
-    return (record.schemaVersion === 1 &&
-        targets !== null &&
-        typeof targets === "object" &&
-        !Array.isArray(targets) &&
-        Array.isArray(record.requirements) &&
-        Array.isArray(record.verificationTargets));
-}
-/**
- * Shared merge pipeline for revisionPatch mode and content-driven
- * compatibility: read the original contract node, extract the original
- * contract and the effective node's patch, apply the RFC 7386 merge-patch, and
- * serialize deterministically. Throws on any failure; callers map the error to
- * their own classification (retryable-invalid for explicit revisionPatch mode,
- * blocked for content-driven fallback).
- */
-async function mergeRevisionPatch(runDir, planText, originalNodeId) {
-    const originalText = await readNodeText(runDir, originalNodeId);
-    const originalValue = extractFrontendImplementationJson(originalText);
-    const patchValue = extractFrontendImplementationJson(planText);
-    const merged = applyFrontendImplementationContractPatch(originalValue, patchValue);
-    return serializeDeterministicJson(merged);
+async function readCanonicalContractFromNode(runDir, nodeId) {
+    const record = await readFinishedNodeRecord(runDir, nodeId);
+    if (!record.structuredArtifactPath) {
+        throw new Error(`frontend prewrite gate missing structured artifact for ${nodeId}`);
+    }
+    const artifactPath = path.isAbsolute(record.structuredArtifactPath)
+        ? record.structuredArtifactPath
+        : path.join(runDir, record.structuredArtifactPath);
+    const resolvedRun = path.resolve(runDir);
+    const resolvedArtifact = path.resolve(artifactPath);
+    const relative = path.relative(resolvedRun, resolvedArtifact);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`frontend prewrite gate structured artifact escapes runDir: ${record.structuredArtifactPath}`);
+    }
+    const bytes = await readFile(resolvedArtifact);
+    const digest = createHash("sha256").update(bytes).digest("hex");
+    if (record.structuredArtifactSha256 &&
+        record.structuredArtifactSha256 !== digest) {
+        throw new Error(`frontend prewrite gate structured artifact hash mismatch for ${nodeId}`);
+    }
+    if (record.structuredArtifactSchemaId &&
+        record.structuredArtifactSchemaId !== FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID) {
+        throw new Error(`frontend prewrite gate structured artifact schema mismatch for ${nodeId}: ${record.structuredArtifactSchemaId}`);
+    }
+    const contractText = bytes.toString("utf8");
+    let citationsText = "";
+    try {
+        const citationsRaw = await readFile(path.join(path.dirname(resolvedArtifact), "openspec-citations.json"), "utf8");
+        try {
+            const parsed = JSON.parse(citationsRaw);
+            citationsText =
+                typeof parsed.block === "string" ? parsed.block : citationsRaw;
+        }
+        catch {
+            citationsText = citationsRaw;
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    return { contractText, citationsText, rawSha256: digest };
 }
 function firstNonEmptyVerdictLine(text) {
     const lines = text
@@ -439,7 +448,30 @@ export async function runFrontendPrewriteGate(input) {
     // remains an ERROR and is intentionally not classified into prewrite-result.
     const planNodeId = await selectNode(input.runDir, input.config.planFromNodeId, input.config.planFallbackFromNodeIds);
     const reviewNodeId = await selectNode(input.runDir, input.config.reviewFromNodeId, input.config.reviewFallbackFromNodeIds);
-    const candidateRawSha256 = sha256Hex(await readNodeRawText(input.runDir, planNodeId));
+    let planArtifact;
+    try {
+        planArtifact = await readCanonicalContractFromNode(input.runDir, planNodeId);
+    }
+    catch (error) {
+        return finalizePrewrite(input, {
+            planNodeId,
+            reviewNodeId,
+            verdict: "",
+            candidateRawSha256: sha256Hex(""),
+            candidateJsonSha256: null,
+            canonicalSha256: null,
+            normalizationActions: [],
+            mockStrategy: undefined,
+            artifact: undefined,
+            failureReason: error instanceof Error ? error.message : String(error),
+            failureCode: "plan-text-unreadable",
+            classification: "retryable-invalid",
+            openspecReadPaths: [],
+            openspecCandidatePaths: input.config.openspecCandidatePaths ?? [],
+            openspecPolicy: input.config.openspecPolicy ?? "scan-strict",
+        });
+    }
+    const candidateRawSha256 = planArtifact.rawSha256;
     const openspecPolicy = input.config.openspecPolicy ?? "scan-strict";
     const basePending = {
         planNodeId,
@@ -458,18 +490,9 @@ export async function runFrontendPrewriteGate(input) {
         openspecCandidatePaths: input.config.openspecCandidatePaths ?? [],
         openspecPolicy,
     };
-    let planText;
-    try {
-        planText = await readNodeText(input.runDir, planNodeId);
-    }
-    catch (error) {
-        return finalizePrewrite(input, {
-            ...basePending,
-            classification: "retryable-invalid",
-            failureReason: error instanceof Error ? error.message : String(error),
-            failureCode: "plan-text-unreadable",
-        });
-    }
+    const planText = [planArtifact.contractText, planArtifact.citationsText]
+        .filter(Boolean)
+        .join("\n");
     let reviewText;
     try {
         reviewText = await readNodeText(input.runDir, reviewNodeId);
@@ -492,77 +515,7 @@ export async function runFrontendPrewriteGate(input) {
             failureCode: "verdict-not-pass",
         });
     }
-    // revisionPatch mode: the effective plan node emits an RFC 7386 merge-patch
-    // delta against the original contract node (planFallbackFromNodeIds[0]).
-    // Legacy DAGs without revisionPatch (undefined) keep full-contract semantics.
-    const revisionPatchMode = input.config.revisionPatch === true &&
-        planNodeId === input.config.planFromNodeId &&
-        input.config.planFallbackFromNodeIds.length > 0;
-    let effectiveContractText = null;
-    if (revisionPatchMode) {
-        const originalNodeId = input.config.planFallbackFromNodeIds[0];
-        try {
-            effectiveContractText = await mergeRevisionPatch(input.runDir, planText, originalNodeId);
-        }
-        catch (error) {
-            return finalizePrewrite(input, {
-                ...basePending,
-                verdict,
-                classification: "retryable-invalid",
-                failureReason: `frontend prewrite gate revisionPatch mode requires original contract node ${originalNodeId}: ${error instanceof Error ? error.message : String(error)}`,
-                failureCode: "contract-invalid",
-            });
-        }
-    }
-    else {
-        // Content-driven compatibility (Bug 1): legacy DAGs without
-        // revisionPatch can still receive a merge-patch delta from the revision
-        // node. Detect the output shape instead of trusting the DAG flag alone.
-        // - Full contract shape → keep legacy full-contract semantics unchanged.
-        // - Patch shape with a usable original contract node → auto-merge and
-        //   run the existing analysis/materialization pipeline.
-        // - Patch shape but unmergeable → blocked + revision-patch-unmergeable
-        //   (no retryable loop).
-        let planJsonValue = null;
-        try {
-            planJsonValue = extractFrontendImplementationJson(planText);
-        }
-        catch {
-            // Not machine-readable JSON: fall back to the legacy full-contract
-            // path where analyzeFrontendImplementationContract surfaces the
-            // original diagnostic (fail-closed without a new failure mode).
-        }
-        if (planJsonValue !== null && !isFullContractShape(planJsonValue)) {
-            const originalNodeId = input.config.planFallbackFromNodeIds[0];
-            if (!originalNodeId || originalNodeId === planNodeId) {
-                return finalizePrewrite(input, {
-                    ...basePending,
-                    verdict,
-                    classification: "blocked",
-                    failureReason: "frontend prewrite gate: the effective plan output is a merge-patch delta but no distinct original contract node is available. Check the DAG revisionPatch/planFallbackFromNodeIds configuration or regenerate the DAG.",
-                    failureCode: "revision-patch-unmergeable",
-                });
-            }
-            try {
-                const originalText = await readNodeText(input.runDir, originalNodeId);
-                const originalValue = extractFrontendImplementationJson(originalText);
-                if (!isFullContractShape(originalValue)) {
-                    throw new Error(`original contract node ${originalNodeId} is not a full frontend implementation contract`);
-                }
-                effectiveContractText = await mergeRevisionPatch(input.runDir, planText, originalNodeId);
-            }
-            catch (error) {
-                return finalizePrewrite(input, {
-                    ...basePending,
-                    verdict,
-                    classification: "blocked",
-                    failureReason: `frontend prewrite gate: the effective plan output is a merge-patch delta but it cannot be merged onto the original contract node ${originalNodeId}: ${error instanceof Error ? error.message : String(error)}. Check the DAG revisionPatch/planFallbackFromNodeIds configuration or regenerate the DAG.`,
-                    failureCode: "revision-patch-unmergeable",
-                });
-            }
-        }
-    }
-    const requirementIdSearchText = effectiveContractText ?? planText;
+    const requirementIdSearchText = planArtifact.contractText;
     const missingIds = input.config.requiredRequirementIds.filter((id) => !requirementIdSearchText.includes(id));
     if (missingIds.length > 0) {
         return finalizePrewrite(input, {
@@ -610,14 +563,13 @@ export async function runFrontendPrewriteGate(input) {
                 workspaceRoot,
             });
     }
-    // Candidate -> canonical conversion. The gate consumes the selected
-    // plan/revision assistant output directly and is the only conversion point.
+    // Candidate -> canonical conversion. The gate consumes the producing node's
+    // hash-bound canonical artifact and never re-merges plan/revision stdout.
     let analysis;
     try {
         analysis = await analyzeFrontendImplementationContract({
             runDir: input.runDir,
-            fromNodeId: effectiveContractText ? undefined : planNodeId,
-            rawContractText: effectiveContractText ?? undefined,
+            rawContractText: planArtifact.contractText,
             sourceBinding: input.sourceBinding,
         });
     }

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

@@ -3,6 +3,7 @@ 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";
+import { FRONTEND_NO_VERIFICATION_MARKER_TEXT, FRONTEND_VERIFICATION_UNAVAILABLE_MESSAGE, } from "./frontend-verification-trace.js";
 export const FRONTEND_REPAIR_ASSESSMENT_SCHEMA_ID = "frontend-repair-assessment-v1";
 export const frontendRepairFailureClassSchema = z.enum([
     "typecheck",
@@ -82,6 +83,12 @@ export function classifyFrontendFailure(input) {
     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";
     }
@@ -424,6 +431,13 @@ export async function runFrontendFailureAssessGate(input) {
             : !baseEligible
                 ? `non-repairable or ineligible: failureClass=${failureClass} attempt=${attempt}`
                 : `missing structured evidence for failureClass=${failureClass} on ${primary.nodeId}`;
+        if (!eligible &&
+            `${primary.record.stderr ?? ""}`.includes(FRONTEND_NO_VERIFICATION_MARKER_TEXT)) {
+            // Surface the actionable unavailable-verification reason in the
+            // assessment (and the non-repairable gate error) instead of a
+            // generic class label.
+            reason = FRONTEND_VERIFICATION_UNAVAILABLE_MESSAGE;
+        }
     }
     // fixScope and changedPaths must stay inside the implement writeSet.
     if (evidence.fixScope?.length) {

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

@@ -2,6 +2,12 @@
  * Deterministic frontend-implementation risk classifier (M4).
  * Pure function: no I/O, no model, no side effects.
  */
+/**
+ * Dependency-installation language in task text. Mentioning package.json or
+ * allowing its path is NOT dependency introduction by itself; the manifest
+ * path check in classifyFrontendRisk requires this language to escalate.
+ */
+const DEPENDENCY_INSTALL_LANGUAGE = /new\s+dependency|add\s+dependencies?|install\s+dependencies?|npm\s+(?:install|i)\b|yarn\s+(?:add|install)\b|pnpm\s+(?:add|install)\b|bun\s+(?:add|install)\b|新增依赖|添加依赖|安装依赖|引入依赖/i;
 const HIGH_RISK_PATTERNS = [
     {
         id: "new-route",
@@ -25,7 +31,7 @@ const HIGH_RISK_PATTERNS = [
     },
     {
         id: "new-dependency",
-        re: /new\s+dependency|add\s+dependency|npm\s+install|新增依赖|package\.json/i,
+        re: DEPENDENCY_INSTALL_LANGUAGE,
     },
     {
         id: "schema-api-change",
@@ -88,7 +94,14 @@ export function classifyFrontendRisk(input) {
     const paths = input.allowedPaths ?? [];
     const spread = pathSpreadScore(paths);
     if (paths.some((p) => /package\.json|pnpm-lock|yarn\.lock|package-lock/.test(p))) {
-        signals.push("new-dependency");
+        if (DEPENDENCY_INSTALL_LANGUAGE.test(blob)) {
+            signals.push("new-dependency");
+        }
+        else {
+            // Editing manifest scripts/config is not dependency introduction;
+            // record the rejected escalation instead of forcing full gates.
+            rejectedSignals.push("new-dependency:manifest-path-without-install-language");
+        }
     }
     // Explicit multi-domain language only — path count alone is not high-risk
     if (spread >= 3 &&