monomind 1.18.15 → 1.19.0

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

package/packages/@monomind/cli/bin/mcp-server.js

@@ -97,7 +97,16 @@ async function handleMessage(message) {
 
   try {
     switch (message.method) {
-      case 'initialize':
+      case 'initialize': {
+        const roots = params.roots ?? params.workspaceFolders ?? [];
+        if (roots.length > 0 && !process.env.MONOMIND_CWD) {
+          const rootUri = typeof roots[0] === 'string' ? roots[0] : (roots[0].uri ?? roots[0].path ?? '');
+          const rootPath = rootUri.startsWith('file://') ? decodeURIComponent(rootUri.slice(7)) : rootUri;
+          if (rootPath) {
+            process.env.MONOMIND_CWD = rootPath;
+            console.error(`[${new Date().toISOString()}] INFO [monomind-mcp] Project root set to ${rootPath}`);
+          }
+        }
         return {
           jsonrpc: '2.0',
           id: message.id,
@@ -110,6 +119,7 @@ async function handleMessage(message) {
             },
           },
         };
+      }
 
       case 'tools/list': {
         const tools = listMCPTools();

package/packages/@monomind/cli/dist/src/commands/agent-ops.d.ts

@@ -1,9 +1,8 @@
 /**
- * Agent operational commands — metrics, pool, health, logs
+ * Agent operational commands — metrics, pool, health
  */
 import type { Command } from '../types.js';
 export declare const metricsCommand: Command;
 export declare const poolCommand: Command;
 export declare const healthCommand: Command;
-export declare const logsCommand: Command;
 //# sourceMappingURL=agent-ops.d.ts.map

package/packages/@monomind/cli/dist/src/commands/agent-ops.js

@@ -1,5 +1,5 @@
 /**
- * Agent operational commands — metrics, pool, health, logs
+ * Agent operational commands — metrics, pool, health
  */
 import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
@@ -268,62 +268,4 @@ export const healthCommand = {
         }
     },
 };
-// ─── logs subcommand ─────────────────────────────────────────────────────────
-function formatLogLevel(level) {
-    switch (level) {
-        case 'debug': return output.dim('[DEBUG]');
-        case 'info': return '[INFO] ';
-        case 'warn': return output.warning('[WARN] ');
-        case 'error': return output.error('[ERROR]');
-        default: return `[${level.toUpperCase()}]`;
-    }
-}
-export const logsCommand = {
-    name: 'logs',
-    description: 'Show agent activity logs',
-    options: [
-        { name: 'id', short: 'i', description: 'Agent ID', type: 'string' },
-        { name: 'tail', short: 'n', description: 'Number of recent entries', type: 'number', default: 50 },
-        { name: 'level', short: 'l', description: 'Minimum log level', type: 'string', choices: ['debug', 'info', 'warn', 'error'], default: 'info' },
-        { name: 'follow', short: 'f', description: 'Follow log output', type: 'boolean', default: false },
-        { name: 'since', description: 'Show logs since (e.g., "1h", "30m")', type: 'string' },
-    ],
-    examples: [
-        { command: 'monomind agent logs -i agent-001', description: 'Show agent logs' },
-        { command: 'monomind agent logs -i agent-001 -f', description: 'Follow agent logs' },
-        { command: 'monomind agent logs -l error --since 1h', description: 'Show errors from last hour' },
-    ],
-    action: async (ctx) => {
-        const agentId = ((ctx.args[0] || ctx.flags.id) ?? '').slice(0, 128);
-        const tail = ctx.flags.tail;
-        const level = ctx.flags.level?.slice(0, 32);
-        if (!agentId) {
-            output.printError('Agent ID is required. Use --id or -i');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('agent_logs', { agentId, tail, level, since: ctx.flags.since });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold(`Logs for ${agentId}`));
-            output.writeln(output.dim(`Showing ${result.entries.length} of ${result.total} entries`));
-            output.writeln();
-            for (const entry of result.entries) {
-                const time = new Date(entry.timestamp).toLocaleTimeString();
-                output.writeln(`${output.dim(time)} ${formatLogLevel(entry.level)} ${entry.message}`);
-                if (entry.context && Object.keys(entry.context).length > 0) {
-                    output.writeln(output.dim(`  ${JSON.stringify(entry.context)}`));
-                }
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(error instanceof MCPClientError ? `Logs error: ${error.message}` : `Unexpected error: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
 //# sourceMappingURL=agent-ops.js.map

package/packages/@monomind/cli/dist/src/commands/agent.js

@@ -4,11 +4,11 @@
  */
 import { output } from '../output.js';
 import { spawnCommand, listCommand, statusCommand, stopCommand } from './agent-lifecycle.js';
-import { metricsCommand, poolCommand, healthCommand, logsCommand } from './agent-ops.js';
+import { metricsCommand, poolCommand, healthCommand } from './agent-ops.js';
 export const agentCommand = {
     name: 'agent',
     description: 'Agent management commands',
-    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand, logsCommand],
+    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand],
     options: [],
     examples: [
         { command: 'monomind agent spawn -t coder', description: 'Spawn a coder agent' },
@@ -30,7 +30,6 @@ export const agentCommand = {
             `${output.highlight('metrics')}       - Show agent metrics`,
             `${output.highlight('pool')}          - Manage agent pool`,
             `${output.highlight('health')}        - Show agent health`,
-            `${output.highlight('logs')}          - Show agent logs`,
         ]);
         output.writeln();
         output.writeln('Run "monomind agent <subcommand> --help" for subcommand help');

package/packages/@monomind/cli/dist/src/commands/analyze-diff.js

@@ -236,7 +236,7 @@ export const diffCommand = {
         }
     },
 };
-// Code subcommand (placeholder for future code analysis)
+// Code subcommand
 export const codeCommand = {
     name: 'code',
     description: 'Static code analysis and quality assessment',

package/packages/@monomind/cli/dist/src/commands/browse-action.js

@@ -130,8 +130,100 @@ const runSubcommand = {
         { name: 'port', type: 'number', description: 'CDP port', default: 9222 },
     ],
     action: async (ctx) => {
-        output.printInfo('Direct action run is coming soon. Use workflow run to execute actions.');
-        return { success: true };
+        const actionId = ctx.args[0];
+        if (!actionId) {
+            output.printError('Action ID required. Usage: monomind browse action run <action-id>');
+            return { success: false, exitCode: 1 };
+        }
+        const port = ctx.flags.port ?? 9222;
+        const paramsRaw = ctx.flags.params ?? [];
+        const params = {};
+        for (const pair of paramsRaw) {
+            const eq = pair.indexOf('=');
+            if (eq > 0)
+                params[pair.slice(0, eq)] = pair.slice(eq + 1);
+        }
+        const customDir = join(ctx.cwd, '.monomind', 'actions');
+        const filename = actionId.replace(/[^a-z0-9_-]/gi, '_') + '.json';
+        let def;
+        try {
+            def = JSON.parse(await readFile(join(customDir, filename), 'utf8'));
+        }
+        catch {
+            output.printError(`Action not found: ${actionId}. Run "monomind browse action list" to see available actions.`);
+            return { success: false, exitCode: 1 };
+        }
+        output.printInfo(`Running action: ${def.id} (${def.steps.length} steps)`);
+        try {
+            const { connectToTarget, openUrl, clickElement, fillElement, evaluateJs, findBySelector, waitFor } = await import('@monoes/monobrowse');
+            const { client, sessionId } = await connectToTarget(port);
+            const refs = new Map();
+            const interpolate = (s) => s.replace(/\{\{(\w+)\}\}/g, (_, k) => params[k] ?? `{{${k}}}`);
+            for (const step of def.steps) {
+                switch (step.type) {
+                    case 'navigate':
+                        await openUrl(client, sessionId, interpolate(step.url));
+                        output.writeln(output.dim(`  navigate -> ${step.url}`));
+                        break;
+                    case 'find':
+                        for (const sel of step.selectors ?? []) {
+                            const found = await findBySelector(client, sessionId, refs, interpolate(sel)).catch(() => null);
+                            if (found) {
+                                refs.set(step.as, found);
+                                break;
+                            }
+                        }
+                        output.writeln(output.dim(`  find -> ${step.as}`));
+                        break;
+                    case 'click': {
+                        const ref = refs.get(step.target);
+                        if (!ref)
+                            throw new Error(`Element "${step.target}" not found`);
+                        await clickElement(client, sessionId, ref);
+                        output.writeln(output.dim(`  click -> ${step.target}`));
+                        break;
+                    }
+                    case 'type': {
+                        const ref = refs.get(step.target);
+                        if (!ref)
+                            throw new Error(`Element "${step.target}" not found`);
+                        await fillElement(client, sessionId, ref, interpolate(step.text));
+                        output.writeln(output.dim(`  type -> ${step.target}`));
+                        break;
+                    }
+                    case 'wait':
+                        if (step.condition === 'network_idle')
+                            await waitFor(client, sessionId, { load: 'networkidle', timeout: step.timeout });
+                        else if (step.condition === 'selector')
+                            await waitFor(client, sessionId, { selector: step.selector, timeout: step.timeout });
+                        else if (step.condition === 'duration')
+                            await new Promise(r => setTimeout(r, step.timeout ?? 1000));
+                        output.writeln(output.dim(`  wait -> ${step.condition}`));
+                        break;
+                    case 'extract': {
+                        const ref = refs.get(step.target);
+                        if (!ref)
+                            throw new Error(`Element "${step.target}" not found`);
+                        const val = await evaluateJs(client, sessionId, `document.querySelector('[data-ref="${ref.ref}"]')?.textContent`);
+                        output.writeln(output.dim(`  extract -> ${step.as}: ${val}`));
+                        break;
+                    }
+                    case 'condition': {
+                        const result = await evaluateJs(client, sessionId, step.expression);
+                        if (result) {
+                            output.writeln(output.dim('  condition -> true branch'));
+                        }
+                        break;
+                    }
+                }
+            }
+            output.printSuccess(`Action ${def.id} completed successfully.`);
+            return { success: true };
+        }
+        catch (err) {
+            output.printError(`Action failed: ${err.message}`);
+            return { success: false, exitCode: 1 };
+        }
     },
 };
 export const browseActionCommand = {

package/packages/@monomind/cli/dist/src/commands/completions.js

@@ -8,20 +8,20 @@ import { output } from '../output.js';
 // Get all top-level commands for completions
 const TOP_LEVEL_COMMANDS = [
     'swarm', 'agent', 'task', 'session', 'config', 'memory', 'workflow',
-    'hive-mind', 'hooks', 'daemon', 'neural', 'security', 'performance',
-    'providers', 'deployment', 'claims', 'embeddings',
+    'hive-mind', 'hooks', 'daemon', 'security', 'performance',
+    'providers', 'claims', 'embeddings',
     'doctor', 'completions', 'help', 'version'
 ];
 // Swarm subcommands
-const SWARM_SUBCOMMANDS = ['init', 'status', 'scale', 'destroy', 'monitor', 'optimize'];
+const SWARM_SUBCOMMANDS = ['init', 'status', 'scale', 'destroy', 'monitor'];
 // Agent subcommands
 const AGENT_SUBCOMMANDS = ['spawn', 'terminate', 'status', 'list', 'pool', 'health', 'update'];
 // Task subcommands
 const TASK_SUBCOMMANDS = ['create', 'status', 'list', 'complete', 'cancel'];
 // Memory subcommands
-const MEMORY_SUBCOMMANDS = ['store', 'retrieve', 'search', 'list', 'delete', 'stats', 'configure', 'cleanup', 'compress', 'export', 'import'];
+const MEMORY_SUBCOMMANDS = ['store', 'retrieve', 'search', 'list', 'delete', 'stats', 'configure', 'export', 'import'];
 // Hive-mind subcommands
-const HIVE_MIND_SUBCOMMANDS = ['init', 'spawn', 'status', 'task', 'join', 'leave', 'consensus', 'broadcast', 'memory', 'optimize-memory', 'shutdown'];
+const HIVE_MIND_SUBCOMMANDS = ['init', 'spawn', 'status', 'join', 'leave', 'consensus', 'broadcast', 'memory', 'shutdown'];
 // Hooks subcommands
 const HOOKS_SUBCOMMANDS = ['pre-edit', 'post-edit', 'pre-command', 'post-command', 'pre-task', 'post-task', 'route', 'explain', 'pretrain', 'build-agents', 'metrics', 'transfer', 'list', 'intelligence'];
 // Generate bash completion script
@@ -69,20 +69,12 @@ _monomind_completions() {
             COMPREPLY=( $(compgen -W "\${hooks_commands}" -- "\${cur}") )
             return 0
             ;;
-        neural)
-            COMPREPLY=( $(compgen -W "train status patterns predict optimize" -- "\${cur}") )
-            return 0
-            ;;
         security)
-            COMPREPLY=( $(compgen -W "scan cve threats audit secrets" -- "\${cur}") )
+            COMPREPLY=( $(compgen -W "scan cve audit secrets" -- "\${cur}") )
             return 0
             ;;
         performance)
-            COMPREPLY=( $(compgen -W "benchmark profile metrics optimize bottleneck" -- "\${cur}") )
-            return 0
-            ;;
-        deployment|deploy)
-            COMPREPLY=( $(compgen -W "deploy status rollback history environments logs" -- "\${cur}") )
+            COMPREPLY=( $(compgen -W "benchmark profile metrics bottleneck" -- "\${cur}") )
             return 0
             ;;
         claims)
@@ -139,11 +131,9 @@ _monomind() {
         'hive-mind:Queen-led consensus coordination'
         'hooks:Self-learning automation hooks'
         'daemon:Background service management'
-        'neural:Neural pattern training'
         'security:Security scanning and CVE detection'
         'performance:Performance profiling'
         'providers:AI provider management'
-        'deployment:Deployment management'
         'claims:Claims-based authorization'
         'embeddings:Vector embeddings'
         'doctor:System diagnostics'
@@ -170,7 +160,6 @@ _monomind() {
                         'scale:Scale agent count'
                         'destroy:Shutdown swarm'
                         'monitor:Real-time monitoring'
-                        'optimize:Optimize topology'
                     )
                     ;;
                 agent)
@@ -202,8 +191,6 @@ _monomind() {
                         'delete:Delete entry'
                         'stats:Show statistics'
                         'configure:Configure backend'
-                        'cleanup:Clean stale data'
-                        'compress:Compress storage'
                         'export:Export to file'
                         'import:Import from file'
                     )
@@ -213,13 +200,11 @@ _monomind() {
                         'init:Initialize hive mind'
                         'spawn:Spawn worker agents'
                         'status:Show hive status'
-                        'task:Submit task'
                         'join:Join agent to hive'
                         'leave:Remove agent'
                         'consensus:Consensus management'
                         'broadcast:Broadcast message'
                         'memory:Shared memory'
-                        'optimize-memory:Optimize patterns'
                         'shutdown:Shutdown hive'
                     )
                     ;;
@@ -241,20 +226,10 @@ _monomind() {
                         'intelligence:Neural intelligence commands'
                     )
                     ;;
-                neural)
-                    subcommands=(
-                        'train:Train neural patterns'
-                        'status:Check neural status'
-                        'patterns:Manage patterns'
-                        'predict:Make predictions'
-                        'optimize:Optimize models'
-                    )
-                    ;;
                 security)
                     subcommands=(
                         'scan:Security scan'
                         'cve:CVE detection'
-                        'threats:Threat modeling'
                         'audit:Security audit'
                         'secrets:Secrets scanning'
                     )
@@ -264,20 +239,9 @@ _monomind() {
                         'benchmark:Run benchmarks'
                         'profile:Profile code'
                         'metrics:Show metrics'
-                        'optimize:Optimize performance'
                         'bottleneck:Find bottlenecks'
                     )
                     ;;
-                deployment|deploy)
-                    subcommands=(
-                        'deploy:Deploy to environment'
-                        'status:Deployment status'
-                        'rollback:Rollback version'
-                        'history:Deployment history'
-                        'environments:List environments'
-                        'logs:View logs'
-                    )
-                    ;;
                 claims)
                     subcommands=(
                         'list:List claims'
@@ -355,17 +319,11 @@ ${HIVE_MIND_SUBCOMMANDS.map(sub => `complete -c monomind -n "__fish_seen_subcomm
 # Hooks subcommands
 ${HOOKS_SUBCOMMANDS.map(sub => `complete -c monomind -n "__fish_seen_subcommand_from hooks" -a "${sub}"`).join('\n')}
 
-# Neural subcommands
-complete -c monomind -n "__fish_seen_subcommand_from neural" -a "train status patterns predict optimize"
-
 # Security subcommands
-complete -c monomind -n "__fish_seen_subcommand_from security" -a "scan cve threats audit secrets"
+complete -c monomind -n "__fish_seen_subcommand_from security" -a "scan cve audit secrets"
 
 # Performance subcommands
-complete -c monomind -n "__fish_seen_subcommand_from performance" -a "benchmark profile metrics optimize bottleneck"
-
-# Deployment subcommands
-complete -c monomind -n "__fish_seen_subcommand_from deployment deploy" -a "deploy status rollback history environments logs"
+complete -c monomind -n "__fish_seen_subcommand_from performance" -a "benchmark profile metrics bottleneck"
 
 # Claims subcommands
 complete -c monomind -n "__fish_seen_subcommand_from claims" -a "list check grant revoke roles policies"
@@ -398,11 +356,8 @@ $script:SubCommands = @{
     'hive-mind' = @('${HIVE_MIND_SUBCOMMANDS.join("', '")}')
     'hive' = @('${HIVE_MIND_SUBCOMMANDS.join("', '")}')
     'hooks' = @('${HOOKS_SUBCOMMANDS.join("', '")}')
-    'neural' = @('train', 'status', 'patterns', 'predict', 'optimize')
-    'security' = @('scan', 'cve', 'threats', 'audit', 'secrets')
-    'performance' = @('benchmark', 'profile', 'metrics', 'optimize', 'bottleneck')
-    'deployment' = @('deploy', 'status', 'rollback', 'history', 'environments', 'logs')
-    'deploy' = @('deploy', 'status', 'rollback', 'history', 'environments', 'logs')
+    'security' = @('scan', 'cve', 'audit', 'secrets')
+    'performance' = @('benchmark', 'profile', 'metrics', 'bottleneck')
     'claims' = @('list', 'check', 'grant', 'revoke', 'roles', 'policies')
     'embeddings' = @('generate', 'search', 'compare', 'collections', 'index', 'providers')
     'daemon' = @('start', 'stop', 'status', 'trigger', 'enable')

package/packages/@monomind/cli/dist/src/commands/doctor-project-checks.d.ts

@@ -19,7 +19,7 @@ export declare function checkGitignoreCoverage(): Promise<HealthCheck>;
 export declare function checkAgentRegistry(): Promise<HealthCheck>;
 export declare function checkGuidanceGates(): Promise<HealthCheck>;
 /**
- * AutoMem proficiency check — reports memory learning health (arXiv:2607.01224)
+ * AutoMem proficiency check — reports memory learning health
  */
 export declare function checkMemoryProficiency(): Promise<HealthCheck>;
 //# sourceMappingURL=doctor-project-checks.d.ts.map

package/packages/@monomind/cli/dist/src/commands/doctor-project-checks.js

@@ -446,7 +446,7 @@ export async function checkGuidanceGates() {
     }
 }
 /**
- * AutoMem proficiency check — reports memory learning health (arXiv:2607.01224)
+ * AutoMem proficiency check — reports memory learning health
  */
 export async function checkMemoryProficiency() {
     try {

package/packages/@monomind/cli/dist/src/commands/hive-mind-helpers.js

@@ -18,8 +18,8 @@ export const TOPOLOGIES = [
 export const CONSENSUS_STRATEGIES = [
     { value: 'byzantine', label: 'Byzantine Fault Tolerant', hint: '2/3 majority, handles malicious actors' },
     { value: 'raft', label: 'Raft', hint: 'Leader-based consensus' },
-    { value: 'gossip', label: 'Gossip', hint: 'Eventually consistent, scalable' },
-    { value: 'crdt', label: 'CRDT', hint: 'Conflict-free replicated data' },
+    { value: 'gossip', label: 'Gossip', hint: 'Eventually consistent, scalable (planned — not yet implemented)' },
+    { value: 'crdt', label: 'CRDT', hint: 'Conflict-free replicated data (planned — not yet implemented)' },
     { value: 'quorum', label: 'Quorum', hint: 'Simple majority voting' }
 ];
 export function groupWorkersByType(workers) {

package/packages/@monomind/cli/dist/src/commands/hive-mind-ops.d.ts

@@ -1,8 +1,6 @@
 /**
- * Hive Mind operational subcommands — status, task, optimize-memory
+ * Hive Mind operational subcommands — status
  */
 import type { Command } from '../types.js';
 export declare const statusCommand: Command;
-export declare const taskCommand: Command;
-export declare const optimizeMemoryCommand: Command;
 //# sourceMappingURL=hive-mind-ops.d.ts.map