@tea-agent/loop-agent 0.40.0-next.10 → 0.40.0-next.12

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

@@ -20,7 +20,8 @@ const factsSchema = z
         tpId: z.string(),
         field: z.string().optional(),
         intent: z.string(),
-        observed: z.string(),
+        observed: z.string().max(200),
+        observedLength: z.number().int().min(0).optional(),
         status: z.enum(["MATCH", "MISMATCH", "UNDETERMINED"]),
         repairability: z.enum([
             "repairable",
@@ -28,6 +29,12 @@ const factsSchema = z
             "none",
             "undetermined-no-repair",
         ]),
+        reasonCode: z.enum(["SCENARIO_PARAM_MATCH", "SCENARIO_PARAM_MISMATCH", "SCENARIO_PARAM_UNDETERMINED"]),
+        expectedRaw: z.string().max(512).optional(),
+        observedRaw: z.string().max(512),
+        expectedNormalized: z.string().max(512).optional(),
+        observedNormalized: z.string().max(512).optional(),
+        sourceLocation: z.string().max(512).optional(),
         suggestedFix: z.string().optional(),
         scriptPath: z.string().optional(),
         bound: z.number().optional(),
@@ -435,8 +442,16 @@ function isWhitespacePaddedString(value) {
 }
 function normalizeScenarioLiteralText(value) {
     // Writers sometimes emit visible-space placeholders (U+2420), NBSP variants,
-    // or URL-encoded spaces in machine-readable Markdown.
+    // URL-encoded spaces, or explicit Python/JSON whitespace escapes in
+    // machine-readable Markdown. Decode only escapes that resolve to whitespace;
+    // ordinary business characters such as `\\u0041` remain literal and fail closed.
+    const decodeWhitespaceEscape = (token, hex) => {
+        const decoded = String.fromCodePoint(Number.parseInt(hex, 16));
+        return /^\s$/u.test(decoded) || /[   ]/u.test(decoded) ? decoded : token;
+    };
     const normalized = value
+        .replace(/\\u([0-9a-f]{4})/gi, decodeWhitespaceEscape)
+        .replace(/\\x([0-9a-f]{2})/gi, decodeWhitespaceEscape)
         .replace(/␠/g, " ")
         .replace(/ /g, " ")
         .replace(/ /g, " ")
@@ -677,6 +692,50 @@ export function extractPytestParamBlock(source, tpId) {
     }
     return undefined;
 }
