@anastops/mcp-server 1.1.2 → 2.0.0

package/dist/handlers/tool-definitions.js

@@ -1,161 +1,189 @@
 /**
- * MCP Tool Definitions
- * Defines all 40+ tools available through the Anastops MCP server
+ * MCP Tool Definitions - v3.0.0
+ *
+ * Aggressive consolidation: 45 tools → 19 tools (58% reduction)
+ *
+ * Consolidation summary:
+ * - Session management: 9 → 3 tools (session_manage, session_query, session_queue_config)
+ * - Agent management: 5 → 2 tools (agent_manage, agent_query)
+ * - Task management: 10 → 4 tools (task_manage, task_execute, task_query, task_retry)
+ * - Data management: 6 → 2 tools (data_manage, data_query)
+ * - Utility tools: 3 → 1 tool (system_query)
+ * - Lock management: 3 → 1 tool (lock_manage)
+ * - Monitoring: 3 → 1 tool (session_monitoring)
+ * - Config: 2 → 1 tool (config_manage)
+ * - Orchestration: 4 tools (kept unchanged)
+ *
+ * @see docs/MCP-V3-AGGRESSIVE-CONSOLIDATION.md
  */
 export const toolDefinitions = [
-    // Session tools (9)
+    // ========================================================================
+    // SESSION MANAGEMENT (3 tools)
+    // ========================================================================
     {
-        name: 'session_spawn',
-        description: 'Create a new AI orchestration session',
+        name: 'session_manage',
+        description: 'Manage sessions: create new sessions, fork existing sessions, archive completed sessions, or delete sessions permanently',
         inputSchema: {
             type: 'object',
             properties: {
-                objective: { type: 'string', description: 'High-level objective' },
-                context_files: { type: 'array', items: { type: 'string' } },
-                parent_session: { type: 'string' },
-                concurrency: { type: 'number', description: 'Max concurrent running tasks (default: 1)' },
+                operation: {
+                    type: 'string',
+                    enum: ['create', 'fork', 'archive', 'delete'],
+                    description: 'Operation to perform: create=spawn new session, fork=create alternative branch, archive=mark completed, delete=permanently remove',
+                },
+                // CREATE operation parameters
+                objective: {
+                    type: 'string',
+                    description: 'Required for create: High-level objective for the session',
+                },
+                context_files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'For create: Array of file paths to include in session context',
+                },
+                parent_session: {
+                    type: 'string',
+                    description: 'For create: Parent session ID if this is a child session',
+                },
+                concurrency: {
+                    type: 'number',
+                    description: 'For create: Max concurrent running tasks (1-10, default: 1)',
+                },
                 auto_execute: {
                     type: 'boolean',
-                    description: 'Auto-execute queued tasks when slots available (default: false)',
+                    description: 'For create: Auto-execute queued tasks when slots available (default: false)',
                 },
-            },
-            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: {
+                // FORK operation parameters
+                session_id: {
                     type: 'string',
-                    enum: ['table', 'json'],
-                    description: 'Output format: "table" for ASCII table, "json" for raw JSON (default)',
+                    description: 'Required for fork/archive/delete: Session ID to operate on',
+                },
+                fork_point: {
+                    type: 'number',
+                    description: 'For fork: Task number to fork from (optional)',
+                },
+                reason: {
+                    type: 'string',
+                    description: 'For fork: Reason for forking (e.g., "Explore OAuth approach")',
+                },
+                // DELETE operation parameters
+                session_ids: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'For delete: Array of session IDs to delete (bulk deletion)',
                 },
-            },
-        },
-    },
-    {
-        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)',
+                    description: 'For delete: Delete all sessions with this status',
                 },
