musememory 1.6.1 → 1.7.1

package/.agents/skills/muse-brief/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: muse-brief
+description: Proactive daily briefing and knowledge hygiene governor. Scans decaying knowledge, audits policy staleness, tracks overdue due_at deadlines, and surfaces unresolved open loops with zero resident daemons.
+---
+
+# ⏰ Muse Brief (`muse-brief`)
+
+> **When to use**: Execute at the start of a workday, during daily standup/planning, or when performing knowledge hygiene and backlog triage.
+
+---
+
+## 🚀 Execution Workflow
+
+### Step 1: Generate Actionable Daily Briefing
+Run `memory briefing` (or execute via `memory routine run daily-briefing`):
+
+```bash
+memory briefing --limit 10
+```
+
+The briefing renders a clean Markdown summary containing:
+1. **Fresh Insights**: Recently confirmed architectural decisions and bug fixes.
+2. **Upcoming & Overdue Items**: Entries with `due_at` timestamps requiring attention.
+3. **Active Constraints**: Current rules in `.memory/CURRENT.md`.
+4. **Open Loops**: Extracted tasks and unresolved commitments from recent agent sessions.
+
+### Step 2: Run Staleness & Attention Audits
+Run `memory nudge` to inspect decaying knowledge:
+- **Policy Decay Check**: Flags fixes older than 90 days or operational rules older than 180 days.
+- **Action**: Prompt the user or agent to re-verify, mark stale (`memory mark-stale <id>`), or supersede with updated patterns.
+
+### Step 3: Run Routine Automation (Zero Daemon)
+Declare routine workflows in `.memory/routines.yaml`:
+
+```yaml
+routines:
+  - name: daily-hygiene
+    schedule: "0 9 * * 1-5"
+    commands:
+      - "memory nudge"
+      - "memory briefing"
+      - "memory wiki compile"
+```
+
+Install the crontab line via `memory routine install daily-hygiene` to run via system cron without any persistent background Node daemon.
+
+---
+
+## 🛡️ Invariant Rules for Agents
+
+- **Deterministic & Zero-Daemon**: Never launch a long-running background daemon process; execute on-demand or via cron.
+- **Actionable Output**: Highlight only actionable staleness warnings and open loops rather than dumping entire databases.
+
+---
+
+## 💻 CLI Equivalents (Zero-MCP Fallback)
+
+```bash
+# Generate daily briefing
+memory briefing
+
+# Surface overdue items and decaying knowledge
+memory nudge
+
+# Execute declared routine
+memory routine run daily-hygiene
+```

package/.agents/skills/muse-capture/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: muse-capture
+description: Autonomous post-fix and architectural decision distillation. Captures atomic, verified knowledge units with inline Vibeguard secret defense and supersedes outdated patterns.
+---
+
+# 🧠 Muse Capture (`muse-capture`)
+
+> **When to use**: Execute immediately after fixing a non-trivial bug, establishing an architectural pattern, learning an operational rule, or making a system decision.
+
+---
+
+## 🚀 Execution Workflow
+
+### Step 1: Verify Evidence Before Capturing
+Ensure the fix or decision has been verified with real build outputs, test runs, or command logs:
+- **Evidence Directive**: Do not propose speculative or unverified fixes.
+- **Verification Level**: Tag with `observed`, `reproducible`, `user-confirmed`, or `independently-verified`.
+
+### Step 2: Propose Atomic Memory Unit
+Call the `memory_capture` MCP tool:
+
+```json
+{
+  "title": "Fix SQLite Connection Pool Exhaustion under Bun Microtasks",
+  "content": "SQLite WAL mode with busy_timeout=5000ms prevents disk lock errors during concurrent microtask flushes. Use PRAGMA busy_timeout = 5000 in openDatabase.",
+  "project": "my-project",
+  "type": "fix",
+  "tags": ["sqlite", "bun", "concurrency"],
+  "salience": 0.9,
+  "verification": {
+    "level": "independently-verified",
+    "test_command": "bun test test/sqlite_concurrency.test.ts"
+  }
+}
+```
+
+### Step 3: Handle Knowledge Supersession (When Deprecating Old Knowledge)
+If the new fix or architecture replaces an outdated pattern:
+1. Identify the existing memory ID (e.g. `m_1700000001000_old_pool`).
+2. Call `memory_supersede` to atomically update bidirectional links:
+
+```json
+{
+  "old_id": "m_1700000001000_old_pool",
+  "new_id": "m_1700000002000_new_pool"
+}
+```
+
+---
+
+## 🛡️ Vibeguard Zero-Leakage Protocol
+
+- **Automatic Interception**: `memory_capture` automatically scans all proposed fields (title, content, tags, verification commands).
+- **Hard Rejection**: Any presence of AI API keys (`sk-*`), GitHub tokens (`ghp_*`), AWS keys (`AKIA*`), private keys, or passwords will immediately throw an error.
+- **Sanitization Directive**: Always redact secrets to `[REDACTED_SECRET]` before proposing.
+
+---
+
+## 💻 CLI Equivalents (Zero-MCP Fallback)
+
+```bash
+# Propose a new candidate memory
+memory capture "Fix details" --title "Title" --project my-project --type fix
+
+# Confirm a candidate memory
+memory confirm <id>
+
+# Supersede an old memory with a confirmed replacement
+memory supersede <old_id> --with <new_id>
+```

