@deftai/directive 0.55.0

package/dist/bin.d.ts

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

package/dist/bin.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { routeAndDispatch } from "./cli-router/index.js";
+const code = await routeAndDispatch(process.argv.slice(2));
+process.exit(code);
+//# sourceMappingURL=bin.js.map

package/dist/branch-parity.d.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+export interface ScenarioResult {
+    readonly name: string;
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ParityScenario {
+    readonly name: string;
+    readonly branch: "default" | "feature" | "detached";
+    readonly defaultBranchName?: string;
+    readonly plan?: Record<string, unknown> | null;
+    readonly allowMissingProjectDefinition?: boolean;
+    readonly env?: Record<string, string | undefined>;
+}
+export interface ParityResult {
+    readonly ok: boolean;
+    readonly scenarios: Array<{
+        readonly name: string;
+        readonly exitMismatch: boolean;
+        readonly pythonExit: number;
+        readonly tsExit: number;
+        readonly messageMismatch: boolean;
+        readonly pythonMessage: string;
+        readonly tsMessage: string;
+    }>;
+}
+/** Scenarios exercised by the parity harness (mirrors Python contract cases). */
+export declare const PARITY_SCENARIOS: readonly ParityScenario[];
+/** Normalise gate message for comparison (trim, collapse whitespace). */
+export declare function normaliseMessage(stdout: string, stderr: string, exitCode: number): string;
+/** Build a fixture git repo for one scenario. */
+export declare function buildScenarioRepo(scenario: ParityScenario): {
+    root: string;
+};
+/** Diff python vs TS gate outputs for one scenario. */
+export declare function diffParity(python: ScenarioResult, ts: ScenarioResult): {
+    exitMismatch: boolean;
+    messageMismatch: boolean;
+    pythonMessage: string;
+    tsMessage: string;
+};
+/** Run all parity scenarios and return a structured result. */
+export declare function runParity(): ParityResult;
+/** Render a human-readable parity report (exported for unit tests). */
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=branch-parity.d.ts.map

package/dist/branch-parity.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1719): builds throwaway git fixture repos for
+ * branch-protection scenarios, runs BOTH the Python oracle
+ * (`scripts/preflight_branch.py`) and the ported TS gate, and diffs exit
+ * codes + normalised messages. Exit 0 only on identical results.
+ *
+ * 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";
+function gitCommit(cwd, message) {
+    execFileSync("git", ["commit", "-q", "-m", message], {
+        cwd,
+        env: {
+            ...process.env,
+            GIT_AUTHOR_NAME: "deft-parity",
+            GIT_AUTHOR_EMAIL: "parity@test.local",
+            GIT_COMMITTER_NAME: "deft-parity",
+            GIT_COMMITTER_EMAIL: "parity@test.local",
+        },
+    });
+}
+function writeProjectDef(root, plan) {
+    const dir = join(root, "vbrief");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "PROJECT-DEFINITION.vbrief.json"), `${JSON.stringify({
+        vBRIEFInfo: { version: "0.6" },
+        plan: { title: "T", status: "running", items: [], ...plan },
+    }, null, 2)}\n`, { encoding: "utf8" });
+}
+/** Scenarios exercised by the parity harness (mirrors Python contract cases). */
+export const PARITY_SCENARIOS = [
+    {
+        name: "setup-exemption",
+        branch: "default",
+        plan: null,
+        env: { DEFT_SETUP_INTERVIEW: "1", DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "feature-branch",
+        branch: "feature",
+        plan: { policy: { allowDirectCommitsToMaster: false } },
+        env: { DEFT_SETUP_INTERVIEW: "", DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "detached-head",
+        branch: "detached",
+        plan: { policy: { allowDirectCommitsToMaster: false } },
+        env: { DEFT_SETUP_INTERVIEW: "", DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "master-blocked",
+        branch: "default",
+        defaultBranchName: "master",
+        plan: { policy: { allowDirectCommitsToMaster: false } },
+        env: { DEFT_SETUP_INTERVIEW: "", DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "master-opt-out-typed",
+        branch: "default",
+        defaultBranchName: "master",
+        plan: { policy: { allowDirectCommitsToMaster: true } },
+        env: { DEFT_SETUP_INTERVIEW: "", DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "env-bypass",
+        branch: "default",
+        defaultBranchName: "master",
+        plan: { policy: { allowDirectCommitsToMaster: false } },
+        env: { DEFT_SETUP_INTERVIEW: "", DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "1" },
+    },
+    {
+        name: "missing-pd-config-error",
+        branch: "default",
+        defaultBranchName: "master",
+        plan: undefined,
+        env: { DEFT_SETUP_INTERVIEW: "", DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "missing-pd-bootstrap",
+        branch: "default",
+        defaultBranchName: "master",
+        plan: undefined,
+        allowMissingProjectDefinition: true,
+        env: { DEFT_SETUP_INTERVIEW: "", DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "malformed-typed-field",
+        branch: "default",
+        defaultBranchName: "master",
+        plan: { policy: { allowDirectCommitsToMaster: "yes" } },
+        env: { DEFT_SETUP_INTERVIEW: "", DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+];
+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 : "",
+        };
+    }
+}
+/** Normalise gate message for comparison (trim, collapse whitespace). */
+export function normaliseMessage(stdout, stderr, exitCode) {
+    const raw = exitCode === 0 ? stdout : stderr;
+    return raw
+        .trim()
+        .replace(/\s+/g, " ")
+        .replace(/PROJECT-DEFINITION not found at [^\s)]+/g, "PROJECT-DEFINITION not found at <ROOT>");
+}
+/** Build a fixture git repo for one scenario. */
+export function buildScenarioRepo(scenario) {
+    const root = mkdtempSync(join(tmpdir(), "deft-branch-parity-"));
+    const defaultBranch = scenario.defaultBranchName ?? "master";
+    try {
+        writeFileSync(join(root, "README.md"), "# parity\n", "utf8");
+        if (scenario.plan !== null && scenario.plan !== undefined) {
+            writeProjectDef(root, scenario.plan);
+        }
+        execFileSync("git", ["init", "-q"], { cwd: root });
+        execFileSync("git", ["branch", "-M", defaultBranch], { cwd: root });
+        execFileSync("git", ["add", "-A"], { cwd: root });
+        gitCommit(root, "init");
+        if (scenario.branch === "feature") {
+            execFileSync("git", ["checkout", "-q", "-b", "feat/parity"], { cwd: root });
+        }
+        else if (scenario.branch === "detached") {
+            execFileSync("git", ["checkout", "-q", "--detach"], { cwd: root });
+        }
+    }
+    catch (err) {
+        rmSync(root, { recursive: true, force: true });
+        throw err;
+    }
+    return { root };
+}
+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 { root } = buildScenarioRepo(scenario);
+    const env = scenario.env ?? {};
+    const sharedArgs = ["--project-root", root];
+    if (scenario.allowMissingProjectDefinition) {
+        sharedArgs.push("--allow-missing-project-definition");
+    }
+    const pyArgs = ["run", "python", join(deftRoot, "scripts", "preflight_branch.py"), ...sharedArgs];
+    const tsArgs = [join(deftRoot, "packages", "cli", "dist", "verify-branch.js"), ...sharedArgs];
+    const py = runCapture("uv", pyArgs, deftRoot, env);
+    const ts = runCapture("node", tsArgs, deftRoot, env);
+    return {
+        root,
+        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,
+        },
+    };
+}
+/** Diff python vs TS gate outputs for one scenario. */
+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,
+    };
+}
+/** Run all parity scenarios and return a structured result. */
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const scenarios = [];
+    for (const scenario of PARITY_SCENARIOS) {
+        let root;
+        try {
+            const ran = runScenario(deftRoot, scenario);
+            root = ran.root;
+            const diff = diffParity(ran.python, ran.ts);
+            scenarios.push({
+                name: scenario.name,
+                pythonExit: ran.python.exitCode,
+                tsExit: ran.ts.exitCode,
+                ...diff,
+            });
+        }
+        finally {
+            if (root !== undefined) {
+                rmSync(root, { recursive: true, force: true });
+            }
+        }
+    }
+    const ok = scenarios.every((s) => !s.exitMismatch && !s.messageMismatch);
+    return { ok, scenarios };
+}
+/** Render a human-readable parity report (exported for unit tests). */
+export function renderReport(result) {
+    if (result.ok) {
+        return `verify_branch parity: CLEAN -- Python and TS agree on ${result.scenarios.length} scenario(s).`;
+    }
+    const lines = ["verify_branch 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(`verify_branch parity: harness error -- ${msg}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=branch-parity.js.map

package/dist/cache-parity.d.ts

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+export interface ScenarioResult {
+    readonly name: string;
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ParityScenario {
+    readonly name: string;
+    readonly argv: readonly string[];
+}
+export interface ParityResult {
+    readonly ok: boolean;
+    readonly scenarios: Array<{
+        readonly name: string;
+        readonly exitMismatch: boolean;
+        readonly pythonExit: number;
+        readonly tsExit: number;
+        readonly messageMismatch: boolean;
+        readonly pythonMessage: string;
+        readonly tsMessage: string;
+    }>;
+}
+/** Validation-only scenarios (no live gh network). */
+export declare const PARITY_SCENARIOS: readonly ParityScenario[];
+/** Normalise gate output for comparison. */
+export declare function normaliseMessage(stdout: string, stderr: string, exitCode: number): string;
+export declare function diffParity(python: ScenarioResult, ts: ScenarioResult): {
+    exitMismatch: boolean;
+    messageMismatch: boolean;
+    pythonMessage: string;
+    tsMessage: string;
+};
+export declare function runParity(): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=cache-parity.d.ts.map

package/dist/cache-parity.js

@@ -0,0 +1,165 @@
+#!/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/cache.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from "../../core/dist/cache/main.js";
+export { main };
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { main } from "../../core/dist/cache/main.js";
+/* v8 ignore start -- entry guard; behaviour covered via main() unit tests */
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(main(process.argv.slice(2)));
+}
+/* v8 ignore stop */
+export { main };
+//# sourceMappingURL=cache.js.map

package/dist/capacity-backfill.d.ts

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

package/dist/capacity-backfill.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runCapacityBackfillCli } from "@deftai/directive-core/capacity";
+const result = await runCapacityBackfillCli(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=capacity-backfill.js.map

package/dist/capacity-show.d.ts

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

package/dist/capacity-show.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runCapacityShowCli } from "@deftai/directive-core/capacity";
+const result = runCapacityShowCli(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=capacity-show.js.map

package/dist/check.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    frameworkRoot?: string;
+    projectRoot?: string;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=check.d.ts.map

package/dist/check.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * check.ts -- CLI wrapper for the context-aware `task check` orchestrator (#1854).
+ *
+ * Usage: deft-ts check --framework-root <path> --project-root <path>
+ *
+ * Thin shim: parses args and delegates to dispatchTaskCheck in @deftai/directive-core/check.
+ */
+import { fileURLToPath } from "node:url";
+import { dispatchTaskCheck } from "@deftai/directive-core/check";
+export function parseArgs(argv) {
+    const parsed = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i] ?? "";
+        if (arg === "--framework-root") {
+            const next = argv[i + 1];
+            if (next === undefined) {
+                return { ...parsed, error: "argument --framework-root: expected one argument" };
+            }
+            parsed.frameworkRoot = next;
+            i++;
+        }
+        else if (arg.startsWith("--framework-root=")) {
+            parsed.frameworkRoot = arg.slice("--framework-root=".length);
+        }
+        else if (arg === "--project-root") {
+            const next = argv[i + 1];
+            if (next === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = next;
+            i++;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`check: ${args.error}\n`);
+        return 2;
+    }
+    if (args.frameworkRoot === undefined || args.projectRoot === undefined) {
+        process.stderr.write("check: --framework-root and --project-root are required\n");
+        return 2;
+    }
+    return dispatchTaskCheck(args.frameworkRoot, args.projectRoot);
+}
+/* v8 ignore start -- entry guard */
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+/* v8 ignore stop */
+//# sourceMappingURL=check.js.map

package/dist/cli-router/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CLI router entry: `directive <namespace> <verb>` → flat dispatcher (#1670 / #11 S3).
+ */
+import { type DispatchIo } from "../dispatch.js";
+export { DEFERRED_TOP_LEVEL_VERBS, PR_VERB_MAP, type RoutedArgv, type RouteKind, 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 declare function routeAndDispatch(argv: readonly string[], io?: DispatchIo): Promise<number>;
+//# sourceMappingURL=index.d.ts.map