hmem-mcp 5.0.0 → 5.1.21

package/skills/hmem-read/SKILL.md

@@ -2,21 +2,25 @@
 name: hmem-read
 description: >
   Load long-term memory from hmem. Use when:
-  - User types /hmem-read or says "load memory", "check your memory", "was weißt du über..."
+  - User types /hmem-read or says "load memory", "check your memory", "what do you remember",
+    "show me the project", "continue where we left off", "was weißt du über..."
   - Starting work and you have no L1 summaries in context yet
   - After /compact or context reset, to reload knowledge
   - Before any significant work to anchor yourself with prior context
   - User asks about a specific project, error, or topic visible in L1 summaries
-  Calls read_memory() immediately. Also covers all read_memory query patterns:
-  search, prefix filter, context_for, stale detection, find_related, memory_stats, memory_health.
+  - User says "pick up where we left off", "what were we working on", "resume",
+    "Woran haben wir gearbeitet", "Was war der letzte Stand"
+  Calls read_memory() or load_project() immediately. Also covers all read_memory query
+  patterns: search, prefix filter, context_for, stale detection, find_related,
+  memory_stats, memory_health.
 ---
 
 # Load Memory — Choose Your Path
 
-When this skill is invoked, pick the right path based on your situation.
-Do NOT just read this document — execute a tool call immediately.
+When this skill is invoked, pick the right path and execute a tool call immediately.
+Do NOT just read this document — act.
 
-If the tool `read_memory` is not available, tell the user:
+If `read_memory` is not available, tell the user:
 "read_memory tool not found. Run `hmem init` to configure the MCP server."
 
 **Announcements:** If `read_memory` or `hmem-sync pull` shows urgent announcements
@@ -26,43 +30,55 @@ server migrations, or breaking updates that must be handled first.
 
 ---
 
-## Path A: Fresh Session Start (no context yet)
+## Path A: Start Working on a Project (primary workflow)
 
-Start by seeing what projects exist, then focus:
+Use `load_project` as the single entry point. It activates the project, returns the full
+briefing (L2 content + L3 titles), and shows recent O-entries with full L4/L5 user/agent
+exchanges — so you see exactly what happened in previous sessions, not just titles.
 
-```
-# Step 1: Quick project overview (~200 tokens)
-read_memory(titles_only=true, prefix="P")
-```
-
-This shows all projects as one-liners. Then:
+- **User mentioned a project** → load it directly:
+  ```
+  load_project(id="P0037")
+  ```
+  This replaces the old pattern of `update_memory(active=true)` + `read_memory()`.
+  One call gives you everything: project structure, open tasks, and recent session history.
 
-- **If the user mentioned a project** → activate it and load full context:
+- **Unclear which project** → list projects first, then load:
   ```
-  update_memory(id="P0037", active=true)     # mark project as active
-  read_memory()                                # bulk read, filtered by active project
+  read_memory(titles_only=true, prefix="P")   # ~200 tokens overview
   ```
+  Then ask the user or pick the most relevant one, and call `load_project(id="P00XX")`.
 
-- **If working on a new project** → create it first, then read:
+- **New project** → create it first, then load:
   ```
-  write_memory(prefix="P", content="New project: ...", tags=["#project-name"])
-  update_memory(id="P00XX", active=true)
-  read_memory()
+  write_memory(prefix="P", content="New project: ...")   # → P00XX
+  load_project(id="P00XX")
   ```
 
-- **If unclear what to work on** → load everything:
+- **No specific project** → load everything:
   ```
-  read_memory()                                # full bulk read, all projects
+  read_memory()   # full bulk read, all projects
   ```
 
-The bulk read returns memories **grouped by category** with smart expansion:
-- **Expanded entries** (newest, most-accessed, favorites): show L2 children + links
-- **Non-expanded entries**: latest child + `[+N more → ID]` hint
-- **Active-prefix filtering**: entries in active projects get full expansion, others title-only
+### What load_project returns
+
+The response includes:
+- **L2 content + L3 titles** — the complete project briefing (~700 tokens)
+- **Recent O-entries with full exchanges** — configurable via `recentOEntries` in config
+  (default: 10). Each O-entry contains the actual L4/L5 user/agent messages, not just
+  summaries. This is your continuity — read them to understand where the last session
+  left off.
+
+### Why load_project over read_memory
+
+`read_memory()` shows a cross-project overview optimized for breadth. `load_project`
+goes deep on one project — it activates it, filters related entries, and includes session
+history. Use `load_project` when you know which project to work on; use `read_memory`
+when you need orientation across all projects.
 
 ## Path B: After Context Compression (/compact)
 
