@tea-agent/loop-agent 0.25.3 → 0.25.5

package/dist/commands/run-dag-progress.js

@@ -0,0 +1,109 @@
+export const DEFAULT_RUN_DAG_PROGRESS_INTERVAL_MS = 30_000;
+function formatDuration(durationMs) {
+    const totalSeconds = Math.max(0, Math.floor(durationMs / 1_000));
+    const hours = Math.floor(totalSeconds / 3_600);
+    const minutes = Math.floor((totalSeconds % 3_600) / 60);
+    const seconds = totalSeconds % 60;
+    if (hours > 0)
+        return `${hours}h${String(minutes).padStart(2, "0")}m`;
+    if (minutes > 0)
+        return `${minutes}m${String(seconds).padStart(2, "0")}s`;
+    return `${seconds}s`;
+}
+function countStatuses(state) {
+    const counts = { finished: 0, running: 0, pending: 0, error: 0, skipped: 0 };
+    for (const node of Object.values(state.nodes)) {
+        if (node.status === "FINISHED")
+            counts.finished += 1;
+        else if (node.status === "RUNNING")
+            counts.running += 1;
+        else if (node.status === "ERROR")
+            counts.error += 1;
+        else if (node.status === "SKIPPED")
+            counts.skipped += 1;
+        else
+            counts.pending += 1;
+    }
+    return `finished=${counts.finished} running=${counts.running} pending=${counts.pending} error=${counts.error} skipped=${counts.skipped}`;
+}
+function nodeElapsedMs(node, now) {
+    const startedAt = node.startedAt ? Date.parse(node.startedAt) : Number.NaN;
+    return Number.isFinite(startedAt) ? Math.max(0, now - startedAt) : 0;
+}
+function activeNodeSummary(state, now) {
+    const running = Object.values(state.nodes).filter((node) => node.status === "RUNNING");
+    if (running.length === 0)
+        return "nodes=none";
+    return running
+        .map((node) => {
+        const details = [
+            `${node.id}(${formatDuration(nodeElapsedMs(node, now))}`,
+            node.livenessStatus ? `liveness=${node.livenessStatus}` : undefined,
+            node.currentAttempt ? `attempt=${node.currentAttempt}` : undefined,
+        ]
+            .filter(Boolean)
+            .join(" ");
+        return `${details})`;
+    })
+        .join(",");
+}
+/**
+ * Human-readable CLI progress written to stderr. The final run-dag JSON remains
+ * the only stdout payload, so machine callers can continue parsing stdout.
+ */
+export function createRunDagProgressObserver(options = {}) {
+    const intervalMs = options.intervalMs ?? DEFAULT_RUN_DAG_PROGRESS_INTERVAL_MS;
+    const write = options.write ?? ((text) => process.stderr.write(text));
+    const now = options.now ?? Date.now;
+    let latestState;
+    let timer;
+    const emit = (message) => {
+        try {
+            write(`[run-dag] ${message}\n`);
+        }
+        catch {
+            // Progress is a derived CLI view and must never decide DAG execution.
+        }
+    };
+    const stop = () => {
+        if (timer)
+            clearInterval(timer);
+        timer = undefined;
+    };
+    const start = () => {
+        if (timer || intervalMs <= 0)
+            return;
+        timer = setInterval(() => {
+            if (!latestState)
+                return;
+            emit(`heartbeat run=${latestState.runId} ${countStatuses(latestState)} ${activeNodeSummary(latestState, now())}`);
+        }, intervalMs);
+        timer.unref?.();
+    };
+    const observer = {
+        onRunStart: (state) => {
+            latestState = state;
+            emit(`started run=${state.runId} nodes=${Object.keys(state.nodes).length} title=${JSON.stringify(state.title)}`);
+            start();
+        },
+        onNodeStart: (nodeId, state) => {
+            latestState = state;
+            const node = state.nodes[nodeId];
+            emit(`node-started run=${state.runId} node=${nodeId} executor=${node?.executor ?? "unknown"} ${countStatuses(state)}`);
+        },
+        onNodeOutput: (_nodeId, _chunk, state) => {
+            latestState = state;
+        },
+        onNodeFinish: (nodeId, state) => {
+            latestState = state;
+            const node = state.nodes[nodeId];
+            emit(`node-finished run=${state.runId} node=${nodeId} status=${node?.status ?? "unknown"} duration=${formatDuration(node?.durationMs ?? 0)} ${countStatuses(state)}`);
+        },
+        onRunFinish: (state) => {
+            latestState = state;
+            stop();
+            emit(`finished run=${state.runId} status=${state.status} ${countStatuses(state)}`);
+        },
+    };
+    return { observer, dispose: stop };
+}

package/dist/commands/run-dag.js

@@ -1,11 +1,22 @@
 import { parseRunDagArgs } from "../application/dag/args.js";
 import { runDagUseCase } from "../application/dag/run-dag.js";
