memhouse 0.8.0 → 0.9.0

package/README.md

@@ -1,19 +1,31 @@
 # memhouse
 
-Long-term memory for coding agents. memhouse reads the session transcripts your
-editors already write to disk — **17 of them**, Claude Code, Codex, Cursor, Zed,
-Copilot, Gemini CLI and the rest — parses them locally, and ships typed rows into
-ClickHouse. Nothing is proxied or intercepted. Then you can search every past
-session, see what it cost, and let an agent query its own history.
+**Claude Code deletes your transcripts after 30 days.** (`cleanupPeriodDays`,
+default 30 — session files are removed at startup.) Measured on the machine this
+was built on: months of daily use, and the oldest surviving local transcript was
+nine days old. Every problem you solved before that exists nowhere — unless
+something durable was keeping it.
+
+memhouse is that something. It reads the session transcripts your editors already
+write to disk — **17 of them**: Claude Code, Codex, Cursor, Zed, Copilot, Gemini
+CLI and the rest — parses them locally, and ships typed rows into a ClickHouse
+**you own**. Nothing is proxied, intercepted, or sent to anyone's cloud. Then you
+can search every past session, see what it cost, resume the conversation that
+solved this before, and let an agent query its own history.
+
+And every row says where it came from, in a way no client can fake: `user_id` is
+stamped **by the server** (`MATERIALIZED currentUser()`, async inserts pinned off
+so the stamp cannot be skipped) and `host` is a fingerprint minted once per
+install. A team pointed at one house is a team memory with real attribution — not
+a label somebody's client claimed.
 
 ```bash
-npm install -g memhouse --allow-scripts=better-sqlite3
+npm install -g memhouse
 memhouse onboard
 ```
 
