sqlew 1.1.2 → 2.1.0

package/dist/index.js

@@ -8,11 +8,11 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { initializeDatabase, closeDatabase, setConfigValue, getAllConfig } from './database.js';
 import { CONFIG_KEYS } from './constants.js';
-import { setDecision, getContext, getDecision, searchByTags, getVersions, searchByLayer } from './tools/context.js';
-import { sendMessage, getMessages, markRead } from './tools/messaging.js';
-import { recordFileChange, getFileChanges, checkFileLock } from './tools/files.js';
+import { setDecision, getContext, getDecision, searchByTags, getVersions, searchByLayer, quickSetDecision, searchAdvanced, setDecisionBatch, hasUpdates, setFromTemplate, createTemplate, listTemplates } from './tools/context.js';
+import { sendMessage, getMessages, markRead, sendMessageBatch } from './tools/messaging.js';
+import { recordFileChange, getFileChanges, checkFileLock, recordFileChangeBatch } from './tools/files.js';
 import { addConstraint, getConstraints, deactivateConstraint } from './tools/constraints.js';
-import { getLayerSummary, clearOldData, getStats } from './tools/utils.js';
+import { getLayerSummary, clearOldData, getStats, getActivityLog } from './tools/utils.js';
 import { getConfig, updateConfig } from './tools/config.js';
 // Parse command-line arguments
 const args = process.argv.slice(2);
