@deftai/directive 0.62.0 → 0.64.0

package/dist/validate-content-parity.js

@@ -1,356 +0,0 @@
-#!/usr/bin/env node
-/**
- * Golden-output parity harness (#1783 s3): runs BOTH the Python oracles
- * (`validate-links.py`, `validate_strategy_output.py`, `verify_capacity.py`)
- * and the ported TS validate-content gates over shared fixtures, then diffs
- * exit codes + stdout/stderr (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 { validateLinks, validateStrategyOutput, verifyCapacity, } from "@deftai/directive-core/validate-content";
-export function normalizeOutput(text) {
-    return text.replace(/verify_capacity: --project-root is not a directory: [^\n]+/g, "verify_capacity: --project-root is not a directory: <ROOT>");
-}
-const NOW_ISO = "2026-06-04T12:00:00Z";
-function runPythonGate(deftRoot, gate, repo, argv, env) {
-    const scriptsDir = join(deftRoot, "scripts").replace(/\\/g, "/");
-    const repoPath = repo.replace(/\\/g, "/");
-    let code;
-    if (gate === "validate-links") {
-        const strict = argv.includes("--strict") || env.LINK_CHECK_STRICT === "1";
-        code = [
-            "import sys,os,importlib.util",
-            `sys.path.insert(0, ${JSON.stringify(scriptsDir)})`,
-            `os.chdir(${JSON.stringify(repoPath)})`,
-            strict ? "os.environ['LINK_CHECK_STRICT']='1'" : "os.environ.pop('LINK_CHECK_STRICT', None)",
-            `spec=importlib.util.spec_from_file_location('validate_links', ${JSON.stringify(join(deftRoot, "scripts", "validate-links.py"))})`,
-            "mod=importlib.util.module_from_spec(spec); spec.loader.exec_module(mod)",
-            `sys.argv = ['validate-links.py'] + ${JSON.stringify(argv)}`,
-            "raise SystemExit(mod.main())",
-        ].join(";");
-    }
-    else if (gate === "validate-strategy-output") {
-        code = [
-            "import sys",
-            `sys.path.insert(0, ${JSON.stringify(scriptsDir)})`,
-            "from validate_strategy_output import main as m",
-            `raise SystemExit(m([${["--project-root", repoPath, ...argv].map((a) => JSON.stringify(a)).join(",")}]))`,
-        ].join(";");
-    }
-    else {
-        code = [
-            "import sys",
-            "from datetime import datetime",
-            "from pathlib import Path",
-            `sys.path.insert(0, ${JSON.stringify(scriptsDir)})`,
-            "from verify_capacity import evaluate as ev",
-            `root = Path(${JSON.stringify(repoPath)})`,
-            `now = datetime.fromisoformat(${JSON.stringify(NOW_ISO)}.replace("Z", "+00:00"))`,
-            "code, msg = ev(root, now=now)",
-            "stream = sys.stdout if code == 0 else sys.stderr",
-            "stream.write(msg)",
-            'if not msg.endswith("\\n"):',
-            '    stream.write("\\n")',
-            "raise SystemExit(code)",
-        ].join("\n");
-    }
-    try {
-        const stdout = execFileSync("uv", ["run", "python", "-c", code], {
-            cwd: deftRoot,
-            encoding: "utf8",
-            env: { ...process.env, ...env, DEFT_CACHE_DISABLE: "1", PYTHONUTF8: "1" },
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        return { exitCode: 0, stdout: typeof stdout === "string" ? stdout : "", stderr: "" };
-    }
-    catch (err) {
-        const e = err;
-        return {
-            exitCode: e.status ?? 2,
-            stdout: typeof e.stdout === "string" ? e.stdout : "",
-            stderr: typeof e.stderr === "string" ? e.stderr : "",
-        };
-    }
-}
-function runTsGate(gate, repo, testCase) {
-    const argv = testCase.argv ?? [];
-    const env = testCase.env ?? {};
-    const now = testCase.now ? new Date(testCase.now) : new Date(NOW_ISO);
-    let result;
-    if (gate === "validate-links") {
-        result = validateLinks.evaluate({
-            cwd: repo,
-            argv,
-            linkCheckStrict: env.LINK_CHECK_STRICT === "1",
-            strict: argv.includes("--strict"),
-        });
-    }
-    else if (gate === "validate-strategy-output") {
-        result = validateStrategyOutput.evaluate({
-            projectRoot: repo,
-            strict: argv.includes("--strict"),
-            quiet: argv.includes("--quiet"),
-        });
-    }
-    else {
-        result = verifyCapacity.evaluate({ projectRoot: repo, now });
-    }
-    const stream = result.stream;
-    return {
-        exitCode: result.code,
-        stdout: stream === "stdout" ? `${result.message}\n` : "",
-        stderr: stream === "stderr" ? `${result.message}\n` : "",
-    };
-}
-function writeJson(path, data) {
-    writeFileSync(path, `${JSON.stringify(data)}\n`, { encoding: "utf8" });
-}
-function makeLifecycle(root) {
-    for (const folder of ["proposed", "pending", "active", "completed", "cancelled"]) {
-        mkdirSync(join(root, "vbrief", folder), { recursive: true });
-    }
-}
-export const PARITY_CASES = [
-    {
-        gate: "validate-links",
-        name: "links-clean",
-        setup: (root) => {
-            writeFileSync(join(root, "README.md"), "See [guide](guide.md)\n", { encoding: "utf8" });
-            writeFileSync(join(root, "guide.md"), "# Guide\n", { encoding: "utf8" });
-        },
-    },
-    {
-        gate: "validate-links",
-        name: "links-broken-warning",
-        setup: (root) => {
-            writeFileSync(join(root, "README.md"), "See [missing](nope.md)\n", { encoding: "utf8" });
-        },
-        env: { LINK_CHECK_STRICT: "" },
-    },
-    {
-        gate: "validate-links",
-        name: "links-broken-strict",
-        setup: (root) => {
-            writeFileSync(join(root, "doc.md"), "See [nope](nope.md).\n", { encoding: "utf8" });
-        },
-        argv: ["--strict"],
-    },
-    {
-        gate: "validate-strategy-output",
-        name: "strategy-conformant",
-        setup: (root) => {
-            mkdirSync(join(root, "vbrief", "proposed"), { recursive: true });
-            writeFileSync(join(root, "vbrief", "PROJECT-DEFINITION.vbrief.json"), "{}", {
-                encoding: "utf8",
-            });
-            writeFileSync(join(root, "vbrief", "proposed", "2026-05-26-good.vbrief.json"), "{}", {
-                encoding: "utf8",
-            });
-        },
-    },
-    {
-        gate: "validate-strategy-output",
-        name: "strategy-missing-projdef",
-        setup: (root) => {
-            mkdirSync(join(root, "vbrief", "proposed"), { recursive: true });
-            writeFileSync(join(root, "vbrief", "proposed", "2026-05-26-good.vbrief.json"), "{}", {
-                encoding: "utf8",
-            });
-        },
-    },
-    {
-        gate: "validate-strategy-output",
-        name: "strategy-strict-missing-vbrief",
-        setup: () => {
-            /* empty root */
-        },
-        argv: ["--strict"],
-    },
-    {
-        gate: "verify-capacity",
-        name: "capacity-unconfigured",
-        setup: (root) => {
-            makeLifecycle(root);
-            writeJson(join(root, "vbrief", "PROJECT-DEFINITION.vbrief.json"), {
-                vBRIEFInfo: { version: "0.6" },
-                plan: { title: "T", status: "running", items: [] },
-            });
-        },
-    },
-    {
-        gate: "verify-capacity",
-        name: "capacity-advise-posture",
-        setup: (root) => {
-            makeLifecycle(root);
-            writeJson(join(root, "vbrief", "PROJECT-DEFINITION.vbrief.json"), {
-                vBRIEFInfo: { version: "0.6" },
-                plan: {
-                    title: "T",
-                    status: "running",
-                    items: [],
-                    policy: {
-                        capacityAllocation: {
-                            unit: "vbrief-count",
-                            window: 30,
-                            enforcement: "advise",
-                            minSampleSize: 2,
-                            defaultBucket: "feature",
-                            buckets: [
-                                { id: "debt", target: 0.4 },
-                                { id: "feature", target: 0.6 },
-                            ],
-                        },
-                    },
-                },
-            });
-            const completedAt = "2026-06-03T12:00:00Z";
-            for (let i = 0; i < 4; i += 1) {
-                writeJson(join(root, "vbrief", "completed", `feat-${i}.vbrief.json`), {
-                    vBRIEFInfo: { version: "0.6" },
-                    plan: {
-                        title: `feat-${i}`,
-                        status: "completed",
-                        items: [],
-                        metadata: { capacityBucket: "feature", completedAt },
-                    },
-                });
-            }
-        },
-    },
-    {
-        gate: "verify-capacity",
-        name: "capacity-enforce-deficit",
-        setup: (root) => {
-            makeLifecycle(root);
-            writeJson(join(root, "vbrief", "PROJECT-DEFINITION.vbrief.json"), {
-                vBRIEFInfo: { version: "0.6" },
-                plan: {
-                    title: "T",
-                    status: "running",
-                    items: [],
-                    policy: {
-                        capacityAllocation: {
-                            unit: "vbrief-count",
-                            window: 30,
-                            enforcement: "enforce",
-                            minSampleSize: 2,
-                            defaultBucket: "feature",
-                            buckets: [
-                                { id: "debt", target: 0.4 },
-                                { id: "feature", target: 0.6 },
-                            ],
-                        },
-                    },
-                },
-            });
-            const completedAt = "2026-06-03T12:00:00Z";
-            for (let i = 0; i < 4; i += 1) {
-                writeJson(join(root, "vbrief", "completed", `feat-${i}.vbrief.json`), {
-                    vBRIEFInfo: { version: "0.6" },
-                    plan: {
-                        title: `feat-${i}`,
-                        status: "completed",
-                        items: [],
-                        metadata: { capacityBucket: "feature", completedAt },
-                    },
-                });
-            }
-        },
-    },
-    {
-        gate: "verify-capacity",
-        name: "capacity-config-error",
-        setup: (root) => {
-            writeFileSync(join(root, "not-a-dir.txt"), "x", { encoding: "utf8" });
-        },
-    },
-];
-export function diffCase(python, ts, gate, caseName) {
-    const pyOut = normalizeOutput(python.stdout);
-    const tsOut = normalizeOutput(ts.stdout);
-    const pyErr = normalizeOutput(python.stderr);
-    const tsErr = normalizeOutput(ts.stderr);
-    return {
-        gate,
-        caseName,
-        exitMismatch: python.exitCode !== ts.exitCode,
-        stdoutMismatch: pyOut !== tsOut,
-        stderrMismatch: pyErr !== tsErr,
-        pythonExit: python.exitCode,
-        tsExit: ts.exitCode,
-    };
-}
-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)), "..", "..", "..");
-}
-export function runParity() {
-    const deftRoot = resolveDeftRoot();
-    const diffs = [];
-    for (const testCase of PARITY_CASES) {
-        const pyRepo = mkdtempSync(join(tmpdir(), "deft-vc-parity-py-"));
-        const tsRepo = mkdtempSync(join(tmpdir(), "deft-vc-parity-ts-"));
-        try {
-            testCase.setup(pyRepo);
-            testCase.setup(tsRepo);
-            const argv = testCase.argv ?? [];
-            const env = testCase.env ?? {};
-            const configErrorRoot = testCase.name === "capacity-config-error" ? join(pyRepo, "not-a-dir.txt") : pyRepo;
-            const tsConfigRoot = testCase.name === "capacity-config-error" ? join(tsRepo, "not-a-dir.txt") : tsRepo;
-            const python = testCase.gate === "verify-capacity" && testCase.name === "capacity-config-error"
-                ? runPythonGate(deftRoot, testCase.gate, configErrorRoot, argv, env)
-                : runPythonGate(deftRoot, testCase.gate, pyRepo, argv, env);
-            const ts = testCase.gate === "verify-capacity" && testCase.name === "capacity-config-error"
-                ? runTsGate(testCase.gate, tsConfigRoot, testCase)
-                : runTsGate(testCase.gate, tsRepo, testCase);
-            diffs.push(diffCase(python, ts, testCase.gate, 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 `validate-content parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
-    }
-    const lines = ["validate-content parity: DIVERGENCE"];
-    for (const d of result.diffs) {
-        if (d.exitMismatch || d.stdoutMismatch || d.stderrMismatch) {
-            lines.push(`  gate: ${d.gate} 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(`validate-content parity: harness error -- ${String(err)}\n`);
-        process.exit(2);
-    }
-}
-//# sourceMappingURL=validate-content-parity.js.map

package/dist/vbrief-activate-parity.d.ts

@@ -1,39 +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 folder: string;
-    readonly status: string;
-    readonly mutates?: boolean;
-    readonly rawOverride?: string;
-    readonly payloadOverride?: Record<string, unknown>;
-    readonly preSeedActive?: boolean;
-    readonly missingPath?: boolean;
-}
-export interface ParityDiff {
-    readonly caseName: string;
-    readonly exitMismatch: boolean;
-    readonly stdoutMismatch: boolean;
-    readonly stderrMismatch: boolean;
-    readonly sideEffectMismatch: boolean;
-    readonly pythonExit: number;
-    readonly tsExit: number;
-    readonly pythonStdout: string;
-    readonly pythonStderr: string;
-    readonly tsStdout: string;
-    readonly tsStderr: string;
-}
-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, sideEffectMismatch: boolean): ParityDiff;
-export declare function runParity(): ParityResult;
-export declare function renderReport(result: ParityResult): string;
-export declare function runParityCli(): number;
-//# sourceMappingURL=vbrief-activate-parity.d.ts.map

package/dist/vbrief-activate-parity.js

@@ -1,216 +0,0 @@
-#!/usr/bin/env node
-/**
- * Golden-output parity harness (#1782 s5): runs BOTH the Python oracle
- * (`scripts/vbrief_activate.py`) and the ported TS vbrief-activate CLI over
- * temp fixture vBRIEF trees, then diffs exit codes and byte-identical
- * stdout/stderr (cache-off). Mutating scenarios also compare destination
- * JSON with the volatile ``vBRIEFInfo.updated`` field stripped.
- *
- * 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";
-const FIXTURE_NAME = "2026-05-01-test.vbrief.json";
-export const PARITY_CASES = [
-    { name: "pending-to-active", folder: "pending", status: "pending", mutates: true },
-    { name: "approved-to-active", folder: "pending", status: "approved", mutates: true },
-    { name: "already-active-noop", folder: "active", status: "running" },
-    { name: "proposed-reject", folder: "proposed", status: "proposed" },
-    { name: "completed-reject", folder: "completed", status: "completed" },
-    { name: "active-blocked-reject", folder: "active", status: "blocked" },
-    { name: "pending-draft-reject", folder: "pending", status: "draft" },
-    { name: "nonexistent-reject", folder: "pending", status: "pending", missingPath: true },
-    { name: "malformed-json", folder: "pending", status: "pending", rawOverride: "{ not json" },
-    {
-        name: "missing-plan",
-        folder: "pending",
-        status: "pending",
-        payloadOverride: { vBRIEFInfo: { version: "0.6" } },
-    },
-    {
-        name: "missing-plan-status",
-        folder: "pending",
-        status: "pending",
-        payloadOverride: { vBRIEFInfo: { version: "0.6" }, plan: { title: "T" } },
-    },
-    {
-        name: "destination-collision",
-        folder: "pending",
-        status: "pending",
-        preSeedActive: true,
-    },
-];
-function runCapture(cmd, args, cwd) {
-    try {
-        const stdout = execFileSync(cmd, args, {
-            cwd,
-            encoding: "utf8",
-            env: process.env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        return { exitCode: 0, stdout, stderr: "" };
-    }
-    catch (err) {
-        const e = err;
-        return {
-            exitCode: typeof e.status === "number" ? e.status : 2,
-            stdout: typeof e.stdout === "string" ? e.stdout : "",
-            stderr: typeof e.stderr === "string" ? e.stderr : "",
-        };
-    }
-}
-function resolveDeftRoot() {
-    if (process.env.DEFT_ROOT !== undefined && process.env.DEFT_ROOT.length > 0) {
-        return resolve(process.env.DEFT_ROOT);
-    }
-    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-}
-function writeFixture(repo, testCase) {
-    const full = join(repo, "vbrief", testCase.folder, FIXTURE_NAME);
-    mkdirSync(dirname(full), { recursive: true });
-    if (testCase.rawOverride !== undefined) {
-        writeFileSync(full, testCase.rawOverride, "utf8");
-        return full;
-    }
-    if (testCase.payloadOverride !== undefined) {
-        writeFileSync(full, JSON.stringify(testCase.payloadOverride), "utf8");
-        return full;
-    }
-    writeFileSync(full, JSON.stringify({
-        vBRIEFInfo: { version: "0.6", updated: "2026-04-30T00:00:00Z" },
-        plan: { title: "T", status: testCase.status, items: [] },
-    }), "utf8");
-    return full;
-}
-function setupRepo(testCase) {
-    const repo = mkdtempSync(join(tmpdir(), "deft-vbrief-activate-parity-"));
-    mkdirSync(join(repo, "vbrief"), { recursive: true });
-    if (testCase.missingPath === true) {
-        return { repo, vbriefPath: join(repo, "vbrief", "pending", "missing.vbrief.json") };
-    }
-    const vbriefPath = writeFixture(repo, testCase);
-    if (testCase.preSeedActive === true) {
-        const activePath = join(repo, "vbrief", "active", FIXTURE_NAME);
-        mkdirSync(dirname(activePath), { recursive: true });
-        writeFileSync(activePath, "{}", "utf8");
-    }
-    return { repo, vbriefPath };
-}
-function stripUpdatedField(repo) {
-    const dest = join(repo, "vbrief", "active", FIXTURE_NAME);
-    if (!existsSync(dest)) {
-        return null;
-    }
-    const payload = JSON.parse(readFileSync(dest, "utf8"));
-    const info = payload.vBRIEFInfo;
-    if (info !== null && typeof info === "object" && !Array.isArray(info)) {
-        delete info.updated;
-    }
-    return JSON.stringify(payload);
-}
-function runPython(deftRoot, vbriefPath) {
-    return runCapture("uv", ["run", "python", join(deftRoot, "scripts", "vbrief_activate.py"), vbriefPath], deftRoot);
-}
-function runTs(deftRoot, vbriefPath) {
-    return runCapture("node", [join(deftRoot, "packages", "cli", "dist", "vbrief-activate.js"), vbriefPath], deftRoot);
-}
-export function diffCase(python, ts, caseName, sideEffectMismatch) {
-    return {
-        caseName,
-        exitMismatch: python.exitCode !== ts.exitCode,
-        stdoutMismatch: python.stdout !== ts.stdout,
-        stderrMismatch: python.stderr !== ts.stderr,
-        sideEffectMismatch,
-        pythonExit: python.exitCode,
-        tsExit: ts.exitCode,
-        pythonStdout: python.stdout,
-        pythonStderr: python.stderr,
-        tsStdout: ts.stdout,
-        tsStderr: ts.stderr,
-    };
-}
-export function runParity() {
-    const deftRoot = resolveDeftRoot();
-    const diffs = [];
-    for (const testCase of PARITY_CASES) {
-        const pySetup = setupRepo(testCase);
-        const tsSetup = testCase.mutates === true ? setupRepo(testCase) : pySetup;
-        try {
-            const py = runPython(deftRoot, pySetup.vbriefPath);
-            const ts = runTs(deftRoot, tsSetup.vbriefPath);
-            let sideEffectMismatch = false;
-            if (testCase.mutates === true && py.exitCode === 0 && ts.exitCode === 0) {
-                const pyBody = stripUpdatedField(pySetup.repo);
-                const tsBody = stripUpdatedField(tsSetup.repo);
-                sideEffectMismatch = pyBody !== tsBody;
-                if (pyBody !== null && tsBody !== null) {
-                    const pyPendingGone = !existsSync(pySetup.vbriefPath);
-                    const tsPendingGone = !existsSync(tsSetup.vbriefPath);
-                    sideEffectMismatch =
-                        sideEffectMismatch ||
-                            pyPendingGone !== tsPendingGone ||
-                            !pyPendingGone ||
-                            !tsPendingGone;
-                }
-            }
-            diffs.push(diffCase(py, ts, testCase.name, sideEffectMismatch));
-        }
-        finally {
-            rmSync(pySetup.repo, { recursive: true, force: true });
-            if (tsSetup.repo !== pySetup.repo) {
-                rmSync(tsSetup.repo, { recursive: true, force: true });
-            }
-        }
-    }
-    const ok = diffs.every((d) => !d.exitMismatch && !d.stdoutMismatch && !d.stderrMismatch && !d.sideEffectMismatch);
-    return { ok, diffs };
-}
-export function renderReport(result) {
-    if (result.ok) {
-        return `vbrief-activate parity: CLEAN -- Python and TS agree on ${result.diffs.length} scenario(s).`;
-    }
-    const lines = ["vbrief-activate parity: DIVERGENCE"];
-    for (const d of result.diffs) {
-        if (d.exitMismatch || d.stdoutMismatch || d.stderrMismatch || d.sideEffectMismatch) {
-            lines.push(`  scenario: ${d.caseName}`);
-            if (d.exitMismatch) {
-                lines.push(`    exit mismatch: python=${d.pythonExit} ts=${d.tsExit}`);
-            }
-            if (d.stdoutMismatch) {
-                lines.push(`    python stdout: ${JSON.stringify(d.pythonStdout)}`);
-                lines.push(`    ts stdout:     ${JSON.stringify(d.tsStdout)}`);
-            }
-            if (d.stderrMismatch) {
-                lines.push(`    python stderr: ${JSON.stringify(d.pythonStderr)}`);
-                lines.push(`    ts stderr:     ${JSON.stringify(d.tsStderr)}`);
-            }
-            if (d.sideEffectMismatch) {
-                lines.push("    side-effect mismatch (active/ payload or source removal)");
-            }
-        }
-    }
-    return lines.join("\n");
-}
-export function runParityCli() {
-    try {
-        const result = runParity();
-        if (result.ok) {
-            process.stdout.write(`${renderReport(result)}\n`);
-            return 0;
-        }
-        process.stderr.write(`${renderReport(result)}\n`);
-        return 1;
-    }
-    catch (err) {
-        const msg = String(err).replace(/\r?\n/g, " ");
-        process.stderr.write(`vbrief-activate parity: harness error -- ${msg}\n`);
-        return 2;
-    }
-}
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    process.exit(runParityCli());
-}
-//# sourceMappingURL=vbrief-activate-parity.js.map

package/dist/vbrief-build-parity.d.ts

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-export interface ScenarioResult {
-    readonly name: string;
-    readonly exitCode: number;
-    readonly stdout: string;
-    readonly stderr: string;
-}
-export interface ParityResult {
-    readonly ok: boolean;
-    readonly scenarios: Array<{
-        readonly name: string;
-        readonly exitMismatch: boolean;
-        readonly pythonExit: number;
-        readonly tsExit: number;
-        readonly outputMismatch: boolean;
-        readonly pythonOutput: string;
-        readonly tsOutput: string;
-    }>;
-}
-export declare function diffParity(python: ScenarioResult, ts: ScenarioResult): {
-    exitMismatch: boolean;
-    outputMismatch: boolean;
-    pythonOutput: string;
-    tsOutput: string;
-};
-export declare function runParity(): ParityResult;
-export declare function renderReport(result: ParityResult): string;
-//# sourceMappingURL=vbrief-build-parity.d.ts.map