@tea-agent/loop-agent 0.29.0 → 0.29.2

package/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 ## [Unreleased]
 
+## [0.29.2] - 2026-08-07
+
+### 重点更新
+
+- 优化后端测试生成 writer 的续写重试机制，直接内嵌具体目标路径以恢复输出，不再依赖读取受限路径
+- 修复三处完整性门禁（Completeness Gate）误报，避免将正确的测试生成误判为残缺写集
+
+### 改进
+
+- 后端测试生成 writer（N2 MD / N5 pytest）在输出截断或残缺写集后，续写重试直接内嵌具体目标路径清单，不再依赖读取 `.harness/**` 路径
+- 即使遇到结果为空或输出失败的异常，也会评估完整性门禁，将可恢复的部分写入升格为不完整写集，避免重试空转
+
+### 修复
+
+- 修复 README 正文提及的编号式文件名被误判为缺失模块的问题
+- 修复覆盖率矩阵（Coverage Matrix）表头识别被覆盖率范围（Coverage Scope）数据行遮蔽的问题
+- 修复合法多行 `def` 的 pytest 脚本被误判为截断的问题（真正截断现仍由括号配平计数准确捕获）
+
+## [0.29.1] - 2026-08-07
+
+### 重点更新
+
+- 前端测试默认执行流程大幅精简，收敛至约 11 个静态节点，合并了多项检查与报告步骤
+- 前端测试浏览器默认改为无头（headless）模式，减少环境干扰
+- 优化证据缺失处理逻辑，非路径逃逸的异常不再强制阻断报告生成
+- 修复文档说明被误判为可执行命令的问题，提升执行稳定性
+
+### 新增
+
+- 新增前端测试标准场景物化节点，支持执行后针对阻塞或缺失证据进行最多两轮有界重跑
+- 新增前端测试标准场景规范模板（frontend-test-standard-scenarios.v1.json）
+- 前端测试独占节点支持 tools-only 写保护策略，在保留工具级写沙箱的同时跳过 Git 基线的硬失败限制
+
+### 改进
+
+- 前端测试默认 DAG 结构精简至约 11 个静态节点：合并双重重跑、检查清单与清单文件、证据与结果、L5 与 HTML 报告
+- 前端测试主 HTML 报告不再依赖回顾（retrospect）节点，回顾功能改为可选开启
+- 权威清单文件（manifest.json）仅记录规范化后的测试用例，并在未配置重试时省略相关静态节点
+- 强化运营 HTML 报告的状态过滤功能，并优化失败与阻塞原因的展示
+
+### 修复
+
+- 修复前端测试检查清单将不可用或阻塞状态的说明文字误判为非法可执行命令的问题
+- 修复前端测试收尾阶段因证据缺失或格式错误导致强制失败的问题，现仅对路径逃逸强制报错，其余降级为建议性提示
+- 修复前端测试合并后清单文件物化异常的问题，确保仅写入规范化用例并恢复负向测试用例
+- 回退误改的全局默认 Pi 模型（DEFAULT_PI_MODEL），将其恢复为 glm-5.2，模型路由统一交由 harness 复杂度矩阵处理
+
 ## [0.29.0] - 2026-08-07
 
 ### 重点更新

package/dist/commands/init.js