@@ -92,505 +92,150 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         tools: [
             {
-                name: 'set_decision',
-                description: 'Set or update a decision in the shared context. Auto-detects numeric vs string values. Supports tags, layers, scopes, and version tracking.',
+                name: 'decision',
+                description: 'Manage decisions (13 actions + help)',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        key: {
-                            type: 'string',
-                            description: 'Unique key for the decision (e.g., "auth_method", "max_connections")',
-                        },
-                        value: {
-                            type: ['string', 'number'],
-                            description: 'Decision value (string or numeric). Numeric values are stored in optimized table.',
-                        },
-                        agent: {
-                            type: 'string',
-                            description: 'Name of the agent making the decision (defaults to "system")',
-                        },
-                        layer: {
-                            type: 'string',
-                            description: 'Architecture layer (presentation, business, data, infrastructure, cross-cutting)',
-                            enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'],
-                        },
-                        version: {
-                            type: 'string',
-                            description: 'Version identifier (defaults to "1.0.0"). Used for change tracking.',
-                        },
-                        status: {
-                            type: 'string',
-                            description: 'Decision status (defaults to "active")',
-                            enum: ['active', 'deprecated', 'draft'],
-                        },
-                        tags: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: 'Tags for categorization (e.g., ["authentication", "security"])',
-                        },
-                        scopes: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: 'Module or component scopes (e.g., ["user-service", "api"])',
-                        },
-                    },
-                    required: ['key', 'value'],
-                },
-            },
-            {
-                name: 'get_context',
-                description: 'Retrieve decisions with advanced filtering. Returns token-efficient view with all metadata. Supports filtering by status, layer, tags, and scope.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        status: {
-                            type: 'string',
-                            description: 'Filter by decision status',
-                            enum: ['active', 'deprecated', 'draft'],
-                        },
-                        layer: {
-                            type: 'string',
-                            description: 'Filter by architecture layer',
-                            enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'],
-                        },
-                        tags: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: 'Filter by tags (use tag_match to control AND/OR logic)',
-                        },
-                        scope: {
-                            type: 'string',
-                            description: 'Filter by specific scope/module',
-                        },
-                        tag_match: {
-                            type: 'string',
-                            description: 'Tag matching mode: "AND" (all tags required) or "OR" (any tag)',
-                            enum: ['AND', 'OR'],
-                            default: 'OR',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'get_decision',
-                description: 'Get a specific decision by key. Returns full metadata including tags, layer, scopes, version, and timestamp.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        key: {
-                            type: 'string',
-                            description: 'Decision key to retrieve',
-                        },
-                    },
-                    required: ['key'],
-                },
-            },
-            {
-                name: 'search_by_tags',
-                description: 'Search for decisions by tags with AND/OR logic. Supports flexible tag-based filtering with optional status and layer filters.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        tags: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: 'Array of tags to search for (at least one required)',
-                        },
-                        match_mode: {
-                            type: 'string',
-                            description: 'Tag matching mode: "AND" (all tags required) or "OR" (any tag)',
-                            enum: ['AND', 'OR'],
-                            default: 'OR',
-                        },
-                        status: {
-                            type: 'string',
-                            description: 'Optional filter by decision status',
-                            enum: ['active', 'deprecated', 'draft'],
-                        },
-                        layer: {
-                            type: 'string',
-                            description: 'Optional filter by architecture layer',
-                            enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'],
-                        },
-                    },
-                    required: ['tags'],
-                },
-            },
-            {
-                name: 'get_versions',
-                description: 'Get version history for a specific decision key. Returns all historical versions ordered by timestamp (newest first).',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        key: {
-                            type: 'string',
-                            description: 'Decision key to get version history for',
-                        },
-                    },
-                    required: ['key'],
-                },
-            },
-            {
-                name: 'search_by_layer',
-                description: 'Search for decisions within a specific architecture layer. Supports status filtering and optional tag inclusion.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        layer: {
-                            type: 'string',
-                            description: 'Architecture layer to search in',
-                            enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'],
-                        },
-                        status: {
-                            type: 'string',
-                            description: 'Filter by decision status (defaults to "active")',
-                            enum: ['active', 'deprecated', 'draft'],
-                            default: 'active',
-                        },
-                        include_tags: {
-                            type: 'boolean',
-                            description: 'Include tag information in results (defaults to true)',
-                            default: true,
-                        },
-                    },
-                    required: ['layer'],
-                },
-            },
-            {
-                name: 'send_message',
-                description: 'Send a message from one agent to another (or broadcast to all). Supports priority levels and optional JSON payload.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        from_agent: {
-                            type: 'string',
-                            description: 'Name of the sending agent',
-                        },
-                        to_agent: {
-                            type: ['string', 'null'],
-                            description: 'Name of the receiving agent (null or omit for broadcast)',
-                        },
-                        msg_type: {
-                            type: 'string',
-                            description: 'Type of message',
-                            enum: ['decision', 'warning', 'request', 'info'],
-                        },
-                        message: {
-                            type: 'string',
-                            description: 'The message content',
-                        },
-                        priority: {
-                            type: 'string',
-                            description: 'Message priority level (defaults to "medium")',
-                            enum: ['low', 'medium', 'high', 'critical'],
-                            default: 'medium',
-                        },
-                        payload: {
-                            type: 'object',
-                            description: 'Optional JSON payload with additional data',
-                        },
-                    },
-                    required: ['from_agent', 'msg_type', 'message'],
-                },
-            },
-            {
-                name: 'get_messages',
-                description: 'Retrieve messages for an agent. Returns messages addressed to the agent or broadcast messages. Supports filtering by read status, priority, and message type.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        agent_name: {
-                            type: 'string',
-                            description: 'Name of the agent to retrieve messages for',
-                        },
-                        unread_only: {
-                            type: 'boolean',
-                            description: 'Only return unread messages (defaults to false)',
-                            default: false,
-                        },
-                        priority_filter: {
-                            type: 'string',
-                            description: 'Filter by specific priority level',
-                            enum: ['low', 'medium', 'high', 'critical'],
-                        },
-                        msg_type_filter: {
-                            type: 'string',
-                            description: 'Filter by message type',
-                            enum: ['decision', 'warning', 'request', 'info'],
-                        },
-                        limit: {
-                            type: 'number',
-                            description: 'Maximum number of messages to return (defaults to 50)',
-                            default: 50,
-                        },
-                    },
-                    required: ['agent_name'],
-                },
-            },
-            {
-                name: 'mark_read',
-                description: 'Mark messages as read. Only marks messages addressed to the specified agent (security check). Idempotent operation.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        message_ids: {
-                            type: 'array',
-                            items: { type: 'number' },
-                            description: 'Array of message IDs to mark as read',
-                        },
-                        agent_name: {
-                            type: 'string',
-                            description: 'Name of the agent marking messages as read',
-                        },
-                    },
-                    required: ['message_ids', 'agent_name'],
-                },
-            },
-            {
-                name: 'record_file_change',
-                description: 'Record a file change with optional layer assignment and description. Auto-registers the file and agent. Useful for tracking file modifications across agents.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        file_path: {
-                            type: 'string',
-                            description: 'The file path (absolute or relative)',
-                        },
-                        agent_name: {
-                            type: 'string',
-                            description: 'Name of the agent making the change',
-                        },
-                        change_type: {
-                            type: 'string',
-                            description: 'Type of change made to the file',
-                            enum: ['created', 'modified', 'deleted'],
-                        },
-                        layer: {
-                            type: 'string',
-                            description: 'Optional architecture layer assignment',
-                            enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'],
-                        },
-                        description: {
-                            type: 'string',
-                            description: 'Optional description of the change',
-                        },
-                    },
-                    required: ['file_path', 'agent_name', 'change_type'],
-                },
-            },
-            {
-                name: 'get_file_changes',
-                description: 'Retrieve file changes with advanced filtering. Supports filtering by file, agent, layer, change type, and time range. Returns token-efficient view when no filters applied.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        file_path: {
-                            type: 'string',
-                            description: 'Filter by specific file path',
-                        },
-                        agent_name: {
-                            type: 'string',
-                            description: 'Filter by agent who made the change',
-                        },
-                        layer: {
-                            type: 'string',
-                            description: 'Filter by architecture layer',
-                            enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'],
-                        },
-                        change_type: {
-                            type: 'string',
-                            description: 'Filter by type of change',
-                            enum: ['created', 'modified', 'deleted'],
-                        },
-                        since: {
-                            type: 'string',
-                            description: 'ISO 8601 timestamp - return changes since this time',
-                        },
-                        limit: {
-                            type: 'number',
-                            description: 'Maximum number of changes to return (default: 100)',
-                            default: 100,
-                        },
-                    },
-                },
-            },
-            {
-                name: 'check_file_lock',
-                description: 'Check if a file is "locked" (recently modified). Useful to prevent concurrent edits by multiple agents. Returns lock status with details of last change.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        file_path: {
-                            type: 'string',
-                            description: 'The file path to check',
-                        },
-                        lock_duration: {
-                            type: 'number',
-                            description: 'Time window in seconds to consider "locked" (default: 300 = 5 minutes)',
-                            default: 300,
-                        },
+                        action: {
+                            type: 'string',
+                            description: 'Action',
+                            enum: ['set', 'get', 'list', 'search_tags', 'search_layer', 'versions', 'quick_set', 'search_advanced', 'set_batch', 'has_updates', 'set_from_template', 'create_template', 'list_templates', 'help']
+                        },
+                        key: { type: 'string' },
+                        value: { type: ['string', 'number'] },
+                        agent: { type: 'string' },
+                        layer: { type: 'string', enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'] },
+                        version: { type: 'string' },
+                        status: { type: 'string', enum: ['active', 'deprecated', 'draft'] },
+                        tags: { type: 'array', items: { type: 'string' } },
+                        scopes: { type: 'array', items: { type: 'string' } },
+                        scope: { type: 'string' },
+                        tag_match: { type: 'string', enum: ['AND', 'OR'] },
+                        include_tags: { type: 'boolean' },
+                        layers: { type: 'array', items: { type: 'string' } },
+                        tags_all: { type: 'array', items: { type: 'string' } },
+                        tags_any: { type: 'array', items: { type: 'string' } },
+                        exclude_tags: { type: 'array', items: { type: 'string' } },
+                        updated_after: { type: 'string' },
+                        updated_before: { type: 'string' },
+                        decided_by: { type: 'array', items: { type: 'string' } },
+                        statuses: { type: 'array', items: { type: 'string', enum: ['active', 'deprecated', 'draft'] } },
+                        search_text: { type: 'string' },
+                        sort_by: { type: 'string', enum: ['updated', 'key', 'version'] },
+                        sort_order: { type: 'string', enum: ['asc', 'desc'] },
+                        limit: { type: 'number' },
+                        offset: { type: 'number' },
+                        decisions: { type: 'array' },
+                        atomic: { type: 'boolean' },
+                        agent_name: { type: 'string' },
+                        since_timestamp: { type: 'string' },
+                        template: { type: 'string' },
+                        name: { type: 'string' },
+                        defaults: { type: 'object' },
+                        required_fields: { type: 'array', items: { type: 'string' } },
+                        created_by: { type: 'string' },
                     },
