memhouse 0.16.0 → 0.17.0

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

@@ -1,130 +0,0 @@
----
-name: invite
-description: Invite another person onto this memhouse ClickHouse — mint their user and their own house (database) with the right grants, producing the one env file their install needs. Use when the user says "invite X", "add X to memhouse", "get my friend set up". Inviting comes BEFORE sharing — /mem:share can only grant a user who exists.
-user-invocable: true
-argument-hint: "<name> [into <db>]"
-allowed-tools: Bash
----
-
-# /mem:invite — mint a member and hand them one file
-
-This runs the `memhouse invite` CLI and nothing else. Inviting mints a ClickHouse user
-and a house, which takes an ADMIN credential — and an admin password must never enter
-this conversation, because memhouse ships the transcript into the house it just
-provisioned. The CLI is the only safe path: the admin password is passed to one process
-and never echoed. **Do not hand-run `CREATE USER` / `GRANT` with an admin password
-substituted into a command — that burns the credential into the transcript on disk.**
-
-## Do this
-
-1. Confirm the `memhouse` binary is present: `command -v memhouse`. If it is not, tell
-   the user to install it first (`npm install -g memhouse`) — there is no in-skill
-   fallback, on purpose (see above).
-
-2. Gather ONLY two things by asking:
-   - the invitee's **name** (validate `[A-Za-z][A-Za-z0-9_]*`; refuse otherwise)
-   - the **URL the invitee will reach the house at** — NOT localhost (that is the
-     invitee's own machine). A LAN IP, hostname, or tunnel.
-
-   Do NOT ask for an admin user or password yet — the next step usually needs neither.
-   Only ask about a **shared house** if the user brings one up; default is the invitee's
-   own house (omit --db; never pass `--db default` for "the default house").
-
-3. TRY IT BARE FIRST — run this via the Bash tool, from the directory the file should
-   land in (step 4). `memhouse invite` uses the caller's OWN configured credential when
-   it can manage users, which is the common case for whoever set the house up, so no
-   admin is needed:
-
-   ```
-   memhouse invite <name> --url <url> [--db <shared-house>]
-   ```
-
-   If it prints `invite written: …`, go to step 4 — you are done, and no admin secret
-   ever touched this conversation.
-
-   Otherwise read WHICH refusal came back; they need different answers.
-
-   **"cannot reach `<url>` …"** — nothing to do with privileges. The address is wrong,
-   or the house is bound to loopback (`memhouse deploy --local` binds to 127.0.0.1 on
-   purpose, so no LAN address reaches it and no invitee could either). Ask the user for
-   the address the invitee will actually use; do not retry with a guess.
-
-   **"`<user>` is a MEMBER of this ClickHouse, not an administrator"** — inviting needs
-   CREATE USER and CREATE DATABASE, which a member deliberately does not hold. Two cases,
-   and you must ask which one applies rather than assuming:
-
-   - **They run the ClickHouse.** They have the admin credential; memhouse never stores
-     it. Do NOT take that password in chat — memhouse archives this transcript. Hand them
-     the line to run THEMSELVES, and leave `--admin-password` OFF so it is prompted for,
-     keeping it out of both the process list and shell history:
-
-     ```
-     memhouse invite <name> --url <url> [--db <shared-house>] --admin-user <admin>
-     ```
-
-     **You cannot run that line yourself.** The prompt needs a TTY and your Bash tool has
-     none, so it refuses with "no TTY to prompt on" — and the fix is NOT to add
-     `--admin-password`, which would put the credential in this transcript. The user runs
-     it in their own terminal; you wait for them to say it is done.
-
-   - **Somebody else runs it.** They cannot invite, and no flag changes that. Print the
-     statements for whoever administers the server — this contacts nothing and needs no
-     credential:
-
-     ```
-     memhouse invite <name> --url <url> [--db <shared-house>] --print-sql
-     ```
-
-     The output ends with the four `MEMHOUSE_*` lines the invitee needs. Those lines are
-     a credential: tell the user to send them over a trusted channel, and **never print
-     them into the conversation yourself**.
-
-   **If it refuses with "house `<db>` already exists and holds N messages", STOP.** That
-   house is somebody's memory, and inviting into it would hand the invitee someone else's
-   sessions. Do not pass `--adopt` on your own initiative — report the row count and the
-   writer count to the user and let them choose: a different handle, a different `--db`,
-   or `--adopt` if sharing that house is genuinely what they want.
-
-4. **Put the file where the user can attach it.** The CLI writes `invite-<name>.env`
-   into the CURRENT directory, and the user has to send it by hand — so run the command
-   from their downloads directory (on macOS and most Linux desktops `~/Downloads`), or
-   move it there afterwards. Never leave it in a git repo: it is a password, and
-   `invite-*.env` is only gitignored in this repo, not in whatever checkout the user
-   happened to be standing in.
-
-   Confirm it is there and still mode `600`, and say the full path. **Never print the
-   file's contents** — the password inside would land in a transcript memhouse ships.
-
-5. **Say whether the house was fresh.** Run
-   `memhouse stats` or query `SELECT count() FROM <db>.messages` and tell the user
-   plainly: a brand-new house reads 0. This is a second line of defence behind step 3's
-   refusal, and it is how the user learns the invitee is starting clean.
-
-6. **Write the message the user will send.** They are about to hand over a file plus an
-   explanation, so compose it for them rather than making them write it. Put it in a
-   fenced block they can copy whole, and cover:
-   - what memhouse is, in a sentence or two — the invitee may never have heard of it
-   - that the attached `invite-<name>.env` IS a password: don't forward it, don't paste
-     it into chat
-   - `npm install -g memhouse` (Node 24+, no flags, nothing compiles), then
-     `memhouse install --env invite-<name>.env`
-   - that install OFFERS to change the password to one only they know, then deletes the
-     file — so they should say yes, because the inviter knows the current one
-   - `memhouse onboard` to start shipping, `memhouse status` to check it worked
-   - that their house is theirs alone; the inviter cannot read it unless they run
-     `/mem:share <inviter>`
-
-   If the invitee is REPLACING an existing setup (they were shipping under another
-   credential), add `memhouse ship --full` after the install — a plain incremental pass
-   skips sessions the new house has no record of, so their history would not follow them.
-
-   Then: once installed, sharing works both ways — `/mem:share <name>`.
-
-## Never
-
-Never create a ClickHouse user by running raw SQL with an admin password you were given
-in chat. Never invent an admin credential. Never suggest granting beyond what `memhouse
-invite` does. If the binary is absent, stop and say so — do not improvise the SQL.
-
-Never print the invite file's contents, and never pass `--adopt` unless the user asked
-for it after being told what is already in that house.

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.