@tea-agent/loop-agent 0.16.23 → 0.16.25

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

@@ -334,6 +334,41 @@ function asRecord(value) {
  * Prefer exact schema payloads; otherwise map common discovery shapes onto the
  * pytest-centric runtime contract without inventing secrets or managed commands.
  */
+/** True when managed start is a local node/npm process the adapter cannot host. */
+export function isLocalManagedServerStart(start) {
+    if (!start)
+        return false;
+    const normalized = start.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    return (/\bnpm(\s+run)?\s+start\b/.test(normalized) ||
+        /\bnode\s+server(\.js)?\b/.test(normalized) ||
+        /\bnode\s+\.\/?server(\.js)?\b/.test(normalized) ||
+        /\bbash\s+scripts\/fe-test-server\.sh\b/.test(normalized) ||
+        normalized === "node server.js" ||
+        normalized.includes("server.js"));
+}
+function seedLocalServerFixture(fixtures, managedStart) {
+    if (Array.isArray(fixtures) && fixtures.length > 0) {
+        return fixtures.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item)));
+    }
+    if (managedStart.includes("server") || managedStart.includes("npm")) {
+        return [
+            {
+                name: "server-bootstrap",
+                sourcePath: "server.js",
+                kind: "server-bootstrap",
+            },
+        ];
+    }
+    return [
+        {
+            name: "pytest-test-root",
+            sourcePath: BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT,
+            kind: "test-root",
+        },
+    ];
+}
 /** Drop empty managedCommand strings; omit block when not managed-command. */
 export function sanitizeBackendTestExecutionInput(value) {
     const record = asRecord(value);
@@ -359,6 +394,51 @@ export function sanitizeBackendTestExecutionInput(value) {
             next.managedCommand = cleaned;
         }
     }
+    // Adapter always executes `python -m pytest testcase/`. Scout-chosen relative roots such as
+    // tests/api/** are product sample trees, not the frozen automation root. Absolute / ..
+    // paths stay untouched so schema materialize remains fail-closed.
+    if (typeof next.testRoot === "string" && next.testRoot.trim()) {
+        const rawRoot = next.testRoot.trim();
+        const normalizedRoot = rawRoot.replace(/\/+$/, "");
+        const looksUnsafe = normalizedRoot.startsWith("/") ||
+            normalizedRoot.includes("..") ||
+            normalizedRoot.includes("\\") ||
+            /^[A-Za-z]:/.test(normalizedRoot);
+        if (!looksUnsafe &&
+            normalizedRoot !== BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT) {
+            const gaps = Array.isArray(next.evidenceGaps)
+                ? [...next.evidenceGaps]
+                : [];
+            gaps.push({
+                description: `scout testRoot=${normalizedRoot} remapped to frozen adapter root ${BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT}`,
+                sourceRef: "adapter:backend-test-execution",
+            });
+            next.evidenceGaps = gaps;
+            next.testRoot = BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT;
+        }
+    }
+    // Local node/npm managed-command is not hosted by the clean-env pytest shell.
+    // Demote to in-process so generate-pytest must bootstrap the server inside fixtures
+    // instead of requiring host-injected base URL env vars that clean env cannot provide.
+    const managedStart = asRecord(next.managedCommand) &&
+        typeof asRecord(next.managedCommand).start === "string"
+        ? String(asRecord(next.managedCommand).start)
+        : "";
+    if (next.targetMode === "managed-command" &&
+        isLocalManagedServerStart(managedStart)) {
+        next.targetMode = "in-process";
+        next.requiredEnvNames = [];
+        next.existingFixtures = seedLocalServerFixture(Array.isArray(next.existingFixtures) ? next.existingFixtures : null, managedStart);
+        const gaps = Array.isArray(next.evidenceGaps)
+            ? [...next.evidenceGaps]
+            : [];
+        gaps.push({
+            description: "local managed-command demoted to in-process: clean-env pytest shell does not start npm/node servers or inject base URL env; tests must bootstrap via fixtures",
+            sourceRef: asRecord(next.managedCommand)?.sourceRef ||
+                "adapter:backend-test-execution",
+        });
+        next.evidenceGaps = gaps;
+    }
     // Near-schema scouts sometimes emit in-process with existingFixtures: [].
     // Only rewrite near-schema payloads here; free-form envelopes keep empty/missing
     // fixtures so coerceBackendTestExecutionInput can map discoveredFixtures first.