-                    required: ['file_path'],
+                    required: ['action'],
                 },
             },
             {
-                name: 'add_constraint',
-                description: 'Add a constraint with priority level, optional layer assignment, and tags. Categories: performance, architecture, security. Auto-registers category and agent.',
+                name: 'message',
+                description: 'Agent messaging (actions: send, get, mark_read, send_batch)',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        category: {
-                            type: 'string',
-                            description: 'Constraint category',
-                            enum: ['performance', 'architecture', 'security'],
-                        },
-                        constraint_text: {
-                            type: 'string',
-                            description: 'The constraint description/requirement',
-                        },
-                        priority: {
-                            type: 'string',
-                            description: 'Priority level (defaults to "medium")',
-                            enum: ['low', 'medium', 'high', 'critical'],
-                            default: 'medium',
-                        },
-                        layer: {
-                            type: 'string',
-                            description: 'Optional architecture layer assignment',
-                            enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'],
-                        },
-                        tags: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: 'Optional tags for categorization (e.g., ["api", "security"])',
-                        },
-                        created_by: {
-                            type: 'string',
-                            description: 'Agent creating the constraint (defaults to "system")',
-                        },
+                        action: { type: 'string', description: 'Action (use "help" for usage)', enum: ['send', 'get', 'mark_read', 'send_batch', 'help'] },
+                        agent_name: { type: 'string' },
+                        from_agent: { type: 'string' },
+                        to_agent: { type: ['string', 'null'] },
+                        msg_type: { type: 'string', enum: ['decision', 'warning', 'request', 'info'] },
+                        message: { type: 'string' },
+                        priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'], default: 'medium' },
+                        payload: { type: 'object' },
+                        message_ids: { type: 'array', items: { type: 'number' } },
+                        unread_only: { type: 'boolean', default: false },
+                        msg_type_filter: { type: 'string', enum: ['decision', 'warning', 'request', 'info'] },
+                        priority_filter: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
+                        limit: { type: 'number', default: 50 },
+                        // send_batch parameters
+                        messages: { type: 'array', description: 'Array of messages for batch operation (max: 50)' },
+                        atomic: { type: 'boolean', description: 'Atomic mode - all succeed or all fail (default: true)' },
                     },