+import { createRunDagProgressObserver } from "./run-dag-progress.js";
 export { parseRunDagArgs };
 export async function runRunDag(repoRoot, rawArgs) {
     const parsed = parseRunDagArgs(rawArgs, repoRoot);
-    const result = await runDagUseCase({
-        repoRoot,
-        ...parsed,
-    });
-    console.log(JSON.stringify(result, null, 2));
+    const { quiet, progressIntervalMs, ...runInput } = parsed;
+    const progress = quiet || parsed.dryRun || parsed.initOnly
+        ? undefined
+        : createRunDagProgressObserver({ intervalMs: progressIntervalMs });
+    try {
+        const result = await runDagUseCase({
+            repoRoot,
+            ...runInput,
+            observer: progress?.observer,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    }
+    finally {
+        progress?.dispose();
+    }
 }

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

@@ -4,6 +4,7 @@ import { writeDagNodeJsonArtifact, writeTextArtifactFile, } from "../infrastruct
 import { executePiStep, } from "./pi-executor.js";
 import { redactPromptForLog, truncateOutput, } from "../shared/output-truncation.js";
 import { pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
+import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
 export const DAG_PI_READONLY_TOOLS = ["read", "grep", "find", "ls"];
 export const DAG_PI_WRITE_TOOLS = [
     "read",
@@ -15,6 +16,7 @@ export const DAG_PI_WRITE_TOOLS = [
     "ls",
 ];
 export const DEFAULT_DAG_PI_PROVIDER = "wizard-local";
+const WRITER_OUTCOME_PROTOCOL_LINE = "IMPLEMENTATION_OUTCOME:";
 export const DAG_PI_MODEL_PROVIDERS = {
     "gpt-5.3-codex-spark": "wizard-local",
     "gpt-5.5": "wizard-local",
@@ -266,9 +268,14 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
             beforeStatus = await readGitStatusPorcelain(input.cwd);
             beforePathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, snapshotGitStatusPorcelain(beforeStatus));
         }
-        catch {
-            beforeStatus = undefined;
-            beforePathFingerprints = undefined;
+        catch (error) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: `writer Git baseline unavailable before Pi execution: ${error instanceof Error ? error.message : String(error)}`,
+                failureCategory: "write-guard",
+                durationMs: Date.now() - started,
+            };
         }
     }
     const reportActivity = input.reportActivity;
@@ -319,7 +326,9 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         persona,
         step,
     });
-    const mapped = mapPiResultToDagNodeResult(result, input.task.firstProtocolLine);
+    const mapped = mapPiResultToDagNodeResult(result, input.task.writerOutcomePolicy
+        ? WRITER_OUTCOME_PROTOCOL_LINE
+        : input.task.firstProtocolLine);
     if (!isWriteTask) {
         return mapped;
     }
