monomind 2.7.11 → 2.7.13

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

@@ -1,346 +0,0 @@
-/**
- * Agent lifecycle commands — spawn, list, status, stop
- */
-import { output } from '../output.js';
-import { select, confirm, input } from '../prompt.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import { writeJsonFileAtomic } from '../utils/json-file.js';
-// ─── Shared utilities ────────────────────────────────────────────────────────
-export function updateSwarmActivityMetrics(agentCountDelta) {
-    try {
-        const metricsDir = path.join(process.cwd(), '.monomind', 'metrics');
-        const activityPath = path.join(metricsDir, 'swarm-activity.json');
-        let data = {
-            timestamp: new Date().toISOString(),
-            swarm: { active: false, agent_count: 0, coordination_active: false },
-        };
-        if (fs.existsSync(activityPath) && fs.statSync(activityPath).size <= 10 * 1024 * 1024) {
-            data = JSON.parse(fs.readFileSync(activityPath, 'utf-8'));
-        }
-        const swarm = data.swarm ?? {};
-        const currentCount = Math.max(0, swarm.agent_count || 0);
-        const newCount = Math.max(0, currentCount + agentCountDelta);
-        swarm.agent_count = newCount;
-        swarm.active = newCount > 0;
-        swarm.coordination_active = newCount > 0;
-        data.swarm = swarm;
-        data.timestamp = new Date().toISOString();
-        writeJsonFileAtomic(activityPath, data);
-    }
-    catch {
-        // Non-critical — don't fail the command if metrics update fails
-    }
-}
-export const AGENT_TYPES = [
-    { value: 'coder', label: 'Coder', hint: 'Code development with neural patterns' },
-    { value: 'researcher', label: 'Researcher', hint: 'Research with web access and data analysis' },
-    { value: 'tester', label: 'Tester', hint: 'Comprehensive testing with automation' },
-    { value: 'reviewer', label: 'Reviewer', hint: 'Code review with security and quality checks' },
-    { value: 'architect', label: 'Architect', hint: 'System design with enterprise patterns' },
-    { value: 'coordinator', label: 'Coordinator', hint: 'Multi-agent orchestration and workflow' },
-    { value: 'analyst', label: 'Analyst', hint: 'Performance analysis and optimization' },
-    { value: 'optimizer', label: 'Optimizer', hint: 'Performance optimization and bottleneck analysis' },
-    { value: 'security-architect', label: 'Security Architect', hint: 'Security architecture and threat modeling' },
-    { value: 'security-auditor', label: 'Security Auditor', hint: 'CVE remediation and security testing' },
-    { value: 'memory-specialist', label: 'Memory Specialist', hint: 'SQLite-backed ANN search (150x-12,500x faster)' },
-    { value: 'swarm-specialist', label: 'Swarm Specialist', hint: 'Unified coordination engine' },
-    { value: 'performance-engineer', label: 'Performance Engineer', hint: '2.49x-7.47x optimization targets' },
-    { value: 'core-architect', label: 'Core Architect', hint: 'Domain-driven design restructure' },
-    { value: 'test-architect', label: 'Test Architect', hint: 'TDD London School methodology' },
-];
-export function getAgentCapabilities(type) {
-    const capabilities = {
-        coder: ['code-generation', 'refactoring', 'debugging', 'testing'],
-        researcher: ['web-search', 'data-analysis', 'summarization', 'citation'],
-        tester: ['unit-testing', 'integration-testing', 'coverage-analysis', 'automation'],
-        reviewer: ['code-review', 'security-audit', 'quality-check', 'documentation'],
-        architect: ['system-design', 'pattern-analysis', 'scalability', 'documentation'],
-        coordinator: ['task-orchestration', 'agent-management', 'workflow-control'],
-        'security-architect': ['threat-modeling', 'security-patterns', 'compliance', 'audit'],
-        'memory-specialist': ['vector-search', 'lancedb', 'caching', 'optimization'],
-        'performance-engineer': ['benchmarking', 'profiling', 'optimization', 'monitoring'],
-    };
-    return capabilities[type] || ['general'];
-}
-export function formatStatus(status) {
-    const s = String(status);
-    switch (s) {
-        case 'active': return output.success(s);
-        case 'idle': return output.warning(s);
-        case 'inactive':
-        case 'stopped': return output.dim(s);
-        case 'error': return output.error(s);
-        default: return s;
-    }
-}
-// ─── spawn subcommand ────────────────────────────────────────────────────────
-export const spawnCommand = {
-    name: 'spawn',
-    description: 'Spawn a new agent',
-    options: [
-        { name: 'type', short: 't', description: 'Agent type to spawn', type: 'string', choices: AGENT_TYPES.map(a => a.value) },
-        { name: 'name', short: 'n', description: 'Agent name/identifier', type: 'string' },
-        { name: 'provider', short: 'p', description: 'Provider to use (anthropic, openrouter, ollama)', type: 'string', default: 'anthropic' },
-        { name: 'model', short: 'm', description: 'Model to use', type: 'string' },
-        { name: 'task', description: 'Initial task for the agent', type: 'string' },
-        { name: 'timeout', description: 'Agent timeout in seconds', type: 'number', default: 300 },
-        { name: 'auto-tools', description: 'Enable automatic tool usage', type: 'boolean', default: true },
-    ],
-    examples: [
-        { command: 'monomind agent spawn --type coder --name bot-1', description: 'Spawn a coder agent' },
-        { command: 'monomind agent spawn -t researcher --task "Research React 19"', description: 'Spawn researcher with task' },
-    ],
-    action: async (ctx) => {
-        let agentType = ctx.flags.type?.slice(0, 64) ?? '';
-        let agentName = ctx.flags.name?.slice(0, 128) ?? '';
-        if (!agentType && ctx.interactive) {
-            agentType = await select({ message: 'Select agent type:', options: AGENT_TYPES });
-        }
-        const taskDescription = ctx.flags.task?.slice(0, 2048);
-        if (!agentType && taskDescription) {
-            try {
-                const { createConfiguredRouteLayer } = await import('../routing/route-layer-factory.js');
-                const layer = await createConfiguredRouteLayer();
-                const routeResult = await layer.route(taskDescription);
-                agentType = routeResult.agentSlug;
-                process.stderr.write(`[route] ${routeResult.method}: "${agentType}" (confidence: ${(routeResult.confidence * 100).toFixed(1)}%)\n`);
-            }
-            catch {
-                // RouteLayer unavailable — fall through to error below
-            }
-        }
-        if (!agentType) {
-            output.printError('Agent type is required. Use --type or -t flag, or provide --task for auto-routing.');
-            return { success: false, exitCode: 1 };
-        }
-        if (!agentName)
-            agentName = `${agentType}-${Date.now().toString(36)}`;
-        output.printInfo(`Spawning ${agentType} agent: ${output.highlight(agentName)}`);
-        try {
-            const result = await callMCPTool('agent_spawn', {
-                agentType, id: agentName,
-                config: {
-                    provider: ctx.flags.provider || 'anthropic',
-                    model: ctx.flags.model,
-                    task: ctx.flags.task,
-                    timeout: ctx.flags.timeout,
-                    autoTools: ctx.flags['auto-tools'],
-                },
-                priority: 'normal',
-                metadata: { name: agentName, capabilities: getAgentCapabilities(agentType) },
-            });
-            // agent_spawn resolves (doesn't throw) on a tool-level failure like
-            // "agent store is unreadable" or "agent already exists" — callMCPTool
-            // only throws for registry/infra errors (tool not found/disabled), not
-            // for a handler's own {success:false} response. Without this check the
-            // CLI silently rendered a "spawned successfully" table full of
-            // undefined fields for a spawn that never actually happened.
-            if (result.success === false) {
-                output.printError(`Failed to spawn agent: ${result.error || 'unknown error'}`);
-                return { success: false, exitCode: 1 };
-            }
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 15 },
-                    { key: 'value', header: 'Value', width: 40 },
-                ],
-                data: [
-                    { property: 'ID', value: result.agentId },
-                    { property: 'Type', value: result.agentType },
-                    { property: 'Name', value: agentName },
-                    { property: 'Status', value: result.status },
-                    { property: 'Created', value: result.createdAt },
-                    { property: 'Capabilities', value: getAgentCapabilities(agentType).join(', ') },
-                ],
-            });
-            output.writeln();
-            output.printSuccess(`Agent ${agentName} spawned successfully`);
-            updateSwarmActivityMetrics(1);
-            if (ctx.flags.format === 'json')
-                output.printJson(result);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(error instanceof MCPClientError ? `Failed to spawn agent: ${error.message}` : `Unexpected error: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// ─── list subcommand ─────────────────────────────────────────────────────────
-export const listCommand = {
-    name: 'list',
-    aliases: ['ls'],
-    description: 'List all active agents',
-    options: [
-        { name: 'all', short: 'a', description: 'Include inactive agents', type: 'boolean', default: false },
-        { name: 'type', short: 't', description: 'Filter by agent type', type: 'string' },
-        { name: 'status', short: 's', description: 'Filter by status', type: 'string' },
-    ],
-    action: async (ctx) => {
-        try {
-            // agent_list emits `agentId` (agent-tools.ts), not `id` — reading `id`
-            // here rendered a blank ID column for every agent. `id` is kept as a
-            // fallback because agent_pool/agent_health project the same records
-            // under that key.
-            const result = await callMCPTool('agent_list', {
-                status: ctx.flags.all ? 'all' : ctx.flags.status || undefined,
-                agentType: ctx.flags.type || undefined,
-                limit: 100,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Active Agents'));
-            output.writeln();
-            if (result.agents.length === 0) {
-                output.printInfo('No agents found matching criteria');
-                return { success: true, data: result };
-            }
-            const displayAgents = result.agents.map(agent => ({
-                id: agent.agentId ?? agent.id ?? '',
-                type: agent.agentType,
-                status: agent.status,
-                created: new Date(agent.createdAt).toLocaleTimeString(),
-                lastActivity: agent.lastActivityAt ? new Date(agent.lastActivityAt).toLocaleTimeString() : 'N/A',
-            }));
-            output.printTable({
-                columns: [
-                    { key: 'id', header: 'ID', width: 20 },
-                    { key: 'type', header: 'Type', width: 15 },
-                    { key: 'status', header: 'Status', width: 12, format: formatStatus },
-                    { key: 'created', header: 'Created', width: 12 },
-                    { key: 'lastActivity', header: 'Last Activity', width: 12 },
-                ],
-                data: displayAgents,
-            });
-            output.writeln();
-            output.printInfo(`Total: ${result.total} agents`);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(error instanceof MCPClientError ? `Failed to list agents: ${error.message}` : `Unexpected error: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// ─── status subcommand ───────────────────────────────────────────────────────
-export const statusCommand = {
-    name: 'status',
-    description: 'Show detailed status of an agent',
-    options: [{ name: 'id', description: 'Agent ID', type: 'string' }],
-    action: async (ctx) => {
-        let agentId = ctx.args[0] || ctx.flags.id;
-        if (!agentId && ctx.interactive) {
-            agentId = await input({ message: 'Enter agent ID:', validate: (v) => v.length > 0 || 'Agent ID is required' });
-        }
-        if (!agentId) {
-            output.printError('Agent ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const status = await callMCPTool('agent_status', { agentId, includeMetrics: true, includeHistory: false });
-            // agent_status resolves (doesn't throw) with {status:'not_found', error}
-            // for a nonexistent agent — callMCPTool only throws for registry/infra
-            // errors, not a handler's own not-found response. Without this check
-            // the CLI reported success:true for an agent that was never found.
-            if (status.error) {
-                output.printError(`Failed to get agent status: ${status.error}`);
-                return { success: false, exitCode: 1 };
-            }
-            if (ctx.flags.format === 'json') {
-                output.printJson(status);
-                return { success: true, data: status };
-            }
-            output.writeln();
-            output.printBox([
-                `Type: ${status.agentType}`,
-                `Status: ${formatStatus(status.status)}`,
-                `Created: ${new Date(status.createdAt).toLocaleString()}`,
-                `Last Activity: ${status.lastActivityAt ? new Date(status.lastActivityAt).toLocaleString() : 'N/A'}`,
-            ].join('\n'), `Agent: ${status.id}`);
-            if (status.metrics) {
-                output.writeln();
-                output.writeln(output.bold('Metrics'));
-                const avgExecTime = status.metrics.averageExecutionTime ?? 0;
-                const uptime = status.metrics.uptime ?? 0;
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 15, align: 'right' },
-                    ],
-                    data: [
-                        { metric: 'Tasks Completed', value: status.metrics.tasksCompleted ?? 0 },
-                        { metric: 'Tasks In Progress', value: status.metrics.tasksInProgress ?? 0 },
-                        { metric: 'Tasks Failed', value: status.metrics.tasksFailed ?? 0 },
-                        { metric: 'Avg Execution Time', value: `${avgExecTime.toFixed(2)}ms` },
-                        { metric: 'Uptime', value: `${(uptime / 1000 / 60).toFixed(1)}m` },
-                    ],
-                });
-            }
-            return { success: true, data: status };
-        }
-        catch (error) {
-            output.printError(error instanceof MCPClientError ? `Failed to get agent status: ${error.message}` : `Unexpected error: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// ─── stop subcommand ─────────────────────────────────────────────────────────
-export const stopCommand = {
-    name: 'stop',
-    aliases: ['kill'],
-    description: 'Stop a running agent',
-    options: [
-        { name: 'force', short: 'f', description: 'Force stop without graceful shutdown', type: 'boolean', default: false },
-        { name: 'timeout', description: 'Graceful shutdown timeout in seconds', type: 'number', default: 30 },
-    ],
-    action: async (ctx) => {
-        const agentId = ctx.args[0];
-        if (!agentId) {
-            output.printError('Agent ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        const force = ctx.flags.force;
-        if (!force && ctx.interactive) {
-            const confirmed = await confirm({ message: `Are you sure you want to stop agent ${agentId}?`, default: false });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
-            }
-        }
-        output.printInfo(`Stopping agent ${agentId}...`);
-        try {
-            const result = await callMCPTool('agent_terminate', {
-                agentId, graceful: !force, reason: 'Stopped by user via CLI',
-            });
-            // agent_terminate resolves (doesn't throw) with {success:false, error}
-            // for a nonexistent agent or an unreadable store — callMCPTool only
-            // throws for registry/infra errors. Without this check the CLI printed
-            // "stopped successfully" for an agent that was never actually stopped.
-            if (result.success === false) {
-                output.printError(`Failed to stop agent: ${result.error || 'unknown error'}`);
-                return { success: false, exitCode: 1 };
-            }
-            if (!force) {
-                output.writeln(output.dim('  Completing current task...'));
-                output.writeln(output.dim('  Saving state...'));
-                output.writeln(output.dim('  Releasing resources...'));
-            }
-            output.printSuccess(`Agent ${agentId} stopped successfully`);
-            updateSwarmActivityMetrics(-1);
-            if (ctx.flags.format === 'json')
-                output.printJson(result);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(error instanceof MCPClientError ? `Failed to stop agent: ${error.message}` : `Unexpected error: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-//# sourceMappingURL=agent-lifecycle.js.map

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

@@ -1,8 +0,0 @@
-/**
- * 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;
-//# sourceMappingURL=agent-ops.d.ts.map

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

@@ -1,277 +0,0 @@
-/**
- * Agent operational commands — metrics, pool, health
- */
-import { output } from '../output.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { formatStatus } from './agent-lifecycle.js';
-// ─── metrics subcommand ──────────────────────────────────────────────────────
-export const metricsCommand = {
-    name: 'metrics',
-    description: 'Show agent performance metrics',
-    action: async (ctx) => {
-        // Previously read from .swarm/agents/*.json (one file per agent) — a
-        // directory nothing in the codebase has ever written to. agent_spawn
-        // (agent-tools.ts) persists to a single store.json at
-        // getMonomindDataRoot()/agents/store.json, keyed by agentId. This
-        // command was structurally incapable of reflecting a single real
-        // spawned agent; always reported zero regardless of activity. Read the
-        // real store instead.
-        const { loadAgentStore } = await import('../mcp-tools/agent-tools.js');
-        const store = loadAgentStore();
-        const agents = Object.values(store.agents);
-        let totalAgents = 0;
-        let activeAgents = 0;
-        let tasksCompleted = 0;
-        const typeCounts = {};
-        for (const agent of agents) {
-            totalAgents++;
-            const agType = agent.agentType || 'unknown';
-            if (!typeCounts[agType])
-                typeCounts[agType] = { count: 0, tasks: 0 };
-            typeCounts[agType].count++;
-            if (agent.status !== 'terminated')
-                activeAgents++;
-            // AgentRecord tracks a single taskCount, not a completed/failed
-            // breakdown — this is the best available proxy for "task activity",
-            // not literally "completed" tasks. Success-rate data doesn't exist
-            // anywhere in the current agent store schema, so it's reported as
-            // N/A below rather than fabricated.
-            const taskCount = agent.taskCount || 0;
-            typeCounts[agType].tasks += taskCount;
-            tasksCompleted += taskCount;
-        }
-        let vectorCount = 0;
-        try {
-            const { bridgeGetBackendStats } = await import('../memory/memory-bridge.js');
-            const backendStats = await bridgeGetBackendStats();
-            vectorCount = backendStats?.totalEntries ?? 0;
-        }
-        catch { /* backend unavailable */ }
-        const byType = Object.entries(typeCounts).map(([type, data]) => ({
-            type, count: data.count, tasks: data.tasks,
-            successRate: 'N/A', // not tracked in the current agent store schema
-        }));
-        const avgSuccessRate = 'N/A'; // not tracked in the current agent store schema
-        const metrics = {
-            summary: {
-                totalAgents, activeAgents, tasksCompleted, avgSuccessRate, vectorCount,
-                note: totalAgents === 0 ? 'No agents spawned yet. Use: agent spawn -t coder' : undefined,
-            },
-            byType,
-            performance: { memoryEntries: `${vectorCount} entries`, searchBackend: vectorCount > 0 ? 'SQLite' : 'none' },
-        };
-        if (ctx.flags.format === 'json') {
-            output.printJson(metrics);
-            return { success: true, data: metrics };
-        }
-        output.writeln();
-        output.writeln(output.bold('Agent Metrics'));
-        output.writeln();
-        output.printTable({
-            columns: [
-                { key: 'metric', header: 'Metric', width: 20 },
-                { key: 'value', header: 'Value', width: 15, align: 'right' },
-            ],
-            data: [
-                { metric: 'Total Agents', value: metrics.summary.totalAgents },
-                { metric: 'Active Agents', value: metrics.summary.activeAgents },
-                { metric: 'Tasks Completed', value: metrics.summary.tasksCompleted },
-                { metric: 'Success Rate', value: metrics.summary.avgSuccessRate },
-                { metric: 'Memory Entries', value: metrics.summary.vectorCount },
-            ],
-        });
-        output.writeln();
-        output.writeln(output.bold('By Agent Type'));
-        output.printTable({
-            columns: [
-                { key: 'type', header: 'Type', width: 12 },
-                { key: 'count', header: 'Count', width: 8, align: 'right' },
-                { key: 'tasks', header: 'Tasks', width: 8, align: 'right' },
-                { key: 'successRate', header: 'Success', width: 10, align: 'right' },
-            ],
-            data: metrics.byType,
-        });
-        if (metrics.summary.note) {
-            output.writeln();
-            output.writeln(output.dim(metrics.summary.note));
-        }
-        output.writeln();
-        output.writeln(output.bold('Memory'));
-        output.printList([
-            `Entries: ${output.success(metrics.performance.memoryEntries)}`,
-            `Backend: ${output.success(metrics.performance.searchBackend)}`,
-        ]);
-        return { success: true, data: metrics };
-    },
-};
-// ─── pool subcommand ─────────────────────────────────────────────────────────
-export const poolCommand = {
-    name: 'pool',
-    description: 'Manage agent pool for scaling',
-    options: [
-        { name: 'size', short: 's', description: 'Pool size', type: 'number' },
-        { name: 'min', description: 'Minimum pool size', type: 'number', default: 1 },
-        { name: 'max', description: 'Maximum pool size', type: 'number', default: 10 },
-        { name: 'auto-scale', short: 'a', description: 'Enable auto-scaling', type: 'boolean', default: true },
-    ],
-    examples: [
-        { command: 'monomind agent pool --size 5', description: 'Set pool size' },
-        { command: 'monomind agent pool --min 2 --max 15', description: 'Configure auto-scaling' },
-    ],
-    action: async (ctx) => {
-        try {
-            const result = await callMCPTool('agent_pool', {
-                size: ctx.flags.size, min: ctx.flags.min, max: ctx.flags.max,
-                autoScale: ctx.flags['auto-scale'] ?? true,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            const utilization = result.utilization ?? 0;
-            output.printBox([
-                `Pool ID: ${result.poolId ?? 'default'}`,
-                `Current Size: ${result.currentSize ?? 0}`,
-                `Min/Max: ${result.minSize ?? 0}/${result.maxSize ?? 100}`,
-                `Auto-Scale: ${result.autoScale ? 'Yes' : 'No'}`,
-                `Utilization: ${(utilization * 100).toFixed(1)}%`,
-            ].join('\n'), 'Agent Pool');
-            const agents = result.agents ?? [];
-            if (agents.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Pool Agents'));
-                output.printTable({
-                    columns: [
-                        { key: 'id', header: 'ID', width: 20 },
-                        { key: 'type', header: 'Type', width: 15 },
-                        { key: 'status', header: 'Status', width: 12, format: formatStatus },
-                    ],
-                    data: agents,
-                });
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(error instanceof MCPClientError ? `Pool error: ${error.message}` : `Unexpected error: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// ─── health subcommand ───────────────────────────────────────────────────────
-function formatHealthStatus(health) {
-    switch (String(health)) {
-        case 'healthy': return output.success(String(health));
-        case 'degraded': return output.warning(String(health));
-        case 'unhealthy': return output.error(String(health));
-        default: return String(health);
-    }
-}
-export const healthCommand = {
-    name: 'health',
-    description: 'Show agent health and metrics',
-    options: [
-        { name: 'id', short: 'i', description: 'Agent ID (all if not specified)', type: 'string' },
-        { name: 'detailed', short: 'd', description: 'Show detailed health metrics', type: 'boolean', default: false },
-        { name: 'watch', short: 'w', description: 'Watch mode (refresh every 5s)', type: 'boolean', default: false },
-    ],
-    examples: [
-        { command: 'monomind agent health', description: 'Show all agents health' },
-        { command: 'monomind agent health -i agent-001 -d', description: 'Detailed health for specific agent' },
-    ],
-    action: async (ctx) => {
-        // --watch was declared (and documented as "refresh every 5s") but never
-        // read, so the command rendered once and exited. Mirrors the watch loop in
-        // commands/status.ts.
-        if (ctx.flags.watch) {
-            return watchAgentHealth(ctx);
-        }
-        return renderAgentHealth(ctx);
-    },
-};
-const WATCH_INTERVAL_MS = 5000;
-async function watchAgentHealth(ctx) {
-    const refresh = async () => {
-        process.stdout.write('\x1b[2J\x1b[H');
-        output.writeln(output.dim(`Last updated: ${new Date().toLocaleTimeString()} — refreshing every 5s. Press Ctrl+C to exit.`));
-        await renderAgentHealth(ctx);
-    };
-    await refresh();
-    const intervalId = setInterval(() => { void refresh(); }, WATCH_INTERVAL_MS);
-    // `once` so repeated invocations don't accumulate SIGINT handlers.
-    return new Promise((resolve) => {
-        process.once('SIGINT', () => {
-            clearInterval(intervalId);
-            output.writeln();
-            output.printInfo('Watch mode stopped');
-            resolve({ success: true });
-        });
-    });
-}
-async function renderAgentHealth(ctx) {
-    {
-        const agentId = ctx.args[0] || ctx.flags.id;
-        const detailed = ctx.flags.detailed;
-        try {
-            const result = await callMCPTool('agent_health', { agentId, detailed });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Agent Health'));
-            output.writeln();
-            const overall = result.overall ?? { healthy: 0, degraded: 0, unhealthy: 0, avgCpu: 0, avgMemory: 0 };
-            output.printBox([
-                `Healthy: ${output.success(String(overall.healthy ?? 0))}`,
-                `Degraded: ${output.warning(String(overall.degraded ?? 0))}`,
-                `Unhealthy: ${output.error(String(overall.unhealthy ?? 0))}`,
-                `Avg CPU: ${(overall.avgCpu ?? 0).toFixed(1)}%`,
-                `Avg Memory: ${((overall.avgMemory ?? 0) * 100).toFixed(1)}%`,
-            ].join('  |  '), 'Overall Status');
-            const healthAgents = result.agents ?? [];
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'id', header: 'Agent ID', width: 18 },
-                    { key: 'type', header: 'Type', width: 12 },
-                    { key: 'health', header: 'Health', width: 10, format: formatHealthStatus },
-                    { key: 'cpu', header: 'CPU %', width: 8, align: 'right', format: (v) => `${Number(v ?? 0).toFixed(1)}%` },
-                    { key: 'memory', header: 'Memory', width: 10, align: 'right', format: (v) => {
-                            const mem = v;
-                            return mem ? `${(mem.used / mem.limit * 100).toFixed(0)}%` : '0%';
-                        } },
-                    { key: 'tasks', header: 'Tasks', width: 12, align: 'right', format: (v) => {
-                            const t = v;
-                            return t ? `${t.active ?? 0}/${t.completed ?? 0}` : '0/0';
-                        } },
-                ],
-                data: healthAgents,
-            });
-            if (detailed && healthAgents.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Detailed Metrics'));
-                for (const agent of healthAgents) {
-                    output.writeln();
-                    output.writeln(output.highlight(agent.id));
-                    const uptime = agent.uptime ?? 0;
-                    const latency = agent.latency ?? { avg: 0, p99: 0 };
-                    const tasks = agent.tasks ?? { completed: 0, failed: 0, queued: 0 };
-                    const errors = agent.errors ?? { count: 0 };
-                    output.printList([
-                        `Uptime: ${(uptime / 1000 / 60).toFixed(1)} min`,
-                        `Latency: avg ${(latency.avg ?? 0).toFixed(1)}ms, p99 ${(latency.p99 ?? 0).toFixed(1)}ms`,
-                        `Tasks: ${tasks.completed ?? 0} completed, ${tasks.failed ?? 0} failed, ${tasks.queued ?? 0} queued`,
-                        `Errors: ${errors.count ?? 0}${errors.lastError ? ` (${errors.lastError})` : ''}`,
-                    ]);
-                }
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(error instanceof MCPClientError ? `Health check 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.d.ts

@@ -1,8 +0,0 @@
-/**
- * CLI Agent Command
- * Agent management commands for spawning, listing, and controlling agents
- */
-import type { Command } from '../types.js';
-export declare const agentCommand: Command;
-export default agentCommand;
-//# sourceMappingURL=agent.d.ts.map