@deftai/directive 0.55.0

package/dist/triage-queue.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { activeReferencedIssueNumbers, buildQueue, collectOrphanIssueNumbers, DEFAULT_QUEUE_LIMIT, loadCachedIssues, loadSliceRecords, readAuditEntries, renderQueue, resolveRankingLabels, resolveRepo, } from "../../core/dist/triage/queue/index.js";
+/** Parse triage-queue CLI args for the queue subcommand. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: process.env.DEFT_PROJECT_ROOT ?? ".",
+        repo: process.env.DEFT_TRIAGE_REPO ?? null,
+        limit: DEFAULT_QUEUE_LIMIT,
+        includeBlocked: false,
+        cacheRoot: null,
+        auditLog: null,
+        slicesLog: null,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "queue") {
+            continue;
+        }
+        if (arg === "--include-blocked") {
+            parsed.includeBlocked = true;
+            continue;
+        }
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+            continue;
+        }
+        if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --repo: expected one argument" };
+            }
+            parsed.repo = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--repo=")) {
+            parsed.repo = arg.slice("--repo=".length);
+            continue;
+        }
+        if (arg === "--limit") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --limit: expected one argument" };
+            }
+            const parsedLimit = Number.parseInt(value, 10);
+            if (!Number.isFinite(parsedLimit)) {
+                return { ...parsed, error: `argument --limit: invalid int value: '${value}'` };
+            }
+            parsed.limit = parsedLimit;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--limit=")) {
+            const value = arg.slice("--limit=".length);
+            const parsedLimit = Number.parseInt(value, 10);
+            if (!Number.isFinite(parsedLimit)) {
+                return { ...parsed, error: `argument --limit: invalid int value: '${value}'` };
+            }
+            parsed.limit = parsedLimit;
+            continue;
+        }
+        if (arg === "--cache-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --cache-root: expected one argument" };
+            }
+            parsed.cacheRoot = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--cache-root=")) {
+            parsed.cacheRoot = arg.slice("--cache-root=".length);
+            continue;
+        }
+        if (arg === "--audit-log") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --audit-log: expected one argument" };
+            }
+            parsed.auditLog = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--audit-log=")) {
+            parsed.auditLog = arg.slice("--audit-log=".length);
+            continue;
+        }
+        if (arg === "--slices-log") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --slices-log: expected one argument" };
+            }
+            parsed.slicesLog = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--slices-log=")) {
+            parsed.slicesLog = arg.slice("--slices-log=".length);
+            continue;
+        }
+        if (arg?.startsWith("-")) {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+function resolveFrameworkRoot() {
+    const fromEnv = process.env.DEFT_ROOT?.trim() ?? "";
+    if (fromEnv.length > 0) {
+        return resolve(fromEnv);
+    }
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+}
+/** Run triage:queue and return process exit code. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`triage_queue: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const repo = resolveRepo(args.repo, projectRoot);
+    if (repo === null) {
+        process.stderr.write("triage:queue: --repo OWNER/NAME (or $DEFT_TRIAGE_REPO) is required.\n");
+        return 2;
+    }
+    const issuesForQueue = loadCachedIssues(repo, { projectRoot });
+    const issuesWithClosed = loadCachedIssues(repo, { projectRoot, includeClosed: true });
+    const issuesByNumber = new Map(issuesWithClosed.map((row) => [row.number, row]));
+    const auditEntries = readAuditEntries(repo, {
+        frameworkRoot: resolveFrameworkRoot(),
+        auditLogPath: args.auditLog,
+    });
+    const rankingLabels = resolveRankingLabels(projectRoot);
+    const activeRefs = activeReferencedIssueNumbers(projectRoot);
+    const sliceRecords = loadSliceRecords({
+        frameworkRoot: resolveFrameworkRoot(),
+        slicesLogPath: args.slicesLog,
+    });
+    const orphanNumbers = collectOrphanIssueNumbers(sliceRecords, issuesByNumber);
+    const limit = args.limit === 0 ? null : Math.max(0, args.limit);
+    const items = buildQueue(issuesForQueue, auditEntries, {
+        repo,
+        queue: {
+            rankingLabels,
+            activeReferenced: activeRefs,
+            orphanIssueNumbers: orphanNumbers,
+            includeBlocked: args.includeBlocked,
+            limit,
+        },
+    });
+    process.stdout.write(`${renderQueue({
+        items,
+        repo,
+        limit,
+        rankingLabels,
+    })}\n`);
+    return 0;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-queue.js.map

package/dist/triage-reconcile.d.ts

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

package/dist/triage-reconcile.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { emitReconcileJson, reconcile, reconcileSummary, } from "../../core/dist/triage/reconcile/index.js";
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: process.env.DEFT_PROJECT_ROOT ?? ".",
+        dryRun: false,
+        emitJson: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--dry-run")
+            parsed.dryRun = true;
+        else if (arg === "--json")
+            parsed.emitJson = true;
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --repo: expected one argument" };
+            parsed.repo = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--repo=")) {
+            parsed.repo = arg.slice("--repo=".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(`triage:reconcile: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    try {
+        if (!statSync(projectRoot).isDirectory()) {
+            process.stderr.write(`❌ triage:reconcile: --project-root ${projectRoot} does not exist or is not a directory.\n`);
+            return 2;
+        }
+    }
+    catch {
+        process.stderr.write(`❌ triage:reconcile: --project-root ${projectRoot} does not exist or is not a directory.\n`);
+        return 2;
+    }
+    const result = reconcile(projectRoot, {
+        repo: args.repo ?? process.env.DEFT_TRIAGE_REPO ?? null,
+        dryRun: args.dryRun,
+    });
+    if (args.emitJson) {
+        process.stdout.write(`${emitReconcileJson(result)}\n`);
+    }
+    else {
+        process.stdout.write(`${reconcileSummary(result)}\n`);
+    }
+    return result.exitCode;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-reconcile.js.map

package/dist/triage-refresh.d.ts

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

package/dist/triage-refresh.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { refreshActive } from "../../core/dist/triage/refresh/index.js";
+export function parseArgs(argv) {
+    let projectRoot = ".";
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { projectRoot, error: "argument --project-root: expected one argument" };
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg !== undefined) {
+            return { projectRoot, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return { projectRoot };
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`triage:refresh-active: ${args.error}\n`);
+        return 2;
+    }
+    refreshActive(resolve(args.projectRoot));
+    return 0;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-refresh.js.map

package/dist/triage-scope-drift.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+export interface ParsedArgs {
+    projectRoot: string;
+    cacheRoot?: string;
+    threshold?: number;
+    ignoreLabel?: string;
+    ignoreMilestone?: string;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function run(argv: string[]): number;
+//# sourceMappingURL=triage-scope-drift.d.ts.map

package/dist/triage-scope-drift.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { addIgnore, computeDrift, renderDriftReport, } from "../../core/dist/triage/scope-drift/index.js";
+export function parseArgs(argv) {
+    const parsed = { projectRoot: process.env.DEFT_PROJECT_ROOT ?? "." };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--cache-root") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --cache-root: expected one argument" };
+            parsed.cacheRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--cache-root=")) {
+            parsed.cacheRoot = arg.slice("--cache-root=".length);
+        }
+        else if (arg === "--threshold") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --threshold: expected one argument" };
+            parsed.threshold = Number(value);
+            i += 1;
+        }
+        else if (arg?.startsWith("--threshold=")) {
+            parsed.threshold = Number(arg.slice("--threshold=".length));
+        }
+        else if (arg === "--ignore-label") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --ignore-label: expected one argument" };
+            parsed.ignoreLabel = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--ignore-label=")) {
+            parsed.ignoreLabel = arg.slice("--ignore-label=".length);
+        }
+        else if (arg === "--ignore-milestone") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --ignore-milestone: expected one argument" };
+            parsed.ignoreMilestone = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--ignore-milestone=")) {
+            parsed.ignoreMilestone = arg.slice("--ignore-milestone=".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(`triage:scope-drift: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    try {
+        if (!statSync(projectRoot).isDirectory()) {
+            process.stderr.write(`triage:scope-drift: --project-root ${projectRoot} does not exist or is not a directory.\n`);
+            return 2;
+        }
+    }
+    catch {
+        process.stderr.write(`triage:scope-drift: --project-root ${projectRoot} does not exist or is not a directory.\n`);
+        return 2;
+    }
+    if (args.ignoreLabel !== undefined && args.ignoreMilestone !== undefined) {
+        process.stderr.write("triage:scope-drift: --ignore-label and --ignore-milestone are mutually exclusive (pick one per invocation).\n");
+        return 2;
+    }
+    if (args.ignoreLabel !== undefined || args.ignoreMilestone !== undefined) {
+        try {
+            const { changed, message } = addIgnore(projectRoot, {
+                label: args.ignoreLabel,
+                milestone: args.ignoreMilestone,
+            });
+            if (!changed) {
+                process.stderr.write(`triage:scope-drift: ${message} (no-op).\n`);
+            }
+            else {
+                process.stdout.write(`triage:scope-drift: ${message}.\n`);
+                process.stderr.write("  Next run of `task triage:scope-drift` will exclude this signal.\n");
+            }
+        }
+        catch (err) {
+            process.stderr.write(`triage:scope-drift: ${String(err)}\n`);
+            return 1;
+        }
+        return 0;
+    }
+    const report = computeDrift(projectRoot, {
+        cacheRoot: args.cacheRoot ? resolve(args.cacheRoot) : undefined,
+        threshold: args.threshold,
+    });
+    process.stdout.write(`${renderDriftReport(report)}\n`);
+    return 0;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-scope-drift.js.map

package/dist/triage-scope-parity.d.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+export interface CommandCapture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ScopeFixtureOptions {
+    readonly policy?: Record<string, unknown>;
+}
+export interface ParityCase {
+    readonly name: string;
+    readonly argv: string[];
+    readonly fixture?: ScopeFixtureOptions;
+}
+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 absolute paths before compare. */
+export declare function normalizeOutput(text: string): string;
+export declare function buildFixtureRepo(options?: ScopeFixtureOptions): string;
+export declare function diffCase(python: CommandCapture, ts: CommandCapture, caseName: string): ParityDiff;
+export declare const PARITY_CASES: readonly ParityCase[];
+export declare function runParity(): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=triage-scope-parity.d.ts.map

