@monoes/monomindcli 1.8.0 → 1.9.0

package/.claude/commands/{monomind-do.md → monomind/do.md}

@@ -1,5 +1,5 @@
 ---
-name: monomind-do
+name: monomind:do
 description: "Monomind — Execute tasks from monomind-task board with parallel, minimal, or sequential agent modes, smart context group routing, and review cycles"
 ---
 
@@ -51,7 +51,7 @@ If `cargo` is also missing, output this and STOP:
 
 2. **Find space**: Run `monotask space list` and find the space named `$REPO_NAME`. If no space exists, output "No monotask space found. Run `/monomind:idea` first." and STOP. Store `SPACE_ID`.
 
-3. **Find task board**: List boards via `monotask board list --json`. For each board ID, run `monotask column list <BOARD_ID> --json` to find one whose title is `monomind-task`. If not found, output "No monomind-task board found. Run `/monomind:idea` first." and STOP. Store `TASK_BOARD_ID`.
+3. **Find task board**: Retrieve the stored board ID via `npx monomind@latest memory search "monomind-task board_id"`. If found, use it as `TASK_BOARD_ID`. Otherwise, list boards in the space via `monotask space boards list $SPACE_ID` and try each ID with `monotask column list <BOARD_ID> --json` to find the one containing a `Backlog` column. If no board is found, output "No monomind-task board found. Run `/monomind:idea` or `/monomind:createtask` first." and STOP. Store `TASK_BOARD_ID`.
 
 4. **Store column IDs**: Run `monotask column list $TASK_BOARD_ID --json` and map all columns by name: `COL_BACKLOG`, `COL_TODO`, `COL_IN_PROGRESS`, `COL_REVIEW`, `COL_HUMAN_IN_LOOP`, `COL_DONE`.
 
@@ -126,10 +126,12 @@ Store chosen mode as `EXEC_MODE`.
 Generate a loop ID and write the initial state file:
 ```bash
 mkdir -p .monomind/loops
-export DO_LOOP_ID="do-$(date +%s%3N)"
+NOW_MS=$(python3 -c 'import time;print(int(time.time()*1000))' 2>/dev/null || echo "$(date +%s)000")
+export DO_LOOP_ID="do-${NOW_MS}"
 cat > ".monomind/loops/${DO_LOOP_ID}.json" << EOF
 {
   "id": "${DO_LOOP_ID}",
+  "sessionId": "${DO_LOOP_ID}",
   "type": "do",
   "prompt": "/monomind:do $ARGUMENTS",
   "mode": "${EXEC_MODE}",
@@ -137,8 +139,8 @@ cat > ".monomind/loops/${DO_LOOP_ID}.json" << EOF
   "spaceId": "${SPACE_ID:-}",
   "boardId": "${TASK_BOARD_ID:-}",
   "filter": "${FILTER:-}",
-  "startedAt": $(date +%s%3N),
-  "lastRunAt": $(date +%s%3N),
+  "startedAt": ${NOW_MS},
+  "lastRunAt": ${NOW_MS},
   "nextRunAt": 0,
   "status": "running"
 }
@@ -277,7 +279,12 @@ For each task being assigned to an agent, gather:
    - Acceptance criteria
    - Additional notes
 
-3. **Checklist**: Run `monotask card checklist list $TASK_BOARD_ID $CARD_ID --json`. If a checklist exists, include as step-by-step guide.
+3. **Checklist**: Cards created by `/monomind:createtask` store their checklist ID in a card comment (line starting with `CHECKLIST_ID:`). Retrieve it:
+   ```bash
+   CHECKLIST_ID=$(monotask card comment list $TASK_BOARD_ID $CARD_ID --json \
+     | jq -r '.[].text' | grep '^CHECKLIST_ID:' | head -1 | cut -d: -f2 | tr -d ' ')
+   ```
+   If a checklist ID is found, retrieve steps via `monotask card view $TASK_BOARD_ID $CARD_ID` and include as step-by-step guide.
 
 Bundle into `TASK_CONTEXT` for that task.
 
@@ -352,9 +359,13 @@ Proceed to Step 9.
    ```bash
    monotask card comment add $TASK_BOARD_ID $CARD_ID "Completed and reviewed: <summary>"
    ```
-2. If there's a checklist, mark completed items:
+2. If there's a checklist, retrieve and mark all item IDs as complete:
    ```bash
