@tea-agent/loop-agent 0.26.0 → 0.26.2

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

@@ -1,7 +1,7 @@
-/**
- * Shell service locator removed in R5 boundary final (BND-02).
- * Views import focused modules directly (shell-chrome, kpi, dag-helpers, run-processing).
- * This file is retained only so historical bundle paths do not 404; do not reintroduce getShell.
- */
-
-export {};
+/**
+ * Shell service locator removed in R5 boundary final (BND-02).
+ * Views import focused modules directly (shell-chrome, kpi, dag-helpers, run-processing).
+ * This file is retained only so historical bundle paths do not 404; do not reintroduce getShell.
+ */
+
+export {};

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

@@ -1,163 +1,163 @@
-/** Observe UI view module (R5). */
-import {
-	UI_TEXT,
-	LIVENESS_LABELS,
-	ARTIFACT_LABELS,
-	ARTIFACT_KEYS,
-	STEP_LABELS,
-	STEP_ORDER,
-	DAG_INSPECTOR_DEFAULT_WIDTH,
-	DAG_INSPECTOR_MIN_WIDTH,
-	DAG_INSPECTOR_MAX_WIDTH,
-	DAG_INSPECTOR_RIGHT_OFFSET,
-	DAG_INSPECTOR_VIEWPORT_MARGIN,
-	DAG_INSPECTOR_KEYBOARD_STEP,
-	TERMINAL_RUN_STATUSES,
-	DAG_EFFECTIVE_STATUS_LABELS,
-	STATUS_LABELS,
-} from "../constants.js";
-import { clearNode, el, metaGrid, buildTable } from "../dom.js";
-import {
-	badge,
-	badgeClass,
-	statusLabel,
-	formatTs,
-	formatMs,
-	formatDuration,
-	formatAgo,
-	dagStatusBadge,
-	livenessBadge,
-	displayDurationMs,
-	derivedDurationMs,
-	summaryText,
-	truncateText,
-	repoBaseName,
-	parseMarkdownBlocks,
-	markdownLinkHref,
-} from "../format.js";
-import { parseRoute, navigate, buildHashPath } from "../router.js";
-import {
-	fetchJson,
-	artifactUrl,
-	parseArtifactPreviewResponse,
-} from "../api.js";
-import {
-	objectRouteLink,
-	findFeatureInSnapshot,
-	featureLookupState,
-	buildObjectRelations,
-	renderObjectRelationBar,
-} from "../relations.js";
-import { copyText, renderRecommendedCommand } from "../copy.js";
-import {
-	isPageVisible,
-	detailPollDelay,
-	dashboardPollDelay,
-	captureDagGraphViewportState,
-	updateDagGraphViewportState,
-	updateDagTimelineViewportState,
-	renderViewState,
-	mountViewState,
-} from "../state.js";
-import { uiState } from "../state.js";
-import { sortPoolTasks } from "../format-pool.js";
-import {
-	dagMetaVisibility,
-	isDagRunActive,
-	dashboardVisibleFeatures,
-	findDagForRun,
-} from "../dag-model.js";
-import { layoutDag } from "../dag-layout.js";
-
-export async function mountBoundedEventTimeline(container, apiBase, title) {
-	clearNode(container);
-	container.appendChild(el("h3", "section-heading", title));
-	const note = el(
-		"p",
-		"process-timeline-note",
-		"有界历史（默认 50 / 最大 200）；分页使用 cursor，与 SSE 行号 offset 分离。",
-	);
-	container.appendChild(note);
-	const scroll = el("div", "process-timeline-scroll event-history-scroll");
-	const listHost = el("div", "event-history-list");
-	scroll.appendChild(listHost);
-	container.appendChild(scroll);
-	const footer = el("div", "event-history-footer");
-	container.appendChild(footer);
-
-	let nextCursor = null;
-	let loading = false;
-	const accumulated = [];
-
-	const renderList = () => {
-		clearNode(listHost);
-		if (accumulated.length === 0) {
-			mountViewState(listHost, "empty", "暂无事件");
-			return;
-		}
-		const ul = el("ul", "process-timeline");
-		for (let index = 0; index < accumulated.length; index += 1) {
-			const event = accumulated[index];
-			const li = el(
-				"li",
-				`process-timeline-item process-timeline-event has-time${index === 0 ? " is-first" : ""}${index === accumulated.length - 1 ? " is-last" : ""}`,
-			);
-			const rail = el("span", "process-timeline-rail");
-			rail.appendChild(el("span", "process-timeline-dot"));
-			li.appendChild(rail);
-			li.appendChild(
-				el("span", "process-timeline-time", formatTs(event.at) || "—"),
-			);
-			const label = `${event.type ?? "event"}${event.taskId ? ` · ${event.taskId}` : ""}${event.workerRunId ? ` · ${event.workerRunId}` : ""}`;
-			li.appendChild(el("span", "process-timeline-label", label));
-			ul.appendChild(li);
-		}
-		listHost.appendChild(ul);
-	};
-
-	const loadPage = async (cursor) => {
-		if (loading) return;
-		loading = true;
-		if (accumulated.length === 0) {
-			mountViewState(listHost, "loading", "加载事件…");
-		}
-		const qs = new URLSearchParams();
-		qs.set("limit", "50");
-		if (cursor) qs.set("cursor", cursor);
-		const page = await fetchJson(`${apiBase}?${qs.toString()}`);
-		loading = false;
-		if (!page) {
-			mountViewState(listHost, "error", "无法加载事件历史。");
-			return;
-		}
-		const events = page.events ?? [];
-		for (const event of events) accumulated.push(event);
-		nextCursor = page.nextCursor ?? null;
-		renderList();
-		clearNode(footer);
-		if (page.corruptLineCount > 0) {
-			footer.appendChild(
-				renderViewState(
-					"degraded",
-					`跳过损坏行 ${page.corruptLineCount} 条（failure-safe）。`,
-				),
-			);
-		}
-		if (nextCursor) {
-			const btn = el(
-				"button",
-				"btn-secondary event-history-more",
-				"加载更早事件",
-			);
-			btn.type = "button";
-			btn.addEventListener("click", () => {
-				void loadPage(nextCursor);
-			});
-			footer.appendChild(btn);
-		} else if (accumulated.length > 0) {
-			footer.appendChild(el("p", "muted", "已到历史边界"));
-		}
-	};
-
-	await loadPage(null);
-}
+/** Observe UI view module (R5). */
+import {
+	UI_TEXT,
+	LIVENESS_LABELS,
+	ARTIFACT_LABELS,
+	ARTIFACT_KEYS,
+	STEP_LABELS,
+	STEP_ORDER,
+	DAG_INSPECTOR_DEFAULT_WIDTH,
+	DAG_INSPECTOR_MIN_WIDTH,
+	DAG_INSPECTOR_MAX_WIDTH,
+	DAG_INSPECTOR_RIGHT_OFFSET,
+	DAG_INSPECTOR_VIEWPORT_MARGIN,
+	DAG_INSPECTOR_KEYBOARD_STEP,
+	TERMINAL_RUN_STATUSES,
+	DAG_EFFECTIVE_STATUS_LABELS,
+	STATUS_LABELS,
+} from "../constants.js";
+import { clearNode, el, metaGrid, buildTable } from "../dom.js";
+import {
+	badge,
+	badgeClass,
+	statusLabel,
+	formatTs,
+	formatMs,
+	formatDuration,
+	formatAgo,
+	dagStatusBadge,
+	livenessBadge,
+	displayDurationMs,
+	derivedDurationMs,
+	summaryText,
+	truncateText,
+	repoBaseName,
+	parseMarkdownBlocks,
+	markdownLinkHref,
+} from "../format.js";
+import { parseRoute, navigate, buildHashPath } from "../router.js";
+import {
+	fetchJson,
+	artifactUrl,
+	parseArtifactPreviewResponse,
+} from "../api.js";
+import {
+	objectRouteLink,
+	findFeatureInSnapshot,
+	featureLookupState,
+	buildObjectRelations,
+	renderObjectRelationBar,
+} from "../relations.js";
+import { copyText, renderRecommendedCommand } from "../copy.js";
+import {
+	isPageVisible,
+	detailPollDelay,
+	dashboardPollDelay,
+	captureDagGraphViewportState,
+	updateDagGraphViewportState,
+	updateDagTimelineViewportState,
+	renderViewState,
+	mountViewState,
+} from "../state.js";
+import { uiState } from "../state.js";
+import { sortPoolTasks } from "../format-pool.js";
+import {
+	dagMetaVisibility,
+	isDagRunActive,
+	dashboardVisibleFeatures,
+	findDagForRun,
+} from "../dag-model.js";
+import { layoutDag } from "../dag-layout.js";
+
+export async function mountBoundedEventTimeline(container, apiBase, title) {
+	clearNode(container);
+	container.appendChild(el("h3", "section-heading", title));
+	const note = el(
+		"p",
+		"process-timeline-note",
+		"有界历史（默认 50 / 最大 200）；分页使用 cursor，与 SSE 行号 offset 分离。",
+	);
+	container.appendChild(note);
+	const scroll = el("div", "process-timeline-scroll event-history-scroll");
+	const listHost = el("div", "event-history-list");
+	scroll.appendChild(listHost);
+	container.appendChild(scroll);
+	const footer = el("div", "event-history-footer");
+	container.appendChild(footer);
+
+	let nextCursor = null;
+	let loading = false;
+	const accumulated = [];
+
+	const renderList = () => {
+		clearNode(listHost);
+		if (accumulated.length === 0) {
+			mountViewState(listHost, "empty", "暂无事件");
+			return;
+		}
+		const ul = el("ul", "process-timeline");
+		for (let index = 0; index < accumulated.length; index += 1) {
+			const event = accumulated[index];
+			const li = el(
+				"li",
+				`process-timeline-item process-timeline-event has-time${index === 0 ? " is-first" : ""}${index === accumulated.length - 1 ? " is-last" : ""}`,
+			);
+			const rail = el("span", "process-timeline-rail");
+			rail.appendChild(el("span", "process-timeline-dot"));
+			li.appendChild(rail);
+			li.appendChild(
+				el("span", "process-timeline-time", formatTs(event.at) || "—"),
+			);
+			const label = `${event.type ?? "event"}${event.taskId ? ` · ${event.taskId}` : ""}${event.workerRunId ? ` · ${event.workerRunId}` : ""}`;
+			li.appendChild(el("span", "process-timeline-label", label));
+			ul.appendChild(li);
+		}
+		listHost.appendChild(ul);
+	};
+
+	const loadPage = async (cursor) => {
+		if (loading) return;
+		loading = true;
+		if (accumulated.length === 0) {
+			mountViewState(listHost, "loading", "加载事件…");
+		}
+		const qs = new URLSearchParams();
+		qs.set("limit", "50");
+		if (cursor) qs.set("cursor", cursor);
+		const page = await fetchJson(`${apiBase}?${qs.toString()}`);
+		loading = false;
+		if (!page) {
+			mountViewState(listHost, "error", "无法加载事件历史。");
+			return;
+		}
+		const events = page.events ?? [];
+		for (const event of events) accumulated.push(event);
+		nextCursor = page.nextCursor ?? null;
+		renderList();
+		clearNode(footer);
+		if (page.corruptLineCount > 0) {
+			footer.appendChild(
+				renderViewState(
+					"degraded",
+					`跳过损坏行 ${page.corruptLineCount} 条（failure-safe）。`,
+				),
+			);
+		}
+		if (nextCursor) {
+			const btn = el(
+				"button",
+				"btn-secondary event-history-more",
+				"加载更早事件",
+			);
+			btn.type = "button";
+			btn.addEventListener("click", () => {
+				void loadPage(nextCursor);
+			});
+			footer.appendChild(btn);
+		} else if (accumulated.length > 0) {
+			footer.appendChild(el("p", "muted", "已到历史边界"));
+		}
+	};
+
+	await loadPage(null);
+}

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