package/.agents/skills/muse-current/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: muse-current
+description: Active working constraints and interruption-proof session handoff manager. Synchronizes hard invariants, open loops, and in-flight checkpoints directly into CURRENT.md.
+---
+
+# 📐 Muse Current (`muse-current`)
+
+> **When to use**: Execute when the user establishes a hard project invariant, when starting a multi-step task, or before context compaction/task switching to record in-flight handoffs.
+
+---
+
+## 🚀 Execution Workflow
+
+### Step 1: Record Hard Constraints
+When a non-negotiable rule or invariant is declared:
+Call `memory_current` or `memory_capture(type="constraint")`:
+
+```json
+{
+  "action": "append",
+  "text": "- Invariant: Never allow cross-origin POST mutations without Origin header check (CSRF defense)."
+}
+```
+
+This immediately updates `.memory/CURRENT.md` and dual-persists a constraint memory in SQLite.
+
+### Step 2: Record Interruption-Proof Session Handoffs
+When completing a subtask, hitting context limits, or preparing for the next agent:
+Append a structured handoff block to `CURRENT.md`:
+
+```markdown
+## Active Handoff & Session Checkpoint
+- **Goal**: Migrate SQLite WAL connection pool to asynchronous microtask flushes.
+- **Completed**:
+  - Implemented async query worker in `src/sqlite/worker.ts`.
+  - Added unit test suite `test/sqlite_worker.test.ts`.
+- **In-Flight / Next Steps**:
+  - Wire worker into `src/store.ts` save transaction.
+  - Run full suite: `bun test`.
+```
+
+### Step 3: Clear Resolved Invariants
+When a temporary constraint or migration phase is complete, update `CURRENT.md` to prune obsolete rules so future context windows stay lightweight.
+
+---
+
+## 🛡️ Invariant Rules for Agents
+
+- **High Locality**: `CURRENT.md` must contain only active, high-priority invariants and current handoffs—not historical archives.
+- **Zero Hallucination**: Do not contradict constraints recorded in `CURRENT.md`.
+
+---
+
+## 💻 CLI Equivalents (Zero-MCP Fallback)
+
+```bash
+# Read active working constraints
+memory current get
+
+# Append a new active constraint
+memory current set "- Hard constraint description" --project my-project
+```