-   monotask card checklist check $TASK_BOARD_ID $CARD_ID <ITEM_ID>
+   ITEM_IDS=$(monotask card comment list $TASK_BOARD_ID $CARD_ID --json \
+     | jq -r '.[].text' | grep '^ITEM_IDS:' | head -1 | sed 's/^ITEM_IDS: //')
+   for ITEM_ID in $(echo "$ITEM_IDS" | tr ',' '\n'); do
+     [ -n "$ITEM_ID" ] && monotask checklist item-check $TASK_BOARD_ID $CARD_ID $CHECKLIST_ID "$ITEM_ID"
+   done
    ```
 3. If DONE_WITH_CONCERNS, add concerns:
    ```bash
@@ -402,6 +413,8 @@ If no tasks remain, output:
 [monomind:do] All tasks processed. Queue empty.
 ```
 
+To repeat this command on a schedule, wrap it with `/monomind:repeat`.
+
 ### Store execution outcome in session memory
 
 Call `mcp__monomind__memory_store` with:

package/.claude/commands/monomind/help.md

@@ -0,0 +1,118 @@
+---
+name: monomind-help
+description: Monomind commands reference — quick overview of all skills, CLI subcommands, and MCP tools available in this session
+---
+
+# Monomind Help
+
+Quick reference for all Monomind skills and CLI commands available in this project.
+
+## Monomind Skills (invoke via Skill tool)
+
+| Skill | Description |
+|-------|-------------|
+| `monomind:createtask` | Decompose a prompt, spec file, or folder into agent-optimized tasks on monotask |
+| `monomind:do` | Execute tasks from monotask board with parallel/minimal/sequential agent modes |
+| `monomind:idea` | Research ideas from a prompt and decompose them into subtasks on monotask |
+| `monomind:improve` | Deeply analyze a component, research improvements, create tasks |
+| `monomind:repeat` | Repeat a prompt on a schedule (default: 15 min, 10 times) |
+| `monomind:understand` | Run semantic enrichment on the monograph knowledge graph |
+| `monomind:specialagents` | Activate a specialist agent persona (browse categories or auto-select) |
+| `monomind:swarm` | Swarm coordination reference — topologies, strategies, init patterns |
+| `monomind:memory` | Memory CLI quick reference |
+
+## Core CLI Commands
+
+```bash
+# Initialize project
+npx monomind init --wizard
+
+# Start background daemon
+npx monomind daemon start
+
+# System diagnostics
+npx monomind doctor --fix
+
+# Agent management
+npx monomind agent spawn -t coder --name my-coder
+npx monomind agent list
+npx monomind agent status --id <agent-id>
+npx monomind agent stop --id <agent-id>
+
+# Swarm management
+npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
+npx monomind swarm status
+npx monomind swarm stop
+
+# Memory operations
+npx monomind memory store --key "my-key" --value "my-value" --namespace patterns
+npx monomind memory search --query "search terms"
+npx monomind memory list --namespace patterns
+npx monomind memory retrieve --key "my-key"
+
+# Workflow management
+npx monomind workflow run -t development --task "Build feature"
+npx monomind workflow list
+
+# Knowledge graph
+npx monomind monograph build
+npx monomind monograph search -q "authentication"
+npx monomind monograph stats
+
+# Neural patterns
+npx monomind neural train --pattern coordination --epochs 50
+npx monomind neural status --verbose
+
+# Hooks
+npx monomind hooks pre-task --description "task description"
+npx monomind hooks post-task --task-id "id" --success true
+npx monomind hooks route --task "task description"
+
+# Session management
+npx monomind session restore --latest
+npx monomind session save
+
+# Security
+npx monomind security scan --depth full
+
+# Performance
+npx monomind performance benchmark --suite all
+```
+
+## Built-in Workflow Templates
+
+`development`, `research`, `testing`, `security-audit`, `code-review`, `refactoring`, `sparc`, `custom`
+
+## Swarm Topologies
+
+| Topology | Use When |
+|----------|----------|
+| `hierarchical` | Feature dev, bug fixes (anti-drift, tight control) |
+| `mesh` | Research, analysis (broad coverage) |
+| `star` | Parallel testing, parallel maintenance |
+| `hierarchical-mesh` | Large teams 10+ agents |
+
+## Key MCP Tools
+
+```javascript
+// Memory
+mcp__monomind__memory_store({ key: "...", value: "...", namespace: "..." })
+mcp__monomind__memory_search({ query: "...", namespace: "..." })
+
+// Knowledge graph
+mcp__monomind__graphify_suggest({ task: "..." })
+mcp__monomind__graphify_query({ query: "..." })
+
+// Swarm
+mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
+mcp__monomind__swarm_status({})
+
+// System
+mcp__monomind__system_health({})
+mcp__monomind__agent_health({})
+```
+
+## Support
+
+- Documentation: https://github.com/nokhodian/monomind
+- Issues: https://github.com/nokhodian/monomind/issues

package/.claude/commands/{monomind-idea.md → monomind/idea.md}

@@ -1,5 +1,5 @@
 ---
-name: monomind-idea
+name: monomind:idea
 description: "Monomind — Research ideas from a prompt, evaluate them, and decompose into subtasks on monotask boards"
 ---
 
@@ -65,10 +65,12 @@ Bundle all gathered information into a single `PROJECT_CONTEXT` string for downs
 - Store the `SPACE_ID`.
 
 ### Idea Board
-- List boards via `monotask board list --json`. For each board ID, run `monotask column list <BOARD_ID> --json` to find one whose title is `monomind-idea`. (There is no "board view" command -- column list reveals the board structure.)
+- First check memory: `npx monomind@latest memory search "monomind-idea board_id"`. If a board ID is returned, use it as `BOARD_ID` and skip the board search below.
+- Otherwise, list boards in the space via `monotask space boards list $SPACE_ID` (one board ID per line). For each ID, check `monotask column list <BOARD_ID> --json` — if the result contains a column named `New`, treat it as the `monomind-idea` board candidate and use its ID as `BOARD_ID`.
 - If the `monomind-idea` board does not exist:
   1. Create it: `monotask board create "monomind-idea" --json` -- store the returned `BOARD_ID`.
   2. Add it to the space: `monotask space boards add $SPACE_ID $BOARD_ID`.
+  3. Persist the ID: `npx monomind@latest memory store --key "monomind-idea board_id" --value "$BOARD_ID" --namespace monomind`.
   3. Create these columns in order:
      - `New`
      - `Evaluated`
@@ -109,8 +111,8 @@ After all agents complete:
    ```bash
    monotask card create $BOARD_ID $COL_NEW "<title>" --json
    monotask card comment add $BOARD_ID $CARD_ID "<description>"
