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

package/dist/brief/config.js

@@ -0,0 +1,85 @@
+/**
+ * Minimal `monolith.config.json` reader for the brief subsystem.
+ *
+ * Mirrors the existing `readMonolithRoot()` duplicated in
+ * `src/coordinatorium/cli.ts` and `src/validate/index.ts` — same
+ * "duplicate rather than couple CLI layers together" precedent. Adds one
+ * new, explicit, optional field: `contextGateway.adrDirs` (DEC-CONTEXT-003 /
+ * section 8 — the existing config contract had no way to name additional
+ * ADR directories, so this is the minimal extension to it, not a new
+ * configuration subsystem).
+ *
+ * Review finding F-6: a missing config file is a legitimate, silent
+ * default (no project has been configured yet). A *present but corrupted*
+ * config file is not the same thing and must not be masked as "healthy
+ * project, defaults apply" — it is reported via CONFIG_UNREADABLE and
+ * forces Completeness: INCOMPLETE, same severity model as STATE_UNREADABLE.
+ * Likewise, a present-but-wrong-shape `contextGateway.adrDirs` (not an
+ * array) is reported via CONFIG_ADR_DIRS_INVALID rather than silently
+ * collapsing to `[]`. Non-string entries *within* an otherwise-valid array
+ * are dropped with a lower-severity (warn) note — a partially-junk list is
+ * a lesser problem than the field having the wrong shape entirely.
+ */
+import { readConfigFile, resolveMonolithRoot, DEFAULT_MONOLITH_ROOT } from '../root/index.js';
+import { DEFAULT_ADR_DIR } from './constants.js';
+const DEFAULT_PROJECT_NAME = 'project';
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/**
+ * Throws RootContainmentError when `monolithRoot` violates the SEC-001A
+ * containment policy (see src/root) — the brief never degrades to a default
+ * root in that case.
+ */
+export function readBriefConfig(targetDir, diagnostics = []) {
+    const defaults = { monolithRoot: DEFAULT_MONOLITH_ROOT, projectName: DEFAULT_PROJECT_NAME, adrDirs: [DEFAULT_ADR_DIR] };
+    const read = readConfigFile(targetDir);
+    if (read.status === 'absent') {
+        // Absent config is a legitimate, unconfigured project — not an error.
+        return defaults;
+    }
+    if (read.status !== 'ok') {
+        const message = read.status === 'unreadable'
+            ? `monolith.config.json exists but could not be read: ${read.detail}. Proceeding with defaults.`
+            : read.status === 'invalid-json'
+                ? `monolith.config.json is not valid JSON: ${read.detail}. Proceeding with defaults.`
+                : 'monolith.config.json does not contain a JSON object. Proceeding with defaults.';
+        diagnostics.push({ code: 'CONFIG_UNREADABLE', severity: 'error', message });
+        return defaults;
+    }
+    const cfg = read.cfg;
+    const monolithRoot = resolveMonolithRoot(targetDir, read).monolithRoot;
+    let projectName = DEFAULT_PROJECT_NAME;
+    const project = cfg.project;
+    if (typeof project === 'object' && project !== null && !Array.isArray(project)) {
+        const name = project.name;
+        if (typeof name === 'string' && name.length > 0)
+            projectName = name;
+    }
+    let adrDirs = [DEFAULT_ADR_DIR];
+    const contextGateway = cfg.contextGateway;
+    if (typeof contextGateway === 'object' && contextGateway !== null && !Array.isArray(contextGateway)) {
+        const configured = contextGateway.adrDirs;
+        if (configured !== undefined) {
+            if (!Array.isArray(configured)) {
+                diagnostics.push({
+                    code: 'CONFIG_ADR_DIRS_INVALID',
+                    severity: 'error',
+                    message: 'monolith.config.json#contextGateway.adrDirs is present but is not an array; using the default ADR directory.',
+                });
+            }
+            else {
+                const stringEntries = configured.filter((d) => typeof d === 'string' && d.length > 0);
+                if (stringEntries.length !== configured.length) {
+                    diagnostics.push({
+                        code: 'CONFIG_ADR_DIRS_INVALID',
+                        severity: 'warn',
+                        message: 'monolith.config.json#contextGateway.adrDirs contains non-string entries; they were dropped.',
+                    });
+                }
+                adrDirs = stringEntries;
+            }
+        }
+    }
+    return { monolithRoot, projectName, adrDirs };
+}