-                include_output: {
-                    type: 'boolean',
-                    description: 'Include full task output content (default: true)',
+                older_than_days: {
+                    type: 'number',
+                    description: 'For delete: Delete sessions older than N days',
                 },
-                include_artifacts: {
+                confirm: {
                     type: 'boolean',
-                    description: 'Include artifact content (default: false, only metadata)',
+                    description: 'Required for delete: Must be true to execute deletion (safety check)',
                 },
-                limit: { type: 'number', description: 'Max sessions to return (default: 20)' },
             },
+            required: ['operation'],
         },
     },
     {
-        name: 'session_purge',
-        description: 'Permanently delete sessions and all related data (tasks, agents, artifacts). Use with caution.',
+        name: 'session_query',
+        description: 'Query session information: get status for a specific session, list all sessions with filters, or generate comprehensive reports',
         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',
+                operation: {
+                    type: 'string',
+                    enum: ['status', 'list', 'report'],
+                    description: 'Type of query: status=get session details, list=list sessions with filters, report=generate comprehensive report',
                 },
-                status: {
+                // STATUS operation parameters
+                session_id: {
+                    type: 'string',
+                    description: 'Required for status: Session ID to query. Optional for report: omit to get all sessions',
+                },
+                // LIST operation parameters
+                status_filter: {
                     type: 'string',
                     enum: ['active', 'completed', 'archived'],
-                    description: 'Delete all sessions with this status',
+                    description: 'For list/report: Filter sessions by status',
+                },
+                include_forks: {
+                    type: 'boolean',
+                    description: 'For list: Include forked sessions in results (default: false)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'For list/report: Maximum number of sessions to return (default: 20 for report)',
+                },
+                format: {
+                    type: 'string',
+                    enum: ['table', 'json'],
+                    description: 'For list: Output format (table=ASCII table, json=raw JSON, default: json)',
+                },
+                // REPORT operation parameters
+                include_output: {
+                    type: 'boolean',
+                    description: 'For report: Include full task output content (default: true)',
+                },
+                include_artifacts: {
+                    type: 'boolean',
+                    description: 'For report: Include artifact content, not just metadata (default: false)',
                 },
-                older_than_days: { type: 'number', description: 'Delete sessions older than N days' },
-                confirm: { type: 'boolean', description: 'Must be true to execute deletion' },
             },
-            required: ['confirm'],
+            required: ['operation'],
         },
     },
     {
         name: 'session_queue_config',
-        description: 'Configure session queue settings for automatic task execution',
+        description: 'Configure session queue settings (concurrency, auto-execution) or query queue status (running/queued counts, available slots)',
         inputSchema: {
             type: 'object',
             properties: {
-                session_id: { type: 'string', description: 'Session ID to configure' },
-                concurrency: { type: 'number', description: 'Max concurrent running tasks (1-10)' },
+                operation: {
+                    type: 'string',
+                    enum: ['configure', 'status'],
+                    description: 'Operation: configure=update queue settings, status=get queue status and ready tasks',
+                },
+                session_id: {
+                    type: 'string',
+                    description: 'Required: Session ID to configure or query',
+                },
+                // CONFIGURE operation parameters
+                concurrency: {
+                    type: 'number',
+                    description: 'For configure: Max concurrent running tasks (1-10)',
+                },
                 auto_execute: {
                     type: 'boolean',
-                    description: 'Auto-execute queued tasks when slots available',
+                    description: 'For configure: Auto-execute queued tasks when slots available',
                 },
             },
-            required: ['session_id'],
+            required: ['operation', 'session_id'],
         },
     },
