@deftai/directive 0.55.0

package/dist/triage-scope.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+/** Run triage:scope with argv; returns process exit code. */
+export declare function run(argv: string[]): number;
+//# sourceMappingURL=triage-scope.d.ts.map

package/dist/triage-scope.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/**
+ * Thin CLI entry for triage:scope (#1725).
+ * Delegates to the core implementation at packages/core/dist/triage/scope/cli.js.
+ */
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function coreCliPath() {
+    return join(dirname(fileURLToPath(import.meta.url)), "../../core/dist/triage/scope/cli.js");
+}
+/** Run triage:scope with argv; returns process exit code. */
+export function run(argv) {
+    const result = spawnSync(process.execPath, [coreCliPath(), ...argv], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (typeof result.stdout === "string" && result.stdout.length > 0) {
+        process.stdout.write(result.stdout);
+    }
+    if (typeof result.stderr === "string" && result.stderr.length > 0) {
+        process.stderr.write(result.stderr);
+    }
+    return result.status ?? 2;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-scope.js.map

package/dist/triage-smoketest.d.ts

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

package/dist/triage-smoketest.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import { existsSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { interceptHelp } from "../../core/dist/triage/help/index.js";
+import { DEFAULT_FIXTURE_REL, parseSmoketestArgs, runSmoketest, } from "../../core/dist/triage/smoketest/index.js";
+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 function run(argv) {
+    const helpRc = interceptHelp("triage_smoketest", argv);
+    if (helpRc !== null) {
+        return helpRc;
+    }
+    const args = parseSmoketestArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`${args.error}\n`);
+        return 2;
+    }
+    if (args.showHelp) {
+        return 0;
+    }
+    const deftRoot = resolveDeftRoot();
+    const fixtureRoot = resolve(args.fixture !== "" ? args.fixture : join(deftRoot, DEFAULT_FIXTURE_REL));
+    if (!existsSync(fixtureRoot) || !statSync(fixtureRoot).isDirectory()) {
+        process.stderr.write(`[triage:smoketest] FAIL: fixture root ${fixtureRoot} does not exist ` +
+            "or is not a directory.\n");
+        return 1;
+    }
+    return runSmoketest(fixtureRoot, {
+        verbose: args.verbose,
+        keepTempdir: args.keepTempdir,
+        cacheOnly: args.cacheOnly,
+        deftRoot,
+    });
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-smoketest.js.map

package/dist/triage-subscribe.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    op: string;
+    projectRoot: string;
+    label: string | null;
+    milestone: string | null;
+    issue: number | null;
+    issueNote: string;
+    actor: string | null;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=triage-subscribe.d.ts.map

package/dist/triage-subscribe.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { interceptHelp } from "../../core/dist/triage/help/index.js";
+import { RECONCILE_HINT, subscribe, unsubscribe } from "../../core/dist/triage/subscribe/index.js";
+export function parseArgs(argv) {
+    const parsed = {
+        op: "",
+        projectRoot: process.env.DEFT_PROJECT_ROOT ?? ".",
+        label: null,
+        milestone: null,
+        issue: null,
+        issueNote: "added via task triage:subscribe",
+        actor: null,
+    };
+    const positional = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            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;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--label") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --label: expected one argument" };
+            }
+            parsed.label = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--label=")) {
+            parsed.label = arg.slice("--label=".length);
+        }
+        else if (arg === "--milestone") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --milestone: expected one argument" };
+            }
+            parsed.milestone = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--milestone=")) {
+            parsed.milestone = arg.slice("--milestone=".length);
+        }
+        else 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 === "--issue-note") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --issue-note: expected one argument" };
+            }
+            parsed.issueNote = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--issue-note=")) {
+            parsed.issueNote = arg.slice("--issue-note=".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.startsWith("-")) {
+            return { ...parsed, error: `unrecognized arguments: ${arg}` };
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    if (positional.length > 0 && positional[0] !== undefined) {
+        parsed.op = positional[0];
+    }
+    return parsed;
+}
+export function run(argv) {
+    const helpRc = interceptHelp("triage_subscribe", argv);
+    if (helpRc !== null) {
+        return helpRc;
+    }
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`${args.error}\n`);
+        return 2;
+    }
+    if (args.op !== "subscribe" && args.op !== "unsubscribe") {
+        process.stderr.write("triage:subscribe: first positional arg must be 'subscribe' or " +
+            "'unsubscribe'; e.g. task triage:subscribe -- --label=bug\n");
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    if (!existsSync(projectRoot) || !statSync(projectRoot).isDirectory()) {
+        process.stderr.write(`triage:${args.op}: --project-root ${projectRoot} does not exist ` +
+            "or is not a directory.\n");
+        return 2;
+    }
+    const chosen = [args.label, args.milestone, args.issue].filter((v) => v !== null).length;
+    if (chosen !== 1) {
+        process.stderr.write(`triage:${args.op}: exactly one of --label / --milestone / --issue is required.\n`);
+        return 2;
+    }
+    try {
+        const [changed, message] = args.op === "subscribe"
+            ? subscribe(projectRoot, {
+                label: args.label,
+                milestone: args.milestone,
+                issue: args.issue,
+                issueNote: args.issueNote,
+                actor: args.actor,
+            })
+            : unsubscribe(projectRoot, {
+                label: args.label,
+                milestone: args.milestone,
+                issue: args.issue,
+                actor: args.actor,
+            });
+        if (!changed) {
+            process.stderr.write(`triage:${args.op}: ${message} (no-op).\n`);
+            return 0;
+        }
+        process.stdout.write(`triage:${args.op}: ${message}.\n`);
+        process.stderr.write(`${RECONCILE_HINT}\n`);
+        return 0;
+    }
+    catch (exc) {
+        process.stderr.write(`triage:${args.op}: ${String(exc)}\n`);
+        return 1;
+    }
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-subscribe.js.map

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

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+export interface CommandCapture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface SummaryFixtureOptions {
+    readonly wipCap?: number;
+    readonly triageScope?: Record<string, unknown>[] | null;
+    readonly cachedIssues?: ReadonlyArray<{
+        repo: string;
+        number: number;
+    }>;
+    readonly auditEntries?: Record<string, unknown>[];
+    readonly pendingVbriefs?: number;
+    readonly activeVbriefs?: ReadonlyArray<{
+        name: string;
+        status?: string;
+    }>;
+}
+export interface ParityCase {
+    readonly name: string;
+    readonly argv: string[];
+    readonly fixture?: SummaryFixtureOptions;
+}
+export interface ParityDiff {
+    readonly caseName: string;
+    readonly exitMismatch: boolean;
+    readonly stdoutMismatch: boolean;
+    readonly stderrMismatch: boolean;
+    readonly pythonExit: number;
+    readonly tsExit: number;
+    readonly pythonStdout: string;
+    readonly tsStdout: string;
+}
+export interface ParityResult {
+    readonly ok: boolean;
+    readonly diffs: ParityDiff[];
+}
+/** Strip volatile fields before compare. */
+export declare function normalizeOutput(text: string): string;
+/** Build a throwaway project root with optional cache / audit / vBRIEF state. */
+export declare function buildFixtureRepo(options?: SummaryFixtureOptions): 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-summary-parity.d.ts.map

package/dist/triage-summary-parity.js

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1725): builds throwaway fixture repos, runs
+ * BOTH the Python oracle (`scripts/triage_summary.py`) and the ported TS
+ * triage:summary CLI, and diffs stdout (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 fields before compare. */
+export function normalizeOutput(text) {
+    return text
+        .replace(/\r\n/g, "\n")
+        .replace(/"emitted_at": "[^"]+"/g, '"emitted_at": "<TS>"')
+        .trimEnd();
+}
+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, options) {
+    const dir = join(root, "vbrief");
+    mkdirSync(dir, { recursive: true });
+    const policy = {};
+    if (options.wipCap !== undefined) {
+        policy.wipCap = options.wipCap;
+    }
+    if (options.triageScope !== undefined && options.triageScope !== null) {
+        policy.triageScope = options.triageScope;
+    }
+    writeFileSync(join(dir, "PROJECT-DEFINITION.vbrief.json"), `${JSON.stringify({
+        vBRIEFInfo: { version: "0.6" },
+        plan: { title: "T", status: "running", items: [], policy },
+    }, null, 2)}\n`, { encoding: "utf8" });
+}
+function makeCachedIssue(cacheRoot, repo, number) {
+    const [owner, name] = repo.split("/", 2);
+    const entry = join(cacheRoot, "github-issue", owner ?? "", name ?? "", String(number));
+    mkdirSync(entry, { recursive: true });
+    writeFileSync(join(entry, "meta.json"), "{}\n", { encoding: "utf8" });
+    writeFileSync(join(entry, "raw.json"), "{}\n", { encoding: "utf8" });
+}
+function writeAuditLog(root, entries) {
+    const logDir = join(root, "vbrief", ".eval");
+    mkdirSync(logDir, { recursive: true });
+    const lines = entries.map((e) => JSON.stringify(e, Object.keys(e).sort())).join("\n");
+    writeFileSync(join(logDir, "candidates.jsonl"), lines.length > 0 ? `${lines}\n` : "", {
+        encoding: "utf8",
+    });
+}
+function writeActiveVbrief(root, name, status) {
+    const dir = join(root, "vbrief", "active");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `${name}.vbrief.json`), `${JSON.stringify({
+        vBRIEFInfo: { version: "0.6" },
+        plan: { status, title: name },
+    })}\n`, { encoding: "utf8" });
+}
+function writePendingVbriefs(root, count) {
+    const dir = join(root, "vbrief", "pending");
+    mkdirSync(dir, { recursive: true });
+    for (let i = 0; i < count; i += 1) {
+        writeFileSync(join(dir, `pending-${i}.vbrief.json`), `${JSON.stringify({ vBRIEFInfo: { version: "0.6" }, plan: { status: "approved" } })}\n`, { encoding: "utf8" });
+    }
+}
+/** Build a throwaway project root with optional cache / audit / vBRIEF state. */
+export function buildFixtureRepo(options = {}) {
+    const root = mkdtempSync(join(tmpdir(), "deft-triage-summary-parity-"));
+    mkdirSync(join(root, "vbrief"), { recursive: true });
+    if (options.wipCap !== undefined || options.triageScope !== undefined) {
+        writeProjectDefinition(root, {
+            wipCap: options.wipCap,
+            triageScope: options.triageScope,
+        });
+    }
+    const cacheRoot = join(root, ".deft-cache");
+    for (const issue of options.cachedIssues ?? []) {
+        makeCachedIssue(cacheRoot, issue.repo, issue.number);
+    }
+    if (options.auditEntries !== undefined && options.auditEntries.length > 0) {
+        writeAuditLog(root, options.auditEntries);
+    }
+    if (options.pendingVbriefs !== undefined && options.pendingVbriefs > 0) {
+        writePendingVbriefs(root, options.pendingVbriefs);
+    }
+    for (const vb of options.activeVbriefs ?? []) {
+        writeActiveVbrief(root, vb.name, vb.status ?? "running");
+    }
+    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 runPythonSummary(deftRoot, repo, argv) {
+    const cap = runCapture("uv", [
+        "run",
+        "python",
+        join(deftRoot, "scripts", "triage_summary.py"),
+        ...argv,
+        "--project-root",
+        repo,
+        "--no-history",
+    ], deftRoot);
+    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+}
+function runTsSummary(deftRoot, repo, argv) {
+    const cap = runCapture("node", [
+        join(deftRoot, "packages", "cli", "dist", "triage-summary.js"),
+        ...argv,
+        "--project-root",
+        repo,
+        "--no-history",
+    ], 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,
+        pythonStdout: pyOut,
+        tsStdout: tsOut,
+    };
+}
+const auditEntry = (repo, issueNumber, decision, decisionId) => ({
+    actor: "agent:test",
+    decision,
+    decision_id: decisionId,
+    issue_number: issueNumber,
+    repo,
+    timestamp: "2026-05-17T20:00:00Z",
+});
+export const PARITY_CASES = [
+    {
+        name: "empty-cache",
+        argv: [],
+        fixture: {},
+    },
+    {
+        name: "populated-zero-wip",
+        argv: [],
+        fixture: {
+            cachedIssues: [
+                { repo: "deftai/directive", number: 100 },
+                { repo: "deftai/directive", number: 101 },
+                { repo: "deftai/directive", number: 102 },
+            ],
+            auditEntries: [
+                auditEntry("deftai/directive", 100, "accept", "11111111-1111-1111-1111-111111111101"),
+                auditEntry("deftai/directive", 101, "accept", "11111111-1111-1111-1111-111111111102"),
+            ],
+        },
+    },
+    {
+        name: "zero-untriaged-still-prints",
+        argv: [],
+        fixture: {
+            cachedIssues: [{ repo: "deftai/directive", number: 200 }],
+            auditEntries: [
+                auditEntry("deftai/directive", 200, "accept", "22222222-2222-2222-2222-222222222200"),
+            ],
+        },
+    },
+    {
+        name: "wip-at-cap-warning",
+        argv: [],
+        fixture: {
+            wipCap: 12,
+            cachedIssues: [{ repo: "deftai/directive", number: 500 }],
+            pendingVbriefs: 12,
+        },
+    },
+    {
+        name: "wip-above-cap-warning",
+        argv: [],
+        fixture: {
+            wipCap: 5,
+            cachedIssues: [{ repo: "deftai/directive", number: 501 }],
+            activeVbriefs: Array.from({ length: 7 }, (_, i) => ({ name: `active-${i}` })),
+        },
+    },
+    {
+        name: "filesystem-in-flight-divergence",
+        argv: [],
+        fixture: {
+            cachedIssues: [
+                { repo: "deftai/directive", number: 600 },
+                { repo: "deftai/directive", number: 601 },
+                { repo: "deftai/directive", number: 602 },
+            ],
+            auditEntries: [
+                auditEntry("deftai/directive", 600, "accept", "66666666-6666-6666-6666-666666666600"),
+                auditEntry("deftai/directive", 601, "accept", "66666666-6666-6666-6666-666666666601"),
+            ],
+            activeVbriefs: [{ name: "only-running", status: "running" }],
+        },
+    },
+    {
+        name: "configured-scope-divergence",
+        argv: [],
+        fixture: {
+            triageScope: [{ rule: "labels", "any-of": ["phase-1"] }],
+            cachedIssues: [{ repo: "deftai/directive", number: 700 }],
+            auditEntries: [
+                auditEntry("deftai/directive", 700, "accept", "77777777-7777-7777-7777-777777777700"),
+            ],
+            activeVbriefs: [
+                { name: "one-running", status: "running" },
+                { name: "two-running", status: "running" },
+            ],
+        },
+    },
+    {
+        name: "json-mode",
+        argv: ["--json"],
+        fixture: {
+            cachedIssues: [{ repo: "deftai/directive", number: 900 }],
+        },
+    },
+];
+/** 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 {
+            const python = runPythonSummary(deftRoot, pyRepo, testCase.argv);
+            const ts = runTsSummary(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:summary parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
+    }
+    const lines = ["triage:summary 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(`    python stdout: ${d.pythonStdout}`);
+                lines.push(`    ts stdout:     ${d.tsStdout}`);
+            }
+            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) {
+        const msg = String(err).replace(/\r?\n/g, " ");
+        process.stderr.write(`triage:summary parity: harness error -- ${msg}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=triage-summary-parity.js.map

package/dist/triage-summary.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    cacheRoot: string | null;
+    noHistory: boolean;
+    json: boolean;
+    error?: string;
+}
+/** Parse triage-summary CLI args, mirroring the Python argparse surface. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the triage:summary CLI — always returns exit code 0. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=triage-summary.d.ts.map