memhouse 0.16.0 → 0.18.0

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

@@ -1,186 +0,0 @@
----
-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". 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
----
-
-# /mem:search — search conversation memory
-
-Search the full message history in the memhouse house. Every room is named for your
-ClickHouse user — `messages`, `sessions` — see **Room names** below.
-
-## Connection
-
-**Never print this file or the variables in it.** No `cat "$MH_ENV"`, no `env | grep
-MEMHOUSE`, no `set -x` around these commands. Anything you print becomes part of a
-transcript that memhouse itself ships into the house.
-
-Credentials resolve as **flags > exported `MEMHOUSE_*` > `$MEMHOUSE_HOME/env`**
-(default `~/.memhouse/env`) — the same order the `memhouse` CLI uses. Every query
-runs over ClickHouse HTTP with `final=1` and `join_use_nulls=1` (ReplacingMergeTree
-keeps stale row versions until merges; `final=1` collapses to latest-wins — always
-include it on reads):
-
-```bash
-# Config lives at $MEMHOUSE_HOME/env (default ~/.memhouse/env). Exported MEMHOUSE_*
-# vars WIN over the file — snapshot them, source, then put them back. Sourcing alone
-# lets a stale file silently override the house you were pointed at.
-MH_ENV="${MEMHOUSE_HOME:-$HOME/.memhouse}/env"
-_u=${MEMHOUSE_URL-}; _s=${MEMHOUSE_USER-}; _p=${MEMHOUSE_PASSWORD-}; _d=${MEMHOUSE_DB-}
-set -a; [ -f "$MH_ENV" ] && . "$MH_ENV"; set +a
-[ -n "$_u" ] && MEMHOUSE_URL=$_u; [ -n "$_s" ] && MEMHOUSE_USER=$_s
-[ -n "$_p" ] && MEMHOUSE_PASSWORD=$_p; [ -n "$_d" ] && MEMHOUSE_DB=$_d
-# No default URL. localhost:8123 as memhouse_root is a REAL house on many machines,
-# usually the pilot's own — guessing it reads someone else's memory and looks like it
-# worked. If there is no config, say so and stop.
-if [ -z "${MEMHOUSE_URL:-}" ] || [ -z "${MEMHOUSE_USER:-}" ]; then
-  # An explicit test, not ${VAR:?msg}: zsh does not expand the message, so under the
-  # shell Claude Code actually uses the refusal read "nothing in $MH_ENV" literally.
-  echo "no memhouse house configured — nothing in $MH_ENV and no MEMHOUSE_URL/MEMHOUSE_USER set." >&2
-  echo "Run: memhouse install" >&2
-  exit 1
-fi
-
-# --user, not a -K config file. The config-file parser treats `"` and `\` specially, so a
-# password containing either authenticates fine from the CLI and fails from every skill
-# with "password is incorrect" — measured. The argv exposure -K was meant to avoid is not
-# observable here either: curl blanks the --user argument before `ps` can read it (0 hits
-# in 50 samples). What actually leaks a credential is PRINTING it, which the rule above
-# covers.
-curl -sS --fail-with-body --user "$MEMHOUSE_USER:${MEMHOUSE_PASSWORD:-}" \
-  --data-binary @- "$MEMHOUSE_URL/?database=${MEMHOUSE_DB:-$MEMHOUSE_USER}&final=1&join_use_nulls=1&readonly=1" <<'SQL'
-<the query>
-FORMAT PrettyCompact
-SQL
-```
-
-`FORMAT PrettyCompact` for display; `FORMAT JSONEachRow` when you want to parse
-the rows yourself.
-
-## Room names — plain, shared tables
-
-The house's rooms are three plain tables: `messages`, `sessions`, `tool_calls` — resolved
-by the connection's database (`MEMHOUSE_DB`), not by who is asking. Everyone in the house
-writes into the same tables; `user_id` (stamped by the server) says whose row it is and
-`host` says which machine shipped it. Search the whole house by default; add
-`AND user_id = '<name>'` only when the user asks for one person's sessions.
-
-**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
-skill did exactly that, unprompted, on the first attempt. Measured consequences, from
-`system.query_log`:
-
-- a term containing `$home` became the empty string, so `LIKE '%%'` matched **every row**
-  and reported hits with exit 0 — silently wrong, not an error;
-- a term containing a backtick **executed the command inside it**.
-
-A user's search term is arbitrary text. With the heredoc quoted, neither can happen.
-
-**There is no `sessions_v` object.** The session rollup is a saved query over those same
-rooms — `memhouse sessions-query` prints it for whoever you are connected as, ready to
-paste into a `FROM (...) AS c` position.
-
-**The rollup is self-contained.** As of 0.4.5 the printed text carries its own `FINAL` on
-both rooms and a trailing `SETTINGS join_use_nulls = 1`, so it is correct wherever you
-paste it. `final=1` on the connection still matters for reads of the rooms THEMSELVES,
-which carry no FINAL of their own.
-
-
-## How to search (the FTS columns)
-
-`messages` carries two MATERIALIZED lowercase copies of `text`, each with a
-text index — search those, display `text`:
-
-- `text_ngram` (ngram index) → substring match: `text_ngram LIKE '%term%'`
-- `text_word` (word index) → whole-token match: `hasToken(text_word, 'term')`
-
-**Search terms MUST be lowercased** (the columns are `lower(text)`); escape
-single quotes in user terms as `\'`. Multiple words → AND of clauses; a quoted
-phrase → one `LIKE` clause for the whole phrase.
-
-### Example 1 — substring search with session names
-
-```sql
-SELECT m.ts, m.source, m.project, m.role, m.session_id,
-       s.name AS session,
-       substring(m.text, 1, 300) AS snippet
-FROM messages AS m
-LEFT JOIN sessions AS s USING (session_id, user_id)
-WHERE m.text_ngram LIKE '%postgres%' AND m.text_ngram LIKE '%migration%'
-ORDER BY m.ts DESC
-LIMIT 30
-FORMAT PrettyCompact
-```
-
-### Example 2 — word match, scoped by editor and time
-
-```sql
-SELECT ts, project, session_id, substring(text, 1, 200) AS snippet
-FROM messages
-WHERE hasToken(text_word, 'rls')
-  AND source = 'claude-code'
-  AND ts > now() - INTERVAL 14 DAY
-ORDER BY ts DESC
-LIMIT 20
-FORMAT PrettyCompact
-```
-
-### Example 3 — which sessions mention it most (then drill in)
-
-```sql
-SELECT m.session_id, m.user_id, any(s.name) AS session, any(m.project) AS project,
-       count() AS hits, max(m.ts) AS last_hit
-FROM messages AS m
-LEFT JOIN sessions AS s USING (session_id, user_id)
-WHERE m.text_ngram LIKE '%clickhouse cache%'
-GROUP BY m.session_id, m.user_id
-ORDER BY hits DESC
-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:-$MEMHOUSE_USER}` 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>%'` — 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`,
-  `windsurf`, `antigravity`, `copilot-cli`, `goose`, `kiro`, …)
-- Skip subagent noise → `AND NOT m.is_subagent`
-- Only user/assistant text lives in `messages`; tool invocations are in
-  `tool_calls` (`tool_name`, `args`) — search `args ILIKE '%term%'` there
-  only if the user explicitly wants tool calls searched.
-
-## Output
-
-Summarize hits grouped by session (name, source, project, date, 1–2 best
-snippets each) and give the total hit count. Offer to pull the full transcript
-of the best session (`SELECT role, text FROM messages WHERE session_id = '…'
-ORDER BY seq`). If zero hits, retry with broader/fewer terms and report the
-corpus size (`SELECT count() FROM messages`).

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