@@ -2217,7 +2217,7 @@ function buildTargetFeatureWorkflow(input) {
         '- `taskKind: "backend-test"` selects the dedicated backend test DAG. Its Pi nodes analyze requirements, generate and review backend cases, generate pytest, and retrospect on results; shell gate/execution nodes enforce the review verdict and run the target project\'s pytest. The backend test templates (`backend-test-dag.json` and the `backend-test-dag.*.prompt.md` files) ship inside the loop-agent package as static references and are projected to target projects under the governance `templates/` directory.',
         '- `taskKind: "knowledge-sync"` selects the Feature-scoped test-knowledge write-back DAG (collect → draft → validate → apply → pointer). Bind `featureId` in `task.json` (or hardConstraints / requirement text). It writes only under `features/<featureId>/…` after final verification evidence exists.',
         '- `taskKind: "knowledge-graph-bootstrap"` selects the business knowledge-graph bootstrap DAG (preflight → inventory → propose → validate → review → gate → promote → materialize). AI writes only `knowledge/bootstrap/staging/**`; promote is merge-new-only.',
-        '- `taskKind: "frontend-test"` selects the FE-test RAG DAG. It writes a traceable frontend RAG package and Markdown case manifest, then executes manifest cases serially with `playwright-cli` in isolated test environments and retains per-case evidence. It never generates pytest or Playwright source code. `frontendTest.maxCasesPerBatch` defaults to 20 (maximum 50); optional `maxTokensPerCase` and `maxTotalTokens` stop only later cases after a completed case\'s token usage is recorded, marking them `blocked: token-budget-exhausted`. Generated browser startup uses `playwright-cli open --browser=chrome --headed <base-url>`; the generic playwright-cli skill is unchanged.',
+        '- `taskKind: "frontend-test"` selects the FE-test RAG DAG. It writes a traceable frontend RAG package and Markdown case manifest, then executes manifest cases serially with `playwright-cli` in isolated test environments and retains per-case evidence. It never generates pytest or Playwright source code. `frontendTest.maxCasesPerBatch` defaults to 20 (maximum 50); optional `maxTokensPerCase` and `maxTotalTokens` stop only later cases after a completed case\'s token usage is recorded, marking them `blocked: token-budget-exhausted`. Generated browser startup uses `playwright-cli open --browser=chrome --headless <base-url>`; the generic playwright-cli skill is unchanged.',
         "- Only eligible read-only Pi nodes (planner, scout, reviewer, verifier, closeout with no write-capable tool profile) receive the conservative automatic retry policy. Supervisor, implementer, writer, docs-only, dynamic, shell, static, and decision-gate nodes are not retried automatically. Eligible nodes cannot write repository files; the controller only records immutable attempt evidence under `.harness/dag-runs/<state>/<run-id>/<node-id>/attempt-<n>.json`.",
         "",
         "Use the package-backed public knowledge CLI for graph operations. Do not require target projects to run package-only kb runtime scripts:",

package/dist/executors/dag-pi-executor.js

@@ -340,7 +340,9 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     }
     let beforeStatus;
     let beforePathFingerprints;
-    if (isWriteTask) {
+    /** tools-only: keep SDK path sandbox; skip git baseline + post-diff write-guard hard fail. */
+    const skipGitWriteGuard = isWriteTask && input.task.writeGuardPolicy === "tools-only";
+    if (isWriteTask && !skipGitWriteGuard) {
         try {
             beforeStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, { phase: "pi-writer-before" });
             const beforeSnapshot = snapshotGitStatusPorcelain(beforeStatus);
@@ -683,9 +685,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         });
     }
     let completenessFailure;
