@monoes/monomindcli 1.18.15 → 2.0.0

package/.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/.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/.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/.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/.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/.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/.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/.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/.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/.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/.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/.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/.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/.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/.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/.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.

package/.claude/skills/specialagent/SKILL.md

@@ -62,7 +62,7 @@ The available domains and their agent counts are:
 Once the domain is selected, use only the agent names for that domain:
 
 ### development
-sparc-coder, coder, backend-dev, Frontend Developer, mobile-dev, ml-developer, Rapid Prototyper, base-template-generator, LSP/Index Engineer, macOS Spatial/Metal Engineer, Terminal Integration Specialist, Embedded Firmware Engineer, Solidity Smart Contract Engineer, WeChat Mini Program Developer, Feishu Integration Developer, Roblox Systems Scripter, Godot Gameplay Scripter, Unity Architect, Unreal Systems Engineer, visionOS Spatial Engineer
+coder, backend-dev, Frontend Developer, mobile-dev, ml-developer, Rapid Prototyper, base-template-generator, LSP/Index Engineer, macOS Spatial/Metal Engineer, Terminal Integration Specialist, Embedded Firmware Engineer, Solidity Smart Contract Engineer, WeChat Mini Program Developer, Feishu Integration Developer, Roblox Systems Scripter, Godot Gameplay Scripter, Unity Architect, Unreal Systems Engineer, visionOS Spatial Engineer
 
 ### testing
 tdd-london-swarm, API Tester, production-validator, Evidence Collector, agent-browser-testing, Accessibility Auditor, Reality Checker, Code Reviewer, code-analyzer, feature-dev:code-reviewer
@@ -80,7 +80,7 @@ Data Engineer, AI Engineer, Database Optimizer, AI Data Remediation Engineer, Mo
 system-architect, Software Architect, Backend Architect, Plan, UX Architect, Workflow Architect
 
 ### research
-sparc:researcher, Explore, Trend Researcher, Technical Writer, api-docs
+Explore, Trend Researcher, Technical Writer, api-docs
 
 ### marketing
 AI Citation Strategist, App Store Optimizer, Baidu SEO Specialist, Bilibili Content Strategist, Carousel Growth Engine, China E-Commerce Operator, Content Creator, Cross-Border E-Commerce Specialist, Developer Advocate, Douyin Strategist, Growth Hacker, Healthcare Marketing Compliance Specialist, Instagram Curator, Kuaishou Strategist, LinkedIn Content Creator, Podcast Strategist, Reddit Community Builder, SEO Specialist, Short-Video Editing Coach, Social Media Strategist, TikTok Strategist, Twitter Engager, WeChat Official Account Manager, Weibo Strategist, Xiaohongshu Specialist, Zhihu Strategist, Livestream Commerce Coach
@@ -125,7 +125,6 @@ Analytics Reporter, Executive Summary Generator, Finance Tracker, Support Respon
 Use this to convert the chosen agent name to a callable slug:
 
 ```
-sparc-coder → sparc-coder
 coder → coder
 backend-dev → backend-dev
 Frontend Developer → Frontend Developer
@@ -158,7 +157,6 @@ Software Architect → Software Architect
 Backend Architect → Backend Architect
 Plan → Plan
 UX Architect → UX Architect
-sparc:researcher → sparc:researcher
 Explore → Explore
 Trend Researcher → Trend Researcher
 Technical Writer → Technical Writer