memhouse 0.3.1 → 0.4.2

package/editors/zed.js

@@ -81,6 +81,44 @@ function queryDb(sql) {
   }
 }
 
+// Zed's `threads` schema varies by version: `worktree_branch` exists in some builds
+// and not others, and older builds lack `created_at`. Naming a column that is not
+// there fails the WHOLE query with "no such column", which cost every Zed thread on
+// this machine — silently, until the adapter started reporting. So ask the table what
+// it has rather than assuming. Cached: the schema cannot change while we scan.
+let threadColumns = null;
+function getThreadColumns() {
+  if (threadColumns) return threadColumns;
+  if (!fs.existsSync(THREADS_DB)) return new Set();
+  try {
+    const db = new Database(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
+    // throwing. Left unreported, that would cache an empty set, return no sessions,
+    // and look exactly like an unused Zed install — the same silent whole-adapter
+    // drop this function exists to end. Do not cache it either: the next scan should
+    // look again rather than inherit the verdict.
+    if (cols.length === 0) {
+      adapterErrors.record('zed', new Error('threads table missing or unreadable — incompatible Zed schema'), THREADS_DB);
+      return new Set();
+    }
+    threadColumns = new Set(cols);
+    return threadColumns;
+  } catch (e) {
+    adapterErrors.record('zed', e, THREADS_DB);
+    return new Set();
+  }
+}
+
+// index.js calls this between passes of a long-running `ship --loop`. Without it the
+// column set would be fixed for the life of the process, so a Zed upgrade mid-run
+// would keep querying a column that no longer exists — or keep ignoring one newly
+// added — until someone restarted the shipper.
+function resetCache() {
+  threadColumns = null;
+}
+
 function queryBlob(id) {
   if (!fs.existsSync(THREADS_DB)) return null;
   try {
@@ -103,22 +141,33 @@ function queryBlob(id) {
 const name = 'zed';
 
 function getChats() {
-  const rows = queryDb(
-    'SELECT id, summary, updated_at, data_type, length(data) as data_size, parent_id, worktree_branch FROM threads ORDER BY updated_at DESC'
-  );
+  const cols = getThreadColumns();
+  if (cols.size === 0) return [];
+
+  // Only these are relied on. Anything else is taken when the build provides it.
+  const select = ['id', 'summary', 'updated_at', 'data_type', 'length(data) as data_size', 'parent_id'];
+  const hasBranch = cols.has('worktree_branch');
+  const hasCreated = cols.has('created_at');
+  if (hasBranch) select.push('worktree_branch');
+  if (hasCreated) select.push('created_at');
+
+  const rows = queryDb(`SELECT ${select.join(', ')} FROM threads ORDER BY updated_at DESC`);
 
   return rows.map(row => ({
     source: 'zed',
     composerId: row.id,
     name: row.summary || null,
-    createdAt: row.updated_at ? new Date(row.updated_at).getTime() : null,
+    // created_at when the build has it. Falling back to updated_at is not a
+    // creation time — it just keeps the field non-null on builds that lack it.
+    createdAt: (hasCreated && row.created_at) ? new Date(row.created_at).getTime()
+      : (row.updated_at ? new Date(row.updated_at).getTime() : null),
     lastUpdatedAt: row.updated_at ? new Date(row.updated_at).getTime() : null,
     mode: 'thread',
     folder: null,
     encrypted: false,
     bubbleCount: 0,
     _dataType: row.data_type,
-    _gitBranch: row.worktree_branch,
+    _gitBranch: hasBranch ? row.worktree_branch : null,
   }));
 }
 
@@ -226,4 +275,4 @@ function getMCPServers() {
   return results;
 }
 
-module.exports = { name, labels, getChats, getMessages, getMCPServers };
+module.exports = { name, labels, getChats, getMessages, getMCPServers, resetCache };

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.md

@@ -17,6 +17,24 @@ the install script that builds the native binding. Without it those five silentl
 return zero sessions and you ship a partial history. Verify with step 4 —
 `memhouse discover` names any adapter it had to skip.
 
+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
+user-owned in both. Not the failing file either — an earlier `sudo npm` leaves
+root-owned files inside a prefix that is still the user's, and judging by those
+misreads it as system-managed.
+
+```bash
+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`.
+
+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`
+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.
@@ -32,7 +50,7 @@ cat > ~/.memhouse/env <<'EOF'
 MEMHOUSE_URL=http://localhost:8123
 MEMHOUSE_USER=memhouse_root
 MEMHOUSE_PASSWORD=<credential>
-MEMHOUSE_DB=memhouse
+MEMHOUSE_DB=mem
 EOF
 chmod 600 ~/.memhouse/env
 ```
@@ -58,11 +76,13 @@ warns by name about any adapter it had to skip — that warning is the only sign
 that step 1's `--allow-scripts` flag was missed and five editors are dark.
 
 `stats` should show one row per source (claude-code, codex, gemini-cli, …) with
-non-zero sessions/messages. Or verify by SQL:
+non-zero sessions/messages. Or verify by SQL — rooms are named for your ClickHouse
+user, and the session rollup is a saved query rather than an object, so
+`memhouse sessions-query` prints it:
 
 ```bash
 curl -s -u "$MEMHOUSE_USER:$MEMHOUSE_PASSWORD" "$MEMHOUSE_URL/?database=$MEMHOUSE_DB" \
-  --data-binary "SELECT source, count() FROM sessions_v GROUP BY source SETTINGS final=1 FORMAT PrettyCompact"
+  --data-binary "SELECT source, count() FROM $(memhouse sessions-query) AS c GROUP BY source SETTINGS final=1, join_use_nulls=1 FORMAT PrettyCompact"
 ```
 
 ## 5. Start the dashboard and the shipper loop

package/mem-house/delivery/PROMPT.md

@@ -9,10 +9,13 @@ long-term conversation memory.
 
 You have persistent memory of past agent sessions — every conversation this user
 has had with coding agents (Claude Code, Codex, Gemini CLI, Cursor, and other
-editors), across machines, stored in a ClickHouse database called **mem-house**.
+editors), across all of YOUR machines, stored in your own rooms in a ClickHouse
+database called **mem**. Other members of the same house have their own rooms and
+you hold no grant on them.
 Connection: read `~/.memhouse/env` (`MEMHOUSE_URL/USER/PASSWORD/DB`); query over
 HTTP with `curl -u "$MEMHOUSE_USER:$MEMHOUSE_PASSWORD" "$MEMHOUSE_URL/?database=$MEMHOUSE_DB"`
-and always add `SETTINGS final=1` to reads.
+and always add `SETTINGS final=1, join_use_nulls=1` to reads — the second matters
+wherever the session rollup is used (see below).
 
 **When to reach for it — before claiming ignorance.** If the user refers to past
 work that is not in your current context ("that session where…", "how did I solve
@@ -21,22 +24,32 @@ FIRST. Only say you don't know after a search comes back empty.
 
 **How to query.** Prefer the installed skills when present: `/memhouse:search`
 (full-text over messages), `/memhouse:sessions` (list/filter sessions),
-`/memhouse:sql` (free-form read-only SQL). Without skills, query directly:
+`/memhouse:sql` (free-form read-only SQL). Without skills, query directly.
+
+**Table names first.** Every member owns their rooms, so every table below takes your
+username as a suffix — `messages_<you>`, `sessions_<you>`, `tool_calls_<you>`. There
+are no unsuffixed rooms; the plain names fail with `UNKNOWN_TABLE` rather than
+returning nothing. Get the suffix from `SELECT currentUser()`. **There is no
+`sessions_v` object** — the rollup is a saved query over those same rooms, and
+`memhouse sessions-query` prints it ready to drop into a `FROM (...) AS c`.
+`all_messages` / `all_sessions` / `all_tool_calls` read across every member you hold a
+grant for.
 
 - Find sessions about a topic (FTS, lowercase your terms):
-  `SELECT DISTINCT session_id, any(project), min(ts) FROM messages
+  `SELECT DISTINCT session_id, any(project), min(ts) FROM messages_<you>
    WHERE hasToken(text_word, 'clickhouse') GROUP BY session_id
-   ORDER BY 3 DESC LIMIT 10 SETTINGS final=1 FORMAT PrettyCompact`
+   ORDER BY 3 DESC LIMIT 10 SETTINGS final=1, join_use_nulls=1 FORMAT PrettyCompact`
 - Recent sessions: `SELECT session_id, source, project, started, first_prompt
-   FROM sessions_v ORDER BY started DESC LIMIT 20 SETTINGS final=1`
-- Replay one session: `SELECT role, text FROM messages
-   WHERE session_id = '<id>' ORDER BY seq SETTINGS final=1`
+   FROM $(memhouse sessions-query) AS c ORDER BY started DESC LIMIT 20 SETTINGS final=1, join_use_nulls=1`
+- Replay one session: `SELECT role, text FROM messages_<you>
+   WHERE session_id = '<id>' ORDER BY seq SETTINGS final=1, join_use_nulls=1`
 
 **Rules.**
 - Memory is READ-ONLY for you. Never INSERT/ALTER/DROP — ingestion belongs to the
   mem-house shipper alone.
 - Quote retrieved content as *the user's past sessions*, and cite the session_id
   when the user may want to dig deeper.
-- Other members' sessions may be invisible to you (row-level security). An empty
-  result means "nothing visible", not "nothing ever happened".
+- Other members' sessions are invisible to you unless they have granted you their rooms.
+  You hold no grant on them otherwise, so naming one fails rather than returning nothing.
+  An empty result means "nothing visible", not "nothing ever happened".
 - Do not paste credentials from `~/.memhouse/env` into responses, commits, or logs.

package/mem-house/delivery/install.sh

@@ -3,19 +3,19 @@
 #
 # Checks node >= 20 and a reachable ClickHouse, writes ~/.memhouse/env
 # (MEMHOUSE_* vars), applies the house schema via the shipper
-# (`ship.js --ensure-schema`), runs a first ship, and prints how to start the
+# (`ship.js --ensure-schema` mints the caller's own rooms), runs a first ship, and prints how to start the
 # dashboard and set up continuous shipping (`--loop`).
 #
 # Usage:
 #   ./install.sh                                  # interactive (prompts for missing values)
-#   ./install.sh --url http://localhost:8123 --user memhouse_root --password 'pw' --db memhouse
+#   ./install.sh --url http://localhost:8123 --user memhouse_root --password 'pw' --db mem
 #   ./install.sh --yes                            # non-interactive, defaults / env / existing env file
 #
 # Flags:
 #   --url URL         ClickHouse HTTP(S) endpoint   (default http://localhost:8123)
 #   --user USER       ClickHouse user               (default memhouse_root; 'default' works for a local CH)
 #   --password PW     credential                    (default empty)
-#   --db DB           the house (database)          (default memhouse)
+#   --db DB           the house (database)          (default mem)
 #   --port PORT       dashboard/API port            (default 4640)
 #   --yes             never prompt; take flags > current env > ~/.memhouse/env > defaults
 #   --no-ship         stop after writing env + ensure-schema (skip the first ship)
@@ -43,7 +43,7 @@ fi
 CH_URL="${MEMHOUSE_URL:-http://localhost:8123}"
 CH_USER="${MEMHOUSE_USER:-memhouse_root}"
 CH_PASSWORD="${MEMHOUSE_PASSWORD:-}"
-CH_DB="${MEMHOUSE_DB:-memhouse}"
+CH_DB="${MEMHOUSE_DB:-mem}"
 DASH_PORT="${MEMHOUSE_PORT:-4640}"
 
 ASSUME_YES=0
@@ -103,7 +103,7 @@ ONE="$(curl -sS --connect-timeout 5 --fail-with-body \
 [ "$ONE" = "1" ] || die "unexpected reply from $CH_URL: $ONE"
 info "ClickHouse ok"
 
-# Ensure the house exists before ensure-schema (schema.sql is unqualified and the
+# Ensure the house exists before ensure-schema (the room DDL is unqualified and the
 # shipper binds to MEMHOUSE_DB — on a virgin standalone server the database must
 # be created first). On a kernel realm the house is already provisioned; if the
 # user lacks CREATE DATABASE but the house is reachable, that's fine too.
@@ -174,8 +174,10 @@ Next steps:
   # -> installs memhouse-search / memhouse-sessions / memhouse-sql into
   #    \${CLAUDE_CONFIG_DIR:-\$HOME/.claude}/skills (loads next session)
 
-Verify anytime:
+Verify anytime (rooms are named for your ClickHouse user):
   set -a; . "$ENV_FILE"; set +a
+  ME=\$(curl -sS --user "\$MEMHOUSE_USER:\$MEMHOUSE_PASSWORD" \\
+    --data-binary "SELECT currentUser() FORMAT TabSeparated" "\$MEMHOUSE_URL/")
   curl -sS --user "\$MEMHOUSE_USER:\$MEMHOUSE_PASSWORD" --data-binary \\
-    "SELECT count() FROM sessions" "\$MEMHOUSE_URL/?database=\$MEMHOUSE_DB&final=1"
+    "SELECT count() FROM sessions_\$ME" "\$MEMHOUSE_URL/?database=\$MEMHOUSE_DB&final=1"
 EOF