monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/.claude/commands/workflows/research.md

@@ -1,89 +0,0 @@
----
-name: workflows:research
-description: Research workflow coordination pattern — mesh swarm for comprehensive exploration using real MCP tools and npx monomind workflow run -t research
----
-
-# Research Workflow Coordination
-
-Coordinate multi-agent research activities for comprehensive, systematic exploration.
-
-## How to Invoke
-
-```
-Skill("workflows:research")
-```
-
----
-
-## Quick Start
-
-```bash
-# Run the built-in research workflow
-npx monomind workflow run -t research --task "Analyze modern web framework performance"
-
-# Preview stages without executing
-npx monomind workflow run -t research --dry-run
-
-# Show template details
-npx monomind workflow template show research
-```
-
-## Stages
-
-The `research` template runs these stages:
-1. **Discovery** — Identify sources, gather raw information
-2. **Analysis** — Evaluate and compare findings
-3. **Synthesis** — Combine into coherent conclusions
-4. **Documentation** — Write up findings
-
-Agents: `researcher`, `analyst` (mesh topology for broad coverage)
-
-## MCP Coordination
-
-For custom research coordination via MCP:
-
-```javascript
-// Initialize mesh swarm for broad exploration
-mcp__monomind__swarm_init({
-  topology: "mesh",
-  maxAgents: 5,
-  strategy: "balanced"
-})
-
-// Run the research workflow
-mcp__monomind__workflow_run({
-  template: "research",
-  task: "Research modern web frameworks performance",
-  options: { parallel: true, maxAgents: 4 }
-})
-
-// Store research findings in memory
-mcp__monomind__memory_store({
-  key: "research-web-frameworks-2026",
-  value: "React/Next.js leads for SSR; Astro for static; Svelte for performance",
-  namespace: "research"
-})
-
-// Search past research before starting
-mcp__monomind__memory_search({
-  query: "web framework performance analysis",
-  namespace: "research",
-  limit: 5
-})
-```
-
-## What Claude Code Actually Does
-
-1. **WebSearch** tool — finds relevant resources
-2. **Read** tool — analyzes documentation and code
-3. **Task** tool — spawns parallel research agents for different angles
-4. Synthesizes findings in the conversation
-5. Stores insights in memory for future sessions
-
-The workflow template coordinates the research strategy; Claude Code does the actual searching and reading.
-
-## Related Skills
-
-- `workflows:workflow-execute` — Full workflow run reference
-- `swarm:research` — Direct swarm-based research coordination
-- `memory:memory-search` — Search past research findings

package/packages/@monomind/cli/.claude/commands/workflows/workflow-create.md

@@ -1,83 +0,0 @@
----
-name: workflows:workflow-create
-description: Create and save custom workflow templates using npx monomind workflow template create — save successful workflows for reuse
----
-
-# Workflow Create
-
-Create and save custom workflow templates for reuse.
-
-## How to Invoke
-
-```
-Skill("workflows:workflow-create")
-```
-
----
-
-## CLI Reference
-
-```bash
-# Create a template from a workflow ID
-npx monomind workflow template create --name "my-api-workflow" --workflow wf-abc123
-
-# Create a template from a workflow file
-npx monomind workflow template create --name "deploy-workflow" --file ./workflow.yaml
-
-# List existing templates
-npx monomind workflow template list
-
-# Show a specific template's stages and agents
-npx monomind workflow template show development
-```
-
-## Template Create Flags
-
-| Flag | Short | Description |
-|------|-------|-------------|
-| `--name` | `-n` | Template name (required) |
-| `--workflow` | `-w` | Workflow ID to save as template |
-| `--file` | `-f` | Workflow file to save as template |
-
-## MCP Tools
-
-```javascript
-// Create a workflow definition
-mcp__monomind__workflow_create({
-  name: "my-workflow",
-  template: "development",
-  task: "Build auth system"
-})
-
-// List available templates
-mcp__monomind__workflow_template({})
-
-// Execute workflow from template
-mcp__monomind__workflow_run({
-  template: "my-workflow",
-  task: "Build feature X"
-})
-```
-
-## Workflow
-
-1. Run a workflow that works well:
-   ```bash
-   npx monomind workflow run -t development --task "Build auth"
-   # Note the workflowId in the output
-   ```
-
-2. Save it as a reusable template:
-   ```bash
-   npx monomind workflow template create --name "auth-workflow" --workflow <workflowId>
-   ```
-
-3. Reuse it:
-   ```bash
-   npx monomind workflow run -t auth-workflow --task "New auth task"
-   ```
-
-## Related Skills
-
-- `workflows:workflow-execute` — Run workflows from templates
-- `workflows:workflow-export` — Browse and manage templates

