@tea-agent/loop-agent 0.20.1 → 0.22.0

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

@@ -231,6 +231,12 @@ export function parseJunitXml(xml) {
         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);
+        const caseStdout = body.match(/<system-out\b[^>]*>([\s\S]*?)<\/system-out>/i)?.[1];
+        const caseStderr = body.match(/<system-err\b[^>]*>([\s\S]*?)<\/system-err>/i)?.[1];
+        const capturedOutput = {
+            ...(caseStdout ? { stdout: decodeXmlEntities(caseStdout).trim() } : {}),
+            ...(caseStderr ? { stderr: decodeXmlEntities(caseStderr).trim() } : {}),
+        };
         if (failureTag) {
             caseFailed += 1;
             const fAttrs = failureTag[1] ?? failureTag[3] ?? "";
@@ -243,7 +249,7 @@ export function parseJunitXml(xml) {
                 message: summary,
                 kind: "failure",
             });
-            cases.push({ classname, name, durationMs: caseDurationMs, status: "failure", message: summary, details: fBody || summary });
+            cases.push({ classname, name, durationMs: caseDurationMs, status: "failure", message: summary, details: fBody || summary, ...capturedOutput });
         }
         else if (errorTag) {
             caseErrors += 1;
@@ -257,16 +263,16 @@ export function parseJunitXml(xml) {
                 message: summary,
                 kind: "error",
             });
-            cases.push({ classname, name, durationMs: caseDurationMs, status: "error", message: summary, details: eBody || summary });
+            cases.push({ classname, name, durationMs: caseDurationMs, status: "error", message: summary, details: eBody || summary, ...capturedOutput });
         }
         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 } : {}) });
+            cases.push({ classname, name, durationMs: caseDurationMs, status: "skipped", ...(message ? { message } : {}), ...capturedOutput });
         }
         else {
-            cases.push({ classname, name, durationMs: caseDurationMs, status: "passed" });
+            cases.push({ classname, name, durationMs: caseDurationMs, status: "passed", ...capturedOutput });
         }
         match = caseRe.exec(trimmed);
     }

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