-   monotask card tag add $BOARD_ID $CARD_ID "monomind-idea"
-   monotask card tag add $BOARD_ID $CARD_ID "<category>"
+   monotask card label add $BOARD_ID $CARD_ID "monomind-idea"
+   monotask card label add $BOARD_ID $CARD_ID "<category>"
    ```
 
 If zero ideas were generated after deduplication, report "No ideas generated by the research swarm." and STOP.
@@ -206,9 +208,9 @@ Also move any `skipElaboration: true` ideas directly to `Elaborated`.
 Spawn a single `Software Architect` agent via the Agent tool. Provide it with:
 - All ideas in the `Elaborated` column (titles, descriptions, and all comments)
 - The `PROJECT_CONTEXT`
-- **The Task Grouping Rules and Card Format from `monomind-task-engine` skill (Sections 1 & 2)** — include them verbatim in the agent prompt so it produces correctly structured tasks
+- **The Task Grouping Rules and Card Format from `/monomind:createtask` Step 5** — include them verbatim in the agent prompt so it produces correctly structured tasks
 
-The agent MUST produce a `TASKS` array following the `monomind-task-engine` card format (Section 2). Each task must comply with all 7 grouping rules (Section 1). For each elaborated idea, decompose into 2-6 subtasks.
+The agent MUST produce a `TASKS` array following the `/monomind:createtask` task card format (Step 5). Each task must comply with all 7 grouping rules. For each elaborated idea, decompose into 2-6 subtasks.
 
 **If the architect has doubts** about decomposing an idea (unclear scope, missing info), they should:
 - Add a comment with the question
@@ -216,27 +218,19 @@ The agent MUST produce a `TASKS` array following the `monomind-task-engine` card
 
 Store the result as `TASKS` array.
 
-### Invoke the Unified Task Engine
+### Create Cards on Monotask
 
-Invoke the `monomind-task-engine` skill (Sections 3-7) with these parameters:
+Follow the same card creation process as `/monomind:createtask` Steps 6–7, with these values:
+- `SOURCE_TAG` = `"monomind:idea"`
+- `SOURCE_SUMMARY` = first 100 chars of `$ARGUMENTS`
 
-| Parameter | Value |
-|-----------|-------|
-| `TASKS` | The array from the architect agent |
-| `TASK_BOARD_ID` | From Step 2 (or let the engine set up the board) |
-| `REPO_NAME` | From Step 1 |
-| `SOURCE_TAG` | `"monomind-idea"` |
-| `SOURCE_SUMMARY` | First 100 chars of `$ARGUMENTS` |
-| `PARENT_CARD_ID` | Each `IDEA_CARD_ID` in the Elaborated column |
-| `PARENT_BOARD_ID` | `$BOARD_ID` (the monomind-idea board) |
-| `PARENT_DONE_COLUMN` | `$COL_TASKED` |
+After all cards are created for each idea, annotate its idea card and move it to `Tasked`:
+```bash
+monotask card comment add $BOARD_ID $IDEA_CARD_ID "Subtasks created:\n- <title> (agent: <type>, effort: <N>/10)\n..."
+monotask card move $BOARD_ID $IDEA_CARD_ID $COL_TASKED --json
+```
 
-The engine will:
-1. Create all cards on the monotask board (Section 4)
-2. Store execution strategy in session memory (Section 5)
-3. Run the **Final Dependency & Critical Path Review** (Section 6) — a fresh Code Reviewer agent validates prerequisites, context groups, critical path, parallel safety, and agent assignments
-4. Fix any blocker issues automatically, present warnings to user
-5. Present execution offer with mode recommendation (Section 7)
+Then follow `/monomind:createtask` Steps 8 (Final Dependency Review) and report results.
 
 ---
 
@@ -266,10 +260,10 @@ Then output:
 
 ## Step 8: Offer to Execute Tasks
 
-The `monomind-task-engine` (Section 7) already presents the execution offer after the final review passes. If the user picks a mode there, it invokes `monomind-do` automatically.
-
-If the engine's execution offer was skipped or the user deferred, and there are tasks in Todo, offer:
+If there are tasks in Todo, offer:
 
 ```
