@tea-agent/loop-agent 0.33.4 → 0.33.6-beta.0

package/dist/workflows/dag/backend-test-writer-completeness.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
+import { BACKEND_TEST_MAX_MODULE_COUNT, isOpaqueHashBackendTestModuleStem, isPriorityOnlyBackendTestModuleStem, } from "./backend-test-module-stem.js";
 /**
  * Maps a backend-test generation writer task id to its writer-progress role.
  * Returns undefined for nodes that are not completeness-gated generators.
@@ -96,51 +97,89 @@ function hasMarkdownTable(section, headerNeedle) {
  * phantom missing modules when the model discusses forbidden filenames
  * ("do not create 1.md / 9.md") inside the README body.
  */
-function looksLikeValidModuleStem(raw) {
+function moduleStemInvalidReason(raw) {
     if (!raw)
-        return false;
+        return "invalid-syntax";
     const stem = normalizeBackendTestModuleStem(raw);
+    if (isPriorityOnlyBackendTestModuleStem(stem))
+        return "priority-only-module-stem";
+    if (isOpaqueHashBackendTestModuleStem(stem))
+        return "opaque-hash-module-stem";
     if (stem.toLowerCase() === "readme")
-        return false;
+        return "reserved-module-stem";
     if (!/^[a-z][a-z0-9_]*$/.test(stem))
-        return false;
+        return "invalid-syntax";
     if (/^(?:be|tp|ac|req|br)[_-]/i.test(stem))
-        return false;
-    return true;
+        return "case-like-module-stem";
+    return undefined;
 }
-/**
- * Exported for reuse by the manifest-shell node that materializes the
- * module list JSON consumed by the map_agent expansion. Kept deterministic
- * (same extractor as the completeness gate) so the shard set always matches
- * the README index the gate trusts.
- */
-export function extractModuleStemsFromReadme(readme) {
-    const stems = [];
-    // Only trust testcase/md/<stem>.md mentions that appear inside markdown
-    // table rows (`| ... testcase/md/x.md ... |`) or as canonical relative
-    // links (`[label](./x.md)`). Free-form prose mentions such as a recovery
-    // note listing `testcase/md/1.md` must NOT be treated as authoritative
-    // module references, otherwise the gate invents phantom missing modules.
-    const tableRowLines = readme
+function looksLikeValidModuleStem(raw) {
+    return moduleStemInvalidReason(raw) === undefined;
+}
+function extractCanonicalModuleIndexSection(readme) {
+    const lines = readme
         .replaceAll("\r\n", "\n")
         .replaceAll("\r", "\n")
-        .split("\n")
-        .filter((line) => line.includes("|"));
+        .split("\n");
+    const headings = lines.flatMap((line, index) => line.trim() === "## Module Index" ? [index] : []);
+    if (headings.length === 0) {
+        return { section: "", structureIssues: ["missing-module-index"] };
+    }
+    if (headings.length > 1) {
+        return { section: "", structureIssues: ["duplicate-module-index"] };
+    }
+    const start = headings[0] + 1;
+    const relativeEnd = lines.slice(start).findIndex((line) => /^##\s+\S/.test(line.trim()));
+    const end = relativeEnd < 0 ? lines.length : start + relativeEnd;
+    return { section: lines.slice(start, end).join("\n"), structureIssues: [] };
+}
+/** Inspect only candidates inside the unique exact `## Module Index` section. */
+export function inspectModuleStemsFromReadme(readme) {
+    const extracted = extractCanonicalModuleIndexSection(readme);
+    const candidates = [];
+    const tableRowLines = extracted.section.split("\n").filter((line) => line.includes("|"));
     for (const line of tableRowLines) {
         for (const match of line.matchAll(/`?testcase\/md\/([A-Za-z0-9_.-]+)\.md`?/g)) {
-            if (looksLikeValidModuleStem(match[1]))
-                stems.push(match[1]);
+            candidates.push(match[1]);
         }
         for (const match of line.matchAll(/\|\s*`?([A-Za-z0-9_.-]+)`?\s*\|\s*`?testcase\/test_/g)) {
-            if (looksLikeValidModuleStem(match[1]))
-                stems.push(match[1]);
+            const raw = match[1];
+            if (looksLikeValidModuleStem(raw) || moduleStemInvalidReason(raw) !== "invalid-syntax") {
+                candidates.push(raw);
+            }
         }
     }
-    for (const match of readme.matchAll(/\[[^\]]+\]\(\.\/([A-Za-z0-9_.-]+)\.md\)/g)) {
-        if (looksLikeValidModuleStem(match[1]))
-            stems.push(match[1]);
+    for (const match of extracted.section.matchAll(/\[[^\]]+\]\(\.\/([A-Za-z0-9_.-]+)\.md\)/g)) {
+        candidates.push(match[1]);
+    }
+    const uniqueCandidates = orderedUnique(candidates);
+    const invalid = uniqueCandidates.flatMap((raw) => {
+        const reasonCode = moduleStemInvalidReason(raw);
+        return reasonCode
+            ? [{ raw, normalized: normalizeBackendTestModuleStem(raw), reasonCode }]
+            : [];
+    });
+    const validStems = orderedUnique(uniqueCandidates
+        .filter(looksLikeValidModuleStem)
+        .map((stem) => normalizeBackendTestModuleStem(stem)));
+    const structureIssues = [...extracted.structureIssues];
+    if (validStems.length > BACKEND_TEST_MAX_MODULE_COUNT) {
+        structureIssues.push(`excessive-module-count: ${validStems.length} > ${BACKEND_TEST_MAX_MODULE_COUNT}`);
     }
-    return orderedUnique(stems.map((stem) => normalizeBackendTestModuleStem(stem)));
+    return {
+        candidates: uniqueCandidates,
+        validStems,
+        invalid,
+        structureIssues,
+    };
+}
+/**
+ * Exported for reuse by callers that only need the trusted shard set.
+ * Completeness gates must use inspectModuleStemsFromReadme so invalid
+ * authoritative candidates cannot be silently dropped.
+ */
+export function extractModuleStemsFromReadme(readme) {
+    return inspectModuleStemsFromReadme(readme).validStems;
 }
 async function listMarkdownModules(workspaceRoot) {
     const root = path.join(workspaceRoot, "testcase", "md");
@@ -242,12 +281,80 @@ function moduleStructuralDetail(result) {
         return "module file is structurally complete";
     return `module file is empty or has structural issues: ${result.reasons.join("; ")}`;
 }
+function pythonStructureOutsideStrings(source) {
+    const input = source.replace(/\r\n/g, "\n");
+    let output = "";
+    let index = 0;
+    let quote;
+    let triple = false;
+    let comment = false;
+    while (index < input.length) {
+        const char = input[index];
+        if (comment) {
+            if (char === "\n") {
+                comment = false;
+                output += "\n";
+            }
+            else
+                output += " ";
+            index += 1;
+            continue;
+        }
+        if (quote) {
+            if (char === "\\") {
+                output += " ";
+                if (index + 1 < input.length)
+                    output += input[index + 1] === "\n" ? "\n" : " ";
+                index += 2;
+                continue;
+            }
+            if (triple && input.slice(index, index + 3) === quote.repeat(3)) {
+                output += "   ";
+                index += 3;
+                quote = undefined;
+                triple = false;
+                continue;
+            }
+            if (!triple && char === quote) {
+                output += " ";
+                index += 1;
+                quote = undefined;
+                continue;
+            }
+            if (!triple && char === "\n")
+                return { text: output, stringsClosed: false };
+            output += char === "\n" ? "\n" : " ";
+            index += 1;
+            continue;
+        }
+        if (char === "#") {
+            comment = true;
+            output += " ";
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            triple = input.slice(index, index + 3) === char.repeat(3);
+            output += triple ? "   " : " ";
+            index += triple ? 3 : 1;
+            continue;
+        }
+        output += char;
+        index += 1;
+    }
+    return { text: output, stringsClosed: quote === undefined };
+}
 function pythonParseable(source) {
-    const text = source.replace(/\r\n/g, "\n");
-    if (!text.trim())
+    const normalized = source.replace(/\r\n/g, "\n");
+    if (!normalized.trim())
         return false;
-    if (/^\s*(?:def|class|import|from)\b/m.test(text) === false)
+    if (/^\s*(?:def|class|import|from)\b/m.test(normalized) === false)
         return false;
+    const structural = pythonStructureOutsideStrings(normalized);
+    if (!structural.stringsClosed)
+        return false;
+    const text = structural.text;
     const openParens = (text.match(/\(/g) ?? []).length;
     const closeParens = (text.match(/\)/g) ?? []).length;
     const openBrackets = (text.match(/\[/g) ?? []).length;
@@ -260,15 +367,6 @@ function pythonParseable(source) {
         return false;
     if (openBraces !== closeBraces)
         return false;
-    if (/("""|''')[\s\S]*$/.test(text)) {
-        const triples = text.match(/("""|''')/g) ?? [];
-        if (triples.length % 2 !== 0)
-            return false;
-    }
-    // The balanced-bracket counts above already catch a genuinely truncated
-    // file (an unclosed def/call leaves unbalanced parens). The previous
-    // per-line "def ... ( ... $" heuristic was a false-positive source for
-    // legal multi-line definitions such as `def f(\n    x,\n):` — removed.
     return true;
 }
 /**
@@ -318,12 +416,7 @@ function looksLikeValidPythonModule(source) {
         return false;
     if (/^\s*(?:def|class|import|from)\b/m.test(text) === false)
         return false;
-    if (/("""|''')[\s\S]*$/.test(text)) {
-        const triples = text.match(/("""|''')/g) ?? [];
-        if (triples.length % 2 !== 0)
-            return false;
-    }
-    return true;
+    return pythonStructureOutsideStrings(text).stringsClosed;
 }
 export function buildOutputLimitRecoveryPrompt(input) {
     return buildOutputLimitRecoverySection(input);
@@ -842,7 +935,30 @@ export async function assessBackendTestMdPlanCompleteness(workspaceRoot) {
         // The README must advertise a non-empty module index so the downstream
         // manifest shell has stems to shard; the indexed module files themselves
         // are produced by map_agent children and are NOT required here.
-        const indexedStems = extractModuleStemsFromReadme(readme);
+        const stemInspection = inspectModuleStemsFromReadme(readme);
+        const indexedStems = stemInspection.validStems;
+        for (const structureIssue of stemInspection.structureIssues) {
+            if (!brokenPaths.includes("testcase/md/README.md")) {
+                brokenPaths.push("testcase/md/README.md");
+            }
+            issues.push({
+                code: "T5",
+                path: "testcase/md/README.md",
+                detail: structureIssue,
+                recoverable: true,
+            });
+        }
+        for (const invalid of stemInspection.invalid) {
+            if (!brokenPaths.includes("testcase/md/README.md")) {
+                brokenPaths.push("testcase/md/README.md");
+            }
+            issues.push({
+                code: "T5",
+                path: "testcase/md/README.md",
+                detail: `${invalid.reasonCode}: ${invalid.normalized}; use a stable lowercase business resource/domain stem`,
+                recoverable: true,
+            });
+        }
         if (indexedStems.length === 0) {
             if (!brokenPaths.includes("testcase/md/README.md")) {
                 brokenPaths.push("testcase/md/README.md");

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

@@ -367,19 +367,26 @@ export async function executeDynamicMapExpansion(input) {
         }
     }
     const budgetBlockedIds = new Set(blockedChildren.map((entry) => entry.nodeId));
+    const failOnTokenBudgetExhaustion = input.expansion.failOnTokenBudgetExhaustion === 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;
+            if (budgetBlockedIds.has(nodeId) || isBudgetBlockedRecord(record)) {
+                return failOnTokenBudgetExhaustion;
+            }
             return true;
         });
+    const finishedItemCount = childNodeIds.filter((nodeId) => input.state.nodes[nodeId]?.status === "FINISHED").length;
+    const blockedItemCount = budgetBlockedIds.size;
     const aggregate = {
         workflowNodeId: input.expansion.workflowNodeId,
         itemCount: items.length,
+        expectedItemCount: items.length,
+        finishedItemCount,
+        blockedItemCount,
         children: childNodeIds.map((nodeId, index) => ({
             nodeId,
             item: items[index],
@@ -399,21 +406,30 @@ export async function executeDynamicMapExpansion(input) {
                 ?.reason,
         })),
         tokensUsed: totalTokensUsed,
+        maxTotalTokens: tokenBudget?.maxTotalTokens,
         caseOutcomeNotes: caseOutcomeNotes.length > 0 ? caseOutcomeNotes : undefined,
     };
+    const tokenBudgetFailure = failOnTokenBudgetExhaustion && blockedItemCount > 0;
     return {
-        // With tolerateChildFailures: barrier always succeeds; product outcomes live in
-        // case evidence + result materialization. Without it: real child failures fail-close.
-        ok: failedChildren.length === 0,
+        // With tolerateChildFailures: barrier succeeds and product outcomes live in
+        // case evidence. Backend-test opts into token-budget fail-closed because a
+        // partial generated module set is never a valid downstream input.
+        ok: failedChildren.length === 0 && !tokenBudgetFailure,
         stdout: JSON.stringify(aggregate),
         stderr: caseOutcomeNotes.length > 0
             ? `map children recorded as case outcomes: ${caseOutcomeNotes
                 .map((entry) => `${entry.nodeId}=${entry.status}:${entry.reason}`)
                 .join(", ")}`
+            : tokenBudgetFailure
+                ? `dynamic map token budget exhausted: expected=${items.length} finished=${finishedItemCount} blocked=${blockedItemCount} tokensUsed=${totalTokensUsed} maxTotalTokens=${tokenBudget?.maxTotalTokens ?? "unbounded"}`
+                : failedChildren.length > 0
+                    ? `dynamic map children failed: ${failedChildren.join(", ")}`
+                    : "",
+        failureCategory: tokenBudgetFailure
+            ? "dynamic-expansion-token-budget-exhausted"
             : failedChildren.length > 0
-                ? `dynamic map children failed: ${failedChildren.join(", ")}`
-                : "",
-        failureCategory: failedChildren.length > 0 ? "dynamic-expansion-child-failed" : "success",
+                ? "dynamic-expansion-child-failed"
+                : "success",
         durationMs: Date.now() - started,
     };
 }