package/packages/@monomind/cli/.claude/commands/workflows/workflow-execute.md

@@ -1,101 +0,0 @@
----
-name: workflows:workflow-execute
-description: Run multi-agent workflows using built-in templates (development, research, testing, security-audit, etc.) via real npx monomind workflow run CLI
----
-
-# Workflow Execute
-
-Run multi-agent workflows using built-in templates or custom workflow files.
-
-## How to Invoke
-
-```
-Skill("workflows:workflow-execute")
-```
-
----
-
-## CLI Reference
-
-```bash
-# Run a built-in template
-npx monomind workflow run -t development --task "Build REST API with auth"
-npx monomind workflow run -t research --task "Analyze performance bottlenecks"
-npx monomind workflow run -t testing
-npx monomind workflow run -t security-audit
-
-# Run from a workflow file
-npx monomind workflow run -f ./workflow.yaml
-npx monomind workflow run -f ./workflow.json
-
-# Validate without executing
-npx monomind workflow run -t development --dry-run
-```
-
-## All Flags
-
-| Flag | Short | Default | Description |
-|------|-------|---------|-------------|
-| `--template` | `-t` | — | Built-in template name |
-| `--file` | `-f` | — | Workflow definition file (YAML/JSON) |
-| `--task` | — | — | Task description passed to the workflow |
-| `--parallel` | `-p` | `true` | Enable parallel agent execution |
-| `--max-agents` | `-m` | `5` | Maximum agents to spawn |
-| `--timeout` | — | `30` | Timeout in minutes |
-| `--dry-run` | `-d` | `false` | Validate without executing |
-
-## Built-in Templates
-
-| Template | Stages | Agent Types |
-|----------|--------|-------------|
-| `development` | Planning → Implementation → Testing → Review → Integration | coder, tester, reviewer |
-| `research` | Discovery → Analysis → Synthesis → Documentation | researcher, analyst |
-| `testing` | Unit → Integration → E2E → Performance | tester, coder |
-| `security-audit` | Threat Model → Static → Dynamic → Report | security-architect, auditor |
-| `code-review` | Initial → Security → Quality → Feedback | reviewer, auditor, analyst |
-| `refactoring` | Analysis → Planning → Refactor → Validation | architect, coder, reviewer |
-| `custom` | Define your own | configurable |
-
-## MCP Tools
-
-```javascript
-// Run a workflow
-mcp__monomind__workflow_run({
-  template: "development",
-  task: "Build REST API with auth",
-  options: {
-    parallel: true,
-    maxAgents: 6,
-    timeout: 30,
-    dryRun: false
-  }
-})
-
-// Check workflow status after launch
-mcp__monomind__workflow_status({ workflowId: "wf-123" })
-
-// List all workflows
-mcp__monomind__workflow_list({ status: "running", limit: 10 })
-
-// Stop a running workflow
-mcp__monomind__workflow_cancel({ workflowId: "wf-123" })
-```
-
-## After Launch
-
-Track progress:
-
-```bash
-# Check status by ID (shown after run)
-npx monomind workflow status <workflowId>
-
-# List all running workflows
-npx monomind workflow list --status running
-```
-
-## Related Skills
-
-- `workflows:workflow-create` — Save a custom workflow template
-- `workflows:development` — Development workflow coordination pattern
-- `workflows:research` — Research workflow coordination pattern
-- `swarm:swarm` — Direct swarm init for custom coordination

