mcp-codex-subagent 2.0.8 → 2.0.10

package/dist/tools/handlers.js

@@ -1,15 +1,22 @@
-import { spawn } from 'child_process';
 import { readFile } from 'fs/promises';
-import { TOOLS, PINNED_CODEX_MODEL, ROLE_TO_TASK_TYPE, CodexToolSchema, ReviewToolSchema, PingToolSchema, HelpToolSchema, ListSessionsToolSchema, } from '../types.js';
-import { InMemorySessionStorage, } from '../session/storage.js';
+import { TOOLS, PINNED_CODEX_MODEL, ROLE_TO_TASK_TYPE, CodexToolSchema, ReviewToolSchema, } from '../types.js';
+import { SpawnAgentGroupSchema, GROUP_TIMEOUT_MS, } from '../wave/types.js';
+import { validateDag } from '../wave/dag.js';
+import { groupRegistry } from '../wave/registry.js';
+import { orchestrate } from '../wave/orchestrator.js';
+import { FileSessionStorage } from '../session/file-storage.js';
 import { ToolExecutionError, ValidationError } from '../errors.js';
 import { executeCommand, executeCommandStreaming } from '../utils/command.js';
 import { ZodError } from 'zod';
 import { applyTemplate, isValidTaskType } from '../templates/index.js';
 import { mcpText, mcpValidationError } from '../utils/format.js';
 import { validateBrief, formatBriefValidationError, assemblePromptWithContext, } from '../utils/brief-validator.js';
-import { createTask, appendOutput, completeTask, failTask, setProcess, } from '../services/task-manager.js';
 import { getLastMessagePath } from '../services/output-file.js';
