monomind 1.18.15 → 2.0.0

package/packages/@monomind/cli/.claude/helpers/skill-registry.json

@@ -36,21 +36,6 @@
       "category": "implementation",
       "primaryAgent": "coder"
     },
-    {
-      "skill": "sparc:tdd",
-      "invoke": "Skill(\"sparc:tdd\")",
-      "description": "Test-driven development — write failing tests first, then implementation",
-      "keywords": [
-        "tdd",
-        "test driven",
-        "tests first",
-        "unit test",
-        "spec",
-        "red green refactor"
-      ],
-      "category": "testing",
-      "primaryAgent": "tester"
-    },
     {
       "skill": "agent-browser-testing",
       "invoke": "Skill(\"agent-browser-testing\")",
@@ -106,166 +91,6 @@
       "category": "testing",
       "primaryAgent": "agent-browser-testing"
     },
-    {
-      "skill": "sparc:architect",
-      "invoke": "Skill(\"sparc:architect\")",
-      "description": "System architecture design — patterns, DDD, scalability, API design",
-      "keywords": [
-        "architect",
-        "design",
-        "system design",
-        "structure",
-        "domain",
-        "ddd",
-        "patterns",
-        "scalability"
-      ],
-      "category": "architecture",
-      "primaryAgent": "architect"
-    },
-    {
-      "skill": "sparc:security-review",
-      "invoke": "Skill(\"sparc:security-review\")",
-      "description": "Security analysis — vulnerabilities, CVEs, threat modeling, input validation",
-      "keywords": [
-        "security",
-        "vulnerability",
-        "cve",
-        "threat",
-        "injection",
-        "xss",
-        "auth",
-        "exploit"
-      ],
-      "category": "security",
-      "primaryAgent": "reviewer"
-    },
-    {
-      "skill": "sparc:debugger",
-      "invoke": "Skill(\"sparc:debugger\")",
-      "description": "Systematic debugging — root cause analysis, error tracing, fix verification",
-      "keywords": [
-        "debug",
-        "bug",
-        "error",
-        "crash",
-        "fix",
-        "broken",
-        "not working",
-        "exception",
-        "trace"
-      ],
-      "category": "debugging",
-      "primaryAgent": "coder"
-    },
-    {
-      "skill": "sparc:optimizer",
-      "invoke": "Skill(\"sparc:optimizer\")",
-      "description": "Performance optimization — profiling, bottlenecks, memory, speed improvements",
-      "keywords": [
-        "optimize",
-        "performance",
-        "slow",
-        "speed",
-        "memory",
-        "bottleneck",
-        "profile",
-        "latency"
-      ],
-      "category": "performance",
-      "primaryAgent": "coder"
-    },
-    {
-      "skill": "sparc:devops",
-      "invoke": "Skill(\"sparc:devops\")",
-      "description": "DevOps and deployment — CI/CD, Docker, infrastructure, pipelines",
-      "keywords": [
-        "deploy",
-        "ci",
-        "cd",
-        "docker",
-        "pipeline",
-        "infrastructure",
-        "kubernetes",
-        "build",
-        "release"
-      ],
-      "category": "devops",
-      "primaryAgent": "devops"
-    },
-    {
-      "skill": "sparc:documenter",
-      "invoke": "Skill(\"sparc:documenter\")",
-      "description": "Documentation generation — READMEs, API docs, architecture docs, inline comments",
-      "keywords": [
-        "document",
-        "docs",
-        "readme",
-        "api docs",
-        "explain",
-        "write documentation",
-        "comment"
-      ],
-      "category": "documentation",
-      "primaryAgent": "researcher"
-    },
-    {
-      "skill": "sparc:researcher",
-      "invoke": "Skill(\"sparc:researcher\")",
-      "description": "Research and analysis — investigate, explore, gather information, summarize",
-      "keywords": [
-        "research",
-        "find",
-        "search",
-        "investigate",
-        "explore",
-        "analyse",
-        "understand",
-        "how does",
-        "what kind",
-        "what is",
-        "list",
-        "show me",
-        "available",
-        "skills",
-        "agents",
-        "capabilities"
-      ],
-      "category": "research",
-      "primaryAgent": "researcher"
-    },
-    {
-      "skill": "sparc:spec-pseudocode",
-      "invoke": "Skill(\"sparc:spec-pseudocode\")",
-      "description": "Specification and pseudocode — clarify requirements, write specs, plan logic",
-      "keywords": [
-        "spec",
-        "specification",
-        "requirements",
-        "pseudocode",
-        "plan",
-        "design logic",
-        "clarify"
-      ],
-      "category": "planning",
-      "primaryAgent": "architect"
-    },
-    {
-      "skill": "sparc:refactor",
-      "invoke": "Skill(\"sparc:coder\")",
-      "description": "Refactoring — clean up code, extract functions, improve structure without changing behavior",
-      "keywords": [
-        "refactor",
-        "clean up",
-        "restructure",
-        "extract",
-        "simplify",
-        "technical debt",
-        "improve code"
-      ],
-      "category": "implementation",
-      "primaryAgent": "coder"
-    },
     {
       "skill": "github:code-review",
       "invoke": "Skill(\"github:code-review\")",
@@ -772,20 +597,6 @@
       "category": "core",
       "primaryAgent": "coder"
     },