package/.agents/skills/muse-graph/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: muse-graph
+description: AST code-aware symbol graph investigation and indexing. Integrates CodeGraph and Graphify to map codebase identifiers, auto-tag memories, and rank symbol-matching decisions with graph overlap bonuses.
+---
+
+# 🌐 Muse Graph (`muse-graph`)
+
+> **When to use**: Execute during deep codebase investigation, refactoring critical classes/modules, or diagnosing complex bugs where symbol-level architectural context is required.
+
+---
+
+## 🚀 Execution Workflow
+
+### Step 1: Check & Index AST Symbol Graph
+Verify provider status or build the cached AST symbol map:
+- Call `graph_status` MCP tool to check provider availability (`.codegraph` or `.graphify`).
+- Call `graph_index` MCP tool (or run `memory graph index`) to compile a fresh symbol map in `.memory/graph-symbols.json`.
+
+```json
+{}
+```
+
+### Step 2: Code-Aware Retrieval Queries
+When querying memories for a specific function, class, or type, include the exact identifier name in your query:
+
+```json
+{
+  "query": "queryContext knapsack token scoring formula in retrieval.ts",
+  "project": "my-project",
+  "token_budget": 1500
+}
+```
+
+### Step 3: Multi-Factor AST Overlap Scoring Bonus
+The retrieval engine matches query tokens against indexed symbols (`entry.graph.symbol_names`), awarding up to **+0.2 graph bonus**:
+
+$$\text{Score} = 1.0 \times \text{Applicability} + \text{StatusBonus} + \text{VerificationBonus} + \mathbf{GraphBonus (+0.2)} + \text{TimeDecay}$$
+
+Symbol-matching architectural decisions and past fixes rank above generic prose matching.
+
+---
+
+## 🛡️ Invariant Rules for Agents
+
+- **Opt-In & Non-Blocking**: If no AST graph provider is installed, memory queries and captures fall back gracefully with zero behavioral disruption.
+- **Affected Paths**: Inspect `entry.graph.affected_paths` to discover related files that may be impacted by a refactor.
+
+---
+
+## 💻 CLI Equivalents (Zero-MCP Fallback)
+
+```bash
+# Check provider status (provider type, availability, revision, symbol count)
+memory graph status
+
+# Index codebase AST symbols and cache to .memory/graph-symbols.json
+memory graph index
+
+# Search with symbol terms
+memory search "queryContext" --token-budget 1500
+```

package/.agents/skills/muse-ground/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: muse-ground
+description: Pre-flight context and invariant grounding for AI coding agents. Retrieves Top-K relevant memories, active USER.md persona, and CURRENT.md working constraints at the start of any session or major task.
+---
+
+# 🎯 Muse Ground (`muse-ground`)
+
+> **When to use**: Execute at the start of every session, task initiation, or context switch before proposing code changes, creating plans, or executing refactors.
+
+---
+
+## 🚀 Execution Workflow
+
+### Step 1: Query Context & Constraints
+Call the `get_context` MCP tool (or run `memory context "<query>"`) using your current task objective or keyword domain:
+
+```json
+{
+  "query": "authentication JWT expiration and database pool configuration",
+  "project": "my-project",
+  "token_budget": 2000
+}
+```
+
+### Step 2: Ingest Three-Tier Grounding Hierarchy
+The grounding response deterministically packages 3 critical layers in strict priority order:
+
+1. **`### User Profile & Preferences (USER.md)`**:
+   - Understand the user's role (`developer`, `designer`, `marketer`, `casual`, `custom`).
+   - Ground in explicit communication rules (e.g. terse output, runnable diffs, fail-fast mechanics).
+
+2. **`### Active Working Constraints (CURRENT.md)`**:
+   - Inspect immutable hard invariants (e.g. "Never commit secrets", "Preserve v1 backward compatibility").
+   - Review active session handoffs and in-flight checkpoints from previous agents.
+
+3. **`### Relevant Memories & Learned Patterns (Top-K)`**:
+   - Review past architectural decisions (`type: architecture`).
+   - Review previously solved edge-case bug fixes (`type: fix`).
+   - Avoid re-introducing known antipatterns or rejected hypotheses (`type: failure` / `status: rejected`).
+
+---
+
+## 🛡️ Invariant Rules for Agents
+
+- **Read Before Mutating**: Never edit code without first checking `CURRENT.md` and active constraints.
+- **Fail Fast on Missing Context**: If `get_context` reveals a conflicting historical decision, escalate or verify rather than blindly overriding.
+- **Tone Alignment**: Strictly mirror the persona defined in `USER.md`.
+
+---
+
+## 💻 CLI Equivalents (Zero-MCP Fallback)
+
+```bash
+# Retrieve top-ranked prompt context
+memory context "query terms" --token-budget 2000
+
+# Inspect active working constraints directly
+memory current get
+
+# Inspect active user persona profile
+memory user get
+```

