@deftai/directive-core 0.55.0

package/dist/triage/summary/scope-drift.js

@@ -0,0 +1,219 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadProjectDefinition } from "../../policy/resolve.js";
+const DRIFT_MIN_ISSUES = 3;
+const CACHE_SOURCE = "github-issue";
+function isPosIntDirName(name) {
+    if (name.length === 0) {
+        return false;
+    }
+    for (const ch of name) {
+        if (ch < "0" || ch > "9") {
+            return false;
+        }
+    }
+    return true;
+}
+function iterCacheIssues(cacheRoot) {
+    const base = join(cacheRoot, CACHE_SOURCE);
+    if (!existsSync(base)) {
+        return [];
+    }
+    const out = [];
+    for (const ownerEntry of readdirSync(base, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+        if (!ownerEntry.isDirectory()) {
+            continue;
+        }
+        const ownerDir = join(base, ownerEntry.name);
+        for (const repoEntry of readdirSync(ownerDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            if (!repoEntry.isDirectory()) {
+                continue;
+            }
+            const repo = `${ownerEntry.name}/${repoEntry.name}`;
+            const repoDir = join(ownerDir, repoEntry.name);
+            const issueDirs = readdirSync(repoDir, { withFileTypes: true })
+                .filter((e) => e.isDirectory() && isPosIntDirName(e.name))
+                .sort((a, b) => Number.parseInt(a.name, 10) - Number.parseInt(b.name, 10));
+            for (const issueEntry of issueDirs) {
+                const number = Number.parseInt(issueEntry.name, 10);
+                const rawPath = join(repoDir, issueEntry.name, "raw.json");
+                if (!existsSync(rawPath)) {
+                    continue;
+                }
+                try {
+                    const raw = JSON.parse(readFileSync(rawPath, { encoding: "utf8" }));
+                    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+                        continue;
+                    }
+                    const obj = raw;
+                    const state = typeof obj.state === "string" ? obj.state : "open";
+                    const labels = [];
+                    if (Array.isArray(obj.labels)) {
+                        for (const label of obj.labels) {
+                            if (typeof label === "string") {
+                                labels.push(label);
+                            }
+                            else if (typeof label === "object" &&
+                                label !== null &&
+                                !Array.isArray(label) &&
+                                typeof label.name === "string") {
+                                labels.push(label.name);
+                            }
+                        }
+                    }
+                    let milestone = null;
+                    const ms = obj.milestone;
+                    if (typeof ms === "object" && ms !== null && !Array.isArray(ms)) {
+                        const title = ms.title;
+                        if (typeof title === "string") {
+                            milestone = title;
+                        }
+                    }
+                    out.push({ repo, number, state, labels, milestone });
+                }
+                catch {
+                    // skip unreadable raw.json
+                }
+            }
+        }
+    }
+    return out;
+}
+function resolveScopeRules(projectRoot) {
+    const [data] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return [{ rule: "all-open" }];
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return [{ rule: "all-open" }];
+    }
+    const policy = plan.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        return [{ rule: "all-open" }];
+    }
+    const scope = policy.triageScope;
+    if (!Array.isArray(scope) || scope.length === 0) {
+        return [{ rule: "all-open" }];
+    }
+    const rules = [];
+    for (const rule of scope) {
+        if (typeof rule === "object" && rule !== null && !Array.isArray(rule)) {
+            rules.push(rule);
+        }
+    }
+    return rules.length > 0 ? rules : [{ rule: "all-open" }];
+}
+function subscribedLabels(rules) {
+    const out = new Set();
+    for (const rule of rules) {
+        if (rule.rule !== "labels") {
+            continue;
+        }
+        const anyOf = rule["any-of"];
+        if (Array.isArray(anyOf)) {
+            for (const label of anyOf) {
+                if (typeof label === "string") {
+                    out.add(label);
+                }
+            }
+        }
+    }
+    return out;
+}
+function subscribedMilestones(rules) {
+    const out = new Set();
+    for (const rule of rules) {
+        if (rule.rule !== "milestone") {
+            continue;
+        }
+        const name = rule.name;
+        if (typeof name === "string") {
+            out.add(name);
+        }
+    }
+    return out;
+}
+/**
+ * Compute scope-drift total (#1133) — mirrors `triage_scope_drift.compute_drift().total`.
+ */
+export function computeScopeDriftTotal(projectRoot, cacheRoot) {
+    try {
+        const issues = iterCacheIssues(cacheRoot);
+        const rules = resolveScopeRules(projectRoot);
+        if (rules.some((r) => r.rule === "all-open")) {
+            return 0;
+        }
+        const subscribedLabelsSet = subscribedLabels(rules);
+        const subscribedMilestonesSet = subscribedMilestones(rules);
+        const labelCounts = new Map();
+        const milestoneCounts = new Map();
+        const surfacedIssues = new Set();
+        for (const issue of issues) {
+            if (issue.state !== "open") {
+                continue;
+            }
+            const issueKey = `${issue.repo}\0${issue.number}`;
+            for (const label of issue.labels) {
+                if (subscribedLabelsSet.has(label)) {
+                    continue;
+                }
+                labelCounts.set(label, (labelCounts.get(label) ?? 0) + 1);
+            }
+            if (issue.milestone !== null && !subscribedMilestonesSet.has(issue.milestone)) {
+                milestoneCounts.set(issue.milestone, (milestoneCounts.get(issue.milestone) ?? 0) + 1);
+            }
+            for (const [label, count] of labelCounts) {
+                if (count >= DRIFT_MIN_ISSUES && issue.labels.includes(label)) {
+                    surfacedIssues.add(issueKey);
+                }
+            }
+            if (issue.milestone !== null) {
+                const msCount = milestoneCounts.get(issue.milestone) ?? 0;
+                if (msCount >= DRIFT_MIN_ISSUES && !subscribedMilestonesSet.has(issue.milestone)) {
+                    surfacedIssues.add(issueKey);
+                }
+            }
+        }
+        const surfacedLabels = new Set();
+        const surfacedMilestones = new Set();
+        for (const [label, count] of labelCounts) {
+            if (count >= DRIFT_MIN_ISSUES) {
+                surfacedLabels.add(label);
+            }
+        }
+        for (const [ms, count] of milestoneCounts) {
+            if (count >= DRIFT_MIN_ISSUES) {
+                surfacedMilestones.add(ms);
+            }
+        }
+        const distinct = new Set();
+        for (const issue of issues) {
+            if (issue.state !== "open") {
+                continue;
+            }
+            const issueKey = `${issue.repo}\0${issue.number}`;
+            let surfaced = false;
+            for (const label of issue.labels) {
+                if (surfacedLabels.has(label) && !subscribedLabelsSet.has(label)) {
+                    surfaced = true;
+                    break;
+                }
+            }
+            if (!surfaced &&
+                issue.milestone !== null &&
+                surfacedMilestones.has(issue.milestone) &&
+                !subscribedMilestonesSet.has(issue.milestone)) {
+                surfaced = true;
+            }
+            if (surfaced) {
+                distinct.add(issueKey);
+            }
+        }
+        return distinct.size;
+    }
+    catch {
+        return 0;
+    }
+}
+//# sourceMappingURL=scope-drift.js.map