-                    required: ['category', 'constraint_text'],
+                    required: ['action'],
                 },
             },
             {
-                name: 'get_constraints',
-                description: 'Retrieve constraints with advanced filtering. Supports filtering by category, layer, priority, tags, and active status. Uses token-efficient view with all metadata.',
+                name: 'file',
+                description: 'File change tracking (actions: record, get, check_lock, record_batch)',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        category: {
-                            type: 'string',
-                            description: 'Filter by constraint category',
-                            enum: ['performance', 'architecture', 'security'],
-                        },
-                        layer: {
-                            type: 'string',
-                            description: 'Filter by architecture layer',
-                            enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'],
-                        },
-                        priority: {
-                            type: 'string',
-                            description: 'Filter by priority level',
-                            enum: ['low', 'medium', 'high', 'critical'],
-                        },
-                        tags: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: 'Filter by tags (OR logic - matches ANY tag)',
-                        },
-                        active_only: {
-                            type: 'boolean',
-                            description: 'Only return active constraints (defaults to true)',
-                            default: true,
-                        },
-                        limit: {
-                            type: 'number',
-                            description: 'Maximum number of constraints to return (default: 50)',
-                            default: 50,
-                        },
+                        action: { type: 'string', description: 'Action (use "help" for usage)', enum: ['record', 'get', 'check_lock', 'record_batch', 'help'] },
+                        file_path: { type: 'string' },
+                        agent_name: { type: 'string' },
+                        change_type: { type: 'string', enum: ['created', 'modified', 'deleted'] },
+                        layer: { type: 'string', enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'] },
+                        description: { type: 'string' },
+                        since: { type: 'string' },
+                        limit: { type: 'number' },
+                        lock_duration: { type: 'number' },
+                        // record_batch parameters
+                        file_changes: { type: 'array', description: 'Array of file changes for batch operation (max: 50)' },
+                        atomic: { type: 'boolean', description: 'Atomic mode - all succeed or all fail (default: true)' },
                     },
+                    required: ['action'],
                 },
             },
             {
-                name: 'deactivate_constraint',
-                description: 'Deactivate a constraint (soft delete). Idempotent - deactivating already-inactive constraint is safe. Constraints are never removed from database.',
+                name: 'constraint',
+                description: 'Constraint management (actions: add, get, deactivate)',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        constraint_id: {
-                            type: 'number',
-                            description: 'The constraint ID to deactivate',
-                        },
+                        action: { type: 'string', description: 'Action (use "help" for usage)', enum: ['add', 'get', 'deactivate', 'help'] },
+                        constraint_id: { type: 'number' },
+                        category: { type: 'string', enum: ['performance', 'architecture', 'security'] },
+                        constraint_text: { type: 'string' },
+                        priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'], default: 'medium' },
+                        layer: { type: 'string', enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'] },
+                        tags: { type: 'array', items: { type: 'string' } },
+                        created_by: { type: 'string' },
+                        active_only: { type: 'boolean', default: true },
+                        limit: { type: 'number', default: 50 },
                     },
-                    required: ['constraint_id'],
-                },
-            },
-            {
-                name: 'get_layer_summary',
-                description: 'Get summary statistics for all architecture layers. Returns decision counts, recent file changes (last 1 hour), and active constraints per layer.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {},
+                    required: ['action'],
                 },
             },
             {
-                name: 'clear_old_data',
-                description: 'Manually clear old data from the database. Deletes messages older than specified hours and file changes older than specified days. Transaction-safe operation that returns counts of deleted records.',
+                name: 'stats',
+                description: 'Statistics and data cleanup (actions: layer_summary, db_stats, clear, activity_log)',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        messages_older_than_hours: {
-                            type: 'number',
-                            description: 'Delete messages older than this many hours (default: 24)',
-                            default: 24,
-                        },
-                        file_changes_older_than_days: {
-                            type: 'number',
-                            description: 'Delete file changes older than this many days (default: 7)',
-                            default: 7,
-                        },
+                        action: { type: 'string', description: 'Action (use "help" for usage)', enum: ['layer_summary', 'db_stats', 'clear', 'activity_log', 'help'] },
+                        messages_older_than_hours: { type: 'number' },
+                        file_changes_older_than_days: { type: 'number' },
+                        since: { type: 'string', description: 'Time filter (e.g., "5m", "1h", "2d" or ISO timestamp)' },
+                        agent_names: { type: 'array', items: { type: 'string' }, description: 'Filter by agents' },
+                        actions: { type: 'array', items: { type: 'string' }, description: 'Filter by action types' },
+                        limit: { type: 'number', description: 'Max results (default: 100)' },
                     },
