@deftai/directive 0.55.0

package/dist/cli-router/index.js

@@ -0,0 +1,37 @@
+/**
+ * CLI router entry: `directive <namespace> <verb>` → flat dispatcher (#1670 / #11 S3).
+ */
+import { dispatch } from "../dispatch.js";
+import { runInit } from "../init-cli/init.js";
+import { runUpdate } from "../init-cli/update.js";
+import { routeArgv } from "./route-argv.js";
+function defaultIo() {
+    return {
+        writeOut: (text) => {
+            process.stdout.write(text);
+        },
+        writeErr: (text) => {
+            process.stderr.write(text);
+        },
+    };
+}
+export { DEFERRED_TOP_LEVEL_VERBS, PR_VERB_MAP, routeArgv, SCOPE_LIFECYCLE_VERBS, STUBBED_TOP_LEVEL_VERBS, SUBCOMMAND_ROUTES, TOP_LEVEL_UX_VERBS, taskKeyToDispatchArgv, VERIFY_VERB_MAP, } from "./route-argv.js";
+/** Route user argv then dispatch to the existing engine handlers. */
+export async function routeAndDispatch(argv, io) {
+    const routed = routeArgv(argv);
+    if (routed.kind === "stub") {
+        const message = routed.stubMessage ?? "directive: command not available";
+        const sink = io ?? defaultIo();
+        sink.writeErr(`${message}\n`);
+        return 2;
+    }
+    const [first, ...rest] = routed.argv;
+    if (first === "init") {
+        return runInit(rest, io ?? defaultIo());
+    }
+    if (first === "update") {
+        return runUpdate(rest, io ?? defaultIo());
+    }
+    return dispatch(routed.argv, io);
+}
+//# sourceMappingURL=index.js.map