+import { CodexProcessRunner } from '../process/runner.js';
+import { taskStore } from '../task/store.js';
+import { taskEventBus } from '../event/bus.js';
+import { NotificationThrottle } from '../event/throttle.js';
+import { rotateAccount } from '../services/account-rotator.js';
 // Default no-op context for handlers that don't need progress
 const defaultContext = {
     sendProgress: async () => { },
@@ -20,162 +27,40 @@ const isStructuredContentEnabled = () => {
         return false;
     return ['1', 'true', 'yes', 'on'].includes(raw.toLowerCase());
 };
-// Notification sender reference — set by server.ts after server init
-let notificationSender = null;
-export function setNotificationSender(sender) {
-    notificationSender = sender;
-}
+// --- Notification throttle (replaces direct notifyResourceChanged) ---
+let notificationThrottle = null;
 /**
- * Send MCP resource-changed notification so clients refresh task resources.
+ * Set the notification sender. Creates a throttle that coalesces
+ * resource-update notifications.
  */
-async function notifyResourceChanged(uri) {
-    if (!notificationSender)
-        return;
-    try {
-        await notificationSender.sendNotification({
-            method: 'notifications/resources/updated',
-            params: { uri },
-        });
-    }
-    catch {
-        // Non-fatal — client may not support resource subscriptions
-    }
+export function setNotificationSender(sender) {
+    const intervalMs = parseInt(process.env.CODEX_NOTIFICATION_INTERVAL_MS || '', 10);
+    notificationThrottle = new NotificationThrottle({
+        intervalMs: Number.isFinite(intervalMs) && intervalMs > 0 ? intervalMs : 500,
+        send: async () => {
+            try {
+                await sender.sendNotification({
+                    method: 'notifications/resources/updated',
+                    params: {},
+                });
+            }
+            catch {
+                // Non-fatal
+            }
+        },
+    });
 }
 /**
- * Known stderr noise patterns from codex-core internals.
- * These are non-actionable internal diagnostics that pollute output.
- * Matched via substring — order doesn't matter.
- */
-const STDERR_NOISE_PATTERNS = [
-    // State DB rollout errors — emitted once per old session on every startup
-    'state db missing rollout path',
-    'missing rollout path for thread',
-    'codex_core::rollout::list',
-    // Internal tracing noise
-    'codex_core::config_watcher',
-    'codex_core::telemetry',
-    // Model provider progress (not errors)
-    'Refreshing model list',
-    'model list refreshed',
-];
-/**
- * Test whether a stderr chunk is just noise (should be dropped).
+ * Queue a resource-changed notification (throttled).
  */
-function isStderrNoise(chunk) {
-    return STDERR_NOISE_PATTERNS.some((p) => chunk.includes(p));
+export function notifyResourceChanged() {
+    notificationThrottle?.notify();
 }
 /**
- * Parse a JSONL line from codex --json output.
- *
- * Design:
- *   - Skips streaming intermediates (item.started, thread.started, turn.started)
- *   - Extracts completed items as clean JSONL
- *   - Preserves turn.completed for usage stats
- *   - Preserves turn.failed and item.failed for error visibility
- *   - Normalises legacy event shapes to the modern item schema
- *
- * Every non-null return value is a single valid JSON string (proper JSONL).
- *
- * Ref: https://developers.openai.com/codex/noninteractive/
+ * Flush pending notifications (for shutdown).
  */
-function parseCodexEvent(line) {
-    const trimmed = line.trim();
-    if (!trimmed)
-        return null;
-    try {
-        const event = JSON.parse(trimmed);
-        // ------------------------------------------------------------------
-        // 1. Skip lifecycle / streaming intermediate events
-        // ------------------------------------------------------------------
-        if (event.type === 'thread.started' ||
-            event.type === 'turn.started' ||
-            event.type === 'item.started') {
-            return null;
-        }
-        // ------------------------------------------------------------------
-        // 2. Turn completion — emit usage stats (token counts)
-        //    Schema: { type, usage: { input_tokens, cached_input_tokens, output_tokens } }
-        // ------------------------------------------------------------------
-        if (event.type === 'turn.completed') {
-            if (event.usage) {
-                return JSON.stringify({ type: 'turn_usage', ...event.usage });
-            }
-            return null; // no usage data → skip
-        }
-        // ------------------------------------------------------------------
-        // 3. Turn failure — surface error
-        //    Schema: { type, error: { message?, code? } }
-        // ------------------------------------------------------------------
-        if (event.type === 'turn.failed') {
-            const err = event.error;
-            return JSON.stringify({
-                type: 'turn_failed',
-                code: err?.code ?? err?.codexErrorInfo?.type ?? null,
-                message: err?.message || 'Unknown turn failure',
-            });
-        }
-        // ------------------------------------------------------------------
-        // 4. Item failed — emit item with _failed marker
-        // ------------------------------------------------------------------
-        if (event.type === 'item.failed' && event.item) {
-            return JSON.stringify({ ...event.item, _failed: true });
-        }
-        // ------------------------------------------------------------------
-        // 5. Item completed — the primary event. Extract item payload.
-        //    Item types: agent_message, reasoning, command_execution,
-        //    file_change, mcp_tool_call, web_search, plan_update
-        // ------------------------------------------------------------------
-        if (event.type === 'item.completed' && event.item) {
-            return JSON.stringify(event.item);
-        }
-        // ------------------------------------------------------------------
-        // 6. Top-level error
-        //    Schema: { type: "error", error: { code, message } }
-        // ------------------------------------------------------------------
-        if (event.type === 'error') {
-            const err = event.error ?? event;
-            return JSON.stringify({
-                type: 'error',
-                code: err.code ?? null,
-                message: err.message || trimmed,
-            });
-        }
-        // ------------------------------------------------------------------
-        // 7. Legacy / alternate event shapes (pre-2025 codex versions)
-        // ------------------------------------------------------------------
-        if (event.type === 'message' && event.content) {
-            return JSON.stringify({
-                id: event.id ?? null,
-                type: 'agent_message',
-                text: event.content,
-            });
-        }
-        if (event.type === 'function_call') {
-            return JSON.stringify({
-                id: event.id ?? null,
-                type: 'function_call',
-                name: event.name,
-                arguments: event.arguments,
-            });
-        }
-        if (event.type === 'function_call_output') {
-            return JSON.stringify({
-                id: event.id ?? null,
-                type: 'function_call_output',
-                output: typeof event.output === 'string'
-                    ? event.output
-                    : JSON.stringify(event.output),
-            });
-        }
-        // ------------------------------------------------------------------
-        // 8. Unknown event — pass through as-is
-        // ------------------------------------------------------------------
-        return JSON.stringify(event);
-    }
-    catch {
-        // Not valid JSON — skip malformed lines
-        return null;
-    }
+export async function flushNotifications() {
+    await notificationThrottle?.flush();
 }
 export class CodexToolHandler {
     sessionStorage;
@@ -234,10 +119,10 @@ export class CodexToolHandler {
                     enrichedPrompt = applyTemplate(taskType, enrichedPrompt, specialization);
                 }
             }
-            // --- Step 4: Create task ---
+            // --- Step 4: Create task in store ---
             const selectedModel = PINNED_CODEX_MODEL;
             const effort = reasoningEffort ?? 'xhigh';
-            const task = await createTask({
+            const task = await taskStore.createTask({
                 prompt,
                 role,
                 specialization,
@@ -249,117 +134,141 @@ export class CodexToolHandler {
             const lastMessagePath = getLastMessagePath(cwd, task.id);
             let cmdArgs;
             if (useResume && codexConversationId) {
-                cmdArgs = ['exec', '--skip-git-repo-check', '--json'];
-                cmdArgs.push('-o', lastMessagePath);
-                cmdArgs.push('-c', `model="${selectedModel}"`);
-                cmdArgs.push('-c', `model_reasoning_effort="${effort}"`);
-                cmdArgs.push('resume', codexConversationId, enrichedPrompt);
+                cmdArgs = [
+                    'exec',
+                    '--yolo',
+                    '--search',
+                    '--skip-git-repo-check',
+                    '--json',
+                    '-o',
+                    lastMessagePath,
+                    '-c',
+                    `model="${selectedModel}"`,
+                    '-c',
+                    `model_reasoning_effort="${effort}"`,
+                    'resume',
+                    codexConversationId,
+                    enrichedPrompt,
+                ];
             }
             else {
-                cmdArgs = ['exec', '--json'];
-                cmdArgs.push('-o', lastMessagePath);
-                cmdArgs.push('--model', selectedModel);
-                cmdArgs.push('-c', `model_reasoning_effort="${effort}"`);
-                cmdArgs.push('--sandbox', sandbox ?? 'danger-full-access');
-                cmdArgs.push('--dangerously-bypass-approvals-and-sandbox');
-                cmdArgs.push('-C', cwd);
-                cmdArgs.push('--skip-git-repo-check');
-                cmdArgs.push(enrichedPrompt);
+                cmdArgs = [
+                    'exec',
+                    '--yolo',
+                    '--search',
+                    '--json',
+                    '-o',
+                    lastMessagePath,
+                    '--model',
+                    selectedModel,
+                    '-c',
+                    `model_reasoning_effort="${effort}"`,
+                    '-C',
+                    cwd,
+                    '--skip-git-repo-check',
+                    enrichedPrompt,
+                ];
             }
-            // --- Step 6: Spawn background process ---
-            const isWindows = process.platform === 'win32';
+            // --- Step 6: Spawn via ProcessRunner ---
             const env = effectiveCallbackUri
                 ? { ...process.env, CODEX_MCP_CALLBACK_URI: effectiveCallbackUri }
-                : process.env;
-            const child = spawn('codex', cmdArgs, {
-                shell: isWindows,
-                env,
-                stdio: ['pipe', 'pipe', 'pipe'],
-                detached: false,
-            });
-            setProcess(task.id, child);
-            // --- Step 7: Wire stdout for JSONL parsing ---
-            // Only completed items are emitted as clean JSONL (no streaming intermediates).
-            let stdoutBuffer = '';
-            child.stdout?.on('data', (data) => {
-                stdoutBuffer += data.toString();
-                const lines = stdoutBuffer.split('\n');
-                // Keep incomplete last line in buffer
-                stdoutBuffer = lines.pop() || '';
-                for (const line of lines) {
-                    const parsed = parseCodexEvent(line);
-                    if (parsed) {
-                        appendOutput(task.id, parsed);
+                : undefined;
+            const runner = new CodexProcessRunner({
+                onEvent: (processEvent) => {
+                    // Store raw JSON in ring buffer + output file
+                    taskStore.appendOutput(task.id, processEvent.raw);
+                    // Emit parsed event to subscribers
+                    taskEventBus.emit(task.id, processEvent.parsed);
+                },
+                onExit: async (exitInfo) => {
+                    // Read last-message file if available
+                    let lastMessage;
+                    try {
+                        lastMessage = await readFile(lastMessagePath, 'utf-8');
                     }
-                }
-            });
-            // Capture stderr — filter out known codex-core noise patterns
-            child.stderr?.on('data', (data) => {
-                const chunk = data.toString().trim();
-                if (!chunk)
-                    return;
-                if (isStderrNoise(chunk))
-                    return;
-                appendOutput(task.id, JSON.stringify({ type: 'stderr', text: chunk.slice(0, 500) }));
-            });
-            // --- Step 8: Wire completion handler ---
-            child.on('close', async (code) => {
-                // Process remaining buffer
-                if (stdoutBuffer.trim()) {
-                    const parsed = parseCodexEvent(stdoutBuffer);
-                    if (parsed) {
-                        await appendOutput(task.id, parsed);
+                    catch {
+                        // File may not exist if codex didn't write it
                     }
-                }
-                // Read last-message file if available
-                let lastMessage;
-                try {
-                    lastMessage = await readFile(lastMessagePath, 'utf-8');
-                }
-                catch {
-                    // File may not exist if codex didn't write it
-                }
-                // Extract conversation ID from output for session resume
-                if (activeSessionId && !useResume) {
-                    // Check task output for conversation ID patterns
-                    const allOutput = task.output.join('\n');
-                    const conversationIdMatch = allOutput.match(/(conversation|session)\s*id\s*:\s*([a-zA-Z0-9-]+)/i);
-                    if (conversationIdMatch) {
-                        this.sessionStorage.setCodexConversationId(activeSessionId, conversationIdMatch[2]);
+                    // Extract conversation ID from output for session resume
+                    if (activeSessionId && !useResume) {
+                        const outputArr = task.output.toArray();
+                        const allOutput = outputArr.join('\n');
+                        const conversationIdMatch = allOutput.match(/(conversation|session)\s*id\s*:\s*([a-zA-Z0-9-]+)/i);
+                        if (conversationIdMatch) {
+                            this.sessionStorage.setCodexConversationId(activeSessionId, conversationIdMatch[2]);
+                        }
                     }
-                }
-                // Save turn if using a session
-                if (activeSessionId) {
-                    const turn = {
-                        prompt,
-                        response: lastMessage || task.output.slice(-10).join('\n') || 'No output',
-                        timestamp: new Date(),
-                    };
-                    this.sessionStorage.addTurn(activeSessionId, turn);
-                }
-                if (code === 0 || lastMessage) {
-                    await completeTask(task.id, {
-                        exitCode: code,
-                        ...(lastMessage && { lastMessage: lastMessage.slice(0, 5000) }),
-                    });
-                }
-                else {
-                    await failTask(task.id, `Codex exited with code ${code}`);
-                }
-                // Notify resource subscribers
-                await notifyResourceChanged(`task:///${task.id}`);
-                await notifyResourceChanged('task:///all');
-            });
-            child.on('error', async (error) => {
-                await failTask(task.id, error.message);
-                await notifyResourceChanged(`task:///${task.id}`);
-                await notifyResourceChanged('task:///all');
+                    // Save turn if using a session
+                    if (activeSessionId) {
+                        const outputArr = task.output.toArray();
+                        const turn = {
+                            prompt,
+                            response: lastMessage || outputArr.slice(-10).join('\n') || 'No output',
+                            timestamp: new Date(),
+                        };
+                        this.sessionStorage.addTurn(activeSessionId, turn);
+                    }
+                    // Transition to terminal state
+                    if (exitInfo.exitCode === 0 || lastMessage) {
+                        await taskStore.transitionTo(task.id, 'completed', {
+                            metadata: {
+                                exitCode: exitInfo.exitCode,
+                                ...(lastMessage && {
+                                    lastMessage: lastMessage.slice(0, 5000),
+                                }),
+                            },
+                        });
+                    }
+                    else {
+                        await taskStore.transitionTo(task.id, 'failed', {
+                            error: `Codex exited with code ${exitInfo.exitCode}`,
+                        });
+                    }
+                    // Clean up event bus subscriptions for this task
+                    taskEventBus.removeTaskSubscriptions(task.id);
+                    // Notify resource subscribers (throttled)
+                    notifyResourceChanged();
+                },
             });
-            // --- Step 9: Return immediately ---
+            // Rotate account before spawning
+            try {
+                await rotateAccount();
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                await taskStore.transitionTo(task.id, 'failed', {
+                    error: `Account rotation failed: ${msg}`,
+                });
+                notifyResourceChanged();
+                throw err;
+            }
+            let handle;
+            try {
+                handle = runner.spawn({
+                    args: cmdArgs,
+                    cwd,
+                    env,
+                });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                await taskStore.transitionTo(task.id, 'failed', {
+                    error: `Failed to spawn Codex process: ${msg}`,
+                });
+                taskEventBus.removeTaskSubscriptions(task.id);
+                notifyResourceChanged();
+                throw err;
+            }
+            // Store process reference and transition to running
+            taskStore.setProcess(task.id, handle.childProcess);
+            await taskStore.transitionTo(task.id, 'running');
+            // --- Step 7: Return immediately ---
+            const pidStr = handle.pid ? `\npid: \`${handle.pid}\`` : '';
             const parts = [
-                `**Task launched** (codex)`,
+                `**Task launched** (spawn_subagent)`,
                 `task_id: \`${task.id}\``,
                 task.outputFilePath ? `output_file: \`${task.outputFilePath}\`` : null,
+                pidStr ? pidStr : null,
                 '',
                 'The agent is working in the background. MCP notifications will alert on completion—no need to poll.',
                 'Output is clean JSONL — read resource `task:///' +
@@ -373,9 +282,9 @@ export class CodexToolHandler {
                 throw error;
             }
             if (error instanceof ZodError) {
-                throw new ValidationError(TOOLS.CODEX, error.message);
+                throw new ValidationError(TOOLS.SPAWN_SUBAGENT, error.message);
             }
-            throw new ToolExecutionError(TOOLS.CODEX, 'Failed to execute codex command', error);
+            throw new ToolExecutionError(TOOLS.SPAWN_SUBAGENT, 'Failed to execute codex command', error);
         }
     }
     buildEnhancedPrompt(turns, newPrompt) {
@@ -394,89 +303,12 @@ export class CodexToolHandler {
         return `${contextualInfo}\n\nTask: ${newPrompt}`;
     }
 }
-export class PingToolHandler {
-    async execute(args, _context = defaultContext) {
-        try {
-            const { message = 'pong' } = PingToolSchema.parse(args);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: message,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            if (error instanceof ZodError) {
-                throw new ValidationError(TOOLS.PING, error.message);
-            }
-            throw new ToolExecutionError(TOOLS.PING, 'Failed to execute ping command', error);
-        }
-    }
-}
-export class HelpToolHandler {
-    async execute(args, _context = defaultContext) {
-        try {
-            HelpToolSchema.parse(args);
-            const result = await executeCommand('codex', ['--help']);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: result.stdout || 'No help information available',
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            if (error instanceof ZodError) {
-                throw new ValidationError(TOOLS.HELP, error.message);
-            }
-            throw new ToolExecutionError(TOOLS.HELP, 'Failed to execute help command', error);
-        }
-    }
-}
-export class ListSessionsToolHandler {
-    sessionStorage;
-    constructor(sessionStorage) {
-        this.sessionStorage = sessionStorage;
-    }
-    async execute(args, _context = defaultContext) {
-        try {
-            ListSessionsToolSchema.parse(args);
-            const sessions = this.sessionStorage.listSessions();
-            const sessionInfo = sessions.map((session) => ({
-                id: session.id,
-                createdAt: session.createdAt.toISOString(),
-                lastAccessedAt: session.lastAccessedAt.toISOString(),
-                turnCount: session.turns.length,
-            }));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: sessionInfo.length > 0
-                            ? JSON.stringify(sessionInfo, null, 2)
-                            : 'No active sessions',
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            if (error instanceof ZodError) {
-                throw new ValidationError(TOOLS.LIST_SESSIONS, error.message);
-            }
-            throw new ToolExecutionError(TOOLS.LIST_SESSIONS, 'Failed to list sessions', error);
-        }
-    }
-}
 export class ReviewToolHandler {
     async execute(args, context = defaultContext) {
         try {
             const { prompt, uncommitted, base, commit, title, workingDirectory, } = ReviewToolSchema.parse(args);
             if (prompt && uncommitted) {
-                throw new ValidationError(TOOLS.REVIEW, 'The review prompt cannot be combined with uncommitted=true. Use a base/commit review or omit the prompt.');
+                throw new ValidationError(TOOLS.CODE_REVIEW, 'The review prompt cannot be combined with uncommitted=true. Use a base/commit review or omit the prompt.');
             }
             const cmdArgs = [];
             if (workingDirectory) {
@@ -528,22 +360,136 @@ export class ReviewToolHandler {
         }
         catch (error) {
             if (error instanceof ZodError) {
-                throw new ValidationError(TOOLS.REVIEW, error.message);
+                throw new ValidationError(TOOLS.CODE_REVIEW, error.message);
+            }
+            if (error instanceof ValidationError) {
+                throw error;
+            }
+            throw new ToolExecutionError(TOOLS.CODE_REVIEW, 'Failed to execute code review', error);
+        }
+    }
+}
+export class GroupToolHandler {
+    async execute(args, context = defaultContext) {
+        try {
+            const parsed = SpawnAgentGroupSchema.parse(args);
+            const { agents, commonContext, commonContextFiles, dependsOn, append, appendToGroupTaskId, groupName, workingDirectory, callbackUri, } = parsed;
+            const cwd = workingDirectory || process.cwd();
+            // --- Validation ---
+            // 1. Unique aliases
+            const aliases = agents.map((a) => a.alias);
+            const uniqueAliases = new Set(aliases);
+            if (uniqueAliases.size !== aliases.length) {
+                const dupes = aliases.filter((a, i) => aliases.indexOf(a) !== i);
+                return mcpValidationError(`Duplicate agent aliases: ${[...new Set(dupes)].join(', ')}`);
+            }
+            // 2. DAG validation
+            const dagResult = validateDag(agents);
+            if (!dagResult.valid) {
+                return mcpValidationError(`DAG validation failed:\n${dagResult.errors.join('\n')}`);
+            }
+            // 3. Append validation
+            if (append && !appendToGroupTaskId) {
+                return mcpValidationError('appendToGroupTaskId is required when append=true');
+            }
+            if (append && appendToGroupTaskId) {
+                const existing = groupRegistry.getGroup(appendToGroupTaskId);
+                if (!existing) {
+                    return mcpValidationError(`Group "${appendToGroupTaskId}" not found for append`);
+                }
+                if (existing.state === 'running' ||
+                    existing.state === 'creating_worktree' ||
+                    existing.state === 'waiting_deps' ||
+                    existing.state === 'committing') {
+                    return mcpValidationError(`Cannot append to group "${appendToGroupTaskId}" — still running (state: ${existing.state})`);
+                }
             }
+            // 4. Group dependency validation
+            if (dependsOn && dependsOn.length > 0) {
+                for (const depId of dependsOn) {
+                    const dep = groupRegistry.getGroup(depId);
+                    if (!dep) {
+                        return mcpValidationError(`Dependency group "${depId}" not found`);
+                    }
+                }
+            }
+            // --- Create group ---
+            const group = groupRegistry.createGroup({
+                agents,
+                baseCwd: cwd,
+                dependsOn: dependsOn ?? [],
+                groupName,
+            });
+            // --- Orchestrate (blocks until done) ---
+            const result = await orchestrate({
+                groupId: group.id,
+                baseCwd: cwd,
+                agents,
+                commonContext,
+                commonContextFiles,
+                dependsOn: dependsOn ?? [],
+                append: append ?? false,
+                appendToGroupTaskId,
+                groupName,
+                callbackUri,
+                timeoutMs: GROUP_TIMEOUT_MS,
+                sendProgress: context.sendProgress,
+            });
+            // --- Build response ---
+            const stateLabel = result.state === 'done_success'
+                ? 'SUCCESS'
+                : result.state === 'done_timeout'
+                    ? 'TIMEOUT'
+                    : 'FAILED';
+            const agentRows = result.agentResults.map((a) => {
+                const taskIdStr = a.taskId ? `\`${a.taskId}\`` : '-';
+                const errorStr = a.error ? a.error.slice(0, 60) : '-';
+                return `| ${a.alias} | ${a.state} | ${taskIdStr} | ${a.attempts} | ${errorStr} |`;
+            });
+            const parts = [
+                `**Agent Group [${stateLabel}]** (spawn_agent_group)`,
+                `group_id: \`${result.groupId}\``,
+                `branch: \`${result.branch}\``,
+                `worktree: \`${result.worktreePath}\``,
+                result.baseCommit ? `base_commit: \`${result.baseCommit}\`` : null,
+                result.commitSha ? `commit: \`${result.commitSha}\`` : null,
+                result.error ? `error: ${result.error}` : null,
+                `duration: ${(result.durationMs / 1000).toFixed(1)}s`,
+                '',
+                '| Agent | Status | Task ID | Attempts | Error |',
+                '|-------|--------|---------|----------|-------|',
+                ...agentRows,
+                '',
+                '**Review commands:**',
+                `  git -C ${result.worktreePath} status`,
+                `  git -C ${result.worktreePath} log --oneline -5`,
+                result.baseCommit
+                    ? `  git -C ${result.worktreePath} diff ${result.baseCommit}...HEAD`
+                    : null,
+                result.baseCommit
+                    ? `  git diff ${result.baseCommit}..${result.branch}`
+                    : null,
+                '',
+                'Not merged into main. Review diff and merge manually.',
+            ].filter(Boolean);
+            return mcpText(parts.join('\n'));
+        }
+        catch (error) {
             if (error instanceof ValidationError) {
                 throw error;
             }
-            throw new ToolExecutionError(TOOLS.REVIEW, 'Failed to execute code review', error);
+            if (error instanceof ZodError) {
+                throw new ValidationError(TOOLS.SPAWN_AGENT_GROUP, error.message);
+            }
+            throw new ToolExecutionError(TOOLS.SPAWN_AGENT_GROUP, 'Failed to execute agent group', error);
         }
     }
 }
 // Tool handler registry
-const sessionStorage = new InMemorySessionStorage();
+const sessionStorage = new FileSessionStorage();
 export const toolHandlers = {
-    [TOOLS.CODEX]: new CodexToolHandler(sessionStorage),
-    [TOOLS.REVIEW]: new ReviewToolHandler(),
-    [TOOLS.PING]: new PingToolHandler(),
-    [TOOLS.HELP]: new HelpToolHandler(),
-    [TOOLS.LIST_SESSIONS]: new ListSessionsToolHandler(sessionStorage),
+    [TOOLS.SPAWN_SUBAGENT]: new CodexToolHandler(sessionStorage),
+    [TOOLS.CODE_REVIEW]: new ReviewToolHandler(),
+    [TOOLS.SPAWN_AGENT_GROUP]: new GroupToolHandler(),
 };
 //# sourceMappingURL=handlers.js.map