monomind 1.19.0 → 2.0.1

package/packages/@monomind/cli/.claude/helpers/intelligence.cjs

@@ -156,6 +156,36 @@ function consolidate() {
   // Clear recent-edits after consolidation (session boundary)
   try { fs.writeFileSync(RECENT_EDITS_FILE, '', 'utf-8'); } catch (_) {}
 
+  // Load session episodes (written by session-handler.cjs into the same
+  // .monomind dir) so patterns can carry real semantic content — the user's
+  // prompt snippet and commit subjects — instead of just file basenames.
+  var episodes = [];
+  var episodeLines = safeReadLines(path.join(CWD, '.monomind', 'episodic', 'episodes.jsonl'));
+  for (var epi = 0; epi < episodeLines.length; epi++) {
+    try { episodes.push(JSON.parse(episodeLines[epi])); } catch (_) {}
+  }
+
+  // Build-noise artifacts that say nothing about what the task actually was.
+  function isNoisePath(p) {
+    var base = path.basename(p);
+    if (base === 'tsconfig.tsbuildinfo' || base === 'coverage.json') return true;
+    if (/\.map$/.test(base)) return true;
+    if (/(^|\/)dist\//.test(p)) return true;
+    return false;
+  }
+
+  // Nearest episode whose end time is within 30 minutes of the outcome.
+  function findEpisodeNear(ts) {
+    var best = null;
+    var bestDelta = 30 * 60 * 1000;
+    for (var ki = 0; ki < episodes.length; ki++) {
+      var cand = episodes[ki];
+      var delta = Math.abs((cand.endedAt || 0) - ts);
+      if (delta <= bestDelta) { bestDelta = delta; best = cand; }
+    }
+    return best;
+  }
+
   // Synthesize successful patterns from outcomes into auto-memory-store.json
   var outcomeLines = safeReadLines(OUTCOMES_FILE);
   var newStoreEntries = [];
@@ -174,19 +204,69 @@ function consolidate() {
         // Use e.path if it's a non-empty string; skip objects without a valid path
         return (e && typeof e.path === 'string' && e.path.length > 0) ? e.path : null;
       }).filter(function(p) { return p !== null; });
-      // Deduplicate paths
+      // Deduplicate paths, dropping build-noise artifacts (tsbuildinfo,
+      // sourcemaps, coverage output, dist/ bundles) so the pattern describes
+      // real source work.
       var uniquePaths = [];
       var pathSeen = {};
       for (var pi = 0; pi < editPaths.length; pi++) {
         var p = String(editPaths[pi]);
+        if (isNoisePath(p)) continue;
         if (!pathSeen[p]) { pathSeen[p] = true; uniquePaths.push(p); }
       }
+      if (uniquePaths.length === 0) continue;
+      var baseNames = uniquePaths.slice(0, 5).map(function(bp) { return path.basename(bp); });
+
+      // Prefer real semantic content for the summary: outcome.context (rare —
+      // only set when getContext matched in the same process), else the
+      // matching episode's prompt snippet + first commit subject.
+      var summary = outcome.context || null;
+      var hasCommits = false;
+      var ep = findEpisodeNear(outcome.ts || Date.now());
+      if (ep && ep.summary) {
+        // Episode summaries are newline-joined parts written by
+        // session-handler: prompt snippet, "Commits: ...", "Modified: ...",
+        // "Outcome: ...".
+        var epParts = String(ep.summary).split('\n');
+        var promptSnippet = '';
+        var commitSubject = '';
+        for (var si = 0; si < epParts.length; si++) {
+          var part = epParts[si].trim();
+          if (!part) continue;
+          if (part.indexOf('Commits: ') === 0) {
+            if (!commitSubject) commitSubject = part.slice(9).split(';')[0].trim();
+          } else if (part.indexOf('Modified: ') !== 0 && part.indexOf('Outcome: ') !== 0 && !promptSnippet) {
+            promptSnippet = part.slice(0, 160);
+          }
+        }
+        hasCommits = commitSubject.length > 0;
+        if (!summary) {
+          var bits = [];
+          if (promptSnippet) bits.push(promptSnippet);
+          if (commitSubject) bits.push('commit: ' + commitSubject);
+          if (bits.length > 0) summary = bits.join(' — ') + ' (files: ' + baseNames.join(', ') + ')';
+        }
+      }
+      if (!summary) summary = 'Successful task editing ' + uniquePaths.length + ' files: ' + baseNames.join(', ');
+
+      // Confidence from evidence rather than a hardcoded constant:
+      //   0.5 base for any successful outcome
+      //   +0.2 when commits back the session (strongest success signal)
+      //   +0.1 when test files were part of the edit set
+      var confidence = 0.5;
+      if (hasCommits) confidence += 0.2;
+      var touchedTests = uniquePaths.some(function(tp) {
+        return /(^|\/)(tests?|__tests__)\//.test(tp) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(tp);
+      });
+      if (touchedTests) confidence += 0.1;
+      confidence = Math.round(confidence * 100) / 100; // avoid FP artifacts like 0.7999…
+
       newStoreEntries.push({
         id: 'auto-' + (outcome.ts || Date.now()) + '-' + i,
         type: 'pattern',
-        content: 'Successful edit pattern: ' + uniquePaths.map(function(p) { return path.basename(p); }).join(', '),
-        summary: outcome.context || 'Successful task editing ' + uniquePaths.length + ' files: ' + uniquePaths.slice(0, 5).map(function(p) { return path.basename(p); }).join(', '),
-        confidence: 0.6,
+        content: 'Successful edit pattern: ' + uniquePaths.map(function(cp) { return path.basename(cp); }).join(', '),
+        summary: summary,
+        confidence: confidence,
         files: uniquePaths,
         ts: outcome.ts || Date.now(),
       });
@@ -198,10 +278,21 @@ function consolidate() {
     var existing = safeReadJson(STORE_FILE);
     var store = Array.isArray(existing) ? existing : [];
     var existingIds = new Set(store.map(function(e) { return e && e.id; }));
+    // Skip near-identical patterns: same summary text or same file set as an
+    // entry already in the store (or one added earlier in this batch).
+    var fileSetKey = function(e) { return (e.files || []).slice().sort().join('|'); };
+    var seenSummaries = new Set(store.map(function(e) { return e && e.summary; }));
+    var seenFileSets = new Set(store.filter(function(e) { return e && Array.isArray(e.files) && e.files.length > 0; }).map(fileSetKey));
+    var addedCount = 0;
     for (var j = 0; j < newStoreEntries.length; j++) {
-      if (!existingIds.has(newStoreEntries[j].id)) {
-        store.push(newStoreEntries[j]);
-      }
+      var ne = newStoreEntries[j];
+      if (existingIds.has(ne.id)) continue;
+      if (seenSummaries.has(ne.summary)) continue;
+      if (ne.files && ne.files.length > 0 && seenFileSets.has(fileSetKey(ne))) continue;
+      store.push(ne);
+      seenSummaries.add(ne.summary);
+      if (ne.files && ne.files.length > 0) seenFileSets.add(fileSetKey(ne));
+      addedCount++;
     }
     // Cap store at 200 entries to prevent unbounded growth
     if (store.length > 200) {
@@ -211,7 +302,7 @@ function consolidate() {
     try {
       fs.writeFileSync(STORE_FILE, JSON.stringify(store, null, 2), 'utf-8');
     } catch (_) {}
-    count += newStoreEntries.length;
+    count += addedCount;
   }
 
   // Rotate outcomes: keep last 500 lines to prevent unbounded growth
@@ -221,7 +312,7 @@ function consolidate() {
     } catch (_) {}
   }
 
-  return { entries: count, edges: 0, newEntries: newStoreEntries.length };
+  return { entries: count, edges: 0, newEntries: addedCount || 0 };
 }
 
 // ── feedback ──────────────────────────────────────────────────────────────────

package/packages/@monomind/cli/.claude/helpers/router.cjs

@@ -171,9 +171,6 @@ var SKILLS = [
   { skill: 'graphify', invoke: '/graphify', description: 'Input to knowledge graph',
     keywords: /\b(graph|knowledge|monograph|node|edge|visualize)\b/ig,
     _terms: ['graph','knowledge','monograph','node','edge','visualize'] },
-  { skill: 'sparc', invoke: '/sparc', description: 'SPARC methodology',
-    keywords: /\b(sparc|specification|pseudocode|refinement|methodology)\b/ig,
-    _terms: ['sparc','specification','pseudocode','refinement','methodology'] },
   { skill: 'monobrowse', invoke: '/monobrowse', description: 'Browser automation via CDP',
     keywords: /\b(browse|browser|webpage|screenshot|navigate|selenium|puppeteer|cdp)\b/ig,
     _terms: ['browse','browser','webpage','screenshot','navigate','selenium','puppeteer','cdp'] },
@@ -182,6 +179,82 @@ var SKILLS = [
     _terms: ['tokens','token-usage','cost','spending','budget'] },
 ];
 
+// ── Feedback weight system ────────────────────────────────────────────────────
+// Reads routing-feedback.jsonl (written by session-handler at session-end) and
+// computes per-agent success rates. Adjusts routing confidence by up to +/-0.10
+// so agents with proven track records get a slight boost and poor performers get
+// dampened. Cached with a 60-second TTL to avoid repeated disk reads.
+
+var _feedbackWeightsCache = null;
+var _feedbackWeightsCacheTs = 0;
+var FEEDBACK_TTL_MS = 60000;
+
+function loadFeedbackWeights() {
+  var now = Date.now();
+  if (_feedbackWeightsCache && (now - _feedbackWeightsCacheTs) < FEEDBACK_TTL_MS) {
+    return _feedbackWeightsCache;
+  }
+  var weights = {};
+  try {
+    var fs = require('fs');
+    var path = require('path');
+    var cwd = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    var feedbackPath = path.join(cwd, '.monomind', 'routing-feedback.jsonl');
+    var MAX_SIZE = 512 * 1024;
+    if (!fs.existsSync(feedbackPath)) {
+      _feedbackWeightsCache = weights;
+      _feedbackWeightsCacheTs = now;
+      return weights;
+    }
+    var stat = fs.statSync(feedbackPath);
+    if (stat.size > MAX_SIZE) {
+      _feedbackWeightsCache = weights;
+      _feedbackWeightsCacheTs = now;
+      return weights;
+    }
+    var lines = fs.readFileSync(feedbackPath, 'utf-8').trim().split('\n').filter(Boolean);
+    // Use last 200 entries for weight calculation
+    var recent = lines.slice(-200);
+    var agentStats = {};
+    for (var i = 0; i < recent.length; i++) {
+      try {
+        var entry = JSON.parse(recent[i]);
+        var agent = entry.suggestedAgent;
+        if (!agent) continue;
+        // Skip no-evidence records (sessionSuccess null/missing) — they carry no signal
+        if (typeof entry.intelligenceFeedback !== 'boolean') continue;
+        if (!agentStats[agent]) agentStats[agent] = { total: 0, successes: 0 };
+        agentStats[agent].total++;
+        if (entry.intelligenceFeedback === true) agentStats[agent].successes++;
+      } catch (e) {}
+    }
+    // Compute weight adjustments: agents with >= 5 data points get a weight
+    // successRate > 0.7 → positive boost (up to +0.10)
+    // successRate < 0.4 → negative dampen (down to -0.10)
+    // In between → neutral (0)
+    for (var ag in agentStats) {
+      var s = agentStats[ag];
+      if (s.total < 5) continue;
+      var rate = s.successes / s.total;
+      if (rate > 0.7) {
+        weights[ag] = Math.min(0.10, (rate - 0.7) * 0.33);
+      } else if (rate < 0.4) {
+        weights[ag] = Math.max(-0.10, (rate - 0.4) * 0.25);
+      }
+    }
+  } catch (e) { /* non-fatal */ }
+  _feedbackWeightsCache = weights;
+  _feedbackWeightsCacheTs = now;
+  return weights;
+}
+
+function applyFeedbackWeight(agentSlug, baseConfidence) {
+  var weights = loadFeedbackWeights();
+  var adj = weights[agentSlug] || weights[TASK_AGENTS[agentSlug]] || 0;
+  if (adj === 0) return baseConfidence;
+  return Math.max(0, Math.min(1.0, baseConfidence + adj));
+}
+
 // ── Utilities ─────────────────────────────────────────────────────────────────
 
 var MAX_PROMPT = 2000;
@@ -215,7 +288,7 @@ function routeTask(prompt) {
     return {
       agent: topExtra.name,
       agentSlug: topExtra.slug,
-      confidence: 0.80,
+      confidence: applyFeedbackWeight(topExtra.slug, 0.80),
       reason: 'Domain: ' + topExtra.category,
       semanticRouting: false,
       specificAgents: extras,
@@ -237,7 +310,7 @@ function routeTask(prompt) {
     if (slug === 'coder' && hasStrongSkill) continue;
     var pattern = _ROUTING_PATTERNS[slug];
     if (pattern && pattern.test(safePrompt)) {
-      var confidence = TASK_CONFIDENCES[slug] || 0.75;
+      var confidence = applyFeedbackWeight(slug, TASK_CONFIDENCES[slug] || 0.75);
       return {
         agent: TASK_AGENTS[slug],
         agentSlug: slug,

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/helpers/token-tracker.cjs

@@ -14,6 +14,11 @@ const path = require('path');
 const WEB_SEARCH_COST = 0.01;
 
 const FALLBACK_PRICING = {
+  'claude-fable-5':   { in: 10e-6, out: 50e-6, cw: 12.5e-6, cr: 1e-6,   fast: 1 },
+  'claude-mythos-5':  { in: 10e-6, out: 50e-6, cw: 12.5e-6, cr: 1e-6,   fast: 1 },
+  'claude-opus-4-8':  { in: 5e-6, out: 25e-6, cw: 6.25e-6, cr: 0.5e-6,  fast: 6 },
+  'claude-opus-4-7':  { in: 5e-6, out: 25e-6, cw: 6.25e-6, cr: 0.5e-6,  fast: 6 },
+  'claude-sonnet-5':  { in: 3e-6, out: 15e-6, cw: 3.75e-6, cr: 0.3e-6,  fast: 1 },
   'claude-opus-4-6':  { in: 5e-6, out: 25e-6, cw: 6.25e-6, cr: 0.5e-6,  fast: 6 },
   'claude-opus-4-5':  { in: 5e-6, out: 25e-6, cw: 6.25e-6, cr: 0.5e-6,  fast: 1 },
   'claude-opus-4-1':  { in: 15e-6, out: 75e-6, cw: 18.75e-6, cr: 1.5e-6, fast: 1 },
@@ -32,6 +37,11 @@ const FALLBACK_PRICING = {
 };
 
 const SHORT_MODEL_NAMES = {
+  'claude-fable-5': 'Fable 5',
+  'claude-mythos-5': 'Mythos 5',
+  'claude-opus-4-8': 'Opus 4.8',
+  'claude-opus-4-7': 'Opus 4.7',
+  'claude-sonnet-5': 'Sonnet 5',
   'claude-opus-4-6': 'Opus 4.6',
   'claude-opus-4-5': 'Opus 4.5',
   'claude-opus-4-1': 'Opus 4.1',

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