memhouse 0.3.0 → 0.3.2

package/README.md

@@ -31,13 +31,45 @@ memory-house v4. Start with `mem-house/DESIGN.md` for the four bets
 ## Quickstart — the `memhouse` CLI
 
 ```bash
-npx memhouse onboard      # wizard: discover → configure → ship → start
+npm install -g memhouse --allow-scripts=better-sqlite3
+memhouse onboard          # wizard: discover → configure → ship → start
 ```
 
-While the package is private, run it from the repo (`npm install` once, then
-`node bin/memhouse.js …` or `npm link` for a global `memhouse`), or
-`npx github:agent-realm/memhouse …` with git auth. The public npm
-name `memhouse` is reserved for release.
+**Do not drop `--allow-scripts=better-sqlite3`.** Five adapters — cursor, goose,
+opencode, zed, and antigravity — read sessions out of SQLite files, and
+`better-sqlite3` builds its native binding from an install script. npm 12 blocks
+install scripts by default, so without the flag those five read nothing and you
+silently ship a partial history. `memhouse discover` and `memhouse doctor` both
+say so when the binding is missing.
+
+If that install fails with `EACCES`, `sudo` is the right answer for only one of the
+two causes, and the thing that tells them apart is **who owns the prefix root** —
+not the path, and not the failing file. The path proves nothing: Homebrew's prefix
+is `/usr/local` on Intel and `/opt/homebrew` on Apple Silicon, and is yours in both
+cases. The failing file proves nothing either: an earlier `sudo npm` leaves
+root-owned files *inside* a prefix that is still yours.
+
+```bash
+ls -ld "$(npm prefix -g)"     # the prefix ROOT — this is the deciding one
+```
+
+- **Prefix root owned by `root`** — a genuinely system-managed Node (distro
+  packages under `/usr`). Re-run with `sudo`.
+- **Prefix root owned by you** — the prefix is yours (Homebrew, fnm, nvm, volta),
+  so whatever root-owned file npm tripped on is a stray from an earlier `sudo npm`.
+  Another `sudo` adds more of them. Repair just that path:
+  `sudo chown -R "$(id -u):$(id -g)" <the path npm named>`. The same applies to the
+  cache (`~/.npm`).
+
+To try it without installing, npx takes the same flag — it has to come before the
+package name:
+
+```bash
+npx --allow-scripts=better-sqlite3 -y memhouse discover
+```
+
+Working from a checkout instead: `npm install` (the repo's `allowScripts` field
+covers the binding), then `node bin/memhouse.js …`.
 
 ```text
 memhouse onboard | install | setup | discover | uninstall | reset

package/bin/memhouse.js

@@ -186,14 +186,30 @@ Agents       plugins              list | install claude [--target DIR] | remove
 Config: flags > MEMHOUSE_* env > ${ENV_FILE.replace(os.homedir(), '~')} > defaults.
 `;
 