+function extractPytestParamTopLevelArgs(block) {
+    if (!block)
+        return [];
+    const open = block.indexOf("(");
+    const close = block.lastIndexOf(")");
+    if (open < 0 || close <= open)
+        return [];
+    const input = block.slice(open + 1, close);
+    const args = [];
+    let start = 0;
+    let depth = 0;
+    let quote = "";
+    let escaped = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const ch = input[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (ch === quote)
+                quote = "";
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === "[" || ch === "{" || ch === "(")
+            depth += 1;
+        else if (ch === "]" || ch === "}" || ch === ")")
+            depth -= 1;
+        else if (ch === "," && depth === 0) {
+            args.push(input.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    args.push(input.slice(start).trim());
+    return args.filter((arg) => arg && !/^(?:id|marks)\s*=/.test(arg));
+}
 function extractPytestParamParameterNames(source, tpId) {
     const block = extractPytestParamBlock(source, tpId);
     if (!block)
@@ -688,8 +747,11 @@ function extractPytestParamParameterNames(source, tpId) {
     if (decoratorIndex < 0)
         return [];
     const prefix = source.slice(decoratorIndex, blockIndex);
-    const match = /@pytest\.mark\.parametrize\s*\(\s*["']([^"']+)["']/s.exec(prefix);
-    return match?.[1]?.split(",").map((name) => name.trim()).filter(Boolean) ?? [];
+    const scalar = /@pytest\.mark\.parametrize\s*\(\s*["']([^"']+)["']/s.exec(prefix)?.[1];
+    if (scalar)
+        return scalar.split(",").map((name) => name.trim()).filter(Boolean);
+    const tuple = /@pytest\.mark\.parametrize\s*\(\s*\(\s*((?:["'][^"']+["']\s*,?\s*)+)\)/s.exec(prefix)?.[1];
+    return tuple ? [...tuple.matchAll(/["']([^"']+)["']/g)].map((match) => match[1]).filter(Boolean) : [];
 }
 export function observeParamFeatures(block, field, constants, parameterNames) {
     if (!block)
@@ -749,48 +811,7 @@ export function observeParamFeatures(block, field, constants, parameterNames) {
     }
     // Parse top-level positional args before the legacy token scanner so list
     // cardinality and field/value rows remain statically visible.
-    const topLevelArgs = (() => {
-        const open = block.indexOf("(");
-        const close = block.lastIndexOf(")");
-        if (open < 0 || close <= open)
-            return [];
-        const input = block.slice(open + 1, close);
-        const args = [];
-        let start = 0;
-        let depth = 0;
-        let quote = "";
-        let escaped = false;
-        for (let i = 0; i < input.length; i += 1) {
-            const ch = input[i];
-            if (escaped) {
-                escaped = false;
-                continue;
-            }
-            if (ch === "\\") {
-                escaped = true;
-                continue;
-            }
-            if (quote) {
-                if (ch === quote)
-                    quote = "";
-                continue;
-            }
-            if (ch === '"' || ch === "'") {
-                quote = ch;
-                continue;
-            }
-            if (ch === "[" || ch === "{" || ch === "(")
-                depth += 1;
-            else if (ch === "]" || ch === "}" || ch === ")")
-                depth -= 1;
-            else if (ch === "," && depth === 0) {
-                args.push(input.slice(start, i).trim());
-                start = i + 1;
-            }
-        }
-        args.push(input.slice(start).trim());
-        return args.filter((arg) => arg && !/^(?:id|marks)\s*=/.test(arg));
-    })();
+    const topLevelArgs = extractPytestParamTopLevelArgs(block);
     if (topLevelArgs.length > 0) {
         const idTp = /\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/i.exec(block)?.[1]?.toUpperCase();
         const meaningfulArgs = topLevelArgs.filter((arg) => {
@@ -1161,11 +1182,13 @@ function suggestedFixFor(intent, field, bound, example) {
                 : undefined;
         default:
             if (intent.startsWith("custom-literal:")) {
-                const expected = intent.slice("custom-literal:".length);
-                if (isWhitespaceSemanticLiteral(expected)) {
-                    return field ? `set ${field}="   "` : 'set value="   "';
+                const expectedRaw = intent.slice("custom-literal:".length);
+                const expected = normalizeCustomLiteralExpected(expectedRaw);
+                if (isWhitespaceSemanticLiteral(expectedRaw) || isWhitespaceOnlyString(expected)) {
+                    const length = isWhitespaceOnlyString(expected) ? expected.length : 3;
+                    return field ? `set ${field} to ${length} literal spaces` : `set value to ${length} literal spaces`;
                 }
-                if (isWhitespacePaddedSemanticLiteral(expected)) {
+                if (isWhitespacePaddedSemanticLiteral(expectedRaw)) {
                     return field
                         ? `set ${field}="  ${field}-value  "`
                         : 'set value="  value  "';
@@ -1177,6 +1200,200 @@ function suggestedFixFor(intent, field, bound, example) {
             return undefined;
     }
 }
+const MAX_PERSISTED_SCENARIO_TEXT = 192;
+function boundedScenarioText(value, logicalLength) {
+    if (value.length <= MAX_PERSISTED_SCENARIO_TEXT)
+        return value;
+    const suffix = `<truncated length=${logicalLength ?? value.length}>`;
+    return `${value.slice(0, Math.max(0, MAX_PERSISTED_SCENARIO_TEXT - suffix.length - 3))}...${suffix}`;
+}
+function localPythonFunctionRegion(source, functionName) {
+    const escaped = functionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const startMatch = new RegExp(`^def\\s+${escaped}\\s*\\(`, "m").exec(source);
+    if (!startMatch || startMatch.index === undefined)
+        return undefined;
+    const start = startMatch.index;
+    const remainder = source.slice(start + startMatch[0].length);
+    const nextTopLevel = /^(?:def|class|@pytest\b|@(?:[A-Za-z_][A-Za-z0-9_.]*))\s*/m.exec(remainder);
+    return source.slice(start, nextTopLevel?.index === undefined ? source.length : start + startMatch[0].length + nextTopLevel.index);
+}
+function splitPythonTopLevelArguments(input) {
+    const args = [];
+    let start = 0;
+    let depth = 0;
+    let quote = "";
+    let escaped = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const ch = input[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (ch === quote)
+                quote = "";
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === "[" || ch === "{" || ch === "(")
+            depth += 1;
+        else if (ch === "]" || ch === "}" || ch === ")")
+            depth -= 1;
+        else if (ch === "," && depth === 0) {
+            args.push(input.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    args.push(input.slice(start).trim());
+    return args.filter(Boolean);
+}
+function parseSimplePythonCall(expression) {
+    const call = /^([A-Za-z_][A-Za-z0-9_]*)\s*\(([\s\S]*)\)$/.exec(expression.trim());
+    if (!call)
+        return undefined;
+    const positional = [];
+    const keywords = new Map();
+    for (const argument of splitPythonTopLevelArguments(call[2] ?? "")) {
+        const keyword = /^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*([\s\S]+)$/.exec(argument);
+        if (keyword) {
+            if (keywords.has(keyword[1]))
+                return undefined;
+            keywords.set(keyword[1], keyword[2].trim());
+        }
+        else {
+            if (keywords.size > 0 || /^\*{1,2}/.test(argument))
+                return undefined;
+            positional.push(argument);
+        }
+    }
+    return { name: call[1], positional, keywords };
+}
+function safeSameModuleDictHelper(source, helperName) {
+    if (!helperName.startsWith("_"))
+        return undefined;
+    const region = localPythonFunctionRegion(source, helperName);
+    if (!region)
+        return undefined;
+    const functionBody = region.slice(region.indexOf(":") + 1);
+    const escapedName = helperName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (new RegExp(`\\b${escapedName}\\s*\\(`).test(functionBody))
+        return undefined;
+    if (/\b(?:Faker|fake|random|randint|uuid4|environ|getenv|requests|httpx|urlopen|subprocess|Popen|socket|open)\b/i.test(region))
+        return undefined;
+    const signature = new RegExp(`^def\\s+${escapedName}\\s*\\(([\\s\\S]*?)\\)\\s*(?:->[^:]+)?\\s*:`, "m").exec(region);
+    if (!signature)
+        return undefined;
+    const parameters = [];
+    for (const rawParameter of splitPythonTopLevelArguments(signature[1] ?? "")) {
+        if (rawParameter === "*" || rawParameter === "/")
+            continue;
+        if (/^\*{1,2}/.test(rawParameter))
+            return undefined;
+        const parameter = /^([A-Za-z_][A-Za-z0-9_]*)(?:\s*:[^=]+)?(?:\s*=\s*([\s\S]+))?$/.exec(rawParameter);
+        if (!parameter)
+            return undefined;
+        parameters.push({ name: parameter[1], defaultExpression: parameter[2]?.trim() });
+    }
+    const directReturn = /\breturn\s*(\{[\s\S]*?\})/.exec(functionBody)?.[1];
+    const assignment = /\b([A-Za-z_][A-Za-z0-9_]*)\s*(?::[^=\n]+)?=\s*(\{[\s\S]*?\})/.exec(functionBody);
+    const assignedReturn = assignment && new RegExp(`\\breturn\\s+${assignment[1].replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(functionBody)
+        ? assignment[2]
+        : undefined;
+    const dictExpression = directReturn ?? assignedReturn;
+    if (!dictExpression)
+        return undefined;
+    const fieldBindings = new Map();
+    for (const item of splitPythonTopLevelArguments(dictExpression.slice(1, -1))) {
+        const binding = /^(?:["']([^"']+)["'])\s*:\s*([A-Za-z_][A-Za-z0-9_]*)$/.exec(item);
+        if (!binding || !parameters.some((parameter) => parameter.name === binding[2]))
+            return undefined;
+        fieldBindings.set(binding[1], binding[2]);
+    }
+    return { parameters, fieldBindings };
+}
+function observeSameModulePayloadHelperField(input) {
+    const payloadIndex = input.parameterNames.findIndex((name) => /^(?:payload|body|data|json)$/i.test(name));
+    if (payloadIndex < 0)
+        return undefined;
+    let expression = extractPytestParamTopLevelArgs(input.block)[payloadIndex]?.trim() ?? "";
+    const wrapper = parseSimplePythonCall(expression);
+    if (wrapper?.name === "_without") {
+        if (wrapper.positional.length !== 2 || wrapper.keywords.size > 0)
+            return undefined;
+        const removed = observeLiteralToken(wrapper.positional[1], input.field, input.constants);
+        if (removed?.kind !== "string" || removed.literal !== input.field)
+            return undefined;
+        expression = wrapper.positional[0];
+        const inner = parseSimplePythonCall(expression);
+        if (!inner || !safeSameModuleDictHelper(input.source, inner.name))
+            return undefined;
+        return { kind: "missing-key", text: `missing:${input.field}` };
+    }
+    const call = parseSimplePythonCall(expression);
+    if (!call)
+        return undefined;
+    const helper = safeSameModuleDictHelper(input.source, call.name);
+    if (!helper)
+        return undefined;
+    const parameterName = helper.fieldBindings.get(input.field);
+    if (!parameterName)
+        return { kind: "missing-key", text: `missing:${input.field}` };
+    const parameterIndex = helper.parameters.findIndex((parameter) => parameter.name === parameterName);
+    if (parameterIndex < 0 || call.positional.length > helper.parameters.length)
+        return undefined;
+    const expressionForField = call.keywords.get(parameterName) ?? call.positional[parameterIndex] ?? helper.parameters[parameterIndex]?.defaultExpression;
+    return expressionForField
+        ? observeLiteralToken(expressionForField, input.field, input.constants)
+        : undefined;
+}
+function hasSafeSameModulePayloadHelper(source, block, parameterNames) {
+    const payloadIndex = parameterNames.findIndex((name) => /^(?:payload|body|data|json)$/i.test(name));
+    if (payloadIndex < 0)
+        return false;
+    const expression = extractPytestParamTopLevelArgs(block)[payloadIndex]?.trim() ?? "";
+    const call = parseSimplePythonCall(expression);
+    if (!call)
+        return false;
+    if (/\b(?:Faker|fake|random|randint|uuid4|environ|getenv|requests|httpx|urlopen|subprocess|Popen|socket|open)\b/i.test(expression))
+        return false;
+    return Boolean(safeSameModuleDictHelper(source, call.name));
+}
+function observeDeterministicFunctionFieldOverride(input) {
+    const region = scenarioFunctionRegion(input.source, input.tpId);
+    if (!region)
+        return undefined;
+    const escapedField = input.field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const assignment = new RegExp(`^([ \\t]*)([A-Za-z_][A-Za-z0-9_]*)\\s*\\[\\s*["']${escapedField}["']\\s*\\]\\s*=\\s*([A-Za-z_][A-Za-z0-9_]*)\\s*$`, "m").exec(region);
+    if (!assignment)
+        return undefined;
+    const indentation = assignment[1]?.length ?? 0;
+    const valueParameter = assignment[3];
+    const valueIndex = input.parameterNames.indexOf(valueParameter);
+    if (valueIndex < 0)
+        return undefined;
+    const beforeAssignment = region.slice(0, assignment.index);
+    const guardMatches = [...beforeAssignment.matchAll(/^([ \\t]*)if\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*$/gm)];
+    const nearestGuard = guardMatches.at(-1);
+    if (nearestGuard && (nearestGuard[1]?.length ?? 0) < indentation) {
+        const guardIndex = input.parameterNames.indexOf(nearestGuard[2]);
+        if (guardIndex < 0)
+            return undefined;
+        const guardExpression = extractPytestParamTopLevelArgs(input.block)[guardIndex]?.trim();
+        if (guardExpression !== "True")
+            return undefined;
+    }
+    const valueExpression = extractPytestParamTopLevelArgs(input.block)[valueIndex]?.trim();
+    return valueExpression
+        ? observeLiteralToken(valueExpression, input.field, input.constants)
+        : undefined;
+}
 function scenarioFunctionRegion(source, tpId) {
     const idIndex = source.indexOf(`id="${tpId}"`) >= 0
         ? source.indexOf(`id="${tpId}"`)
@@ -1202,6 +1419,43 @@ function hasCreateDeleteDerivedJourney(source, tpId) {
         (/\b_create[A-Za-z0-9_]*\s*\(/.test(region) &&
             (/\b_delete[A-Za-z0-9_]*\s*\(/.test(region) || /\.delete\s*\(/.test(region) || /\.request\s*\(\s*["']DELETE["']/i.test(region)));
 }
+function hasConditionalFieldOmission(source, tpId, field, parameterNames) {
+    if (!field)
+        return false;
+    const region = scenarioFunctionRegion(source, tpId);
+    const escapedField = field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const candidateNames = parameterNames.filter((name) => {
+        const normalized = name.toLowerCase();
+        const normalizedField = field.toLowerCase();
+        return normalized === normalizedField || normalized.startsWith(`${normalizedField}_`) || normalized.endsWith(`_${normalizedField}`);
+    });
+    return candidateNames.some((name) => {
+        const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return new RegExp(`\\{\\s*\\}\\s*if\\s+${escapedName}\\s+is\\s+None\\s+else\\s+\\{[\\s\\S]{0,200}?["']${escapedField}["']\\s*:\\s*${escapedName}\\b`).test(region) ||
+            new RegExp(`\\{[\\s\\S]{0,200}?["']${escapedField}["']\\s*:\\s*${escapedName}\\b[\\s\\S]{0,200}?\\}\\s*if\\s+${escapedName}\\s+is\\s+not\\s+None\\s+else\\s+\\{\\s*\\}`).test(region) ||
+            new RegExp(`if\\s+${escapedName}\\s+is\\s+not\\s+None\\s*:[\\s\\S]{0,200}?["']${escapedField}["']\\s*\\]\\s*=\\s*${escapedName}\\b`).test(region);
+    });
+}
+function scenarioParamSourceLocation(scriptPath, source, tpId) {
+    const block = extractPytestParamBlock(source, tpId);
+    if (!block)
+        return undefined;
+    const index = source.indexOf(block);
+    if (index < 0)
+        return undefined;
+    return `${scriptPath}:${source.slice(0, index).split("\n").length}`;
+}
+function scenarioParamDiagnosticValues(intent, observed) {
+    const expectedRaw = intent.startsWith("custom-literal:")
+        ? intent.slice("custom-literal:".length)
+        : intent === "unknown" ? undefined : intent;
+    return {
+        expectedRaw,
+        observedRaw: boundedScenarioText(observed.text, observed.length),
+        expectedNormalized: expectedRaw === undefined ? undefined : normalizeCustomLiteralExpected(expectedRaw).slice(0, 512),
+        observedNormalized: observed.literal === undefined ? undefined : boundedScenarioText(normalizeScenarioLiteralText(observed.literal), observed.length),
+    };
+}
 export async function assessBackendScenarioParamConsistency(input) {
     const cases = await listMarkdownCases(input.workspaceRoot, input.layout);
     const entries = [];
@@ -1223,7 +1477,26 @@ export async function assessBackendScenarioParamConsistency(input) {
             const constants = source ? collectPythonStringConstants(source) : undefined;
             const block = source ? extractPytestParamBlock(source, tpId) : undefined;
             const parameterNames = source ? extractPytestParamParameterNames(source, tpId) : [];
-            const observed = observeParamFeatures(block, inferred.field, constants, parameterNames);
+            const functionFieldOverride = source && inferred.field
+                ? observeDeterministicFunctionFieldOverride({
+                    source,
+                    tpId,
+                    block,
+                    parameterNames,
+                    field: inferred.field,
+                    constants,
+                })
+                : undefined;
+            const helperFieldObserved = source && inferred.field
+                ? observeSameModulePayloadHelperField({
+                    source,
+                    block,
+                    parameterNames,
+                    field: inferred.field,
+                    constants,
+                })
+                : undefined;
+            const observed = functionFieldOverride ?? helperFieldObserved ?? observeParamFeatures(block, inferred.field, constants, parameterNames);
             // Request-level / health checks often have no pytest.param payload row,
             // or only a TP-id label positional (no field value).
             const requestLevelNoParam = Boolean(source) &&
@@ -1242,9 +1515,17 @@ export async function assessBackendScenarioParamConsistency(input) {
                     hasCreateDeleteDerivedJourney(source, tpId)) ||
                     (/^custom-literal:(?:create-derived(?:-active-id|-id)?|active-existing-derived)$/i.test(inferred.intent) &&
                         hasCreateDerivedJourney(source, tpId)));
+            const conditionalOmissionMatch = Boolean(source) &&
+                inferred.intent === "missing" &&
+                observed.kind === "none" &&
+                hasConditionalFieldOmission(source, tpId, inferred.field, parameterNames);
+            const localPayloadHelperMatch = Boolean(source) &&
+                inferred.intent === "nominal" &&
+                !inferred.field &&
+                hasSafeSameModulePayloadHelper(source, block, parameterNames);
             const status = !source
                 ? "UNDETERMINED"
-                : derivedJourneyMatch
+                : derivedJourneyMatch || conditionalOmissionMatch || localPayloadHelperMatch
                     ? "MATCH"
                     : requestLevelNoParam
                         ? "MATCH"
@@ -1252,14 +1533,19 @@ export async function assessBackendScenarioParamConsistency(input) {
                             ? "UNDETERMINED"
                             : compareIntent(inferred.intent, observed, inferred.bound, inferred.example, inferred.field);
             const repairability = repairabilityFor(status, inferred.intent, observed, inferred.example);
+            const diagnostics = scenarioParamDiagnosticValues(inferred.intent, observed);
             entries.push({
                 caseId: testCase.caseId,
                 tpId,
                 field: inferred.field,
                 intent: inferred.intent,
-                observed: observed.text,
+                observed: boundedScenarioText(observed.text, observed.length),
+                observedLength: observed.length,
                 status,
                 repairability,
+                reasonCode: status === "MATCH" ? "SCENARIO_PARAM_MATCH" : status === "MISMATCH" ? "SCENARIO_PARAM_MISMATCH" : "SCENARIO_PARAM_UNDETERMINED",
+                ...diagnostics,
+                sourceLocation: source ? scenarioParamSourceLocation(testCase.scriptPath, source, tpId) : undefined,
                 suggestedFix: fallbackSourced
                     ? undefined
                     : suggestedFixFor(inferred.intent, inferred.field, inferred.bound, inferred.example),

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

@@ -4,6 +4,7 @@ import path from "node:path";
 import { z } from "zod";
 import { BACKEND_TEST_MAX_MODULE_COUNT, isOpaqueHashBackendTestModuleStem, isPriorityOnlyBackendTestModuleStem, } from "./backend-test-module-stem.js";
 import { resolveBackendTestLayout, } from "./backend-test-layout.js";
+import { inspectBackendTestMarkdownTestPointBindings } from "./backend-test-case-coverage-analysis.js";
 /**
  * Maps a backend-test generation writer task id to its writer-progress role.
  * Returns undefined for nodes that are not completeness-gated generators.
@@ -276,6 +277,16 @@ function moduleStructurallyComplete(markdown) {
             reasons: [`missing required sections: [${missing.join(", ")}]`],
         };
     }
+    const bindingReasons = inspectBackendTestMarkdownTestPointBindings(markdown).flatMap((entry) => [
+        ...(entry.unclassifiedTestPoints.length > 0
+            ? [`${entry.caseId} has unclassified Test Points: ${entry.unclassifiedTestPoints.join(", ")}`]
+            : []),
+        ...(entry.duplicateBindingTestPoints.length > 0
+            ? [`${entry.caseId} has duplicate Test Point bindings: ${entry.duplicateBindingTestPoints.join(", ")}`]
+            : []),
+    ]);
+    if (bindingReasons.length > 0)
+        return { ok: false, reasons: bindingReasons };
     return { ok: true, reasons: [] };
 }
 function moduleStructuralDetail(result) {

package/dist/workflows/dag/init-hybrid.js

@@ -4520,7 +4520,7 @@ async function buildBackendTestHybridDag(sources) {
             "Coverage priority is strict inside the declared scope: P0 product requirements/task hard constraints always remain in scope; P1 exhaustively supplements documented operations, fields, business rules, statuses and errors only for Affected Operations; P2 adds bounded protocol robustness only when it is relevant to the change and does not invent product behavior. Coverage percentages describe the declared affected scope, never whole-API completeness unless every operation is explicitly listed. Conflicts or undefined expectations must stay visible as GAP/CONFLICT with precise source pointers, never guessed.",
             "For uniqueness/lifecycle rules cover absent, active-existing, deleted-existing, create-delete-recreate, restore-then-recreate and documented scope/case-normalization states. For every enum cover every valid value plus bounded invalid equivalence classes (unknown, case variant, whitespace, empty, null/missing and wrong types as applicable). For every length/number rule cover min-1, min, nominal, max and max+1. For format rules cover each allowed class separately plus a valid mixed value, and representative forbidden classes including uppercase, internal/leading/trailing whitespace, tab/newline, unsupported punctuation, slash, emoji or control characters when the source contract supports that expectation.",
             "Mandatory module index: include a `## Module Index` table in the plan artifact that lists every planned module as a canonical relative link of the exact form `[label](./<stem>.md)` plus a `testcase/md/<stem>.md` path cell, so a downstream deterministic manifest can parse the module list. Group by stable business resource/domain, not by CRUD operation: one resource's list/detail/create/update/delete cases belong in one module such as `resource_notes`; split only when a single module would exceed the per-child 16K output protocol, keep the total module count at the smallest safe value, and never exceed 8 modules. Name each module file with a stable lowercase business stem such as `health` or `resource_notes`. Pure hexadecimal/hash-like opaque stems such as `a401606` or `deadbeef` are forbidden. Do not use priority-only stems `p0`, `p1` or `p2`; Priority belongs only in the Coverage Matrix and never defines module files. Do not use Case-ID-like module filenames such as `BE-HEALTH.md` or `BE-NOTES.md`. The relative link target MUST equal the on-disk filename stem the sharded writer will create. For every automatable case, `自动化映射` must name exactly `testcase/test_<module>.py`, where <module> is that Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `testcase/md/health.md` → `testcase/test_health.py`; `testcase/md/resource_notes.md` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.",
-            "Scenario Partitions (query/filter axes): for every affected GET/list operation, declare one row per enum or classification axis used for filtering (query/path parameters such as type/status/category). Add a mandatory machine-readable `## Scenario Partitions` section after the Coverage Matrix using exactly `| Partition ID | Operation | Axis | Domain | Required Slots | Expected by Slot | Bind Rule |` with the separator row. Partition ID is a stable `SP-<OPERATION>-<AXIS>` token; Domain must copy the legal values verbatim from the bound OpenAPI enum or requirement sentence (never guess), using bare semicolon-separated identifier values inside the single table cell (for example `ACTIVE; ARCHIVED`, with no Markdown backticks or prose); Required Slots writes `each-value` plus `omitted` only when the parameter is optional; Expected by Slot states the documented expectation per slot kind (`domain-value`, `default-behavior`, `empty-result`/`excluded-result` when documented, or `GAP` when the source does not document the complement expectation — never invent 空列表/400). POST/PUT body field-validation enums stay in the Coverage Matrix as `TP-<FIELD>-ENUM-*` and MUST NOT get a Scenario Partition row. Do not create partitions for axes without a documented legal-value domain. Only GET/list query or path parameters whose bound source documents a finite enum or classification set may become a Scenario Partition. Do not create partitions for free-form strings, primary keys, required-or-optional-only parameters, or boundary/format-only axes. If an axis has no finite legal-value domain, do not declare a Partition row and do not invent NOT-IN-SET cases. Cross-axis combinations stay as ONE nominal Case; never declare a cross-axis cartesian partition.",
+            "Scenario Partitions (query/filter axes): for every affected GET/list operation, declare one row per enum or classification axis used for filtering (query/path parameters such as type/status/category). Add a mandatory machine-readable `## Scenario Partitions` section after the Coverage Matrix using exactly `| Partition ID | Operation | Axis | Domain | Required Slots | Expected by Slot | Bind Rule |` with the separator row. Partition ID is a stable `SP-<OPERATION>-<AXIS>` token; Domain must copy the legal values verbatim from the bound OpenAPI enum or requirement sentence (never guess), using bare semicolon-separated identifier values inside the single table cell (for example `ACTIVE; ARCHIVED`, with no Markdown backticks or prose); Required Slots must contain `each-value` and exactly one `not-in-set`, plus `omitted` only when the parameter is optional; Expected by Slot states the documented expectation per slot kind (`domain-value`, `default-behavior`, `empty-result`/`excluded-result` when documented, or `GAP` when the source does not document the complement expectation — never invent 空列表/400). POST/PUT body field-validation enums stay in the Coverage Matrix as `TP-<FIELD>-ENUM-*` and MUST NOT get a Scenario Partition row. Do not create partitions for axes without a documented legal-value domain. Only GET/list query or path parameters whose bound source documents a finite enum or classification set may become a Scenario Partition. Do not create partitions for free-form strings, primary keys, required-or-optional-only parameters, or boundary/format-only axes. If an axis has no finite legal-value domain, do not declare a Partition row and do not invent NOT-IN-SET cases. Cross-axis combinations stay as ONE nominal Case; never declare a cross-axis cartesian partition.",
             "Before finalizing README, calculate the predicted collected-item count as `sum(max(1, number of variant Test Points in each Case))`. If the task declares an item budget, the prediction must not exceed it. Reduce excess only by removing duplicate execution and converting same-request checkpoints to assertions; never drop required rules, boundaries, enums, operation-specific inputs, or business states. Record the prediction in README. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
             ...(sharedSetupPrompt ? [sharedSetupPrompt] : []),
             intake.boundedSourceContext,
@@ -4815,7 +4815,7 @@ async function buildBackendTestHybridDag(sources) {
         writerOutcomePolicy: { type: "implementation-outcome-v1", requireChangedFiles: true },
         outputContract: "First non-empty line is IMPLEMENTATION_OUTCOME: changed|blocked, followed by a concise repair summary. This node runs only for REPAIRABLE initial facts, so already-satisfied is invalid and a successful outcome requires a non-empty bounded diff. Modify only generated pytest scripts/helpers/factories and preserve every Markdown Case, Test Point, primary symbol and assertion meaning.",
         subtask_prompt: [
-            "Repair the generated backend pytest asset as one bounded program using the direct upstream collection assessment. This is the only repair attempt and happens before any business test body execution. Treat any upstream line such as `Repair paths: testcase/test_x.py` as complete authoritative repairPaths evidence. Directly read and edit that testcase path; do not search for separate root-level `contracts/**`, guess a DAG run directory, or require another report artifact. If the read tool successfully returns the testcase file, the path exists—continue the bounded repair and never later claim that file is absent.",
+            "Repair the generated backend pytest asset as one bounded program using the direct upstream collection assessment. This is the only repair attempt and happens before any business test body execution. The direct upstream JSON includes authoritative `repairPaths` and bounded `repairFindings`; treat both as the complete mandatory checklist without searching for a run directory or report file. Treat any upstream line such as `Repair paths: testcase/test_x.py` as equivalent authoritative repairPaths evidence. Directly read and edit that testcase path; do not search for separate root-level `contracts/**`, guess a DAG run directory, or require another report artifact. If the read tool successfully returns the testcase file, the path exists—continue the bounded repair and never later claim that file is absent.",
             "Initial status REPAIRABLE means at least one listed finding remains: `already-satisfied` is forbidden, and you must produce a non-empty bounded diff on repairPaths before returning `IMPLEMENTATION_OUTCOME: changed`. Fix only readiness-proven generated testcase-local defects on initial facts repairPaths: create exact safe missing mapped test_*.py paths, repair syntax/import/symbol/decorator/parameterization, close generated fixture dependencies/plugin registration, and repair initial Markdown-to-pytest correspondence findings. Use this deterministic repair map instead of reading analyzer implementation: findings about `Case-ID`, `Assertion-Test-Points`, or `Cross-Cutting-Test-Points` are fixed by editing the declared primary symbol docstring metadata lines; variant binding findings are fixed in the literal direct `pytest.param(..., id=\"TP-...\")` row; primary-symbol cardinality/name findings are fixed in the function name or duplicate primary symbols; script mismatch is fixed only on the authoritative assessment repairPaths; payload findings are fixed in request payload construction. Do not read controller `src/**` or inspect JS/TS analyzer code. Do not search for `testcase/**/README.md`. Never invent a business pytest symbol for evidence-only Markdown Cases that declare `脚本/primary symbol=无` with empty variants. For fixture defects inspect both provider and importer listed by repairPaths; fix ScopeMismatch by aligning fixture scopes or inlining request-scoped values so module fixtures never depend on function fixtures; when a shared fixture depends on sibling fixtures, register the whole provider module through an exact pytest_plugins declaration rather than importing only the outer fixture. Do not create unrelated pytest scripts.",
             "This is the single pytest incremental synchronization round. The `Findings` in `reports/backend-test-pytest-collection-initial.md` are the mandatory repair checklist: resolve every repairable listed finding on every authoritative `Repair paths` file before considering any other advisory evidence, and never substitute an unrelated scenario-param cleanup for a listed correspondence/collection defect. For every assessment-listed path, compare the effective Markdown Case/Test Points/test data and its `Payload Contract`/`Payload Required Paths`/`Payload Allowed Paths`/`Payload Enum` labels with the generated module. Incrementally add or repair only missing symbols, params, assertions and payload builders. Repair every assessment-listed missing nested path, unexpected key and enum mismatch; preserve exact DTO keys, nested shapes, enum/boundary literals, operation transport and business preconditions; remove guessed replacement keys only when the effective Markdown proves the exact contract. Keep path/query/header identifiers and scenario-control metadata separate from DTO patches and JSON bodies; an `id` used for a path target must be passed to the request path/helper, never inserted into a body patch unless `id` is explicitly listed in Payload Allowed Paths. Flatten every variant into a literal direct `pytest.param(..., id=\"TP-...\")` row; replace `_post_case`/`_put_case` or other parameter-row factories because correspondence and scenario readiness require the actual row values and IDs to be statically visible. Also repair helper call sites to match their defined return signatures; do not tuple-unpack a helper that returns one scalar value.",
             "Preserve final testcase/md/** semantics, every Case ID, Rule/Test Point binding, primary symbol, parameter ID, expected status/body/schema assertion, HTTP logging, redaction and truncation behavior.",

package/docs/architecture/runtime-boundaries.md

@@ -207,7 +207,8 @@ Runtime 变更另需 `npm run typecheck` 及对应 targeted Vitest（见 exec pl
 | --- | --- | --- |
 | OpenCode transient-retry | `.opencode/plugins/loop-agent-transient-retry.js`（init surface `generated`） | 仅瞬态 UnknownError resume；busy/retry 门控 + backoff；overflow/401/配额/取消/业务标 permanent（`plugin-ignore-permanent-error`），**不** compact |
 | OpenCode overflow-compact | `.opencode/plugins/loop-agent-context-overflow-compact.js`（init surface `generated`） | 仅 context overflow → `session.compact`（无则 `summarize`）+ 有限 `promptAsync` 续接；`MAX_OVERFLOW_RECOVERIES ≤ 2`；session 锁；非 overflow 不动作 |
-| Pi project extension | `.pi/extensions/loop-agent-context-overflow.js`（init surface `generated`） | `message_end` 上将 overflow `errorMessage` 幂等改写为 `context_length_exceeded:` 前缀，触发 Pi 原生 compact/retry；**不**写 `~/.pi` settings / compaction / 模型窗口 |
+| Pi project extension | `.pi/extensions/loop-agent-context-overflow.js`（init surface `generated`） | `message_end` 上将 overflow `errorMessage` 幂等改写为 `context_length_exceeded:` 前缀，触发 Pi 原生 compact/retry；分类器与控制器共享 P1–P10 / N1–N5 语料（含嵌套 JSON）；**不**写 `~/.pi` settings / compaction / 模型窗口，**不**投影 sift native |
+| Console / DAG 运行时 | npm 内置 inline extension + 可选 `@agent-context/sift` | 默认开启 L0/L1/L2；`HARNESS_CONTEXT_PRESSURE_MODE=off` 关 L0/L2；`HARNESS_CONSOLE_SIFT` / `HARNESS_DAG_SIFT` 的 `0\|false\|off` 关 L1。DAG 不做 streaming 主动 compact。不进入目标项目 init 文件 |
 | Pi 用户配置 | `~/.pi/agent/settings.json` | **不**进入项目 `.harness/init-surface.json` hash；仅 `--client-recovery=user` 可字段级补缺并原子写；`auto`/`project`/`off` 与 `check-update` 默认零写 home；读取时只有 `ENOENT` 视为缺文件，其他 I/O 错误 fail closed |
 | CLI mode | `--client-recovery=auto\|project\|user\|off`（默认 `auto`） | `auto`/`project` 安装上述三份项目产物；`user` = 三产物 + 显式 Pi retry 合并；`off` 全跳过 |
 | Ownership | recorded sha256 + apply-safe | 三份 generated 缺失可补、与 recorded hash 一致可升级；用户改过 → model merge / human decision，禁止静默覆盖 |