package/dist/triage/welcome/constants.d.ts

@@ -0,0 +1,24 @@
+export declare const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
+export declare const CACHE_DIR_NAME = ".deft-cache";
+export declare const CACHE_SOURCE = "github-issue";
+export declare const CANDIDATES_RELPATH: readonly ["vbrief", ".eval", "candidates.jsonl"];
+export declare const WIP_LIFECYCLE_DIRS: readonly ["pending", "active"];
+export declare const AUDIT_LOG_REL_PATH = "meta/policy-changes.log";
+export declare const DEFAULT_WIP_CAP = 10;
+export declare const DEFAULT_RELIEF_AGE_DAYS = 30;
+export declare const TRIAGE_SKILL_PATH = "skills/deft-directive-triage/SKILL.md";
+export declare const WELCOME_AUDIT_TAG = "triage-welcome";
+export declare const SUMMARY_HISTORY_REL_PATH = "vbrief/.eval/summary-history.jsonl";
+export declare const SUMMARY_HISTORY_SCHEMA = "deft.triage.summary.v1";
+export declare const EMPTY_CACHE_LINE = "[triage] cache empty -- run task triage:bootstrap";
+export declare const MAX_LINE_CHARS = 120;
+export declare const WIP_WARN_GLYPH = "\u26A0";
+export declare const FIRST_TIME_NUDGE = "[welcome] First-time? Run `deft triage:welcome --onboard` to set up triage.";
+export declare const INCOMPLETE_NUDGE_TEMPLATE = "[welcome] Onboarding incomplete: {missing}. Run `deft triage:welcome --onboard` to resume.";
+export declare const SUBSCRIPTION_PRESETS: Readonly<Record<string, ReadonlyArray<Record<string, unknown>>>>;
+export declare const BOOTSTRAP_ACTION_RAN = "ran";
+export declare const BOOTSTRAP_ACTION_SKIPPED_ALREADY_BOOTSTRAPPED = "skipped:already-bootstrapped";
+export declare const BOOTSTRAP_ACTION_SKIPPED_DECLINED = "skipped:declined";
+export declare const BOOTSTRAP_ACTION_SKIPPED_DRY_MODE = "skipped:dry-mode";
+export declare const DEFAULT_PENDING_DECISIONS_THRESHOLD = 3;
+//# sourceMappingURL=constants.d.ts.map