+// A skipped adapter and an editor the user does not have look identical — both
+// contribute zero sessions. Say which happened, and how to fix the one that is fixable.
+function printAdapterErrors(errors) {
+  if (!errors || errors.length === 0) return;
+  const blocked = errors.filter((e) => e.missingBinding);
+  const other = errors.filter((e) => !e.missingBinding);
+  if (blocked.length) {
+    console.log(warn(`${blocked.length} adapter${blocked.length > 1 ? 's' : ''} skipped — better-sqlite3 has no native binding: ${blocked.map((e) => e.source).join(', ')}`));
+    console.log('  their sessions are NOT being shipped. npm >= 12 blocks install scripts by default; rebuild with:');
+    console.log('    npm install -g memhouse --allow-scripts=better-sqlite3');
+    console.log('  (from a checkout: npm install --no-audit --no-fund, which package.json already allows)');
+  }
+  for (const e of other) console.log(warn(`${e.source.padEnd(16)} skipped: ${e.message}`));
+}
+
 async function cmdDiscover() {
   const out = { editors: [], clickhouse: [], config: null, memoryHouse: false };
   process.stdout.write(JSON_OUT ? '' : 'Scanning editors (reading local session stores)…\n');
   try {
-    const { getAllChats } = require(path.join(REPO_ROOT, 'editors'));
+    const { getAllChats, getAdapterErrors } = require(path.join(REPO_ROOT, 'editors'));
     const counts = {};
     for (const c of getAllChats()) counts[c.source] = (counts[c.source] || 0) + 1;
     out.editors = Object.entries(counts).sort((a, b) => b[1] - a[1]).map(([source, sessions]) => ({ source, sessions }));
+    out.adapterErrors = getAdapterErrors();
   } catch (e) { out.editorsError = e.message; }
 
   for (const url of [...new Set([resolveConfig().url, 'http://localhost:8123'])]) {
@@ -220,6 +236,7 @@ async function cmdDiscover() {
   console.log('\nEditors with sessions on this machine:');
   if (out.editors.length === 0) console.log(warn('none found' + (out.editorsError ? ` (${out.editorsError})` : '')));
   for (const e of out.editors) console.log(ok(`${e.source.padEnd(16)} ${e.sessions} sessions`));
+  printAdapterErrors(out.adapterErrors);
   console.log('\nClickHouse endpoints:');
   for (const p of out.clickhouse) {
     if (!p.reachable) console.log(bad(`${p.url} — unreachable`));
@@ -359,9 +376,64 @@ async function cmdDoctor() {
     add((u[0]?.u ?? '') !== '' || (await chRows(cfg, 'SELECT count() AS c FROM sessions'))[0].c === 0,
       `identity stamping (user_id='${u[0]?.u ?? ''}')`, 'writers must use async_insert=0');
   } catch { add(false, 'identity stamping', 'schema missing?'); }
+  let adapterErrors = [];
   try {
-    const { getAllChats } = require(path.join(REPO_ROOT, 'editors'));
-    add(true, `adapters: ${getAllChats().length} sessions visible locally`);
+    const { getAllChats, getAdapterErrors, getMessages } = require(path.join(REPO_ROOT, 'editors'));
+    const chats = getAllChats();
+    const seen = chats.length;
+    // Listing sessions is not the same as being able to read them. Goose, for one,
+    // can query `sessions` while its `messages` rows use a schema this parser cannot
+    // decode — the shipper would then withhold every one of those sessions while
+    // doctor reported a clean bill of health. Read the newest session per source so
+    // the message readers actually run; that is one parse per editor, not a full scan.
+    // One chat per source is not enough coverage: several adapters mix storage
+    // paths, and a probe only exercises the one the sampled chat happens to use.
+    // Each such adapter declares which store a chat came from — Cursor as _type
+    // (agent-store vs workspace), Goose as _storage (sqlite vs jsonl), OpenCode as
+    // _storageType (file vs sqlite) — so probing one chat per declared variant
+    // covers every path deterministically.
+    //
+    // The newest/middle/oldest spread is kept on top of that as a cheap hedge for
+    // any split an adapter does NOT declare.
+    const picks = new Map();
+    const bySource = new Map();
+    for (const chat of chats) {
+      if (!bySource.has(chat.source)) bySource.set(chat.source, []);
+      bySource.get(chat.source).push(chat);
+    }
+    for (const [source, list] of bySource) {
+      for (const i of new Set([0, Math.floor(list.length / 2), list.length - 1])) {
+        picks.set(`${source}#${i}`, list[i]);
+      }
+      for (const chat of list) {
+        const variant = `${source}|${chat._type || ''}|${chat._storage || ''}|${chat._storageType || ''}`;
+        if (!picks.has(variant)) picks.set(variant, chat);
+      }
+    }
+
+    const thrown = [];
+    for (const chat of picks.values()) {
+      // Not every reader reports through the sink — some throw instead, e.g.
+      // Cursor's agent-store path, where discovery reads `meta` fine but
+      // collectStoreMessages() can throw on a corrupt `blobs` table. Swallowing
+      // that here would discard the only signal and leave doctor green while the
+      // shipper withholds every one of those sessions.
+      try { getMessages(chat); }
+      catch (e) { thrown.push({ source: chat.source, message: ((e && e.message) || String(e)).split('\n')[0] }); }
+    }
+    adapterErrors = getAdapterErrors();
+    for (const t of thrown) {
+      if (!adapterErrors.some((e) => e.source === t.source)) adapterErrors.push({ ...t, missingBinding: false });
+    }
+    // Any adapter that could not be read is a failure, whatever the cause — a
+    // locked or corrupt store loses just as many sessions as a missing binding.
+    const blocked = adapterErrors.filter((e) => e.missingBinding).map((e) => e.source);
+    const failed = adapterErrors.map((e) => e.source);
+    add(adapterErrors.length === 0,
+      `adapters: ${seen} sessions visible locally${failed.length ? ` (${failed.length} skipped: ${failed.join(', ')})` : ''}`,
+      blocked.length ? 'npm install -g memhouse --allow-scripts=better-sqlite3'
+        : adapterErrors.length ? adapterErrors.map((e) => `${e.source}: ${e.message}`).join('; ')
+          : undefined);
   } catch (e) { add(false, 'adapters', e.message); }
   add(!!pidOf('shipper'), 'shipper daemon', 'memhouse start');
   add(!!pidOf('dashboard'), 'dashboard daemon', 'memhouse start');

package/editors/adapter-errors.js

@@ -0,0 +1,52 @@
+// A place for adapters to report failures they otherwise swallow.
+//
+// Every SQLite-backed adapter wraps its database access in `try { … } catch { return [] }`
+// so that one unreadable store cannot take down a whole scan. That is the right
+// behaviour, but it makes a broken store indistinguishable from an editor the user
+// does not have: both contribute zero sessions and neither says anything. Sessions
+// then go missing from the house silently, forever.
+//
+// Adapters call record() from those catch blocks. index.js drains it per scan and
+// reports through discover, doctor, and the shipper.
+//
+// This lives in its own module rather than in index.js because the adapters are
+// required *by* index.js — importing it back would be circular.
+
+let errors = [];
+
+/** Report a failure that would otherwise be swallowed. `source` is the adapter name. */
+function record(source, err, detail) {
+  const message = ((err && err.message) || String(err)).split('\n')[0];
+  errors.push({ source, message, detail: detail || null });
+}
+
+/** All failures recorded since the last reset. */
+function recorded() {
+  return errors.slice();
+}
+
+/** Current position, for scoping a retraction. See dropRange(). */
+function mark() {
+  return errors.length;
+}
+
+/**
+ * Retract the failures recorded between two marks.
+ *
+ * For readers with a fallback: opencode tries its file store, then opencode.db. A
+ * failure on the first path is not a failure of the read if the second path returns
+ * the full transcript, and leaving it recorded would make the shipper withhold a
+ * session it can read perfectly well. Scoped by range rather than truncating to a
+ * mark, so failures recorded by the fallback itself — which are real truncation —
+ * survive.
+ */
+function dropRange(start, end) {
+  if (end <= start) return;
+  errors.splice(start, end - start);
+}
+
+function reset() {
+  errors = [];
+}
+
+module.exports = { record, recorded, mark, dropRange, reset };

package/editors/antigravity.js

@@ -4,6 +4,7 @@ const path = require('path');
 const os = require('os');
 const Database = require('better-sqlite3');
 const { getAppDataPath } = require('./base');
+const adapterErrors = require('./adapter-errors');
 
 const HOME = os.homedir();
 const ANTIGRAVITY_USER_DIR = path.join(getAppDataPath('Antigravity'), 'User');
@@ -241,7 +242,10 @@ function readGlobalStateValue(key) {
     if (typeof v === 'string') return v;
     if (Buffer.isBuffer(v) || v instanceof Uint8Array) return Buffer.from(v).toString('utf-8');
     return v == null ? null : String(v);
-  } catch {
+  } catch (e) {
+    // Only the offline half of getChats() reads this store; live cascades come over
+    // RPC. So a failure here costs some sessions, not all of them.
+    adapterErrors.record('antigravity', e, ANTIGRAVITY_GLOBAL_STORAGE_DB);
     return null;
   } finally {
     if (db) db.close();
@@ -613,6 +617,10 @@ function callRpc(method, body) {
     );
     return JSON.parse(result);
   } catch { return null; }
+  // Deliberately does NOT record. One failed call is not a failed read: getSteps()
+  // falls back from GetCascadeTrajectorySteps to GetCascadeTrajectory, and the tail
+  // lookup is optional. Recording per attempt would reject chats whose fallback
+  // succeeded. The read paths record once their fallbacks are exhausted.
 }
 
 // ============================================================
@@ -657,8 +665,29 @@ function getSteps(chat) {
 
   // Fallback to old method
   const resp2 = callRpc('GetCascadeTrajectory', { cascadeId: chat.composerId });
-  if (resp2 && resp2.trajectory && resp2.trajectory.steps) return resp2.trajectory.steps;
-
+  const fallbackSteps = (resp2 && resp2.trajectory && Array.isArray(resp2.trajectory.steps))
+    ? resp2.trajectory.steps
+    : null;
+  if (fallbackSteps && fallbackSteps.length > 0) return fallbackSteps;
+
+  // Nothing produced steps. Two distinct ways that happens, and both must be
+  // reported, because either one yields an empty transcript that would overwrite
+  // the stored one on a re-ship:
+  //
+  //   - Both calls returned null: the calls themselves failed. The language server
+  //     is stopped or neither endpoint is supported. This matters even when
+  //     Antigravity is closed, because getChats() still lists offline cascades out
+  //     of SQLite, so the chat looks live while its messages are unreachable.
+  //   - A call answered but carried no steps, for a cascade the listing said HAS
+  //     steps. getChats() preserves summary.stepCount as _stepCount, which is what
+  //     separates this from a cascade that is legitimately empty.
+  const rpcFailed = resp === null && resp2 === null;
+  const expected = Number(chat._stepCount) || 0;
+  if (rpcFailed) {
+    adapterErrors.record('antigravity', new Error('language server unreachable — cannot read messages'), chat.composerId);
+  } else if (expected > 0) {
+    adapterErrors.record('antigravity', new Error(`no steps returned for a cascade reporting ${expected} steps`), chat.composerId);
+  }
   return [];
 }
 

package/editors/cursor.js

@@ -3,6 +3,7 @@ const path = require('path');
 const fs = require('fs');
 const os = require('os');
 const { getAppDataPath } = require('./base');
+const adapterErrors = require('./adapter-errors');
 
 const HOME = os.homedir();
 const CURSOR_CHATS_DIR = path.join(HOME, '.cursor', 'chats');
@@ -131,7 +132,15 @@ function getWorkspaceMap() {
       const ws = JSON.parse(fs.readFileSync(wsJson, 'utf-8'));
       const folder = (ws.folder || '').replace('file://', '');
       map.push({ hash, folder, stateDb });
-    } catch { /* skip */ }
+    } catch (e) {
+      // The descriptor is only where the folder NAME comes from — state.vscdb holds
+      // the sessions and was already confirmed present. Dropping the whole workspace
+      // over an unreadable workspace.json would take every composer in it out of
+      // discovery, where nothing downstream can notice them missing. Keep the
+      // workspace with no folder, and record why the name is absent.
+      adapterErrors.record('cursor', e, wsJson);
+      map.push({ hash, folder: '', stateDb });
+    }
   }
   return map;
 }