@@ -1,164 +0,0 @@
----
-name: sessions
-description: List recent agent sessions from memhouse conversation memory — names, projects, editors, hosts, times, message and token counts across all 17 supported editors. Use for "what was I working on", "show my recent sessions", "sessions from last week", "what did I do in project X", "list my cursor sessions", or to orient before drilling into one session.
-user-invocable: true
-argument-hint: "[N] [project <name>] [from <editor>] [today|week|month]"
-allowed-tools: Bash
----
-
-# /mem:sessions — browse session history
-
-List/filter sessions from the session rollup — a saved query over your own rooms, not an
-object; `memhouse sessions-query` prints it (session metadata +
-message aggregates) in the memhouse house.
-
-## When to use
-
-- The user wants an overview of recent activity rather than a specific quote.
-- As a first step before digging into one session, when they don't have an
-  id/name yet.
-
-## Connection
-
-**Never print this file or the variables in it.** No `cat "$MH_ENV"`, no `env | grep
-MEMHOUSE`, no `set -x` around these commands. Anything you print becomes part of a
-transcript that memhouse itself ships into the house.
-
-Credentials resolve as **flags > exported `MEMHOUSE_*` > `$MEMHOUSE_HOME/env`**
-(default `~/.memhouse/env`) — the same order the `memhouse` CLI uses. Every query
-runs over ClickHouse HTTP with `final=1` and `join_use_nulls=1` (ReplacingMergeTree
-keeps stale row versions until merges; `final=1` collapses to latest-wins — always
-include it on reads):
-
-```bash
-# Config lives at $MEMHOUSE_HOME/env (default ~/.memhouse/env). Exported MEMHOUSE_*
-# vars WIN over the file — snapshot them, source, then put them back. Sourcing alone
-# lets a stale file silently override the house you were pointed at.
-MH_ENV="${MEMHOUSE_HOME:-$HOME/.memhouse}/env"
-_u=${MEMHOUSE_URL-}; _s=${MEMHOUSE_USER-}; _p=${MEMHOUSE_PASSWORD-}; _d=${MEMHOUSE_DB-}
-set -a; [ -f "$MH_ENV" ] && . "$MH_ENV"; set +a
-[ -n "$_u" ] && MEMHOUSE_URL=$_u; [ -n "$_s" ] && MEMHOUSE_USER=$_s
-[ -n "$_p" ] && MEMHOUSE_PASSWORD=$_p; [ -n "$_d" ] && MEMHOUSE_DB=$_d
-# No default URL. localhost:8123 as memhouse_root is a REAL house on many machines,
-# usually the pilot's own — guessing it reads someone else's memory and looks like it
-# worked. If there is no config, say so and stop.
-if [ -z "${MEMHOUSE_URL:-}" ] || [ -z "${MEMHOUSE_USER:-}" ]; then
-  # An explicit test, not ${VAR:?msg}: zsh does not expand the message, so under the
-  # shell Claude Code actually uses the refusal read "nothing in $MH_ENV" literally.
-  echo "no memhouse house configured — nothing in $MH_ENV and no MEMHOUSE_URL/MEMHOUSE_USER set." >&2
-  echo "Run: memhouse install" >&2
-  exit 1
-fi
-
-# --user, not a -K config file. The config-file parser treats `"` and `\` specially, so a
-# password containing either authenticates fine from the CLI and fails from every skill
-# with "password is incorrect" — measured. The argv exposure -K was meant to avoid is not
-# observable here either: curl blanks the --user argument before `ps` can read it (0 hits
-# in 50 samples). What actually leaks a credential is PRINTING it, which the rule above
-# covers.
-curl -sS --fail-with-body --user "$MEMHOUSE_USER:${MEMHOUSE_PASSWORD:-}" \
-  --data-binary @- "$MEMHOUSE_URL/?database=${MEMHOUSE_DB:-$MEMHOUSE_USER}&final=1&join_use_nulls=1&readonly=1" <<'SQL'
-<the query>
-FORMAT PrettyCompact
-SQL
-```
-
-## Room names — plain, shared tables
-
-The house's rooms are three plain tables: `messages`, `sessions`, `tool_calls` — resolved
-by the connection's database (`MEMHOUSE_DB`), not by who is asking. Everyone in the house
-writes into the same tables; `user_id` (stamped by the server) says whose row it is and
-`host` says which machine shipped it. Search the whole house by default; add
-`AND user_id = '<name>'` only when the user asks for one person's sessions.
-
-**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
-skill did exactly that, unprompted, on the first attempt. Measured consequences, from
-`system.query_log`:
-
-- a term containing `$home` became the empty string, so `LIKE '%%'` matched **every row**
-  and reported hits with exit 0 — silently wrong, not an error;
-- a term containing a backtick **executed the command inside it**.
-
-A user's search term is arbitrary text. With the heredoc quoted, neither can happen.
-
-**There is no `sessions_v` object.** The session rollup is a saved query over those same
-rooms — `memhouse sessions-query` prints it for whoever you are connected as, ready to
-paste into a `FROM (...) AS c` position.
-
-**The rollup is self-contained.** As of 0.4.5 the printed text carries its own `FINAL` on
-both rooms and a trailing `SETTINGS join_use_nulls = 1`, so it is correct wherever you
-paste it. Both matter: without `FINAL` every message is counted once per undeleted
-ReplacingMergeTree version (2x right after a ship, 3x a few ships later — measured, and it
-grows); without `join_use_nulls` a session with no messages reports `total_msgs = 1`
-rather than 0.
-
-**If the `memhouse` binary is not on PATH**, you cannot print the rollup — the skills are
-installable on their own. Query the rooms directly instead: `sessions` for metadata
-and `messages` for counts, each read `FINAL`, joined on `session_id` and `user_id`.
-Prefer the binary when it is there; a rollup you assemble by hand and one printed by a
-DIFFERENT memhouse version are the two ways this goes quietly wrong.
-
-
-## Default listing
-
-```sql
-SELECT session_id, name, source, host, project,
-       started, ended, total_msgs, user_msgs, assistant_msgs,
-       output_tokens,
-       substring(first_prompt, 1, 80) AS first_prompt
-FROM (the rollup from `memhouse sessions-query`)
-ORDER BY ended DESC
-LIMIT 20
-FORMAT PrettyCompact
-```
-
-- Default `LIMIT 20`; `[N]` overrides.
-- `today` / `week` / `month` → `WHERE ended > now() - INTERVAL 1 DAY`
-  (`7 DAY` / `30 DAY`).
-- `project <name>` → `WHERE project ILIKE '%<name>%'`.
-- `from <editor>` → `WHERE source = '<id>'` (`claude-code`, `codex`, `cursor`,
-  `vscode`, `zed`, `opencode`, `gemini-cli`, `windsurf`, …).
-- Unnamed sessions (`name = ''`): fall back to `first_prompt` as the label.
-
-## More cuts
-
-Per-editor rollup ("where has my work been happening?"):
-
-```sql
-SELECT source, count() AS sessions, sum(total_msgs) AS msgs,
-       sum(output_tokens) AS out_tokens, max(ended) AS last_activity
-FROM (the rollup from `memhouse sessions-query`)
-GROUP BY source
-ORDER BY sessions DESC
-FORMAT PrettyCompact
-```
-
-Busiest projects this month:
-
-```sql
-SELECT project, count() AS sessions, sum(assistant_msgs) AS assistant_msgs
-FROM (the rollup from `memhouse sessions-query`)
-WHERE ended > now() - INTERVAL 30 DAY AND project != ''
-GROUP BY project
-ORDER BY sessions DESC
-LIMIT 15
-FORMAT PrettyCompact
-```
-
-## Examples
-
-| User says | What you do |
-|---|---|
-| "what was I working on yesterday?" | `WHERE ended > now() - INTERVAL 1 DAY` |
-| "show my last 10 sessions in agentlytics" | `LIMIT 10 … WHERE project ILIKE '%agentlytics%'` |
-| "list my cursor sessions this month" | `WHERE source = 'cursor' AND ended > now() - INTERVAL 30 DAY` |
-| "which machine did I do the schema work on?" | search via /mem:search, or filter `host` here |
-
-## Output
-
-A compact table: when, name (or first prompt), source, host, project, msgs,
-tokens. Offer to pull a full transcript next
-(`SELECT role, text FROM messages WHERE session_id = '…' ORDER BY seq`) or to
-run /mem:search for a specific quote.

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

@@ -1,130 +0,0 @@
----
-name: share
-description: Share your conversation memory with another user on the same ClickHouse — grant them read-only access to your house, list who can currently read it, or revoke a share. Use when the user says "share my memory with X", "let X see my sessions", "who can read my memory", "stop sharing with X". Read-only by construction — a share can never let anyone write to or delete your memory.
-user-invocable: true
-argument-hint: "[<user> | revoke <user> | (nothing: list current shares)]"
-allowed-tools: Bash
----
-
-# /mem:share — a read-only window into your memory
-
-Three forms, decided by the arguments:
-
-- `/mem:share yigit` — let `yigit` read this house
-- `/mem:share revoke yigit` — close that window
-- `/mem:share` — who can read this house right now
-
-Sharing is a ClickHouse GRANT and nothing else — memhouse adds no layer on top, so what
-you grant is exactly what they get: `SELECT`, never write, never delete. Your own grant
-carries `WITH GRANT OPTION` on SELECT only (installs from 0.10.0 on), so you can open
-this window yourself and can hand on nothing more.
-
-## Connection
-
-**Never print this file or the variables in it.** No `cat "$MH_ENV"`, no `env | grep
-MEMHOUSE`, no `set -x` around these commands.
-
-```bash
-MH_ENV="${MEMHOUSE_HOME:-$HOME/.memhouse}/env"
-_u=${MEMHOUSE_URL-}; _s=${MEMHOUSE_USER-}; _p=${MEMHOUSE_PASSWORD-}; _d=${MEMHOUSE_DB-}
-set -a; [ -f "$MH_ENV" ] && . "$MH_ENV"; set +a
-[ -n "$_u" ] && MEMHOUSE_URL=$_u; [ -n "$_s" ] && MEMHOUSE_USER=$_s
-[ -n "$_p" ] && MEMHOUSE_PASSWORD=$_p; [ -n "$_d" ] && MEMHOUSE_DB=$_d
-if [ -z "${MEMHOUSE_URL:-}" ] || [ -z "${MEMHOUSE_USER:-}" ]; then
-  echo "no memhouse house configured — nothing in $MH_ENV and no MEMHOUSE_URL/MEMHOUSE_USER set." >&2
-  echo "Run: memhouse install" >&2
-  exit 1
-fi
-
-# NO readonly=1 on this skill's grant/revoke calls — GRANT is refused under readonly.
-# The list query below still pins it.
-curl -sS --fail-with-body --user "$MEMHOUSE_USER:${MEMHOUSE_PASSWORD:-}" \
-  --data-binary @- "$MEMHOUSE_URL/?database=${MEMHOUSE_DB:-$MEMHOUSE_USER}" <<'SQL'
-<the statement>
-SQL
-```
-
-## Grant — `/mem:share <user>`
-
-The user name goes into SQL unquoted: **refuse anything not matching
-`[A-Za-z][A-Za-z0-9_]*`** rather than quoting it — a name you cannot type bare is a name
-that will be gotten wrong everywhere else too.
-
-**Validate `<user>` FIRST, once, and use only the validated token — in the GRANT, the
-REVOKE, and the house_meta record alike.** The record INSERT is a quoted literal;
-anything that has not passed the name check must never reach it.
-
-**`<db>` below is the LIVE value of `$MEMHOUSE_DB` — print it with the connection
-(`echo "house: $MEMHOUSE_DB"`) and use THAT in every statement and every piece of
-advice.** Driven live, a model filled `<db>` in the admin advice with the literal
-fallback `mem` while the real house was named differently — advice the admin would have
-run against the wrong database.
-
-```sql
-GRANT SELECT ON <db>.* TO <user>
-```
-
-(`<db>` is `$MEMHOUSE_DB`.) Then RECORD it in the house's own memory — a member cannot
-read `system.grants` (measured: `Not enough privileges … SELECT ON system.grants`), so
-this record is what the list form reads back:
-
-```sql
-INSERT INTO house_meta (key, value) VALUES ('share:<user>', 'granted <today, YYYY-MM-DD>')
-```
-
-Verify the grant took by USING it if you can, or simply report the server accepted it —
-do not call `SHOW GRANTS FOR <user>` (it needs privileges a member does not hold).
-
-Two failure shapes, both to report exactly:
-
-- `There is no user ... in user directories` — the person has no ClickHouse user on this
-  server yet. Joining comes first: they run `memhouse install` against this server (or
-  the admin runs `memhouse install --print-sql --member <user> --db <their-house>`).
-  A share cannot create a user, by design.
-- `Not enough privileges` — either this house predates 0.10.0 (your own grant carries
-  no grant option), or **the configured house is not yours to share** (a team house, or
-  someone else's). Only suggest the admin remedy when the house is the user's OWN — the
-  grant-option statement hands them standing power to share it, which is the owner's
-  decision, not a fix. For their own pre-0.10 house, print for the ADMIN:
-  `GRANT SELECT ON <db>.* TO <user>` — and to make future shares self-serve:
-  `GRANT SELECT ON <db>.* TO <your-user> WITH GRANT OPTION`.
-  For a house that is not theirs, say so and stop: the owner shares it, not you.
-
-Tell the user how their friend actually reads it: qualified names —
-`SELECT … FROM <db>.messages …` — from /mem:ask, /mem:search or /mem:sql on the friend's
-side, with the same epoch filter those skills already carry.
-
-## Revoke — `/mem:share revoke <user>`
-
-```sql
-REVOKE SELECT ON <db>.* FROM <user>
-```
-```sql
-INSERT INTO house_meta (key, value) VALUES ('share:<user>', 'revoked <today, YYYY-MM-DD>')
-```
-
-Revoking a share that never existed is a no-op, not an error — say which it was (the
-`share:<user>` record answers that).
-
-## List — `/mem:share` (no arguments)
-
-From the house's own record (append `&readonly=1` to the URL for this one):
-
-```sql
-SELECT substring(key, 7) AS user, value AS state,
-       formatDateTime(updated_at, '%Y-%m-%d %H:%i') AS at
-FROM house_meta FINAL WHERE key LIKE 'share:%' ORDER BY key
-```
-
-Latest-wins per user: `granted …` rows are live shares, `revoked …` rows are closed
-ones. Be honest about the record's edge: it shows shares made THROUGH THIS SKILL — a
-grant the admin issued directly will not appear. The authoritative list is the admin's
-one query: `SELECT user_name, access_type FROM system.grants WHERE database = '<db>'`
-(members cannot run it; `system.grants` needs privileges a member does not hold).
-
-## What this never does
-
-No `GRANT ALL`, no write grants, no `WITH GRANT OPTION` onward, no user creation, no
-grants on any database but your own. If the user asks for more than read access, that is
-the shared-house model (both members in ONE database) — a decision, not a grant; point
-them at `memhouse install --db <shared>` and stop.

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

@@ -1,139 +0,0 @@
----
-name: status
-description: Show the state of the memory system — what the house holds (sessions, messages, tokens per editor), how fresh it is, its schema generation and migration state, and every machine writing into it. Use when the user asks "is my memory working", "how much is stored", "when did it last ship", "what's in the house", "which machines are shipping", or before debugging why a search found nothing.
-user-invocable: true
-argument-hint: ""
-allowed-tools: Bash
----
-
-# /mem:status — the state of the memory system
-
-**Invoking this skill IS the request. Run the report immediately — connect, run the four
-sections below, and present the summary. There are no arguments and nothing to clarify;
-do not describe this skill or ask what to check.** (Driven live, a model did exactly
-that: it summarized the file and asked "is there something specific?" — a status command
-that answers with a question has failed.)
-
-One report, four sections: what the house holds, how fresh it is, what generation it is
-at, and who writes into it. Read-only; nothing here changes anything.
-
-## Connection
-
-**Never print this file or the variables in it.** No `cat "$MH_ENV"`, no `env | grep
-MEMHOUSE`, no `set -x` around these commands. Anything you print becomes part of a
-transcript that memhouse itself ships into the house.
-
-```bash
-MH_ENV="${MEMHOUSE_HOME:-$HOME/.memhouse}/env"
-_u=${MEMHOUSE_URL-}; _s=${MEMHOUSE_USER-}; _p=${MEMHOUSE_PASSWORD-}; _d=${MEMHOUSE_DB-}
-set -a; [ -f "$MH_ENV" ] && . "$MH_ENV"; set +a
-[ -n "$_u" ] && MEMHOUSE_URL=$_u; [ -n "$_s" ] && MEMHOUSE_USER=$_s
-[ -n "$_p" ] && MEMHOUSE_PASSWORD=$_p; [ -n "$_d" ] && MEMHOUSE_DB=$_d
-if [ -z "${MEMHOUSE_URL:-}" ] || [ -z "${MEMHOUSE_USER:-}" ]; then
-  echo "no memhouse house configured — nothing in $MH_ENV and no MEMHOUSE_URL/MEMHOUSE_USER set." >&2
-  echo "Run: memhouse install" >&2
-  exit 1
-fi
-
-curl -sS --fail-with-body --user "$MEMHOUSE_USER:${MEMHOUSE_PASSWORD:-}" \
-  --data-binary @- "$MEMHOUSE_URL/?database=${MEMHOUSE_DB:-$MEMHOUSE_USER}&final=1&join_use_nulls=1&readonly=1" <<'SQL'
-<the query>
-FORMAT PrettyCompact
-SQL
-```
-
-## The report — run these, then summarize
-
-**1. What the house holds** — per editor, CURRENT parses only (the rooms retain
-superseded parses; an unfiltered count over-reports on any compacted session):
-
-```sql
-SELECT source,
-       uniqExact(session_id) AS sessions,
-       count() AS messages,
-       sum(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens) AS tokens
-FROM messages
-WHERE origin != 'ship'
-   OR (session_id, user_id, epoch) IN (
-        SELECT session_id, user_id, max(epoch) FROM messages
-        WHERE origin = 'ship' GROUP BY session_id, user_id)
-GROUP BY source ORDER BY sessions DESC
-```
-
-**2. Freshness and coverage** — when the archive starts, ends, and last received:
-
-```sql
-SELECT formatDateTime(min(ts), '%Y-%m-%d') AS oldest,
-       formatDateTime(max(ts), '%Y-%m-%d %H:%i') AS newest,
-       formatDateTime(max(ingested_at), '%Y-%m-%d %H:%i') AS last_ingest
-FROM messages
-```
-
-A `last_ingest` hours old with the user actively working means the shipper is not
-running — say so and point at `memhouse status` / `memhouse start` on that machine.
-
-**3. Generation and migration state** — the house's record of itself (absent on a
-pre-0.10 house; that absence is itself the answer: say the house predates the record):
-
-```sql
-SELECT key, value FROM house_meta FINAL
-WHERE key IN ('schema_version', 'min_writer_schema') ORDER BY key
-```
-```sql
-SELECT id, argMax(status, event_at) AS status,
-       formatDateTime(max(event_at), '%Y-%m-%d %H:%i') AS at
-FROM house_events WHERE kind = 'migration' GROUP BY id ORDER BY at DESC LIMIT 3
-```
-
-A `pending` here with nothing running means an interrupted migration — name
-`memhouse migrate` (it refuses stale leftovers legibly rather than clobbering them).
-
-**4. The fleet** — every machine writing into this house, from the DATA (a pre-0.10
-writer records nothing about itself, so rows-without-record is the finding):
-
-```sql
-SELECT user_id, host, count() AS rows,
-       formatDateTime(max(ingested_at), '%Y-%m-%d %H:%i') AS last_write
-FROM messages GROUP BY user_id, host ORDER BY last_write DESC
-```
-```sql
-SELECT key, value FROM house_meta FINAL
-WHERE key LIKE 'client_version:%' OR key LIKE 'client_schema:%' OR key LIKE 'last_ship:%'
-```
-
-Match `client_*:<member>@<host>` against the data rows. A `(user_id, host)` pair with
-rows but NO `client_*` record is a **pre-0.10 memhouse still writing** — flag it: its
-re-ships delete retained parses, and the fixes are upgrade it or (as admin)
-`REVOKE ALTER DELETE, ALTER UPDATE ON <db>.* FROM <member>`.
-
-**5. Client freshness** — is the installed memhouse behind the published release? This is a
-shell check, not SQL (it reads the local binary and the npm registry, no house involved):
-
-```bash
-INSTALLED=$(memhouse version 2>/dev/null | head -1 | tr -d '[:space:]')
-LATEST=$(curl -sS -m 5 https://registry.npmjs.org/memhouse/latest 2>/dev/null | sed -n 's/.*"version":"\([^"]*\)".*/\1/p')
-echo "installed=${INSTALLED:-unknown} latest=${LATEST:-unknown}"
-```
-
-Compare the two as `MAJOR.MINOR.PATCH`. Report freshness, and size the nudge to the gap:
-
-- **up to date** (installed ≥ latest) — one line: "client 0.X.Y, current."
-- **small gap** (same major+minor, a patch or two behind) — a gentle note: "a newer patch
-  0.X.Z is out; `memhouse update` when convenient."
-- **big gap** (latest MAJOR or MINOR is ahead, or many patches) — surface it prominently and
-  **offer to update**: "your memhouse is 0.A.B but 0.C.D is released — run **`memhouse
-  update`** to upgrade; it also refreshes the `/mem:*` plugin, then `/reload-plugins`."
-- either side **unknown** (no binary on PATH, or the registry did not answer) — say which,
-  don't guess. A plugin-only install with no CLI can't self-update; point at
-  `npm i -g memhouse`.
-
-Never run `memhouse update` yourself — it restarts daemons and may migrate the house.
-Offer the command; the pilot runs it.
-
-## Presenting it
-
-Lead with one line of verdict ("healthy: N sessions across M editors, last ingest X
-minutes ago" — or the one thing wrong). Then the per-editor table, then anything from
-sections 3–5 that needs action. A **big version gap (section 5) is an action** — put the
-`memhouse update` offer near the top, not buried. Skip empty sections; do not pad. If the
-house is unreachable, say which URL refused and stop — never guess another endpoint.