@deftai/directive-core 0.55.0

package/dist/triage/reconcile/reconcile.js

@@ -0,0 +1,163 @@
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { auditKey, existingAuditRefs, scanLifecycleRefs } from "./audit.js";
+import { AUDIT_LOG_RELPATH, BACKFILL_FOLDERS, RECONCILE_ACTOR, } from "./types.js";
+const GIT_ORIGIN_RE = /^(?:https?:\/\/(?:[^@/]+@)?github\.com\/|git@github\.com:|ssh:\/\/git@github\.com[:/])([A-Za-z0-9][A-Za-z0-9._-]*)\/([A-Za-z0-9][A-Za-z0-9._-]*?)(?:\.git)?\/?\s*$/;
+export function inferRepoFromGit(cwd) {
+    try {
+        const stdout = execFileSync("git", ["remote", "get-url", "origin"], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const url = stdout.trim();
+        if (!url)
+            return null;
+        const m = GIT_ORIGIN_RE.exec(url);
+        if (!m)
+            return null;
+        return `${m[1]}/${m[2]}`;
+    }
+    catch {
+        return null;
+    }
+}
+function utcIso() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function newDecisionId() {
+    return randomUUID();
+}
+export function findReconcilable(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    const auditPath = options.auditLogPath ?? join(root, AUDIT_LOG_RELPATH);
+    const existing = existingAuditRefs(auditPath);
+    const defaultRepo = options.defaultRepo ?? null;
+    const items = [];
+    const seen = new Set();
+    for (const folderName of BACKFILL_FOLDERS) {
+        const folderPath = join(root, "vbrief", folderName);
+        for (const [refRepo, number, path] of scanLifecycleRefs(folderPath)) {
+            const effectiveRepo = refRepo ?? defaultRepo;
+            if (effectiveRepo === null)
+                continue;
+            const key = auditKey(effectiveRepo, number);
+            if (existing.has(key) || seen.has(key))
+                continue;
+            seen.add(key);
+            items.push({
+                repo: effectiveRepo,
+                issueNumber: number,
+                folder: folderName,
+                path,
+            });
+        }
+    }
+    return items;
+}
+function countSkippedExisting(projectRoot, defaultRepo, auditPath) {
+    const existing = existingAuditRefs(auditPath);
+    const counted = new Set();
+    let count = 0;
+    const root = resolve(projectRoot);
+    for (const folderName of BACKFILL_FOLDERS) {
+        for (const [refRepo, number] of scanLifecycleRefs(join(root, "vbrief", folderName))) {
+            const effectiveRepo = refRepo ?? defaultRepo;
+            if (effectiveRepo === null)
+                continue;
+            const key = auditKey(effectiveRepo, number);
+            if (existing.has(key) && !counted.has(key)) {
+                counted.add(key);
+                count += 1;
+            }
+        }
+    }
+    return count;
+}
+function countNoRepo(projectRoot, defaultRepo, auditPath) {
+    const existingNumbers = new Set();
+    for (const key of existingAuditRefs(auditPath)) {
+        const num = Number(key.split(":")[1]);
+        if (!Number.isNaN(num))
+            existingNumbers.add(num);
+    }
+    let count = 0;
+    const root = resolve(projectRoot);
+    for (const folderName of BACKFILL_FOLDERS) {
+        for (const [refRepo, number] of scanLifecycleRefs(join(root, "vbrief", folderName))) {
+            if ((refRepo ?? defaultRepo) === null && !existingNumbers.has(number))
+                count += 1;
+        }
+    }
+    return count;
+}
+function buildReconcileEntry(repo, issueNumber, sourceFolder) {
+    return {
+        decision_id: newDecisionId(),
+        timestamp: utcIso(),
+        repo,
+        issue_number: issueNumber,
+        decision: "accept",
+        actor: RECONCILE_ACTOR,
+        reason: `reconcile backfill (#1468): vBRIEF present in vbrief/${sourceFolder}/ ` +
+            "with a github-issue reference but no prior decision in the audit log",
+    };
+}
+function appendAuditEntry(auditPath, entry) {
+    mkdirSync(dirname(auditPath), { recursive: true });
+    appendFileSync(auditPath, `${JSON.stringify(entry)}\n`, "utf8");
+}
+export function reconcile(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    let defaultRepo = options.repo ?? null;
+    if (defaultRepo === null) {
+        defaultRepo = inferRepoFromGit(root);
+    }
+    const auditPath = options.auditLogPath ?? join(root, AUDIT_LOG_RELPATH);
+    const dryRun = options.dryRun ?? false;
+    const result = {
+        projectRoot: root,
+        defaultRepo,
+        restored: 0,
+        skippedExisting: countSkippedExisting(root, defaultRepo, auditPath),
+        skippedNoRepo: countNoRepo(root, defaultRepo, auditPath),
+        dryRun,
+        items: [],
+        error: null,
+        exitCode: 0,
+    };
+    const items = findReconcilable(root, { defaultRepo, auditLogPath: auditPath });
+    if (dryRun) {
+        return { ...result, items, restored: items.length };
+    }
+    let restored = 0;
+    for (const item of items) {
+        const entry = buildReconcileEntry(item.repo, item.issueNumber, item.folder);
+        try {
+            appendAuditEntry(auditPath, entry);
+        }
+        catch (err) {
+            return {
+                ...result,
+                error: `${err instanceof Error ? err.constructor.name : "Error"}: ${String(err)}`,
+                restored,
+                items: items.slice(0, restored),
+                exitCode: 1,
+            };
+        }
+        restored += 1;
+    }
+    return { ...result, restored, items };
+}
+export function countReconcilable(projectRoot, options = {}) {
+    const items = findReconcilable(projectRoot, options);
+    let keys = new Set(items.map((i) => auditKey(i.repo, i.issueNumber)));
+    if (options.restrictTo) {
+        const restrict = new Set([...options.restrictTo].map(([repo, num]) => auditKey(repo, num)));
+        keys = new Set([...keys].filter((k) => restrict.has(k)));
+    }
+    return keys.size;
+}
+//# sourceMappingURL=reconcile.js.map

package/dist/triage/reconcile/types.d.ts

@@ -0,0 +1,23 @@
+export declare const AUDIT_LOG_RELPATH = "vbrief/.eval/candidates.jsonl";
+export declare const BACKFILL_FOLDERS: readonly ["proposed", "pending", "active"];
+export declare const RECONCILE_ACTOR = "agent:reconcile";
+export interface ReconcileItem {
+    readonly repo: string;
+    readonly issueNumber: number;
+    readonly folder: string;
+    readonly path: string;
+}
+export interface ReconcileResult {
+    readonly projectRoot: string;
+    readonly defaultRepo: string | null;
+    readonly restored: number;
+    readonly skippedExisting: number;
+    readonly skippedNoRepo: number;
+    readonly dryRun: boolean;
+    readonly items: readonly ReconcileItem[];
+    readonly error: string | null;
+    readonly exitCode: 0 | 1 | 2;
+}
+export declare function reconcileSummary(result: ReconcileResult): string;
+export declare function emitReconcileJson(result: ReconcileResult): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/triage/reconcile/types.js

@@ -0,0 +1,70 @@
+export const AUDIT_LOG_RELPATH = "vbrief/.eval/candidates.jsonl";
+export const BACKFILL_FOLDERS = ["proposed", "pending", "active"];
+export const RECONCILE_ACTOR = "agent:reconcile";
+export function reconcileSummary(result) {
+    const verb = result.dryRun ? "would restore" : "restored";
+    const mark = result.exitCode === 0 ? "✓" : "✗";
+    const lines = ["", "Triage audit-log reconcile recap:"];
+    lines.push(`  ${mark} ${verb} ${result.restored} accept decision(s) from on-disk ` +
+        `vBRIEFs; skipped ${result.skippedExisting} (already in audit log)`);
+    if (result.skippedNoRepo > 0) {
+        lines.push(`      skipped ${result.skippedNoRepo} vBRIEF(s) with no ` +
+            "resolvable repo (no owner/name in the github-issue reference " +
+            "and no --repo / git remote fallback)");
+    }
+    if (result.error) {
+        lines.push(`      error: ${result.error}`);
+    }
+    if (result.items.length > 0) {
+        lines.push("");
+        lines.push("  Issues reconciled:");
+        for (const item of result.items) {
+            lines.push(`    #${item.issueNumber} (${item.repo}) <- vbrief/${item.folder}/`);
+        }
+    }
+    if (result.exitCode === 0 && result.items.length === 0 && !result.dryRun) {
+        lines.push("");
+        lines.push("  Nothing to reconcile -- the audit log already covers every in-scope vBRIEF.");
+    }
+    return lines.join("\n");
+}
+function pythonStyleJson(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number")
+        return String(value);
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => pythonStyleJson(item)).join(", ")}]`;
+    }
+    if (typeof value === "object") {
+        const keys = Object.keys(value).sort();
+        const body = keys
+            .map((key) => `${JSON.stringify(key)}: ${pythonStyleJson(value[key])}`)
+            .join(", ");
+        return `{${body}}`;
+    }
+    return "null";
+}
+export function emitReconcileJson(result) {
+    const payload = {
+        default_repo: result.defaultRepo,
+        dry_run: result.dryRun,
+        error: result.error,
+        exit_code: result.exitCode,
+        items: result.items.map((item) => ({
+            folder: item.folder,
+            issue_number: item.issueNumber,
+            repo: item.repo,
+        })),
+        project_root: result.projectRoot,
+        restored: result.restored,
+        skipped_existing: result.skippedExisting,
+        skipped_no_repo: result.skippedNoRepo,
+    };
+    return pythonStyleJson(payload);
+}
+//# sourceMappingURL=types.js.map

package/dist/triage/refresh/drift.d.ts

@@ -0,0 +1,15 @@
+import { type DriftRecord } from "./types.js";
+export type FetchLive = (repo: string, issueNumber: number) => string;
+export type CacheLoader = (repo: string, issueNumber: number, projectRoot: string) => string | null;
+/** Return true iff live timestamp postdates cached fetch. */
+export declare function isDrift(cachedFetchedAt: string | null, liveUpdatedAt: string): boolean;
+export declare function loadCachedFetchedAt(repo: string, issueNumber: number, projectRoot: string): string | null;
+export interface DetectDriftOptions {
+    readonly fetchLive?: FetchLive;
+    readonly cacheLoader?: CacheLoader;
+    readonly skippedOut?: Array<[string, number, string]>;
+    readonly checkedOut?: Array<[string, number]>;
+    readonly log?: (line: string) => void;
+}
+export declare function detectDrift(activeDir: string, projectRoot: string, options?: DetectDriftOptions): DriftRecord[];
+//# sourceMappingURL=drift.d.ts.map

package/dist/triage/refresh/drift.js

@@ -0,0 +1,72 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { extractIssueRefs, iterActiveVbriefs } from "./extract.js";
+import { CACHE_SOURCE } from "./types.js";
+/** Return true iff live timestamp postdates cached fetch. */
+export function isDrift(cachedFetchedAt, liveUpdatedAt) {
+    if (!liveUpdatedAt)
+        return false;
+    if (cachedFetchedAt === null)
+        return true;
+    return liveUpdatedAt > cachedFetchedAt;
+}
+export function loadCachedFetchedAt(repo, issueNumber, projectRoot) {
+    const key = `${repo}/${issueNumber}`;
+    const parts = key.split("/");
+    if (parts.length < 3)
+        return null;
+    const owner = parts[0];
+    const repoName = parts[1];
+    const num = parts[2];
+    const metaPath = join(projectRoot, ".deft-cache", CACHE_SOURCE, owner ?? "", repoName ?? "", num ?? "", "meta.json");
+    if (!existsSync(metaPath))
+        return null;
+    try {
+        const meta = JSON.parse(readFileSync(metaPath, "utf8"));
+        if (typeof meta !== "object" || meta === null || Array.isArray(meta))
+            return null;
+        const fetchedAt = meta.fetched_at;
+        return fetchedAt !== undefined && fetchedAt !== null ? String(fetchedAt) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function detectDrift(activeDir, projectRoot, options = {}) {
+    const fetchLive = options.fetchLive ?? (() => "");
+    const cacheLoader = options.cacheLoader ?? loadCachedFetchedAt;
+    const log = options.log ?? (() => { });
+    const drifts = [];
+    const seen = new Set();
+    for (const vbrief of iterActiveVbriefs(activeDir)) {
+        for (const [repo, num] of extractIssueRefs(vbrief)) {
+            const key = `${repo}#${num}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            options.checkedOut?.push([repo, num]);
+            const cached = cacheLoader(repo, num, projectRoot);
+            let live;
+            try {
+                live = fetchLive(repo, num);
+            }
+            catch (err) {
+                const reason = `${err instanceof Error ? err.constructor.name : "Error"}: ${String(err)}`;
+                log(`[triage:refresh-active] WARN: live fetch skipped for ${repo}#${num} (${reason})`);
+                options.skippedOut?.push([repo, num, reason]);
+                continue;
+            }
+            if (isDrift(cached, live)) {
+                drifts.push({
+                    repo,
+                    issueNumber: num,
+                    cachedFetchedAt: cached,
+                    liveUpdatedAt: live,
+                    vbriefPath: vbrief,
+                });
+            }
+        }
+    }
+    return drifts;
+}
+//# sourceMappingURL=drift.js.map

