memhouse 0.11.1 → 0.11.3

package/README.md

@@ -336,6 +336,11 @@ Deeper reading: `memhouse/DESIGN.md` (the four bets),
 `memhouse/per-member/SCHEMA.md`, `memhouse/delivery/kernel-install.md`,
 `memhouse/COMPETITION.md`.
 
+Deferred designs (captured, not yet built): `docs/design/host-repoint-reconciliation.md`
+— what should happen when the shipper is repointed at a new, empty host (house identity,
+local binding state, and a refuse-then-`init-here` gate so transcripts never land on the
+wrong server).
+
 In constellation terms (`TERMINOLOGY.md`) memhouse is an **agency**: a **house**
 — the `mem` database — plus a **resident** working in it, the shipper. The house
 alone would hold; the shipper is what makes it act. It competes with

package/memhouse/delivery/plugin/skills/ask/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ask
-description: Answer a question FROM conversation memory — retrieve the relevant past sessions out of the memhouse ClickHouse store, read the actual transcripts, and synthesize an answer with citations. Use when the user asks something their past work already answered, e.g. "how did I fix X last time", "what approach did we settle on for Y", "why did we choose Z", "have I solved this error before", "what did the reviewer say about W". This is the retrieve-and-answer skill; /mem:search is find-the-session, /mem:sql is run-a-query.
+description: Answer a question FROM conversation memory — retrieve the relevant past sessions out of the memhouse ClickHouse store, read the actual transcripts, and synthesize an answer with citations. Use when the user asks something their past work already answered, e.g. "how did I fix X last time", "what approach did we settle on for Y", "why did we choose Z", "have I solved this error before", "what did the reviewer say about W". Also answers from a friend's house shared with you when they name it ("how did yigit fix X", "ask yigit's memory"). This is the retrieve-and-answer skill; /mem:search is find-the-session, /mem:sql is run-a-query.
 user-invocable: true
 argument-hint: "<question about past work>"
 allowed-tools: Bash
@@ -47,6 +47,25 @@ SQL
 
 `readonly=1` is pinned on every request: this skill never writes.
 
+## Answering from another person's house (shared with you)
+
+The house is a ClickHouse database; a share is a read-only GRANT on it. When the user asks
+about a FRIEND's memory — "how did yigit fix X", "in yigit's house", "ask yigit's memory",
+"from yigit" — answer from THEIR house without changing your credentials:
+
+1. **Resolve the house.** `SHOW DATABASES` returns what your credential may read; a name
+   that is not `system` / `information_schema` / `default` and not your own `$MEMHOUSE_DB`
+   is a house shared with you. Match the named person to one; set `HOUSE=yigit`. With no
+   house named, `HOUSE=$MEMHOUSE_DB`.
+2. **Point the connection at it:** replace `database=${MEMHOUSE_DB:-mem}` with
+   `database=<HOUSE>` in the recipe above. The rooms (`messages`, `sessions`) resolve by
+   the connection's database, so retrieval, the transcript read, and the citation all run
+   against that house — leave the table names bare.
+3. **Cite the house.** Say whose memory the answer came from ("from yigit's house") so the
+   user never mistakes a friend's session for their own.
+4. **Read-only, thin by design.** A refused SELECT means the house was not shared with you
+   (or the share was revoked) — say so; never guess another database.
+
 ## The method — retrieve, read, answer, cite
 
 **Escaping, before anything touches SQL.** Search terms, session ids and user ids are

package/memhouse/delivery/plugin/skills/hello/SKILL.md

@@ -34,6 +34,25 @@ fi
 
 (Do not print the env values, and do not narrate that you are withholding them — just use them.)
 
