monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/.claude/commands/mastermind/topology.md

@@ -1,121 +0,0 @@
----
-name: mastermind-topology
-description: Swarm & Hive-Mind architecture picker — presents all topologies, consensus protocols, and strategies, then gives one concrete recommendation for the current task
----
-
-IMPORTANT: Do NOT dump all the reference content at once. Follow the two-phase flow below exactly.
-
-**If $ARGUMENTS is non-empty**, treat it as the user's task description and skip Phase 1 — go straight to Phase 2 with that description.
-
----
-
-## Phase 1 — Present the picker and STOP
-
-Output this menu and WAIT for the user's reply before doing anything else:
-
----
-
-**MASTERMIND — Swarm & Hive-Mind Picker**
-
-Describe your task and I'll recommend the right mode, or pick directly from the options below.
-
-### Swarm Topologies
-| # | Topology | Shape | Best for |
-|---|---|---|---|
-| **1** | `hierarchical` | One coordinator → all workers | Feature dev, bug fixes, most coding tasks |
-| **2** | `mesh` | Every agent ↔ every agent | Research, brainstorming, docs |
-| **3** | `hierarchical-mesh` | Queen + peer lanes | Large projects, 10–15 agents |
-| **4** | `ring` | Agent → next → next → loop | Pipelines: research→draft→edit→review |
-| **5** | `star` | Hub aggregates independent workers | Parallel analysis, test coverage |
-| **6** | `adaptive` | Starts hierarchical, self-reconfigures | Long-running or unknown workloads |
-
-### Hive-Mind Modes
-| # | Mode | Consensus | Best for |
-|---|---|---|---|
-| **7** | `hive-mind hierarchical-mesh` | `byzantine` | Security-critical, fault-tolerant (f < n/3) |
-| **8** | `hive-mind hierarchical` | `raft` | Refactors, rewrites — leader keeps authoritative state |
-| **9** | `hive-mind mesh` | `gossip` | Large agent counts, eventual consistency |
-| **10** | `hive-mind hierarchical-mesh` | `crdt` | Concurrent writes, collaborative editing |
-| **11** | `hive-mind adaptive` | `quorum` | Custom fault-tolerance, majority vote |
-
-> Type a number (1–11), or just **describe what you want to build** and I'll pick for you.
-
----
-
-## Phase 2 — Give a concrete recommendation
-
-Based on the task or user choice, pick ONE mode and output EXACTLY this structure:
-
----
-
-**Your Plan**
-
-- **Mode:** `<swarm|hive-mind>` · `<topology>` — <one sentence why>
-- **Agents:** <N> · <list agent types>
-- **Consensus:** `<protocol>` — <one sentence why>
-- **Strategy:** `<specialized|balanced|pipeline|parallel>` _(swarm only)_
-
-**Launch command:**
-```bash
-# Swarm:
-npx monomind swarm init --topology <topology> --max-agents <N> --strategy <strategy>
-
-# OR Hive-Mind (no --strategy flag):
-npx monomind hive-mind init --topology <topology> --consensus <protocol> --max-agents <N>
-```
-
-**Agent team:**
-```
-coordinator  → plans and delegates
-<agent>      → <role>
-<agent>      → <role>
-...
-```
-
-**Then spawn in Claude Code (one message):**
-```javascript
-// Bash: init the swarm/hive-mind first (above command)
-// Then Task tool calls — all in the same message:
-Task({ subagent_type: "coordinator", description: "...", run_in_background: true })
-Task({ subagent_type: "<agent>",     description: "...", run_in_background: true })
-// ... one Task call per agent
-```
-
-> Ready? Say **go** and I'll launch it, or adjust any detail first.
-
----
-
-## Recommendation Logic (internal — do not output)
-
-Use this to pick the right mode when the user describes a task:
-
-| Task type | Mode | Topology | Consensus | Agents | Strategy |
-|---|---|---|---|---|---|
-| Bug fix (1–2 files) | swarm | hierarchical | raft | 4 | specialized |
-| Feature (3+ files) | swarm | hierarchical | raft | 6–8 | specialized |
-| Refactor / migration | swarm | hierarchical | raft | 5–6 | specialized |
-| Performance optimization | swarm | star | raft | 4–5 | parallel |
-| Security audit / fix | hive-mind | hierarchical-mesh | byzantine | 6 | specialized |
-| Research / docs | swarm | mesh | gossip | 4–6 | balanced |
-| Docs pipeline | swarm | ring | raft | 4 | pipeline |
-| Testing / coverage | swarm | star | raft | 5–6 | parallel |
-| Architecture design | swarm | hierarchical-mesh | raft | 8–10 | specialized |
-| Full release (end-to-end) | hive-mind | hierarchical-mesh | byzantine | 12–15 | specialized |
-| Long-running / unknown | swarm | adaptive | raft | 8–10 | specialized |
-| Refactor with rollback safety | hive-mind | hierarchical | raft | 5–6 | specialized |
-| Concurrent collaborative writes | hive-mind | hierarchical-mesh | crdt | 4–6 | balanced |
-| Large-scale eventual consistency (20+ agents) | hive-mind | mesh | gossip | 15–20 | balanced |
-| Custom fault-tolerance / majority vote | hive-mind | adaptive | quorum | 8–12 | specialized |
-
-**Quick decision rule:**
-- 1 file → use Edit tool directly, no swarm needed
-- 2–3 files, clear scope → swarm hierarchical, 4–6 agents, raft
-- Security/fault-critical → hive-mind hierarchical-mesh, byzantine
-- Research/exploration → swarm mesh, gossip
-- Pipeline stages (A→B→C) → swarm ring
-- Parallel independent work → swarm star
-- 10+ agents or long-running → hierarchical-mesh or adaptive
-- Refactor needing authoritative rollback → hive-mind hierarchical, raft
-- Concurrent collaborative writes → hive-mind hierarchical-mesh, crdt
-- Large agent pool (20+), eventual consistency → hive-mind mesh, gossip
-- Custom fault-tolerance threshold → hive-mind adaptive, quorum