package/packages/@monomind/cli/.claude/commands/workflows/workflow-export.md

@@ -1,88 +0,0 @@
----
-name: workflows:workflow-export
-description: Browse, inspect, and manage workflow templates — list built-in templates, show template details and stages, validate workflow files
----
-
-# Workflow Templates
-
-Browse and manage workflow templates — inspect built-in templates and validate custom workflow files.
-
-## How to Invoke
-
-```
-Skill("workflows:workflow-export")
-```
-
----
-
-## CLI Reference
-
-```bash
-# List all available templates
-npx monomind workflow template list
-
-# Show details for a specific template (stages, agents, estimated duration)
-npx monomind workflow template show development
-npx monomind workflow template show security-audit
-
-# Validate a custom workflow file
-npx monomind workflow validate -f ./workflow.yaml
-npx monomind workflow validate -f ./workflow.json --strict
-
-# List past workflow runs
-npx monomind workflow list --status completed --limit 20
-npx monomind workflow list --status all
-```
-
-## Built-in Templates Reference
-
-| Template | Stages | Estimated Duration |
-|----------|--------|--------------------|
-| `development` | Planning → Implementation → Testing → Review → Integration | 15-30 min |
-| `research` | Discovery → Analysis → Synthesis → Documentation | 10-20 min |
-| `testing` | Unit → Integration → E2E → Performance | 5-15 min |
-| `security-audit` | Threat Model → Static → Dynamic → Report | 20-40 min |
-| `code-review` | Initial → Security → Quality → Feedback | 10-25 min |
-| `refactoring` | Analysis → Planning → Refactor → Validation | 15-35 min |
-| `custom` | Define your own stages | varies |
-
-## MCP Tools
-
-```javascript
-// List templates
-mcp__monomind__workflow_template({})
-
-// List past workflow runs
-mcp__monomind__workflow_list({ status: "completed", limit: 20 })
-
-// Get status of a specific run
-mcp__monomind__workflow_status({ workflowId: "wf-123" })
-```
-
-## Workflow File Format
-
-To create a custom workflow file for use with `workflow run -f`:
-
-```yaml
-name: my-workflow
-stages:
-  - name: Planning
-    agents: [architect]
-  - name: Implementation
-    agents: [coder]
-  - name: Testing
-    agents: [tester]
-  - name: Review
-    agents: [reviewer]
-```
-
-Validate before running:
-
-```bash
-npx monomind workflow validate -f ./my-workflow.yaml --strict
-```
-
-## Related Skills
-
-- `workflows:workflow-execute` — Run workflows from templates
-- `workflows:workflow-create` — Save a custom workflow as a template

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