package/dist/triage/refresh/extract.d.ts

@@ -0,0 +1,3 @@
+export declare function iterActiveVbriefs(activeDir: string): string[];
+export declare function extractIssueRefs(vbriefPath: string): Array<[string, number]>;
+//# sourceMappingURL=extract.d.ts.map

package/dist/triage/refresh/extract.js

@@ -0,0 +1,43 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+const ISSUE_URL_RE = /github\.com\/([^/]+\/[^/]+)\/issues\/(\d+)/i;
+export function iterActiveVbriefs(activeDir) {
+    if (!existsSync(activeDir))
+        return [];
+    return readdirSync(activeDir)
+        .filter((name) => name.endsWith(".vbrief.json"))
+        .sort()
+        .map((name) => join(activeDir, name));
+}
+export function extractIssueRefs(vbriefPath) {
+    let data;
+    try {
+        data = JSON.parse(readFileSync(vbriefPath, "utf8"));
+    }
+    catch {
+        return [];
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data))
+        return [];
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+        return [];
+    const refs = plan.references;
+    if (!Array.isArray(refs))
+        return [];
+    const out = [];
+    for (const ref of refs) {
+        if (typeof ref !== "object" || ref === null || Array.isArray(ref))
+            continue;
+        const rec = ref;
+        if (rec.type !== "x-vbrief/github-issue")
+            continue;
+        const uri = String(rec.uri ?? "");
+        const match = ISSUE_URL_RE.exec(uri);
+        if (!match)
+            continue;
+        out.push([match[1] ?? "", Number(match[2])]);
+    }
+    return out;
+}
+//# sourceMappingURL=extract.js.map

