Rename SemMem to MemoryAccess, JSON output format, post-compaction insight hooks

- Rename SemMemApp class and all references to MemoryAccessApp
- Update all legacy naming (sem-mem, Sem-Mem, brainspace) to memory-access
- Convert all MCP tool output from plain text to structured JSON
- Add UserPromptSubmit hook for automatic post-compaction insight storage
- Rework PreCompact hook to use marker file + <pending-insights> block
- Update tests to assert on JSON output
- Add publishing workflow docs to CLAUDE.md

Author: emmahyde

CLAUDE.md

@@ -4,7 +4,9 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## What This Is
 
-A semantic memory MCP server that stores intent-based knowledge for AI agents. Text is decomposed into atomic insights, classified into semantic frames, embedded as vectors, and stored in SQLite with a subject-indexed knowledge graph.
+**memory-access** — a semantic memory MCP server that stores intent-based knowledge for AI agents. Text is decomposed into atomic insights, classified into semantic frames, embedded as vectors, and stored in SQLite with a subject-indexed knowledge graph.
+
+> **Naming:** The canonical name is `memory-access`. All old references to `sem-mem`, `semantic-memory`, `SemMem`, or `brainspace` are deprecated and should be updated to `memory-access` / `MemoryAccessApp`.
 
 ## Commands
 
@@ -37,7 +39,7 @@ uv run memory-access
 - **`normalizer.py`** — LLM decomposition/classification via Anthropic API (or Bedrock). Uses `DECOMPOSE_PROMPT` and `CLASSIFY_PROMPT`
 - **`embeddings.py`** — Embedding generation (OpenAI or Bedrock Titan), L2-normalized float32 vectors. `create_embedding_engine()` factory selects provider.
 - **`storage.py`** — `InsightStore` class: SQLite persistence, migration system, subject indexing, knowledge graph queries
-- **`server.py`** — `SemMemApp` orchestrator + MCP tool definitions (9 tools: `store_insight`, `search_insights`, `list_insights`, `update_insight`, `forget`, `search_by_subject`, `related_insights`, `add_subject_relation`, `get_subject_relations`)
+- **`server.py`** — `MemoryAccessApp` orchestrator + MCP tool definitions (9 tools: `store_insight`, `search_insights`, `list_insights`, `update_insight`, `forget`, `search_by_subject`, `related_insights`, `add_subject_relation`, `get_subject_relations`)
 
 ### Database
 
@@ -70,6 +72,10 @@ Migrations are Python functions in `storage.py` (named `_migrate_NNN_*`), tracke
 - `BEDROCK_EMBEDDING_MODEL` — Bedrock embedding model ID (default: `amazon.titan-embed-text-v2:0`)
 - `BEDROCK_LLM_MODEL` — Bedrock Claude model ID (default: `us.anthropic.claude-haiku-4-5-20251001-v1:0`)
 
+## Publishing
+
+The git workflow automatically publishes to PyPI. To release a new version, just push a commit to the `main` branch of the memory-access repo. The GitHub Actions release workflow bumps versions in both `pyproject.toml` and `.claude-plugin/plugin.json` and publishes.
+
 ## Plugin
 
-This repo is also a Claude Code plugin (`claude plugin install memory-access@emmahyde`). Plugin files live at the repo root: `.claude-plugin/`, `skills/`, `hooks/`. Includes a `using-semantic-memory` skill and a `PreCompact` hook.
+This repo is also a Claude Code plugin (`claude plugin install memory-access@emmahyde`). Plugin files live at the repo root: `.claude-plugin/`, `skills/`, `hooks/`. Includes a `using-semantic-memory` skill, a `PreCompact` hook for insight preservation, and a `UserPromptSubmit` hook for post-compaction insight storage.

commands/setup-memory-access.md

@@ -4,7 +4,7 @@ description: Interactive wizard to install and configure the memory-access MCP s
 allowed-tools: ["Bash", "Read", "Edit", "Write", "AskUserQuestion"]
 ---
 
-# Setup Sem-Mem
+# Setup Memory-Access
 
 Walk the user through installing and configuring the memory-access semantic memory system. Execute each step sequentially, reporting progress as you go.
 

docs/plans/2026-02-07-knowledge-bases.md

@@ -438,21 +438,21 @@ git commit -m "feat: add Ingestor with crawl → split → normalize → embed 
 
 ---
 