-    if (mapped.ok &&
-        writeGuardOk &&
-        !writerOutcomeViolation &&
+    if (writeGuardOk &&
         isBackendTestCompletenessRetryCandidate(input.task)) {
         try {
             const progress = input.task.id === "generate-backend-pytest-pi"
@@ -699,12 +699,25 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             });
             if (progress.status !== "PASS") {
                 const classified = classifyBackendTestWriterCompletenessFailure(progress);
-                completenessFailure = {
-                    failureCategory: classified.recoverable
-                        ? INCOMPLETE_WRITE_SET_RETRY_CATEGORY
-                        : "invalid-output",
-                    detail: `backend-test completeness gate ${progress.status}: targets=${progress.targetPaths.join(",") || "(none)"}; issues=${progress.issues.map((issue) => issue.detail).join("; ") || "none"}`,
-                };
+                // A recoverable partial write set (missing/broken files) always wins
+                // over empty-output / invalid-output / writer-empty-diff: it carries
+                // the concrete target paths the continuation attempt needs.
+                if (classified.recoverable) {
+                    completenessFailure = {
+                        failureCategory: INCOMPLETE_WRITE_SET_RETRY_CATEGORY,
+                        detail: `backend-test completeness gate ${progress.status}: targets=${progress.targetPaths.join(",") || "(none)"}; issues=${progress.issues.map((issue) => issue.detail).join("; ") || "none"}`,
+                    };
+                }
+                else if (mapped.ok && !writerOutcomeViolation) {
+                    // Non-recoverable completeness issue only overrides a clean
+                    // successful path; on an already-failed attempt, keep the
+                    // executor's original category so retries reflect the real
+                    // cause (empty-output / invalid-output / writer-empty-diff).
+                    completenessFailure = {
+                        failureCategory: "invalid-output",
+                        detail: `backend-test completeness gate ${progress.status}: targets=${progress.targetPaths.join(",") || "(none)"}; issues=${progress.issues.map((issue) => issue.detail).join("; ") || "none"}`,
+                    };
+                }
             }
         }
         catch (error) {
@@ -744,7 +757,21 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                         ? WRITER_EMPTY_DIFF_RETRY_CATEGORY
                         : "invalid-output"
                 : "write-guard"
-            : mapped.failureCategory,
+            : // When the attempt already failed with a writer-style category
+                // (empty-output / invalid-output / writer-empty-diff) but the workspace
+                // shows a recoverable partial write set, prefer incomplete-write-set so
+                // the continuation is retryable and carries the embedded target paths.
+                // Provider/transport failures (quota, auth, network, timeout,
+                // rate-limit, unavailable) keep their original category so a provider
+                // outage is never masked as a recoverable local write problem.
+                writeGuardOk &&
+                    completenessFailure?.failureCategory ===
+                        INCOMPLETE_WRITE_SET_RETRY_CATEGORY &&
+                    (mapped.failureCategory === "empty-output" ||
+                        mapped.failureCategory === "invalid-output" ||
+                        mapped.failureCategory === WRITER_EMPTY_DIFF_RETRY_CATEGORY)
+                    ? INCOMPLETE_WRITE_SET_RETRY_CATEGORY
+                    : mapped.failureCategory,
         durationMs: mapped.durationMs || Date.now() - started,
     };
 }

package/dist/executors/pi-playwright-cli-tool.js