-    {
-      "skill": "sparc-methodology",
-      "invoke": "Skill(\"sparc-methodology\")",
-      "description": "SPARC development methodology — Specification, Pseudocode, Architecture, Refinement, Completion",
-      "keywords": [
-        "sparc",
-        "methodology",
-        "architecture",
-        "specification",
-        "development"
-      ],
-      "category": "core",
-      "primaryAgent": "architect"
-    },
     {
       "skill": "specialagent",
       "invoke": "Skill(\"specialagent\")",

package/packages/@monomind/cli/.claude/skills/github-toolkit/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: github-toolkit
+description: >
+  GitHub workflow guidance for monomind projects — issues, PRs, releases,
+  repo structure, and multi-package sync. Trigger on "open a PR", "manage
+  issues", "cut a release", "sync packages", or any GitHub Actions/repo
+  automation request. All GitHub operations use the `gh` CLI plus monomind's
+  MCP GitHub tools — there is no `monomind github` CLI command group.
+---
+
+# GitHub Toolkit
+
+Guidance for GitHub-integrated workflows in monomind projects. All GitHub
+operations go through the `gh` CLI directly (for PRs, issues, releases) or
+through monomind's MCP GitHub tools when running inside a swarm.
+
+## Core operations
+
+- **Issues** — triage, label, and track via `gh issue` or `mcp__monomind__github_issue_track`.
+  See `.claude/commands/github/issue-tracker.md`.
+- **Pull requests** — create, review, and merge via `gh pr` or `mcp__monomind__github_pr_manage`.
+  See `.claude/commands/github/pr-manager.md`.
+- **Releases** — version bump, changelog, tag, and publish coordination.
+  See `.claude/commands/github/release-manager.md`.
+- **Repo structure** — multi-repo layout and package boundary decisions.
+  See `.claude/commands/github/repo-architect.md`.
+- **Multi-package sync** — version alignment and dependency sync across a monorepo.
+  See `.claude/commands/github/sync-coordinator.md`.
+- **Integration modes overview** — which mode to use for which workflow.
+  See `.claude/commands/github/github-modes.md`.
+
+## Quick reference
+
+```bash
+# Issues
+gh issue list --state open
+gh issue create --title "..." --body "..."
+
+# Pull requests
+gh pr create --title "..." --body "..."
+gh pr view <number> --json reviews,statusCheckRollup
+
+# Releases
+gh release create v1.2.3 --generate-notes
+```
+
+## MCP tools (when running inside a swarm)
+
+```javascript
+mcp__monomind__github_pr_manage({ action: "review", pr: 123 })
+mcp__monomind__github_issue_track({ action: "list", state: "open" })
+mcp__monomind__github_metrics({ repo: "owner/repo" })
+```
+
+## When to reach for the full docs
+
+Each linked command file under `.claude/commands/github/` has the complete
+option/flag reference and swarm-coordination patterns for its area — read
+the relevant one before doing multi-step GitHub automation (e.g. spawning
+a `pr-manager` or `release-manager` agent).

package/packages/@monomind/cli/.claude/skills/hive-mind-advanced/SKILL.md

@@ -234,20 +234,6 @@ Task("Database Architect", "Design PostgreSQL schema...", "code-analyzer")
 Task("Test Engineer", "Create Jest test suite...", "tester")
 ```
 
-### With SPARC Methodology
-
-```bash
-# Use hive mind for SPARC workflow
-npx monomind sparc tdd "User authentication" --hive-mind
-
-# Spawns:
-# - Specification agent
-# - Architecture agent
-# - Coder agents
-# - Tester agents
-# - Reviewer agents
-```
-
 ### With GitHub Integration
 
 ```bash
@@ -691,7 +677,6 @@ npx monomind hive-mind spawn "Review PR #456" \
 - `swarm-orchestration`: Basic swarm coordination
 - `consensus-mechanisms`: Distributed decision making
 - `memory-systems`: Advanced memory management
-- `sparc-methodology`: Structured development workflow
 - `github-integration`: Repository coordination
 
 ## References

package/packages/@monomind/cli/.claude/skills/hooks-automation/SKILL.md

@@ -1185,7 +1185,6 @@ npx monomind hook validate-config
 ### Integration with Other Skills
 
 This skill works seamlessly with:
-- **SPARC Methodology** - Hooks enhance SPARC workflows
 - **Pair Programming** - Automated quality in pairing sessions
 - **Verification Quality** - Truth-score validation in hooks
 - **GitHub Workflows** - Git integration for commits/PRs

package/packages/@monomind/cli/.claude/skills/mastermind-skills/_protocol.md

@@ -396,7 +396,7 @@ SUCCESS CRITERIA:
 - [ ] [Concrete checkable item 1]
 - [ ] [Concrete checkable item 2]
 
-AGENT: [agent slug, e.g. backend-dev | sparc-coder | frontend-dev]
+AGENT: [agent slug, e.g. backend-dev | frontend-dev]
 SWARM: [topology agent-count consensus, e.g. \"hierarchical 4 raft\"]
 
 DEPENDENCIES: [task IDs, or \"none\"]

package/packages/@monomind/cli/.claude/skills/mastermind-skills/architect.md

@@ -251,22 +251,21 @@ _entry=${_entry:-.}
   npx --yes madge --circular "$_entry/" 2>/dev/null; } | head -20
 
 # 6. Find god files (imported by many others)
-# NOTE: This step covers JS/TS/Vue and Python only.
-# For Go, Rust, Java, and other stacks, use mcp__monomind__monograph_god_nodes instead.
-# JS/TS/Vue: skip comment lines; perl extracts module name from from '...' or from "..."
-# --exclude-dir applied at grep level so exclusions work before -h strips filenames
+# PREFERRED: use monograph (pre-computed graph index, faster and more accurate)
+# Call mcp__monomind__monograph_god_nodes({}) first.
+# Only fall back to grep below if monograph returns 0 results or the DB is not built.
+#
+# FALLBACK (grep-based, JS/TS/Vue and Python only):
 grep -rh "^[^/]*from ['\"]" . \
   --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" --include="*.vue" \
   --exclude-dir=node_modules --exclude-dir=dist --exclude-dir=.git \
   2>/dev/null \
   | perl -ne 'if (/from\s+['"'"'"]([^'"'"'"\s]+)['"'"'"]/) { print "$1\n" }' \
   | sort | uniq -c | sort -rn | head -20
-# Python: count imports separately (no quotes in Python import syntax)
 grep -rh "^from \|^import " . --include="*.py" \
   --exclude-dir=node_modules --exclude-dir=dist --exclude-dir=.git \
   2>/dev/null \
   | awk '{print $2}' | sed 's/,.*//' | sed 's/\..*//' | grep -v '^$' | sort | uniq -c | sort -rn | head -20
-# Note: if monograph is built, prefer mcp__monomind__monograph_god_nodes — it uses the pre-computed graph index
 ```
 
 For each finding, produce a **Deduplication Action Table**:

package/packages/@monomind/cli/.claude/skills/mastermind-skills/autodev.md

@@ -48,19 +48,22 @@ Default `count = 1`.
 
 ```bash
 git log --oneline -30
-find . -maxdepth 3 -type f \( -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.md" \) \
-  ! -path "*/node_modules/*" ! -path "*/.git/*" ! -path "*/dist/*" | head -80
 cat package.json 2>/dev/null || cat pyproject.toml 2>/dev/null || cat go.mod 2>/dev/null || true
 head -120 README.md 2>/dev/null || true
-grep -rn "<PATTERNS>" --include="*.ts" --include="*.js" --include="*.py" --include="*.go" --include="*.md" \
-  . 2>/dev/null | grep -v node_modules | grep -v dist | head -40
 ```
 
-Plus these MCP calls (also parallel):
+Plus these MCP calls (also parallel — **preferred over grep for symbol/pattern search**):
+- `mcp__monomind__monograph_query` — search for `<PATTERNS>` (see mode table below); replaces grep for symbol lookup
 - `mcp__monomind__monograph_god_nodes` — high-centrality modules (hotspots / where new features plug in)
 - `mcp__monomind__monograph_suggest` — query per mode below
 - `mcp__monomind__memory_search` — namespace `"mastermind:autodev"`, to exclude already-built work
 
+**Fallback only** (if monograph returns 0 results or DB not built):
+```bash
+grep -rn "<PATTERNS>" --include="*.ts" --include="*.js" --include="*.py" --include="*.go" --include="*.md" \
+  . 2>/dev/null | grep -v node_modules | grep -v dist | head -40
+```
+
 Mode-specific values:
 
 | | Improvement loop | Feature pipeline |

package/packages/@monomind/cli/.claude/skills/mastermind-skills/build.md

@@ -106,7 +106,7 @@ SCOPE: [exact file paths in scope]
 CONSTRAINTS: [must-not-break items, existing APIs to preserve]
 SUCCESS CRITERIA:
 - [ ] [checkable item]
-AGENT: [backend-dev | frontend-dev | tester | reviewer | sparc-coder]
+AGENT: [backend-dev | frontend-dev | tester | reviewer]
 SWARM: hierarchical 4 raft
 DEPENDENCIES: [task IDs or \"none\"]
 OUTPUT FORMAT: unified output schema"
@@ -118,7 +118,6 @@ Spawn one Task agent per task (all in parallel where dependencies allow):
 - Frontend tasks: subagent_type "frontend-dev"
 - Testing tasks: subagent_type "tester"
 - Code review: subagent_type "reviewer"
-- TDD/SPARC work: subagent_type "sparc-coder"
 
 Also run /mastermind:do --board <board_id> to track execution.
 

package/packages/@monomind/cli/.claude/skills/mastermind-skills/review.md

@@ -148,11 +148,14 @@ Run the test suite and adversarial probes against the live monofence-ai detector
 ```
 MONOFENCE INPUT BOUNDARY SCAN (monofence_deep flag):
 
-Step 1 — Find LLM input boundary files using these patterns:
-  grep -rl "detect\|isSafe\|prompt\|chat\|completion\|message" src/ --include="*.ts" --include="*.js"
-  find . -name "*.ts" -path "*/routes/*" -o -name "*.ts" -path "*/handlers/*" \
-         -o -name "*.ts" -path "*/controllers/*" -o -name "*.ts" -path "*/api/*" \
-         -o -name "prompt*.ts" -o -name "*chat*.ts" -o -name "*completion*.ts"
+Step 1 — Find LLM input boundary files:
+  PREFERRED: monograph_query({ query: "detect isSafe prompt chat completion message" })
+             monograph_neighbors({ name: "detect" })  // trace call chains into LLM boundaries
+  FALLBACK (if monograph returns 0 results):
+    grep -rl "detect\|isSafe\|prompt\|chat\|completion\|message" src/ --include="*.ts" --include="*.js"
+    find . -name "*.ts" -path "*/routes/*" -o -name "*.ts" -path "*/handlers/*" \
+           -o -name "*.ts" -path "*/controllers/*" -o -name "*.ts" -path "*/api/*" \
+           -o -name "prompt*.ts" -o -name "*chat*.ts" -o -name "*completion*.ts"
 
 Step 2 — For each boundary file found, extract string literals and template literals
   that flow into LLM calls (look for openai/anthropic/fetch calls).

package/packages/@monomind/cli/.claude/skills/mastermind-skills/techport.md

@@ -75,8 +75,17 @@ find .claude -name "*.md" \
 
 ### 0B — Naming Convention Extraction (from actual monomind code)
 
-Extract the real conventions — not the stated ones — from the codebase itself:
+Extract the real conventions — not the stated ones — from the codebase itself.
 
+**Step 1 — monograph-based extraction (preferred):**
+```
+# Use monograph for exported symbol discovery
+monograph_query({ query: "export class interface" })    # all exported types
+monograph_god_nodes({})                                  # high-centrality files (naming exemplars)
+monograph_stats({})                                      # node counts by type
+```
+
+**Step 2 — grep fallback (only if monograph returns 0 results or DB not built):**
 ```bash
 BASE=packages/@monomind/cli/src
 
@@ -143,10 +152,20 @@ Domain vocab:       Agent, Memory, Swarm, Config, Node, Graph, Session, Task, Wo
 
 ### 0C — Dependency Direction Constraints
 
+**Preferred: monograph-based dependency analysis:**
+```
+# Use monograph for dependency direction mapping
+monograph_community({})                              # module clusters with import directions
+monograph_context({ name: "types" })                 # 360° view: importers vs imports
+monograph_context({ name: "utils" })
+monograph_context({ name: "core" })
+monograph_context({ name: "commands" })
+monograph_context({ name: "services" })
+```
+
+**Fallback (only if monograph unavailable):**
 ```bash
 BASE=packages/@monomind/cli/src
-
-# Map import directions by directory layer
 for dir in types utils core commands services; do
   count=$(grep -rn "^import" "$BASE/$dir" --include="*.ts" 2>/dev/null | wc -l)
   refs=$(grep -rn "from.*/$dir/" "$BASE" --include="*.ts" 2>/dev/null | wc -l)
@@ -160,6 +179,13 @@ Extract the implied layering from the import ratio. High `imported_by` → leaf/
 
 ### 0D — Build Monomind Vocabulary Name Set (for collision detection)
 
+**Preferred: monograph-based symbol enumeration:**
+```
+monograph_query({ query: "export class interface function const type enum" })
+# Extract names from results for collision checking
+```
+
+**Fallback (only if monograph unavailable):**
 ```bash
 grep -rhn "^export" packages/@monomind/cli/src \
   --include="*.ts" | grep -v dist | \
@@ -200,6 +226,14 @@ Set `source_brand` to the PascalCase result (e.g., `Monomind`, `ClaudeFlow`, `So
 
 ### 1B — Repo-Map (Structural Index)
 
+**If source project has a monograph index** (check with `monograph_health` against source_path):
+```
+monograph_query({ query: "export class interface function" })  # all exported symbols
+monograph_god_nodes({})                                         # high-centrality files
+monograph_community({})                                         # module structure
+```
+
+**Otherwise (foreign project without monograph — grep is expected here):**
 ```bash
 # File tree
 find "{source_path}" -maxdepth 4 \

package/packages/@monomind/cli/.claude/skills/memory-toolkit/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: memory-toolkit
+description: >
+  Use monomind's persistent memory store (LanceDB + pure-JS HNSW) to save,
+  search, list, and retrieve cross-session knowledge — patterns, solutions,
+  decisions. Trigger on "remember this", "store in memory", "search memory",
+  "have we solved this before", "recall past decisions", or before starting
+  work that benefits from prior context (debugging, refactors, repeated tasks).
+---
+
+# Memory Toolkit
+
+Monomind ships a persistent, namespaced memory store backed by LanceDB with
+a pure-JS HNSW index for approximate nearest-neighbor vector search. Use it
+to avoid re-solving the same problem twice across sessions.
+
+## Before starting non-trivial work
+
+Search for prior art first:
+
+```bash
+npx monomind memory search --query "[task keywords]" --namespace patterns
+npx monomind memory search --query "[task keywords]" --namespace solutions
+```
+
+## Store data
+
+```bash
+# REQUIRED: --key and --value. OPTIONAL: --namespace (default: "default"), --ttl, --tags
+npx monomind memory store --key "pattern-auth" --value "JWT with refresh tokens" --namespace patterns
+npx monomind memory store --key "bug-fix-123" --value "Fixed null check in parser" --namespace solutions --tags "bugfix,auth"
+```
+
+## Search data (semantic / keyword / hybrid)
+
+```bash
+# REQUIRED: --query. OPTIONAL: --namespace, --limit, --threshold, --type
+npx monomind memory search --query "authentication patterns"
+npx monomind memory search --query "JWT" --type keyword
+npx monomind memory search --query "error handling" --namespace patterns --limit 5
+```
+
+| Search 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 (default)  |
+
+Use `--build-hnsw` before searching large memory stores (1,000+ entries) —
+it builds a pure-JS HNSW index for O(log n) queries instead of O(n) linear
+scan (one-time build cost).
+
+## List and retrieve
+
+```bash
+npx monomind memory list --namespace patterns --limit 10
+npx monomind memory retrieve --key "pattern-auth" --namespace patterns
+```
+
+## MCP equivalents
+
+```javascript
+mcp__monomind__memory_store({ key: "pattern-auth", value: "...", namespace: "patterns" })
+mcp__monomind__memory_search({ query: "authentication patterns", namespace: "default", limit: 10, threshold: 0.7, type: "hybrid" })
+```
+
+## After completing non-trivial work
+
+Store what worked so the next session (or agent) doesn't start from zero:
+
+```bash
+npx monomind memory store --key "[short-name]" --value "[what worked and why]" --namespace patterns
+```
+
+See also: `.claude/commands/memory/memory-search.md` for the full flag reference.

package/packages/@monomind/cli/.claude/skills/monodesign/document.md

@@ -16,15 +16,18 @@ Read `reference/document.md` from the monodesign skill directory for the full pr
 
 ## Discovery
 
-**Extract from codebase:**
+**Extract from codebase (monograph-first):**
+```
+# Preferred: monograph for design token discovery
+monograph_query({ query: "CSS custom properties variables tokens" })
+monograph_query({ query: "font-family font-face typography" })
+monograph_query({ query: "color theme palette" })
+```
+
+**Fallback (if monograph returns 0 results or DB not built):**
 ```bash
-# Find CSS custom properties
 grep -r "^--" src/ --include="*.css" --include="*.scss" -h | sort -u
-
-# Find font declarations
 grep -r "font-family\|@font-face\|@import.*font" src/ -h | sort -u
-
-# Find color values
 grep -rE "#[0-9a-fA-F]{3,8}|oklch\(|rgb\(|hsl\(" src/ -h | sort -u | head -50
 ```
 

package/packages/@monomind/cli/.claude/skills/monodesign/extract.md

@@ -17,7 +17,7 @@ Every codebase with more than a few pages has an implicit design system — inco
 ## Discovery Phase
 
 **Color inventory**
-- Collect all color values used in the codebase (grep for `#`, `rgb`, `hsl`, `oklch`)
+- Collect all color values used in the codebase (use `monograph_query({ query: "color rgb hsl oklch" })` first; fall back to grep for `#`, `rgb`, `hsl`, `oklch` if monograph returns 0 results)
 - Group by apparent purpose (backgrounds, text, accents, borders, shadows)
 - Identify the brand anchor color(s)
 - Spot inconsistencies (5 slightly different grays)

package/packages/@monomind/cli/.claude/skills/monodesign/reference/document.md

@@ -81,7 +81,7 @@ Decide by scanning first (Scan mode Step 1). If the scan finds no tokens, no com
 
 Search the codebase in priority order:
 
-1. **CSS custom properties**: grep for `--color-`, `--font-`, `--spacing-`, `--radius-`, `--shadow-`, `--ease-`, `--duration-` declarations in CSS files (usually `src/styles/`, `public/css/`, `app/globals.css`, etc.). Record name, value, and the file it's defined in.
+1. **CSS custom properties**: use `monograph_query({ query: "color font spacing radius shadow ease duration CSS custom property" })` first; fall back to grep for `--color-`, `--font-`, `--spacing-`, `--radius-`, `--shadow-`, `--ease-`, `--duration-` declarations in CSS files if monograph returns 0 results. Record name, value, and the file it's defined in.
 2. **Tailwind config**: if `tailwind.config.{js,ts,mjs}` exists, read the `theme.extend` block for colors, fontFamily, spacing, borderRadius, boxShadow.
 3. **CSS-in-JS theme files**: styled-components, emotion, vanilla-extract, stitches; look for `theme.ts`, `tokens.ts`, or equivalent.
 4. **Design token files**: `tokens.json`, `design-tokens.json`, Style Dictionary output, W3C token community group format.

package/packages/@monomind/cli/.claude/skills/monodesign/reference/live.md

@@ -364,7 +364,7 @@ The goal is the same: give the user three variants to choose from AND persist th
 
 Use the error payload:
 
-- `element_not_in_source` with `generatedMatch: "public/docs/foo.html"`: the served HTML is generated. Find the generator (grep for writers of that path, e.g. `scripts/build-sub-pages.js`, an Astro/Next template) and locate the template or partial that emits this element.
+- `element_not_in_source` with `generatedMatch: "public/docs/foo.html"`: the served HTML is generated. Find the generator (use `monograph_query({ query: "build generate template" })` or `monograph_neighbors` to trace writers of that path; fall back to grep if monograph returns 0 results, e.g. `scripts/build-sub-pages.js`, an Astro/Next template) and locate the template or partial that emits this element.
 - `element_not_found`: the element is runtime-injected. Look for the component that renders it (React/Vue/Svelte), the JS that assembles it, or the data source that feeds it.
 - `file_is_generated` with `file: "..."`: user pointed at a generated file explicitly. Same resolution as `element_not_in_source`.
 

package/packages/@monomind/cli/.claude/skills/monolean/SKILL.md

@@ -45,7 +45,7 @@ take the higher one and move on. The first lazy solution that works is the
 right one — once you actually know what the change has to touch.
 
 **Bug fix = root cause, not symptom.** A report names a symptom. Before you
-edit, grep every caller of the function you're about to touch. The lazy fix IS
+edit, find every caller of the function you're about to touch (use `monograph_neighbors` or `monograph_impact` first; fall back to grep only if monograph returns 0 results). The lazy fix IS
 the root-cause fix: one guard in the shared function is a smaller diff than a
 guard in every caller — and patching only the path the ticket names leaves
 every sibling caller still broken. Fix it once, where all callers route through.