@anastops/mcp-server 0.1.0

package/dist/handlers.js

@@ -0,0 +1,1840 @@
+/**
+ * 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
+ *
+ * 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
+ */
+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}`);
+    }
+}
+//# sourceMappingURL=handlers.js.map