+                    required: ['action'],
                 },
             },
             {
-                name: 'get_stats',
-                description: 'Get comprehensive database statistics including counts for all major tables, active vs total records for decisions and constraints, and overall database health metrics.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {},
-                },
-            },
-            {
-                name: 'get_config',
-                description: 'Get current auto-deletion configuration settings. Returns weekend-awareness flag, message retention hours, and file history retention days.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {},
-                },
-            },
-            {
-                name: 'update_config',
-                description: 'Update auto-deletion configuration settings. All parameters are optional. Changes take effect immediately for subsequent cleanup operations.',
+                name: 'config',
+                description: 'Auto-deletion config (actions: get, update)',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        ignoreWeekend: {
-                            type: 'boolean',
-                            description: 'Whether to skip weekends when calculating retention periods (true = skip weekends)',
-                        },
-                        messageRetentionHours: {
-                            type: 'number',
-                            description: 'Number of hours to retain messages (1-168 hours)',
-                            minimum: 1,
-                            maximum: 168,
-                        },
-                        fileHistoryRetentionDays: {
-                            type: 'number',
-                            description: 'Number of days to retain file change history (1-90 days)',
-                            minimum: 1,
-                            maximum: 90,
-                        },
+                        action: { type: 'string', description: 'Action (use "help" for usage)', enum: ['get', 'update', 'help'] },
+                        ignoreWeekend: { type: 'boolean' },
+                        messageRetentionHours: { type: 'number', minimum: 1, maximum: 168 },
+                        fileHistoryRetentionDays: { type: 'number', minimum: 1, maximum: 90 },
                     },
+                    required: ['action'],
                 },
             },
         ],