-Skill("monomind-do", "--space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
+Skill("monomind:do", "--space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
 ```
+
+To repeat this command on a schedule, wrap it with `/monomind:repeat`.

package/.claude/commands/{monomind-improve.md → monomind/improve.md}

@@ -1,5 +1,5 @@
 ---
-name: monomind-improve
+name: monomind:improve
 description: "Monomind — Deeply analyze a project component, research improvements online, and create improvement tasks on monotask boards"
 ---
 
@@ -134,10 +134,12 @@ After both agents complete, merge their outputs into `COMPONENT_ANALYSIS`.
 - Store the `SPACE_ID`.
 
 ### Improve Board
-- List boards via `monotask board list --json`. For each board ID, run `monotask column list <BOARD_ID> --json` to find one whose title is `monomind-improve`. (There is no "board view" command -- column list reveals the board structure.)
+- First check memory: `npx monomind@latest memory search "monomind-improve board_id"`. If a board ID is returned, use it as `BOARD_ID` and skip the search below.
+- Otherwise, list boards in the space via `monotask space boards list $SPACE_ID` (one board ID per line) and check each via `monotask column list <ID> --json` for a `Discovered` column — if found, that is the `monomind-improve` board.
 - If the `monomind-improve` board does not exist:
   1. Create it: `monotask board create "monomind-improve" --json` — store the returned `BOARD_ID`.
   2. Add it to the space: `monotask space boards add $SPACE_ID $BOARD_ID`.
+  3. Persist the ID: `npx monomind@latest memory store --key "monomind-improve board_id" --value "$BOARD_ID" --namespace monomind`.
   3. Create these columns in order:
      - `Discovered`
      - `Evaluated`
@@ -180,7 +182,7 @@ For each idea, create a card in the `Discovered` column:
 monotask card create $BOARD_ID $COL_DISCOVERED "<title>" --json
 monotask card comment add $BOARD_ID $CARD_ID "<description>"
 monotask card comment add $BOARD_ID $CARD_ID "Category: <category>\nEvidence: <evidence>\nExpected impact: <estimated_impact>"
-monotask card tag add $BOARD_ID $CARD_ID "monomind-improve"
+monotask card label add $BOARD_ID $CARD_ID "monomind-improve"
 ```
 
 If zero ideas were generated, report "No improvement opportunities found for this component." and STOP.
@@ -273,9 +275,9 @@ Spawn a single `Software Architect` agent via the Agent tool. Provide it with:
 - All ideas in the `Approved` column (titles, descriptions, and all comments including implementation paths and research)
 - The `COMPONENT_ANALYSIS` from Step 2
 - The `PROJECT_CONTEXT`
-- **The Task Grouping Rules and Card Format from `monomind-task-engine` skill (Sections 1 & 2)** — include them verbatim in the agent prompt so it produces correctly structured tasks
+- **The Task Grouping Rules and Card Format from `/monomind:createtask` Step 5** — include them verbatim in the agent prompt so it produces correctly structured tasks
 
-The agent MUST produce a `TASKS` array following the `monomind-task-engine` card format (Section 2). Each task must comply with all 7 grouping rules (Section 1). For each approved improvement, decompose into 2-6 subtasks.
+The agent MUST produce a `TASKS` array following the `/monomind:createtask` task card format (Step 5). Each task must comply with all 7 grouping rules. For each approved improvement, decompose into 2-6 subtasks.
 
 **If the architect has doubts** about decomposing an improvement (unclear scope, missing info):
 - Add a comment with the question
@@ -283,27 +285,19 @@ The agent MUST produce a `TASKS` array following the `monomind-task-engine` card
 
 Store the result as `TASKS` array.
 
-### Invoke the Unified Task Engine
+### Create Cards on Monotask
 
-Invoke the `monomind-task-engine` skill (Sections 3-7) with these parameters:
+Follow the same card creation process as `/monomind:createtask` Steps 6–7, with these values:
+- `SOURCE_TAG` = `"monomind:improve"`
+- `SOURCE_SUMMARY` = first 100 chars of `$ARGUMENTS`
 
-| Parameter | Value |
-|-----------|-------|
-| `TASKS` | The array from the architect agent |
-| `TASK_BOARD_ID` | From Step 3 (or let the engine set up the board) |
-| `REPO_NAME` | From Step 1 |
-| `SOURCE_TAG` | `"monomind-improve"` |
-| `SOURCE_SUMMARY` | First 100 chars of `$ARGUMENTS` |
-| `PARENT_CARD_ID` | Each `IMPROVE_CARD_ID` in the Approved column |
-| `PARENT_BOARD_ID` | `$BOARD_ID` (the monomind-improve board) |
-| `PARENT_DONE_COLUMN` | `$COL_TASKED` |
+After all cards are created for each improvement, annotate its improvement card and move it to `Tasked`:
+```bash
+monotask card comment add $BOARD_ID $IMPROVE_CARD_ID "Subtasks created:\n- <title> (agent: <type>, effort: <N>/10)\n..."
+monotask card move $BOARD_ID $IMPROVE_CARD_ID $COL_TASKED --json
+```
 
-The engine will:
-1. Create all cards on the monotask board (Section 4)
-2. Store execution strategy in session memory (Section 5)
-3. Run the **Final Dependency & Critical Path Review** (Section 6) — a fresh Code Reviewer agent validates prerequisites, context groups, critical path, parallel safety, and agent assignments
-4. Fix any blocker issues automatically, present warnings to user
-5. Present execution offer with mode recommendation (Section 7)
+Then follow `/monomind:createtask` Steps 8 (Final Dependency Review) and report results.
 
 ---
 
@@ -343,10 +337,10 @@ Output board references:
 
 ## Step 9: Offer to Execute Tasks
 
-The `monomind-task-engine` (Section 7) already presents the execution offer after the final review passes. If the user picks a mode there, it invokes `monomind-do` automatically.
-
-If the engine's execution offer was skipped or the user deferred, and there are tasks in Todo, offer:
+If there are tasks in Todo, offer:
 
 ```
-Skill("monomind-do", "--space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
+Skill("monomind:do", "--space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
 ```
+
+To repeat this command on a schedule, wrap it with `/monomind:repeat`.

package/.claude/commands/monomind/memory.md

@@ -0,0 +1,230 @@
+---
+name: monomind-memory
+description: AgentDB memory system — store, search, retrieve, list, delete, and manage cross-session persistent memory with vector embeddings
+---
+
+# Monomind Memory System
+
+Persistent memory backed by AgentDB with HNSW vector indexing for semantic search (150x-12,500x faster than brute-force). Supports cross-session and cross-agent collaboration.
+
+## Subcommands
+
+| Subcommand | Alias | Description |
+|---|---|---|
+| `init` | — | Initialize memory database (sql.js + AgentDB) |
+| `store` | — | Store a key/value entry |
+| `edit` | — | Edit an existing entry |
+| `retrieve` | `get` | Retrieve entry by key |
+| `search` | — | Semantic/vector search |
+| `list` | `ls` | List memory entries |
+| `delete` | `rm` | Delete an entry |
+| `templates` | — | Show best-practice entry templates |
+| `stats` | — | Show memory statistics |
+| `configure` | `config` | Configure memory backend |
+| `cleanup` | — | Clean expired/stale entries |
+| `compress` | — | Compress and optimize storage |
+| `export` | — | Export memory to file |
+| `import` | — | Import memory from file |
+
+## init — Initialize Database
+
+```bash
+npx monomind memory init
+npx monomind memory init --backend agentdb --verbose --verify
+npx monomind memory init --force  # Overwrite existing
+```
+
+**Flags:** `--backend hybrid|sqlite|agentdb` (default: `hybrid`), `--path`, `--force`, `--verbose`, `--verify` (default: true), `--load-embeddings`
+
+## store — Store Data
+
+```bash
+# Store with specific namespace
+npx monomind memory store --key "arch/api-design" --value "RESTful microservices" --namespace arch
+
+# With tags and TTL
+npx monomind memory store --key "pattern/auth" --value "JWT + refresh tokens" --namespace patterns --tags "auth,security" --ttl 86400
+
+# Upsert (update if exists)
+npx monomind memory store --key "bug/null-check" --value "Fixed null check in parser" --upsert
+```
+
+**Flags:**
+
+| Flag | Short | Default | Description |
+|---|---|---|---|
+| `--key` | `-k` | — | Storage key (required) |
+| `--value` | — | — | Value to store (required) |
+| `--namespace` | `-n` | `default` | Memory namespace |
+| `--ttl` | — | — | Time to live in seconds |
+| `--tags` | — | — | Comma-separated tags |
+| `--vector` | — | `false` | Store as vector embedding |
+| `--upsert` | `-u` | `false` | Update if key exists |
+
+## search — Semantic Search
+
+```bash
+# Semantic search (default)
+npx monomind memory search --query "authentication patterns"
+
+# Keyword search
+npx monomind memory search --query "JWT" --type keyword
+
+# Hybrid search with namespace filter
+npx monomind memory search --query "error handling" --namespace patterns --limit 5
+
+# Build HNSW index first for max speed
+npx monomind memory search --query "API design" --build-hnsw
+```
+
+**Flags:**
+
+| Flag | Short | Default | Description |
+|---|---|---|---|
+| `--query` | `-q` | — | Search query (required) |
+| `--namespace` | `-n` | all | Filter by namespace |
+| `--limit` | `-l` | `10` | Maximum results |
+| `--threshold` | — | `0.7` | Similarity threshold (0-1) |
+| `--type` | `-t` | `semantic` | `semantic`, `keyword`, `hybrid` |
+| `--build-hnsw` | — | `false` | Rebuild HNSW index before search |
+
+## retrieve — Get by Key
+
+```bash
+npx monomind memory retrieve --key "arch/api-design"
+npx monomind memory retrieve --key "pattern/auth" --namespace patterns
+```
+
+**Flags:** `--key/-k` (required), `--namespace/-n` (default: `default`)
+
+## list — Browse Entries
+
+```bash
+npx monomind memory list
+npx monomind memory list --namespace patterns --limit 20
+```
+
+**Flags:** `--namespace/-n`, `--limit/-l` (default: `20`)
+
+## delete — Remove Entry
+
+```bash
+npx monomind memory delete --key "old-pattern"
+npx monomind memory delete --key "temp-key" --namespace temp --force
+```
+
+**Flags:** `--key/-k` (required), `--namespace/-n` (default: `default`), `--force/-f` (skip confirmation)
+
+## templates — Entry Templates
+
+```bash
+npx monomind memory templates
+npx monomind memory templates --type feedback
+```
+
+Types: `user`, `feedback`, `project`, `reference` — scaffolds for the auto-memory format.
+
+## stats — Storage Overview
+
+```bash
+npx monomind memory stats
+```
+
+Shows backend, total entries, storage size, oldest/newest entry.
+
+## configure — Backend Settings
+
+```bash
+npx monomind memory configure --backend agentdb
+npx monomind memory configure --backend hybrid --cache-size 512 --hnsw-m 16 --hnsw-ef 200
+```
+
+**Flags:** `--backend/-b`, `--path`, `--cache-size`, `--hnsw-m`, `--hnsw-ef`
+
+## cleanup — Remove Stale Entries
+
+```bash
+# Preview without deleting
+npx monomind memory cleanup --dry-run
+
+# Delete entries older than 30 days
+npx monomind memory cleanup --older-than 30d
+
+# Remove expired TTL entries only
+npx monomind memory cleanup --expired-only
+
+# Clean specific namespace
+npx monomind memory cleanup --namespace temp --older-than 7d --force
+```
+
+**Flags:** `--dry-run/-d`, `--older-than/-o` (e.g., `7d`, `30d`), `--expired-only/-e`, `--namespace/-n`, `--force/-f`
+
+## compress — Optimize Storage
+
+```bash
+npx monomind memory compress
+npx monomind memory compress --quantize --bits 4  # 32x size reduction
+npx monomind memory compress --level max --target vectors
+```
+
+**Flags:** `--level fast|balanced|max` (default: `balanced`), `--target vectors|text|patterns|all`, `--quantize/-z`, `--bits 4|8|16`, `--rebuild-index/-r` (default: true)
+
+## export / import
+
+```bash
+# Export all to JSON
+npx monomind memory export --output ./backup.json
+
+# Export specific namespace to CSV
+npx monomind memory export --output ./patterns.csv --format csv --namespace patterns
+
+# Import
+npx monomind memory import --input ./backup.json
+npx monomind memory import --input ./backup.json --namespace archive
+```
+
+## Namespaces
+
+`default`, `agents`, `tasks`, `sessions`, `swarm`, `project`, `spec`, `arch`, `impl`, `test`, `debug`, `patterns`, `solutions`
+
+## MCP Tools
+
+```javascript
+// Store
+mcp__monomind__memory_store({ key: "pattern/auth", value: "JWT + refresh", namespace: "patterns" })
+
+// Search
+mcp__monomind__memory_search({ query: "authentication", namespace: "patterns" })
+
+// Retrieve
+mcp__monomind__memory_retrieve({ key: "pattern/auth", namespace: "patterns" })
+
+// List
+mcp__monomind__memory_list({ namespace: "patterns" })
+
+// Delete
+mcp__monomind__memory_delete({ key: "pattern/auth", namespace: "patterns" })
+
+// Stats
+mcp__monomind__memory_stats({})
+```
+
+## Common Workflows
+
+### Store successful pattern after completing a task
+
+```bash
+npx monomind memory store --key "pattern/oauth-integration" --value "Use PKCE flow, store tokens in httpOnly cookies" --namespace patterns --tags "auth,oauth"
+```
+
+### Search before starting a task
+
+```bash
+npx monomind memory search --query "OAuth integration patterns" --namespace patterns --limit 5
+```
+
+### Backup before major refactor
+
+```bash
+npx monomind memory export --output "./backups/memory-$(date +%Y%m%d).json"
+```