-That is the whole install. `onboard` finds your editors, sets up a house, ships,
-and starts the dashboard. **Don't drop `--allow-scripts`** — see
-[below](#the-allow-scripts-flag).
+That is the whole install — no flags, nothing to compile. `onboard` finds your
+editors, sets up a house, ships, and starts the dashboard.
 
 **On most Linux distros that first line needs `sudo`.** A distro-packaged Node puts
 its global prefix under `/usr`, which you do not own, so npm stops with `EACCES`.
@@ -22,7 +34,7 @@ Ubuntu machine:
 
 ```bash
 ls -ld "$(npm prefix -g)"     # root-owned? use sudo. Owned by you? do NOT — see EACCES below
-sudo npm install -g memhouse --allow-scripts=better-sqlite3
+sudo npm install -g memhouse
 ```
 
 If the prefix is yours (Homebrew, fnm, nvm, volta), `sudo` is the wrong fix and
@@ -149,13 +161,11 @@ memhouse update            # upgrade, restart the daemons, check the house schem
 memhouse update --check    # compare versions, change nothing
 ```
 
-A bare `npm i -g memhouse@latest` does one third of the job. It does not re-pass
-`--allow-scripts=better-sqlite3`, so the five SQLite adapters go quiet; it does not
-restart the daemons, which keep parsing with the code they booted with (a shipper here
-once ran 1d16h out of a directory that had been *moved*); and it does not check whether
-your house predates a room the new shipper needs. `update` does all three, and from a
-checkout it rebuilds `public/` — otherwise `git pull` serves you the previous release's
-dashboard forever.
+A bare `npm i -g memhouse@latest` does half the job. It does not restart the daemons,
+which keep parsing with the code they booted with (a shipper here once ran 1d16h out of
+a directory that had been *moved*); and it does not check whether your house predates a
+room the new shipper needs. `update` does both, and from a checkout it rebuilds
+`public/` — otherwise `git pull` serves you the previous release's dashboard forever.
 
 The daemons also notice on their own: each one compares the installed version against
 what it booted with and hands over — exiting under systemd/launchd so the supervisor
@@ -210,24 +220,22 @@ has it wrong, so an old house cannot be corrupted by a new shipper.
 
 ## Troubleshooting
 
-### The `--allow-scripts` flag
+### An editor reads zero sessions
 
-Five adapters — **cursor, zed, opencode, goose, 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 ship a partial history.
+Five adapters — **cursor, zed, opencode, goose, antigravity** — read sessions out of
+SQLite files. That used to mean `better-sqlite3`, whose native binding is built by
+an npm install script; npm 12 blocks install scripts by default, so a plain install left
+all five reading nothing and the fix was a flag
+(`--allow-scripts=better-sqlite3`) you had to re-type on every upgrade. SQLite is
+`node:sqlite` now — part of Node — so that failure class is gone along with the flag.
 
-(This said six and named windsurf, which is wrong: windsurf lists its sessions over
-language-server RPC and touches SQLite only to read a usage key, so a dead binding
-costs it numbers, not sessions. `editors/index.js` has the real list.)
-
-It is not silent: `memhouse discover` and `memhouse doctor` both name the skipped
-adapters. The other twelve adapters keep working.
-
-`npx` takes the same flag, before the package name:
+What can still go wrong is one store at a time: a `state.vscdb` locked by a running
+editor, a corrupt file, a schema a new editor release changed. None of it is silent —
+`memhouse discover` and `memhouse doctor` both name the skipped adapter and say why,
+and the other sixteen keep working.
 
 ```bash
-npx --allow-scripts=better-sqlite3 -y memhouse discover
+npx -y memhouse discover      # no flags here either
 ```
 
 ### `EACCES` on install
@@ -262,7 +270,7 @@ A rootless podman house has the same problem for the same reason, and
 ## Working from a checkout
 
 ```bash
-npm install            # the repo's allowScripts field covers the binding
+npm install            # two runtime deps, no build step
 node bin/memhouse.js …
 npm test               # syntax gate + unit checks
 ```
@@ -293,6 +301,16 @@ In constellation terms (`TERMINOLOGY.md`) memhouse is an **agency**: a **house**
 alone would hold; the shipper is what makes it act. It competes with
 memory-house; if it wins, it becomes memory-house v4.
 
+## What's supported
+
+| Surface | Status |
+|---|---|
+| macOS | primary — developed and driven here daily |
+| Linux | real — installs, ships, `service install` (systemd `--user`), rootless podman `deploy --local`; exercised on Debian and Ubuntu machines |
+| Windows | **untested** — the adapters declare Windows paths but no one has run a single install; treat it as unknown until this row changes |
+| ClickHouse | 25.11 and 26.x, both in CI; 26.2+ needs no flags, 25.x needs the text-index flag the shipper already passes |
+| Node | **≥ 24** — SQLite comes from `node:sqlite`, which is stable in 24. It works flagless on 22.13+ but prints `ExperimentalWarning` on every command (measured on v22.23.2), and Node 20 is past EOL. There is no native dependency and no build step at any version. |
+
 ## Heritage & license
 
 Built on [agentlytics](https://github.com/f/agentlytics) by Fatih Kadir Akın (MIT)

package/bin/memhouse.js

@@ -356,18 +356,15 @@ Engine: MEMHOUSE_ENGINE pins docker or podman when both are installed and one ca
 `;
 
 // 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.
+// contribute zero sessions. Say which happened.
+//
+// There was a second branch here for the one cause that hit five adapters at once: a
+// missing better-sqlite3 native binding, fixable only by reinstalling with a flag. With
+// SQLite now inside Node there is nothing to install and nothing to advise — every
+// remaining failure is one adapter's own store, and its own message is the whole story.
 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('    ${installCommand()}');
-    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}`));
+  for (const e of errors) console.log(warn(`${e.source.padEnd(16)} skipped: ${e.message}`));
 }
 
 async function cmdDiscover() {
@@ -1229,8 +1226,11 @@ async function cmdDoctor() {
   const checks = [];
   const add = (okFlag, label, hint) => checks.push({ ok: okFlag, label, hint });
 
-  const [major, minor] = process.versions.node.split('.').map(Number);
-  add(major > 20 || (major === 20 && minor >= 19), `node ${process.versions.node}`, 'need >= 20.19');
+  // 24 because SQLite comes from `node:sqlite`, which is stable there. It works on 22.13+
+  // but prints an ExperimentalWarning on every command, and 20 is past EOL. Below the
+  // floor, the five SQLite-backed adapters are the part that actually breaks.
+  const [major] = process.versions.node.split('.').map(Number);
+  add(major >= 24, `node ${process.versions.node}`, 'need >= 24 — node:sqlite is stable there; the SQLite-backed adapters need it');
   add(fs.existsSync(ENV_FILE), `config ${ENV_FILE}`, 'run: memhouse install');
   // doctor is exempt from requireConfig — diagnosing an unconfigured machine is its job —
   // but "exempt from refusing" is not "licensed to log in somewhere". With no config it
@@ -1445,11 +1445,11 @@ async function cmdDoctor() {
     }
     adapterErrors = getAdapterErrors();
     for (const t of thrown) {
-      if (!adapterErrors.some((e) => e.source === t.source)) adapterErrors.push({ ...t, missingBinding: false });
+      if (!adapterErrors.some((e) => e.source === t.source)) adapterErrors.push(t);
     }
-    // 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);
+    // Any adapter that could not be read is a failure, whatever the cause — a locked or
+    // corrupt store loses sessions just as surely as the missing native binding this
+    // used to have a separate remedy for.
     const failed = adapterErrors.map((e) => e.source);
     add(adapterErrors.length === 0,
       // "visible locally" is what the ADAPTERS see; `stats` reports what the house HOLDS,
@@ -1458,9 +1458,7 @@ async function cmdDoctor() {
       // find the other number elsewhere (161 here, 156 there, on a real machine) gives
       // them no way to tell "correctly skipped" from "silently dropped".
       `adapters: ${seen} sessions visible locally${failed.length ? ` (${failed.length} skipped: ${failed.join(', ')})` : ''} — compare with what the house holds: memhouse stats`,
-      blocked.length ? installCommand()
-        : adapterErrors.length ? adapterErrors.map((e) => `${e.source}: ${e.message}`).join('; ')
-          : undefined);
+      adapterErrors.length ? adapterErrors.map((e) => `${e.source}: ${e.message}`).join('; ') : undefined);
   } catch (e) { add(false, 'adapters', e.message); }
   // Which models in this house have no price. An unpriced model is not an error — a new
   // release always lands before pricing.json catches up — but it IS silent: calculateCost
@@ -1657,12 +1655,12 @@ async function cmdUpdate() {
 
   if (kind === 'npx') {
     console.log(warn('nothing to update — npx resolves the registry on every run'));
-    console.log('  to keep a version around: npm install -g memhouse --allow-scripts=better-sqlite3');
+    console.log('  to keep a version around: npm install -g memhouse');
     return 1;
   }
   if (kind === 'local-dep') {
     console.log(warn('this is a project dependency, not a global install'));
-    console.log(`  upgrade it where it lives: npm install memhouse@latest --allow-scripts=better-sqlite3`);
+    console.log(`  upgrade it where it lives: npm install memhouse@latest`);
     return 1;
   }
 
@@ -1690,10 +1688,11 @@ async function cmdUpdate() {
       }
     }
   } else {
-    // --allow-scripts is not optional and not remembered: npm >= 12 blocks install scripts
-    // by default, so an upgrade without it leaves better-sqlite3 with no binding and the
-    // five SQLite-backed adapters read zero sessions on every pass afterwards.
-    const r = spawnSync('npm', ['install', '-g', 'memhouse@latest', '--allow-scripts=better-sqlite3'], { stdio: 'inherit' });
+    // Plain, with no flag to forget. This carried `--allow-scripts=better-sqlite3` for as
+    // long as SQLite was a native module: npm never remembered it, and an upgrade without
+    // it left the binding unbuilt and the five SQLite-backed adapters reading zero
+    // sessions on every pass afterwards. There is no binding to build now.
+    const r = spawnSync('npm', ['install', '-g', 'memhouse@latest'], { stdio: 'inherit' });
     if (r.status !== 0) {
       console.log(bad('npm install failed — nothing was restarted, the running version is unchanged'));
       console.log('  if it was EACCES: ls -ld "$(npm prefix -g)" — root-owned needs sudo, yours needs a chown');

package/editors/antigravity.js

@@ -2,16 +2,7 @@ const { execSync, execFileSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-// Required lazily. A top-level require makes this native module a load-time dependency
-// of the whole adapter set: editors/index.js imports every adapter, so one missing
-// binding threw before any adapter ran and `discover` reported ZERO editors — losing the
-// eleven that need no native code at all. The adapterErrors path exists to degrade one
-// adapter at a time, and a top-level throw walks straight past it.
-let Database = null;
-function openDb(...a) {
-  if (!Database) Database = require('better-sqlite3');
-  return new Database(...a);
-}
+const { openReadOnly, textOf } = require('./sqlite');
 const { getAppDataPath } = require('./base');
 const adapterErrors = require('./adapter-errors');
 
@@ -244,13 +235,14 @@ function readGlobalStateValue(key) {
 
   let db = null;
   try {
-    db = openDb(ANTIGRAVITY_GLOBAL_STORAGE_DB, { readonly: true, fileMustExist: true });
+    // fileMustExist is gone with better-sqlite3, not lost: node:sqlite refuses to
+    // create a database it is opening read-only, and the existsSync above still stands.
+    db = openReadOnly(ANTIGRAVITY_GLOBAL_STORAGE_DB);
     const row = db.prepare('SELECT value FROM ItemTable WHERE key = ?').get(key);
     if (!row) return null;
-    const v = row.value;
-    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);
+    // ItemTable.value is declared BLOB and usually holds TEXT — textOf covers both,
+    // including the Uint8Array node:sqlite returns for the byte case.
+    return row.value == null ? null : textOf(row.value);
   } 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.

package/editors/cursor.js

@@ -1,13 +1,4 @@
-// Required lazily. A top-level require makes this native module a load-time dependency
-// of the whole adapter set: editors/index.js imports every adapter, so one missing
-// binding threw before any adapter ran and `discover` reported ZERO editors — losing the
-// eleven that need no native code at all. The adapterErrors path exists to degrade one
-// adapter at a time, and a top-level throw walks straight past it.
-let Database = null;
-function openDb(...a) {
-  if (!Database) Database = require('better-sqlite3');
-  return new Database(...a);
-}
+const { openReadOnly, textOf, bytesOf } = require('./sqlite');
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
@@ -52,16 +43,16 @@ function hexToString(hex) {
 function readStoreMeta(db) {
   const row = db.prepare('SELECT value FROM meta WHERE key = ?').get('0');
   if (!row) return null;
-  const hex = typeof row.value === 'string' ? row.value : Buffer.from(row.value).toString('hex');
+  const hex = typeof row.value === 'string' ? row.value : bytesOf(row.value).toString('hex');
   try {
     return JSON.parse(hexToString(hex));
   } catch {
-    try { return JSON.parse(row.value); } catch { return null; }
+    try { return JSON.parse(textOf(row.value)); } catch { return null; }
   }
 }
 
 function parseTreeBlob(data) {
-  const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+  const buf = bytesOf(data);
   const messageRefs = [];
   const childRefs = [];
   let offset = 0;
@@ -114,7 +105,10 @@ function collectStoreMessages(db, rootBlobId) {
     if (!row) return;
     const data = row.data;
     try {
-      const json = typeof data === 'string' ? JSON.parse(data) : JSON.parse(data.toString('utf-8'));
+      // textOf, not data.toString(): a message blob arrives as a Uint8Array, whose own
+      // toString() renders the bytes as "123,45,…" and would send every message in the
+      // tree down the tree-blob path below.
+      const json = JSON.parse(textOf(data));
       if (json && json.role) { allMessages.push(normalizeStoreMessage(json)); return; }
     } catch { /* tree blob */ }
     const { messageRefs, childRefs } = parseTreeBlob(data);
@@ -156,11 +150,11 @@ function getWorkspaceMap() {
 
 function getComposerHeaders(stateDbPath) {
   try {
-    const db = openDb(stateDbPath, { readonly: true });
+    const db = openReadOnly(stateDbPath);
     const row = db.prepare("SELECT value FROM ItemTable WHERE key = 'composer.composerData'").get();
     db.close();
     if (!row) return [];
-    const data = JSON.parse(row.value);
+    const data = JSON.parse(textOf(row.value));
     return (data.allComposers || []).map((c) => ({
       composerId: c.composerId,
       name: c.name || null,
@@ -183,7 +177,7 @@ function getModelPreference(globalDb) {
   try {
     const row = globalDb.prepare("SELECT value FROM ItemTable WHERE key = 'cursor/lastSingleModelPreference'").get();
     if (!row) return null;
-    const pref = JSON.parse(row.value);
+    const pref = JSON.parse(textOf(row.value));
     return pref.composer || pref.agent || null;
   } catch { return null; }
 }
@@ -197,7 +191,7 @@ function getComposerBubbles(globalDb, composerId) {
   const bubbles = [];
   for (const row of rows) {
     try {
-      const obj = JSON.parse(row.value);
+      const obj = JSON.parse(textOf(row.value));
       bubbles.push(obj);
     } catch (e) {
       // Historically treated as "binary blob, skip", but a row that will not decode
@@ -286,7 +280,7 @@ function getChats() {
   // Source 1: ~/.cursor/chats store.db
   for (const { workspace, chatId, dbPath } of getAgentStoreChats()) {
     try {
-      const db = openDb(dbPath, { readonly: true });
+      const db = openReadOnly(dbPath);
       const meta = readStoreMeta(db);
       db.close();
       if (meta) {
@@ -325,7 +319,7 @@ function getChats() {
 
   // Source 2: workspaceStorage composers
   let globalDb = null;
-  try { globalDb = openDb(GLOBAL_STORAGE_DB, { readonly: true }); }
+  try { globalDb = openReadOnly(GLOBAL_STORAGE_DB); }
   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);
@@ -378,7 +372,7 @@ function getChats() {
 
 function getMessages(chat) {
   if (chat._type === 'agent-store') {
-    const db = openDb(chat._dbPath, { readonly: true });
+    const db = openReadOnly(chat._dbPath);
     const msgs = collectStoreMessages(db, chat._rootBlobId);
     db.close();
     // Use lastUsedModel as fallback for assistant messages without model info
@@ -391,7 +385,7 @@ function getMessages(chat) {
   }
 
   let globalDb;
-  try { globalDb = openDb(GLOBAL_STORAGE_DB, { readonly: true }); }
+  try { globalDb = openReadOnly(GLOBAL_STORAGE_DB); }
   catch (e) {
     // Returning [] unreported would let a re-ship overwrite this session's stored
     // transcript with nothing.
@@ -416,10 +410,10 @@ function getMessages(chat) {
 
 function getCursorAccessToken() {
   try {
-    const db = openDb(GLOBAL_STORAGE_DB, { readonly: true });
+    const db = openReadOnly(GLOBAL_STORAGE_DB);
     const row = db.prepare("SELECT value FROM ItemTable WHERE key = 'cursorAuth/accessToken'").get();
     db.close();
-    return row ? row.value : null;
+    return row ? textOf(row.value) : null;
   } catch { return null; }
 }
 

package/editors/goose.js

@@ -2,6 +2,7 @@ const path = require('path');
 const fs = require('fs');
 const os = require('os');
 
+const { openReadOnly, textOf } = require('./sqlite');
 const adapterErrors = require('./adapter-errors');
 
 const GOOSE_DIR = path.join(os.homedir(), '.local', 'share', 'goose', 'sessions');
@@ -9,30 +10,17 @@ const DB_PATH = path.join(GOOSE_DIR, 'sessions.db');
 const CONFIG_PATH = path.join(os.homedir(), '.config', 'goose', 'config.yaml');
 
 // ============================================================
-// Query SQLite via better-sqlite3 (cross-platform)
+// Query SQLite via node:sqlite (cross-platform, part of Node itself)
 // ============================================================
 
-let Database;
-function getDatabase() {
-  if (!Database) {
-    try {
-      Database = require('better-sqlite3');
-    } catch {
-      // better-sqlite3 not available
-    }
-  }
-  return Database;
-}
-
+// This used to swallow "SQLite is unavailable" as a case of its own, because
+// better-sqlite3's binding could genuinely be absent. It cannot be now — so an open
+// that fails is an open that failed, and the one catch below reports it like any other
+// unreadable store.
 function queryDb(sql) {
   if (!fs.existsSync(DB_PATH)) return [];
-  const Db = getDatabase();
-  if (!Db) {
-    adapterErrors.record('goose', new Error('better-sqlite3 unavailable'), DB_PATH);
-    return [];
-  }
   try {
-    const db = new Db(DB_PATH, { readonly: true });
+    const db = openReadOnly(DB_PATH);
     const rows = db.prepare(sql).all();
     db.close();
     return rows;
@@ -201,7 +189,7 @@ function getMessagesFromDb(chat) {
     // 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); }
+    try { parts = JSON.parse(textOf(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}`);
@@ -314,7 +302,7 @@ function getMessagesFromJsonl(chat) {
 function extractSessionModel(row) {
   if (row.model_config_json) {
     try {
-      const cfg = JSON.parse(row.model_config_json);
+      const cfg = JSON.parse(textOf(row.model_config_json));
       if (cfg.model) return cfg.model;
       if (cfg.model_id) return cfg.model_id;
     } catch {}

package/editors/index.js

@@ -26,58 +26,19 @@ for (const editor of editors) {
 
 // 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.
+// here rather than discarded: an unreadable store and an editor the user simply does
+// not have both produce zero sessions, and only this tells them apart. See
+// getAdapterErrors().
 //
-// 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;
-}
+// There used to be a second, coarser class beside those: better-sqlite3's native
+// binding could be missing outright, taking all five SQLite-backed adapters down at
+// once for a reason none of them could see, so a separate probe ran an in-memory open
+// and reported the verdict against every one of them. SQLite is `node:sqlite` now — it
+// arrives with Node and cannot go missing — so that probe, its MISSING_BINDING regex,
+// and the `missingBinding` flag they put on every error are gone. What remains is the
+// per-store reporting the adapters do themselves: permissions, locking, corruption and
+// schema drift are all still real and all still land here, one line per adapter.
+let adapterErrors = [];
 
 /**
  * Get all chats from all editor adapters, sorted by most recent first.
@@ -92,11 +53,7 @@ function getAllChats() {
       chats.push(...editorChats);
     } catch (e) {
       const message = (e && e.message) || String(e);
-      adapterErrors.push({
-        source: editor.name,
-        message: message.split('\n')[0],
-        missingBinding: MISSING_BINDING.test(message),
-      });
+      adapterErrors.push({ source: editor.name, message: message.split('\n')[0] });
     }
   }
 
@@ -110,27 +67,19 @@ function getAllChats() {
 }
 
 /**
- * Adapters that could not report their sessions: [{ source, message, missingBinding }].
+ * Adapters that could not report their sessions: [{ source, message, detail? }].
  * 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.
+ * getChats() and is recorded during the pass. The other catches its own failure — a
+ * locked state.vscdb, a thread blob that will not decompress, a schema the parser does
+ * not know — and reports it through the adapter-errors sink so the shipper knows not to
+ * overwrite a good stored transcript with a partial read.
  */
 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 });
-      }
-    }
+    errors.push({ source: e.source, message: e.message, detail: e.detail });
   }
   // One line per adapter, not one per failed query — a broken store is usually hit
   // many times in a single scan.

