@tea-agent/loop-agent 0.35.1-beta.3 → 0.35.1

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

@@ -4,69 +4,10 @@ import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
-import { writeTextArtifactFile } from "../../infrastructure/harness/artifact-store.js";
+import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { findPackageRoot } from "../../shared/package-metadata.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
-export const frontendNormalizationActionSchema = z.enum([
-    "remove-trailing-commas",
-    "strip-comments",
-    "canonicalize-requirement-ids",
-    "canonicalize-verification-alias",
-    "inject-source-binding",
-]);
-export function sha256Hex(input) {
-    return createHash("sha256").update(input, "utf8").digest("hex");
-}
-function sortKeysDeep(value) {
-    if (Array.isArray(value))
-        return value.map(sortKeysDeep);
-    if (value && typeof value === "object") {
-        const record = value;
-        const sorted = {};
-        for (const key of Object.keys(record).sort()) {
-            sorted[key] = sortKeysDeep(record[key]);
-        }
-        return sorted;
-    }
-    return value;
-}
-/** Deterministic JSON serialization: fixed key order, 2-space indent, no
- * trailing newline. Shared by candidate/canonical/digest hashes so the same
- * input always reproduces the same digest. */
-export function serializeDeterministicJson(value) {
-    return JSON.stringify(sortKeysDeep(value), null, 2);
-}
-export function deterministicSha256(value) {
-    return sha256Hex(serializeDeterministicJson(value));
-}
-/** A contract materialization failure carries its classification plus the
- * audit context collected up to the failure point, so the prewrite gate can
- * persist a complete frontend-prewrite-result-v1 even when the canonical
- * contract is never materialized. */
-export class FrontendContractFailure extends Error {
-    kind;
-    candidateRawSha256;
-    candidateJsonSha256;
-    normalizationActions;
-    constructor(options) {
-        super(options.message);
-        this.name = "FrontendContractFailure";
-        this.kind = options.kind;
-        this.candidateRawSha256 = options.candidateRawSha256;
-        this.candidateJsonSha256 = options.candidateJsonSha256 ?? null;
-        this.normalizationActions = options.normalizationActions ?? [];
-    }
-}
-/** Write a JSON artifact with deterministic key order and return its sha256
- * over the exact file bytes, so the canonical contract identity matches what
- * downstream verify/repair/review re-read from disk. */
-export async function writeDeterministicJsonArtifact(runDir, relativePath, value) {
-    const json = `${serializeDeterministicJson(value)}\n`;
-    const targetPath = path.join(runDir, relativePath);
-    await writeTextArtifactFile(targetPath, json);
-    return { path: targetPath, sha256: sha256Hex(json) };
-}
 /**
  * Extract frozen command labels from the DAG run spec (run.json).
  * The run spec is written before any node executes, so it is always available
@@ -191,32 +132,7 @@ const gap = z
     blocking: z.boolean(),
 })
     .strict();
-/**
- * Normalize unstable model emissions before the strict schema sees them:
- * recursively drop null values (object entries and array elements). A null for
- * an optional field becomes "absent" (accepted); a null for a required field
- * still fails, but with a clean Required issue instead of a confusing type
- * mismatch. Unknown keys and misspellings remain strict rejections.
- */
-function stripNullValuesDeep(value) {
-    if (Array.isArray(value)) {
-        return value
-            .filter((item) => item !== null)
-            .map((item) => stripNullValuesDeep(item));
-    }
-    if (value && typeof value === "object") {
-        const record = value;
-        const stripped = {};
-        for (const [key, item] of Object.entries(record)) {
-            if (item !== null)
-                stripped[key] = stripNullValuesDeep(item);
-        }
-        return stripped;
-    }
-    return value;
-}
 export const frontendImplementationContractSchema = z
