@monoes/monomindcli 2.9.2 → 2.9.4

package/dist/src/commands/swarm.js

@@ -8,7 +8,7 @@ import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { writeJsonFileAtomic } from '../utils/json-file.js';
-import { getMonomindDataRoot, getProjectCwd, migrateLegacyStoreFile } from '../mcp-tools/types.js';
+import { getMonomindDataRoot, getProjectCwd, migrateLegacyStoreFile } from '../utils/paths.js';
 // Canonical paths — resolved through getMonomindDataRoot() so the CLI and the MCP
 // tools (agent-tools.ts / swarm-tools.ts / task-tools.ts) read and write the SAME
 // physical files. These used to be `path.join(process.cwd(), '.monomind/...')`,
@@ -106,7 +106,7 @@ function getSwarmStatus(swarmId) {
     let sessionCount = 0;
     if (fs.existsSync(sessionDir)) {
         try {
-            sessionCount = fs.readdirSync(sessionDir).filter(f => f.endsWith('.json')).length;
+            sessionCount = fs.readdirSync(sessionDir).filter((f) => f.endsWith('.json')).length;
         }
         catch {
             // Ignore
@@ -132,7 +132,7 @@ function getSwarmStatus(swarmId) {
     const tasksDir = path.join(getSwarmDir(), 'tasks');
     if (fs.existsSync(tasksDir)) {
         try {
-            const taskFiles = fs.readdirSync(tasksDir).filter(f => f.endsWith('.json'));
+            const taskFiles = fs.readdirSync(tasksDir).filter((f) => f.endsWith('.json'));
             for (const file of taskFiles) {
                 try {
                     const taskFilePath = path.join(tasksDir, file);
@@ -182,7 +182,10 @@ function getSwarmStatus(swarmId) {
         status = 'ready';
     }
     return {
-        id: swarmId || swarmState?.swarmId || swarmState?.id || 'no-active-swarm',
+        id: swarmId ||
+            swarmState?.swarmId ||
+            swarmState?.id ||
+            'no-active-swarm',
         topology: swarmState?.topology || 'none',
         status,
         objective: swarmState?.objective || 'No active objective',
@@ -191,37 +194,45 @@ function getSwarmStatus(swarmId) {
             total: totalAgents,
             active: activeAgents,
             idle: Math.max(0, totalAgents - activeAgents),
-            completed: 0
+            completed: 0,
         },
         progress,
         tasks: {
             total: totalTasks,
             completed: completedTasks,
             inProgress: inProgressTasks,
-            pending: pendingTasks
+            pending: pendingTasks,
         },
         metrics: {
             tokensUsed: 0,
             avgResponseTime: '--',
             successRate: totalTasks > 0 ? `${Math.round((completedTasks / totalTasks) * 100)}%` : '--',
-            elapsedTime: '--'
+            elapsedTime: '--',
         },
         coordination: {
             consensusRounds: 0,
             messagesSent: 0,
-            conflictsResolved: 0
+            conflictsResolved: 0,
         },
-        hasActiveSwarm: !!swarmState || totalAgents > 0
+        hasActiveSwarm: !!swarmState || totalAgents > 0,
     };
 }
 // Swarm topologies
 const TOPOLOGIES = [
-    { value: 'hierarchical', label: 'Hierarchical', hint: 'Queen-led coordination with worker agents' },
+    {
+        value: 'hierarchical',
+        label: 'Hierarchical',
+        hint: 'Queen-led coordination with worker agents',
+    },
     { value: 'mesh', label: 'Mesh', hint: 'Fully connected peer-to-peer network' },
     { value: 'ring', label: 'Ring', hint: 'Circular communication pattern' },
     { value: 'star', label: 'Star', hint: 'Central coordinator with spoke agents' },
     { value: 'hybrid', label: 'Hybrid', hint: 'Hierarchical mesh for maximum flexibility' },
-    { value: 'hierarchical-mesh', label: 'Hierarchical Mesh', hint: 'v1 15-agent queen + peer communication (recommended)' }
+    {
+        value: 'hierarchical-mesh',
+        label: 'Hierarchical Mesh',
+        hint: 'v1 15-agent queen + peer communication (recommended)',
+    },
 ];
 // Swarm strategies
 const STRATEGIES = [
@@ -233,7 +244,7 @@ const STRATEGIES = [
     { value: 'testing', label: 'Testing', hint: 'Comprehensive test coverage' },
     { value: 'optimization', label: 'Optimization', hint: 'Performance optimization' },
     { value: 'maintenance', label: 'Maintenance', hint: 'Codebase maintenance and refactoring' },
-    { value: 'analysis', label: 'Analysis', hint: 'Code analysis and documentation' }
+    { value: 'analysis', label: 'Analysis', hint: 'Code analysis and documentation' },
 ];
 // Initialize swarm
 const initCommand = {
@@ -245,35 +256,35 @@ const initCommand = {
             short: 't',
             description: 'Swarm topology',
             type: 'string',
-            choices: TOPOLOGIES.map(t => t.value),
-            default: 'hierarchical'
+            choices: TOPOLOGIES.map((t) => t.value),
+            default: 'hierarchical',
         },
         {
             name: 'max-agents',
             short: 'm',
             description: 'Maximum number of agents',
             type: 'number',
-            default: 15
+            default: 15,
         },
         {
             name: 'auto-scale',
             description: 'Enable automatic scaling',
             type: 'boolean',
-            default: true
+            default: true,
         },
         {
             name: 'strategy',
             short: 's',
             description: 'Coordination strategy',
             type: 'string',
-            choices: STRATEGIES.map(s => s.value)
+            choices: STRATEGIES.map((s) => s.value),
         },
         {
             name: 'v1-mode',
             description: 'Enable v1 15-agent hierarchical mesh mode',
             type: 'boolean',
-            default: false
-        }
+            default: false,
+        },
     ],
     action: async (ctx) => {
         let topology = ctx.flags.topology;
@@ -289,7 +300,7 @@ const initCommand = {
             topology = await select({
                 message: 'Select swarm topology:',
                 options: TOPOLOGIES,
-                default: 'hierarchical'
+                default: 'hierarchical',
             });
         }
         output.writeln();
@@ -312,18 +323,15 @@ const initCommand = {
                 },
             });
             // Display initialization progress
-            output.writeln(output.dim('  Creating coordination topology...'));
-            output.writeln(output.dim('  Initializing memory namespace...'));
-            output.writeln(output.dim('  Setting up communication channels...'));
+            output.writeln(output.dim(`  Wrote swarm config: ${result.swarmId}`));
             if (v1Mode) {
-                output.writeln(output.dim('  Configuring SQLite-backed vector search (ANN)....'));
-                output.writeln(output.dim('  Initializing keyword routing + outcome measurement...'));
+                output.writeln(output.dim('  (v1-mode: topology renamed to hierarchical-mesh; no ANN or keyword routing is performed during init)'));
             }
             output.writeln();
             output.printTable({
                 columns: [
                     { key: 'property', header: 'Property', width: 20 },
-                    { key: 'value', header: 'Value', width: 35 }
+                    { key: 'value', header: 'Value', width: 35 },
                 ],
                 data: [
                     { property: 'Swarm ID', value: result.swarmId },
@@ -331,8 +339,8 @@ const initCommand = {
                     { property: 'Max Agents', value: result.config.maxAgents },
                     { property: 'Auto Scale', value: result.config.autoScaling ? 'Enabled' : 'Disabled' },
                     { property: 'Protocol', value: result.config.communicationProtocol || 'N/A' },
-                    { property: 'v1 Mode', value: v1Mode ? 'Enabled' : 'Disabled' }
-                ]
+                    { property: 'v1 Mode', value: v1Mode ? 'Enabled' : 'Disabled' },
+                ],
             });
             output.writeln();
             output.printSuccess('Swarm initialized successfully');
@@ -349,7 +357,9 @@ const initCommand = {
                     try {
                         store = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
                     }
-                    catch { /* use default */ }
+                    catch {
+                        /* use default */
+                    }
                 }
                 if (!store.swarms || typeof store.swarms !== 'object')
                     store.swarms = {};
@@ -357,12 +367,15 @@ const initCommand = {
                     swarmId: result.swarmId,
                     topology: result.topology,
                     maxAgents: result.config.maxAgents,
-                    status: 'running',
+                    // P0-4: no agents are actually running yet at init time — the
+                    // printed message says so; the persisted state must agree, or
+                    // `swarm status --format json` contradicts the human-readable output.
+                    status: 'configured',
                     agents: [],
                     tasks: [],
                     config: { strategy: ctx.flags.strategy || 'development', v1Mode },
                     createdAt: result.initializedAt || new Date().toISOString(),
-                    updatedAt: new Date().toISOString()
+                    updatedAt: new Date().toISOString(),
                 };
                 writeJsonFileAtomic(stateFile, store);
             }
@@ -384,7 +397,7 @@ const initCommand = {
             }
             return { success: false, exitCode: 1 };
         }
-    }
+    },
 };
 // Start swarm execution
 const startCommand = {
@@ -396,32 +409,38 @@ const startCommand = {
             short: 'o',
             description: 'Swarm objective/task',
             type: 'string',
-            required: true
+            required: true,
         },
         {
             name: 'strategy',
             short: 's',
             description: 'Execution strategy',
             type: 'string',
-            choices: STRATEGIES.map(s => s.value)
+            choices: STRATEGIES.map((s) => s.value),
         },
         {
             name: 'parallel',
             short: 'p',
             description: 'Enable parallel execution',
             type: 'boolean',
-            default: true
+            default: true,
         },
         {
             name: 'monitor',
             description: 'Enable real-time monitoring',
             type: 'boolean',
-            default: true
-        }
+            default: true,
+        },
     ],
     examples: [
-        { command: 'monomind swarm start -o "Build REST API" -s development', description: 'Start development swarm' },
-        { command: 'monomind swarm start -o "Analyze codebase" --parallel', description: 'Parallel analysis' }
+        {
+            command: 'monomind swarm start -o "Build REST API" -s development',
+            description: 'Start development swarm',
+        },
+        {
+            command: 'monomind swarm start -o "Analyze codebase" --parallel',
+            description: 'Parallel analysis',
+        },
     ],
     action: async (ctx) => {
         const objective = ctx.args[0] || ctx.flags.objective;
@@ -435,7 +454,7 @@ const startCommand = {
             strategy = await select({
                 message: 'Select execution strategy:',
                 options: STRATEGIES,
-                default: 'development'
+                default: 'development',
             });
         }
         strategy = strategy || 'development';
@@ -450,15 +469,15 @@ const startCommand = {
                 { key: 'role', header: 'Role', width: 20 },
                 { key: 'type', header: 'Type', width: 15 },
                 { key: 'count', header: 'Count', width: 8, align: 'right' },
-                { key: 'purpose', header: 'Purpose', width: 30 }
+                { key: 'purpose', header: 'Purpose', width: 30 },
             ],
-            data: agentPlan
+            data: agentPlan,
         });
         // Confirm execution
         if (ctx.interactive) {
             const confirmed = await confirm({
                 message: `Deploy ${agentPlan.reduce((sum, a) => sum + a.count, 0)} agents?`,
-                default: true
+                default: true,
             });
             if (!confirmed) {
                 output.printInfo('Swarm execution cancelled');
@@ -469,7 +488,10 @@ const startCommand = {
         const swarmId = `swarm-${Date.now().toString(36)}`;
         const totalAgents = agentPlan.reduce((sum, a) => sum + a.count, 0);
         output.writeln();
-        const spinner = output.createSpinner({ text: 'Initializing swarm via MCP...', spinner: 'dots' });
+        const spinner = output.createSpinner({
+            text: 'Initializing swarm via MCP...',
+            spinner: 'dots',
+        });
         spinner.start();
         let resolvedSwarmId = swarmId;
         try {
@@ -503,7 +525,9 @@ const startCommand = {
             try {
                 startStore = JSON.parse(fs.readFileSync(stateFile2, 'utf-8'));
             }
-            catch { /* use default */ }
+            catch {
+                /* use default */
+            }
         }
         if (!startStore.swarms || typeof startStore.swarms !== 'object')
             startStore.swarms = {};
@@ -511,21 +535,24 @@ const startCommand = {
             swarmId: resolvedSwarmId,
             topology: 'hierarchical',
             maxAgents: totalAgents,
-            status: 'running',
+            // P0-4: same fix as swarm init — persisted status must match the
+            // "No agents are running" message below, not claim 'running'.
+            status: 'configured',
             agents: [],
             tasks: [],
             config: { strategy, objective, agentPlan, parallel: ctx.flags.parallel ?? true },
             createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString()
+            updatedAt: new Date().toISOString(),
         };
         writeJsonFileAtomic(stateFile2, startStore);
         output.writeln();
-        output.printSuccess(`Swarm ${resolvedSwarmId} initialized with ${totalAgents} agent slots`);
-        output.writeln(output.dim('  Note: Agents are registered but actual task execution requires'));
-        output.writeln(output.dim('  Claude Code Task tool or hive-mind spawn --claude to drive work.'));
+        output.printSuccess(`Swarm ${resolvedSwarmId} config written (${totalAgents} agent slots reserved). No agents are running — use 'agent spawn' or hive-mind spawn --claude to dispatch Task-tool agents.`);
         output.writeln(output.dim(`  Monitor: monomind swarm status ${resolvedSwarmId}`));
-        return { success: true, data: { swarmId: resolvedSwarmId, objective, strategy, agents: totalAgents } };
-    }
+        return {
+            success: true,
+            data: { swarmId: resolvedSwarmId, objective, strategy, agents: totalAgents },
+        };
+    },
 };
 // Swarm status
 const statusCommand = {
@@ -560,14 +587,14 @@ const statusCommand = {
         output.printTable({
             columns: [
                 { key: 'status', header: 'Status', width: 12 },
-                { key: 'count', header: 'Count', width: 10, align: 'right' }
+                { key: 'count', header: 'Count', width: 10, align: 'right' },
             ],
             data: [
                 { status: output.success('Active'), count: status.agents.active },
                 { status: output.warning('Idle'), count: status.agents.idle },
                 { status: output.dim('Completed'), count: status.agents.completed },
-                { status: 'Total', count: status.agents.total }
-            ]
+                { status: 'Total', count: status.agents.total },
+            ],
         });
         output.writeln();
         // Task status
@@ -575,14 +602,14 @@ const statusCommand = {
         output.printTable({
             columns: [
                 { key: 'status', header: 'Status', width: 12 },
-                { key: 'count', header: 'Count', width: 10, align: 'right' }
+                { key: 'count', header: 'Count', width: 10, align: 'right' },
             ],
             data: [
                 { status: output.success('Completed'), count: status.tasks.completed },
                 { status: output.info('In Progress'), count: status.tasks.inProgress },
                 { status: output.dim('Pending'), count: status.tasks.pending },
-                { status: 'Total', count: status.tasks.total }
-            ]
+                { status: 'Total', count: status.tasks.total },
+            ],
         });
         output.writeln();
         // Metrics
@@ -591,7 +618,7 @@ const statusCommand = {
             `Tokens Used: ${status.metrics.tokensUsed.toLocaleString()}`,
             `Avg Response Time: ${status.metrics.avgResponseTime}`,
             `Success Rate: ${status.metrics.successRate}`,
-            `Elapsed Time: ${status.metrics.elapsedTime}`
+            `Elapsed Time: ${status.metrics.elapsedTime}`,
         ]);
         output.writeln();
         // Coordination stats
@@ -599,10 +626,10 @@ const statusCommand = {
         output.printList([
             `Consensus Rounds: ${status.coordination.consensusRounds}`,
             `Messages Sent: ${status.coordination.messagesSent}`,
-            `Conflicts Resolved: ${status.coordination.conflictsResolved}`
+            `Conflicts Resolved: ${status.coordination.conflictsResolved}`,
         ]);
         return { success: true, data: status };
-    }
+    },
 };
 // Stop swarm
 const stopCommand = {
@@ -614,14 +641,14 @@ const stopCommand = {
             short: 'f',
             description: 'Force immediate stop',
             type: 'boolean',
-            default: false
+            default: false,
         },
         {
             name: 'save-state',
             description: 'Save current state for resume',
             type: 'boolean',
-            default: true
-        }
+            default: true,
+        },
     ],
     action: async (ctx) => {
         const swarmId = ctx.args[0];
@@ -633,7 +660,7 @@ const stopCommand = {
         if (ctx.interactive && !force) {
             const confirmed = await confirm({
                 message: `Stop swarm ${swarmId}? Progress will be saved.`,
-                default: false
+                default: false,
             });
             if (!confirmed) {
                 output.printInfo('Operation cancelled');
@@ -681,7 +708,7 @@ const stopCommand = {
         }
         output.printSuccess(`Swarm ${swarmId} stopped`);
         return { success: true, data: { swarmId, stopped: true, force } };
-    }
+    },
 };
 // Scale swarm
 const scaleCommand = {
@@ -693,14 +720,14 @@ const scaleCommand = {
             short: 'a',
             description: 'Target number of agents',
             type: 'number',
-            required: true
+            required: true,
         },
         {
             name: 'type',
             short: 't',
             description: 'Agent type to scale',
-            type: 'string'
-        }
+            type: 'string',
+        },
     ],
     action: async (ctx) => {
         const swarmId = ctx.args[0];
@@ -740,7 +767,7 @@ const scaleCommand = {
             output.printError(`Scale error: ${error instanceof MCPClientError ? error.message : String(error)}`);
             return { success: false, exitCode: 1 };
         }
-    }
+    },
 };
 // Coordinate command (v1 specific)
 const coordinateCommand = {
@@ -751,13 +778,13 @@ const coordinateCommand = {
             name: 'agents',
             description: 'Number of agents',
             type: 'number',
-            default: 15
+            default: 15,
         },
         {
             name: 'domains',
             description: 'Domains to activate',
-            type: 'array'
-        }
+            type: 'array',
+        },
     ],
     action: async (ctx) => {
         const agentCount = ctx.flags.agents || 15;
@@ -780,22 +807,27 @@ const coordinateCommand = {
             { id: 12, role: 'MCP Specialist', domain: 'Integration', status: 'active' },
             { id: 13, role: 'Project Coordinator', domain: 'Management', status: 'active' },
             { id: 14, role: 'Documentation Lead', domain: 'Management', status: 'standby' },
-            { id: 15, role: 'DevOps Engineer', domain: 'Management', status: 'standby' }
+            { id: 15, role: 'DevOps Engineer', domain: 'Management', status: 'standby' },
         ].slice(0, agentCount);
         output.printTable({
             columns: [
                 { key: 'id', header: '#', width: 3, align: 'right' },
                 { key: 'role', header: 'Role', width: 22 },
                 { key: 'domain', header: 'Domain', width: 15 },
-                { key: 'status', header: 'Status', width: 10, format: (v) => {
+                {
+                    key: 'status',
+                    header: 'Status',
+                    width: 10,
+                    format: (v) => {
                         if (v === 'primary')
                             return output.highlight(String(v));
                         if (v === 'active')
                             return output.success(String(v));
                         return output.dim(String(v));
-                    } }
+                    },
+                },
             ],
-            data: v1Agents
+            data: v1Agents,
         });
         // Actually initialize via MCP instead of just displaying (#1423)
         output.writeln();
@@ -805,27 +837,36 @@ const coordinateCommand = {
                 maxAgents: agentCount,
                 strategy: 'specialized',
             });
