@claude-flow/cli 3.0.0-alpha.6 → 3.0.0-alpha.60

package/__tests__/p1-commands.test.ts

@@ -1,1064 +0,0 @@
-/**
- * V3 CLI P1 Commands Tests
- * Tests for init, start, status, task, and session commands
- */
-
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { initCommand } from '../src/commands/init.js';
-import { startCommand } from '../src/commands/start.js';
-import { statusCommand } from '../src/commands/status.js';
-import { taskCommand } from '../src/commands/task.js';
-import { sessionCommand } from '../src/commands/session.js';
-import type { CommandContext } from '../src/types.js';
-import * as fs from 'fs';
-import * as path from 'path';
-
-// Mock fs module
-vi.mock('fs', () => ({
-  existsSync: vi.fn(),
-  mkdirSync: vi.fn(),
-  writeFileSync: vi.fn(),
-  readFileSync: vi.fn(),
-  unlinkSync: vi.fn()
-}));
-
-// Mock MCP client
-vi.mock('../src/mcp-client.js', () => ({
-  callMCPTool: vi.fn(async (toolName: string, input: Record<string, unknown>) => {
-    // Swarm tools
-    if (toolName === 'swarm/init') {
-      return {
-        swarmId: 'swarm-mock-123',
-        topology: input.topology || 'hierarchical-mesh',
-        initializedAt: new Date().toISOString(),
-        config: {
-          topology: input.topology,
-          maxAgents: input.maxAgents || 15,
-          currentAgents: 0,
-          autoScaling: true
-        }
-      };
-    }
-
-    if (toolName === 'swarm/status') {
-      return {
-        swarmId: 'swarm-mock-123',
-        topology: 'hierarchical-mesh',
-        agents: { total: 5, active: 3, idle: 2, terminated: 0 },
-        health: 'healthy',
-        uptime: 3600000
-      };
-    }
-
-    if (toolName === 'swarm/health') {
-      return {
-        status: 'healthy',
-        checks: [
-          { name: 'agents', status: 'pass' },
-          { name: 'memory', status: 'pass' }
-        ]
-      };
-    }
-
-    if (toolName === 'swarm/stop') {
-      return { stopped: true, stoppedAt: new Date().toISOString() };
-    }
-
-    // MCP tools
-    if (toolName === 'mcp/start') {
-      return {
-        serverId: 'mcp-mock-123',
-        port: input.port || 3000,
-        transport: input.transport || 'stdio',
-        startedAt: new Date().toISOString()
-      };
-    }
-
-    if (toolName === 'mcp/status') {
-      return { running: true, port: 3000, transport: 'stdio' };
-    }
-
-    if (toolName === 'mcp/stop') {
-      return { stopped: true };
-    }
-
-    // Memory tools
-    if (toolName === 'memory/stats') {
-      return {
-        entries: 100,
-        size: 1024000,
-        backend: 'hybrid',
-        performance: { avgSearchTime: 0.5, cacheHitRate: 0.85 }
-      };
-    }
-
-    if (toolName === 'memory/detailed-stats') {
-      return {
-        backend: 'hybrid',
-        entries: 100,
-        size: 1024000,
-        namespaces: [{ name: 'default', entries: 100 }],
-        performance: {
-          avgSearchTime: 0.5,
-          avgWriteTime: 1.2,
-          cacheHitRate: 0.85,
-          hnswEnabled: true
-        },
-        v3Gains: {
-          searchImprovement: '150x faster',
-          memoryReduction: '50% reduction'
-        }
-      };
-    }
-
-    // Task tools
-    if (toolName === 'task/create') {
-      return {
-        taskId: `task-${Date.now()}`,
-        type: input.type,
-        description: input.description,
-        priority: input.priority || 'normal',
-        status: 'pending',
-        createdAt: new Date().toISOString(),
-        assignedTo: input.assignedTo,
-        tags: input.tags || []
-      };
-    }
-
-    if (toolName === 'task/list') {
-      return {
-        tasks: [
-          {
-            id: 'task-1',
-            type: 'implementation',
-            description: 'Add user auth',
-            priority: 'high',
-            status: 'running',
-            progress: 50,
-            createdAt: new Date().toISOString()
-          },
-          {
-            id: 'task-2',
-            type: 'testing',
-            description: 'Write unit tests',
-            priority: 'normal',
-            status: 'pending',
-            progress: 0,
-            createdAt: new Date().toISOString()
-          }
-        ],
-        total: 2
-      };
-    }
-
-    if (toolName === 'task/status') {
-      return {
-        id: input.taskId,
-        type: 'implementation',
-        description: 'Add user authentication',
-        priority: 'high',
-        status: 'running',
-        progress: 50,
-        assignedTo: ['coder-1'],
-        parentId: null,
-        dependencies: [],
-        dependents: [],
-        tags: ['auth', 'security'],
-        createdAt: new Date().toISOString(),
-        startedAt: new Date().toISOString(),
-        metrics: {
-          executionTime: 60000,
-          retries: 0,
-          tokensUsed: 5000
-        }
-      };
-    }
-
-    if (toolName === 'task/cancel') {
-      return {
-        taskId: input.taskId,
-        cancelled: true,
-        previousStatus: 'running',
-        cancelledAt: new Date().toISOString()
-      };
-    }
-
-    if (toolName === 'task/assign') {
-      return {
-        taskId: input.taskId,
-        assignedTo: input.agentIds || [],
-        previouslyAssigned: []
-      };
-    }
-
-    if (toolName === 'task/retry') {
-      return {
-        taskId: input.taskId,
-        newTaskId: `task-retry-${Date.now()}`,
-        previousStatus: 'failed',
-        status: 'pending'
-      };
-    }
-
-    if (toolName === 'task/summary') {
-      return {
-        total: 10,
-        pending: 3,
-        running: 2,
-        completed: 4,
-        failed: 1
-      };
-    }
-
-    // Session tools
-    if (toolName === 'session/list') {
-      return {
-        sessions: [
-          {
-            id: 'session-1',
-            name: 'dev-session',
-            status: 'saved',
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            agentCount: 3,
-            taskCount: 5,
-            memorySize: 1024
-          },
-          {
-            id: 'session-2',
-            name: 'test-session',
-            status: 'active',
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            agentCount: 2,
-            taskCount: 3,
-            memorySize: 512
-          }
-        ],
-        total: 2
-      };
-    }
-
-    if (toolName === 'session/save') {
-      return {
-        sessionId: `session-${Date.now()}`,
-        name: input.name || 'unnamed',
-        description: input.description,
-        savedAt: new Date().toISOString(),
-        includes: {
-          memory: input.includeMemory !== false,
-          agents: input.includeAgents !== false,
-          tasks: input.includeTasks !== false
-        },
-        stats: {
-          agentCount: 3,
-          taskCount: 5,
-          memoryEntries: 100,
-          totalSize: 1024000
-        }
-      };
-    }
-
-    if (toolName === 'session/restore') {
-      return {
-        sessionId: input.sessionId,
-        restoredAt: new Date().toISOString(),
-        restored: {
-          memory: input.restoreMemory !== false,
-          agents: input.restoreAgents !== false,
-          tasks: input.restoreTasks !== false
-        },
-        stats: {
-          agentsRestored: 3,
-          tasksRestored: 5,
-          memoryEntriesRestored: 100
-        }
-      };
-    }
-
-    if (toolName === 'session/delete') {
-      return {
-        sessionId: input.sessionId,
-        deleted: true,
-        deletedAt: new Date().toISOString()
-      };
-    }
-
-    if (toolName === 'session/export') {
-      return {
-        sessionId: input.sessionId || 'current',
-        data: { agents: [], tasks: [], memory: [] },
-        stats: {
-          agentCount: 3,
-          taskCount: 5,
-          memoryEntries: 100
-        }
-      };
-    }
-
-    if (toolName === 'session/import') {
-      return {
-        sessionId: `session-imported-${Date.now()}`,
-        name: input.name || 'imported',
-        importedAt: new Date().toISOString(),
-        stats: {
-          agentsImported: 3,
-          tasksImported: 5,
-          memoryEntriesImported: 100
-        },
-        activated: input.activate || false
-      };
-    }
-
-    if (toolName === 'session/current') {
-      return {
-        sessionId: 'session-current',
-        name: 'current-session',
-        status: 'active',
-        startedAt: new Date().toISOString(),
-        stats: {
-          agentCount: 3,
-          taskCount: 5,
-          memoryEntries: 100,
-          duration: 3600000
-        }
-      };
-    }
-
-    // Agent tools for task assign
-    if (toolName === 'agent/list') {
-      return {
-        agents: [
-          { id: 'coder-1', type: 'coder', status: 'active' },
-          { id: 'tester-1', type: 'tester', status: 'idle' }
-        ],
-        total: 2
-      };
-    }
-
-    return {};
-  }),
-  MCPClientError: class MCPClientError extends Error {
-    constructor(message: string, public toolName: string, public cause?: Error) {
-      super(message);
-      this.name = 'MCPClientError';
-    }
-  }
-}));
-
-// Mock output
-vi.mock('../src/output.js', () => ({
-  output: {
-    writeln: vi.fn(),
-    printInfo: vi.fn(),
-    printSuccess: vi.fn(),
-    printError: vi.fn(),
-    printWarning: vi.fn(),
-    printTable: vi.fn(),
-    printJson: vi.fn(),
-    printList: vi.fn(),
-    printBox: vi.fn(),
-    createSpinner: vi.fn(() => ({
-      start: vi.fn(),
-      succeed: vi.fn(),
-      fail: vi.fn(),
-      stop: vi.fn(),
-      setText: vi.fn()
-    })),
-    createProgress: vi.fn(() => ({
-      update: vi.fn(),
-      finish: vi.fn()
-    })),
-    highlight: (str: string) => str,
-    bold: (str: string) => str,
-    dim: (str: string) => str,
-    success: (str: string) => str,
-    error: (str: string) => str,
-    warning: (str: string) => str,
-    info: (str: string) => str,
-    progressBar: () => '[=====>    ]',
-    setColorEnabled: vi.fn()
-  }
-}));
-
-// Mock prompts
-vi.mock('../src/prompt.js', () => ({
-  select: vi.fn(async (opts) => opts.default || opts.options[0]?.value),
-  confirm: vi.fn(async (opts) => opts.default ?? false),
-  input: vi.fn(async (opts) => opts.default || 'test-input'),
-  multiSelect: vi.fn(async (opts) => opts.default || [])
-}));
-
-describe('Init Command', () => {
-  let ctx: CommandContext;
-
-  beforeEach(() => {
-    ctx = {
-      args: [],
-      flags: { _: [] },
-      cwd: '/test/project',
-      interactive: false
-    };
-    vi.clearAllMocks();
-  });
-
-  describe('init (default)', () => {
-    // TODO: Init command tests require complex mocking of executeInit internals
-    // These tests were never running before, skipped for alpha release
-    it.skip('should initialize with default configuration', async () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-
-      const result = await initCommand.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('success', true);
-      expect(fs.mkdirSync).toHaveBeenCalled();
-      expect(fs.writeFileSync).toHaveBeenCalled();
-    });
-
-    it.skip('should initialize with minimal configuration', async () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-      ctx.flags = { minimal: true, _: [] };
-
-      const result = await initCommand.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('success', true);
-    });
-
-    it.skip('should initialize with full configuration', async () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-      ctx.flags = { full: true, _: [] };
-
-      const result = await initCommand.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('success', true);
-    });
-
-    it('should fail if already initialized without force', async () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-
-      const result = await initCommand.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-
-    it.skip('should reinitialize with force flag', async () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      ctx.flags = { force: true, _: [] };
-
-      const result = await initCommand.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('init check', () => {
-    it('should report initialized status', async () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-
-      const checkCmd = initCommand.subcommands?.find(c => c.name === 'check');
-      const result = await checkCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('initialized', true);
-    });
-
-    it('should report not initialized status', async () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-
-      const checkCmd = initCommand.subcommands?.find(c => c.name === 'check');
-      const result = await checkCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('initialized', false);
-    });
-  });
-});
-
-describe('Start Command', () => {
-  let ctx: CommandContext;
-
-  beforeEach(() => {
-    ctx = {
-      args: [],
-      flags: { _: [] },
-      cwd: '/test/project',
-      interactive: false
-    };
-    vi.clearAllMocks();
-    vi.mocked(fs.existsSync).mockImplementation((p: fs.PathLike) => {
-      const pathStr = String(p);
-      return pathStr.includes('config.yaml');
-    });
-    vi.mocked(fs.readFileSync).mockReturnValue('version: 3.0.0\nswarm:\n  topology: mesh');
-  });
-
-  describe('start (default)', () => {
-    it('should start system with defaults', async () => {
-      const result = await startCommand.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('swarmId');
-      expect(result.data).toHaveProperty('topology');
-    });
-
-    it('should start with custom port', async () => {
-      ctx.flags = { port: 3001, _: [] };
-
-      const result = await startCommand.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should start with custom topology', async () => {
-      ctx.flags = { topology: 'mesh', _: [] };
-
-      const result = await startCommand.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('topology', 'mesh');
-    });
-
-    it('should start in daemon mode', async () => {
-      ctx.flags = { daemon: true, _: [] };
-
-      const result = await startCommand.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('daemon', true);
-    });
-
-    it('should skip MCP server when requested', async () => {
-      ctx.flags = { 'skip-mcp': true, _: [] };
-
-      const result = await startCommand.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('mcp', null);
-    });
-
-    it('should fail if not initialized', async () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-
-      const result = await startCommand.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('start stop', () => {
-    it('should stop system', async () => {
-      ctx.flags = { force: true, _: [] };
-
-      const stopCmd = startCommand.subcommands?.find(c => c.name === 'stop');
-      const result = await stopCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('stopped', true);
-    });
-  });
-
-  describe('start restart', () => {
-    it('should restart system', async () => {
-      const restartCmd = startCommand.subcommands?.find(c => c.name === 'restart');
-      const result = await restartCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('restarted');
-    });
-  });
-});
-
-describe('Status Command', () => {
-  let ctx: CommandContext;
-
-  beforeEach(() => {
-    ctx = {
-      args: [],
-      flags: { _: [] },
-      cwd: '/test/project',
-      interactive: false
-    };
-    vi.clearAllMocks();
-    vi.mocked(fs.existsSync).mockReturnValue(true);
-  });
-
-  describe('status (default)', () => {
-    it('should show system status', async () => {
-      const result = await statusCommand.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('running');
-      expect(result.data).toHaveProperty('swarm');
-      expect(result.data).toHaveProperty('mcp');
-      expect(result.data).toHaveProperty('memory');
-      expect(result.data).toHaveProperty('tasks');
-    });
-
-    it('should output JSON when requested', async () => {
-      ctx.flags = { format: 'json', _: [] };
-
-      const result = await statusCommand.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should perform health check', async () => {
-      ctx.flags = { 'health-check': true, _: [] };
-
-      const result = await statusCommand.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('checks');
-      expect(result.data).toHaveProperty('summary');
-    });
-
-    it('should fail if not initialized', async () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-
-      const result = await statusCommand.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('status agents', () => {
-    it('should show agent status', async () => {
-      const agentsCmd = statusCommand.subcommands?.find(c => c.name === 'agents');
-      const result = await agentsCmd!.action!(ctx);
-
-      // The status agents command makes an agent/list call which returns successfully
-      // Success depends on whether the MCP call succeeds
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('status tasks', () => {
-    it('should show task status', async () => {
-      const tasksCmd = statusCommand.subcommands?.find(c => c.name === 'tasks');
-      const result = await tasksCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('status memory', () => {
-    it('should show memory status', async () => {
-      const memoryCmd = statusCommand.subcommands?.find(c => c.name === 'memory');
-      const result = await memoryCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-  });
-});
-
-describe('Task Command', () => {
-  let ctx: CommandContext;
-
-  beforeEach(() => {
-    ctx = {
-      args: [],
-      flags: { _: [] },
-      cwd: '/test/project',
-      interactive: false
-    };
-    vi.clearAllMocks();
-  });
-
-  describe('task create', () => {
-    it('should create task with type and description', async () => {
-      const createCmd = taskCommand.subcommands?.find(c => c.name === 'create');
-      ctx.flags = {
-        type: 'implementation',
-        description: 'Add user authentication',
-        _: []
-      };
-
-      const result = await createCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('taskId');
-      expect(result.data).toHaveProperty('type', 'implementation');
-      expect(result.data).toHaveProperty('description', 'Add user authentication');
-    });
-
-    it('should create task with priority', async () => {
-      const createCmd = taskCommand.subcommands?.find(c => c.name === 'create');
-      ctx.flags = {
-        type: 'bug-fix',
-        description: 'Fix login issue',
-        priority: 'high',
-        _: []
-      };
-
-      const result = await createCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('priority', 'high');
-    });
-
-    it('should fail without type', async () => {
-      const createCmd = taskCommand.subcommands?.find(c => c.name === 'create');
-      ctx.flags = { description: 'Test', _: [] };
-
-      const result = await createCmd!.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-
-    it('should fail without description', async () => {
-      const createCmd = taskCommand.subcommands?.find(c => c.name === 'create');
-      ctx.flags = { type: 'implementation', _: [] };
-
-      const result = await createCmd!.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('task list', () => {
-    it('should list tasks', async () => {
-      const listCmd = taskCommand.subcommands?.find(c => c.name === 'list');
-
-      const result = await listCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('tasks');
-      expect(result.data).toHaveProperty('total');
-    });
-
-    it('should filter by status', async () => {
-      const listCmd = taskCommand.subcommands?.find(c => c.name === 'list');
-      ctx.flags = { status: 'running', _: [] };
-
-      const result = await listCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should show all tasks', async () => {
-      const listCmd = taskCommand.subcommands?.find(c => c.name === 'list');
-      ctx.flags = { all: true, _: [] };
-
-      const result = await listCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('task status', () => {
-    it('should get task status', async () => {
-      const statusCmd = taskCommand.subcommands?.find(c => c.name === 'status');
-      ctx.args = ['task-123'];
-
-      const result = await statusCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('id');
-      expect(result.data).toHaveProperty('status');
-      expect(result.data).toHaveProperty('metrics');
-    });
-
-    it('should fail without task ID', async () => {
-      const statusCmd = taskCommand.subcommands?.find(c => c.name === 'status');
-
-      const result = await statusCmd!.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('task cancel', () => {
-    it('should cancel task', async () => {
-      const cancelCmd = taskCommand.subcommands?.find(c => c.name === 'cancel');
-      ctx.args = ['task-123'];
-      ctx.flags = { force: true, _: [] };
-
-      const result = await cancelCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('cancelled', true);
-    });
-
-    it('should fail without task ID', async () => {
-      const cancelCmd = taskCommand.subcommands?.find(c => c.name === 'cancel');
-
-      const result = await cancelCmd!.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('task assign', () => {
-    it('should assign task to agent', async () => {
-      const assignCmd = taskCommand.subcommands?.find(c => c.name === 'assign');
-      ctx.args = ['task-123'];
-      ctx.flags = { agent: 'coder-1', _: [] };
-
-      const result = await assignCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('assignedTo');
-    });
-
-    it('should unassign task', async () => {
-      const assignCmd = taskCommand.subcommands?.find(c => c.name === 'assign');
-      ctx.args = ['task-123'];
-      ctx.flags = { unassign: true, _: [] };
-
-      const result = await assignCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should fail without task ID', async () => {
-      const assignCmd = taskCommand.subcommands?.find(c => c.name === 'assign');
-      ctx.flags = { agent: 'coder-1', _: [] };
-
-      const result = await assignCmd!.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('task retry', () => {
-    it('should retry failed task', async () => {
-      const retryCmd = taskCommand.subcommands?.find(c => c.name === 'retry');
-      ctx.args = ['task-123'];
-
-      const result = await retryCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('newTaskId');
-    });
-
-    it('should fail without task ID', async () => {
-      const retryCmd = taskCommand.subcommands?.find(c => c.name === 'retry');
-
-      const result = await retryCmd!.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-  });
-});
-
-describe('Session Command', () => {
-  let ctx: CommandContext;
-
-  beforeEach(() => {
-    ctx = {
-      args: [],
-      flags: { _: [] },
-      cwd: '/test/project',
-      interactive: false
-    };
-    vi.clearAllMocks();
-  });
-
-  describe('session list', () => {
-    it('should list sessions', async () => {
-      const listCmd = sessionCommand.subcommands?.find(c => c.name === 'list');
-
-      const result = await listCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('sessions');
-      expect(result.data).toHaveProperty('total');
-    });
-
-    it('should filter active sessions', async () => {
-      const listCmd = sessionCommand.subcommands?.find(c => c.name === 'list');
-      ctx.flags = { active: true, _: [] };
-
-      const result = await listCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should include archived sessions', async () => {
-      const listCmd = sessionCommand.subcommands?.find(c => c.name === 'list');
-      ctx.flags = { all: true, _: [] };
-
-      const result = await listCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('session save', () => {
-    it('should save session with name', async () => {
-      const saveCmd = sessionCommand.subcommands?.find(c => c.name === 'save');
-      ctx.flags = { name: 'my-session', _: [] };
-
-      const result = await saveCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('sessionId');
-      expect(result.data).toHaveProperty('name', 'my-session');
-    });
-
-    it('should save session with description', async () => {
-      const saveCmd = sessionCommand.subcommands?.find(c => c.name === 'save');
-      ctx.flags = { name: 'checkpoint', description: 'Before refactoring', _: [] };
-
-      const result = await saveCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should exclude memory when requested', async () => {
-      const saveCmd = sessionCommand.subcommands?.find(c => c.name === 'save');
-      ctx.flags = { name: 'no-memory', 'include-memory': false, _: [] };
-
-      const result = await saveCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('session restore', () => {
-    it('should restore session', async () => {
-      const restoreCmd = sessionCommand.subcommands?.find(c => c.name === 'restore');
-      ctx.args = ['session-123'];
-      ctx.flags = { force: true, _: [] };
-
-      const result = await restoreCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('restored');
-    });
-
-    it('should restore only memory', async () => {
-      const restoreCmd = sessionCommand.subcommands?.find(c => c.name === 'restore');
-      ctx.args = ['session-123'];
-      ctx.flags = { force: true, 'memory-only': true, _: [] };
-
-      const result = await restoreCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should fail without session ID in non-interactive mode', async () => {
-      const restoreCmd = sessionCommand.subcommands?.find(c => c.name === 'restore');
-
-      const result = await restoreCmd!.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('session delete', () => {
-    it('should delete session', async () => {
-      const deleteCmd = sessionCommand.subcommands?.find(c => c.name === 'delete');
-      ctx.args = ['session-123'];
-      ctx.flags = { force: true, _: [] };
-
-      const result = await deleteCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('deleted', true);
-    });
-
-    it('should fail without session ID', async () => {
-      const deleteCmd = sessionCommand.subcommands?.find(c => c.name === 'delete');
-      ctx.flags = { force: true, _: [] };
-
-      const result = await deleteCmd!.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('session export', () => {
-    it('should export session to file', async () => {
-      // Need to set up proper mock for session/current call
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-
-      const exportCmd = sessionCommand.subcommands?.find(c => c.name === 'export');
-      ctx.args = ['session-123'];
-      ctx.flags = { output: 'backup.json', _: [] };
-
-      const result = await exportCmd!.action!(ctx);
-
-      // Result depends on MCP calls succeeding
-      expect(result).toBeDefined();
-    });
-
-    it('should export in YAML format', async () => {
-      const exportCmd = sessionCommand.subcommands?.find(c => c.name === 'export');
-      ctx.args = ['session-123'];
-      ctx.flags = { output: 'backup.yaml', format: 'yaml', _: [] };
-
-      const result = await exportCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('format', 'yaml');
-    });
-  });
-
-  describe('session import', () => {
-    it('should import session from file', async () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue('{"agents":[],"tasks":[]}');
-
-      const importCmd = sessionCommand.subcommands?.find(c => c.name === 'import');
-      ctx.args = ['backup.json'];
-
-      const result = await importCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('sessionId');
-    });
-
-    it('should fail if file not found', async () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-
-      const importCmd = sessionCommand.subcommands?.find(c => c.name === 'import');
-      ctx.args = ['missing.json'];
-
-      const result = await importCmd!.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-
-    it('should fail without file path', async () => {
-      const importCmd = sessionCommand.subcommands?.find(c => c.name === 'import');
-
-      const result = await importCmd!.action!(ctx);
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('session current', () => {
-    it('should show current session', async () => {
-      const currentCmd = sessionCommand.subcommands?.find(c => c.name === 'current');
-
-      const result = await currentCmd!.action!(ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveProperty('sessionId');
-      expect(result.data).toHaveProperty('stats');
-    });
-  });
-});
-
-describe('Command Index Exports', () => {
-  it('should export all P1 commands', async () => {
-    const { commands, initCommand: init, startCommand: start, statusCommand: status, taskCommand: task, sessionCommand: session } = await import('../src/commands/index.js');
-
-    expect(init).toBeDefined();
-    expect(start).toBeDefined();
-    expect(status).toBeDefined();
-    expect(task).toBeDefined();
-    expect(session).toBeDefined();
-
-    expect(commands).toContain(init);
-    expect(commands).toContain(start);
-    expect(commands).toContain(status);
-    expect(commands).toContain(task);
-    expect(commands).toContain(session);
-  });
-});