+## What memhouse is — the overview (give this in every state, before the tour)
+
+One paragraph, grounded not sold: **memhouse is your personal, permanent archive of every
+AI coding session.** A background shipper reads the session files your editors write —
+Claude Code, Codex, Cursor, VS Code, Zed, OpenCode, Gemini CLI and 10 more, 17 in all —
+and ships them into a ClickHouse database you own, called a **house**. YOU choose that
+ClickHouse: a local one on your laptop, one on your own VM, or any ClickHouse server you
+control — managed or remote. memhouse itself is not a hosted service and phones nothing
+home; your sessions go only to the house you point it at, and it runs no LLM in its write
+or read path — it stores rows, the agent reading them (this chat) does the thinking. It
+outlives the transcripts on disk: editors compact and delete their local session files
+after weeks, so for anything older than ~30 days the house is the only place it still
+exists. One archive spans every editor, every project, every machine you ship from.
+
+What it gives you, in one breath: **ask** your own history a question and get a cited
+answer, **search** for the session you half-remember, **query** the raw data for numbers,
+browse a **dashboard**, and **invite** other people onto your ClickHouse so memories can be
+**shared** read-only. The tour below names each.
+
 ## Then introduce it — three states, three openings
 
 **Configured and answering** — open with the numbers: "Your memory holds N sessions
@@ -61,12 +80,24 @@ What you can DO from this chat:
 - `/mem:sql <question or SQL>` — ad-hoc analytics (tokens, costs, rankings)
 - `/mem:status` — is it healthy, how much is stored, which machines ship into it
 
+The first three overlap — same words work in each — so give the reader the rule that
+separates them: **want a session → search. Want an answer → ask. Want a number → sql.**
+`ask` runs a `search` first, then reads the turns it finds and writes you a cited answer;
+`search` stops at the ranked list of sessions; `sql` counts and aggregates the columns
+rather than hunting text.
+
 And around other people — **inviting comes before sharing**:
 
 - `/mem:invite <name>` — mint a friend's account + their own house on your ClickHouse,
   hand them one env file; they install with it and have their own memory
 - `/mem:share <name>` — once they exist, open a read-only window into YOUR memory
   (`/mem:share revoke <name>` closes it); `/mem:users` shows who's around
+- **Read a friend's shared memory** — once they've shared theirs with you, name their
+  house right in the question: `/mem:ask <question> in <their-house>`, or
+  `/mem:search <terms> in <their-house>` / `/mem:sql … on <their-house>`. It reads THEIR
+  house read-only, with your own credentials; `/mem:users` lists the houses shared with
+  you. (A house is a whole ClickHouse database — sharing grants read on it, not on single
+  sessions.)
 
 Also worth naming: `memhouse start` serves a dashboard at http://localhost:4640 for
 browsing and analytics outside the chat, and everything here is read-only for agents —

package/memhouse/delivery/plugin/skills/search/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: search
-description: Full-text search across ALL shipped agent conversations — every session from all 17 supported editors (Claude Code, Codex, Cursor, VS Code, Zed, OpenCode, Gemini CLI, …), every project, every machine — stored in the memhouse ClickHouse. Use whenever the user refers to something from the past that isn't in the current context, e.g. "what did I say about X", "find that conversation about Y", "when did I work on Z", "did I ever try W", "the chat where we discussed it", "remind me how I did it". Reach for this before saying you don't know about prior work.
+description: Full-text search across ALL shipped agent conversations — every session from all 17 supported editors (Claude Code, Codex, Cursor, VS Code, Zed, OpenCode, Gemini CLI, …), every project, every machine — stored in the memhouse ClickHouse. Use whenever the user refers to something from the past that isn't in the current context, e.g. "what did I say about X", "find that conversation about Y", "when did I work on Z", "did I ever try W", "the chat where we discussed it", "remind me how I did it". Searches your own house by default, or a friend's house shared with you when they name it ("find X in yigit's memory"). Reach for this before saying you don't know about prior work.
 user-invocable: true
 argument-hint: "<search terms> [in <project>] [last <N> days] [from <editor>]"
 allowed-tools: Bash