@@ -151,7 +160,14 @@ function getComposerHeaders(stateDbPath) {
       mode: c.unifiedMode || c.forceMode || 'unknown',
       isAgentic: c.unifiedMode === 'agent',
     }));
-  } catch { return []; }
+  } catch (e) {
+    // One workspace's state.vscdb being locked, corrupt, or on an incompatible
+    // ItemTable removes every composer in that workspace. The global database still
+    // opens, so without this Cursor looks healthy while a whole workspace of
+    // sessions quietly disappears.
+    adapterErrors.record('cursor', e, stateDbPath);
+    return [];
+  }
 }
 
 function getModelPreference(globalDb) {
@@ -174,7 +190,12 @@ function getComposerBubbles(globalDb, composerId) {
     try {
       const obj = JSON.parse(row.value);
       bubbles.push(obj);
-    } catch { /* binary blob, skip */ }
+    } catch (e) {
+      // Historically treated as "binary blob, skip", but a row that will not decode
+      // is a message missing from the transcript either way. Unreported, the
+      // shortened result overwrites the stored one on a re-ship.
+      adapterErrors.record('cursor', e, `bubble ${row.key || '(unknown)'}`);
+    }
   }
   return bubbles;
 }
@@ -260,25 +281,46 @@ function getChats() {
       const meta = readStoreMeta(db);
       db.close();
       if (meta) {
+        // The agent store carries no per-chat updated time and no message count, so
+        // the shipper had nothing that changes as the conversation grows: it
+        // compared a fixed createdAt against itself and an absent count against 0,
+        // and skipped every intact session forever. store.db's mtime is the real
+        // change signal — it moves when blobs are appended. If it cannot be read,
+        // fall back to declaring the count unknown so the skip stands down instead
+        // of silently freezing the transcript.
+        let storeMtime = null;
+        try { storeMtime = fs.statSync(dbPath).mtimeMs; } catch { /* fall back below */ }
         chats.push({
           source: 'cursor',
           composerId: chatId,
           name: meta.name || null,
           createdAt: meta.createdAt || null,
+          lastUpdatedAt: storeMtime,
           mode: meta.mode || null,
           folder: null,
+          _countUnknown: storeMtime === null,
           _dbPath: dbPath,
           _rootBlobId: meta.latestRootBlobId,
           _lastUsedModel: meta.lastUsedModel || null,
           _type: 'agent-store',
         });
+      } else {
+        // The database opened but its meta row would not decode, so this session is
+        // dropped here at discovery — before doctor's probes or the shipper ever see
+        // it. Nothing downstream can notice a chat that was never listed, which is
+        // why it has to be recorded at the point of omission.
+        adapterErrors.record('cursor', new Error('agent-store meta row could not be decoded'), dbPath);
       }
-    } catch { /* skip */ }
+    } catch (e) { adapterErrors.record('cursor', e, dbPath); }
   }
 
   // Source 2: workspaceStorage composers
   let globalDb = null;