package/dist/triage-scope-parity.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1725): runs BOTH the Python oracle
+ * (`scripts/triage_scope.py`) and the ported TS triage:scope CLI, then
+ * diffs exit codes and normalised stdout/stderr (cache-off).
+ *
+ * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
+ */
+import { spawnSync } 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 absolute paths before compare. */
+export function normalizeOutput(text) {
+    return text
+        .replace(/--project-root [^\s]+/g, "--project-root <ROOT>")
+        .replace(/--cache-root [^\s]+/g, "--cache-root <ROOT>")
+        .replace(/path=[^\s\n]+coverage\.json/g, "path=<ROOT>/coverage.json");
+}
+function runCapture(cmd, args, cwd) {
+    const result = spawnSync(cmd, args, {
+        cwd,
+        encoding: "utf8",
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return {
+        exitCode: result.status ?? 2,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr: typeof result.stderr === "string" ? result.stderr : "",
+    };
+}
+function writeProjectDefinition(root, policy = {}) {
+    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: [], policy },
+    }, null, 2)}\n`, "utf8");
+}
+export function buildFixtureRepo(options = {}) {
+    const root = mkdtempSync(join(tmpdir(), "deft-triage-scope-parity-"));
+    mkdirSync(join(root, "vbrief"), { recursive: true });
+    writeProjectDefinition(root, options.policy ?? {});
+    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 runPythonScope(deftRoot, repo, argv) {
+    return runCapture("uv", [
+        "run",
+        "python",
+        join(deftRoot, "scripts", "triage_scope.py"),
+        ...argv,
+        "--project-root",
+        repo,
+    ], deftRoot);
+}
+function runTsScope(deftRoot, repo, argv) {
+    return runCapture("node", [join(deftRoot, "packages", "cli", "dist", "triage-scope.js"), ...argv, "--project-root", repo], deftRoot);
+}
+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: "list-default",
+        argv: ["--list"],
+    },
+    {
+        name: "list-custom-scope-ignores",
+        argv: ["--list"],
+        fixture: {
+            policy: {
+                triageScope: [{ rule: "labels", "any-of": ["bug"] }],
+                triageScopeIgnores: [
+                    { label: "wontfix" },
+                    { rule: "author", "any-of": ["dependabot[bot]"] },
+                ],
+            },
+        },
+    },
+    {
+        name: "add-label",
+        argv: ["--add-label=priority:p0"],
+    },
+    {
+        name: "add-milestone",
+        argv: ["--add-milestone=v2.0-blocker"],
+    },
+    {
+        name: "ignore-label",
+        argv: ["--ignore-label=wontfix"],
+    },
+    {
+        name: "mutations-mutually-exclusive",
+        argv: ["--add-label=bug", "--ignore-label=wontfix"],
+    },
+    {
+        name: "diff-from-upstream-missing-repo",
+        argv: ["--diff-from-upstream"],
+        fixture: { policy: {} },
+    },
+    {
+        name: "refresh-denominator-missing-repo",
+        argv: ["--refresh-denominator", "--count", "10"],
+    },
+    {
+        name: "invalid-project-root",
+        argv: ["--list"],
+        fixture: undefined,
+    },
+    {
+        name: "schema-error",
+        argv: ["--list"],
+        fixture: {
+            policy: {
+                triageScope: [{ rule: "bogus-type" }],
+            },
+        },
+    },
+    {
+        name: "refresh-denominator-success",
+        argv: [
+            "--refresh-denominator",
+            "--repo",
+            "deftai/directive",
+            "--count",
+            "247",
+            "--source",
+            "github-issue",
+        ],
+        fixture: {
+            policy: { triageScope: [{ rule: "all-open" }] },
+        },
+    },
+];
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const diffs = [];
+    for (const testCase of PARITY_CASES) {
+        if (testCase.name === "invalid-project-root") {
+            const missing = join(tmpdir(), `deft-missing-${Date.now()}`);
+            const python = runPythonScope(deftRoot, missing, testCase.argv);
+            const ts = runTsScope(deftRoot, missing, testCase.argv);
+            diffs.push(diffCase(python, ts, testCase.name));
+            continue;
+        }
+        const pyRepo = buildFixtureRepo(testCase.fixture);
+        const tsRepo = buildFixtureRepo(testCase.fixture);
+        try {
+            const extraArgv = [...testCase.argv];
+            if (testCase.name === "refresh-denominator-success") {
+                const cacheRoot = mkdtempSync(join(tmpdir(), "deft-scope-cache-"));
+                extraArgv.push("--cache-root", cacheRoot);
+            }
+            const python = runPythonScope(deftRoot, pyRepo, extraArgv);
+            const ts = runTsScope(deftRoot, tsRepo, extraArgv);
+            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 `triage:scope parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
+    }
+    const lines = ["triage:scope 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(`triage:scope parity: harness error -- ${String(err)}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=triage-scope-parity.js.map