-### Task 5: SemMemApp KB Methods + MCP Tools
+### Task 5: MemoryAccessApp KB Methods + MCP Tools
 
 **Files:**
 - Modify: `src/memory_access/server.py`
 - Modify: `tests/test_server.py`
 
-**Step 1: Add KB methods to `SemMemApp`**
+**Step 1: Add KB methods to `MemoryAccessApp`**
 
 Add to the class:
 - `search_knowledge_base(query, kb_name="", limit=5) -> str` — embed query, search kb_chunks (optionally filtered by KB name via `get_kb_by_name`), format results
 - `list_knowledge_bases() -> str` — list all KBs with descriptions and chunk counts
 
 **Step 2: Update `create_app` to accept crawl service config**
 
-Add `crawl_service` parameter to `create_app()`. Store on `SemMemApp` for use by CLI (not by MCP tools directly — ingestion happens via CLI, not MCP).
+Add `crawl_service` parameter to `create_app()`. Store on `MemoryAccessApp` for use by CLI (not by MCP tools directly — ingestion happens via CLI, not MCP).
 
 **Step 3: Add MCP tools to `create_mcp_server`**
 
@@ -472,7 +472,7 @@ async def list_knowledge_bases() -> str:
 
 **Step 4: Add tests to `tests/test_server.py`**
 
-Test the new `SemMemApp` methods with mocked store/embeddings. Verify `search_knowledge_base` formats results correctly. Verify `list_knowledge_bases` returns formatted list.
+Test the new `MemoryAccessApp` methods with mocked store/embeddings. Verify `search_knowledge_base` formats results correctly. Verify `list_knowledge_bases` returns formatted list.
 
 **Step 5: Commit**
 

hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "Sem-Mem hooks — preserves knowledge before context compaction",
+  "description": "memory-access hooks — preserves knowledge before and after context compaction",
   "hooks": {
     "PreCompact": [
       {
@@ -12,6 +12,18 @@
           }
         ]
       }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/check-pending-insights.sh",
+            "timeout": 5
+          }
+        ]
+      }
     ]
   }
 }

hooks/scripts/check-pending-insights.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+# UserPromptSubmit hook: Check for pending insights from a pre-compaction cycle.
+#
+# If the marker file exists, a compaction recently occurred and the compaction
+# summary should contain a <pending-insights> block. Emit a system message
+# telling the agent to extract and store them, then clean up the marker.
+
+set -euo pipefail
+
+MARKER_FILE="$HOME/.claude/memory-access/insights-pending"
+
+if [ ! -f "$MARKER_FILE" ]; then
+  # No pending insights — no-op
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# Remove marker immediately to prevent re-triggering on subsequent messages
+rm -f "$MARKER_FILE"
+
+cat <<'INSTRUCTION'
+{
+  "continue": true,
+  "systemMessage": "POST-COMPACTION INSIGHT STORAGE: A compaction just occurred and your context summary should contain a <pending-insights> block with insights to preserve.\n\nYour task: spawn a BACKGROUND agent to store these insights. Do this silently without disrupting the user's request.\n\n1. Parse the <pending-insights> block from your current context\n2. For each insight, call `store_insight` with the text, domain, and any git context fields\n3. For any structural relationships mentioned, call `add_subject_relation`\n4. If no <pending-insights> block is found in your context, skip silently\n\nUse: Task(subagent_type=\"general-purpose\", model=\"haiku\", run_in_background=true, prompt=\"...\")\n\nIMPORTANT: Do not let this interfere with the user's actual request. Handle it as a background task and proceed with whatever the user asked."
+}
+INSTRUCTION

hooks/scripts/pre-compact.sh

@@ -1,32 +1,27 @@
 #!/bin/bash
-# PreCompact hook: Extract and store insights from the current conversation
-# before context compaction occurs. This preserves knowledge that would
-# otherwise be lost when the conversation window is compacted.
+# PreCompact hook: Preserve knowledge before context compaction.
 #
-# Strategy: Read hook input, output a system message instructing Claude
-# to store key insights via memory-access MCP tools before compaction.
+# Strategy:
+# 1. Create a marker file so a post-compaction hook knows insights are pending
+# 2. Instruct the LLM to include insights in a structured <pending-insights>
+#    block within the compaction summary — these survive compaction and get
+#    stored automatically on the next user message.
 
 set -euo pipefail
 
 # Read hook input from stdin
 input=$(cat)
 
