@deftai/directive 0.55.0

package/dist/policy.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+/**
+ * Policy CLI (#1722): `policy:show` and `policy:allow-direct-commits` surfaces,
+ * mirroring scripts/_policy_show_cli.py and scripts/policy_set.py.
+ */
+import { existsSync } from "node:fs";
+import { join, resolve as pathResolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { disclosureLine, inspectAllPolicies, inspectOnePolicy, PROJECT_DEFINITION_REL_PATH, pythonListRepr, pythonStringRepr, registeredPolicyNames, renderJson, renderText, resolvePolicy, setPolicy, } from "@deftai/directive-core/policy";
+const CAPABILITY_COST_DISCLOSURE = "\u26a0 Capability-cost disclosure -- enabling direct commits to the default " +
+    "branch turns OFF the deft branch-protection policy.\n" +
+    "  \u2022 Pre-commit + pre-push hooks will no longer block default-branch " +
+    "commits.\n" +
+    "  \u2022 verify:branch will pass on the default branch.\n" +
+    "  \u2022 The CI sanity check (head_ref != base_ref) is still independent and " +
+    "will continue to flag master->master PRs.\n" +
+    "  \u2022 This change is reversible: run `task policy:enforce-branches` to " +
+    "re-enable the gate.\n" +
+    "  \u2022 The change is recorded to meta/policy-changes.log for auditability.";
+function makeSetError(message) {
+    return {
+        cmd: "show",
+        confirm: false,
+        actor: "",
+        note: "",
+        projectRoot: ".",
+        format: "text",
+        changedOnly: false,
+        field: null,
+        error: message,
+    };
+}
+function parseProjectRoot(argv) {
+    let projectRoot = ".";
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--project-root") {
+            const v = argv[i + 1];
+            if (v === undefined) {
+                return { projectRoot: ".", error: "argument --project-root: expected one argument" };
+            }
+            projectRoot = v;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else {
+            return { projectRoot: ".", error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return { projectRoot };
+}
+/** Parse policy:show flags (mirrors _policy_show_cli.py). */
+export function parseShowArgs(argv) {
+    const parsed = {
+        format: "text",
+        changedOnly: false,
+        field: null,
+        projectRoot: ".",
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--format") {
+            const v = argv[i + 1];
+            if (v !== "text" && v !== "json") {
+                return {
+                    ...parsed,
+                    error: v === undefined ? "argument --format: expected one argument" : `invalid choice: '${v}'`,
+                };
+            }
+            parsed.format = v;
+            i += 1;
+        }
+        else if (arg?.startsWith("--format=")) {
+            const v = arg.slice("--format=".length);
+            if (v !== "text" && v !== "json") {
+                return { ...parsed, error: `invalid choice: '${v}'` };
+            }
+            parsed.format = v;
+        }
+        else if (arg === "--changed-only") {
+            parsed.changedOnly = true;
+        }
+        else if (arg === "--field") {
+            const v = argv[i + 1];
+            if (v === undefined)
+                return { ...parsed, error: "argument --field: expected one argument" };
+            parsed.field = v;
+            i += 1;
+        }
+        else if (arg?.startsWith("--field=")) {
+            parsed.field = arg.slice("--field=".length);
+        }
+        else if (arg === "--project-root") {
+            const v = argv[i + 1];
+            if (v === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = v;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Parse argv for the policy CLI (show + set subcommands). */
+export function parseArgs(argv) {
+    if (argv.length === 0) {
+        return makeSetError("usage: policy [show|enforce-branches|allow-direct-commits|resolve] ...");
+    }
+    const cmd = argv[0];
+    if (cmd === "show") {
+        const show = parseShowArgs(argv.slice(1));
+        return {
+            cmd: "show",
+            confirm: false,
+            actor: "task policy:show",
+            note: "",
+            projectRoot: show.projectRoot,
+            format: show.format,
+            changedOnly: show.changedOnly,
+            field: show.field,
+            error: show.error,
+        };
+    }
+    if (cmd === "resolve") {
+        const root = parseProjectRoot(argv.slice(1));
+        return {
+            cmd: "resolve",
+            confirm: false,
+            actor: "agent",
+            note: "",
+            projectRoot: root.projectRoot,
+            format: "text",
+            changedOnly: false,
+            field: null,
+            error: root.error,
+        };
+    }
+    if (cmd === "enforce-branches" || cmd === "allow-direct-commits") {
+        let confirm = false;
+        let actor = cmd === "enforce-branches"
+            ? "task policy:enforce-branches"
+            : "task policy:allow-direct-commits";
+        let note = "";
+        let projectRoot = ".";
+        for (let i = 1; i < argv.length; i += 1) {
+            const arg = argv[i];
+            if (arg === "--confirm") {
+                confirm = true;
+            }
+            else if (arg === "--actor") {
+                const v = argv[i + 1];
+                if (v === undefined)
+                    return makeSetError("argument --actor: expected one argument");
+                actor = v;
+                i += 1;
+            }
+            else if (arg?.startsWith("--actor=")) {
+                actor = arg.slice("--actor=".length);
+            }
+            else if (arg === "--note") {
+                const v = argv[i + 1];
+                if (v === undefined)
+                    return makeSetError("argument --note: expected one argument");
+                note = v;
+                i += 1;
+            }
+            else if (arg?.startsWith("--note=")) {
+                note = arg.slice("--note=".length);
+            }
+            else if (arg === "--project-root") {
+                const v = argv[i + 1];
+                if (v === undefined)
+                    return makeSetError("argument --project-root: expected one argument");
+                projectRoot = v;
+                i += 1;
+            }
+            else if (arg?.startsWith("--project-root=")) {
+                projectRoot = arg.slice("--project-root=".length);
+            }
+            else {
+                return makeSetError(`unrecognized argument: ${arg}`);
+            }
+        }
+        return {
+            cmd,
+            confirm,
+            actor,
+            note,
+            projectRoot,
+            format: "text",
+            changedOnly: false,
+            field: null,
+        };
+    }
+    return makeSetError(`unknown subcommand: ${cmd}`);
+}
+function runShow(args) {
+    const projectRoot = pathResolve(args.projectRoot);
+    const pdPath = join(projectRoot, PROJECT_DEFINITION_REL_PATH);
+    if (!existsSync(pdPath)) {
+        process.stderr.write(`[policy:show] PROJECT-DEFINITION not found at ${pdPath}; ` +
+            "rendering framework defaults.\n");
+    }
+    if (args.field !== null) {
+        const field = inspectOnePolicy(args.field, projectRoot);
+        if (field === null) {
+            const known = registeredPolicyNames();
+            process.stderr.write(`[policy:show] unknown --field=${pythonStringRepr(args.field)}; ` +
+                `registered fields: ${pythonListRepr(known)}\n`);
+            return 2;
+        }
+        if (args.format === "json") {
+            process.stdout.write(`${renderJson([field])}\n`);
+        }
+        else {
+            process.stdout.write(`${renderText([field])}\n`);
+        }
+        return 0;
+    }
+    let fields = inspectAllPolicies(projectRoot);
+    if (args.changedOnly) {
+        fields = fields.filter((f) => f.source !== "default");
+    }
+    if (args.format === "json") {
+        process.stdout.write(`${renderJson(fields)}\n`);
+    }
+    else {
+        process.stdout.write(`${renderText(fields)}\n`);
+    }
+    return 0;
+}
+function runResolve(projectRoot) {
+    const result = resolvePolicy(projectRoot);
+    process.stdout.write(`allowDirectCommitsToMaster=${String(result.allowDirectCommits).toLowerCase()}\n`);
+    process.stdout.write(`source=${result.source}\n`);
+    if (result.deprecationWarning !== null) {
+        process.stdout.write(`warning=${result.deprecationWarning}\n`);
+    }
+    if (result.error !== null) {
+        process.stdout.write(`error=${result.error}\n`);
+    }
+    process.stdout.write(`${disclosureLine(result)}\n`);
+    return 0;
+}
+function runSet(args) {
+    const projectRoot = pathResolve(args.projectRoot);
+    if (args.cmd === "allow-direct-commits" && !args.confirm) {
+        process.stdout.write(`${CAPABILITY_COST_DISCLOSURE}\n\n`);
+        process.stdout.write("Re-run with --confirm to apply: task policy:allow-direct-commits -- --confirm\n");
+        return 1;
+    }
+    const target = args.cmd === "allow-direct-commits";
+    try {
+        const { changed, auditEntry } = setPolicy(projectRoot, {
+            allowDirectCommits: target,
+            actor: args.actor,
+            note: args.note,
+        });
+        const state = target ? "OFF" : "ON";
+        process.stdout.write(`\u2713 plan.policy.allowDirectCommitsToMaster=${target ? "true" : "false"} ` +
+            `(branch-protection ${state}).\n`);
+        if (changed) {
+            process.stdout.write(`  audit: meta/policy-changes.log :: ${auditEntry}\n`);
+        }
+        else {
+            process.stdout.write("  no-op: value already matched (audit entry still appended for trail).\n");
+        }
+        process.stdout.write(`${disclosureLine(resolvePolicy(projectRoot))}\n`);
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes("PROJECT-DEFINITION not found")) {
+            process.stderr.write(`\u274c ${message}\n`);
+            process.stderr.write("  Recovery: run `task setup` to generate vbrief/PROJECT-DEFINITION.vbrief.json.\n");
+            return 2;
+        }
+        process.stderr.write(`\u274c Config error: ${message}\n`);
+        return 2;
+    }
+}
+/** Run the policy CLI; returns process exit code. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`policy: ${args.error}\n`);
+        return 2;
+    }
+    if (args.cmd === "show") {
+        return runShow({
+            format: args.format,
+            changedOnly: args.changedOnly,
+            field: args.field,
+            projectRoot: args.projectRoot,
+        });
+    }
+    if (args.cmd === "resolve") {
+        return runResolve(pathResolve(args.projectRoot));
+    }
+    if (args.cmd === "enforce-branches" || args.cmd === "allow-direct-commits") {
+        return runSet(args);
+    }
+    return 2;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=policy.js.map

package/dist/pr-closing-keywords-parity.d.ts

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+export interface FakeGhResponses {
+    readonly [label: string]: {
+        readonly returncode: number;
+        readonly stdout?: string;
+        readonly stderr?: string;
+    };
+}
+export interface ParityScenario {
+    readonly name: string;
+    readonly argv: readonly string[];
+    readonly responses?: FakeGhResponses;
+    readonly setupFiles?: (dir: string) => Record<string, string>;
+    readonly compareStream?: "stdout" | "stderr";
+}
+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;
+        readonly stream: "stdout" | "stderr";
+    }>;
+}
+export declare const PARITY_SCENARIOS: readonly ParityScenario[];
+export declare function pickOutput(result: ScenarioResult, stream: "stdout" | "stderr"): string;
+export declare function diffParity(python: ScenarioResult, ts: ScenarioResult, stream: "stdout" | "stderr"): {
+    exitMismatch: boolean;
+    outputMismatch: boolean;
+    pythonOutput: string;
+    tsOutput: string;
+};
+export declare function runParity(): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=pr-closing-keywords-parity.d.ts.map

package/dist/pr-closing-keywords-parity.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1730): runs BOTH the Python oracle
+ * (`scripts/pr_check_closing_keywords.py`) and the ported TS CLI with a fake `gh`
+ * on PATH (cache-off), then diffs exit codes and byte-identical stderr.
+ *
+ * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
+ */
+import { spawnSync } from "node:child_process";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const FAKE_GH_PY = `import json
+import os
+import sys
+
+def classify(cmd):
+    joined = " ".join(cmd)
+    if "--json" in cmd and "body" in cmd:
+        return "pr-body"
+    if "--json" in cmd and "commits" in cmd:
+        return "pr-commits"
+    return "unknown"
+
+responses = json.loads(os.environ.get("DEFT_FAKE_GH_RESPONSES", "{}"))
+label = classify(sys.argv[1:])
+resp = responses.get(label, {"returncode": 1, "stderr": f"unexpected gh call: {label}", "stdout": ""})
+stdout = resp.get("stdout", "")
+stderr = resp.get("stderr", "")
+if stdout:
+    sys.stdout.write(stdout)
+if stderr:
+    sys.stderr.write(stderr)
+sys.exit(int(resp.get("returncode", 0)))
+`;
+export const PARITY_SCENARIOS = [
+    {
+        name: "offline-no-keywords-clean",
+        argv: ["--body-file", "{body}"],
+        setupFiles: () => ({ body: "Refs #642 (umbrella; remains open)." }),
+        compareStream: "stderr",
+    },
+    {
+        name: "offline-negation-hit",
+        argv: ["--body-file", "{body}"],
+        setupFiles: () => ({
+            body: "This PR DOES NOT CLOSE #734 -- the issue stays open.",
+        }),
+        compareStream: "stderr",
+    },
+    {
+        name: "offline-true-positive-closes-clean",
+        argv: ["--body-file", "{body}"],
+        setupFiles: () => ({
+            body: "feat(core): land the gate.\n\nCloses #734\n\nDescription continues...",
+        }),
+        compareStream: "stderr",
+    },
+    {
+        name: "pr-mode-no-keywords-clean",
+        argv: ["--pr", "735", "--repo", "deftai/directive"],
+        responses: {
+            "pr-body": {
+                returncode: 0,
+                stdout: JSON.stringify({ body: "Refs #642 only." }),
+            },
+            "pr-commits": {
+                returncode: 0,
+                stdout: JSON.stringify({
+                    commits: [{ messageHeadline: "feat: implement", messageBody: "Refs #1\n" }],
+                }),
+            },
+        },
+        compareStream: "stderr",
+    },
+    {
+        name: "pr-mode-negation-hit",
+        argv: ["--pr", "735", "--repo", "deftai/directive"],
+        responses: {
+            "pr-body": {
+                returncode: 0,
+                stdout: JSON.stringify({
+                    body: "Body header. Intentionally NOT using `Closes #642` because umbrella.",
+                }),
+            },
+            "pr-commits": { returncode: 0, stdout: JSON.stringify({ commits: [] }) },
+        },
+        compareStream: "stderr",
+    },
+    {
+        name: "allow-list-suppressed",
+        argv: ["--body-file", "{body}", "--allow-known-false-positives", "999"],
+        setupFiles: () => ({
+            body: "Body. Intentionally not `Closes #999` (test fixture).\n",
+        }),
+        compareStream: "stderr",
+    },
+];
+function installFakeGh() {
+    const binDir = mkdtempSync(join(tmpdir(), "deft-pr-closing-keywords-fake-gh-"));
+    const ghBin = join(binDir, "gh");
+    const ghxBin = join(binDir, "ghx");
+    writeFileSync(ghBin, `#!/usr/bin/env python3\n${FAKE_GH_PY}`, "utf8");
+    writeFileSync(ghxBin, `#!/usr/bin/env python3\n${FAKE_GH_PY}`, "utf8");
+    chmodSync(ghBin, 0o755);
+    chmodSync(ghxBin, 0o755);
+    return {
+        binDir,
+        cleanup: () => {
+            rmSync(binDir, { recursive: true, force: true });
+        },
+    };
+}
+function runCapture(cmd, args, cwd, env) {
+    const result = spawnSync(cmd, args, {
+        cwd,
+        encoding: "utf8",
+        env: { ...process.env, ...env },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return {
+        status: result.status ?? 2,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr: typeof result.stderr === "string" ? result.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 normaliseHarnessNoise(text) {
+    return text
+        .split("\n")
+        .filter((line) => !line.startsWith("Using CPython") &&
+        !line.startsWith("Creating virtual environment") &&
+        !line.startsWith("Installed "))
+        .join("\n");
+}
+export function pickOutput(result, stream) {
+    return stream === "stdout" ? result.stdout : result.stderr;
+}
+export function diffParity(python, ts, stream) {
+    const pythonOutput = normaliseHarnessNoise(pickOutput(python, stream));
+    const tsOutput = normaliseHarnessNoise(pickOutput(ts, stream));
+    return {
+        exitMismatch: python.exitCode !== ts.exitCode,
+        outputMismatch: pythonOutput !== tsOutput,
+        pythonOutput,
+        tsOutput,
+    };
+}
+function materializeArgv(scenario, fileDir) {
+    const files = scenario.setupFiles?.(fileDir) ?? {};
+    for (const [name, content] of Object.entries(files)) {
+        writeFileSync(join(fileDir, name), content, "utf8");
+    }
+    return scenario.argv.map((arg) => {
+        if (arg.startsWith("{") && arg.endsWith("}")) {
+            const key = arg.slice(1, -1);
+            return join(fileDir, key);
+        }
+        return arg;
+    });
+}
+function runScenario(deftRoot, scenario) {
+    const fake = installFakeGh();
+    const fileDir = mkdtempSync(join(tmpdir(), "deft-pr-closing-keywords-files-"));
+    try {
+        const argv = materializeArgv(scenario, fileDir);
+        const pathPrefix = `${fake.binDir}:${process.env.PATH ?? ""}`;
+        const env = {
+            DEFT_CACHE_DISABLE: "1",
+            PYTHONUTF8: "1",
+            PATH: pathPrefix,
+        };
+        if (scenario.responses !== undefined) {
+            env.DEFT_FAKE_GH_RESPONSES = JSON.stringify(scenario.responses);
+        }
+        const py = runCapture("uv", ["run", "python", join(deftRoot, "scripts", "pr_check_closing_keywords.py"), ...argv], deftRoot, env);
+        const ts = runCapture("node", [join(deftRoot, "packages", "cli", "dist", "pr-closing-keywords.js"), ...argv], deftRoot, env);
+        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 {
+        fake.cleanup();
+        rmSync(fileDir, { recursive: true, force: true });
+    }
+}
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const scenarios = [];
+    for (const scenario of PARITY_SCENARIOS) {
+        const ran = runScenario(deftRoot, scenario);
+        const stream = scenario.compareStream ?? "stderr";
+        scenarios.push({
+            name: scenario.name,
+            pythonExit: ran.python.exitCode,
+            tsExit: ran.ts.exitCode,
+            stream,
+            ...diffParity(ran.python, ran.ts, stream),
+        });
+    }
+    const ok = scenarios.every((s) => !s.exitMismatch && !s.outputMismatch);
+    return { ok, scenarios };
+}
+export function renderReport(result) {
+    if (result.ok) {
+        return `pr_check_closing_keywords parity: CLEAN -- Python and TS agree on ${result.scenarios.length} scenario(s).`;
+    }
+    const lines = ["pr_check_closing_keywords parity: DIVERGENCE"];
+    for (const s of result.scenarios) {
+        if (s.exitMismatch || s.outputMismatch) {
+            lines.push(`  scenario: ${s.name}`);
+            if (s.exitMismatch) {
+                lines.push(`    exit mismatch: python=${s.pythonExit} ts=${s.tsExit}`);
+            }
+            if (s.outputMismatch) {
+                lines.push(`    stream: ${s.stream}`);
+                lines.push(`    python (${s.pythonOutput.length} bytes):`);
+                lines.push(s.pythonOutput.slice(0, 500));
+                lines.push(`    ts (${s.tsOutput.length} bytes):`);
+                lines.push(s.tsOutput.slice(0, 500));
+            }
+        }
+    }
+    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(`pr_check_closing_keywords parity: harness error -- ${msg}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=pr-closing-keywords-parity.js.map

package/dist/pr-closing-keywords.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(argv: string[]): number;
+//# sourceMappingURL=pr-closing-keywords.d.ts.map

package/dist/pr-closing-keywords.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { cmdPrCheckClosingKeywords } from "../../core/dist/pr-closing-keywords/main.js";
+export function run(argv) {
+    return cmdPrCheckClosingKeywords(argv);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=pr-closing-keywords.js.map

package/dist/pr-merge-readiness-parity.d.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+export interface FakeGhResponses {
+    readonly [label: string]: {
+        readonly returncode: number;
+        readonly stdout?: string;
+        readonly stderr?: string;
+    };
+}
+export interface ParityScenario {
+    readonly name: string;
+    readonly argv: readonly string[];
+    readonly responses: FakeGhResponses;
+    readonly compareStream?: "stdout" | "stderr";
+}
+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;
+        readonly stream: "stdout" | "stderr";
+    }>;
+}
+export declare const PARITY_SCENARIOS: readonly ParityScenario[];
+export declare function pickOutput(result: ScenarioResult, stream: "stdout" | "stderr"): string;
+export declare function diffParity(python: ScenarioResult, ts: ScenarioResult, stream: "stdout" | "stderr"): {
+    exitMismatch: boolean;
+    outputMismatch: boolean;
+    pythonOutput: string;
+    tsOutput: string;
+};
+export declare function runParity(): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=pr-merge-readiness-parity.d.ts.map