@tea-agent/loop-agent 0.19.0 → 0.20.0

package/dist/workflows/dag/backend-test-result-contract.js

@@ -178,8 +178,10 @@ export function parseJunitXml(xml) {
     if (openedCases !== closedCases + selfClosingCases) {
         throw new Error("invalid junit xml: unclosed testcase element");
     }
-    // Prefer root testsuites aggregates when present.
+    // Prefer root testsuites aggregates when present, then fall back to the first
+    // testsuite aggregate. Pytest commonly emits time only on <testsuite>.
     const suitesOpen = trimmed.match(/<testsuites\b[^>]*>/i)?.[0];
+    const firstSuiteOpen = trimmed.match(/<testsuite\b[^>]*>/i)?.[0];
     let tests = 0;
     let failed = 0;
     let errors = 0;
@@ -202,9 +204,15 @@ export function parseJunitXml(xml) {
         if (time !== undefined && time !== "")
             timeSec = Number(time);
     }
+    if (timeSec === undefined && firstSuiteOpen) {
+        const time = attr(firstSuiteOpen, "time");
+        if (time !== undefined && time !== "")
+            timeSec = Number(time);
+    }
     // Self-closing first so empty cases ending with /> are not greedily paired with a later </testcase>.
     const caseRe = /<testcase\b([^>]*?)\/>|<testcase\b([^>]*)>([\s\S]*?)<\/testcase>/gi;
     const failures = [];
+    const cases = [];
     let caseCount = 0;
     let caseFailed = 0;
     let caseErrors = 0;
@@ -216,35 +224,49 @@ export function parseJunitXml(xml) {
         const body = match[3] ?? "";
         const classname = attr(openAttrs, "classname") || "unknown";
         const name = attr(openAttrs, "name") || "unknown";
+        const caseTime = attr(openAttrs, "time");
+        const caseDurationMs = caseTime !== undefined && caseTime !== "" && !Number.isNaN(Number(caseTime))
+            ? Math.round(Number(caseTime) * 1000)
+            : undefined;
         const failureTag = body.match(/<failure\b([^>]*)>([\s\S]*?)<\/failure>|<failure\b([^>]*)\/>/i);
         const errorTag = body.match(/<error\b([^>]*)>([\s\S]*?)<\/error>|<error\b([^>]*)\/>/i);
         const skippedTag = /<skipped\b/i.test(body);
         if (failureTag) {
             caseFailed += 1;
             const fAttrs = failureTag[1] ?? failureTag[3] ?? "";
-            const fBody = failureTag[2] ?? "";
-            const message = attr(fAttrs, "message") || fBody || "failure";
+            const fBody = decodeXmlEntities(failureTag[2] ?? "").trim();
+            const message = decodeXmlEntities(attr(fAttrs, "message") || fBody || "failure");
+            const summary = truncate(message);
             failures.push({
                 classname,
                 name,
-                message: truncate(message),
+                message: summary,
                 kind: "failure",
             });
+            cases.push({ classname, name, durationMs: caseDurationMs, status: "failure", message: summary, details: fBody || summary });
         }
         else if (errorTag) {
             caseErrors += 1;
             const eAttrs = errorTag[1] ?? errorTag[3] ?? "";
-            const eBody = errorTag[2] ?? "";
-            const message = attr(eAttrs, "message") || eBody || "error";
+            const eBody = decodeXmlEntities(errorTag[2] ?? "").trim();
+            const message = decodeXmlEntities(attr(eAttrs, "message") || eBody || "error");
+            const summary = truncate(message);
             failures.push({
                 classname,
                 name,
-                message: truncate(message),
+                message: summary,
                 kind: "error",
             });
+            cases.push({ classname, name, durationMs: caseDurationMs, status: "error", message: summary, details: eBody || summary });
         }
         else if (skippedTag) {
             caseSkipped += 1;
+            const skippedAttrs = body.match(/<skipped\b([^>]*)/i)?.[1] ?? "";
+            const message = attr(skippedAttrs, "message");
+            cases.push({ classname, name, durationMs: caseDurationMs, status: "skipped", ...(message ? { message } : {}) });
+        }
+        else {
+            cases.push({ classname, name, durationMs: caseDurationMs, status: "passed" });
         }
         match = caseRe.exec(trimmed);
     }
@@ -322,6 +344,7 @@ export function parseJunitXml(xml) {
         durationMs: timeSec !== undefined && !Number.isNaN(timeSec)
             ? Math.round(timeSec * 1000)
             : undefined,
+        cases,
         failures: failures.slice(0, MAX_FAILURES),
     };
 }

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