package/editors/opencode.js

@@ -1,16 +1,7 @@
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
-// Required lazily. A top-level require makes this native module a load-time dependency
-// of the whole adapter set: editors/index.js imports every adapter, so one missing
-// binding threw before any adapter ran and `discover` reported ZERO editors — losing the
-// eleven that need no native code at all. The adapterErrors path exists to degrade one
-// adapter at a time, and a top-level throw walks straight past it.
-let Database = null;
-function openDb(...a) {
-  if (!Database) Database = require('better-sqlite3');
-  return new Database(...a);
-}
+const { openReadOnly, textOf } = require('./sqlite');
 const adapterErrors = require('./adapter-errors');
 
 // OpenCode stores data in XDG-style paths across all platforms
@@ -31,13 +22,13 @@ function getOpenCodeDbPath() {
 const DB_PATH = getOpenCodeDbPath();
 
 // ============================================================
-// Query SQLite using better-sqlite3
+// Query SQLite using node:sqlite (built into Node — nothing to install)
 // ============================================================
 
 function queryDb(sql) {
   if (!fs.existsSync(DB_PATH)) return [];
   try {
-    const db = openDb(DB_PATH, { readonly: true });
+    const db = openReadOnly(DB_PATH);
     const rows = db.prepare(sql).all();
     db.close();
     return rows;
@@ -94,7 +85,7 @@ function getSqliteSessions() {
 function getSqliteMessages(sessionId) {
   if (!fs.existsSync(DB_PATH)) return [];
   try {
-    const db = openDb(DB_PATH, { readonly: true });
+    const db = openReadOnly(DB_PATH);
     const messages = db.prepare(
       `SELECT m.id as msg_id, m.data as msg_data, m.time_created
        FROM message m WHERE m.session_id = ? ORDER BY m.time_created ASC`
@@ -107,7 +98,7 @@ function getSqliteMessages(sessionId) {
       // yields a TRUNCATED history that looks complete — and a re-ship would replace
       // the full stored transcript with the shortened one. Report it so the shipper
       // refuses to overwrite good data with a partial read.
-      try { msgData = JSON.parse(msg.msg_data); }
+      try { msgData = JSON.parse(textOf(msg.msg_data)); }
       catch (e) { adapterErrors.record('opencode', e, `message ${msg.msg_id}`); continue; }
 
       const role = msgData.role;
@@ -120,7 +111,7 @@ function getSqliteMessages(sessionId) {
       const contentParts = [];
       for (const part of parts) {
         let partData;
-        try { partData = JSON.parse(part.data); }
+        try { partData = JSON.parse(textOf(part.data)); }
         catch (e) { adapterErrors.record('opencode', e, `part of message ${msg.msg_id}`); continue; }
         const type = partData.type;
 

package/editors/sqlite.js

@@ -0,0 +1,74 @@
+// SQLite for the five adapters that read an editor's store directly — cursor, zed,
+// opencode, goose, antigravity — plus windsurf's Devin API-key lookup.
+//
+// This was `better-sqlite3`, a native module whose prebuilt binary arrives through an
+// npm install script — and npm >= 12 blocks install scripts by default, so a plain
+// `npm i -g memhouse` left no binding at all. Those five adapters then read ZERO
+// sessions and looked exactly like editors the pilot does not have. The fix was a flag
+// (`--allow-scripts=better-sqlite3`) that had to be typed on every install and every
+// upgrade, was never remembered by npm, and produced no error when omitted.
+//
+// `node:sqlite` is part of Node itself — stable in 24, no build step, no binary to
+// misplace, nothing to allow. The whole "adapter silently skipped for a missing native
+// binding" failure class is gone, and install is one command with no flags.
+//
+// Still required lazily, but for a different reason than before. On a Node older than
+// the engines floor `require('node:sqlite')` throws, and editors/index.js imports every
+// adapter at load time — a top-level require here would take the eleven adapters that
+// need no SQLite at all down with the five that do, and `discover` would report zero
+// editors. Lazy, that throw lands inside each adapter's own try/catch and is reported
+// through adapter-errors like any other unreadable store.
+let DatabaseSync = null;
+
+/**
+ * Open an editor's store read-only.
+ *
+ * Every call site in this repo is a read, so there is no write mode to get wrong.
+ * better-sqlite3 spelled the option `readonly` and needed `fileMustExist` beside it to
+ * stop a typo'd path from quietly creating an empty database; node:sqlite spells it
+ * `readOnly` and refuses on its own — measured, a missing file throws ERR_SQLITE_ERROR
+ * "unable to open database file" rather than creating one. Callers that check
+ * fs.existsSync() first keep working unchanged; callers that do not still cannot
+ * conjure a store that is not there.
+ */
+function openReadOnly(file) {
+  if (!DatabaseSync) ({ DatabaseSync } = require('node:sqlite'));
+  return new DatabaseSync(file, { readOnly: true });
+}
+
+/**
+ * A column's value as text, whether SQLite handed back TEXT or BLOB.
+ *
+ * SQLite types values, not columns, and these stores are not consistent about it: the
+ * VS Code family declares `ItemTable.value` as BLOB but stores strings in it, while
+ * Cursor's agent store keeps real bytes in the same shape of table. better-sqlite3
+ * returned a Buffer for the byte case and every `JSON.parse(row.value)` in these
+ * adapters worked by accident, because Buffer.toString() decodes utf-8.
+ *
+ * node:sqlite returns a plain Uint8Array, whose toString() renders "40,181,47,253,…" —
+ * a comma-joined list of byte values. That is not utf-8, not JSON, and not empty, so it
+ * does not fail loudly; it fails four frames deeper as a parse error against a store
+ * that is perfectly healthy. Every read that may be either type goes through here.
+ */
+function textOf(v) {
+  if (v == null) return v;
+  if (typeof v === 'string') return v;
+  if (v instanceof Uint8Array) return Buffer.from(v.buffer, v.byteOffset, v.byteLength).toString('utf-8');
+  return String(v);
+}
+
+/**
+ * A column's value as a Buffer, for readers that slice it, hex-encode it, or hand it to
+ * zlib. Buffer IS a Uint8Array, so this is a no-op on anything better-sqlite3 would have
+ * returned — it exists so the byte-walking code below never has to ask which it got.
+ */
+function bytesOf(v) {
+  if (v == null) return v;
+  if (Buffer.isBuffer(v)) return v;
+  if (typeof v === 'string') return Buffer.from(v, 'utf-8');
+  // A view over the same memory, not a copy — these blobs run to megabytes and every
+  // consumer here only reads.
+  return Buffer.from(v.buffer, v.byteOffset, v.byteLength);
+}
+
+module.exports = { openReadOnly, textOf, bytesOf };

package/editors/windsurf.js

@@ -484,13 +484,13 @@ function getDevinApiKey(appNames) {
           dbPath = path.join(HOME, '.config', appName, 'User', 'globalStorage', 'state.vscdb');
       }
       if (!fs.existsSync(dbPath)) continue;
-      const Database = require('better-sqlite3');
-      const db = new Database(dbPath, { readonly: true });
+      const { openReadOnly, textOf } = require('./sqlite');
+      const db = openReadOnly(dbPath);
       try {
         for (const key of keys) {
           const row = db.prepare('SELECT value FROM ItemTable WHERE key = ?').get(key);
           if (!row) continue;
-          const parsed = JSON.parse(row.value);
+          const parsed = JSON.parse(textOf(row.value));
           if (parsed.apiKey) return parsed.apiKey;
         }
       } finally {

package/editors/zed.js

@@ -2,16 +2,7 @@ const path = require('path');
 const fs = require('fs');
 const os = require('os');
 
-// Required lazily. A top-level require makes this native module a load-time dependency
-// of the whole adapter set: editors/index.js imports every adapter, so one missing
-// binding threw before any adapter ran and `discover` reported ZERO editors — losing the
-// eleven that need no native code at all. The adapterErrors path exists to degrade one
-// adapter at a time, and a top-level throw walks straight past it.
-let Database = null;
-function openDb(...a) {
-  if (!Database) Database = require('better-sqlite3');
-  return new Database(...a);
-}
+const { openReadOnly, bytesOf } = require('./sqlite');
 const adapterErrors = require('./adapter-errors');
 
 // Zed stores data in different locations depending on the platform
@@ -72,13 +63,13 @@ function decompressZstd(buf) {
 }
 
 // ============================================================
-// Query SQLite using better-sqlite3 (cross-platform)
+// Query SQLite using node:sqlite (cross-platform, no native dependency)
 // ============================================================
 
 function queryDb(sql) {
   if (!fs.existsSync(THREADS_DB)) return [];
   try {
-    const db = openDb(THREADS_DB, { readonly: true });
+    const db = openReadOnly(THREADS_DB);
     const rows = db.prepare(sql).all();
     db.close();
     return rows;
@@ -100,7 +91,7 @@ function getThreadColumns() {
   if (threadColumns) return threadColumns;
   if (!fs.existsSync(THREADS_DB)) return new Set();
   try {
-    const db = openDb(THREADS_DB, { readonly: true });
+    const db = openReadOnly(THREADS_DB);
     const cols = db.prepare('PRAGMA table_info(threads)').all().map((r) => r.name);
     db.close();
     // PRAGMA on a missing or renamed table SUCCEEDS with zero rows rather than
@@ -131,10 +122,14 @@ function resetCache() {
 function queryBlob(id) {
   if (!fs.existsSync(THREADS_DB)) return null;
   try {
-    const db = openDb(THREADS_DB, { readonly: true });
+    const db = openReadOnly(THREADS_DB);
     const row = db.prepare('SELECT data FROM threads WHERE id = ?').get(id);
     db.close();
-    return row ? row.data : null;
+    // As a Buffer, not the raw Uint8Array node:sqlite hands back. Both callers below
+    // treat it as one: the uncompressed path calls .toString('utf-8') on it, which on a
+    // bare Uint8Array yields "40,181,47,…" — the byte VALUES, comma-joined — and the
+    // thread would then fail JSON.parse as if it were corrupt.
+    return row ? bytesOf(row.data) : null;
   } catch (e) {
     // This is the message-blob read. A silent null here becomes a zero-message
     // session, which overwrites the stored transcript on re-ship.

package/memhouse/COMPETITION.md

@@ -141,11 +141,15 @@ memory. None ingest agent sessions.
   into *installed skills*. Our skills must be chosen. One independent analysis of 270
   real sessions found **only 4.8% involved an explicit history query** — a pull-only
   model gets invoked rarely.
-- **Install weight — we are the heaviest in the category.** AgentsView, deja-vu and
-  ctx are single dependency-free binaries via Homebrew, Docker, `go install` or curl.
-  We are Node, need `--allow-scripts=better-sqlite3` (five adapters silently read
-  nothing without it), and additionally need a ClickHouse to point at. Our README
-  spends paragraphs on `EACCES`/`sudo` triage. That is a real adoption tax.
+- **Install weight — still the heaviest in the category, but half the tax is paid.**
+  AgentsView, deja-vu and ctx are single dependency-free binaries via Homebrew, Docker,
+  `go install` or curl. We are Node and need a ClickHouse to point at.
+  **Resolved 2026-08-16:** the native-dependency half is gone. `better-sqlite3` was
+  replaced by `node:sqlite`, so `npm i -g memhouse` with no flags is now a complete,
+  fully working install — no `--allow-scripts`, no build step, and no five-adapters-
+  silently-read-nothing failure mode. What remains of the tax is the runtime (Node,
+  not a static binary), the ClickHouse dependency, and the `EACCES`/`sudo` prefix
+  triage, which was never about the flag and is not fixable from our side.
 - **Semantic search.** AgentsView (opt-in index), claude-mem (Chroma),
   claude-history (local embedding model). We are FTS-only. Contested rather than
   settled — deja-vu made the same choice and was criticised for it on HN.

package/memhouse/RESUME-AND-UPDATE.md

@@ -95,18 +95,15 @@ original to duplicate the copy.
 
 ### The gap
 
-`npm i -g memhouse@latest` does one third of the job, and the other two thirds have each
-cost a real machine real sessions:
-
-1. **`--allow-scripts=better-sqlite3` is not remembered.** Omit it on the upgrade and
-   `better-sqlite3` has no binding again — cursor, zed, opencode, goose and antigravity
-   read zero sessions on every pass afterwards.
-2. **The daemons keep running the old code.** See §3.
-3. **The house can be older than the shipper.** A newer shipper may need a column an
+`npm i -g memhouse@latest` does half the job, and the other half has cost a real machine
+real sessions:
+
+1. **The daemons keep running the old code.** See §3.
+2. **The house can be older than the shipper.** A newer shipper may need a column an
    existing room lacks; it detects that and prints the rebuild, but only if something runs
    it.
 
-And from a checkout there is a fourth: `git pull` updates `ui/src` and leaves the built
+And from a checkout there is a third: `git pull` updates `ui/src` and leaves the built
 bundle in `public/`, so the dashboard serves the previous release however often it is
 restarted. A published tarball is immune — `prepack` builds `public/` before publish.
 
@@ -114,7 +111,7 @@ restarted. A published tarball is immune — `prepack` builds `public/` before p
 
 | Kind | Detected by | Action |
 |---|---|---|
-| `global` | under `npm prefix -g` | `npm i -g memhouse@latest --allow-scripts=better-sqlite3` |
+| `global` | under `npm prefix -g` | `npm i -g memhouse@latest` |
 | `checkout` | a `.git` at the root | `git pull --ff-only` → `npm install` → `npm run build` |
 | `local-dep` | `node_modules/memhouse`, not under the global prefix | refuse; print the right command for where it lives |
 | `npx` | `_npx` in the resolved path | refuse — the next `npx` resolves the registry anyway |

package/memhouse/delivery/AGENT-INSTALL.md

@@ -7,21 +7,21 @@ in order; every command is copy-pasteable.
 machine it runs on — which editors have sessions, whether a ClickHouse answers, whether
 docker or podman exists — and states the one route that applies. This file is the static
 long-form version and assumes a reachable ClickHouse already exists, which is the case
-`deploy --local` was added to remove. Prereqs: Node >= 20.19 and a reachable
+`deploy --local` was added to remove. Prereqs: Node >= 24 and a reachable
 ClickHouse >= 26.2 (local server, Cloud, or a kernel house — see
 `kernel-install.md` for the kernel path). No checkout required — memhouse is on npm.
 
 ## 1. Install
 
 ```bash
-npm install -g memhouse --allow-scripts=better-sqlite3
+npm install -g memhouse
 ```
 
-`--allow-scripts=better-sqlite3` is required, not cosmetic. Five adapters (cursor,
-goose, opencode, zed, antigravity) read SQLite session stores, and npm 12 blocks
-the install script that builds the native binding. Without it those five silently
-return zero sessions and you ship a partial history. Verify with step 4 —
-`memhouse discover` names any adapter it had to skip.
+No flags. This line used to require `--allow-scripts=better-sqlite3`, without which
+five adapters (cursor, goose, opencode, zed, antigravity) silently returned zero
+sessions and you shipped a partial history. SQLite now comes from `node:sqlite`, which
+is part of Node, so there is no install script and nothing to allow. Step 4 still
+verifies — `memhouse discover` names any adapter it had to skip, for any reason.
 
 On `EACCES`, decide by **who owns the prefix root**. Not the path — Homebrew's
 prefix is `/usr/local` on Intel and `/opt/homebrew` on Apple Silicon and is
@@ -34,7 +34,7 @@ ls -ld "$(npm prefix -g)"     # the prefix ROOT decides
 ```
 
 Prefix root owned by `root` → a system-managed Node; re-run as
-`sudo npm install -g memhouse --allow-scripts=better-sqlite3`.
+`sudo npm install -g memhouse`.
 
 Prefix root owned by the current user → the prefix is theirs (Homebrew, fnm, nvm,
 volta), so the root-owned file npm tripped on is a stray from an earlier `sudo npm`
@@ -42,8 +42,8 @@ and another `sudo` adds more. Repair that path instead:
 `sudo chown -R "$(id -u):$(id -g)" <path npm named>` (same for `~/.npm`).
 
 From a checkout instead (contributors): `npm install --no-audit --no-fund` in the
-repo root — its `allowScripts` field already covers the binding — then substitute
-`node bin/memhouse.js` for `memhouse` below.
+repo root — nothing compiles — then substitute `node bin/memhouse.js` for `memhouse`
+below.
 
 ## 2. Configure the connection
 
@@ -77,9 +77,11 @@ memhouse discover     # which adapters were read, and which were SKIPPED
 memhouse stats        # per-source counts now in the house
 ```
 
-Read `discover` first. It prints one line per editor it found sessions for, and
-warns by name about any adapter it had to skip — that warning is the only signal
-that step 1's `--allow-scripts` flag was missed and five editors are dark.
+Read `discover` first. It prints one line per editor it found sessions for, and warns
+by name about any adapter it had to skip. On a healthy install that list is empty: the
+one cause that could take five adapters out at once — a missing native SQLite binding —
+no longer exists, so anything named here is a single editor's own store (locked by a
+running editor, corrupt, or on a schema this parser does not know).
 
 `stats` should show one row per source (claude-code, codex, gemini-cli, …) with
 non-zero sessions/messages. Or verify by SQL — rooms are named for your ClickHouse

package/memhouse/delivery/kernel-install.md

@@ -35,7 +35,7 @@ rotate on first connect (`issue-credential{user:'memhouse_root'}`).
 ## 2. Owner sets up the house
 
 ```bash
-npm install -g memhouse --allow-scripts=better-sqlite3
+npm install -g memhouse
 memhouse install --yes \
   --url https://<kernel-host>:8443 \
   --user memhouse_root \
@@ -46,9 +46,9 @@ memhouse install --yes \
 That writes `~/.memhouse/env`, applies the schema, and runs the first ship.
 `memhouse start` then keeps it fresh on a 300s loop.
 
-Keep `--allow-scripts=better-sqlite3`: without it npm 12 leaves `better-sqlite3`
-with no native binding and the five SQLite-backed adapters ship nothing, silently.
-`memhouse discover` names any adapter it had to skip.
+No flags: SQLite comes from `node:sqlite`, so there is no native binding to build
+and no adapter that can go dark for want of one. `memhouse discover` still names any
+adapter it had to skip — now always a single editor's own store.
 
 The kernel never runs or reads any of this — it is content-blind; the shipper is
 the agency's own resident, a deterministic `worker` on a loop (no LLM, not an

package/memhouse/house/house.js

@@ -50,14 +50,19 @@ const MEMBER_PIN = 'async_insert = 0 CONST';
 /**
  * The global-install command that will actually work HERE.
  *
- * Every site that printed `npm install -g memhouse --allow-scripts=better-sqlite3` printed
- * a line that fails with EACCES on any distro-packaged Node, because the global prefix is
- * root-owned — measured on a clean Ubuntu machine, exit 243. `sudo` is right for exactly
- * one of the two causes and makes the other worse, and what tells them apart is who owns
- * the prefix — so look, rather than guess.
+ * The flag half of this is gone: the command carried `--allow-scripts=better-sqlite3`
+ * for as long as SQLite was a native module, and omitting it silently cost five
+ * adapters. `node:sqlite` needs no install script, so the base command is now the plain
+ * one everybody already types.
+ *
+ * The `sudo` half stays, because it was never about the flag. A bare install fails with
+ * EACCES on any distro-packaged Node, because the global prefix is root-owned — measured
+ * on a clean Ubuntu machine, exit 243. `sudo` is right for exactly one of the two causes
+ * and makes the other worse, and what tells them apart is who owns the prefix — so look,
+ * rather than guess.
  */
 function installCommand() {
-  const base = 'npm install -g memhouse --allow-scripts=better-sqlite3';
+  const base = 'npm install -g memhouse';
   try {
     const { execFileSync } = require('child_process');
     const prefix = execFileSync('npm', ['prefix', '-g'], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();

package/memhouse/self-update.js

@@ -6,10 +6,10 @@
 // of the CLI you just typed, not the version the daemon is running. On macminim a shipper
 // ran 1d16h out of a directory that had been MOVED — the fix was live, the machine was not.
 //
-// npm's own `postinstall` is the obvious hook and the wrong one. Install scripts are
-// blocked by default (`--allow-scripts`), which is the very condition this product already
-// has to work around, and a package install that restarts a user's daemons is a surprise
-// even when it works.
+// npm's own `postinstall` is the obvious hook and the wrong one. npm >= 12 blocks install
+// scripts by default, so it would not run at all on a stock install — the same default
+// that cost this product its SQLite binding until `node:sqlite` removed the need for one —
+// and a package install that restarts a user's daemons is a surprise even when it works.
 //
 // So the daemon notices for itself. Once per loop pass it compares what is on disk against
 // what it booted with, and when they differ it hands over:

package/memhouse/shipper/ship.js

@@ -792,18 +792,17 @@ async function runShip(client, opts = {}) {
   return { sessions, skipped, msgRows, toolRows, unreadable };
 }
 
-// Warn once per adapter per pass. `warned` carries across the two call sites so a
-// dead binding is not reported twice in the same run.
+// Warn once per adapter per pass. `warned` carries across the two call sites so one
+// unreadable store is not reported twice in the same run.
+//
+// The loud case used to be a missing better-sqlite3 binding, which took five adapters
+// out together and came with a reinstall command attached. SQLite ships with Node now;
+// what is left is per-store, and each error already says what happened.
 function reportAdapterErrors(warned) {
   const errors = getAdapterErrors().filter((e) => !warned.has(e.source));
   if (!errors.length) return;
   for (const e of errors) warned.add(e.source);
-  const noBinding = errors.filter((e) => e.missingBinding).map((e) => e.source);
-  if (noBinding.length) {
-    console.log(`[memhouse] WARNING: ${noBinding.length} adapter(s) skipped, sessions NOT shipped — better-sqlite3 has no native binding: ${noBinding.join(', ')}`);
-    console.log(`[memhouse]          fix: ${require('../house/house').installCommand()}`);
-  }
-  for (const e of errors.filter((x) => !x.missingBinding)) {
+  for (const e of errors) {
     console.log(`[memhouse] WARNING: ${e.source} skipped — ${e.message}`);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memhouse",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "memhouse — agent conversation memory across 17 editors: parse-on-client shippers, a typed ClickHouse store with one set of rooms per member, kernel-agency install, and the agentlytics dashboard",
   "main": "bin/memhouse.js",
   "bin": {
@@ -43,10 +43,7 @@
   "author": "Ramazan Polat <ramazanpolat@gmail.com> (built on agentlytics by fkadev)",
   "license": "MIT",
   "engines": {
-    "node": ">=20.19.0"
-  },
-  "allowScripts": {
-    "better-sqlite3": true
+    "node": ">=24.0.0"
   },
   "repository": {
     "type": "git",
@@ -54,7 +51,6 @@
   },
   "dependencies": {
     "@clickhouse/client": "^1.23.1",
-    "better-sqlite3": "^12.6.2",
     "express": "^4.22.1"
   }
 }