monomind 1.17.1 → 1.17.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.17.1",
+  "version": "1.17.2",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/dist/src/agents/registry-builder.d.ts

@@ -7,6 +7,7 @@ type AgentRegistryEntry = {
     name: string;
     version: string;
     category: string;
+    description: string;
     capabilities: string[];
     taskTypes: string[];
     tools: string[];
@@ -32,6 +33,13 @@ type AgentRegistry = {
  * @returns The built AgentRegistry object.
  */
 export declare function buildRegistry(agentsRoot: string, outputPath?: string): AgentRegistry;
+/**
+ * Compute the ordered list of agent-definition roots for `cwd`: extras
+ * (canonical, from MONOMIND_EXTRA_AGENT_PATHS or a sibling `agency-agents`
+ * dir) first, then the project's `.claude/agents`. Shared by CLI startup
+ * and `monomind doctor` so both build the registry the same way.
+ */
+export declare function computeAgentRoots(cwd: string): string[];
 /**
  * Build a unified agent registry from multiple root directories, deduplicating
  * by slug. When the same slug appears in more than one root, the entry from the

package/packages/@monomind/cli/dist/src/agents/registry-builder.js

@@ -132,6 +132,27 @@ function categoryFromPath(filePath, agentsRoot) {
 export function buildRegistry(agentsRoot, outputPath) {
     return buildUnifiedRegistry([agentsRoot], outputPath);
 }
+/**
+ * Compute the ordered list of agent-definition roots for `cwd`: extras
+ * (canonical, from MONOMIND_EXTRA_AGENT_PATHS or a sibling `agency-agents`
+ * dir) first, then the project's `.claude/agents`. Shared by CLI startup
+ * and `monomind doctor` so both build the registry the same way.
+ */
+export function computeAgentRoots(cwd) {
+    const devAgentsRoot = join(cwd, '.claude', 'agents');
+    const extraPaths = process.env.MONOMIND_EXTRA_AGENT_PATHS
+        ? process.env.MONOMIND_EXTRA_AGENT_PATHS.split(':').filter(Boolean)
+        : [];
+    const siblingExtraPath = join(cwd, '..', 'agency-agents');
+    if (extraPaths.length === 0) {
+        try {
+            if (statSync(siblingExtraPath).isDirectory())
+                extraPaths.push(siblingExtraPath);
+        }
+        catch { /* sibling path doesn't exist */ }
+    }
+    return [...extraPaths, devAgentsRoot];
+}
 /**
  * Build a unified agent registry from multiple root directories, deduplicating
  * by slug. When the same slug appears in more than one root, the entry from the
@@ -178,6 +199,7 @@ export function buildUnifiedRegistry(roots, outputPath) {
                 version: (typeof fm.version === 'string' ? fm.version : undefined) || '0.0.0',
                 category: (typeof fm.category === 'string' ? fm.category : undefined) ||
                     categoryFromPath(file, root),
+                description: typeof fm.description === 'string' ? fm.description : '',
                 capabilities: toStringArray(fm.capabilities),
                 taskTypes: toStringArray(fm.taskTypes ?? fm['task-types'] ?? fm.task_types),
                 tools: toStringArray(fm.tools),

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

@@ -15,5 +15,6 @@ export declare function checkMonoesMemory(): Promise<HealthCheck>;
 export declare function checkHelpersFresh(): Promise<HealthCheck>;
 export declare function checkMonoesIntegration(): Promise<HealthCheck>;
 export declare function checkGitignoreCoverage(): Promise<HealthCheck>;
+export declare function checkAgentRegistry(): Promise<HealthCheck>;
 export declare function checkGuidanceGates(): Promise<HealthCheck>;
 //# sourceMappingURL=doctor-project-checks.d.ts.map

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

@@ -2,7 +2,7 @@
  * Doctor — project/monomind health checks
  * Config, daemon, memory, API keys, MCP, monograph, helpers, routing, gates, gitignore
  */
-import { existsSync, readFileSync, statSync } from 'fs';
+import { existsSync, readFileSync, statSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
@@ -356,6 +356,50 @@ export async function checkGitignoreCoverage() {
     const missingList = missing.map(m => m.pattern).join(', ');
     return { name: 'Gitignore Coverage', status: 'warn', message: `${missing.length} runtime path(s) not in .gitignore: ${missingList}`, fix: `printf "${missing.map(m => m.pattern).join('\\n')}\\n" >> .gitignore` };
 }
+export async function checkAgentRegistry() {
+    try {
+        const { buildUnifiedRegistry, computeAgentRoots } = await import('../agents/registry-builder.js');
+        const cwd = process.cwd();
+        const roots = computeAgentRoots(cwd);
+        const outDir = join(cwd, '.monomind');
+        mkdirSync(outDir, { recursive: true });
+        // Rebuilds fresh in-memory (and refreshes .monomind/registry.json on disk)
+        // rather than reading a file that a separate, unawaited startup task also
+        // writes — avoids reporting stale results from a race between the two.
+        const registry = buildUnifiedRegistry(roots, join(outDir, 'registry.json'));
+        const entries = registry.agents;
+        if (entries.length === 0) {
+            return { name: 'Agent Registry', status: 'warn', message: 'No agents found under .claude/agents', fix: 'monomind init  (installs agent definitions)' };
+        }
+        let missingSlug = 0, missingName = 0, missingDescription = 0;
+        for (const agent of entries) {
+            if (!agent.slug)
+                missingSlug++;
+            if (!agent.name)
+                missingName++;
+            if (!agent.description)
+                missingDescription++;
+        }
+        const total = missingSlug + missingName + missingDescription;
+        if (total === 0) {
+            return { name: 'Agent Registry', status: 'pass', message: `${entries.length} agent(s), all metadata complete` };
+        }
+        const parts = [
+            missingSlug > 0 ? `${missingSlug} missing slug` : null,
+            missingName > 0 ? `${missingName} missing name` : null,
+            missingDescription > 0 ? `${missingDescription} missing description` : null,
+        ].filter(Boolean).join(', ');
+        return {
+            name: 'Agent Registry',
+            status: 'warn',
+            message: `${total} metadata issue(s) across ${entries.length} agent(s): ${parts}`,
+            fix: 'Add the missing field(s) to frontmatter in .claude/agents/*.md',
+        };
+    }
+    catch {
+        return { name: 'Agent Registry', status: 'warn', message: 'Could not build/parse agent registry' };
+    }
+}
 export async function checkGuidanceGates() {
     const settingsPath = join(process.cwd(), '.claude', 'settings.json');
     const gatesHandlerPath = join(process.cwd(), '.claude', 'helpers', 'handlers', 'gates-handler.cjs');

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

@@ -6,7 +6,7 @@
  */
 import { output } from '../output.js';
 import { checkNodeVersion, checkNpmVersion, checkGit, checkGitRepo, checkDiskSpace, checkBuildTools, checkVersionFreshness, checkClaudeCode, installClaudeCode, } from './doctor-env-checks.js';
-import { checkConfigFile, checkDaemonStatus, checkMemoryDatabase, checkApiKeys, checkMcpServers, checkMonograph, checkMonographFreshness, checkMonoesMemory, checkHelpersFresh, checkMonoesIntegration, checkGuidanceGates, checkGitignoreCoverage, } from './doctor-project-checks.js';
+import { checkConfigFile, checkDaemonStatus, checkMemoryDatabase, checkApiKeys, checkMcpServers, checkMonograph, checkMonographFreshness, checkMonoesMemory, checkHelpersFresh, checkMonoesIntegration, checkGuidanceGates, checkGitignoreCoverage, checkAgentRegistry, } from './doctor-project-checks.js';
 function formatCheck(check) {
     const icon = check.status === 'pass' ? output.success('✓') :
         check.status === 'warn' ? output.warning('⚠') :
@@ -21,7 +21,7 @@ export const doctorCommand = {
         { name: 'install', short: 'i', description: 'Auto-install missing dependencies (Claude Code CLI)', type: 'boolean', default: false },
         {
             name: 'component', short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, graph-freshness, memory-pkg, helpers, monoes, gates, gitignore)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, graph-freshness, memory-pkg, helpers, monoes, gates, gitignore, registry)',
             type: 'string',
         },
         { name: 'verbose', short: 'v', description: 'Verbose output', type: 'boolean', default: false },
@@ -48,6 +48,7 @@ export const doctorCommand = {
             checkApiKeys, checkMcpServers, checkDiskSpace, checkBuildTools,
             checkMonograph, checkMonographFreshness, checkMonoesMemory,
             checkHelpersFresh, checkMonoesIntegration, checkGuidanceGates, checkGitignoreCoverage,
+            checkAgentRegistry,
         ];
         const componentMap = {
             version: checkVersionFreshness, freshness: checkVersionFreshness,
@@ -58,6 +59,7 @@ export const doctorCommand = {
             'graph-freshness': checkMonographFreshness, 'memory-pkg': checkMonoesMemory,
             helpers: checkHelpersFresh, monoes: checkMonoesIntegration,
             gates: checkGuidanceGates, gitignore: checkGitignoreCoverage,
+            registry: checkAgentRegistry,
         };
         const checksToRun = (component && componentMap[component]) ? [componentMap[component]] : allChecks;
         const results = [];

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.17.1",
+  "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",