@tea-agent/loop-agent 0.25.4 → 0.25.6

package/dist/commands/init.js

@@ -4,7 +4,6 @@ import os from "node:os";
 import path from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { fileURLToPath } from "node:url";
-import { copyDir } from "../shared/copy-dir.js";
 import { isInitRuntimeActive, } from "../shared/runtime-activity.js";
 import { loadHarnessManifest } from "../governance/harness.js";
 import { OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH, applyPiRetryMerge, buildOpenCodeTransientRetryPluginSource, inspectPiRetryConfig, parseClientRecoveryMode, runClientRecovery, } from "./client-recovery.js";
@@ -119,6 +118,12 @@ const COMPAT_PROMPTS = {
     ].join("\n"),
 };
 const GOVERNANCE_ROOT_TOKEN = "__LOOP_AGENT_GOVERNANCE_ROOT__";
+const PROJECT_NAME_TOKEN = "__LOOP_AGENT_PROJECT_NAME__";
+/** Package-shipped render source for AGENTS.md managed block; not projected to target repos. */
+const MANAGED_AGENTS_TEMPLATE_PATH = "docs/templates/init-managed-agents.md";
+/** Files under package assets that init must not copy into target projects. */
+const PACKAGE_ONLY_SURFACE_FILES = new Set([MANAGED_AGENTS_TEMPLATE_PATH]);
+let managedAgentsTemplateCache;
 const INIT_CHECK_ENGINEERING_STRUCTURE_SH = `#!/usr/bin/env bash
 set -euo pipefail
 
@@ -798,130 +803,28 @@ function mergeRecord(base, patch) {
         ...patch,
     };
 }
-function buildManagedAgentsBlock(input) {
-    return [
-        MANAGED_BLOCK_START,
-        "## loop-agent 治理",
-        "",
-        `本仓库已初始化为 \`${input.projectName}\` 的 loop-agent harness 项目。`,
-        "",
-        "### 默认立场",
-        "",
-        "- 仓库是记录系统：决策、契约、计划、验证、报告和交接应进入可追踪文件。",
-        "- 一次只推进一个有边界、可验证的工作块；实现前先搜索现有代码、文档、脚本和测试。",
-        "- Shell 验证是完成依据；模型建议不能替代命令证据。",
-        "- 保留无关的用户改动，不要回退自己没有做的修改。",
-        "- 委托模型写入前，必须把写入边界写成结构化 `task.json.allowedPaths` / `task.json.forbiddenPaths`，再审查生成 DAG 的 writer `writeSet`；不要只依赖 `source/执行约束.md` 的自然语言约束。",
-        "- 本仓库对 openCode 等主会话的定位是 **Compatibility / Operator Assist**：主会话编排 CLI 与只读诊断，**不是**默认实现 agent。",
-        "",
-        "### 主会话硬约束（Compatibility / Operator Assist）",
-        "",
-        "主会话（含 openCode、Cursor Chat、其他宿主 agent）= **operator-only**；skills 与本文件是纪律文档，**不能**替代 `task.json` / DAG `writeSet` / runtime 执法。",
-        "",
-        "| 类别 | 规则 |",
-        "|---|---|",
-        "| **允许** | 已发布 `loop-agent` / `agent-worker` CLI；只读 status/doctor/report/inspect/observe；准备 `source/*` 与 `task.json` 边界；human gate；shell 验证与 handoff。 |",
-        "| **禁止** | 绕过 CLI 用宿主 Edit/Write/ApplyPatch 直接改业务实现；CLI/DAG 失败后「救火改文件」；用聊天自述代替 shell 验证。 |",
-        "| **失败时** | `dag doctor` / `dag report` / `dag reconcile-run`（及适用 worker reconcile）；修正任务源/`task.json`/DAG 后经 CLI 重跑。 |",
-        "| **实现写入** | 业务代码 **只** 经受治理 DAG writer（`implement-pi` / `repair-pi`）经 `dag run-task` / `run-dag`。 |",
-        "",
-        "**永远不要**：`loop-agent` / `agent-worker` 失败 ⇒ 主会话直接改仓库实现。",
-        "",
-        "### 自然语言入口路由",
-        "",
-        "| 用户表达 | 入口 | 执行动作 |",
-        "|---|---|---|",
-        "| loop-agent 初始化 / loop agent 初始化 / loop agent初始化 / 初始化 loop-agent | 初始化 | 完成确定性初始化闭环 |",
-        "| 初始化更新校验 / 检查初始化更新 / loop-agent 初始化更新校验 / loop agent初始化更新校验 | 更新校验 | 只读报告，不写入 |",
-        "| 初始化对齐 / 升级后对齐 / reconcile 初始化 / loop-agent 初始化对齐 | 升级对齐 | 自动应用确定性安全动作；活跃 DAG/Worker 或人工决策时零写入 |",
-        "| 初始化安全更新 / 应用初始化更新 / loop-agent 初始化安全更新 / loop agent初始化安全更新 | 安全更新 | 先 check-update，再只执行确定性安全动作 |",
-        "| loop-agent 帮我完成 / 帮我实现 / 帮我修复 / 帮我开发 <需求>；使用 loop-agent 完成 <X>；按 loop-agent 流程处理 <X> | 通用需求实现 | 先建任务源与 `task.json.allowedPaths` / `forbiddenPaths`，再 `new-task` → `dag run-task` → `dag validate` → `run-dag`；主会话不得直接修改业务实现 |",
-        "",
-        "**更新校验（只读）**：只读执行下面命令；**不得自动**执行 `apply-safe` 或模型合并。",
-        "",
-        "```bash",
-        "loop-agent init check-update --repo-root . --markdown",
-        "```",
-        "",
-        "**升级对齐**：`loop-agent init reconcile --repo-root .`；存在活跃 DAG/Worker、human decisions 时必须零写入。",
-        "",
-        "**安全更新**：先 check-update，再 `apply-safe`；surface 缺失才 `--bootstrap-surface`。完成后复查 `init doctor` / `inspect` / `docs audit` 与目标治理检查。",
-        "",
-        "```bash",
-        "loop-agent init check-update --repo-root . --markdown",
-        "loop-agent init update --repo-root . --apply-safe",
-        "```",
-        "",
-        "### 初始化闭环",
-        "",
-        `当用户要求初始化 loop-agent（“初始化 loop-agent”“loop agent 初始化”“loop agent初始化”“loop-agent 初始化”），或发现 \`README.md\` / \`${input.governanceRoot}/verification-matrix.md\` 仍停留在通用初始化状态时，模型应在同一轮工作中完成初始化闭环，不要把补全文档和验证矩阵留给用户交互。`,
-        "",
-        "1. 运行 `loop-agent init instructions --repo-root .`。",
-        "2. 运行 `loop-agent init --repo-root . --profile full --merge`。",
-        `3. 基于真实项目文件补全根 \`README.md\`、\`${input.governanceRoot}/verification-matrix.md\`，必要时适配 \`scripts/ci-tests.sh\`。`,
-        "4. 复查 `init doctor` / `inspect` / `docs audit` 与 quick verification。",
-        "",
-        "信息不足时写明尚未识别到的事实；不要留下泛化占位符。",
-        "",
-        "### 文档收敛",
-        "",
-        "完成实现和验证后，必须检查 `README.md`、`AGENTS.md`、`CHANGELOG.md`（如果目标项目维护）、治理文档、skills references、初始化模板和脚本说明是否仍与实际行为一致。只更新与本次变更相关的内容；如果决定不更新，应在交接里写明理由。",
-        "",
-        "### 开始顺序",
-        "",
-        `pwd → \`README.md\` → \`harness.json\` → \`${input.governanceRoot}/README.md\` → 实现类再读 principles/feature-workflow/verification-matrix；测试纪律读 harness-methodology-*；\`git status\`；最小基线验证。`,
-        "",
-        "### Agent DAG 路径",
-        "",
-        "```bash",
-        'loop-agent new-task <task-id> "任务标题"',
-        "# write .harness/tasks/<task-id>/source/需求.md",
-        "# write .harness/tasks/<task-id>/source/执行约束.md",
-        "loop-agent dag run-task <task-id> --profile auto --strict-models",
-        "loop-agent dag validate --dag .harness/tasks/<task-id>/dag.json --strict-models --strict-governance",
-        "loop-agent run-dag --dag .harness/tasks/<task-id>/dag.json --cwd .",
-        "```",
-        "",
-        "`source/需求.md` 与 `source/执行约束.md` 必需；写入前同步 `task.json.allowedPaths` / `task.json.forbiddenPaths` 并审查 writer `writeSet`。",
-        "",
-        "凡是影响项目公共契约、执行入口、交付流水线、自动化/治理、数据模型、安全或权限模型、跨模块行为、用户可见工作流的改动，都必须在编辑实现文件前先创建任务、写好两个 source 文件、生成 DAG，并审查 DAG/writeSet。",
-        "",
-        "### 任务类型路由（taskKind）",
-        "",
-        '- 用户明确提出后端测试、接口/API 测试、pytest，或语境明确为后端的自动化测试时，必须把 `.harness/tasks/<task-id>/task.json` 的 `taskKind` 设置为 `"backend-test"`，不得保留默认 `standard`。',
-        "- `backend-test` 是 `taskKind`，不是 `--profile` 的可选值；运行 `dag run-task` 时继续使用 `--profile auto`。",
-        "- 仅出现“自动化测试”且无法判断前后端时，先阅读任务源与目标项目技术栈再决定，禁止无条件路由到 `backend-test`。",
-        '- 用户提示词明确是前端实现需求（例如前端页面、UI、组件或交互开发）时，必须把 `.harness/tasks/<task-id>/task.json` 的 `taskKind` 设置为 `"frontend-implementation"`，不得保留默认 `standard`。',
-        "- `frontend-implementation` 是 `taskKind`，不是 `--profile` 的可选值；运行 `dag run-task` 时继续使用 `--profile auto`，也可按需显式选择 `minimal` / `standard` / `reviewed` / `supervised`，不要把业务模板名当作 profile。",
-        '- 前端自动化测试（浏览器/UI 自动化、Playwright、E2E）继续使用 `taskKind: "frontend-test"`，不得设置为 `frontend-implementation`。',
-        "",
-        "### 运行看板（只读）",
-        "",
-        "```bash",
-        "agent-worker console                       # 默认 repo=当前目录，port=8790",
-        "agent-worker console serve --repo . --port 8790   # 兼容入口，等价于上面裸入口",
-        "```",
-        "",
-        "浏览器打开 `http://127.0.0.1:8790/`；检视面为 `http://127.0.0.1:8790/inspect/`。默认绑定本机 `127.0.0.1`；不要直接暴露到公开网络。端口被占用时不会自动更换，请用 `--port <port>` 显式指定。`agent-worker observe serve` 仅为兼容入口。",
-        "",
-        "### DAG 诊断与收口",
-        "",
-        "用 `loop-agent dag report --run-id <run-id> --markdown` 读 facts；失败/paused 用 `loop-agent dag doctor --run-id <run-id> --markdown`；生命周期对齐用 `loop-agent dag reconcile-run`。失败 run 用 `dag closeout-draft` 生成 failure handoff，不要写成成功 closeout。",
-        "",
-        "恢复：doctor/report → classify → reconcile/replan → CLI 重跑 → shell verify。**禁止**把主会话直接 Edit 业务代码当作恢复手段。",
-        "",
-        "### 运行态与验证",
-        "",
-        "- `.harness/tasks/`、`.harness/dag-runs/`、`.harness/runs/` 保存运行事实；已完成事实只读。",
-        "- `.agents/skills/` 为本地 skills；缺失时可回退 npm 包内置。",
-        `- 验证命令选择：\`${input.governanceRoot}/verification-matrix.md\`。常用：\`bash scripts/check-repo.sh\`、\`bash scripts/ci.sh\`、\`loop-agent inspect\`、\`loop-agent doctor\`、\`loop-agent docs audit\`。`,
-        "- `scripts/ci-tests.sh` 必须反映目标项目真实工具链。Windows 脚本用 Git Bash；仓库引用用 `/`。",
-        "",
-        "### 交接",
-        "",
-        `交接写清变更、原因、验证证据、影响面、风险与下一步；长期结论进入 \`${input.governanceRoot}/progress\`、reports、exec-plans、decisions。`,
-        MANAGED_BLOCK_END,
-    ].join("\n");
+async function loadManagedAgentsTemplate(assetRoot) {
+    if (managedAgentsTemplateCache !== undefined)
+        return managedAgentsTemplateCache;
+    const templatePath = path.join(assetRoot, MANAGED_AGENTS_TEMPLATE_PATH);
+    const raw = await readFile(templatePath, "utf-8");
+    // Prefer a START marker on its own line so header notes mentioning the token are ignored.
+    const lines = raw.split(/\r?\n/);
+    const startLine = lines.findIndex((line) => line.trim() === MANAGED_BLOCK_START);
+    const endLine = startLine >= 0
+        ? lines.findIndex((line, index) => index > startLine && line.trim() === MANAGED_BLOCK_END)
+        : -1;
+    if (startLine < 0 || endLine < 0) {
+        throw new Error(`managed agents template missing LOOP_AGENT_INIT markers: ${MANAGED_AGENTS_TEMPLATE_PATH}`);
+    }
+    managedAgentsTemplateCache = lines.slice(startLine, endLine + 1).join("\n");
+    return managedAgentsTemplateCache;
+}
+async function buildManagedAgentsBlock(input) {
+    const template = await loadManagedAgentsTemplate(input.assetRoot);
+    return template
+        .replaceAll(PROJECT_NAME_TOKEN, input.projectName)
+        .replaceAll(GOVERNANCE_ROOT_TOKEN, input.governanceRoot);
 }
 function mergeManagedBlock(existing, block) {
     const start = existing.indexOf(MANAGED_BLOCK_START);
@@ -1137,11 +1040,39 @@ async function copyFileIfMissing(input) {
 async function copyDirMerge(input) {
     const source = path.join(input.assetRoot, input.sourceRelativePath);
     const target = path.join(input.repoRoot, input.targetRelativePath);
-    await copyDir(source, target);
+    const sourcePrefix = `${input.sourceRelativePath.replaceAll(path.sep, "/").replace(/\/$/, "")}/`;
+    await copyDirSkippingPackageOnly({
+        source,
+        target,
+        packageRelativePrefix: sourcePrefix,
+    });
     input.written.push(input.targetRelativePath.endsWith("/")
         ? input.targetRelativePath
         : `${input.targetRelativePath}/`);
 }
+/** Like copyDir, but skips package-only assets that must not land in target projects. */
+async function copyDirSkippingPackageOnly(input) {
+    await mkdir(input.target, { recursive: true });
+    const entries = await readdir(input.source, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(input.source, entry.name);
+        const destPath = path.join(input.target, entry.name);
+        const packageRelative = `${input.packageRelativePrefix}${entry.name}`;
+        if (entry.isDirectory()) {
+            await copyDirSkippingPackageOnly({
+                source: srcPath,
+                target: destPath,
+                packageRelativePrefix: `${packageRelative}/`,
+            });
+            continue;
+        }
+        if (PACKAGE_ONLY_SURFACE_FILES.has(packageRelative))
+            continue;
+        if (entry.isFile() || entry.isSymbolicLink()) {
+            await copyFile(srcPath, destPath);
+        }
+    }
+}
 async function ensureHarnessDirs(repoRoot, written) {
     const dirs = [
         ".harness/prompts",
@@ -1289,7 +1220,10 @@ async function discoverCopiedSurfaceFiles(assetRoot) {
             continue;
         const files = await listRelativeFiles(rootPath);
         for (const relativePath of files) {
-            discovered.push(`${prefix}${relativePath}`);
+            const manifestPath = `${prefix}${relativePath}`;
+            if (PACKAGE_ONLY_SURFACE_FILES.has(manifestPath))
+                continue;
+            discovered.push(manifestPath);
         }
     }
     return discovered.sort();
@@ -1335,7 +1269,8 @@ async function buildDesiredSurfaceContent(input) {
     }
     if (manifestPath === "AGENTS.md") {
         return {
-            content: buildManagedAgentsBlock({
+            content: await buildManagedAgentsBlock({
+                assetRoot: input.assetRoot,
                 projectName: input.projectName,
                 governanceRoot: input.governanceRoot,
             }),
@@ -2427,7 +2362,11 @@ export async function initializeLoopAgentProject(options) {
     await writeText({
         repoRoot,
         relativePath: "AGENTS.md",
-        content: mergeManagedBlock(existingAgents, buildManagedAgentsBlock({ projectName, governanceRoot })),
+        content: mergeManagedBlock(existingAgents, await buildManagedAgentsBlock({
+            assetRoot,
+            projectName,
+            governanceRoot,
+        })),
         merge: true,
         written,
         skipped,

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,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"}`, `correspondenceSummary.primarySymbolCount=${manifest.correspondenceSummary?.primarySymbolCount ?? "unavailable"}`, `correspondenceSummary.testPoints=${manifest.correspondenceSummary?.mappedTestPointCount ?? "unavailable"}/${manifest.correspondenceSummary?.testPointCount ?? "unavailable"}`, `correspondenceSummary.variantTestPointCount=${manifest.correspondenceSummary?.variantTestPointCount ?? "unavailable"}`, `correspondenceSummary.assertionTestPointCount=${manifest.correspondenceSummary?.assertionTestPointCount ?? "unavailable"}`, `correspondenceSummary.crossCuttingTestPointCount=${manifest.correspondenceSummary?.crossCuttingTestPointCount ?? "unavailable"}`, `correspondenceSummary.unclassifiedTestPointCount=${manifest.correspondenceSummary?.unclassifiedTestPointCount ?? "unavailable"}`, `correspondenceSummary.duplicateBindingTestPointCount=${manifest.correspondenceSummary?.duplicateBindingTestPointCount ?? "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);
     }