-You still have the recent conversation in memory — you don't need the newest entries again.
+You still have the recent conversation — you do not need the newest entries again.
 Load the long-term knowledge that was lost during compression:
 
 ```
@@ -72,116 +88,96 @@ read_memory(mode="essentials")
 Essentials mode prioritizes favorites, most-accessed, and pinned entries over newest.
 This is your "recover what matters" call — rules, decisions, error patterns, key references.
 
-If you need a specific project's full context:
+For a specific project's full context:
 ```
 read_memory(context_for="P0029")
 ```
 
 ## Path C: User Asks About a Specific Topic
 
-When the user asks about something you can see in your L1 summaries:
+When the user asks about something visible in your L1 summaries:
 
 ```
-# User: "Was weißt du über das hmem Projekt?"
+# "Was weißt du über das hmem Projekt?"
 read_memory(context_for="P0029")
 
-# User: "Tell me about that Heimdall error"
+# "Tell me about that Heimdall error"
 read_memory(context_for="E0090")
 ```
 
-`context_for` loads the entry expanded + all related entries (via links and weighted tag scoring)
-in a single call. The `min_tag_score` parameter controls strictness (default: 5). Raise for fewer results:
+`context_for` loads the entry expanded + all related entries (via links and weighted tag
+scoring) in a single call. Raise `min_tag_score` for fewer results:
 
 ```
-read_memory(context_for="P0029", min_tag_score=7)  # stricter — only strong matches
+read_memory(context_for="P0029", min_tag_score=7)   # stricter — only strong matches
 ```
 
 ---
 
-## Adapt Communication to User Skill Level
-
-After loading memory, check H-prefix entries for **User Skill Assessments** (e.g. H0010 "User Skill: IT").
-These contain 1-10 scores per subtopic — adapt your language accordingly:
-
-- **1-4**: Explain concepts, avoid jargon, use analogies
-- **5-6**: Brief explanations, some jargon OK
-- **7-8**: Direct technical language, skip basics
-- **9-10**: Peer-level discussion, challenge assumptions
+## Bulk Read Design
 
-If no skill assessment exists yet, create one based on the user's vocabulary and questions
-(see hmem-write skill for the H-prefix convention).
+`read_memory()` shows **current context** — newest entries, most-accessed favorites, open
+tasks. It is not a full dump. Older entries with low access_count are intentionally omitted.
 
----
+**Expanded entries** (newest, most-accessed, favorites): show L2 children + links.
+**Non-expanded entries**: latest child + `[+N more → ID]` hint.
+**Active-prefix filtering**: entries in active projects get full expansion, others title-only.
 
-## After loading — proactive cleanup
+**For older or broader knowledge:**
 
-Only on the **first read of a session** (not after every read). Scan L1 summaries and flag:
+```
+read_memory(titles_only=true, prefix="L")   # all lesson titles as table of contents
+read_memory(search="SQLite corruption")      # semantic search
+read_memory(tag="#sqlite")                   # hashtag filter
+```
 
-- **Wrong** → write correction first, then `update_memory(id="E0023", content="Wrong — see [✓E0076]", obsolete=true)`
-- **Noise** → `update_memory(id="T0005", irrelevant=true)` or `update_many(ids=["T0005", "T0012"], irrelevant=true)`
-- **Important** → `update_memory(id="S0001", favorite=true)`
+**Tags are hidden by default** — use `read_memory(curator=true)` to see hashtags on entries.
 
-For a thorough review, use the `/hmem-self-curate` skill.
+Repeated bulk reads without a goal yield little new information after 3-4 iterations — use
+targeted search or a prefix overview instead.
 
 ---
 
-## Bulk Read Design Intent
-
-`read_memory()` shows **current context** — newest entries, most-accessed favorites, open tasks. It is not a full dump. Older entries with low access_count are intentionally omitted.
+## Title vs. Body (v5.1+)
 
-**For older or broader knowledge:**
-
-```
-# All lesson titles as table of contents (one line per entry)
-read_memory(titles_only=true, prefix="L")
-
-# Semantic search
-read_memory(search="SQLite corruption")
-
-# Hashtag filter
-read_memory(tag="#sqlite")
-```
+Every node has a **title** (short navigation label) and an optional **body** (detail shown on drill-down). This affects what you see in different read modes:
 
-**Tags are hidden by default** — hashtags are only shown when `curator=true` is set. This saves tokens in normal reads. Use `read_memory(curator=true)` when you need to see or verify tags on entries.
+| Mode | Shows |
+|------|-------|
+| `titles_only=true` | Title only — compact table of contents |
+| Default (by ID) | Title + body for requested node, children as title-only |
+| `expand=true` | Title + body recursively for all nodes |
+| Bulk reads | Title only for L1, expanded entries show L2 titles |
 
-Repeated bulk reads without a goal yield little new information after 3–4 iterations — use targeted search or a prefix overview instead.
+Entries written with the `>` body format have explicit title/body separation. Older entries without `>` show auto-extracted titles (~50 chars) — the full text is still accessible on drill-down.
 
 ---
 
-## Lazy Loading Protocol (for subsequent reads)
+## Lazy Loading Protocol (subsequent reads)
 
-After the initial `read_memory()`, use these patterns to drill deeper:
+After the initial load, drill deeper with these patterns:
 
 ```
