@tea-agent/loop-agent 0.40.0-next.9 → 0.41.0-next.1

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. Before returning, expand every declared partition into its complete deterministic exact slot ID set: one `TP-<Partition ID>-<VALUE-TOKEN>` per Domain value, `TP-<Partition ID>-OMITTED` only for an optional axis, and exactly one `TP-<Partition ID>-NOT-IN-SET`. Every expanded slot ID must appear verbatim in the binding Rule's `Required Test Points` cell and be assigned to concrete Case IDs in that same Coverage Matrix row; ordinary alias/family Test Points do not replace this inventory. 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,
@@ -4603,7 +4603,7 @@ async function buildBackendTestHybridDag(sources) {
                     "Write human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.",
                     'Write the module {{item.stem}} as readable case cards covering every in-scope rule/Test Point the README Coverage Matrix assigns to this module. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>`. `<NNN>` is exactly three zero-padded digits (`001`, `002`, ...), never two digits (`01`), a bare number, or an alphabetic suffix such as `011A`. Every case must include `### 覆盖规则`, `### 测试点`, `### 场景类型`, `### 前置条件`, `### 操作步骤`, `### 预期结果`, and `### 自动化映射` Do not group cases under "## 测试类 ..." (or any h2 grouping) headings that force Cases down to h3; each Case must be a direct h2 (`##`), and its seven sections must be h3 (`###`) children of that Case. If you need to convey a pytest class, state it inside the Case\'s `### 自动化映射` instead. Forbidden: `## 测试类 X` then `### BE-PD-001` and `### 覆盖规则` at the same h3 level. Required: `## BE-PD-001` then `### 覆盖规则`.; `覆盖规则` and `测试点` must reference exact Matrix Rule Keys/Test Points. Add `测试目的`, `验收标准`, `需求依据`, and `测试数据` for readable evidence. The `验收标准` section must list the exact applicable `AC-...` IDs, and every explicit task AC must appear in at least one Case. Every automatable case explicitly names its target pytest script and exactly one primary symbol so traceability scans only that script/symbol. Evidence-only meta cases that exist solely for non-executable assertion/cross-cutting process evidence may declare `脚本：无` and `primary symbol：无` with empty `变体测试点`, and must not invent a business pytest item.',
                     "Name this module file with the stable lowercase business stem `{{item.stem}}` (filename `testcase/md/{{item.stem}}.md`). Priority-only stems `p0`, `p1` and `p2` are forbidden and must never produce `p0.md` or `test_p0.py`. Pure hexadecimal/hash-like opaque stems such as `a401606` and `deadbeef` are also forbidden. Do not use Case-ID-like module filenames. For every automatable case, `自动化映射` must name exactly `testcase/test_{{item.stem}}.py`, where the module stem is this Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `health` → `testcase/test_health.py`; `resource_notes` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.",
-                    "Scenario Partition slots: when README declares `## Scenario Partitions`, every slot of each declared partition MUST appear in this module's Cases as exactly one variant Test Point with the deterministic ID `TP-<Partition ID>-<VALUE-TOKEN>` (each-value), `TP-<Partition ID>-OMITTED` (optional axis only) and exactly one `TP-<Partition ID>-NOT-IN-SET` complement slot with `intent=enum-invalid`. Example: Partition ID `SP-GET-API-RESOURCE-NOTES-STATUS` → `TP-SP-GET-API-RESOURCE-NOTES-STATUS-ACTIVE`. Slot IDs copy the declared Partition ID exactly; never drop the HTTP method, invent, merge, renumber or split slot IDs. Prefer ONE Case per partition with a parameter table over duplicated Cases per value. The not-in-set slot value must be a concrete literal absent from the Domain (e.g. `UNKNOWN_TYPE`) and its expected result must come from the bound source — when Expected by Slot is GAP, the Case states the expectation as GAP evidence, never a guessed 空列表/400. Never create cross-axis combination variants beyond the single documented nominal.",
+                    "Scenario Partition slots: when README declares `## Scenario Partitions`, every slot of each declared partition MUST appear in this module's Cases as exactly one variant Test Point with the deterministic ID `TP-<Partition ID>-<VALUE-TOKEN>` (each-value), `TP-<Partition ID>-OMITTED` (optional axis only) and exactly one `TP-<Partition ID>-NOT-IN-SET` complement slot with `intent=enum-invalid`. Example: Partition ID `SP-GET-API-RESOURCE-NOTES-STATUS` → `TP-SP-GET-API-RESOURCE-NOTES-STATUS-ACTIVE`. Slot IDs copy the declared Partition ID exactly; never drop the HTTP method, invent, merge, renumber or split slot IDs. Before returning, derive the complete exact slot set from every applicable Scenario Partitions row and verify that the module Cases declare and bind every slot assigned by the Coverage Matrix; ordinary alias Test Points do not satisfy a partition slot, and aggregate aliases such as `SINGLE`/`MULTIPLE` are forbidden. Prefer ONE Case per partition with a parameter table over duplicated Cases per value. The not-in-set slot value must be a concrete literal absent from the Domain (e.g. `UNKNOWN_TYPE`) and its expected result must come from the bound source — when Expected by Slot is GAP, the Case states the expectation as GAP evidence, never a guessed 空列表/400. Never create cross-axis combination variants beyond the single documented nominal.",
                     "For every variant Test Point, write its machine-checkable `场景意图: <TP-ID>; operation=...; target=...; intent=...` line inside that same Case body/自动化映射. Never collect Scenario Intent lines in a file-level appendix, implementation-details block, or another Case; local TP ownership is mandatory.",
                     "Every Case must keep at least one numbered executable line under `### 操作步骤`; a compact variant/result table may follow but must not replace the numbered action anchor. Keep numbered/bulleted independently assertable results under `### 预期结果`. The exact `### 操作步骤` and `### 预期结果` headings must remain present for every Case, including compact/table-based Cases; never compress later Cases by dropping required headings. Every result must name the observable HTTP status, response field/value, state transition or membership condition, never vague wording such as ‘符合预期’.",
                     "In every `自动化映射`, use exactly these machine-readable list labels: `脚本`, `primary symbol`, `变体测试点`, `场景断言测试点`, `横切证据测试点`, plus a deterministic payload contract. For operations without a request body write `Payload Contract: none`. Otherwise write `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum` (write `none` when there is no enum); nested fields use dot paths such as `approver.name`. Each Case describes exactly one target request payload contract: put every payload label on its own list line, never concatenate multiple operations or setup POST/PUT contracts into one label line, and never repeat a `Payload Contract:` token inside explanatory prose/details after the machine-readable line. Values must come only from bound API/DTO evidence, never guesses. Each Test Point from `### 测试点` must appear in exactly one binding list, and every Test Point named in any binding list must also be declared in that Case's `### 测试点`; write `无` for an empty list. A variant Test Point is atomic: one exact endpoint/input/precondition/outcome row equals one exact pytest item and one exact TP ID. If a parameter table has five rows, declare five distinct variant TP IDs in Markdown; never declare one family TP and append row suffixes only in pytest. Classify as `variant` only when endpoint, request input, precondition business state, or expected outcome genuinely changes and therefore needs an independent pytest parameter item. Classify CRUD checkpoints, status/body/header/schema assertions and multiple checks over the same response/journey as `assertion`; classify shared HTTP logging/redaction/truncation evidence as `cross-cutting`. Never create a Test Point merely to parameterize a checkpoint. Every non-cross-cutting TP ID is owned by exactly one Case; when the same response/schema/error assertion is needed in different Cases, use distinct Case-specific TP IDs instead of reusing one assertion TP across Cases. Keep the script path identical to the module one-to-one path and declare exactly one primary symbol named with the canonical Case prefix, for example `BE-RN-003` → `test_BE_RN_003_<description>`; non-Case-prefixed primary symbols are forbidden because parameterized item association must remain deterministic. For evidence-only meta Cases with no executable business journey, write `脚本：无` and `primary symbol：无`, keep `变体测试点：无`, and place process evidence only in assertion/cross-cutting lists. If the bound contract only says an identifier is returned/present, do not declare a concrete identifier type. If a 404 Case needs a nonexistent path identifier but its syntax/type is unspecified, define a create-delete-derived valid identifier journey instead of an arbitrary UUID/text placeholder. For redaction scenarios, list sensitive header/field key names only. Never write any header-name-and-value pair, credential placeholder, fake token, anti-example, or other secret-shaped literal in Markdown; state only that a test-only value is supplied at runtime and omitted. Put implementation-only restrictions in a concise `<details>` block rather than dominating the main case flow. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
@@ -4648,7 +4648,7 @@ async function buildBackendTestHybridDag(sources) {
             "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, rename module files to stable lowercase stems when needed, normalize every Case ID to hyphen-separated module segments plus exactly three zero-padded digits (`BE-RESOURCE_NOTES-01` → `BE-RESOURCE-NOTES-001`; `BE-RN-011A` must be renumbered or merged) consistently across headings/index/mappings, fix automation mappings so each automatable case points at `testcase/test_<module>.py` derived from that module filename and declares exactly one primary symbol (evidence-only meta cases may keep `脚本/primary symbol=无` with empty variants), assign every Test Point exactly one of `变体测试点`/`场景断言测试点`/`横切证据测试点`, then perform an exact-set check: each Case's `### 测试点` set must equal (not merely contain) the union of those three binding lists; delete stale/legacy aliases and ensure every binding-list Test Point is present, expand every variant parameter row into its own atomic TP ID, make every non-cross-cutting TP Case-specific and owned by exactly one Case, require every primary symbol to start with the canonical Case prefix, ensure every explicit AC ID appears in an applicable Case `验收标准`, merge execution duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Remove every credential/header value, placeholder, fake token and anti-example from Markdown. Sensitive key names may remain only as a plain list; values must be described as runtime-only and omitted, with no colon/value pair or literal example anywhere, including details blocks and explanatory text. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations as exact machine-readable identifiers; only normalize Case ID separator/sequence formatting as specified above. Recalculate predicted collected items as `sum(max(1, variant count per Case))`; when the task declares a budget, directly merge redundant journeys/reclassify same-request checkpoints until the prediction is within budget, while preserving all required coverage. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
             "This is the single Markdown incremental synchronization round. Read every authoritative reference index entry whose role hints include acceptance-criteria, api-contract, data-contract or business-rule; do not rely on the derived PRD as a complete inventory. Preserve every explicit AC/REQ/BR ID, every documented HTTP/business error code, every DTO/JSON field, enum value, boundary, format, nested shape, transaction/state/idempotency/uniqueness/auth/tenant/cross-field rule. For each natural-language normative business rule preserved as required scope, include its exact source sentence without paraphrase together with source path and line/heading anchor so the deterministic ledger can verify quote/hash provenance. Ensure every Case declares exactly `Payload Contract: none` or the three labels `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; every label must occupy its own machine-readable list line, and a Case must never concatenate target/setup operations or multiple `Payload Contract` tokens onto one line, and explanatory prose/details must not repeat any `Payload Contract:` token; never infer missing keys or enum values. A target GET/DELETE operation with no request body must remain `Payload Contract: none` even when its setup journey performs POST/PUT with a DTO; setup payloads never redefine the target Case payload contract. Add only missing Matrix rows/Test Points/Cases/assertions or repair exact drift; do not rewrite already-valid unrelated modules. Work gap-targeted: inspect source anchors and affected modules first, leave unrelated valid modules byte-stable, and return `already-satisfied` without restating the full suite when no gap exists.",
             "For affected API fields, use one valid nominal payload plus atomic required/missing/null/empty/wrong-type, every documented enum value plus bounded invalid classes, documented min-1/min/nominal/max/max+1, formats and nested object/array constraints. Do not generate a Cartesian product or invent undocumented constraints. Do not invent a concrete identifier type when the source only requires presence; for a missing-resource 404 path with unspecified identifier syntax/type, synchronize the Case to a create-delete-derived valid identifier journey rather than an arbitrary UUID/text placeholder.",
-            "Scenario Partitions synchronization: when the run-owned plan declares `## Scenario Partitions`, verify each declared partition's slots are fully materialized as variant Test Points with exact `TP-<Partition ID>-...` IDs (each-value per Domain value, OMITTED only for optional axes, exactly one NOT-IN-SET with intent=enum-invalid). Directly add missing slot rows/Cases. Record an illegal plan Partition row that has no source-backed finite domain as GAP/CONFLICT and remove only its derived `TP-SP-*` slots/Cases from target modules; never modify the immutable plan artifact. Never delete a legal source-backed partition or drop its complement slot to force coverage green. When the bound source does not document the complement expectation, keep the slot with GAP expected instead of guessing. Body-field validation enums (`TP-<FIELD>-ENUM-*`) are NOT partitions — do not add partition rows for them.",
+            "Scenario Partitions synchronization: when the run-owned plan declares `## Scenario Partitions`, verify each declared partition's slots are fully materialized as variant Test Points with exact `TP-<Partition ID>-...` IDs (each-value per Domain value, OMITTED only for optional axes, exactly one NOT-IN-SET with intent=enum-invalid). Before returning, derive the complete exact slot set from every legal Scenario Partitions row and compare it with both the binding Coverage Matrix Rule's Required Test Points and the final Case `### 测试点`/`变体测试点` sets; directly add every missing exact slot to the already-assigned Case IDs; ordinary alias Test Points do not satisfy a partition slot, and aggregate aliases such as `SINGLE`/`MULTIPLE` are forbidden. Directly add missing slot rows/Cases. Record an illegal plan Partition row that has no source-backed finite domain as GAP/CONFLICT and remove only its derived `TP-SP-*` slots/Cases from target modules; never modify the immutable plan artifact. Never delete a legal source-backed partition or drop its complement slot to force coverage green. When the bound source does not document the complement expectation, keep the slot with GAP expected instead of guessing. Body-field validation enums (`TP-<FIELD>-ENUM-*`) are NOT partitions — do not add partition rows for them.",
             "Before returning, verify that every explicit source AC/REQ/BR, error code and strong DTO field token appears in the run-owned plan or an applicable module Case. If a fact cannot be safely automated, retain it as GAP/CONFLICT with its exact source pointer instead of dropping it. Return already-satisfied only when no target file needs an incremental edit.",
             "Read only indexed source paths. Do not scan the repository, modify source/**, generate pytest, execute tests, or emit JSON.",
             ...(sharedSetupPrompt ? [sharedSetupPrompt] : []),
@@ -4776,6 +4776,7 @@ async function buildBackendTestHybridDag(sources) {
     // intentional repair as an out-of-bounds mutation.
     collectionAssess.writePolicy = "exclusive";
     collectionAssess.writeSet = [applyLayout("testcase/**/test_*.py")];
+    collectionAssess.allowedPaths = Array.from(new Set([...ro, ...collectionAssess.writeSet]));
     const repairPytest = {
         id: "repair-backend-pytest-collection-pi",
         depends_on: [collectionAssess.id],
@@ -4814,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，禁止静默覆盖 |