package/dist/triage/welcome/constants.js

@@ -0,0 +1,34 @@
+export const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
+export const CACHE_DIR_NAME = ".deft-cache";
+export const CACHE_SOURCE = "github-issue";
+export const CANDIDATES_RELPATH = ["vbrief", ".eval", "candidates.jsonl"];
+export const WIP_LIFECYCLE_DIRS = ["pending", "active"];
+export const AUDIT_LOG_REL_PATH = "meta/policy-changes.log";
+export const DEFAULT_WIP_CAP = 10;
+export const DEFAULT_RELIEF_AGE_DAYS = 30;
+export const TRIAGE_SKILL_PATH = "skills/deft-directive-triage/SKILL.md";
+export const WELCOME_AUDIT_TAG = "triage-welcome";
+export const SUMMARY_HISTORY_REL_PATH = "vbrief/.eval/summary-history.jsonl";
+export const SUMMARY_HISTORY_SCHEMA = "deft.triage.summary.v1";
+export const EMPTY_CACHE_LINE = "[triage] cache empty -- run task triage:bootstrap";
+export const MAX_LINE_CHARS = 120;
+export const WIP_WARN_GLYPH = "\u26a0";
+export const FIRST_TIME_NUDGE = "[welcome] First-time? Run `deft triage:welcome --onboard` to set up triage.";
+export const INCOMPLETE_NUDGE_TEMPLATE = "[welcome] Onboarding incomplete: {missing}. Run `deft triage:welcome --onboard` to resume.";
+export const SUBSCRIPTION_PRESETS = {
+    small: [{ rule: "all-open" }],
+    mid: [
+        { rule: "labels", "any-of": ["urgent", "breaking", "security", "p0", "p1"] },
+        { rule: "opened-since", duration: "60d" },
+    ],
+    mega: [
+        { rule: "explicit-watch", issues: [] },
+        { rule: "referenced-by-vbrief", scope: "active" },
+    ],
+};
+export const BOOTSTRAP_ACTION_RAN = "ran";
+export const BOOTSTRAP_ACTION_SKIPPED_ALREADY_BOOTSTRAPPED = "skipped:already-bootstrapped";
+export const BOOTSTRAP_ACTION_SKIPPED_DECLINED = "skipped:declined";
+export const BOOTSTRAP_ACTION_SKIPPED_DRY_MODE = "skipped:dry-mode";
+export const DEFAULT_PENDING_DECISIONS_THRESHOLD = 3;
+//# sourceMappingURL=constants.js.map

package/dist/triage/welcome/default-mode.d.ts

@@ -0,0 +1,21 @@
+export interface WelcomeOutcome {
+    phasesRun: number[];
+    phasesSkipped: number[];
+    subscriptionChoice: string | null;
+    wipCapChoice: number | null;
+    reliefOffered: boolean;
+    reliefConfirmed: boolean;
+    discussedAtPhase: number | null;
+    exitCode: number;
+    bootstrapAction: string | null;
+}
+export declare function normalizeTaskPrefix(taskPrefix?: string | null): string;
+export declare function formatWelcomeCommand(args: string[], taskPrefix?: string | null): string;
+export interface DefaultModeOptions {
+    readonly output?: (line: string) => void;
+    readonly writeHistory?: boolean;
+    readonly taskPrefix?: string | null;
+}
+/** Non-interactive default mode (#1309). */
+export declare function runDefaultMode(projectRoot: string, options?: DefaultModeOptions): WelcomeOutcome;
+//# sourceMappingURL=default-mode.d.ts.map