@@ -142,9 +142,32 @@ LIMIT 10
 FORMAT PrettyCompact
 ```
 
+## Reading another person's house (shared with you)
+
+Every house is its own ClickHouse database on the same server; a share is a read-only
+GRANT on that database. To read a friend's memory you keep YOUR credentials and point the
+connection at THEIR house — the rooms (`messages`, `sessions`, `tool_calls`) resolve by
+the connection's `database`, so one change redirects every query in this skill.
+
+1. **Resolve the target house.** `SHOW DATABASES` lists what your credential may read; the
+   names that are not `system` / `information_schema` / `default` and not your own
+   `$MEMHOUSE_DB` are houses shared with you. If the user names one — "yigit's memory",
+   "in yigit", "house yigit", "from yigit" — set `HOUSE=yigit`; otherwise leave
+   `HOUSE=$MEMHOUSE_DB`.
+2. **Point the connection at it:** in the recipe above, replace
+   `database=${MEMHOUSE_DB:-mem}` with `database=<HOUSE>`. Leave the table names bare —
+   they resolve to that house. Nothing else in the query changes.
+3. **A house wins over `in <project>`.** A name that matches a readable house is a HOUSE,
+   not a project filter — otherwise "in yigit" silently filters YOUR house's project
+   column and returns nothing. If a real project in your own house shares the name, keep
+   the possessive ("<name>'s memory") or say "project <name>" to force the project reading.
+4. **Read-only, thin by design.** If the SELECT is refused, that house was not shared with
+   you (or the share was revoked) — say so; never guess another database.
+
 ## Qualifiers
 
-- `in <project>` → `AND m.project ILIKE '%<project>%'`
+- `in <project>` → `AND m.project ILIKE '%<project>%'` — but a name matching a readable
+  house is a HOUSE (see above), not a project.
 - `last N days` → `AND m.ts > now() - INTERVAL N DAY`
 - `from <editor>` → `AND m.source = '<id>'` (ids: `claude-code`, `codex`,
   `cursor`, `cursor-agent`, `vscode`, `zed`, `opencode`, `gemini-cli`,

package/memhouse/delivery/plugin/skills/sql/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: sql
-description: Run free-form read-only SQL against memhouse conversation memory (typed sessions/messages/tool_calls tables on ClickHouse, shared by the house). Use for ad-hoc analytics the other memhouse skills don't cover — token spend, model/editor usage, tool rankings, activity heatmaps, busiest days/projects, cache-hit ratios, or any custom question over conversation data.
+description: Run free-form read-only SQL against memhouse conversation memory (typed sessions/messages/tool_calls tables on ClickHouse, shared by the house). Use for ad-hoc analytics the other memhouse skills don't cover — token spend, model/editor usage, tool rankings, activity heatmaps, busiest days/projects, cache-hit ratios, or any custom question over conversation data — over your own house, or a friend's house shared with you when they name it.
 user-invocable: true
 argument-hint: "<question or SQL>"
 allowed-tools: Bash
@@ -100,6 +100,16 @@ writes into the same tables; `user_id` (stamped by the server) says whose row it
 `host` says which machine shipped it. Filter with `WHERE user_id = '<name>'` when you want
 one person, or leave it off for the whole house.
 
+**Another person's house (shared with you).** A house is a database; a share is a
+read-only GRANT on it. Because the rooms resolve by the connection's database, you read a
+friend's memory by pointing the connection at THEIR house — same credentials, different
+`database`. `SHOW DATABASES` lists what you may read; a name that is not `system` /
+`information_schema` / `default` and not your own `$MEMHOUSE_DB` is a house shared with
+you. When the user names one ("query yigit's house", "on yigit", "from yigit"), replace
+`database=${MEMHOUSE_DB:-mem}` with `database=<house>` in the connection recipe and leave
+the table names bare — or, to join across houses in one query, qualify tables explicitly
+(`yigit.messages`). Read-only: a refused SELECT means that house was not shared with you.
+
 **Keep the SQL heredoc quoted (`<<'SQL'`).** This skill once told the agent to substitute
 a shell variable into the table names, which cannot expand inside a quoted heredoc — so
 the agent unquotes it, and then the SEARCH TERMS expand too. Both instances driving this

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memhouse",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "memhouse — agent conversation memory across 17 editors: parse-on-client shippers, a typed ClickHouse store with one set of rooms per member, kernel-agency install, and the agentlytics dashboard",
   "main": "bin/memhouse.js",
   "bin": {