@tea-agent/loop-agent 0.42.0-next.6 → 0.42.0-next.8

package/dist/workflows/dag/backend-test-scenario-param.js

@@ -59,6 +59,7 @@ const CLOSED_SET = new Set([
     "null",
     "min-1",
     "min",
+    "max-1",
     "max",
     "max+1",
     "pattern-invalid",
@@ -155,14 +156,19 @@ function parseScenarioBoundToken(raw) {
 function parseScenarioIntentLine(line) {
     // Target may contain commas (body.title,body.status). Intent may contain `|` / spaces.
     // Stop field values only at known trailing keys or end-of-line.
-    const precise = /场景意图\s*[:：]\s*(TP-[A-Z0-9-]+)\s*[|;]\s*operation\s*=\s*([^;\n]+?)\s*[|;]\s*target\s*=\s*([^;\n]+?)\s*[|;]\s*intent\s*=\s*([^;\n]+?)(?:\s*[|;]\s*bound\s*=\s*([^\s;|\n]+))?(?:\s*[|;]\s*example\s*=\s*([^;\n]+))?(?:\s*[|;]\s*expectedCode\s*=\s*[^;\n]+)?\s*$/i.exec(line.trim());
+    const unfenced = line
+        .trim()
+        .replace(/^[-*+]\s+/, "")
+        .replace(/^`(.+)`$/, "$1")
+        .trim();
+    const precise = /场景意图\s*[:：]\s*(TP-[A-Z0-9-]+)\s*[|;]\s*operation\s*=\s*([^;\n]+?)\s*[|;]\s*target\s*=\s*([^;\n]+?)\s*[|;]\s*intent\s*=\s*([^;\n]+?)(?:\s*[|;]\s*bound\s*=\s*([^\s;`|\n]+))?(?:\s*[|;]\s*example\s*=\s*([^;\n]*))?(?:\s*[|;]\s*expectedCode\s*=\s*[^;\n]+)?\s*$/i.exec(unfenced);
     if (precise) {
         return {
             tpId: precise[1],
             rawIntent: (precise[4] ?? "unknown").trim(),
             target: precise[3]?.trim(),
             bound: parseScenarioBoundToken(precise[5]),
-            example: precise[6]?.trim(),
+            example: precise[6] === undefined ? undefined : precise[6].trim(),
             legacy: false,
         };
     }
@@ -192,6 +198,53 @@ function resolveScenarioIntentField(target, field) {
         target.split(/\s*,\s*/)[0];
     return preferred?.split(".").at(-1);
 }
+function normalizeLengthIntentAlias(rawIntent) {
+    const lower = rawIntent.trim().toLowerCase();
+    if (lower === "max-1" || lower === "maxminus1" || lower === "max_minus_1") {
+        return "max-1";
+    }
+    if (lower === "min-1" || lower === "minminus1" || lower === "min_minus_1") {
+        return "min-1";
+    }
+    return lower;
+}
+function proseLengthBound(haystack, field) {
+    const fieldAlt = field ? field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : undefined;
+    const scoped = fieldAlt ? new RegExp(`${fieldAlt}[^\\n]{0,160}`, "ig") : undefined;
+    const windows = [];
+    if (scoped) {
+        for (const match of haystack.matchAll(scoped)) {
+            windows.push(match[0] ?? "");
+        }
+    }
+    windows.push(haystack);
+    let max;
+    let min;
+    const proseMaxRe = /(\d{1,4})\s*个字符的最大/i;
+    for (const window of windows) {
+        const proseMax = proseMaxRe.exec(window);
+        if (proseMax && max === undefined)
+            max = Number(proseMax[1]);
+        const nums = [...window.matchAll(/(?<![+\-])\d{1,4}/g)]
+            .map((item) => Number(item[0]))
+            .filter((item) => Number.isFinite(item));
+        for (let i = 0; i + 2 < nums.length; i += 1) {
+            const a = nums[i];
+            const b = nums[i + 1];
+            const c = nums[i + 2];
+            // Prefer n-1,n,n+1 around a documented max (100/2000), not 0,1,99 or 99,100,101's first two plus leftover.
+            if (b === a + 1 && c === b + 1 && b >= 10) {
+                max ??= b;
+                break;
+            }
+        }
+        if (nums.includes(0) && nums.includes(1))
+            min ??= 1;
+        if (max !== undefined && min !== undefined)
+            break;
+    }
+    return { max, min };
+}
 function resolveCustomLiteralIntent(rawIntent, field) {
     const lower = rawIntent.toLowerCase();
     if (!lower.startsWith("custom-literal:")) {
@@ -250,7 +303,7 @@ export function inferScenarioParamIntent(input) {
         const field = resolveScenarioIntentField(machine.target, machine.field);
         const rawIntent = machine.rawIntent.trim();
         const example = machine.example;
-        const lower = rawIntent.toLowerCase();
+        const lower = normalizeLengthIntentAlias(rawIntent);
         let normalizedIntent = lower === "nominal-operation" ? "nominal" : lower;
         // Writers sometimes mark a short "typical" length sample as min/max with bound=LEN<nominal>.
         // Treat that as nominal so a short helper/string is not forced to equal maxLength.
@@ -273,16 +326,16 @@ export function inferScenarioParamIntent(input) {
                 new RegExp(`(?:minLength|min(?:imum)?|下限|最小长度)\\s*[=:：]?\\s*(\\d{1,4})[^\\n]{0,80}?${fieldEsc}`, "i").exec(haystack) ??
                 /(?:minLength|min(?:imum)?|下限|最小长度)\s*[=:：]?\s*(\d{1,4})/i.exec(haystack)
             : /(?:minLength|min(?:imum)?|下限|最小长度)\s*[=:：]?\s*(\d{1,4})/i.exec(haystack);
+        const proseBound = proseLengthBound(haystack, field);
         const prefersMinBound = normalizedIntent === "min" ||
             normalizedIntent === "min-1" ||
             /(?:MIN|LEN1|LENGTH-?1|最短|最小)/i.test(tpId);
-        const boundFromBody = prefersMinBound
-            ? minBoundFromBody ?? maxBoundFromBody
-            : maxBoundFromBody ?? minBoundFromBody;
+        const boundFromBody = prefersMinBound ? minBoundFromBody : maxBoundFromBody ?? minBoundFromBody;
         const boundFromTp = /(?:LEN(?:GTH)?|长度)[_-]?(\d{1,5})(?:[_-]|$)/i.exec(tpId) ??
-            /(?:MIN|MAX)[_-]?(\d{1,5})(?:[_-]|$)/i.exec(tpId);
+            /(?:MIN|MAX)[_-](\d{2,5})(?:[_-]|$)/i.exec(tpId);
         const lengthIntent = normalizedIntent === "min" ||
             normalizedIntent === "min-1" ||
+            normalizedIntent === "max-1" ||
             normalizedIntent === "max" ||
             normalizedIntent === "max+1";
         // Length intents: explicit machine bound >0, then TP-encoded LEN1/LEN100,
@@ -294,13 +347,35 @@ export function inferScenarioParamIntent(input) {
             : normalizedIntent === "max+1"
                 ? Math.max(0, boundFromTpNumber - 1)
                 : boundFromTpNumber;
-        const bound = machine.bound && machine.bound > 0
-            ? machine.bound
-            : lengthIntent && boundFromTpNormalized !== undefined
-                ? boundFromTpNormalized
-                : boundFromBody
-                    ? Number(boundFromBody[1])
-                    : machine.bound;
+        const boundFromProse = prefersMinBound ? proseBound.min : proseBound.max;
+        const offsetIntent = normalizedIntent === "max-1" ||
+            normalizedIntent === "max+1" ||
+            normalizedIntent === "min-1";
+        const contractBound = boundFromBody
+            ? Number(boundFromBody[1])
+            : boundFromProse !== undefined && boundFromProse >= 0
+                ? boundFromProse
+                : undefined;
+        const machineBoundPositive = typeof machine.bound === "number" && Number.isFinite(machine.bound) && machine.bound > 0;
+        const minLengthFromBody = prefersMinBound && minBoundFromBody ? Number(minBoundFromBody[1]) : undefined;
+        const machineBoundZeroMin = prefersMinBound &&
+            machine.bound === 0 &&
+            minLengthFromBody === undefined &&
+            boundFromTpNormalized === undefined;
+        const bound = offsetIntent && contractBound !== undefined && contractBound > 0
+            ? contractBound
+            : machineBoundPositive && !offsetIntent
+                ? machine.bound
+                : lengthIntent && boundFromTpNormalized !== undefined
+                    ? boundFromTpNormalized
+                    : minLengthFromBody !== undefined && minLengthFromBody >= 0
+                        ? minLengthFromBody
+                        : machineBoundZeroMin
+                            ? 0
+                            : contractBound !== undefined &&
+                                (prefersMinBound ? contractBound >= 0 : contractBound > 0)
+                                ? contractBound
+                                : undefined;
         if (rawIntent.toLowerCase().startsWith("custom-literal:")) {
             const resolved = resolveCustomLiteralIntent(rawIntent, field);
             const rawLiteral = rawIntent.slice(rawIntent.indexOf(":") + 1).trim();
@@ -387,13 +462,15 @@ export function inferScenarioParamIntent(input) {
     const boundMatch = fieldScopedBound ??
         /(?:maxLength|max(?:imum)?|上限|最大长度)\s*[=:：]?\s*(\d{1,4})/i.exec(`${caseBody}\n${dataSection}`) ??
         /(?:minLength|min(?:imum)?|下限|最小长度)\s*[=:：]?\s*(\d{1,4})/i.exec(`${caseBody}\n${dataSection}`);
-    const bound = boundMatch ? Number(boundMatch[1]) : undefined;
+    const proseBound = proseLengthBound(`${caseBody}
+${dataSection}`, field);
+    const bound = boundMatch ? Number(boundMatch[1]) : proseBound.max ?? proseBound.min;
     const exampleMatch = /(?:反例|invalid example|example)\s*[=:：]\s*[`"]?([^`"\n]+)[`"]?/i.exec(caseBody);
     const example = exampleMatch?.[1]?.trim();
     if (/EMPTY|空白|空串|空字符串/.test(upper) || /空字符串|空串|empty string/i.test(caseBody)) {
         return { intent: "empty", field, bound, example, intentSource: "tp-fallback" };
     }
-    if (/MISSING|缺省|缺失|省略/.test(upper) || /缺少字段|缺失字段|missing field/i.test(caseBody)) {
+    if (/MISSING|OMITTED|\bOMIT\b|缺省|缺失|省略/.test(upper) || /缺少字段|缺失字段|missing field/i.test(caseBody)) {
         return { intent: "missing", field, bound, example, intentSource: "tp-fallback" };
     }
     if (/\bNULL\b|空值/.test(upper) || /\bnull\b/i.test(caseBody)) {
@@ -402,6 +479,9 @@ export function inferScenarioParamIntent(input) {
     if (/MAX[-_]?PLUS[-_]?1|MAX\+1|超长|越界|LENGTH[-_]?OVER|OVER[-_]?LENGTH|OVER/.test(upper)) {
         return { intent: "max+1", field, bound, example, intentSource: "tp-fallback" };
     }
+    if (/MAX[-_]1(?:$|[-_])|max-1/i.test(upper)) {
+        return { intent: "max-1", field, bound, example, intentSource: "tp-fallback" };
+    }
     if (/\bMAX\b|最大/.test(upper)) {
         return { intent: "max", field, bound, example, intentSource: "tp-fallback" };
     }
@@ -425,7 +505,7 @@ export function inferScenarioParamIntent(input) {
     }
     return { intent: "unknown", field, bound, example, intentSource: "tp-fallback" };
 }
-const OMIT_SENTINEL_RE = /^(?:_OMIT|OMIT|MISSING|Ellipsis|\.\.\.)\b/;
+const OMIT_SENTINEL_RE = /^(?:_OMIT|_MISSING|OMIT|MISSING|Ellipsis|\.\.\.)\b/;
 const HTTP_EXPECTED_CODE_RE = /^(?:2xx|3xx|4xx|5xx|[1-5]\d{2}|HTTP_[1-5]\d{2})$/i;
 /** Semantic custom-literal tokens that describe a value class, not a raw string. */
 function isWhitespaceSemanticLiteral(token) {
@@ -774,6 +854,10 @@ export function observeParamFeatures(block, field, constants, parameterNames) {
         (/["'][A-Za-z_][A-Za-z0-9_]*["']\s*:/.test(dictText) ||
             /(?:payload|body|data|json)\s*=/.test(block));
     if (dictLooksLikePayload && !field) {
+        const emptyField = /["']([A-Za-z_][A-Za-z0-9_.]*)["']\s*:\s*(?:""|'')/.exec(dictText);
+        if (emptyField?.[1]) {
+            return { kind: "empty-string", text: '""', length: 0, literal: "" };
+        }
         return { kind: "dict", text: dictText.replace(/\s+/g, " ").slice(0, 160) };
     }
     if (dictLooksLikePayload && field) {
@@ -803,7 +887,7 @@ export function observeParamFeatures(block, field, constants, parameterNames) {
         };
     }
     // Bare omit sentinel before id=...
-    if (/pytest\.param\s*\(\s*(?:_OMIT|OMIT|MISSING|\.\.\.|Ellipsis)\s*(?:,|\)|$)/.test(block)) {
+    if (/pytest\.param\s*\(\s*(?:_OMIT|_MISSING|OMIT|MISSING|\.\.\.|Ellipsis)\s*(?:,|\)|$)/.test(block)) {
         return {
             kind: "missing-key",
             text: field ? `missing:${field}` : "missing-key",
@@ -865,7 +949,7 @@ export function observeParamFeatures(block, field, constants, parameterNames) {
     if (paramOpen) {
         const afterOpen = block.slice((paramOpen.index ?? 0) + paramOpen[0].length);
         const positionalTokens = [];
-        const tokenRe = /\s*(_OMIT|OMIT|MISSING|Ellipsis|\.\.\.|None|True|False|-?\d+(?:\.\d+)?|"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'|(?:["'][^"'\\]["']\s*\*\s*(?:\d{1,5}|[A-Za-z_][A-Za-z0-9_]*))|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[A-Za-z_][A-Za-z0-9_]*)\s*(?:,|\)|$)/g;
+        const tokenRe = /\s*(_OMIT|_MISSING|OMIT|MISSING|Ellipsis|\.\.\.|None|True|False|-?\d+(?:\.\d+)?|"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'|(?:["'][^"'\\]["']\s*\*\s*(?:\d{1,5}|[A-Za-z_][A-Za-z0-9_]*))|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[A-Za-z_][A-Za-z0-9_]*)\s*(?:,|\)|$)/g;
         let match;
         while ((match = tokenRe.exec(afterOpen)) !== null) {
             const between = afterOpen.slice(0, match.index);
@@ -1008,12 +1092,25 @@ function compareIntent(intent, observed, bound, example, field) {
                     return "MATCH";
                 return len !== undefined ? "MISMATCH" : "UNDETERMINED";
             }
+        case "max-1":
+            if (bound === undefined)
+                return "UNDETERMINED";
+            {
+                const expectedMax1 = Math.max(0, bound - 1);
+                const len = observedLengthValue(observed);
+                if (len === expectedMax1)
+                    return "MATCH";
+                return len !== undefined ? "MISMATCH" : "UNDETERMINED";
+            }
         case "min":
             if (bound === undefined)
                 return "UNDETERMINED";
             {
                 if (isMinLengthHelper(observed))
                     return "MATCH";
+                // Optional min=0 may omit the key instead of sending "".
+                if (bound === 0 && observed.kind === "missing-key")
+                    return "MATCH";
                 const len = observedLengthValue(observed);
                 if (len === bound)
                     return "MATCH";
@@ -1167,6 +1264,10 @@ function suggestedFixFor(intent, field, bound, example) {
             return field && bound !== undefined
                 ? `set ${field}="x"*${bound + 1}`
                 : undefined;
+        case "max-1":
+            return field && bound !== undefined
+                ? `set ${field}="x"*${Math.max(0, bound - 1)}`
+                : undefined;
         case "min":
             return field && bound !== undefined
                 ? `set ${field}="x"*${bound}`
@@ -1720,6 +1821,12 @@ export function deterministicRewriteScenarioParam(input) {
             }
             valueLiteral = `"x" * ${bound + 1}`;
             break;
+        case "max-1":
+            if (bound === undefined) {
+                return { ok: false, source: input.source, detail: "missing bound for max-1" };
+            }
+            valueLiteral = `"x" * ${Math.max(0, bound - 1)}`;
+            break;
         case "min-1":
             if (bound === undefined) {
                 return { ok: false, source: input.source, detail: "missing bound for min-1" };

package/dist/workflows/dag/backend-test-scenario-partitions.js

@@ -43,6 +43,67 @@ function splitCells(raw) {
         .map((cell) => cell.trim())
         .filter((cell, index, cells) => !(cell === "" && (index === 0 || index === cells.length - 1)));
 }
+function isExactSlotInventory(extras, partitionId) {
+    const tokens = extras
+        .join(";")
+        .split(/[;,，；]/)
+        .map((token) => token.trim().replace(/`/g, ""))
+        .filter((token) => token.length > 0);
+    if (tokens.length === 0)
+        return false;
+    const prefix = `TP-${partitionId.trim().toUpperCase()}-`;
+    return tokens.every((token) => /^TP-[A-Z0-9-]+$/i.test(token) &&
+        (token.toUpperCase().startsWith(prefix) || token.toUpperCase().startsWith("TP-SP-")));
+}
+function trimExactSlotInventoryCells(cells) {
+    if (cells.length <= 7)
+        return { cells, trimmed: false };
+    const partitionId = cells[0] ?? "";
+    if (!isExactSlotInventory(cells.slice(7), partitionId)) {
+        return { cells, trimmed: false };
+    }
+    return { cells: cells.slice(0, 7), trimmed: true };
+}
+export function canonicalizeScenarioPartitionTable(markdown) {
+    const lines = markdown.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+    const headingIndex = lines.findIndex((line) => PARTITION_HEADING.test(line.trim()));
+    if (headingIndex === -1) {
+        return { markdown: lines.join("\n"), changed: false, trimmedRows: 0 };
+    }
+    let headerIndex = -1;
+    let sectionEnd = lines.length;
+    for (let i = headingIndex + 1; i < lines.length; i++) {
+        if (/^##\s+/.test(lines[i].trim()) && !PARTITION_HEADING.test(lines[i].trim())) {
+            sectionEnd = i;
+            break;
+        }
+        if (PARTITION_TABLE_HEADER.test(lines[i])) {
+            headerIndex = i;
+        }
+    }
+    if (headerIndex === -1) {
+        return { markdown: lines.join("\n"), changed: false, trimmedRows: 0 };
+    }
+    let trimmedRows = 0;
+    for (let i = headerIndex + 2; i < sectionEnd; i++) {
+        const line = lines[i];
+        if (!TABLE_ROW.test(line)) {
+            if (/^##\s+/.test(line) || /^#\s+/.test(line))
+                break;
+            continue;
+        }
+        const { cells, trimmed } = trimExactSlotInventoryCells(splitCells(line));
+        if (!trimmed)
+            continue;
+        lines[i] = `| ${cells.join(" | ")} |`;
+        trimmedRows += 1;
+    }
+    return {
+        markdown: lines.join("\n"),
+        changed: trimmedRows > 0,
+        trimmedRows,
+    };
+}
 /**
  * Parse the `## Scenario Partitions` section of the README into declared
  * partitions. Returns { partitions, issues }; issues are fail-closed parse
@@ -77,7 +138,7 @@ export function parseScenarioPartitions(readmeMarkdown) {
                 break;
             continue;
         }
-        const cells = splitCells(line);
+        const { cells } = trimExactSlotInventoryCells(splitCells(line));
         if (cells.length !== 7) {
             issues.push(`MISSING_PARTITION: row has ${cells.length} cells, expected 7: ${line.trim()}`);
             continue;

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

@@ -369,8 +369,6 @@ function pythonParseable(source) {
     const normalized = source.replace(/\r\n/g, "\n");
     if (!normalized.trim())
         return false;
-    if (/^\s*(?:def|class|import|from)\b/m.test(normalized) === false)
-        return false;
     const structural = pythonStructureOutsideStrings(normalized);
     if (!structural.stringsClosed)
         return false;
@@ -387,7 +385,13 @@ function pythonParseable(source) {
         return false;
     if (openBraces !== closeBraces)
         return false;
-    return true;
+    // Business modules still need a statement. Evidence-only mapped scripts may
+    // be a closed module docstring + Case-ID with no `def test_` (R10 health).
+    if (/^\s*(?:def|class|import|from|__all__\s*=)/m.test(normalized))
+        return true;
+    return (/^\s*(?:'''|""")/.test(normalized) &&
+        /\bCase-ID\s*:/i.test(normalized) &&
+        !/^\s*(?:async\s+)?def\s+test_/m.test(normalized));
 }
 /**
  * Forbidden generated shared helper/factory namespaces for the self-contained

package/dist/workflows/dag/frontend-shadow-dual-write.js

@@ -659,10 +659,13 @@ function latestCommittedScoutTargetSurface(records) {
 }
 /**
  * Scout owns discovery. A complete fact must explicitly say so, name at least
- * one target candidate, leave no unresolved paths, and include fresh runtime
- * evidence for a named target file. This deliberately accepts an empty test
- * path list: some small changes have no existing focused test file, but they
- * still need a proven implementation entrypoint.
+ * one target candidate and leave no unresolved paths. Existing surfaces must
+ * include fresh runtime evidence for a named target path. Greenfield
+ * surfaces are the one explicit exception: when runtime-injected source
+ * declarations prove that every named path was specified by the task source,
+ * all paths may be future (not yet on disk). This keeps create-new work
+ * possible without allowing Scout to invent an arbitrary path under the
+ * writer boundary. An empty test path list remains valid.
  */
 export function readCompleteScoutTargetSurface(records) {
     const fact = latestCommittedScoutTargetSurface(records);
@@ -704,11 +707,35 @@ export function readCompleteScoutTargetSurface(records) {
             .map((item) => asString(item.path))
             .filter(Boolean)
         : []);
-    if (!namedPaths.some((candidate) => freshPaths.has(candidate)))
+    const pathEvidence = Array.isArray(fact.pathEvidence)
+        ? fact.pathEvidence.filter(isRecord)
+        : [];
+    const hasSourceDeclarationLedger = Array.isArray(fact.sourceDeclaredPaths);
+    const undeclaredFuturePaths = hasSourceDeclarationLedger
+        ? namedPaths.filter((candidate) => {
+            const evidence = pathEvidence.find((item) => asString(item.path) === candidate);
+            return evidence?.fresh !== true && evidence?.sourceDeclared !== true;
+        })
+        : [];
+    if (undeclaredFuturePaths.length > 0)
         return {
             ok: false,
-            reason: "frontend scout target surface lacks fresh runtime evidence for a named target path; record_target_surface enriches every declared entrypoint/implementation/test path against the real workspace, so at least one named path must exist on disk (an existing directory counts; a file to be created later cannot count)",
+            reason: `frontend scout target surface has future paths not declared by the task source: ${undeclaredFuturePaths.join(", ")}; test path is not declared by the task source, so do not guess test/ vs tests/ or other target directories`,
         };
+    if (!namedPaths.some((candidate) => freshPaths.has(candidate))) {
+        const allPathsAreSourceDeclaredFuturePaths = hasSourceDeclarationLedger &&
+            namedPaths.length > 0 &&
+            namedPaths.every((candidate) => {
+                const evidence = pathEvidence.find((item) => asString(item.path) === candidate);
+                return evidence?.fresh !== true && evidence?.sourceDeclared === true;
+            });
+        if (allPathsAreSourceDeclaredFuturePaths)
+            return { ok: true, surface };
+        return {
+            ok: false,
+            reason: "frontend scout target surface lacks fresh runtime evidence for a named target path; greenfield exceptions require runtime-injected source declarations for every future path",
+        };
+    }
     return { ok: true, surface };
 }
 /** Paths with Scout ownership that Plan may read for a specific decision. */