osborn 0.9.229 → 0.9.231

package/dist/claude-llm.js

@@ -358,7 +358,7 @@ export const NAMED_AGENTS = {
             'finding patterns, reading multiple files, searching for examples.',
             'Returns structured findings — does NOT make decisions or edit files.',
             'Use this for ANY task that needs more than 2 tool calls to gather information.',
-            'GROUNDED: reads the session search-index for prior findings before researching.',
+            'GROUNDED: reads the session recall store (osborn-recall) for prior findings before researching.',
         ].join(' '),
         tools: ['Read', 'Glob', 'Grep', 'Bash', 'WebSearch', 'WebFetch', 'Task'],
         grounded: true, // applyGrounding() injects the osborn-recall command + ensures Bash
@@ -419,7 +419,7 @@ export const NAMED_AGENTS = {
             'Think hard about complex problems. Consider multiple approaches. Identify risks and edge cases.',
             '',
             '## Session context',
-            'The orchestrator provides, as an artifact in your brief, the PATH to the session index file (search-index.txt — the running index of this session/mission). You MUST actually READ it — do not rely on a summary or a preloaded window. Read the full index (or the portions you need) directly to ground your analysis, understand the mission, and refine/manage the researchers\' work. Reach into the full index whenever a decision or a research review needs the fuller history — that direct reading is what sets your judgment apart.',
+            'You are deliberately NOT grounded (no raw session recall) — that keeps your analysis fresh and unbiased. Work from the STRUCTURED SUMMARIES the orchestrator hands you in your brief; do not attempt to pull raw session history yourself. If you need more context, ask the orchestrator for a structured summary rather than raw dumps.',
             '',
             '## How to work',
             '1. Read and understand the full context before forming an opinion.',
@@ -461,7 +461,7 @@ export const NAMED_AGENTS = {
             'Handles ALL file operations: code, config, docs, scripts, data files.',
             'VERIFY-FIRST workflow: checks assumptions before making changes, runs tests after.',
             'If anything is unclear, asks the main agent for clarification before touching files.',
-            'GROUNDED: reads the session search-index before editing to avoid contradicting prior decisions.',
+            'GROUNDED: reads the session recall store (osborn-recall) before editing to avoid contradicting prior decisions.',
         ].join(' '),
         tools: ['Read', 'Write', 'Edit', 'MultiEdit', 'Bash', 'Glob', 'Grep', 'NotebookRead', 'NotebookEdit'],
         grounded: true, // applyGrounding() injects the osborn-recall command
@@ -612,7 +612,7 @@ export const NAMED_AGENTS = {
             'ordered sequence of atomic writer-safe steps. Returns a self-contained brief the writer',
             'can execute without further clarification. Slow but thorough — only use for genuinely',
             'complex multi-file changes or when the approach is uncertain.',
-            'GROUNDED: reads the session search-index before planning to respect prior decisions.',
+            'GROUNDED: reads the session recall store (osborn-recall) before planning to respect prior decisions.',
         ].join(' '),
         tools: ['Read', 'Glob', 'Grep', 'WebSearch'],
         grounded: true, // applyGrounding() injects the osborn-recall command + adds Bash

package/dist/index.js

@@ -37,7 +37,6 @@ import { loadConfig, getMcpServers, getEnabledMcpServerNames, getVoiceMode, getD
 import { createSTT, createTTS } from './voice-io.js';
 import { createClaudeLLM, NAMED_AGENTS, applyTurbo } from './claude-llm.js';
 import { clearPipelineFastBrainSession, prewarmBM25Index } from './pipeline-fastbrain.js';
-import { getIndexPath, buildSummaryIndex } from './summary-index.js';
 import { ensureClaudeAuth, applyAuthFallback } from './claude-auth.js';
 import { createSmitheryProxy, destroySmitheryProxy, parseSmitheryUrl, isSmitheryUrl, SmitheryAuthorizationError } from './smithery-proxy.js';
 import { DIRECT_MODE_PROMPT } from './prompts.js';
@@ -1823,47 +1822,29 @@ function startApiServer(workingDir, port) {
  * OpenAI handles full history (30 exchanges, 2000 char content).
  */
 /**
- * Pass the session index path to the voice agent's ChatContext.
+ * Note to the voice agent's ChatContext on resume that prior conversation
+ * history is searchable via the recall store.
  *
- * For active/previously-run sessions the index already exists — startIndexWatcher
- * keeps it current throughout the conversation. We just hand the agent the file
- * path so it can reference it if the user asks about prior work. No file read at
- * resume time.
- *
- * Only exception: first-ever resume of a session that was never indexed (e.g. a
- * session started before the index watcher was added). In that case we build once.
+ * Native --resume already replays the session into the SDK, so this is not a
+ * context-injection path — it just reminds the agent that the FULL prior history
+ * (this + previous sessions) is queryable through the `osborn-recall` command,
+ * which reads the per-session recall store (session.db). We no longer inject the
+ * old flat search-index.txt path or its `lineNum|…` line format (retired).
  */
-function injectSessionIndexIntoChatCtx(agent, sessionId, workingDir) {
+function injectSessionIndexIntoChatCtx(agent, sessionId, _workingDir) {
     if (!agent || !sessionId)
         return;
     try {
-        let indexPath = getIndexPath(sessionId, workingDir);
-        if (!indexPath) {
-            // First-ever resume with no index — build once, then point at it
-            console.log(`🗂️ No index for ${sessionId.slice(0, 8)} — building (one-time)...`);
-            try {
-                const state = buildSummaryIndex(sessionId, workingDir);
-                indexPath = (state.indexPath && existsSync(state.indexPath) && statSync(state.indexPath).size > 0)
-                    ? state.indexPath : null;
-            }
-            catch {
-                return;
-            }
-        }
-        if (!indexPath)
-            return;
-        // Pass the path — don't read the file. Native --resume already loaded the session;
-        // this is just a reference the agent can use to search history if asked.
         const chatCtx = agent.chatCtx.copy();
         chatCtx.addMessage({
             role: 'user',
-            content: `[Session resume] Previous conversation history is indexed at: ${indexPath}\nFormat per line: lineNum|timestamp|source|msgType|summary`,
+            content: `[Session resume] Prior conversation history is searchable via the \`osborn-recall\` command (hybrid keyword + semantic recall over the session store). Use it if the user asks about earlier work.`,
         });
         agent.updateChatCtx(chatCtx);
-        console.log(`🗂️ Session index path injected: ${indexPath}`);
+        console.log(`🗂️ Session recall note injected for ${sessionId.slice(0, 8)}`);
     }
     catch (err) {
-        console.log('⚠️ Failed to inject session index path:', err);
+        console.log('⚠️ Failed to inject session recall note:', err);
     }
 }
 // Main function
@@ -2033,6 +2014,10 @@ async function main() {
     let currentLLM = null;
     const slots = new Map();
     let focusedSlotId = null; // reserved for future focused-slot wiring; not used yet
+    // P1 host-agent anchor: the dashboard-started session that owns the room's env + keeps it alive.
+    let hostActive = false;
+    let hostSessionId = null;
+    let hostWorkingDir = null;
     // Agent-side "alone in room" leave timer (see Room-presence lifecycle note up
     // top). Armed in ParticipantDisconnected once a user has left; if no one
     // rejoins within the grace window the agent leaves LiveKit on its own.
@@ -2047,7 +2032,31 @@ async function main() {
     // ParticipantDisconnected (covers a finished session). Cancelled the moment a
     // user joins. Net invariant: the agent never holds an empty room beyond
     // ALONE_GRACE_MS, in any scenario — the root cause of the 25h burn.
+    // P1: room stays alive while the host anchor is active or any background slot
+    // is running. Teardown timers below early-return on this so a dashboard-started
+    // session + its background dispatches aren't killed by the empty-room grace.
+    const agentsActive = () => hostActive || slots.size > 0;
+    // Release the host anchor + hard-kill background slots at a genuine session-end
+    // boundary so the room can idle-exit (agentsActive → false). Idempotent. MUST be
+    // called before arming idle-exit on EVERY path where the session ends, or the
+    // empty-room billing burn returns — the keep-alive guard is only as safe as its
+    // release sites (endMeeting / intentional-leave / destroyRoomSession / disconnect).
+    const releaseAgents = () => {
+        hostActive = false;
+        hostSessionId = null;
+        hostWorkingDir = null;
+        for (const [, s] of slots) {
+            try {
+                s.llm.abortQuery?.();
+                s.llm.abortAgent?.();
+            }
+            catch { }
+        }
+        slots.clear();
+    };
     const armAloneTimer = () => {
+        if (agentsActive())
+            return;
         if (aloneTimer)
             clearTimeout(aloneTimer);
         aloneTimer = null;
@@ -2073,6 +2082,8 @@ async function main() {
     let fastLeaveTimer = null;
     const POST_LEAVE_GRACE_MS = 20 * 1000;
     const armFastLeaveTimer = () => {
+        if (agentsActive())
+            return;
         if (fastLeaveTimer)
             clearTimeout(fastLeaveTimer);
         fastLeaveTimer = null;
@@ -2118,7 +2129,7 @@ async function main() {
             idleExitTimer = null;
             const stillIdle = livekitState.status === 'idle' || livekitState.status === 'failed';
             const empty = !activeRoom || activeRoom.remoteParticipants.size === 0;
-            if (stillIdle && empty) {
+            if (stillIdle && empty && !agentsActive()) {
                 console.log(`⏻ [IDLE-EXIT] still idle after grace — exiting 0 so Fly stops the machine (billing stops; next Resume boots it)`);
                 // Give the log tee a beat to flush, then stop the machine.
                 setTimeout(() => process.exit(0), 2000);
@@ -2172,21 +2183,10 @@ async function main() {
             return;
         try {
             const llm = currentLLM;
-            // Heap-OOM fix (2026-06-02): stop the PipelineDirectLLM summary-index
-            // watcher BEFORE we abort + drop the reference. The watcher is a 10s
-            // setInterval whose closure retains the entire PipelineDirectLLM →
-            // ClaudeLLM object graph. killCurrentLLM is the single chokepoint all
-            // three cleanup sites (Disconnected, previous-session-cleanup,
-            // ParticipantDisconnected) call, but it previously only aborted the
-            // SDK subprocess — leaving the interval (and the whole graph) alive and
-            // uncollectable on every disconnect/reconnect. A reconnect-heavy session
-            // (e.g. 15 reconnects from a frontend redeploy) leaked 15 timers + 15
-            // retained graphs, each re-reading JSONL every 10s, until the node heap
-            // OOM'd (~980MB) and the process crashed. Stopping the watcher here lets
-            // the abandoned graph be GC'd. Duck-typed: only PipelineDirectLLM has it.
-            if (typeof llm.stopIndexWatcher === 'function') {
-                llm.stopIndexWatcher();
-            }
+            // NOTE (fast-brain migration): the old summary-index 10s setInterval watcher
+            // was retired — fast-brain now reads the recall store (session.db) directly,
+            // so there is no per-LLM timer holding the PipelineDirectLLM → ClaudeLLM graph
+            // alive anymore. We only abort the SDK subprocess here.
             if (typeof llm.abortQuery === 'function') {
                 llm.abortQuery();
             }
@@ -2259,6 +2259,25 @@ async function main() {
             console.error(`❌ Background slot ${slotId.substring(0, 8)}: resume failed — requested ${requestedSessionId?.substring(0, 8)} got ${actualSessionId?.substring(0, 8)}`);
             sendToFrontend({ type: 'background_session_error', slotId, error: 'Session resume failed' }).catch(() => { });
         });
+        // P1: a real dispatch finished — notify the frontend. The [BACKGROUND_INIT]
+        // ack also fires assistant_result, so gate on dispatchInFlight to skip it.
+        bgEmitter.on('assistant_result', ({ text }) => {
+            const slot = slots.get(slotId);
+            if (!slot)
+                return;
+            // The [BACKGROUND_INIT] kickoff also fires assistant_result and, on the cold-spawn
+            // dispatch path, can arrive AFTER dispatchInFlight was set. Consume that first result
+            // as the kickoff ack so it's never mis-reported as (and never clobbers) the dispatch's
+            // real answer.
+            if (!slot.kickoffDone) {
+                slot.kickoffDone = true;
+                return;
+            }
+            if (!slot.dispatchInFlight)
+                return; // only notify for a real dispatched instruction
+            slot.dispatchInFlight = false;
+            sendToFrontend({ type: 'background_update', sessionId: slotId, stage: 'done', summary: (text || '').trim().slice(0, 500) }).catch(() => { });
+        });
         // Wire up the LLM's internal EventEmitter so hook-emitted events also flow.
         bgLLM.events.on('session_id', (data) => bgEmitter.emit('session_id', data));
         bgLLM.events.on('tool_blocked', (data) => bgEmitter.emit('tool_blocked', data));
@@ -2281,6 +2300,12 @@ async function main() {
             settingSources: ['project', 'user'],
             env: bgEnv,
         };
+        // P1: persist the cold-start emitter + sdkOptions on the slot so a later
+        // dispatch_background can reuse them. CRITICAL: pushMessage's fast path
+        // ignores the callbacks/emitter arg once the subprocess exists, so a
+        // dispatch MUST reuse THIS emitter — otherwise its output goes nowhere.
+        slot.emitter = bgEmitter;
+        slot.sdkOptions = bgSdkOptions;
         // Cold-start: deliver an init message so the subprocess actually spawns
         // and begins consuming the session JSONL.
         const KICKOFF_TEXT = '[BACKGROUND_INIT] You have been resumed in headless background mode. No voice session is active. Acknowledge receipt with a single brief line.';
@@ -2481,6 +2506,7 @@ async function main() {
             currentLLM = null;
             clearPipelineFastBrainSession();
             clearPipelineFastBrainSession();
+            releaseAgents(); // session over → clear host + kill slots so idle-exit can fire
             armIdleExitTimer(`meeting ended (${reason}), no user`);
         }
     };
@@ -3284,6 +3310,15 @@ async function main() {
         // PipelineDirectLLM (llmOverride path) wraps its own ClaudeLLM and may not expose setTurbo.
         directLLM?.setTurbo?.(turboMode);
         currentLLM = directLLM;
+        // P1 host-agent anchor: this dashboard-started session owns the room's env
+        // and keeps it alive (agentsActive → true) so background dispatches survive.
+        // Keep-alive keys off the hostActive boolean, NOT a session_id event;
+        // hostSessionId is best-effort (the focused id is otherwise resolved as
+        // currentLLM?.sessionId || currentResumeSessionId).
+        hostActive = true;
+        hostWorkingDir = workingDir;
+        if (resumeSessionId)
+            hostSessionId = resumeSessionId;
         // Reset the session always-allow list for each new direct session
         sessionAlwaysAllowPaths = new Set();
         // For resumed sessions, eagerly create workspace (we know the real ID)
@@ -3914,6 +3949,7 @@ async function main() {
             console.log('🕊️ Left LiveKit room intentionally — idle, awaiting /connect-room (no auto-rejoin)');
             // 0.9.73: idle machines must not bill forever — stop the Fly machine
             // after the grace window unless a /connect-room revives us first.
+            releaseAgents(); // session over → clear host + kill slots so idle-exit can fire
             armIdleExitTimer('intentional leave → idle');
             return;
         }
@@ -4576,10 +4612,6 @@ async function main() {
                     try {
                         // Reuse existing session ID so Claude SDK resumes where it left off
                         const recoverySessionId = currentLLM?.sessionId || resumeSessionId;
-                        // Stop old index watcher if it exists
-                        if (currentLLM && 'stopIndexWatcher' in currentLLM) {
-                            currentLLM.stopIndexWatcher();
-                        }
                         let result;
                         {
                             // Pipeline mode: recreate PipelineDirectLLM wrapper with fast brain
@@ -4877,6 +4909,12 @@ async function main() {
             currentLLM = null;
             clearPipelineFastBrainSession();
             clearPipelineFastBrainSession();
+            // P1 (CRITICAL FOR COST): the human left a non-meeting session. Clear the
+            // host anchor AND hard-kill every background slot so their subprocesses
+            // stop burning tokens. agentsActive() keeps the room alive on the host +
+            // slots, so this is the ONLY safe place to release them — leaving a slot
+            // alive here would defeat the empty-room teardown timers entirely.
+            releaseAgents();
             // Auto-leave path for a NON-meeting session. 0.9.83: a real session just
             // ended → use the FAST leave (~20s), not the 3-min alone grace. Fires even
             // on an abrupt tab close; cancelled if a user rejoins within the grace.
@@ -5781,6 +5819,39 @@ async function main() {
                     });
                 }
             }
+            else if (data.type === 'dispatch_background') {
+                // P1: push an instruction into a background slot (spawning it cold-start
+                // first if needed), then notify the frontend when the turn completes.
+                const targetSessionId = data.targetSessionId;
+                const instruction = data.instruction;
+                if (!targetSessionId || !instruction) {
+                    await sendToFrontend({ type: 'background_session_error', slotId: targetSessionId ?? null, error: 'dispatch_background requires targetSessionId + instruction' });
+                }
+                else {
+                    const focusedId = currentLLM?.sessionId || currentResumeSessionId || null;
+                    if (targetSessionId === focusedId) {
+                        await sendToFrontend({ type: 'background_session_error', slotId: targetSessionId, error: 'Target is the focused session — use the normal path' });
+                    }
+                    else {
+                        const doDispatch = () => {
+                            const slot = slots.get(targetSessionId);
+                            if (!slot || !slot.emitter || !slot.sdkOptions) {
+                                void sendToFrontend({ type: 'background_session_error', slotId: targetSessionId, error: 'Slot not ready' });
+                                return;
+                            }
+                            slot.dispatchInFlight = true;
+                            // Reuse the cold-start emitter — pushMessage's fast path ignores a
+                            // fresh emitter once the subprocess exists (see spawnBackgroundSession).
+                            slot.llm.pushMessage(instruction, slot.sdkOptions, { onSessionId: () => { }, onCheckpoint: () => { }, eventEmitter: slot.emitter });
+                            void sendToFrontend({ type: 'background_dispatched', sessionId: targetSessionId, instruction });
+                        };
+                        if (slots.has(targetSessionId))
+                            doDispatch();
+                        else
+                            spawnBackgroundSession(targetSessionId).then(doDispatch).catch((err) => { void sendToFrontend({ type: 'background_session_error', slotId: targetSessionId, error: err instanceof Error ? err.message : String(err) }); });
+                    }
+                }
+            }
             else if (data.type === 'list_slots') {
                 // Return all live slots: the focused session + every background slot.
                 const focusedId = currentLLM?.sessionId || currentResumeSessionId || null;
@@ -5959,6 +6030,7 @@ async function main() {
         if (!activeRoom) {
             // Already idle — still ensure billing backstop is armed.
             livekitState.status = 'idle';
+            releaseAgents(); // ensure no lingering host/slots keep the machine alive
             armIdleExitTimer(`destroyRoomSession(${reason}) — already idle`);
             return;
         }
@@ -5991,6 +6063,7 @@ async function main() {
         livekitState.status = 'idle';
         livekitState.error = null;
         livekitState.errorCode = null;
+        releaseAgents(); // session torn down → clear host + kill slots so idle-exit can fire
         armIdleExitTimer(`destroyRoomSession(${reason})`);
         destroyingRoomSession = false;
     };

package/dist/pipeline-direct-llm.d.ts

@@ -46,8 +46,6 @@ export declare class PipelineDirectLLM extends llm.LLM {
     #private;
     suppressMeetingTTS: boolean;
     constructor(opts: PipelineDirectOptions);
-    /** Stop the index watcher (call on disconnect/session switch) */
-    stopIndexWatcher(): void;
     get events(): EventEmitter;
     get sessionId(): string | null;
     get model(): string;

package/dist/pipeline-direct-llm.js

@@ -9,10 +9,9 @@
  * Phase 2 (future): Gemini speaks first, Claude suppressed when Gemini has HIGH confidence
  */
 import { llm, DEFAULT_API_CONNECT_OPTIONS } from '@livekit/agents';
-import { readFileSync } from 'fs';
 import { ClaudeLLM } from './claude-llm.js';
 import { askPipelineFastBrain } from './pipeline-fastbrain.js';
-import { buildSummaryIndex, startIndexWatcher, getIndexPath } from './summary-index.js';
+import { storeExists, openStore, recentRows } from './session-store.js';
 // ============================================================
 // SESSION TAIL — compact recent-conversation block prepended to every user turn
 // so the orchestrator never loses the thread across context compaction.
@@ -27,31 +26,33 @@ function buildSessionTail(sessionId, workingDir) {
         return '';
     const maxLines = parseInt(process.env.OSBORN_SESSION_TAIL_COUNT || '3000', 10);
     try {
-        const indexPath = getIndexPath(sessionId, workingDir);
-        if (!indexPath)
-            return '';
-        const raw = readFileSync(indexPath, 'utf-8');
-        const allLines = raw.split('\n').filter(Boolean);
-        // Read a larger raw window (4× target) then keep the last maxLines user+assistant entries
-        const rawWindow = allLines.slice(-maxLines * 4);
-        const convLines = [];
-        for (const line of rawWindow) {
-            const parts = line.split('|');
-            // format: lineNum|byteOffset|timestamp|source|msgType|summary
-            if (parts.length < 6)
-                continue;
-            const msgType = parts[4];
-            if (msgType !== 'user' && msgType !== 'assistant')
-                continue;
-            const timestamp = parts[2];
-            const speaker = msgType === 'user' ? 'User' : 'Assistant';
-            const summary = parts.slice(5).join('|').substring(0, 150);
-            convLines.push(`${timestamp}  ${speaker}: ${summary}`);
+        const dbPath = storeExists(sessionId, workingDir);
+        if (!dbPath)
+            return ''; // no store → prior empty-index behavior
+        const db = openStore(dbPath, { readonly: true });
+        try {
+            // Pull the most recent user+assistant rows (filtered in SQL, so we only
+            // decompress rows we keep), newest-first, then reverse to chronological.
+            const rows = recentRows(db, maxLines, ['user', 'assistant']);
+            const convLines = [];
+            for (const row of rows) {
+                if (row.msgType !== 'user' && row.msgType !== 'assistant')
+                    continue;
+                const timestamp = (row.ts || '').substring(0, 19);
+                const speaker = row.msgType === 'user' ? 'User' : 'Assistant';
+                const summary = row.text.replace(/[\n\r\t]+/g, ' ').replace(/\s+/g, ' ').trim().substring(0, 150);
+                convLines.push(`${timestamp}  ${speaker}: ${summary}`);
+            }
+            // recentRows is newest-first — reverse to chronological, then keep the tail.
+            convLines.reverse();
+            const kept = convLines.slice(-maxLines);
+            if (kept.length === 0)
+                return '';
+            return ['<session_tail>', ...kept, '</session_tail>'].join('\n');
+        }
+        finally {
+            db.close();
         }
-        const kept = convLines.slice(-maxLines);
-        if (kept.length === 0)
-            return '';
-        return ['<session_tail>', ...kept, '</session_tail>'].join('\n');
     }
     catch {
         return '';
@@ -61,8 +62,6 @@ export class PipelineDirectLLM extends llm.LLM {
     #claudeLLM;
     #opts;
     #turnAbort = null;
-    #indexWatcher = null;
-    #indexBuilding = false;
     // Set to true when PostCompact fires — cleared after injecting the tail once
     // on the next real user turn (seam-only injection, never per-turn).
     #postCompactionTailPending = false;
@@ -88,13 +87,6 @@ export class PipelineDirectLLM extends llm.LLM {
         this.#claudeLLM = new ClaudeLLM(chainedOpts);
         this.#opts = chainedOpts;
     }
-    /** Stop the index watcher (call on disconnect/session switch) */
-    stopIndexWatcher() {
-        if (this.#indexWatcher) {
-            this.#indexWatcher.stop();
-            this.#indexWatcher = null;
-        }
-    }
     // Proxy all properties
     get events() { return this.#claudeLLM.events; }
     get sessionId() { return this.#claudeLLM.sessionId; }
@@ -105,8 +97,6 @@ export class PipelineDirectLLM extends llm.LLM {
     setResumeSessionId(id) { this.#claudeLLM.setResumeSessionId(id); }
     setContinueSession(e) { this.#claudeLLM.setContinueSession(e); }
     resetForSessionSwitch() {
-        this.stopIndexWatcher();
-        this.#indexBuilding = false;
         this.#claudeLLM.resetForSessionSwitch();
     }
     respondToPermission(allow, msg) { this.#claudeLLM.respondToPermission(allow, msg); }
@@ -326,20 +316,6 @@ export class PipelineDirectLLM extends llm.LLM {
         }
         const workingDir = this.#opts.workingDirectory || process.cwd();
         const sessionBaseDir = this.#opts.sessionBaseDir || workingDir;
-        // Build summary index on first question (async, non-blocking for subsequent questions)
-        if (!this.#indexWatcher && !this.#indexBuilding && sessionId !== 'pending') {
-            this.#indexBuilding = true;
-            try {
-                const startBuild = Date.now();
-                const state = buildSummaryIndex(sessionId, workingDir, undefined, (msg) => console.log(`🔍 [index] ${msg}`));
-                this.#indexWatcher = startIndexWatcher(sessionId, workingDir, undefined, state);
-                console.log(`🔍 [index] Built + watching in ${Date.now() - startBuild}ms`);
-            }
-            catch (err) {
-                console.error('🔍 [index] Build failed:', err?.message);
-            }
-            this.#indexBuilding = false;
-        }
         // NOTE: the embedded session.db write-through was CONSOLIDATED into the main agent's
         // UserPromptSubmit hook (claude-llm.ts) — one canonical trigger per real user submission,
         // main-thread only, sweeping main + all sub-agent JSONLs. Kept out of the per-turn pipeline

package/dist/session-store.d.ts

@@ -92,5 +92,7 @@ export declare function recall(db: Database.Database, query: string, opts?: Reca
  * Return the most recent N content rows (highest id = latest, append-only order),
  * newest first, as RecallHit-shaped objects. Powers fast-brain's "recent entries"
  * path. Encapsulates decompress so callers never touch the blob/compression.
+ * `msgTypes` optionally filters by msg_type IN SQL — so callers that only want
+ * user/assistant rows don't decompress rows they'd discard.
  */
-export declare function recentRows(db: Database.Database, count: number): RecallHit[];
+export declare function recentRows(db: Database.Database, count: number, msgTypes?: string[]): RecallHit[];

package/dist/session-store.js

@@ -575,10 +575,16 @@ export async function recall(db, query, opts) {
  * Return the most recent N content rows (highest id = latest, append-only order),
  * newest first, as RecallHit-shaped objects. Powers fast-brain's "recent entries"
  * path. Encapsulates decompress so callers never touch the blob/compression.
+ * `msgTypes` optionally filters by msg_type IN SQL — so callers that only want
+ * user/assistant rows don't decompress rows they'd discard.
  */
-export function recentRows(db, count) {
+export function recentRows(db, count, msgTypes) {
+    const filter = msgTypes && msgTypes.length
+        ? `WHERE msg_type IN (${msgTypes.map(() => '?').join(', ')})`
+        : '';
+    const params = msgTypes && msgTypes.length ? [...msgTypes, Math.max(1, count)] : [Math.max(1, count)];
     const rows = db.prepare(`SELECT id, source, line_num, byte_offset, ts, msg_type, model, git_branch, cwd, tool_name, blob
-     FROM content ORDER BY id DESC LIMIT ?`).all(Math.max(1, count));
+     FROM content ${filter} ORDER BY id DESC LIMIT ?`).all(...params);
     return rows.map((row) => ({
         id: row.id,
         source: row.source,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osborn",
-  "version": "0.9.229",
+  "version": "0.9.231",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {