@anastops/mcp-server 0.1.0 → 1.0.0

package/dist/handlers.js

@@ -1,1840 +1,21 @@
 /**
- * MCP Tool Handlers - Simplified implementation for MVP
- */
-import { AdapterRegistry } from '@anastops/adapters';
-import { SessionManager, SessionForkService, ContextOptimizer, IntelligentRouter, } from '@anastops/core';
-import { LRUCache } from 'lru-cache';
-import { nanoid } from 'nanoid';
-import { getPersistence } from './persistence.js';
-import { formatSessionTable, formatTaskTable, formatAgentTable, getOutputFormat, } from './formatters.js';
-/**
- * Safe fire-and-forget wrapper for persistence operations
- * Catches errors to prevent uncaught promise rejections from crashing the server
- */
-function safePersist(operation) {
-    operation.catch(error => {
-        console.error('[Persistence Error]', error instanceof Error ? error.message : error);
-    });
-}
-// TOON encoding constants
-const TOON_MIN_SIZE_BYTES = 500;
-/**
- * Estimate token count for text
- * Rough approximation: ~4 characters per token for English
- */
-function estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-}
-/**
- * Convert array of uniform objects to TOON tabular format
- * TOON format uses pipe-separated headers and values for compact representation
- */
-function toTOONTabular(arr, keys) {
-    if (arr.length === 0 || keys.length === 0)
-        return '';
-    const lines = [];
-    // Header row
-    lines.push(keys.join(' | '));
-    // Data rows
-    for (const item of arr) {
-        const values = keys.map(k => {
-            const val = item[k];
-            if (val === null || val === undefined)
-                return '';
-            if (typeof val === 'string')
-                return val.slice(0, 50);
-            if (val instanceof Date)
-                return val.toISOString();
-            return String(val);
-        });
-        lines.push(values.join(' | '));
-    }
-    return lines.join('\n');
-}
-/**
- * Check if array contains uniform objects (all objects have same keys)
- */
-function isUniformObjectArray(data) {
-    if (!Array.isArray(data) || data.length === 0)
-        return false;
-    if (typeof data[0] !== 'object' || data[0] === null)
-        return false;
-    const firstKeys = Object.keys(data[0]).sort().join(',');
-    return data.every(item => {
-        if (typeof item !== 'object' || item === null)
-            return false;
-        return Object.keys(item).sort().join(',') === firstKeys;
-    });
-}
-/**
- * Apply TOON encoding to response if beneficial
- * Returns original data if TOON doesn't provide savings
+ * MCP Tool Handlers - Main Export
  *
- * TOON (Token-Optimized Object Notation) is most effective for:
- * - Arrays of uniform objects (converted to tabular format)
- * - Large structured responses (> 500 bytes)
- */
-export function applyTOONEncodingToResponse(data) {
-    // Only apply TOON to arrays or large objects
-    const jsonStr = JSON.stringify(data);
-    if (jsonStr.length < TOON_MIN_SIZE_BYTES) {
-        return { data }; // Too small, not worth encoding
-    }
-    const originalTokens = estimateTokens(jsonStr);
-    // Check if data structure is TOON-eligible
-    // TOON works best with arrays of uniform objects
-    if (typeof data !== 'object' || data === null) {
-        return { data };
-    }
-    const dataObj = data;
-    // Look for arrays within the response that could be TOON-encoded
-    let hasEncodableArrays = false;
-    const toonParts = [];
-    const scalarParts = [];
-    for (const [key, value] of Object.entries(dataObj)) {
-        if (isUniformObjectArray(value)) {
-            hasEncodableArrays = true;
-            const keys = Object.keys(value[0]);
-            toonParts.push(`${key}:\n${toTOONTabular(value, keys)}`);
-        }
-        else if (Array.isArray(value)) {
-            // Non-uniform array, keep as JSON
-            scalarParts.push(`${key}: ${JSON.stringify(value)}`);
-        }
-        else if (typeof value === 'object' && value !== null) {
-            // Nested object, keep as compact JSON
-            scalarParts.push(`${key}: ${JSON.stringify(value)}`);
-        }
-        else {
-            // Scalar value
-            scalarParts.push(`${key}: ${String(value)}`);
-        }
-    }
-    if (!hasEncodableArrays) {
-        return { data }; // No benefit from TOON encoding
-    }
-    // Build TOON-encoded representation
-    const toonEncoded = [...scalarParts, ...toonParts].join('\n');
-    const encodedTokens = estimateTokens(toonEncoded);
-    // Only use TOON if we get meaningful savings (> 20%)
-    const savingsPercent = ((originalTokens - encodedTokens) / originalTokens) * 100;
-    if (savingsPercent < 20) {
-        return { data }; // Not enough savings to justify encoding change
-    }
-    return {
-        data: toonEncoded,
-        encoding: 'toon',
-        token_reduction: {
-            original: originalTokens,
-            encoded: encodedTokens,
-            savings_percent: Math.round(savingsPercent * 100) / 100,
-        },
-    };
-}
-/**
- * Format a session report with all related data
- */
-function formatSessionReport(report, includeOutput, includeArtifactContent) {
-    const { session, tasks: sessionTasks, agents: sessionAgents, artifacts: sessionArtifacts } = report;
-    // Calculate statistics
-    const taskStats = {
-        total: sessionTasks.length,
-        pending: sessionTasks.filter(t => t.status === 'pending').length,
-        queued: sessionTasks.filter(t => t.status === 'queued').length,
-        running: sessionTasks.filter(t => t.status === 'running').length,
-        completed: sessionTasks.filter(t => t.status === 'completed').length,
-        failed: sessionTasks.filter(t => t.status === 'failed').length,
-        cancelled: sessionTasks.filter(t => t.status === 'cancelled').length,
-    };
-    const totalTokens = sessionTasks.reduce((sum, t) => sum + (t.token_usage?.total_tokens ?? 0), 0);
-    const totalCost = sessionTasks.reduce((sum, t) => sum + (t.token_usage?.cost ?? 0), 0);
-    // Format tasks with full details
-    const formattedTasks = sessionTasks.map(t => {
-        const taskData = {
-            id: t.id,
-            type: t.type,
-            status: t.status,
-            description: t.description,
-            provider: t.provider,
-            model: t.model,
-            routing_tier: t.routing_tier,
-            complexity_score: t.complexity_score,
-            token_usage: t.token_usage,
-            created_at: t.created_at,
-            started_at: t.started_at,
-            completed_at: t.completed_at,
-            retry_count: t.retry_count,
-            input: {
-                prompt: t.input?.prompt?.slice(0, 500) ?? '',
-                context_files: t.input?.context_files ?? [],
-                agent: t.input?.agent,
-                skills: t.input?.skills,
-            },
-        };
-        if (t.error) {
-            taskData.error = t.error;
-        }
-        if (includeOutput && t.output) {
-            taskData.output = {
-                content: t.output.content,
-                artifacts: t.output.artifacts,
-                files_modified: t.output.files_modified,
-            };
-        }
-        else if (t.output) {
-            taskData.output = {
-                content_length: t.output.content?.length ?? 0,
-                artifacts_count: t.output.artifacts?.length ?? 0,
-                files_modified: t.output.files_modified,
-            };
-        }
-        return taskData;
-    });
-    // Format agents
-    const formattedAgents = sessionAgents.map(a => ({
-        id: a.id,
-        name: a.name,
-        role: a.role,
-        status: a.status,
-        provider: a.provider,
-        model: a.model,
-        tasks_completed: a.tasks_completed,
-        tasks_failed: a.tasks_failed,
-        tokens_used: a.tokens_used,
-        current_task_id: a.current_task_id,
-        created_at: a.created_at,
-        last_activity_at: a.last_activity_at,
-    }));
-    // Format artifacts
-    const formattedArtifacts = sessionArtifacts.map(a => {
-        const artifactData = {
-            id: a.id,
-            name: a.name,
-            type: a.type,
-            size_bytes: a.size_bytes,
-            token_count: a.token_count,
-            created_at: a.created_at,
-        };
-        if (includeArtifactContent) {
-            artifactData.content = a.content;
-        }
-        else {
-            artifactData.summary = a.summary;
-        }
-        return artifactData;
-    });
-    return {
-        session: {
-            id: session.id,
-            objective: session.objective,
-            status: session.status,
-            created_at: session.created_at,
-            updated_at: session.updated_at,
-            metadata: session.metadata,
-        },
-        statistics: {
-            tasks: taskStats,
-            total_tokens: totalTokens,
-            total_cost_usd: totalCost,
-            agents_count: sessionAgents.length,
-            artifacts_count: sessionArtifacts.length,
-        },
-        tasks: formattedTasks,
-        agents: formattedAgents,
-        artifacts: formattedArtifacts,
-    };
-}
-// Shared instances
-const sessionManager = new SessionManager();
-const forkService = new SessionForkService(sessionManager);
-const contextOptimizer = new ContextOptimizer();
-const router = new IntelligentRouter();
-const registry = AdapterRegistry.getInstance();
-// LRU caches with size limits and TTL to prevent memory leaks
-const agents = new LRUCache({ max: 1000, ttl: 1000 * 60 * 60 }); // 1 hour TTL
-const tasks = new LRUCache({ max: 5000, ttl: 1000 * 60 * 60 * 24 }); // 24 hour TTL
-const artifacts = new LRUCache({ max: 1000, ttl: 1000 * 60 * 60 * 24 }); // 24 hour TTL
-const memoryStore = new LRUCache({ max: 10000, ttl: 1000 * 60 * 60 }); // 1 hour TTL
-/**
- * Get task from memory or MongoDB
- * Loads from MongoDB and caches in memory if not found
- */
-async function getTask(taskId) {
-    // Check in-memory first
-    const memTask = tasks.get(taskId);
-    if (memTask !== undefined) {
-        return memTask;
-    }
-    // Try to load from MongoDB
-    const dbTask = await getPersistence().getTask(taskId);
-    if (dbTask !== null) {
-        // Cache in memory for subsequent access
-        tasks.set(taskId, dbTask);
-        return dbTask;
-    }
-    return null;
-}
-/**
- * Get agent from memory or MongoDB
- */
-async function getAgent(agentId) {
-    const memAgent = agents.get(agentId);
-    if (memAgent !== undefined) {
-        return memAgent;
-    }
-    const dbAgent = await getPersistence().getAgent(agentId);
-    if (dbAgent !== null) {
-        agents.set(agentId, dbAgent);
-        return dbAgent;
-    }
-    return null;
-}
-/**
- * Get artifact from memory or MongoDB
- */
-async function getArtifact(artifactId) {
-    const memArtifact = artifacts.get(artifactId);
-    if (memArtifact !== undefined) {
-        return memArtifact;
-    }
-    const dbArtifact = await getPersistence().getArtifact(artifactId);
-    if (dbArtifact !== null) {
-        artifacts.set(artifactId, dbArtifact);
-        return dbArtifact;
-    }
-    return null;
-}
-// Tool definitions
-export const toolDefinitions = [
-    // Session tools (5)
-    {
-        name: 'session_spawn',
-        description: 'Create a new AI orchestration session',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                objective: { type: 'string', description: 'High-level objective' },
-                context_files: { type: 'array', items: { type: 'string' } },
-                parent_session: { type: 'string' },
-            },
-            required: ['objective'],
-        },
-    },
-    {
-        name: 'session_status',
-        description: 'Get session status and metrics',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string', description: 'Session ID' },
-            },
-            required: ['session_id'],
-        },
-    },
-    {
-        name: 'session_list',
-        description: 'List sessions with filters. Use format="table" for beautiful ASCII table output.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                status: { type: 'string', enum: ['active', 'completed', 'archived'] },
-                include_forks: { type: 'boolean' },
-                limit: { type: 'number' },
-                format: { type: 'string', enum: ['table', 'json'], description: 'Output format: "table" for ASCII table, "json" for raw JSON (default)' },
-            },
-        },
-    },
-    {
-        name: 'session_fork',
-        description: 'Fork a session to explore alternatives',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string', description: 'Session ID to fork' },
-                fork_point: { type: 'number' },
-                reason: { type: 'string' },
-            },
-            required: ['session_id'],
-        },
-    },
-    {
-        name: 'session_archive',
-        description: 'Archive a completed session',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-            },
-            required: ['session_id'],
-        },
-    },
-    {
-        name: 'session_report',
-        description: 'Get comprehensive report of sessions with all tasks, agents, artifacts, and full details. Use for observability and debugging.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string', description: 'Specific session ID (omit for all sessions)' },
-                status: { type: 'string', enum: ['active', 'completed', 'archived'], description: 'Filter by status (when no session_id provided)' },
-                include_output: { type: 'boolean', description: 'Include full task output content (default: true)' },
-                include_artifacts: { type: 'boolean', description: 'Include artifact content (default: false, only metadata)' },
-                limit: { type: 'number', description: 'Max sessions to return (default: 20)' },
-            },
-        },
-    },
-    {
-        name: 'session_purge',
-        description: 'Permanently delete sessions and all related data (tasks, agents, artifacts). Use with caution.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string', description: 'Specific session ID to delete' },
-                session_ids: { type: 'array', items: { type: 'string' }, description: 'Array of session IDs to delete' },
-                status: { type: 'string', enum: ['active', 'completed', 'archived'], description: 'Delete all sessions with this status' },
-                older_than_days: { type: 'number', description: 'Delete sessions older than N days' },
-                confirm: { type: 'boolean', description: 'Must be true to execute deletion' },
-            },
-            required: ['confirm'],
-        },
-    },
-    // Agent tools (4)
-    {
-        name: 'agent_create',
-        description: 'Create a new AI agent',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-                role: { type: 'string', enum: ['orchestrator', 'planner', 'implementer', 'reviewer', 'tester', 'debugger', 'documenter', 'specialist'] },
-                name: { type: 'string' },
-                provider: { type: 'string' },
-                model: { type: 'string' },
-            },
-            required: ['session_id', 'role'],
-        },
-    },
-    {
-        name: 'agent_deploy',
-        description: 'Deploy an agent to a task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agent_id: { type: 'string' },
-                task_id: { type: 'string' },
-            },
-            required: ['agent_id', 'task_id'],
-        },
-    },
-    {
-        name: 'agent_status',
-        description: 'Get agent status',
-        inputSchema: {
-            type: 'object',
-            properties: { agent_id: { type: 'string' } },
-            required: ['agent_id'],
-        },
-    },
-    {
-        name: 'agent_list',
-        description: 'List agents in a session. Use format="table" for beautiful ASCII table output.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-                status: { type: 'string' },
-                format: { type: 'string', enum: ['table', 'json'], description: 'Output format: "table" for ASCII table, "json" for raw JSON (default)' },
-            },
-            required: ['session_id'],
-        },
-    },
-    {
-        name: 'agent_retire',
-        description: 'Retire an agent, marking it as completed',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agent_id: { type: 'string', description: 'ID of the agent to retire' },
-            },
-            required: ['agent_id'],
-        },
-    },
-    // Task tools (5)
-    {
-        name: 'task_create',
-        description: 'Create a task with intelligent routing. Supports agents and skills for Claude provider.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-                type: { type: 'string' },
-                description: { type: 'string' },
-                prompt: { type: 'string' },
-                context_files: { type: 'array', items: { type: 'string' } },
-                force_provider: { type: 'string' },
-                force_tier: { type: 'number' },
-                agent: { type: 'string', description: 'Agent name to use (e.g., orchestration-specialist). Agent defines model, tools, and skills.' },
-                skills: { type: 'array', items: { type: 'string' }, description: 'Specific skills to load (e.g., ["anastops-sessions", "anastops-tasks"])' },
-            },
-            required: ['session_id', 'type', 'description', 'prompt'],
-        },
-    },
-    {
-        name: 'task_queue',
-        description: 'Queue a task for execution',
-        inputSchema: {
-            type: 'object',
-            properties: { task_id: { type: 'string' } },
-            required: ['task_id'],
-        },
-    },
-    {
-        name: 'task_status',
-        description: 'Get task status',
-        inputSchema: {
-            type: 'object',
-            properties: { task_id: { type: 'string' } },
-            required: ['task_id'],
-        },
-    },
-    {
-        name: 'task_complete',
-        description: 'Mark task as completed',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                task_id: { type: 'string' },
-                content: { type: 'string' },
-                artifacts: { type: 'array', items: { type: 'string' } },
-            },
-            required: ['task_id', 'content'],
-        },
-    },
-    {
-        name: 'task_list',
-        description: 'List tasks in a session. Use format="table" for beautiful ASCII table output.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-                status: { type: 'string' },
-                format: { type: 'string', enum: ['table', 'json'], description: 'Output format: "table" for ASCII table, "json" for raw JSON (default)' },
-            },
-            required: ['session_id'],
-        },
-    },
-    {
-        name: 'task_execute',
-        description: 'Execute a pending or queued task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                task_id: { type: 'string', description: 'ID of the task to execute' },
-                wait: { type: 'boolean', description: 'Wait for task completion (default: true)' },
-            },
-            required: ['task_id'],
-        },
-    },
-    {
-        name: 'task_cancel',
-        description: 'Cancel a pending, queued, or running task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                task_id: { type: 'string', description: 'ID of the task to cancel' },
-            },
-            required: ['task_id'],
-        },
-    },
-    {
-        name: 'task_retry',
-        description: 'Retry a failed task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                task_id: { type: 'string', description: 'ID of the failed task to retry' },
-            },
-            required: ['task_id'],
-        },
-    },
-    // Lock Management tools (3)
-    {
-        name: 'lock_acquire',
-        description: 'Acquire a file lock for a session to prevent conflicts',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-                file_path: { type: 'string' },
-                ttl: { type: 'number', description: 'Lock TTL in milliseconds (default: 300000)' },
-            },
-            required: ['session_id', 'file_path'],
-        },
-    },
-    {
-        name: 'lock_release',
-        description: 'Release a file lock held by a session',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-                file_path: { type: 'string' },
-            },
-            required: ['session_id', 'file_path'],
-        },
-    },
-    {
-        name: 'lock_status',
-        description: 'Check lock status for a file or session',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string', description: 'Session ID to check locks for' },
-                file_path: { type: 'string', description: 'File path to check lock status' },
-            },
-        },
-    },
-    // Cost Monitoring tools (3)
-    {
-        name: 'session_cost',
-        description: 'Get cost breakdown for a session',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-            },
-            required: ['session_id'],
-        },
-    },
-    {
-        name: 'session_metrics',
-        description: 'Get request and token usage metrics for a session',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-            },
-            required: ['session_id'],
-        },
-    },
-    {
-        name: 'session_throttle',
-        description: 'Check rate limit and throttle status for a session',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-                provider: { type: 'string', description: 'Specific provider to check' },
-            },
-            required: ['session_id'],
-        },
-    },
-    // Memory tools (5)
-    {
-        name: 'memory_store',
-        description: 'Store data in memory',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                key: { type: 'string' },
-                value: {},
-                session_id: { type: 'string' },
-            },
-            required: ['key', 'value'],
-        },
-    },
-    {
-        name: 'memory_retrieve',
-        description: 'Retrieve data from memory',
-        inputSchema: {
-            type: 'object',
-            properties: { key: { type: 'string' } },
-            required: ['key'],
-        },
-    },
-    {
-        name: 'artifact_save',
-        description: 'Save an artifact',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-                type: { type: 'string', enum: ['code', 'document', 'data', 'config', 'test', 'other'] },
-                name: { type: 'string' },
-                content: { type: 'string' },
-            },
-            required: ['session_id', 'type', 'name', 'content'],
-        },
-    },
-    {
-        name: 'artifact_get',
-        description: 'Get an artifact',
-        inputSchema: {
-            type: 'object',
-            properties: { artifact_id: { type: 'string' } },
-            required: ['artifact_id'],
-        },
-    },
-    {
-        name: 'artifact_list',
-        description: 'List all artifacts for a session',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string', description: 'Session ID to list artifacts for' },
-                type: { type: 'string', enum: ['code', 'document', 'data', 'config', 'test', 'other'], description: 'Optional filter by artifact type' },
-            },
-            required: ['session_id'],
-        },
-    },
-    {
-        name: 'context_optimize',
-        description: 'Optimize context for token reduction',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-                objective: { type: 'string' },
-                phase: { type: 'string' },
-                progress: { type: 'number' },
-                messages: { type: 'array' },
-            },
-            required: ['session_id', 'objective', 'phase', 'progress', 'messages'],
-        },
-    },
-    // Orchestration tools (4)
-    {
-        name: 'dispatch',
-        description: 'Dispatch prompt to AI provider with routing',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-                prompt: { type: 'string' },
-                type: { type: 'string' },
-                force_provider: { type: 'string' },
-                force_tier: { type: 'number' },
-            },
-            required: ['session_id', 'prompt'],
-        },
-    },
-    {
-        name: 'route',
-        description: 'Get routing decision without executing',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                type: { type: 'string' },
-                description: { type: 'string' },
-            },
-            required: ['type', 'description'],
-        },
-    },
-    {
-        name: 'broadcast',
-        description: 'Broadcast message to session agents',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-                message: { type: 'string' },
-                message_type: { type: 'string', enum: ['info', 'warning', 'error', 'progress', 'complete'] },
-            },
-            required: ['session_id', 'message'],
-        },
-    },
-    {
-        name: 'aggregate',
-        description: 'Aggregate results from multiple tasks',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                task_ids: { type: 'array', items: { type: 'string' } },
-                strategy: { type: 'string', enum: ['concat', 'merge', 'first', 'last', 'vote'] },
-            },
-            required: ['task_ids'],
-        },
-    },
-    // Utility tools (5)
-    {
-        name: 'health_check',
-        description: 'Check system health',
-        inputSchema: {
-            type: 'object',
-            properties: { include_providers: { type: 'boolean' } },
-        },
-    },
-    {
-        name: 'provider_list',
-        description: 'List available AI providers',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                filter_healthy: { type: 'boolean' },
-                include_capabilities: { type: 'boolean' },
-            },
-        },
-    },
-    {
-        name: 'metrics_get',
-        description: 'Get system metrics',
-        inputSchema: {
-            type: 'object',
-            properties: { metric_type: { type: 'string', enum: ['routing', 'tokens', 'costs', 'all'] } },
-        },
-    },
-    {
-        name: 'config_get',
-        description: 'Get configuration value',
-        inputSchema: {
-            type: 'object',
-            properties: { key: { type: 'string' } },
-            required: ['key'],
-        },
-    },
-    {
-        name: 'config_set',
-        description: 'Set configuration value',
-        inputSchema: {
-            type: 'object',
-            properties: { key: { type: 'string' }, value: {} },
-            required: ['key', 'value'],
-        },
-    },
-];
-// Tool handler
-export async function handleToolCall(name, args) {
-    try {
-        const result = await executeToolHandler(name, args);
-        const format = getOutputFormat(args);
-        // Apply table formatting for specific tools when format='table'
-        if (format === 'table') {
-            const formatted = formatResultAsTable(name, result);
-            if (formatted !== null) {
-                return {
-                    content: [{ type: 'text', text: formatted }],
-                };
-            }
-        }
-        // Return result directly as JSON (no pretty-printing - MCP messages must not contain embedded newlines)
-        return {
-            content: [{ type: 'text', text: JSON.stringify(result) }],
-            isError: false,
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: JSON.stringify({ error: message }) }],
-            isError: true,
-        };
-    }
-}
-/**
- * Format result as table for supported tools
- * Returns null if tool doesn't support table formatting
+ * This file re-exports the split handler modules for backward compatibility.
+ * The actual handlers are now split across the handlers/ directory:
+ * - handlers/handlers.base.ts - Shared utilities (TOON, formatting, cache)
+ * - handlers/handlers.session.ts - Session management
+ * - handlers/handlers.agent.ts - Agent management
+ * - handlers/handlers.task.ts - Task management
+ * - handlers/handlers.lock.ts - Lock management
+ * - handlers/handlers.monitoring.ts - Cost & metrics monitoring
+ * - handlers/handlers.memory.ts - Memory & artifacts
+ * - handlers/handlers.orchestration.ts - Dispatch, routing, broadcast
+ * - handlers/handlers.utility.ts - Health checks, config
+ * - handlers/index.ts - Main router
+ * - handlers/tool-definitions.ts - Tool schema definitions
+ *
+ * SECURITY: All inputs are validated using Zod schemas before processing.
  */
