@deftai/directive 0.55.0

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

@@ -0,0 +1,308 @@
+#!/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

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

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+export interface CommandCapture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ParityCase {
+    readonly name: string;
+    readonly argv: string[];
+    readonly fixture?: FixtureOptions;
+}
+export interface FixtureOptions {
+    readonly scopeVbriefs?: Array<{
+        folder: string;
+        slug: string;
+        issue: number;
+    }>;
+    readonly preRunBootstrap?: boolean;
+}
+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;
+/** Compare stdout, parsing JSON payloads when present. */
+export declare function normalizeStdout(text: string): string;
+/** Build a throwaway project root with optional vBRIEF fixtures. */
+export declare function buildFixtureRepo(options?: FixtureOptions): string;
+/** Diff one parity case between Python oracle and TS CLI. */
+export declare function diffCase(python: CommandCapture, ts: CommandCapture, caseName: string): ParityDiff;
+export declare const PARITY_CASES: readonly ParityCase[];
+/** Run all parity cases; returns aggregate result. */
+export declare function runParity(): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=triage-bootstrap-parity.d.ts.map

package/dist/triage-bootstrap-parity.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1725): builds throwaway fixture repos, runs
+ * BOTH the Python oracle (`scripts/triage_bootstrap.py`) and the ported TS
+ * triage:bootstrap CLI, and 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": "[^"]+"/g, 'project_root": "<ROOT>"')
+        .replace(/"project_root": "[^"]+"/g, '"project_root": "<ROOT>"')
+        .replace(/project_root=[^\s)]+/g, "project_root=<ROOT>")
+        .replace(/under \/tmp\/[^\s)]+/g, "under <ROOT>")
+        .replace(/under \/var\/[^\s)]+/g, "under <ROOT>");
+}
+/** Compare stdout, parsing JSON payloads when present. */
+export function normalizeStdout(text) {
+    const trimmed = text.trim();
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed.project_root === "string") {
+                parsed.project_root = "<ROOT>";
+            }
+            const steps = parsed.steps;
+            if (Array.isArray(steps)) {
+                for (const step of steps) {
+                    if (typeof step !== "object" || step === null)
+                        continue;
+                    const record = step;
+                    if (typeof record.message === "string") {
+                        record.message = normalizeOutput(record.message);
+                    }
+                    const details = record.details;
+                    if (typeof details === "object" && details !== null) {
+                        const detailRecord = details;
+                        if (typeof detailRecord.audit_path === "string") {
+                            detailRecord.audit_path = "<ROOT>/vbrief/.eval/candidates.jsonl";
+                        }
+                        if (typeof detailRecord.fetch_timeout_s === "number") {
+                            detailRecord.fetch_timeout_s = Math.trunc(detailRecord.fetch_timeout_s);
+                        }
+                        if (typeof detailRecord.elapsed_s === "number") {
+                            detailRecord.elapsed_s = Number(detailRecord.elapsed_s.toFixed(3));
+                        }
+                    }
+                }
+            }
+            return JSON.stringify(parsed);
+        }
+        catch {
+            return normalizeOutput(text);
+        }
+    }
+    return normalizeOutput(text);
+}
+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 writeScopeVbrief(root, folder, slug, issueNumber) {
+    const dir = join(root, "vbrief", folder);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `${slug}.vbrief.json`), `${JSON.stringify({
+        vBRIEFInfo: { version: "0.6" },
+        plan: {
+            id: slug,
+            title: slug,
+            status: "proposed",
+            references: [
+                {
+                    type: "x-vbrief/github-issue",
+                    uri: `https://github.com/deftai/directive/issues/${issueNumber}`,
+                },
+            ],
+        },
+    })}\n`, { encoding: "utf8" });
+}
+/** Build a throwaway project root with optional vBRIEF fixtures. */
+export function buildFixtureRepo(options = {}) {
+    const root = mkdtempSync(join(tmpdir(), "deft-triage-bootstrap-parity-"));
+    mkdirSync(join(root, "vbrief"), { recursive: true });
+    for (const item of options.scopeVbriefs ?? []) {
+        writeScopeVbrief(root, item.folder, item.slug, item.issue);
+    }
+    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 runPythonBootstrap(deftRoot, repo, argv) {
+    const args = ["run", "python", join(deftRoot, "scripts", "triage_bootstrap.py"), ...argv];
+    if (!argv.some((a) => a === "--project-root" || a.startsWith("--project-root="))) {
+        args.push("--project-root", repo);
+    }
+    const cap = runCapture("uv", args, deftRoot);
+    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+}
+function runTsBootstrap(deftRoot, repo, argv) {
+    const args = [join(deftRoot, "packages", "cli", "dist", "triage-bootstrap.js"), ...argv];
+    if (!argv.some((a) => a === "--project-root" || a.startsWith("--project-root="))) {
+        args.push("--project-root", repo);
+    }
+    const cap = runCapture("node", args, 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 = normalizeStdout(python.stdout);
+    const tsOut = normalizeStdout(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: "json-no-repo-quiet",
+        argv: ["--json", "--quiet"],
+    },
+    {
+        name: "recap-no-repo-quiet",
+        argv: ["--quiet"],
+    },
+    {
+        name: "config-error-bad-root",
+        argv: ["--json", "--project-root", "/nonexistent-deft-bootstrap-parity-root"],
+    },
+    {
+        name: "json-invalid-repo-quiet",
+        argv: ["--json", "--quiet", "--repo", "bad"],
+    },
+    {
+        name: "json-idempotent-rerun",
+        argv: ["--json", "--quiet"],
+        fixture: { preRunBootstrap: true },
+    },
+];
+/** Run all parity cases; returns aggregate result. */
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const diffs = [];
+    for (const testCase of PARITY_CASES) {
+        const pyRepo = buildFixtureRepo(testCase.fixture ?? {});
+        const tsRepo = buildFixtureRepo(testCase.fixture ?? {});
+        try {
+            if (testCase.fixture?.preRunBootstrap === true) {
+                runPythonBootstrap(deftRoot, pyRepo, ["--quiet"]);
+                runTsBootstrap(deftRoot, tsRepo, ["--quiet"]);
+            }
+            const python = runPythonBootstrap(deftRoot, pyRepo, testCase.argv);
+            const ts = runTsBootstrap(deftRoot, 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:bootstrap parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
+    }
+    const lines = ["triage:bootstrap 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:bootstrap parity: harness error -- ${String(err)}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=triage-bootstrap-parity.js.map

package/dist/triage-bootstrap.d.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+export interface ParsedArgs {
+    projectRoot: string;
+    repo: string | null;
+    limit?: number;
+    state?: string;
+    labels: string[];
+    author?: string;
+    batchSize?: number;
+    delayMs?: number;
+    fetchTimeoutS: number;
+    quiet: boolean;
+    emitJson: boolean;
+    error?: string;
+}
+type BootstrapModule = typeof import("../../core/dist/triage/bootstrap/index.js");
+/** Parse triage-bootstrap CLI args, mirroring the Python argparse surface. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run triage:bootstrap with an injected core module (test seam). */
+export declare function runWithModule(mod: BootstrapModule, argv: string[]): Promise<number>;
+/** Run triage:bootstrap and return the process exit code. */
+export declare function run(argv: string[]): Promise<number>;
+export {};
+//# sourceMappingURL=triage-bootstrap.d.ts.map