@tea-agent/loop-agent 0.37.0 → 0.37.1-beta.0

package/dist/commands/task-advance.js

@@ -1,6 +1,5 @@
 import { advanceTaskLifecycle, } from "../application/task-lifecycle/index.js";
 import { buildOperatorResult, operatorFailed, processExitCodeForOutcome, writeOperatorJson, } from "../shared/operator/index.js";
-import { createRunDagProgressObserver, validateRunDagProgressIntervalMs, } from "./run-dag-progress.js";
 const COMMAND = "task advance";
 const USAGE = `usage:
   task advance <task-id> [title]
@@ -25,8 +24,6 @@ const USAGE = `usage:
     [--dag-output <path>]
     [--skip-finalize]
     [--no-strict-models]
-    [--quiet]
-    [--progress-interval-ms <ms>]
     [--dry-run]
     [--json]`;
 function pushList(target, value) {
@@ -173,19 +170,6 @@ export function parseTaskAdvanceArgs(args) {
             options.strictModels = false;
             continue;
         }
-        if (token === "--quiet") {
-            options.quiet = true;
-            continue;
-        }
-        if (token === "--progress-interval-ms") {
-            const raw = next();
-            const parsed = Number(raw);
-            if (!Number.isFinite(parsed)) {
-                throw new Error(`progress-interval-ms must be an integer >= 1000\n${USAGE}`);
-            }
-            options.progressIntervalMs = validateRunDagProgressIntervalMs(parsed);
-            continue;
-        }
         if (token === "--help" || token === "-h") {
             throw new Error(USAGE);
         }
@@ -224,7 +208,7 @@ function mapOutcome(result) {
         return "blocked";
     return "succeeded";
 }
-export function toUseCaseInput(repoRoot, taskId, options, observer) {
+function toUseCaseInput(repoRoot, taskId, options) {
     const timeouts = new Map((options.verifyTimeout ?? []).map((entry) => {
         const parsed = parseVerifyTimeout(entry);
         return [parsed.label, parsed.timeoutMs];
@@ -287,8 +271,7 @@ export function toUseCaseInput(repoRoot, taskId, options, observer) {
         dagOutputPath: options.dagOutputPath,
         skipFinalize: options.skipFinalize,
         strictModels: options.strictModels,
-        ...(observer ? { observer } : {}),
-        onProgress: options.quiet
+        onProgress: options.json
             ? undefined
             : (message) => {
                 process.stderr.write(`[task advance] ${message}\n`);
@@ -313,18 +296,8 @@ export async function runTaskAdvance(repoRoot, args) {
         process.exitCode = processExitCodeForOutcome(envelope.outcome);
         return;
     }
-    let progress;
     try {
-        // AC-006/AC-007: periodic DAG progress goes to stderr only (stdout stays
-        // the single final OperatorCommandResultV1 JSON). The observer is created
-        // ONLY for the approve-gate execution path and disposed on every exit;
-        // its timer starts only after onRunStart (double guard, no stray timer).
-        if (options.approveGate && !options.dryRun && !options.quiet) {
-            progress = createRunDagProgressObserver({
-                intervalMs: options.progressIntervalMs,
-            });
-        }
-        const result = await advanceTaskLifecycle(toUseCaseInput(repoRoot, taskId, options, progress?.observer));
+        const result = await advanceTaskLifecycle(toUseCaseInput(repoRoot, taskId, options));
         const outcome = mapOutcome(result);
         const gateStop = result.lifecycleState === "awaiting-write-set-approval" &&
             result.blockers.length === 0;
@@ -360,7 +333,4 @@ export async function runTaskAdvance(repoRoot, args) {
         writeOperatorJson(envelope);
         process.exitCode = processExitCodeForOutcome(envelope.outcome);
     }
-    finally {
-        progress?.dispose();
-    }
 }

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

@@ -194,7 +194,7 @@ export function buildDagPiUserMessage(task, persona, step) {
     if (isDagPiWriteTask(task)) {
         const outcomeInstruction = task.writerOutcomePolicy
             ? [
-                "The first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked. The runner measures your diff mechanically from git status snapshots taken before and after this node: code pasted into the response text is NOT an implementation and yields an empty diff. Use changed only after actually calling write/edit tools that persist files to disk; use already-satisfied only when the contract is already met and no file changed; use blocked when implementation cannot proceed. Claiming changed without a persisted diff fails this node as invalid-output.",
+                "The first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked. Use changed only after producing a non-empty bounded diff; use already-satisfied only when the contract is already met and no file changed; use blocked when implementation cannot proceed.",
                 task.writerOutcomePolicy.requireChangedFiles
                     ? "This generation node requires a non-empty bounded diff; already-satisfied cannot complete it successfully."
                     : undefined,
@@ -206,8 +206,6 @@ export function buildDagPiUserMessage(task, persona, step) {
             `You are executing hybrid DAG node "${task.id}" (role=${role}, piStep=${step}, writePolicy=${writePolicy}).`,
             "The system prompt contains the full DAG envelope: objective, constraints, upstream context, and task.",
             "Use write tools only for the bounded implementation requested by this node.",
-            "The upstream plan node's output is a BLUEPRINT, not a deliverable: reading it never satisfies this node. You MUST materialize the plan into actual working-tree changes by calling write/edit tools before claiming changed. A detailed plan that names every file, test, or snippet still requires you to write those files yourself.",
-            "Forbidden paths bound the writeSet, not the task: when the task only requires writing inside the writeSet (e.g. adding tests that call existing public APIs), a forbidden src/** does not make the task impossible — do NOT claim blocked merely because some path you never need to write is forbidden. blocked is only for when you genuinely cannot produce the required writeSet changes.",
             outcomeInstruction,
             `Allowed paths: ${(task.allowedPaths ?? []).join(", ") || "(none declared)"}.`,
             `Write set: ${(task.writeSet ?? []).join(", ") || "(none declared)"}.`,
@@ -522,33 +520,6 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     }
     let result;
     try {
-        // Phase 5 (P1-9): capture the writeSet baseline BEFORE the writer provider
-        // call so a transient partial write can be rolled back and recovered via a
-        // staged child. Only frontend-implementation writers; a failed capture is a
-        // hard fail (no baseline → no rollback → no recovery). Dynamic import avoids
-        // an executor ↔ scheduler static cycle.
-        if (isWriteTask &&
-            (input.task.id === "frontend-implement-pi" ||
-                input.task.id === "frontend-repair-pi") &&
-            (input.task.writeSet?.length ?? 0) > 0) {
-            try {
-                const { captureFrontendWriterAttemptIntent } = await import("../workflows/dag/frontend-writer-recovery.js");
-                await captureFrontendWriterAttemptIntent({
-                    cwd: input.cwd,
-                    runDir: meta.runDir,
-                    writeSet: input.task.writeSet,
-                });
-            }
-            catch (error) {
-                return {
-                    ok: false,
-                    stdout: "",
-                    stderr: `frontend writer attempt baseline capture failed: ${error instanceof Error ? error.message : String(error)}`,
-                    failureCategory: "write-guard",
-                    durationMs: Date.now() - started,
-                };
-            }
-        }
         result = await piStepFn({
             attachedFiles: [],
             modelConfig: resolveDagPiModelConfig(input.model, input.thinking ? { thinking: input.thinking } : undefined),
@@ -720,23 +691,6 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             const changedFiles = pathsChangedDuringRun(snapshotGitStatusPorcelain(beforeStatus), afterSnapshot, beforePathFingerprints, afterPathFingerprints);
             changeManifestAfterStatus = afterStatus;
             changeManifestChangedFiles = changedFiles;
-            // Phase 5: record the attempt changed paths/hashes into the rollback
-            // intent so a transient partial write can be CAS-restored.
-            if ((input.task.id === "frontend-implement-pi" ||
-                input.task.id === "frontend-repair-pi") &&
-                (input.task.writeSet?.length ?? 0) > 0) {
-                try {
-                    const { recordFrontendWriterAttempt } = await import("../workflows/dag/frontend-writer-recovery.js");
-                    await recordFrontendWriterAttempt({
-                        cwd: input.cwd,
-                        runDir: meta.runDir,
-                        changedPaths: changedFiles,
-                    });
-                }
-                catch {
-                    // best-effort: a missing intent (no baseline captured) is a no-op
-                }
-            }
             const guard = validateShellWriteGuardFromDiff({
                 changedFiles,
                 task: input.task,
@@ -977,6 +931,15 @@ function parseWriterImplementationOutcome(text) {
     const lines = text.split(/\r?\n/);
     const candidates = [];
     for (const [lineIndex, line] of lines.entries()) {
+        const localizedOutcome = localizedWriterImplementationOutcome(line);
+        if (localizedOutcome) {
+            candidates.push({
+                lineIndex,
+                value: localizedOutcome,
+                outcome: localizedOutcome,
+            });
+            continue;
+        }
         const nextLine = lines[lineIndex + 1];
         const normalized = normalizeProtocolLine(line, WRITER_OUTCOME_PROTOCOL_LINE, nextLine);
         if (normalized === undefined)
@@ -1005,6 +968,26 @@ function parseWriterImplementationOutcome(text) {
         candidates,
     };
 }
+function localizedWriterImplementationOutcome(line) {
+    const normalized = normalizedProtocolValue(line);
+    const match = /^(?:实现|实施)结果\s*[:：]\s*(已变更|已更改|已修改|已满足|无需变更|已阻塞|阻塞)$/u.exec(normalized);
+    if (!match)
+        return undefined;
+    switch (match[1]) {
+        case "已变更":
+        case "已更改":
+        case "已修改":
+            return "changed";
+        case "已满足":
+        case "无需变更":
+            return "already-satisfied";
+        case "已阻塞":
+        case "阻塞":
+            return "blocked";
+        default:
+            return undefined;
+    }
+}
 function isWriterImplementationOutcome(value) {
     return (value === "changed" || value === "already-satisfied" || value === "blocked");
 }

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

@@ -78,40 +78,6 @@ export async function checkPiSdkAvailability(_repoRoot) {
         return { ok: false, detail: `pi SDK not available: ${message}` };
     }
 }
-/**
- * Best-effort Pi SDK model catalog (credentialed providers first).
- * Empty on SDK/auth/runtime failure — callers must fall back to harness tiers.
- */
-export async function listPiSdkAvailableModels() {
-    try {
-        const imported = sdkImportOverrideForTests
-            ? await sdkImportOverrideForTests()
-            : await loadPiSdkModule();
-        const sdk = imported;
-        const getAgentDir = sdk.getAgentDir;
-        const ModelRuntime = sdk.ModelRuntime;
-        if (typeof getAgentDir !== "function" || typeof ModelRuntime?.create !== "function") {
-            return [];
-        }
-        const agentDir = getAgentDir();
-        const runtime = await ModelRuntime.create({
-            authPath: path.join(agentDir, "auth.json"),
-            modelsPath: path.join(agentDir, "models.json"),
-        });
-        const snapshot = runtime.snapshot ?? {};
-        const configured = snapshot.configuredProviders;
-        const isConfigured = (provider) => configured instanceof Set ? configured.has(provider) : false;
-        return (snapshot.available ?? []).map((entry) => ({
-            provider: entry.provider,
-            id: entry.id,
-            name: entry.name,
-            hasCredentials: isConfigured(entry.provider),
-        }));
-    }
-    catch {
-        return [];
-    }
-}
 /** Fail-closed probe for the SDK-only structured custom-tool surface. */
 export async function checkPiSdkCustomToolCapability(_repoRoot) {
     if (sdkSessionFactoryOverride) {

package/dist/executors/shell-executor.js

@@ -31,7 +31,7 @@ import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorresp
 import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport, } from "../workflows/dag/backend-test-result-contract.js";
 import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, resolveBackendTestMappedPytestScripts, collectJacocoCoverage, hasBlockingBackendMarkdownSafetyFindings, hasBlockingBackendMarkdownModuleStemFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
 import { applyDeterministicScenarioParamRepairs, assessBackendScenarioParamConsistency, classifyBackendTestFailureWithScenarioParam, readBackendScenarioParamFacts, renderBackendTestFailureAnalysis, writeBackendScenarioParamArtifacts, writeScenarioParamRepairAudit, } from "../workflows/dag/backend-test-scenario-param.js";
-import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assessPriorityOnlyBackendPytestModules, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
+import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assessPriorityOnlyBackendPytestModules, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, buildBackendTestItemEligibility, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
 import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
@@ -678,6 +678,42 @@ async function executeBackendTestPipeline(input, meta) {
                     fixtureResolution,
                 });
             }
+            try {
+                const correspondence = await analyzeBackendTestMarkdownPytestCorrespondence({
+                    workspaceRoot: input.cwd,
+                    taskId: meta.spec.sourceBinding?.taskId ?? "unbound",
+                });
+                const correspondenceReportPath = await writeRunReport(meta.runDir, "backend-test-markdown-pytest-correspondence-initial.md", correspondence.markdown);
+                const contractsDir = path.join(meta.runDir, "contracts");
+                await mkdir(contractsDir, { recursive: true });
+                const correspondenceFactsPath = path.join(contractsDir, "backend-test-markdown-pytest-correspondence-initial.json");
+                await writeFile(correspondenceFactsPath, JSON.stringify(correspondence.facts, null, 2), "utf8");
+                outputs.push(`initialCorrespondence=${correspondenceReportPath}`, `initialCorrespondenceFacts=${correspondenceFactsPath}`);
+                if (correspondence.facts.status === "FAIL" && facts.status === "PASS") {
+                    const correspondenceRepairPaths = Array.from(new Set(correspondence.facts.entries
+                        .filter((entry) => entry.status !== "EXACT_1_TO_1")
+                        .flatMap((entry) => [entry.expectedScript, ...entry.actualScripts])
+                        .filter((candidate) => candidate.startsWith("testcase/") && candidate.endsWith(".py")))).sort();
+                    if (correspondenceRepairPaths.length > 0) {
+                        facts.status = "REPAIRABLE";
+                        facts.repairEligible = true;
+                        facts.repairPaths = Array.from(new Set([...facts.repairPaths, ...correspondenceRepairPaths])).sort();
+                        facts.findings.push({
+                            kind: "markdown-pytest-correspondence",
+                            classification: "test-asset-defect",
+                            repairability: "repairable",
+                            detail: correspondence.facts.entries
+                                .filter((entry) => entry.status !== "EXACT_1_TO_1")
+                                .flatMap((entry) => entry.findings)
+                                .join("; ")
+                                .slice(0, 12_000) || "Markdown-to-pytest correspondence is incomplete",
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                outputs.push(`initialCorrespondence=UNAVAILABLE: ${error instanceof Error ? error.message : String(error)}`);
+            }
             const artifacts = await writeBackendPytestCollectionArtifacts({
                 runDir: meta.runDir,
                 stem: "initial",
@@ -776,12 +812,56 @@ async function executeBackendTestPipeline(input, meta) {
                 facts: effective,
             });
             const scenarioFacts = await readBackendScenarioParamFacts(path.join(meta.runDir, "contracts", "backend-test-scenario-param-consistency-facts.json"));
+            const correspondence = meta.spec.sourceBinding
+                ? await analyzeBackendTestMarkdownPytestCorrespondence({
+                    workspaceRoot: input.cwd,
+                    taskId: meta.spec.sourceBinding.taskId,
+                })
+                : undefined;
+            const eligibility = correspondence
+                ? buildBackendTestItemEligibility(effective.collectedItemIds, {
+                    correspondenceEntries: correspondence.facts.entries,
+                    scenarioEntries: scenarioFacts.entries,
+                })
+                : { eligibleItemIds: effective.collectedItemIds, excludedItems: [] };
+            const eligibilityInputHashes = Object.fromEntries((correspondence?.facts.inputFiles ?? []).map((item) => [item.path, item.sha256]));
+            const eligibilityFactsPath = path.join(meta.runDir, "contracts", "backend-test-execution-eligibility.json");
+            await mkdir(path.dirname(eligibilityFactsPath), { recursive: true });
+            await writeFile(eligibilityFactsPath, `${JSON.stringify({
+                schemaId: "backend-test-execution-eligibility-v1",
+                status: eligibility.eligibleItemIds.length === 0 ? "BLOCKED" : eligibility.excludedItems.length > 0 ? "PARTIAL" : "PASS",
+                collectedItemCount: effective.collectedItemIds.length,
+                eligibleItemCount: eligibility.eligibleItemIds.length,
+                excludedItemCount: eligibility.excludedItems.length,
+                eligibleItemIds: eligibility.eligibleItemIds,
+                excludedItems: eligibility.excludedItems,
+                inputHashes: eligibilityInputHashes,
+            }, null, 2)}\n`, "utf8");
+            const eligibilityReportPath = await writeRunReport(meta.runDir, "backend-test-execution-eligibility.md", [
+                "# Backend Test Execution Eligibility",
+                "",
+                "## Status",
+                "",
+                eligibility.eligibleItemIds.length === 0 ? "BLOCKED" : eligibility.excludedItems.length > 0 ? "PARTIAL" : "PASS",
+                "",
+                `- Collected items: ${effective.collectedItemIds.length}`,
+                `- Eligible items: ${eligibility.eligibleItemIds.length}`,
+                `- Excluded items: ${eligibility.excludedItems.length}`,
+                "",
+                "## Excluded Items",
+                "",
+                ...(eligibility.excludedItems.length > 0 ? eligibility.excludedItems.map((item) => `- \`${item.itemId}\` (${item.caseId ?? "unknown Case"}): ${item.reasons.join("; ")}`) : ["- None"]),
+                "",
+            ].join("\n"));
+            outputs.push(`executionEligibility=${eligibilityReportPath}`, `executionEligibilityFacts=${eligibilityFactsPath}`);
             const readiness = await materializeBackendTestExecutionReadiness({
                 runDir: meta.runDir,
                 workspaceRoot: input.cwd,
                 effective,
                 scenarioParamStatus: scenarioFacts.overallStatus,
                 scenarioParamRepairAttempt: scenarioFacts.repairAttempt,
+                eligibility,
+                eligibilityInputHashes,
             });
             return {
                 ok: true,
@@ -792,6 +872,8 @@ async function executeBackendTestPipeline(input, meta) {
                     collectedItemCount: effective.collectedItemCount,
                     fixtureResolutionStatus: effective.fixtureResolutionStatus,
                     executionReadinessStatus: readiness.status,
+                    eligibleItemCount: readiness.eligibleItemIds.length,
+                    excludedItemCount: readiness.excludedItems.length,
                     factsPath: "contracts/backend-test-pytest-collection-effective.json",
                     readinessPath: "contracts/backend-test-execution-readiness.json",
                     reportPath: artifacts.reportPath,
@@ -889,8 +971,11 @@ async function executeBackendTestPipeline(input, meta) {
             const executionReadiness = await readBackendTestExecutionReadiness(path.join(meta.runDir, "contracts", "backend-test-execution-readiness.json"));
             await assertBackendTestExecutionReadinessFresh(input.cwd, executionReadiness);
             const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd);
-            const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
-            const pytestTargets = mappedScripts.map(shellQuote).join(" ");
+            const eligibleItemIds = executionReadiness.eligibleItemIds;
+            const pytestTargetsRelative = "reports/backend-test-pytest-targets.txt";
+            const pytestTargetsAbsolute = path.join(meta.runDir, pytestTargetsRelative);
+            await writeFile(pytestTargetsAbsolute, `${eligibleItemIds.join("\n")}\n`, "utf8");
+            const pytestTargetsArg = `@\"\${HARNESS_DAG_RUN_DIR}/${pytestTargetsRelative}\"`;
             // Split into short bash -c commands (aligned with markdown-environment).
             // A single ultra-long compound command has been observed on Windows to
             // exit 0xC0000142 (STATUS_DLL_INIT_FAILED) in ~40ms with empty stdout/
@@ -967,8 +1052,10 @@ async function executeBackendTestPipeline(input, meta) {
                 'PYTHON_BIN="$(command -v python || command -v python3 || true)"',
                 'if [ -z "${PYTHON_BIN}" ]; then echo "python/python3 is required for backend-test execution" | tee -a "${DIAG_FILE}" >&2; exit 127; fi',
                 'echo "STEP=pytest-run"',
-                `echo "- pytestCommand: python -m pytest ${mappedScripts.join(" ")} -v -p no:cacheprovider --html=reports/backend-test.html --self-contained-html" >> "\${DIAG_FILE}"`,
-                `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 "\${PYTHON_BIN}" -m pytest ${pytestTargets} -v -p no:cacheprovider --html="\${HARNESS_DAG_RUN_DIR}/reports/backend-test.html" --self-contained-html`,
+                `echo "- pytestCommand: python -m pytest <${eligibleItemIds.length} eligibility-authorized-items> -v -p no:cacheprovider --html=reports/backend-test.html --self-contained-html" >> "\${DIAG_FILE}"`,
+                `echo "- eligibleItemCount: ${eligibleItemIds.length}" >> "\${DIAG_FILE}"`,
+                `echo "- excludedItemCount: ${executionReadiness.excludedItems.length}" >> "\${DIAG_FILE}"`,
+                `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 "\${PYTHON_BIN}" -m pytest ${pytestTargetsArg} -v -p no:cacheprovider --html="\${HARNESS_DAG_RUN_DIR}/reports/backend-test.html" --self-contained-html`,
                 "STATUS=$?",
                 'printf "%s" "${STATUS}" > "${HARNESS_DAG_RUN_DIR}/reports/backend-test-pytest-exit.txt"',
                 'echo "- pytestExitCode: ${STATUS}" >> "${DIAG_FILE}"',
@@ -1057,7 +1144,9 @@ async function executeBackendTestPipeline(input, meta) {
             const caseValidationSummary = await readRequiredRunReport(reportsDir, "backend-md-case-validation.md");
             const caseCoverageSummary = await readAdvisoryRunReport(reportsDir, "backend-test-case-coverage-analysis.md", "Backend Test Case Coverage Analysis");
             const traceabilitySummary = await readRequiredRunReport(reportsDir, "backend-test-traceability.md");
-            const correspondenceSummary = await readAdvisoryRunReport(reportsDir, "backend-test-markdown-pytest-correspondence.md", "Backend Test Markdown → pytest Correspondence");
+            const correspondenceSummaryBase = await readAdvisoryRunReport(reportsDir, "backend-test-markdown-pytest-correspondence.md", "Backend Test Markdown → pytest Correspondence");
+            const eligibilitySummary = await readAdvisoryRunReport(reportsDir, "backend-test-execution-eligibility.md", "Backend Test Execution Eligibility");
+            const correspondenceSummary = `${correspondenceSummaryBase.trim()}\n\n${eligibilitySummary.trim()}\n`;
             const htmlContent = renderBackendTestHtml({
                 title: meta.spec.title,
                 parsed,