@deftai/directive 0.126.0-beta.2 → 0.126.1

package/dist/triage-queue.js

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+/**
+ * triage:queue / triage:show CLI (#1128 / #2890).
+ *
+ * Subcommands:
+ *   queue  — ranked queue (default when first token is not show/audit)
+ *   show   — per-issue detail; --format=operator for Phase 3 brief backbone
+ *
+ * audit remains routed here by Taskfile; not reimplemented in this story.
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ensureTriageCacheHydrated } from "@deftai/directive-core/dist/cache/empty-populate.js";
+import { findByIssue } from "@deftai/directive-core/dist/triage/actions/candidates-log.js";
+import { resolveTriageCachePath } from "@deftai/directive-core/dist/triage/cache-path.js";
+import { activeReferencedIssueNumbers, buildQueue, collectOrphanIssueNumbers, DEFAULT_QUEUE_LIMIT, formatAuthorFilterLine, loadCachedIssueDetail, loadCachedIssues, loadSliceRecords, partitionByAuthorFilter, readAuditEntries, reconcileLiveOpenState, renderOperatorBrief, renderQueue, renderShow, resolveAuthorFilter, resolveRankingLabels, resolveRepo, ShowQuarantineRefuseError, } from "@deftai/directive-core/dist/triage/queue/index.js";
+import { resolveScopeIgnores } from "@deftai/directive-core/dist/triage/scope-drift/index.js";
+function baseArgs() {
+    return {
+        projectRoot: process.env.DEFT_PROJECT_ROOT ?? ".",
+        repo: process.env.DEFT_TRIAGE_REPO ?? null,
+        cacheRoot: null,
+        auditLog: null,
+    };
+}
+function parseCommonFlag(arg, argv, i, parsed) {
+    if (arg === "--project-root") {
+        const value = argv[i + 1];
+        if (value === undefined) {
+            return { consumed: 0, error: "argument --project-root: expected one argument" };
+        }
+        parsed.projectRoot = value;
+        return { consumed: 1 };
+    }
+    if (arg?.startsWith("--project-root=")) {
+        parsed.projectRoot = arg.slice("--project-root=".length);
+        return { consumed: 0 };
+    }
+    if (arg === "--repo") {
+        const value = argv[i + 1];
+        if (value === undefined) {
+            return { consumed: 0, error: "argument --repo: expected one argument" };
+        }
+        parsed.repo = value;
+        return { consumed: 1 };
+    }
+    if (arg?.startsWith("--repo=")) {
+        parsed.repo = arg.slice("--repo=".length);
+        return { consumed: 0 };
+    }
+    if (arg === "--cache-root") {
+        const value = argv[i + 1];
+        if (value === undefined) {
+            return { consumed: 0, error: "argument --cache-root: expected one argument" };
+        }
+        parsed.cacheRoot = value;
+        return { consumed: 1 };
+    }
+    if (arg?.startsWith("--cache-root=")) {
+        parsed.cacheRoot = arg.slice("--cache-root=".length);
+        return { consumed: 0 };
+    }
+    if (arg === "--audit-log") {
+        const value = argv[i + 1];
+        if (value === undefined) {
+            return { consumed: 0, error: "argument --audit-log: expected one argument" };
+        }
+        parsed.auditLog = value;
+        return { consumed: 1 };
+    }
+    if (arg?.startsWith("--audit-log=")) {
+        parsed.auditLog = arg.slice("--audit-log=".length);
+        return { consumed: 0 };
+    }
+    return null;
+}
+/** Parse triage-queue CLI args (queue subcommand — default). */
+export function parseArgs(argv) {
+    const common = baseArgs();
+    const parsed = {
+        ...common,
+        cmd: "queue",
+        limit: DEFAULT_QUEUE_LIMIT,
+        includeBlocked: false,
+        reconcile: true,
+        slicesLog: null,
+        author: null,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "queue" || arg === "--") {
+            continue;
+        }
+        if (arg === "--include-blocked") {
+            parsed.includeBlocked = true;
+            continue;
+        }
+        if (arg === "--no-reconcile") {
+            parsed.reconcile = false;
+            continue;
+        }
+        if (arg === "--author-mine") {
+            // #1318 Layer 1 optional alias for --author @me
+            parsed.author = "@me";
+            continue;
+        }
+        if (arg === "--author") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --author: expected one argument" };
+            }
+            // Reject adjacent flags (e.g. `--author --limit 10`) so they are not
+            // swallowed as logins (#3129 Greptile P1 adjacent-option).
+            if (value.startsWith("-")) {
+                return {
+                    ...parsed,
+                    error: `argument --author: expected a login (or @me), got flag token '${value}'`,
+                };
+            }
+            parsed.author = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--author=")) {
+            const value = arg.slice("--author=".length);
+            if (value.startsWith("-") && value.length > 1) {
+                return {
+                    ...parsed,
+                    error: `argument --author: expected a login (or @me), got flag token '${value}'`,
+                };
+            }
+            parsed.author = value;
+            continue;
+        }
+        const commonHit = parseCommonFlag(arg, argv, i, parsed);
+        if (commonHit !== null) {
+            if (commonHit.error !== undefined) {
+                return { ...parsed, error: commonHit.error };
+            }
+            i += commonHit.consumed;
+            continue;
+        }
+        if (arg === "--limit") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --limit: expected one argument" };
+            }
+            const parsedLimit = Number.parseInt(value, 10);
+            if (!Number.isFinite(parsedLimit)) {
+                return { ...parsed, error: `argument --limit: invalid int value: '${value}'` };
+            }
+            parsed.limit = parsedLimit;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--limit=")) {
+            const value = arg.slice("--limit=".length);
+            const parsedLimit = Number.parseInt(value, 10);
+            if (!Number.isFinite(parsedLimit)) {
+                return { ...parsed, error: `argument --limit: invalid int value: '${value}'` };
+            }
+            parsed.limit = parsedLimit;
+            continue;
+        }
+        if (arg === "--slices-log") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --slices-log: expected one argument" };
+            }
+            parsed.slicesLog = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--slices-log=")) {
+            parsed.slicesLog = arg.slice("--slices-log=".length);
+            continue;
+        }
+        if (arg?.startsWith("-")) {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Parse show subcommand args. */
+export function parseShowArgs(argv) {
+    const common = baseArgs();
+    const parsed = {
+        ...common,
+        cmd: "show",
+        number: null,
+        format: "default",
+    };
+    // Skip leading "show" token if present
+    let start = 0;
+    if (argv[0] === "show") {
+        start = 1;
+    }
+    for (let i = start; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--") {
+            continue;
+        }
+        const commonHit = parseCommonFlag(arg, argv, i, parsed);
+        if (commonHit !== null) {
+            if (commonHit.error !== undefined) {
+                return { ...parsed, error: commonHit.error };
+            }
+            i += commonHit.consumed;
+            continue;
+        }
+        if (arg === "--format") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --format: expected one argument" };
+            }
+            if (value !== "default" && value !== "operator" && value !== "plain" && value !== "text") {
+                return {
+                    ...parsed,
+                    error: `argument --format: invalid choice: '${value}' (choose from default, operator)`,
+                };
+            }
+            parsed.format = value === "operator" ? "operator" : "default";
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--format=")) {
+            const value = arg.slice("--format=".length);
+            if (value !== "default" && value !== "operator" && value !== "plain" && value !== "text") {
+                return {
+                    ...parsed,
+                    error: `argument --format: invalid choice: '${value}' (choose from default, operator)`,
+                };
+            }
+            parsed.format = value === "operator" ? "operator" : "default";
+            continue;
+        }
+        if (arg?.startsWith("-")) {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+        // positional issue number — strict positive int (reject "42abc" / "42.5")
+        if (!/^[1-9]\d*$/u.test(arg ?? "")) {
+            return { ...parsed, error: `argument number: invalid int value: '${arg}'` };
+        }
+        parsed.number = Number(arg);
+    }
+    if (parsed.number === null && parsed.error === undefined) {
+        return { ...parsed, error: "triage:show: issue number is required (e.g. triage:show -- 42)" };
+    }
+    return parsed;
+}
+function runQueue(args, options = {}) {
+    if (args.error !== undefined) {
+        process.stderr.write(`triage_queue: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const repo = resolveRepo(args.repo, projectRoot);
+    if (repo === null) {
+        process.stderr.write("triage:queue: --repo OWNER/NAME (or $DEFT_TRIAGE_REPO) is required.\n");
+        return 2;
+    }
+    let authorFilterLine = null;
+    let authorAllow;
+    // Flag present (including empty `--author=`) must resolve or fail closed — never
+    // silent no-op that would show the full queue (#3129 Greptile P1).
+    if (args.author !== null) {
+        const resolved = resolveAuthorFilter(args.author, options.resolveAuthenticatedLogin ?? undefined);
+        if (resolved.error !== undefined || resolved.filter === undefined) {
+            process.stderr.write(`triage:queue: ${resolved.error ?? "argument --author: expected a non-empty login (or @me)"}\n`);
+            return 2;
+        }
+        authorAllow = resolved.filter;
+    }
+    ensureTriageCacheHydrated(projectRoot, { repo });
+    const cachedForQueue = loadCachedIssues(repo, { projectRoot });
+    let issuesForQueue = args.reconcile
+        ? reconcileLiveOpenState(cachedForQueue, repo, options.liveOpenReader)
+        : cachedForQueue;
+    if (authorAllow !== undefined) {
+        const partition = partitionByAuthorFilter(issuesForQueue, (row) => row.author ?? null, authorAllow);
+        issuesForQueue = [...partition.matched];
+        authorFilterLine = formatAuthorFilterLine(authorAllow, {
+            unknownCount: partition.unknownCount,
+        });
+    }
+    const issuesWithClosed = loadCachedIssues(repo, { projectRoot, includeClosed: true });
+    const issuesByNumber = new Map(issuesWithClosed.map((row) => [row.number, row]));
+    const auditEntries = readAuditEntries(repo, {
+        auditLogPath: args.auditLog ?? resolveTriageCachePath(projectRoot, "candidates.jsonl"),
+    });
+    const rankingLabels = resolveRankingLabels(projectRoot);
+    const activeRefs = activeReferencedIssueNumbers(projectRoot);
+    const sliceRecords = loadSliceRecords({
+        slicesLogPath: args.slicesLog ?? resolveTriageCachePath(projectRoot, "slices.jsonl"),
+    });
+    const orphanNumbers = collectOrphanIssueNumbers(sliceRecords, issuesByNumber);
+    const limit = args.limit === 0 ? null : Math.max(0, args.limit);
+    const scopeIgnores = resolveScopeIgnores(projectRoot);
+    const items = buildQueue(issuesForQueue, auditEntries, {
+        repo,
+        queue: {
+            rankingLabels,
+            activeReferenced: activeRefs,
+            orphanIssueNumbers: orphanNumbers,
+            includeBlocked: args.includeBlocked,
+            limit,
+            scopeIgnores,
+        },
+    });
+    process.stdout.write(`${renderQueue({
+        items,
+        repo,
+        limit,
+        rankingLabels,
+        authorFilterLine,
+    })}\n`);
+    return 0;
+}
+function runShow(args) {
+    if (args.error !== undefined) {
+        process.stderr.write(`triage:show: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const repo = resolveRepo(args.repo, projectRoot);
+    if (repo === null) {
+        process.stderr.write("triage:show: --repo OWNER/NAME (or $DEFT_TRIAGE_REPO) is required.\n");
+        return 2;
+    }
+    const number = args.number;
+    if (number === null) {
+        process.stderr.write("triage:show: issue number is required\n");
+        return 2;
+    }
+    const cacheRoot = args.cacheRoot !== null && args.cacheRoot.length > 0 ? resolve(args.cacheRoot) : null;
+    ensureTriageCacheHydrated(projectRoot, {
+        repo,
+        ...(cacheRoot !== null ? { cacheRoot } : {}),
+    });
+    const loaded = loadCachedIssueDetail(repo, number, {
+        projectRoot,
+        cacheRoot,
+    });
+    // Typed quarantine refuse (#5367): returned-failure → exit 1 + stderr; never emit raw.json.
+    if (loaded instanceof ShowQuarantineRefuseError) {
+        process.stderr.write(`${loaded.message}\n`);
+        return 1;
+    }
+    const issue = loaded;
+    const logPath = args.auditLog ?? resolveTriageCachePath(projectRoot, "candidates.jsonl");
+    const history = findByIssue(number, repo, logPath)
+        .slice()
+        .sort((a, b) => String(a.timestamp ?? "").localeCompare(String(b.timestamp ?? "")));
+    const latest = history.length > 0 ? (history[history.length - 1] ?? null) : null;
+    const activeRefs = activeReferencedIssueNumbers(projectRoot);
+    const inActive = activeRefs.has(number);
+    if (args.format === "operator") {
+        process.stdout.write(`${renderOperatorBrief({
+            issue,
+            repo,
+            number,
+            latestDecision: latest,
+            inActiveXbrief: inActive,
+        })}\n`);
+    }
+    else {
+        process.stdout.write(`${renderShow({
+            issue,
+            repo,
+            number,
+            latestDecision: latest,
+            history,
+            inActiveXbrief: inActive,
+        })}\n`);
+    }
+    return issue !== null ? 0 : 1;
+}
+/** Run triage:queue or triage:show and return process exit code. */
+export function run(argv, options = {}) {
+    const first = argv[0];
+    if (first === "show") {
+        return runShow(parseShowArgs(argv));
+    }
+    // Other subcommands (e.g. audit) keep prior queue-module routing until
+    // separately ported; only `show` is specialized here (#2890).
+    return runQueue(parseArgs(argv), options);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-queue.js.map

package/dist/triage-reconcile.d.ts

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

package/dist/triage-reconcile.js

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

package/dist/triage-refresh.d.ts

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

package/dist/triage-refresh.js

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

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

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

package/dist/triage-scope-drift.js

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

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

@@ -0,0 +1,32 @@
+export interface CommandCapture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ScopeFixtureOptions {
+    readonly policy?: Record<string, unknown>;
+}
+export interface ParityCase {
+    readonly name: string;
+    readonly argv: string[];
+    readonly fixture?: ScopeFixtureOptions;
+}
+export interface ParityDiff {
+    readonly caseName: string;
+    readonly exitMismatch: boolean;
+    readonly stdoutMismatch: boolean;
+    readonly stderrMismatch: boolean;
+    readonly pythonExit: number;
+    readonly tsExit: number;
+}
+export interface ParityResult {
+    readonly ok: boolean;
+    readonly diffs: ParityDiff[];
+}
+/** Strip volatile absolute paths before compare. */
+export declare function normalizeOutput(text: string): string;
+export declare function buildFixtureRepo(options?: ScopeFixtureOptions): string;
+export declare function diffCase(python: CommandCapture, ts: CommandCapture, caseName: string): ParityDiff;
+export declare const PARITY_CASES: readonly ParityCase[];
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=triage-scope-fixtures.d.ts.map