-    .preprocess(stripNullValuesDeep, z
     .object({
     schemaVersion: z.literal(1),
     sourceBinding: z
@@ -273,9 +189,7 @@ export const frontendImplementationContractSchema = z
             "not-needed",
         ]),
         productionDefaultOff: z.literal(true),
-        activation: z.preprocess((value) => value === "" || value === null || value === undefined
-            ? "explicit activation boundary"
-            : value, z.string().min(1)),
+        activation: z.preprocess((value) => (value === "" || value === null ? "explicit activation boundary" : value), z.string().min(1)),
         endpoints: z.array(z
             .object({
             method: z.enum([
@@ -425,7 +339,7 @@ export const frontendImplementationContractSchema = z
             }
         });
     }
-}));
+});
 export async function assertFrontendSourceBindingFresh(input) {
     for (const source of input.binding.sources) {
         const absolute = resolveDagTaskSourcePath({
@@ -464,13 +378,8 @@ function secretIssues(value, at = "$", issues = []) {
         }
     return issues;
 }
-function extractFrontendImplementationJsonWithAudit(text) {
+export function extractFrontendImplementationJson(text) {
     const trimmed = text.trim();
-    const actions = [];
-    const recordAction = (action) => {
-        if (!actions.includes(action))
-            actions.push(action);
-    };
     const parse = (source) => {
         try {
             return JSON.parse(source);
@@ -483,10 +392,6 @@ function extractFrontendImplementationJsonWithAudit(text) {
                 .replace(/\/\*[\s\S]*?\*\//g, "")
                 .replace(/^\s*\/\/.*$/gm, "");
             const withoutTrailingCommas = withoutComments.replace(/,\s*([}\]])/g, "$1");
-            if (withoutComments !== source)
-                recordAction("strip-comments");
-            if (withoutTrailingCommas !== withoutComments)
-                recordAction("remove-trailing-commas");
             try {
                 return JSON.parse(withoutTrailingCommas);
             }
@@ -545,7 +450,7 @@ function extractFrontendImplementationJsonWithAudit(text) {
             Array.isArray(record.verificationTargets));
     };
     if (trimmed.startsWith("{") && trimmed.endsWith("}"))
-        return { value: parse(trimmed), actions };
+        return parse(trimmed);
     const balancedObjects = [];
     for (let start = 0; start < trimmed.length; start += 1) {
         if (trimmed[start] !== "{")
@@ -583,9 +488,9 @@ function extractFrontendImplementationJsonWithAudit(text) {
     }
     const balancedContracts = balancedObjects.filter(isContract);
     if (balancedContracts.length === 1)
-        return { value: balancedContracts[0], actions };
+        return balancedContracts[0];
     if (balancedObjects.length === 1)
-        return { value: balancedObjects[0], actions };
+        return balancedObjects[0];
     const blocks = [...trimmed.matchAll(/```json\s*\n([\s\S]*?)\n```/gi)];
     if (blocks.length === 0)
         throw new Error("output must contain exactly one fenced json object");
@@ -603,16 +508,13 @@ function extractFrontendImplementationJsonWithAudit(text) {
     }
     const contractCandidates = candidates.filter(isContract);
     if (contractCandidates.length === 1)
-        return { value: contractCandidates[0], actions };
+        return contractCandidates[0];
     if (candidates.length === 1)
-        return { value: candidates[0], actions };
+        return candidates[0];
     if (candidates.length === 0)
         throw new Error("output must contain exactly one valid fenced json object (found 0)");
     throw new Error(`output must contain exactly one valid frontend contract json object (found ${contractCandidates.length || candidates.length})`);
 }
-export function extractFrontendImplementationJson(text) {
-    return extractFrontendImplementationJsonWithAudit(text).value;
-}
 /**
  * Build the authoritative frontend-implementation-contract sourceBinding from
  * the DAG-owned binding. Model JSON must not invent taskId/path/sha256; the
@@ -850,14 +752,7 @@ function deriveFrontendVerificationCoverage(value, canonicalBinding) {
             const requirementId = canonicalizeRequirementId(asString(gap.requirementId));
             // Model gaps are advisory. Blocking status is reconstructed below
             // from the source binding and executable verification targets.
-            // Drop a null/empty optional requirementId so the strict schema
-            // accepts model emissions (null is not a valid string).
-            const { requirementId: _rawRequirementId, ...rest } = gap;
-            return {
-                ...rest,
-                ...(requirementId ? { requirementId } : {}),
-                blocking: false,
-            };
+            return { ...gap, blocking: false };
         })
         : [];
     const derivedBlockingGaps = canonicalBinding.requirementIds
@@ -1333,87 +1228,40 @@ export function coerceFrontendImplementationContractInput(value, canonicalBindin
         evidenceGaps,
     };
 }
-/**
- * Deterministic contract validation shared by the prewrite gate and the plan
- * node output self-check. Extracts, security-checks, coerces, and schema-parses
- * a model-emitted frontend contract, so schema/typo/null violations surface as
- * invalid-output at the producing node (where they can retry) instead of only
- * failing later at the prewrite gate.
- */
-export async function analyzeFrontendImplementationContract(input) {
+export async function materializeFrontendImplementationContract(input) {
     if (!input.sourceBinding)
         throw new Error("frontend implementation contract gate requires DAG sourceBinding");
-    let rawOutput;
-    if (input.rawContractText !== undefined) {
-        rawOutput = input.rawContractText;
-    }
-    else if (input.fromNodeId !== undefined) {
-        const record = JSON.parse(await readFile(path.join(input.runDir, `${input.fromNodeId}.json`), "utf8"));
-        rawOutput = record.assistantText ?? record.stdout ?? "";
-    }
-    else {
-        throw new Error("analyzeFrontendImplementationContract requires fromNodeId or rawContractText");
-    }
-    const rawContractText = rawOutput.trim();
-    const candidateRawSha256 = sha256Hex(rawOutput);
-    const normalizationActions = [];
-    const pushAction = (action) => {
-        if (!normalizationActions.includes(action))
-            normalizationActions.push(action);
-    };
-    function fail(kind, message, candidateJsonSha256) {
-        throw new FrontendContractFailure({
-            kind,
-            message,
-            candidateRawSha256,
-            candidateJsonSha256,
-            normalizationActions,
-        });
-    }
+    const record = JSON.parse(await readFile(path.join(input.runDir, `${input.fromNodeId}.json`), "utf8"));
+    let parsed;
+    const rawContractText = record.assistantText?.trim() || record.stdout?.trim() || "";
     if (rawContractText.includes('"files":["/'))
-        fail("blocked", "invalid-output: absolute frontend contract path is forbidden", null);
+        throw new Error("invalid-output: absolute frontend contract path is forbidden");
     if (/(?:"(?:files|file|implementationTargets|fixture|consumer)"\s*:\s*(?:\[\s*)?)"\//.test(rawContractText))
-        fail("blocked", "invalid-output: absolute frontend contract path is forbidden", null);
+        throw new Error("invalid-output: absolute frontend contract path is forbidden");
     if (/(?:"strategy"\s*:\s*")(?!native\b|browser-intercept\b|request-adapter\b|not-needed\b)[^"]+"/.test(rawContractText))
-        fail("blocked", "invalid-output: unsupported mock strategy", null);
-    let parsed;
+        throw new Error("invalid-output: unsupported mock strategy");
     try {
-        const extracted = extractFrontendImplementationJsonWithAudit(rawContractText);
-        parsed = extracted.value;
-        for (const action of extracted.actions)
-            pushAction(action);
+        parsed = extractFrontendImplementationJson(rawContractText);
     }
     catch (error) {
-        fail("retryable-invalid", `invalid-output: ${error instanceof Error ? error.message : String(error)}`, null);
+        throw new Error(`invalid-output: ${error instanceof Error ? error.message : String(error)}`);
     }
-    const candidateJsonSha256 = deterministicSha256(parsed);
     const secrets = secretIssues(parsed);
     if (secrets.length)
-        fail("blocked", `invalid-output: ${secrets.join("; ")}`, candidateJsonSha256);
+        throw new Error(`invalid-output: ${secrets.join("; ")}`);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-        fail("retryable-invalid", "invalid-output: frontend contract must be a JSON object", candidateJsonSha256);
+        throw new Error("invalid-output: frontend contract must be a JSON object");
     const parsedTargetObject = parsed.targets;
     const parsedFiles = parsedTargetObject && typeof parsedTargetObject === "object"
         ? parsedTargetObject.files
         : undefined;
     if (Array.isArray(parsedFiles) && parsedFiles.some((file) => typeof file === "string" && file.startsWith("/")))
-        fail("blocked", "invalid-output: absolute frontend contract path is forbidden", candidateJsonSha256);
+        throw new Error("invalid-output: absolute frontend contract path is forbidden");
     // Normalize model-emitted compact requirement IDs before deriving the
     // canonical binding or invoking the strict zod schema.
-    const beforeIds = JSON.stringify(parsed);
     parsed = canonicalizeRequirementIdsInPayload(parsed);
-    if (JSON.stringify(parsed) !== beforeIds)
-        pushAction("canonicalize-requirement-ids");
-    const beforeAliases = JSON.stringify(parsed);
     parsed = canonicalizeVerificationTargetAliases(parsed);
-    if (JSON.stringify(parsed) !== beforeAliases)
-        pushAction("canonicalize-verification-alias");
-    try {
-        assertFrontendContractPathsSafe(parsed);
-    }
-    catch (error) {
-        fail("blocked", error instanceof Error ? error.message : String(error), candidateJsonSha256);
-    }
+    assertFrontendContractPathsSafe(parsed);
     // Validate verificationTarget commandLabels against frozen command set.
     // The frozen set is derived from DAG verification shell task verifyEvidence.
     const frozenLabels = await deriveFrozenCommandLabelsFromRun(input.runDir);
@@ -1424,7 +1272,7 @@ export async function analyzeFrontendImplementationContract(input) {
             for (const vt of parsedVt) {
                 const label = asString(asRecord(vt)?.commandLabel);
                 if (label && !frozen.has(label)) {
-                    fail("blocked", `invalid-output: verificationTarget commandLabel "${label}" is not in the frozen command set [${[...frozen].join(", ")}]`, candidateJsonSha256);
+                    throw new Error(`invalid-output: verificationTarget commandLabel "${label}" is not in the frozen command set [${[...frozen].join(", ")}]`);
                 }
             }
         }
@@ -1432,94 +1280,52 @@ export async function analyzeFrontendImplementationContract(input) {
     const parsedTargets = asRecord(parsed)?.targets;
     const parsedTargetFiles = asStringArray(asRecord(parsedTargets)?.files);
     if (parsedTargetFiles.some((file) => file.startsWith("/") || file.includes("\\")))
-        fail("blocked", "invalid-output: frontend contract target paths must be relative POSIX paths", candidateJsonSha256);
+        throw new Error("invalid-output: frontend contract target paths must be relative POSIX paths");
     const parsedStates = asRecord(parsed)?.uiStates;
     if (Array.isArray(parsedStates) && parsedStates.some((item) => {
         const state = asRecord(item);
         return state?.applicable === true &&
             (!asString(state.expectedBehavior) || asStringArray(state.implementationTargets).length === 0 || asStringArray(state.verificationTargetIds).length === 0);
     }))
-        fail("retryable-invalid", "invalid-output: applicable UI state requires behavior, implementation, and verification", candidateJsonSha256);
+        throw new Error("invalid-output: applicable UI state requires behavior, implementation, and verification");
     const parsedMockApi = asRecord(parsed)?.mockApi;
     if (asRecord(parsedMockApi) &&
         typeof asRecord(parsedMockApi)?.strategy === "string" &&
         !["native", "browser-intercept", "request-adapter", "not-needed"].includes(String(asRecord(parsedMockApi)?.strategy)))
-        fail("blocked", `invalid-output: unsupported mock strategy ${String(asRecord(parsedMockApi)?.strategy)}`, candidateJsonSha256);
+        throw new Error(`invalid-output: unsupported mock strategy ${String(asRecord(parsedMockApi)?.strategy)}`);
     const baseCanonicalBinding = canonicalFrontendContractSourceBinding(input.sourceBinding);
     const canonicalBinding = withDerivedRequirementIdsWhenUnscoped(baseCanonicalBinding, parsed);
     // Always inject DAG-owned identity. Model-provided sourceBinding is advisory
-    // only and must not fail a otherwise-valid contract. Record the action only
-    // when the model's emitted binding actually differs from canonical identity.
-    const modelBinding = asRecord(asRecord(parsed)?.sourceBinding);
-    if (serializeDeterministicJson(modelBinding ?? null) !== serializeDeterministicJson(canonicalBinding))
-        pushAction("inject-source-binding");
+    // only and must not fail a otherwise-valid contract (common live failure:
+    // wrong requirementPath/sha, extra referencePaths, or omitted binding).
+    const normalizedContract = coerceFrontendImplementationContractInput(parsed, canonicalBinding);
     // There is exactly one post-security candidate. A fallback candidate would
     // allow malformed raw fields to bypass the boundary checks above.
-    const normalizedContract = coerceFrontendImplementationContractInput(parsed, canonicalBinding);
     const candidate = deriveFrontendVerificationCoverage({
         ...(asRecord(normalizedContract) ?? parsed),
         sourceBinding: canonicalBinding,
     }, canonicalBinding);
     const result = frontendImplementationContractSchema.safeParse(candidate);
     if (!result.success)
-        fail("retryable-invalid", `invalid-output: ${result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`, candidateJsonSha256);
+        throw new Error(`invalid-output: ${result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`);
     const blockingGaps = [
         ...result.data.evidenceGaps,
         ...result.data.requirements.flatMap((item) => item.evidenceGap ? [item.evidenceGap] : []),
     ].filter((item) => item.blocking);
     if (blockingGaps.length > 0)
-        fail("blocked", `frontend contract has blocking evidence gap: ${blockingGaps
+        throw new Error(`frontend contract has blocking evidence gap: ${blockingGaps
             .map((item) => item.requirementId ?? item.description)
-            .join(", ")}`, candidateJsonSha256);
+            .join(", ")}`);
     for (const requirementId of canonicalBinding.requirementIds)
         if (!result.data.requirements.some((item) => item.id === requirementId) &&
             !result.data.evidenceGaps.some((item) => item.requirementId === requirementId))
-            fail("blocked", `frontend contract does not cover ${requirementId}`, candidateJsonSha256);
-    return {
-        canonical: result.data,
-        candidateRawSha256,
-        candidateJsonSha256,
-        normalizationActions,
-    };
-}
-export async function writeFrontendImplementationContractArtifact(input) {
-    const written = await writeDeterministicJsonArtifact(input.runDir, path.posix.join(input.outputDir, input.artifactName), input.canonical);
+            throw new Error(`frontend contract does not cover ${requirementId}`);
+    const artifactPath = await writeDagRunJsonArtifact(input.runDir, path.posix.join(input.outputDir, input.artifactName), result.data);
     return {
-        path: written.path,
-        sha256: written.sha256,
+        path: artifactPath,
+        sha256: createHash("sha256")
+            .update(`${JSON.stringify(result.data, null, 2)}\n`)
+            .digest("hex"),
         schemaId: FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
     };
 }
-/**
- * Node-output self-check for plan nodes that produce the implementation
- * contract. Mirrors the prewrite gate validation so schema/typo/null violations
- * are caught at the producing node and retried instead of failing the run later.
- * Skipped when no sourceBinding is available (the gate remains the authority).
- */
-export async function validateFrontendContractNodeOutput(input) {
-    if (!input.sourceBinding)
-        return { ok: true };
-    try {
-        const analysis = await analyzeFrontendImplementationContract({
-            runDir: input.runDir,
-            rawContractText: input.text,
-            sourceBinding: input.sourceBinding,
-        });
-        return { ok: true, contract: analysis.canonical };
-    }
-    catch (error) {
-        return {
-            ok: false,
-            reason: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-export async function materializeFrontendImplementationContract(input) {
-    const analysis = await analyzeFrontendImplementationContract(input);
-    return writeFrontendImplementationContractArtifact({
-        runDir: input.runDir,
-        outputDir: input.outputDir,
-        artifactName: input.artifactName,
-        canonical: analysis.canonical,
-    });
-}