+    // ========================================================================
+    // AGENT MANAGEMENT (2 tools)
+    // ========================================================================
     {
-        name: 'queue_status',
-        description: 'Get queue status for a session including running/queued task counts and ready tasks',
+        name: 'agent_manage',
+        description: 'Manage agents: create new agents, deploy agents to tasks, or retire agents. Use create to spawn new agents, deploy to assign work, retire to mark completion.',
         inputSchema: {
             type: 'object',
             properties: {
-                session_id: { type: 'string', description: 'Session ID to check' },
-            },
-            required: ['session_id'],
-        },
-    },
-    // Agent tools (5)
-    {
-        name: 'agent_create',
-        description: 'Create a new AI agent',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
+                operation: {
+                    type: 'string',
+                    enum: ['create', 'deploy', 'retire'],
+                    description: 'Operation to perform: create, deploy, or retire',
+                },
+                // create operation parameters
+                session_id: {
+                    type: 'string',
+                    description: 'Required for create: session ID to create agent in',
+                },
                 role: {
                     type: 'string',
                     enum: [
@@ -168,182 +196,128 @@ export const toolDefinitions = [
                         'documenter',
                         'specialist',
                     ],
+                    description: 'Required for create: agent role',
+                },
+                name: {
+                    type: 'string',
+                    description: 'For create: agent name (defaults to auto-generated)',
+                },
+                provider: {
+                    type: 'string',
+                    description: 'For create: AI provider (default: claude)',
+                },
+                model: {
+                    type: 'string',
+                    description: 'For create: model to use (default: claude-sonnet)',
+                },
+                // deploy operation parameters
+                agent_id: {
+                    type: 'string',
+                    description: 'Required for deploy/retire: agent ID',
+                },
+                task_id: {
+                    type: 'string',
+                    description: 'Required for deploy: task ID to assign agent to',
                 },
-                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'],
+            required: ['operation'],
         },
     },
     {
-        name: 'agent_list',
-        description: 'List agents in a session. Use format="table" for beautiful ASCII table output.',
+        name: 'agent_query',
+        description: 'Query agent information: get status of a specific agent or list all agents in a session. Use status for detailed info, list for overview.',
         inputSchema: {
             type: 'object',
             properties: {
-                session_id: { type: 'string' },
-                status: { type: 'string' },
+                operation: {
+                    type: 'string',
+                    enum: ['status', 'list'],
+                    description: 'Type of query (default: status if agent_id provided, else list if session_id provided)',
+                },
+                // status operation parameters
+                agent_id: {
+                    type: 'string',
+                    description: 'For status: specific agent ID to query',
+                },
+                // list operation parameters
+                session_id: {
+                    type: 'string',
+                    description: 'For list: session ID to list agents from',
+                },
+                status: {
+                    type: 'string',
+                    description: 'For list: filter by agent status',
+                },
                 format: {
                     type: 'string',
                     enum: ['table', 'json'],
-                    description: 'Output format: "table" for ASCII table, "json" for raw JSON (default)',
+                    description: 'For list: output format (default: json)',
                 },
             },
-            required: ['session_id'],
         },
     },
+    // ========================================================================
+    // TASK MANAGEMENT (4 tools)
+    // ========================================================================
     {
-        name: 'agent_retire',
-        description: 'Retire an agent, marking it as completed',
+        name: 'task_manage',
+        description: 'Manage tasks: create (single or batch), complete, or cancel tasks. Use batch=true for creating multiple tasks at once.',
         inputSchema: {
             type: 'object',
             properties: {
-                agent_id: { type: 'string', description: 'ID of the agent to retire' },
-            },
-            required: ['agent_id'],
-        },
-    },
-    // Task tools (10)
-    {
-        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' },
+                operation: {
+                    type: 'string',
+                    enum: ['create', 'complete', 'cancel'],
+                    description: 'Operation to perform: create=create new task(s), complete=mark task done, cancel=cancel pending/queued/running task',
+                },
+                // ---------- Common parameters ----------
+                session_id: {
+                    type: 'string',
+                    description: 'Required for create: session ID',
+                },
+                // ---------- Single task creation ----------
+                type: {
+                    type: 'string',
+                    description: 'For create (single): task type',
+                },
+                description: {
+                    type: 'string',
+                    description: 'For create (single): task description',
+                },
+                prompt: {
+                    type: 'string',
+                    description: 'For create (single): task prompt/instruction',
+                },
+                context_files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'For create: context files to include',
+                },
+                force_provider: {
+                    type: 'string',
+                    description: 'For create: force specific provider (claude, cursor, codex, gemini, grok, copilot, aider)',
+                },
+                force_tier: {
+                    type: 'number',
+                    description: 'For create: force routing tier (1-5)',
+                },
                 agent: {
                     type: 'string',
-                    description: 'Agent name to use (e.g., orchestration-specialist). Agent defines model, tools, and skills.',
+                    description: 'For create: 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"])',
+                    description: 'For create: 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)',
+                // ---------- Batch creation ----------
+                batch: {
+                    type: 'boolean',
+                    description: 'For create: if true, expects tasks array instead of single task parameters (default: false)',
                 },
-            },
-            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'],
-        },
-    },
-    {
-        name: 'task_batch_create',
-        description: 'Create multiple tasks in a single call. ALWAYS use this instead of multiple task_create calls when creating 2+ tasks.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string', description: 'Session to create tasks in' },
                 tasks: {
                     type: 'array',
-                    description: 'Array of task definitions (max 50)',
+                    description: 'For create (batch=true): array of task definitions (max 50). Each task has: type, description, prompt, optional: context_files, force_provider, force_tier, agent, skills',
                     items: {
                         type: 'object',
                         properties: {
@@ -359,183 +333,312 @@ export const toolDefinitions = [
                         required: ['type', 'description', 'prompt'],
                     },
                 },
+                // ---------- Complete operation ----------
+                task_id: {
+                    type: 'string',
+                    description: 'Required for complete/cancel: task ID',
+                },
+                content: {
+                    type: 'string',
+                    description: 'Required for complete: completion content/result',
+                },
+                artifacts: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'For complete: artifact IDs produced by the task',
+                },
             },
