@tea-agent/loop-agent 0.38.1 → 0.39.0-beta.0

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

@@ -4,14 +4,15 @@ 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_CANONICAL_CONTRACT_MAX_BYTES, applyFrontendImplementationContractPatch, extractFrontendImplementationJson, 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";
+import { normalizeVerdictCandidateLine } from "./dynamic-runtime/shared.js";
 export const FRONTEND_PREWRITE_RESULT_SCHEMA_ID = "frontend-prewrite-result-v1";
 export const FRONTEND_PREWRITE_RESULT_ARTIFACT_NAME = "frontend-prewrite-result.json";
 /** Canonical contract serialization must stay at or below this byte size. */
-export const FRONTEND_CONTRACT_MAX_BYTES = 65536;
+export const FRONTEND_CONTRACT_MAX_BYTES = FRONTEND_CANONICAL_CONTRACT_MAX_BYTES;
 /**
  * Machine-readable failure classification for blocked/retryable-invalid
  * prewrite outcomes. Kept alongside the human-readable failureReason so
@@ -39,6 +40,7 @@ export const frontendPrewriteFailureCodeSchema = z.enum([
     "component-spec-not-cited",
     "component-choices-missing",
     "contract-too-large",
+    "revision-patch-unmergeable",
 ]);
 export const frontendPrewriteResultV1Schema = z
     .object({
@@ -160,9 +162,12 @@ async function readNodeText(runDir, nodeId) {
     if (record.status !== "FINISHED") {
         throw new Error(`frontend prewrite gate requires FINISHED node ${nodeId} (got ${String(record.status)})`);
     }
-    const text = [record.assistantText, record.stdout]
-        .filter((value) => Boolean(value?.trim()))
-        .join("\n");
+    // 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.
+    const text = record.assistantText?.trim() || record.stdout?.trim() || "";
     if (!text)
         throw new Error(`frontend prewrite gate empty output from ${nodeId}`);
     return text;
@@ -171,16 +176,129 @@ async function readNodeRawText(runDir, nodeId) {
     const record = JSON.parse(await readFile(path.join(runDir, `${nodeId}.json`), "utf8"));
     return record.assistantText ?? record.stdout ?? "";
 }
+function resolveRunOwnedArtifact(runDir, candidate, label) {
+    const root = path.resolve(runDir);
+    const resolved = path.resolve(candidate);
+    const relative = path.relative(root, resolved);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`frontend prewrite gate ${label} must be contained by the current run directory`);
+    }
+    return resolved;
+}
+async function readHashBoundArtifact(input) {
+    const resolved = resolveRunOwnedArtifact(input.runDir, input.artifactPath, input.label);
+    const text = await readFile(resolved, "utf8");
+    const actual = sha256Hex(text);
+    if (actual !== input.expectedSha256) {
+        throw new Error(`frontend prewrite gate ${input.label} SHA-256 mismatch (expected ${input.expectedSha256}, got ${actual})`);
+    }
+    return text;
+}
+async function readFrontendPlanNodeInput(runDir, nodeId) {
+    const record = JSON.parse(await readFile(path.join(runDir, `${nodeId}.json`), "utf8"));
+    if (record.status !== "FINISHED") {
+        throw new Error(`frontend prewrite gate requires FINISHED node ${nodeId} (got ${String(record.status)})`);
+    }
+    const frontend = record.frontendPlanOutput;
+    if (!frontend) {
+        const payloadText = record.assistantText?.trim() || record.stdout?.trim() || "";
+        if (!payloadText)
+            throw new Error(`frontend prewrite gate empty output from ${nodeId}`);
+        return {
+            artifactFirst: false,
+            payloadText,
+            citationsText: payloadText,
+            rawCandidateSha256: sha256Hex(record.assistantText ?? record.stdout ?? ""),
+            payloadKind: "canonical-contract",
+        };
+    }
+    if (frontend.schemaVersion !== 1 ||
+        !record.structuredArtifactPath ||
+        !record.structuredArtifactSha256 ||
+        !record.structuredArtifactSchemaId) {
+        throw new Error(`frontend prewrite gate ${nodeId} has incomplete artifact-first metadata`);
+    }
+    const expectedSchema = frontend.payloadKind === "canonical-contract"
+        ? "frontend-implementation-contract-v1"
+        : "frontend-implementation-contract-revision-patch-v1";
+    if (record.structuredArtifactSchemaId !== expectedSchema) {
+        throw new Error(`frontend prewrite gate ${nodeId} artifact schema ${record.structuredArtifactSchemaId} does not match ${frontend.payloadKind}`);
+    }
+    const [payloadText, citationsText] = await Promise.all([
+        readHashBoundArtifact({
+            runDir,
+            artifactPath: record.structuredArtifactPath,
+            expectedSha256: record.structuredArtifactSha256,
+            label: `${nodeId} primary payload`,
+        }),
+        readHashBoundArtifact({
+            runDir,
+            artifactPath: frontend.citationsArtifactPath,
+            expectedSha256: frontend.citationsArtifactSha256,
+            label: `${nodeId} citations`,
+        }),
+        readHashBoundArtifact({
+            runDir,
+            artifactPath: frontend.rawCandidatePath,
+            expectedSha256: frontend.rawCandidateSha256,
+            label: `${nodeId} raw candidate`,
+        }).then(() => undefined),
+    ]);
+    return {
+        artifactFirst: true,
+        payloadText,
+        citationsText,
+        rawCandidateSha256: frontend.rawCandidateSha256,
+        payloadKind: frontend.payloadKind,
+    };
+}
+/**
+ * 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);
+}
 function firstNonEmptyVerdictLine(text) {
     const lines = text
         .split(/\r?\n/)
         .map((line) => line.trim())
         .filter(Boolean);
-    const normalize = (line) => {
-        const emphasized = line.match(/^(?:`{1,3}|\*{1,3})\s*(VERDICT:[^`*]+?)\s*(?:`{1,3}|\*{1,3})$/);
-        return (emphasized?.[1] ?? line).trim();
-    };
-    const normalizedLines = lines.map(normalize);
+    // Emphasis stripping (backtick + asterisk) is shared with the runIf
+    // selector and node-level output-protocol validation via
+    // normalizeVerdictCandidateLine. The gate keeps its own loose
+    // pass/request-revision normalization below (prefix match + trailing
+    // prose tolerance) for deterministic fail-closed behavior.
+    const normalizedLines = lines.map(normalizeVerdictCandidateLine);
     const first = normalizedLines[0] ?? "";
     // The prompt requires VERDICT to be the first non-empty line, but model
     // output can still prepend a summary. Keep the protocol strict in the
@@ -416,9 +534,9 @@ export async function runFrontendPrewriteGate(input) {
         openspecCandidatePaths: input.config.openspecCandidatePaths ?? [],
         openspecPolicy,
     };
-    let planText;
+    let planInput;
     try {
-        planText = await readNodeText(input.runDir, planNodeId);
+        planInput = await readFrontendPlanNodeInput(input.runDir, planNodeId);
     }
     catch (error) {
         return finalizePrewrite(input, {
@@ -428,6 +546,9 @@ export async function runFrontendPrewriteGate(input) {
             failureCode: "plan-text-unreadable",
         });
     }
+    const planText = planInput.payloadText;
+    const citationsText = planInput.citationsText;
+    basePending.candidateRawSha256 = planInput.rawCandidateSha256;
     let reviewText;
     try {
         reviewText = await readNodeText(input.runDir, reviewNodeId);
@@ -459,9 +580,21 @@ export async function runFrontendPrewriteGate(input) {
     let effectiveContractText = null;
     if (revisionPatchMode) {
         const originalNodeId = input.config.planFallbackFromNodeIds[0];
-        let originalText;
         try {
-            originalText = await readNodeText(input.runDir, originalNodeId);
+            const originalInput = await readFrontendPlanNodeInput(input.runDir, originalNodeId);
+            if (planInput.artifactFirst && !originalInput.artifactFirst) {
+                throw new Error(`artifact-first revision ${planNodeId} requires artifact-first original contract ${originalNodeId}`);
+            }
+            if (planInput.artifactFirst) {
+                if (planInput.payloadKind !== "merge-patch" ||
+                    originalInput.payloadKind !== "canonical-contract") {
+                    throw new Error("artifact-first revision/original payload kinds are invalid");
+                }
+                effectiveContractText = serializeDeterministicJson(applyFrontendImplementationContractPatch(JSON.parse(originalInput.payloadText), JSON.parse(planInput.payloadText)));
+            }
+            else {
+                effectiveContractText = await mergeRevisionPatch(input.runDir, planText, originalNodeId);
+            }
         }
         catch (error) {
             return finalizePrewrite(input, {
@@ -472,35 +605,54 @@ export async function runFrontendPrewriteGate(input) {
                 failureCode: "contract-invalid",
             });
         }
-        let originalValue;
-        let patchValue;
+    }
+    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 {
-            originalValue = extractFrontendImplementationJson(originalText);
-            patchValue = extractFrontendImplementationJson(planText);
-        }
-        catch (error) {
-            return finalizePrewrite(input, {
-                ...basePending,
-                verdict,
-                classification: "retryable-invalid",
-                failureReason: `frontend prewrite gate revisionPatch mode failed to parse contract/patch: ${error instanceof Error ? error.message : String(error)}`,
-                failureCode: "contract-invalid",
-            });
+            planJsonValue = extractFrontendImplementationJson(planText);
         }
-        let merged;
-        try {
-            merged = applyFrontendImplementationContractPatch(originalValue, patchValue);
+        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).
         }
-        catch (error) {
-            return finalizePrewrite(input, {
-                ...basePending,
-                verdict,
-                classification: "retryable-invalid",
-                failureReason: `frontend prewrite gate revisionPatch apply failed: ${error instanceof Error ? error.message : String(error)}`,
-                failureCode: "contract-invalid",
-            });
+        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",
+                });
+            }
         }
-        effectiveContractText = serializeDeterministicJson(merged);
     }
     const requirementIdSearchText = effectiveContractText ?? planText;
     const missingIds = input.config.requiredRequirementIds.filter((id) => !requirementIdSearchText.includes(id));
@@ -550,14 +702,17 @@ 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. Artifact-first inputs must keep using
+    // the already hash-verified payload: re-reading the selected node record
+    // here would silently fall back to its prose and defeat the integrity gate.
+    // Historical records intentionally retain their node-text compatibility path.
     let analysis;
     try {
+        const rawContractText = effectiveContractText ?? (planInput.artifactFirst ? planText : undefined);
         analysis = await analyzeFrontendImplementationContract({
             runDir: input.runDir,
-            fromNodeId: effectiveContractText ? undefined : planNodeId,
-            rawContractText: effectiveContractText ?? undefined,
+            fromNodeId: rawContractText ? undefined : planNodeId,
+            rawContractText,
             sourceBinding: input.sourceBinding,
         });
     }
@@ -702,7 +857,7 @@ export async function runFrontendPrewriteGate(input) {
             repoRoot: candidateRoot,
         });
         if (candidatePaths.length > 0) {
-            const parsed = parseOpenspecCitations(planText, candidateRoot);
+            const parsed = parseOpenspecCitations(citationsText, candidateRoot);
             if (!parsed.blockPresent || parsed.unparseable) {
                 return finalizePrewrite(input, {
                     ...basePending,
@@ -843,7 +998,7 @@ export async function runFrontendPrewriteGate(input) {
             });
         }
         if (openspecPolicy === "cited") {
-            const parsedCitations = parseOpenspecCitations(planText, candidateRoot);
+            const parsedCitations = parseOpenspecCitations(citationsText, candidateRoot);
             const citedPaths = new Set(parsedCitations.citations.map((citation) => citation.path));
             const readSet = new Set(openspecReadPaths);
             const uncorroborated = [