package/dist/brief/constants.d.ts

@@ -0,0 +1,10 @@
+/** Shared path constants for the brief subsystem (relative to monolithRoot). */
+export declare const ACTIVE_MD_REL = "memory/working/active.md";
+/** Canonical ADR directory, relative to the project root (not monolithRoot). Used when `contextGateway.adrDirs` is not configured. */
+export declare const DEFAULT_ADR_DIR = "docs/adr";
+export declare const PROTOCOLS_DIR = "protocols";
+/** State documents whose last commit marks the "last recorded state update" (SELF-AWARENESS-001). */
+export declare const ROADMAP_INDEX_REL = "context/maps/roadmap-index.md";
+export declare const STORY_INDEX_REL = "memory/working/story-index.md";
+export declare const HANDOFF_REL = "context/boot/HANDOFF.md";
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/brief/constants.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,eAAO,MAAM,aAAa,6BAA6B,CAAC;AACxD,sIAAsI;AACtI,eAAO,MAAM,eAAe,aAAa,CAAC;AAC1C,eAAO,MAAM,aAAa,cAAc,CAAC;AACzC,qGAAqG;AACrG,eAAO,MAAM,iBAAiB,kCAAkC,CAAC;AACjE,eAAO,MAAM,eAAe,kCAAkC,CAAC;AAC/D,eAAO,MAAM,WAAW,4BAA4B,CAAC"}

package/dist/brief/constants.js

@@ -0,0 +1,9 @@
+/** Shared path constants for the brief subsystem (relative to monolithRoot). */
+export const ACTIVE_MD_REL = 'memory/working/active.md';
+/** Canonical ADR directory, relative to the project root (not monolithRoot). Used when `contextGateway.adrDirs` is not configured. */
+export const DEFAULT_ADR_DIR = 'docs/adr';
+export const PROTOCOLS_DIR = 'protocols';
+/** State documents whose last commit marks the "last recorded state update" (SELF-AWARENESS-001). */
+export const ROADMAP_INDEX_REL = 'context/maps/roadmap-index.md';
+export const STORY_INDEX_REL = 'memory/working/story-index.md';
+export const HANDOFF_REL = 'context/boot/HANDOFF.md';

package/dist/brief/docs.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Generic, deterministic markdown-frontmatter discovery used for both
+ * Mandatory Protocols (section 7) and ADR Discovery (section 8). Reuses
+ * Scriptorium's existing frontmatter parser (per the brief contract) — does
+ * NOT use `compileMarkdownArtifact()` or the ERG graph builder, both of
+ * which are explicitly out of scope here.
+ *
+ * Resilience (review findings F-2/F-3): a single unreadable directory,
+ * unreadable file, dangling symlink, symlink cycle, or a configured
+ * directory that escapes the project root must never crash the whole brief
+ * or silently disappear. Each failure is caught, reported as a diagnostic
+ * (forcing Completeness: INCOMPLETE), and discovery continues with
+ * whatever else is readable.
+ *
+ * Symlinks (file or directory entries) are never followed while walking —
+ * this is what makes a symlink cycle (ELOOP) impossible by construction,
+ * and is also the first line of defense against using a nested symlink to
+ * tunnel outside a configured directory. The *top-level* directories named
+ * in `dirs` (i.e. `contextGateway.adrDirs` and the standard protocols
+ * dir) get an explicit containment check in addition: both a string-level
+ * check (rejects `..` segments in the configured path itself) and a
+ * real-path check after resolving symlinks (rejects a configured directory
+ * that is itself a symlink escaping the project root). Neither check alone
+ * is treated as sufficient — path.join()/path.relative() string comparison
+ * alone does not account for symlinks on disk.
+ *
+ * `monolithRoot` itself, and the fixed files below it (state.json,
+ * active.md), are vetted separately by the shared resolver in src/root
+ * (SEC-001A); this check covers document directories only.
+ */
+import type { BriefDiagnostic, DocRef } from './types.js';
+/** SEC-001B.1: protocol / ADR documents (largest in this repo is ~80 KB). */
+export declare const MAX_MARKDOWN_DOC_BYTES: number;
+export interface ParsedDoc {
+    /** Relative to targetDir. */
+    relPath: string;
+    id: string | undefined;
+    /** frontmatter `title:`, or (only when no frontmatter title exists) the first H1 — resolved once, at parse time. */
+    resolvedTitle: string | undefined;
+    /** All frontmatter fields (first value per key), for filter predicates. */
+    fields: Map<string, string>;
+}
+/**
+ * Discover documents under `dirs` (relative to targetDir, deduplicated,
+ * each walked recursively) whose frontmatter matches `predicate`. Only
+ * documents with a usable frontmatter `id:` are included — a markdown file
+ * without one isn't a candidate ADR/protocol record, it's silently excluded
+ * from this listing (not an error). `diagnostics` collects every resilience
+ * finding described in the module doc comment; callers that don't care can
+ * omit it.
+ */
+export declare function discoverDocs(targetDir: string, dirs: string[], predicate: (fields: Map<string, string>) => boolean, diagnostics?: BriefDiagnostic[]): DocRef[];
+//# sourceMappingURL=docs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/brief/docs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAOH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAE1D,6EAA6E;AAC7E,eAAO,MAAM,sBAAsB,QAAc,CAAC;AAIlD,MAAM,WAAW,SAAS;IACxB,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;IACvB,oHAAoH;IACpH,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,2EAA2E;IAC3E,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7B;AA+KD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EAAE,EACd,SAAS,EAAE,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,OAAO,EACnD,WAAW,GAAE,eAAe,EAAO,GAClC,MAAM,EAAE,CAmBV"}

