memhouse 0.4.4 → 0.7.0

package/editors/base.js

@@ -41,6 +41,12 @@ function getAppDataPath(appName) {
  *       { source, composerId, name, createdAt, lastUpdatedAt, mode, folder, bubbleCount, encrypted }
  *   getMessages(chat) - returns array of message objects:
  *       { role: 'user'|'assistant'|'system'|'tool', content: string|Array }
+ *     Optional per message, when the underlying transcript records it:
+ *       _ts         - epoch ms the message was sent. Without it the shipper
+ *                     interpolates a position between the session's createdAt and
+ *                     lastUpdatedAt, which can be off by the whole span of a session.
+ *                     Set it wherever the format has it; leave it out otherwise.
+ *       _model, _inputTokens, _outputTokens, _cacheRead, _cacheWrite, _toolCalls
  */
 
 /**

package/editors/claude.js

@@ -1,6 +1,7 @@
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
+const adapterErrors = require('./adapter-errors');
 
 const HOME = os.homedir();
 
@@ -165,14 +166,28 @@ function peekSessionMeta(filePath) {
 
 function cleanPrompt(prompt) {
   if (!prompt || prompt === 'No prompt') return null;
-  // Strip XML tags and system-reminder blocks
+  // Strip envelopes CONTENT AND ALL, before the generic tag strip.
+  //
+  // <local-command-caveat> was being handled by the tag strip alone, which removes the
+  // tags and keeps the text — so 34 of 400 sessions on this machine stored "Caveat: The
+  // messages below were generated by the user while running local commands. DO NOT
+  // respond to these messages…" as their title and first_prompt. Two costs: it is a
+  // 120-character legal blob where a session name belongs, and an agent READING those
+  // rows treats it as an instruction aimed at itself. Observed — a Claude Code driving
+  // the sessions skill spent two answers warning about "a prompt injection stored as
+  // data" instead of listing sessions, and concluded of one row that "the injection
+  // worked". Anything whose whole purpose is to instruct a model is not a title.
   let clean = prompt
     .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
+    .replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g, '')
+    .replace(/<command-(?:name|message|args|contents|stdout|stderr)>[\s\S]*?<\/command-\1>/g, '')
     .replace(/<[^>]+>/g, '')
     .replace(/\s+/g, ' ')
-    .trim()
-    .substring(0, 120);
-  return clean || null;
+    .trim();
+  // A prompt that was ONLY an envelope has no title in it. Say so rather than storing a
+  // fragment of boilerplate that survived the strip.
+  if (/^Caveat: The messages below were generated by the user/i.test(clean)) return null;
+  return clean.substring(0, 120) || null;
 }
 
 // Parse one Claude session .jsonl into the adapter's message shape. When
@@ -186,11 +201,27 @@ function parseSessionFile(filePath, isSubagent) {
 
   for (const line of lines) {
     let obj;
-    try { obj = JSON.parse(line); } catch { continue; }
+    // A line that will not parse is a message that will not be stored. Dropping it in
+    // silence means the transcript is quietly short: not withheld, not truncated, and
+    // nothing in ship, discover or doctor says a line was lost. The SQLite adapters
+    // report their parse failures through this sink and the shipper withholds the session
+    // on them; JSONL line failures bypassed it entirely.
+    try { obj = JSON.parse(line); } catch (e) {
+      adapterErrors.record('claude-code', new Error(`unparseable JSONL line: ${e.message}`), filePath);
+      continue;
+    }
+
+    // Claude Code stamps every JSONL line with an ISO timestamp. Carrying it through as
+    // _ts lets the shipper store when a message was ACTUALLY sent instead of a position
+    // interpolated between the session's first and last times — see messageTs() in
+    // memhouse/shipper/ship.js. Optional by contract: adapters that have no per-message
+    // time simply omit it.
+    const _ts = obj.timestamp ? Date.parse(obj.timestamp) : undefined;
+    const at = Number.isFinite(_ts) ? _ts : undefined;
 
     if (obj.type === 'user' && obj.message) {
       const content = extractContent(obj.message.content);
-      if (content) messages.push({ role: 'user', content: tag + content });
+      if (content) messages.push({ role: 'user', content: tag + content, _ts: at });
     } else if (obj.type === 'assistant' && obj.message) {
       const { text, toolCalls } = extractAssistantContent(obj.message.content);
       const usage = obj.message.usage;
@@ -198,11 +229,11 @@ function parseSessionFile(filePath, isSubagent) {
         role: 'assistant', content: tag + text, _model: obj.message.model,
         _inputTokens: usage?.input_tokens, _outputTokens: usage?.output_tokens,
         _cacheRead: usage?.cache_read_input_tokens, _cacheWrite: usage?.cache_creation_input_tokens,
-        _toolCalls: toolCalls,
+        _toolCalls: toolCalls, _ts: at,
       });
     } else if (obj.type === 'system') {
       const text = typeof obj.message?.content === 'string' ? obj.message.content : '';
-      if (text) messages.push({ role: 'system', content: tag + text });
+      if (text) messages.push({ role: 'system', content: tag + text, _ts: at });
     }
   }
   return messages;
@@ -383,4 +414,8 @@ function getMCPServers() {
   return results;
 }
 
-module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts, getMCPServers };
+// discoverClaudeRoots is exported for the CLI's plugin installer, which needs the same
+// answer to a different question: where this pilot's Claude Code instances live. Two
+// implementations of "find every CLAUDE_CONFIG_DIR" would drift the first time a playbook
+// layout changes, and this is the copy exercised on every single ship.
+module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts, getMCPServers, discoverClaudeRoots };

package/editors/goose.js

@@ -243,6 +243,10 @@ function getMessagesFromDb(chat) {
     const msg = { role: mappedRole, content };
     if (mappedRole === 'assistant' && chat._model) msg._model = chat._model;
     if (toolCalls.length) msg._toolCalls = toolCalls;
+    // created_timestamp is the column this query already sorts by (seconds). Pass it on
+    // so the shipper stores the real send time rather than interpolating one; messageTs()
+    // handles the seconds-vs-milliseconds split.
+    if (row.created_timestamp) msg._ts = Number(row.created_timestamp);
     result.push(msg);
   }
 

package/editors/opencode.js

@@ -317,6 +317,9 @@ function getMessagesForSession(sessionId) {
         _cacheRead: cacheRead,
         _cacheWrite: cacheWrite,
         _finish: msg.finish,
+        // The same time already used to sort above. Passing it on means the shipper
+        // stores when the message was sent instead of interpolating a position.
+        _ts: msg.time?.created,
       });
     }
   }

package/{mem-house → memhouse}/COMPETITION.md

@@ -1,4 +1,4 @@
-# mem-house — the competition
+# memhouse — the competition
 
 Companion to `DESIGN.md`. That file states **the four bets**; this one grades each
 bet against the field as it actually stands.
@@ -25,7 +25,7 @@ whole analysis, because most "agent memory" products are not competitors at all.
 | **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.
+memhouse 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.
 
@@ -48,7 +48,7 @@ Editor coverage — the number we lead the README with — is mid-pack:
 | AgentsView | **50+** | each with documented on-disk paths |
 | lean-ctx | 30+ | claimed |
 | CCHV | 28 | each with documented paths |
-| **mem-house** | **17** | |
+| **memhouse** | **17** | |
 | deja-vu | 17 | different 17 — has Cline, aider, Qwen Code, Kimi Code, Roo Code |
 | coding_agent_session_search | 11+ | |
 | ctx | 8 | |
@@ -90,7 +90,7 @@ datastore's own permission layer.
 | 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 |
+| **memhouse** | 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.
@@ -133,7 +133,7 @@ memory. None ingest agent sessions.
 
 ## What they do better
 
-- **Distribution.** mem-house: 0 stars, 655 npm downloads/month, no HN or search
+- **Distribution.** memhouse: 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

package/{mem-house → memhouse}/DESIGN.md

@@ -1,6 +1,6 @@
-# mem-house — design
+# memhouse — design
 
-**mem-house** is agent conversation memory as a product: every coding-agent session
+**memhouse** is agent conversation memory as a product: every coding-agent session
 on your machines — across **all 17 editors** agentlytics supports — parsed locally,
 shipped to a typed ClickHouse store, shareable with a team, installable on the
 ultimagent kernel as an **agency**, and visible through the agentlytics dashboard.
@@ -10,7 +10,7 @@ ultimagent kernel as an **agency**, and visible through the agentlytics dashboar
 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
+**Agency, precisely.** In constellation terms (`../TERMINOLOGY.md`) memhouse is a
 **house** — the `mem` database — **plus a resident**: the shipper. That pairing
 is what the word *agency* means; a house on its own only holds.
 
@@ -26,7 +26,7 @@ on   = "loop"      # a daemon — not an insert trigger, not a schedule
 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
+nothing. memhouse 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.
 
@@ -42,7 +42,7 @@ skills/plugin delivery) and agentlytics' proven assets (adapters, UI, cost engin
 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
+**memhouse**; 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
@@ -58,7 +58,7 @@ them free and further along; **bet 3 is the one nobody else attempts.**
    parsing is not a style choice — it is what unlocks 17-editor coverage. The
    shipper runs the adapters (`editors/`) and ships **typed rows**. On the canon's
    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
+   memory-house parses when you query, memhouse parses before anyone asks and
    writes the result down.
 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
@@ -75,8 +75,8 @@ them free and further along; **bet 3 is the one nobody else attempts.**
    (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
+   memhouse server implements the **same `/api/*` contract** as agentlytics'
+   `server.js` (same routes, same response shapes) over the memhouse schema, and
    serves the same built `public/` bundle. UI changes: none.
 
 ## Components (this directory)
@@ -131,10 +131,16 @@ Config file: `~/.memhouse/config.json` (`hiddenProjects`, future prefs).
 
 ## Delivery kit (mirrors memory-house)
 
-`install.sh` (standalone), `AGENT-INSTALL.md` (agent-facing install steps),
-`skills/` (Claude Code skills to query/search mem-house), `plugin/` (Claude Code
-plugin wrapping the skills), `PROMPT.md` (system-prompt snippet teaching an agent
-to use mem-house as memory), `kernel-install.md` (provision as agency `memhouse`).
+`AGENT-INSTALL.md` (agent-facing install steps), `plugin/` (the Claude Code plugin
+wrapping the three skills), `PROMPT.md` (system-prompt snippet teaching an agent to
+use memhouse as memory), `kernel-install.md` (provision as agency `memhouse`).
+
+**`install.sh` is retired.** It was a second implementation of `memhouse install`,
+maintained separately and drifting apart from it: by the end it still defaulted to
+`http://localhost:8123` as `memhouse_root` — precisely the guessed house the CLI now
+refuses on purpose, because on many machines that credential reaches a real house
+belonging to someone else. One installer, and it is the one the acceptance suite
+drives.
 
 ## Non-goals (v0)
 

package/memhouse/RESUME-AND-UPDATE.md

@@ -0,0 +1,185 @@
+# resume, update, and a daemon that notices
+
+Three things that were missing, specified together because they share one premise: the
+pilot's memory is only useful if they can *get back into* it, and only trustworthy if the
+process holding it is the version they installed.
+
+---
+
+## 1. `memhouse resume <session-id>`
+
+### The gap
+
+memhouse was a read-only archive. You could find the session that solved this problem
+six weeks ago and not return to it. Every rival that does this is praised for it
+(`COMPETITION.md`: Agent Sessions copies resume commands for six CLIs, claude-history
+resumes *and* forks worktree-aware).
+
+### What it needs
+
+Nothing new. A stored session already carries both halves:
+
+| Column | Supplies |
+|---|---|
+| `session_id` | `<source>:<native-id>` — which CLI, and which session in it (`ship.js:575`) |
+| `folder` | the directory the session ran in |
+
+So resume is a **read-time computation over two columns**. No schema change, no
+migration, no new room.
+
+### It prints; it does not run
+
+The command is written to stdout for the pilot to paste.
+
+Running it would mean guessing a terminal, inheriting this process's cwd, and assuming the
+id is still live. When any of those is wrong, the CLI **does not fail** — it opens a new
+session. The transcript the pilot asked for is still lost, and the tool reports success.
+That is the exact failure shape this repo has been bitten by fifteen times: a wrong answer
+delivered confidently.
+
+### The flag table is evidence, not recall
+
+`memhouse/resume.js` holds one entry per resumable editor, and each entry records the date
+its syntax was read out of that CLI's own `--help`.
+
+| Source | Command | Read from |
+|---|---|---|
+| `claude` | `claude --resume <id>` | `claude --help`, 2026-08-12 |
+| `codex` | `codex resume <id>` | `codex resume --help`, 2026-08-12 |
+| `opencode` | `opencode --session <id>` | `opencode --help`, 2026-08-12 |
+
+**An editor whose flag has not been read that way is absent from the table**, and an absent
+entry prints a refusal. Round 10 is why: a field name was asserted from a failed search,
+written into a comment, a PR and the task file, and was simply wrong. `goose`, `gemini-cli`
+and `cursor-agent` are plausibly resumable and are *not* listed, because they are not
+installed on the machine the table was written on.
+
+The refusal distinguishes two cases, for the same reason `discover` separates a skipped
+adapter from an editor you do not have:
+
+- **No CLI at all** (`cursor`, `vscode`, `zed`, `kiro`, `copilot-jetbrains`, `antigravity`,
+  `devin`, `devin-next`) — nothing takes a session id, and no amount of checking will
+  produce something that does. Opening the folder is not resuming the session and is not
+  dressed up as it; the folder is printed as the one actionable fact memhouse holds.
+- **Unverified** (`goose`, `gemini-cli`, `cursor-agent`, `copilot-cli`, `codebuff`,
+  `commandcode`, `gsd`) — a CLI that may well support it; nobody has read the flag yet.
+
+Both sets are **explicit**, and a test derives the full source inventory from `editors/`
+and asserts every source lands in exactly one of the three buckets. That test exists because
+the same mistake was made twice within a day of each other: `RESUMERS` was first keyed on
+`claude` when rows carry `claude-code`, and `windsurf` was listed as a GUI editor when the
+adapter emits its VARIANTS ids, `devin` and `devin-next` — so every Devin session fell
+through to the *unverified* message, which says the opposite of the truth. A source that
+matches nothing must be a test failure, not a default.
+
+And `copilot-cli` was in the GUI set while being, self-evidently, a command line.
+
+### Two more decisions
+
+- **`FINAL` on the read.** `sessions` is a `ReplacingMergeTree`; without `FINAL` a
+  re-shipped session can resolve against its older row and print the folder the project
+  *used* to live in.
+- **Ambiguity refuses.** A bare native id can match more than one source. The command lists
+  the matches and exits non-zero rather than picking, because resuming the wrong editor's
+  session of the same name is precisely the silent-wrong-answer it exists to prevent.
+
+### Explicitly not built: write-back
+
+Restoring an archived transcript into an editor's own store. Every editor's format is
+private and different, and a bad write corrupts the pilot's live history — risking the
+original to duplicate the copy.
+
+---
+
+## 2. `memhouse update`
+
+### 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
+   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
+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.
+
+### Install kinds, because the wrong upgrade is not a no-op
+
+| Kind | Detected by | Action |
+|---|---|---|
+| `global` | under `npm prefix -g` | `npm i -g memhouse@latest --allow-scripts=better-sqlite3` |
+| `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 |
+
+Running `npm i -g` from a checkout would install the **published** version over the branch
+the pilot was testing. Running `git pull` in a global install does nothing and says it
+worked.
+
+### Order of operations
+
+Read the daemon state **first** (`stop` erases the evidence), upgrade, then restart, then
+ensure the schema. A failed upgrade restarts nothing and says so — the running version is
+left intact rather than half-replaced.
+
+A service-managed shipper is not restarted behind the supervisor's back; the command prints
+the supervisor's own restart line.
+
+---
+
+## 3. A daemon that notices
+
+### The gap
+
+Nothing tells a running daemon that its files were replaced. `status` prints the version of
+the CLI you just typed, not the version the daemon is executing. On macminim a shipper ran
+**1d16h** out of a directory that had been moved.
+
+### Why not `postinstall`
+
+npm blocks install scripts by default — the very condition this product already works
+around — so a `postinstall` hook is unreliable exactly where it matters. And a package
+install that restarts a user's daemons is a surprise even when it works.
+
+### The mechanism
+
+`memhouse/self-update.js`. Each daemon snapshots at boot: the version **read off disk**
+(never `require`d — require caches the first read, which is the value we are trying to
+detect a change in), plus the realpath and mtime of its own entry script. Then:
+
+- **shipper** — checks once per loop pass, *after* the sleep and never mid-pass, so an
+  upgrade landing during the interval is acted on at the top of the next pass and a
+  half-shipped session is never abandoned.
+- **dashboard** — has no pass, so it polls on an unref'd 60s timer. It must be covered: the
+  static middleware bound to the old `public/` at boot, so its stale bundle is what the
+  pilot actually *sees*.
+
+### Two modes, and getting them backwards is expensive
+
+| Mode | Signal | Behaviour |
+|---|---|---|
+| supervised | `MEMHOUSE_SUPERVISED=1`, written into the unit by `service install` | **exit 0** — the supervisor starts the new version |
+| unsupervised | `memhouse start` pidfiles | **re-exec** detached, adopt the pidfile, exit |
+
+A process that re-execs under a supervisor races the unit's own restart, and two shippers
+on one house clear each other's rows. A process that merely exits with no supervisor stops
+collecting memory entirely.
+
+### Guards
+
+- **Re-exec chains are counted in the environment** (`MEMHOUSE_REEXEC_CHAIN`) and capped at
+  3, so a mis-detection cannot spin.
+- **A 60s floor** from boot before any handover.
+- **The pidfile is only rewritten if it names us.** A daemon started by hand has no pidfile;
+  one naming another process belongs to that process, and overwriting it would point
+  `memhouse stop` at ours and orphan theirs forever.
+- **A vanished entry is reported, not acted on.** If the directory is gone there is nothing
+  to exec and no supervisor to resolve a fresh path, so the daemon keeps running and says so
+  every pass. A stale daemon still collects sessions; a dead one collects nothing.

package/{mem-house → memhouse}/delivery/AGENT-INSTALL-PROMPT.md

@@ -38,7 +38,7 @@ already exist.
   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
+- The install writes `{{ENV_FILE}}` 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.

package/{mem-house → memhouse}/delivery/AGENT-INSTALL.md

@@ -1,6 +1,6 @@
-# mem-house — agent install
+# memhouse — agent install
 
-Imperative steps for an AI coding agent installing mem-house on a machine. Execute
+Imperative steps for an AI coding agent installing memhouse on a machine. Execute
 in order; every command is copy-pasteable.
 
 **Prefer `memhouse prompt --install`.** It renders `AGENT-INSTALL-PROMPT.md` against the
@@ -67,7 +67,7 @@ chmod 600 ~/.memhouse/env
 memhouse install --yes     # applies the schema, then runs the first full ship
 ```
 
-Expected output shape: `[mem-house] shipped N sessions (0 skipped) → M msg rows, T
+Expected output shape: `[memhouse] shipped N sessions (0 skipped) → M msg rows, T
 tool rows in Xs` with N in the hundreds on a machine with real agent usage.
 
 ## 4. Verify
@@ -107,7 +107,9 @@ re-ship loop, so this replaces any separate cron. `memhouse stop` ends both.
 memhouse plugins install claude
 ```
 
-Installs the `memhouse-search` / `memhouse-sessions` / `memhouse-sql` skills into
-the agent's skills directory; they read the connection from `~/.memhouse/env`.
-`memhouse plugins list` shows what is installed, `memhouse plugins remove claude`
-undoes it.
+Installs the memhouse plugin into `<claude-config>/skills/memhouse`, which loads next
+session as `memhouse@skills-dir` and exposes `/memhouse:search`, `/memhouse:sessions`
+and `/memhouse:sql`. They read the connection from `$MEMHOUSE_HOME/env` (default
+`~/.memhouse/env`), with exported `MEMHOUSE_*` vars taking precedence, and refuse to run
+rather than guessing a URL when neither is set. `memhouse plugins list` shows what is
+installed, `memhouse plugins remove claude` undoes it.

package/{mem-house → memhouse}/delivery/PROMPT.md

@@ -1,25 +1,25 @@
-# mem-house — system-prompt snippet
+# memhouse — system-prompt snippet
 
-Paste (or import) this into an agent's system prompt to make mem-house its
+Paste (or import) this into an agent's system prompt to make memhouse its
 long-term conversation memory.
 
 ---
 
-## Conversation memory (mem-house)
+## Conversation memory (memhouse)
 
 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 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
+database called **{{DB}}**. 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
+Connection: read `{{ENV_FILE}}` (`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, 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
-X before", "did we ever…", "what was I working on last week"), search mem-house
+X before", "did we ever…", "what was I working on last week"), search memhouse
 FIRST. Only say you don't know after a search comes back empty.
 
 **How to query.** Prefer the installed skills when present: `/memhouse:search`
@@ -46,10 +46,10 @@ grant for.
 
 **Rules.**
 - Memory is READ-ONLY for you. Never INSERT/ALTER/DROP — ingestion belongs to the
-  mem-house shipper alone.
+  memhouse 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 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.
+- Do not paste credentials from `{{ENV_FILE}}` into responses, commits, or logs.

package/{mem-house → memhouse}/delivery/kernel-install.md

@@ -1,6 +1,6 @@
-# mem-house — install as a kernel agency
+# memhouse — install as a kernel agency
 
-How to run mem-house as an **agency** on an ultimagent kernel — a ClickHouse server
+How to run memhouse as an **agency** on an ultimagent kernel — a ClickHouse server
 (a **town**) promoted into a realm — instead of a plain ClickHouse. Same flow proven
 for the agentlytics agency (`agency/AGENCY.md`); the agency is named **`memhouse`** and
 its house is the **`mem`** database (CH identifiers can't carry a dash, and the owning
@@ -67,7 +67,7 @@ python3 executor/executor.py approve <call_id> && python3 executor/executor.py d
 # grant-option on mem.*). One idempotent step — see ../per-member/PROVISIONING.md:
 MEM_URL=https://<kernel-host>:8443 MEM_USER=memhouse_root \
 MEM_PASSWORD=<credential> MEM_DB=mem \
-  node mem-house/per-member/provision.js --member alice --merge
+  node memhouse/per-member/provision.js --member alice --merge
 ```
 
 **Never `GRANT … ON mem.*` to a member.** A member who can read `mem.*` can read every

package/{mem-house → memhouse}/delivery/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "memhouse",
   "description": "Conversation memory for AI agents over the memhouse typed ClickHouse store: search, browse, and analyze every past session across all 17 supported editors and machines. Skills install as /memhouse:search, /memhouse:sessions, and /memhouse:sql.",
-  "version": "0.3.0",
+  "version": "0.4.6",
   "author": { "name": "Ramazan Polat" },
   "homepage": "https://github.com/agent-realm/memhouse",
   "keywords": ["memory", "clickhouse", "search", "sessions", "analytics", "agentlytics"]