package/.agents/skills/muse-wiki/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: muse-wiki
+description: Obsidian-compatible knowledge compounding and entity graph generation. Compiles confirmed memories into interlinked Markdown concept pages and tracks named entity co-occurrences.
+---
+
+# 📚 Muse Wiki (`muse-wiki`)
+
+> **When to use**: Execute at milestone completion, weekly review, or when synthesizing scattered memory units into a structured, readable documentation wiki.
+
+---
+
+## 🚀 Execution Workflow
+
+### Step 1: Compile Knowledge Wiki
+Call the `memory_wiki_compile` MCP tool (or run `memory wiki compile`):
+
+```json
+{
+  "project": "my-project",
+  "min_cluster_size": 2
+}
+```
+
+This compiles confirmed memories into structured Obsidian Markdown files in `.memory/wiki/`:
+- **Concept Pages (`wiki/concepts/`)**: Clustered architectural concepts with bidirectional `[[concept-slug]]` wikilinks.
+- **Entity Pages (`wiki/entities/`)**: Extracted tools, frameworks, components, and libraries.
+- **Master Index (`wiki/index.md`)**: Table of contents mapping all domain topics.
+
+### Step 2: Query Wiki Concepts & Entity Graph
+- Call `memory_wiki_search` / `memory_wiki_get` to read synthesized domain documentation.
+- Call `memory_entities_search` / `memory_entities_get` to inspect entity co-occurrence networks (e.g. which libraries are frequently paired with specific architectures).
+
+---
+
+## 🛡️ Invariant Rules for Agents
+
+- **Confirmed Only**: Only `confirmed` memories are compiled into wiki pages to guarantee high signal and prevent draft noise.
+- **Dual Persistence**: Wiki pages are plain Markdown files with YAML frontmatter, fully editable in Obsidian, VS Code, or Cursor.
+
+---
+
+## 💻 CLI Equivalents (Zero-MCP Fallback)
+
+```bash
+# Compile confirmed memories into Obsidian-compatible wiki
+memory wiki compile
+
+# List compiled wiki pages
+memory wiki list
+
+# Read a specific concept page
+memory wiki show auth-patterns
+
+# Inspect entity relationships
+memory entities show nextjs
+memory entities related nextjs
+```

package/README.md

@@ -2,12 +2,21 @@
 
 <div align="center">
 
