@tea-agent/loop-agent 0.29.1 → 0.29.2

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [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
 
 ### 重点更新

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

@@ -685,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"
@@ -701,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) {
@@ -746,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/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"];

package/dist/workflows/dag/node-execution.js

@@ -8,6 +8,7 @@ import { writeNodeRecord, writeNodeSkillArtifacts } from "./run-store.js";
 import { resolveContextPolicy } from "./context-policy.js";
 import { buildDagNodePromptEnvelope, formatConvergenceFeedbackBlock, } from "./prompt.js";
 import { persistLongNodeOutputArtifacts } from "./upstream-artifacts.js";
+import { buildOutputLimitRecoverySection, loadBackendTestWriterProgressForRetry, } from "./backend-test-writer-completeness.js";
 import { computeBackoffDelayMs, isRetryablePiFailureCategory, isSafeReadOnlyPiRetryCandidate, isWriterEmptyDiffRetryCandidate, } from "./retry-policy.js";
 import { applyNodeActivity, evaluateNodeLiveness, resolveLivenessPolicy, } from "./liveness-policy.js";
 import { buildProtocolRetryInstruction, normalizeReviewVerdictAfterRetries, parseJsonReviewVerdict, validateOutputProtocol, } from "./output-protocol.js";
@@ -125,7 +126,7 @@ export function buildNodePrompt(spec, task, upstream, options) {
         convergenceFeedback: options?.convergenceFeedback,
     });
 }
-function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCategory, previousProtocolReason) {
+function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCategory, previousProtocolReason, recoveryTargetPaths) {
     if (attemptNumber <= 1)
         return basePrompt;
     if (previousFailureCategory === "protocol-invalid" &&
@@ -138,6 +139,22 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
         ].join("\n");
     }
     if (previousFailureCategory === "writer-empty-diff") {
+        const maxAttempts = task.retryPolicy?.maxAttempts ?? 3;
+        // When a completeness progress exists for this writer, fold the concrete
+        // target paths into the empty-diff retry so the model does not guess and
+        // does not need to read a forbidden `.harness/**` evidence file.
+        if (recoveryTargetPaths && recoveryTargetPaths.length > 0) {
+            return [
+                basePrompt,
+                "",
+                buildOutputLimitRecoverySection({
+                    attempt: attemptNumber,
+                    maxAttempts,
+                    reason: "T4",
+                    targetPaths: recoveryTargetPaths,
+                }),
+            ].join("\n");
+        }
         return [
             basePrompt,
             "",
@@ -150,6 +167,22 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
     }
     if (previousFailureCategory === "incomplete-write-set") {
         const maxAttempts = task.retryPolicy?.maxAttempts ?? 3;
+        // Embed concrete missing/broken paths from the run-owned progress facts
+        // so the continuation attempt is fully self-contained and never reads
+        // a forbidden `.harness/**` evidence file. When the loader finds no
+        // progress facts yet (rare), fall back to the path-pointing contract.
+        if (recoveryTargetPaths) {
+            return [
+                basePrompt,
+                "",
+                buildOutputLimitRecoverySection({
+                    attempt: attemptNumber,
+                    maxAttempts,
+                    reason: "T3_or_T5",
+                    targetPaths: recoveryTargetPaths,
+                }),
+            ].join("\n");
+        }
         return [
             basePrompt,
             "",
@@ -597,12 +630,18 @@ export async function executeDagNode(input) {
                 tasksById,
                 state,
             });
+            // For backend-test generation writers, load the most recent
+            // completeness progress from the run dir so the next attempt's
+            // prompt embeds concrete target paths. Undefined for non-writers
+            // or when no progress facts exist yet (no-op).
+            const recoveryProgress = await loadBackendTestWriterProgressForRetry(runDir, task.id);
+            const recoveryTargetPaths = recoveryProgress?.targetPaths;
             result = await executeNode({
                 task,
                 cwd,
                 model,
                 ...(thinking ? { thinking } : {}),
-                prompt: buildAttemptPrompt(task, prompt, attemptNumber, previousFailureCategory, previousProtocolReason),
+                prompt: buildAttemptPrompt(task, prompt, attemptNumber, previousFailureCategory, previousProtocolReason, recoveryTargetPaths),
                 attempt: attemptNumber,
                 reportActivity,
                 timeoutMs: livenessPolicy.absoluteMaxWallClockMs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.29.1",
+  "version": "0.29.2",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",