package/packages/@monomind/cli/.claude/commands/mastermind/understand.md

@@ -1,136 +0,0 @@
-<!-- "Monomind — Run semantic enrichment on the current project's monograph knowledge graph. Uses the active Claude Code session for LLM work — no API key needed." -->
-
-# /mastermind:understand — Semantic Enrichment
-
-Enriches the current project's monograph knowledge graph with summaries, architectural
-layers, and semantic relationships.
-
-**Designed to run inside Claude Code** — uses YOUR current session for LLM work via
-the Task tool. No `ANTHROPIC_API_KEY` required. The script handles layer detection
-and DB writes; you (Claude) handle per-file summarization.
-
-## Parse Arguments
-
-Parse `$ARGUMENTS` for these flags:
-
-- `--dir <path>`      — project directory (default: cwd)
-- `--db <path>`       — monograph.db path (default: `<dir>/.monomind/monograph.db`)
-- `--full`            — force full re-analysis
-- `--no-llm`          — heuristic-only mode (no per-file summaries)
-- `--layers-only`     — skip per-file analysis, only re-detect layers
-- `--max-files <N>`   — stop after N files (0 = all)
-- `--dry-run`         — show what would happen, don't write
-
-Bare path argument → `--dir`.
-
----
-
-## Step 1: Locate project, DB, and script
-
-```bash
-DIR="${ARGUMENTS_dir:-$(pwd)}"
-DB="${ARGUMENTS_db:-$DIR/.monomind/monograph.db}"
-
-# Find understand-analyze.mjs (ships with monomind globally)
-GLOBAL_ROOT=$(npm root -g 2>/dev/null)
-SCRIPT="$GLOBAL_ROOT/monomind/packages/@monomind/cli/scripts/understand-analyze.mjs"
-[ ! -f "$SCRIPT" ] && SCRIPT="$GLOBAL_ROOT/@monoes/monomindcli/scripts/understand-analyze.mjs"
-```
-
-If `$DB` does not exist:
-> monograph.db not found at `$DB`. Build it first: `npx monomind monograph build`
-
-If `$SCRIPT` does not exist:
-> understand engine missing. Update: `npm install -g monomind@latest`
-
-In either case, STOP.
-
----
-
-## Step 2: Run the script in heuristic mode (always — fast and deterministic)
-
-This step is non-negotiable. The script handles:
-- File node discovery from monograph.db
-- Heuristic layer detection from file paths
-- DB writes (community_id + properties)
-- graph.json emission to `.understand/knowledge-graph.json`
-- Auto-shadowing the DB to `/tmp` when it lives on a network FS
-
-```bash
-node "$SCRIPT" --dir "$DIR" --db "$DB" --no-llm
-```
-
-Wait for completion. Capture stdout. Note how many file nodes were found and how
-many layers were detected. Do NOT advise the user about API keys.
-
----
-
-## Step 3: Per-file summarization (ONLY if `--no-llm` and `--layers-only` are both UNSET)
-
-This is where YOU (the current Claude session) do the LLM work. The script left
-behind a fresh `.understand/knowledge-graph.json` with placeholder summaries.
-
-1. Read `.understand/knowledge-graph.json`. For each node where `properties.fileSummary`
-   is empty or marked `[heuristic]`, do the following:
-   - Use the `Read` tool on `node.file_path` (relative to `$DIR`).
-   - Produce a JSON object: `{ id, fileSummary, tags, complexity, functionSummaries, classSummaries }`
-     where:
-     - `fileSummary`: 1-2 sentences explaining what the file does
-     - `tags`: array of 2-5 short tags
-     - `complexity`: "simple" | "moderate" | "complex"
-     - `functionSummaries`: top-5 functions → 1-sentence each
-     - `classSummaries`: classes → 1-sentence each
-2. Process files in batches of 5 for efficiency. Use `--max-files` to cap if set.
-3. Collect all analyses into an `analyses` array.
-
-If `$ARGUMENTS` includes `--no-llm` or `--layers-only`, SKIP this step entirely.
-
----
-
-## Step 4: Write analyses back to the DB
-
-Pipe the collected analyses to a small re-import:
-
-```bash
-echo "$ANALYSES_JSON" | node "$SCRIPT" --dir "$DIR" --db "$DB" --import-analyses-stdin
-```
-
-(If your `analyses` array is empty, skip this step.)
-
----
-
-## Step 5: Report
-
-```
-╔══════════════════════════════════════════════════╗
-║  /mastermind:understand — Enrichment Done           ║
-╠══════════════════════════════════════════════════╣
-║  DB:              .monomind/monograph.db          ║
-║  Files analyzed:  <N>                             ║
-║  LLM summaries:   <N> (via active session)        ║
-║  Layers:          <N>                             ║
-║  graph.json:      .understand/knowledge-graph.json║
-╚══════════════════════════════════════════════════╝
-```
-
-If LLM summaries = 0 (because `--no-llm` was set), say "heuristic-only mode — no per-file summaries written".
-
-Then:
-> Open the Monomind control panel and click **Monograph → GRAPH** to see layers.
-> Each color = one architectural layer (API, Service, Data, UI, etc.).
->
-> Follow-ups:
-> - `/mastermind:understand --full` — re-run from scratch
-> - `/mastermind:understand --layers-only` — refresh only layers
-> - `/mastermind:understand --no-llm` — heuristic-only mode
-
----
-
-## Error Handling
-
-- Do NOT prompt the user to set `ANTHROPIC_API_KEY`. LLM work happens in this session.
-- If the script exits non-zero: show stderr and suggest `npm install -g monomind@latest`.
-- If monograph.db has no file nodes: tell the user to run `npx monomind monograph build` first.
-- All errors are non-fatal — report and return cleanly.
-
-To re-run on a schedule: wrap with `/mastermind:repeat`.