package/dist/cli-router/route-argv.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Maps `directive <namespace> <verb>` argv to flat dispatcher verbs (#1670 / #11 S3).
+ * Mirrors the `task <namespace>:<verb>` surface one-to-one.
+ */
+/** Top-level UX verbs promoted above the namespace layer (#1670). */
+export declare const TOP_LEVEL_UX_VERBS: readonly ["init", "update", "bootstrap", "check", "doctor", "version", "feature"];
+/** Stubbed until a later story lands the handler (#1670 / #11). */
+export declare const STUBBED_TOP_LEVEL_VERBS: Set<string>;
+/** Registered but not yet implemented as TS handlers. */
+export declare const DEFERRED_TOP_LEVEL_VERBS: Set<string>;
+/** scope:* lifecycle verbs routed through scope-lifecycle handler. */
+export declare const SCOPE_LIFECYCLE_VERBS: Set<string>;
+/** pr:* task names that do not hyphenate 1:1 to handler stems. */
+export declare const PR_VERB_MAP: Readonly<Record<string, string>>;
+/** verify:* aliases that map to non-verify-* handler stems. */
+export declare const VERIFY_VERB_MAP: Readonly<Record<string, string>>;
+/** Namespace handlers that require a subcommand token after the handler stem. */
+export declare const SUBCOMMAND_ROUTES: Readonly<Record<string, readonly [string, string]>>;
+export type RouteKind = "dispatch" | "stub";
+export interface RoutedArgv {
+    kind: RouteKind;
+    argv: string[];
+    stubMessage?: string;
+}
+/**
+ * Transform user-facing argv (`directive <ns> <verb>` or top-level UX) into
+ * flat dispatcher argv consumed by `dispatch()`.
+ */
+export declare function routeArgv(argv: readonly string[]): RoutedArgv;
+/** Map `namespace:verb` task key to flat dispatcher argv (test seam). */
+export declare function taskKeyToDispatchArgv(taskKey: string, rest?: readonly string[]): string[] | null;
+//# sourceMappingURL=route-argv.d.ts.map

package/dist/cli-router/route-argv.js

@@ -0,0 +1,226 @@
+/**
+ * Maps `directive <namespace> <verb>` argv to flat dispatcher verbs (#1670 / #11 S3).
+ * Mirrors the `task <namespace>:<verb>` surface one-to-one.
+ */
+import { resolveCanonicalVerb } from "../dispatch.js";
+/** Top-level UX verbs promoted above the namespace layer (#1670). */
+export const TOP_LEVEL_UX_VERBS = [
+    "init",
+    "update",
+    "bootstrap",
+    "check",
+    "doctor",
+    "version",
+    "feature",
+];
+/** Stubbed until a later story lands the handler (#1670 / #11). */
+export const STUBBED_TOP_LEVEL_VERBS = new Set([]);
+/** Registered but not yet implemented as TS handlers. */
+export const DEFERRED_TOP_LEVEL_VERBS = new Set(["bootstrap", "feature"]);
+/** scope:* lifecycle verbs routed through scope-lifecycle handler. */
+export const SCOPE_LIFECYCLE_VERBS = new Set([
+    "promote",
+    "activate",
+    "complete",
+    "fail",
+    "cancel",
+    "restore",
+    "block",
+    "unblock",
+]);
+/** pr:* task names that do not hyphenate 1:1 to handler stems. */
+export const PR_VERB_MAP = {
+    "merge-ready": "pr-merge-readiness",
+    "check-protected-issues": "pr-protected-issues",
+    "check-closing-keywords": "pr-closing-keywords",
+    "wait-mergeable-and-merge": "pr-wait-mergeable",
+};
+/** verify:* aliases that map to non-verify-* handler stems. */
+export const VERIFY_VERB_MAP = {
+    routing: "swarm-routing-verify",
+    "codebase-map-fresh": "codebase-map-fresh",
+    "strategy-output": "validate-strategy-output",
+    "vbrief-conformance": "vbrief-validate",
+    "destructive-gh-verbs": "preflight-gh",
+    "cache-fresh": "preflight-cache",
+    "pack-drift": "pack-render",
+};
+/** Namespace handlers that require a subcommand token after the handler stem. */
+export const SUBCOMMAND_ROUTES = {
+    "triage:accept": ["triage-actions", "accept"],
+    "triage:reject": ["triage-actions", "reject"],
+    "triage:defer": ["triage-actions", "defer"],
+    "triage:needs-ac": ["triage-actions", "needs-ac"],
+    "triage:mark-duplicate": ["triage-actions", "mark-duplicate"],
+    "triage:status": ["triage-actions", "status"],
+    "triage:reset": ["triage-actions", "reset"],
+    "triage:history": ["triage-actions", "history"],
+    "triage:bulk-accept": ["triage-bulk", "accept"],
+    "triage:bulk-reject": ["triage-bulk", "reject"],
+    "triage:bulk-defer": ["triage-bulk", "defer"],
+    "triage:bulk-needs-ac": ["triage-bulk", "needs-ac"],
+    "triage:show": ["triage-queue", "show"],
+    "triage:audit": ["triage-queue", "audit"],
+    "cache:put": ["cache", "put"],
+    "cache:get": ["cache", "get"],
+    "cache:invalidate": ["cache", "invalidate"],
+    "cache:fetch-all": ["cache", "fetch-all"],
+    "cache:prune": ["cache", "prune"],
+    "policy:show": ["policy", "show"],
+    "policy:enforce-branches": ["policy", "enforce-branches"],
+    "policy:allow-direct-commits": ["policy", "allow-direct-commits"],
+    "vbrief:reconcile-graph": ["vbrief-reconcile", "graph"],
+    "vbrief:reconcile-labels": ["vbrief-reconcile", "labels"],
+    "vbrief:reconcile-umbrellas": ["vbrief-reconcile", "umbrellas"],
+    "slice:record-existing": ["slice", "record-existing"],
+    "slice:list": ["slice", "list"],
+    "github-body:issue-create": ["github-body", "issue-create"],
+    "github-body:issue-edit": ["github-body", "issue-edit"],
+    "github-body:comment-create": ["github-body", "comment-create"],
+    "github-body:comment-edit": ["github-body", "comment-edit"],
+    "github-body:pr-edit": ["github-body", "pr-edit"],
+};
+function isMetaVerb(token) {
+    return token === "--help" || token === "-h" || token === "--version" || token === "-V";
+}
+function routeTopLevel(first, rest) {
+    if (first === "version") {
+        return { kind: "dispatch", argv: ["--version", ...rest] };
+    }
+    if (first === "check" || first === "doctor") {
+        return { kind: "dispatch", argv: [first, ...rest] };
+    }
+    if (first === "init" || first === "update") {
+        return { kind: "dispatch", argv: [first, ...rest] };
+    }
+    if (STUBBED_TOP_LEVEL_VERBS.has(first)) {
+        return {
+            kind: "stub",
+            argv: [],
+            stubMessage: `directive ${first}: not yet implemented in the TS CLI (#1670 / #11).`,
+        };
+    }
+    if (DEFERRED_TOP_LEVEL_VERBS.has(first)) {
+        return {
+            kind: "stub",
+            argv: [],
+            stubMessage: `directive ${first}: not yet implemented in the TS CLI (#1670 / #11).`,
+        };
+    }
+    return null;
+}
+function routeSubcommandKey(ns, verb, rest) {
+    const colonKey = `${ns}:${verb}`;
+    const mapped = SUBCOMMAND_ROUTES[colonKey];
+    if (mapped !== undefined) {
+        return { kind: "dispatch", argv: [...mapped, ...rest] };
+    }
+    return null;
+}
+function routeNamespaceVerb(ns, verb, rest) {
+    const colonKey = `${ns}:${verb}`;
+    const subcommand = routeSubcommandKey(ns, verb, rest);
+    if (subcommand !== null)
+        return subcommand;
+    if (resolveCanonicalVerb(colonKey) !== null) {
+        return { kind: "dispatch", argv: [colonKey, ...rest] };
+    }
+    if (ns === "scope") {
+        if (SCOPE_LIFECYCLE_VERBS.has(verb)) {
+            return { kind: "dispatch", argv: ["scope-lifecycle", verb, ...rest] };
+        }
+        if (verb === "demote")
+            return { kind: "dispatch", argv: ["scope-demote", ...rest] };
+        if (verb === "decompose")
+            return { kind: "dispatch", argv: ["scope-decompose", ...rest] };
+        if (verb === "undo")
+            return { kind: "dispatch", argv: ["scope-undo", ...rest] };
+    }
+    if (ns === "pr") {
+        const prStem = PR_VERB_MAP[verb];
+        if (prStem !== undefined) {
+            return { kind: "dispatch", argv: [prStem, ...rest] };
+        }
+    }
+    if (ns === "verify") {
+        const verifyStem = VERIFY_VERB_MAP[verb];
+        if (verifyStem !== undefined) {
+            return { kind: "dispatch", argv: [verifyStem, ...rest] };
+        }
+    }
+    if (ns === "issue" && verb === "ingest") {
+        return { kind: "dispatch", argv: ["issue-ingest", ...rest] };
+    }
+    if (ns === "issue" && verb === "emit") {
+        return { kind: "dispatch", argv: ["issue-emit", ...rest] };
+    }
+    if (ns === "triage" && verb.startsWith("bulk-")) {
+        return { kind: "dispatch", argv: ["triage-bulk", verb.slice("bulk-".length), ...rest] };
+    }
+    const hyphenStem = `${ns}-${verb}`;
+    if (resolveCanonicalVerb(hyphenStem) !== null) {
+        return { kind: "dispatch", argv: [hyphenStem, ...rest] };
+    }
+    return null;
+}
+function routeThreeToken(ns, verb, subverb, rest) {
+    if (ns === "scm" && verb === "issue") {
+        return { kind: "dispatch", argv: ["scm", "issue", subverb, ...rest] };
+    }
+    if (ns === "vbrief" && verb === "reconcile") {
+        return { kind: "dispatch", argv: ["vbrief-reconcile", subverb, ...rest] };
+    }
+    if (ns === "policy" && verb === "set") {
+        return { kind: "dispatch", argv: ["policy-set", subverb, ...rest] };
+    }
+    const compositeKey = `${ns}:${verb}-${subverb}`;
+    const subcommand = SUBCOMMAND_ROUTES[compositeKey];
+    if (subcommand !== undefined) {
+        return { kind: "dispatch", argv: [...subcommand, ...rest] };
+    }
+    return null;
+}
+/**
+ * Transform user-facing argv (`directive <ns> <verb>` or top-level UX) into
+ * flat dispatcher argv consumed by `dispatch()`.
+ */
+export function routeArgv(argv) {
+    if (argv.length === 0) {
+        return { kind: "dispatch", argv: [] };
+    }
+    const [first, second, third, ...tail] = argv;
+    if (first === undefined) {
+        return { kind: "dispatch", argv: [] };
+    }
+    if (isMetaVerb(first) || first === "help") {
+        return { kind: "dispatch", argv: [...argv] };
+    }
+    const topLevel = routeTopLevel(first, argv.slice(1));
+    if (topLevel !== null)
+        return topLevel;
+    if (argv.length === 1 && resolveCanonicalVerb(first) !== null) {
+        return { kind: "dispatch", argv: [first] };
+    }
+    if (second !== undefined) {
+        const nsRoute = routeNamespaceVerb(first, second, third !== undefined ? [third, ...tail] : tail);
+        if (nsRoute !== null)
+            return nsRoute;
+    }
+    if (second !== undefined && third !== undefined) {
+        const threeToken = routeThreeToken(first, second, third, tail);
+        if (threeToken !== null)
+            return threeToken;
+    }
+    return { kind: "dispatch", argv: [...argv] };
+}
+/** Map `namespace:verb` task key to flat dispatcher argv (test seam). */
+export function taskKeyToDispatchArgv(taskKey, rest = []) {
+    const colon = taskKey.indexOf(":");
+    if (colon <= 0)
+        return null;
+    const ns = taskKey.slice(0, colon);
+    const verb = taskKey.slice(colon + 1);
+    const routed = routeNamespaceVerb(ns, verb, [...rest]);
+    return routed?.kind === "dispatch" ? routed.argv : null;
+}
+//# sourceMappingURL=route-argv.js.map

package/dist/codebase-default-extractor.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=codebase-default-extractor.d.ts.map

package/dist/codebase-default-extractor.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runDefaultExtractorCli } from "@deftai/directive-core/codebase";
+const result = runDefaultExtractorCli(process.argv.slice(2));
+if (result.stdout)
+    process.stdout.write(result.stdout);
+if (result.stderr)
+    process.stderr.write(result.stderr);
+process.exit(result.exitCode);
+//# sourceMappingURL=codebase-default-extractor.js.map