-![GitHub Release](https://img.shields.io/github/v/release/harshsinghmp/musememory?style=for-the-badge&logo=github&color=blue)
-![NPM Version](https://img.shields.io/npm/v/musememory?style=for-the-badge&logo=npm&color=red)
-![Bun](https://img.shields.io/badge/Bun-1.4.0-black?style=for-the-badge&logo=bun)
-![MCP](https://img.shields.io/badge/MCP-2024--11--05-green?style=for-the-badge&logo=anthropic)
-![CI Tests](https://img.shields.io/badge/Tests-297%20Passed-brightgreen?style=for-the-badge&logo=checkmarx)
-![License](https://img.shields.io/badge/License-MIT-purple?style=for-the-badge)
+![GitHub Release](https://img.shields.io/github/v/release/harshsinghmp/musememory?style=for-the-badge&logo=github&color=2563EB)
+![NPM Version](https://img.shields.io/npm/v/musememory?style=for-the-badge&logo=npm&color=CB3837)
+![Bun](https://img.shields.io/badge/Bun-v1.4.0_(Latest)-black?style=for-the-badge&logo=bun)
+![Node.js](https://img.shields.io/badge/Node.js-≥18.0.0-339933?style=for-the-badge&logo=node.js&logoColor=white)
+![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-3178C6?style=for-the-badge&logo=typescript&logoColor=white)
+
+![MCP Protocol](https://img.shields.io/badge/MCP-2024--11--05-green?style=for-the-badge&logo=anthropic)
+![SQLite Engine](https://img.shields.io/badge/SQLite-Primary_DB-003B57?style=for-the-badge&logo=sqlite&logoColor=white)
+![AST Graph](https://img.shields.io/badge/AST-CodeGraph_%26_Graphify-orange?style=for-the-badge&logo=diagram-project&logoColor=white)
+![Architecture](https://img.shields.io/badge/Storage-Zero--Daemon_%2F_Local--First-0D9488?style=for-the-badge)
+
+![CI Tests](https://img.shields.io/badge/Tests-304%20Passed-brightgreen?style=for-the-badge&logo=checkmarx)
+![Security](https://img.shields.io/badge/Security-Vibeguard_Zero--Leak-DC2626?style=for-the-badge&logo=shield)
+![Agent Coverage](https://img.shields.io/badge/Agents-80+_Supported-4F46E5?style=for-the-badge&logo=openai)
+![License](https://img.shields.io/badge/License-MIT-9333EA?style=for-the-badge)
 
 **Autonomous, Self-Organizing Cognitive Memory System for AI Agents & Agency Networks**
 
@@ -54,13 +63,22 @@ Most AI chatbots and coding assistants have **"goldfish memory"**: every time yo
 └─────────────────────────────────────────────────────────────┘
 ```
 
-- 👤 **Remembers You (`USER.md`)**: Configures your role (`developer`, `designer`, `marketer`, `casual`, `custom`) and communication preferences so AI models talk your language.
-- 📐 **Remembers Active Constraints (`CURRENT.md`)**: Real-time auto-synchronization ensures agents never break hard invariants or lose in-flight task context across session interruptions.
-- 💾 **Primary SQLite + Dual YAML Mirror**: Millisecond queries from `.memory/memory.db` with human-readable YAML mirrors in `.memory/memories/` for seamless Git tracking and team diffing.
-- ⚖️ **Token Knapsack Retrieval**: Multi-factor scoring and exact prompt token budgeting pack relevant memories into prompts with zero token waste.
-- 📚 **Knowledge Compounding**: Compiles memories into Obsidian-compatible Markdown wikis (`memory wiki`), named entity co-occurrence graphs (`memory entities`), and hierarchical PageIndex reasoning trees.
-- 🔌 **Zero-Permission Auto-Wiring**: Automatically scans for 80+ coding agent platforms (Claude Code, Cursor, Antigravity, Windsurf, OpenCode, Codex, etc.) and wires them with zero friction.
-- 🛡️ **Zero-Leakage Secret Defense (Vibeguard)**: Intercepts and rejects API keys, AWS tokens, private keys, and database passwords before they can touch disk.
+---
+
+## ✨ Key Feature Highlights
+
+- 👤 **Persona & Style Grounding (`USER.md`)**: Configures your role (`developer`, `designer`, `marketer`, `casual`, `custom`) and communication preferences so AI models write code that matches your style.
+- 📐 **Real-Time Active Constraints (`CURRENT.md`)**: Bi-temporal working constraints and invariant tracking synchronized on every mutation to eliminate amnesia during task handoffs.
+- 💾 **SQLite Primary + Dual-Persisted YAML Mirror**: Sub-millisecond queries via SQLite with transparent human-readable `.yaml` files in `.memory/memories/` for seamless Git diffs.
+- ⚖️ **Token Knapsack Retrieval**: Multi-factor scoring (applicability, verification bonus, AST graph overlap, time decay, due date urgency) tightly packed under prompt token ceilings.
+- 🌐 **Pluggable AST CodeGraph & Symbol Indexing**: Native CodeGraph & Graphify integration that indexes codebase AST symbols, auto-tags memories, and awards graph overlap bonuses.
+- 🌳 **Hierarchical Tree Retrieval & Progressive Disclosure**: Sharded tree partitions with 3-tier progressive disclosure (`L1` abstracts, `L2` summaries, `L3` full context) for massive knowledge bases.
+- 📚 **Obsidian Markdown Wiki & Entity Graph Compiler**: Dual-persistence knowledge compounding compiling linked Markdown pages (`wiki/concepts/`, `wiki/entities/`) with bidirectional `[[wikilinks]]`.
+- 🛡️ **Vibeguard Zero-Leakage Secret Scanner**: Regex-powered memory defense intercepting and rejecting API keys, AWS credentials, private keys, database URIs, and passwords before writes.
+- 🔌 **Zero-Permission Auto-Wiring (80+ Agents)**: Automatically detects and wires Claude Code, Cursor, Antigravity, Windsurf, OpenCode, Codex, Gemini CLI, Hermes, etc.
+- 🔄 **Universal Memory Migrator (29 Engines)**: One-click migration from Letta, Mem0, Supermemory, Cognee, Beads, Mnemosyne, GBrain, and more with state preservation.
+- 🎨 **Cognitive Studio Visual Dashboard (`memory ui`)**: Embedded zero-dependency web interface featuring 3D force-directed knowledge graphs, live `CURRENT.md` monitor, wiki reader, and persona editor.
+- ⏰ **Proactive Nudges & Routines Scheduler**: Cron-invoked daily briefings, staleness policy tracking, and ambient open-loop trackers with zero resident background daemons.
 
 ---
 
@@ -108,7 +126,7 @@ docker build -t musememory .
 
 ---
 
-## 🔄 Complete NPX Lifecycle (Install → Verify → Connect → Uninstall)
+## 🔄 Complete Lifecycle (Install → Verify → Connect → Uninstall)
 
 Every command works with **zero installation** via `npx musememory <cmd>` (or `bunx musememory <cmd>`). Use plain `memory <cmd>` if installed globally.
 
@@ -147,18 +165,64 @@ npx musememory connect windsurf
 npx musememory connect opencode
 ```
 
-### 4️⃣ Clean Uninstallation
+### 4️⃣ Clean Uninstallation & Removal
+
+<details>
+<summary><b>🗑️ Complete Uninstallation & System Removal Steps</b> — <i>Click to expand</i></summary>
+
+Muse Memory can be cleanly and completely removed with zero trace left on your machine.
+
+#### Step 1: Unwire Coding Agents (Zero-Trace MCP Cleanup)
+Remove the memory MCP server configuration from all 80+ detected agent config files (`cursor`, `claude-code`, `antigravity`, `windsurf`, `opencode`, `codex`, etc.):
+
 ```bash
-# Preview what would be unwired
+# Preview changes before modifying any configuration
 npx musememory uninstall --dry-run
 
-# Unwire MCP from all agents (preserves .memory/ data)
+# Unwire all detected AI coding agents automatically
 npx musememory uninstall
 
-# Unwire AND purge local project .memory/ data
+# Or unwire a single specific agent
+npx musememory uninstall cursor
+```
+
+#### Step 2: Purge Memory Data & Stores (Optional)
+By default, `uninstall` preserves your project `.memory/` data. To completely delete all memory files and databases:
+
+```bash
+# Unwire agents AND purge local project .memory/ directory
 npx musememory uninstall --purge
+
+# Remove global user profile and global memory store (~/.memory/)
+npx musememory uninstall --global --purge
+
+# Manual cleanup (equivalent):
+rm -rf .memory/           # Local project store
+rm -rf ~/.memory/          # Global user profile & store
 ```
 
+#### Step 3: Remove Globally Installed Package
+If you installed `musememory` globally via a package manager:
+
+```bash
+# If installed via npm:
+npm uninstall -g musememory
+
+# If installed via bun:
+bun remove -g musememory
+
+# If installed via yarn / pnpm:
+pnpm remove -g musememory
+yarn global remove musememory
+```
+
+#### Step 4: Clean Git Hooks & Directives (Optional)
+If you installed the pre-commit transcript harvester hook or injected agent prompt directives:
+- **Git Hook**: Delete `.git/hooks/pre-commit` (or restore your previous hook).
+- **AGENTS.md**: Remove the `<!-- musememory:start --> ... <!-- musememory:end -->` block from your project's `AGENTS.md` file.
+
+</details>
+
 ---
 
 ## 🏛️ System Capabilities & Architecture
@@ -234,7 +298,7 @@ Navigate to `http://localhost:2222` to access:
 ## 📖 Deep Technical References & Documentation
 
 <details>
-<summary><b>🔌 Complete MCP Tool Reference (28 Tools)</b> — <i>Click to expand</i></summary>
+<summary><b>🔌 Complete MCP Tool Reference (29 Tools)</b> — <i>Click to expand</i></summary>
 
 When registered as an MCP server, `musememory` exposes the following native tools:
 
@@ -270,7 +334,8 @@ When registered as an MCP server, `musememory` exposes the following native tool
 | `memory_export` / `import` | **Team Sharing** | Exports and imports portable JSON memory snapshots. |
 | `memory_validate` | **Integrity Check** | Verifies database integrity and scans for credential leaks. |
 | `memory_settings_get` / `set` | **Configuration** | Reads and updates unified global or project configuration settings. |
-| `graph_status` | **AST Graph** | Inspects CodeGraph symbol overlap provider status. |
+| `graph_status` | **AST Graph** | Inspects CodeGraph/Graphify symbol overlap provider status. |
+| `graph_index` | **AST Graph** | Indexes AST symbol graph and caches in `.memory/graph-symbols.json`. |
 
 </details>
 
@@ -317,11 +382,27 @@ memory <command> [arguments] [flags]  # alias: musememory
 | `entities` | `list\|show <id>\|related <id>` | Inspect extracted knowledge graph entities and co-occurrence weights. |
 | `settings` | `get\|set\|reset\|export\|import` | Manage unified settings across retrieval, wiki, PageIndex, and UI. |
 | `current` | `get` / `set <text> --project P` | Read or append hard constraints in `.memory/CURRENT.md`. |
-| `graph` | `status` | Query active CodeGraph provider status. |
+| `graph` | `status` / `index` | Query active CodeGraph provider status or index AST symbol map. |
 | `mcp` | *(none)* | Start stdio MCP server (Protocol 2024-11-05). |
 
 </details>
 
+<details>
+<summary><b>🧠 Shipped Agent Skills (<code>.agents/skills/</code>)</b> — <i>Click to expand</i></summary>
+
+Muse Memory ships with 6 turnkey Agent Skills designed for coding agents (Claude Code, Cursor, Antigravity, OpenCode, Codex, Gemini CLI, etc.) under `.agents/skills/`:
+
+| Skill | Trigger Phase | Core Agent Responsibility |
+| :--- | :--- | :--- |
+| [`muse-ground`](.agents/skills/muse-ground/SKILL.md) | **Session Start** | Retrieves Top-$K$ relevant memories, active `USER.md` persona profile, and `CURRENT.md` constraints before writing code. |
+| [`muse-capture`](.agents/skills/muse-capture/SKILL.md) | **During Fixes & Refactors** | Captures atomic fix/architecture memories, validates evidence, runs Vibeguard secret scan, and supersedes obsolete knowledge. |
+| [`muse-current`](.agents/skills/muse-current/SKILL.md) | **Invariants & Handoffs** | Synchronizes hard constraints into `.memory/CURRENT.md` and persists structured handoffs across context resets. |
+| [`muse-graph`](.agents/skills/muse-graph/SKILL.md) | **AST Code Investigation** | Indexes `.codegraph`/`.graphify` symbols and queries symbol-matching decisions with `+0.2` graph overlap bonus. |
+| [`muse-wiki`](.agents/skills/muse-wiki/SKILL.md) | **Knowledge Compounding** | Compiles confirmed memories into Obsidian-compatible Markdown pages (`[[wikilinks]]`) and entity co-occurrence graphs. |
+| [`muse-brief`](.agents/skills/muse-brief/SKILL.md) | **Daily Hygiene & Loops** | Generates morning briefings, tracks 90/180-day staleness decay, and surfaces unresolved transcript commitments. |
+
+</details>
+
 <details>
 <summary><b>👤 5 Zero-Fingerprint Role Archetypes (`USER.md`)</b> — <i>Click to expand</i></summary>
 
@@ -383,7 +464,7 @@ Every Scope-of-Work item is tracked as a GitHub issue and delivered via pull req
 
 ```bash
 bun install
-bun test          # 297 passed across 53 test files (1163 assertions)
+bun test          # 304 passed across 55 test files (1248 assertions)
 bun run typecheck # 0 static type errors
 bun run build     # Clean bundled distribution build (dist/index.js)
 ```