@deftai/directive 0.55.0

package/dist/platform-parity.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1787 s3): runs BOTH the frozen Python oracle
+ * modules and the ported TS @deftai/directive-core/platform helpers over shared fixtures,
+ * cache-off, and diffs JSON payloads + exit codes.
+ *
+ * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { agentsRefreshPlan, detectIpTerms, disambiguateSlug, normalizeSlug, probeRuntimeCapabilities, reportToDict, resolveChangelog, resolveVersion, toPep440, } from "@deftai/directive-core/platform";
+const FIXED_ISO = "2026-06-19T12:00:00Z";
+const FIXED_SESSION = "abcdef012345";
+const FIXED_SHA = "deadbeefcafe";
+const SLUG_FIXTURES = [
+    "Hello World",
+    "Add widget (v2)!",
+    "café latte",
+    "El Niño Año",
+    "日本語",
+    "[x] Fix login bug",
+    "con",
+    "foo   bar---baz",
+];
+const PEP440_FIXTURES = ["v0.22.0", "v0.20.0-rc.3", "v0.20.0-beta.2", "0.20.0-alpha.1"];
+function resolveDeftRoot() {
+    if (process.env.DEFT_ROOT)
+        return resolve(process.env.DEFT_ROOT);
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+}
+function runPythonJson(deftRoot, code) {
+    const scriptsDir = join(deftRoot, "scripts").replace(/\\/g, "/");
+    const wrapped = [
+        "import json,sys",
+        `sys.path.insert(0, ${JSON.stringify(scriptsDir)})`,
+        code,
+    ].join("\n");
+    const stdout = execFileSync("uv", ["run", "python", "-c", wrapped], {
+        cwd: deftRoot,
+        encoding: "utf8",
+        env: { ...process.env, DEFT_CACHE_DISABLE: "1", PYTHONUTF8: "1" },
+    });
+    return JSON.parse(stdout.trim());
+}
+function stableJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+/** Strip volatile filesystem paths from capability reports before compare. */
+export function normalizeCapabilityReport(value) {
+    if (value === null || typeof value !== "object")
+        return value;
+    const record = value;
+    const out = { ...record };
+    if (record.ownership && typeof record.ownership === "object") {
+        out.ownership = { ...record.ownership, path: "<REPO>" };
+    }
+    return out;
+}
+/** Normalise volatile agents-refresh plan fields for comparison. */
+export function normalizeAgentsPlan(plan) {
+    const out = { ...plan };
+    for (const key of ["sha", "refreshed", "session", "attributed_rendered", "new_content"]) {
+        if (key in out)
+            out[key] = "<NORMALIZED>";
+    }
+    return out;
+}
+const CHANGELOG_HEADER = "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n";
+function buildConflictChangelog() {
+    return (`${CHANGELOG_HEADER}## [Unreleased]\n\n` +
+        "### Added\n\n" +
+        "<<<<<<< HEAD\n" +
+        "- **feat: head entry** -- landed (#100)\n" +
+        "=======\n" +
+        "- **feat: branch entry** -- new (#200)\n" +
+        ">>>>>>> branch-sha\n\n" +
+        "## [0.1.0] - 2026-01-01\n");
+}
+function readTemplate(deftRoot) {
+    // #1875: the AGENTS.md template moved under content/ in the source repo
+    // (content/templates/agents-entry.md). Prefer that location and fall back to
+    // the flattened layout (templates/agents-entry.md) so the harness resolves in
+    // both a source checkout and a flattened consumer deposit.
+    const contentCandidate = join(deftRoot, "content", "templates", "agents-entry.md");
+    const flatCandidate = join(deftRoot, "templates", "agents-entry.md");
+    return readFileSync(existsSync(contentCandidate) ? contentCandidate : flatCandidate, "utf8");
+}
+export const PARITY_CASES = [
+    {
+        name: "slug-normalize-unicode",
+        runPython: (deftRoot) => runPythonJson(deftRoot, [
+            "from slug_normalize import normalize_slug, disambiguate_slug",
+            `fixtures = ${JSON.stringify(SLUG_FIXTURES)}`,
+            "out = {'slugs': [normalize_slug(t) for t in fixtures], 'collision': disambiguate_slug('hello-world', {'hello-world'})}",
+            "print(json.dumps(out))",
+        ].join("\n")),
+        runTs: () => ({
+            slugs: SLUG_FIXTURES.map((t) => normalizeSlug(t)),
+            collision: disambiguateSlug("hello-world", new Set(["hello-world"])),
+        }),
+    },
+    {
+        name: "version-resolve-manifest",
+        setup: (repo) => {
+            writeFileSync(join(repo, "VERSION"), "tag: v9.8.7\nref: v9.8.7\n", "utf8");
+        },
+        runPython: (deftRoot, repo) => runPythonJson(deftRoot, [
+            "import json",
+            "from pathlib import Path",
+            "import resolve_version as rv",
+            `base = Path(${JSON.stringify(repo)})`,
+            "print(json.dumps({'version': rv._from_manifest(base), 'pep440': [rv.to_pep440(v) for v in " +
+                JSON.stringify(PEP440_FIXTURES) +
+                "]}))",
+        ].join("\n")),
+        runTs: (_deftRoot, repo) => ({
+            version: resolveVersion({
+                frameworkRoot: repo,
+                fromEnv: () => null,
+                fromManifest: (base) => {
+                    const text = readFileSync(join(base, "VERSION"), "utf8");
+                    for (const line of text.split("\n")) {
+                        const trimmed = line.trim();
+                        if (trimmed.startsWith("tag:") || trimmed.startsWith("ref:")) {
+                            let value = trimmed.slice(trimmed.indexOf(":") + 1).trim();
+                            if (value.startsWith("v"))
+                                value = value.slice(1);
+                            return value;
+                        }
+                    }
+                    return null;
+                },
+                fromDeftVersion: () => null,
+                fromGit: () => null,
+            }),
+            pep440: PEP440_FIXTURES.map((v) => toPep440(v)),
+        }),
+    },
+    {
+        name: "changelog-union-merge",
+        runPython: (deftRoot) => runPythonJson(deftRoot, [
+            "import resolve_changelog_unreleased as r",
+            `content = ${JSON.stringify(buildConflictChangelog())}`,
+            "new_content, msg = r.resolve_changelog(content)",
+            "print(json.dumps({'message': msg, 'has_100': '(#100)' in new_content, 'has_200': '(#200)' in new_content, 'markers': '<<<<<<<' in new_content}))",
+        ].join("\n")),
+        runTs: () => {
+            const { content, message } = resolveChangelog(buildConflictChangelog());
+            return {
+                message,
+                has_100: content?.includes("(#100)") ?? false,
+                has_200: content?.includes("(#200)") ?? false,
+                markers: content?.includes("<<<<<<<") ?? false,
+            };
+        },
+    },
+    {
+        name: "agents-refresh-managed-section",
+        setup: (repo) => {
+            const deftRoot = resolveDeftRoot();
+            const template = readTemplate(deftRoot);
+            writeFileSync(join(repo, "AGENTS.md"), `# Notes\n\n<!-- deft:managed-section v3 sha=old refreshed=2020-01-01T00:00:00Z session=oldsession12 -->\nlegacy body\n<!-- /deft:managed-section -->\n`, "utf8");
+            mkdirSync(join(repo, "templates"), { recursive: true });
+            writeFileSync(join(repo, "templates", "agents-entry.md"), template, "utf8");
+        },
+        runPython: (deftRoot, repo) => {
+            const template = readTemplate(deftRoot);
+            return runPythonJson(deftRoot, [
+                "import json",
+                "from pathlib import Path",
+                "import _agents_md as am",
+                `root = Path(${JSON.stringify(repo)})`,
+                `template = ${JSON.stringify(template)}`,
+                "plan = am._agents_refresh_plan(",
+                "    root,",
+                "    read_template=lambda: template,",
+                `    resolve_sha=lambda: ${JSON.stringify(FIXED_SHA)},`,
+                `    now_iso=lambda: ${JSON.stringify(FIXED_ISO)},`,
+                `    new_session=lambda: ${JSON.stringify(FIXED_SESSION)},`,
+                ")",
+                "print(json.dumps({'state': plan['state'], 'rendered_len': len(plan.get('rendered') or ''), 'has_v3': 'v3 sha=' in (plan.get('new_content') or '')}))",
+            ].join("\n"));
+        },
+        runTs: (deftRoot, repo) => {
+            const template = readTemplate(deftRoot);
+            const plan = agentsRefreshPlan(repo, {
+                frameworkRoot: repo,
+                readTemplate: () => template,
+                resolveSha: () => FIXED_SHA,
+                nowIso: () => FIXED_ISO,
+                newSession: () => FIXED_SESSION,
+            });
+            return {
+                state: plan.state,
+                rendered_len: (plan.rendered ?? "").length,
+                has_v3: String(plan.new_content ?? "").includes("v3 sha="),
+            };
+        },
+    },
+    {
+        name: "platform-capabilities-sandbox",
+        setup: (repo) => {
+            writeFileSync(join(repo, "uid_map"), "0 1000 1\n1 100001 1\n", "utf8");
+        },
+        runPython: (deftRoot, repo) => runPythonJson(deftRoot, [
+            "import json",
+            "from pathlib import Path",
+            "import platform_capabilities as pc",
+            `env = {'CURSOR_ORIG_UID': '1000', 'CURSOR_SANDBOX': '1'}`,
+            `report = pc.probe_runtime_capabilities(environ=env, uid_map_path=Path(${JSON.stringify(join(repo, "uid_map"))}), cwd=Path(${JSON.stringify(repo)}), effective_uid_override=0)`,
+            "payload = report.to_dict()",
+            "if payload.get('ownership'): payload['ownership'] = {**payload['ownership'], 'path': '<REPO>'}",
+            "print(json.dumps(payload))",
+        ].join("\n")),
+        runTs: (_deftRoot, repo) => normalizeCapabilityReport(reportToDict(probeRuntimeCapabilities({
+            environ: { CURSOR_ORIG_UID: "1000", CURSOR_SANDBOX: "1" },
+            uidMapPath: join(repo, "uid_map"),
+            cwd: repo,
+            effectiveUidOverride: 0,
+        }))),
+    },
+    {
+        name: "ip-risk-detect",
+        runPython: (deftRoot) => runPythonJson(deftRoot, [
+            "import json",
+            "import ip_risk",
+            "text = 'A Magic: The Gathering deck-builder with NFL stats'",
+            "hits = ip_risk.detect_ip_terms(text)",
+            "print(json.dumps([{'term': h.term, 'category': h.category} for h in hits]))",
+        ].join("\n")),
+        runTs: () => detectIpTerms("A Magic: The Gathering deck-builder with NFL stats").map((h) => ({
+            term: h.term,
+            category: h.category,
+        })),
+    },
+];
+export function diffCase(name, python, ts) {
+    const pythonJson = stableJson(python);
+    const tsJson = stableJson(ts);
+    return {
+        caseName: name,
+        mismatch: pythonJson !== tsJson,
+        pythonJson,
+        tsJson,
+    };
+}
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const diffs = [];
+    for (const testCase of PARITY_CASES) {
+        const pyRepo = mkdtempSync(join(tmpdir(), "deft-platform-parity-py-"));
+        const tsRepo = mkdtempSync(join(tmpdir(), "deft-platform-parity-ts-"));
+        try {
+            testCase.setup?.(pyRepo);
+            testCase.setup?.(tsRepo);
+            const python = testCase.runPython(deftRoot, pyRepo);
+            const ts = testCase.runTs(deftRoot, tsRepo);
+            diffs.push(diffCase(testCase.name, python, ts));
+        }
+        finally {
+            rmSync(pyRepo, { recursive: true, force: true });
+            rmSync(tsRepo, { recursive: true, force: true });
+        }
+    }
+    return { ok: diffs.every((d) => !d.mismatch), diffs };
+}
+export function renderReport(result) {
+    if (result.ok) {
+        return `platform parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} case(s).`;
+    }
+    const lines = ["platform parity: DIVERGENCE"];
+    for (const d of result.diffs) {
+        if (d.mismatch) {
+            lines.push(`  case: ${d.caseName}`);
+            lines.push("    --- python");
+            lines.push(d.pythonJson
+                .split("\n")
+                .slice(0, 12)
+                .map((l) => `    ${l}`)
+                .join("\n"));
+            lines.push("    --- ts");
+            lines.push(d.tsJson
+                .split("\n")
+                .slice(0, 12)
+                .map((l) => `    ${l}`)
+                .join("\n"));
+        }
+    }
+    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(`platform parity: harness error -- ${String(err)}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=platform-parity.js.map

package/dist/policy-parity.d.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+export interface CommandCapture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ParityCase {
+    readonly name: string;
+    readonly argv: string[];
+    readonly env?: Record<string, string | undefined>;
+    readonly fixture?: Record<string, unknown>;
+}
+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[];
+}
+/** Strip volatile ISO timestamps from audit / JSON envelopes before compare. */
+export declare function normalizeOutput(text: string): string;
+/** Build a throwaway project root with optional PROJECT-DEFINITION plan payload. */
+export declare function buildFixtureRepo(plan?: Record<string, unknown>): string;
+/** Diff one parity case between Python oracle and TS CLI. */
+export declare function diffCase(python: CommandCapture, ts: CommandCapture, caseName: string): ParityDiff;
+export declare const PARITY_CASES: readonly ParityCase[];
+/** Run all parity cases; returns aggregate result. */
+export declare function runParity(): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=policy-parity.d.ts.map

package/dist/policy-parity.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1722): builds throwaway fixture repos, runs
+ * BOTH the Python oracle (scripts/policy.py + shims) and the TS policy CLI,
+ * and diffs resolution output + disclosure_line + exit codes.
+ *
+ * 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";
+/** Strip volatile ISO timestamps from audit / JSON envelopes before compare. */
+export function normalizeOutput(text) {
+    return text
+        .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/g, "<TS>")
+        .replace(/PROJECT-DEFINITION not found at [^\s)]+/g, "PROJECT-DEFINITION not found at <ROOT>")
+        .replace(/fail-closed: PROJECT-DEFINITION not found at [^)]+/g, "fail-closed: PROJECT-DEFINITION not found at <ROOT>");
+}
+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 writeFixture(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" });
+}
+/** Build a throwaway project root with optional PROJECT-DEFINITION plan payload. */
+export function buildFixtureRepo(plan) {
+    const root = mkdtempSync(join(tmpdir(), "deft-policy-parity-"));
+    mkdirSync(join(root, "vbrief"), { recursive: true });
+    if (plan !== undefined) {
+        writeFixture(root, plan);
+    }
+    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 runPythonPolicy(deftRoot, repo, argv, env) {
+    const sub = argv[0];
+    if (sub === undefined) {
+        throw new Error("missing policy subcommand");
+    }
+    const rest = argv.slice(1);
+    const withRoot = [...rest, "--project-root", repo];
+    if (sub === "show") {
+        const cap = runCapture("uv", ["run", "python", join(deftRoot, "scripts", "_policy_show_cli.py"), ...withRoot], deftRoot, env);
+        return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+    }
+    if (sub === "resolve") {
+        const cap = runCapture("uv", ["run", "python", join(deftRoot, "scripts", "policy.py"), "show", ...withRoot], deftRoot, env);
+        return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+    }
+    const cap = runCapture("uv", ["run", "python", join(deftRoot, "scripts", "policy_set.py"), sub, ...withRoot], deftRoot, env);
+    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+}
+function runTsPolicy(deftRoot, repo, argv, env) {
+    const cap = runCapture("node", [join(deftRoot, "packages", "cli", "dist", "policy.js"), ...argv, "--project-root", repo], deftRoot, env);
+    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+}
+/** Diff one parity case between Python oracle and TS CLI. */
+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 const PARITY_CASES = [
+    {
+        name: "resolve-default-missing-pd",
+        argv: ["resolve"],
+        env: { DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "resolve-typed-false",
+        argv: ["resolve"],
+        fixture: { policy: { allowDirectCommitsToMaster: false } },
+        env: { DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "resolve-typed-true",
+        argv: ["resolve"],
+        fixture: { policy: { allowDirectCommitsToMaster: true } },
+        env: { DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "resolve-legacy-narrative",
+        argv: ["resolve"],
+        fixture: { narratives: { "Allow direct commits to master": "true" } },
+        env: { DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "resolve-env-bypass",
+        argv: ["resolve"],
+        fixture: { policy: { allowDirectCommitsToMaster: false } },
+        env: { DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "1" },
+    },
+    {
+        name: "show-text-defaults",
+        argv: ["show"],
+        fixture: {},
+        env: { DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "show-field-wipCap",
+        argv: ["show", "--field", "plan.policy.wipCap"],
+        fixture: { policy: { wipCap: 7 } },
+        env: { DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "allow-direct-commits-refuse",
+        argv: ["allow-direct-commits"],
+        fixture: {},
+        env: { DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+    {
+        name: "enforce-branches",
+        argv: ["enforce-branches", "--actor", "parity-test"],
+        fixture: { policy: { allowDirectCommitsToMaster: true } },
+        env: { DEFT_ALLOW_DEFAULT_BRANCH_COMMIT: "" },
+    },
+];
+/** Run all parity cases; returns aggregate result. */
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const diffs = [];
+    for (const testCase of PARITY_CASES) {
+        const pyRepo = buildFixtureRepo(testCase.fixture);
+        const tsRepo = buildFixtureRepo(testCase.fixture);
+        try {
+            const env = testCase.env ?? {};
+            const python = runPythonPolicy(deftRoot, pyRepo, testCase.argv, env);
+            const ts = runTsPolicy(deftRoot, tsRepo, testCase.argv, env);
+            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 `policy parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
+    }
+    const lines = ["policy 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(`policy parity: harness error -- ${String(err)}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=policy-parity.js.map

package/dist/policy.d.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+interface ShowArgs {
+    format: "text" | "json";
+    changedOnly: boolean;
+    field: string | null;
+    projectRoot: string;
+    error?: string;
+}
+interface SetArgs {
+    cmd: "show" | "enforce-branches" | "allow-direct-commits" | "resolve";
+    confirm: boolean;
+    actor: string;
+    note: string;
+    projectRoot: string;
+    format: "text" | "json";
+    changedOnly: boolean;
+    field: string | null;
+    error?: string;
+}
+/** Parse policy:show flags (mirrors _policy_show_cli.py). */
+export declare function parseShowArgs(argv: string[]): ShowArgs;
+/** Parse argv for the policy CLI (show + set subcommands). */
+export declare function parseArgs(argv: string[]): SetArgs;
+/** Run the policy CLI; returns process exit code. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=policy.d.ts.map