-            required: ['session_id', 'tasks'],
+            required: ['operation'],
         },
     },
     {
-        name: 'task_batch_execute',
-        description: 'Execute multiple tasks in parallel. Use after task_batch_create or with existing task IDs. Much more efficient than sequential task_execute calls.',
+        name: 'task_execute',
+        description: 'Execute one or multiple tasks (parallel or sequential). Queue tasks or execute immediately. Use task_id for single execution or task_ids for batch execution.',
         inputSchema: {
             type: 'object',
             properties: {
+                // ---------- Single task execution ----------
+                task_id: {
+                    type: 'string',
+                    description: 'Single task ID to execute. Use this OR task_ids, not both. Mutually exclusive with task_ids.',
+                },
+                // ---------- Batch task execution ----------
                 task_ids: {
                     type: 'array',
                     items: { type: 'string' },
-                    description: 'Array of task IDs to execute (max 50)',
+                    description: 'Array of task IDs to execute (max 50). Use this OR task_id, not both. Mutually exclusive with task_id.',
                 },
                 parallel: {
                     type: 'boolean',
-                    description: 'Execute tasks in parallel (default: true). Set false for sequential.',
+                    description: 'For batch (task_ids): execute tasks in parallel (default: true). Set false for sequential execution.',
+                },
+                // ---------- Common parameters ----------
+                queue_only: {
+                    type: 'boolean',
+                    description: 'If true, queue task(s) for later execution instead of executing immediately (default: false). Queued tasks will be auto-executed if session has auto_execute enabled.',
                 },
                 wait: {
                     type: 'boolean',
-                    description: 'Wait for all tasks to complete (default: true)',
+                    description: 'Wait for task(s) to complete before returning (default: true). Set false to return immediately after starting execution.',
                 },
             },
-            required: ['task_ids'],
-        },
-    },
-    // 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',
+        name: 'task_query',
+        description: 'Query task information: get status of a specific task or list all tasks in a session. Use format="table" for CLI-friendly output.',
         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' },
+                operation: {
+                    type: 'string',
+                    enum: ['status', 'list'],
+                    description: 'Type of query: status=get specific task details, list=list all tasks in session (default: status if task_id provided, else list)',
+                },
+                // ---------- Status operation ----------
+                task_id: {
+                    type: 'string',
+                    description: 'For status: specific task ID to query',
+                },
+                // ---------- List operation ----------
+                session_id: {
+                    type: 'string',
+                    description: 'Required for list: session to list tasks from',
+                },
+                status_filter: {
+                    type: 'string',
+                    description: 'For list: filter by status (pending, queued, running, completed, failed, cancelled)',
+                },
+                format: {
+                    type: 'string',
+                    enum: ['table', 'json'],
+                    description: 'Output format: table=ASCII table for CLI, json=raw JSON (default: json)',
+                },
             },
         },
     },
-    // Cost Monitoring tools (3)
     {
-        name: 'session_cost',
-        description: 'Get cost breakdown for a session',
+        name: 'task_retry',
+        description: 'Retry a failed task with the same parameters. Task must be in failed status and not exceed max_retries.',
         inputSchema: {
             type: 'object',
             properties: {
-                session_id: { type: 'string' },
+                task_id: {
+                    type: 'string',
+                    description: 'ID of the failed task to retry',
+                },
             },
-            required: ['session_id'],
+            required: ['task_id'],
         },
     },
