osborn 0.9.226 → 0.9.227

package/dist/embedder.js

@@ -25,7 +25,16 @@ const OPENROUTER_URL = process.env.OPENROUTER_EMBED_URL || 'https://openrouter.a
 const MODEL_ID = EMBED_MODEL;
 const MAX_BATCH = 64; // inputs per request (OpenAI-compatible arrays)
 const REQUEST_TIMEOUT_MS = Number(process.env.OSBORN_EMBED_TIMEOUT_MS || 20_000);
-let disabled = false;
+let lastEmbedWarn = 0;
+/** Throttled failure log (max ~1/30s) so a bulk re-embed can't spam, but embedded=0 is
+ * never silent — every failure surfaces a reason (status/network) in the machine logs. */
+function embedWarn(msg) {
+    const now = Date.now();
+    if (now - lastEmbedWarn > 30_000) {
+        lastEmbedWarn = now;
+        console.warn(`[embedder] ${msg}`);
+    }
+}
 function apiKey() {
     return process.env.OPENROUTER_API_KEY || process.env.OPENROUTER_WORKSPACE_API_KEY;
 }
@@ -72,26 +81,35 @@ async function embedBatch(inputs, key) {
             }),
             signal: controller.signal,
         });
-        if (!res.ok)
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            embedWarn(`OpenRouter ${res.status} ${res.statusText}: ${body.slice(0, 200)}`);
             return null;
+        }
         const json = await res.json();
         const data = json?.data;
-        if (!Array.isArray(data) || !data.length)
+        if (!Array.isArray(data) || !data.length) {
+            embedWarn('empty/invalid embeddings response');
             return null;
+        }
         // OpenAI-compatible: each entry carries its input `index`; align by it.
+        // Fall back to array order if `index` is absent so a missing field never voids the batch.
         const byIndex = new Array(inputs.length).fill(null);
-        for (const d of data) {
-            const idx = typeof d?.index === 'number' ? d.index : -1;
+        data.forEach((d, pos) => {
+            const idx = typeof d?.index === 'number' ? d.index : pos;
             const emb = d?.embedding;
             if (idx >= 0 && idx < inputs.length && Array.isArray(emb)) {
                 byIndex[idx] = normalizeAndQuantize(emb);
             }
+        });
+        if (byIndex.some((v) => v == null)) {
+            embedWarn('response missing/misaligned embeddings');
+            return null;
         }
-        if (byIndex.some((v) => v == null))
-            return null; // malformed / partial response
         return byIndex;
     }