package/dist/brief/docs.js

@@ -0,0 +1,229 @@
+/**
+ * Generic, deterministic markdown-frontmatter discovery used for both
+ * Mandatory Protocols (section 7) and ADR Discovery (section 8). Reuses
+ * Scriptorium's existing frontmatter parser (per the brief contract) — does
+ * NOT use `compileMarkdownArtifact()` or the ERG graph builder, both of
+ * which are explicitly out of scope here.
+ *
+ * Resilience (review findings F-2/F-3): a single unreadable directory,
+ * unreadable file, dangling symlink, symlink cycle, or a configured
+ * directory that escapes the project root must never crash the whole brief
+ * or silently disappear. Each failure is caught, reported as a diagnostic
+ * (forcing Completeness: INCOMPLETE), and discovery continues with
+ * whatever else is readable.
+ *
+ * Symlinks (file or directory entries) are never followed while walking —
+ * this is what makes a symlink cycle (ELOOP) impossible by construction,
+ * and is also the first line of defense against using a nested symlink to
+ * tunnel outside a configured directory. The *top-level* directories named
+ * in `dirs` (i.e. `contextGateway.adrDirs` and the standard protocols
+ * dir) get an explicit containment check in addition: both a string-level
+ * check (rejects `..` segments in the configured path itself) and a
+ * real-path check after resolving symlinks (rejects a configured directory
+ * that is itself a symlink escaping the project root). Neither check alone
+ * is treated as sufficient — path.join()/path.relative() string comparison
+ * alone does not account for symlinks on disk.
+ *
+ * `monolithRoot` itself, and the fixed files below it (state.json,
+ * active.md), are vetted separately by the shared resolver in src/root
+ * (SEC-001A); this check covers document directories only.
+ */
+import { readdirSync, existsSync, lstatSync, realpathSync } from 'fs';
+import { join, relative, isAbsolute, resolve } from 'path';
+import { readBoundedFileStable } from '../root/index.js';
+import { parseFrontmatter } from '../scriptorium/frontmatter.js';
+import { compareStrings } from './selectors.js';
+/** SEC-001B.1: protocol / ADR documents (largest in this repo is ~80 KB). */
+export const MAX_MARKDOWN_DOC_BYTES = 1024 * 1024;
+const H1_RE = /^#\s+(.+?)\s*$/;
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/** True if `candidateAbs` is `baseAbs` itself or strictly inside it. */
+function isContained(baseAbs, candidateAbs) {
+    const rel = relative(baseAbs, candidateAbs);
+    return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+/**
+ * Resolves `relDir` (relative to targetDir) to an absolute path, rejecting
+ * it — with a diagnostic, never silently — if it is not contained within
+ * targetDir. See the module doc comment for why both a string-level and a
+ * real-path (symlink-resolved) check are performed.
+ */
+function resolveContainedDir(targetDir, relDir, diagnostics) {
+    const targetAbs = resolve(targetDir);
+    const requestedAbs = resolve(join(targetDir, relDir));
+    if (!isContained(targetAbs, requestedAbs)) {
+        diagnostics.push({
+            code: 'DOC_DIR_OUTSIDE_PROJECT',
+            severity: 'error',
+            message: `Configured directory "${relDir}" resolves outside the project root and was skipped.`,
+        });
+        return null;
+    }
+    // `lstat`, not `existsSync`: existsSync follows symlinks, so a DANGLING symlink would
+    // read as "absent" and be skipped silently (SEC-001B.1-R, M-1). Only ENOENT on the
+    // path itself means "not created yet"; a dangling link falls through to realpath below
+    // and is reported as DOC_DIR_UNREADABLE.
+    try {
+        lstatSync(requestedAbs);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            // Not an error: an ADR/protocol directory that hasn't been created yet is routine.
+            return requestedAbs;
+        }
+        diagnostics.push({
+            code: 'DOC_DIR_UNREADABLE',
+            severity: 'error',
+            message: `"${relDir}" could not be inspected: ${errMsg(err)}`,
+        });
+        return null;
+    }
+    let realRequested;
+    try {
+        realRequested = realpathSync(requestedAbs);
+    }
+    catch (err) {
+        diagnostics.push({
+            code: 'DOC_DIR_UNREADABLE',
+            severity: 'error',
+            message: `"${relDir}" could not be resolved: ${errMsg(err)}`,
+        });
+        return null;
+    }
+    let realTarget;
+    try {
+        realTarget = realpathSync(targetAbs);
+    }
+    catch {
+        realTarget = targetAbs;
+    }
+    if (!isContained(realTarget, realRequested)) {
+        diagnostics.push({
+            code: 'DOC_DIR_OUTSIDE_PROJECT',
+            severity: 'error',
+            message: `Configured directory "${relDir}" escapes the project root via a symlink and was skipped.`,
+        });
+        return null;
+    }
+    return requestedAbs;
+}
+/**
+ * All `.md` files under `dir`, sorted deterministically (not FS traversal
+ * order). Never follows symlinks — a symlinked file or directory entry is
+ * skipped outright, which also makes a symlink cycle harmless (it is never
+ * entered to begin with). Directory read failures (EACCES, ELOOP from a
+ * symlink that isn't itself recognized as one by readdir's dirent type,
+ * etc.) are reported and that subtree is skipped; sibling subtrees are
+ * still walked.
+ */
+function walkMarkdownFilesSorted(dir, targetDir, diagnostics) {
+    const results = [];
+    if (!existsSync(dir))
+        return results;
+    function walk(d) {
+        let entries;
+        try {
+            entries = readdirSync(d, { withFileTypes: true });
+        }
+        catch (err) {
+            diagnostics.push({
+                code: 'DOC_DIR_UNREADABLE',
+                severity: 'error',
+                message: `"${relative(targetDir, d)}" could not be read: ${errMsg(err)}`,
+            });
+            return;
+        }
+        const sorted = entries.slice().sort((a, b) => compareStrings(a.name, b.name));
+        for (const entry of sorted) {
+            if (entry.isSymbolicLink())
+                continue; // never follow symlinks — files or directories
+            const full = join(d, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                results.push(full);
+            }
+        }
+    }
+    walk(dir);
+    return results.sort(compareStrings);
+}
+function firstH1(bodyLines) {
+    for (const line of bodyLines) {
+        const match = H1_RE.exec(line.trim());
+        if (match)
+            return match[1];
+    }
+    return undefined;
+}
+function parseDoc(absPath, targetDir, diagnostics) {
+    const read = readBoundedFileStable(absPath, `"${relative(targetDir, absPath)}"`, { boundary: targetDir, maxBytes: MAX_MARKDOWN_DOC_BYTES, allowEmpty: true }, true);
+    if (!read.ok) {
+        diagnostics.push({
+            code: 'DOC_FILE_UNREADABLE',
+            severity: 'error',
+            message: `"${relative(targetDir, absPath)}" could not be read: ${read.code}: ${read.detail}`,
+            readCode: read.code,
+        });
+        return null;
+    }
+    const content = 'content' in read ? read.content : '';
+    const lines = content.split('\n');
+    const fm = parseFrontmatter(lines);
+    if (!fm)
+        return null;
+    const fields = new Map();
+    let frontmatterTitle;
+    let id;
+    for (const field of fm.fields) {
+        if (field.values[0] !== undefined)
+            fields.set(field.key, field.values[0]);
+        if (field.key === 'title' && field.values[0])
+            frontmatterTitle = field.values[0];
+        if (field.key === 'id' && field.values[0])
+            id = field.values[0];
+    }
+    const resolvedTitle = frontmatterTitle ?? firstH1(lines.slice(fm.bodyStartLine));
+    return {
+        relPath: relative(targetDir, absPath).split('\\').join('/'),
+        id,
+        resolvedTitle,
+        fields,
+    };
+}
+function resolveTitle(doc) {
+    return doc.resolvedTitle ?? doc.id ?? doc.relPath;
+}
+/**
+ * Discover documents under `dirs` (relative to targetDir, deduplicated,
+ * each walked recursively) whose frontmatter matches `predicate`. Only
+ * documents with a usable frontmatter `id:` are included — a markdown file
+ * without one isn't a candidate ADR/protocol record, it's silently excluded
+ * from this listing (not an error). `diagnostics` collects every resilience
+ * finding described in the module doc comment; callers that don't care can
+ * omit it.
+ */
+export function discoverDocs(targetDir, dirs, predicate, diagnostics = []) {
+    const seenAbsDirs = new Set();
+    const refs = [];
+    for (const relDir of dirs) {
+        const absDir = resolveContainedDir(targetDir, relDir, diagnostics);
+        if (!absDir)
+            continue;
+        if (seenAbsDirs.has(absDir))
+            continue;
+        seenAbsDirs.add(absDir);
+        for (const absPath of walkMarkdownFilesSorted(absDir, targetDir, diagnostics)) {
+            const doc = parseDoc(absPath, targetDir, diagnostics);
+            if (!doc || !doc.id)
+                continue;
+            if (!predicate(doc.fields))
+                continue;
+            refs.push({ id: doc.id, title: resolveTitle(doc), path: doc.relPath });
+        }
+    }
+    return refs.sort((a, b) => compareStrings(a.id, b.id) || compareStrings(a.path, b.path));
+}

