@tea-agent/loop-agent 0.25.4 → 0.25.5

package/dist/executors/shell-executor.js

@@ -10,6 +10,7 @@ import { materializeBackendTestAnalysisContract } from "../workflows/dag/backend
 import { extractBackendTestContractEnvelope } from "../workflows/dag/backend-test-contract-envelope.js";
 import { materializeFrontendImplementationContract } from "../workflows/dag/frontend-implementation-contract.js";
 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 { renderFrontendTestHtmlReport } from "../workflows/dag/frontend-test-html-report.js";
 import { formatFrontendVerificationTraceStdout, runFrontendVerificationTraceGate, } from "../workflows/dag/frontend-verification-trace.js";
@@ -20,6 +21,7 @@ import { formatFrontendReviewContextStdout, runFrontendReviewContextGate, } from
 import { materializeFrontendLintAssessment, materializeFrontendLintBaseline, } from "../workflows/dag/frontend-lint-baseline.js";
 import { formatTraceabilityGateStdout, materializeBackendTestCaseManifest, runBackendTestTraceabilityGate, } from "../workflows/dag/backend-test-case-manifest.js";
 import { materializeBackendTestExecutionContract } from "../workflows/dag/backend-test-execution-contract.js";
+import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorrespondence, materializeBackendTestCaseManifestFromFacts, } from "../workflows/dag/backend-test-case-coverage-analysis.js";
 import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport } from "../workflows/dag/backend-test-result-contract.js";
 import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, collectJacocoCoverage, hasBlockingBackendMarkdownSafetyFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
 import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
@@ -372,6 +374,14 @@ async function readRequiredRunReport(reportsDir, filename) {
         throw new Error(`missing required upstream report: reports/${filename}`);
     }
 }
+async function readAdvisoryRunReport(reportsDir, filename, title) {
+    try {
+        return await readFile(path.join(reportsDir, filename), "utf8");
+    }
+    catch {
+        return `# ${title}\n\n## Status\n\nUNAVAILABLE\n\n## Findings\n\n- Missing advisory upstream report: reports/${filename}\n`;
+    }
+}
 async function executeBackendTestPipeline(input, meta) {
     const pipeline = input.task.shell?.backendTestPipeline;
     const started = Date.now();
@@ -423,6 +433,48 @@ async function executeBackendTestPipeline(input, meta) {
                     durationMs: Date.now() - started,
                 };
             }