-  try { globalDb = new Database(GLOBAL_STORAGE_DB, { readonly: true }); } catch { /* no global db */ }
+  try { globalDb = new Database(GLOBAL_STORAGE_DB, { readonly: true }); }
+  catch (e) {
+    // Absent is normal — Cursor may simply not be installed. Unreadable is not.
+    if (fs.existsSync(GLOBAL_STORAGE_DB)) adapterErrors.record('cursor', e, GLOBAL_STORAGE_DB);
+  }
 
   const modelPref = globalDb ? getModelPreference(globalDb) : null;
 
@@ -286,13 +328,24 @@ function getChats() {
     const headers = getComposerHeaders(stateDb);
     for (const h of headers) {
       let bubbleCount = 0;
+      let countUnknown = false;
       if (globalDb) {
         try {
           const countRow = globalDb.prepare(
             "SELECT count(*) as cnt FROM cursorDiskKV WHERE key LIKE ?"
           ).get(`bubbleId:${h.composerId}:%`);
           bubbleCount = countRow ? countRow.cnt : 0;
-        } catch { /* skip */ }
+        } catch (e) {
+          // A failed count is NOT a count of zero, and the difference decides
+          // whether this session ever updates again. bubbleCount feeds the shipper's
+          // skip predicate (prev.bc >= chat.bubbleCount); left at 0 that is
+          // trivially true, so a grown transcript stays stale on every incremental
+          // pass. Recording alone does not save it either — the skip is evaluated
+          // before any per-chat error guard, so the chat is dropped before the guard
+          // can see it. Flag it instead, and let the predicate refuse to skip.
+          adapterErrors.record('cursor', e, `bubble count for ${h.composerId}`);
+          countUnknown = true;
+        }
       }
       chats.push({
         source: 'cursor',
@@ -303,6 +356,7 @@ function getChats() {
         mode: h.mode,
         folder,
         bubbleCount,
+        _countUnknown: countUnknown,
         _type: 'workspace',
         _modelPref: modelPref,
       });
@@ -328,7 +382,13 @@ function getMessages(chat) {
   }
 
   let globalDb;
-  try { globalDb = new Database(GLOBAL_STORAGE_DB, { readonly: true }); } catch { return []; }
+  try { globalDb = new Database(GLOBAL_STORAGE_DB, { readonly: true }); }
+  catch (e) {
+    // Returning [] unreported would let a re-ship overwrite this session's stored
+    // transcript with nothing.
+    adapterErrors.record('cursor', e, GLOBAL_STORAGE_DB);
+    return [];
+  }
   const bubbles = getComposerBubbles(globalDb, chat.composerId);
   globalDb.close();
   const msgs = bubblesToMessages(bubbles);

package/editors/goose.js

@@ -2,6 +2,8 @@ const path = require('path');
 const fs = require('fs');
 const os = require('os');
 
+const adapterErrors = require('./adapter-errors');
+
 const GOOSE_DIR = path.join(os.homedir(), '.local', 'share', 'goose', 'sessions');
 const DB_PATH = path.join(GOOSE_DIR, 'sessions.db');
 const CONFIG_PATH = path.join(os.homedir(), '.config', 'goose', 'config.yaml');
@@ -25,13 +27,19 @@ function getDatabase() {
 function queryDb(sql) {
   if (!fs.existsSync(DB_PATH)) return [];
   const Db = getDatabase();
-  if (!Db) return []; // Fallback if better-sqlite3 not available
+  if (!Db) {
+    adapterErrors.record('goose', new Error('better-sqlite3 unavailable'), DB_PATH);
+    return [];
+  }
   try {
     const db = new Db(DB_PATH, { readonly: true });
     const rows = db.prepare(sql).all();
     db.close();
     return rows;
-  } catch { return []; }
+  } catch (e) {
+    adapterErrors.record('goose', e, DB_PATH);
+    return [];
+  }
 }
 
 // ============================================================
@@ -89,7 +97,11 @@ function getChats() {
   // --- Legacy JSONL files ---
   if (fs.existsSync(GOOSE_DIR)) {
     let files;
-    try { files = fs.readdirSync(GOOSE_DIR).filter(f => f.endsWith('.jsonl')); } catch { files = []; }
+    // The directory exists (checked above); if it will not enumerate, every legacy
+    // jsonl session disappears at discovery and nothing downstream can miss what it
+    // never saw.
+    try { files = fs.readdirSync(GOOSE_DIR).filter(f => f.endsWith('.jsonl')); }
+    catch (e) { adapterErrors.record('goose', e, GOOSE_DIR); files = []; }
 
     for (const file of files) {
       const sessionId = file.replace('.jsonl', '');
@@ -112,7 +124,12 @@ function getChats() {
           _fullPath: fullPath,
           _model: configModel,
         });
-      } catch { /* skip */ }
+      } catch (e) {
+        // Same shape one level down: an unstattable or unparseable session file is
+        // omitted from the listing entirely, so it is invisible to doctor and the
+        // shipper alike.
+        adapterErrors.record('goose', e, fullPath);
+      }
     }
   }
 
