@deftai/directive 0.62.0 → 0.64.0

package/dist/triage-actions-parity.js

@@ -1,357 +0,0 @@
-#!/usr/bin/env node
-/**
- * Golden-output parity harness (#1725): runs BOTH the Python oracle
- * (`scripts/triage_actions.py`) and the ported TS triage-actions CLI with
- * isolated fixture roots, then diffs exit codes and normalised stdout/stderr.
- *
- * 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";
-import { cachePut } from "@deftai/directive-core/dist/cache/operations.js";
-/** Strip volatile UUIDs and timestamps before compare. */
-export function normalizeOutput(text) {
-    return text
-        .replace(/(?:\/private)?\/(?:tmp|var\/folders\/[^\s"']+\/T)\/deft-triage-actions-parity-[^/\s"']+/g, "<FIXTURE>")
-        .replace(/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/g, "<UUID>")
-        .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/g, "<TS>")
-        .replace(/Using CPython[^\n]*\n/g, "")
-        .replace(/Creating virtual environment[^\n]*\n/g, "")
-        .replace(/Installed \d+ packages[^\n]*\n/g, "")
-        .replace(/Downloading[^\n]*\n/g, "")
-        .replace(/Built[^\n]*\n/g, "")
-        .replace(/triage_actions: needs-ac comment not posted[^\n]*/g, "triage_actions: needs-ac comment not posted <GH-FAIL>");
-}
-/** Keep only operator-facing triage stderr; drop uv/tooling noise from Python spawns. */
-export function normalizeStderr(text) {
-    return normalizeOutput(text)
-        .split("\n")
-        .filter((line) => line.length === 0 || line.startsWith("triage_actions:"))
-        .join("\n");
-}
-function runCapture(cmd, args, cwd, env = {}) {
-    const merged = {
-        ...process.env,
-        ...env,
-        GITHUB_TOKEN: "",
-        GH_TOKEN: "",
-        GH_ENTERPRISE_TOKEN: "",
-    };
-    for (const key of Object.keys(merged)) {
-        if (merged[key] === undefined)
-            delete merged[key];
-    }
-    const result = spawnSync(cmd, args, {
-        cwd,
-        encoding: "utf8",
-        env: merged,
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    return {
-        status: result.status ?? 2,
-        stdout: typeof result.stdout === "string" ? result.stdout : "",
-        stderr: typeof result.stderr === "string" ? result.stderr : "",
-    };
-}
-/** Build a throwaway project root with an empty audit-log parent directory. */
-export function buildFixtureRepo() {
-    const root = mkdtempSync(join(tmpdir(), "deft-triage-actions-parity-"));
-    mkdirSync(join(root, "vbrief", ".eval"), { recursive: true });
-    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 pythonWrapperScript(deftRoot, fixtureRoot) {
-    return [
-        "import os, sys",
-        "from pathlib import Path",
-        `fixture = Path(${JSON.stringify(fixtureRoot)})`,
-        `deft_root = Path(${JSON.stringify(deftRoot)})`,
-        "sys.path.insert(0, str(deft_root / 'scripts'))",
-        "import candidates_log as cl",
-        "cl.DEFAULT_LOG_PATH = fixture / 'vbrief/.eval/candidates.jsonl'",
-        "import cache as cache_mod",
-        "cache_mod.DEFAULT_CACHE_ROOT = fixture / '.deft-cache'",
-        "import triage_actions",
-        "triage_actions.candidates_log = cl",
-        "triage_actions.cache = cache_mod",
-        "def _parity_gh(args):",
-        "    raise triage_actions.UpstreamCloseError('gh disabled for parity')",
-        "triage_actions._run_gh = _parity_gh",
-        "raise SystemExit(triage_actions.main(sys.argv[1:]))",
-    ].join("\n");
-}
-function runPythonTriageAction(deftRoot, fixtureRoot, argv) {
-    const cap = runCapture("uv", ["run", "python", "-c", pythonWrapperScript(deftRoot, fixtureRoot), ...argv], deftRoot, { TRIAGE_PARITY_FIXTURE: fixtureRoot, DEFT_TRIAGE_ACTIONS_PARITY: "1" });
-    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
-}
-function runTsTriageAction(deftRoot, fixtureRoot, argv) {
-    const cap = runCapture("node", [
-        join(deftRoot, "packages", "cli", "dist", "triage-actions.js"),
-        ...argv,
-        "--project-root",
-        fixtureRoot,
-    ], deftRoot, { DEFT_TRIAGE_ACTIONS_PARITY: "1" });
-    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 = normalizeStderr(python.stderr);
-    const tsErr = normalizeStderr(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: "defer-invalid-resume-on",
-        argv: [
-            "defer",
-            "--issue",
-            "7",
-            "--repo",
-            "deftai/directive",
-            "--reason",
-            "later",
-            "--resume-on",
-            "not-valid",
-        ],
-    },
-    {
-        name: "defer-success",
-        argv: ["defer", "--issue", "7", "--repo", "deftai/directive", "--reason", "later"],
-    },
-    {
-        name: "defer-with-resume-on",
-        argv: [
-            "defer",
-            "--issue",
-            "8",
-            "--repo",
-            "deftai/directive",
-            "--reason",
-            "blocked",
-            "--resume-on",
-            "ref:closed:#99",
-        ],
-    },
-    {
-        name: "accept-idempotent",
-        argv: ["accept", "--issue", "9", "--repo", "deftai/directive", "--actor", "agent:test"],
-    },
-    {
-        name: "needs-ac-default",
-        argv: ["needs-ac", "--issue", "10", "--repo", "deftai/directive", "--actor", "agent:test"],
-    },
-    {
-        name: "status-empty",
-        argv: ["status", "--issue", "11", "--repo", "deftai/directive"],
-    },
-    {
-        name: "status-with-defer",
-        argv: ["status", "--issue", "12", "--repo", "deftai/directive"],
-        seed: "defer-status",
-    },
-    {
-        name: "reset-no-prior",
-        argv: ["reset", "--issue", "13", "--repo", "deftai/directive"],
-    },
-    {
-        name: "reset-success",
-        argv: ["reset", "--issue", "14", "--repo", "deftai/directive", "--actor", "agent:test"],
-        seed: "defer-reset",
-    },
-    {
-        name: "reset-idempotent",
-        argv: ["reset", "--issue", "15", "--repo", "deftai/directive"],
-        seed: "reset-idempotent",
-    },
-    {
-        name: "history-empty",
-        argv: ["history", "--issue", "16", "--repo", "deftai/directive"],
-    },
-    {
-        name: "history-multi",
-        argv: ["history", "--issue", "17", "--repo", "deftai/directive"],
-        seed: "history-multi",
-    },
-    {
-        name: "mark-duplicate-missing-cache",
-        argv: ["mark-duplicate", "--issue", "18", "--repo", "deftai/directive", "--of", "99"],
-    },
-    {
-        name: "mark-duplicate-success",
-        argv: [
-            "mark-duplicate",
-            "--issue",
-            "19",
-            "--repo",
-            "deftai/directive",
-            "--of",
-            "20",
-            "--actor",
-            "agent:test",
-        ],
-        seed: "mark-duplicate-cache",
-    },
-    {
-        name: "mark-duplicate-idempotent",
-        argv: ["mark-duplicate", "--issue", "21", "--repo", "deftai/directive", "--of", "22"],
-        seed: "mark-duplicate-idempotent",
-    },
-    {
-        name: "mark-duplicate-self",
-        argv: ["mark-duplicate", "--issue", "23", "--repo", "deftai/directive", "--of", "23"],
-        seed: "mark-duplicate-cache-self",
-    },
-];
-function seedAcceptFixture(fixtureRoot) {
-    const entry = {
-        actor: "agent:test",
-        decision: "accept",
-        decision_id: "prior-id-0000-0000-0000-000000000001",
-        issue_number: 9,
-        repo: "deftai/directive",
-        timestamp: "2026-06-18T12:00:00Z",
-    };
-    writeFileSync(join(fixtureRoot, "vbrief/.eval/candidates.jsonl"), `${JSON.stringify(entry, Object.keys(entry).sort())}\n`, "utf8");
-}
-function seedAuditEntry(fixtureRoot, issueNumber, decision, extras = {}) {
-    const entry = {
-        actor: "agent:test",
-        decision,
-        decision_id: "11111111-1111-1111-1111-111111111111",
-        issue_number: issueNumber,
-        repo: "deftai/directive",
-        timestamp: "2026-06-18T12:00:00Z",
-        ...extras,
-    };
-    const path = join(fixtureRoot, "vbrief/.eval/candidates.jsonl");
-    const line = `${JSON.stringify(entry, Object.keys(entry).sort())}\n`;
-    writeFileSync(path, line, { encoding: "utf8", flag: "a" });
-}
-function seedCacheIssue(fixtureRoot, issueNumber) {
-    const cacheRoot = join(fixtureRoot, ".deft-cache");
-    cachePut("github-issue", `deftai/directive/${issueNumber}`, { number: issueNumber, title: "parity fixture", body: "fixture body" }, { cacheRoot });
-}
-function seedFixture(fixtureRoot, seed) {
-    if (seed === undefined)
-        return;
-    switch (seed) {
-        case "defer-status":
-            seedAuditEntry(fixtureRoot, 12, "defer", { reason: "later" });
-            break;
-        case "defer-reset":
-            seedAuditEntry(fixtureRoot, 14, "defer", { reason: "later" });
-            break;
-        case "reset-idempotent":
-            seedAuditEntry(fixtureRoot, 15, "reset", {
-                decision_id: "22222222-2222-2222-2222-222222222222",
-                prior_decision_id: "11111111-1111-1111-1111-111111111111",
-            });
-            break;
-        case "history-multi":
-            seedAuditEntry(fixtureRoot, 17, "defer", {
-                decision_id: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
-                reason: "first",
-                timestamp: "2026-06-18T10:00:00Z",
-            });
-            seedAuditEntry(fixtureRoot, 17, "needs-ac", {
-                decision_id: "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
-                reason: "needs criteria",
-                timestamp: "2026-06-18T11:00:00Z",
-            });
-            break;
-        case "mark-duplicate-cache":
-            seedCacheIssue(fixtureRoot, 20);
-            break;
-        case "mark-duplicate-idempotent":
-            seedCacheIssue(fixtureRoot, 22);
-            seedAuditEntry(fixtureRoot, 21, "mark-duplicate", {
-                decision_id: "cccccccc-cccc-cccc-cccc-cccccccccccc",
-                linked_to: 22,
-            });
-            break;
-        case "mark-duplicate-cache-self":
-            seedCacheIssue(fixtureRoot, 23);
-            break;
-        default:
-            break;
-    }
-}
-/** Run all parity cases; returns aggregate result. */
-export function runParity() {
-    const deftRoot = resolveDeftRoot();
-    const diffs = [];
-    for (const testCase of PARITY_CASES) {
-        const pyFixture = buildFixtureRepo();
-        const tsFixture = buildFixtureRepo();
-        if (testCase.name === "accept-idempotent") {
-            seedAcceptFixture(pyFixture);
-            seedAcceptFixture(tsFixture);
-        }
-        else {
-            seedFixture(pyFixture, testCase.seed);
-            seedFixture(tsFixture, testCase.seed);
-        }
-        try {
-            const python = runPythonTriageAction(deftRoot, pyFixture, testCase.argv);
-            const ts = runTsTriageAction(deftRoot, tsFixture, testCase.argv);
-            diffs.push(diffCase(python, ts, testCase.name));
-        }
-        finally {
-            rmSync(pyFixture, { recursive: true, force: true });
-            rmSync(tsFixture, { 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-actions parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
-    }
-    const lines = ["triage-actions 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-actions parity: harness error -- ${String(err)}\n`);
-        process.exit(2);
-    }
-}
-//# sourceMappingURL=triage-actions-parity.js.map

package/dist/triage-aux-b-parity.js

@@ -1,308 +0,0 @@
-#!/usr/bin/env node
-/**
- * Golden-output parity harness (#1725): runs BOTH Python oracles and ported TS
- * CLIs for triage aux verbs B (bulk / subscribe / help / smoketest).
- *
- * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
- */
-import { spawnSync } from "node:child_process";
-import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-export function normalizeOutput(text) {
-    return text
-        .replace(/project_root=[^\s)]+/g, "project_root=<ROOT>")
-        .replace(/\/tmp\/deft-[^\s/]+/g, "<TMPROOT>")
-        .replace(/change_id": "[^"]+"/g, 'change_id": "<UUID>"')
-        .replace(/Using CPython[^\n]*\n/g, "")
-        .replace(/Creating virtual environment[^\n]*\n/g, "")
-        .replace(/Installed \d+ packages[^\n]*\n/g, "");
-}
-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];
-    }
-    const result = spawnSync(cmd, args, {
-        cwd,
-        encoding: "utf8",
-        env: merged,
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    return {
-        status: result.status ?? 2,
-        stdout: typeof result.stdout === "string" ? result.stdout : "",
-        stderr: typeof result.stderr === "string" ? result.stderr : "",
-    };
-}
-function writeProjectDefinition(root, policy = {}) {
-    mkdirSync(join(root, "vbrief"), { recursive: true });
-    writeFileSync(join(root, "vbrief", "PROJECT-DEFINITION.vbrief.json"), `${JSON.stringify({
-        vBRIEFInfo: { version: "0.6" },
-        plan: { title: "T", status: "running", items: [], policy },
-    }, null, 2)}\n`, { encoding: "utf8" });
-}
-function populateCache(cacheRoot, repo, issues) {
-    const [owner, name] = repo.split("/");
-    if (owner === undefined || name === undefined) {
-        throw new Error(`invalid repo ${repo}`);
-    }
-    for (const issue of issues) {
-        const n = String(issue.number);
-        const entryDir = join(cacheRoot, "github-issue", owner, name, n);
-        mkdirSync(entryDir, { recursive: true });
-        writeFileSync(join(entryDir, "raw.json"), JSON.stringify(issue), { encoding: "utf8" });
-        writeFileSync(join(entryDir, "meta.json"), JSON.stringify({
-            source: "github-issue",
-            key: `${repo}/${n}`,
-            fetched_at: "2026-05-05T00:00:00Z",
-            ttl_seconds: 604800,
-            expires_at: "2099-01-01T00:00:00Z",
-            scan_result: {
-                passed: true,
-                scanned_at: "2026-05-05T00:00:00Z",
-                scanner_version: "2.0.0",
-                flags: [],
-            },
-            size_bytes: 100,
-            stale: false,
-        }), { encoding: "utf8" });
-    }
-}
-export function buildFixtureRepo(kind) {
-    const root = mkdtempSync(join(tmpdir(), "deft-triage-aux-b-parity-"));
-    if (kind === "subscribe") {
-        writeProjectDefinition(root);
-        return root;
-    }
-    if (kind === "bulk-empty") {
-        writeProjectDefinition(root);
-        mkdirSync(join(root, ".deft-cache"), { recursive: true });
-        return root;
-    }
-    writeProjectDefinition(root);
-    populateCache(join(root, ".deft-cache"), "deftai/parity", [
-        {
-            number: 99,
-            title: "parity issue",
-            labels: [{ name: "other-label" }],
-            author: { login: "bot" },
-            createdAt: "2020-01-01T00:00:00Z",
-        },
-    ]);
-    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)), "..", "..", "..");
-}
-const PY_SCRIPT = {
-    help: "triage_help.py",
-    subscribe: "triage_subscribe.py",
-    bulk: "triage_bulk.py",
-    smoketest: "triage_smoketest.py",
-};
-const TS_CLI = {
-    help: "triage-help.js",
-    subscribe: "triage-subscribe.js",
-    bulk: "triage-bulk.js",
-    smoketest: "triage-smoketest.js",
-};
-function runPython(deftRoot, testCase, repo) {
-    const script = join(deftRoot, "scripts", PY_SCRIPT[testCase.verb]);
-    if (testCase.verb === "help") {
-        const cap = runCapture("uv", ["run", "python", script, ...testCase.argv], deftRoot, testCase.env);
-        return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
-    }
-    if (testCase.verb === "bulk") {
-        const cap = runCapture("uv", ["run", "python", script, ...testCase.argv], repo, {
-            ...testCase.env,
-            DEFT_ROOT: deftRoot,
-        });
-        return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
-    }
-    if (testCase.verb === "smoketest") {
-        const cap = runCapture("uv", ["run", "python", script, ...testCase.argv], deftRoot, testCase.env);
-        return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
-    }
-    const cap = runCapture("uv", ["run", "python", script, ...testCase.argv, "--project-root", repo], deftRoot, testCase.env);
-    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
-}
-function runTs(deftRoot, testCase, repo) {
-    const cli = join(deftRoot, "packages", "cli", "dist", TS_CLI[testCase.verb]);
-    const argv = [...testCase.argv];
-    if (testCase.verb === "subscribe") {
-        argv.push("--project-root", repo);
-    }
-    const cwd = testCase.verb === "bulk" ? repo : deftRoot;
-    const cap = runCapture("node", [cli, ...argv], cwd, {
-        ...testCase.env,
-        DEFT_ROOT: deftRoot,
-    });
-    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
-}
-export function diffCase(python, ts, caseName) {
-    return {
-        caseName,
-        exitMismatch: python.exitCode !== ts.exitCode,
-        stdoutMismatch: normalizeOutput(python.stdout) !== normalizeOutput(ts.stdout),
-        stderrMismatch: normalizeOutput(python.stderr) !== normalizeOutput(ts.stderr),
-        pythonExit: python.exitCode,
-        tsExit: ts.exitCode,
-    };
-}
-export const PARITY_CASES = [
-    { name: "help-triage-list", verb: "help", argv: ["triage"] },
-    { name: "help-scope-list", verb: "help", argv: ["scope"] },
-    { name: "help-verb-queue", verb: "help", argv: ["help", "task triage:queue"] },
-    { name: "help-registry-list", verb: "help", argv: ["list"] },
-    { name: "help-bulk-intercept", verb: "bulk", argv: ["accept", "--help"] },
-    {
-        name: "subscribe-label-create",
-        verb: "subscribe",
-        argv: ["subscribe", "--label", "area:parity"],
-        fixtureRoot: "subscribe",
-    },
-    {
-        name: "subscribe-label-idempotent",
-        verb: "subscribe",
-        argv: ["subscribe", "--label", "dup-label"],
-        fixtureRoot: "subscribe",
-        env: { DEFT_TRIAGE_ACTOR: "agent:parity" },
-    },
-    {
-        name: "subscribe-unsubscribe-missing",
-        verb: "subscribe",
-        argv: ["unsubscribe", "--label", "ghost"],
-        fixtureRoot: "subscribe",
-    },
-    {
-        name: "bulk-empty-cache",
-        verb: "bulk",
-        argv: ["accept", "--repo", "deftai/parity"],
-        fixtureRoot: "bulk-empty",
-    },
-    {
-        name: "bulk-zero-match",
-        verb: "bulk",
-        argv: ["defer", "--repo", "deftai/parity", "--label", "no-such-label"],
-        fixtureRoot: "bulk-filter",
-    },
-    {
-        name: "smoketest-missing-fixture",
-        verb: "smoketest",
-        argv: ["--fixture", "/nonexistent/deft-smoketest-fixture"],
-    },
-];
-export function runParity() {
-    const deftRoot = resolveDeftRoot();
-    const diffs = [];
-    const fixtureCache = new Map();
-    for (const testCase of PARITY_CASES) {
-        let pyRepo = deftRoot;
-        let tsRepo = deftRoot;
-        let ownsFixture = false;
-        if (testCase.fixtureRoot !== undefined) {
-            if (!fixtureCache.has(testCase.fixtureRoot)) {
-                fixtureCache.set(testCase.fixtureRoot, buildFixtureRepo(testCase.fixtureRoot));
-            }
-            const template = fixtureCache.get(testCase.fixtureRoot);
-            if (template === undefined) {
-                throw new Error(`missing fixture template ${testCase.fixtureRoot}`);
-            }
-            pyRepo = mkdtempSync(join(tmpdir(), "deft-parity-py-"));
-            tsRepo = mkdtempSync(join(tmpdir(), "deft-parity-ts-"));
-            for (const dest of [pyRepo, tsRepo]) {
-                mkdirSync(dest, { recursive: true });
-                for (const name of ["vbrief", ".deft-cache"]) {
-                    const src = join(template, name);
-                    if (existsSync(src)) {
-                        cpRecursive(src, join(dest, name));
-                    }
-                }
-            }
-            ownsFixture = true;
-            if (testCase.name === "subscribe-label-idempotent") {
-                for (const repo of [pyRepo, tsRepo]) {
-                    const setup = runCapture("uv", [
-                        "run",
-                        "python",
-                        join(deftRoot, "scripts", "triage_subscribe.py"),
-                        "subscribe",
-                        "--label",
-                        "dup-label",
-                        "--project-root",
-                        repo,
-                    ], deftRoot);
-                    if (setup.status !== 0) {
-                        throw new Error(`subscribe-label-idempotent setup failed for ${repo}: ${setup.stderr || setup.stdout}`);
-                    }
-                }
-            }
-        }
-        try {
-            const python = runPython(deftRoot, testCase, pyRepo);
-            const ts = runTs(deftRoot, testCase, tsRepo);
-            diffs.push(diffCase(python, ts, testCase.name));
-        }
-        finally {
-            if (ownsFixture) {
-                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 };
-}
-function cpRecursive(src, dest) {
-    mkdirSync(dest, { recursive: true });
-    for (const entry of readdirSync(src, { withFileTypes: true })) {
-        const s = join(src, entry.name);
-        const d = join(dest, entry.name);
-        if (entry.isDirectory()) {
-            cpRecursive(s, d);
-        }
-        else {
-            copyFileSync(s, d);
-        }
-    }
-}
-export function renderReport(result) {
-    if (result.ok) {
-        return `triage-aux-b parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
-    }
-    const lines = ["triage-aux-b 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-aux-b parity: harness error -- ${String(err)}\n`);
-        process.exit(2);
-    }
-}
-//# sourceMappingURL=triage-aux-b-parity.js.map