+            const sourceBinding = meta.spec.sourceBinding;
+            if (!sourceBinding) {
+                const coverage = "# Backend Test Case Coverage Analysis\n\n## Status\n\nUNAVAILABLE\n\n## Findings\n\n- Coverage analysis requires spec.sourceBinding; node 4 and node 7 fail closed on the same task/source binding contract.\n";
+                const coveragePath = await writeRunReport(meta.runDir, "backend-test-case-coverage-analysis.md", coverage);
+                outputs.push(`caseCoverage=${coveragePath}`, coverage);
+                return {
+                    ok: false,
+                    stdout: outputs.join("\n\n"),
+                    stderr: "backend-test markdown-cases requires spec.sourceBinding",
+                    failureCategory: "invalid-output",
+                    durationMs: Date.now() - started,
+                };
+            }
+            const normalizedBinding = {
+                taskId: sourceBinding.taskId,
+                requirementPath: sourceBinding.sources.find((s) => s.kind === "requirement")?.path ?? "source/requirement.md",
+                requirementSha256: sourceBinding.sources.find((s) => s.kind === "requirement")?.sha256 ?? "0".repeat(64),
+                referencePaths: sourceBinding.sources.filter((s) => s.kind === "reference").map((s) => s.path),
+                requirementIds: sourceBinding.requirementIds,
+            };
+            try {
+                const coverage = await analyzeBackendTestCaseCoverage({ workspaceRoot: input.cwd, sourceBinding: normalizedBinding });
+                const coveragePath = await writeRunReport(meta.runDir, "backend-test-case-coverage-analysis.md", coverage.markdown);
+                const contractsDir = path.join(meta.runDir, "contracts");
+                await mkdir(contractsDir, { recursive: true });
+                const factsPath = path.join(contractsDir, "backend-test-case-coverage-facts.json");
+                await writeFile(factsPath, JSON.stringify(coverage.facts, null, 2), "utf8");
+                outputs.push(`caseCoverage=${coveragePath}`, `caseCoverageFacts=${factsPath}`, coverage.markdown);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const coverage = `# Backend Test Case Coverage Analysis\n\n## Status\n\nUNAVAILABLE\n\n## Findings\n\n- Coverage analysis crashed and is treated as an infrastructure failure: ${message}\n`;
+                const coveragePath = await writeRunReport(meta.runDir, "backend-test-case-coverage-analysis.md", coverage);
+                outputs.push(`caseCoverage=${coveragePath}`, coverage);
+                return {
+                    ok: false,
+                    stdout: outputs.join("\n\n"),
+                    stderr: `backend-test coverage analysis crashed: ${message}`,
+                    failureCategory: "invalid-output",
+                    durationMs: Date.now() - started,
+                };
+            }
         }
         else if (pipeline === "markdown-traceability") {
             let report;
@@ -434,6 +486,60 @@ async function executeBackendTestPipeline(input, meta) {
             }
             const reportPath = await writeRunReport(meta.runDir, "backend-test-traceability.md", report);
             outputs.push(`traceability=${reportPath}`, report);
+            const sourceBinding = meta.spec.sourceBinding;
+            if (!sourceBinding) {
+                const correspondence = "# Backend Test Markdown → pytest Correspondence\n\n## Status\n\nUNAVAILABLE\n\n## Findings\n\n- Correspondence analysis requires spec.sourceBinding; nodes 4, 6 and 7 fail closed on the same task/source binding contract.\n";
+                const correspondencePath = await writeRunReport(meta.runDir, "backend-test-markdown-pytest-correspondence.md", correspondence);
+                outputs.push(`correspondence=${correspondencePath}`, correspondence);
+                return {
+                    ok: false,
+                    stdout: outputs.join("\n\n"),
+                    stderr: "backend-test markdown-traceability requires spec.sourceBinding",
+                    failureCategory: "invalid-output",
+                    durationMs: Date.now() - started,
+                };
+            }
+            try {
+                const correspondence = await analyzeBackendTestMarkdownPytestCorrespondence({ workspaceRoot: input.cwd, taskId: sourceBinding.taskId });
+                const correspondencePath = await writeRunReport(meta.runDir, "backend-test-markdown-pytest-correspondence.md", correspondence.markdown);
+                const contractsDir = path.join(meta.runDir, "contracts");
+                await mkdir(contractsDir, { recursive: true });
+                const factsPath = path.join(contractsDir, "backend-test-markdown-pytest-correspondence-facts.json");
+                await writeFile(factsPath, JSON.stringify(correspondence.facts, null, 2), "utf8");
+                outputs.push(`correspondence=${correspondencePath}`, `correspondenceFacts=${factsPath}`, correspondence.markdown);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const correspondence = `# Backend Test Markdown → pytest Correspondence\n\n## Status\n\nUNAVAILABLE\n\n## Findings\n\n- Correspondence analysis crashed and is treated as an infrastructure failure: ${message}\n`;
+                const correspondencePath = await writeRunReport(meta.runDir, "backend-test-markdown-pytest-correspondence.md", correspondence);
+                outputs.push(`correspondence=${correspondencePath}`, correspondence);
+                return {
+                    ok: false,
+                    stdout: outputs.join("\n\n"),
+                    stderr: `backend-test correspondence analysis crashed: ${message}`,
+                    failureCategory: "invalid-output",
+                    durationMs: Date.now() - started,
+                };
+            }
+        }
+        else if (pipeline === "markdown-manifest") {
+            const sourceBinding = meta.spec.sourceBinding;
+            if (!sourceBinding)
+                throw new Error("backend-test markdown-manifest requires spec.sourceBinding");
+            const manifest = await materializeBackendTestCaseManifestFromFacts({
+                runDir: meta.runDir,
+                workspaceRoot: input.cwd,
+                sourceBinding: {
+                    taskId: sourceBinding.taskId,
+                    requirementPath: sourceBinding.sources.find((s) => s.kind === "requirement")?.path ?? "source/requirement.md",
+                    requirementSha256: sourceBinding.sources.find((s) => s.kind === "requirement")?.sha256 ?? "0".repeat(64),
+                    referencePaths: sourceBinding.sources.filter((s) => s.kind === "reference").map((s) => s.path),
+                    requirementIds: sourceBinding.requirementIds,
+                },
+            });
+            const manifestPath = path.join(meta.runDir, "contracts", "backend-test-case-manifest.json");
+            const summary = manifest.coverageSummary;
+            outputs.push(`manifest=${manifestPath}`, `materializationStatus=${manifest.materializationStatus ?? "available"}`, `coverageSummary.explicitAcCount=${summary?.explicitAcCount ?? "unavailable"}`, `coverageSummary.coveredAcCount=${summary?.coveredAcCount ?? "unavailable"}`, `coverageSummary.caseCount=${summary?.caseCount ?? "unavailable"}`, `coverageSummary.generatedCount=${summary?.generatedCount ?? "unavailable"}`, `ruleCoverageSummary.ruleCount=${manifest.ruleCoverageSummary?.ruleCount ?? "unavailable"}`, `correspondenceSummary.exactCorrespondenceCount=${manifest.correspondenceSummary?.exactCorrespondenceCount ?? "unavailable"}`);
         }
         else if (pipeline === "markdown-execute-html") {
             const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd);