package/dist/triage/welcome/default-mode.js

@@ -0,0 +1,48 @@
+import { resolve } from "node:path";
+import { FIRST_TIME_NUDGE, INCOMPLETE_NUDGE_TEMPLATE } from "./constants.js";
+import { classifyOnboarding, detectPriorState } from "./prior-state.js";
+import { emitOneliner } from "./summary.js";
+export function normalizeTaskPrefix(taskPrefix) {
+    const prefix = (taskPrefix ?? "").trim();
+    if (prefix && !prefix.endsWith(":"))
+        return `${prefix}:`;
+    return prefix;
+}
+export function formatWelcomeCommand(args, taskPrefix) {
+    const prefix = normalizeTaskPrefix(taskPrefix);
+    const canonical = `deft ${args.join(" ")}`;
+    if (!prefix)
+        return canonical;
+    return `task ${prefix}${args[0] ?? ""}${args.length > 1 ? ` ${args.slice(1).join(" ")}` : ""}`;
+}
+/** Non-interactive default mode (#1309). */
+export function runDefaultMode(projectRoot, options = {}) {
+    const out = options.output ?? ((line) => process.stdout.write(`${line}\n`));
+    const outcome = {
+        phasesRun: [0],
+        phasesSkipped: [],
+        subscriptionChoice: null,
+        wipCapChoice: null,
+        reliefOffered: false,
+        reliefConfirmed: false,
+        discussedAtPhase: null,
+        exitCode: 0,
+        bootstrapAction: null,
+    };
+    emitOneliner(projectRoot, {
+        writeHistory: options.writeHistory !== false,
+        output: out,
+    });
+    const state = detectPriorState(projectRoot);
+    const [label, missing] = classifyOnboarding(state);
+    const canonicalOnboard = "deft triage:welcome --onboard";
+    const onboardCommand = formatWelcomeCommand(["triage:welcome", "--onboard"], options.taskPrefix);
+    if (label === "first-time") {
+        out(FIRST_TIME_NUDGE.replace(canonicalOnboard, onboardCommand));
+    }
+    else if (label === "incomplete") {
+        out(INCOMPLETE_NUDGE_TEMPLATE.replace("{missing}", missing.join(" + ")).replace(canonicalOnboard, onboardCommand));
+    }
+    return outcome;
+}
+//# sourceMappingURL=default-mode.js.map

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

@@ -0,0 +1,6 @@
+export * from "./constants.js";
+export { type DefaultModeOptions, formatWelcomeCommand, normalizeTaskPrefix, runDefaultMode, type WelcomeOutcome, } from "./default-mode.js";
+export { candidatesLogPath, classifyOnboarding, detectPriorState, type PriorState, pendingDecisionsNudgeLine, } from "./prior-state.js";
+export { computeSummary, emitOneliner, formatOneLiner, formatSummary, type SummaryResult, } from "./summary.js";
+export { appendAuditEntry, previewWipRelief, type ReliefPreview, subscriptionPreset, writeTriageScope, writeWipCap, } from "./writers.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/triage/welcome/index.js

@@ -0,0 +1,6 @@
+export * from "./constants.js";
+export { formatWelcomeCommand, normalizeTaskPrefix, runDefaultMode, } from "./default-mode.js";
+export { candidatesLogPath, classifyOnboarding, detectPriorState, pendingDecisionsNudgeLine, } from "./prior-state.js";
+export { computeSummary, emitOneliner, formatOneLiner, formatSummary, } from "./summary.js";
+export { appendAuditEntry, previewWipRelief, subscriptionPreset, writeTriageScope, writeWipCap, } from "./writers.js";
+//# sourceMappingURL=index.js.map

package/dist/triage/welcome/prior-state.d.ts

