osborn 0.9.249 → 0.9.251

package/dist/content/lens-library-index.js

@@ -0,0 +1,79 @@
+/**
+ * lens-library-index.ts — rebuild a session library's INDEX.md from the period
+ * pages on disk. The pages are the source of truth (renderPeriodMd format), so
+ * pages written by the manual backfill are listed alongside auto-written ones,
+ * and a rebuild is idempotent: same pages in → same INDEX out.
+ */
+import { readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const INDEX_FILE = 'INDEX.md';
+export const PAGE_RE = /^(\d{4}-\d{2}-\d{2}|undated)-period-(\d+)\.md$/;
+function section(md, heading) {
+    const at = md.indexOf(`\n## ${heading}\n`);
+    if (at < 0)
+        return '';
+    const rest = md.slice(at + heading.length + 5);
+    const end = rest.search(/\n## /);
+    return end < 0 ? rest : rest.slice(0, end);
+}
+/** Parse one period page (renderPeriodMd output). Pure. */
+export function parsePage(file, md) {
+    const m = file.match(PAGE_RE);
+    const rows = md.match(/^- Rows in block: #(\d+)–#(\d+)/m);
+    const time = md.match(/^- Time: (\S+) → (\S+)/m);
+    const goalLines = section(md, 'Period goal').split('\n').map(s => s.trim()).filter(s => s && !s.startsWith('- >'));
+    const goal = goalLines[0] && goalLines[0] !== '- (none verified)' ? goalLines[0] : '(no verified goal)';
+    const top = section(md, 'High-leverage work (ranked)').match(/^1\. \*\*(.+?)\*\* \[([^\]]+)\]/m);
+    const stories = [];
+    for (const block of section(md, 'Stories').split(/(?:^|\n)### /).slice(1)) {
+        const title = block.split('\n')[0].trim();
+        const r = block.match(/^Rows: (#\d+–#\d+)/m);
+        const a = block.match(/^\s*- > "(.+)" — user, row #(\d+)/m);
+        stories.push({ title, rows: r?.[1] ?? '', anchor: a ? `“${a[1]}” (row #${a[2]})` : null });
+    }
+    const cost = md.match(/^- Calls: .*?\$(\d+(?:\.\d+)?) \(cap/m);
+    return {
+        file, index: m ? Number(m[2]) : 0, rows: rows ? `#${rows[1]}–#${rows[2]}` : '-',
+        from: time?.[1] ?? '', to: time?.[2] ?? '', goal,
+        topItem: top ? `${top[1]} [${top[2]}]` : null, stories, costUsd: cost ? Number(cost[1]) : 0,
+    };
+}
+const cell = (s) => s.replace(/\|/g, '\\|').replace(/\n+/g, ' ');
+const when = (iso) => (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(iso) ? iso.slice(0, 16).replace('T', ' ') : iso || '?');
+/** Render INDEX.md. Pure. */
+export function renderIndex(sessionLabel, pages) {
+    const ps = [...pages].sort((a, b) => a.index - b.index || a.file.localeCompare(b.file));
+    const L = [`# Content library — session ${sessionLabel}`, ''];
+    L.push('Period pages from the period map (review mode). New pages are written automatically by the content-lens worker on each ' +
+        'compaction, one per period, keyed on the period\'s opening boundary row. content-profile.md and the HWM are not touched.', '');
+    L.push('## Periods (chronological)', '', '| # | Date range (UTC) | Rows | Period goal | Top high-leverage item | File |', '|---|---|---|---|---|---|');
+    for (const p of ps) {
+        L.push(`| ${String(p.index).padStart(2, '0')} | ${when(p.from)} → ${when(p.to)} | ${p.rows} | ${cell(p.goal)} | ${cell(p.topItem ?? '(none verified)')} | [${p.file}](${p.file}) |`);
+    }
+    L.push('', '## Stories', '', '| Date | Story | User anchor line (verbatim) | Rows | File |', '|---|---|---|---|---|');
+    for (const p of ps) {
+        for (const s of p.stories)
+            L.push(`| ${p.from.slice(0, 10) || '?'} | ${cell(s.title)} | ${cell(s.anchor ?? '-')} | ${s.rows || '-'} | [${p.file}](${p.file}) |`);
+    }
+    const tops = ps.filter(p => p.topItem);
+    L.push('', '## Top high-leverage item per period', '');
+    if (!tops.length)
+        L.push('- (none verified)');
+    for (const p of tops)
+        L.push(`- ${String(p.index).padStart(2, '0')}: ${p.topItem} — [${p.file}](${p.file})`);
+    const stories = ps.reduce((n, p) => n + p.stories.length, 0);
+    const cost = ps.reduce((n, p) => n + p.costUsd, 0);
+    L.push('', '## Totals', '', `- Periods: ${ps.length}`, `- Stories: ${stories}`, `- Model spend across pages: $${cost.toFixed(4)}`);
+    return L.join('\n') + '\n';
+}
+/** Rebuild <dir>/INDEX.md from every period page in <dir>. `scrub` = final redaction pass. Returns the path. */
+export function rebuildIndex(dir, sessionLabel, scrub = s => s) {
+    const pages = readdirSync(dir)
+        .filter(f => PAGE_RE.test(f))
+        .map(f => parsePage(f, readFileSync(join(dir, f), 'utf-8')));
+    const path = join(dir, INDEX_FILE);
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, scrub(renderIndex(sessionLabel, pages)), 'utf-8');
+    renameSync(tmp, path);
+    return path;
+}

package/dist/content/lens-library-select.d.ts

@@ -0,0 +1,59 @@
+/**
+ * lens-library-select.ts — which PERIOD a compaction just ended. Pure + deterministic.
+ *
+ * A period runs from one compaction seam (lens-period-boundaries) to the row
+ * before the next seam. Seams come in clusters (several re-compactions within
+ * minutes), so short periods are merged FORWARD: walking the seams in order, a
+ * group only closes at a seam once it spans >= minSpanMs of conversation. The
+ * walk depends only on earlier rows, so a later seam never re-numbers an earlier
+ * group. That makes the group's OPENING boundary row (startRowId) a stable key:
+ * the same period always gets the same key, index and file name.
+ *
+ * Timing: the worker runs at PostCompact, usually BEFORE the recall store has
+ * ingested the seam this compaction will produce. So the db's TAIL (last seam →
+ * last row) is the period that just ended; it is treated as closed by "this
+ * compaction" when it spans >= minSpanMs, else it is deferred (merged into the
+ * next one). If the new seam is already ingested, the tail is tiny and the last
+ * seam-closed group is the one that just ended.
+ */
+export declare const DEFAULT_MIN_SPAN_MS: number;
+export interface RowStamp {
+    id: number;
+    timestamp: string;
+}
+export interface LibraryPeriod {
+    /** 1-based position in the session's period sequence (stable). */
+    index: number;
+    /** Opening boundary row (or the session's first row for period 1) — the idempotency key. */
+    startRowId: number;
+    /** Inclusive last row. */
+    endRowId: number;
+    /** Seam row that closed it; null = the tail, closed by the compaction that triggered this run. */
+    closedBy: number | null;
+    /** Conversation rows in the period. */
+    rows: number;
+    fromTs: string;
+    toTs: string;
+    spanMs: number;
+}
+export interface Segmentation {
+    closed: LibraryPeriod[];
+    tail: LibraryPeriod | null;
+}
+/** Split records (ascending id) into greedy forward-merged periods at the given seams. */
+export declare function segmentPeriods(records: RowStamp[], boundaries: number[], minSpanMs?: number): Segmentation;
+export type PickResult = {
+    period: LibraryPeriod;
+    reason: 'tail' | 'last-closed';
+} | {
+    period: null;
+    reason: 'no-rows' | 'deferred' | 'already-written';
+};
+/**
+ * The newest period not yet written, among (1) the tail when it is long enough
+ * and (2) the last seam-closed group. At most one per run; older gaps are left to
+ * a manual backfill so a compaction never triggers surprise spend.
+ */
+export declare function pickLibraryPeriod(seg: Segmentation, isDone: (startRowId: number) => boolean, minSpanMs?: number): PickResult;
+/** <YYYY-MM-DD of the period start>-period-<NN>.md — same scheme as the manual backfill. */
+export declare function pageFileName(p: Pick<LibraryPeriod, 'index' | 'fromTs'>): string;

package/dist/content/lens-library-select.js

@@ -0,0 +1,77 @@
+/**
+ * lens-library-select.ts — which PERIOD a compaction just ended. Pure + deterministic.
+ *
+ * A period runs from one compaction seam (lens-period-boundaries) to the row
+ * before the next seam. Seams come in clusters (several re-compactions within
+ * minutes), so short periods are merged FORWARD: walking the seams in order, a
+ * group only closes at a seam once it spans >= minSpanMs of conversation. The
+ * walk depends only on earlier rows, so a later seam never re-numbers an earlier
+ * group. That makes the group's OPENING boundary row (startRowId) a stable key:
+ * the same period always gets the same key, index and file name.
+ *
+ * Timing: the worker runs at PostCompact, usually BEFORE the recall store has
+ * ingested the seam this compaction will produce. So the db's TAIL (last seam →
+ * last row) is the period that just ended; it is treated as closed by "this
+ * compaction" when it spans >= minSpanMs, else it is deferred (merged into the
+ * next one). If the new seam is already ingested, the tail is tiny and the last
+ * seam-closed group is the one that just ended.
+ */
+export const DEFAULT_MIN_SPAN_MS = 4 * 3_600_000;
+function span(recs) {
+    if (recs.length < 2)
+        return 0;
+    const a = Date.parse(recs[0].timestamp);
+    const b = Date.parse(recs[recs.length - 1].timestamp);
+    return Number.isFinite(a) && Number.isFinite(b) ? Math.max(0, b - a) : 0;
+}
+function period(index, start, end, closedBy, recs) {
+    return {
+        index, startRowId: start, endRowId: end, closedBy, rows: recs.length,
+        fromTs: recs[0]?.timestamp ?? '', toTs: recs[recs.length - 1]?.timestamp ?? '', spanMs: span(recs),
+    };
+}
+/** Split records (ascending id) into greedy forward-merged periods at the given seams. */
+export function segmentPeriods(records, boundaries, minSpanMs = DEFAULT_MIN_SPAN_MS) {
+    if (!records.length)
+        return { closed: [], tail: null };
+    const firstId = records[0].id;
+    const lastId = records[records.length - 1].id;
+    const seams = [...new Set(boundaries)].filter(b => b > firstId && b <= lastId).sort((a, b) => a - b);
+    const closed = [];
+    let start = firstId;
+    let i = 0; // first record index of the current group
+    for (const s of seams) {
+        let j = i;
+        while (j < records.length && records[j].id < s)
+            j++;
+        const group = records.slice(i, j);
+        if (span(group) >= minSpanMs) {
+            closed.push(period(closed.length + 1, start, s - 1, s, group));
+            start = s;
+            i = j;
+        }
+    }
+    const tailRecs = records.slice(i);
+    return { closed, tail: tailRecs.length ? period(closed.length + 1, start, lastId, null, tailRecs) : null };
+}
+/**
+ * The newest period not yet written, among (1) the tail when it is long enough
+ * and (2) the last seam-closed group. At most one per run; older gaps are left to
+ * a manual backfill so a compaction never triggers surprise spend.
+ */
+export function pickLibraryPeriod(seg, isDone, minSpanMs = DEFAULT_MIN_SPAN_MS) {
+    if (!seg.tail && !seg.closed.length)
+        return { period: null, reason: 'no-rows' };
+    const tailReady = !!seg.tail && seg.tail.spanMs >= minSpanMs;
+    if (tailReady && !isDone(seg.tail.startRowId))
+        return { period: seg.tail, reason: 'tail' };
+    const last = seg.closed[seg.closed.length - 1];
+    if (last && !isDone(last.startRowId))
+        return { period: last, reason: 'last-closed' };
+    return { period: null, reason: tailReady || !seg.tail ? 'already-written' : 'deferred' };
+}
+/** <YYYY-MM-DD of the period start>-period-<NN>.md — same scheme as the manual backfill. */
+export function pageFileName(p) {
+    const day = /^\d{4}-\d{2}-\d{2}/.test(p.fromTs) ? p.fromTs.slice(0, 10) : 'undated';
+    return `${day}-period-${String(p.index).padStart(2, '0')}.md`;
+}

package/dist/content/lens-library.d.ts

@@ -0,0 +1,92 @@
+/**
+ * lens-library.ts — the LIBRARY STEP of the detached content-lens worker.
+ *
+ * On each compaction: pick the period that just ended (lens-library-select),
+ * run the existing period map on exactly that row range (period-run: strip →
+ * redact → one OpenRouter call under PERIOD_CAP_USD, review mode — never the
+ * profile or the HWM), and publish ONE page per period to
+ *   <project>/osb/<sessionId>/library/<sid8>/<YYYY-MM-DD>-period-<NN>.md
+ * then rebuild INDEX.md there. Same layout as the manual c97588f4 backfill.
+ *
+ * Idempotent: pages are keyed on the period's opening boundary row in
+ * .library-manifest.json; a period already written ("ok") is skipped with no
+ * model call. A failed run publishes nothing (the reply stays in .staging/) and
+ * is retried next time. Fail-open: never throws; the caller just logs the result.
+ * Opt-out: OSBORN_CONTENT_LENS=0 (same switch as the launcher).
+ */
+import { type LibraryPeriod } from './lens-library-select.js';
+import { type IngestOptions, type IngestState } from './lens-ingest.js';
+export declare const MANIFEST_FILE = ".library-manifest.json";
+export interface ManifestEntry {
+    startRowId: number;
+    endRowId: number;
+    closedBy: number | 'compaction';
+    index: number;
+    file: string;
+    status: 'ok' | 'error' | 'dry';
+    costUsd: number;
+    errors: string[];
+    updatedAt: string;
+    /** Cloud ingest outcome (content_ingest RPC). Anything but ok/oversize is retried next run. */
+    ingest?: IngestState;
+}
+export interface Manifest {
+    version: 1;
+    sessionId: string;
+    /** key = String(startRowId) */
+    periods: Record<string, ManifestEntry>;
+}
+export type LibraryStatus = 'disabled' | 'no-key' | 'no-db' | 'no-rows' | 'deferred' | 'already-written' | 'written' | 'dry' | 'model-error' | 'failed';
+export interface LibraryStepResult {
+    status: LibraryStatus;
+    libraryDir: string | null;
+    period: LibraryPeriod | null;
+    page: string | null;
+    index: string | null;
+    costUsd: number;
+    errors: string[];
+}
+export interface LibraryStepOptions {
+    sessionId: string;
+    projectDir?: string | null;
+    cwd?: string;
+    /** No model call: block stats page only (manifest status "dry", never counts as written). */
+    dry?: boolean;
+    /** Write here instead of the session's library dir (dry runs / review). */
+    outDir?: string;
+    minSpanMs?: number;
+    /** Called every 60s while the step runs (worker refreshes its lock). */
+    keepAlive?: () => void;
+    log?: (m: string) => void;
+}
+/** The record handed to the ingest seam. */
+export interface LibraryPageRecord {
+    sessionId: string;
+    key: string;
+    period: LibraryPeriod;
+    pagePath: string;
+    markdown: string;
+    costUsd: number;
+}
+/**
+ * ── INGEST SEAM ──────────────────────────────────────────────────────────────
+ * The ONE place a published page goes to the cloud library: Supabase RPC
+ * content_ingest (migration 007) as a private draft, authed by OSBORN_SYNC_TOKEN
+ * (see lens-ingest.ts). Never throws; the returned state is recorded in the
+ * manifest so failures retry next run. Errors here never affect the local page.
+ * Opt-out: OSBORN_CONTENT_INGEST=0 (and OSBORN_CONTENT_LENS=0).
+ */
+export declare function ingestLibraryPage(page: LibraryPageRecord, o?: IngestOptions): Promise<IngestState>;
+/**
+ * Retry pass: ingest every written ("ok") page whose ingest never succeeded (or
+ * whose content changed). No model call. Does nothing when ingest isn't
+ * configured. Returns true if the manifest changed. Never throws.
+ */
+export declare function ingestPendingPages(dir: string, m: Manifest, o?: IngestOptions & {
+    skipKey?: string;
+}): Promise<boolean>;
+export declare function libraryDirFor(dbPath: string, sessionId: string): string;
+export declare function readManifest(dir: string, sessionId: string): Manifest;
+export declare function writeManifest(dir: string, m: Manifest): void;
+/** Run the library step once. Never throws. */
+export declare function runLibraryStep(o: LibraryStepOptions): Promise<LibraryStepResult>;

package/dist/content/lens-library.js

@@ -0,0 +1,179 @@
+/**
+ * lens-library.ts — the LIBRARY STEP of the detached content-lens worker.
+ *
+ * On each compaction: pick the period that just ended (lens-library-select),
+ * run the existing period map on exactly that row range (period-run: strip →
+ * redact → one OpenRouter call under PERIOD_CAP_USD, review mode — never the
+ * profile or the HWM), and publish ONE page per period to
+ *   <project>/osb/<sessionId>/library/<sid8>/<YYYY-MM-DD>-period-<NN>.md
+ * then rebuild INDEX.md there. Same layout as the manual c97588f4 backfill.
+ *
+ * Idempotent: pages are keyed on the period's opening boundary row in
+ * .library-manifest.json; a period already written ("ok") is skipped with no
+ * model call. A failed run publishes nothing (the reply stays in .staging/) and
+ * is retried next time. Fail-open: never throws; the caller just logs the result.
+ * Opt-out: OSBORN_CONTENT_LENS=0 (same switch as the launcher).
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { loadConversationRows, resolveSessionDb } from './lens-db.js';
+import { isContentLensEnabled } from './lens-launch.js';
+import { readCompactionBoundaries } from './lens-period-boundaries.js';
+import { loadClientRedactor } from './lens-redact.js';
+import { redactSecrets } from './transcript-sanitizer.js';
+import { runPeriodMap } from './period-run.js';
+import { DEFAULT_MIN_SPAN_MS, pageFileName, pickLibraryPeriod, segmentPeriods } from './lens-library-select.js';
+import { rebuildIndex } from './lens-library-index.js';
+import { contentHashFor, ingestPage, needsIngest, resolveIngestConfig } from './lens-ingest.js';
+export const MANIFEST_FILE = '.library-manifest.json';
+const STAGING_DIR = '.staging';
+/**
+ * ── INGEST SEAM ──────────────────────────────────────────────────────────────
+ * The ONE place a published page goes to the cloud library: Supabase RPC
+ * content_ingest (migration 007) as a private draft, authed by OSBORN_SYNC_TOKEN
+ * (see lens-ingest.ts). Never throws; the returned state is recorded in the
+ * manifest so failures retry next run. Errors here never affect the local page.
+ * Opt-out: OSBORN_CONTENT_INGEST=0 (and OSBORN_CONTENT_LENS=0).
+ */
+export async function ingestLibraryPage(page, o = {}) {
+    const p = page.period;
+    return ingestPage({
+        sessionId: page.sessionId, startRowId: p.startRowId, endRowId: p.endRowId, index: p.index,
+        closedBy: p.closedBy ?? 'compaction', file: basename(page.pagePath), markdown: page.markdown,
+    }, o);
+}
+/**
+ * Retry pass: ingest every written ("ok") page whose ingest never succeeded (or
+ * whose content changed). No model call. Does nothing when ingest isn't
+ * configured. Returns true if the manifest changed. Never throws.
+ */
+export async function ingestPendingPages(dir, m, o = {}) {
+    if (!resolveIngestConfig().ok)
+        return false;
+    let changed = false;
+    for (const [key, e] of Object.entries(m.periods)) {
+        if (e.status !== 'ok' || key === o.skipKey)
+            continue;
+        try {
+            const path = join(dir, e.file);
+            if (!existsSync(path))
+                continue;
+            const markdown = readFileSync(path, 'utf-8');
+            if (!needsIngest(e.ingest, contentHashFor({ sessionId: m.sessionId, startRowId: e.startRowId, markdown })))
+                continue;
+            e.ingest = await ingestPage({ sessionId: m.sessionId, startRowId: e.startRowId, endRowId: e.endRowId, index: e.index, closedBy: e.closedBy, file: e.file, markdown }, o);
+            changed = true;
+        }
+        catch {
+            /* fail-open: try again next run */
+        }
+    }
+    return changed;
+}
+export function libraryDirFor(dbPath, sessionId) {
+    return join(dirname(dbPath), 'library', sessionId.slice(0, 8));
+}
+export function readManifest(dir, sessionId) {
+    try {
+        const o = JSON.parse(readFileSync(join(dir, MANIFEST_FILE), 'utf-8'));
+        if (o && typeof o.periods === 'object' && !Array.isArray(o.periods))
+            return { version: 1, sessionId, periods: o.periods };
+    }
+    catch {
+        /* missing / unreadable → empty */
+    }
+    return { version: 1, sessionId, periods: {} };
+}
+function writeAtomic(path, text) {
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, text, 'utf-8');
+    renameSync(tmp, path);
+}
+export function writeManifest(dir, m) {
+    writeAtomic(join(dir, MANIFEST_FILE), JSON.stringify(m, null, 2) + '\n');
+}
+const envNum = (k) => {
+    const n = Number(process.env[k]);
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+};
+/** Run the library step once. Never throws. */
+export async function runLibraryStep(o) {
+    const log = o.log ?? (() => { });
+    const res = { status: 'failed', libraryDir: null, period: null, page: null, index: null, costUsd: 0, errors: [] };
+    const timer = o.keepAlive ? setInterval(o.keepAlive, 60_000) : null;
+    timer?.unref();
+    try {
+        if (!isContentLensEnabled())
+            return { ...res, status: 'disabled' };
+        if (!o.dry && !(process.env.OPENROUTER_API_KEY || '').trim())
+            return { ...res, status: 'no-key' };
+        const db = resolveSessionDb(o.sessionId, o.projectDir, o.cwd);
+        if (!db)
+            return { ...res, status: 'no-db' };
+        const projectDir = dirname(dirname(dirname(db)));
+        const envH = envNum('OSBORN_LIBRARY_MIN_PERIOD_H');
+        const minSpan = o.minSpanMs ?? (envH ? envH * 3_600_000 : DEFAULT_MIN_SPAN_MS);
+        const dir = (res.libraryDir = o.outDir ?? libraryDirFor(db, o.sessionId));
+        // Segment the whole session at its compaction seams (ids + timestamps only).
+        const rows = loadConversationRows(db, 0).records.map(r => ({ id: r.id, timestamp: r.timestamp }));
+        const seg = segmentPeriods(rows, readCompactionBoundaries(db), minSpan);
+        const manifest = readManifest(dir, o.sessionId);
+        const pick = pickLibraryPeriod(seg, start => manifest.periods[String(start)]?.status === 'ok', minSpan);
+        log(`library: ${seg.closed.length} closed period(s), tail ${seg.tail ? `#${seg.tail.startRowId}–#${seg.tail.endRowId} (${(seg.tail.spanMs / 3_600_000).toFixed(1)}h)` : 'none'} → ${pick.reason}`);
+        const red = loadClientRedactor(projectDir);
+        const scrub = (s) => redactSecrets(red.redact(s), { assistant: true });
+        if (pick.reason !== 'tail' && pick.reason !== 'last-closed') {
+            // Nothing new to write; still retry pages whose cloud ingest never landed (no model call).
+            if (!o.dry && !o.outDir && (await ingestPendingPages(dir, manifest, { scrub, log })))
+                writeManifest(dir, manifest);
+            return { ...res, status: pick.reason };
+        }
+        const p = (res.period = pick.period);
+        const key = String(p.startRowId);
+        const file = pageFileName(p);
+        // Period map on exactly this row range, staged first; published only when a map came back.
+        mkdirSync(join(dir, STAGING_DIR), { recursive: true });
+        const staged = join(dir, STAGING_DIR, file);
+        const r = await runPeriodMap({ sessionId: o.sessionId, outPath: staged, fromRowId: p.startRowId, toRowId: p.endRowId, dry: o.dry, log });
+        res.costUsd = r.costUsd;
+        res.errors = [...r.errors];
+        const ok = !!r.map || !!o.dry;
+        const entry = {
+            startRowId: p.startRowId, endRowId: p.endRowId, closedBy: p.closedBy ?? 'compaction', index: p.index, file,
+            status: o.dry ? 'dry' : r.map ? 'ok' : 'error', costUsd: r.costUsd, errors: r.errors, updatedAt: new Date().toISOString(),
+        };
+        if (ok) {
+            const marker = `<!-- osborn-library: key=${key} rows=${p.startRowId}-${p.endRowId} closed-by=${entry.closedBy} period=${p.index}${o.dry ? ' dry' : ''} -->\n`;
+            const markdown = marker + readFileSync(staged, 'utf-8');
+            res.page = join(dir, file);
+            writeAtomic(res.page, markdown);
+            rmSync(staged, { force: true });
+            res.index = rebuildIndex(dir, o.sessionId.slice(0, 8), scrub);
+            if (!o.dry) {
+                try {
+                    const st = await ingestLibraryPage({ sessionId: o.sessionId, key, period: p, pagePath: res.page, markdown, costUsd: r.costUsd }, { scrub, log });
+                    entry.ingest = st;
+                }
+                catch (e) {
+                    log(`library: ingest seam failed (page kept): ${e?.message ?? e}`);
+                }
+            }
+        }
+        manifest.periods[key] = entry;
+        if (!o.dry && !o.outDir)
+            await ingestPendingPages(dir, manifest, { scrub, log, skipKey: key });
+        writeManifest(dir, manifest);
+        res.status = o.dry ? 'dry' : r.map ? 'written' : 'model-error';
+        log(`library: period ${p.index} rows #${p.startRowId}–#${p.endRowId} → ${res.status}${res.page ? ` ${res.page}` : ''} $${r.costUsd.toFixed(4)}${r.errors.length ? ` errors=${r.errors.join('; ')}` : ''}`);
+        return res;
+    }
+    catch (e) {
+        res.errors.push(e?.message ?? String(e));
+        log(`library: failed (fail-open): ${e?.message ?? e}`);
+        return { ...res, status: 'failed' };
+    }
+    finally {
+        if (timer)
+            clearInterval(timer);
+    }
+}

package/dist/content/lens-model.d.ts

@@ -0,0 +1,64 @@
+/**
+ * lens-model.ts — OpenRouter model calls for the content lens (map-reduce).
+ * OpenRouter ONLY — never the Claude subscription / Anthropic SDK.
+ *
+ * Model: big-window, env-overridable (OSBORN_CONTENT_LENS_MODEL). Default
+ * minimax/minimax-m3 — verified 2026-10-05 via GET /api/v1/models:
+ * context_length 1,048,576, $0.30/M prompt, $1.20/M completion (top provider
+ * 524,288 ctx). Window = 25% of the model's context_length, looked up live so an
+ * override is sized correctly; the constants below are only the fallback.
+ *
+ * Credit is limited, so every run has a HARD cap on calls AND dollars
+ * (OSBORN_LENS_MAX_CALLS / OSBORN_LENS_MAX_COST_USD). A call is refused up front
+ * if its worst-case cost would cross the cap; actual cost comes from OpenRouter's
+ * usage accounting when present.
+ */
+export declare const DEFAULT_MODEL = "minimax/minimax-m3";
+export declare const WINDOW_FRACTION = 0.25;
+export declare const lensModel: () => string;
+export interface ModelInfo {
+    id: string;
+    contextLength: number;
+    promptPerTok: number;
+    completionPerTok: number;
+    /** true = read from the OpenRouter models API this run; false = built-in fallback. */
+    verified: boolean;
+}
+/** Live context length + price. Null for an unknown overridden model (can't enforce the cost cap). */
+export declare function getModelInfo(apiKey: string, id?: string): Promise<ModelInfo | null>;
+export declare const windowTokensFor: (info: ModelInfo) => number;
+export declare class Budget {
+    readonly info: ModelInfo;
+    calls: number;
+    failures: number;
+    spentUsd: number;
+    refused: number;
+    readonly maxCalls: number;
+    readonly maxCostUsd: number;
+    /** caps override the env/default caps (e.g. the period map's own $0.50 hard cap). */
+    constructor(info: ModelInfo, caps?: {
+        maxCalls?: number;
+        maxCostUsd?: number;
+    });
+    estimate(promptTokens: number, maxOut: number): number;
+    /** Reserve one call if both caps allow its worst case. */
+    take(promptTokens: number, maxOut: number): boolean;
+}
+/**
+ * Transcript FIRST, instructions AFTER: measured on minimax-m3 with a ~257k-token
+ * window, instructions-before-transcript returned {"angles":[],"capabilities":[]}
+ * (the task gets lost in a long context); the query belongs at the end.
+ */
+export declare function mapPrompt(window: string, part: number, total: number, maxA: number, maxC: number): string;
+export declare function reducePrompt(candidatesJson: string, maxA: number, maxC: number): string;
+export interface ChatResult {
+    content: string;
+    /** 'stop' normally; 'length' = output cap hit (JSON likely truncated). */
+    finish: string;
+    provider: string;
+    promptTokens: number;
+    completionTokens: number;
+    costUsd: number;
+}
+/** One chat call. Returns null when the budget refuses; throws on HTTP/timeout errors. */
+export declare function chat(budget: Budget, user: string, apiKey: string, maxOut?: number): Promise<ChatResult | null>;