monomind 1.17.0 → 1.17.1

package/packages/@monomind/cli/dist/src/browser/dashboard/ui.html

@@ -420,8 +420,9 @@ body { background: #0b0b14; color: #ccc; font-family: system-ui,-apple-system,sa
 <!-- ── top bar ─────────────────────────────────────── -->
 <div id="topbar">
   <span class="logo">monomind <span>dashboard</span></span>
-  <span class="pill pill-run" id="p-workflows" title="Total workflows">⚡ workflows</span>
-  <span class="pill pill-done" id="p-actions" title="Total actions">✓ actions</span>
+  <span class="pill pill-run" id="p-run">● 0</span>
+  <span class="pill pill-done" id="p-done">✓ 0</span>
+  <span class="pill pill-fail" id="p-fail">✗ 0</span>
   <span id="conn">
     <span id="conn-dot"></span>
     <span id="conn-label">connecting…</span>
@@ -434,9 +435,12 @@ body { background: #0b0b14; color: #ccc; font-family: system-ui,-apple-system,sa
   <!-- sidebar -->
   <nav id="sidebar">
     <div class="nav-section-label">Project</div>
-    <div class="nav-item active" data-panel="monoagent">
-      <span class="nav-icon">🤖</span> MonoAgent
-      <span class="nav-badge green" id="nb-ma">0</span>
+    <div class="nav-item active" data-panel="playbooks">
+      <span class="nav-icon">⚡</span> Runs
+      <span class="nav-badge" id="nb-run">0</span>
+    </div>
+    <div class="nav-item" data-panel="builder">
+      <span class="nav-icon">🔧</span> Builder
     </div>
 
     <div class="nav-section-label" style="margin-top:8px">System</div>
@@ -454,38 +458,21 @@ body { background: #0b0b14; color: #ccc; font-family: system-ui,-apple-system,sa
   <!-- main -->
   <div id="main">
 
-    <!-- MonoAgent panel -->
-    <div class="panel active" id="monoagent-panel">
+    <!-- Playbook Runs panel -->
+    <div class="panel active" id="pb-panel">
       <div class="panel-header">
-        <span class="panel-title">MonoAgent Workflows</span>
-        <span class="panel-subtitle" id="ma-subtitle">loading…</span>
-        <button onclick="loadMonoagentData()" style="margin-left:auto;background:#1a1a2e;border:1px solid #2a2a4a;color:#a78bfa;padding:3px 10px;border-radius:6px;cursor:pointer;font-size:11px">↻ Refresh</button>
+        <span class="panel-title">Playbook Runs</span>
+        <span class="panel-subtitle" id="pb-subtitle">0 runs</span>
       </div>
-      <div style="flex:1;overflow-y:auto;padding:12px;display:flex;flex-direction:column;gap:16px">
-        <!-- Workflow list -->
-        <div>
-          <div style="font-size:10px;font-weight:700;text-transform:uppercase;letter-spacing:1px;color:#3a3a5a;margin-bottom:8px">Workflows</div>
-          <div id="ma-workflows" style="display:grid;gap:8px;align-content:start"></div>
-          <div class="empty" id="ma-wf-empty" style="display:none">
-            <span class="empty-icon">🤖</span>
-            <span class="empty-title">No workflows found</span>
-            <span class="empty-sub">Create one with: <code style="color:#7c3aed">monoagent workflow create</code></span>
-          </div>
-        </div>
-        <!-- Action run history -->
-        <div>
-          <div style="font-size:10px;font-weight:700;text-transform:uppercase;letter-spacing:1px;color:#3a3a5a;margin-bottom:8px">Action History</div>
-          <div id="ma-history" style="display:grid;gap:6px;align-content:start"></div>
-          <div class="empty" id="ma-hist-empty" style="display:none">
-            <span class="empty-icon">📋</span>
-            <span class="empty-title">No action history</span>
-            <span class="empty-sub">Run an action with: <code style="color:#7c3aed">monoagent run &lt;ACTION_ID&gt;</code></span>
-          </div>
-        </div>
+      <div id="pb-cards" style="overflow-y:auto;flex:1;padding:12px;display:grid;gap:10px;align-content:start"></div>
+      <div class="empty" id="pb-empty">
+        <span class="empty-icon">⚡</span>
+        <span class="empty-title">No playbook runs yet</span>
+        <span class="empty-sub">Use the Builder tab to create and run playbooks,<br>or run via CLI: <code style="color:#7c3aed">npx monomind browse playbook run &lt;name&gt;</code></span>
       </div>
     </div>
 
-    <!-- Builder panel (kept for internal use, hidden from nav) -->
+    <!-- Builder panel -->
     <div class="panel" id="builder-panel">
       <!-- Toolbar -->
       <div id="builder-toolbar">
@@ -586,11 +573,12 @@ function navigateToPanel(target) {
   var navItem = document.querySelector('[data-panel="' + target + '"]');
   if (navItem) navItem.classList.add('active');
   document.querySelectorAll('.panel').forEach(function(p) { p.classList.remove('active'); });
-  var panelId = target + '-panel';
+  var panelId = target === 'playbooks' ? 'pb-panel'
+              : target === 'builder'   ? 'builder-panel'
+              : target + '-panel';
   var panel = document.getElementById(panelId);
   if (panel) panel.classList.add('active');
   if (target === 'builder') renderEdges();
-  if (target === 'monoagent') loadMonoagentData();
   location.hash = target;
 }
 
@@ -604,7 +592,7 @@ document.querySelectorAll('.nav-item').forEach(function(item) {
 // Hash-based routing on load
 (function() {
   var hash = location.hash.replace('#', '');
-  var validPanels = ['monoagent', 'agents', 'memory', 'sessions'];
+  var validPanels = ['playbooks', 'builder', 'agents', 'memory', 'sessions'];
   if (hash && validPanels.indexOf(hash) !== -1) {
     // defer until after renderEdges is defined
     window.addEventListener('load', function() { navigateToPanel(hash); });
@@ -625,7 +613,20 @@ function esc(s) {
 }
 
 function updateHeader() {
-  // no-op: topbar pills are updated by loadMonoagentData
+  var running = 0, done = 0, fail = 0;
+  for (var id in runs) {
+    var s = runs[id].status;
+    if (s === 'running') running++;
+    else if (s === 'completed') done++;
+    else if (s === 'failed') fail++;
+  }
+  document.getElementById('p-run').textContent = '● ' + running;
+  document.getElementById('p-done').textContent = '✓ ' + done;
+  document.getElementById('p-fail').textContent = '✗ ' + fail;
+  document.getElementById('nb-run').textContent = String(running || Object.keys(runs).length);
+  document.getElementById('nb-run').className = 'nav-badge' + (running ? '' : ' green');
+  var total = Object.keys(runs).length;
+  document.getElementById('pb-subtitle').textContent = total + (total === 1 ? ' run' : ' runs');
 }
 
 function progressPct(r) {
@@ -647,7 +648,6 @@ function elapsed(r) {
 function renderCards() {
   var cards = document.getElementById('pb-cards');
   var empty = document.getElementById('pb-empty');
-  if (!cards) return; // panel removed from DOM
   var sorted = Object.values(runs).sort(function(a, b) { return b.startedAt - a.startedAt; });
   if (!sorted.length) { cards.innerHTML = ''; empty.style.display = 'flex'; return; }
   empty.style.display = 'none';
@@ -1737,94 +1737,6 @@ function handleEvent(evt) {
   renderCards();
 }
 
-// ═══════════════════════════════════════════════════════════════════
-// MONOAGENT DATA
-// ═══════════════════════════════════════════════════════════════════
-var MA_STATE_COLORS = { COMPLETED: '#22c55e', FAILED: '#ef4444', PENDING: '#f59e0b', RUNNING: '#a78bfa' };
-
-function maStateLabel(state) {
-  var s = (state || '').toUpperCase();
-  return { color: MA_STATE_COLORS[s] || '#555', text: s || 'UNKNOWN' };
-}
-
-function renderWorkflows(workflows) {
-  var el = document.getElementById('ma-workflows');
-  var empty = document.getElementById('ma-wf-empty');
-  if (!workflows || !workflows.length) {
-    el.innerHTML = '';
-    empty.style.display = 'flex';
-    return;
-  }
-  empty.style.display = 'none';
-  el.innerHTML = workflows.map(function(wf) {
-    var active = wf.is_active;
-    var updated = wf.updated_at && wf.updated_at !== '0001-01-01T00:00:00Z'
-      ? new Date(wf.updated_at).toLocaleDateString()
-      : '—';
-    return '<div style="background:#0f0f1e;border:1px solid #1a1a2e;border-radius:8px;padding:10px 14px;display:flex;align-items:center;gap:10px">' +
-      '<span style="font-size:16px">' + (active ? '▶' : '⏸') + '</span>' +
-      '<div style="flex:1;min-width:0">' +
-        '<div style="font-weight:600;font-size:12px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis">' + esc(wf.name || wf.id) + '</div>' +
-        '<div style="font-size:10px;color:#3a3a5a;margin-top:2px">' + esc(wf.id) + ' · v' + (wf.version || 1) + ' · updated ' + esc(updated) + '</div>' +
-        (wf.description ? '<div style="font-size:10px;color:#555;margin-top:2px">' + esc(wf.description) + '</div>' : '') +
-      '</div>' +
-      '<span style="font-size:10px;padding:2px 7px;border-radius:10px;border:1px solid;' +
-        (active ? 'background:#22c55e15;border-color:#22c55e44;color:#22c55e' : 'background:#33333315;border-color:#33333344;color:#555') + '">' +
-        (active ? 'active' : 'inactive') +
-      '</span>' +
-    '</div>';
-  }).join('');
-  document.getElementById('nb-ma').textContent = String(workflows.length);
-}
-
-function renderHistory(actions) {
-  var el = document.getElementById('ma-history');
-  var empty = document.getElementById('ma-hist-empty');
-  if (!actions || !actions.length) {
-    el.innerHTML = '';
-    empty.style.display = 'flex';
-    return;
-  }
-  empty.style.display = 'none';
-  el.innerHTML = actions.map(function(a) {
-    var sl = maStateLabel(a.state);
-    var dt = a.created_at
-      ? new Date(typeof a.created_at === 'number' ? a.created_at * 1000 : a.created_at).toLocaleString()
-      : '—';
-    return '<div style="background:#0f0f1e;border:1px solid #1a1a2e;border-radius:6px;padding:8px 12px;display:flex;align-items:center;gap:10px">' +
-      '<div style="flex:1;min-width:0">' +
-        '<div style="font-weight:600;font-size:11px">' + esc(a.type || '(unnamed)') + '</div>' +
-        '<div style="font-size:10px;color:#3a3a5a;margin-top:2px">' +
-          esc(a.id.slice(0, 8)) + '… · ' + esc(a.platform || '') + ' · ' + esc(dt) +
-        '</div>' +
-      '</div>' +
-      '<span style="font-size:10px;font-weight:600;color:' + sl.color + '">' + sl.text + '</span>' +
-    '</div>';
-  }).join('');
-}
-
-function loadMonoagentData() {
-  document.getElementById('ma-subtitle').textContent = 'loading…';
-  fetch('/monoagent/data')
-    .then(function(r) { return r.json(); })
-    .then(function(d) {
-      renderWorkflows(d.workflows || []);
-      renderHistory(d.actions || []);
-      var wc = (d.workflows || []).length;
-      var ac = (d.actions || []).length;
-      document.getElementById('ma-subtitle').textContent = wc + ' workflow' + (wc !== 1 ? 's' : '') + ' · ' + ac + ' action' + (ac !== 1 ? 's' : '');
-      document.getElementById('p-workflows').textContent = '⚡ ' + wc;
-      document.getElementById('p-actions').textContent = '✓ ' + ac;
-    })
-    .catch(function(e) {
-      document.getElementById('ma-subtitle').textContent = 'error loading data';
-      console.error('monoagent data fetch failed', e);
-    });
-}
-
-// Load monoagent data on startup (it's the default panel)
-loadMonoagentData();
-
 // ═══════════════════════════════════════════════════════════════════
 // CONNECTION
 // ═══════════════════════════════════════════════════════════════════

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

@@ -0,0 +1,17 @@
+/**
+ * Agent lifecycle commands — spawn, list, status, stop
+ */
+import type { Command } from '../types.js';
+export declare function updateSwarmActivityMetrics(agentCountDelta: number): void;
+export declare const AGENT_TYPES: {
+    value: string;
+    label: string;
+    hint: string;
+}[];
+export declare function getAgentCapabilities(type: string): string[];
+export declare function formatStatus(status: unknown): string;
+export declare const spawnCommand: Command;
+export declare const listCommand: Command;
+export declare const statusCommand: Command;
+export declare const stopCommand: Command;
+//# sourceMappingURL=agent-lifecycle.d.ts.map

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

@@ -0,0 +1,320 @@
+/**
+ * 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';
+// ─── 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'));
+        }
+        else {
+            fs.mkdirSync(metricsDir, { recursive: true });
+        }
+        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();
+        const tmpPath = activityPath + '.tmp';
+        fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+        fs.renameSync(tmpPath, activityPath);
+    }
+    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: 'LanceDB 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) },
+            });
+            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 {
+            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.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 });
+            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',
+            });
+            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

@@ -0,0 +1,9 @@
+/**
+ * Agent operational commands — metrics, pool, health, logs
+ */
+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