@tea-agent/loop-agent 0.19.0 → 0.20.1-beta.0

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) {