-            output.printSuccess(`Swarm coordination initialized with ${agentCount} agent slots via MCP`);
+            output.printSuccess(`Swarm coordination config written (${agentCount} agent slots reserved) via MCP. No agents are running.`);
         }
         catch {
-            output.printWarning('MCP unavailable — showing agent plan only (no active coordination)');
+            output.printWarning('MCP unavailable — showing agent plan only (no swarm state written)');
         }
         output.writeln();
-        output.writeln(output.dim('Note: Use Claude Code Task tool or hive-mind spawn --claude to'));
-        output.writeln(output.dim('drive actual agent execution. This command sets up the topology.'));
+        output.writeln(output.dim('Use Claude Code Task tool or hive-mind spawn --claude to drive actual agent execution.'));
         return { success: true, data: { agents: v1Agents, count: agentCount } };
-    }
+    },
 };
 // Main swarm command
 export const swarmCommand = {
     name: 'swarm',
     description: 'Swarm coordination commands',
-    subcommands: [initCommand, startCommand, statusCommand, stopCommand, scaleCommand, coordinateCommand],
+    subcommands: [
+        initCommand,
+        startCommand,
+        statusCommand,
+        stopCommand,
+        scaleCommand,
+        coordinateCommand,
+    ],
     options: [],
     examples: [
         { command: 'monomind swarm init --v1-mode', description: 'Initialize swarm' },
-        { command: 'monomind swarm start -o "Build API" -s development', description: 'Start development swarm' },
-        { command: 'monomind swarm coordinate --agents 15', description: 'v1 coordination' }
+        {
+            command: 'monomind swarm start -o "Build API" -s development',
+            description: 'Start development swarm',
+        },
+        { command: 'monomind swarm coordinate --agents 15', description: 'v1 coordination' },
     ],
     action: async (ctx) => {
         output.writeln();
@@ -840,65 +881,70 @@ export const swarmCommand = {
             `${output.highlight('status')}      - Show swarm status`,
             `${output.highlight('stop')}        - Stop swarm execution`,
             `${output.highlight('scale')}       - Scale swarm agent count`,
-            `${output.highlight('coordinate')}  - 15-agent coordination`
+            `${output.highlight('coordinate')}  - 15-agent coordination`,
         ]);
         return { success: true };
-    }
+    },
 };
 // Helper function
 function getAgentPlan(strategy) {
     const plans = {
         specialized: [
-            { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Central orchestration (anti-drift)' },
+            {
+                role: 'Coordinator',
+                type: 'coordinator',
+                count: 1,
+                purpose: 'Central orchestration (anti-drift)',
+            },
             { role: 'Researcher', type: 'researcher', count: 1, purpose: 'Requirements analysis' },
             { role: 'Architect', type: 'architect', count: 1, purpose: 'System design' },
             { role: 'Coder', type: 'coder', count: 2, purpose: 'Implementation' },
             { role: 'Tester', type: 'tester', count: 1, purpose: 'Quality assurance' },
-            { role: 'Reviewer', type: 'reviewer', count: 1, purpose: 'Code review' }
+            { role: 'Reviewer', type: 'reviewer', count: 1, purpose: 'Code review' },
         ],
         balanced: [
             { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Orchestrate workflow' },
             { role: 'Worker', type: 'coder', count: 4, purpose: 'General implementation' },
-            { role: 'Reviewer', type: 'reviewer', count: 1, purpose: 'Quality review' }
+            { role: 'Reviewer', type: 'reviewer', count: 1, purpose: 'Quality review' },
         ],
         adaptive: [
             { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Dynamic orchestration' },
             { role: 'Scout', type: 'researcher', count: 1, purpose: 'Task analysis' },
-            { role: 'Worker', type: 'coder', count: 3, purpose: 'Adaptive execution' }
+            { role: 'Worker', type: 'coder', count: 3, purpose: 'Adaptive execution' },
         ],
         development: [
             { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Orchestrate workflow' },
             { role: 'Architect', type: 'architect', count: 1, purpose: 'System design' },
             { role: 'Coder', type: 'coder', count: 3, purpose: 'Implementation' },
             { role: 'Tester', type: 'tester', count: 2, purpose: 'Quality assurance' },
-            { role: 'Reviewer', type: 'reviewer', count: 1, purpose: 'Code review' }
+            { role: 'Reviewer', type: 'reviewer', count: 1, purpose: 'Code review' },
         ],
         research: [
             { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Research coordination' },
             { role: 'Researcher', type: 'researcher', count: 4, purpose: 'Data gathering' },
-            { role: 'Analyst', type: 'analyst', count: 2, purpose: 'Analysis and synthesis' }
+            { role: 'Analyst', type: 'analyst', count: 2, purpose: 'Analysis and synthesis' },
         ],
         testing: [
             { role: 'Test Lead', type: 'tester', count: 1, purpose: 'Test strategy' },
             { role: 'Unit Tester', type: 'tester', count: 2, purpose: 'Unit tests' },
             { role: 'Integration Tester', type: 'tester', count: 2, purpose: 'Integration tests' },
-            { role: 'QA Reviewer', type: 'reviewer', count: 1, purpose: 'Quality review' }
+            { role: 'QA Reviewer', type: 'reviewer', count: 1, purpose: 'Quality review' },
         ],
         optimization: [
             { role: 'Performance Lead', type: 'optimizer', count: 1, purpose: 'Performance strategy' },
             { role: 'Profiler', type: 'analyst', count: 2, purpose: 'Profiling' },
-            { role: 'Optimizer', type: 'coder', count: 2, purpose: 'Optimization' }
+            { role: 'Optimizer', type: 'coder', count: 2, purpose: 'Optimization' },
         ],
         maintenance: [
             { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Maintenance planning' },
             { role: 'Refactorer', type: 'coder', count: 2, purpose: 'Code cleanup' },
-            { role: 'Documenter', type: 'researcher', count: 1, purpose: 'Documentation' }
+            { role: 'Documenter', type: 'researcher', count: 1, purpose: 'Documentation' },
         ],
         analysis: [
             { role: 'Analyst Lead', type: 'analyst', count: 1, purpose: 'Analysis coordination' },
             { role: 'Code Analyst', type: 'analyst', count: 2, purpose: 'Code analysis' },
-            { role: 'Security Analyst', type: 'reviewer', count: 1, purpose: 'Security review' }
-        ]
+            { role: 'Security Analyst', type: 'reviewer', count: 1, purpose: 'Security review' },
+        ],
     };
     return plans[strategy] || plans.development;
 }