@@ -0,0 +1,17 @@
+export interface PriorState {
+    readonly triageScopeSet: boolean;
+    readonly triageScopeSummary: string;
+    readonly cacheEmpty: boolean;
+    readonly cacheEntryCount: number;
+    readonly wipCapSet: boolean;
+    readonly wipCap: number;
+    readonly wipCount: number;
+    readonly auditLogPresent: boolean;
+    readonly pendingDecisions: number;
+}
+export declare function candidatesLogPath(projectRoot: string): string;
+export declare function pendingDecisionsNudgeLine(count: number, threshold?: number): string;
+/** Read every Phase 1 probe in one pass. Pure — no writes. */
+export declare function detectPriorState(projectRoot: string): PriorState;
+export declare function classifyOnboarding(state: PriorState): [string, string[]];
+//# sourceMappingURL=prior-state.d.ts.map

package/dist/triage/welcome/prior-state.js

@@ -0,0 +1,170 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { CACHE_DIR_NAME, CACHE_SOURCE, CANDIDATES_RELPATH, DEFAULT_WIP_CAP, SUBSCRIPTION_PRESETS, WIP_LIFECYCLE_DIRS, } from "./constants.js";
+function loadProjectDefinition(projectRoot) {
+    const path = join(resolve(projectRoot), "vbrief", "PROJECT-DEFINITION.vbrief.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(path, "utf8"));
+        return typeof data === "object" && data !== null && !Array.isArray(data)
+            ? data
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function countCacheEntries(projectRoot) {
+    const base = join(resolve(projectRoot), CACHE_DIR_NAME, CACHE_SOURCE);
+    if (!existsSync(base))
+        return 0;
+    let count = 0;
+    for (const ownerDir of readdirSync(base, { withFileTypes: true })) {
+        if (!ownerDir.isDirectory())
+            continue;
+        const ownerPath = join(base, ownerDir.name);
+        for (const repoDir of readdirSync(ownerPath, { withFileTypes: true })) {
+            if (!repoDir.isDirectory())
+                continue;
+            const repoPath = join(ownerPath, repoDir.name);
+            for (const entry of readdirSync(repoPath, { withFileTypes: true })) {
+                if (entry.isDirectory() && /^\d+$/.test(entry.name))
+                    count += 1;
+            }
+        }
+    }
+    return count;
+}
+export function candidatesLogPath(projectRoot) {
+    return join(resolve(projectRoot), ...CANDIDATES_RELPATH);
+}
+function countWip(projectRoot) {
+    let total = 0;
+    const root = join(resolve(projectRoot), "vbrief");
+    for (const sub of WIP_LIFECYCLE_DIRS) {
+        const folder = join(root, sub);
+        if (!existsSync(folder))
+            continue;
+        for (const child of readdirSync(folder, { withFileTypes: true })) {
+            if (child.isFile() && child.name.endsWith(".vbrief.json"))
+                total += 1;
+        }
+    }
+    return total;
+}
+function summarizeScope(rules) {
+    if (!rules || rules.length === 0) {
+        return [false, "unset (default applied -- all-open)"];
+    }
+    const small = SUBSCRIPTION_PRESETS.small;
+    if (JSON.stringify(rules) === JSON.stringify(small)) {
+        return [true, "Small (all-open)"];
+    }
+    const mid = SUBSCRIPTION_PRESETS.mid;
+    if (JSON.stringify(rules) === JSON.stringify(mid)) {
+        return [true, "Mid (curated labels + opened-since 60d)"];
+    }
+    const megaBaseline = SUBSCRIPTION_PRESETS.mega?.map((r) => ({ ...r })) ?? [];
+    if (rules.length === megaBaseline.length) {
+        let match = true;
+        for (let i = 0; i < rules.length; i += 1) {
+            if (rules[i]?.rule !== megaBaseline[i]?.rule) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            return [true, "Mega (explicit-watch + referenced-by-vbrief)"];
+    }
+    return [true, `custom (${rules.length} rule(s))`];
+}
+function countPendingDecisions(projectRoot) {
+    const logPath = join(resolve(projectRoot), "vbrief", ".audit", "pending-human-decisions.jsonl");
+    if (!existsSync(logPath))
+        return 0;
+    let text;
+    try {
+        text = readFileSync(logPath, "utf8");
+    }
+    catch {
+        return 0;
+    }
+    const latest = new Map();
+    for (const raw of text.split("\n")) {
+        const stripped = raw.trim();
+        if (!stripped)
+            continue;
+        try {
+            const event = JSON.parse(stripped);
+            const id = event.decision_id;
+            if (typeof id === "string" && id)
+                latest.set(id, event);
+        }
+        catch { }
+    }
+    let pending = 0;
+    for (const event of latest.values()) {
+        if (event.status === "pending")
+            pending += 1;
+    }
+    return pending;
+}
+export function pendingDecisionsNudgeLine(count, threshold = 3) {
+    if (count <= threshold)
+        return "";
+    return (`[TIER-1] pending human-clearance backlog: ${count} decision(s) ` +
+        `awaiting adjudication (> threshold ${threshold}). Tune wipCap to real ` +
+        "review throughput or clear the backlog before dispatching more work.");
+}
+/** Read every Phase 1 probe in one pass. Pure — no writes. */
+export function detectPriorState(projectRoot) {
+    const data = loadProjectDefinition(projectRoot) ?? {};
+    const plan = data.plan;
+    const policy = typeof plan === "object" && plan !== null && !Array.isArray(plan)
+        ? plan.policy
+        : null;
+    const rawScope = typeof policy === "object" && policy !== null && !Array.isArray(policy)
+        ? policy.triageScope
+        : null;
+    const scopeRules = Array.isArray(rawScope)
+        ? rawScope.filter((r) => typeof r === "object" && r !== null && !Array.isArray(r))
+        : null;
+    let wipCap = DEFAULT_WIP_CAP;
+    let wipCapSet = false;
+    if (typeof policy === "object" && policy !== null && !Array.isArray(policy)) {
+        const rawCap = policy.wipCap;
+        if (typeof rawCap === "number" && Number.isInteger(rawCap) && rawCap >= 0) {
+            wipCap = rawCap;
+            wipCapSet = true;
+        }
+    }
+    const [scopeSet, scopeLabel] = summarizeScope(scopeRules);
+    const cacheCount = countCacheEntries(projectRoot);
+    return {
+        triageScopeSet: scopeSet,
+        triageScopeSummary: scopeLabel,
+        cacheEmpty: cacheCount === 0,
+        cacheEntryCount: cacheCount,
+        wipCapSet,
+        wipCap,
+        wipCount: countWip(projectRoot),
+        auditLogPresent: existsSync(candidatesLogPath(projectRoot)),
+        pendingDecisions: countPendingDecisions(projectRoot),
+    };
+}
+export function classifyOnboarding(state) {
+    const signals = {
+        "candidates.jsonl": state.auditLogPresent,
+        triageScope: state.triageScopeSet,
+        wipCap: state.wipCapSet,
+    };
+    const present = Object.keys(signals).filter((k) => signals[k]);
+    const missing = Object.keys(signals).filter((k) => !signals[k]);
+    if (present.length === 0)
+        return ["first-time", missing];
+    if (missing.length === 0)
+        return ["fully-set-up", []];
+    return ["incomplete", missing];
+}
+//# sourceMappingURL=prior-state.js.map

package/dist/triage/welcome/summary.d.ts

@@ -0,0 +1,23 @@
+export interface SummaryResult {
+    readonly cacheEmpty: boolean;
+    readonly untriaged: number;
+    readonly staleDefer: number;
+    readonly inFlight: number;
+    readonly wipCount: number;
+    readonly wipCap: number;
+    readonly repos: readonly string[];
+    readonly scopeDrift: number;
+    readonly inFlightFilesystem: number;
+    readonly inFlightCacheScoped: number;
+    readonly triageScopeConfigured: boolean;
+    readonly reconcilable: number;
+}
+export declare function computeSummary(projectRoot: string): SummaryResult;
+export declare function formatOneLiner(result: SummaryResult, maxChars?: number): string;
+export declare function formatSummary(result: SummaryResult, maxChars?: number): string;
+export declare function appendHistory(historyPath: string, result: SummaryResult, line: string): void;
+export declare function emitOneliner(projectRoot: string, options?: {
+    writeHistory?: boolean;
+    output?: (line: string) => void;
+}): string;
+//# sourceMappingURL=summary.d.ts.map