package/dist/triage/refresh/index.d.ts

@@ -0,0 +1,5 @@
+export { type CacheLoader, type DetectDriftOptions, detectDrift, type FetchLive, isDrift, loadCachedFetchedAt, } from "./drift.js";
+export { extractIssueRefs, iterActiveVbriefs } from "./extract.js";
+export { type AuditWriter, type InputFn, type RefreshActiveOptions, type RefreshLocal, refreshActive, } from "./refresh.js";
+export { CACHE_SOURCE, type DriftRecord, type FreshnessSummary, PROMPT_OPTIONS, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/triage/refresh/index.js

@@ -0,0 +1,5 @@
+export { detectDrift, isDrift, loadCachedFetchedAt, } from "./drift.js";
+export { extractIssueRefs, iterActiveVbriefs } from "./extract.js";
+export { refreshActive, } from "./refresh.js";
+export { CACHE_SOURCE, PROMPT_OPTIONS, } from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/triage/refresh/refresh.d.ts

@@ -0,0 +1,16 @@
+import { type CacheLoader, type FetchLive } from "./drift.js";
+import { type FreshnessSummary } from "./types.js";
+export type InputFn = (prompt: string) => string;
+export type RefreshLocal = (repo: string, issueNumber: number, projectRoot: string) => void;
+export type AuditWriter = (repo: string, issueNumber: number, annotation: string) => void;
+export interface RefreshActiveOptions {
+    readonly activeDir?: string;
+    readonly inputFn?: InputFn;
+    readonly fetchLive?: FetchLive;
+    readonly cacheLoader?: CacheLoader;
+    readonly refreshLocal?: RefreshLocal;
+    readonly auditWriter?: AuditWriter;
+    readonly log?: (line: string) => void;
+}
+export declare function refreshActive(projectRoot: string, options?: RefreshActiveOptions): FreshnessSummary;
+//# sourceMappingURL=refresh.d.ts.map

package/dist/triage/refresh/refresh.js

@@ -0,0 +1,95 @@
+import { join, resolve } from "node:path";
+import { detectDrift } from "./drift.js";
+import { iterActiveVbriefs } from "./extract.js";
+import { PROMPT_OPTIONS } from "./types.js";
+function promptUser(drift, inputFn, log) {
+    log("");
+    log(`Drift detected for ${drift.repo}#${drift.issueNumber}:`);
+    log(`  cached fetched_at: ${JSON.stringify(drift.cachedFetchedAt)}`);
+    log(`  live   updatedAt:  ${JSON.stringify(drift.liveUpdatedAt)}`);
+    log(`  vBRIEF: ${drift.vbriefPath}`);
+    log("  1) proceed-with-stale");
+    log("  2) refresh-and-update-local");
+    log("  3) defer-from-this-batch");
+    const raw = inputFn("Choose [1/2/3]: ").trim();
+    return PROMPT_OPTIONS[raw] ?? "defer-from-this-batch";
+}
+function defaultAuditWriter(repo, issueNumber, annotation, log) {
+    log(`[triage:refresh-active] WARN: audit annotation for ${repo}#${issueNumber} not persisted -- candidates_log rejected the entry. The proceed-with-stale choice has been logged to stdout but the JSONL trail does not yet recognize 'freshness-annotation'.`);
+    void annotation;
+}
+export function refreshActive(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    const activeDir = options.activeDir ?? join(root, "vbrief", "active");
+    const log = options.log ?? ((line) => process.stdout.write(`${line}\n`));
+    const inputFn = options.inputFn ?? (() => "");
+    const refreshLocal = options.refreshLocal ?? (() => { });
+    const auditWriter = options.auditWriter ?? ((repo, num, ann) => defaultAuditWriter(repo, num, ann, log));
+    const activeFiles = iterActiveVbriefs(activeDir);
+    if (activeFiles.length === 0) {
+        log("[triage:refresh-active] vbrief/active/ is empty -- no-op");
+        return {
+            totalActive: 0,
+            driftsDetected: 0,
+            proceeded: [],
+            refreshed: [],
+            deferred: [],
+            skipped: [],
+        };
+    }
+    const skippedRecords = [];
+    const checkedPairs = [];
+    const drifts = detectDrift(activeDir, root, {
+        fetchLive: options.fetchLive,
+        cacheLoader: options.cacheLoader,
+        skippedOut: skippedRecords,
+        checkedOut: checkedPairs,
+        log,
+    });
+    const skippedPairs = skippedRecords.map(([repo, num]) => [repo, num]);
+    if (drifts.length === 0) {
+        if (skippedPairs.length > 0) {
+            log(`[triage:refresh-active] WARN: no drift detected, but ${skippedPairs.length} of ${checkedPairs.length} (repo, issue) fetch(es) were skipped (treat freshness signal as unverified)`);
+        }
+        else {
+            log(`[triage:refresh-active] all ${activeFiles.length} active vBRIEFs fresh`);
+        }
+        return {
+            totalActive: activeFiles.length,
+            driftsDetected: 0,
+            proceeded: [],
+            refreshed: [],
+            deferred: [],
+            skipped: skippedPairs,
+        };
+    }
+    const proceeded = [];
+    const refreshed = [];
+    const deferred = [];
+    for (const drift of drifts) {
+        const choice = promptUser(drift, inputFn, log);
+        if (choice === "proceed-with-stale") {
+            auditWriter(drift.repo, drift.issueNumber, `proceed-with-stale: cached_fetched_at=${drift.cachedFetchedAt} live_updated_at=${drift.liveUpdatedAt}`);
+            proceeded.push([drift.repo, drift.issueNumber]);
+            log(`[triage:refresh-active] ${drift.repo}#${drift.issueNumber} proceed-with-stale (audit recorded)`);
+        }
+        else if (choice === "refresh-and-update-local") {
+            refreshLocal(drift.repo, drift.issueNumber, root);
+            refreshed.push([drift.repo, drift.issueNumber]);
+            log(`[triage:refresh-active] ${drift.repo}#${drift.issueNumber} refreshed-and-updated-local`);
+        }
+        else {
+            deferred.push([drift.repo, drift.issueNumber]);
+            log(`[triage:refresh-active] ${drift.repo}#${drift.issueNumber} deferred-from-this-batch`);
+        }
+    }
+    return {
+        totalActive: activeFiles.length,
+        driftsDetected: drifts.length,
+        proceeded,
+        refreshed,
+        deferred,
+        skipped: skippedPairs,
+    };
+}
+//# sourceMappingURL=refresh.js.map

package/dist/triage/refresh/types.d.ts

@@ -0,0 +1,18 @@
+export interface DriftRecord {
+    readonly repo: string;
+    readonly issueNumber: number;
+    readonly cachedFetchedAt: string | null;
+    readonly liveUpdatedAt: string;
+    readonly vbriefPath: string;
+}
+export interface FreshnessSummary {
+    readonly totalActive: number;
+    readonly driftsDetected: number;
+    readonly proceeded: Array<[string, number]>;
+    readonly refreshed: Array<[string, number]>;
+    readonly deferred: Array<[string, number]>;
+    readonly skipped: Array<[string, number]>;
+}
+export declare const PROMPT_OPTIONS: Readonly<Record<string, string>>;
+export declare const CACHE_SOURCE = "github-issue";
+//# sourceMappingURL=types.d.ts.map

package/dist/triage/refresh/types.js

@@ -0,0 +1,7 @@
+export const PROMPT_OPTIONS = {
+    "1": "proceed-with-stale",
+    "2": "refresh-and-update-local",
+    "3": "defer-from-this-batch",
+};
+export const CACHE_SOURCE = "github-issue";
+//# sourceMappingURL=types.js.map

package/dist/triage/scope/cli.d.ts

@@ -0,0 +1,23 @@
+export interface ParsedCliArgs {
+    projectRoot: string;
+    doList: boolean;
+    refreshDenominator: boolean;
+    repo: string | undefined;
+    addLabel: string | undefined;
+    addMilestone: string | undefined;
+    ignoreLabel: string | undefined;
+    diffFromUpstream: boolean;
+    source: string;
+    cacheRoot: string | undefined;
+    count: number | undefined;
+}
+export declare function parseCliArgs(argv: string[]): ParsedCliArgs;
+export declare const CLI_HELP = "usage: triage_scope.py [-h] [--project-root PROJECT_ROOT] [--list]\n                       [--refresh-denominator] [--repo REPO]\n                       [--add-label ADD_LABEL] [--add-milestone ADD_MILESTONE]\n                       [--ignore-label IGNORE_LABEL] [--diff-from-upstream]\n                       [--source SOURCE] [--cache-root CACHE_ROOT]\n                       [--count COUNT]\n\nInspect, mutate, and diff the typed plan.policy.triageScope[] subscription +\nplan.policy.triageScopeIgnores[] (#1131 / D12, #1133 / D14, #1182 / D14c).\nRead paths never trigger a recompute; use --refresh-denominator to update the\ncoverage cache. Mutation flags --add-label / --add-milestone / --ignore-label\nare idempotent and atomic; every mutation appends a subscription-change audit\nentry to vbrief/.eval/subscription-history.jsonl.\n";
+/** Run triage:scope CLI; returns exit code and captured output for parity. */
+export declare function runCliCapture(argv: string[]): {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function run(argv: string[]): number;
+//# sourceMappingURL=cli.d.ts.map