+    // ========================================================================
+    // DATA MANAGEMENT (2 tools)
+    // ========================================================================
     {
-        name: 'session_metrics',
-        description: 'Get request and token usage metrics for a session',
+        name: 'data_manage',
+        description: 'Manage data operations: store memory, save artifacts, or optimize context. Use operation="store" for memory storage, operation="save" for artifact creation, operation="optimize" for context token reduction.',
         inputSchema: {
             type: 'object',
             properties: {
-                session_id: { type: 'string' },
+                operation: {
+                    type: 'string',
+                    enum: ['store', 'save', 'optimize'],
+                    description: 'Operation type: store=memory storage, save=artifact creation, optimize=context optimization',
+                },
+                // For memory_store operation
+                key: {
+                    type: 'string',
+                    description: 'For store operation: memory key to store value under',
+                },
+                value: {
+                    description: 'For store operation: value to store (any JSON-serializable type)',
+                },
+                // For artifact_save operation
+                session_id: {
+                    type: 'string',
+                    description: 'Required for save/optimize operations: session ID',
+                },
+                artifact_type: {
+                    type: 'string',
+                    enum: ['code', 'document', 'data', 'config', 'test', 'other'],
+                    description: 'For save operation: artifact type classification',
+                },
+                name: {
+                    type: 'string',
+                    description: 'For save operation: artifact name/filename',
+                },
+                content: {
+                    type: 'string',
+                    description: 'For save operation: artifact content',
+                },
+                // For context_optimize operation
+                objective: {
+                    type: 'string',
+                    description: 'For optimize operation: session objective for context optimization',
+                },
+                phase: {
+                    type: 'string',
+                    description: 'For optimize operation: current phase of work',
+                },
+                progress: {
+                    type: 'number',
+                    description: 'For optimize operation: progress percentage (0-1)',
+                },
+                messages: {
+                    type: 'array',
+                    description: 'For optimize operation: messages to optimize',
+                },
             },
-            required: ['session_id'],
+            required: ['operation'],
         },
     },
     {
-        name: 'session_throttle',
-        description: 'Check rate limit and throttle status for a session',
+        name: 'data_query',
+        description: 'Query data: retrieve memory, get artifacts, or list artifacts. Use operation="retrieve" for memory lookup, operation="get" for single artifact, operation="list" for all session artifacts.',
         inputSchema: {
             type: 'object',
             properties: {
-                session_id: { type: 'string' },
-                provider: { type: 'string', description: 'Specific provider to check' },
+                operation: {
+                    type: 'string',
+                    enum: ['retrieve', 'get', 'list'],
+                    description: 'Operation type: retrieve=memory lookup, get=single artifact, list=all artifacts',
+                },
+                // For memory_retrieve operation
+                key: {
+                    type: 'string',
+                    description: 'For retrieve operation: memory key to lookup',
+                },
+                // For artifact_get operation
+                artifact_id: {
+                    type: 'string',
+                    description: 'For get operation: artifact ID to retrieve',
+                },
+                // For artifact_list operation
+                session_id: {
+                    type: 'string',
+                    description: 'Required for list operation: session ID to list artifacts from',
+                },
+                artifact_type: {
+                    type: 'string',
+                    enum: ['code', 'document', 'data', 'config', 'test', 'other'],
+                    description: 'For list operation: optional filter by artifact type',
+                },
             },
-            required: ['session_id'],
+            required: ['operation'],
         },
     },