@@ -601,14 +707,18 @@ async function executeBackendTestPipeline(input, meta) {
             });
             const cases = await collectBackendTestHumanCaseCatalog(input.cwd);
             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 htmlContent = renderBackendTestHtml({
                 title: meta.spec.title,
                 parsed,
                 cases,
                 environmentSummary: await readFile(path.join(reportsDir, "backend-test-environment.md"), "utf8"),
                 caseValidationSummary,
+                caseCoverageSummary,
                 traceabilitySummary,
+                correspondenceSummary,
             });
             const htmlPath = await writeRunReport(meta.runDir, "backend-test.html", htmlContent);
             const facts = renderBackendTestFacts({
@@ -618,7 +728,9 @@ async function executeBackendTestPipeline(input, meta) {
                 htmlRelativePath: "reports/backend-test.html",
                 htmlContent,
                 caseValidationSummary,
+                caseCoverageSummary,
                 traceabilitySummary,
+                correspondenceSummary,
             });
             const markdownPath = await writeRunReport(meta.runDir, "backend-test.md", facts);
             const factsPath = await writeRunReport(meta.runDir, "backend-test-facts.md", facts);
@@ -681,7 +793,9 @@ async function executeBackendTestPipeline(input, meta) {
                 parsed,
                 metrics: l5Metrics,
                 caseValidationSummary,
+                caseCoverageSummary,
                 traceabilitySummary,
+                correspondenceSummary,
                 failures: failureSummaries.length > 0 ? failureSummaries : undefined,
             });
             const l5Path = await writeRunReport(meta.runDir, "backend-test-l5-dashboard.html", l5Html);
@@ -1159,6 +1273,16 @@ async function executeFrontendTestCaseChecklist(input, meta) {
         return { ok: false, stdout: "", stderr: error instanceof Error ? error.message : String(error), failureCategory: "invalid-output", durationMs: Date.now() - started };
     }
 }
