@deftai/directive 0.55.0

package/dist/lifecycle-packs-parity.js

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1787 s2): runs BOTH the frozen Python oracles
+ * (`packs_slice`, `quarantine_ext`, `_lifecycle_hygiene`, `_event_detect`) and
+ * the ported TS lifecycle/packs modules over shared fixtures, cache-off.
+ *
+ * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
+ */
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { eventDetect, lifecycleHygiene } from "@deftai/directive-core/lifecycle";
+import { packsSlice, quarantineExt } from "@deftai/directive-core/packs";
+const NOW_ISO = "2026-06-01T12:00:00.000Z";
+function runCapture(cmd, args, cwd, env = {}) {
+    const merged = {
+        ...process.env,
+        DEFT_CACHE_DISABLE: "1",
+        PYTHONUTF8: "1",
+        ...env,
+    };
+    for (const key of Object.keys(merged)) {
+        if (merged[key] === undefined)
+            delete merged[key];
+    }
+    try {
+        const stdout = execFileSync(cmd, args, {
+            cwd,
+            encoding: "utf8",
+            env: merged,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return { status: 0, stdout, stderr: "" };
+    }
+    catch (err) {
+        const e = err;
+        return {
+            status: typeof e.status === "number" ? e.status : 2,
+            stdout: typeof e.stdout === "string" ? e.stdout : "",
+            stderr: typeof e.stderr === "string" ? e.stderr : "",
+        };
+    }
+}
+function resolveDeftRoot() {
+    if (process.env.DEFT_ROOT !== undefined && process.env.DEFT_ROOT.length > 0) {
+        return resolve(process.env.DEFT_ROOT);
+    }
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+}
+function runPythonScript(deftRoot, script) {
+    return runCapture("uv", ["run", "python", "-c", script], deftRoot);
+}
+function writeJson(path, data) {
+    writeFileSync(path, `${JSON.stringify(data)}\n`, { encoding: "utf8" });
+}
+function makeLifecycle(root) {
+    for (const folder of ["proposed", "pending", "active", "completed", "cancelled"]) {
+        mkdirSync(join(root, "vbrief", folder), { recursive: true });
+    }
+}
+function writeFixturePack(repo) {
+    const schema = {
+        "x-sliceRegistry": {
+            recent: {
+                path: "lessons",
+                filters: ["since"],
+                description: "Lessons dated on or after --since.",
+            },
+            "by-tag": {
+                path: "lessons",
+                filters: ["tag"],
+                description: "Lessons carrying any requested --tag.",
+            },
+        },
+        "x-display": {
+            heading: "title",
+            fields: [],
+            body: "body",
+            noun: "lessons",
+        },
+    };
+    const source = {
+        pack: "lessons-pack-0.1",
+        version: "0.1",
+        lessons: [
+            {
+                id: "old-windows",
+                title: "Old Windows Lesson (2026-03)",
+                date: "2026-03",
+                issue_refs: [],
+                tags: ["windows", "encoding"],
+                source: "PR #1",
+                body: "Body about cp1252.",
+            },
+            {
+                id: "mid-swarm",
+                title: "Mid Swarm Lesson (2026-05)",
+                date: "2026-05",
+                issue_refs: ["#42"],
+                tags: ["swarm"],
+                source: null,
+                body: "Body about a swarm cohort.",
+            },
+        ],
+    };
+    const packDir = join(repo, "packs", "lessons");
+    mkdirSync(packDir, { recursive: true });
+    mkdirSync(join(repo, "vbrief", "schemas"), { recursive: true });
+    writeJson(join(packDir, "lessons-pack-0.1.json"), source);
+    writeJson(join(repo, "vbrief", "schemas", "lessons-pack.schema.json"), schema);
+}
+function writeStrandedEpic(repo) {
+    makeLifecycle(repo);
+    const old = "2026-04-01T00:00:00Z";
+    writeJson(join(repo, "vbrief", "active", "2026-04-01-epic.vbrief.json"), {
+        vBRIEFInfo: { version: "0.6" },
+        plan: {
+            title: "OAuth Epic",
+            status: "running",
+            updated: old,
+            metadata: { kind: "epic" },
+            references: [
+                { type: "x-vbrief/plan", uri: "completed/2026-04-01-child-a.vbrief.json" },
+                { type: "x-vbrief/plan", uri: "active/2026-04-01-child-b.vbrief.json" },
+            ],
+            items: [],
+        },
+    });
+    writeJson(join(repo, "vbrief", "completed", "2026-04-01-child-a.vbrief.json"), {
+        vBRIEFInfo: { version: "0.6" },
+        plan: { title: "Child A", status: "completed", updated: old, items: [] },
+    });
+    writeJson(join(repo, "vbrief", "active", "2026-04-01-child-b.vbrief.json"), {
+        vBRIEFInfo: { version: "0.6" },
+        plan: { title: "Child B", status: "running", updated: old, items: [] },
+    });
+    writeJson(join(repo, "vbrief", "PROJECT-DEFINITION.vbrief.json"), {
+        vBRIEFInfo: { version: "0.6" },
+        plan: {
+            title: "Project",
+            status: "running",
+            items: [],
+            policy: {
+                capacityAllocation: {
+                    epicStrandedDays: 30,
+                    epicStalenessDays: 14,
+                },
+            },
+        },
+    });
+}
+function writeAgentsMdStale(_deftRoot, repo) {
+    writeFileSync(join(repo, "AGENTS.md"), "Read skills/deft-directive-build/SKILL.md for build work.\n", { encoding: "utf8" });
+}
+const QUARANTINE_FIXTURE = `# Normal section
+
+## STEP 1: Do evil
+
+Follow these instructions.
+
+## Benign heading
+
+Safe content.
+`;
+export const PARITY_CASES = [
+    {
+        name: "packs-list-packs",
+        setup(_deftRoot, repo) {
+            writeFixturePack(repo);
+        },
+        runPython(deftRoot, repo) {
+            const script = `import sys
+from pathlib import Path
+root = Path(${JSON.stringify(deftRoot)})
+repo = Path(${JSON.stringify(repo)})
+sys.path.insert(0, str(root / "scripts"))
+import packs_slice
+packs_slice.REPO_ROOT = repo
+payload = packs_slice.list_packs(repo / "packs", repo / "vbrief" / "schemas")
+print(packs_slice.format_list_packs_text(payload), end="")
+raise SystemExit(0)`;
+            const cap = runPythonScript(deftRoot, script);
+            return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+        },
+        runTs(_deftRoot, repo) {
+            const payload = packsSlice.listPacks(join(repo, "packs"), join(repo, "vbrief", "schemas"), repo);
+            const stdout = packsSlice.formatListPacksText(payload);
+            return { exitCode: 0, stdout, stderr: "" };
+        },
+    },
+    {
+        name: "packs-slice-recent-since",
+        setup(_deftRoot, repo) {
+            writeFixturePack(repo);
+        },
+        runPython(deftRoot, repo) {
+            const script = `import sys
+from pathlib import Path
+root = Path(${JSON.stringify(deftRoot)})
+repo = Path(${JSON.stringify(repo)})
+sys.path.insert(0, str(root / "scripts"))
+import packs_slice
+packs_slice.REPO_ROOT = repo
+packs_slice.PACK_REGISTRY["lessons"] = {
+    "source": repo / "packs" / "lessons" / "lessons-pack-0.1.json",
+    "schema": repo / "vbrief" / "schemas" / "lessons-pack.schema.json",
+}
+source_path = repo / "packs" / "lessons" / "lessons-pack-0.1.json"
+schema_path = repo / "vbrief" / "schemas" / "lessons-pack.schema.json"
+registry = packs_slice.load_registry(schema_path)
+data = packs_slice.load_source(source_path)
+result = packs_slice.slice_pack(data["pack"], "recent", registry, data, source_path, since="2026-05")
+display = packs_slice.load_display(schema_path)
+print(packs_slice.format_slice_text(result, display), end="")
+raise SystemExit(0)`;
+            const cap = runPythonScript(deftRoot, script);
+            return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+        },
+        runTs(_deftRoot, repo) {
+            const source = join(repo, "packs", "lessons", "lessons-pack-0.1.json");
+            const schema = join(repo, "vbrief", "schemas", "lessons-pack.schema.json");
+            const registry = packsSlice.loadRegistry(schema);
+            const data = packsSlice.loadSource(source);
+            const result = packsSlice.slicePack(String(data.pack ?? "lessons"), "recent", registry, data, source, { since: "2026-05", repoRoot: repo });
+            const display = packsSlice.loadDisplay(schema);
+            return { exitCode: 0, stdout: packsSlice.formatSliceText(result, display), stderr: "" };
+        },
+    },
+    {
+        name: "quarantine-ext-heading",
+        runPython(deftRoot) {
+            const script = `import sys
+from pathlib import Path
+root = Path(${JSON.stringify(deftRoot)})
+sys.path.insert(0, str(root / "scripts"))
+import quarantine_ext
+text = ${JSON.stringify(QUARANTINE_FIXTURE)}
+sys.stdout.write(quarantine_ext.quarantine_body(text))
+raise SystemExit(0)`;
+            const cap = runPythonScript(deftRoot, script);
+            return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+        },
+        runTs() {
+            const stdout = quarantineExt.quarantineBody(QUARANTINE_FIXTURE);
+            return { exitCode: 0, stdout, stderr: "" };
+        },
+    },
+    {
+        name: "lifecycle-stranded-nudge",
+        setup(_deftRoot, repo) {
+            writeStrandedEpic(repo);
+        },
+        runPython(deftRoot, repo) {
+            const script = `import sys
+from datetime import datetime, UTC
+from pathlib import Path
+root = Path(${JSON.stringify(deftRoot)})
+repo = Path(${JSON.stringify(repo)})
+sys.path.insert(0, str(root / "scripts"))
+import _lifecycle_hygiene as lifecycle_hygiene
+now = datetime.fromisoformat(${JSON.stringify(NOW_ISO)}.replace("Z", "+00:00"))
+nudges = lifecycle_hygiene.detect_lifecycle_nudges(repo, now=now)
+lines = [n.message for n in nudges if n.kind == "stranded"]
+print("\\n".join(lines))
+raise SystemExit(0)`;
+            const cap = runPythonScript(deftRoot, script);
+            return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+        },
+        runTs(_deftRoot, repo) {
+            const now = new Date(NOW_ISO);
+            const nudges = lifecycleHygiene.detectLifecycleNudges(repo, { now });
+            const lines = nudges.filter((n) => n.kind === "stranded").map((n) => n.message);
+            return { exitCode: 0, stdout: `${lines.join("\n")}\n`, stderr: "" };
+        },
+    },
+    {
+        name: "event-detect-agents-md-stale",
+        setup(deftRoot, repo) {
+            writeAgentsMdStale(deftRoot, repo);
+        },
+        runPython(deftRoot, repo) {
+            const script = `import json, sys
+from pathlib import Path
+root = Path(${JSON.stringify(deftRoot)})
+repo = Path(${JSON.stringify(repo)})
+sys.path.insert(0, str(root / "scripts"))
+import _event_detect as event_detect
+payload = event_detect.detect_agents_md_stale(repo, framework_root=root)
+print(json.dumps(payload, sort_keys=True) if payload else "null")
+raise SystemExit(0)`;
+            const cap = runPythonScript(deftRoot, script);
+            return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+        },
+        runTs(deftRoot, repo) {
+            eventDetect.clearRegistryCache();
+            const payload = eventDetect.detectAgentsMdStale(repo, { frameworkRoot: deftRoot });
+            const stdout = payload === null ? "null\n" : `${JSON.stringify(payload, Object.keys(payload).sort())}\n`;
+            return { exitCode: 0, stdout, stderr: "" };
+        },
+    },
+];
+export function normalizeOutput(text) {
+    return text.replace(/\r\n/g, "\n");
+}
+export function diffCase(python, ts, caseName) {
+    const pyOut = normalizeOutput(python.stdout);
+    const tsOut = normalizeOutput(ts.stdout);
+    const pyErr = normalizeOutput(python.stderr);
+    const tsErr = normalizeOutput(ts.stderr);
+    return {
+        caseName,
+        exitMismatch: python.exitCode !== ts.exitCode,
+        stdoutMismatch: pyOut !== tsOut,
+        stderrMismatch: pyErr !== tsErr,
+        pythonExit: python.exitCode,
+        tsExit: ts.exitCode,
+    };
+}
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const diffs = [];
+    for (const testCase of PARITY_CASES) {
+        const pyRepo = mkdtempSync(join(tmpdir(), "deft-lp-parity-py-"));
+        const tsRepo = mkdtempSync(join(tmpdir(), "deft-lp-parity-ts-"));
+        try {
+            if (testCase.setup !== undefined) {
+                testCase.setup(deftRoot, pyRepo);
+                testCase.setup(deftRoot, tsRepo);
+            }
+            const python = testCase.runPython(deftRoot, pyRepo);
+            const ts = testCase.runTs(deftRoot, tsRepo);
+            diffs.push(diffCase(python, ts, testCase.name));
+        }
+        finally {
+            rmSync(pyRepo, { recursive: true, force: true });
+            rmSync(tsRepo, { recursive: true, force: true });
+        }
+    }
+    const ok = diffs.every((d) => !d.exitMismatch && !d.stdoutMismatch && !d.stderrMismatch);
+    return { ok, diffs };
+}
+export function renderReport(result) {
+    if (result.ok) {
+        return `lifecycle-packs parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} case(s).`;
+    }
+    const lines = ["lifecycle-packs parity: DIVERGENCE"];
+    for (const d of result.diffs) {
+        if (d.exitMismatch || d.stdoutMismatch || d.stderrMismatch) {
+            lines.push(`  case: ${d.caseName}`);
+            if (d.exitMismatch)
+                lines.push(`    exit: python=${d.pythonExit} ts=${d.tsExit}`);
+            if (d.stdoutMismatch)
+                lines.push("    stdout mismatch");
+            if (d.stderrMismatch)
+                lines.push("    stderr mismatch");
+        }
+    }
+    return lines.join("\n");
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    try {
+        const result = runParity();
+        if (result.ok) {
+            process.stdout.write(`${renderReport(result)}\n`);
+            process.exit(0);
+        }
+        process.stderr.write(`${renderReport(result)}\n`);
+        process.exit(1);
+    }
+    catch (err) {
+        process.stderr.write(`lifecycle-packs parity: harness error -- ${String(err)}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=lifecycle-packs-parity.js.map

package/dist/orchestration-cli/coverage-map.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Wave 8.5 s4 coverage map (#1838): Python CLI tests → TS vitest / existing core coverage.
+ * Used in the PR body table and audited by coverage-map.test.ts.
+ */
+export type CoverageKind = "existing-coverage" | "orchestration-cli-spec";
+export interface CoverageEntry {
+    readonly pythonTest: string;
+    readonly kind: CoverageKind;
+    readonly tsTarget: string;
+    readonly notes?: string;
+}
+export declare const ORCHESTRATION_CLI_PYTHON_TESTS: readonly ["test_pr_check_closing_keywords.py", "test_pr_check_protected_issues.py", "test_pr_merge_readiness.py", "test_pr_merge_readiness_fallbacks.py", "test_pr_wait_mergeable.py", "test_release.py", "test_release_branch_gate.py", "test_release_e2e.py", "test_release_prerelease.py", "test_release_publish.py", "test_release_pyproject_sync.py", "test_release_rollback.py", "test_release_rollback_725.py", "test_release_skip_flags.py", "test_release_subprocess_path.py", "test_release_summary.py", "test_release_tag_availability.py", "test_release_upgrade_banner.py", "test_release_vbrief_lifecycle.py", "test_swarm_complete_cohort.py", "test_swarm_launch.py", "test_swarm_readiness.py", "test_swarm_verify_review_clean.py", "test_swarm_worktrees.py", "test_subagent_monitor.py", "test_probe_session.py", "test_resolve_changelog_unreleased.py", "test_resolve_version.py"];
+export declare const ORCHESTRATION_CLI_COVERAGE_MAP: readonly CoverageEntry[];
+/** Every in-scope Python file must appear at least once in the map. */
+export declare function coverageMapCompleteness(): {
+    ok: boolean;
+    missing: string[];
+};
+/** Markdown table for PR body (#1838 Wave 8.5 s4). */
+export declare function renderCoverageMapMarkdown(): string;
+//# sourceMappingURL=coverage-map.d.ts.map

package/dist/orchestration-cli/coverage-map.js

@@ -0,0 +1,225 @@
+export const ORCHESTRATION_CLI_PYTHON_TESTS = [
+    "test_pr_check_closing_keywords.py",
+    "test_pr_check_protected_issues.py",
+    "test_pr_merge_readiness.py",
+    "test_pr_merge_readiness_fallbacks.py",
+    "test_pr_wait_mergeable.py",
+    "test_release.py",
+    "test_release_branch_gate.py",
+    "test_release_e2e.py",
+    "test_release_prerelease.py",
+    "test_release_publish.py",
+    "test_release_pyproject_sync.py",
+    "test_release_rollback.py",
+    "test_release_rollback_725.py",
+    "test_release_skip_flags.py",
+    "test_release_subprocess_path.py",
+    "test_release_summary.py",
+    "test_release_tag_availability.py",
+    "test_release_upgrade_banner.py",
+    "test_release_vbrief_lifecycle.py",
+    "test_swarm_complete_cohort.py",
+    "test_swarm_launch.py",
+    "test_swarm_readiness.py",
+    "test_swarm_verify_review_clean.py",
+    "test_swarm_worktrees.py",
+    "test_subagent_monitor.py",
+    "test_probe_session.py",
+    "test_resolve_changelog_unreleased.py",
+    "test_resolve_version.py",
+];
+export const ORCHESTRATION_CLI_COVERAGE_MAP = [
+    {
+        pythonTest: "test_pr_check_closing_keywords.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/pr-closing-keywords/main.test.ts",
+        notes: "Offline + gh argv parsing; parity in pr-closing-keywords-parity.test.ts",
+    },
+    {
+        pythonTest: "test_pr_check_protected_issues.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/pr-protected-issues/main.test.ts",
+    },
+    {
+        pythonTest: "test_pr_merge_readiness.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/pr-merge-readiness/main.test.ts",
+        notes: "Greptile parse + gate evaluation",
+    },
+    {
+        pythonTest: "test_pr_merge_readiness_fallbacks.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/pr-merge-readiness/gh.test.ts",
+        notes: "Layered gh fallbacks",
+    },
+    {
+        pythonTest: "test_pr_wait_mergeable.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/pr-wait-mergeable/main.test.ts",
+    },
+    {
+        pythonTest: "test_pr_check_closing_keywords.py",
+        kind: "orchestration-cli-spec",
+        tsTarget: "packages/cli/src/orchestration-cli/pr-cli.test.ts",
+        notes: "deft-ts pr-closing-keywords argv / exit 2 for missing input",
+    },
+    {
+        pythonTest: "test_pr_merge_readiness.py",
+        kind: "orchestration-cli-spec",
+        tsTarget: "packages/cli/src/orchestration-cli/pr-cli.test.ts",
+        notes: "deft-ts pr-merge-readiness / pr-protected-issues / pr-wait-mergeable dispatcher",
+    },
+    {
+        pythonTest: "test_release.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/main.test.ts",
+        notes: "Pipeline + changelog promotion",
+    },
+    {
+        pythonTest: "test_release_branch_gate.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/pipeline-branches.test.ts",
+    },
+    {
+        pythonTest: "test_release_e2e.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release-e2e/main.test.ts",
+    },
+    {
+        pythonTest: "test_release_prerelease.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/version.test.ts",
+    },
+    {
+        pythonTest: "test_release_publish.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release-publish/main.test.ts",
+    },
+    {
+        pythonTest: "test_release_pyproject_sync.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/pyproject.test.ts",
+    },
+    {
+        pythonTest: "test_release_rollback.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release-rollback/rollback.test.ts",
+    },
+    {
+        pythonTest: "test_release_rollback_725.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release-rollback/rollback-coverage.test.ts",
+    },
+    {
+        pythonTest: "test_release_skip_flags.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/flags.test.ts",
+    },
+    {
+        pythonTest: "test_release_subprocess_path.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/python-bridge.test.ts",
+    },
+    {
+        pythonTest: "test_release_summary.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/pipeline.test.ts",
+    },
+    {
+        pythonTest: "test_release_tag_availability.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/gh.test.ts",
+    },
+    {
+        pythonTest: "test_release_upgrade_banner.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/pipeline-branches.test.ts",
+    },
+    {
+        pythonTest: "test_release_vbrief_lifecycle.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/pipeline.test.ts",
+    },
+    {
+        pythonTest: "test_release.py",
+        kind: "orchestration-cli-spec",
+        tsTarget: "packages/cli/src/orchestration-cli/release-cli.test.ts",
+        notes: "deft-ts release / release-publish / release-rollback / release-e2e argv surface",
+    },
+    {
+        pythonTest: "test_swarm_complete_cohort.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/swarm/complete-cohort-sweep.test.ts",
+    },
+    {
+        pythonTest: "test_swarm_launch.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/swarm/swarm.test.ts",
+    },
+    {
+        pythonTest: "test_swarm_readiness.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/swarm/readiness-branches.test.ts",
+    },
+    {
+        pythonTest: "test_swarm_verify_review_clean.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/swarm/swarm-branches.test.ts",
+    },
+    {
+        pythonTest: "test_swarm_worktrees.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/swarm/worktrees.test.ts",
+    },
+    {
+        pythonTest: "test_swarm_launch.py",
+        kind: "orchestration-cli-spec",
+        tsTarget: "packages/cli/src/orchestration-cli/swarm-cli.test.ts",
+        notes: "deft-ts swarm-* dispatcher argv + exit codes",
+    },
+    {
+        pythonTest: "test_subagent_monitor.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/orchestration/orchestration.test.ts",
+    },
+    {
+        pythonTest: "test_probe_session.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/orchestration/orchestration.test.ts",
+    },
+    {
+        pythonTest: "test_subagent_monitor.py",
+        kind: "orchestration-cli-spec",
+        tsTarget: "packages/cli/src/orchestration-cli/probe-orchestration-cli.test.ts",
+        notes: "deft-ts subagent-monitor / probe-session dispatcher",
+    },
+    {
+        pythonTest: "test_probe_session.py",
+        kind: "orchestration-cli-spec",
+        tsTarget: "packages/cli/src/orchestration-cli/probe-orchestration-cli.test.ts",
+    },
+    {
+        pythonTest: "test_resolve_changelog_unreleased.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/platform/platform.test.ts",
+        notes: "No deft-ts verb; resolve-changelog is platform module",
+    },
+    {
+        pythonTest: "test_resolve_version.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/platform/branch-coverage.test.ts",
+        notes: "No deft-ts verb; resolve-version is platform module",
+    },
+];
+/** Every in-scope Python file must appear at least once in the map. */
+export function coverageMapCompleteness() {
+    const mapped = new Set(ORCHESTRATION_CLI_COVERAGE_MAP.map((e) => e.pythonTest));
+    const missing = ORCHESTRATION_CLI_PYTHON_TESTS.filter((f) => !mapped.has(f));
+    return { ok: missing.length === 0, missing: [...missing] };
+}
+/** Markdown table for PR body (#1838 Wave 8.5 s4). */
+export function renderCoverageMapMarkdown() {
+    const rows = ORCHESTRATION_CLI_COVERAGE_MAP.map((e) => `| \`${e.pythonTest}\` | ${e.kind} | \`${e.tsTarget}\` | ${e.notes ?? ""} |`);
+    return ["| Python test | Kind | TS target | Notes |", "| --- | --- | --- | --- |", ...rows].join("\n");
+}
+//# sourceMappingURL=coverage-map.js.map

package/dist/orchestration-cli/helpers.d.ts

@@ -0,0 +1,11 @@
+import type { DispatchIo } from "../dispatch.js";
+/** Silent IO sinks for dispatcher / CLI wrapper tests. */
+export declare function silentIo(): DispatchIo;
+/** Capture stderr while keeping stdout silent. */
+export declare function captureStderrIo(): {
+    io: DispatchIo;
+    stderr: string[];
+};
+/** Run a CLI `run()` export without polluting the vitest console. */
+export declare function muteProcessStreams<T>(fn: () => T): T;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/orchestration-cli/helpers.js

@@ -0,0 +1,35 @@
+/** Silent IO sinks for dispatcher / CLI wrapper tests. */
+export function silentIo() {
+    return {
+        writeOut: () => { },
+        writeErr: () => { },
+    };
+}
+/** Capture stderr while keeping stdout silent. */
+export function captureStderrIo() {
+    const stderr = [];
+    return {
+        stderr,
+        io: {
+            writeOut: () => { },
+            writeErr: (text) => {
+                stderr.push(text);
+            },
+        },
+    };
+}
+/** Run a CLI `run()` export without polluting the vitest console. */
+export function muteProcessStreams(fn) {
+    const stdoutWrite = process.stdout.write.bind(process.stdout);
+    const stderrWrite = process.stderr.write.bind(process.stderr);
+    process.stdout.write = (() => true);
+    process.stderr.write = (() => true);
+    try {
+        return fn();
+    }
+    finally {
+        process.stdout.write = stdoutWrite;
+        process.stderr.write = stderrWrite;
+    }
+}
+//# sourceMappingURL=helpers.js.map