-    // Memory tools (6)
+    // ========================================================================
+    // UTILITY TOOLS (4 tools)
+    // ========================================================================
     {
-        name: 'memory_store',
-        description: 'Store data in memory',
+        name: 'system_query',
+        description: 'Query system information: health status, available providers, or system metrics. Use operation="health" for health checks, operation="providers" for provider list, operation="metrics" for system metrics.',
         inputSchema: {
             type: 'object',
             properties: {
-                key: { type: 'string' },
-                value: {},
-                session_id: { type: 'string' },
+                operation: {
+                    type: 'string',
+                    enum: ['health', 'providers', 'metrics'],
+                    description: 'Operation type: health=system health, providers=available providers, metrics=system metrics',
+                },
+                // For health_check operation
+                include_providers: {
+                    type: 'boolean',
+                    description: 'For health operation: include provider status in health check',
+                },
+                // For provider_list operation
+                filter_healthy: {
+                    type: 'boolean',
+                    description: 'For providers operation: only show healthy providers',
+                },
+                include_capabilities: {
+                    type: 'boolean',
+                    description: 'For providers operation: include provider capabilities',
+                },
+                // For metrics_get operation
+                metric_type: {
+                    type: 'string',
+                    enum: ['routing', 'tokens', 'costs', 'all'],
+                    description: 'For metrics operation: type of metrics to retrieve',
+                },
             },
-            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',
+        name: 'lock_manage',
+        description: 'Manage file locks: acquire, release, or check status. Use operation="acquire" to lock a file, operation="release" to unlock, operation="status" to check lock state.',
         inputSchema: {
             type: 'object',
             properties: {
-                session_id: { type: 'string' },
-                type: { type: 'string', enum: ['code', 'document', 'data', 'config', 'test', 'other'] },
-                name: { type: 'string' },
-                content: { type: 'string' },
+                operation: {
+                    type: 'string',
+                    enum: ['acquire', 'release', 'status'],
+                    description: 'Operation type: acquire=lock file, release=unlock file, status=check lock',
+                },
+                session_id: {
+                    type: 'string',
+                    description: 'Required for acquire/release, optional for status: session ID',
+                },
+                file_path: {
+                    type: 'string',
+                    description: 'Required for acquire/release, optional for status: file path to lock',
+                },
+                ttl: {
+                    type: 'number',
+                    description: 'For acquire operation: lock TTL in milliseconds (default: 300000)',
+                },
             },
-            required: ['session_id', 'type', 'name', 'content'],
-        },
-    },
-    {
-        name: 'artifact_get',
-        description: 'Get an artifact',
-        inputSchema: {
-            type: 'object',
-            properties: { artifact_id: { type: 'string' } },
-            required: ['artifact_id'],
+            required: ['operation'],
         },
     },
     {
-        name: 'artifact_list',
-        description: 'List all artifacts for a session',
+        name: 'session_monitoring',
+        description: 'Monitor session activity: cost breakdown, token metrics, or rate limits. Use operation="cost" for costs, operation="metrics" for token usage, operation="throttle" for rate limits.',
         inputSchema: {
             type: 'object',
             properties: {
-                session_id: { type: 'string', description: 'Session ID to list artifacts for' },
-                type: {
+                operation: {
                     type: 'string',
-                    enum: ['code', 'document', 'data', 'config', 'test', 'other'],
-                    description: 'Optional filter by artifact type',
+                    enum: ['cost', 'metrics', 'throttle'],
+                    description: 'Operation type: cost=cost breakdown, metrics=token usage, throttle=rate limits',
+                },
+                session_id: {
+                    type: 'string',
+                    description: 'Required for all operations: session ID to monitor',
+                },
+                provider: {
+                    type: 'string',
+                    description: 'For throttle operation: specific provider to check',
                 },
             },
-            required: ['session_id'],
+            required: ['operation', 'session_id'],
         },
     },
     {
-        name: 'context_optimize',
-        description: 'Optimize context for token reduction',
+        name: 'config_manage',
+        description: 'Manage configuration: get or set values. Use operation="get" to retrieve config, operation="set" to update config.',
         inputSchema: {
             type: 'object',
             properties: {
-                session_id: { type: 'string' },
-                objective: { type: 'string' },
-                phase: { type: 'string' },
-                progress: { type: 'number' },
-                messages: { type: 'array' },
+                operation: {
+                    type: 'string',
+                    enum: ['get', 'set'],
+                    description: 'Operation type: get=retrieve value, set=update value',
+                },
+                key: {
+                    type: 'string',
+                    description: 'Required for both operations: configuration key',
+                },
+                value: {
+                    description: 'Required for set operation: value to set (any JSON-serializable type)',
+                },
             },
-            required: ['session_id', 'objective', 'phase', 'progress', 'messages'],
+            required: ['operation', 'key'],
         },
     },
-    // Orchestration tools (4)
+    // ========================================================================
+    // ORCHESTRATION TOOLS (4 tools - unchanged)
+    // ========================================================================
     {
         name: 'dispatch',
         description: 'Dispatch prompt to AI provider with routing',
@@ -591,51 +694,5 @@ export const toolDefinitions = [
             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'],
-        },
-    },
 ];
 //# sourceMappingURL=tool-definitions.js.map