@@ -1,11 +1,12 @@
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { findPackageRoot } from "../../shared/package-metadata.js";
+import { pathMatchesPattern } from "../../shared/git-progress.js";
 export const FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID = "frontend-implementation-contract-v1";
 /**
  * Load the canonical frontend-implementation-contract-v1 JSON Schema from the
@@ -122,7 +123,7 @@ export const frontendImplementationContractSchema = z
         verificationTargetIds: z.array(z.string().min(1)),
         evidenceGap: gap.optional(),
     })
-        .strict()),
+        .strict()).min(1),
     uiStates: z.array(z
         .object({
         name: z.string().min(1),
@@ -132,7 +133,7 @@ export const frontendImplementationContractSchema = z
         verificationTargetIds: z.array(z.string().min(1)).optional(),
         notApplicableReason: z.string().min(1).optional(),
     })
-        .strict()),
+        .strict()).min(1),
     interactions: z.array(z
         .object({
         name: z.string().min(1),
@@ -185,7 +186,7 @@ export const frontendImplementationContractSchema = z
         requirementIds: z.array(id),
         uiStates: z.array(z.string().min(1)),
     })
-        .strict()),
+        .strict()).min(1),
     evidenceGaps: z.array(gap),
 })
     .strict()
@@ -198,6 +199,30 @@ export const frontendImplementationContractSchema = z
             path: ["verificationTargets"],
         });
     const known = new Set(value.sourceBinding.requirementIds);
+    const stateNames = new Set(value.uiStates.map((state) => state.name));
+    for (const target of value.verificationTargets) {
+        // Verification evidence may point to read-only project files such as
+        // tsconfig.json or a test entrypoint; implementation targets remain
+        // governed by targets.files and the writer writeSet.
+        for (const requirementId of target.requirementIds) {
+            if (!known.has(requirementId)) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: `verification target references unknown requirement ${requirementId}`,
+                    path: ["verificationTargets"],
+                });
+            }
+        }
+        for (const stateName of target.uiStates) {
+            if (!stateNames.has(stateName)) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: `verification target references unknown UI state ${stateName}`,
+                    path: ["verificationTargets"],
+                });
+            }
+        }
+    }
     for (const requirement of value.requirements) {
         if (!known.has(requirement.id))
             ctx.addIssue({
@@ -238,7 +263,70 @@ export const frontendImplementationContractSchema = z
                 path: ["uiStates"],
             });
     }
+    if (value.mockApi.strategy !== "not-needed") {
+        if (value.mockApi.endpoints.length === 0) {
+            ctx.addIssue({
+                code: "custom",
+                message: "Mock strategy requires at least one endpoint",
+                path: ["mockApi", "endpoints"],
+            });
+        }
+        value.mockApi.endpoints.forEach((endpoint, index) => {
+            if (!endpoint.fixture) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: "Mock endpoint requires a fixture path",
+                    path: ["mockApi", "endpoints", index, "fixture"],
+                });
+            }
+            if (!endpoint.consumer) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: "Mock endpoint requires a consumer path",
+                    path: ["mockApi", "endpoints", index, "consumer"],
+                });
+            }
+            for (const [field, file] of [["fixture", endpoint.fixture], ["consumer", endpoint.consumer]]) {
+                if (file && !value.targets.files.some((pattern) => pathMatchesPattern(file, pattern))) {
+                    ctx.addIssue({
+                        code: "custom",
+                        message: `Mock ${field} is outside contract targets: ${file}`,
+                        path: ["mockApi", "endpoints", index, field],
+                    });
+                }
+            }
+        });
+    }
 });
+export async function assertFrontendSourceBindingFresh(input) {
+    for (const source of input.binding.sources) {
+        // DAG source bindings are task-relative (for example source/需求.md),
+        // while older bindings may already contain the repository-relative
+        // .harness/tasks/<taskId>/ prefix. Resolve both forms before hashing.
+        const taskDir = path.resolve(input.workspaceRoot, ".harness", "tasks", input.binding.taskId);
+        const absolute = source.path.startsWith(".harness/")
+            ? path.resolve(input.workspaceRoot, source.path)
+            : path.resolve(taskDir, source.path);
+        const relative = path.relative(input.workspaceRoot, absolute);
+        if (relative.startsWith("..") || path.isAbsolute(relative)) {
+            throw new Error(`frontend source binding escapes workspace: ${source.path}`);
+        }
+        let content;
+        try {
+            content = await readFile(absolute);
+            const info = await stat(absolute);
+            if (!info.isFile())
+                throw new Error("not a regular file");
+        }
+        catch (error) {
+            throw new Error(`frontend source binding file unavailable: ${source.path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const actual = createHash("sha256").update(content).digest("hex");
+        if (actual !== source.sha256) {
+            throw new Error(`frontend source binding is stale: ${source.path}`);
+        }
+    }
+}
 const SECRET_KEY = /(?:password|passwd|secret|token|api[_-]?key|private[_-]?key|credential|authorization)/i;
 const SECRET_VALUE = /(?:-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:sk|ghp|github_pat|xox[baprs]|AKIA)[-_A-Za-z0-9]{12,}\b)/;
 function secretIssues(value, at = "$", issues = []) {
@@ -314,9 +402,42 @@ function looksLikeStrictFrontendContract(value) {
  * Near-schema payloads are left untouched so unknown-key fail-closed still holds.
  */
 export function coerceFrontendImplementationContractInput(value, canonicalBinding) {
-    if (looksLikeStrictFrontendContract(value))
-        return value;
-    const record = asRecord(value);
+    const rawRecord = asRecord(value);
+    const verificationTargetIds = rawRecord && Array.isArray(rawRecord.verificationTargets)
+        ? new Set(rawRecord.verificationTargets
+            .map((item) => asString(asRecord(item)?.id))
+            .filter(Boolean))
+        : undefined;
+    const normalizedValue = rawRecord
+        ? {
+            ...rawRecord,
+            requirements: verificationTargetIds && Array.isArray(rawRecord.requirements)
+                ? rawRecord.requirements.map((item) => {
+                    const requirement = asRecord(item);
+                    if (!requirement || !Array.isArray(requirement.verificationTargetIds))
+                        return item;
+                    return {
+                        ...requirement,
+                        verificationTargetIds: requirement.verificationTargetIds.filter((id) => typeof id === "string" && verificationTargetIds.has(id)),
+                    };
+                })
+                : rawRecord.requirements,
+            uiStates: Array.isArray(rawRecord.uiStates)
+                ? rawRecord.uiStates.map((item) => {
+                    const state = asRecord(item);
+                    if (!state ||
+                        state.applicable === false ||
+                        (state.notApplicableReason !== "" && state.notApplicableReason !== null))
+                        return item;
+                    const { notApplicableReason: _emptyReason, ...withoutEmptyReason } = state;
+                    return withoutEmptyReason;
+                })
+                : rawRecord.uiStates,
+        }
+        : value;
+    if (looksLikeStrictFrontendContract(normalizedValue))
+        return normalizedValue;
+    const record = asRecord(normalizedValue);
     if (!record)
         return value;
     const implementation = asRecord(record.implementation);
@@ -333,7 +454,7 @@ export function coerceFrontendImplementationContractInput(value, canonicalBindin
         ...asStringArray(asRecord(component?.paths)?.domHelper ? [asRecord(component?.paths)?.domHelper] : []),
     ].filter((item, index, arr) => arr.indexOf(item) === index);
     if (targetFiles.length === 0) {
-        targetFiles.push("apps/web/src/welcome/WelcomeBanner.js");
+        throw new Error("frontend contract compatibility input must declare target files");
     }
     const riskRaw = asString(record.riskLevel) ||
         asString(record.risk) ||
@@ -383,21 +504,7 @@ export function coerceFrontendImplementationContractInput(value, canonicalBindin
         });
     }
     if (verificationTargets.length === 0) {
-        verificationTargets.push({
-            id: "VT-STATIC",
-            type: "static",
-            commandLabel: "npm run typecheck",
-            file: targetFiles[0],
-            requirementIds: [...canonicalBinding.requirementIds],
-            uiStates: ["success"],
-        }, {
-            id: "VT-UNIT",
-            type: "unit",
-            commandLabel: "npm run test:unit:fe",
-            file: targetFiles.find((p) => p.includes("__tests__")) || targetFiles[0],
-            requirementIds: [...canonicalBinding.requirementIds],
-            uiStates: ["success", "error"],
-        });
+        throw new Error("frontend contract compatibility input must declare verification targets");
     }
     const defaultVerificationIds = verificationTargets.map((item) => String(item.id));
     const requirements = [];
