monomind 1.17.0 → 1.17.2

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

@@ -572,7 +572,7 @@ const importCommand = {
             : path.join(ctx.cwd, filePath);
         // Path traversal protection: resolved path must stay within cwd or home
         const resolvedPath = path.resolve(absolutePath);
-        const cwd = process.cwd();
+        const cwd = ctx.cwd || process.cwd();
         const home = process.env.HOME || '';
         const underCwd = resolvedPath === cwd || resolvedPath.startsWith(cwd + path.sep);
         const underHome = home && (resolvedPath === home || resolvedPath.startsWith(home + path.sep));

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

@@ -635,30 +635,36 @@ const scaleCommand = {
             output.printError('Swarm ID is required');
             return { success: false, exitCode: 1 };
         }
-        if (!targetAgents) {
+        // 0 is a valid target (scale a swarm down to no agents) — check for
+        // presence, not truthiness.
+        if (targetAgents === undefined || Number.isNaN(targetAgents)) {
             output.printError('Target agent count required. Use --agents or -a');
             return { success: false, exitCode: 1 };
         }
         output.printInfo(`Scaling swarm ${swarmId} to ${targetAgents} agents...`);
-        // Calculate scaling delta — fetch actual count instead of hardcoded 8 (#1425)
-        let currentAgents = 0;
         try {
-            const statusResult = await callMCPTool('swarm_status', { swarmId });
-            const statusData = typeof statusResult === 'string' ? JSON.parse(statusResult) : statusResult;
-            currentAgents = statusData?.agentCount ?? statusData?.agents?.length ?? 0;
-        }
-        catch {
-            // If MCP unavailable, fall back to 0 (will spawn all requested agents)
-            currentAgents = 0;
+            const result = await callMCPTool('swarm_scale', { swarmId, targetAgents, agentType });
+            if (!result.success) {
+                output.printError(result.error || 'Failed to scale swarm');
+                return { success: false, exitCode: 1 };
+            }
+            if (result.spawned.length === 0 && result.terminated.length === 0) {
+                output.printInfo('Swarm already at target size');
+                return { success: true, data: result };
+            }
+            if (result.spawned.length > 0) {
+                output.printSuccess(`Spawned ${result.spawned.length} agent(s): ${result.spawned.join(', ')}`);
+            }
+            if (result.terminated.length > 0) {
+                output.printSuccess(`Terminated ${result.terminated.length} agent(s): ${result.terminated.join(', ')}`);
+            }
+            output.writeln(output.dim(`  ${result.previousCount} → ${result.currentCount} agents`));
+            return { success: true, data: result };
         }
-        const delta = targetAgents - currentAgents;
-        if (delta === 0) {
-            output.printInfo('Swarm already at target size');
-            return { success: true };
+        catch (error) {
+            output.printError(`Scale error: ${error instanceof MCPClientError ? error.message : String(error)}`);
+            return { success: false, exitCode: 1 };
         }
-        // No swarm_scale MCP tool is available — report the computed delta but do not pretend to act
-        output.printWarning('Swarm scaling is not yet implemented. The target count was computed but no agents were spawned or stopped.');
-        return { success: false, message: 'Scaling not implemented', exitCode: 1 };
     }
 };
 // Coordinate command (v1 specific)

package/packages/@monomind/cli/dist/src/index.js

@@ -439,50 +439,21 @@ export class CLI {
         // Extra paths are read from MONOMIND_EXTRA_AGENT_PATHS env var (colon-separated)
         // or fall back to the known local path when available.
         try {
-            const { buildUnifiedRegistry } = await import('./agents/registry-builder.js');
+            const { buildUnifiedRegistry, computeAgentRoots } = await import('./agents/registry-builder.js');
             const { mkdirSync } = await import('fs');
             const { join } = await import('path');
-            const devAgentsRoot = join(process.cwd(), '.claude', 'agents');
-            const extraPaths = process.env.MONOMIND_EXTRA_AGENT_PATHS
-                ? process.env.MONOMIND_EXTRA_AGENT_PATHS.split(':').filter(Boolean)
-                : [];
-            // Fallback: well-known sibling path relative to project root (no hardcoded dev paths)
-            const { existsSync } = await import('fs');
-            const siblingExtraPath = join(process.cwd(), '..', 'agency-agents');
-            if (extraPaths.length === 0 && existsSync(siblingExtraPath)) {
-                extraPaths.push(siblingExtraPath);
-            }
-            // extras-first so they win deduplication; dev agents fill in the rest
-            const roots = [...extraPaths, devAgentsRoot];
+            const roots = computeAgentRoots(process.cwd());
             const outDir = join(process.cwd(), '.monomind');
             mkdirSync(outDir, { recursive: true });
             buildUnifiedRegistry(roots, join(outDir, 'registry.json'));
         }
         catch { /* optional — registry build failures must never block startup */ }
-        // Task 04: CapabilityMetadata — validate agent registry at startup
-        try {
-            const { readFileSync, existsSync, statSync: statSyncReg } = await import('fs');
-            const { join: pathJoin } = await import('path');
-            const registryPath = pathJoin(process.cwd(), '.monomind', 'registry.json');
-            const MAX_REGISTRY_BYTES = 10 * 1024 * 1024; // 10 MB
-            if (existsSync(registryPath) && statSyncReg(registryPath).size <= MAX_REGISTRY_BYTES) {
-                const registry = JSON.parse(readFileSync(registryPath, 'utf-8'));
-                const entries = registry.agents ?? [];
-                const issues = [];
-                for (const agent of entries) {
-                    if (!agent.slug)
-                        issues.push(`Agent missing 'slug'`);
-                    if (!agent.name)
-                        issues.push(`Agent ${String(agent.slug ?? '?')} missing 'name'`);
-                    if (!agent.description)
-                        issues.push(`Agent ${String(agent.slug ?? '?')} missing 'description'`);
-                }
-                if (issues.length > 0) {
-                    console.warn(`[CapabilityMetadata] ${issues.length} agent metadata issue(s) in registry — run 'monomind doctor' to review`);
-                }
-            }
-        }
-        catch { /* optional */ }
+        // Task 04: CapabilityMetadata validation moved to `monomind doctor -c registry`
+        // (see doctor-project-checks.ts:checkAgentRegistry). Printing this from a
+        // fire-and-forget startup task raced process exit — short-lived commands
+        // could skip the warning even when the underlying issue was present. Doctor
+        // runs it synchronously within its own check pass instead, so it's always
+        // visible and itemized when you actually look for it.
         // NOTE: Semantic routing (@monomind/routing) is constructed on-demand by
         // its consumers — `monomind route` and `monomind agent --task` (see
         // commands/route.ts and commands/agent.ts). It is intentionally NOT

package/packages/@monomind/cli/dist/src/mcp-tools/swarm-tools.js

@@ -8,6 +8,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, statSyn
 import { join } from 'node:path';
 import { randomBytes } from 'node:crypto';
 import { getProjectCwd } from './types.js';
+import { agentTools } from './agent-tools.js';
 // Swarm state persistence
 const SWARM_DIR = '.monomind/swarm';
 const SWARM_STATE_FILE = 'swarm-state.json';
@@ -185,6 +186,82 @@ export const swarmTools = [
             };
         },
     },