package/dist/brief/freshness.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 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".
+ */
+export type FreshnessStatus = 'FRESH' | 'STALE' | 'UNKNOWN';
+export type FreshnessReasonCode = 'STATE_CONTRADICTION' | 'UNRECORDED_WORK' | 'GIT_UNAVAILABLE' | 'STATE_NOT_IN_GIT' | 'GIT_HISTORY_TRUNCATED' | 'UNATTRIBUTED_ACTIVITY' | 'NO_ACTIVITY_SINCE_STATE_UPDATE' | 'ACTIVITY_RECORDED';
+export interface FreshnessReason {
+    code: FreshnessReasonCode;
+    message: string;
+    /** STATE_CONTRADICTION only: the state documents (by file name) that disagree. */
+    documents?: string[];
+}
+/** One commit after the last state update, as seen by git. */
+export interface GitCommitSignal {
+    sha: string;
+    /** ISO-8601 committer date. Informational only — never compared with "now". */
+    date: string;
+    subject: string;
+    /** Paths changed by the commit, relative to the project directory. Empty for plain merges. */
+    files: string[];
+}
+export type GitUnavailableReason = 'GIT_NOT_INSTALLED' | 'NOT_A_GIT_REPOSITORY' | 'GIT_FAILED';
+export type GitSignals = {
+    status: 'unavailable';
+    reason: GitUnavailableReason;
+} | {
+    status: 'ok';
+    /** The newest commit that touched any state document; null if none ever did. */
+    lastStateUpdate: {
+        sha: string;
+        date: string;
+    } | null;
+    /** Commits reachable from HEAD but not from `lastStateUpdate`, newest first. */
+    commitsSince: GitCommitSignal[];
+    /** True when git history was cut at the read limit — the picture is partial. */
+    truncated: boolean;
+};
+export type StoryClaim = {
+    kind: 'none';
+} | {
+    kind: 'ids';
+    ids: string[];
+} | {
+    kind: 'unknown';
+};
+export interface FreshnessEvidence {
+    git: GitSignals;
+    /** What `active.md` says is current. `unknown` when the file/section is unreadable or says nothing parseable. */
+    activeStory: StoryClaim;
+    /** What `roadmap-index.md` says is the active story ("Active Story: ..."), or null if the line is absent. */
+    roadmapActiveStory: string | null;
+    /** Work-item status by id as declared by roadmap-index.md and story-index.md (uppercased status). */
+    roadmapStatuses: ReadonlyMap<string, string>;
+    storyIndexStatuses: ReadonlyMap<string, string>;
+    /** Concatenated text of the state documents that were readable; used to decide whether an id is "recorded". */
+    recordedText: string;
+    /** Repo-relative-to-project paths that are state documents (their own commits are not "activity"). */
+    stateFiles: ReadonlySet<string>;
+}
+export interface FreshnessResult {
+    status: FreshnessStatus;
+    reasons: FreshnessReason[];
+    /** Human-readable, single-line warnings (never fatal). */
+    warnings: string[];
+    recommendation: string;
+    activeStory: 'none-recorded' | 'recorded' | 'unknown';
+    lastStateUpdate: {
+        sha: string;
+        date: string;
+    } | null;
+    /** Commits after the last state update that touched something other than state documents. */
+    activityCount: number | null;
+    /** Work-item ids seen in git after the last state update and absent from every state document. */
+    unrecordedWork: string[];
+}
+export declare function extractWorkItemIds(text: string): string[];
+export declare function mentionsId(text: string, id: string): boolean;
+/** Interprets the `## Current Story` excerpt of active.md. */
+export declare function parseActiveStoryClaim(excerpt: string | null): StoryClaim;
+/** `Active Story: <text>` line of roadmap-index.md. */
+export declare function parseRoadmapActiveStory(content: string): string | null;
+/** Table rows `| id | title | STATUS | date |` of roadmap-index.md. */
+export declare function parseRoadmapStatuses(content: string): Map<string, string>;
+/** `### [STORY ]<id> — title` followed by `**Status:** X` in story-index.md. */
+export declare function parseStoryIndexStatuses(content: string): Map<string, string>;
+export declare function evaluateFreshness(ev: FreshnessEvidence): FreshnessResult;
+//# sourceMappingURL=freshness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"freshness.d.ts","sourceRoot":"","sources":["../../src/brief/freshness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;AAE5D,MAAM,MAAM,mBAAmB,GAC3B,qBAAqB,GACrB,iBAAiB,GACjB,iBAAiB,GACjB,kBAAkB,GAClB,uBAAuB,GACvB,uBAAuB,GACvB,gCAAgC,GAChC,mBAAmB,CAAC;AAExB,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,8DAA8D;AAC9D,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,8FAA8F;IAC9F,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,GAAG,sBAAsB,GAAG,YAAY,CAAC;AAE/F,MAAM,MAAM,UAAU,GAClB;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,oBAAoB,CAAA;CAAE,GACvD;IACE,MAAM,EAAE,IAAI,CAAC;IACb,gFAAgF;IAChF,eAAe,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACtD,gFAAgF;IAChF,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,gFAAgF;IAChF,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEN,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAExB,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,UAAU,CAAC;IAChB,iHAAiH;IACjH,WAAW,EAAE,UAAU,CAAC;IACxB,6GAA6G;IAC7G,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,qGAAqG;IACrG,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,kBAAkB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,+GAA+G;IAC/G,YAAY,EAAE,MAAM,CAAC;IACrB,sGAAsG;IACtG,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,eAAe,GAAG,UAAU,GAAG,SAAS,CAAC;IACtD,eAAe,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACtD,6FAA6F;IAC7F,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,kGAAkG;IAClG,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAmBD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAOzD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAG5D;AAQD,8DAA8D;AAC9D,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,UAAU,CAMxE;AAED,uDAAuD;AACvD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGtE;AAED,uEAAuE;AACvE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAYzE;AAED,gFAAgF;AAChF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAgB5E;AA8DD,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,iBAAiB,GAAG,eAAe,CA2GxE"}