package/packages/@monomind/cli/.claude/commands/mastermind/verify.md

@@ -1,19 +0,0 @@
-<!-- Run the verification gate before claiming any work is complete, fixed, or passing — evidence before assertions always. -->
-
-**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`.
-
-Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text = claim_or_task.
-
-Load brain context for the `verify` domain (follow `mastermind-protocol/SKILL.md` Brain Load Procedure).
-
-If claim_or_task is empty: ask "What claim or task needs verification?"
-
-Default mode: **auto**.
-
----
-
-Invoke `Skill("mastermind-verify")` passing: brain_context, claim_or_task, project_name, mode.
-
-After skill returns: follow `mastermind-protocol/SKILL.md` Brain Write Procedure for domain `verify`.
-
-**MANDATORY — invoke `Skill("mastermind-repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/worktree.md

@@ -1,17 +0,0 @@
-<!-- Use when starting feature work that needs isolation from the current workspace or before executing implementation plans — sets up an isolated git worktree -->
-
-**First — extract repeat flags:** Follow REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`.
-
-Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text.
-
-Load brain context (follow `mastermind-protocol/SKILL.md` Brain Load Procedure).
-
-Default mode: **auto**.
-
----
-
-Invoke `Skill("mastermind-worktree")` passing: brain_context, params, mode.
-
-After skill returns: follow `mastermind-protocol/SKILL.md` Brain Write Procedure.
-
-Invoke `Skill("mastermind-repeat")` now. Required — do not skip.

package/packages/@monomind/cli/.claude/commands/mastermind.md

@@ -1,140 +0,0 @@
----
-name: mastermind
-description: Universal intent router — deeply understands what a prompt is really asking for, matches it against the full monomind capability surface (mastermind commands, monomind CLI/MCP tools, monodesign, monomotion, monograph, orgs, skills), then either executes the best route or hands the user an exact step-by-step playbook
----
-
-MASTERMIND is the front door to everything in this project. Given any prompt, it figures out what the user actually needs, picks the right capability out of everything installed, and either runs it or teaches the user to run it. It never answers with a generic response when a purpose-built tool exists.
-
-## Step 1 — Parse flags
-
-From `$ARGUMENTS` extract:
-- `--auto` → mode = **auto**: execute the chosen route immediately, no confirmation
-- `--suggest` → mode = **suggest**: never execute — deliver the playbook only
-- Remaining text = the prompt to route
-
-Default mode (no flag) = **guided**: present the playbook, run read-only analysis steps immediately, ask one confirmation before anything that writes files, spawns agents, or costs real tokens.
-
-**If the prompt is empty**, ask: "What do you want to accomplish? Describe the goal — I'll route it to the right monomind capability and either run it or show you exactly how." Then STOP and wait.
-
-## Step 2 — Deep intent analysis (mandatory, before touching any tool)
-
-Do not skim for keywords. Analyze the prompt and state an INTENT block:
-
-```
-INTENT
-━━━━━━
-Surface ask:     <what the words literally request>
-Underlying goal: <what the user is actually trying to achieve — the outcome behind the ask>
-Domain(s):       <code | design | animation | research | content | marketing | sales | ops | finance | org/agents | memory | testing | security | performance | docs | release>
-Deliverable:     <what "done" looks like — file, fix, report, running system, decision>
-Scope:           <single-file | multi-file | whole-system | ongoing/recurring>
-Risk:            <read-only | writes code | destructive | external-facing>
-Implicit needs:  <what the user didn't say but the goal requires — tests, verification, design review, index rebuild, isolation branch…>
-```
-
-Rules for this step:
-- **Surface ask ≠ underlying goal.** "Make this page pop" is a design-system task, not a CSS tweak. "Why is this slow" is a debugging/profiling task, not an explanation request. Route on the goal.
-- Ambiguous between 2 domains? Pick the one whose deliverable matches; name the runner-up in the playbook as an alternative.
-- Genuinely unroutable without one missing fact (e.g. which project, which file)? Ask exactly ONE question, then proceed.
-
-## Step 3 — Capability match
-
-Match the intent against this catalog. Pick ONE primary route, plus supporting steps that the goal implies (prep, verification). Prefer the most specific capability over the most powerful one.
-
-**Tie-break rule:** if the prompt describes broken, wrong, or unexpected behavior — anything currently misbehaving — the primary route is `Skill("mastermind-debug")`, no matter which domain's keywords appear. "Wrong version number", "layout renders broken", "org won't start" are debug tasks first; the topical skill (release, design, org) comes after root cause.
-
-### Code & building
-| Intent | Primary route |
-|---|---|
-| Fix a bug, test failure, unexpected behavior | `Skill("mastermind-debug")` → root cause first, then fix |
-| Build a feature / implement anything | `Skill("mastermind-design")` → spec, then `Skill("mastermind-build")` |
-| Plan before coding | `Skill("mastermind-plan")` (write) / `Skill("mastermind-execute")` or `Skill("mastermind-taskdev")` (run) |
-| TDD workflow | `Skill("mastermind-tdd")` |
-| Refactor / architecture / DDD / dedup | `Skill("mastermind-architect")` |
-| Code review, audit quality | `Skill("mastermind-review")`; apply one received: `Skill("mastermind-receive-review")` |
-| Verify a claim ("it works", "tests pass") | `Skill("mastermind-verify")` |
-| Autonomous improve-loop | `Skill("mastermind-autodev")` (`--tillend` for until-clean) |
-| Finish/merge/PR a branch | `Skill("mastermind-finish")`; release/versioning: `Skill("mastermind-release")` |
-| Isolate risky work | `Skill("mastermind-worktree")` |
-| Spec → agent task file/board | `Skill("mastermind-createtask")`, execute with `Skill("mastermind-do")` |
-
-### Design, animation, frontend
-| Intent | Primary route |
-|---|---|
-| ANY UI/UX design, critique, polish, tokens, brand, image prompts, dark mode | `Skill("monodesign")` — the only design agent, mandatory first |
-| ANY web animation, motion graphics, GSAP, scroll/text animation | `Skill("monomotion")` — mandatory first |
-| Browser testing, UI QA, web navigation | `Skill("agent-browser-testing")` → `npx monomind browse` (NEVER Playwright/Puppeteer/claude-in-chrome) |
-| Actual image generation | `Skill("monoagent-image")` (monodesign only writes prompts) |
-| Charts/dashboards/data viz | `Skill("dataviz")` before any chart code |
-
-### Understanding the codebase
-| Intent | Primary route |
-|---|---|
-| Find code, symbols, "what imports X" | `mcp__monomind__monograph_query` / `monograph_suggest` (before any grep) |
-| Blast radius of a change | `mcp__monomind__monograph_impact` / `monograph_api_impact` |
-| Dead code, orphan files | `mcp__monomind__monograph_dead_code` |
-| High-centrality / god files | `mcp__monomind__monograph_god_nodes` |
-| Stale index | `mcp__monomind__monograph_build` (background) |
-
-### Research, ideas, content, business
-| Intent | Primary route |
-|---|---|
-| Market/competitor/user research | `Skill("mastermind-research")`; deep cited web report: `Skill("deep-research")` |
-| Ideation, feature brainstorm | `Skill("mastermind-idea")` / `Skill("mastermind-ideate")` (evaluate + decompose) |
-| Improve an existing component | `Skill("mastermind-improve")` |
-| Blog/docs/newsletter/threads | `Skill("mastermind-content")`; docs generation: `npx monomind doc` |
-| Marketing / sales / ops / finance | `Skill("mastermind-marketing")` / `-sales` / `-ops` / `-finance` |
-| Port capability from another project | `Skill("mastermind-techport")` |
-
-### Agents, orgs, orchestration
-| Intent | Primary route |
-|---|---|
-| Multi-domain goal spanning several of the above | `/mastermind:master` — spawns parallel domain managers |
-| Create a persistent agent org | `Skill("mastermind-createorg")` → `monomind org run <name>` (`Skill("mastermind-runorg")`) |
-| Inspect running org | `monomind org status/logs/questions`; `Skill("mastermind-orgstatus")` |
-| Pick swarm/hive-mind topology | `/mastermind:topology` (the old picker lives here) |
-| Recurring/scheduled task | `Skill("loop")` (in-session interval) / `Skill("schedule")` (cloud cron) / `Skill("mastermind-repeat")` |
-| Watch external boards & execute tasks | `Skill("mastermind-monitor")` |
-
-### System, memory, quality
-| Intent | Primary route |
-|---|---|
-| "What does monomind know" / recall context | `mcp__monomind__knowledge_search`, `memory_kg_search`; inspect: `Skill("mastermind-brain")` |
-| Security scan/audit/secrets | `npx monomind security scan|cve|audit|secrets` |
-| Performance profiling | `npx monomind performance profile|benchmark` |
-| System health | `npx monomind doctor` (`--fix`) / `monomind status` |
-| Write/improve a mastermind skill | `Skill("mastermind-skill-builder")` |
-
-**No match at all?** Say so honestly, name the two nearest capabilities and why they miss, and offer: handle it directly, or scaffold it as a new skill via `Skill("mastermind-skill-builder")`.
-
-## Step 4 — Deliver the playbook
-
-Output EXACTLY this structure:
-
-```
-MASTERMIND ROUTE
-━━━━━━━━━━━━━━━━
-Goal: <one sentence — the underlying goal>
-
-▶ Primary: <capability> — <one sentence why this beats the alternatives>
-  How: <exact invocation — the Skill()/MCP call or shell command, with real arguments filled in>
-
-Full playbook:
-  1. <prep step, if the goal implies one — e.g. monograph_suggest for 3+ file work, worktree for risky changes>
-  2. <primary route>
-  3. <verification step — how the user will KNOW it worked, e.g. mastermind:verify, browse test, doctor>
-
-Alternative: <runner-up route + when to prefer it — omit if none is close>
-DIY: <the 1–3 commands the user would type themselves to run this without me>
-```
-
-Then act by mode:
-- **auto** → execute the full playbook now, in order, without asking. Report results when done.
-- **guided** → run step 1 if it's read-only analysis, then ask once: "Run the rest? (or take the DIY commands and drive it yourself)". On yes, execute to completion.
-- **suggest** → stop after the playbook. Make the DIY section detailed enough to run unaided: every command copy-pasteable, flags explained in one clause each.
-
-Execution rules — mastermind is hardworking, not lazy:
-- Never route-and-quit in auto/guided mode. Routing to `Skill("mastermind-debug")` means INVOKING it and following it through, not mentioning it.
-- The playbook always has a verification step. "It should work now" is not a deliverable.
-- Multi-domain prompts (build + marketing, design + animation): route to `/mastermind:master` rather than chaining routes manually — unless one domain is trivially small.
-- Respect the iron laws of the routed skills (TDD, debug-before-fix, verify-before-claiming). Routing does not exempt you from them.

package/packages/@monomind/cli/.claude/commands/memory/README.md

@@ -1,79 +0,0 @@
----
-name: memory:README
----
-
-# Memory Commands
-
-Commands for the LanceDB memory system — vector search, namespaced storage, HNSW indexing, and cross-session persistence.
-
-## Available Subcommands
-
-| Subcommand | Description |
-|---|---|
-| `memory init` | Initialize memory backend (lancedb, sqlite, hybrid) |
-| `memory store` | Store a memory entry with optional vector embedding |
-| `memory retrieve` | Retrieve a memory entry by key |
-| `memory search` | Search memory (semantic / keyword / hybrid) |
-| `memory list` | List all memory entries with optional filters |
-| `memory edit` | Update an existing memory entry |
-| `memory delete` | Delete one or more memory entries |
-| `memory templates` | Manage memory templates |
-| `memory stats` | Show memory usage statistics |
-| `memory configure` | Configure memory backend settings |
-| `memory cleanup` | Remove expired or stale entries |
-| `memory compress` | Compress stored data and rebuild indexes |
-| `memory export` | Export memories to JSON/JSONL file |
-| `memory import` | Import memories from a file |
-
-## Quick Reference
-
-```bash
-# Initialize
-npx monomind memory init --backend hybrid
-
-# Store
-npx monomind memory store --key "auth-pattern" --value "Use JWT with refresh tokens" --namespace "patterns"
-
-# Search
-npx monomind memory search --query "authentication" --type hybrid --build-hnsw
-
-# Retrieve exact key
-npx monomind memory retrieve --key "auth-pattern"
-
-# List all in namespace
-npx monomind memory list --namespace "patterns"
-
-# Export / Import
-npx monomind memory export --output backup.json --format json
-npx monomind memory import --input backup.json --merge
-```
-
-## Files
-
-- [memory-search.md](./memory-search.md) — Search memory (semantic/keyword/hybrid + HNSW)
-
-## MCP Tools
-
-| Tool | Purpose |
-|---|---|
-| `mcp__monomind__memory_store` | Store a memory entry |
-| `mcp__monomind__memory_retrieve` | Retrieve by key |
-| `mcp__monomind__memory_search` | Search memory |
-| `mcp__monomind__memory_list` | List entries |
-| `mcp__monomind__memory_delete` | Delete entries |
-| `mcp__monomind__memory_stats` | Usage statistics |
-| `mcp__monomind__memory_migrate` | Migrate between backends |
-
-## Backends
-
-| Backend | Description | Recommended |
-|---|---|---|
-| `lancedb` | Full LanceDB with HNSW vector search | Production |
-| `sqlite` | SQLite-only, no vector search | Lightweight |
-| `hybrid` | SQLite + LanceDB HNSW | Default (recommended) |
-
-## See Also
-
-- `hooks intelligence` — pattern learning on top of memory
-- `neural` — neural pattern training
-- `session` — session state (separate from memory)

package/packages/@monomind/cli/.claude/commands/memory/memory-search.md

@@ -1,77 +0,0 @@
----
-name: memory:memory-search
----
-
-# memory search
-
-Search stored memory using semantic, keyword, or hybrid search.
-
-## Usage
-
-```bash
-npx monomind memory search [options]
-```
-
-## Options
-
-| Flag | Short | Type | Default | Description |
-|---|---|---|---|---|
-| `--query` | `-q` | string | — | Search query text |
-| `--namespace` | `-n` | string | `default` | Namespace to search |
-| `--limit` | `-l` | number | `10` | Maximum results to return |
-| `--threshold` | — | number | `0.7` | Minimum similarity threshold (0–1) |
-| `--type` | `-t` | string | `hybrid` | Search type: `semantic`, `keyword`, `hybrid` |
-| `--build-hnsw` | — | boolean | `false` | Build pure-JS HNSW index before search (O(log n) vs O(n) linear) |
-| `--format` | — | string | — | Output format: `json` |
-
-## Examples
-
-```bash
-# Semantic search
-npx monomind memory search --query "authentication patterns"
-
-# Keyword search
-npx monomind memory search -q "JWT" --type keyword
-
-# Hybrid search with namespace
-npx monomind memory search -q "error handling" -n "project-x" --type hybrid
-
-# Build HNSW index first for large datasets
-npx monomind memory search -q "config" --build-hnsw --limit 20
-
-# High-precision search with threshold
-npx monomind memory search -q "OAuth flow" --threshold 0.9
-
-# JSON output
-npx monomind memory search -q "auth" --format json
-```
-
-## Search Types
-
-| Type | Description | Best For |
-|---|---|---|
-| `semantic` | Vector similarity search | Concept/meaning matching |
-| `keyword` | BM25 full-text search | Exact term matching |
-| `hybrid` | Combined semantic + keyword | General purpose (recommended) |
-
-## HNSW Index
-
-Use `--build-hnsw` when searching large memory stores (1,000+ entries). The pure-JS HNSW index gives O(log n) approximate-nearest-neighbor queries (vs O(n) linear scan) after the one-time build cost.
-
-## MCP Tool
-
-```javascript
-mcp__monomind__memory_search({
-  query: "authentication patterns",
-  namespace: "default",
-  limit: 10,
-  threshold: 0.7,
-  type: "hybrid"
-})
-```
-
-## See Also
-
-- `memory store` — store new memories
-- `memory list` — list all memories
-- `memory retrieve` — retrieve by exact key

package/packages/@monomind/cli/.claude/commands/monitoring/README.md

@@ -1,69 +0,0 @@
----
-name: monitoring:README
----
-
-# Monitoring Commands
-
-Commands for monitoring Monomind system health — swarm status, agents, tasks, memory, and performance metrics.
-
-## Available Commands
-
-| Command | Description |
-|---|---|
-| `status` | Full system status (swarm, agents, tasks, memory, MCP) |
-| `status agents` | Detailed agent table with uptime and success rate |
-| `status tasks` | Detailed task table with progress and priority |
-| `status memory` | Memory backend stats and HNSW performance |
-| `agent metrics` | Agent performance metrics by type and time period |
-| `agent health` | Per-agent health check with optional watch mode |
-| `swarm status` | Swarm-specific status (topology, consensus, agents) |
-
-## Quick Reference
-
-```bash
-# One-shot system snapshot
-npx monomind status
-
-# Live watch (refreshes every 2s)
-npx monomind status --watch
-
-# Health checks with pass/warn/fail
-npx monomind status --health-check
-
-# Detailed agent view
-npx monomind status agents
-
-# Agent performance metrics
-npx monomind agent metrics --period 7d
-
-# Swarm status
-npx monomind swarm status
-```
-
-## Files
-
-- [status.md](./status.md) — Full system status + watch mode + health checks
-- [agents.md](./agents.md) — `status agents` subcommand
-- [agent-metrics.md](./agent-metrics.md) — `agent metrics` by type and period
-
-## MCP Tools
-
-| Tool | Purpose |
-|---|---|
-| `mcp__monomind__swarm_status` | Swarm health and agent counts |
-| `mcp__monomind__swarm_health` | Swarm health check |
-| `mcp__monomind__agent_list` | All agents with metrics |
-| `mcp__monomind__agent_status` | Specific agent status |
-| `mcp__monomind__agent_health` | Agent health check |
-| `mcp__monomind__memory_stats` | Memory backend stats |
-| `mcp__monomind__task_summary` | Task counts by status |
-| `mcp__monomind__task_list` | All tasks with progress |
-| `mcp__monomind__system_health` | Full system health |
-| `mcp__monomind__system_metrics` | System performance metrics |
-| `mcp__monomind__mcp_status` | MCP server status |
-
-## See Also
-
-- `doctor` — comprehensive diagnostics (`npx monomind doctor`)
-- `hooks metrics` — learning and intelligence metrics
-- `performance` — performance profiling commands