package/dist/codebase-map-fresh.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=codebase-map-fresh.d.ts.map

package/dist/codebase-map-fresh.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runCodebaseMapFreshCli } from "@deftai/directive-core/codebase";
+const result = runCodebaseMapFreshCli(process.argv.slice(2));
+if (result.stdout)
+    process.stdout.write(result.stdout);
+if (result.stderr)
+    process.stderr.write(result.stderr);
+process.exit(result.exitCode);
+//# sourceMappingURL=codebase-map-fresh.js.map

package/dist/codebase-map.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=codebase-map.d.ts.map

package/dist/codebase-map.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runCodebaseMapCli } from "@deftai/directive-core/codebase";
+const result = runCodebaseMapCli(process.argv.slice(2));
+if (result.stdout)
+    process.stdout.write(result.stdout);
+if (result.stderr)
+    process.stderr.write(result.stderr);
+process.exit(result.exitCode);
+//# sourceMappingURL=codebase-map.js.map

package/dist/codebase-parity.d.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+export interface CommandCapture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ParityCase {
+    readonly name: string;
+    readonly script: string;
+    readonly argv: string[];
+    readonly setup?: (root: string) => void;
+    readonly env?: Record<string, string | undefined>;
+}
+export interface ParityDiff {
+    readonly caseName: string;
+    readonly exitMismatch: boolean;
+    readonly stdoutMismatch: boolean;
+    readonly stderrMismatch: boolean;
+    readonly pythonExit: number;
+    readonly tsExit: number;
+}
+export interface ParityResult {
+    readonly ok: boolean;
+    readonly diffs: ParityDiff[];
+}
+export declare const PARITY_CASES: readonly ParityCase[];
+export declare function diffCase(python: CommandCapture, ts: CommandCapture, caseName: string): ParityDiff;
+export declare function runParity(): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=codebase-parity.d.ts.map