-function formatResultAsTable(toolName, result) {
-    if (result === null || typeof result !== 'object') {
-        return null;
-    }
-    const data = result;
-    switch (toolName) {
-        case 'session_list': {
-            const sessions = data['sessions'];
-            if (sessions !== undefined) {
-                // Add created_at if not present (use current time as fallback)
-                const sessionsWithDate = sessions.map(s => ({
-                    ...s,
-                    created_at: s.created_at ?? new Date(),
-                }));
-                return formatSessionTable(sessionsWithDate);
-            }
-            break;
-        }
-        case 'task_list': {
-            const tasks = data['tasks'];
-            if (tasks !== undefined) {
-                return formatTaskTable(tasks);
-            }
-            break;
-        }
-        case 'agent_list': {
-            const agents = data['agents'];
-            if (agents !== undefined) {
-                return formatAgentTable(agents);
-            }
-            break;
-        }
-    }
-    return null;
-}
-async function executeToolHandler(name, args) {
-    switch (name) {
-        // Session tools
-        case 'session_spawn': {
-            const session = sessionManager.spawn({
-                objective: args['objective'],
-                ...(args['context_files'] !== undefined && { context_files: args['context_files'] }),
-                ...(args['parent_session'] !== undefined && { parent_session: args['parent_session'] }),
-            });
-            // Persist to MongoDB
-            safePersist(getPersistence().saveSession(session));
-            return { session_id: session.id, objective: session.objective, status: session.status };
-        }
-        case 'session_status': {
-            const status = sessionManager.getStatus(args['session_id']);
-            // TOON encoding applied in handleToolCall
-            return status;
-        }
-        case 'session_list': {
-            // Get from in-memory first
-            const inMemorySessions = sessionManager.list({
-                ...(args['status'] !== undefined && { status: args['status'] }),
-                ...(args['include_forks'] !== undefined && { include_forks: args['include_forks'] }),
-                ...(args['limit'] !== undefined && { limit: args['limit'] }),
-            });
-            // Also get from MongoDB for persistence
-            const persistedSessions = await getPersistence().listSessions({
-                ...(args['status'] !== undefined && { status: args['status'] }),
-                ...(args['limit'] !== undefined && { limit: args['limit'] }),
-            });
-            // Merge: in-memory takes precedence, then add persisted ones not in memory
-            const inMemoryIds = new Set(inMemorySessions.map(s => s.id));
-            const sessions = [
-                ...inMemorySessions,
-                ...persistedSessions.filter(s => !inMemoryIds.has(s.id)),
-            ];
-            // Return raw result for table formatting to be applied in handleToolCall
-            const result = {
-                count: sessions.length,
-                sessions: sessions.map(s => ({
-                    id: s.id,
-                    objective: s.objective,
-                    status: s.status,
-                    created_at: s.created_at,
-                })),
-            };
-            // Don't apply TOON encoding here - let handleToolCall handle formatting
-            return result;
-        }
-        case 'session_fork': {
-            const forked = forkService.fork({
-                session_id: args['session_id'],
-                ...(args['fork_point'] !== undefined && { fork_point: args['fork_point'] }),
-                ...(args['reason'] !== undefined && { reason: args['reason'] }),
-            });
-            // Persist to MongoDB
-            void getPersistence().saveSession(forked);
-            return { forked_session_id: forked.id, parent_id: forked.parent_session_id, fork_point: forked.fork_point };
-        }
-        case 'session_archive': {
-            const session = sessionManager.updateStatus(args['session_id'], 'archived');
-            // Persist to MongoDB
-            safePersist(getPersistence().saveSession(session));
-            return { session_id: session.id, status: session.status };
-        }
-        case 'session_report': {
-            const sessionId = args['session_id'];
-            const statusFilter = args['status'];
-            const includeOutput = args['include_output'] ?? true;
-            const includeArtifactContent = args['include_artifacts'] ?? false;
-            const limit = args['limit'] ?? 20;
-            const persistence = getPersistence();
-            if (sessionId) {
-                // Single session report
-                const report = await persistence.getSessionReport(sessionId);
-                if (!report) {
-                    throw new Error(`Session not found: ${sessionId}`);
-                }
-                return formatSessionReport(report, includeOutput, includeArtifactContent);
-            }
-            // All sessions report
-            const reportFilters = { limit };
-            if (statusFilter !== undefined) {
-                reportFilters.status = statusFilter;
-            }
-            const reports = await persistence.getAllSessionReports(reportFilters);
-            return {
-                total_sessions: reports.length,
-                sessions: reports.map(r => formatSessionReport(r, includeOutput, includeArtifactContent)),
-            };
-        }
-        case 'session_purge': {
-            const confirm = args['confirm'];
-            if (!confirm) {
-                return { error: 'Must set confirm: true to execute deletion' };
-            }
-            const sessionId = args['session_id'];
-            const sessionIds = args['session_ids'];
-            const statusFilter = args['status'];
-            const olderThanDays = args['older_than_days'];
-            const persistence = getPersistence();
-            // Single session deletion
-            if (sessionId) {
-                // Remove from in-memory cache
-                sessionManager.remove(sessionId);
-                // Remove related tasks from cache
-                for (const [taskId, task] of tasks.entries()) {
-                    if (task.session_id === sessionId) {
-                        tasks.delete(taskId);
-                    }
-                }
-                // Remove related agents from cache
-                for (const [agentId, agent] of agents.entries()) {
-                    if (agent.session_id === sessionId) {
-                        agents.delete(agentId);
-                    }
-                }
-                // Remove related artifacts from cache
-                for (const [artifactId, artifact] of artifacts.entries()) {
-                    if (artifact.session_id === sessionId) {
-                        artifacts.delete(artifactId);
-                    }
-                }
-                const deleted = await persistence.deleteSession(sessionId);
-                return { deleted: deleted, session_id: sessionId };
-            }
-            // Build filters for bulk deletion
-            const filters = {};
-            if (sessionIds && sessionIds.length > 0) {
-                filters.session_ids = sessionIds;
-            }
-            if (statusFilter) {
-                filters.status = statusFilter;
-            }
-            if (olderThanDays !== undefined) {
-                const cutoffDate = new Date();
-                cutoffDate.setDate(cutoffDate.getDate() - olderThanDays);
-                filters.older_than = cutoffDate;
-            }
-            if (Object.keys(filters).length === 0) {
-                return { error: 'Must provide at least one filter: session_id, session_ids, status, or older_than_days' };
-            }
-            const result = await persistence.deleteSessions(filters);
-            // Clean up in-memory caches for deleted sessions
-            for (const deletedId of result.session_ids) {
-                sessionManager.remove(deletedId);
-                for (const [taskId, task] of tasks.entries()) {
-                    if (task.session_id === deletedId) {
-                        tasks.delete(taskId);
-                    }
-                }
-                for (const [agentId, agent] of agents.entries()) {
-                    if (agent.session_id === deletedId) {
-                        agents.delete(agentId);
-                    }
-                }
-                for (const [artifactId, artifact] of artifacts.entries()) {
-                    if (artifact.session_id === deletedId) {
-                        artifacts.delete(artifactId);
-                    }
-                }
-            }
-            return {
-                deleted_count: result.deleted_count,
-                session_ids: result.session_ids,
-            };
-        }
-        // Agent tools
-        case 'agent_create': {
-            const agentId = nanoid(12);
-            const now = new Date();
-            const agent = {
-                id: agentId,
-                session_id: args['session_id'],
-                role: args['role'] ?? 'implementer',
-                name: args['name'] ?? `agent-${agentId.slice(0, 4)}`,
-                status: 'idle',
-                provider: args['provider'] ?? 'claude',
-                model: args['model'] ?? 'claude-sonnet',
-                current_task_id: null,
-                tasks_completed: 0,
-                tasks_failed: 0,
-                tokens_used: 0,
-                created_at: now,
-                last_activity_at: now,
-                config: {},
-            };
-            agents.set(agentId, agent);
-            // Persist to MongoDB
-            safePersist(getPersistence().saveAgent(agent));
-            return { agent_id: agent.id, name: agent.name, role: agent.role, status: agent.status };
-        }
-        case 'agent_deploy': {
-            const agent = await getAgent(args['agent_id']);
-            if (agent === null)
-                throw new Error('Agent not found');
-            agent.current_task_id = args['task_id'];
-            agent.status = 'working';
-            agent.last_activity_at = new Date();
-            agents.set(agent.id, agent);
-            safePersist(getPersistence().saveAgent(agent));
-            return { agent_id: agent.id, task_id: agent.current_task_id, status: agent.status };
-        }
-        case 'agent_status': {
-            const agent = await getAgent(args['agent_id']);
-            if (agent === null)
-                throw new Error('Agent not found');
-            return agent;
-        }
-        case 'agent_list': {
-            // Get from in-memory cache first
-            const inMemoryAgents = [];
-            for (const [, agent] of agents.entries()) {
-                if (!args['session_id'] || agent.session_id === args['session_id']) {
-                    inMemoryAgents.push(agent);
-                }
-            }
-            // Also get from MongoDB for persistence
-            const persistedAgents = await getPersistence().listAgents({
-                ...(args['session_id'] !== undefined && { session_id: args['session_id'] }),
-            });
-            // Merge: in-memory takes precedence
-            const inMemoryIds = new Set(inMemoryAgents.map(a => a.id));
-            const sessionAgents = [
-                ...inMemoryAgents,
-                ...persistedAgents.filter(a => !inMemoryIds.has(a.id)),
-            ];
-            return { count: sessionAgents.length, agents: sessionAgents.map(a => ({ id: a.id, name: a.name, role: a.role, status: a.status })) };
-        }
-        case 'agent_retire': {
-            const agentId = args['agent_id'];
-            const agent = await getAgent(agentId);
-            if (agent === null) {
-                throw new Error(`Agent not found: ${agentId}`);
-            }
-            // Retire the agent
-            agent.status = 'completed';
-            agent.last_activity_at = new Date();
-            agent.current_task_id = null;
-            agents.set(agentId, agent);
-            // Persist to MongoDB
-            safePersist(getPersistence().saveAgent(agent));
-            return {
-                agent_id: agent.id,
-                name: agent.name,
-                role: agent.role,
-                status: agent.status,
-                tasks_completed: agent.tasks_completed,
-                retired: true,
-            };
-        }
-        // Task tools
-        case 'task_create': {
-            const taskId = nanoid(12);
-            const now = new Date();
-            const taskType = args['type'] ?? 'other';
-            // Store agent and skills in task input for execution
-            const taskInput = {
-                prompt: args['prompt'],
-                context_files: args['context_files'] ?? [],
-            };
-            if (args['agent'] !== undefined) {
-                taskInput.agent = args['agent'];
-            }
-            if (args['skills'] !== undefined) {
-                taskInput.skills = args['skills'];
-            }
-            const task = {
-                id: taskId,
-                session_id: args['session_id'],
-                agent_id: null,
-                type: taskType,
-                status: 'pending',
-                description: args['description'],
-                input: taskInput,
-                output: null,
-                error: null,
-                complexity_score: 0,
-                routing_tier: 3,
-                provider: 'claude',
-                model: 'claude-sonnet',
-                token_usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, cost: 0 },
-                created_at: now,
-                started_at: null,
-                completed_at: null,
-                dependencies: [],
-                priority: 5,
-                retry_count: 0,
-                max_retries: 3,
-            };
-            // Route the task with optional overrides
-            const routingOverride = {};
-            if (args['force_provider'] !== undefined) {
-                routingOverride.force_provider = args['force_provider'];
-            }
-            if (args['force_tier'] !== undefined) {
-                routingOverride.force_tier = args['force_tier'];
-            }
-            const routing = router.route(task, routingOverride);
-            task.routing_tier = routing.tier;
-            task.provider = routing.provider;
-            task.model = routing.model;
-            task.complexity_score = routing.complexity_score;
-            tasks.set(taskId, task);
-            // Persist to MongoDB
-            safePersist(getPersistence().saveTask(task));
-            const response = {
-                task_id: task.id,
-                type: task.type,
-                routing: { tier: routing.tier, provider: routing.provider, model: routing.model },
-            };
-            if (taskInput.agent) {
-                response.agent = taskInput.agent;
-            }
-            return response;
-        }
-        case 'task_queue': {
-            const task = await getTask(args['task_id']);
-            if (task === null)
-                throw new Error('Task not found');
-            task.status = 'queued';
-            tasks.set(task.id, task);
-            safePersist(getPersistence().saveTask(task));
-            return { task_id: task.id, status: task.status };
-        }
-        case 'task_status': {
-            const task = await getTask(args['task_id']);
-            if (task === null)
-                throw new Error('Task not found');
-            return task;
-        }
-        case 'task_complete': {
-            const task = await getTask(args['task_id']);
-            if (task === null)
-                throw new Error('Task not found');
-            task.status = 'completed';
-            task.completed_at = new Date();
-            task.output = { content: args['content'], artifacts: args['artifacts'] ?? [], files_modified: [], metadata: {} };
-            tasks.set(task.id, task);
-            // Persist to MongoDB
-            safePersist(getPersistence().saveTask(task));
-            return { task_id: task.id, status: task.status };
-        }
-        case 'task_list': {
-            // Get from in-memory cache first
-            const inMemoryTasks = [];
-            for (const [, task] of tasks.entries()) {
-                if (!args['session_id'] || task.session_id === args['session_id']) {
-                    inMemoryTasks.push(task);
-                }
-            }
-            // Also get from MongoDB for persistence
-            const persistedTasks = await getPersistence().listTasks({
-                ...(args['session_id'] !== undefined && { session_id: args['session_id'] }),
-            });
-            // Merge: in-memory takes precedence
-            const inMemoryIds = new Set(inMemoryTasks.map(t => t.id));
-            const sessionTasks = [
-                ...inMemoryTasks,
-                ...persistedTasks.filter(t => !inMemoryIds.has(t.id)),
-            ];
-            return { count: sessionTasks.length, tasks: sessionTasks.map(t => ({ id: t.id, type: t.type, status: t.status, description: t.description.slice(0, 50) })) };
-        }
-        case 'task_execute': {
-            const taskId = args['task_id'];
-            const wait = args['wait'] ?? true;
-            const task = await getTask(taskId);
-            if (task === null) {
-                throw new Error(`Task not found: ${taskId}`);
-            }
-            if (task.status !== 'pending' && task.status !== 'queued') {
-                return {
-                    task_id: taskId,
-                    status: task.status,
-                    error: `Task cannot be executed - current status is '${task.status}'`,
-                };
-            }
-            // Update task status to running
-            task.status = 'running';
-            task.started_at = new Date();
-            tasks.set(taskId, task);
-            // Persist running status
-            safePersist(getPersistence().saveTask(task));
-            try {
-                // Get adapter for the routed provider
-                const adapter = registry.get(task.provider);
-                if (adapter === undefined) {
-                    throw new Error(`Provider adapter not found: ${task.provider}`);
-                }
-                // Execute task with adapter
-                // Use workspace root from environment or cwd
-                const workingDir = process.env['ANASTOPS_WORKSPACE'] ?? process.cwd();
-                // Build request with optional agent and skills
-                const taskInput = task.input;
-                const executeRequest = {
-                    model: task.model,
-                    prompt: taskInput?.prompt ?? task.description,
-                    working_dir: workingDir,
-                };
-                // Pass agent and skills if specified
-                if (taskInput?.agent) {
-                    executeRequest.agent = taskInput.agent;
-                }
-                if (taskInput?.skills) {
-                    executeRequest.skills = taskInput.skills;
-                }
-                const response = await adapter.execute(executeRequest, { workingDir });
-                // Update task with result
-                task.status = 'completed';
-                task.completed_at = new Date();
-                task.output = {
-                    content: response.content,
-                    artifacts: [],
-                    files_modified: [],
-                    metadata: { usage: response.usage },
-                };
-                tasks.set(taskId, task);
-                // Persist completed task
-                safePersist(getPersistence().saveTask(task));
-                // Update session metadata via sessionManager
-                if (sessionManager.exists(task.session_id)) {
-                    const session = sessionManager.getSession(task.session_id);
-                    session.metadata = session.metadata ?? { total_tokens: 0, total_cost: 0, agents_used: [], files_affected: [], tasks_completed: 0, tasks_failed: 0 };
-                    session.metadata.tasks_completed = (session.metadata.tasks_completed ?? 0) + 1;
-                    session.metadata.total_tokens = (session.metadata.total_tokens ?? 0) + (response.usage?.total_tokens ?? 0);
-                    session.metadata.total_cost = (session.metadata.total_cost ?? 0) + (response.usage?.cost ?? 0);
-                    session.updated_at = new Date();
-                    safePersist(getPersistence().saveSession(session));
-                }
-                return {
-                    task_id: taskId,
-                    status: 'completed',
-                    result: response,
-                    waited: wait,
-                };
-            }
-            catch (error) {
-                task.status = 'failed';
-                task.completed_at = new Date();
-                task.error = error instanceof Error ? error.message : String(error);
-                tasks.set(taskId, task);
-                // Persist failed task
-                safePersist(getPersistence().saveTask(task));
-                // Update session metadata for failure via sessionManager
-                if (sessionManager.exists(task.session_id)) {
-                    const session = sessionManager.getSession(task.session_id);
-                    session.metadata = session.metadata ?? { total_tokens: 0, total_cost: 0, agents_used: [], files_affected: [], tasks_completed: 0, tasks_failed: 0 };
-                    session.metadata.tasks_failed = (session.metadata.tasks_failed ?? 0) + 1;
-                    session.updated_at = new Date();
-                    safePersist(getPersistence().saveSession(session));
-                }
-                throw error;
-            }
-        }
-        case 'task_cancel': {
-            const taskId = args['task_id'];
-            const task = await getTask(taskId);
-            if (task === null) {
-                throw new Error(`Task not found: ${taskId}`);
-            }
-            // Check if task is cancelable (pending, queued, or running)
-            const cancelableStatuses = ['pending', 'queued', 'running'];
-            if (!cancelableStatuses.includes(task.status)) {
-                return {
-                    task_id: taskId,
-                    status: task.status,
-                    cancelled: false,
-                    error: `Task cannot be cancelled - current status is '${task.status}'`,
-                };
-            }
-            // Cancel the task
-            task.status = 'cancelled';
-            task.completed_at = new Date();
-            tasks.set(taskId, task);
-            // Persist to MongoDB
-            safePersist(getPersistence().saveTask(task));
-            return {
-                task_id: taskId,
-                status: task.status,
-                cancelled: true,
-            };
-        }
-        case 'task_retry': {
-            const taskId = args['task_id'];
-            const task = await getTask(taskId);
-            if (task === null) {
-                throw new Error(`Task not found: ${taskId}`);
-            }
-            // Check if task is in failed status
-            if (task.status !== 'failed') {
-                return {
-                    task_id: taskId,
-                    status: task.status,
-                    retried: false,
-                    error: `Task cannot be retried - current status is '${task.status}' (must be 'failed')`,
-                };
-            }
-            // Check if max retries exceeded
-            if (task.retry_count >= task.max_retries) {
-                return {
-                    task_id: taskId,
-                    status: task.status,
-                    retried: false,
-                    error: `Task has exceeded max retries (${task.max_retries})`,
-                    retry_count: task.retry_count,
-                };
-            }
-            // Retry the task
-            task.status = 'pending';
-            task.retry_count += 1;
-            task.error = null;
-            task.started_at = null;
-            task.completed_at = null;
-            tasks.set(taskId, task);
-            // Persist to MongoDB
-            safePersist(getPersistence().saveTask(task));
-            return {
-                task_id: taskId,
-                status: task.status,
-                retried: true,
-                retry_count: task.retry_count,
-                max_retries: task.max_retries,
-            };
-        }
-        // Lock Management tools
-        case 'lock_acquire': {
-            const sessionId = args['session_id'];
-            const filePath = args['file_path'];
-            const ttl = args['ttl'] ?? 300000;
-            // In-memory lock implementation (Redis-based implementation would be used in production)
-            const lockKey = `lock:${filePath}`;
-            const existingLock = memoryStore.get(lockKey);
-            if (existingLock !== undefined) {
-                const lockData = existingLock.value;
-                // Check if lock is expired
-                if (lockData.expires_at > Date.now() && lockData.session_id !== sessionId) {
-                    return {
-                        session_id: sessionId,
-                        file_path: filePath,
-                        acquired: false,
-                        owner: lockData.session_id,
-                        ttl,
-                    };
-                }
-            }
-            // Acquire lock
-            memoryStore.set(lockKey, {
-                value: { session_id: sessionId, expires_at: Date.now() + ttl },
-                stored_at: new Date(),
-            });
-            return {
-                session_id: sessionId,
-                file_path: filePath,
-                acquired: true,
-                ttl,
-            };
-        }
-        case 'lock_release': {
-            const sessionId = args['session_id'];
-            const filePath = args['file_path'];
-            const lockKey = `lock:${filePath}`;
-            const existingLock = memoryStore.get(lockKey);
-            if (existingLock !== undefined) {
-                const lockData = existingLock.value;
-                if (lockData.session_id === sessionId) {
-                    memoryStore.delete(lockKey);
-                    return {
-                        session_id: sessionId,
-                        file_path: filePath,
-                        released: true,
-                    };
-                }
-                return {
-                    session_id: sessionId,
-                    file_path: filePath,
-                    released: false,
-                    error: 'Lock is held by another session',
-                };
-            }
-            return {
-                session_id: sessionId,
-                file_path: filePath,
-                released: true,
-                message: 'Lock did not exist',
-            };
-        }
-        case 'lock_status': {
-            const sessionId = args['session_id'];
-            const filePath = args['file_path'];
-            if (filePath !== undefined) {
-                const lockKey = `lock:${filePath}`;
-                const existingLock = memoryStore.get(lockKey);
-                if (existingLock !== undefined) {
-                    const lockData = existingLock.value;
-                    const isExpired = lockData.expires_at <= Date.now();
-                    return {
-                        file_path: filePath,
-                        is_locked: !isExpired,
-                        owner: isExpired ? null : lockData.session_id,
-                        expires_at: lockData.expires_at,
-                    };
-                }
-                return {
-                    file_path: filePath,
-                    is_locked: false,
-                    owner: null,
-                };
-            }
-            if (sessionId !== undefined) {
-                // List all locks held by this session
-                const sessionLocks = [];
-                for (const [key, data] of memoryStore.entries()) {
-                    if (key.startsWith('lock:')) {
-                        const lockData = data.value;
-                        if (lockData.session_id === sessionId && lockData.expires_at > Date.now()) {
-                            sessionLocks.push({
-                                file_path: key.replace('lock:', ''),
-                                expires_at: lockData.expires_at,
-                            });
-                        }
-                    }
-                }
-                return {
-                    session_id: sessionId,
-                    lock_count: sessionLocks.length,
-                    locks: sessionLocks,
-                };
-            }
-            return { error: 'Must provide either session_id or file_path' };
-        }
-        // Cost Monitoring tools
-        case 'session_cost': {
-            const sessionId = args['session_id'];
-            // Aggregate cost from task token_usage
-            let totalCost = 0;
-            for (const [, task] of tasks.entries()) {
-                if (task.session_id === sessionId && task.token_usage !== undefined) {
-                    totalCost += task.token_usage.cost ?? 0;
-                }
-            }
-            return {
-                session_id: sessionId,
-                total_cost_usd: totalCost,
-                currency: 'USD',
-            };
-        }
-        case 'session_metrics': {
-            const sessionId = args['session_id'];
-            // Aggregate metrics from tasks
-            let requestCount = 0;
-            let inputTokens = 0;
-            let outputTokens = 0;
-            let totalTokens = 0;
-            for (const [, task] of tasks.entries()) {
-                if (task.session_id === sessionId) {
-                    requestCount++;
-                    if (task.token_usage !== undefined) {
-                        inputTokens += task.token_usage.prompt_tokens ?? 0;
-                        outputTokens += task.token_usage.completion_tokens ?? 0;
-                        totalTokens += task.token_usage.total_tokens ?? 0;
-                    }
-                }
-            }
-            return {
-                session_id: sessionId,
-                request_count: requestCount,
-                token_usage: {
-                    input: inputTokens,
-                    output: outputTokens,
-                    total: totalTokens,
-                },
-            };
-        }
-        case 'session_throttle': {
-            const sessionId = args['session_id'];
-            const provider = args['provider'] ?? 'claude';
-            // In-memory rate limit tracking (Redis-based in production)
-            const rateKey = `rate:${sessionId}:${provider}`;
-            const rateData = memoryStore.get(rateKey);
-            // Default limits per provider (requests per minute)
-            const defaultLimit = 30;
-            const limits = {
-                claude: 50,
-                openai: 60,
-                gemini: 60,
-            };
-            const limit = limits[provider] ?? defaultLimit;
-            if (rateData !== undefined) {
-                const data = rateData.value;
-                const windowSize = 60000; // 1 minute
-                const now = Date.now();
-                if (now - data.window_start > windowSize) {
-                    // Window expired, reset
-                    return {
-                        session_id: sessionId,
-                        provider,
-                        usage_percent: 0,
-                        current_count: 0,
-                        limit,
-                        throttled: false,
-                        blocked: false,
-                    };
-                }
-                const usagePercent = (data.count / limit) * 100;
-                return {
-                    session_id: sessionId,
-                    provider,
-                    usage_percent: Math.min(100, usagePercent),
-                    current_count: data.count,
-                    limit,
-                    throttled: usagePercent >= 85,
-                    blocked: usagePercent >= 95,
-                };
-            }
-            return {
-                session_id: sessionId,
-                provider,
-                usage_percent: 0,
-                current_count: 0,
-                limit,
-                throttled: false,
-                blocked: false,
-            };
-        }
-        // Memory tools
-        case 'memory_store': {
-            const key = args['session_id'] !== undefined
-                ? `${String(args['session_id'])}:${String(args['key'])}`
-                : String(args['key']);
-            memoryStore.set(key, { value: args['value'], stored_at: new Date() });
-            return { key, stored: true };
-        }
-        case 'memory_retrieve': {
-            const data = memoryStore.get(args['key']);
-            if (data === undefined)
-                throw new Error('Key not found');
-            return { key: args['key'], data };
-        }
-        case 'artifact_save': {
-            const artifactId = nanoid(12);
-            const now = new Date();
-            const content = args['content'];
-            const artifact = {
-                id: artifactId,
-                session_id: args['session_id'],
-                task_id: null,
-                type: args['type'] ?? 'other',
-                name: args['name'],
-                extension: '',
-                content,
-                content_hash: '',
-                size_bytes: content.length,
-                summary: content.slice(0, 200),
-                token_count: Math.ceil(content.length / 4),
-                relevance_score: 50,
-                metadata: {},
-                created_at: now,
-                updated_at: now,
-            };
-            artifacts.set(artifactId, artifact);
-            // Persist to MongoDB
-            safePersist(getPersistence().saveArtifact(artifact));
-            return { artifact_id: artifact.id, name: artifact.name, size_bytes: artifact.size_bytes };
-        }
-        case 'artifact_get': {
-            const artifact = await getArtifact(args['artifact_id']);
-            if (artifact === null)
-                throw new Error('Artifact not found');
-            return artifact;
-        }
-        case 'artifact_list': {
-            const sessionId = args['session_id'];
-            const typeFilter = args['type'];
-            // Get from in-memory cache first
-            const inMemoryArtifacts = [];
-            for (const [, artifact] of artifacts.entries()) {
-                if (artifact.session_id === sessionId) {
-                    if (typeFilter === undefined || artifact.type === typeFilter) {
-                        inMemoryArtifacts.push(artifact);
-                    }
-                }
-            }
-            // Also get from MongoDB for persistence
-            const persistedArtifacts = await getPersistence().listArtifacts({
-                session_id: sessionId,
-                ...(typeFilter !== undefined && { type: typeFilter }),
-            });
-            // Merge: in-memory takes precedence
-            const inMemoryIds = new Set(inMemoryArtifacts.map(a => a.id));
-            const sessionArtifacts = [
-                ...inMemoryArtifacts,
-                ...persistedArtifacts.filter(a => !inMemoryIds.has(a.id)),
-            ];
-            return {
-                session_id: sessionId,
-                count: sessionArtifacts.length,
-                ...(typeFilter !== undefined && { type_filter: typeFilter }),
-                artifacts: sessionArtifacts.map(a => ({
-                    id: a.id,
-                    name: a.name,
-                    type: a.type,
-                    size_bytes: a.size_bytes,
-                    created_at: a.created_at,
-                })),
-            };
-        }
-        case 'context_optimize': {
-            const sessionArtifacts = [];
-            for (const [, artifact] of artifacts.entries()) {
-                if (artifact.session_id === args['session_id']) {
-                    sessionArtifacts.push(artifact);
-                }
-            }
-            const result = contextOptimizer.optimize({
-                session_id: args['session_id'],
-                objective: args['objective'],
-                phase: args['phase'],
-                progress: args['progress'],
-                current_task: null,
-                artifacts: sessionArtifacts,
-                messages: args['messages'],
-                decisions: [],
-                completed_tasks: [],
-                active_work: [],
-                blockers: [],
-            });
-            return {
-                original_tokens: result.original_tokens,
-                optimized_tokens: result.optimized_tokens,
-                reduction_percent: result.reduction_percent,
-                minimal_context: result.context,
-            };
-        }
-        // Orchestration tools
-        case 'dispatch': {
-            const taskId = nanoid(12);
-            const task = {
-                id: taskId,
-                session_id: args['session_id'],
-                agent_id: null,
-                type: args['type'] ?? 'other',
-                status: 'pending',
-                description: args['prompt'].slice(0, 200),
-                input: { prompt: args['prompt'] },
-                output: null,
-                error: null,
-                complexity_score: 0,
-                routing_tier: 3,
-                provider: 'claude',
-                model: 'claude-sonnet',
-                token_usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, cost: 0 },
-                created_at: new Date(),
-                started_at: null,
-                completed_at: null,
-                dependencies: [],
-                priority: 5,
-                retry_count: 0,
-                max_retries: 3,
-            };
-            const routingOverride = {};
-            if (args['force_provider'] !== undefined) {
-                routingOverride.force_provider = args['force_provider'];
-            }
-            if (args['force_tier'] !== undefined) {
-                routingOverride.force_tier = args['force_tier'];
-            }
-            const routing = router.route(task, routingOverride);
-            // Get adapter and execute
-            const adapter = registry.get(routing.provider);
-            if (adapter === undefined) {
-                throw new Error(`Provider not available: ${routing.provider}`);
-            }
-            // Use workspace root for dispatch calls
-            const workingDir = process.env['ANASTOPS_WORKSPACE'] ?? process.cwd();
-            const response = await adapter.execute({ prompt: args['prompt'], model: routing.model, working_dir: workingDir }, { workingDir });
-            const dispatchResult = {
-                task_id: taskId,
-                routing: { tier: routing.tier, provider: routing.provider, model: routing.model },
-                response: { content: response.content, usage: response.usage },
-            };
-            // TOON encoding applied in handleToolCall
-            return dispatchResult;
-        }
-        case 'route': {
-            const task = {
-                id: 'route-check',
-                session_id: 'route-check',
-                agent_id: null,
-                type: args['type'] ?? 'other',
-                status: 'pending',
-                description: args['description'],
-                input: { prompt: args['description'] },
-                output: null,
-                error: null,
-                complexity_score: 0,
-                routing_tier: 3,
-                provider: 'claude',
-                model: 'claude-sonnet',
-                token_usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, cost: 0 },
-                created_at: new Date(),
-                started_at: null,
-                completed_at: null,
-                dependencies: [],
-                priority: 5,
-                retry_count: 0,
-                max_retries: 3,
-            };
-            const routing = router.route(task, {});
-            return routing;
-        }
-        case 'broadcast': {
-            return { session_id: args['session_id'], message: args['message'], message_type: args['message_type'] ?? 'info', broadcast_at: new Date() };
-        }
-        case 'aggregate': {
-            const taskIds = args['task_ids'];
-            const taskResults = taskIds.map(id => tasks.get(id)).filter(t => t !== undefined);
-            return { task_count: taskResults.length, strategy: args['strategy'] ?? 'concat' };
-        }
-        // Utility tools
-        case 'health_check': {
-            const result = {
-                status: 'healthy',
-                timestamp: new Date(),
-                components: { core: 'healthy', router: 'healthy', memory: 'in-memory' },
-            };
-            if (args['include_providers'] === true) {
-                const providerHealth = {};
-                for (const adapter of registry.list()) {
-                    const health = await adapter.healthCheck();
-                    providerHealth[adapter.type] = { healthy: health.healthy, error: health.error };
-                }
-                result['providers'] = providerHealth;
-            }
-            return result;
-        }
-        case 'provider_list': {
-            const providers = [];
-            for (const adapter of registry.list()) {
-                const health = await adapter.healthCheck();
-                if (args['filter_healthy'] === true && !health.healthy)
-                    continue;
-                const info = { type: adapter.type, name: adapter.name, healthy: health.healthy };
-                if (args['include_capabilities'] === true) {
-                    const caps = await adapter.getCapabilities();
-                    info['capabilities'] = caps;
-                }
-                providers.push(info);
-            }
-            return { count: providers.length, providers };
-        }
-        case 'metrics_get': {
-            return router.getMetrics();
-        }
-        case 'config_get': {
-            // Placeholder config
-            const config = {
-                default_provider: 'claude',
-                default_timeout: 600000, // 10 minutes
-                context_budget: 1600,
-            };
-            return { key: args['key'], value: config[args['key']] };
-        }
-        case 'config_set': {
-            return { key: args['key'], value: args['value'], updated: true };
-        }
-        default:
-            throw new Error(`Unknown tool: ${name}`);
-    }
-}
+export { handleToolCall, toolDefinitions } from './handlers/index.js';
 //# sourceMappingURL=handlers.js.map