@deftai/directive 0.55.0

package/dist/triage-actions-parity.js

@@ -0,0 +1,201 @@
+#!/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";
+/** Strip volatile UUIDs and timestamps before compare. */
+export function normalizeOutput(text) {
+    return text
+        .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, "");
+}
+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 : "",
+    };
+}
+/** 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 triage_actions",
+        "triage_actions.candidates_log = cl",
+        "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 });
+    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);
+    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+}
+/** Diff one parity case between Python oracle and TS CLI. */
+export function diffCase(python, ts, caseName) {
+    const pyOut = normalizeOutput(python.stdout);
+    const tsOut = normalizeOutput(ts.stdout);
+    const pyErr = normalizeOutput(python.stderr);
+    const tsErr = normalizeOutput(ts.stderr);
+    return {
+        caseName,
+        exitMismatch: python.exitCode !== ts.exitCode,
+        stdoutMismatch: pyOut !== tsOut,
+        stderrMismatch: pyErr !== tsErr,
+        pythonExit: python.exitCode,
+        tsExit: ts.exitCode,
+    };
+}
+export const PARITY_CASES = [
+    {
+        name: "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"],
+    },
+];
+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");
+}
+/** 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);
+        }
+        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-actions.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    cmd?: string;
+    issue?: number;
+    repo?: string;
+    reason?: string;
+    resumeOn?: string;
+    actor?: string;
+    projectRoot: string;
+    error?: string;
+}
+/** Parse triage-actions CLI argv mirroring ``triage_actions.py`` argparse. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run triage-actions CLI and return exit code. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=triage-actions.d.ts.map

package/dist/triage-actions.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { accept, createDefaultDeps, deferAction, reject, TriageError, UpstreamCloseError, } from "../../core/dist/triage/actions/index.js";
+/** Parse triage-actions CLI argv mirroring ``triage_actions.py`` argparse. */
+export function parseArgs(argv) {
+    const parsed = { projectRoot: process.cwd() };
+    if (argv.length === 0) {
+        return { ...parsed, error: "missing subcommand" };
+    }
+    parsed.cmd = argv[0];
+    for (let i = 1; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--issue") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --issue: expected one argument" };
+            parsed.issue = Number.parseInt(value, 10);
+            i += 1;
+        }
+        else if (arg?.startsWith("--issue=")) {
+            parsed.issue = Number.parseInt(arg.slice("--issue=".length), 10);
+        }
+        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 if (arg === "--reason") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --reason: expected one argument" };
+            parsed.reason = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--reason=")) {
+            parsed.reason = arg.slice("--reason=".length);
+        }
+        else if (arg === "--resume-on") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --resume-on: expected one argument" };
+            parsed.resumeOn = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--resume-on=")) {
+            parsed.resumeOn = arg.slice("--resume-on=".length);
+        }
+        else if (arg === "--actor") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --actor: expected one argument" };
+            parsed.actor = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--actor=")) {
+            parsed.actor = arg.slice("--actor=".length);
+        }
+        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 {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run triage-actions CLI and return exit code. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`triage_actions: ${args.error}\n`);
+        return 2;
+    }
+    if (args.cmd !== "accept" && args.cmd !== "reject" && args.cmd !== "defer") {
+        process.stderr.write(`triage_actions: unknown subcommand ${args.cmd ?? ""}\n`);
+        return 2;
+    }
+    if (args.issue === undefined || Number.isNaN(args.issue)) {
+        process.stderr.write("triage_actions: argument --issue: expected one argument\n");
+        return 2;
+    }
+    if (args.repo === undefined) {
+        process.stderr.write("triage_actions: argument --repo: expected one argument\n");
+        return 2;
+    }
+    if (args.cmd === "reject" && args.reason === undefined) {
+        process.stderr.write("triage_actions: argument --reason: expected one argument\n");
+        return 2;
+    }
+    if (args.cmd === "defer" && args.reason === undefined) {
+        process.stderr.write("triage_actions: argument --reason: expected one argument\n");
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const deps = createDefaultDeps(projectRoot);
+    const n = args.issue;
+    const repo = args.repo;
+    try {
+        if (args.cmd === "accept") {
+            const decisionId = accept(n, repo, deps, { actor: args.actor, projectRoot });
+            process.stdout.write(`accept #${n} (${repo}) -> ${decisionId}\n`);
+        }
+        else if (args.cmd === "reject") {
+            const decisionId = reject(n, repo, args.reason ?? "", deps, {
+                actor: args.actor,
+                projectRoot,
+            });
+            process.stdout.write(`reject #${n} (${repo}) -> ${decisionId}\n`);
+        }
+        else {
+            const decisionId = deferAction(n, repo, args.reason, deps, {
+                actor: args.actor,
+                resumeOn: args.resumeOn,
+                projectRoot,
+            });
+            process.stdout.write(`defer #${n} (${repo}) -> ${decisionId}\n`);
+        }
+    }
+    catch (err) {
+        if (err instanceof TriageError || err instanceof UpstreamCloseError) {
+            process.stderr.write(`triage_actions: ${err.message}\n`);
+            return 1;
+        }
+        throw err;
+    }
+    return 0;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-actions.js.map

package/dist/triage-aux-a-parity.d.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+export interface CommandCapture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ParityCase {
+    readonly name: string;
+    readonly script: "triage_welcome.py" | "triage_reconcile.py" | "triage_scope_drift.py" | "triage_refresh.py";
+    readonly tsCli: "triage-welcome.js" | "triage-reconcile.js" | "triage-scope-drift.js" | "triage-refresh.js";
+    readonly argv: readonly string[];
+    readonly setup?: (root: string) => void;
+}
+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;
+declare function resolveDeftRoot(): string;
+export { resolveDeftRoot };
+export declare function diffCase(python: CommandCapture, ts: CommandCapture, caseName: string): ParityDiff;
+export declare const PARITY_CASES: readonly ParityCase[];
+export declare function buildFixtureRepo(setup?: (root: string) => void): string;
+export declare function runParity(): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=triage-aux-a-parity.d.ts.map

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

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1725): runs BOTH the Python oracle and the
+ * ported TS triage aux-A CLIs with identical argv on throwaway fixtures,
+ * then diffs exit codes + 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(/"project_root": "[^"]+"/g, '"project_root": "<ROOT>"')
+        .replace(/\/tmp\/[^\s"']+/g, "<TMP>");
+}
+function runCapture(cmd, args, cwd) {
+    const result = spawnSync(cmd, args, {
+        cwd,
+        encoding: "utf8",
+        env: { ...process.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)), "..", "..", "..");
+}
+export { resolveDeftRoot };
+function runPython(deftRoot, script, repo, argv) {
+    const cap = runCapture("python3", [join(deftRoot, "scripts", script), ...argv, "--project-root", repo], deftRoot);
+    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+}
+function runTs(deftRoot, cli, repo, argv) {
+    const cap = runCapture("node", [join(deftRoot, "packages", "cli", "dist", cli), ...argv, "--project-root", repo], deftRoot);
+    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+}
+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,
+    };
+}
+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: { policy } }, null, 2)}\n`, "utf8");
+}
+export const PARITY_CASES = [
+    {
+        name: "welcome-default-empty",
+        script: "triage_welcome.py",
+        tsCli: "triage-welcome.js",
+        argv: ["--no-history"],
+    },
+    {
+        name: "reconcile-dry-run-json-empty",
+        script: "triage_reconcile.py",
+        tsCli: "triage-reconcile.js",
+        argv: ["--dry-run", "--json"],
+    },
+    {
+        name: "reconcile-text-empty",
+        script: "triage_reconcile.py",
+        tsCli: "triage-reconcile.js",
+        argv: [],
+    },
+    {
+        name: "scope-drift-empty-cache",
+        script: "triage_scope_drift.py",
+        tsCli: "triage-scope-drift.js",
+        argv: [],
+        setup: (root) => writeProjectDefinition(root),
+    },
+    {
+        name: "refresh-empty-active",
+        script: "triage_refresh.py",
+        tsCli: "triage-refresh.js",
+        argv: [],
+    },
+    {
+        name: "welcome-bad-root",
+        script: "triage_welcome.py",
+        tsCli: "triage-welcome.js",
+        argv: [],
+        setup: () => { },
+    },
+];
+export function buildFixtureRepo(setup) {
+    const root = mkdtempSync(join(tmpdir(), "deft-triage-aux-a-parity-"));
+    mkdirSync(join(root, "vbrief"), { recursive: true });
+    setup?.(root);
+    return root;
+}
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const diffs = [];
+    for (const testCase of PARITY_CASES) {
+        if (testCase.name === "welcome-bad-root") {
+            const badRoot = join(tmpdir(), "deft-triage-missing-dir-never-created");
+            const python = runPython(deftRoot, testCase.script, badRoot, testCase.argv);
+            const ts = runTs(deftRoot, testCase.tsCli, badRoot, testCase.argv);
+            diffs.push(diffCase(python, ts, testCase.name));
+            continue;
+        }
+        const pyRepo = buildFixtureRepo(testCase.setup);
+        const tsRepo = buildFixtureRepo(testCase.setup);
+        try {
+            const python = runPython(deftRoot, testCase.script, pyRepo, testCase.argv);
+            const ts = runTs(deftRoot, testCase.tsCli, tsRepo, testCase.argv);
+            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-aux-a parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
+    }
+    const lines = ["triage-aux-a 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-a parity: harness error -- ${String(err)}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=triage-aux-a-parity.js.map

package/dist/triage-aux-b-parity.d.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+export interface CommandCapture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ParityCase {
+    readonly name: string;
+    readonly verb: "help" | "subscribe" | "bulk" | "smoketest";
+    readonly argv: readonly string[];
+    readonly fixtureRoot?: string;
+    readonly env?: Record<string, string>;
+}
+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[];
+}
+export declare function normalizeOutput(text: string): string;
+export declare function buildFixtureRepo(kind: "subscribe" | "bulk-empty" | "bulk-filter"): 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-aux-b-parity.d.ts.map