@tea-agent/loop-agent 0.25.5 → 0.26.0

package/dist/workflows/dag/backend-test-case-coverage-analysis.js

@@ -4,10 +4,11 @@ import path from "node:path";
 import { z } from "zod";
 import YAML from "yaml";
 import { backendTestCaseManifestSchema, computeCaseManifestCoverageSummary, } from "./backend-test-case-manifest.js";
-const CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-\d{2,3})\b.*$/gm;
-const CASE_ID_IN_TEXT = /\bBE-[A-Z0-9_-]+-\d{2,3}\b/g;
+const CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-\d{3})\b.*$/gm;
+const CASE_ID_IN_TEXT = /\bBE-[A-Z0-9_-]+-\d{3}\b/g;
+const NON_CANONICAL_CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-(?:\d{2}|\d{2,3}[A-Z]+))\b.*$/gm;
 const AC_ID_IN_TEXT = /\bAC-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g;
-const RULE_KEY = /^(?:AC|REQ|BR|API)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/;
+const RULE_KEY = /^(?:AC|REQ|BR|API|GET|POST|PUT|PATCH|DELETE)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/;
 const TEST_POINT = /^TP-[A-Z0-9]+(?:-[A-Z0-9]+)*$/;
 const COVERAGE_HEADERS = [
     "Rule Key",
@@ -27,6 +28,40 @@ const CASE_SECTION_ALIASES = {
     scenarioTypes: ["场景类型", "Scenario Types", "Scenario Type"],
     automation: ["自动化映射", "自动化说明", "Automation Notes"],
 };
+const TEST_POINT_BINDING_MODES = ["variant", "assertion", "cross-cutting"];
+const CHANGE_CLASSIFICATIONS = [
+    "new-operation",
+    "contract-change",
+    "behavior-change",
+    "bugfix",
+    "implementation-optimization",
+];
+const COVERAGE_POLICIES = [
+    "full-contract",
+    "affected-contract-full",
+    "affected-behavior-full",
+    "reproduction-plus-neighbors",
+    "change-focused-plus-regression-floor",
+];
+const COVERAGE_POLICY_BY_CLASSIFICATION = {
+    "new-operation": "full-contract",
+    "contract-change": "affected-contract-full",
+    "behavior-change": "affected-behavior-full",
+    bugfix: "reproduction-plus-neighbors",
+    "implementation-optimization": "change-focused-plus-regression-floor",
+};
+const REQUIRED_REGRESSION_FLOOR = {
+    "new-operation": [],
+    "contract-change": ["main-success-path", "unchanged-response-shape", "changed-contract-boundaries"],
+    "behavior-change": ["main-success-path", "unchanged-response-shape", "affected-state-transition"],
+    bugfix: ["main-success-path", "unchanged-response-shape", "defect-reproduction", "adjacent-boundary"],
+    "implementation-optimization": ["main-success-path", "unchanged-response-shape"],
+};
+const AUTOMATION_BINDING_LABELS = {
+    variant: ["变体测试点", "Variant Test Points"],
+    assertion: ["场景断言测试点", "Assertion Test Points"],
+    "cross-cutting": ["横切证据测试点", "Cross-Cutting Test Points"],
+};
 const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
 const inputFileSchema = z.object({ path: z.string().min(1), sha256: sha256Schema }).strict();
 const sourceBindingSchema = z.object({
@@ -43,8 +78,15 @@ const coverageCaseSchema = z.object({
     acIds: z.array(z.string()),
     ruleKeys: z.array(z.string()),
     testPoints: z.array(z.string()),
+    testPointBindings: z.array(z.object({
+        testPoint: z.string(),
+        mode: z.enum(TEST_POINT_BINDING_MODES),
+    }).strict()),
+    unclassifiedTestPoints: z.array(z.string()),
+    duplicateBindingTestPoints: z.array(z.string()),
     scenarioTypes: z.array(z.string()),
     declaredScripts: z.array(z.string()),
+    declaredPrimarySymbols: z.array(z.string()),
 }).strict();
 const coverageRuleSchema = z.object({
     ruleKey: z.string().min(1),
@@ -60,13 +102,23 @@ const coverageRuleSchema = z.object({
     missingTestPoints: z.array(z.string()),
     status: z.enum(["COVERED", "PARTIAL", "GAP", "CONFLICT"]),
 }).strict();
+const coverageScopeSchema = z.object({
+    changeClassification: z.enum(CHANGE_CLASSIFICATIONS),
+    coveragePolicy: z.enum(COVERAGE_POLICIES),
+    affectedOperations: z.array(z.string().min(1)),
+    affectedRuleKeys: z.array(z.string().min(1)),
+    regressionFloor: z.array(z.string().min(1)),
+    scopeEvidence: z.array(z.string().min(1)),
+    completenessClaim: z.enum(["affected-operations-full", "affected-scope"]),
+}).strict();
 export const backendTestCaseCoverageFactsSchema = z.object({
-    schemaId: z.literal("backend-test-case-coverage-facts-v1"),
-    schemaVersion: z.literal(1),
+    schemaId: z.literal("backend-test-case-coverage-facts-v3"),
+    schemaVersion: z.literal(3),
     taskId: z.string().min(1),
     status: z.enum(["PASS", "FAIL", "UNAVAILABLE"]),
     sourceBinding: sourceBindingSchema,
     inputFiles: z.array(inputFileSchema),
+    coverageScope: coverageScopeSchema,
     summary: z.object({
         explicitAcCount: z.number().int().min(0),
         coveredAcCount: z.number().int().min(0),
@@ -86,6 +138,11 @@ export const backendTestCaseCoverageFactsSchema = z.object({
         coveredBusinessStateCount: z.number().int().min(0),
         gapCount: z.number().int().min(0),
         conflictCount: z.number().int().min(0),
+        variantTestPointCount: z.number().int().min(0),
+        assertionTestPointCount: z.number().int().min(0),
+        crossCuttingTestPointCount: z.number().int().min(0),
+        unclassifiedTestPointCount: z.number().int().min(0),
+        duplicateBindingTestPointCount: z.number().int().min(0),
     }).strict(),
     cases: z.array(coverageCaseSchema),
     rules: z.array(coverageRuleSchema),
@@ -97,7 +154,12 @@ const correspondenceEntrySchema = z.object({
     markdownModule: z.string().min(1),
     caseId: z.string().optional(),
     testPoints: z.array(z.string()),
+    variantTestPoints: z.array(z.string()),
+    assertionTestPoints: z.array(z.string()),
+    crossCuttingTestPoints: z.array(z.string()),
+    mappedTestPoints: z.array(z.string()),
     declaredScript: z.string().optional(),
+    declaredPrimarySymbol: z.string().optional(),
     expectedScript: z.string().min(1),
     actualScripts: z.array(z.string()),
     pytestSymbols: z.array(z.string()),
@@ -110,14 +172,17 @@ const correspondenceEntrySchema = z.object({
         "EXTRA_PYTEST",
         "SCRIPT_MISMATCH",
         "SYMBOL_MISSING_CASE_ID",
-        "PARAMETER_POINT_MISSING",
-        "PARAMETER_POINT_EXTRA",
+        "VARIANT_PARAMETER_MISSING",
+        "ASSERTION_BINDING_MISSING",
+        "CROSS_CUTTING_EVIDENCE_MISSING",
+        "TEST_POINT_BINDING_DUPLICATE",
+        "TEST_POINT_BINDING_EXTRA",
     ]),
     findings: z.array(z.string()),
 }).strict();
 export const backendTestMarkdownPytestCorrespondenceFactsSchema = z.object({
-    schemaId: z.literal("backend-test-markdown-pytest-correspondence-facts-v1"),
-    schemaVersion: z.literal(1),
+    schemaId: z.literal("backend-test-markdown-pytest-correspondence-facts-v2"),
+    schemaVersion: z.literal(2),
     taskId: z.string().min(1),
     status: z.enum(["PASS", "FAIL", "UNAVAILABLE"]),
     inputFiles: z.array(inputFileSchema),
@@ -126,12 +191,18 @@ export const backendTestMarkdownPytestCorrespondenceFactsSchema = z.object({
         exactModuleCount: z.number().int().min(0),
         markdownCaseCount: z.number().int().min(0),
         exactCorrespondenceCount: z.number().int().min(0),
+        primarySymbolCount: z.number().int().min(0),
         missingPytestCount: z.number().int().min(0),
         multiplePytestCount: z.number().int().min(0),
         extraPytestCount: z.number().int().min(0),
         scriptMismatchCount: z.number().int().min(0),
         testPointCount: z.number().int().min(0),
         mappedTestPointCount: z.number().int().min(0),
+        variantTestPointCount: z.number().int().min(0),
+        assertionTestPointCount: z.number().int().min(0),
+        crossCuttingTestPointCount: z.number().int().min(0),
+        unclassifiedTestPointCount: z.number().int().min(0),
+        duplicateBindingTestPointCount: z.number().int().min(0),
     }).strict(),
     entries: z.array(correspondenceEntrySchema),
     findings: z.array(z.string()),
@@ -165,10 +236,19 @@ function openApiTestPoints(field, dimension, values = []) {
         return [`${prefix}-VALID-CLASS`, `${prefix}-VALID-MIXED`, `${prefix}-UPPERCASE`, `${prefix}-WHITESPACE`, `${prefix}-PUNCTUATION`, `${prefix}-SLASH`, `${prefix}-EMOJI`, `${prefix}-CONTROL`];
     return [`${prefix}-PRESENT`, `${prefix}-MISSING`, `${prefix}-NULL`, `${prefix}-WRONG-TYPE`];
 }
+function resolveBoundSourcePath(workspaceRoot, taskId, sourcePath) {
+    if (path.isAbsolute(sourcePath))
+        return sourcePath;
+    const normalized = sourcePath.replaceAll("\\", "/").replace(/^\.\//, "");
+    const boundPrefix = `.harness/tasks/${taskId}/`;
+    return normalized.startsWith(boundPrefix)
+        ? path.join(workspaceRoot, ...normalized.split("/"))
+        : path.join(workspaceRoot, ".harness", "tasks", taskId, ...normalized.split("/"));
+}
 export async function extractBackendTestOpenApiRules(input) {
     const rules = [];
     for (const referencePath of input.sourceBinding.referencePaths) {
-        const physicalPath = path.join(input.workspaceRoot, ".harness", "tasks", input.sourceBinding.taskId, referencePath);
+        const physicalPath = resolveBoundSourcePath(input.workspaceRoot, input.sourceBinding.taskId, referencePath);
         let document;
         try {
             const parsed = YAML.parse(await readFile(physicalPath, "utf8"));
@@ -287,11 +367,8 @@ function orderedUnique(values) {
     return result;
 }
 function canonicalCaseId(value) {
-    const upper = value.toUpperCase();
-    const match = upper.match(/^(BE-[A-Z0-9_-]+)-(\d{2,3})$/);
-    if (!match)
-        return upper;
-    return `${match[1].replaceAll("_", "-").replace(/-+/g, "-")}-${match[2].padStart(3, "0")}`;
+    const upper = value.toUpperCase().replaceAll("_", "-").replace(/-+/g, "-");
+    return /^(BE-[A-Z0-9]+(?:-[A-Z0-9]+)*)-\d{3}$/.test(upper) ? upper : value.toUpperCase();
 }
 function caseIds(value) {
     return orderedUnique((value.match(CASE_ID_IN_TEXT) ?? []).map(canonicalCaseId));
@@ -323,6 +400,31 @@ function declaredScripts(body) {
     return orderedUnique([...automation.matchAll(/testcase\/[A-Za-z0-9_./-]*test_[A-Za-z0-9_.-]*\.py/gi)]
         .map((match) => match[0].replaceAll("\\", "/")));
 }
+function automationLabelBody(body, labels) {
+    const automation = sectionBody(body, CASE_SECTION_ALIASES.automation);
+    const escaped = labels.map((label) => label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+    const match = new RegExp(`^\\s*[-*+]\\s*(?:${escaped})\\s*[：:]\\s*(.*)$`, "mi").exec(automation);
+    return match?.[1]?.replaceAll("`", "").trim() ?? "";
+}
+function testPointBindingFacts(body, testPoints) {
+    const bindings = TEST_POINT_BINDING_MODES.flatMap((mode) => {
+        const value = automationLabelBody(body, AUTOMATION_BINDING_LABELS[mode]);
+        return orderedUnique(value.match(/\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? [])
+            .map((testPoint) => ({ testPoint, mode }));
+    });
+    const counts = new Map();
+    for (const binding of bindings)
+        counts.set(binding.testPoint, (counts.get(binding.testPoint) ?? 0) + 1);
+    return {
+        testPointBindings: bindings,
+        unclassifiedTestPoints: testPoints.filter((testPoint) => !counts.has(testPoint)),
+        duplicateBindingTestPoints: testPoints.filter((testPoint) => (counts.get(testPoint) ?? 0) > 1),
+    };
+}
+function declaredPrimarySymbols(body) {
+    const value = automationLabelBody(body, ["primary symbol", "Primary Symbol", "主测试符号"]);
+    return orderedUnique(value.match(/\btest_[A-Za-z0-9_]+\b/g) ?? []);
+}
 function cleanTitle(heading, id) {
     return heading.replace(/^##\s+/, "").replace(/^BE-[A-Z0-9_-]+-\d{2,3}\s*(?:[｜|—–-]\s*)?/i, "").trim() || id;
 }
@@ -352,15 +454,18 @@ async function parseMarkdownCases(workspaceRoot) {
             const heading = headings[index];
             const id = canonicalCaseId(heading[1]);
             const body = markdown.slice(heading.index, headings[index + 1]?.index ?? markdown.length);
+            const testPoints = listTokens(body, CASE_SECTION_ALIASES.testPoints, TEST_POINT);
             result.push({
                 caseId: id,
                 title: cleanTitle(heading[0], id),
                 markdownPath: path.relative(workspaceRoot, file).replaceAll(path.sep, "/"),
                 acIds: orderedUnique(body.match(AC_ID_IN_TEXT) ?? []),
                 ruleKeys: listTokens(body, CASE_SECTION_ALIASES.rules, RULE_KEY),
-                testPoints: listTokens(body, CASE_SECTION_ALIASES.testPoints, TEST_POINT),
+                testPoints,
+                ...testPointBindingFacts(body, testPoints),
                 scenarioTypes: scenarioTypes(body),
                 declaredScripts: declaredScripts(body),
+                declaredPrimarySymbols: declaredPrimarySymbols(body),
                 body,
             });
         }
@@ -392,6 +497,89 @@ function splitCellTokens(value, pattern) {
     const values = orderedUnique(value.split(/;|<br\s*\/?\s*>|，|、/i).map((item) => item.replaceAll("`", "").trim()).filter(Boolean));
     return pattern ? values.filter((item) => pattern.test(item)) : values;
 }
+function parseCoverageScope(readme) {
+    const findings = [];
+    const fallback = {
+        changeClassification: "new-operation",
+        coveragePolicy: "full-contract",
+        affectedOperations: [],
+        affectedRuleKeys: [],
+        regressionFloor: [],
+        scopeEvidence: [],
+        completenessClaim: "affected-operations-full",
+    };
+    const marker = /^##\s+Coverage Scope\s*$/mi.exec(readme);
+    if (!marker)
+        return { scope: fallback, findings: ["README is missing required ## Coverage Scope section; defaulted to full-contract"] };
+    const rest = readme.slice(marker.index + marker[0].length);
+    const nextHeading = /^##\s+/m.exec(rest);
+    const section = rest.slice(0, nextHeading?.index ?? rest.length);
+    const lines = section.split(/\r?\n/).filter((line) => line.trim().startsWith("|"));
+    if (lines.length < 2 || JSON.stringify(parseTableRow(lines[0])) !== JSON.stringify(["Field", "Value"])) {
+        return { scope: fallback, findings: ["Coverage Scope table headers must be exactly: Field | Value"] };
+    }
+    const separatorCells = lines[1] ? parseTableRow(lines[1]) : [];
+    const hasSeparator = separatorCells.length === 2 && separatorCells.every((cell) => /^:?-{3,}:?$/.test(cell));
+    if (!hasSeparator)
+        findings.push("Coverage Scope table is missing the required |---|---| separator row");
+    const values = new Map();
+    for (const line of lines.slice(hasSeparator ? 2 : 1)) {
+        const cells = parseTableRow(line);
+        if (cells.length !== 2) {
+            findings.push(`Coverage Scope row must have exactly 2 columns: ${line.slice(0, 160)}`);
+            continue;
+        }
+        const field = cells[0].trim();
+        if (values.has(field))
+            findings.push(`duplicate Coverage Scope field: ${field}`);
+        values.set(field, cells[1].trim());
+    }
+    const classificationRaw = (values.get("Change Classification") ?? "").replaceAll("`", "").trim();
+    const policyRaw = (values.get("Coverage Policy") ?? "").replaceAll("`", "").trim();
+    const changeClassification = CHANGE_CLASSIFICATIONS.includes(classificationRaw)
+        ? classificationRaw
+        : fallback.changeClassification;
+    const coveragePolicy = COVERAGE_POLICIES.includes(policyRaw)
+        ? policyRaw
+        : fallback.coveragePolicy;
+    if (!CHANGE_CLASSIFICATIONS.includes(classificationRaw))
+        findings.push(`invalid or missing Change Classification: ${classificationRaw || "<empty>"}`);
+    if (!COVERAGE_POLICIES.includes(policyRaw))
+        findings.push(`invalid or missing Coverage Policy: ${policyRaw || "<empty>"}`);
+    const expectedPolicy = COVERAGE_POLICY_BY_CLASSIFICATION[changeClassification];
+    if (coveragePolicy !== expectedPolicy)
+        findings.push(`Change Classification ${changeClassification} requires Coverage Policy ${expectedPolicy}, received ${coveragePolicy}`);
+    const affectedOperations = splitCellTokens(values.get("Affected Operations") ?? "").map((value) => value.replace(/\s+/g, " ").trim());
+    const affectedRuleKeys = splitCellTokens(values.get("Affected Rule Keys") ?? "", RULE_KEY);
+    const regressionFloor = splitCellTokens(values.get("Regression Floor") ?? "").map((value) => value.toLowerCase());
+    const scopeEvidence = splitCellTokens(values.get("Scope Evidence") ?? "");
+    if (affectedOperations.length === 0)
+        findings.push("Coverage Scope requires at least one Affected Operations entry");
+    if (affectedRuleKeys.length === 0)
+        findings.push("Coverage Scope requires at least one Affected Rule Keys entry");
+    if (scopeEvidence.length === 0)
+        findings.push("Coverage Scope requires non-empty Scope Evidence");
+    for (const required of REQUIRED_REGRESSION_FLOOR[changeClassification]) {
+        if (!regressionFloor.includes(required))
+            findings.push(`Coverage Scope regression floor is missing required entry: ${required}`);
+    }
+    return {
+        scope: {
+            changeClassification,
+            coveragePolicy,
+            affectedOperations,
+            affectedRuleKeys,
+            regressionFloor,
+            scopeEvidence,
+            completenessClaim: coveragePolicy === "full-contract" ? "affected-operations-full" : "affected-scope",
+        },
+        findings,
+    };
+}
+function operationFromEndpointField(endpointField) {
+    const match = /^([A-Z]+)\s+(\/\S+)/.exec(endpointField.trim());
+    return match ? `${match[1]} ${match[2]}` : undefined;
+}
 function parseCoverageMatrix(readme) {
     const findings = [];
     const marker = /^##\s+(?:(?:\d+(?:\.\d+)*[.)]?\s+)?(?:Coverage Matrix|覆盖矩阵))\s*$/mi.exec(readme);
@@ -452,9 +640,17 @@ export async function analyzeBackendTestCaseCoverage(input) {
     const findings = [];
     const readmePath = path.join(input.workspaceRoot, "testcase", "md", "README.md");
     const readme = (await exists(readmePath)) ? await readFile(readmePath, "utf8") : "";
+    const coverageScope = parseCoverageScope(readme);
+    findings.push(...coverageScope.findings);
     const matrix = parseCoverageMatrix(readme);
     findings.push(...matrix.findings);
     const cases = await parseMarkdownCases(input.workspaceRoot);
+    for (const file of await markdownModuleFiles(input.workspaceRoot)) {
+        const markdown = await readFile(file, "utf8");
+        for (const match of markdown.matchAll(NON_CANONICAL_CASE_HEADING)) {
+            findings.push(`non-canonical Case ID heading must use BE-<MODULE>-<NNN>: ${match[1]}`);
+        }
+    }
     const caseById = new Map(cases.map((item) => [item.caseId, item]));
     const rules = [];
     const evidenceGaps = [];
@@ -518,10 +714,19 @@ export async function analyzeBackendTestCaseCoverage(input) {
         });
     }
     const extractedOpenApiRules = await extractBackendTestOpenApiRules(input);
-    for (const extracted of extractedOpenApiRules) {
+    const knownOperations = orderedUnique(extractedOpenApiRules.map((rule) => operationFromEndpointField(rule.endpointField)).filter((value) => Boolean(value)));
+    for (const affectedOperation of coverageScope.scope.affectedOperations) {
+        if (knownOperations.length > 0 && !knownOperations.includes(affectedOperation))
+            findings.push(`Coverage Scope Affected Operation is absent from bound OpenAPI evidence: ${affectedOperation}`);
+    }
+    const requiredOpenApiRules = extractedOpenApiRules.filter((rule) => {
+        const operation = operationFromEndpointField(rule.endpointField);
+        return Boolean(operation && coverageScope.scope.affectedOperations.includes(operation));
+    });
+    for (const extracted of requiredOpenApiRules) {
         if (seenRules.has(extracted.ruleKey))
             continue;
-        findings.push(`Coverage Matrix is missing documented OpenAPI rule: ${extracted.ruleKey} (${extracted.source})`);
+        findings.push(`Coverage Matrix is missing documented in-scope OpenAPI rule: ${extracted.ruleKey} (${extracted.source})`);
         seenRules.add(extracted.ruleKey);
         rules.push({
             ...extracted,
@@ -532,6 +737,11 @@ export async function analyzeBackendTestCaseCoverage(input) {
             status: "PARTIAL",
         });
     }
+    for (const affectedRuleKey of coverageScope.scope.affectedRuleKeys) {
+        if (!seenRules.has(affectedRuleKey))
+            findings.push(`Coverage Scope Affected Rule Key is absent from Coverage Matrix: ${affectedRuleKey}`);
+    }
+    const nonCrossCuttingOwners = new Map();
     for (const testCase of cases) {
         if (testCase.ruleKeys.length === 0)
             findings.push(`${testCase.caseId} missing section or entries: 覆盖规则`);
@@ -539,10 +749,29 @@ export async function analyzeBackendTestCaseCoverage(input) {
             findings.push(`${testCase.caseId} missing section or entries: 测试点`);
         if (testCase.scenarioTypes.length === 0)
             findings.push(`${testCase.caseId} missing section or entries: 场景类型`);
+        if (testCase.declaredPrimarySymbols.length !== 1)
+            findings.push(`${testCase.caseId} must declare exactly one primary symbol`);
+        if (testCase.unclassifiedTestPoints.length > 0)
+            findings.push(`${testCase.caseId} has unclassified Test Points: ${testCase.unclassifiedTestPoints.join(", ")}`);
+        if (testCase.duplicateBindingTestPoints.length > 0)
+            findings.push(`${testCase.caseId} has duplicate Test Point bindings: ${testCase.duplicateBindingTestPoints.join(", ")}`);
+        const extraBindings = testCase.testPointBindings.filter((binding) => !testCase.testPoints.includes(binding.testPoint));
+        if (extraBindings.length > 0)
+            findings.push(`${testCase.caseId} binds undeclared Test Points: ${orderedUnique(extraBindings.map((binding) => binding.testPoint)).join(", ")}`);
+        for (const binding of testCase.testPointBindings.filter((item) => item.mode !== "cross-cutting")) {
+            const owners = nonCrossCuttingOwners.get(binding.testPoint) ?? [];
+            owners.push(testCase.caseId);
+            nonCrossCuttingOwners.set(binding.testPoint, owners);
+        }
         for (const ruleKey of testCase.ruleKeys)
             if (!seenRules.has(ruleKey))
                 findings.push(`${testCase.caseId} references unknown Rule Key: ${ruleKey}`);
     }
+    for (const [testPoint, owners] of nonCrossCuttingOwners) {
+        const uniqueOwners = orderedUnique(owners);
+        if (uniqueOwners.length > 1)
+            findings.push(`${testPoint} is bound as a non-cross-cutting Test Point by multiple Cases: ${uniqueOwners.join(", ")}`);
+    }
     const explicitAc = input.sourceBinding.requirementIds.filter((id) => id.startsWith("AC-"));
     const coveredAc = new Set(cases.flatMap((item) => item.acIds));
     const [enumValueCount, coveredEnumValueCount] = dimensionCounts(rules, /enum/);
@@ -553,8 +782,8 @@ export async function analyzeBackendTestCaseCoverage(input) {
     const invalidEquivalenceClassCount = rules.reduce((sum, rule) => sum + rule.requiredTestPoints.filter((point) => invalidPointPattern.test(point)).length, 0);
     const coveredInvalidEquivalenceClassCount = rules.reduce((sum, rule) => sum + rule.coveredTestPoints.filter((point) => invalidPointPattern.test(point)).length, 0);
     const facts = backendTestCaseCoverageFactsSchema.parse({
-        schemaId: "backend-test-case-coverage-facts-v1",
-        schemaVersion: 1,
+        schemaId: "backend-test-case-coverage-facts-v3",
+        schemaVersion: 3,
         taskId: input.sourceBinding.taskId,
         status: findings.length === 0 ? "PASS" : "FAIL",
         sourceBinding: input.sourceBinding,
@@ -562,10 +791,11 @@ export async function analyzeBackendTestCaseCoverage(input) {
             ...((await exists(readmePath)) ? [readmePath] : []),
             ...(await markdownModuleFiles(input.workspaceRoot)),
             ...(await Promise.all(input.sourceBinding.referencePaths.map(async (referencePath) => {
-                const physicalPath = path.join(input.workspaceRoot, ".harness", "tasks", input.sourceBinding.taskId, referencePath);
+                const physicalPath = resolveBoundSourcePath(input.workspaceRoot, input.sourceBinding.taskId, referencePath);
                 return (await exists(physicalPath)) ? physicalPath : "";
             }))).filter(Boolean),
         ]),
+        coverageScope: coverageScope.scope,
         summary: {
             explicitAcCount: explicitAc.length,
             coveredAcCount: explicitAc.filter((id) => coveredAc.has(id)).length,
@@ -585,6 +815,11 @@ export async function analyzeBackendTestCaseCoverage(input) {
             coveredBusinessStateCount,
             gapCount: evidenceGaps.length,
             conflictCount: conflicts.length,
+            variantTestPointCount: cases.reduce((sum, item) => sum + item.testPointBindings.filter((binding) => binding.mode === "variant").length, 0),
+            assertionTestPointCount: cases.reduce((sum, item) => sum + item.testPointBindings.filter((binding) => binding.mode === "assertion").length, 0),
+            crossCuttingTestPointCount: cases.reduce((sum, item) => sum + item.testPointBindings.filter((binding) => binding.mode === "cross-cutting").length, 0),
+            unclassifiedTestPointCount: cases.reduce((sum, item) => sum + item.unclassifiedTestPoints.length, 0),
+            duplicateBindingTestPointCount: cases.reduce((sum, item) => sum + item.duplicateBindingTestPoints.length, 0),
         },
         cases: cases.map(({ body: _body, ...item }) => item),
         rules,
@@ -600,6 +835,17 @@ export async function analyzeBackendTestCaseCoverage(input) {
         "",
         facts.status,
         "",
+        "## Coverage Scope",
+        "",
+        `- Change Classification: ${facts.coverageScope.changeClassification}`,
+        `- Coverage Policy: ${facts.coverageScope.coveragePolicy}`,
+        `- Completeness Claim: ${facts.coverageScope.completenessClaim}`,
+        `- Affected Operations: ${facts.coverageScope.affectedOperations.join(", ") || "Unavailable"}`,
+        `- Affected Rule Keys: ${facts.coverageScope.affectedRuleKeys.join(", ") || "Unavailable"}`,
+        `- Regression Floor: ${facts.coverageScope.regressionFloor.join(", ") || "Unavailable"}`,
+        `- Scope Evidence: ${facts.coverageScope.scopeEvidence.join(", ") || "Unavailable"}`,
+        ...(facts.coverageScope.completenessClaim === "affected-scope" ? ["- Coverage is scoped to affected operations; it is not whole-API completeness."] : ["- Coverage fully evaluates the declared affected operations; it is not whole-API completeness unless every operation is explicitly listed."]),
+        "",
         "## Coverage Summary",
         "",
         "| Dimension | Total | Covered |",
@@ -611,6 +857,11 @@ export async function analyzeBackendTestCaseCoverage(input) {
         `| Boundary | ${summary.boundaryPointCount} | ${summary.coveredBoundaryPointCount} |`,
         `| Format | ${summary.formatClassCount} | ${summary.coveredFormatClassCount} |`,
         `| Business State | ${summary.businessStateCount} | ${summary.coveredBusinessStateCount} |`,
+        `| Variant bindings | ${summary.variantTestPointCount} | ${summary.variantTestPointCount} |`,
+        `| Assertion bindings | ${summary.assertionTestPointCount} | ${summary.assertionTestPointCount} |`,
+        `| Cross-cutting bindings | ${summary.crossCuttingTestPointCount} | ${summary.crossCuttingTestPointCount} |`,
+        `| Unclassified bindings | ${summary.unclassifiedTestPointCount} | 0 |`,
+        `| Duplicate bindings | ${summary.duplicateBindingTestPointCount} | 0 |`,
         "",
         "## Product Requirement Coverage",
         "",
@@ -658,6 +909,11 @@ function symbolCaseId(symbol) {
     const match = symbol.match(/^test_(BE(?:_[A-Z0-9]+)+?_\d{2,3})(?:_|$)/i);
     return match ? canonicalCaseId(match[1].replaceAll("_", "-")) : undefined;
 }
+function metadataTestPoints(region, label) {
+    const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = new RegExp(`^\\s*${escaped}\\s*:\\s*(.*)$`, "mi").exec(region);
+    return orderedUnique(match?.[1]?.match(/\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? []);
+}
 function pytestFunctionRegionStart(source, functionIndex) {
     let regionStart = source.lastIndexOf("\n", functionIndex - 1) + 1;
     let cursor = regionStart;
@@ -672,24 +928,40 @@ function pytestFunctionRegionStart(source, functionIndex) {
     }
     return regionStart;
 }
+function pytestParameterCollections(source) {
+    const collections = new Map();
+    for (const match of source.matchAll(/^([A-Z][A-Z0-9_]*)\s*=\s*\[([\s\S]*?)^\]/gm)) {
+        collections.set(match[1], orderedUnique([...match[2].matchAll(/\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1])));
+    }
+    return collections;
+}
 function pytestSymbols(script, source) {
     const matches = [...source.matchAll(/^([ \t]*)(?:async\s+)?def\s+(test_[A-Za-z0-9_]+)\s*\([^)]*\)\s*(?:->\s*[^:\r\n]+)?\s*:/gm)];
     const regionStarts = matches.map((match) => pytestFunctionRegionStart(source, match.index));
+    const parameterCollections = pytestParameterCollections(source);
     return matches.map((match, index) => {
         const regionStart = regionStarts[index];
         const regionEnd = regionStarts[index + 1] ?? source.length;
-        const region = source.slice(regionStart, regionEnd);
+        const region = source.slice(match.index, regionEnd);
+        const decorators = source.slice(regionStart, match.index);
         const ids = caseIds(region);
         const fromSymbol = symbolCaseId(match[2]);
         if (fromSymbol)
             ids.unshift(fromSymbol);
-        const parameterIds = orderedUnique([...region.matchAll(/\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1]));
+        const parameterIds = orderedUnique([
+            ...[...decorators.matchAll(/\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1]),
+            ...[...parameterCollections.entries()].flatMap(([name, values]) => new RegExp(`\\b${name}\\b`).test(decorators) ? values : []),
+        ]);
+        const assertionTestPoints = metadataTestPoints(region, "Assertion-Test-Points");
+        const crossCuttingTestPoints = metadataTestPoints(region, "Cross-Cutting-Test-Points");
         return {
             script,
             symbol: match[2],
             caseIds: orderedUnique(ids),
-            testPoints: orderedUnique(region.match(/\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? []),
+            testPoints: orderedUnique([...parameterIds, ...assertionTestPoints, ...crossCuttingTestPoints]),
             parameterIds,
+            assertionTestPoints,
+            crossCuttingTestPoints,
         };
     });
 }
@@ -715,41 +987,69 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
         const actualScripts = orderedUnique(refs.map((item) => item.script));
         const symbols = orderedUnique(refs.map((item) => item.symbol));
         const parameterIds = orderedUnique(refs.flatMap((item) => item.parameterIds));
-        const observedPoints = orderedUnique(refs.flatMap((item) => item.testPoints));
-        let cardinality = refs.length === 0 ? "1:0" : refs.length === 1 ? "1:1" : "1:N";
+        const assertionBindings = orderedUnique(refs.flatMap((item) => item.assertionTestPoints));
+        const crossCuttingBindings = orderedUnique(refs.flatMap((item) => item.crossCuttingTestPoints));
+        const variantTestPoints = testCase.testPointBindings.filter((item) => item.mode === "variant").map((item) => item.testPoint);
+        const assertionTestPoints = testCase.testPointBindings.filter((item) => item.mode === "assertion").map((item) => item.testPoint);
+        const crossCuttingTestPoints = testCase.testPointBindings.filter((item) => item.mode === "cross-cutting").map((item) => item.testPoint);
+        const mappedTestPoints = orderedUnique([
+            ...variantTestPoints.filter((point) => parameterIds.includes(point)),
+            ...assertionTestPoints.filter((point) => assertionBindings.includes(point)),
+            ...crossCuttingTestPoints.filter((point) => crossCuttingBindings.includes(point)),
+        ]);
+        const declaredPrimarySymbol = testCase.declaredPrimarySymbols[0];
+        const cardinality = refs.length === 0 ? "1:0" : refs.length === 1 ? "1:1" : "1:N";
         let status = refs.length === 0 ? "MISSING_PYTEST" : refs.length > 1 ? "MULTIPLE_PYTEST" : "EXACT_1_TO_1";
         const entryFindings = [];
         if (refs.length === 0)
             entryFindings.push(`${testCase.caseId} has no pytest symbol`);
         if (refs.length > 1)
             entryFindings.push(`${testCase.caseId} maps to multiple pytest symbols: ${symbols.join(", ")}`);
-        if (!declared || declared !== expected || actualScripts.some((script) => script !== expected)) {
+        if (!declared || declared !== expected || actualScripts.some((script) => script !== expected) || !declaredPrimarySymbol || symbols.some((symbol) => symbol !== declaredPrimarySymbol)) {
             if (refs.length > 0 && status === "EXACT_1_TO_1")
                 status = "SCRIPT_MISMATCH";
-            entryFindings.push(`${testCase.caseId} script mapping mismatch: declared=${declared ?? "none"}, expected=${expected}, actual=${actualScripts.join(", ") || "none"}`);
+            entryFindings.push(`${testCase.caseId} script/primary-symbol mapping mismatch: declaredScript=${declared ?? "none"}, expectedScript=${expected}, actual=${actualScripts.join(", ") || "none"}, declaredPrimarySymbol=${declaredPrimarySymbol ?? "none"}, actualSymbols=${symbols.join(", ") || "none"}`);
         }
-        const missingPoints = testCase.testPoints.filter((point) => {
-            if (testCase.testPoints.length > 1)
-                return !parameterIds.includes(point);
-            return !observedPoints.includes(point) && !parameterIds.includes(point);
-        });
-        const extraPoints = parameterIds.filter((point) => !testCase.testPoints.includes(point));
-        if (missingPoints.length > 0) {
+        const missingVariant = variantTestPoints.filter((point) => !parameterIds.includes(point));
+        const missingAssertion = assertionTestPoints.filter((point) => !assertionBindings.includes(point));
+        const missingCrossCutting = crossCuttingTestPoints.filter((point) => !crossCuttingBindings.includes(point));
+        const extraPoints = orderedUnique([...parameterIds, ...assertionBindings, ...crossCuttingBindings]).filter((point) => !testCase.testPoints.includes(point));
+        if (testCase.unclassifiedTestPoints.length > 0 || testCase.duplicateBindingTestPoints.length > 0) {
             if (refs.length > 0 && status === "EXACT_1_TO_1")
-                status = "PARAMETER_POINT_MISSING";
-            entryFindings.push(`${testCase.caseId} missing pytest Test Point IDs: ${missingPoints.join(", ")}`);
+                status = "TEST_POINT_BINDING_DUPLICATE";
+            entryFindings.push(`${testCase.caseId} invalid Markdown Test Point bindings: unclassified=${testCase.unclassifiedTestPoints.join(", ") || "none"}; duplicate=${testCase.duplicateBindingTestPoints.join(", ") || "none"}`);
+        }
+        if (missingVariant.length > 0) {
+            if (refs.length > 0 && status === "EXACT_1_TO_1")
+                status = "VARIANT_PARAMETER_MISSING";
+            entryFindings.push(`${testCase.caseId} missing variant pytest parameter IDs: ${missingVariant.join(", ")}`);
+        }
+        if (missingAssertion.length > 0) {
+            if (refs.length > 0 && status === "EXACT_1_TO_1")
+                status = "ASSERTION_BINDING_MISSING";
+            entryFindings.push(`${testCase.caseId} missing assertion docstring bindings: ${missingAssertion.join(", ")}`);
+        }
+        if (missingCrossCutting.length > 0) {
+            if (refs.length > 0 && status === "EXACT_1_TO_1")
+                status = "CROSS_CUTTING_EVIDENCE_MISSING";
+            entryFindings.push(`${testCase.caseId} missing cross-cutting evidence bindings: ${missingCrossCutting.join(", ")}`);
         }
         if (extraPoints.length > 0) {
             if (refs.length > 0 && status === "EXACT_1_TO_1")
-                status = "PARAMETER_POINT_EXTRA";
-            entryFindings.push(`${testCase.caseId} has extra pytest parameter IDs: ${extraPoints.join(", ")}`);
+                status = "TEST_POINT_BINDING_EXTRA";
+            entryFindings.push(`${testCase.caseId} has extra pytest Test Point bindings: ${extraPoints.join(", ")}`);
         }
         findings.push(...entryFindings);
         entries.push({
             markdownModule: testCase.markdownPath,
             caseId: testCase.caseId,
             testPoints: testCase.testPoints,
+            variantTestPoints,
+            assertionTestPoints,
+            crossCuttingTestPoints,
+            mappedTestPoints,
             ...(declared ? { declaredScript: declared } : {}),
+            ...(declaredPrimarySymbol ? { declaredPrimarySymbol } : {}),
             expectedScript: expected,
             actualScripts,
             pytestSymbols: symbols,
@@ -772,6 +1072,10 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
             markdownModule: "—",
             ...(unknownId ? { caseId: unknownId } : {}),
             testPoints: symbol.testPoints,
+            variantTestPoints: [],
+            assertionTestPoints: [],
+            crossCuttingTestPoints: [],
+            mappedTestPoints: [],
             expectedScript: symbol.script,
             actualScripts: [symbol.script],
             pytestSymbols: [symbol.symbol],
@@ -788,8 +1092,8 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     }).length;
     const caseEntries = entries.filter((entry) => entry.cardinality !== "0:1");
     const facts = backendTestMarkdownPytestCorrespondenceFactsSchema.parse({
-        schemaId: "backend-test-markdown-pytest-correspondence-facts-v1",
-        schemaVersion: 1,
+        schemaId: "backend-test-markdown-pytest-correspondence-facts-v2",
+        schemaVersion: 2,
         taskId: input.taskId,
         status: findings.length === 0 ? "PASS" : "FAIL",
         inputFiles: await inputFileFacts(input.workspaceRoot, [
@@ -802,12 +1106,18 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
             exactModuleCount,
             markdownCaseCount: cases.length,
             exactCorrespondenceCount: caseEntries.filter((entry) => entry.status === "EXACT_1_TO_1").length,
+            primarySymbolCount: orderedUnique(caseEntries.flatMap((entry) => entry.pytestSymbols)).length,
             missingPytestCount: caseEntries.filter((entry) => entry.status === "MISSING_PYTEST").length,
             multiplePytestCount: caseEntries.filter((entry) => entry.status === "MULTIPLE_PYTEST").length,
             extraPytestCount: entries.filter((entry) => entry.cardinality === "0:1").length,
             scriptMismatchCount: caseEntries.filter((entry) => entry.status === "SCRIPT_MISMATCH").length,
             testPointCount: cases.reduce((sum, item) => sum + item.testPoints.length, 0),
-            mappedTestPointCount: caseEntries.reduce((sum, entry) => sum + entry.testPoints.filter((point) => entry.parameterIds.includes(point) || (entry.testPoints.length === 1 && entry.status === "EXACT_1_TO_1")).length, 0),
+            mappedTestPointCount: caseEntries.reduce((sum, entry) => sum + entry.mappedTestPoints.length, 0),
+            variantTestPointCount: cases.reduce((sum, item) => sum + item.testPointBindings.filter((binding) => binding.mode === "variant").length, 0),
+            assertionTestPointCount: cases.reduce((sum, item) => sum + item.testPointBindings.filter((binding) => binding.mode === "assertion").length, 0),
+            crossCuttingTestPointCount: cases.reduce((sum, item) => sum + item.testPointBindings.filter((binding) => binding.mode === "cross-cutting").length, 0),
+            unclassifiedTestPointCount: cases.reduce((sum, item) => sum + item.unclassifiedTestPoints.length, 0),
+            duplicateBindingTestPointCount: cases.reduce((sum, item) => sum + item.duplicateBindingTestPoints.length, 0),
         },
         entries,
         findings: orderedUnique(findings),
@@ -825,16 +1135,22 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
         `- Exact module mappings: ${facts.summary.exactModuleCount}`,
         `- Markdown Cases: ${facts.summary.markdownCaseCount}`,
         `- Exact 1:1: ${facts.summary.exactCorrespondenceCount}`,
+        `- Primary pytest symbols: ${facts.summary.primarySymbolCount}`,
         `- Missing pytest: ${facts.summary.missingPytestCount}`,
         `- Multiple pytest: ${facts.summary.multiplePytestCount}`,
         `- Extra pytest: ${facts.summary.extraPytestCount}`,
         `- Test Points: ${facts.summary.mappedTestPointCount}/${facts.summary.testPointCount}`,
+        `- Variant Test Points: ${facts.summary.variantTestPointCount}`,
+        `- Assertion Test Points: ${facts.summary.assertionTestPointCount}`,
+        `- Cross-Cutting Test Points: ${facts.summary.crossCuttingTestPointCount}`,
+        `- Unclassified Test Points: ${facts.summary.unclassifiedTestPointCount}`,
+        `- Duplicate Test Point Bindings: ${facts.summary.duplicateBindingTestPointCount}`,
         "",
         "## Correspondence Matrix",
         "",
-        "| Markdown Module | Case ID | Test Points | Declared Script | Expected Script | Actual Script | Pytest Symbol | Parameter IDs | Cardinality | Status |",
-        "|---|---|---|---|---|---|---|---|---|---|",
-        ...facts.entries.map((entry) => `| ${entry.markdownModule} | ${entry.caseId ?? "—"} | ${entry.testPoints.join(", ") || "—"} | ${entry.declaredScript ?? "—"} | ${entry.expectedScript} | ${entry.actualScripts.join(", ") || "—"} | ${entry.pytestSymbols.join(", ") || "—"} | ${entry.parameterIds.join(", ") || "—"} | ${entry.cardinality} | ${entry.status} |`),
+        "| Markdown Module | Case ID | Variant | Assertion | Cross-Cutting | Mapped | Declared Script | Primary Symbol | Actual Script | Pytest Symbol | Parameter IDs | Cardinality | Status |",
+        "|---|---|---|---|---|---|---|---|---|---|---|---|---|",
+        ...facts.entries.map((entry) => `| ${entry.markdownModule} | ${entry.caseId ?? "—"} | ${entry.variantTestPoints.join(", ") || "—"} | ${entry.assertionTestPoints.join(", ") || "—"} | ${entry.crossCuttingTestPoints.join(", ") || "—"} | ${entry.mappedTestPoints.join(", ") || "—"} | ${entry.declaredScript ?? "—"} | ${entry.declaredPrimarySymbol ?? "—"} | ${entry.actualScripts.join(", ") || "—"} | ${entry.pytestSymbols.join(", ") || "—"} | ${entry.parameterIds.join(", ") || "—"} | ${entry.cardinality} | ${entry.status} |`),
         "",
         "## Findings",
         "",
@@ -928,6 +1244,7 @@ export async function materializeBackendTestCaseManifestFromFacts(input) {
         ...base,
         materializationStatus,
         sourceFactsIssues,
+        coverageScope: coverageResult.value?.coverageScope,
         ruleCoverageSummary: coverageResult.value?.summary,
         correspondenceSummary: correspondenceResult.value?.summary,
         artifactRefs: {