@@ -181,8 +198,15 @@ function getMessagesFromDb(chat) {
   const result = [];
   for (const row of rows) {
     let parts;
-    try { parts = JSON.parse(row.content_json); } catch { continue; }
-    if (!Array.isArray(parts)) continue;
+    // A row we cannot decode drops a message from the transcript. Silently, that is
+    // a truncation that looks complete, and a re-ship would replace the stored
+    // transcript with it. Report so the shipper withholds and retries instead.
+    try { parts = JSON.parse(row.content_json); }
+    catch (e) { adapterErrors.record('goose', e, `session ${chat.composerId}`); continue; }
+    if (!Array.isArray(parts)) {
+      adapterErrors.record('goose', new Error('message content_json is not an array'), `session ${chat.composerId}`);
+      continue;
+    }
 
     const role = row.role;
     const contentParts = [];
@@ -234,7 +258,11 @@ function getMessagesFromJsonl(chat) {
 
   for (const line of lines) {
     let obj;
-    try { obj = JSON.parse(line); } catch { continue; }
+    // The legacy JSONL store needs the same protection as the SQLite one: a corrupt
+    // line drops a message, and the truncated transcript would overwrite the stored
+    // one when the file's mtime changes or --full is used.
+    try { obj = JSON.parse(line); }
+    catch (e) { adapterErrors.record('goose', e, filePath); continue; }
 
     if (!obj.role) continue;
 

package/editors/index.js

@@ -14,6 +14,7 @@ const commandcode = require('./commandcode');
 const goose = require('./goose');
 const kiro = require('./kiro');
 const codebuff = require('./codebuff');
+const adapterErrorSink = require('./adapter-errors');
 
 const editors = [cursor, devin, antigravity, claude, vscode, zed, opencode, codex, gemini, copilot, copilotJetbrains, cursorAgent, commandcode, goose, kiro, codebuff];
 
@@ -23,16 +24,80 @@ for (const editor of editors) {
   if (editor.labels) Object.assign(editorLabels, editor.labels);
 }
 
+// Per-adapter failures from the last getAllChats() pass. An adapter that throws is
+// skipped so one broken editor cannot take down a scan, but the failure is recorded
+// here rather than discarded: a missing better-sqlite3 native binding and an editor
+// the user simply does not have both produce zero sessions, and only this tells them
+// apart. See getAdapterErrors().
+let adapterErrors = [];
+
+// better-sqlite3 ships a prebuilt binary via an install script. npm >= 12 blocks
+// install scripts by default, so a plain `npm i -g memhouse` leaves no binding and
+// every SQLite-backed adapter reads zero sessions.
+const MISSING_BINDING = /Could not locate the bindings file|Cannot find module 'better-sqlite3'/;
+
+// Adapters that read sessions out of a SQLite store, so a dead binding costs
+// sessions. Membership is narrower than `grep -l better-sqlite3 editors/*.js`:
+// windsurf/devin also requires better-sqlite3, but only in getDevinApiKey() for
+// usage — its getChats() is pure language-server RPC, so its sessions survive a
+// broken binding and listing it here would raise a false alarm. antigravity is
+// listed because its *offline* chats come from SQLite, though its live cascades,
+// like devin's, come over RPC — a failure there is partial.
+// Held as module references, not strings, so the reported name always matches the
+// adapter's own `name`.
+const SQLITE_BACKED = [antigravity, cursor, goose, opencode, zed].map((m) => m.name);
+
+// Construct an in-memory database. Loading the module is not enough — better-sqlite3
+// resolves the native binding lazily, on first open.
+//
+// This only answers "can SQLite work at all". It deliberately cannot tell whether a
+// given editor's real store is readable: permissions, locking, corruption, and
+// SQLCipher all pass this probe and fail later. Those are reported by the adapters
+// themselves through adapter-errors.
+function probeSqlite() {
+  try {
+    const Database = require('better-sqlite3');
+    const db = new Database(':memory:');
+    db.close();
+    return { available: true };
+  } catch (e) {
+    const message = ((e && e.message) || String(e)).split('\n')[0];
+    return { available: false, message, missingBinding: MISSING_BINDING.test(message) };
+  }
+}
+
+// Cache only success. A failed probe must be retried: a long-running shipper daemon
+// that warned about a missing binding should notice once the user installs it,
+// rather than repeating the warning for the life of the process.
+let sqliteProbe = null;
+function sqliteStatus() {
+  if (sqliteProbe === null) {
+    const result = probeSqlite();
+    if (result.available) sqliteProbe = result;
+    return result;
+  }
+  return sqliteProbe;
+}
+
 /**
  * Get all chats from all editor adapters, sorted by most recent first.
  */
 function getAllChats() {
   const chats = [];
+  adapterErrors = [];
+  adapterErrorSink.reset();
   for (const editor of editors) {
     try {
       const editorChats = editor.getChats();
       chats.push(...editorChats);
-    } catch { /* skip broken adapters */ }
+    } catch (e) {
+      const message = (e && e.message) || String(e);
+      adapterErrors.push({
+        source: editor.name,
+        message: message.split('\n')[0],
+        missingBinding: MISSING_BINDING.test(message),
+      });
+    }
   }
 
   chats.sort((a, b) => {
@@ -44,6 +109,36 @@ function getAllChats() {
   return chats;
 }
 
+/**
+ * Adapters that could not report their sessions: [{ source, message, missingBinding }].
+ * Empty when every adapter ran clean.
+ *
+ * Two sources, because there are two ways an adapter goes quiet. One throws out of
+ * getChats() and is recorded during the pass. The other is a dead SQLite binding,
+ * which throws nowhere at all — the adapters catch it internally — so it is probed
+ * for directly and reported against every SQLite-backed adapter at once.
+ */
+function getAdapterErrors() {
+  const errors = adapterErrors.slice();
+  for (const e of adapterErrorSink.recorded()) {
+    errors.push({ source: e.source, message: e.message, detail: e.detail, missingBinding: MISSING_BINDING.test(e.message) });
+  }
+  const sqlite = sqliteStatus();
+  if (!sqlite.available) {
+    const already = new Set(errors.map((e) => e.source));
+    for (const source of SQLITE_BACKED) {
+      if (!already.has(source)) {
+        errors.push({ source, message: sqlite.message, missingBinding: sqlite.missingBinding });
+      }
+    }
+  }
+  // One line per adapter, not one per failed query — a broken store is usually hit
+  // many times in a single scan.
+  const bySource = new Map();
+  for (const e of errors) if (!bySource.has(e.source)) bySource.set(e.source, e);
+  return Array.from(bySource.values());
+}
+
 /**
  * Get messages for a chat object, dispatching to the right editor adapter.
  */
@@ -176,4 +271,4 @@ function getAllMCPServers(projectFolders = []) {
   return Array.from(seen.values());
 }
 
-module.exports = { getAllChats, getMessages, editors, editorLabels, resetCaches, getAllUsage, getAllArtifacts, getAllMCPServers };
+module.exports = { getAllChats, getAdapterErrors, getMessages, editors, editorLabels, resetCaches, getAllUsage, getAllArtifacts, getAllMCPServers };