+async function executeFrontendTestL5Report(input, meta) {
+    const started = Date.now();
+    try {
+        const output = await renderFrontendTestL5Report({ workspaceRoot: input.cwd, runDir: meta.runDir });
+        return { ok: true, stdout: `Frontend L-5 report: ${output.htmlPath}\nMarkdown: ${output.markdownPath}\nStatus: ${output.metrics.status}`, 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 executeFrontendTestHtmlReport(input, meta) {
     const started = Date.now();
     try {
@@ -1307,6 +1431,9 @@ export async function executeDagShellNode(input, meta) {
     if (shell?.frontendTestEvidenceValidation) {
         return executeFrontendTestEvidenceValidation(input);
     }
+    if (shell?.frontendTestL5Report) {
+        return executeFrontendTestL5Report(input, meta);
+    }
     if (shell?.frontendTestHtmlReport) {
         return executeFrontendTestHtmlReport(input, meta);
     }

package/dist/executors/shell-write-guard.js

@@ -165,8 +165,8 @@ export function validateShellWriteGuard(input) {
     return { ok: violations.length === 0, violations };
 }
 export async function readGitStatusPorcelain(cwd, options = {}) {
-    const attempts = Math.max(1, options.attempts ?? 3);
-    const retryDelayMs = Math.max(0, options.retryDelayMs ?? 100);
+    const attempts = Math.max(1, options.attempts ?? 5);
+    const retryDelayMs = Math.max(0, options.retryDelayMs ?? 150);
     let lastError;
     for (let attempt = 1; attempt <= attempts; attempt += 1) {
         try {
@@ -179,14 +179,24 @@ export async function readGitStatusPorcelain(cwd, options = {}) {
             }
         }
     }
-    throw lastError instanceof Error
-        ? lastError
-        : new Error(`git status failed after ${attempts} attempts`);
+    const detail = lastError instanceof Error ? lastError.message : String(lastError);
+    const exitCode = lastError instanceof Error &&
+        "exitCode" in lastError &&
+        typeof lastError.exitCode === "number"
+        ? String(lastError.exitCode)
+        : "unavailable";
+    const signal = lastError instanceof Error &&
+        "signal" in lastError &&
+        typeof lastError.signal === "string"
+        ? lastError.signal
+        : "unavailable";
+    throw new Error(`git status failed after ${attempts} attempts (exit code=${exitCode}, signal=${signal}, cwd=${path.resolve(cwd)}): ${detail}`, { cause: lastError });
 }
 function readGitStatusPorcelainOnce(cwd) {
     return new Promise((resolve, reject) => {
         const child = spawn("git", ["status", "--porcelain=v1", "--untracked-files=all"], {
             cwd,
+            env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
             stdio: ["ignore", "pipe", "pipe"],
         });
         let stdout = "";
@@ -200,12 +210,16 @@ function readGitStatusPorcelainOnce(cwd) {
             stderr += chunk;
         });
         child.on("error", reject);
-        child.on("close", (code) => {
+        child.on("close", (code, signal) => {
             if (code === 0) {
                 resolve(stdout);
                 return;
             }
-            reject(new Error(`git status failed: ${stderr.trim() || stdout.trim()}`));
+            const detail = stderr.trim() || stdout.trim() || "no stderr/stdout";
+            const error = new Error(`git status failed: ${detail}`);
+            error.exitCode = code;
+            error.signal = signal;
+            reject(error);
         });
     });
 }

package/dist/worker/console/repo-fingerprint.js

@@ -7,7 +7,13 @@ import path from "node:path";
  * (except a bare root). No extra case-folding on macOS/Windows.
  */
 export function normalizeWorktreeRealpath(repoRoot) {
-    let resolved = realpathSync(path.resolve(repoRoot));
+    // The legacy JS implementation preserves an input 8.3 path such as
+    // C:\\Users\\MICROS~1 on Windows. The native implementation expands the
+    // short and long aliases to the same physical path before hashing.
+    const absolute = path.resolve(repoRoot);
+    let resolved = process.platform === "win32"
+        ? realpathSync.native(absolute)
+        : realpathSync(absolute);
     if (/^[a-zA-Z]:/.test(resolved)) {
         resolved = resolved[0].toUpperCase() + resolved.slice(1);
     }