-    catch {
+    catch (err) {
+        embedWarn(`request failed: ${err?.name || ''} ${err?.message || err}`);
         return null; // network error, timeout/abort, bad JSON — degrade to keyword-only
     }
     finally {
@@ -103,11 +121,16 @@ async function embedBatch(inputs, key) {
  * The returned function degrades to null on any per-call failure (keyword-only recall).
  */
 export async function getEmbedder() {
-    if (process.env.OSBORN_EMBED === '0' || disabled)
+    if (process.env.OSBORN_EMBED === '0')
         return null;
+    // Re-read the key EVERY call and never latch off on a missing key: the platform
+    // OpenRouter key is hydrated into the env by the secrets layer, which can finish
+    // AFTER the first (boot-time) warm call. A permanent latch there disabled embedding
+    // for the whole session (embedded=0) even though fast-brain — which reads the key
+    // fresh per request — kept working. Re-reading recovers as soon as the key lands.
     const key = apiKey();
     if (!key) {
-        disabled = true; // no key on this machine — don't retry every turn
+        embedWarn('no OPENROUTER_API_KEY in env yet — keyword-only for this call');
         return null;
     }
     const embed = async (texts) => {

package/dist/session-store.js

@@ -256,12 +256,22 @@ function countLines(filePath, upToBytes) {
     return c;
 }
 /**
- * Max bytes ingested from a single JSONL per sweep. A very large session file
- * (100MB+) is drained gap-free across many turns instead of being read whole in
- * one synchronous pass — that whole-file read + insert transaction is what pegged
- * the single Node event loop and starved the SDK's time-boxed UserPromptSubmit hook.
+ * Max bytes ingested from a SINGLE JSONL per sweep. Kept small so each synchronous
+ * read+parse+gzip+FTS-insert block is short (~sub-300ms) and never stutters realtime
+ * voice (VAD) between event-loop yields.
  */
-const MAX_INGEST_BYTES = 4 * 1024 * 1024;
+const MAX_INGEST_BYTES = 1 * 1024 * 1024;
+/**
+ * Max bytes ingested across ALL sources in one turn. This is the cap that actually
+ * matters: a session can have HUNDREDS of subagent JSONL files, and on a store
+ * migration the offsets reset so every source re-ingests from 0 at once. The old
+ * code looped all sources inside ONE synchronous db.transaction — hundreds of MB of
+ * synchronous work that pegged the single Node thread for minutes and starved VAD,
+ * the SDK's UserPromptSubmit hook (30s timeout), and fast-brain. Bounding the total
+ * per turn (and yielding between sources) drains large sessions over many turns
+ * without ever monopolizing the loop.
+ */
+const MAX_INGEST_BYTES_PER_TURN = 4 * 1024 * 1024;
 /**
  * Ingest new bytes from a single JSONL file into the store.
  * Reads only from `fromOffset` forward, at most `maxBytes` per call. Returns rows
@@ -370,21 +380,44 @@ export async function updateSessionStore(sessionId, workingDir, opts) {
         const upSrc = db.prepare(`INSERT INTO sources(source, jsonl_path, byte_offset, line_count) VALUES (@source,@path,@off,@lines)
        ON CONFLICT(source) DO UPDATE SET jsonl_path=@path, byte_offset=@off, line_count=@lines`);
         const freshRows = [];
-        const txn = db.transaction(() => {
-            for (const s of sources) {
-                const prev = getSrc.get(s.source);
-                const fromOffset = prev?.byte_offset ?? 0;
-                const res = ingestFile(db, s.path, s.source, fromOffset);
-                if (res.inserted.length || res.newOffset !== fromOffset) {
-                    upSrc.run({
-                        source: s.source, path: s.path, off: res.newOffset,
-                        lines: (prev?.line_count ?? 0) + res.linesProcessed,
-                    });
-                }
-                freshRows.push(...res.inserted);
+        let budget = MAX_INGEST_BYTES_PER_TURN;
+        let sinceYield = 0;
+        for (const s of sources) {
+            // Yield to the event loop periodically even across drained sources, so iterating
+            // a large source list (statSync + SELECT each) can't itself stall voice/hook.
+            if (++sinceYield >= 8) {
+                sinceYield = 0;
+                await new Promise((r) => setImmediate(r));
             }
-        });
-        txn();
+            if (budget <= 0)
+                break; // per-turn cap reached — remaining sources drain next turn
+            const prev = getSrc.get(s.source);
+            const fromOffset = prev?.byte_offset ?? 0;
+            const cap = Math.min(budget, MAX_INGEST_BYTES);
+            let res;
+            try {
+                // Per-source transaction (not one giant txn over all sources) so we can yield
+                // between them and never hold the thread for the whole fleet of subagent files.
+                res = db.transaction(() => ingestFile(db, s.path, s.source, fromOffset, cap))();
+            }
+            catch {
+                continue; // a bad source never blocks the rest
+            }
+            if (res.inserted.length || res.newOffset !== fromOffset) {
+                upSrc.run({
+                    source: s.source, path: s.path, off: res.newOffset,
+                    lines: (prev?.line_count ?? 0) + res.linesProcessed,
+                });
+            }
+            const consumed = res.newOffset - fromOffset;
+            budget -= consumed;
+            freshRows.push(...res.inserted);
+            // Yield after any source that did real synchronous work.
+            if (consumed > 0) {
+                sinceYield = 0;
+                await new Promise((r) => setImmediate(r));
+            }
+        }
         opts?.onProgress?.(`content: +${freshRows.length} rows across ${sources.length} sources`);
         // ── Embeddings (best-effort, never blocks the keyword layer) ──
         let embeddedRows = 0;

package/package.json

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