@tea-agent/loop-agent 0.40.0-next.1 → 0.40.0-next.3

package/dist/worker/observe/static/views/dag.d.ts

@@ -0,0 +1,13 @@
+export interface DagNodeRemark {
+	failed: boolean;
+	text: string;
+	isErrorSummary: boolean;
+}
+
+export function resolveNodeRemark(node: {
+	status?: string | null;
+	errorPreview?: string | null;
+	label?: string | null;
+	nodeId: string;
+	rank?: string | number | null;
+} | null | undefined): DagNodeRemark;

package/dist/worker/observe/static/views/dag.js

@@ -70,6 +70,7 @@ import {
 	dashboardVisibleFeatures,
 	findDagForRun,
 } from "../dag-model.js";
+import { describeDagNodePurpose } from "../dag-node-purpose.js";
 import { layoutDag } from "../dag-layout.js";
 import {
 	showView,
@@ -136,7 +137,7 @@ export function extractFirstErrorSummary(errorPreview) {
 	return effective ?? "";
 }
 
-/** Resolve 备注 cell content for a DAG node (failed → summary; else label). */
+/** Resolve 备注 cell content for a DAG node (failed → summary; else purpose). */
 export function resolveNodeRemark(node) {
 	const failed = isNodeFailed(node?.status);
 	if (failed) {
@@ -147,10 +148,10 @@ export function resolveNodeRemark(node) {
 			isErrorSummary: Boolean(summary),
 		};
 	}
-	const label = typeof node?.label === "string" ? node.label.trim() : "";
+	const purpose = describeDagNodePurpose(node?.nodeId, node);
 	return {
 		failed: false,
-		text: label || "—",
+		text: purpose || "—",
 		isErrorSummary: false,
 	};
 }

package/dist/worker/observe/static/views/task.js

@@ -34,6 +34,7 @@ import {
 	repoBaseName,
 	parseMarkdownBlocks,
 	markdownLinkHref,
+	formatLedgerSummary,
 } from "../format.js";
 import { parseRoute, navigate, buildHashPath } from "../router.js";
 import {
@@ -94,6 +95,7 @@ export async function renderTaskDetail(featureId, taskId) {
 	const linksEl = document.getElementById("task-links");
 	const evidenceEl = document.getElementById("task-evidence");
 	const runsEl = document.getElementById("task-runs");
+	const ledgerEl = document.getElementById("task-ledger");
 	if (!metaEl || !linksEl || !evidenceEl || !runsEl) return false;
 	if (titleEl) titleEl.textContent = displayLabel;
 	mountViewState(metaEl, "loading", "加载 Task…");
@@ -252,9 +254,62 @@ export async function renderTaskDetail(featureId, taskId) {
 	const active = ["running", "pending", "blocked", "stale"].includes(
 		(task.status ?? "").toLowerCase(),
 	);
+	if (ledgerEl) {
+		void renderTaskLedger(ledgerEl, taskId);
+	}
 	return active;
 }
 
+/**
+ * Task 详情页 ledger 安全摘要（AC-009）：从只读 GET /api/tasks/:id/ledger 拉取，
+ * 计数/状态/failure code + 有界排除理由；无 ledger 显示空态，失败安全降级。
+ */
+async function renderTaskLedger(ledgerEl, taskId) {
+	clearNode(ledgerEl);
+	ledgerEl.appendChild(el("h3", "section-heading", "Source fidelity ledger"));
+	mountViewState(ledgerEl, "loading", "加载 ledger…");
+	let body = null;
+	try {
+		body = await fetchJson(`/api/tasks/${encodeURIComponent(taskId)}/ledger`);
+	} catch {
+		body = null;
+	}
+	if (!body) {
+		mountViewState(ledgerEl, "error", "ledger 只读接口失败（安全降级）。");
+		return;
+	}
+	if (body.present !== true) {
+		mountViewState(
+			ledgerEl,
+			body.error ? "error" : "empty",
+			body.error
+				? `ledger 不可用（${body.error}）。`
+				: "无 source fidelity ledger（任务无引用或 ledger 缺失，不伪造计数）。",
+		);
+		return;
+	}
+	const pre = el(
+		"pre",
+		"cmd",
+		formatLedgerSummary({
+			present: true,
+			fragmentCount: body.fragmentCount,
+			canonicalRequirementCount: body.canonicalRequirementCount,
+			contextOnlyCount: body.contextOnlyCount,
+			duplicateCount: body.duplicateCount,
+			unresolvedCount: body.unresolvedCount,
+			conflictCount: body.conflictCount,
+			gateStatus: body.gateStatus,
+			failureCode: body.failureCode,
+			exclusions: body.exclusions ?? [],
+		}),
+	);
+	pre.dataset.testid = "task-ledger-summary";
+	clearNode(ledgerEl);
+	ledgerEl.appendChild(el("h3", "section-heading", "Source fidelity ledger"));
+	ledgerEl.appendChild(pre);
+}
+
 export async function loadOlderTaskRuns(featureId, taskId, before, runsEl) {
 	if (runsEl === undefined) {
 		runsEl = before;

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

@@ -5,6 +5,7 @@ import path from "node:path";
 import { z } from "zod";
 import YAML from "yaml";
 import { resolveBackendTestLayout, } from "./backend-test-layout.js";
+import { resolveBackendTestManifestModules, backendManifestStatusFinding } from "./backend-test-markdown-workflow.js";
 import { applyOpenApiPartitionDomainPolicy, assessScenarioPartitionCoverage, parseScenarioPartitions, } from "./backend-test-scenario-partitions.js";
 import { backendTestCaseManifestSchema, computeCaseManifestCoverageSummary, } from "./backend-test-case-manifest.js";
 const CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-\d{3})\b.*$/gm;
@@ -659,10 +660,18 @@ async function markdownModuleFiles(workspaceRoot, layout) {
     const resolved = layout ?? resolveBackendTestLayout(undefined);
     const dir = path.join(workspaceRoot, ...resolved.markdownDir.split("/"));
     const entries = await readdir(dir, { withFileTypes: true });
-    return entries
+    const all = entries
         .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md") && entry.name.toLowerCase() !== "readme.md")
         .map((entry) => path.join(dir, entry.name))
         .sort();
+    // Current-round Markdown scope is the README Module Index manifest: unmanifested
+    // legacy .md files must not enter Case/coverage/partition statistics. Workspaces
+    // without a Module Index fall back to the whole directory (prior behaviour).
+    const manifest = await resolveBackendTestManifestModules(workspaceRoot, resolved);
+    if (manifest.manifestStatus !== "valid")
+        return [];
+    const declaredAbs = new Set(manifest.declaredMdFiles.map((rel) => path.join(workspaceRoot, ...rel.split("/")).toLowerCase()));
+    return all.filter((file) => declaredAbs.has(file.toLowerCase())).sort();
 }
 async function parseMarkdownCases(workspaceRoot, layout) {
     const result = [];
@@ -874,6 +883,16 @@ export async function analyzeBackendTestCaseCoverage(input) {
     findings.push(...coverageScope.findings);
     const matrix = parseCoverageMatrix(readme);
     findings.push(...matrix.findings);
+    const manifest = await resolveBackendTestManifestModules(input.workspaceRoot, layout);
+    // Fail closed on README Module Index entries declared but never materialized.
+    if (manifest.declaredMissing.length > 0) {
+        findings.push(`declared Markdown module is missing (Module Index): ${manifest.declaredMissing.join(", ")}`);
+    }
+    // Fail closed on every non-valid Module Index state: without a valid unique
+    // Module Index the current round must not re-scan historical `.md` files.
+    if (manifest.manifestStatus !== "valid") {
+        findings.push(backendManifestStatusFinding(manifest.manifestStatus, manifest.moduleIndexHeadingCount));
+    }
     const cases = await parseMarkdownCases(input.workspaceRoot, layout);
     for (const file of await markdownModuleFiles(input.workspaceRoot, layout)) {
         const markdown = await readFile(file, "utf8");
@@ -1109,6 +1128,15 @@ export async function analyzeBackendTestCaseCoverage(input) {
         "",
         facts.status,
         "",
+        `- Manifest scope: ${manifest.manifestStatus === "valid" ? "declared-modules" : `fails-closed:${manifest.manifestStatus}`} (declared-missing=${manifest.declaredMissing.length}, unmanifested-advisory=${manifest.unmanifested.length}, module-index-heading-count=${manifest.moduleIndexHeadingCount})`,
+        "",
+        "## Unmanifested Markdown Modules",
+        "",
+        "- Advisory: existing .md files not declared by the README Module Index are excluded from Case/coverage/partition statistics for this round.",
+        ...(manifest.unmanifested.length > 0
+            ? manifest.unmanifested.map((item) => `- ${item}`)
+            : ["- None"]),
+        "",
         "## Coverage Scope",
         "",
         `- Change Classification: ${facts.coverageScope.changeClassification}`,

package/dist/workflows/dag/backend-test-markdown-workflow.js

@@ -200,14 +200,170 @@ export async function inspectBackendTestEnvironment(input) {
         serverEntries,
     };
 }
+/**
+ * Filenames declared by the canonical `## Module Index` section of the backend
+ * README. Only a unique exact `## Module Index` heading is authoritative; a
+ * missing/duplicate section yields an empty declaration set (callers then fall
+ * back to the whole directory so legacy workspaces without a manifest keep
+ * their prior behaviour). Reads `[x](./x.md)`, `` `testcase/md/<x>.md` `` and
+ * inline `x.md` tokens inside the section; README.md itself is never a module.
+ */
+export function extractDeclaredModuleIndexFilenames(readme) {
+    const lines = readme
+        .replaceAll("\r\n", "\n")
+        .replaceAll("\r", "\n")
+        .split("\n");
+    const headings = lines.flatMap((line, index) => line.trim() === "## Module Index" ? [index] : []);
+    if (headings.length !== 1)
+        return [];
+    const start = headings[0] + 1;
+    const relativeEnd = lines
+        .slice(start)
+        .findIndex((line) => /^##\s+\S/.test(line.trim()));
+    const end = relativeEnd < 0 ? lines.length : start + relativeEnd;
+    const section = lines.slice(start, end).join("\n");
+    return unique([...section.matchAll(/`?[A-Za-z0-9_.-]+\.md`?/g)]
+        .map((match) => match[0].replaceAll("`", ""))
+        .filter((name) => name.toLowerCase() !== "readme.md"));
+}
+/**
+ * Count exact `## Module Index` headings in the backend README.
+ */
+function moduleIndexHeadingCountIn(readme) {
+    return readme
+        .replaceAll("\r\n", "\n")
+        .replaceAll("\r", "\n")
+        .split("\n")
+        .filter((line) => line.trim() === "## Module Index").length;
+}
+/**
+ * Machine-readable fail-closed finding for an invalid backend-test Module Index.
+ * These are distinct states (missing/unreadable/duplicate/empty-unparsable) so a
+ * stripped Module Index can never silently fall back to a whole-directory scan.
+ */
+export function backendManifestStatusFinding(manifestStatus, moduleIndexHeadingCount = 0) {
+    switch (manifestStatus) {
+        case "missing":
+            return "README is missing; backend-test current round fails closed without a declarative Module Index";
+        case "unreadable":
+            return "README is unreadable; backend-test current round fails closed without a usable Module Index";
+        case "duplicate":
+            return moduleIndexHeadingCount === 0
+                ? "README Module Index heading is missing; backend-test current round fails closed without a declarative Module Index"
+                : `duplicate ## Module Index heading (${moduleIndexHeadingCount} occurrences); backend-test current round fails closed without a unique Module Index`;
+        case "empty-unparsable":
+            return "README Module Index is empty/unparsable; backend-test current round fails closed with no declared module";
+        case "valid":
+            return "";
+    }
+}
+/**
+ * Resolve the current-round Markdown module manifest. The README `## Module
+ * Index` is the authoritative source for which module files belong to this
+ * round. Fail closed on every non-`valid` state (missing/unreadable/duplicate/
+ * empty-unparsable): the backend-test current round must NEVER re-scan the whole
+ * directory, or historical `.md` files could leak back into Case/coverage/
+ * partition facts.
+ *
+ * - `manifestStatus==="valid"`   — unique heading with >= 1 declared `.md` file.
+ * - `missing`                     — README file does not exist.
+ * - `unreadable`                  — README exists but could not be read.
+ * - `duplicate`                   — README has 0 or duplicate `## Module Index`.
+ * - `empty-unparsable`            — unique heading but no `.md` filename parsed.
+ * - `declaredMdFiles`  — declared filenames that exist on disk (relative paths).
+ * - `declaredMissing`  — declared filenames with no file on disk (fail-closed
+ *   evidence, never silently dropped).
+ * - `unmanifested`     — existing `.md` files that the Module Index does not
+ *   declare (non-silent advisory; they must not enter Case/coverage/partition).
+ */
+export async function resolveBackendTestManifestModules(workspaceRoot, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const readmePath = path.join(workspaceRoot, ...resolved.readmePath.split("/"));
+    const invalid = (manifestStatus, moduleIndexHeadingCount) => ({
+        hasManifest: false,
+        manifestStatus,
+        moduleIndexHeadingCount,
+        declaredStems: [],
+        declaredMdFiles: [],
+        declaredMissing: [],
+        unmanifested: [],
+    });
+    let readme = "";
+    if (await exists(readmePath)) {
+        try {
+            readme = await readFile(readmePath, "utf8");
+        }
+        catch {
+            // Unreadable README is fail-closed (not silently treated as no manifest).
+            return invalid("unreadable", 0);
+        }
+    }
+    else {
+        return invalid("missing", 0);
+    }
+    const moduleIndexHeadingCount = moduleIndexHeadingCountIn(readme);
+    if (moduleIndexHeadingCount !== 1) {
+        return invalid("duplicate", moduleIndexHeadingCount);
+    }
+    const declaredStems = extractDeclaredModuleIndexFilenames(readme);
+    if (declaredStems.length === 0) {
+        return invalid("empty-unparsable", moduleIndexHeadingCount);
+    }
+    const hasManifest = true;
+    const directory = path.join(workspaceRoot, ...resolved.markdownDir.split("/"));
+    let existingNames = [];
+    try {
+        existingNames = (await readdir(directory, { withFileTypes: true }))
+            .filter((entry) => entry.isFile() &&
+            entry.name.toLowerCase().endsWith(".md") &&
+            entry.name.toLowerCase() !== "readme.md")
+            .map((entry) => entry.name);
+    }
+    catch {
+        // missing markdown directory -> no existing modules
+    }
+    const declaredByLower = new Map();
+    for (const name of declaredStems) {
+        const base = path.posix.basename(name);
+        declaredByLower.set(base.toLowerCase(), base);
+    }
+    const declaredMdFiles = [];
+    const declaredMissing = [];
+    for (const base of declaredByLower.values()) {
+        const disk = existingNames.find((name) => name.toLowerCase() === base.toLowerCase());
+        if (disk)
+            declaredMdFiles.push(`${resolved.markdownDir}/${disk}`);
+        else
+            declaredMissing.push(`${resolved.markdownDir}/${base}`);
+    }
+    const unmanifested = existingNames
+        .filter((name) => !declaredByLower.has(name.toLowerCase()))
+        .map((name) => `${resolved.markdownDir}/${name}`);
+    return {
+        hasManifest,
+        manifestStatus: "valid",
+        moduleIndexHeadingCount,
+        declaredStems,
+        declaredMdFiles: declaredMdFiles.sort(),
+        declaredMissing: declaredMissing.sort(),
+        unmanifested: unmanifested.sort(),
+    };
+}
 export async function markdownFiles(root, layout) {
     const resolved = layout ?? resolveBackendTestLayout(undefined);
     const directory = path.join(root, ...resolved.markdownDir.split("/"));
     const entries = await readdir(directory, { withFileTypes: true });
-    return entries
+    const all = entries
         .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md"))
         .map((entry) => path.join(directory, entry.name))
         .sort();
+    const manifest = await resolveBackendTestManifestModules(root, resolved);
+    if (manifest.manifestStatus !== "valid")
+        return [];
+    const declaredAbs = new Set(manifest.declaredMdFiles.map((rel) => path.join(root, ...rel.split("/")).toLowerCase()));
+    return all
+        .filter((file) => declaredAbs.has(file.toLowerCase()))
+        .sort();
 }
 function canonicalBackendCaseId(value) {
     const upper = value.toUpperCase();
@@ -453,6 +609,17 @@ export async function validateBackendMarkdownCases(input) {
     const readme = path.join(input.workspaceRoot, ...layout.readmePath.split("/"));
     if (!(await exists(readme)))
         findings.push(`missing ${layout.readmePath}`);
+    const manifest = await resolveBackendTestManifestModules(input.workspaceRoot, layout);
+    // Fail closed on README Module Index entries that were declared but never
+    // materialized — never let a declared module silently vanish from the round.
+    if (manifest.declaredMissing.length > 0) {
+        findings.push(`declared Markdown module is missing (Module Index): ${manifest.declaredMissing.join(", ")}`);
+    }
+    // Fail closed on every non-valid Module Index state: without a valid unique
+    // Module Index the current round must not re-scan historical `.md` files.
+    if (manifest.manifestStatus !== "valid") {
+        findings.push(backendManifestStatusFinding(manifest.manifestStatus, manifest.moduleIndexHeadingCount));
+    }
     const moduleFiles = files.filter((file) => path.basename(file).toLowerCase() !== "readme.md");
     if (moduleFiles.length === 0)
         findings.push(`no ${layout.markdownDir} module case file found`);
@@ -562,6 +729,7 @@ export async function validateBackendMarkdownCases(input) {
         `- Cases: ${caseCount}`,
         `- Covered AC IDs: ${[...coveredAc].sort().join(", ") || "none"}`,
         `- Environment evidence present: ${input.environmentMarkdown.trim() ? "yes" : "no"}`,
+        `- Manifest scope: ${manifest.manifestStatus === "valid" ? "declared-modules" : `fails-closed:${manifest.manifestStatus}`} (declared-missing=${manifest.declaredMissing.length}, unmanifested-advisory=${manifest.unmanifested.length}, module-index-heading-count=${manifest.moduleIndexHeadingCount})`,
         `- Findings: ${findings.length}`,
         "- Required sections: Preconditions/前置条件, Steps/操作步骤, Expected Results/预期结果",
         "- Source-reference validity check: not applied",
@@ -583,6 +751,13 @@ export async function validateBackendMarkdownCases(input) {
             ? safetyFindings.map((finding) => `- ${finding}`)
             : ["- No secret-shaped values detected."]),
         "",
+        "## Unmanifested Markdown Modules",
+        "",
+        "- Advisory: existing .md files not declared by the README Module Index are excluded from this round's Case/coverage/partition scope.",
+        ...(manifest.unmanifested.length > 0
+            ? manifest.unmanifested.map((item) => `- ${item}`)
+            : ["- None"]),
+        "",
         "## Findings",
         "",
         ...(findings.length > 0 ? findings.map((finding) => `- ${finding}`) : ["- None"]),

package/dist/workflows/dag/backend-test-pytest-collection.js

@@ -131,6 +131,23 @@ function normalizeHazardOccurrenceIdentity(line) {
     // Unclosed quote or no out-of-string `#`: do not invent a comment boundary.
     return trimmed;
 }
+/**
+ * Bare `__NNN_*` helper module names imported by a Python source snippet.
+ * Only the head token of an `import`/`from` statement is considered a module
+ * name; dotted submodules (`__551_manager_helpers.x`) collapse to the head.
+ */
+function importedBareHelperModules(source) {
+    const names = [];
+    const seen = new Set();
+    for (const match of normalizeSourceNewlines(source).matchAll(/\b(?:import|from)\s+([A-Za-z0-9_.]+)/g)) {
+        const head = match[1].split(".")[0];
+        if (/^__\d+[A-Za-z0-9_]*$/.test(head) && !seen.has(head)) {
+            seen.add(head);
+            names.push(head);
+        }
+    }
+    return names;
+}
 function listPatternOccurrences(source, patternSource, flags = "") {
     const normalized = normalizeSourceNewlines(source);
     const pattern = new RegExp(patternSource, flags.includes("g") ? flags : `${flags}g`);
@@ -221,6 +238,8 @@ export async function buildBackendPytestAssetInventory(workspaceRoot, mappedScri
     const inputHashes = {};
     const hazardOccurrenceCounts = {};
     const hazardOccurrences = {};
+    const scriptBareImports = {};
+    const mappedScriptSet = new Set(normalizedScripts);
     for (const file of assetFiles) {
         const bytes = await readFile(path.resolve(workspaceRoot, file));
         const source = bytes.toString("utf8");
@@ -228,8 +247,10 @@ export async function buildBackendPytestAssetInventory(workspaceRoot, mappedScri
         const lists = scanRepairHazardOccurrenceLists(source);
         hazardOccurrences[file] = lists;
         hazardOccurrenceCounts[file] = Object.fromEntries(Object.entries(lists).map(([label, identities]) => [label, identities.length]));
+        if (mappedScriptSet.has(file))
+            scriptBareImports[file] = importedBareHelperModules(source);
     }
-    return { mappedScripts: normalizedScripts, assetFiles, inputHashes, hazardOccurrenceCounts, hazardOccurrences };
+    return { mappedScripts: normalizedScripts, assetFiles, inputHashes, hazardOccurrenceCounts, hazardOccurrences, scriptBareImports };
 }
 function bounded(value) {
     const normalized = value.replaceAll(/(Bearer|Basic)\s+[A-Za-z0-9._~+\/-]+/gi, "$1 [REDACTED]");
@@ -308,8 +329,68 @@ function classifyFixtureResolutionFailure(output, layout) {
         repairPaths: paths,
     };
 }
-function classifyCollectionFailure(output) {
+/**
+ * Generated-local bare helper module signatures found in the bound pytest
+ * asset inventory. A file such as `testcase/__551_manager_helpers.py` in the
+ * test root/script dir is generated-local: when collection reports
+ * `No module named '__551_manager_helpers'`, the defect can be precisely
+ * attributed to the generated mapped script instead of a missing third-party
+ * package.
+ */
+function generatedLocalBareHelperNames(inventory) {
+    if (!inventory)
+        return [];
+    const names = [];
+    for (const file of inventory.assetFiles) {
+        const stem = path.posix.basename(file).replace(/\.py$/, "");
+        if (/^__\d+[A-Za-z0-9_]*$/.test(stem))
+            names.push(stem);
+    }
+    return [...new Set(names)];
+}
+function classifyCollectionFailure(output, evidence) {
     const normalized = output.replaceAll("\\", "/");
+    const helperNames = generatedLocalBareHelperNames(evidence?.inventory);
+    const helperByLower = new Map(helperNames.map((name) => [name.toLowerCase(), name]));
+    // A bare `__NNN_...` module import that collection cannot find is only a
+    // candidate generated-local helper signature. REPAIRABLE requires two
+    // deterministic pieces of evidence: (1) a helper asset of the same name in
+    // the bound inventory, and (2) at least one mapped generated script whose
+    // source truly imports that bare module. Without both — or when attribution
+    // is impossible — fail closed as BLOCKED so an un-attributable dependency
+    // error is never widened into a repair. Genuine third-party modules (no
+    // `__NNN_` signature) stay BLOCKED below.
+    const missingModule = /No module named ['\"]([^'\"]+)['\"]/i.exec(normalized)?.[1];
+    if (missingModule && /^__\d+[A-Za-z0-9_]*$/.test(missingModule)) {
+        const helperAsset = helperByLower.get(missingModule.toLowerCase());
+        const inventory = evidence?.inventory;
+        const scriptBareImports = inventory?.scriptBareImports ?? {};
+        const missingLower = missingModule.toLowerCase();
+        const importedByMappedScript = inventory
+            ? inventory.mappedScripts.some((script) => (scriptBareImports[script] ?? []).some((name) => name.toLowerCase() === missingLower))
+            : false;
+        if (helperAsset && importedByMappedScript && inventory) {
+            const repairPaths = [...new Set([
+                    ...(helperAsset
+                        ? inventory.assetFiles.filter((file) => path.posix.basename(file).replace(/\.py$/, "") === helperAsset)
+                        : []),
+                    ...inventory.mappedScripts,
+                ])].sort();
+            return {
+                status: "REPAIRABLE",
+                kind: "missing-generated-local-helper",
+                detail: `generated testcase asset imports missing bare generated-local helper module ${missingModule}; inline the helper or remove the generated shared dependency`,
+                repairPaths,
+            };
+        }
+        return {
+            status: "BLOCKED",
+            kind: "missing-generated-local-helper-without-evidence",
+            detail: helperAsset
+                ? `missing bare generated-local helper module ${missingModule} has a name match but no mapped generated script imports it (no precise generated-local attribution)`
+                : `missing bare __NNN_* module ${missingModule} has no generated-local helper asset in the bound inventory (cannot be precisely attributed)`,
+        };
+    }
     const blockedPatterns = [
         [/No module named ['\"](?!testcase(?:\.|['\"]))/i, "missing-third-party-module"],
         [/pytest(?:_|-)plugin|pluggy|unknown hook|unrecognized arguments/i, "pytest-plugin-or-config"],
@@ -401,7 +482,7 @@ export function assessBackendPytestCollection(input) {
             fixtureStderrExcerpt: bounded(fixtureResolution.stderr),
         });
     }
-    const classification = classifyCollectionFailure(`${input.stdout}\n${input.stderr}`);
+    const classification = classifyCollectionFailure(`${input.stdout}\n${input.stderr}`, { layout: input.layout, inventory: input.inventory });
     return backendPytestCollectionFactsSchema.parse({
         schemaId: "backend-test-pytest-collection-v3",
         phase: input.phase,
@@ -412,7 +493,9 @@ export function assessBackendPytestCollection(input) {
         fixtureResolutionAttempted: false,
         fixtureResolutionStatus: "NOT_RUN",
         fixtureResolutionExitCode: null,
-        repairPaths: testcasePythonPaths(`${input.stdout}\n${input.stderr}`),
+        repairPaths: classification.repairPaths && classification.repairPaths.length > 0
+            ? classification.repairPaths
+            : testcasePythonPaths(`${input.stdout}\n${input.stderr}`),
         mappedScripts: input.inventory.mappedScripts,
         existingMappedScripts: input.inventory.mappedScripts,
         missingMappedScripts: [],

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

@@ -385,12 +385,17 @@ export const FORBIDDEN_GENERATED_IMPORT_NAMESPACES = [
     "testcase.helpers",
     "testcase.factories",
 ];
-const FORBIDDEN_GENERATED_IMPORT_PATTERN = /^\s*(?:from\s+(testcase_helpers|testcase\.helpers|testcase\.factories)\b|import\s+(testcase_helpers|testcase\.helpers|testcase\.factories)\b)/gm;
+const FORBIDDEN_GENERATED_IMPORT_PATTERN = /^\s*(?:from\s+(testcase_helpers|testcase\.helpers|testcase\.factories|__\d+[A-Za-z0-9_]*)\b|import\s+(testcase_helpers|testcase\.helpers|testcase\.factories|__\d+[A-Za-z0-9_]*)\b)/gm;
 /**
- * Scan Python source for imports from forbidden generated shared namespaces.
- * Anchored at line start with a word boundary so `testcase.helpers_other` or a
- * substring inside a docstring sentence is not falsely flagged. Returns the
- * list of offending namespace module names (deduplicated, order-preserving).
+ * Scan Python source for imports from forbidden generated shared namespaces
+ * or bare generated-local helper modules. Anchored at line start with a word
+ * boundary so `testcase.helpers_other` or a substring inside a docstring is not
+ * falsely flagged. In addition to the `testcase_helpers`/`testcase.helpers`/
+ * `testcase.factories` namespaces, bare `__<digits>...` helper modules (for
+ * example `from __551_manager_helpers import ...` / `import __551_manager_helpers`)
+ * are generated-local shared dependencies: a self-contained pytest child must
+ * inline or remove them rather than depend on a generated shared module.
+ * Returns the list of offending module names (deduplicated, order-preserving).
  */
 export function findForbiddenGeneratedImports(source) {
     const hits = [];