-# Extract transcript path from hook input
-transcript_path=$(echo "$input" | jq -r '.transcript_path // empty')
+# Create marker file so post-compaction UserPromptSubmit hook can detect pending insights
+MARKER_DIR="$HOME/.claude/memory-access"
+MARKER_FILE="$MARKER_DIR/insights-pending"
+mkdir -p "$MARKER_DIR"
+touch "$MARKER_FILE"
 
-if [ -z "$transcript_path" ] || [ ! -f "$transcript_path" ]; then
-  # No transcript available — provide guidance without transcript content
-  cat <<'GUIDANCE'
-{
-  "systemMessage": "IMPORTANT — Pre-compaction knowledge preservation: Before this context is compacted, review the conversation for key insights, decisions, discoveries, and solutions. For each significant finding, call the `store_insight` MCP tool with appropriate domain tags and git context (repo, pr, author, project, task) if applicable. Focus on:\n1. Non-obvious technical decisions and their rationale\n2. Bug fixes and their root causes\n3. Architectural patterns discovered or established\n4. Solutions to problems that took multiple attempts\n5. Key facts about the codebase that were expensive to discover\n\nStore these BEFORE compaction occurs so they persist in semantic memory."
-}
-GUIDANCE
-  exit 0
-fi
-
-# Transcript exists — include a summary directive
+# System message instructs the LLM to embed insights in a structured block
+# within the compaction summary. The post-compaction hook will trigger storage.
 cat <<'GUIDANCE'
 {
-  "systemMessage": "IMPORTANT — Pre-compaction knowledge preservation: Before this context is compacted, review the conversation for key insights, decisions, discoveries, and solutions that should be preserved in semantic memory. For each significant finding, call the `store_insight` MCP tool with:\n- Descriptive text capturing the insight\n- Relevant domain tags (e.g., 'python,asyncio' or 'react,hooks')\n- Git context if applicable (repo, pr, author, project, task)\n- Source indicating this session\n\nPrioritize storing:\n1. Non-obvious technical decisions and WHY they were made\n2. Bug root causes and their fixes\n3. Architectural patterns discovered or established\n4. Solutions that took multiple attempts to find\n5. Key codebase facts that were expensive to discover\n6. Problem-resolution pairs (what broke and how it was fixed)\n\nAlso call `add_subject_relation` for any structural relationships discovered (e.g., repo contains project, person works_on project).\n\nDo this NOW before compaction loses this context."
+  "systemMessage": "IMPORTANT — Pre-compaction knowledge preservation.\n\nYou MUST include a <pending-insights> block in your compaction summary containing insights worth preserving. Format each insight as a line with text and domain:\n\n<pending-insights>\n- text: \"Description of the insight\" | domain: \"comma,separated,tags\"\n- text: \"Another insight\" | domain: \"relevant,domains\"\n</pending-insights>\n\nWhat to include:\n1. Non-obvious technical decisions and WHY they were made\n2. Bug root causes and their fixes (problem-resolution pairs)\n3. Architectural patterns discovered or established\n4. Solutions that took multiple attempts to find\n5. Key codebase facts that were expensive to discover\n6. Structural relationships (repo contains project, person works_on project)\n\nInclude git context (repo, pr, author, project) as additional fields if applicable:\n- text: \"...\" | domain: \"...\" | repo: \"org/repo\" | project: \"project-name\"\n\nThis block will be automatically processed after compaction to store insights in semantic memory. Do NOT skip this block — it is the ONLY way insights survive compaction."
 }
 GUIDANCE

skills/using-semantic-memory/SKILL.md

@@ -3,9 +3,9 @@ name: using-semantic-memory
 description: This skill should be used when the user asks to "store a memory", "remember this", "save this insight", "search memories", "find related insights", "what do I know about", "connect these concepts", "add a relationship", "traverse the knowledge graph", or when working with the memory-access MCP tools. Also activates when storing learnings, debugging knowledge, or building on prior insights.
 ---
 
-# Using Sem-Mem
+# Using Memory-Access
 
-Sem-Mem is a persistent knowledge graph MCP server that stores insights as normalized semantic frames with embeddings and typed subject relations. Use it to build durable knowledge that survives context compaction and spans sessions.
+Memory-Access is a persistent knowledge graph MCP server that stores insights as normalized semantic frames with embeddings and typed subject relations. Use it to build durable knowledge that survives context compaction and spans sessions.
 
 ## When to Use