@@ -369,23 +449,7 @@ export function sanitizeBackendTestExecutionInput(value) {
     if (nearSchema &&
         (next.targetMode === "in-process" || next.targetMode === undefined) &&
         (!fixtures || fixtures.length === 0)) {
-        const managedStart = asRecord(next.managedCommand) &&
-            typeof asRecord(next.managedCommand).start === "string"
-            ? String(asRecord(next.managedCommand).start)
-            : "";
-        next.existingFixtures = [
-            managedStart.includes("server")
-                ? {
-                    name: "server-bootstrap",
-                    sourcePath: "server.js",
-                    kind: "server-bootstrap",
-                }
-                : {
-                    name: "pytest-test-root",
-                    sourcePath: BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT,
-                    kind: "test-root",
-                },
-        ];
+        next.existingFixtures = seedLocalServerFixture(fixtures, managedStart);
         if (next.targetMode === undefined)
             next.targetMode = "in-process";
     }
@@ -631,10 +695,12 @@ export function buildBackendTestExecutionPreflightShellSnippet(options) {
         `console.log("backend-test preflight ok: framework=pytest testRoot="+testRoot+" targetMode="+contract.targetMode);'`,
         ' "${CONTRACT}"',
     ].join("");
+    // Fail-closed: join with && so a preflight exit 2 never continues into pytest.
+    // Historical ";" chains recorded I27-style false progresses (env missing + pytest ran).
     return [
         'test -n "${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for backend pytest preflight" >&2; exit 2; }',
         `CONTRACT="\${HARNESS_DAG_RUN_DIR}/${contractRelativePath}"`,
         'test -f "${CONTRACT}" || { echo "missing backend-test execution contract: ${CONTRACT}" >&2; exit 2; }',
         nodePreflight,
-    ].join("; ");
+    ].join(" && ");
 }

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

@@ -0,0 +1,57 @@
+import { z } from "zod";
+export const STABILITY_EVIDENCE_SCHEMA_ID = "stability-evidence-v1";
+const runRefSchema = z.object({
+    runId: z.string().min(1),
+    suiteId: z.string().min(1),
+    version: z.string().min(1),
+    commitSha: z.string().regex(/^[a-f0-9]{7,64}$/),
+    success: z.boolean(),
+    resultRef: z.string().min(1),
+}).strict();
+export const stabilityEvidenceSchema = z.object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(STABILITY_EVIDENCE_SCHEMA_ID),
+    suiteId: z.string().min(1),
+    version: z.string().min(1),
+    commitSha: z.string().regex(/^[a-f0-9]{7,64}$/),
+    runs: z.array(runRefSchema),
+    recordedRuns: z.number().int().min(0),
+    successfulRuns: z.number().int().min(0),
+    failedRuns: z.number().int().min(0),
+    ratio: z.number().min(0).max(1).nullable(),
+    minimumRuns: z.literal(5),
+    status: z.enum(["available", "unavailable"]),
+    reason: z.string().min(1).nullable(),
+}).strict().superRefine((value, ctx) => {
+    if (value.recordedRuns !== value.runs.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "recordedRuns must equal runs.length", path: ["recordedRuns"] });
+    if (value.successfulRuns !== value.runs.filter((run) => run.success).length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "successfulRuns must match run facts", path: ["successfulRuns"] });
+    if (value.failedRuns !== value.runs.filter((run) => !run.success).length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "failedRuns must match run facts", path: ["failedRuns"] });
+    for (const [index, run] of value.runs.entries()) {
+        if (run.suiteId !== value.suiteId || run.version !== value.version || run.commitSha !== value.commitSha) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: "all runs must bind to the same suite/version/commit", path: ["runs", index] });
+        }
+    }
+    if (value.recordedRuns >= value.minimumRuns && value.ratio === null)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "ratio required when minimum sample is met", path: ["ratio"] });
+});
+export function buildStabilityEvidence(input) {
+    const recordedRuns = input.runs.length;
+    const successfulRuns = input.runs.filter((run) => run.success).length;
+    const failedRuns = recordedRuns - successfulRuns;
+    const status = recordedRuns >= 5 ? "available" : "unavailable";
+    return stabilityEvidenceSchema.parse({
+        schemaVersion: 1,
+        schemaId: STABILITY_EVIDENCE_SCHEMA_ID,
+        ...input,
+        recordedRuns,
+        successfulRuns,
+        failedRuns,
+        ratio: recordedRuns >= 5 ? successfulRuns / recordedRuns : null,
+        minimumRuns: 5,
+        status,
+        reason: recordedRuns >= 5 ? null : "minimum-sample-size-not-met",
+    });
+}