@@ -0,0 +1,77 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { frontendImplementationContractSchema, materializeFrontendImplementationContract, } from "./frontend-implementation-contract.js";
+async function selectNode(runDir, primary, fallbacks) {
+    for (const nodeId of [primary, ...fallbacks.filter((id) => id !== primary)]) {
+        try {
+            await stat(path.join(runDir, `${nodeId}.json`));
+            return nodeId;
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                continue;
+            throw error;
+        }
+    }
+    throw new Error(`frontend prewrite gate missing node output: ${[primary, ...fallbacks].join(", ")}`);
+}
+async function readNodeText(runDir, nodeId) {
+    const record = JSON.parse(await readFile(path.join(runDir, `${nodeId}.json`), "utf8"));
+    const text = record.assistantText?.trim() || record.stdout?.trim() || "";
+    if (!text)
+        throw new Error(`frontend prewrite gate empty output from ${nodeId}`);
+    return text;
+}
+function firstVerdictLine(text) {
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim().replace(/^\*{1,3}\s*(VERDICT:[^*]+?)\s*\*{1,3}$/, "$1").trim();
+        if (line.startsWith("VERDICT:"))
+            return line;
+    }
+    return "";
+}
+export async function runFrontendPrewriteGate(input) {
+    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 planText = await readNodeText(input.runDir, planNodeId);
+    const reviewText = await readNodeText(input.runDir, reviewNodeId);
+    const verdict = firstVerdictLine(reviewText);
+    if (verdict !== "VERDICT: pass") {
+        throw new Error(`frontend prewrite gate blocked by ${reviewNodeId}: ${verdict || "missing VERDICT"}`);
+    }
+    const missingIds = input.config.requiredRequirementIds.filter((id) => !planText.includes(id));
+    if (missingIds.length > 0) {
+        throw new Error(`frontend prewrite gate missing requirement ids: ${missingIds.join(", ")}`);
+    }
+    const artifact = await materializeFrontendImplementationContract({
+        runDir: input.runDir,
+        fromNodeId: planNodeId,
+        artifactName: input.config.artifactName,
+        outputDir: input.config.outputDir,
+        sourceBinding: input.sourceBinding,
+    });
+    const raw = JSON.parse(await readFile(artifact.path, "utf8"));
+    const contract = frontendImplementationContractSchema.parse(raw);
+    if (!input.config.allowedMockStrategies.includes(contract.mockApi.strategy)) {
+        throw new Error(`frontend prewrite gate blocked mock strategy ${contract.mockApi.strategy}; allowed=${input.config.allowedMockStrategies.join(",")}`);
+    }
+    return {
+        ok: true,
+        planNodeId,
+        reviewNodeId,
+        verdict,
+        mockStrategy: contract.mockApi.strategy,
+        artifact,
+    };
+}
+export function formatFrontendPrewriteGateStdout(result) {
+    return [
+        "Frontend prewrite gate: pass",
+        `Plan: ${result.planNodeId}`,
+        `Review: ${result.reviewNodeId}`,
+        `Mock strategy: ${result.mockStrategy}`,
+        `Structured artifact: ${result.artifact.path}`,
+        `Schema: ${result.artifact.schemaId}`,
+        `SHA-256: ${result.artifact.sha256}`,
+    ].join("\n");
+}

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

@@ -190,6 +190,8 @@ export async function runFrontendFailureAssessGate(input) {
         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",
@@ -197,8 +199,12 @@ export async function runFrontendFailureAssessGate(input) {
         "frontend-behavior-reverify-shell",
         "frontend-verification-retrace-shell",
     ];
-    const failed = [];
+    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"));

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

@@ -0,0 +1,43 @@
+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";
+export const FRONTEND_REVIEW_CONTEXT_SCHEMA_ID = "frontend-review-context-v1";
+async function readRequiredJson(runDir, relativePath) {
+    try {
+        return JSON.parse(await readFile(path.join(runDir, relativePath), "utf8"));
+    }
+    catch {
+        throw new Error(`frontend review context missing or invalid ${relativePath}`);
+    }
+}
+export async function runFrontendReviewContextGate(input) {
+    const diff = await runFrontendWorktreeDiffGate(input);
+    const contract = await readRequiredJson(input.runDir, "contracts/frontend-implementation-contract.json");
+    const verificationTrace = await readRequiredJson(input.runDir, "contracts/frontend-verification-trace.json");
+    const repairAssessment = await readRequiredJson(input.runDir, "contracts/frontend-repair-assessment.json");
+    const payload = {
+        schemaVersion: 1,
+        schemaId: FRONTEND_REVIEW_CONTEXT_SCHEMA_ID,
+        contract,
+        verificationTrace,
+        repairAssessment,
+        diff: {
+            schemaId: diff.schemaId,
+            patchPath: diff.patchPath,
+            patchSha256: diff.patchSha256,
+            changedFiles: diff.changedFiles,
+            untrackedFiles: diff.untrackedFiles,
+            empty: diff.empty,
+        },
+    };
+    const artifactPath = await writeDagRunJsonArtifact(input.runDir, "contracts/frontend-review-context.json", payload);
+    return { ok: true, artifactPath, diff };
+}
+export function formatFrontendReviewContextStdout(result) {
+    return [
+        "Frontend review context: pass",
+        `Artifact: ${result.artifactPath}`,
+        formatFrontendWorktreeDiffStdout(result.diff),
+    ].join("\n");
+}

package/dist/workflows/dag/frontend-verification-trace.js

@@ -95,26 +95,45 @@ export async function runFrontendVerificationTraceGate(input) {
         }
         throw new Error(`trace: missing static/behavior verify node records (tried ${errors.join(", ")})`);
     }