-# Filter by category
-read_memory(prefix="E")          # only errors
-read_memory(store="company")     # shared company knowledge
-
-# Expand a root entry → shows L2 children
-read_memory(id="E0042")
-
-# Expand an L2 node → shows L3 children
-read_memory(id="E0042.2")
-
-# Expand further (rarely needed)
-read_memory(id="E0042.2.1")
+read_memory(prefix="E")           # only errors
+read_memory(store="company")      # shared company knowledge
+read_memory(id="E0042")           # expand root → shows L2 children
+read_memory(id="E0042.2")         # expand L2 → shows L3 children
+read_memory(id="E0042.2.1")       # expand further (rarely needed)
 ```
 
 **Compact table of contents:**
 
 ```
-read_memory(titles_only=true)              # all entries as compact ID + date + title listing
-read_memory(titles_only=true, prefix="L")  # only lessons
+read_memory(titles_only=true)                # all entries, one line each
+read_memory(titles_only=true, prefix="L")    # only lessons
 ```
 
-V2 selection still applies (only newest + most-accessed + favorites shown), but without L2 children or links — just one line per entry with `(N)` child count hints.
-
-**Rule: depth parameter is useful for listings (max 4), not for ID queries.**
+**Depth parameter** — useful for listings (max 4), not for ID queries:
 
 ```
-read_memory(depth=2)             # all entries with L2 children
-read_memory(prefix="L", depth=2) # all lessons with details
-read_memory(depth=4)             # deep dive — L2+L3+L4 (use sparingly, large output)
+read_memory(depth=2)              # all entries with L2 children
+read_memory(prefix="L", depth=2)  # all lessons with details
+read_memory(depth=4)              # deep dive L2+L3+L4 (large output, use sparingly)
 ```
 
 For L5 detail, drill into a specific node ID instead of using depth.
@@ -193,18 +189,11 @@ For L5 detail, drill into a specific node ID instead of using depth.
 Find entries created around a specific time or near another entry:
 
 ```
-# Entries created around 14:30 today (±2h window)
-read_memory(time="14:30")
-
-# Entries near a specific date + time
-read_memory(time="14:30", date="2026-02-20")
-
-# Custom window: only 1 hour before
-read_memory(time="14:30", period="-1h")
-
-# Entries created around the same time as P0001
-read_memory(time_around="P0001")
-read_memory(time_around="P0001", period="+2h")  # only after P0001
+read_memory(time="14:30")                        # ±2h window around 14:30 today
+read_memory(time="14:30", date="2026-02-20")     # specific date + time
+read_memory(time="14:30", period="-1h")           # custom window: only 1h before
+read_memory(time_around="P0001")                  # entries created near P0001
+read_memory(time_around="P0001", period="+2h")    # only after P0001
 ```
 
 ---
@@ -218,49 +207,60 @@ search_memory(query="auth token", scope="memories")
 
 ---
 
-## Show All Obsolete Entries
+## Original Context History (O-prefix)
 
-By default, bulk reads hide most obsolete entries (top 3 by access count shown). To see all:
+O-entries store raw session context with progressive summarization. They are created
+**automatically** by the Stop hook — every user/agent exchange is recorded as an O-entry
+without manual intervention. When you switch projects, a new O-entry is started
+automatically (project-based O-entries).
+
+O-entries are hidden from bulk reads but searchable. Use them when you need the original
+reasoning behind a decision or the full conversation that led to an entry:
 
 ```