@@ -0,0 +1,277 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+const SHA256 = /^[a-f0-9]{64}$/;
+const MAX_DIAGNOSTIC_CHARS = 12_000;
+export const backendPytestCollectionFindingSchema = z.object({
+    kind: z.string().min(1),
+    classification: z.literal("test-asset-defect"),
+    repairability: z.enum(["repairable", "blocked"]),
+    detail: z.string().min(1),
+}).strict();
+export const backendPytestCollectionFactsSchema = z.object({
+    schemaId: z.literal("backend-test-pytest-collection-v1"),
+    phase: z.enum(["initial", "final", "effective"]),
+    status: z.enum(["PASS", "REPAIRABLE", "BLOCKED"]),
+    repairEligible: z.boolean(),
+    repairAttempt: z.number().int().min(0).max(1),
+    mappedScripts: z.array(z.string()).min(1),
+    assetFiles: z.array(z.string()).min(1),
+    inputHashes: z.record(z.string(), z.string().regex(SHA256)),
+    pytestExitCode: z.number().int(),
+    collectedItemCount: z.number().int().min(0),
+    collectedItemIds: z.array(z.string()),
+    findings: z.array(backendPytestCollectionFindingSchema),
+    stdoutExcerpt: z.string(),
+    stderrExcerpt: z.string(),
+    collectionSource: z.enum(["initial", "final"]).optional(),
+}).strict();
+function repoRef(workspaceRoot, absolutePath) {
+    return path.relative(workspaceRoot, absolutePath).replaceAll(path.sep, "/");
+}
+function sha256(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+async function walkPythonFiles(root) {
+    const results = [];
+    const visit = async (current) => {
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name === "__pycache__" || entry.name === ".pytest_cache")
+                continue;
+            const absolute = path.join(current, entry.name);
+            if (entry.isDirectory())
+                await visit(absolute);
+            else if (entry.isFile() && entry.name.endsWith(".py"))
+                results.push(absolute);
+        }
+    };
+    await visit(root);
+    return results;
+}
+export async function buildBackendPytestAssetInventory(workspaceRoot, mappedScripts) {
+    const normalizedScripts = [...new Set(mappedScripts.map((value) => value.replaceAll("\\", "/")))].sort();
+    if (normalizedScripts.length === 0)
+        throw new Error("backend pytest collection requires mapped scripts");
+    for (const script of normalizedScripts) {
+        if (!/^testcase(?:\/[A-Za-z0-9_.-]+)*\/test_[A-Za-z0-9_.-]+\.py$/.test(script) && !/^testcase\/test_[A-Za-z0-9_.-]+\.py$/.test(script)) {
+            throw new Error(`unsafe backend pytest mapped script: ${script}`);
+        }
+        const absolute = path.resolve(workspaceRoot, script);
+        const testcaseRoot = path.resolve(workspaceRoot, "testcase");
+        if (absolute !== testcaseRoot && !absolute.startsWith(`${testcaseRoot}${path.sep}`)) {
+            throw new Error(`backend pytest mapped script escapes testcase: ${script}`);
+        }
+        await readFile(absolute);
+    }
+    const pythonFiles = await walkPythonFiles(path.resolve(workspaceRoot, "testcase"));
+    const assetFiles = [...new Set(pythonFiles.map((file) => repoRef(workspaceRoot, file)))].sort();
+    const inputHashes = {};
+    for (const file of assetFiles)
+        inputHashes[file] = sha256(await readFile(path.resolve(workspaceRoot, file)));
+    return { mappedScripts: normalizedScripts, assetFiles, inputHashes };
+}
+function bounded(value) {
+    const normalized = value.replaceAll(/(Bearer|Basic)\s+[A-Za-z0-9._~+\/-]+/gi, "$1 [REDACTED]");
+    return normalized.length <= MAX_DIAGNOSTIC_CHARS
+        ? normalized
+        : `${normalized.slice(0, MAX_DIAGNOSTIC_CHARS)}\n...[truncated]`;
+}
+function collectionItems(stdout) {
+    return [...new Set(stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => {
+            if (!line.includes("::"))
+                return false;
+            if (/^(ERROR|FAILED|E\s+)/.test(line))
+                return false;
+            return /^testcase\//.test(line.replaceAll("\\", "/"));
+        }).map((line) => line.replaceAll("\\", "/")))];
+}
+function classifyCollectionFailure(output) {
+    const normalized = output.replaceAll("\\", "/");
+    const blockedPatterns = [
+        [/No module named ['\"](?!testcase(?:\.|['\"]))/i, "missing-third-party-module"],
+        [/pytest(?:_|-)plugin|pluggy|unknown hook|unrecognized arguments/i, "pytest-plugin-or-config"],
+        [/(?:apps|src|server|api)\/[A-Za-z0-9_./-]+\.py/i, "production-module-import"],
+        [/permission denied|access is denied|timed? out|not recognized as an internal|no such file or directory.*python/i, "environment-or-spawn"],
+    ];
+    for (const [pattern, kind] of blockedPatterns) {
+        if (pattern.test(normalized))
+            return { status: "BLOCKED", kind, detail: "collection failure is outside generated testcase asset repair scope" };
+    }
+    if (/ImportError:\s*cannot import name/i.test(normalized) && /(?:from ['\"]testcase\.|\/testcase\/)/i.test(normalized)) {
+        return { status: "REPAIRABLE", kind: "missing-local-import-symbol", detail: "generated testcase asset imports a missing local symbol" };
+    }
+    if (/ModuleNotFoundError:\s*No module named ['\"]testcase(?:\.|['\"])/i.test(normalized)) {
+        return { status: "REPAIRABLE", kind: "missing-local-testcase-module", detail: "generated testcase asset imports a missing local testcase module" };
+    }
+    if (/partially initialized module ['\"]testcase\.|circular import/i.test(normalized)) {
+        return { status: "REPAIRABLE", kind: "local-circular-import", detail: "generated testcase assets contain a local circular import" };
+    }
+    if (/SyntaxError|IndentationError|TabError/i.test(normalized) && /testcase\/[A-Za-z0-9_./-]+\.py/i.test(normalized)) {
+        return { status: "REPAIRABLE", kind: "generated-python-syntax", detail: "generated testcase Python source is not syntactically collectable" };
+    }
+    return { status: "BLOCKED", kind: "unclassified-collection-error", detail: "collection failure cannot be safely attributed to generated testcase assets" };
+}
+export function assessBackendPytestCollection(input) {
+    const items = collectionItems(input.stdout);
+    if (input.exitCode === 0) {
+        return backendPytestCollectionFactsSchema.parse({
+            schemaId: "backend-test-pytest-collection-v1",
+            phase: input.phase,
+            status: "PASS",
+            repairEligible: false,
+            repairAttempt: input.phase === "final" ? 1 : 0,
+            mappedScripts: input.inventory.mappedScripts,
+            assetFiles: input.inventory.assetFiles,
+            inputHashes: input.inventory.inputHashes,
+            pytestExitCode: input.exitCode,
+            collectedItemCount: items.length,
+            collectedItemIds: items,
+            findings: [],
+            stdoutExcerpt: bounded(input.stdout),
+            stderrExcerpt: bounded(input.stderr),
+        });
+    }
+    const classification = classifyCollectionFailure(`${input.stdout}\n${input.stderr}`);
+    return backendPytestCollectionFactsSchema.parse({
+        schemaId: "backend-test-pytest-collection-v1",
+        phase: input.phase,
+        status: classification.status,
+        repairEligible: input.phase === "initial" && classification.status === "REPAIRABLE",
+        repairAttempt: input.phase === "final" ? 1 : 0,
+        mappedScripts: input.inventory.mappedScripts,
+        assetFiles: input.inventory.assetFiles,
+        inputHashes: input.inventory.inputHashes,
+        pytestExitCode: input.exitCode,
+        collectedItemCount: items.length,
+        collectedItemIds: items,
+        findings: [{
+                kind: classification.kind,
+                classification: "test-asset-defect",
+                repairability: classification.status === "REPAIRABLE" ? "repairable" : "blocked",
+                detail: classification.detail,
+            }],
+        stdoutExcerpt: bounded(input.stdout),
+        stderrExcerpt: bounded(input.stderr),
+    });
+}
+export function renderBackendPytestCollectionReport(facts) {
+    return [
+        `# Backend pytest Collection ${facts.phase}`,
+        "",
+        "## Status",
+        "",
+        facts.status,
+        "",
+        `- Repair eligible: ${facts.repairEligible}`,
+        `- Repair attempt: ${facts.repairAttempt}`,
+        `- Pytest exit code: ${facts.pytestExitCode}`,
+        `- Mapped scripts: ${facts.mappedScripts.length}`,
+        `- Bound Python assets: ${facts.assetFiles.length}`,
+        `- Collected items: ${facts.collectedItemCount}`,
+        "",
+        "## Findings",
+        "",
+        ...(facts.findings.length ? facts.findings.map((finding) => `- ${finding.kind}: ${finding.detail}`) : ["- None"]),
+        "",
+        "## Collected Items",
+        "",
+        ...(facts.collectedItemIds.length ? facts.collectedItemIds.map((item) => `- ${item}`) : ["- None"]),
+        "",
+        "## Bounded stdout",
+        "",
+        "```text",
+        facts.stdoutExcerpt,
+        "```",
+        "",
+        "## Bounded stderr",
+        "",
+        "```text",
+        facts.stderrExcerpt,
+        "```",
+        "",
+    ].join("\n");
+}
+export async function writeBackendPytestCollectionArtifacts(input) {
+    const contractsDir = path.join(input.runDir, "contracts");
+    const reportsDir = path.join(input.runDir, "reports");
+    await mkdir(contractsDir, { recursive: true });
+    await mkdir(reportsDir, { recursive: true });
+    const factsPath = path.join(contractsDir, `backend-test-pytest-collection-${input.stem}.json`);
+    const reportPath = path.join(reportsDir, `backend-test-pytest-collection-${input.stem}.md`);
+    await writeFile(factsPath, `${JSON.stringify(input.facts, null, 2)}\n`, "utf8");
+    await writeFile(reportPath, renderBackendPytestCollectionReport(input.facts), "utf8");
+    return { factsPath, reportPath };
+}
+export async function readBackendPytestCollectionFacts(filePath) {
+    return backendPytestCollectionFactsSchema.parse(JSON.parse(await readFile(filePath, "utf8")));
+}
+async function assertBackendPytestRepairSafety(workspaceRoot, initial, final) {
+    if (JSON.stringify(initial.mappedScripts) !== JSON.stringify(final.mappedScripts)) {
+        throw new Error("backend pytest repair changed mapped script scope");
+    }
+    const forbidden = [
+        [/pytest\.mark\.(?:skip|skipif|xfail)\b|pytest\.(?:skip|xfail)\s*\(/, "skip/xfail"],
+        [/sys\.path\s*\.|PYTHONPATH/, "sys.path/PYTHONPATH mutation"],
+        [/except\s+ImportError\b/, "ImportError fallback"],
+        [/except\s+(?:Exception|BaseException)\b[\s\S]{0,160}?\bpass\b/, "broad exception swallowing"],
+    ];
+    for (const file of final.assetFiles) {
+        const source = await readFile(path.resolve(workspaceRoot, file), "utf8");
+        for (const [pattern, label] of forbidden) {
+            if (pattern.test(source))
+                throw new Error(`backend pytest repair safety blocked ${label}: ${file}`);
+        }
+    }
+}
+function assertSameInventory(expected, actual) {
+    const expectedFiles = Object.keys(expected.inputHashes).sort();
+    const actualFiles = Object.keys(actual.inputHashes).sort();
+    if (JSON.stringify(expectedFiles) !== JSON.stringify(actualFiles))
+        throw new Error("backend pytest collection asset inventory drift");
+    for (const file of expectedFiles) {
+        if (expected.inputHashes[file] !== actual.inputHashes[file])
+            throw new Error(`backend pytest collection hash drift: ${file}`);
+    }
+}
+export async function assertBackendPytestCollectionFresh(workspaceRoot, effective) {
+    if (effective.phase !== "effective" || effective.status !== "PASS") {
+        throw new Error("backend pytest execution requires effective collection PASS facts");
+    }
+    const current = await buildBackendPytestAssetInventory(workspaceRoot, effective.mappedScripts);
+    assertSameInventory(effective, current);
+}
+export async function materializeEffectiveBackendPytestCollection(input) {
+    if (input.initial.status === "PASS") {
+        const current = await buildBackendPytestAssetInventory(input.workspaceRoot, input.initial.mappedScripts);
+        assertSameInventory(input.initial, current);
+        return backendPytestCollectionFactsSchema.parse({
+            ...input.initial,
+            phase: "effective",
+            collectionSource: "initial",
+        });
+    }
+    if (input.initial.status === "BLOCKED")
+        throw new Error("backend pytest collection is blocked and not repairable");
+    if (!input.final)
+        throw new Error("backend pytest collection repair requires final collection facts");
+    if (input.final.status !== "PASS")
+        throw new Error("backend pytest collection still fails after bounded repair");
+    await assertBackendPytestRepairSafety(input.workspaceRoot, input.initial, input.final);
+    const current = await buildBackendPytestAssetInventory(input.workspaceRoot, input.final.mappedScripts);
+    assertSameInventory(input.final, current);
+    return backendPytestCollectionFactsSchema.parse({
+        ...input.final,
+        phase: "effective",
+        repairEligible: false,
+        repairAttempt: 1,
+        collectionSource: "final",
+    });
+}