@@ -1,323 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-/**
- * skill-registry.json generator
- *
- * Scans the PROJECT-LOCAL skill/command trees and regenerates
- * .claude/helpers/skill-registry.json, which router.cjs's matchSkills()
- * reads to suggest a skill for a routed task.
- *
- * Why this exists: the registry was previously hand-maintained and rotted
- * badly — 28 of 53 entries pointed at skills that had been renamed
- * (lancedb-* -> agentdb-*, bare names -> v3-* prefixes, github:x -> github-x)
- * or deleted outright, while its own _meta claimed router.cjs read it (it
- * didn't — router.cjs had a separate hardcoded 6-entry list, one of which,
- * /graphify, was itself a phantom). Generating from the live tree is the only
- * way this file stays true.
- *
- * Scope is deliberately project-local (.claude/commands, .claude/skills).
- * User-global plugin skills (~/.claude/plugins) are intentionally excluded —
- * this file is committed and shipped, so machine-specific entries would make
- * it wrong for everyone else.
- *
- * Usage:  node .claude/helpers/build-skill-registry.cjs [projectRoot]
- */
-
-var fs = require('fs');
-var path = require('path');
-
-// Words that carry no routing signal — dropped from derived keywords.
-var STOPWORDS = new Set([
-  'the', 'a', 'an', 'and', 'or', 'but', 'for', 'nor', 'so', 'yet', 'of', 'to',
-  'in', 'on', 'at', 'by', 'from', 'with', 'without', 'into', 'onto', 'up',
-  'down', 'out', 'off', 'over', 'under', 'again', 'then', 'once', 'here',
-  'there', 'when', 'where', 'why', 'how', 'all', 'any', 'both', 'each', 'few',
-  'more', 'most', 'other', 'some', 'such', 'only', 'own', 'same', 'than',
-  'too', 'very', 'can', 'will', 'just', 'should', 'now', 'use', 'used',
-  'using', 'uses', 'this', 'that', 'these', 'those', 'it', 'its', 'is', 'are',
-  'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does',
-  'did', 'you', 'your', 'they', 'them', 'their', 'not', 'no', 'if', 'else',
-  'via', 'per', 'across', 'before', 'after', 'while', 'during', 'about',
-  'every', 'also', 'one', 'two', 'new', 'full', 'run', 'runs', 'running',
-  'never', 'always', 'must', 'need', 'needs', 'want', 'wants', 'want',
-]);
-
-var MAX_KEYWORDS = 150;
-
-/** Parse a leading `---` YAML-ish frontmatter block. Handles `key: value`,
- *  quoted values, and `key: |` block scalars (used by several agent files). */
-function readFrontmatter(text) {
-  var out = {};
-  var m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
-  if (!m) return out;
-  var lines = m[1].split(/\r?\n/);
-  var pendingKey = null;
-  var blockLines = [];
-  for (var i = 0; i < lines.length; i++) {
-    var line = lines[i];
-    if (pendingKey) {
-      // Block scalar continues while lines are indented (or blank).
-      if (/^\s+\S/.test(line) || line.trim() === '') {
-        blockLines.push(line.trim());
-        continue;
-      }
-      out[pendingKey] = blockLines.join(' ').trim();
-      pendingKey = null;
-      blockLines = [];
-    }
-    var kv = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
-    if (!kv) continue;
-    var key = kv[1];
-    var val = kv[2].trim();
-    if (val === '|' || val === '>' || val === '|-' || val === '>-') {
-      pendingKey = key;
-      blockLines = [];
-      continue;
-    }
-    // Strip surrounding quotes
-    if ((val.startsWith('"') && val.endsWith('"') && val.length > 1) ||
-        (val.startsWith("'") && val.endsWith("'") && val.length > 1)) {
-      val = val.slice(1, -1);
-    }
-    out[key] = val;
-  }
-  if (pendingKey) out[pendingKey] = blockLines.join(' ').trim();
-  return out;
-}
-
-/** Many commands in this repo carry their summary in a leading HTML comment
- *  instead of frontmatter (e.g. `<!-- Autonomous research -> build loop -->`).
- *  Falls back to that when frontmatter has no description. */
-function readLeadingComment(text) {
-  var m = /^\s*<!--\s*([\s\S]*?)\s*-->/.exec(text);
-  if (!m) return '';
-  var val = m[1].replace(/\s+/g, ' ').trim();
-  if ((val.startsWith('"') && val.endsWith('"') && val.length > 1) ||
-      (val.startsWith("'") && val.endsWith("'") && val.length > 1)) {
-    val = val.slice(1, -1);
-  }
-  return val;
-}
-
-/** Last-resort description: the first `# Heading` in the body. Covers reference
- *  docs under .claude/commands that carry neither frontmatter nor a comment. */
-function readFirstHeading(text) {
-  var m = /^\s*#\s+(.+?)\s*$/m.exec(text);
-  return m ? m[1].replace(/\s+/g, ' ').trim() : '';
-}
-
-/** Terms from the slug/name. Highest routing signal — router weights these
- *  above description terms so "mastermind orgs" ranks /mastermind:orgs over
- *  the ~60 other /mastermind:* commands that merely share the word. Short
- *  tokens are allowed here so slugs like "do" and "ts" stay routable. */
-function deriveNameTerms(name, slug) {
-  var seen = new Set();
-  var out = [];
-  function push(tok) {
-    tok = tok.trim().toLowerCase();
-    if (!tok || seen.has(tok)) return;
-    seen.add(tok);
-    out.push(tok);
-  }
-  String(slug || '').split(/[^A-Za-z0-9]+/).forEach(push);
-  String(name || '').split(/[^A-Za-z0-9]+/).forEach(push);
-  return out;
-}
-
-/** Terms from the description, excluding anything already a name term. */
-function deriveKeywords(description, nameTerms) {
-  var seen = new Set(nameTerms || []);
-  var out = [];
-  var words = String(description || '')
-    .replace(/[^A-Za-z0-9\s-]/g, ' ')
-    .split(/\s+/);
-  for (var i = 0; i < words.length && out.length < MAX_KEYWORDS; i++) {
-    var tok = words[i].trim().toLowerCase();
-    if (tok.length < 3) continue;
-    if (STOPWORDS.has(tok)) continue;
-    if (seen.has(tok)) continue;
-    seen.add(tok);
-    out.push(tok);
-  }
-  return out;
-}
-
-/** True for files/dirs we must never treat as real entries. */
-function isJunk(basename) {
-  // "._foo" are macOS/exFAT resource forks — they parse as garbage entries.
-  // "_foo.md" are shared includes explicitly documented as never-invoked.
-  return basename.startsWith('._') || basename.startsWith('_');
-}
-
-function walkMarkdown(dir, out) {
-  var entries;
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch (e) {
-    return out;
-  }
-  for (var i = 0; i < entries.length; i++) {
-    var e = entries[i];
-    if (isJunk(e.name)) continue;
-    var full = path.join(dir, e.name);
-    if (e.isDirectory()) walkMarkdown(full, out);
-    else if (e.isFile() && e.name.endsWith('.md')) out.push(full);
-  }
-  return out;
-}
-
-/** Scan .claude/commands -> slash-command entries. */
-function scanCommands(root) {
-  var base = path.join(root, '.claude', 'commands');
-  if (!fs.existsSync(base)) return [];
-  var files = walkMarkdown(base, []);
-  var out = [];
-  for (var i = 0; i < files.length; i++) {
-    var file = files[i];
-    var rel = path.relative(base, file).replace(/\\/g, '/');
-    var parts = rel.replace(/\.md$/, '').split('/');
-    // Nested commands are namespaced: mastermind/build.md -> /mastermind:build
-    var invokeName = parts.length > 1 ? parts.join(':') : parts[0];
-    var group = parts.length > 1 ? parts[0] : 'command';
-
-    var text;
-    try { text = fs.readFileSync(file, 'utf-8'); } catch (e) { continue; }
-    var fm = readFrontmatter(text);
-    if (String(fm['user-invocable']).toLowerCase() === 'false') continue;
-
-    var name = fm.name || parts[parts.length - 1];
-    var description = fm.description || readLeadingComment(text) || readFirstHeading(text);
-    var nameTerms = deriveNameTerms(name, invokeName);
-    out.push({
-      skill: invokeName,
-      invoke: '/' + invokeName,
-      kind: 'command',
-      description: description,
-      nameTerms: nameTerms,
-      keywords: deriveKeywords(description, nameTerms),
-      category: group,
-      source: '.claude/commands/' + rel,
-    });
-  }
-  return out;
-}
-
-/** Scan .claude/skills/<name>/SKILL.md -> Skill() entries. */
-function scanSkills(root) {
-  var base = path.join(root, '.claude', 'skills');
-  if (!fs.existsSync(base)) return [];
-  var dirs;
-  try {
-    dirs = fs.readdirSync(base, { withFileTypes: true });
-  } catch (e) {
-    return [];
-  }
-  var out = [];
-  for (var i = 0; i < dirs.length; i++) {
-    var d = dirs[i];
-    if (!d.isDirectory() || isJunk(d.name)) continue;
-    var skillFile = path.join(base, d.name, 'SKILL.md');
-    if (!fs.existsSync(skillFile)) continue;
-
-    var text;
-    try { text = fs.readFileSync(skillFile, 'utf-8'); } catch (e) { continue; }
-    var fm = readFrontmatter(text);
-    if (String(fm['user-invocable']).toLowerCase() === 'false') continue;
-
-    var name = fm.name || d.name;
-    var description = fm.description || readLeadingComment(text) || readFirstHeading(text);
-    var nameTerms = deriveNameTerms(name, d.name);
-    out.push({
-      skill: d.name,
-      invoke: 'Skill("' + d.name + '")',
-      kind: 'skill',
-      description: description,
-      nameTerms: nameTerms,
-      keywords: deriveKeywords(description, nameTerms),
-      category: 'skill',
-      source: '.claude/skills/' + d.name + '/SKILL.md',
-    });
-  }
-  return out;
-}
-
-function build(root) {
-  var entries = scanCommands(root).concat(scanSkills(root));
-
-  // Preserve hand-tuned keywords for entries that still resolve by the same
-  // key, so manual curation isn't blown away on every regeneration.
-  var registryPath = path.join(root, '.claude', 'helpers', 'skill-registry.json');
-  var curated = {};
-  try {
-    var prev = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
-    var prevList = (prev && prev.skills) || [];
-    for (var i = 0; i < prevList.length; i++) {
-      var p = prevList[i];
-      if (p && p.skill && p.curatedKeywords) curated[p.skill] = p.curatedKeywords;
-    }
-  } catch (e) { /* first run / unreadable — nothing to preserve */ }
-
-  for (var j = 0; j < entries.length; j++) {
-    var c = curated[entries[j].skill];
-    if (c && Array.isArray(c) && c.length) {
-      entries[j].curatedKeywords = c;
-      // Curated terms win, derived terms fill the remainder.
-      var merged = c.slice();
-      for (var k = 0; k < entries[j].keywords.length && merged.length < MAX_KEYWORDS; k++) {
-        if (merged.indexOf(entries[j].keywords[k]) === -1) merged.push(entries[j].keywords[k]);
-      }
-      entries[j].keywords = merged;
-    }
-  }
-
-  entries.sort(function (a, b) { return a.skill < b.skill ? -1 : a.skill > b.skill ? 1 : 0; });
-
-  return {
-    _meta: {
-      version: '2.0.0',
-      description:
-        'Auto-generated index of project-local slash commands (.claude/commands) and ' +
-        'skills (.claude/skills). Read by router.cjs matchSkills() to suggest a skill ' +
-        'for a routed task.',
-      generatedBy: '.claude/helpers/build-skill-registry.cjs',
-      regenerate: 'node .claude/helpers/build-skill-registry.cjs',
-      note:
-        'DO NOT hand-edit entries — regeneration overwrites them. To pin keywords for ' +
-        'an entry, add a "curatedKeywords" array to it; those survive regeneration and ' +
-        'take precedence over derived ones.',
-      scope:
-        'Project-local only. User-global plugin skills (~/.claude/plugins) are excluded ' +
-        'on purpose — this file is committed, so machine-specific entries would be wrong ' +
-        'for other checkouts.',
-      counts: {
-        commands: entries.filter(function (e) { return e.kind === 'command'; }).length,
-        skills: entries.filter(function (e) { return e.kind === 'skill'; }).length,
-        total: entries.length,
-      },
-    },
-    skills: entries,
-  };
-}
-
-function main() {
-  var root = process.argv[2] || process.env.CLAUDE_PROJECT_DIR || process.cwd();
-  var registry = build(root);
-  var outPath = path.join(root, '.claude', 'helpers', 'skill-registry.json');
-  var tmp = outPath + '.' + process.pid + '.tmp';
-  fs.writeFileSync(tmp, JSON.stringify(registry, null, 2) + '\n', 'utf-8');
-  fs.renameSync(tmp, outPath);
-  process.stdout.write(
-    'skill-registry.json: ' + registry._meta.counts.total + ' entries (' +
-    registry._meta.counts.commands + ' commands, ' +
-    registry._meta.counts.skills + ' skills)\n'
-  );
-}
-
-if (require.main === module) main();
-
-module.exports = {
-  build: build,
-  readFrontmatter: readFrontmatter,
-  deriveNameTerms: deriveNameTerms,
-  deriveKeywords: deriveKeywords,
-};