@@ -440,11 +547,7 @@ export function coerceFrontendImplementationContractInput(value, canonicalBindin
     }
     for (const id of canonicalBinding.requirementIds) {
         if (!requirements.some((item) => item.id === id)) {
-            requirements.push({
-                id,
-                implementationTargets: targetFiles,
-                verificationTargetIds: defaultVerificationIds,
-            });
+            throw new Error(`frontend contract compatibility input does not cover ${id}`);
         }
     }
     const uiStates = [];
@@ -511,14 +614,20 @@ export function coerceFrontendImplementationContractInput(value, canonicalBindin
         });
     }
     const strategyRaw = asString(mockApiIn.strategy) || "not-needed";
-    const strategy = [
+    const allowedStrategies = [
         "native",
         "browser-intercept",
         "request-adapter",
         "not-needed",
-    ].includes(strategyRaw)
-        ? strategyRaw
-        : "not-needed";
+    ];
+    if (!allowedStrategies.includes(strategyRaw)) {
+        throw new Error(`frontend contract compatibility input has unsupported Mock strategy: ${strategyRaw}`);
+    }
+    const strategy = strategyRaw;
+    const productionDefaultOff = mockApiIn.productionDefaultOff === true || mockApiIn.productionMockOff === true;
+    if (!productionDefaultOff) {
+        throw new Error("frontend contract compatibility input must prove production Mock is off");
+    }
     const activation = asString(mockApiIn.activation) ||
         (strategy === "not-needed"
             ? "production remains real fetch; unit tests may inject fetchImpl only"