linksee-memory 0.11.0 → 0.11.2

package/README.md

@@ -6,7 +6,7 @@
 >
 > Underneath sits a local-first cross-LLM memory MCP — one SQLite file that **Claude Code, Cursor, Windsurf, OpenAI Codex, and Gemini CLI** all read from. Not just "what happened" but **WHY**: 6-layer structured memory with precision recall and an AST-aware diff cache (50–99% token savings on re-reads).
 >
-> `npx linksee-memory-setup` — one command, done.
+> `npx -y linksee-memory setup` — one command, done.
 
 [![npm](https://img.shields.io/npm/v/linksee-memory.svg)](https://www.npmjs.com/package/linksee-memory)
 [![license](https://img.shields.io/npm/l/linksee-memory.svg)](./LICENSE)
@@ -14,17 +14,34 @@
 [![glama-score](https://glama.ai/mcp/servers/michielinksee/linksee-memory/badges/score.svg)](https://glama.ai/mcp/servers/michielinksee/linksee-memory)
 
 🌐 **Landing page**: [linksee-site.vercel.app](https://linksee-site.vercel.app) (includes non-developer onboarding for Claude Desktop / Cursor / Claude Code / OpenAI Codex / Gemini CLI)
+📖 **Docs**: [docs.linksee.app](https://docs.linksee.app) — full reference: the product map & drift, install, and all 11 tools
 
 ## 🪄 Three spells to remember
 
 | Say this | What happens |
 |---|---|
-| **"use linksee"** ・「リンクシーして」 | Recalls relevant memories before acting |
-| **"linksee this"** ・「これ覚えて」 | Saves the decision / lesson right now |
-| **"what's drifting?"** ・「ズレてない？」 | Reconciles reality against your locked decisions |
+| **"use linksee"** | Recalls relevant memories before acting |
+| **"linksee this"** | Saves the decision / lesson right now |
+| **"what's drifting?"** | Reconciles reality against your locked decisions |
 
 > Make it automatic: add **"Use Linksee Memory"** to your system prompt / `CLAUDE.md`.
 
+## 🗺️ Not just memory — a product map
+
+Memory is the entry point. Tie it to a `map.yaml` of how your product fits together, and the `linksee-memory map` CLI catches drift with file:line evidence:
+
+![linksee-memory-map catching doc/code drift in 30 seconds](demo/where-demo.gif)
+
+**The 30-second demo above:** the README says `--export`. The code doesn't. Linksee catches it — and shows what else a change would touch.
+
+```bash
+npx -y linksee-memory map where README.md   # this file belongs to the README node — and what it touches
+npx -y linksee-memory map explain readme    # README promises --export; the code doesn't implement it — drift, with evidence
+npx -y linksee-memory map affects readme    # changing the README also touches docs, the CLI help, and the npm listing
+```
+
+→ see [The Map](#the-map) for the full flow.
+
 ## 📣 As featured on
 
 - **Zenn**: [あなたの Claude Code、 実は前回のセッションを完全に忘れている](https://zenn.dev/kanseilink/articles/linksee-memory-claude-code-recall-20260508) — 73 ♡ on Zenn, **165+ users on Hatena Bookmark**, picked up by tech blogs + YouTube shorts (May 2026)
@@ -121,7 +138,7 @@ Anchors are classified into four species with different display formats:
 
 <a id="the-map"></a>
 
-## 🗺️ The Map — `linksee-memory-map`
+## 🗺️ The Map — `linksee-memory map`
 
 Drift detection (above) checks individual anchors. The **Map** lifts it to the whole product: a `map.yaml` describing how value reaches your user (`discover → understand → try → adopt → retain → monetize → expand`), with typed dependencies between the pieces — README, npm listing, onboarding, the engine that powers them. The reconciler checks that map against your real code, and the CLI answers the question an engineer actually has:
 
@@ -130,7 +147,7 @@ Drift detection (above) checks individual anchors. The **Map** lifts it to the w
 **1. Where am I?** — locate a file (or, with no argument, infer from your recent edits):
 
 ```
-$ linksee-memory-map where README.md
+$ npx -y linksee-memory map where README.md
 "README.md" belongs to this Map node:
 
   readme  [understand]  convergence
@@ -145,7 +162,7 @@ The blast radius is **graded** — `must fix together` vs `should align` vs `fyi
 **2. Why is it in this state?** — the diagnosis, with file:line evidence:
 
 ```
-$ linksee-memory-map explain readme
+$ npx -y linksee-memory map explain readme
 
 STATUS
   declared: healthy (active)
@@ -159,7 +176,7 @@ EVIDENCE
 
 Declared state and the reality verdict are shown **separately** — a hand-declared `suspect` the scanner refutes reads as *"declared suspect, refuted by reality (→ convergence)"*, not a confusing mix.
 
-**3. Whole-project triage:** `linksee-memory-map status` — a health %, what is *fixable now in code* vs *external checks*, and any deferral with no expiry (so "accounted-for" can't quietly become a drift graveyard).
+**3. Whole-project triage:** `npx -y linksee-memory map status` — a health %, what is *fixable now in code* vs *external checks*, and any deferral with no expiry (so "accounted-for" can't quietly become a drift graveyard).
 
 **How it works**
 - **`map.yaml`** (repo root) is the desired-state source of truth: a journey spine × surface/implementation layers × typed edges (`must-stay-consistent-with` / `should-align-with` / `realizes`).
@@ -187,7 +204,7 @@ It is **fail-open by construction**: any parse / DB / logic error surfaces nothi
 
 ### Enable it
 
-`npx linksee-memory-setup` offers to wire this into your **project's** `.claude/settings.json` (Step 4). To do it by hand, drop this block into `.claude/settings.json` at your project root — it points at the globally-installed `linksee-memory-guard` bin, so no build step is needed:
+`npx -y linksee-memory setup` offers to wire this into your **project's** `.claude/settings.json` (Step 4). To do it by hand, drop this block into `.claude/settings.json` at your project root — it points at the globally-installed `linksee-memory-guard` bin, so no build step is needed:
 
 ```json
 {
@@ -196,7 +213,7 @@ It is **fail-open by construction**: any parse / DB / logic error surfaces nothi
       {
         "matcher": "startup|resume|compact",
         "hooks": [
-          { "type": "command", "command": "npx -y linksee-memory-guard", "timeout": 15 }
+          { "type": "command", "command": "npx -y linksee-memory guard", "timeout": 15 }
         ]
       }
     ],
@@ -204,7 +221,7 @@ It is **fail-open by construction**: any parse / DB / logic error surfaces nothi
       {
         "matcher": "Edit|Write|Bash",
         "hooks": [
-          { "type": "command", "command": "npx -y linksee-memory-guard", "timeout": 8 }
+          { "type": "command", "command": "npx -y linksee-memory guard", "timeout": 8 }
         ]
       }
     ]
@@ -214,7 +231,7 @@ It is **fail-open by construction**: any parse / DB / logic error surfaces nothi
 
 It's **project-scoped on purpose** — the guard enforces *this* repo's decisions, and you opt in per project rather than letting it deny tool calls everywhere (the Stop hook from setup, by contrast, is user-global). Declare what it should watch with `declare_anchor(...)`; set `card_policy.gate_mode:'hard'` on an anchor to make a contradiction **block** instead of just warn (the soft default only re-injects). Anchors that are stale (`at_risk`), superseded, or card-disabled never gate.
 
-> Developing linksee-memory itself? The repo dogfoods the guard via a (gitignored) `.claude/settings.json` that points at the local build (`node ${CLAUDE_PROJECT_DIR}/dist/bin/guard-hook.js`) so it runs against your uncommitted changes. End-user projects should use the published `npx -y linksee-memory-guard` form above.
+> Developing linksee-memory itself? The repo dogfoods the guard via a (gitignored) `.claude/settings.json` that points at the local build (`node ${CLAUDE_PROJECT_DIR}/dist/bin/guard-hook.js`) so it runs against your uncommitted changes. End-user projects should use the published `npx -y linksee-memory guard` form above.
 
 ---
 
@@ -270,7 +287,7 @@ Every memory is tagged with **exactly one layer**. `caveat`-layer entries are pr
 ## Quick Start — One Command
 
 ```bash
-npx linksee-memory-setup
+npx -y linksee-memory setup
 ```
 
 This does everything:
@@ -297,7 +314,7 @@ Tools appear as `mcp__linksee__remember`, `mcp__linksee__recall`, `mcp__linksee_
 **Install the skill (auto-invocation):**
 
 ```bash
-npx -y linksee-memory-install-skill
+npx -y linksee-memory install-skill
 ```
 
 Copies `SKILL.md` to `~/.claude/skills/linksee-memory/`. Agent auto-fires on phrases like "前に…", "また同じエラー", "覚えておいて", new task starts, file edits, etc.
@@ -313,7 +330,7 @@ Add to `~/.claude/settings.json`:
       {
         "matcher": "",
         "hooks": [
-          { "type": "command", "command": "npx -y linksee-memory-sync" }
+          { "type": "command", "command": "npx -y linksee-memory sync" }
         ]
       }
     ]
@@ -371,20 +388,15 @@ Add to `~/.codeium/windsurf/mcp_config.json`:
 <summary><strong>OpenAI Codex CLI</strong></summary>
 
 ```bash
-codex --mcp-server "npx -y linksee-memory"
+codex mcp add linksee -- npx -y linksee-memory
 ```
 
-Or add to `~/.codex/config.json`:
+Or add to `~/.codex/config.toml`:
 
-```json
-{
-  "mcpServers": {
-    "linksee": {
-      "command": "npx",
-      "args": ["-y", "linksee-memory"]
-    }
-  }
-}
+```toml
+[mcp_servers.linksee]
+command = "npx"
+args = ["-y", "linksee-memory"]
 ```
 
 </details>
@@ -413,6 +425,23 @@ All editors share the same `~/.linksee-memory/memory.db`. A decision made in Cla
 
 Default: `~/.linksee-memory/memory.db`. Override with `LINKSEE_MEMORY_DIR` env var.
 
+### Uninstall
+
+```bash
+# 1. Remove the MCP server registration
+claude mcp remove linksee
+
+# 2. Remove the hooks from settings.json (edit the file, delete the linksee entries):
+#    ~/.claude/settings.json          → the Stop hook running "npx -y linksee-memory sync"
+#    <project>/.claude/settings.json  → the SessionStart/PreToolUse hooks running "npx -y linksee-memory guard"
+
+# 3. Remove the installed skill and all local memory (optional)
+rm -rf ~/.claude/skills/linksee-memory
+rm -rf ~/.linksee-memory   # deletes all stored memory — nothing is kept anywhere else
+```
+
+Nothing ever leaves your machine, so step 3 fully erases everything Linksee stored.
+
 ## What's new in v0.9
 
 | Feature | Detail |
@@ -447,7 +476,7 @@ Default: `~/.linksee-memory/memory.db`. Override with `LINKSEE_MEMORY_DIR` env v
 
 | Feature | Detail |
 |---|---|
-| **One-command setup** | `npx linksee-memory-setup` — registers MCP server, installs skill, configures auto-capture hook. One command instead of three. |
+| **One-command setup** | `npx -y linksee-memory setup` — registers MCP server, installs skill, configures auto-capture hook. One command instead of three. |
 | **Structured memory v2** | 3-axis classification (altitude × type × state) for every memory. Auto-extraction from sessions produces machine-scannable JSON, not raw chat dumps. |
 | **Precision recall guide** | SKILL.md now teaches agents HOW to write effective queries, WHEN to recall vs skip, and WHEN to proactively surface caveats before risky actions. |
 | **Five MCP Blocks** | Tools + Resources + Prompts + Sampling + Roots + Elicitation. Most MCP servers expose only Tools; linksee-memory implements all five primitives. |
@@ -488,13 +517,13 @@ Previous versions exposed 3 tools — v0.8.0 added 4 drift tools that let agents
 
 | Command | Purpose |
 |---|---|
-| `npx linksee-memory-setup` | One-command setup: MCP server + skill + Stop hook, then offers to wire the re-injection guard into this project. Idempotent — skips what's already done. |
+| `npx -y linksee-memory setup` | One-command setup: MCP server + skill + Stop hook, then offers to wire the re-injection guard into this project. Idempotent — skips what's already done. |
 | `npx linksee-memory` | MCP server (stdio) |
-| `npx linksee-memory-sync` | Claude Code Stop-hook entry point |
-| `npx linksee-memory-guard` | Re-injection guard hook: `PreToolUse` gate (`Edit`/`Write`/`Bash`) + `SessionStart` boot digest. Wired per-project (see [Re-injection Guard](#reinjection-guard)); fail-open. |
-| `npx linksee-memory-import` | Batch-import Claude Code session JSONL history |
-| `npx linksee-memory-install-skill` | Install the Claude Code Skill that teaches the agent when to call recall/remember/read_smart |
-| `npx linksee-memory-stats` | Summary of the local DB (entity count / layer breakdown / top entities / top edited files). Add `--json` for machine-readable output. |
+| `npx -y linksee-memory sync` | Claude Code Stop-hook entry point |
+| `npx -y linksee-memory guard` | Re-injection guard hook: `PreToolUse` gate (`Edit`/`Write`/`Bash`) + `SessionStart` boot digest. Wired per-project (see [Re-injection Guard](#reinjection-guard)); fail-open. |
+| `npx -y linksee-memory import` | Batch-import Claude Code session JSONL history |
+| `npx -y linksee-memory install-skill` | Install the Claude Code Skill that teaches the agent when to call recall/remember/read_smart |
+| `npx -y linksee-memory stats` | Summary of the local DB (entity count / layer breakdown / top entities / top edited files). Add `--json` for machine-readable output. |
 
 ## The 6 memory layers
 
@@ -544,7 +573,7 @@ The conversation↔file linkage is the key. Every file edit captured by the Stop
 - ✅ Five MCP Blocks (Tools + Resources + Prompts + Sampling + Roots + Elicitation)
 - ✅ Stop-hook auto-capture for Claude Code
 - ✅ JP/EN trigram FTS5
-- ✅ One-command setup (`npx linksee-memory-setup`)
+- ✅ One-command setup (`npx -y linksee-memory setup`)
 - ✅ Structured memory v2 (3-axis classification: altitude × type × state)
 - ✅ Cross-LLM: Claude Code, Cursor, Windsurf, OpenAI Codex, Gemini CLI
 - ✅ Landing page ([linksee-site.vercel.app](https://linksee-site.vercel.app))
@@ -621,7 +650,7 @@ No account, no credit card, no API key. Just install and use.
    ```bash
    ls ~/.claude/skills/linksee-memory/SKILL.md
    ```
-   If absent, run `npx -y linksee-memory-install-skill`.
+   If absent, run `npx -y linksee-memory install-skill`.
 2. Restart Claude Code. Skills are indexed on session start.
 3. Check that the MCP is registered under the name `linksee` (the skill expects `mcp__linksee__*` tool names):
    ```bash
@@ -636,9 +665,9 @@ No account, no credit card, no API key. Just install and use.
 1. Check the hook log: `cat ~/.linksee-memory/hook.log`
 2. Run a manual test:
    ```bash
-   echo '{"session_id":"test","transcript_path":"/path/to/some.jsonl"}' | npx linksee-memory-sync
+   echo '{"session_id":"test","transcript_path":"/path/to/some.jsonl"}' | npx -y linksee-memory sync
    ```
-3. Make sure the `Stop` hook in `~/.claude/settings.json` points to `npx -y linksee-memory-sync` (not the old `-import`).
+3. Make sure the `Stop` hook in `~/.claude/settings.json` points to `npx -y linksee-memory sync` (not the old `-import`).
 </details>
 
 <details>
@@ -647,7 +676,7 @@ No account, no credit card, no API key. Just install and use.
 v0.0.6+ fixed the entity detection bug that collapsed all memories into the session's starting cwd. To re-index existing history with correct project attribution, run:
 
 ```bash
-npx linksee-memory-import --all
+npx -y linksee-memory import --all
 ```
 
 The importer is idempotent (wipes existing session data before re-inserting). Typical runtime: a few minutes for hundreds of sessions. Expect a dramatic improvement in `recall` precision afterward.
@@ -775,12 +804,23 @@ After install, in a new Claude session ask: *"Can you remember that I prefer Typ
 
 ## Changelog
 
-### v0.11.0 — The Map: `where_am_i` + `linksee-memory-map` (2026-06-15)
+### v0.11.2 — More cold-start hardening (2026-06-16)
+
+- **`stats` works on a fresh database** instead of crashing with `no such table` — it ensures the schema exists first (it may be the first command a new user runs).
+- **`map --help`** prints usage instead of trying to import a map.
+
+### v0.11.1 — Cold-start fixes (2026-06-16)
+
+- **Run any CLI through the package name:** `npx -y linksee-memory setup` (and `map`, `sync`, `guard`, `stats`, `import`, `install-skill`). A fresh user couldn't reach the standalone bins (`linksee-memory-setup`, …) via `npx` — npx resolves package names, not sibling bin names — so the one-command install 404'd. The main bin now dispatches subcommands; the standalone bins remain as aliases.
+- **`map` exits gracefully** with a next-step message when there's no `map.yaml` yet (was a raw stack trace — the exact state of a first-time user).
+- **serverInfo** now reports the real package version (was pinned to an old string).
+
+### v0.11.0 — The Map: `where_am_i` + `linksee-memory map` (2026-06-15)
 
 **Memory is the entry point; the product map is the new surface.** Drift detection grows up from individual anchors into a whole-product map you navigate from the CLI.
 
 - **`where_am_i`** (11th MCP tool) — locate the current topic/file on the Current Truth Map and get its blast radius. Call it with no args to auto-locate from your recent edits.
-- **`linksee-memory-map`** CLI — `where` · `affects` · `explain` · `status` · `next` · `reconcile` · `inspect --json` · `blueprint`. A `map.yaml` (git source of truth) describes how value reaches your user; the reconciler checks it against your code with file:line evidence. Bilingual: add `--lang ja`.
+- **`linksee-memory map`** CLI — `where` · `affects` · `explain` · `status` · `next` · `reconcile` · `inspect --json` · `blueprint`. A `map.yaml` (git source of truth) describes how value reaches your user; the reconciler checks it against your code with file:line evidence. Bilingual: add `--lang ja`.
 - Graded blast radius (`must fix together` / `should align` / `fyi`), declared-vs-reality verdicts, and an anti-graveyard guard for accounted-for drift.
 - Per-project keys so the Map handles many projects at once.
 
@@ -884,7 +924,7 @@ Based on one week of dogfooding, here's what changed:
 **New tools**
 - `update_memory` — atomic edit with preserved `memory_id`. Solves the "forget+remember breaks session_file_edits links" bug.
 - `list_entities` — fast "what do I know about?" primitive for session init. Supports `kind`/`min_memories` filters and returns layer breakdown.
-- `npx linksee-memory-stats` — local DB summary CLI.
+- `npx -y linksee-memory stats` — local DB summary CLI.
 
 **`recall` enhancements**
 - `match_reasons` array on each memory: e.g. `["content_match_fts", "heat:hot", "pinned"]`.

package/dist/bin/map-import.js

@@ -15,6 +15,7 @@
 //   linksee-memory-map blueprint             # stage×node board (colors reflect the live verdict)
 //   linksee-memory-map [--file map.yaml] [--root <repo>]
 import { join } from 'node:path';
+import { existsSync } from 'node:fs';
 import { openDb, runMigrations } from '../db/migrate.js';
 import { parseMapFile, importMap } from '../lib/map-import.js';
 import { blastRadius, getSuspects, getBlueprint, getNode, getProjectMeta, whereAmI } from '../lib/map-view.js';
@@ -38,8 +39,38 @@ for (let i = 0; i < argv.length; i++) {
 const sub = positionals[0] ?? 'import';
 const arg1 = positionals[1]; // the node-id / file / topic for explain|blast|affects|where
 const mapPath = flagValue(argv, 'file', join(process.cwd(), 'map.yaml'));
+if (argv.includes('--help') || argv.includes('-h') || sub === 'help') {
+    process.stdout.write(`linksee-memory map — navigate your product map (map.yaml) and catch drift\n\n` +
+        `Usage: npx -y linksee-memory map <command> [args]\n\n` +
+        `  where [<file>]    where am I? (no arg = infer from recent edits) → node + what it affects\n` +
+        `  explain <node>    why this status? — declared vs reality + file:line evidence + fix\n` +
+        `  affects <node>    what to change together if you touch this node\n` +
+        `  status            whole-project health % + what needs attention\n` +
+        `  next              the prioritized next fix candidate(s)\n` +
+        `  reconcile         re-check the map against the real code/files\n` +
+        `  inspect --json    machine-readable dump (CI / tooling)\n` +
+        `  blueprint         stage x node board (colors = live verdict)\n\n` +
+        `Flags: --file <map.yaml>  --root <repo>  --lang ja\n`);
+    process.exit(0);
+}
 const db = openDb();
 runMigrations(db);
+// Graceful exit when there's no map yet (the cold-user state) — never a raw stack trace.
+if (!existsSync(mapPath)) {
+    const ja = flagValue(argv, 'lang', 'en') === 'ja';
+    process.stderr.write(ja
+        ? `map.yaml が見つかりません（探した場所: ${mapPath}）\n\n` +
+            `プロダクトMapは手書き（またはスキャン生成）の map.yaml で、git が正本です。\n` +
+            `リポジトリのルートに作成してから、もう一度実行してください:\n` +
+            `  npx -y linksee-memory map status\n\n` +
+            `書式と例: https://docs.linksee.app/concepts/product-map\n`
+        : `No map.yaml found (looked in: ${mapPath})\n\n` +
+            `The product map is a map.yaml you hand-write (or scan-generate); git is the source of truth.\n` +
+            `Create one in your repo root, then run:\n` +
+            `  npx -y linksee-memory map status\n\n` +
+            `Format & examples: https://docs.linksee.app/concepts/product-map\n`);
+    process.exit(1);
+}
 const map = parseMapFile(mapPath);
 // Always (re)import first so reads reflect the file — map.yaml is authoritative.
 const res = importMap(db, map);

package/dist/bin/setup.js

@@ -2,9 +2,9 @@
 // setup: One-command setup for Linksee Memory — the "Use Linksee" installer.
 //
 // Usage:
-//   npx linksee-memory-setup          (interactive setup)
-//   npx linksee-memory-setup --yes    (accept all defaults, no prompts)
-//   npx linksee-memory-setup --dry-run
+//   npx linksee-memory setup          (interactive setup)
+//   npx linksee-memory setup --yes    (accept all defaults, no prompts)
+//   npx linksee-memory setup --dry-run
 //
 // Does four things:
 //   1. Registers the MCP server with Claude Code
@@ -35,9 +35,9 @@ if (showHelp) {
     console.log(`linksee-memory-setup — One-command setup for Linksee Memory
 
 Usage:
-  npx linksee-memory-setup          Interactive setup
-  npx linksee-memory-setup --yes    Accept all defaults, no prompts
-  npx linksee-memory-setup --dry-run Show what would happen
+  npx linksee-memory setup          Interactive setup
+  npx linksee-memory setup --yes    Accept all defaults, no prompts
+  npx linksee-memory setup --dry-run Show what would happen
 
 What it does:
   1. Registers linksee-memory MCP server with Claude Code
@@ -59,12 +59,14 @@ const __filename = fileURLToPath(import.meta.url);
 const SKILL_SRC = join(dirname(__filename), '..', 'skill', 'SKILL.md');
 const SERVER_NAME = 'linksee';
 const MCP_COMMAND = `claude mcp add -s user ${SERVER_NAME} -- npx -y linksee-memory`;
-const HOOK_COMMAND = 'npx -y linksee-memory-sync';
+// Subcommand form (npx -y linksee-memory <sub>) so the hooks resolve for a cold user —
+// npx can resolve the package name, but not sibling bin names like linksee-memory-sync.
+const HOOK_COMMAND = 'npx -y linksee-memory sync';
 // Re-injection guard — wired into the PROJECT (not user-global) settings, because it enforces THIS
 // project's accepted decisions. Mirrors the dogfood wiring's ${CLAUDE_PROJECT_DIR}/dist/bin path, but
 // points at the globally-installed `linksee-memory-guard` bin so it ships without a build step. Shell
 // form (resolved at run time) survives npx-cache eviction; a baked dist path would not.
-const GUARD_COMMAND = 'npx -y linksee-memory-guard';
+const GUARD_COMMAND = 'npx -y linksee-memory guard';
 const PROJECT_DIR = process.cwd();
 const PROJECT_CLAUDE_DIR = join(PROJECT_DIR, '.claude');
 const PROJECT_SETTINGS_PATH = join(PROJECT_CLAUDE_DIR, 'settings.json');
@@ -293,7 +295,7 @@ console.log('How it works:');
 console.log(`  ${DIM}• Every session is auto-captured (decisions, caveats, learnings)${RESET}`);
 console.log(`  ${DIM}• Agent auto-recalls past context when starting a task${RESET}`);
 console.log(`  ${DIM}• Memory is local-first (nothing leaves your machine)${RESET}`);
-console.log(`  ${DIM}• Works across Claude Code, Cursor, ChatGPT (cross-LLM)${RESET}`);
+console.log(`  ${DIM}• Works across Claude Code, Cursor, Windsurf, Codex, Gemini (cross-agent)${RESET}`);
 if (guardConfigured) {
     console.log(`  ${DIM}• Re-injection guard re-surfaces this project's accepted decisions before edits${RESET}`);
 }

package/dist/bin/stats.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 // linksee-memory-stats — summary of the local memory DB.
 // Usage:
-//   npx linksee-memory-stats
-//   npx linksee-memory-stats --json
-//   npx linksee-memory-stats --per-entity 10
+//   npx -y linksee-memory stats
+//   npx -y linksee-memory stats --json
+//   npx -y linksee-memory stats --per-entity 10
 //
 // Safe to run anytime (read-only).
 import { statSync } from 'node:fs';
-import { openDb, getDbPath } from '../db/migrate.js';
+import { openDb, runMigrations, getDbPath } from '../db/migrate.js';
 function parseArgs() {
     const argv = process.argv.slice(2);
     const a = { json: false, perEntity: 5, help: false };
@@ -68,6 +68,7 @@ function main() {
     }
     catch { /* no db yet */ }
     const db = openDb();
+    runMigrations(db); // ensure schema exists — `stats` may be the first command a fresh user runs
     const counts = {
         entities: db.prepare('SELECT COUNT(*) as c FROM entities').get().c,
         memories: db.prepare('SELECT COUNT(*) as c FROM memories').get().c,

package/dist/mcp/server.js

@@ -24,7 +24,49 @@ import { getTruthView, getDecisionDetail, resolveDrift } from '../lib/truth-engi
 import { declareAnchor, setNodeFields } from '../lib/drift-anchors.js';
 import { getReinjectionFriction, setGateMode } from '../lib/guard.js';
 import { whereAmI } from '../lib/map-view.js';
-const SERVER_VERSION = '0.10.0';
+import { readFileSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+// Single source of truth: read our own version from package.json so the MCP
+// serverInfo can never drift from the published package version. (We catch
+// doc/code drift for a living — our own version string shouldn't drift.)
+function readServerVersion() {
+    try {
+        const here = fileURLToPath(import.meta.url);
+        // dist/mcp/server.js → ../../package.json
+        const pkgPath = join(dirname(dirname(dirname(here))), 'package.json');
+        if (existsSync(pkgPath)) {
+            return String(JSON.parse(readFileSync(pkgPath, 'utf8')).version || '0.0.0');
+        }
+    }
+    catch { /* fall through */ }
+    return '0.0.0';
+}
+const SERVER_VERSION = readServerVersion();
+// ── Subcommand dispatch ───────────────────────────────────────────────────────
+// Each CLI ships as its own bin (linksee-memory-setup, …) AND as a subcommand of
+// the main bin, so `npx -y linksee-memory <sub>` works for a cold user: npx can
+// only resolve the package name (linksee-memory), not sibling bin names like
+// linksee-memory-setup. Run as the MCP server (no subcommand / stdio) → skip this.
+const SUBCOMMANDS = {
+    setup: 'setup.js',
+    map: 'map-import.js',
+    sync: 'sync-session.js',
+    guard: 'guard-hook.js',
+    stats: 'stats.js',
+    import: 'import-sessions.js',
+    'install-skill': 'install-skill.js',
+    declare: 'declare-anchor.js',
+    detect: 'detect-drift.js',
+};
+const subcommand = process.argv[2];
+if (subcommand && Object.prototype.hasOwnProperty.call(SUBCOMMANDS, subcommand)) {
+    // Spawn the target bin as a child (shebang-safe, argv/stdio correct) and exit with its code.
+    const binPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'bin', SUBCOMMANDS[subcommand]);
+    const r = spawnSync(process.execPath, [binPath, ...process.argv.slice(3)], { stdio: 'inherit' });
+    process.exit(r.status ?? (r.signal ? 1 : 0));
+}
 const db = openDb();
 runMigrations(db);
 // Auto-maintenance: consolidate stale memories on startup (non-blocking)
@@ -161,7 +203,7 @@ const TOOLS = [
     },
     {
         name: 'where_am_i',
-        description: 'Locate the current topic on the Current Truth Map and report "you are here" + blast radius — the per-turn re-anchor.\n\nReturns the matching Map node(s) + journey stage (発見→…→拡張), the BLAST RADIUS (what becomes suspect if you change this — the must-stay-consistent-with / should-align-with / realizes dependents; e.g. editing the README implicates the LP), and the decision behind the node (linked anchor), if any.\n\nThree ways to call:\n• NO ARGS → auto-locates from the files you JUST edited this session (the zero-effort re-anchor — call it freely as you work).\n• query: "<topic>" → lexical locate by topic.\n• node_id: "<id>" → exact node.\n\nThis is how you avoid optimizing one node while silently breaking its neighbors (change the spec → npm/Docs/LP must move too). Matching is lexical (no embeddings).\n\nWHEN TO CALL:\n• Right after editing files — call with no args to see what you just touched + its blast radius.\n• When the topic shifts — re-anchor to the new node.\n• When the user asks "what does changing X affect?" / "where does this fit?"',
+        description: 'Locate the current topic on the Current Truth Map and report "you are here" + blast radius — the per-turn re-anchor.\n\nReturns the matching Map node(s) + journey stage (discover → … → expand), the BLAST RADIUS (what becomes suspect if you change this — the must-stay-consistent-with / should-align-with / realizes dependents; e.g. editing the README implicates the LP), and the decision behind the node (linked anchor), if any.\n\nThree ways to call:\n• NO ARGS → auto-locates from the files you JUST edited this session (the zero-effort re-anchor — call it freely as you work).\n• query: "<topic>" → lexical locate by topic.\n• node_id: "<id>" → exact node.\n\nThis is how you avoid optimizing one node while silently breaking its neighbors (change the spec → npm/Docs/LP must move too). Matching is lexical (no embeddings).\n\nWHEN TO CALL:\n• Right after editing files — call with no args to see what you just touched + its blast radius.\n• When the topic shifts — re-anchor to the new node.\n• When the user asks "what does changing X affect?" / "where does this fit?"',
         inputSchema: {
             type: 'object',
             properties: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linksee-memory",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "mcpName": "io.github.michielinksee/linksee-memory",
   "description": "Local-first agent memory MCP — cross-agent brain with drift detection, 6-layer structured memory + token-saving file diff cache",
   "type": "module",