-read_memory(show_obsolete=true)
+read_memory(prefix="O")                                    # browse recent context
+read_memory(search="why did we choose per-node scoring")   # search across raw context
+read_memory(id="O0042", expand=true)                       # drill into specific entry
 ```
 
----
+O-entries are linked to curated entries (P/L/D/E) via tags, so `context_for` will
+surface relevant O-entries when their tags match.
 
-## Stale Detection
+**v5 checkpoint integration:** When `checkpointMode` is set to `"auto"`, a Haiku subagent
+reads recent O-entry exchanges at configurable intervals and automatically extracts
+L/D/E entries + writes a rolling checkpoint summary (`[CP]` node tagged `#checkpoint-summary`).
 
-Find entries you haven't accessed in a while — useful for curation:
+**What `load_project` shows:** For the latest O-entry, it displays:
+1. The most recent checkpoint summary (if available)
+2. Only raw exchanges AFTER the summary (minimum 5 exchanges guaranteed)
+3. Skill-dialog exchanges (brainstorming, TDD, etc.) are filtered out automatically
 
-```
-# Entries not accessed in 30 days (sorted oldest-access first)
-read_memory(stale_days=30)
+This keeps `load_project` compact even for long sessions. To see the full unfiltered
+history, use `read_memory(id="O0042", expand=true)`.
 
-# Filter: only stale lessons
-read_memory(stale_days=60, prefix="L")
-```
+The `recentOEntries` config parameter (default: 10) controls how many recent O-entries
+`load_project` includes.
 
 ---
 
-## Original Context History (O-prefix)
+## Show All Obsolete Entries
 
-O-entries store raw session context with progressive summarization (created by `flush_context`).
-They are hidden from bulk reads but searchable — use when you need the original reasoning
-behind a decision or the full conversation that led to an entry:
+By default, bulk reads hide most obsolete entries (top 3 by access count shown). To see all:
 
 ```
-# Browse recent context entries
-read_memory(prefix="O")
+read_memory(show_obsolete=true)
+```
 
-# Search across raw context
-read_memory(search="why did we choose per-node scoring")
+---
 
-# Drill into a specific context entry (L1→L2→L5 linear chain)
-read_memory(id="O0042", expand=true)
-```
+## Stale Detection
 
-O-entries are linked to curated entries (P/L/D/E) via tags, so `context_for` will
-surface relevant O-entries when their tags match.
+Find entries not accessed in a while — useful for curation:
+
+```
+read_memory(stale_days=30)                # sorted oldest-access first
+read_memory(stale_days=60, prefix="L")    # only stale lessons
+```
 
 ---
 
@@ -269,42 +269,68 @@ surface relevant O-entries when their tags match.
 Quick overview of your memory health:
 
 ```
-memory_stats()                   # personal store
-memory_stats(store="company")    # company store
+memory_stats()                    # personal store
+memory_stats(store="company")     # company store
 ```
 
-Output includes: total entries by prefix, total nodes, favorites count, pinned count, unique hashtags, stale count (>30d), oldest entry, and top 5 most-accessed entries.
+Output includes: total entries by prefix, total nodes, favorites count, pinned count,
+unique hashtags, stale count (>30d), oldest entry, and top 5 most-accessed entries.
 
 ---
 
 ## Find Related
 
-Find entries similar to a given entry via FTS5 keyword matching — useful to spot potential duplicates or discover thematic connections:
+Find entries similar to a given entry via FTS5 keyword matching — spots potential
+duplicates or thematic connections:
 
 ```
-find_related(id="P0029")          # up to 5 similar entries
+find_related(id="P0029")            # up to 5 similar entries
 find_related(id="L0042", limit=10)
 ```
 
-Returns title-only list of entries with overlapping keywords (different from `relatedEntries` in ID reads which uses shared tags).
+Returns title-only list with overlapping keywords (different from `relatedEntries` in
+ID reads which uses shared tags).
 
 ---
 
 ## Memory Health Audit
 
-Check your memory for structural issues before/after curation:
+Check memory for structural issues before/after curation:
 
 ```