-    const staticNode = await loadFirstNode(staticCandidates);
-    const behaviorNode = await loadFirstNode(behaviorCandidates);
+    const staticNode = input.evidence
+        ? {
+            nodeId: input.evidence.static.nodeId,
+            record: {
+                status: "FINISHED",
+                verifyEvidence: { commandLabels: input.evidence.static.commandLabels },
+            },
+        }
+        : await loadFirstNode(staticCandidates);
+    const behaviorNode = input.evidence
+        ? {
+            nodeId: input.evidence.behavior.nodeId,
+            record: {
+                status: "FINISHED",
+                verifyEvidence: { commandLabels: input.evidence.behavior.commandLabels },
+            },
+        }
+        : await loadFirstNode(behaviorCandidates);
     assertNodeFinished(staticNode.nodeId, staticNode.record);
     assertNodeFinished(behaviorNode.nodeId, behaviorNode.record);
     const labelOwners = collectCommandLabels({ nodeId: staticNode.nodeId, record: staticNode.record }, { nodeId: behaviorNode.nodeId, record: behaviorNode.record });
-    const assessPath = path.join(input.runDir, "frontend-mock-assess-pi.json");
-    try {
-        const assess = (await readJsonFile(assessPath));
-        const text = assess.assistantText?.trim() || assess.stdout?.trim() || "";
-        const strategy = parseMockStrategyFromAssess(text);
-        if (strategy && strategy !== contract.mockApi.strategy) {
-            throw new Error(`trace: mock strategy mismatch: assess=${strategy} contract=${contract.mockApi.strategy}`);
+    // Legacy runs may still carry a standalone Mock assessment. New slim runs
+    // bind the strategy directly through the validated implementation contract.
+    if (!input.evidence) {
+        const assessPath = path.join(input.runDir, "frontend-mock-assess-pi.json");
+        try {
+            const assess = (await readJsonFile(assessPath));
+            const text = assess.assistantText?.trim() || assess.stdout?.trim() || "";
+            const strategy = parseMockStrategyFromAssess(text);
+            if (strategy && strategy !== contract.mockApi.strategy) {
+                throw new Error(`trace: mock strategy mismatch: assess=${strategy} contract=${contract.mockApi.strategy}`);
+            }
         }
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            error.message.startsWith("trace: mock strategy mismatch")) {
-            throw error;
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.startsWith("trace: mock strategy mismatch")) {
+                throw error;
+            }
         }
-        // assess optional for pure unit fixtures without mock node
     }
     const targets = [];
     const hardIssues = [];

package/dist/workflows/dag/governance-profile.js

@@ -104,16 +104,24 @@ function writeSetMatchesAnyPattern(writeSet, patterns) {
     return undefined;
 }
 function shellCommandLooksDeterministic(command) {
-    return (/\bnpx vitest run\b/.test(command) ||
-        /\bnpm run (lint|typecheck|test)\b/.test(command) ||
-        /check-repo\.sh/.test(command) ||
-        /\bshell\.preset\b/.test(command) ||
-        /loop-agent-standard-verify/.test(command));
+    const normalized = command.replace(/["']/g, "");
+    return (/\bnpx vitest run\b/.test(normalized) ||
+        /\bnpm (?:run )?(?:lint|typecheck|test)\b/.test(normalized) ||
+        /check-repo\.sh/.test(normalized) ||
+        /\bshell\.preset\b/.test(normalized) ||
+        /loop-agent-standard-verify/.test(normalized));
 }
 function taskHasDeterministicShellVerification(task) {
     if (task.executor !== "shell")
         return false;
-    const commands = resolveShellCommands(task.shell ?? { commands: [] });
+    const bundle = task.shell?.frontendVerificationBundle;
+    const commands = bundle
+        ? [
+            ...bundle.mockCommands,
+            ...bundle.staticCommands,
+            ...bundle.behaviorCommands,
+        ]
+        : resolveShellCommands(task.shell ?? { commands: [] });
     return commands.some(shellCommandLooksDeterministic);
 }
 function collectExclusiveWriters(spec) {