memhouse 0.3.2 → 0.4.3

package/editors/antigravity.js

@@ -2,7 +2,16 @@ const { execSync, execFileSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const Database = require('better-sqlite3');
+// 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 { getAppDataPath } = require('./base');
 const adapterErrors = require('./adapter-errors');
 
@@ -235,7 +244,7 @@ function readGlobalStateValue(key) {
 
   let db = null;
   try {
-    db = new Database(ANTIGRAVITY_GLOBAL_STORAGE_DB, { readonly: true, fileMustExist: true });
+    db = openDb(ANTIGRAVITY_GLOBAL_STORAGE_DB, { readonly: true, fileMustExist: true });
     const row = db.prepare('SELECT value FROM ItemTable WHERE key = ?').get(key);
     if (!row) return null;
     const v = row.value;

package/editors/cursor.js

@@ -1,4 +1,13 @@
-const Database = require('better-sqlite3');
+// 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 path = require('path');
 const fs = require('fs');
 const os = require('os');
@@ -147,7 +156,7 @@ function getWorkspaceMap() {
 
 function getComposerHeaders(stateDbPath) {
   try {
-    const db = new Database(stateDbPath, { readonly: true });
+    const db = openDb(stateDbPath, { readonly: true });
     const row = db.prepare("SELECT value FROM ItemTable WHERE key = 'composer.composerData'").get();
     db.close();
     if (!row) return [];
@@ -277,7 +286,7 @@ function getChats() {
   // Source 1: ~/.cursor/chats store.db
   for (const { workspace, chatId, dbPath } of getAgentStoreChats()) {
     try {
-      const db = new Database(dbPath, { readonly: true });
+      const db = openDb(dbPath, { readonly: true });
       const meta = readStoreMeta(db);
       db.close();
       if (meta) {
@@ -316,7 +325,7 @@ function getChats() {
 
   // Source 2: workspaceStorage composers
   let globalDb = null;
-  try { globalDb = new Database(GLOBAL_STORAGE_DB, { readonly: true }); }
+  try { globalDb = openDb(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);
@@ -369,7 +378,7 @@ function getChats() {
 
 function getMessages(chat) {
   if (chat._type === 'agent-store') {
-    const db = new Database(chat._dbPath, { readonly: true });
+    const db = openDb(chat._dbPath, { readonly: true });
     const msgs = collectStoreMessages(db, chat._rootBlobId);
     db.close();
     // Use lastUsedModel as fallback for assistant messages without model info
@@ -382,7 +391,7 @@ function getMessages(chat) {
   }
 
   let globalDb;
-  try { globalDb = new Database(GLOBAL_STORAGE_DB, { readonly: true }); }
+  try { globalDb = openDb(GLOBAL_STORAGE_DB, { readonly: true }); }
   catch (e) {
     // Returning [] unreported would let a re-ship overwrite this session's stored
     // transcript with nothing.
@@ -407,7 +416,7 @@ function getMessages(chat) {
 
 function getCursorAccessToken() {
   try {
-    const db = new Database(GLOBAL_STORAGE_DB, { readonly: true });
+    const db = openDb(GLOBAL_STORAGE_DB, { readonly: true });
     const row = db.prepare("SELECT value FROM ItemTable WHERE key = 'cursorAuth/accessToken'").get();
     db.close();
     return row ? row.value : null;

package/editors/opencode.js

@@ -1,7 +1,16 @@
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
-const Database = require('better-sqlite3');
+// 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 adapterErrors = require('./adapter-errors');
 
 // OpenCode stores data in XDG-style paths across all platforms
@@ -28,7 +37,7 @@ const DB_PATH = getOpenCodeDbPath();
 function queryDb(sql) {
   if (!fs.existsSync(DB_PATH)) return [];
   try {
-    const db = new Database(DB_PATH, { readonly: true });
+    const db = openDb(DB_PATH, { readonly: true });
     const rows = db.prepare(sql).all();
     db.close();
     return rows;
@@ -85,7 +94,7 @@ function getSqliteSessions() {
 function getSqliteMessages(sessionId) {
   if (!fs.existsSync(DB_PATH)) return [];
   try {
-    const db = new Database(DB_PATH, { readonly: true });
+    const db = openDb(DB_PATH, { readonly: true });
     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`

package/editors/zed.js

@@ -2,7 +2,16 @@ const path = require('path');
 const fs = require('fs');
 const os = require('os');
 
-const Database = require('better-sqlite3');
+// 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 adapterErrors = require('./adapter-errors');
 
 // Zed stores data in different locations depending on the platform
@@ -69,7 +78,7 @@ function decompressZstd(buf) {
 function queryDb(sql) {
   if (!fs.existsSync(THREADS_DB)) return [];
   try {
-    const db = new Database(THREADS_DB, { readonly: true });
+    const db = openDb(THREADS_DB, { readonly: true });
     const rows = db.prepare(sql).all();
     db.close();
     return rows;
@@ -91,7 +100,7 @@ function getThreadColumns() {
   if (threadColumns) return threadColumns;
   if (!fs.existsSync(THREADS_DB)) return new Set();
   try {
-    const db = new Database(THREADS_DB, { readonly: true });
+    const db = openDb(THREADS_DB, { readonly: true });
     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
@@ -122,7 +131,7 @@ function resetCache() {
 function queryBlob(id) {
   if (!fs.existsSync(THREADS_DB)) return null;
   try {
-    const db = new Database(THREADS_DB, { readonly: true });
+    const db = openDb(THREADS_DB, { readonly: true });
     const row = db.prepare('SELECT data FROM threads WHERE id = ?').get(id);
     db.close();
     return row ? row.data : null;

package/index.js

@@ -121,10 +121,10 @@ if (isJoin) {
   // Fail fast: the relay join client still targets the removed synchronous SQLite
   // cache (relay-client.js pickProjects → cache.getDb), which the ClickHouse
   // cutover eliminated — it would crash after connecting. In memhouse, team
-  // sharing is the kernel path (members + owner grants + RLS), not relay.
+  // sharing is grants on per-member rooms, not relay.
   console.error(chalk.red('\n  ✗ Relay join is not supported in memhouse.'));
   console.error(chalk.dim('    Team sharing here is kernel-based: see mem-house/delivery/kernel-install.md'));
-  console.error(chalk.dim('    (register-member + owner GRANT + own-only RLS).\n'));
+  console.error(chalk.dim('    (register-member + per-member rooms + a GRANT on your own rooms).\n'));
   process.exit(1);
 }
 

package/mem-house/COMPETITION.md

@@ -0,0 +1,217 @@
+# mem-house — the competition
+
+Companion to `DESIGN.md`. That file states **the four bets**; this one grades each
+bet against the field as it actually stands.
+
+**Surveyed 2026-08-07.** Every star/fork/date figure was pulled from the GitHub API
+on that date and is a decaying fact — re-run before citing. Claims that could not be
+verified are marked *unverified* rather than asserted. X/Twitter was not reachable
+(HTTP 402 to the fetch tool), so nothing here reflects it.
+
+The finding, in one line: **three of the four bets are already occupied by shipping
+competitors, most of them free and further along. Bet 3 is the one that holds.**
+
+---
+
+## The field splits four ways
+
+The space shares vocabulary but not architecture. Distinguishing the camps is the
+whole analysis, because most "agent memory" products are not competitors at all.
+
+| Camp | What it means | Where memory comes from | Competes with us? |
+|---|---|---|---|
+| **Transcript readers** | Index the JSONL/SQLite stores the agents already wrote | Passive — reads disk | **Yes, directly** |
+| **Hook capturers** | Install lifecycle hooks, compress with an LLM, re-inject | Passive, but must live inside the agent | Yes, on the same users |
+| **Memory SDKs** | Developer calls `add()` / `search()` | Active — the developer writes it | No — different product |
+| **Observability** | OTel/proxy traces of model calls | Passive, at the API layer | Only on analytics |
+
+mem-house is a transcript reader with the observability camp's analytics attached.
+That combination is the most defensible thing about the product's *shape*; the
+individual pieces are not scarce.
+
+---
+
+## The four bets, graded
+
+### Bet 1 — Parse on the client. **Occupied. Not differentiated.**
+
+The reasoning in `DESIGN.md` is sound and the conclusion is correct — sqlite-backed
+editors do force client-side parsing. But it is no longer a distinguishing choice.
+At least five projects crack the same on-disk stores today, and one of them cracks
+formats we do not touch (encrypted Protobuf sidecars for Antigravity CLI, Markdown
+for aider).
+
+Editor coverage — the number we lead the README with — is mid-pack:
+
+| Project | Editors | Note |
+|---|---:|---|
+| AgentsView | **50+** | each with documented on-disk paths |
+| lean-ctx | 30+ | claimed |
+| CCHV | 28 | each with documented paths |
+| **mem-house** | **17** | |
+| deja-vu | 17 | different 17 — has Cline, aider, Qwen Code, Kimi Code, Roo Code |
+| coding_agent_session_search | 11+ | |
+| ctx | 8 | |
+| Conare | 7 | |
+| Contextify | 2 | Claude Code + Codex CLI only |
+
+deja-vu's tagline is our pitch verbatim: *"it indexes the sessions your coding agents
+already wrote to disk, months of history from before you installed it, across
+seventeen harnesses."*
+
+### Bet 2 — Typed common schema. **Occupied on outcome, distinct on method.**
+
+Everyone arrives at structured storage; the axis that still separates us is **when
+the extraction happens and what survives it**.
+
+- **SQLite + FTS5 is the category default**, reached independently by AgentsView,
+  Agent Sessions, claude-code-chat-explorer, claude-mem, ccrecall and mnemo.
+- **ClickHouse for editor transcripts is unclaimed.** The only other ClickHouse-based
+  agent memory found is `clickmem` (57 stars) and it is embedded chDB, single-user,
+  so it inherits none of the multi-member properties. Langfuse is ClickHouse-backed,
+  MIT and self-hostable — but ingests API traces, not editor stores.
+- **Verbatim-with-no-LLM-on-the-write-path has one serious co-traveller**:
+  MemPalace (58k stars in four months) sells exactly that — *"verbatim storage,
+  zero API calls."* We are not alone on this axis, but the company is good.
+
+Honest caveat: at single-team scale SQLite demonstrably suffices. ClickHouse is a
+bet on a scale we have not yet had to prove.
+
+### Bet 3 — Kernel-installable agency, own-only by absent grant. **This one holds.**
+
+This is the finding worth acting on. Every competitor's multi-user story is a
+**shared pool** or **metadata scoping**. Not one enforces isolation at the
+datastore's own permission layer.
+
+| Product | Team mechanism | Isolation |
+|---|---|---|
+| AgentsView | `pg push` / `pg serve` to shared PostgreSQL | **None.** Connection string is the whole boundary; `machine_name` is a label, not a fence |
+| memsearch (Zilliz) | Docker + shared Milvus, documented "for team environments" | **None documented** — no RBAC, no per-user namespacing |
+| mem0 | `user_id` + `agent_id` + `run_id` filters | Metadata filtering, not enforcement |
+| Industry pattern | `tenant_id` column + row-level security | Policy layer, revocable by whoever owns the policy |
+| Contextify | Cloud workspace, per-project opt-in | Real, but proprietary, cloud-first, 2 editors |
+| **mem-house** | three `GRANT SELECT` on the member's own rooms | **A member cannot name another member's rooms.** `WITH GRANT OPTION` on `SELECT` and not on `ALL` makes sharing read-only by construction and operator-free |
+
+Bet 3 is not a niche preference. It is a category-wide blind spot, and it is the
+only thing in this document that nobody else is attempting.
+
+### Bet 4 — Borrowed UI, zero fork. **Occupied. Not differentiated.**
+
+Analytics over the same files is a crowded, mature niche: ccusage (17.8k stars),
+CodexBar (19.8k). Agent Sessions beats us on the analytics *idea* with a per-session
+"Quota Meter / Session Runway" priced per model against 5-hour and weekly windows.
+AgentsView ships cache-aware, LiteLLM-priced cost reporting plus a REST usage API.
+
+Zero-fork was the right call for build cost. It buys no position.
+
+---
+
+## The field, ranked by how directly it competes
+
+| # | Project | What it is | Source | Store | Team | Editors | Licence | Signal (2026-08-07) |
+|---|---|---|---|---|---|---:|---|---|
+| 1 | **AgentsView** | Go binary + Tauri app + Docker image | reads disk | SQLite/FTS5, opt. DuckDB, opt. **PostgreSQL** | shared pool, free | 50+ | MIT | **4,723★**, 574 forks, 100 contributors, six months old, MCP server, semantic search |
+| 2 | **claude-mem** | npm plugin + MCP + web viewer | **hooks** | SQLite + Chroma, opt. cloud | none | ~8 | Apache-2.0 | **89,967★**, 7,831 forks, **62,940 npm dl/mo**. The category's centre of gravity |
+| 3 | **MemPalace** | local-first memory, verbatim | mixed, mining transcripts | pluggable | none | — | MIT | **58,182★ in four months**, 696 open issues, contested benchmarks |
+| 4 | **deja-vu** | zero-dep Go binary, CLI + MCP + hook | reads disk | `records.bin`, no server | none — personal SSH sync | 17 | MIT | 593★, HN 131 pts, redacts secrets at index |
+| 5 | **Contextify** | macOS app + CLI, cloud **and** self-hosted | reads disk | local + optional cloud | **real**: seats, roles, per-project opt-in | 2 | proprietary / FSL | $8–15/seat/mo; self-host $132/seat/yr |
+| 6 | **ctx** | Rust CLI, event-level provenance | reads disk | local SQLite | **ctx cloud**, hosted, private beta | 8 | Apache-2.0 | 1,013★ |
+| 7 | **SpecStory** | IDE extensions + CLI | **writes its own** | local + cloud | team rollups | 9 | Apache-2.0 | 1,296★; **Team $300/mo**; "Lore" mines history into installable skills |
+| 8 | **Conare** | CLI + hosted, MCP | reads disk | vendor cloud | shared memory, audit logs, SSO | 7 | proprietary | **Team $500/mo** |
+| 9 | **memsearch** | Markdown + Milvus shadow index | Stop hooks | Markdown truth + Milvus | Docker, no isolation | 4 | MIT | 2,431★, Zilliz-backed |
+| 10 | **CCHV** | Tauri app + **headless server** | reads disk | provider files + cache | server mode w/ accounts | 28 | MIT | 2,020★, 45 contributors |
+| 11 | **Agent Sessions** | native macOS app | reads disk | SQLite/FTS5 | none | 10 | MIT | 762★; best-in-class quota metering; resume + write-back restore |
+| 12 | **ContextPool** | CLI + MCP | reads disk | local + repo dir | shared pool, $7.99/mo | 4 | mixed | 188 PH upvotes |
+
+Adjacent and **not** competitors, but they own the vocabulary and the capital:
+mem0 (62.8k★, $24M), cognee (29.8k★), graphiti (29.6k★), supermemory (28.8k★),
+letta (24.1k★, $10M seed), memori (15.7k★), OpenViking (28.1k★, ByteDance),
+Hindsight (19.2k★, $3.6M seed). All of them require the developer to write the
+memory. None ingest agent sessions.
+
+---
+
+## What they do better
+
+- **Distribution.** mem-house: 0 stars, 655 npm downloads/month, no HN or search
+  presence. claude-mem: 89,967 stars and 62,940 downloads/month, free, no company.
+  This dominates every other consideration in the document.
+- **Automatic recall.** deja-vu installs a SessionStart hook; claude-mem injects into
+  future sessions; ContextPool loads at session start; SpecStory converts history
+  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.
+- **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.
+- **Secret redaction at ingest.** deja-vu redacts credential patterns on index *and*
+  on sync export. Whether we do is *unverified* — and it matters more here than
+  elsewhere, because Claude Code caches unredacted secrets in transcripts
+  (anthropics/claude-code#43675) and we ship those rows to a shared server.
+- **Resume and write-back.** Agent Sessions copies resume commands for six CLIs and
+  restores into the archive; claude-history resumes *and forks* worktree-aware. We
+  read but do not hand the pilot back in.
+- **Price ceiling.** AgentsView gives the whole stack away under MIT. That caps what
+  a self-hosted OSS competitor can charge for.
+
+---
+
+## Unclaimed ground
+
+Two positions nobody occupies, both reachable from where we already are.
+
+**1. Evidence and claims as two layers.** The sharpest architectural critique found
+anywhere in the survey, and no product in the field claims to do it: keep the capture
+log and the memory layer distinct. The capture log is chronological evidence; memory
+is a set of derived, revisable claims. Each claim cites the exact spans supporting
+it, records when it was inferred, and marks itself current, disputed or superseded —
+and deletion follows that lineage. This is available **only** to a system that keeps
+verbatim transcripts with provenance. Every extract-only competitor has discarded the
+evidence by the time the claim is written. We and MemPalace are the two systems
+positioned to build it. Neither has.
+
+**2. The 30-day deletion window.** Claude Code deletes JSONL transcripts after 30
+days. Contextify was built because of it; vibe-replay documents it; **nobody markets
+on it.** A durable server-side store is the strongest possible answer, and we are
+better positioned than any local-index tool. This is free ground.
+
+---
+
+## Three cautions
+
+**Do not compete on benchmark scores.** The benchmarks are broken. An independent
+LOCOMO audit found 99 score-corrupting errors in 1,540 questions (6.4%), and the
+standard LLM judge accepted 62.81% of adversarially-generated wrong-but-topical
+answers. Nine vendors claim mutually incompatible SOTA on it. MemPalace's claimed
+100% was reverse-engineered publicly to 98.4%, achieved with `top-k=50` — which
+exceeds the session count. deja-vu's 84.9% hit@1 carries the same asterisk. Entering
+this contest means measuring the field against itself.
+
+**Stars are not traction, and are farmed in this category.** `mindverse/Second-Me`
+holds 15,648 stars and has been dead for ten months. MemPalace took 58k stars in four
+months while accumulating 2,183 issues, one titled *"in short: This sucks shit."*
+Screenpipe reportedly mails its stargazers.
+
+**The free incumbent sets the floor.** claude-mem is Apache-2.0, free, no cloud tier,
+no company, one dominant author. Any paid or heavier-install offering is measured
+against that baseline, not against a vendor's price list.
+
+---
+
+## Net position
+
+Not differentiated on parse-on-client, editor breadth, self-hosting, analytics, or
+agent-facing skills — all matched or beaten, most comprehensively by AgentsView
+(MIT, free, 50+ editors, 4,723 stars, six months old).
+
+Two things hold: **grant-enforced per-member isolation**, which nobody attempts, and
+**verbatim transcripts with provenance**, which is the prerequisite for the
+evidence/claims separation the field has identified but not built.
+
+The liabilities are zero distribution and the heaviest install in the category.
+Both are fixable; neither is fixed by adding another editor adapter.

package/mem-house/DESIGN.md

@@ -2,11 +2,16 @@
 
 **mem-house** is agent conversation memory as a product: every coding-agent session
 on your machines — across **all 17 editors** agentlytics supports — parsed locally,
-shipped to one typed ClickHouse store, shareable with a team, installable on the
+shipped to a typed ClickHouse store, shareable with a team, installable on the
 ultimagent kernel as an **agency**, and visible through the agentlytics dashboard.
 
+**One house, a set of rooms per member** — `sessions_<m>`, `messages_<m>`,
+`tool_calls_<m>`. All of one member's machines ship into that member's rooms, told
+apart by the `host` column; no member writes into another's. The shared-table layout
+this once had was removed in 0.4.0; see `per-member/`.
+
 **Agency, precisely.** In constellation terms (`../TERMINOLOGY.md`) mem-house is a
-**house** — the `memhouse` database — **plus a resident**: the shipper. That pairing
+**house** — the `mem` database — **plus a resident**: the shipper. That pairing
 is what the word *agency* means; a house on its own only holds.
 
 The test is mechanical — **residents write, routines read**. The shipper fires on a
@@ -18,27 +23,34 @@ kind = "worker"    # deterministic code, no LLM
 on   = "loop"      # a daemon — not an insert trigger, not a schedule
 ```
 
-`sessions_v` is a plain view: computed during your query, for your query, writing
-nothing. It is a **routine** — house machinery, not a second resident. mem-house has
-**no materialized views at all**, so the shipper is not merely a resident, it is the
-only candidate in the tree. Strip it and every remaining moving part is a routine
-over rows nobody is writing any more.
+The session rollup is a **routine** — house machinery, not a second resident. Since
+0.4.0 it is not even an object: it is SQL text (`per-member/rooms.js`), substituted with
+the caller's own room names and computed during your query, for your query, writing
+nothing. mem-house has **no materialized views at all** — in fact no stored views at all
+— so the shipper is not merely a resident, it is the only candidate in the tree. Strip
+it and every remaining moving part is a routine over rows nobody is writing any more.
 
 Note that `user_id MATERIALIZED currentUser()` is a materialized *column*: it computes
-during your own insert and is part of the table's definition. It makes own-only RLS
-work and it records who wrote each row, but it is an identity property, not what makes
-this an agency.
+during your own insert and is part of the table's definition. It is not what isolates
+members — the room they hold no grant on does that — but it records who wrote each row,
+which keeps provenance across a share and keeps the `Merge` rooms meaningful. An identity
+property, not what makes this an agency.
 
 **Positioning:** an alternative agency **competing with memory-house**. It borrows
-memory-house's proven ideas (server-stamped identity, own-only RLS, idempotent
-shipping, skills/plugin delivery) and agentlytics' proven assets (adapters, UI,
-cost engine). If it wins, it can become memory-house v4; until then the two run
-side by side as separate agencies, each in its own house. Naming: the product is
-**mem-house**; ClickHouse identifiers use **`memhouse`** (agency/house name, owner
-`memhouse_root`) since identifiers can't carry a dash.
+memory-house's proven ideas (server-stamped identity, idempotent shipping,
+skills/plugin delivery) and agentlytics' proven assets (adapters, UI, cost engine) —
+but **not** its shared-table-plus-row-policy layout, which 0.4.0 removed in favour of
+one set of rooms per member. If it wins, it can become memory-house v4; until then the
+two run side by side as separate agencies, each in its own house. Naming: the product is
+**mem-house**; the agency is **`memhouse`** and its house is the **`mem`** database
+(identifiers can't carry a dash; the owner kept the longer name, `memhouse_root`).
 
 ## The four bets
 
+`COMPETITION.md` grades each of these against the field as surveyed 2026-08-07.
+Short version: bets 1, 2 and 4 are occupied by shipping competitors, several of
+them free and further along; **bet 3 is the one nobody else attempts.**
+
 1. **Parse on the client.** memory-house ships raw transcript lines and parses in
    views — workable only because its 4 agents store sessions as JSON/JSONL files.
    agentlytics' breadth includes sqlite-backed editors (Cursor, VS Code, Zed,
@@ -48,19 +60,20 @@ side by side as separate agencies, each in its own house. Naming: the product is
    write axis this bet is precisely *moving work from routine to resident*:
    memory-house parses when you query, mem-house parses before anyone asks and
    writes the result down.
-2. **Typed common schema** (`schema.sql`). Physical typed columns (what
-   memory-house derives in views) + `tool_calls` (memory-house has none) + one
-   `extra JSON` escape hatch per table so unnormalized adapter fields are never
-   lost. `ReplacingMergeTree(ingested_at)`; `messages` keyed `(session_id, seq)` so
-   a re-ship of a grown/changed session replaces stale rows (latest-wins). FTS text
-   indexes built in (CH ≥ 26.2).
+2. **Typed common schema** (`per-member/schema-member.sql.tpl`, applied once per
+   member; `schema-merge.sql.tpl` for the team rooms). Physical typed columns (what
+   memory-house derives in views) + `tool_calls_<m>` (memory-house has no tool table)
+   + one `extra JSON` escape hatch per room so unnormalized adapter fields are never
+   lost. `ReplacingMergeTree(ingested_at)`; `messages_<m>` keyed
+   `(session_id, user_id, seq)` so a re-ship of a grown/changed session replaces stale
+   rows (latest-wins). FTS text indexes built in (CH ≥ 26.2).
 3. **Kernel-installable agency.** Same install path proven for agentlytics-agency:
    `install-agency{memhouse}` → house + `memhouse_root` + credential; members via
-   `register-member` + owner `GRANT`; own-only visibility via the row policy
-   (`rls.sql`) applied by the ego (the `kernel` user) or the mayor. The shipper is
+   `register-member` + owner `GRANT` on that member's own rooms. Own-only visibility
+   needs no policy: a member is granted their rooms and nobody else's. The shipper is
    the resident that lands with it. Identity is `user_id MATERIALIZED currentUser()`
-   (requires `async_insert=0`). Sharing modes: own-only (policy TO member) or
-   team-pool (no policy).
+   (requires `async_insert=0`). Sharing is a further GRANT, issued by the member
+   themselves (grant-option) or the owner.
 4. **Borrowed UI, zero fork.** The React SPA consumes REST JSON, not tables. The
    mem-house server implements the **same `/api/*` contract** as agentlytics'
    `server.js` (same routes, same response shapes) over the mem-house schema, and
@@ -70,11 +83,13 @@ side by side as separate agencies, each in its own house. Naming: the product is
 
 | Path | What | Notes |
 |---|---|---|
-| `schema.sql` | the house schema (typed) | unqualified names; owner applies in its house |
-| `rls.sql` | own-only row policies | the ego (`kernel`) or the mayor applies (owner lacks ACCESS MANAGEMENT) |
+| `per-member/rooms.js` | room-name resolution + the session rollup | one naming rule for both transports |
+| `per-member/schema-member.sql.tpl` | one member's three rooms (typed) | the owner via `provision.js`, or the member on a house they own |
+| `per-member/schema-merge.sql.tpl` | the three team Merge rooms | owner-managed; reduce to the caller's grants |
 | `shipper/ship.js` | parse-on-client shipper CLI — the resident (`worker`) | reuses `../../editors`; incremental; idempotent |
 | `server/server.js` | REST API + dashboard | same API contract as agentlytics; serves `../../public` |
 | `delivery/` | delivery kit | installer, skills, plugin, AGENT-INSTALL.md, prompt |
+| `COMPETITION.md` | the competitive landscape, graded against the four bets | surveyed 2026-08-07; figures decay, re-run before citing |
 
 ## Environment contract
 
@@ -83,7 +98,7 @@ side by side as separate agencies, each in its own house. Naming: the product is
 | `MEMHOUSE_URL` | `http://localhost:8123` | ClickHouse HTTP(S) endpoint |
 | `MEMHOUSE_USER` | `memhouse_root` | CH user (owner, or a member's own credential) |
 | `MEMHOUSE_PASSWORD` | *(empty)* | credential |
-| `MEMHOUSE_DB` | `memhouse` | the house |
+| `MEMHOUSE_DB` | `mem` | the house |
 | `MEMHOUSE_PORT` | `4640` | dashboard/API port |
 
 Config file: `~/.memhouse/config.json` (`hiddenProjects`, future prefs).
@@ -102,6 +117,15 @@ Config file: `~/.memhouse/config.json` (`hiddenProjects`, future prefs).
 - Incremental shipping: read existing `(session_id, last_updated_at, message_count)`
   (FINAL) and skip chats that haven't grown/changed; a full re-ship must remain
   safe (ReplacingMergeTree collapses).
+- Re-shipping a known session **deletes its message/tool rows first**: `ReplacingMergeTree`
+  collapses same-key rows but cannot remove a row the new parse no longer produces, so a
+  shrunken re-parse would leave a stale `seq` tail forever.
+- **A mutation predicate must bind the user, never call `currentUser()`.** A mutation does
+  not evaluate it in the caller's context: measured on ClickHouse 25.11 and chdb, the same
+  `DELETE` matched 0 rows with `user_id = currentUser()` and 2000 with the value bound —
+  silently, both times. Read the identity once (`SELECT currentUser()`) and pass it as a
+  query parameter. This applies to `DELETE`/`ALTER … UPDATE`, not to `SELECT`, where
+  `currentUser()` behaves as expected.
 - Costs are computed in the server from `pricing.js` (repo root) over per-model
   token sums; `<synthetic>` and empty models excluded from model lists.
 
@@ -114,6 +138,11 @@ to use mem-house as memory), `kernel-install.md` (provision as agency `memhouse`
 
 ## Non-goals (v0)
 
-Relay/team-server (the kernel + RLS already covers sharing), launchd daemonization
-(ship `--loop` instead), migration tooling from memory-house's `memory` db, and
-per-adapter true message timestamps.
+Relay/team-server (per-room grants plus the `Merge` rooms already cover sharing),
+migration tooling from memory-house's `memory` db, and per-adapter true message
+timestamps.
+
+OS-level daemonization **was** a non-goal — "ship `--loop` instead" — and is no longer:
+`memhouse service install` writes a systemd `--user` unit or a launchd LaunchAgent. The
+reason the non-goal did not survive is that `--loop` outlives the shell and nothing else,
+so a machine that reboots stops shipping until somebody notices.

package/mem-house/delivery/AGENT-INSTALL-PROMPT.md

@@ -0,0 +1,58 @@
+# memhouse — agent install prompt (template)
+
+`memhouse prompt --install` renders this with THIS machine's facts substituted and
+prints it. Feed the output to a coding agent; it has everything needed to install and
+onboard without asking the user to look anything up.
+
+The point of rendering rather than shipping a static runbook: the CLI has already
+probed the machine, so the prompt states the route that applies instead of making the
+agent reason through a decision tree and possibly pick wrong. `AGENT-INSTALL.md` is the
+static long-form version, and it predates `deploy --local`.
+
+Placeholders are `{{NAME}}`. Everything below the marker is the prompt body.
+
+<!-- PROMPT BODY BELOW -->
+You are installing **memhouse** for the user on this machine.
+
+memhouse gives a coding agent long-term memory of past sessions. It reads the session
+transcripts your editors already write to disk — 17 of them — parses them locally, and
+ships typed rows into ClickHouse. Nothing is intercepted or proxied; it reads files that
+already exist.
+
+## What this machine looks like right now
+
+- memhouse version: **{{VERSION}}**
+- platform: {{PLATFORM}}, node {{NODE}}
+- current state: **{{STATE}}**
+- editors with sessions found: {{EDITORS}}
+- reachable ClickHouse: {{HOUSE}}
+- container engines available: {{ENGINES}}
+
+## Your task
+
+{{PLAN}}
+
+## Rules that matter
+
+- **Never invent a credential.** If a step needs a password for a house the user already
+  runs, ask them for it. Do not guess, do not read it out of a file they did not name.
+- **Do not run `deploy --down`.** It destroys the container *and its volume*. It is never
+  part of an install.
+- The install writes `~/.memhouse/env` at mode 0600. Do not print its contents; do not
+  echo a password into the transcript you are writing, which memhouse will then ship.
+- If a command fails, read what it printed before retrying. memhouse's failures name the
+  cause and usually name the fix — it is not a generic tool that fails generically.
+- Rooms are named for the ClickHouse user: `sessions_<them>`, `messages_<them>`,
+  `tool_calls_<them>`. There are no unsuffixed tables. If you write a query, suffix it.
+
+## When you are done
+
+Run `memhouse doctor` and report its output to the user. Every line should be a check
+mark. Then tell them:
+
+- where the dashboard is (`http://localhost:{{PORT}}`) and that `memhouse start` runs it
+- that `memhouse search <terms>` searches every past session from every editor
+- that you can now search their history yourself, and offer to try one query
+
+If `doctor` reports a failure, say which line failed and what memhouse suggested. Do not
+declare success on a partial install.