package/dist/workflows/dag/dynamic-runtime/map.js

@@ -81,27 +81,77 @@ export function resolveRunLocalPath(runDir, ref, label) {
     }
     return resolved;
 }
+function resolveCaseIdFromItem(item) {
+    if (typeof item === "object" &&
+        item !== null &&
+        typeof item.caseId === "string") {
+        return item.caseId;
+    }
+    return String(item);
+}
+async function materializeBlockedCaseEvidence(input) {
+    if (!input.workspaceRef)
+        return;
+    const workspace = resolveRunLocalPath(input.cwd, input.workspaceRef, "workspaceRef");
+    await mkdir(workspace, { recursive: true });
+    const resultPath = path.join(workspace, "case-result.json");
+    const caseId = resolveCaseIdFromItem(input.item);
+    try {
+        const existing = JSON.parse(await readFile(resultPath, "utf-8"));
+        if (existing.caseId === caseId &&
+            (existing.status === "passed" ||
+                existing.status === "failed" ||
+                existing.status === "blocked"))
+            return;
+    }
+    catch {
+        // Missing or malformed evidence is replaced only for a child that never finished a business result.
+    }
+    await writeFile(path.join(workspace, "execution.md"), `# ${caseId}\n\nStatus: blocked\n\nReason: ${input.reason}\n`, "utf-8");
+    await writeFile(resultPath, `${JSON.stringify({
+        caseId,
+        status: "blocked",
+        blockedReason: input.reason,
+        evidencePaths: ["execution.md"],
+    }, null, 2)}\n`, "utf-8");
+}
 async function materializeTokenBudgetBlockedEvidence(input) {
+    await materializeBlockedCaseEvidence({
+        ...input,
+        reason: "token-budget-exhausted",
+    });
+}
+async function materializeFailedCaseEvidence(input) {
     if (!input.workspaceRef)
         return;
     const workspace = resolveRunLocalPath(input.cwd, input.workspaceRef, "workspaceRef");
     await mkdir(workspace, { recursive: true });
     const resultPath = path.join(workspace, "case-result.json");
-    const caseId = typeof input.item === "object" && input.item !== null &&
-        typeof input.item.caseId === "string"
-        ? input.item.caseId
-        : String(input.item);
+    const caseId = resolveCaseIdFromItem(input.item);
     try {
         const existing = JSON.parse(await readFile(resultPath, "utf-8"));
         if (existing.caseId === caseId &&
-            (existing.status === "passed" || existing.status === "failed" || existing.status === "blocked"))
+            (existing.status === "passed" ||
+                existing.status === "failed" ||
+                existing.status === "blocked"))
             return;
     }
     catch {
-        // Missing or malformed evidence is replaced only for a child that never started.
+        // Missing or malformed evidence is replaced only when the child never finished a business result.
     }
-    await writeFile(path.join(workspace, "execution.md"), `# ${caseId}\n\nStatus: blocked\n\nReason: token-budget-exhausted\n`, "utf-8");
-    await writeFile(resultPath, `${JSON.stringify({ caseId, status: "blocked", blockedReason: "token-budget-exhausted", evidencePaths: ["execution.md"] }, null, 2)}\n`, "utf-8");
+    await writeFile(path.join(workspace, "execution.md"), `# ${caseId}\n\nStatus: failed\n\nReason: ${input.reason}\n`, "utf-8");
+    await writeFile(resultPath, `${JSON.stringify({
+        caseId,
+        status: "failed",
+        errorSummary: input.reason,
+        evidencePaths: ["execution.md"],
+    }, null, 2)}\n`, "utf-8");
+}
+/** Provider auth/timeout on a FE case child is infrastructure, not a product fail; keep the map aggregate. */
+function isInfrastructureCaseChildFailure(record) {
+    if (!record || record.status === "FINISHED")
+        return false;
+    return record.failureCategory === "auth" || record.failureCategory === "timeout";
 }
 export async function executeDynamicMapExpansion(input) {
     const started = Date.now();
@@ -264,15 +314,64 @@ export async function executeDynamicMapExpansion(input) {
             tokenBudgetExhausted = true;
         }
     }