+    {
+        name: 'swarm_scale',
+        description: 'Scale a swarm to a target agent count by spawning or terminating agents',
+        category: 'swarm',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                swarmId: { type: 'string', description: 'Swarm ID to scale' },
+                targetAgents: { type: 'number', description: 'Target number of agents' },
+                agentType: { type: 'string', description: 'Agent type for newly spawned agents (default: worker)' },
+            },
+            required: ['swarmId', 'targetAgents'],
+        },
+        handler: async (input) => {
+            const swarmId = input.swarmId;
+            const targetAgents = input.targetAgents;
+            const agentType = input.agentType || 'worker';
+            const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+            if (!swarmId || FORBIDDEN_KEYS.has(swarmId)) {
+                return { success: false, error: 'Invalid swarm ID' };
+            }
+            if (!Number.isFinite(targetAgents) || targetAgents < 0 || !Number.isInteger(targetAgents)) {
+                return { success: false, error: 'targetAgents must be a non-negative integer' };
+            }
+            const store = loadSwarmStore();
+            if (!Object.hasOwn(store.swarms, swarmId)) {
+                return { success: false, error: `Swarm ${swarmId} not found` };
+            }
+            const swarm = store.swarms[swarmId];
+            const currentCount = swarm.agents.length;
+            const delta = targetAgents - currentCount;
+            const spawnTool = agentTools.find(t => t.name === 'agent_spawn');
+            const terminateTool = agentTools.find(t => t.name === 'agent_terminate');
+            const spawned = [];
+            const terminated = [];
+            if (delta > 0) {
+                for (let i = 0; i < delta; i++) {
+                    const result = await spawnTool.handler({ agentType });
+                    if (result.success && result.agentId) {
+                        swarm.agents.push(result.agentId);
+                        spawned.push(result.agentId);
+                    }
+                }
+            }
+            else if (delta < 0) {
+                const toRemove = swarm.agents.slice(0, -delta);
+                for (const agentId of toRemove) {
+                    const result = await terminateTool.handler({ agentId });
+                    if (result.success) {
+                        terminated.push(agentId);
+                    }
+                }
+                swarm.agents = swarm.agents.filter(id => !terminated.includes(id));
+            }
+            swarm.maxAgents = Math.max(swarm.maxAgents, swarm.agents.length);
+            swarm.updatedAt = new Date().toISOString();
+            saveSwarmStore(store);
+            // Individual agent_spawn/agent_terminate calls can fail silently (e.g. a
+            // stale agent ID already evicted from the agent store) — report success
+            // only if the swarm actually reached the requested count, so callers
+            // can't mistake a no-op failure for "already at target size".
+            const targetReached = swarm.agents.length === targetAgents;
+            return {
+                success: targetReached,
+                error: targetReached
+                    ? undefined
+                    : `Reached ${swarm.agents.length}/${targetAgents} agents — some spawn/terminate operations failed`,
+                swarmId,
+                previousCount: currentCount,
+                currentCount: swarm.agents.length,
+                targetAgents,
+                spawned,
+                terminated,
+            };
+        },
+    },
     {
         name: 'swarm_shutdown',
         description: 'Shutdown a swarm and update persistent state',

package/packages/@monomind/cli/dist/src/parser.js

@@ -296,12 +296,9 @@ export class CommandParser {
     }
     buildAliases() {
         const aliases = {};
-        for (const opt of this.globalOptions) {
-            if (opt.short) {
-                aliases[opt.short] = opt.name;
-            }
-        }
-        // Add aliases from all commands and subcommands
+        // Add aliases from all commands and subcommands first (lowest priority) —
+        // any command's own options may still be re-applied by buildScopedAliases()
+        // once the resolved command is known.
         for (const cmd of this.commands.values()) {
             if (cmd.options) {
                 for (const opt of cmd.options) {
@@ -323,6 +320,14 @@ export class CommandParser {
                 }
             }
         }
+        // Global options are applied last so an unrelated command's short flag
+        // (e.g. "security scan --quick, -Q") can't silently shadow a global flag
+        // of the same letter (e.g. global "-Q, --quiet") for every other command.
+        for (const opt of this.globalOptions) {
+            if (opt.short) {
+                aliases[opt.short] = opt.name;
+            }
+        }
         return { ...aliases, ...this.options.aliases };
     }
     /**

package/packages/@monomind/cli/dist/src/routing/llm-caller.js

@@ -4,8 +4,7 @@
  * Monomind always runs on top of Claude Code, so low-confidence route
  * classification is delegated to the local `claude` CLI in headless print
  * mode — NOT to the Anthropic API with a managed key. There is no
- * `@anthropic-ai/sdk` dependency and no `ANTHROPIC_API_KEY` requirement: the
- * host's existing Claude Code auth is reused.
+ * No API key required: the host's existing Claude Code auth is reused.
  *
  * The returned function matches `LLMFallbackConfig.llmCaller` from
  * `@monomind/routing` — `(prompt: string) => Promise<string>`. When the

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.17.0",
+  "version": "1.17.2",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -81,8 +81,7 @@
   },
   "devDependencies": {
     "typescript": "^5.3.0",
-    "vitest": "^4.1.4",
-    "@anthropic-ai/sdk": "^0.39.0"
+    "vitest": "^4.1.4"
   },
   "dependencies": {
     "ws": "^8.21.0",

package/packages/@monomind/cli/scripts/understand-analyze.mjs

@@ -391,7 +391,7 @@ const FRAMEWORK_SIGNATURES = [
   ['Vite',         'package.json',     ['"vite"']],
   ['Webpack',      'package.json',     ['"webpack"']],
   ['TypeScript',   'package.json',     ['"typescript"']],
-  ['Anthropic SDK','package.json',     ['"@anthropic-ai/sdk"']],
+  ['Claude Code',  'package.json',     ['"@anthropic-ai/claude-code"']],
   ['Django',       'requirements.txt', ['django']],
   ['Flask',        'requirements.txt', ['flask']],
   ['FastAPI',      'requirements.txt', ['fastapi']],