osborn 0.9.250 → 0.9.251

package/dist/content/lens-clip-search.js

@@ -0,0 +1,138 @@
+/**
+ * lens-clip-search.ts — REVERSE direction + compilation topic search.
+ *
+ * demand thread (or topic) → a few search queries (one cheap model call) → the
+ * recall store's OWN search (session-store.ts recall(): FTS5 BM25 + vector, RRF,
+ * read-only) over session.db → keep only conversation rows the lens may read
+ * (sanitized user/assistant main rows) → cluster nearby hits → anchors.
+ * A weak cluster (few distinct queries / few hits) is reported as such; the
+ * caller then refuses to force a draft.
+ */
+import { openStore, recall } from '../session-store.js';
+import { getEmbedder } from '../embedder.js';
+import { clusterAnchors } from './lens-clip-window.js';
+import { parseJsonObject } from './lens-quotes.js';
+const FETCH_TIMEOUT_MS = 15_000;
+async function getJson(url) {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const r = await fetch(url, { signal: ctrl.signal, headers: { 'User-Agent': 'osborn-content-lens', Accept: 'application/json' } });
+        if (!r.ok)
+            throw new Error(`HTTP ${r.status} for ${url}`);
+        return await r.json();
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+/** Public thread → plain text. GitHub issues/PRs and HN items via their JSON APIs; anything else as stripped HTML. */
+export async function fetchThread(url, maxComments = 15) {
+    const gh = url.match(/github\.com\/([^/]+)\/([^/]+)\/(?:issues|pull)\/(\d+)/);
+    if (gh) {
+        const base = `https://api.github.com/repos/${gh[1]}/${gh[2]}/issues/${gh[3]}`;
+        const issue = await getJson(base);
+        const comments = issue?.comments ? await getJson(`${base}/comments?per_page=${maxComments}`).catch(() => []) : [];
+        const parts = [`# ${issue?.title ?? ''}`, String(issue?.body ?? ''), ...comments.map(c => `--- comment by ${c?.user?.login ?? '?'}:\n${c?.body ?? ''}`)];
+        return { title: String(issue?.title ?? ''), text: parts.join('\n\n').slice(0, 20_000) };
+    }
+    const hn = url.match(/news\.ycombinator\.com\/item\?id=(\d+)/);
+    if (hn) {
+        const it = await getJson(`https://hn.algolia.com/api/v1/items/${hn[1]}`);
+        const strip = (s) => String(s ?? '').replace(/<[^>]+>/g, ' ').replace(/&#x27;/g, "'").replace(/&quot;/g, '"').replace(/&amp;/g, '&');
+        const kids = (it?.children ?? []).slice(0, maxComments).map((c) => `--- ${c?.author ?? '?'}: ${strip(c?.text)}`);
+        return { title: String(it?.title ?? ''), text: [`# ${it?.title ?? ''}`, strip(it?.text), ...kids].join('\n\n').slice(0, 20_000) };
+    }
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const r = await fetch(url, { signal: ctrl.signal });
+        if (!r.ok)
+            throw new Error(`HTTP ${r.status} for ${url}`);
+        const html = await r.text();
+        const title = html.match(/<title>([^<]*)<\/title>/i)?.[1]?.trim() ?? '';
+        const body = html.replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>/gi, ' ').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ');
+        return { title, text: body.slice(0, 20_000) };
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+/** Short prompt: demand thread / topic → core problem + 3-5 search queries (instructions after the material). */
+export function queriesPrompt(material, kind) {
+    return [
+        kind === 'thread' ? `<demand_thread>\n${material.slice(0, 12_000)}\n</demand_thread>` : `<topic>\n${material}\n</topic>`,
+        'TASK: state the core problem in one line, then write 3-5 short search queries (2-6 words each) to find where a developer ' +
+            'talked through THIS problem with their AI coding assistant in a voice session. Mix symptom words (what they would ' +
+            'have seen/complained about) and mechanism words (what the cause or fix would be called). Plain words, no operators.',
+        'Output ONLY: {"problem": "...", "queries": ["...", "..."]}',
+    ].join('\n\n');
+}
+export function readQueries(raw) {
+    const o = parseJsonObject(raw);
+    if (!o || !Array.isArray(o.queries))
+        return null;
+    const queries = o.queries.map(q => String(q ?? '').trim()).filter(Boolean).slice(0, 5);
+    return queries.length ? { problem: String(o.problem ?? '').trim(), queries } : null;
+}
+/** Group hits into clusters of nearby conversation rows and rank them. Pure. */
+export function rankClusters(records, hits, mergeRows = 40) {
+    const byId = new Map(records.map(r => [r.id, r]));
+    return clusterAnchors(records, [...hits.keys()], mergeRows)
+        .map(rows => {
+        const qs = new Set();
+        let score = 0;
+        for (const id of rows) {
+            const h = hits.get(id);
+            score += h.score;
+            for (const q of h.queries)
+                qs.add(q);
+        }
+        const sorted = [...rows].sort((a, b) => a - b);
+        return {
+            rows: sorted, score: +(score * qs.size).toFixed(4), hits: rows.length, queries: [...qs],
+            firstTs: byId.get(sorted[0])?.timestamp ?? '', lastTs: byId.get(sorted[sorted.length - 1])?.timestamp ?? '',
+        };
+    })
+        .sort((a, b) => b.score - a.score);
+}
+/** Weak = the best cluster is matched by < 2 distinct queries or has < 3 hits. */
+export function isWeak(c, nQueries) {
+    if (!c)
+        return { weak: true, why: 'no conversation rows matched any query' };
+    const minQ = Math.min(2, nQueries);
+    if (c.queries.length < minQ)
+        return { weak: true, why: `best cluster matched only ${c.queries.length}/${nQueries} queries` };
+    if (c.hits < 3)
+        return { weak: true, why: `best cluster has only ${c.hits} matching row(s)` };
+    return { weak: false, why: '' };
+}
+/**
+ * Run each query through recall() (hybrid when an embedder is available, else
+ * keyword), keep only rows present in `records` (the sanitized conversation view).
+ */
+export async function searchSession(dbPath, records, queries, topK = 60) {
+    const allowed = new Set(records.map(r => r.id));
+    const embed = await getEmbedder().catch(() => null);
+    const db = openStore(dbPath, { readonly: true });
+    const hits = new Map();
+    try {
+        for (const q of queries) {
+            const res = await recall(db, q, { mode: embed ? 'hybrid' : 'keyword', topK, embed: embed ?? undefined });
+            for (const h of res) {
+                if (!allowed.has(h.id))
+                    continue;
+                const cur = hits.get(h.id) ?? { score: 0, queries: new Set() };
+                cur.score += h.score;
+                cur.queries.add(q);
+                hits.set(h.id, cur);
+            }
+        }
+    }
+    finally {
+        db.close();
+    }
+    const clusters = rankClusters(records, hits);
+    const w = isWeak(clusters[0], queries.length);
+    return { clusters, mode: embed ? 'hybrid' : 'keyword', weak: w.weak, weakWhy: w.why };
+}

package/dist/content/lens-clip-window.d.ts

@@ -0,0 +1,72 @@
+/**
+ * lens-clip-window.ts — pass two (the clipper), step 1-2: pick the anchor rows
+ * and pull the FULL surrounding stretch of conversation out of session.db.
+ *
+ * Pure + deterministic (no model): keyword-overlap topic heuristic. Starts from
+ * anchors ± seedRows, grows outward one block at a time, alternating sides; a
+ * block counts as on-topic when it shares enough weighted (idf) terms with the
+ * seed's topic profile. Short off-topic detours are bridged (gapBlocks); a longer
+ * one ends that side. Compaction seams and long silences (time gaps) are SOFT
+ * limits: crossed only by a strongly on-topic block. Hard cap = maxTokens
+ * (callers pass 25% of the model's context).
+ */
+import { type DbRecord } from './lens-db.js';
+export type StopReason = 'topic-shift' | 'soft-limit:compaction' | 'soft-limit:time-gap' | 'cap' | 'session-edge';
+export interface ExpandOptions {
+    seedRows?: number;
+    blockRows?: number;
+    /** Block score (0..1) at/above which a block is on-topic. */
+    threshold?: number;
+    /** Mean score of the 2 blocks beyond a soft limit (compaction seam / time gap) needed to cross it. */
+    strongThreshold?: number;
+    /** Off-topic blocks bridged before a side stops. */
+    gapBlocks?: number;
+    maxTokens?: number;
+    /** Silence between adjacent rows treated as a soft limit. */
+    softGapMs?: number;
+    /** content.ids of compaction seams (readCompactionBoundaries). */
+    boundaries?: number[];
+    /** Anchors within this many conversation rows of each other are merged. */
+    mergeRows?: number;
+}
+export interface ClipWindow {
+    records: DbRecord[];
+    firstRowId: number;
+    lastRowId: number;
+    estTokens: number;
+    anchors: number[];
+    /** Anchor rows in other (far-away) clusters, not used for this window. */
+    otherAnchors: number[];
+    stop: {
+        before: StopReason;
+        after: StopReason;
+    };
+    profile: string[];
+    blocks: {
+        side: 'before' | 'after';
+        firstRowId: number;
+        lastRowId: number;
+        score: number;
+        kept: boolean;
+    }[];
+}
+/** Lower-cased content terms (3+ chars, no stopwords). Keeps tokens like x-forwarded-host, 1006, 0.9.153. */
+export declare function terms(text: string): Set<string>;
+/** Merge anchor row ids into clusters of nearby conversation rows (by record index). */
+export declare function clusterAnchors(records: DbRecord[], anchors: number[], mergeRows?: number): number[][];
+export declare function expandWindow(records: DbRecord[], anchorIds: number[], opts?: ExpandOptions): ClipWindow | null;
+/** Compaction seams: moved to the period-owned lens-period-boundaries.ts (re-exported for the clipper). */
+export { readCompactionBoundaries } from './lens-period-boundaries.js';
+/** Row anchors from a lens output file: every `(row #N)` inside angles/capabilities whose title matches `query`. */
+export declare function parseLensAnchors(md: string, query: string): {
+    title: string;
+    rows: number[];
+}[];
+/**
+ * Multi-stretch: every anchor cluster expanded on its own (each gets an equal share
+ * of maxTokens), overlapping windows merged, ordered chronologically. Used for
+ * montage clips and the polished compilation (same session, different stretches).
+ */
+export declare function expandClusters(records: DbRecord[], anchorIds: number[], opts?: ExpandOptions & {
+    maxClusters?: number;
+}): ClipWindow[];

package/dist/content/lens-clip-window.js

@@ -0,0 +1,257 @@
+/**
+ * lens-clip-window.ts — pass two (the clipper), step 1-2: pick the anchor rows
+ * and pull the FULL surrounding stretch of conversation out of session.db.
+ *
+ * Pure + deterministic (no model): keyword-overlap topic heuristic. Starts from
+ * anchors ± seedRows, grows outward one block at a time, alternating sides; a
+ * block counts as on-topic when it shares enough weighted (idf) terms with the
+ * seed's topic profile. Short off-topic detours are bridged (gapBlocks); a longer
+ * one ends that side. Compaction seams and long silences (time gaps) are SOFT
+ * limits: crossed only by a strongly on-topic block. Hard cap = maxTokens
+ * (callers pass 25% of the model's context).
+ */
+import { recordView, estimateTokens } from './lens-db.js';
+const STOP = new Set(('the and for that this with you your are was were have has had not but just like what when then them they there ' +
+    'their about from into would could should will can its it\'s i\'m don\'t that\'s okay yeah yes so um uh know ' +
+    'mean really actually basically right going gonna wanna want need let\'s lets thing things also well even still ' +
+    'here more some only very much make made does did doing done been being which where while because since each ' +
+    'other than over our out all any one two who how why way get got see say said sure think now back time ' +
+    'kind sort something maybe stuff look looks good same work working').split(/\s+/));
+/** Lower-cased content terms (3+ chars, no stopwords). Keeps tokens like x-forwarded-host, 1006, 0.9.153. */
+export function terms(text) {
+    const out = new Set();
+    for (const m of text.toLowerCase().matchAll(/[a-z0-9][a-z0-9._'-]*[a-z0-9]/g)) {
+        const t = m[0];
+        if (t.length >= 3 && !STOP.has(t) && !/^\d{1,2}$/.test(t))
+            out.add(t);
+    }
+    return out;
+}
+/** Merge anchor row ids into clusters of nearby conversation rows (by record index). */
+export function clusterAnchors(records, anchors, mergeRows = 60) {
+    const idxOf = (id) => {
+        let i = records.findIndex(r => r.id >= id);
+        if (i === -1)
+            i = records.length - 1;
+        return i;
+    };
+    const pts = [...new Set(anchors)].filter(n => Number.isFinite(n)).map(id => ({ id, i: idxOf(id) })).sort((a, b) => a.i - b.i);
+    const clusters = [];
+    for (const p of pts) {
+        const last = clusters[clusters.length - 1];
+        if (last && p.i - last[last.length - 1].i <= mergeRows)
+            last.push(p);
+        else
+            clusters.push([p]);
+    }
+    return clusters.map(c => c.map(p => p.id));
+}
+/** Soft limit between two adjacent records (earlier a, later b), or null. */
+function softLimit(a, b, o) {
+    if (o.boundaries.some(x => x > a.id && x <= b.id))
+        return 'soft-limit:compaction';
+    const gap = Date.parse(b.timestamp) - Date.parse(a.timestamp);
+    if (Number.isFinite(gap) && gap >= o.softGapMs)
+        return 'soft-limit:time-gap';
+    return null;
+}
+export function expandWindow(records, anchorIds, opts = {}) {
+    const o = {
+        seedRows: 12, blockRows: 8, threshold: 0.1, strongThreshold: 0.1, gapBlocks: 4, maxTokens: 200_000,
+        softGapMs: 3 * 3600_000, boundaries: [], mergeRows: 60, ...opts,
+    };
+    if (!records.length || !anchorIds.length)
+        return null;
+    const clusters = clusterAnchors(records, anchorIds, o.mergeRows);
+    const main = [...clusters].sort((a, b) => b.length - a.length)[0];
+    const idx = main.map(id => Math.max(0, records.findIndex(r => r.id >= id))).map(i => (i === -1 ? records.length - 1 : i));
+    let lo = Math.max(0, Math.min(...idx) - o.seedRows);
+    let hi = Math.min(records.length - 1, Math.max(...idx) + o.seedRows);
+    // Seed never crosses a soft limit away from the anchors.
+    for (let i = Math.min(...idx); i > lo; i--)
+        if (softLimit(records[i - 1], records[i], o)) {
+            lo = i;
+            break;
+        }
+    for (let i = Math.max(...idx); i < hi; i++)
+        if (softLimit(records[i], records[i + 1], o)) {
+            hi = i;
+            break;
+        }
+    // Topic profile: seed terms weighted by session idf (rare-in-session terms weigh more).
+    const df = new Map();
+    const termCache = records.map(r => terms(r.text));
+    for (const ts of termCache)
+        for (const t of ts)
+            df.set(t, (df.get(t) ?? 0) + 1);
+    const N = records.length;
+    const tf = new Map();
+    for (let i = lo; i <= hi; i++)
+        for (const t of termCache[i])
+            tf.set(t, (tf.get(t) ?? 0) + 1);
+    const weighted = [...tf]
+        .map(([t, c]) => [t, (1 + Math.log(c)) * Math.log((N + 1) / (df.get(t) ?? 1))])
+        .filter(([, w]) => w > 0)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 40);
+    const profile = new Map(weighted);
+    const total = weighted.reduce((a, [, w]) => a + w, 0) || 1;
+    const score = (from, to) => {
+        const seen = new Set();
+        for (let i = from; i <= to; i++)
+            for (const t of termCache[i])
+                if (profile.has(t))
+                    seen.add(t);
+        let s = 0;
+        for (const t of seen)
+            s += profile.get(t);
+        return s / total;
+    };
+    const viewTok = records.map(r => estimateTokens(recordView(r).length + 2));
+    let tokens = 0;
+    for (let i = lo; i <= hi; i++)
+        tokens += viewTok[i];
+    /** Far index of a block starting at `start` going `dir`, never spanning a soft limit. */
+    const blockEnd = (start, dir) => {
+        let end = start;
+        for (let k = 1; k < o.blockRows; k++) {
+            const nx = end + dir;
+            if (nx < 0 || nx >= N)
+                break;
+            const p = dir < 0 ? [records[nx], records[end]] : [records[end], records[nx]];
+            if (softLimit(p[0], p[1], o))
+                break;
+            end = nx;
+        }
+        return end;
+    };
+    const blocks = [];
+    const sides = [
+        { dir: -1, edge: lo, pending: lo, misses: 0, done: null },
+        { dir: 1, edge: hi, pending: hi, misses: 0, done: null },
+    ];
+    while (sides.some(s => !s.done)) {
+        for (const s of sides) {
+            if (s.done)
+                continue;
+            const start = s.pending + s.dir;
+            if (start < 0 || start >= N) {
+                s.done = 'session-edge';
+                continue;
+            }
+            const pair = s.dir < 0 ? [records[start], records[s.pending]] : [records[s.pending], records[start]];
+            const limit = softLimit(pair[0], pair[1], o);
+            const end = blockEnd(start, s.dir);
+            const [from, to] = s.dir < 0 ? [end, start] : [start, end];
+            const sc = score(from, to);
+            if (limit) {
+                // Cross a seam/silence only if the story clearly continues: mean of this block and the next one beyond it.
+                const nStart = end + s.dir;
+                let ahead = sc;
+                if (nStart >= 0 && nStart < N) {
+                    const nEnd = blockEnd(nStart, s.dir);
+                    ahead = (sc + (s.dir < 0 ? score(nEnd, nStart) : score(nStart, nEnd))) / 2;
+                }
+                if (ahead < o.strongThreshold) {
+                    s.done = limit;
+                    continue;
+                }
+            }
+            // Tokens of everything between the kept edge and this block's far end.
+            let add = 0;
+            const [pf, pt] = s.dir < 0 ? [end, s.edge - 1] : [s.edge + 1, end];
+            for (let i = pf; i <= pt; i++)
+                add += viewTok[i];
+            const on = sc >= o.threshold;
+            if (on && tokens + add > o.maxTokens) {
+                s.done = 'cap';
+                continue;
+            }
+            blocks.push({ side: s.dir < 0 ? 'before' : 'after', firstRowId: records[from].id, lastRowId: records[to].id, score: +sc.toFixed(3), kept: on });
+            s.pending = end;
+            if (on) {
+                tokens += add;
+                s.edge = end;
+                s.misses = 0;
+                if (s.dir < 0)
+                    lo = end;
+                else
+                    hi = end;
+            }
+            else if (++s.misses > o.gapBlocks)
+                s.done = 'topic-shift';
+        }
+    }
+    // Bridged detours are kept only when a later block was accepted: mark trailing misses unkept.
+    const recs = records.slice(lo, hi + 1);
+    return {
+        records: recs,
+        firstRowId: recs[0].id,
+        lastRowId: recs[recs.length - 1].id,
+        estTokens: tokens,
+        anchors: main,
+        otherAnchors: clusters.filter(c => c !== main).flat(),
+        stop: { before: sides[0].done, after: sides[1].done },
+        profile: weighted.slice(0, 15).map(([t]) => t),
+        blocks: blocks.map(b => ({ ...b, kept: b.firstRowId >= recs[0].id && b.lastRowId <= recs[recs.length - 1].id })),
+    };
+}
+/** Compaction seams: moved to the period-owned lens-period-boundaries.ts (re-exported for the clipper). */
+export { readCompactionBoundaries } from './lens-period-boundaries.js';
+/** Row anchors from a lens output file: every `(row #N)` inside angles/capabilities whose title matches `query`. */
+export function parseLensAnchors(md, query) {
+    const q = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const items = [];
+    let cur = null;
+    for (const line of md.split('\n')) {
+        const angle = line.match(/^####\s+(.+)$/);
+        const cap = line.match(/^- \*\*(.+?)\*\*(?!:)/);
+        if (angle || (cap && !/^(Why postable|Verified quotes|Gap evidence)/.test(cap[1]))) {
+            cur = { title: (angle ? angle[1] : cap[1]).trim(), body: [] };
+            items.push(cur);
+        }
+        else if (/^#{1,3}\s/.test(line))
+            cur = null;
+        else if (cur)
+            cur.body.push(line);
+    }
+    return items
+        .filter(it => q.every(w => it.title.toLowerCase().includes(w)))
+        .map(it => ({ title: it.title, rows: [...it.body.join('\n').matchAll(/\(row #(\d+)\)/g)].map(m => Number(m[1])) }))
+        .filter(it => it.rows.length);
+}
+/**
+ * Multi-stretch: every anchor cluster expanded on its own (each gets an equal share
+ * of maxTokens), overlapping windows merged, ordered chronologically. Used for
+ * montage clips and the polished compilation (same session, different stretches).
+ */
+export function expandClusters(records, anchorIds, opts = {}) {
+    const clusters = clusterAnchors(records, anchorIds, opts.mergeRows ?? 60).slice(0, opts.maxClusters ?? 8);
+    if (!clusters.length)
+        return [];
+    const share = Math.floor((opts.maxTokens ?? 200_000) / clusters.length);
+    const wins = clusters
+        .map(c => expandWindow(records, c, { ...opts, maxTokens: share, mergeRows: Number.MAX_SAFE_INTEGER }))
+        .filter((w) => !!w)
+        .sort((a, b) => a.firstRowId - b.firstRowId);
+    const out = [];
+    for (const w of wins) {
+        const last = out[out.length - 1];
+        if (last && w.firstRowId <= last.lastRowId) {
+            const ids = new Set(last.records.map(r => r.id));
+            const recs = [...last.records, ...w.records.filter(r => !ids.has(r.id))].sort((a, b) => a.id - b.id);
+            out[out.length - 1] = {
+                ...last,
+                records: recs,
+                lastRowId: recs[recs.length - 1].id,
+                estTokens: recs.reduce((s, r) => s + estimateTokens(recordView(r).length + 2), 0),
+                anchors: [...last.anchors, ...w.anchors],
+                stop: { before: last.stop.before, after: w.stop.after },
+                blocks: [...last.blocks, ...w.blocks],
+            };
+        }
+        else
+            out.push(w);
+    }
+    return out.map(w => ({ ...w, otherAnchors: [] }));
+}

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

@@ -0,0 +1,70 @@
+/**
+ * lens-db.ts — the content lens's SOURCE: the per-session recall store
+ * (`session.db`, the same SQLite file `osborn-recall` queries), keyed by session ID.
+ *
+ *   <claudeDir>/projects/<slug>/osb/<sessionId>/session.db
+ *     content(id INTEGER PK, source TEXT, line_num, byte_offset, ts TEXT,
+ *             msg_type TEXT, model, git_branch, cwd, tool_name, blob BLOB)
+ *   blob = brotli-compressed full text (session-store.ts compress()).
+ *   id is append-only and chronological; source = 'main' | 'agent-<id8>'.
+ *
+ * CONVERSATION ONLY: msg_type IN ('user','assistant'); thinking / tool_use /
+ * tool_result rows are never read. Default source is the main thread only
+ * (sub-agent rows are the orchestrator's prompts + agent chatter, not the
+ * conversation); OSBORN_LENS_INCLUDE_SUBAGENTS=1 widens it.
+ *
+ * Every pulled row goes through the same sanitizer as before (drops harness
+ * wrappers like <session_tail>/[EMERGENCY STOP], unwraps [INTERRUPTED]/[CONTEXT]
+ * to the user's actual words) and then a second redaction pass in assistant
+ * mode ({assistant:true}, i.e. incl. the high-entropy fallback) for BOTH speakers,
+ * then the optional client/customer redactor (names, IDs, emails, billing amounts).
+ * Opened read-only; never writes to the store.
+ */
+export interface DbRecord {
+    /** content.id in session.db — the row the quote is verified against. */
+    id: number;
+    timestamp: string;
+    speaker: 'user' | 'assistant';
+    text: string;
+}
+export interface DbLoad {
+    dbPath: string;
+    records: DbRecord[];
+    /** Highest content.id scanned (incl. rows the sanitizer dropped) — the next high-water mark. */
+    maxRowId: number;
+    stats: {
+        rowsRead: number;
+        dropped: number;
+        unwrapped: number;
+        chars: number;
+        /** Rows touched per injected-context kind (lens-strip.ts) + sanitizer actions. */
+        stripped: Record<string, number>;
+    };
+}
+export declare const CHARS_PER_TOKEN = 4;
+/**
+ * Resolve session.db for a session id: <projectDir>/osb/<sid>/session.db, then
+ * the cwd slug, then a scan of every project's osb dir (same layout as
+ * session-store.ts getStorePath / recall-cli listStores).
+ */
+export declare function resolveSessionDb(sessionId: string, projectDir?: string | null, cwd?: string): string | null;
+export declare function includeSubagents(): boolean;
+/**
+ * Read conversation rows with id > afterRowId, in id order, sanitized.
+ * Throws if the DB can't be opened (caller logs + exits).
+ */
+export declare function loadConversationRows(dbPath: string, afterRowId?: number, clientRedact?: (s: string) => string, throughRowId?: number): DbLoad;
+/** Record as the model sees it: header with row id, exact timestamp, speaker. */
+export declare function recordView(r: DbRecord): string;
+export declare const estimateTokens: (chars: number) => number;
+export interface Window {
+    index: number;
+    text: string;
+    records: DbRecord[];
+    firstRowId: number;
+    lastRowId: number;
+    chars: number;
+    estTokens: number;
+}
+/** Pack records IN ORDER into windows of ≤ windowTokens (estimated at CHARS_PER_TOKEN). */
+export declare function packWindows(records: DbRecord[], windowTokens: number): Window[];