@deftai/directive 0.62.0 → 0.63.0

package/dist/cache-parity.js

@@ -1,165 +0,0 @@
-#!/usr/bin/env node
-/**
- * Golden-output parity harness (#1728): runs BOTH the Python oracle
- * (`scripts/cache.py`) and the ported TS cache CLI with identical argv,
- * then diffs exit codes and normalised stdout/stderr. Exit 0 only on
- * identical results. Each scenario uses an isolated temp cwd (cache-off).
- *
- * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
- */
-import { spawnSync } from "node:child_process";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-/** Validation-only scenarios (no live gh network). */
-export const PARITY_SCENARIOS = [
-    { name: "usage-no-cmd", argv: [] },
-    { name: "put-missing-args", argv: ["put"] },
-    { name: "get-invalid-key", argv: ["get", "github-issue", "bad/key"] },
-    {
-        name: "put-missing-raw-file",
-        argv: ["put", "github-issue", "deftai/directive/1", "--raw-file", "/nonexistent"],
-    },
-    { name: "get-miss", argv: ["get", "github-issue", "deftai/directive/999"] },
-    {
-        name: "invalidate-missing",
-        argv: ["invalidate", "github-issue", "deftai/directive/999"],
-    },
-    { name: "prune-dry-run-empty", argv: ["prune", "--dry-run"] },
-    {
-        name: "fetch-all-invalid-repo",
-        argv: ["fetch-all", "--source", "github-issue", "--repo", "bad"],
-    },
-    {
-        name: "fetch-all-batch-size-zero",
-        argv: [
-            "fetch-all",
-            "--source",
-            "github-issue",
-            "--repo",
-            "deftai/directive",
-            "--batch-size",
-            "0",
-        ],
-    },
-    {
-        name: "fetch-all-delay-negative",
-        argv: [
-            "fetch-all",
-            "--source",
-            "github-issue",
-            "--repo",
-            "deftai/directive",
-            "--delay-ms",
-            "-1",
-        ],
-    },
-    { name: "prune-to-cap-dry-run", argv: ["prune", "--to-cap", "--dry-run"] },
-];
-function runCapture(cmd, args, cwd) {
-    const result = spawnSync(cmd, args, {
-        cwd,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    return {
-        status: result.status ?? 2,
-        stdout: typeof result.stdout === "string" ? result.stdout : "",
-        stderr: typeof result.stderr === "string" ? result.stderr : "",
-    };
-}
-/** Normalise gate output for comparison. */
-export function normaliseMessage(stdout, stderr, exitCode) {
-    const raw = exitCode === 0 ? stdout : stderr;
-    return raw
-        .split("\n")
-        .filter((line) => !line.startsWith("Using CPython") &&
-        !line.startsWith("Creating virtual environment") &&
-        !line.startsWith("Installed "))
-        .join("\n")
-        .trim()
-        .replace(/\s+/g, " ");
-}
-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 runScenario(deftRoot, scenario) {
-    const cwd = mkdtempSync(join(tmpdir(), "deft-cache-parity-"));
-    try {
-        const pyArgs = ["run", "python", join(deftRoot, "scripts", "cache.py"), ...scenario.argv];
-        const tsArgs = [join(deftRoot, "packages", "cli", "dist", "cache.js"), ...scenario.argv];
-        const py = runCapture("uv", pyArgs, cwd);
-        const ts = runCapture("node", tsArgs, cwd);
-        return {
-            python: { name: scenario.name, exitCode: py.status, stdout: py.stdout, stderr: py.stderr },
-            ts: { name: scenario.name, exitCode: ts.status, stdout: ts.stdout, stderr: ts.stderr },
-        };
-    }
-    finally {
-        rmSync(cwd, { recursive: true, force: true });
-    }
-}
-export function diffParity(python, ts) {
-    const pythonMessage = normaliseMessage(python.stdout, python.stderr, python.exitCode);
-    const tsMessage = normaliseMessage(ts.stdout, ts.stderr, ts.exitCode);
-    return {
-        exitMismatch: python.exitCode !== ts.exitCode,
-        messageMismatch: pythonMessage !== tsMessage,
-        pythonMessage,
-        tsMessage,
-    };
-}
-export function runParity() {
-    const deftRoot = resolveDeftRoot();
-    const scenarios = [];
-    for (const scenario of PARITY_SCENARIOS) {
-        const ran = runScenario(deftRoot, scenario);
-        scenarios.push({
-            name: scenario.name,
-            pythonExit: ran.python.exitCode,
-            tsExit: ran.ts.exitCode,
-            ...diffParity(ran.python, ran.ts),
-        });
-    }
-    const ok = scenarios.every((s) => !s.exitMismatch && !s.messageMismatch);
-    return { ok, scenarios };
-}
-export function renderReport(result) {
-    if (result.ok) {
-        return `cache parity: CLEAN -- Python and TS agree on ${result.scenarios.length} scenario(s).`;
-    }
-    const lines = ["cache parity: DIVERGENCE"];
-    for (const s of result.scenarios) {
-        if (s.exitMismatch || s.messageMismatch) {
-            lines.push(`  scenario: ${s.name}`);
-            if (s.exitMismatch)
-                lines.push(`    exit mismatch: python=${s.pythonExit} ts=${s.tsExit}`);
-            if (s.messageMismatch) {
-                lines.push(`    python: ${s.pythonMessage}`);
-                lines.push(`    ts:     ${s.tsMessage}`);
-            }
-        }
-    }
-    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) {
-        const msg = String(err).replace(/\r?\n/g, " ");
-        process.stderr.write(`cache parity: harness error -- ${msg}\n`);
-        process.exit(2);
-    }
-}
-//# sourceMappingURL=cache-parity.js.map

package/dist/codebase-parity.d.ts

@@ -1,31 +0,0 @@
-#!/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 normalizeOutput(text: string): string;
-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

@@ -1,303 +0,0 @@
-#!/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 normalizeOutput(text) {
-    return text
-        .replace(/(?:\/private)?\/var\/folders\/[^\s"')]+\/deft-codebase-parity-[^\s"')]+/g, "<TMP>")
-        .replace(/\/tmp\/deft-codebase-parity-[^\s"')]+/g, "<TMP>");
-}
-export function diffCase(python, ts, caseName) {
-    const pythonStdout = normalizeOutput(python.stdout);
-    const pythonStderr = normalizeOutput(python.stderr);
-    const tsStdout = normalizeOutput(ts.stdout);
-    const tsStderr = normalizeOutput(ts.stderr);
-    return {
-        caseName,
-        exitMismatch: python.exitCode !== ts.exitCode,
-        stdoutMismatch: pythonStdout !== tsStdout,
-        stderrMismatch: pythonStderr !== tsStderr,
-        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/doc-cli-parity.d.ts

@@ -1,29 +0,0 @@
-/**
- * Doc ↔ CLI parity gate (#1996).
- *
- * Extracts npm-canonical CLI invocations from UPGRADING.md and the AGENTS.md
- * managed-section template, then asserts each resolves through the top-level
- * router to a registered dispatcher verb (or an explicitly allowlisted legacy
- * back-compat surface documented post-#1912).
- */
-/** Documented legacy surfaces that remain in prose but are not npm-router verbs. */
-export declare const LEGACY_DOC_VERB_KEYS: Set<string>;
-export interface DocCliReference {
-    readonly source: string;
-    readonly raw: string;
-    readonly normalized: string;
-}
-export interface DocCliParityFailure {
-    readonly source: string;
-    readonly raw: string;
-    readonly reason: string;
-}
-/** Pull CLI command references from UPGRADING.md + agents-entry managed section. */
-export declare function extractDocCliReferences(repoRoot?: string): DocCliReference[];
-/** Strip flags/placeholders; return null when the literal is not a CLI verb invocation. */
-export declare function normalizeDocCommand(raw: string): string | null;
-/** Validate one normalized doc command against the router + registeredVerbs(). */
-export declare function validateDocCliCommand(normalized: string): string | null;
-/** Run the parity gate; returns failure rows (empty == pass). */
-export declare function collectDocCliParityFailures(repoRoot?: string): DocCliParityFailure[];
-//# sourceMappingURL=doc-cli-parity.d.ts.map

package/dist/doc-cli-parity.js

@@ -1,159 +0,0 @@
-/**
- * Doc ↔ CLI parity gate (#1996).
- *
- * Extracts npm-canonical CLI invocations from UPGRADING.md and the AGENTS.md
- * managed-section template, then asserts each resolves through the top-level
- * router to a registered dispatcher verb (or an explicitly allowlisted legacy
- * back-compat surface documented post-#1912).
- */
-import { readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { hasCommand } from "@deftai/directive-core/render";
-import { routeArgv } from "./cli-router/route-argv.js";
-import { registeredVerbs, resolveCanonicalVerb, VERB_ALIASES } from "./dispatch.js";
-/** Documented legacy surfaces that remain in prose but are not npm-router verbs. */
-export const LEGACY_DOC_VERB_KEYS = new Set(["setup", "upgrade", "relocate"]);
-const CLI_PREFIX_RE = /^(?:directive|deft|npx @deftai\/directive)\s+/;
-const BACKTICK_COMMAND_RE = /`((?:directive|deft|npx @deftai\/directive)\s+[^`]+)`/g;
-const TOP_LEVEL_UX = new Set(["init", "update", "migrate", "bootstrap"]);
-function repoRootFromModule() {
-    return resolve(import.meta.dirname, "..", "..", "..");
-}
-function extractManagedSection(text) {
-    const open = text.indexOf("<!-- deft:managed-section");
-    if (open < 0)
-        return text;
-    const close = text.indexOf("<!-- /deft:managed-section -->", open);
-    if (close < 0)
-        return text.slice(open);
-    return text.slice(open, close);
-}
-/** Pull CLI command references from UPGRADING.md + agents-entry managed section. */
-export function extractDocCliReferences(repoRoot = repoRootFromModule()) {
-    const sources = [
-        ["content/UPGRADING.md", readFileSync(join(repoRoot, "content/UPGRADING.md"), "utf8")],
-        [
-            "content/templates/agents-entry.md",
-            extractManagedSection(readFileSync(join(repoRoot, "content/templates/agents-entry.md"), "utf8")),
-        ],
-    ];
-    const seen = new Set();
-    const out = [];
-    for (const [source, text] of sources) {
-        for (const match of text.matchAll(BACKTICK_COMMAND_RE)) {
-            const raw = match[1]?.trim() ?? "";
-            if (!CLI_PREFIX_RE.test(raw))
-                continue;
-            const normalized = normalizeDocCommand(raw);
-            if (normalized === null)
-                continue;
-            const key = `${source}\0${normalized}`;
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            out.push({ source, raw, normalized });
-        }
-    }
-    return out.sort((a, b) => a.source.localeCompare(b.source) || a.normalized.localeCompare(b.normalized));
-}
-function stripAnglePlaceholders(text) {
-    let out = text;
-    let start = out.indexOf("<");
-    while (start >= 0) {
-        const end = out.indexOf(">", start + 1);
-        if (end < 0)
-            break;
-        out = `${out.slice(0, start)}${out.slice(end + 1)}`;
-        start = out.indexOf("<");
-    }
-    return out.trim();
-}
-/** Strip flags/placeholders; return null when the literal is not a CLI verb invocation. */
-export function normalizeDocCommand(raw) {
-    let rest = raw.replace(CLI_PREFIX_RE, "").trim();
-    if (rest.length === 0)
-        return null;
-    const dd = rest.indexOf(" --");
-    if (dd >= 0)
-        rest = rest.slice(0, dd).trim();
-    rest = rest.replace(/\s+\[[^\]]*\]/g, "").trim();
-    rest = rest.replace(/\s+--[^\s]+(\s+[^\s]+)?/g, "").trim();
-    rest = stripAnglePlaceholders(rest);
-    if (rest.includes("/") || rest.includes(".md") || rest.includes("*"))
-        return null;
-    if (/^deft-install\b/.test(rest))
-        return null;
-    if (/^deft-directive\b/.test(rest))
-        return null;
-    if (/^deftai\b/.test(rest))
-        return null;
-    const first = rest.split(/\s+/)[0] ?? "";
-    if (!/^[\w:-]+$/.test(first))
-        return null;
-    if (first.includes(":")) {
-        return first;
-    }
-    return first;
-}
-function tokenizeDocVerb(normalized) {
-    if (normalized.includes(":")) {
-        const colon = normalized.indexOf(":");
-        return [normalized.slice(0, colon), normalized.slice(colon + 1)];
-    }
-    return [normalized];
-}
-function colonKeyFromNormalized(normalized) {
-    if (normalized.includes(":"))
-        return normalized;
-    return null;
-}
-function isRegisteredHandler(flatVerb) {
-    const verbs = new Set(registeredVerbs());
-    if (verbs.has(flatVerb))
-        return true;
-    const canon = resolveCanonicalVerb(flatVerb);
-    return canon !== null && verbs.has(canon);
-}
-/** Validate one normalized doc command against the router + registeredVerbs(). */
-export function validateDocCliCommand(normalized) {
-    const colonKey = colonKeyFromNormalized(normalized);
-    if (colonKey !== null) {
-        if (LEGACY_DOC_VERB_KEYS.has(colonKey)) {
-            return null;
-        }
-        if (colonKey in VERB_ALIASES || hasCommand(colonKey)) {
-            return null;
-        }
-    }
-    else if (LEGACY_DOC_VERB_KEYS.has(normalized)) {
-        return null;
-    }
-    const tokens = tokenizeDocVerb(normalized);
-    const routed = routeArgv(tokens);
-    if (routed.kind === "stub") {
-        return routed.stubMessage ?? "routes to stub handler";
-    }
-    const head = routed.argv[0];
-    if (head === undefined || head.length === 0) {
-        return "router produced empty argv";
-    }
-    if (TOP_LEVEL_UX.has(head)) {
-        return null;
-    }
-    if (isRegisteredHandler(head)) {
-        return null;
-    }
-    return `unregistered handler '${head}' (tokens=${JSON.stringify(tokens)}, routed=${JSON.stringify(routed.argv.slice(0, 3))})`;
-}
-/** Run the parity gate; returns failure rows (empty == pass). */
-export function collectDocCliParityFailures(repoRoot = repoRootFromModule()) {
-    const failures = [];
-    for (const ref of extractDocCliReferences(repoRoot)) {
-        const reason = validateDocCliCommand(ref.normalized);
-        if (reason !== null) {
-            failures.push({ source: ref.source, raw: ref.raw, reason });
-        }
-    }
-    return failures;
-}
-//# sourceMappingURL=doc-cli-parity.js.map