osborn 0.9.232 → 0.9.234

package/dist/claude-llm.js

@@ -58,7 +58,13 @@ async function buildRecallInjection(sessionId, workingDir, prompt) {
         // fetch, not a local model load). If embed is null, recall() runs keyword-only.
         const embed = process.env.OSBORN_EMBED !== '0' ? (await getEmbedder(QUERY_EMBED_TIMEOUT_MS)) ?? undefined : undefined;
         const { getStorePath } = await import('./session-store.js');
-        const db = openStore(getStorePath(sessionId, workingDir));
+        // READ-ONLY open (regression fix): the writable branch runs synchronous
+        // migration/DDL + meta writes every turn AND lock-contends with the concurrent
+        // ingest writer (triggerStoreUpdate) — under WAL those serialize, stacking the
+        // 5s busy_timeout per statement and blowing the UserPromptSubmit hook past 30s.
+        // A readonly connection takes only SHARED locks and never blocks. storeExists()
+        // above guarantees the DB is present, so readonly can't fail on a missing file.
+        const db = openStore(getStorePath(sessionId, workingDir), { readonly: true });
         let hits;
         try {
             hits = await recall(db, q, { mode: embed ? 'hybrid' : 'keyword', topK: RECALL_TOP_K, embed });
@@ -1577,8 +1583,15 @@ export class ClaudeLLM extends llm.LLM {
                 if (msg.requestId) {
                     callbacks.eventEmitter.emit('query_request_id', { requestId: msg.requestId });
                 }
-                // Stream assistant text → tts_say events
-                if (msg.type === 'assistant' && msg.message?.content) {
+                // Stream assistant text → tts_say events.
+                // SUBAGENT GUARD (regression fix): the SDK surfaces a Task sub-agent's assistant
+                // messages inline in THIS same stream, tagged with a non-null parent_tool_use_id
+                // ("non-null when the message was produced inside a subagent" — SDK docs). Only the
+                // MAIN orchestrator (parent_tool_use_id === null) may speak or post a chat bubble;
+                // a sub-agent's raw narration must NOT reach TTS/UI (its work already shows via the
+                // tool_use activity events). Without this, once verifiers/researcher became real Task
+                // sub-agents their text "took over the mic" and leaked raw code/markdown into audio.
+                if (msg.type === 'assistant' && msg.message?.content && !msg.parent_tool_use_id) {
                     // Assign a stable messageId for this turn (first block sets it, rest reuse)
                     if (!this.#currentTurnMessageId) {
                         this.#currentTurnMessageId = crypto.randomUUID();
@@ -1630,6 +1643,11 @@ export class ClaudeLLM extends llm.LLM {
             else {
                 console.error('❌ Persistent session error:', error);
                 callbacks.eventEmitter.emit('tts_say', { text: 'Sorry, I encountered an error.' });
+                // Surface the failure to any listener (background slots wire this to a
+                // background_session_error → frontend). Without it a cold-start crash here
+                // is swallowed and the "Spawning…" UI hangs forever. Harmless for the main
+                // agent (no consumer_error listener; it already spoke the error above).
+                callbacks.eventEmitter.emit('consumer_error', { message: String(error?.message || error) });
             }
         }
         finally {
@@ -2380,7 +2398,9 @@ class ClaudeLLMStream extends llm.LLMStream {
                     this.#onCheckpoint(checkpointId);
                 }
                 // Stream text chunks — send each assistant text block to TTS
-                if (message.type === 'assistant' && message.message?.content) {
+                // SUBAGENT GUARD (see the persistent-consumer loop above): skip sub-agent messages
+                // (non-null parent_tool_use_id) so only the main orchestrator's text speaks/streams.
+                if (message.type === 'assistant' && message.message?.content && !message.parent_tool_use_id) {
                     // Emit SDK requestId on first assistant message — identifies this query()
                     // in the JSONL for tracking which research task produced which output
                     const sdkRequestId = message.requestId;

package/dist/index.js

@@ -2259,6 +2259,12 @@ 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(() => { });
         });
+        // Cold-start crash in the background consumer (claude-llm #startBackgroundConsumer
+        // catch): surface it so the frontend's "Spawning…" clears instead of hanging forever.
+        bgEmitter.on('consumer_error', ({ message }) => {
+            console.error(`❌ Background slot ${slotId.substring(0, 8)}: consumer error — ${message}`);
+            sendToFrontend({ type: 'background_session_error', slotId, error: String(message || 'Background session failed to start') }).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 }) => {

package/dist/session-store.js

@@ -525,8 +525,18 @@ export async function recall(db, query, opts) {
         const qvecs = await opts.embed([query]);
         const qv = qvecs?.[0];
         if (qv) {
-            const rows = db.prepare('SELECT rowid AS id FROM vec WHERE embedding MATCH vec_int8(?) ORDER BY distance LIMIT ?').all(Buffer.from(qv.buffer, qv.byteOffset, qv.byteLength), pool);
-            rows.forEach((r, i) => vec.set(r.id, i));
+            try {
+                // sqlite-vec KNN REQUIRES an explicit `k = ?` bound; relying on LIMIT alone can
+                // degrade to a brute-force full scan over every int8[EMBED_DIM] row — a multi-second
+                // synchronous stall on a large session. `k = pool` caps the KNN search itself.
+                // Wrapped like the keyword leg: a vec0 version/index mismatch degrades to
+                // keyword-only rather than throwing out of recall() for callers without an outer guard.
+                const rows = db.prepare('SELECT rowid AS id FROM vec WHERE embedding MATCH vec_int8(?) AND k = ? ORDER BY distance').all(Buffer.from(qv.buffer, qv.byteOffset, qv.byteLength), pool);
+                rows.forEach((r, i) => vec.set(r.id, i));
+            }
+            catch {
+                // vec query failed (stale index / dim mismatch) — ignore vector leg, keep keyword
+            }
         }
     }
     // ── Reciprocal Rank Fusion ──

package/package.json

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