@@ -399,38 +408,94 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
     };
 }
 export function validateWriterImplementationOutcome(text, changedFiles) {
-    const firstLine = text
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .find(Boolean);
-    const match = firstLine?.match(/^IMPLEMENTATION_OUTCOME: (changed|already-satisfied|blocked)$/);
-    if (!match) {
+    const parsed = parseWriterImplementationOutcome(text);
+    const diagnostics = writerOutcomeDiagnostics(text, parsed, changedFiles.length);
+    if (parsed.kind !== "valid") {
         return {
             ok: false,
-            reason: "writer outcome validation failed: missing or invalid first line; expected IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked",
+            reason: `writer outcome validation failed: ${parsed.kind} outcome; ${diagnostics}; expected IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked`,
         };
     }
-    const outcome = match[1];
+    const outcome = parsed.outcome;
     if (outcome === "blocked") {
         return {
             ok: false,
-            reason: "writer outcome validation failed: IMPLEMENTATION_OUTCOME: blocked cannot complete successfully",
+            reason: `writer outcome validation failed: IMPLEMENTATION_OUTCOME: blocked cannot complete successfully; ${diagnostics}`,
         };
     }
     if (outcome === "changed" && changedFiles.length === 0) {
         return {
             ok: false,
-            reason: "writer outcome validation failed: changed outcome has an empty diff",
+            reason: `writer outcome validation failed: changed outcome has an empty diff; ${diagnostics}`,
         };
     }
     if (outcome === "already-satisfied" && changedFiles.length > 0) {
         return {
             ok: false,
-            reason: "writer outcome validation failed: already-satisfied outcome has a non-empty diff",
+            reason: `writer outcome validation failed: already-satisfied outcome has a non-empty diff; ${diagnostics}`,
         };
     }
     return { ok: true, outcome };
 }
+function parseWriterImplementationOutcome(text) {
+    const lines = text.split(/\r?\n/);
+    const candidates = [];
+    for (const [lineIndex, line] of lines.entries()) {
+        const nextLine = lines[lineIndex + 1];
+        const normalized = normalizeProtocolLine(line, WRITER_OUTCOME_PROTOCOL_LINE, nextLine);
+        if (normalized === undefined)
+            continue;
+        const value = normalized
+            .slice(WRITER_OUTCOME_PROTOCOL_LINE.length)
+            .trim();
+        const outcome = isWriterImplementationOutcome(value)
+            ? value
+            : undefined;
+        candidates.push({
+            lineIndex,
+            value,
+            outcome,
+        });
+    }
+    if (candidates.length === 0) {
+        return { kind: "missing", candidates };
+    }
+    if (candidates.some((candidate) => candidate.outcome === undefined)) {
+        return { kind: "unknown", candidates };
+    }
+    const outcomes = new Set(candidates.map((candidate) => candidate.outcome));
+    if (outcomes.size !== 1) {
+        return { kind: "conflicting", candidates };
+    }
+    return {
+        kind: "valid",
+        outcome: candidates[0].outcome,
+        candidates,
+    };
+}
+function isWriterImplementationOutcome(value) {
+    return (value === "changed" ||
+        value === "already-satisfied" ||
+        value === "blocked");
+}
+function writerOutcomeDiagnostics(text, parsed, changedFiles) {
+    const firstNonEmpty = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean) ?? "(empty)";
+    const candidateSummary = parsed.candidates.length === 0
+        ? "none"
+        : parsed.candidates
+            .slice(0, 4)
+            .map((candidate) => candidate.outcome
+            ? `${candidate.outcome}@line${candidate.lineIndex + 1}`
+            : `unknown(${boundedWriterDiagnostic(candidate.value)})@line${candidate.lineIndex + 1}`)
+            .join(",");
+    return `firstNonEmpty=${boundedWriterDiagnostic(firstNonEmpty)}; candidates=${candidateSummary}; changedFiles=${changedFiles}`;
+}
+function boundedWriterDiagnostic(value) {
+    return JSON.stringify(truncateUtf8Preview(redactSecrets(value), 160));
+}
 export function mapPiResultToDagNodeResult(result, firstProtocolLine) {
     const assistantText = canonicalizeProtocolFirstLine(result.assistantText, firstProtocolLine);
     return {

package/dist/executors/model-routing.js

@@ -1,7 +1,7 @@
 import { DEFAULT_DAG_EXECUTOR_MODELS, } from '../workflows/dag/types.js';
 export const DEFAULT_DAG_MODELS = {
     HIGH: "gpt-5.5",
-    MED: "glm-5.2",
+    MED: "gpt-5.5",
     LOW: "gpt-5.3-codex-spark",
 };
 /**

package/dist/executors/shell-executor.js

@@ -10,6 +10,9 @@ 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";
 import { formatFrontendWorktreeDiffStdout, runFrontendWorktreeDiffGate, } from "../workflows/dag/frontend-worktree-diff.js";
 import { formatFrontendFailureAssessStdout, formatFrontendRepairContractStdout, runFrontendFailureAssessGate, runFrontendRepairContractGate, } from "../workflows/dag/frontend-repair.js";
@@ -18,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";
@@ -370,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();
@@ -421,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;
@@ -432,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);
@@ -599,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({
@@ -616,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);
@@ -679,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);
@@ -1143,6 +1259,40 @@ async function executeFrontendVerificationBundle(input, meta) {
         };
     }
 }
+async function executeFrontendTestCaseChecklist(input, meta) {
+    const started = Date.now();
+    try {
+        const declaredAcIds = (meta.spec.sourceBinding?.requirementIds ?? []).filter((id) => /^AC(?:-[A-Z0-9]+)+$/i.test(id));
+        const result = await validateFrontendCaseChecklist({ workspaceRoot: input.cwd, declaredAcIds });
+        if (result.issues.length) {
+            return { ok: false, stdout: "", stderr: `frontend-test checklist blocked: ${JSON.stringify(result.issues)}`, failureCategory: "invalid-output", durationMs: Date.now() - started };
+        }
+        return { ok: true, stdout: `frontend-test checklist ok cases=${result.caseCount} source=${path.basename(result.manifestPath)}`, 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 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 {
+        const output = await renderFrontendTestHtmlReport({ workspaceRoot: input.cwd, runDir: meta.runDir });
+        return { ok: true, stdout: `Frontend test report: ${output.htmlPath}\nMarkdown: ${output.markdownPath}\nOutcome: ${output.outcome}\nCases: ${output.caseCount}`, 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 executeFrontendTestEvidenceValidation(input) {
     const started = Date.now();
     try {
@@ -1275,9 +1425,18 @@ export async function executeDagShellNode(input, meta) {
             return { ok: false, stdout: "", stderr: error instanceof Error ? error.message : String(error), failureCategory: "invalid-output", durationMs: Date.now() - started };
         }
     }
+    if (shell?.frontendTestCaseChecklist) {
+        return executeFrontendTestCaseChecklist(input, meta);
+    }
     if (shell?.frontendTestEvidenceValidation) {
         return executeFrontendTestEvidenceValidation(input);
     }
+    if (shell?.frontendTestL5Report) {
+        return executeFrontendTestL5Report(input, meta);
+    }
+    if (shell?.frontendTestHtmlReport) {
+        return executeFrontendTestHtmlReport(input, meta);
+    }
     if (shell?.backendTestPipeline) {
         return executeBackendTestPipelineWithWriteGuard(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);
     }