+    // Opt-in (frontend-test via tolerateChildFailures): materialize case-level
+    // failed/blocked evidence and keep the map barrier green so validate /
+    // result / retrospect can still run. Default maps stay fail-closed on child ERROR.
+    const tolerateChildFailures = input.expansion.tolerateChildFailures === true;
+    const caseOutcomeNotes = [];
+    if (tolerateChildFailures) {
+        for (let index = 0; index < childNodeIds.length; index += 1) {
+            const nodeId = childNodeIds[index];
+            const record = input.state.nodes[nodeId];
+            if (!record || record.status === "FINISHED")
+                continue;
+            if (isBudgetBlockedRecord(record))
+                continue;
+            const infra = isInfrastructureCaseChildFailure(record);
+            const reason = infra
+                ? record?.failureCategory === "timeout"
+                    ? "executor-timeout"
+                    : "executor-auth-unavailable"
+                : `executor-error:${record.failureCategory || record.status || "unknown"}`;
+            const outcomeStatus = infra ? "blocked" : "failed";
+            try {
+                if (outcomeStatus === "blocked") {
+                    await materializeBlockedCaseEvidence({
+                        cwd: input.cwd,
+                        workspaceRef: workspaceRefs[index],
+                        item: items[index],
+                        reason,
+                    });
+                }
+                else {
+                    await materializeFailedCaseEvidence({
+                        cwd: input.cwd,
+                        workspaceRef: workspaceRefs[index],
+                        item: items[index],
+                        reason,
+                    });
+                }
+            }
+            catch (error) {
+                throw new Error(`failed to materialize case outcome evidence for ${nodeId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            caseOutcomeNotes.push({ nodeId, reason, status: outcomeStatus });
+            record.status = "FINISHED";
+            record.stderr = `${outcomeStatus}: ${reason}`;
+            record.failureCategory = "success";
+        }
+    }
     const budgetBlockedIds = new Set(blockedChildren.map((entry) => entry.nodeId));
-    const failedChildren = childNodeIds.filter((nodeId) => {
-        const record = input.state.nodes[nodeId];
-        if (!record || record.status === "FINISHED")
-            return false;
-        if (budgetBlockedIds.has(nodeId) || isBudgetBlockedRecord(record))
-            return false;
-        return true;
-    });
+    const failedChildren = tolerateChildFailures
+        ? []
+        : childNodeIds.filter((nodeId) => {
+            const record = input.state.nodes[nodeId];
+            if (!record || record.status === "FINISHED")
+                return false;
+            if (budgetBlockedIds.has(nodeId) || isBudgetBlockedRecord(record))
+                return false;
+            return true;
+        });
     const aggregate = {
         workflowNodeId: input.expansion.workflowNodeId,
         itemCount: items.length,
@@ -285,21 +384,29 @@ export async function executeDynamicMapExpansion(input) {
             output: parseJsonFromText(input.state.nodes[nodeId]?.stdout),
             assistantText: input.state.nodes[nodeId]?.assistantText,
             blocked: blockedChildren.find((child) => child.nodeId === nodeId)?.reason ??
+                caseOutcomeNotes.find((child) => child.nodeId === nodeId && child.status === "blocked")
+                    ?.reason ??
                 (isBudgetBlockedRecord(input.state.nodes[nodeId])
                     ? "token-budget-exhausted"
                     : undefined),
+            failed: caseOutcomeNotes.find((child) => child.nodeId === nodeId && child.status === "failed")
+                ?.reason,
         })),
         tokensUsed: totalTokensUsed,
+        caseOutcomeNotes: caseOutcomeNotes.length > 0 ? caseOutcomeNotes : undefined,
     };
     return {
-        // A post-case token stop is an expected bounded outcome; downstream review
-        // must receive its aggregate rather than be skipped with the map barrier.
-        // Real child failures remain fail-closed even when later cases are budget-blocked.
+        // With tolerateChildFailures: barrier always succeeds; product outcomes live in
+        // case evidence + result materialization. Without it: real child failures fail-close.
         ok: failedChildren.length === 0,
         stdout: JSON.stringify(aggregate),
-        stderr: failedChildren.length > 0
-            ? `dynamic map children failed: ${failedChildren.join(", ")}`
-            : "",
+        stderr: caseOutcomeNotes.length > 0
+            ? `map children recorded as case outcomes: ${caseOutcomeNotes
+                .map((entry) => `${entry.nodeId}=${entry.status}:${entry.reason}`)
+                .join(", ")}`
+            : failedChildren.length > 0
+                ? `dynamic map children failed: ${failedChildren.join(", ")}`
+                : "",
         failureCategory: failedChildren.length > 0 ? "dynamic-expansion-child-failed" : "success",
         durationMs: Date.now() - started,
     };