package/dist/codebase-parity.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1786): runs BOTH the frozen Python codebase/capacity
+ * modules and the ported TS CLIs 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 { runCodebaseMapCli } from "@deftai/directive-core/codebase";
+function runCapture(cmd, args, cwd, env = {}) {
+    const merged = { ...process.env, ...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)), "..", "..", "..");
+}
+const TS_CLI = {
+    codebase_projection_registry: "codebase-projection-registry.js",
+    codebase_default_extractor: "codebase-default-extractor.js",
+    codebase_provider: "codebase-provider.js",
+    codebase_map: "codebase-map.js",
+    codebase_map_fresh: "codebase-map-fresh.js",
+    capacity_show: "capacity-show.js",
+    capacity_backfill: "capacity-backfill.js",
+};
+const NO_PROJECT_ROOT = new Set(["codebase_projection_registry"]);
+function runPython(deftRoot, script, repo, argv) {
+    const args = ["run", "python", join(deftRoot, "scripts", `${script}.py`), ...argv];
+    if (!NO_PROJECT_ROOT.has(script)) {
+        args.push("--project-root", repo);
+    }
+    const cap = runCapture("uv", args, deftRoot);
+    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+}
+function runTs(deftRoot, script, repo, argv) {
+    const cli = TS_CLI[script];
+    if (cli === undefined) {
+        throw new Error(`no TS CLI mapped for ${script}`);
+    }
+    const args = [join(deftRoot, "packages", "cli", "dist", cli), ...argv];
+    if (!NO_PROJECT_ROOT.has(script)) {
+        args.push("--project-root", repo);
+    }
+    const cap = runCapture("node", args, deftRoot);
+    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+}
+function writeCapacityProject(root) {
+    const vbrief = join(root, "vbrief");
+    for (const folder of ["proposed", "pending", "active", "completed", "cancelled"]) {
+        mkdirSync(join(vbrief, folder), { recursive: true });
+    }
+    writeFileSync(join(vbrief, "PROJECT-DEFINITION.vbrief.json"), `${JSON.stringify({
+        vBRIEFInfo: { version: "0.6" },
+        plan: {
+            title: "Capacity parity",
+            status: "running",
+            items: [],
+            policy: {
+                capacityAllocation: {
+                    unit: "vbrief-count",
+                    window: 30,
+                    enforcement: "advise",
+                    minSampleSize: 2,
+                    defaultBucket: "feature",
+                    buckets: [
+                        { id: "debt", target: 0.4, match: { labels: { "any-of": ["tech-debt"] } } },
+                        { id: "feature", target: 0.6, match: { labels: { "any-of": ["feature"] } } },
+                    ],
+                },
+            },
+        },
+    }, null, 2)}\n`, { encoding: "utf8" });
+}
+function writeCodeStructureProject(root) {
+    const vbrief = join(root, "vbrief");
+    mkdirSync(vbrief, { recursive: true });
+    writeFileSync(join(vbrief, "PROJECT-DEFINITION.vbrief.json"), `${JSON.stringify({
+        vBRIEFInfo: { version: "0.6" },
+        plan: {
+            title: "Fixture",
+            status: "running",
+            architecture: {
+                codeStructure: {
+                    version: "0.1",
+                    modules: [
+                        {
+                            id: "app",
+                            name: "App",
+                            purpose: "Application entry points.",
+                            pathGlobs: ["app/**/*.py"],
+                        },
+                    ],
+                    pathOwnership: [],
+                    allowedPatterns: [],
+                    projectionManifest: [],
+                },
+            },
+        },
+    }, null, 2)}\n`, { encoding: "utf8" });
+    mkdirSync(join(root, "app"), { recursive: true });
+    writeFileSync(join(root, "app", "main.py"), "from lib.util import thing\n", { encoding: "utf8" });
+}
+function writeCodeStructureProjectNonAscii(root) {
+    const vbrief = join(root, "vbrief");
+    mkdirSync(vbrief, { recursive: true });
+    writeFileSync(join(vbrief, "PROJECT-DEFINITION.vbrief.json"), `${JSON.stringify({
+        vBRIEFInfo: { version: "0.6" },
+        plan: {
+            title: "Fixture",
+            status: "running",
+            architecture: {
+                codeStructure: {
+                    version: "0.1",
+                    modules: [
+                        {
+                            id: "app",
+                            name: "Café App — naïve façade",
+                            purpose: "Entrée points with non-ASCII glyphs: \u00e9 \u00f1 \u2014 \ud83d\ude80.",
+                            pathGlobs: ["app/**/*.py"],
+                        },
+                    ],
+                    pathOwnership: [],
+                    allowedPatterns: [],
+                    projectionManifest: [],
+                },
+            },
+        },
+    }, null, 2)}\n`, { encoding: "utf8" });
+    mkdirSync(join(root, "app"), { recursive: true });
+    writeFileSync(join(root, "app", "main.py"), "from lib.util import thing\n", { encoding: "utf8" });
+}
+function writeFreshCodebaseMapProject(root) {
+    writeCodeStructureProject(root);
+    const result = runCodebaseMapCli(["--project-root", root]);
+    if (result.exitCode !== 0) {
+        throw new Error(`failed to write MAP fixture: ${result.stderr || result.stdout}`);
+    }
+}
+export const PARITY_CASES = [
+    {
+        name: "projection-registry-list",
+        script: "codebase_projection_registry",
+        argv: ["--list"],
+    },
+    {
+        name: "projection-registry-kind",
+        script: "codebase_projection_registry",
+        argv: ["--kind", "codebase-map"],
+    },
+    {
+        name: "default-extractor-curated",
+        script: "codebase_default_extractor",
+        argv: [],
+        setup: writeCodeStructureProject,
+    },
+    {
+        name: "provider-default-fallback",
+        script: "codebase_provider",
+        argv: [],
+        setup: writeCodeStructureProject,
+    },
+    {
+        name: "map-stdout",
+        script: "codebase_map",
+        argv: ["--stdout"],
+        setup: writeCodeStructureProject,
+    },
+    {
+        name: "map-stdout-nonascii",
+        script: "codebase_map",
+        argv: ["--stdout"],
+        setup: writeCodeStructureProjectNonAscii,
+    },
+    {
+        name: "map-fresh-missing",
+        script: "codebase_map_fresh",
+        argv: [],
+        setup: writeCodeStructureProject,
+    },
+    {
+        name: "map-fresh-current",
+        script: "codebase_map_fresh",
+        argv: [],
+        setup: writeFreshCodebaseMapProject,
+    },
+    {
+        name: "capacity-show-advisory",
+        script: "capacity_show",
+        argv: [],
+        setup: writeCapacityProject,
+    },
+    {
+        name: "capacity-backfill-dry-run",
+        script: "capacity_backfill",
+        argv: [],
+        setup: writeCapacityProject,
+    },
+    {
+        name: "capacity-backfill-json",
+        script: "capacity_backfill",
+        argv: ["--json"],
+        setup: writeCapacityProject,
+    },
+];
+export function diffCase(python, ts, caseName) {
+    return {
+        caseName,
+        exitMismatch: python.exitCode !== ts.exitCode,
+        stdoutMismatch: python.stdout !== ts.stdout,
+        stderrMismatch: python.stderr !== ts.stderr,
+        pythonExit: python.exitCode,
+        tsExit: ts.exitCode,
+    };
+}
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const diffs = [];
+    for (const testCase of PARITY_CASES) {
+        const repo = mkdtempSync(join(tmpdir(), "deft-codebase-parity-"));
+        try {
+            testCase.setup?.(repo);
+            const argv = testCase.argv.filter((a) => a !== "--project-root");
+            const python = runPython(deftRoot, testCase.script, repo, argv);
+            const ts = runTs(deftRoot, testCase.script, repo, argv);
+            diffs.push(diffCase(python, ts, testCase.name));
+        }
+        finally {
+            rmSync(repo, { 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 `codebase parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
+    }
+    const lines = ["codebase 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(`codebase parity: harness error -- ${String(err)}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=codebase-parity.js.map

package/dist/codebase-projection-registry.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=codebase-projection-registry.d.ts.map