@@ -197,15 +197,21 @@ function validateOpenArgs(args, baseUrl) {
     for (const arg of args) {
         assertNoControlMeta(arg);
         assertNoSessionFlag(arg);
-        if (arg === "--browser=chrome" || arg === "--headed") {
+        if (arg === "--browser=chrome" || arg === "--headless") {
             flags.add(arg);
             normalized.push(arg);
             continue;
         }
+        // Accept legacy --headed but normalize to headless for frontend-test CI/dogfood.
+        if (arg === "--headed") {
+            flags.add("--headless");
+            if (!normalized.includes("--headless"))
+                normalized.push("--headless");
+            continue;
+        }
         if (arg.startsWith("--browser=") ||
-            arg === "--browser" ||
-            arg === "--headless") {
-            throw new PlaywrightCliPolicyError("open-browser-flags", "open must use --browser=chrome --headed only");
+            arg === "--browser") {
+            throw new PlaywrightCliPolicyError("open-browser-flags", "open must use --browser=chrome --headless only");
         }
         if (/^[a-z][a-z0-9+.-]*:/i.test(arg) || arg.startsWith("http")) {
             url = arg;
@@ -213,12 +219,12 @@ function validateOpenArgs(args, baseUrl) {
         }
         throw new PlaywrightCliPolicyError("open-args", `unsupported open argument: ${arg}`);
     }
-    if (!flags.has("--browser=chrome") || !flags.has("--headed")) {
+    if (!flags.has("--browser=chrome") || !flags.has("--headless")) {
         // controller injects required flags when missing from model args
         if (!flags.has("--browser=chrome"))
             normalized.unshift("--browser=chrome");
-        if (!flags.has("--headed"))
-            normalized.push("--headed");
+        if (!flags.has("--headless"))
+            normalized.push("--headless");
     }
     if (!url) {
         throw new PlaywrightCliPolicyError("open-url-required", "open requires an absolute http(s) URL");
@@ -509,7 +515,7 @@ export function preparePlaywrightCliArgv(input, ctx) {
             catch {
                 throw new PlaywrightCliPolicyError("goto-url-invalid", "goto requires a URL relative to the controller baseUrl");
             }
-            const openLike = validateOpenArgs(["--browser=chrome", "--headed", target], ctx.baseUrl);
+            const openLike = validateOpenArgs(["--browser=chrome", "--headless", target], ctx.baseUrl);
             return openLike[openLike.length - 1];
         });
         if (args.length !== 1) {

package/dist/executors/shell-executor.js

@@ -18,6 +18,7 @@ import { materializeFrontendImplementationContract } from "../workflows/dag/fron
 import { materializeFrontendTestResult, validateFrontendCaseEvidence, } from "../workflows/dag/frontend-test-result-contract.js";
 import { renderFrontendTestL5Report } from "../workflows/dag/frontend-test-l5-report.js";
 import { validateFrontendCaseChecklist } from "../workflows/dag/frontend-test-case-checklist.js";
+import { materializeFrontendTestCaseManifest } from "../workflows/dag/frontend-test-case-manifest.js";
 import { renderFrontendTestHtmlReport } from "../workflows/dag/frontend-test-html-report.js";
 import { formatFrontendVerificationTraceStdout, runFrontendVerificationTraceGate, } from "../workflows/dag/frontend-verification-trace.js";
 import { formatFrontendWorktreeDiffStdout, runFrontendWorktreeDiffGate, } from "../workflows/dag/frontend-worktree-diff.js";
@@ -1826,6 +1827,149 @@ async function executeFrontendTestEvidenceValidation(input) {
         };
     }
 }
+async function executeFrontendTestCaseManifest(input, meta) {
+    const started = Date.now();
+    try {
+        const gate = input.task.shell?.frontendTestCaseManifest ?? {};
+        const declaredAcIds = gate.declaredAcIds ??
+            (meta.spec.sourceBinding?.requirementIds ?? []).filter((id) => /^AC(?:-[A-Z0-9]+)+$/i.test(id));
+        const checklist = await validateFrontendCaseChecklist({
+            workspaceRoot: input.cwd,
+            declaredAcIds,
+        });
+        if (checklist.issues.length) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: `frontend-test checklist blocked: ${JSON.stringify(checklist.issues)}`,
+                failureCategory: "invalid-output",
+                durationMs: Date.now() - started,
+            };
+        }
+        const materialized = await materializeFrontendTestCaseManifest({
+            workspaceRoot: input.cwd,
+            maxCases: gate.maxCases,
+            declaredAcIds,
+        });
+        return {
+            ok: true,
+            stdout: `${JSON.stringify({ cases: materialized.cases })}
+`,
+            stderr: "",
+            failureCategory: "success",
+            durationMs: Date.now() - started,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            failureCategory: "invalid-output",
+            durationMs: Date.now() - started,
+        };
+    }
+}
+/** Path-escape / cross-case evidence errors must hard-fail finalize (same class as validate.hardFail). */
+function isFrontendTestEvidencePathHardError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /unsafe evidence|escapes (?:evidence root|its allowed root)|evidence realpath|cross-case/i.test(message);
+}
+/**
+ * Lean finalize: evidence validate + result materialize in one shell.
+ * - Case-level missing/malformed evidence is advisory (issues / advisoryFindings);
+ *   the node still succeeds so reports can render incomplete/failed outcomes.
+ * - Path escape / unsafe evidence roots hard-fail the node.
+ * - Controller/contract errors (missing sourceBinding, empty manifest) still fail closed.
+ */
+async function executeFrontendTestResultFinalize(input, meta) {
+    const started = Date.now();
+    let advisoryStdout = "";
+    try {
+        const evidence = await validateFrontendCaseEvidence({
+            workspaceRoot: input.cwd,
+        });
+        advisoryStdout = `frontend case evidence validation cases=${evidence.cases} findings=${evidence.issues.length}${evidence.issues.length ? ` issues=${JSON.stringify(evidence.issues)}` : ""}`;
+        // Advisory findings must not block materialize; only hardFail (path escape) does.
+        if (evidence.hardFail) {
+            return {
+                ok: false,
+                stdout: advisoryStdout,
+                stderr: `frontend-test evidence hard-fail: ${JSON.stringify(evidence.issues)}`,
+                failureCategory: "nonzero-exit",
+                durationMs: Date.now() - started,
+            };
+        }
+        const artifact = await materializeFrontendTestResult({
+            runDir: meta.runDir,
+            workspaceRoot: input.cwd,
+            artifactName: "frontend-test-result.json",
+            outputDir: "contracts",
+            sourceBinding: meta.spec.sourceBinding,
+        });
+        return {
+            ok: true,
+            stdout: `${advisoryStdout}\nStructured artifact: ${artifact.path}\nSchema: ${artifact.schemaId}\nSHA-256: ${artifact.sha256}`,
+            stderr: "",
+            failureCategory: "success",
+            durationMs: Date.now() - started,
+        };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        if (isFrontendTestEvidencePathHardError(error)) {
+            return {
+                ok: false,
+                stdout: advisoryStdout,
+                stderr: `frontend-test evidence hard-fail: ${detail}`,
+                failureCategory: "nonzero-exit",
+                durationMs: Date.now() - started,
+            };
+        }
+        return {
+            ok: false,
+            stdout: advisoryStdout,
+            stderr: detail,
+            failureCategory: "invalid-output",
+            durationMs: Date.now() - started,
+        };
+    }
+}
+async function executeFrontendTestReports(input, meta) {
+    const started = Date.now();
+    try {
+        const writeL5 = input.task.shell?.frontendTestReports?.l5 !== false;
+        const lines = [];
+        if (writeL5) {
+            const l5 = await renderFrontendTestL5Report({
+                workspaceRoot: input.cwd,
+                runDir: meta.runDir,
+            });
+            lines.push(`Frontend L-5 report: ${l5.htmlPath}\nMarkdown: ${l5.markdownPath}\nStatus: ${l5.metrics.status}`);
+        }
+        const report = await renderFrontendTestHtmlReport({
+            workspaceRoot: input.cwd,
+            runDir: meta.runDir,
+        });
+        lines.push(`Frontend test report: ${report.htmlPath}\nMarkdown: ${report.markdownPath}\nOutcome: ${report.outcome}\nCases: ${report.caseCount}`);
+        return {
+            ok: true,
+            stdout: lines.join("\n"),
+            stderr: "",
+            failureCategory: "success",
+            durationMs: Date.now() - started,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            failureCategory: "invalid-output",
+            durationMs: Date.now() - started,
+        };
+    }
+}
 async function executeFrontendLintBaseline(input, meta) {
     const started = Date.now();
     const shell = input.task.shell;
@@ -2062,15 +2206,24 @@ export async function executeDagShellNode(input, meta) {
     if (shell?.frontendTestCaseChecklist) {
         return executeFrontendTestCaseChecklist(input, meta);
     }
+    if (shell?.frontendTestCaseManifest) {
+        return executeFrontendTestCaseManifest(input, meta);
+    }
     if (shell?.frontendTestEvidenceValidation) {
         return executeFrontendTestEvidenceValidation(input);
     }
+    if (shell?.frontendTestResultFinalize) {
+        return executeFrontendTestResultFinalize(input, meta);
+    }
     if (shell?.frontendTestL5Report) {
         return executeFrontendTestL5Report(input, meta);
     }
     if (shell?.frontendTestHtmlReport) {
         return executeFrontendTestHtmlReport(input, meta);
     }
+    if (shell?.frontendTestReports) {
+        return executeFrontendTestReports(input, meta);
+    }
     if (shell?.backendTestPipeline) {
         return executeBackendTestPipelineWithWriteGuard(input, meta);
     }

package/dist/task/config-types.js

@@ -83,6 +83,27 @@ export const frontendTestConfigSchema = z.object({
      * Default false: pipeline success is result materialize + retrospect report, not full green.
      */
     strictOutcomeGate: z.boolean().optional(),
+    /**
+     * Maximum rerun attempts for blocked or missing-result frontend cases.
+     * Defaults to 2; the static graph always carries a single rerun select+map
+     * pair and bounds candidates within that pair via this value.
+     */
+    maxRerunAttempts: z.number().int().min(0).max(4).optional(),
+    /**
+     * Report chain toggles for the lean frontend-test DAG.
+     * - retrospect: opt-in Pi retrospective node (default off). Pipeline success
+     *   is frontend-test-result-v1 + main HTML/MD report, not the retrospect.
+     * - l5: write the deterministic L-5 dashboard from the merged reports node
+     *   (default true; the merged reports node always renders the main
+     *   HTML/MD report regardless of this flag).
+     */
+    reports: z
+        .object({
+        retrospect: z.boolean().optional(),
+        l5: z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
 });
 export const convergenceConfigSchema = z.object({
     enabled: z.boolean().optional().default(false),

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

@@ -2,6 +2,17 @@ import { createHash } from "node:crypto";
 import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
+/**
+ * Maps a backend-test generation writer task id to its writer-progress role.
+ * Returns undefined for nodes that are not completeness-gated generators.
+ */
+export function backendTestWriterProgressRoleForTask(taskId) {
+    if (taskId === "generate-backend-md-cases-pi")
+        return "md-generate";
+    if (taskId === "generate-backend-pytest-pi")
+        return "pytest-generate";
+    return undefined;
+}
 import { expectedBackendTestPytestScriptForMarkdownModule, normalizeBackendTestModuleStem, } from "./backend-test-markdown-workflow.js";
 export const BACKEND_TEST_WRITER_PROGRESS_SCHEMA_ID = "backend-test-writer-progress-v1";
 export const BACKEND_TEST_OUTPUT_LIMIT_RECOVERY_REPORT = "backend-test-output-limit-recovery.md";
@@ -42,7 +53,21 @@ function hasMarkdownTable(section, headerNeedle) {
         .replaceAll("\r\n", "\n")
         .replaceAll("\r", "\n")
         .split("\n");
-    const headerIndex = lines.findIndex((line) => line.toLowerCase().includes(headerNeedle.toLowerCase()));
+    // A markdown table header row must itself be a pipe-delimited row (start
+    // and end with `|`) AND be immediately followed by a separator row
+    // (`|---|`). Find the first row that satisfies both and contains the
+    // needle, so a Coverage Scope data cell like `| Affected Rule Keys |`
+    // (which mentions the needle but is not a header) does not shadow the
+    // real Coverage Matrix header further down.
+    const headerIndex = lines.findIndex((line, index) => {
+        const trimmed = line.trim();
+        const next = (lines[index + 1] ?? "").trim();
+        return (trimmed.startsWith("|") &&
+            trimmed.endsWith("|") &&
+            /^\|[-: |]+$/.test(next) &&
+            /-{3,}/.test(next) &&
+            line.toLowerCase().includes(headerNeedle.toLowerCase()));
+    });
     if (headerIndex < 0)
         return false;
     const header = lines[headerIndex] ?? "";
@@ -51,19 +76,50 @@ function hasMarkdownTable(section, headerNeedle) {
         /-{3,}/.test(separator) &&
         separator.includes("|"));
 }
+/**
+ * A README module stem must be a stable lowercase business stem such as
+ * `health` or `resource_notes`. Reject tokens that are purely numeric, look
+ * like Case IDs, or were clearly lifted from prose examples (e.g. `1`,
+ * `9`, `BE-RN-001`). This prevents the completeness gate from inventing
+ * phantom missing modules when the model discusses forbidden filenames
+ * ("do not create 1.md / 9.md") inside the README body.
+ */
+function looksLikeValidModuleStem(raw) {
+    if (!raw)
+        return false;
+    const stem = normalizeBackendTestModuleStem(raw);
+    if (stem.toLowerCase() === "readme")
+        return false;
+    if (!/^[a-z][a-z0-9_]*$/.test(stem))
+        return false;
+    if (/^(?:be|tp|ac|req|br)[_-]/i.test(stem))
+        return false;
+    return true;
+}
 function extractModuleStemsFromReadme(readme) {
     const stems = [];
-    for (const match of readme.matchAll(/`?testcase\/md\/([A-Za-z0-9_.-]+)\.md`?/g)) {
-        const stem = match[1];
-        if (stem && stem.toLowerCase() !== "readme")
-            stems.push(stem);
-    }
-    for (const match of readme.matchAll(/\|\s*`?([A-Za-z0-9_.-]+)`?\s*\|\s*`?testcase\/test_/g)) {
-        if (match[1])
-            stems.push(match[1]);
+    // Only trust testcase/md/<stem>.md mentions that appear inside markdown
+    // table rows (`| ... testcase/md/x.md ... |`) or as canonical relative
+    // links (`[label](./x.md)`). Free-form prose mentions such as a recovery
+    // note listing `testcase/md/1.md` must NOT be treated as authoritative
+    // module references, otherwise the gate invents phantom missing modules.
+    const tableRowLines = readme
+        .replaceAll("\r\n", "\n")
+        .replaceAll("\r", "\n")
+        .split("\n")
+        .filter((line) => line.includes("|"));
+    for (const line of tableRowLines) {
+        for (const match of line.matchAll(/`?testcase\/md\/([A-Za-z0-9_.-]+)\.md`?/g)) {
+            if (looksLikeValidModuleStem(match[1]))
+                stems.push(match[1]);
+        }
+        for (const match of line.matchAll(/\|\s*`?([A-Za-z0-9_.-]+)`?\s*\|\s*`?testcase\/test_/g)) {
+            if (looksLikeValidModuleStem(match[1]))
+                stems.push(match[1]);
+        }
     }
     for (const match of readme.matchAll(/\[[^\]]+\]\(\.\/([A-Za-z0-9_.-]+)\.md\)/g)) {
-        if (match[1] && match[1].toLowerCase() !== "readme")
+        if (looksLikeValidModuleStem(match[1]))
             stems.push(match[1]);
     }
     return orderedUnique(stems.map((stem) => normalizeBackendTestModuleStem(stem)));
@@ -118,13 +174,21 @@ function pythonParseable(source) {
         if (triples.length % 2 !== 0)
             return false;
     }
-    if (/\bdef\s+\w+\s*\([^)]*$/m.test(text))
-        return false;
-    if (/\bpytest\.param\s*\([^)]*$/m.test(text))
-        return false;
+    // The balanced-bracket counts above already catch a genuinely truncated
+    // file (an unclosed def/call leaves unbalanced parens). The previous
+    // per-line "def ... ( ... $" heuristic was a false-positive source for
+    // legal multi-line definitions such as `def f(\n    x,\n):` — removed.
     return true;
 }
 export function buildOutputLimitRecoveryPrompt(input) {
+    return buildOutputLimitRecoverySection(input);
+}
+/**
+ * Build an inline `<retry_instruction>` block embedding the exact target
+ * paths. Used by {@link buildAttemptPrompt} so a continuation attempt does
+ * not depend on reading `.harness/**` (which is forbidden for Pi writers).
+ */
+export function buildOutputLimitRecoverySection(input) {
     const paths = input.targetPaths.length > 0
         ? input.targetPaths.map((item) => `  - ${item}`).join("\n")
         : "  - (none)";
@@ -144,6 +208,26 @@ export function buildOutputLimitRecoveryPrompt(input) {
         "</retry_instruction>",
     ].join("\n");
 }
+/**
+ * Load the most recent writer-progress facts from the run dir for a given
+ * generation writer task id, so the next attempt's prompt can embed concrete
+ * target paths instead of asking the model to read a forbidden `.harness/**`
+ * path. Returns undefined when no progress facts exist yet (first retry of
+ * a session, or a non-completeness failure).
+ */
+export async function loadBackendTestWriterProgressForRetry(runDir, taskId) {
+    const role = backendTestWriterProgressRoleForTask(taskId);
+    if (!role)
+        return undefined;
+    const factsPath = path.join(runDir, "contracts", `backend-test-writer-progress-${role}.json`);
+    try {
+        const raw = await readFile(factsPath, "utf8");
+        return progressSchema.parse(JSON.parse(raw));
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function assessBackendTestMdWriterCompleteness(workspaceRoot) {
     const issues = [];
     const expectedPaths = ["testcase/md/README.md"];