@latysh-development/monolith 0.0.0-stage → 0.1.0-alpha.0

package/dist/brief/freshness.js

@@ -0,0 +1,263 @@
+/**
+ * Project State Freshness (SELF-AWARENESS-001).
+ *
+ * `Completeness` says whether the brief lost data while being rendered.
+ * `Freshness` says whether the recorded project state can still be trusted.
+ * They are independent: `Completeness: COMPLETE` + `Freshness: STALE` is a
+ * valid combination, and nothing here ever changes `Completeness`.
+ *
+ * `evaluateFreshness()` is pure: it takes already-gathered evidence and
+ * returns a verdict. Git is a signal, never the only source of truth:
+ *
+ *   STALE    only on a concrete, named discrepancy — either the state
+ *            documents contradict each other, or git history references
+ *            work items that no state document mentions.
+ *   FRESH    only on positive evidence — git is readable, the last state
+ *            update is located, and every commit after it either touches
+ *            only the state documents or belongs to a recorded work item.
+ *   UNKNOWN  everything else. Git activity alone, an old date alone, or the
+ *            absence of an active story alone never produce STALE, and the
+ *            absence of an active story never means "project complete".
+ */
+// ---------------------------------------------------------------------------
+// Work-item ids
+// ---------------------------------------------------------------------------
+/**
+ * Work-item id: an upper-case, dash-separated prefix, a number, then optional
+ * sub-story qualifiers — UI-002D, SEC-001B.1-R, LOCK-RELEASE-001, CONTEXT-001A.
+ * Deliberately narrow: an id that is not matched is simply not evidence.
+ */
+const WORK_ITEM_SOURCE = String.raw `(?:[A-Z]{2,}-)+\d{3}[A-Z]?(?:\.\d+)*(?:-[A-Z])?`;
+/** Decision / lesson records are not work items. */
+const NON_WORK_PREFIXES = ['ADR-', 'DEC-', 'LESSON-'];
+function isWorkItem(id) {
+    return !NON_WORK_PREFIXES.some((p) => id.startsWith(p));
+}
+export function extractWorkItemIds(text) {
+    const re = new RegExp(`(?<![A-Za-z0-9-])${WORK_ITEM_SOURCE}(?![A-Za-z0-9]|\\.\\d|-[A-Z0-9])`, 'g');
+    const seen = new Set();
+    for (const m of text.matchAll(re)) {
+        if (isWorkItem(m[0]))
+            seen.add(m[0]);
+    }
+    return [...seen];
+}
+export function mentionsId(text, id) {
+    const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`(?<![A-Za-z0-9-])${escaped}(?![A-Za-z0-9]|\\.\\d|-[A-Z0-9])`).test(text);
+}
+// ---------------------------------------------------------------------------
+// Parsers for the state documents (confirmed structure only)
+// ---------------------------------------------------------------------------
+const NONE_RE = /^\W*(?:no active story|none|unknown)\b|^\s*[—-]\s*$/i;
+/** Interprets the `## Current Story` excerpt of active.md. */
+export function parseActiveStoryClaim(excerpt) {
+    if (excerpt === null)
+        return { kind: 'unknown' };
+    const firstLine = excerpt.split('\n').find((l) => l.trim() !== '') ?? '';
+    if (/^\W*no active story\b/i.test(firstLine))
+        return { kind: 'none' };
+    const ids = extractWorkItemIds(excerpt);
+    return ids.length > 0 ? { kind: 'ids', ids } : { kind: 'unknown' };
+}
+/** `Active Story: <text>` line of roadmap-index.md. */
+export function parseRoadmapActiveStory(content) {
+    const m = /^Active Story:\s*(.+?)\s*$/m.exec(content);
+    return m ? m[1] : null;
+}
+/** Table rows `| id | title | STATUS | date |` of roadmap-index.md. */
+export function parseRoadmapStatuses(content) {
+    const out = new Map();
+    for (const line of content.split('\n')) {
+        const cells = line.split('|').map((c) => c.trim());
+        // leading and trailing '|' produce empty first/last cells
+        if (cells.length < 5 || cells[0] !== '' || cells[cells.length - 1] !== '')
+            continue;
+        const id = cells[1];
+        const status = cells[3];
+        if (!/^[A-Za-z0-9][A-Za-z0-9.\-]*$/.test(id) || !/^[A-Z][A-Z _]+$/.test(status))
+            continue;
+        if (!out.has(id))
+            out.set(id, status);
+    }
+    return out;
+}
+/** `### [STORY ]<id> — title` followed by `**Status:** X` in story-index.md. */
+export function parseStoryIndexStatuses(content) {
+    const out = new Map();
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const h = /^###\s+(?:STORY\s+)?([A-Za-z0-9][A-Za-z0-9.\-]*)\s+—/.exec(lines[i]);
+        if (!h)
+            continue;
+        for (let j = i + 1; j < Math.min(lines.length, i + 6); j++) {
+            if (/^#{1,3}\s/.test(lines[j]))
+                break;
+            const s = /^\*\*Status:\*\*\s*([A-Z][A-Z _]*)/.exec(lines[j]);
+            if (s) {
+                if (!out.has(h[1]))
+                    out.set(h[1], s[1].trim());
+                break;
+            }
+        }
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Evaluation
+// ---------------------------------------------------------------------------
+const MAX_LISTED = 5;
+function listIds(ids) {
+    if (ids.length <= MAX_LISTED)
+        return ids.join(', ');
+    return `${ids.slice(0, MAX_LISTED).join(', ')} and ${ids.length - MAX_LISTED} more`;
+}
+function isDone(status) {
+    return status === 'COMPLETED' || status === 'DONE';
+}
+function findContradictions(ev) {
+    const out = [];
+    if (ev.activeStory.kind === 'none' && ev.roadmapActiveStory !== null && !NONE_RE.test(ev.roadmapActiveStory)) {
+        out.push({
+            message: `active.md records no active story, but roadmap-index.md names "${ev.roadmapActiveStory}".`,
+            documents: ['active.md', 'roadmap-index.md'],
+        });
+    }
+    if (ev.activeStory.kind === 'ids') {
+        for (const id of ev.activeStory.ids) {
+            if (isDone(ev.roadmapStatuses.get(id))) {
+                out.push({
+                    message: `active.md treats ${id} as current, but roadmap-index.md marks it ${ev.roadmapStatuses.get(id)}.`,
+                    documents: ['active.md', 'roadmap-index.md'],
+                });
+            }
+            else if (isDone(ev.storyIndexStatuses.get(id))) {
+                out.push({
+                    message: `active.md treats ${id} as current, but story-index.md marks it ${ev.storyIndexStatuses.get(id)}.`,
+                    documents: ['active.md', 'story-index.md'],
+                });
+            }
+        }
+    }
+    for (const [id, roadmapStatus] of ev.roadmapStatuses) {
+        const indexStatus = ev.storyIndexStatuses.get(id);
+        if (indexStatus !== undefined && indexStatus !== roadmapStatus) {
+            out.push({
+                message: `${id} is ${roadmapStatus} in roadmap-index.md but ${indexStatus} in story-index.md.`,
+                documents: ['roadmap-index.md', 'story-index.md'],
+            });
+        }
+    }
+    return out;
+}
+const REVIEW_RECOMMENDATION = 'Review project state before relying on this brief.';
+export function evaluateFreshness(ev) {
+    const reasons = [];
+    const warnings = [];
+    const base = {
+        activeStory: ev.activeStory.kind === 'none' ? 'none-recorded' : ev.activeStory.kind === 'ids' ? 'recorded' : 'unknown',
+        lastStateUpdate: ev.git.status === 'ok' ? ev.git.lastStateUpdate : null,
+        activityCount: null,
+        unrecordedWork: [],
+    };
+    // 1. Internal contradictions need no git at all.
+    const contradictions = findContradictions(ev);
+    for (const c of contradictions)
+        reasons.push({ code: 'STATE_CONTRADICTION', message: c.message, documents: c.documents });
+    // 2. Git-derived signals.
+    let gitVerdict = null;
+    if (ev.git.status === 'unavailable') {
+        const why = {
+            GIT_NOT_INSTALLED: 'git is not installed or not runnable',
+            NOT_A_GIT_REPOSITORY: 'the project is not inside a git repository',
+            GIT_FAILED: 'git could not be queried',
+        };
+        reasons.push({ code: 'GIT_UNAVAILABLE', message: `Cannot compare state with history: ${why[ev.git.reason]}.` });
+        gitVerdict = 'unknown';
+    }
+    else if (ev.git.lastStateUpdate === null) {
+        reasons.push({
+            code: 'STATE_NOT_IN_GIT',
+            message: 'No commit touches the state documents, so the last state update cannot be located.',
+        });
+        gitVerdict = 'unknown';
+    }
+    else {
+        const activity = ev.git.commitsSince.filter((c) => c.files.some((f) => !ev.stateFiles.has(f)));
+        base.activityCount = activity.length;
+        const referenced = new Set();
+        let unattributed = 0;
+        for (const c of activity) {
+            const ids = extractWorkItemIds(c.subject);
+            if (ids.length === 0)
+                unattributed++;
+            for (const id of ids)
+                referenced.add(id);
+        }
+        const unrecorded = [...referenced].filter((id) => !mentionsId(ev.recordedText, id)).sort();
+        base.unrecordedWork = unrecorded;
+        if (unrecorded.length > 0) {
+            reasons.push({
+                code: 'UNRECORDED_WORK',
+                message: `${activity.length} commit(s) after the last state update (${ev.git.lastStateUpdate.sha.slice(0, 7)}, ${ev.git.lastStateUpdate.date.slice(0, 10)}) ` +
+                    `reference ${unrecorded.length} work item(s) that no state document mentions: ${listIds(unrecorded)}.`,
+            });
+            gitVerdict = 'stale';
+        }
+        else if (ev.git.truncated) {
+            reasons.push({
+                code: 'GIT_HISTORY_TRUNCATED',
+                message: 'Git history after the last state update was cut at the read limit; the check is partial.',
+            });
+            gitVerdict = 'unknown';
+        }
+        else if (unattributed > 0) {
+            reasons.push({
+                code: 'UNATTRIBUTED_ACTIVITY',
+                message: `${unattributed} commit(s) after the last state update touch project files without naming a work item; ` +
+                    `whether the recorded state still describes them cannot be determined.`,
+            });
+            gitVerdict = 'unknown';
+        }
+        else if (activity.length === 0) {
+            reasons.push({
+                code: 'NO_ACTIVITY_SINCE_STATE_UPDATE',
+                message: 'No commit after the last state update changed anything beyond the state documents.',
+            });
+            gitVerdict = 'fresh';
+        }
+        else {
+            reasons.push({
+                code: 'ACTIVITY_RECORDED',
+                message: `All ${activity.length} commit(s) after the last state update reference work items that the state documents mention.`,
+            });
+            gitVerdict = 'fresh';
+        }
+        if (activity.length > 0 && ev.activeStory.kind === 'none') {
+            warnings.push('Git activity exists after the last recorded state update, but no active story is recorded.');
+        }
+    }
+    // 3. Combine. A contradiction or unrecorded work is concrete evidence of staleness;
+    //    FRESH needs positive evidence and no contradiction.
+    let status;
+    if (contradictions.length > 0 || gitVerdict === 'stale')
+        status = 'STALE';
+    else if (gitVerdict === 'fresh')
+        status = 'FRESH';
+    else
+        status = 'UNKNOWN';
+    if (status !== 'FRESH') {
+        if (status === 'STALE')
+            warnings.unshift('Project state may be outdated.');
+        else
+            warnings.unshift('Freshness could not be established from the available evidence.');
+        if (ev.activeStory.kind === 'none') {
+            warnings.push('No active story is recorded; this does not mean the project is complete.');
+        }
+        else if (ev.activeStory.kind === 'unknown') {
+            warnings.push('The active story could not be determined from active.md.');
+        }
+    }
+    const recommendation = status === 'FRESH' ? 'No action needed.' : status === 'STALE' ? REVIEW_RECOMMENDATION : `${REVIEW_RECOMMENDATION} Freshness is unverified, not confirmed outdated.`;
+    return { status, reasons, warnings, recommendation, ...base };
+}

package/dist/brief/git-signals.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Read-only git signals for the freshness check (SELF-AWARENESS-001).
+ *
+ * Runs only `git log` and `git rev-parse`, never a command that writes, never
+ * through a shell, with config that could launch helper programs switched off.
+ * Any failure degrades to `{ status: 'unavailable' }` — git being absent,
+ * broken or refusing the directory must never fail the brief.
+ */
+import type { GitSignals } from './freshness.js';
+/** Upper bound on commits read after the last state update. Hitting it marks the result truncated. */
+export declare const MAX_COMMITS_SINCE = 500;
+/**
+ * @param targetDir project directory (git is run from here; paths are relative to it)
+ * @param stateFiles state documents, relative to `targetDir`. Only existing ones need be passed.
+ */
+export declare function readGitSignals(targetDir: string, stateFiles: string[]): GitSignals;
+//# sourceMappingURL=git-signals.d.ts.map

package/dist/brief/git-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-signals.d.ts","sourceRoot":"","sources":["../../src/brief/git-signals.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,gBAAgB,CAAC;AAElE,sGAAsG;AACtG,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAgCrC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,UAAU,CAqDlF"}

package/dist/brief/git-signals.js

@@ -0,0 +1,101 @@
+/**
+ * Read-only git signals for the freshness check (SELF-AWARENESS-001).
+ *
+ * Runs only `git log` and `git rev-parse`, never a command that writes, never
+ * through a shell, with config that could launch helper programs switched off.
+ * Any failure degrades to `{ status: 'unavailable' }` — git being absent,
+ * broken or refusing the directory must never fail the brief.
+ */
+import { execFileSync } from 'child_process';
+/** Upper bound on commits read after the last state update. Hitting it marks the result truncated. */
+export const MAX_COMMITS_SINCE = 500;
+const GIT_TIMEOUT_MS = 10_000;
+const GIT_MAX_BUFFER = 8 * 1024 * 1024;
+const SAFE_CONFIG = [
+    '-c', 'core.fsmonitor=false',
+    '-c', 'core.pager=cat',
+    '-c', 'log.showSignature=false',
+    '-c', 'diff.external=',
+];
+class GitMissingError extends Error {
+}
+function git(cwd, args) {
+    try {
+        return execFileSync('git', [...SAFE_CONFIG, ...args], {
+            cwd,
+            encoding: 'utf8',
+            timeout: GIT_TIMEOUT_MS,
+            maxBuffer: GIT_MAX_BUFFER,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', GIT_TERMINAL_PROMPT: '0', GIT_EXTERNAL_DIFF: '' },
+        });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            throw new GitMissingError('git not installed');
+        throw err;
+    }
+}
+const RS = '\x1e'; // record separator, starts each commit
+const US = '\x1f'; // unit separator, between header fields
+/**
+ * @param targetDir project directory (git is run from here; paths are relative to it)
+ * @param stateFiles state documents, relative to `targetDir`. Only existing ones need be passed.
+ */
+export function readGitSignals(targetDir, stateFiles) {
+    try {
+        const inside = git(targetDir, ['rev-parse', '--is-inside-work-tree']).trim();
+        if (inside !== 'true')
+            return { status: 'unavailable', reason: 'NOT_A_GIT_REPOSITORY' };
+    }
+    catch (err) {
+        if (err instanceof GitMissingError)
+            return { status: 'unavailable', reason: 'GIT_NOT_INSTALLED' };
+        const stderr = String(err.stderr ?? '');
+        return { status: 'unavailable', reason: /not a git repository/i.test(stderr) ? 'NOT_A_GIT_REPOSITORY' : 'GIT_FAILED' };
+    }
+    try {
+        // A repository without commits has no HEAD: nothing to compare with.
+        try {
+            git(targetDir, ['rev-parse', '--verify', '--quiet', 'HEAD']);
+        }
+        catch {
+            return { status: 'ok', lastStateUpdate: null, commitsSince: [], truncated: false };
+        }
+        let lastStateUpdate = null;
+        if (stateFiles.length > 0) {
+            const out = git(targetDir, ['log', '-1', `--format=%H${US}%cI`, '--', ...stateFiles]).trim();
+            if (out) {
+                const [sha, date] = out.split(US);
+                lastStateUpdate = { sha, date };
+            }
+        }
+        if (!lastStateUpdate)
+            return { status: 'ok', lastStateUpdate: null, commitsSince: [], truncated: false };
+        const raw = git(targetDir, [
+            'log',
+            `-n${MAX_COMMITS_SINCE + 1}`,
+            '--no-ext-diff',
+            '--no-textconv',
+            '--relative',
+            '--name-only',
+            `--format=${RS}%H${US}%cI${US}%s`,
+            `${lastStateUpdate.sha}..HEAD`,
+        ]);
+        const commits = [];
+        for (const rec of raw.split(RS)) {
+            if (!rec.trim())
+                continue;
+            const nl = rec.indexOf('\n');
+            const header = nl === -1 ? rec : rec.slice(0, nl);
+            const [sha, date, subject] = header.split(US);
+            const files = (nl === -1 ? '' : rec.slice(nl + 1)).split('\n').filter((l) => l.trim() !== '');
+            commits.push({ sha, date, subject: subject ?? '', files });
+        }
+        const truncated = commits.length > MAX_COMMITS_SINCE;
+        return { status: 'ok', lastStateUpdate, commitsSince: commits.slice(0, MAX_COMMITS_SINCE), truncated };
+    }
+    catch {
+        return { status: 'unavailable', reason: 'GIT_FAILED' };
+    }
+}

package/dist/brief/index.d.ts

@@ -0,0 +1,11 @@
+export type { BriefModel, BriefDiagnostic, BriefDiagnosticCode, DiagnosticSeverity, Provenance, ProjectIdentity, StateKeeperStatus, StateKeeperSummary, MissionsSummary, CheckpointSummary, StorySummary, DocRef, AdrRef, AdrIndex, ProtocolIndex, } from './types.js';
+export { collect } from './collect.js';
+export { render, DEFAULT_MAX_CHARS } from './render.js';
+export type { RenderResult, Completeness } from './render.js';
+export { runBrief, parseBriefArgs } from './cli.js';
+export type { BriefArgsResult, BriefArgsOk, BriefArgsErr } from './cli.js';
+export { evaluateFreshness } from './freshness.js';
+export type { FreshnessStatus, FreshnessResult, FreshnessEvidence, FreshnessReason, GitSignals } from './freshness.js';
+export { reconcile, renderReconciliation } from './reconcile.js';
+export type { ReconciliationReport, ReconciliationFinding, FindingKind, UntrackedWorkItem, ReviewDocument } from './reconcile.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/brief/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/brief/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,UAAU,EACV,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,MAAM,EACN,MAAM,EACN,QAAQ,EACR,aAAa,GACd,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACxD,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACpD,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC3E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACvH,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACjE,YAAY,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,WAAW,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/brief/index.js

@@ -0,0 +1,5 @@
+export { collect } from './collect.js';
+export { render, DEFAULT_MAX_CHARS } from './render.js';
+export { runBrief, parseBriefArgs } from './cli.js';
+export { evaluateFreshness } from './freshness.js';
+export { reconcile, renderReconciliation } from './reconcile.js';

package/dist/brief/reconcile.d.ts

@@ -0,0 +1,75 @@
+/**
+ * State Reconciliation Report (SELF-AWARENESS-002).
+ *
+ * SELF-AWARENESS-001 says *whether* the recorded state looks outdated. This
+ * module says *what* the evidence is and *what a human should check*. It is
+ * pure: it takes the same `FreshnessEvidence` / `FreshnessResult` that
+ * `brief` already computed, reads nothing and writes nothing.
+ *
+ * Two rules shape every line of the report:
+ *   - A git commit is not evidence that a work item is complete, and a work-item
+ *     id in a commit subject is not evidence that its recorded status is right.
+ *     The report therefore only ever says "referenced" and "not mentioned",
+ *     never "done" or "missing from the roadmap because it was finished".
+ *   - Recommendations are things for a person to verify or decide. Nothing here
+ *     edits a document or concludes anything on the person's behalf.
+ *
+ * Findings are graded:
+ *   confirmed  a concrete, checkable discrepancy (documents contradict each other,
+ *              or git names a work item that no state document mentions)
+ *   suspected  something that may be a discrepancy but cannot be shown from the data
+ *   unknown    the evidence needed to decide is missing (no git, truncated history, ...)
+ */
+import { type FreshnessEvidence, type FreshnessResult, type FreshnessStatus } from './freshness.js';
+export type FindingKind = 'confirmed' | 'suspected' | 'unknown';
+export type FindingCode = 'STATE_CONTRADICTION' | 'UNRECORDED_WORK' | 'UNATTRIBUTED_ACTIVITY' | 'ACTIVITY_WITHOUT_ACTIVE_STORY' | 'GIT_UNAVAILABLE' | 'STATE_NOT_IN_GIT' | 'GIT_HISTORY_TRUNCATED' | 'ACTIVE_STORY_UNKNOWN';
+export interface ReconciliationFinding {
+    kind: FindingKind;
+    code: FindingCode;
+    summary: string;
+    /** Short, checkable pointers: document names or `<sha7> <subject>`. */
+    evidence: string[];
+}
+export interface UntrackedWorkItem {
+    id: string;
+    /** Newest first, at most `MAX_COMMITS_PER_ITEM`. */
+    commits: {
+        sha: string;
+        subject: string;
+    }[];
+    totalCommits: number;
+}
+export interface ReviewDocument {
+    path: string;
+    reasons: string[];
+}
+export interface ReconciliationReport {
+    freshness: FreshnessStatus;
+    lastStateUpdate: {
+        sha: string;
+        date: string;
+    } | null;
+    findings: ReconciliationFinding[];
+    /** Work-item ids git references after the last state update that no state document mentions. Sorted. */
+    untrackedWork: UntrackedWorkItem[];
+    /** Ids git references that some state document mentions. Mentioned is not correct. Sorted. */
+    mentionedWork: string[];
+    documents: ReviewDocument[];
+    limitations: string[];
+    actions: string[];
+}
+export declare const MAX_COMMITS_PER_ITEM = 3;
+export declare function reconcile(ev: FreshnessEvidence, result: FreshnessResult): ReconciliationReport;
+export interface RenderedReconciliation {
+    text: string;
+    /** True when a section was dropped to fit the budget. */
+    truncated: boolean;
+}
+/**
+ * Deterministic, bounded text. The header (freshness) and the closing
+ * "No files were modified." are mandatory and never dropped; the sections in
+ * between are added in priority order while they fit, and an omission is
+ * always announced.
+ */
+export declare function renderReconciliation(report: ReconciliationReport, maxChars: number): RenderedReconciliation;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/brief/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../src/brief/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,EAErB,MAAM,gBAAgB,CAAC;AAGxB,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,WAAW,GAAG,SAAS,CAAC;AAEhE,MAAM,MAAM,WAAW,GACnB,qBAAqB,GACrB,iBAAiB,GACjB,uBAAuB,GACvB,+BAA+B,GAC/B,iBAAiB,GACjB,kBAAkB,GAClB,uBAAuB,GACvB,sBAAsB,CAAC;AAE3B,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,oDAAoD;IACpD,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC5C,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,eAAe,CAAC;IAC3B,eAAe,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACtD,QAAQ,EAAE,qBAAqB,EAAE,CAAC;IAClC,wGAAwG;IACxG,aAAa,EAAE,iBAAiB,EAAE,CAAC;IACnC,8FAA8F;IAC9F,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAiBtC,wBAAgB,SAAS,CAAC,EAAE,EAAE,iBAAiB,EAAE,MAAM,EAAE,eAAe,GAAG,oBAAoB,CAmI9F;AAiBD,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,GAAG,sBAAsB,CAoF3G"}