@@ -599,258 +244,279 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 // Handle tool execution
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
+    const params = args;
     try {
+        let result;
         switch (name) {
-            case 'set_decision': {
-                const params = args;
-                const result = setDecision(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'get_context': {
-                const params = args;
-                const result = getContext(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'get_decision': {
-                const params = args;
-                const result = getDecision(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'search_by_tags': {
-                const params = args;
-                const result = searchByTags(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'get_versions': {
-                const params = args;
-                const result = getVersions(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'search_by_layer': {
-                const params = args;
-                const result = searchByLayer(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'send_message': {
-                const params = args;
-                const result = sendMessage(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'get_messages': {
-                const params = args;
-                const result = getMessages(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'mark_read': {
-                const params = args;
-                const result = markRead(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'record_file_change': {
-                const params = args;
-                const result = recordFileChange(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'get_file_changes': {
-                const params = args;
-                const result = getFileChanges(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'check_file_lock': {
-                const params = args;
-                const result = checkFileLock(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'add_constraint': {
-                const params = args;
-                const result = addConstraint(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'get_constraints': {
-                const params = args;
-                const result = getConstraints(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'deactivate_constraint': {
-                const params = args;
-                const result = deactivateConstraint(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'get_layer_summary': {
-                const result = getLayerSummary();
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'clear_old_data': {
-                const params = args;
-                const result = clearOldData(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'get_stats': {
-                const result = getStats();
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'get_config': {
-                const result = getConfig();
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'update_config': {
-                const params = args;
-                const result = updateConfig(params);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
+            case 'decision':
+                switch (params.action) {
+                    case 'set':
+                        result = setDecision(params);
+                        break;
+                    case 'get':
+                        result = getDecision(params);
+                        break;
+                    case 'list':
+                        result = getContext(params);
+                        break;
+                    case 'search_tags':
+                        result = searchByTags({ tags: params.tags, match_mode: params.tag_match, status: params.status, layer: params.layer });
+                        break;
+                    case 'search_layer':
+                        result = searchByLayer({ layer: params.layer, status: params.status, include_tags: params.include_tags });
+                        break;
+                    case 'versions':
+                        result = getVersions(params);
+                        break;
+                    case 'quick_set':
+                        result = quickSetDecision(params);
+                        break;
+                    case 'search_advanced':
+                        result = searchAdvanced({
+                            layers: params.layers,
+                            tags_all: params.tags_all,
+                            tags_any: params.tags_any,
+                            exclude_tags: params.exclude_tags,
+                            scopes: params.scopes,
+                            updated_after: params.updated_after,
+                            updated_before: params.updated_before,
+                            decided_by: params.decided_by,
+                            statuses: params.statuses,
+                            search_text: params.search_text,
+                            sort_by: params.sort_by,
+                            sort_order: params.sort_order,
+                            limit: params.limit,
+                            offset: params.offset
+                        });
+                        break;
+                    case 'set_batch':
+                        result = setDecisionBatch({ decisions: params.decisions, atomic: params.atomic });
+                        break;
+                    case 'has_updates':
+                        result = hasUpdates({ agent_name: params.agent_name, since_timestamp: params.since_timestamp });
+                        break;
+                    case 'set_from_template':
+                        result = setFromTemplate(params);
+                        break;
+                    case 'create_template':
+                        result = createTemplate(params);
+                        break;
+                    case 'list_templates':
+                        result = listTemplates(params);
+                        break;
+                    case 'help':
+                        result = {
+                            tool: 'decision',
+                            description: 'Manage decisions with metadata (tags, layers, versions, scopes)',
+                            actions: {
+                                set: 'Set/update a decision. Params: key (required), value (required), agent, layer, version, status, tags, scopes',
+                                get: 'Get specific decision by key. Params: key (required)',
+                                list: 'List/filter decisions. Params: status, layer, tags, scope, tag_match',
+                                search_tags: 'Search decisions by tags. Params: tags (required), match_mode, status, layer',
+                                search_layer: 'Search decisions by layer. Params: layer (required), status, include_tags',
+                                versions: 'Get version history for a decision. Params: key (required)',
+                                quick_set: 'Quick set with smart defaults (FR-002). Params: key (required), value (required), agent, layer, version, status, tags, scopes. Auto-infers layer from key prefix (api/*→presentation, db/*→data, service/*→business, config/*→infrastructure), tags from key hierarchy, scope from parent path. Defaults: status=active, version=1.0.0. All inferred fields can be overridden.',
+                                search_advanced: 'Advanced query with complex filtering (FR-004). Params: layers (OR), tags_all (AND), tags_any (OR), exclude_tags, scopes (wildcards), updated_after/before (ISO or relative like "7d"), decided_by, statuses, search_text, sort_by (updated/key/version), sort_order (asc/desc), limit (default:20, max:1000), offset (default:0). Returns decisions with total_count for pagination. All filters use parameterized queries (SQL injection protection).',
+                                set_batch: 'Batch set decisions (FR-005). Params: decisions (required, array of SetDecisionParams, max: 50), atomic (default: true). Returns: {success, inserted, failed, results}. Atomic mode: all succeed or all fail (transaction). Non-atomic mode: process all, return individual results. 52% token reduction vs individual calls.',
+                                has_updates: 'Check for updates since timestamp (FR-003 Phase A - Lightweight Polling). Params: agent_name (required), since_timestamp (required, ISO 8601 format like "2025-10-14T08:00:00Z"). Returns: {has_updates: boolean, counts: {decisions: N, messages: N, files: N}}. Token cost: ~5-10 tokens per check. Uses COUNT queries on t_decisions, t_agent_messages, t_file_changes with timestamp filtering. Enables efficient polling without full data retrieval.',
+                                set_from_template: 'Set decision using template (FR-006). Params: template (required, template name), key (required), value (required), agent, layer (override), version, status (override), tags (override), scopes, plus any template-required fields. Applies template defaults (layer, status, tags) while allowing overrides. Validates required fields if specified by template. Returns: {success, key, key_id, version, template_used, applied_defaults, message}. Built-in templates: breaking_change, security_vulnerability, performance_optimization, deprecation, architecture_decision.',
+                                create_template: 'Create new decision template (FR-006). Params: name (required, unique), defaults (required, object with layer/status/tags/priority), required_fields (optional, array of field names), created_by (optional, agent name). Returns: {success, template_id, template_name, message}. Example defaults: {"layer":"business","status":"active","tags":["breaking"]}. Validates layer/status values.',
+                                list_templates: 'List all decision templates (FR-006). No params required. Returns: {templates: [{id, name, defaults, required_fields, created_by, created_at}], count}. Shows both built-in and custom templates.'
+                            },
+                            examples: {
+                                set: '{ action: "set", key: "auth_method", value: "jwt", tags: ["security"] }',
+                                get: '{ action: "get", key: "auth_method" }',
+                                list: '{ action: "list", status: "active", layer: "infrastructure" }',
+                                search_tags: '{ action: "search_tags", tags: ["security", "api"] }',
+                                quick_set: '{ action: "quick_set", key: "api/instruments/oscillator-refactor", value: "Moved oscillator_type to MonophonicSynthConfig" }',
+                                search_advanced: '{ action: "search_advanced", layers: ["business", "data"], tags_all: ["breaking", "v0.3.3"], tags_any: ["api", "synthesis"], exclude_tags: ["deprecated"], scopes: ["api/instruments/*"], updated_after: "2025-10-01", statuses: ["active", "draft"], search_text: "oscillator", sort_by: "updated", sort_order: "desc", limit: 20, offset: 0 }',
+                                set_batch: '{ action: "set_batch", decisions: [{"key": "feat-1", "value": "...", "layer": "business"}, {"key": "feat-2", "value": "...", "layer": "data"}], atomic: true }',
+                                has_updates: '{ action: "has_updates", agent_name: "my-agent", since_timestamp: "2025-10-14T08:00:00Z" }',
+                                set_from_template: '{ action: "set_from_template", template: "breaking_change", key: "oscillator-type-moved", value: "oscillator_type moved to MonophonicSynthConfig" }',
+                                create_template: '{ action: "create_template", name: "bug_fix", defaults: {"layer":"business","tags":["bug","fix"],"status":"active"}, created_by: "my-agent" }',
+                                list_templates: '{ action: "list_templates" }'
+                            }
+                        };
+                        break;
+                    default: throw new Error(`Unknown action: ${params.action}`);
+                }
+                break;
+            case 'message':
+                switch (params.action) {
+                    case 'send':
+                        result = sendMessage(params);
+                        break;
+                    case 'get':
+                        result = getMessages(params);
+                        break;
+                    case 'mark_read':
+                        result = markRead(params);
+                        break;
+                    case 'send_batch':
+                        result = sendMessageBatch({ messages: params.messages, atomic: params.atomic });
+                        break;
+                    case 'help':
+                        result = {
+                            tool: 'message',
+                            description: 'Send and retrieve messages between agents with priority levels',
+                            actions: {
+                                send: 'Send message. Params: from_agent (required), msg_type (required), message (required), to_agent, priority, payload',
+                                get: 'Get messages for agent. Params: agent_name (required), unread_only, priority_filter, msg_type_filter, limit',
+                                mark_read: 'Mark messages as read. Params: agent_name (required), message_ids (required)',
+                                send_batch: 'Batch send messages (FR-005). Params: messages (required, array of SendMessageParams, max: 50), atomic (default: true). Returns: {success, inserted, failed, results}. Atomic mode: all succeed or all fail (transaction). Non-atomic mode: process all, return individual results. 52% token reduction vs individual calls.'
+                            },
+                            examples: {
+                                send: '{ action: "send", from_agent: "bot1", msg_type: "info", message: "Task complete", priority: "high" }',
+                                get: '{ action: "get", agent_name: "bot1", unread_only: true }',
+                                mark_read: '{ action: "mark_read", agent_name: "bot1", message_ids: [1, 2, 3] }',
+                                send_batch: '{ action: "send_batch", messages: [{"from_agent": "bot1", "msg_type": "info", "message": "Task 1 done"}, {"from_agent": "bot1", "msg_type": "info", "message": "Task 2 done"}], atomic: true }'
+                            }
+                        };
+                        break;
+                    default: throw new Error(`Unknown action: ${params.action}`);
+                }
+                break;
+            case 'file':
+                switch (params.action) {
+                    case 'record':
+                        result = recordFileChange(params);
+                        break;
+                    case 'get':
+                        result = getFileChanges(params);
+                        break;
+                    case 'check_lock':
+                        result = checkFileLock(params);
+                        break;
+                    case 'record_batch':
+                        result = recordFileChangeBatch({ file_changes: params.file_changes, atomic: params.atomic });
+                        break;
+                    case 'help':
+                        result = {
+                            tool: 'file',
+                            description: 'Track file changes across agents with layer classification',
+                            actions: {
+                                record: 'Record file change. Params: file_path (required), agent_name (required), change_type (required), layer, description',
+                                get: 'Get file changes. Params: file_path, agent_name, layer, change_type, since, limit',
+                                check_lock: 'Check if file locked. Params: file_path (required), lock_duration',
+                                record_batch: 'Batch record file changes (FR-005). Params: file_changes (required, array of RecordFileChangeParams, max: 50), atomic (default: true). Returns: {success, inserted, failed, results}. Atomic mode: all succeed or all fail (transaction). Non-atomic mode: process all, return individual results. 52% token reduction vs individual calls.'
+                            },
+                            examples: {
+                                record: '{ action: "record", file_path: "src/index.ts", agent_name: "refactor-bot", change_type: "modified", layer: "infrastructure" }',
+                                get: '{ action: "get", agent_name: "refactor-bot", layer: "infrastructure", limit: 10 }',
+                                check_lock: '{ action: "check_lock", file_path: "src/index.ts", lock_duration: 300 }',
+                                record_batch: '{ action: "record_batch", file_changes: [{"file_path": "src/types.ts", "agent_name": "bot1", "change_type": "modified", "layer": "data"}, {"file_path": "src/index.ts", "agent_name": "bot1", "change_type": "modified", "layer": "infrastructure"}], atomic: true }'
+                            }
+                        };
+                        break;
+                    default: throw new Error(`Unknown action: ${params.action}`);
+                }
+                break;
+            case 'constraint':
+                switch (params.action) {
+                    case 'add':
+                        result = addConstraint(params);
+                        break;
+                    case 'get':
+                        result = getConstraints(params);
+                        break;
+                    case 'deactivate':
+                        result = deactivateConstraint(params);
+                        break;
+                    case 'help':
+                        result = {
+                            tool: 'constraint',
+                            description: 'Manage project constraints (performance, architecture, security)',
+                            actions: {
+                                add: 'Add constraint. Params: category (required), constraint_text (required), priority, layer, tags, created_by',
+                                get: 'Get constraints. Params: category, layer, priority, tags, active_only, limit',
+                                deactivate: 'Deactivate constraint. Params: constraint_id (required)'
+                            },
+                            examples: {
+                                add: '{ action: "add", category: "performance", constraint_text: "API response time <100ms", priority: "high", tags: ["api"] }',
+                                get: '{ action: "get", category: "performance", active_only: true }',
+                                deactivate: '{ action: "deactivate", constraint_id: 5 }'
+                            }
+                        };
+                        break;
+                    default: throw new Error(`Unknown action: ${params.action}`);
+                }
+                break;
+            case 'stats':
+                switch (params.action) {
+                    case 'layer_summary':
+                        result = getLayerSummary();
+                        break;
+                    case 'db_stats':
+                        result = getStats();
+                        break;
+                    case 'clear':
+                        result = clearOldData(params);
+                        break;
+                    case 'activity_log':
+                        result = getActivityLog({
+                            since: params.since,
+                            agent_names: params.agent_names,
+                            actions: params.actions,
+                            limit: params.limit,
+                        });
+                        break;
+                    case 'help':
+                        result = {
+                            tool: 'stats',
+                            description: 'View database statistics, activity logs, and manage data cleanup',
+                            actions: {
+                                layer_summary: 'Get summary by layer. No params required',
+                                db_stats: 'Get database statistics. No params required',
+                                clear: 'Clear old data. Params: messages_older_than_hours, file_changes_older_than_days',
+                                activity_log: 'Get activity log (v3.0.0). Params: since (e.g., "5m", "1h", "2d"), agent_names (array or ["*"]), actions (filter by action types), limit (default: 100)'
+                            },
+                            examples: {
+                                layer_summary: '{ action: "layer_summary" }',
+                                db_stats: '{ action: "db_stats" }',
+                                clear: '{ action: "clear", messages_older_than_hours: 48, file_changes_older_than_days: 14 }',
+                                activity_log: '{ action: "activity_log", since: "1h", agent_names: ["bot1", "bot2"], limit: 50 }'
+                            }
+                        };
+                        break;
+                    default: throw new Error(`Unknown action: ${params.action}`);
+                }
+                break;
+            case 'config':
+                switch (params.action) {
+                    case 'get':
+                        result = getConfig();
+                        break;
+                    case 'update':
+                        result = updateConfig(params);
+                        break;
+                    case 'help':
+                        result = {
+                            tool: 'config',
+                            description: 'Manage auto-deletion configuration (weekend-aware retention)',
+                            actions: {
+                                get: 'Get current config. No params required',
+                                update: 'Update config. Params: ignoreWeekend, messageRetentionHours (1-168), fileHistoryRetentionDays (1-90)'
+                            },
+                            examples: {
+                                get: '{ action: "get" }',
+                                update: '{ action: "update", ignoreWeekend: true, messageRetentionHours: 48 }'
+                            }
+                        };
+                        break;
+                    default: throw new Error(`Unknown action: ${params.action}`);
+                }
+                break;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({ error: message }, null, 2),
-                },
-            ],
+            content: [{ type: 'text', text: JSON.stringify({ error: message }, null, 2) }],
             isError: true,
         };
     }