-memory_health()                   # personal store
+memory_health()                    # personal store
 memory_health(store="company")
 ```
 
-Checks:
-- **Broken links** — links pointing to deleted entries
-- **Orphaned entries** — root entries with no sub-nodes (never expanded)
-- **Stale favorites/pinned** — not accessed in >60 days
-- **Broken obsolete chains** — `[✓ID]` pointing to non-existent entries
-- **Tag orphans** — `memory_tags` rows with no matching entry/node
+Checks: broken links, orphaned entries, stale favorites/pinned, broken obsolete chains,
+tag orphans.
+
+---
+
+## Adapt Communication to User Skill Level
+
+After loading memory, check H-prefix entries for **User Skill Assessments** (e.g. H0010).
+These contain 1-10 scores per subtopic — adapt your language accordingly:
+
+- **1-4**: Explain concepts, avoid jargon, use analogies
+- **5-6**: Brief explanations, some jargon OK
+- **7-8**: Direct technical language, skip basics
+- **9-10**: Peer-level discussion, challenge assumptions
+
+If no skill assessment exists yet, create one based on the user's vocabulary and questions
+(see hmem-write skill for the H-prefix convention).
+
+---
+
+## After Loading — Proactive Cleanup
+
+Only on the **first read of a session** (not after every read). Scan L1 summaries and flag:
+
+- **Wrong** → write correction first, then `update_memory(id="E0023", content="Wrong — see [✓E0076]", obsolete=true)`
+- **Noise** → `update_memory(id="T0005", irrelevant=true)` or `update_many(ids=["T0005","T0012"], irrelevant=true)`
+- **Important** → `update_memory(id="S0001", favorite=true)`
+
+For a thorough review, use the `/hmem-self-curate` skill.
 
 ---
 
@@ -313,10 +339,12 @@ Checks:
 | Wrong | Right |
 |-------|-------|
 | `read_memory()` after /compact | `read_memory(mode="essentials")` — you already have recent context |
-| Blind bulk read at session start | `read_memory(titles_only=true, prefix="P")` first → pick project → `read_memory()` |
+| `update_memory(active=true)` + `read_memory()` | `load_project(id="P00XX")` — one call does both |
+| Blind bulk read at session start | `read_memory(titles_only=true, prefix="P")` first, then `load_project` |
 | `read_memory(id="E0042", depth=3)` | `read_memory(id="E0042.2")` — branch by branch |
 | Load everything without purpose | Check L1 first, then expand selectively |
-| Read .hmem file directly | Always use MCP tools — it's a SQLite binary |
-| Just display this skill text | **Call a read_memory variant immediately** |
+| Read .hmem file directly | Always use MCP tools — it is a SQLite binary |
+| Just display this skill text | **Call a read_memory or load_project variant immediately** |
 | `update_memory(id="X", obsolete=true)` without `[✓ID]` | Write correction first, then mark obsolete with `[✓ID]` tag |
 | Repeated `read_memory()` to find old entries | `read_memory(titles_only=true, prefix="L")` or `read_memory(search="...")` |
+| Manually creating O-entries | O-entries are auto-logged by the Stop hook — do not create them manually |

package/skills/hmem-release/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: hmem-release
+description: >
+  Pre-publish checklist for hmem-mcp releases. Ensures all skills are updated,
+  version is bumped, tests pass, and nothing is forgotten. Use before every
+  npm publish of hmem-mcp — when the user says "publish", "release", "publishen",
+  "neue Version", or when you're about to run npm publish on the hmem repo.
+---
+
+# /hmem-release — Release Checklist
+
+Run this checklist before every `npm publish` of hmem-mcp. Every release touches code, skills, config, and documentation — this skill ensures nothing falls through the cracks.
+
+---
+
+## Step 1: Version Bump
+
+```bash
+npm version patch --no-git-tag-version  # or minor/major as appropriate
+```
+
+Decide the version type based on what changed:
+- **patch**: bugfixes, skill text updates, small improvements
+- **minor**: new features (new tools, new prefix, new config options, new skills)
+- **major**: breaking changes (schema changes, removed tools, API changes)
+
+---
+
+## Step 2: Build & Type Check
+
+```bash
+npx tsc --noEmit   # type check first (fast)
+npx tsc             # full build
+```
+
+Fix any errors before proceeding.
+
+---
+
+## Step 3: Skill Audit
+
+Every code change can affect skill documentation. Check each skill against the current code:
+
+| Skill | Check for | Common triggers |
+|-------|-----------|-----------------|
+| **hmem-write** | write_memory format, body syntax (`>`), char limits, tag rules | Changes to `parseTree`, `write()`, validation logic |
+| **hmem-read** | read_memory output format, load_project display, O-entry format | Changes to `formatBulkRead`, `formatRecentOEntries`, `load_project` rendering |
+| **hmem-config** | New config parameters, changed defaults, removed options | Changes to `HmemConfig` interface, `DEFAULT_CONFIG`, `loadHmemConfig` |
+| **hmem-update** | New migration steps, new post-update checks | Any schema change, new features that need post-update setup |
+| **hmem-curate** | Curation rules, new node types, new tags | New tagged node types (#checkpoint-summary, #skill-dialog), schema changes |
+| **hmem-self-curate** | Same as curate but for agent self-curation | Same triggers as hmem-curate |
+| **hmem-new-project** | P-entry schema (R0009), write_memory format | Changes to P-entry structure or write format |
+| **hmem-setup** | Hook scripts, init flow, MCP config format | Changes to hooks, CLI commands, environment variables |
+| **hmem-wipe** | Checkpoint references, context threshold | Changes to checkpointMode, contextTokenThreshold |
+| **hmem-sync-setup** | Sync config format, sync commands | Changes to sync parsing, hmem-sync integration |
+
+**How to check:** For each skill, grep for key terms from the code change:
+```bash
+grep -l "relevant_term" skills/*/SKILL.md
+```
+
+If a skill references something you changed, read and update it.
+
+---
+
+## Step 4: Config Schema Check
+
+If you added new config parameters:
+1. Added to `HmemConfig` interface? (hmem-config.ts)
+2. Added to `DEFAULT_CONFIG`? (hmem-config.ts)
+3. Parsing logic in `loadHmemConfig`? (hmem-config.ts)
+4. Added to `MEMORY_KEYS` set? (hmem-config.ts)
+5. Included in `saveHmemConfig` output? (hmem-config.ts)
+6. Documented in **hmem-config** skill?
+
+---
+
+## Step 5: Prefix Check
+
+If you added or changed prefixes:
+1. Added to `DEFAULT_PREFIXES`? (hmem-config.ts)
+2. Added to `DEFAULT_PREFIX_DESCRIPTIONS`? (hmem-config.ts)
+3. Documented in **hmem-write** skill (prefix list)?
+4. Documented in **hmem-read** skill?
+
+---
+
+## Step 6: Tool Parameter Check
+
+If you changed MCP tool parameters (added, removed, changed types):
+1. Zod schema updated in mcp-server.ts?
+2. Using `z.coerce.boolean()` for booleans (not `z.boolean()`)?
+3. Tool description updated?
+4. Affected skills updated?
+
+---
+
+## Step 7: Migration Check
+
+If the release introduces schema changes:
+1. `MIGRATIONS` array updated in hmem-store.ts? (ALTER TABLE for new columns)
+2. **hmem-update** skill documents the migration step?
+3. Auto-migration tested with an old DB?
+
+---
+
+## Step 8: Commit & Publish
+
+```bash
+git add src/ skills/ package.json package-lock.json
+git commit -m "feat/fix: description
+
+Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>"
+npm publish
+git push
+```
+
+---
+
+## Step 9: Post-Publish
+
+1. Verify on npm: `npm view hmem-mcp version`
+2. Sync to devices: `hmem-sync push` (if applicable)
+3. Update hmem P-entry protocol: `append_memory(id="P0048.7", content="\tHandoff: v5.x.x released...")`
+4. Notify user via Telegram if relevant
+
+---
+
+## Quick Reference: What changed → What to check
+
+| Code area | Skills to check |
+|-----------|----------------|
+| hmem-store.ts (write/read) | hmem-write, hmem-read, hmem-curate |
+| hmem-store.ts (O-entries) | hmem-read, hmem-self-curate, hmem-curate |
+| hmem-config.ts | hmem-config, hmem-update, hmem-setup |
+| mcp-server.ts (tools) | hmem-write, hmem-read (tool params) |
+| mcp-server.ts (load_project) | hmem-read, hmem-new-project |
+| cli-checkpoint.ts | hmem-config (checkpoint docs), hmem-read (summary docs) |
+| cli-log-exchange.ts | hmem-setup (hook docs) |
+| cli-context-inject.ts | hmem-wipe, hmem-setup |
+| Any new skill added | hmem-update (list of skills to sync) |