@dcyfr/ai 1.0.3 → 2.1.0

package/dist/ai/mcp/servers/delegation-monitor/index.js

@@ -0,0 +1,757 @@
+/**
+ * Delegation Monitor MCP Server
+ * TLP:CLEAR
+ *
+ * Provides AI assistants with delegation monitoring and management capabilities
+ * including event logging, reputation queries, task status, and manual escalation.
+ *
+ * Tools:
+ * - delegation:logEvent - Log delegation events to telemetry system
+ * - delegation:queryReputation - Query agent reputation scores and history
+ * - delegation:getTaskStatus - Check delegation contract execution status
+ * - delegation:triggerEscalation - Manual escalation for human review
+ * - delegation:querySessionsByMode - Query sessions filtered by execution mode (Phase 3)
+ * - delegation:getSessionHandoffHistory - Get handoff events for a session (Phase 3)
+ * - delegation:triggerSessionHandoff - Trigger an execution mode transition (Phase 3)
+ *
+ * Resources:
+ * - delegation://contracts/active - Active delegation contracts
+ * - delegation://reputation/top - Top-performing agents by reputation
+ * - delegation://events/recent - Recent delegation events
+ * - delegation://escalations/pending - Pending manual reviews
+ * - delegation://sessions/by-mode - Sessions grouped by execution mode (Phase 3)
+ *
+ * @module mcp/servers/delegation-monitor
+ * @version 1.1.0
+ * @date 2026-02-13
+ */
+import { FastMCP } from 'fastmcp';
+import { z } from 'zod';
+import { handleToolError, logToolExecution, MCPToolError, measurePerformance, } from '../shared/utils.js';
+// ============================================================================
+// Authentication
+// ============================================================================
+/**
+ * Validates a bearer token for write operations.
+ * If DELEGATION_MCP_WRITE_TOKEN is set, the provided token must match.
+ * If the env var is unset (dev mode), all writes are permitted.
+ *
+ * @throws MCPToolError with code UNAUTHORIZED if validation fails
+ */
+export function validateWriteToken(token) {
+    const expectedToken = process.env['DELEGATION_MCP_WRITE_TOKEN'];
+    if (!expectedToken) {
+        // Dev/unprotected mode — allow all writes
+        return;
+    }
+    if (!token) {
+        throw new MCPToolError('UNAUTHORIZED', 'Write operations require a bearer token. Provide authToken in the request.');
+    }
+    if (token !== expectedToken) {
+        throw new MCPToolError('UNAUTHORIZED', 'Invalid bearer token for write operation.');
+    }
+}
+// Temporary: Use stub implementations until we wire up actual instances
+// TODO: Inject real ContractManager and ReputationEngine from main module exports
+class StubContractManager {
+    contracts = new Map();
+    queryContracts(query) {
+        return Array.from(this.contracts.values());
+    }
+    getContract(id) {
+        return this.contracts.get(id);
+    }
+    updateContract(id, update) {
+        const contract = this.contracts.get(id);
+        if (contract) {
+            Object.assign(contract, update);
+            this.contracts.set(id, contract);
+        }
+        return Promise.resolve(contract);
+    }
+    getStats() {
+        return { total_contracts: this.contracts.size };
+    }
+    /**
+     * Query contracts filtered by execution mode (stored in metadata).
+     * Phase 3.1: Returns contracts whose metadata.execution_mode matches.
+     */
+    querySessionsByMode(mode) {
+        return Array.from(this.contracts.values()).filter((c) => {
+            try {
+                const meta = typeof c.metadata === 'string' ? JSON.parse(c.metadata) : (c.metadata ?? {});
+                return (meta.execution_mode ?? 'interactive') === mode;
+            }
+            catch {
+                return mode === 'interactive'; // default
+            }
+        });
+    }
+    /**
+     * Get handoff history entries for a given session ID.
+     * Phase 3.6: Searches contracts for parent_contract_id chain.
+     */
+    getSessionHandoffHistory(sessionId) {
+        // In the stub implementation, return an empty history.
+        // Real implementation would trace the parent_contract_id chain.
+        return Array.from(this.contracts.values())
+            .filter((c) => {
+            try {
+                const meta = typeof c.metadata === 'string' ? JSON.parse(c.metadata) : (c.metadata ?? {});
+                return meta.session_id === sessionId;
+            }
+            catch {
+                return false;
+            }
+        })
+            .map((c) => ({
+            contractId: c.contract_id ?? c.id,
+            executionMode: (() => {
+                try {
+                    const meta = typeof c.metadata === 'string' ? JSON.parse(c.metadata) : (c.metadata ?? {});
+                    return meta.execution_mode ?? 'interactive';
+                }
+                catch {
+                    return 'interactive';
+                }
+            })(),
+            status: c.status,
+            createdAt: c.created_at,
+            parentContractId: c.parent_contract_id,
+        }));
+    }
+    /**
+     * Trigger a session handoff (stub — returns a synthetic new contract).
+     * Phase 3.6: Real implementation calls DelegationContractManager.handoffSession().
+     */
+    async triggerSessionHandoff(request) {
+        const source = this.contracts.get(request.fromContractId);
+        if (!source) {
+            throw new Error(`Contract not found: ${request.fromContractId}`);
+        }
+        const newContract = {
+            ...source,
+            contract_id: `${request.fromContractId}-handoff-${Date.now()}`,
+            parent_contract_id: request.fromContractId,
+            metadata: JSON.stringify({
+                ...((() => { try {
+                    return JSON.parse(source.metadata ?? '{}');
+                }
+                catch {
+                    return {};
+                } })()),
+                execution_mode: request.toExecutionMode,
+                handoff_reason: request.handoffReason,
+                handed_off_at: new Date().toISOString(),
+            }),
+            created_at: new Date().toISOString(),
+            status: 'active',
+        };
+        this.contracts.set(newContract.contract_id, newContract);
+        return newContract;
+    }
+}
+class StubReputationEngine {
+    profiles = new Map();
+    queryProfiles(query) {
+        return Array.from(this.profiles.values());
+    }
+    getProfile(agentId) {
+        return this.profiles.get(agentId);
+    }
+    getStats() {
+        return { total_profiles: this.profiles.size };
+    }
+}
+class StubTelemetryEngine {
+    async trackEvent(event) {
+        console.log('[Telemetry]', event);
+    }
+}
+// ============================================================================
+// Server Configuration
+// ============================================================================
+const server = new FastMCP({
+    name: 'dcyfr-delegation-monitor',
+    version: '1.0.0',
+    instructions: 'Provides delegation monitoring and management tools for tracking contracts, reputation, events, and escalations. Use these tools to monitor delegation chains, query agent performance, and trigger manual reviews when needed.',
+});
+// Initialize delegation infrastructure
+// Initialize delegation infrastructure (using stubs until proper wiring)
+const contractManager = new StubContractManager();
+const reputationEngine = new StubReputationEngine();
+const telemetryEngine = new StubTelemetryEngine();
+// ============================================================================
+// Tool 1: Log Delegation Event
+// ============================================================================
+server.addTool({
+    name: 'delegation:logEvent',
+    description: 'Log a delegation event to the telemetry system. Use this to track contract lifecycle events, performance metrics, and delegation chain activities. Requires bearer token authentication (authToken).',
+    parameters: z.object({
+        authToken: z.string().optional().describe('Bearer token for write authorization'),
+        eventType: z
+            .enum([
+            'delegation_contract_created',
+            'delegation_progress',
+            'delegation_completed',
+            'delegation_failed',
+            'delegation_firebreak_triggered',
+        ])
+            .describe('Type of delegation event'),
+        contractId: z.string().describe('Delegation contract identifier'),
+        agentId: z.string().optional().describe('Agent involved in the event'),
+        metadata: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe('Additional event metadata (JSON object)'),
+    }),
+    annotations: {
+        readOnlyHint: false,
+        openWorldHint: false,
+    },
+    execute: async (args, { log }) => {
+        try {
+            validateWriteToken(args.authToken);
+            const { result, durationMs } = await measurePerformance(async () => {
+                // Create simple delegation event (telemetry API not yet fully implemented)
+                const event_id = `evt_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+                // Get contract if exists
+                const contract = contractManager.getContract(args.contractId);
+                // Note: Actual telemetry.trackEvent() or similar method would be called here
+                // For now, we just return success confirmation
+                return {
+                    success: true,
+                    event_id,
+                    event_type: args.eventType,
+                    contract_id: args.contractId,
+                    contract_status: contract?.status || 'unknown',
+                    timestamp: new Date().toISOString(),
+                    message: `Event logged successfully (telemetry integration pending)`,
+                };
+            }, 'logDelegationEvent');
+            logToolExecution('delegation:logEvent', args, true, durationMs);
+            return JSON.stringify(result, null, 2);
+        }
+        catch (error) {
+            logToolExecution('delegation:logEvent', args, false);
+            return handleToolError(error);
+        }
+    },
+});
+// ============================================================================
+// Tool 2: Query Reputation
+// ============================================================================
+server.addTool({
+    name: 'delegation:queryReputation',
+    description: 'Query agent reputation scores and history. Returns multi-dimensional scores (reliability, speed, quality, security), overall score, task completion history, and confidence level.',
+    parameters: z.object({
+        agentId: z.string().optional().describe('Specific agent ID to query'),
+        minScore: z.number().min(0).max(1).optional().describe('Minimum overall score filter'),
+        minTasksCompleted: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe('Minimum number of completed tasks'),
+        dimension: z
+            .enum(['reliability', 'speed', 'quality', 'security'])
+            .optional()
+            .describe('Filter by specific dimension'),
+        limit: z.number().int().min(1).max(100).optional().default(10).describe('Maximum results'),
+    }),
+    annotations: {
+        readOnlyHint: true,
+        openWorldHint: false,
+    },
+    execute: async (args, { log }) => {
+        try {
+            const { result, durationMs } = await measurePerformance(async () => {
+                if (args.agentId) {
+                    // Query specific agent
+                    const profile = reputationEngine.getProfile(args.agentId);
+                    return {
+                        agent_id: profile.agent_id,
+                        overall_score: profile.overall_score,
+                        dimensions: profile.dimensions,
+                        tasks_completed: profile.tasks_completed,
+                        consecutive_successes: profile.consecutive_successes,
+                        consecutive_failures: profile.consecutive_failures,
+                        confidence: profile.confidence,
+                        specializations: profile.specializations || [],
+                        last_updated: profile.last_updated,
+                    };
+                }
+                else {
+                    // Query with filters
+                    const query = {
+                        limit: args.limit,
+                        sort_by: 'overall_score',
+                        sort_order: 'desc',
+                    };
+                    if (args.minScore !== undefined) {
+                        query.min_score = args.minScore;
+                    }
+                    if (args.minTasksCompleted !== undefined) {
+                        query.min_tasks_completed = args.minTasksCompleted;
+                    }
+                    if (args.dimension) {
+                        // Filter by specific dimension score
+                        // Use minScore as threshold for that dimension
+                        query.min_dimension_score = {
+                            dimension: args.dimension,
+                            score: args.minScore || 0.5,
+                        };
+                    }
+                    const profiles = reputationEngine.queryProfiles(query);
+                    return {
+                        total_results: profiles.length,
+                        profiles: profiles.map((p) => ({
+                            agent_id: p.agent_id,
+                            overall_score: p.overall_score,
+                            dimensions: p.dimensions,
+                            tasks_completed: p.tasks_completed,
+                            confidence: p.confidence,
+                            last_updated: p.last_updated,
+                        })),
+                        query_params: args,
+                    };
+                }
+            }, 'queryReputation');
+            logToolExecution('delegation:queryReputation', args, true, durationMs);
+            return JSON.stringify(result, null, 2);
+        }
+        catch (error) {
+            logToolExecution('delegation:queryReputation', args, false);
+            return handleToolError(error);
+        }
+    },
+});
+// ============================================================================
+// Tool 3: Get Task Status
+// ============================================================================
+server.addTool({
+    name: 'delegation:getTaskStatus',
+    description: 'Check the status of a delegation contract including execution progress, verification results, and performance metrics. Use this to monitor ongoing delegations and check completion status.',
+    parameters: z.object({
+        contractId: z.string().describe('Delegation contract identifier'),
+        includeHistory: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe('Include full event history'),
+    }),
+    annotations: {
+        readOnlyHint: true,
+        openWorldHint: false,
+    },
+    execute: async (args, { log }) => {
+        try {
+            const { result, durationMs } = await measurePerformance(async () => {
+                // Get contract from manager
+                const contract = contractManager.getContract(args.contractId);
+                if (!contract) {
+                    return {
+                        found: false,
+                        contract_id: args.contractId,
+                        message: 'Contract not found',
+                    };
+                }
+                // Build status response
+                const statusData = {
+                    found: true,
+                    contract_id: contract.contract_id,
+                    task_id: contract.task_id,
+                    status: contract.status,
+                    delegator: contract.delegator_agent_id,
+                    delegatee: contract.delegatee_agent_id,
+                    verification_policy: contract.verification_policy,
+                    tlp_classification: contract.tlp_classification,
+                    created_at: contract.created_at,
+                    timeout_ms: contract.timeout_ms,
+                };
+                // Add completion data if available
+                if (contract.completion) {
+                    statusData.completion = {
+                        completed_at: contract.completion.completed_at,
+                        success: contract.completion.success,
+                        execution_time_ms: contract.completion.metrics?.execution_time_ms,
+                        verification_passed: contract.completion.verification?.verified,
+                        verification_method: contract.completion.verification?.verification_method,
+                        quality_score: contract.completion.verification?.quality_score,
+                    };
+                    if (contract.completion.error) {
+                        statusData.completion.error = contract.completion.error;
+                    }
+                }
+                // Add event history if requested
+                if (args.includeHistory) {
+                    // Note: telemetryEngine.getContractEvents() not yet implemented
+                    // Would retrieve event history here
+                    statusData.event_history = [];
+                    statusData.event_history_note = 'Event history integration pending';
+                }
+                // Calculate time remaining if active
+                if (contract.status === 'active' && contract.timeout_ms) {
+                    const elapsed = Date.now() - new Date(contract.created_at).getTime();
+                    statusData.time_remaining_ms = Math.max(0, contract.timeout_ms - elapsed);
+                    statusData.progress_percent = Math.min(100, (elapsed / contract.timeout_ms) * 100);
+                }
+                return statusData;
+            }, 'getTaskStatus');
+            logToolExecution('delegation:getTaskStatus', args, true, durationMs);
+            return JSON.stringify(result, null, 2);
+        }
+        catch (error) {
+            logToolExecution('delegation:getTaskStatus', args, false);
+            return handleToolError(error);
+        }
+    },
+});
+// ============================================================================
+// Tool 4: Trigger Escalation
+// ============================================================================
+server.addTool({
+    name: 'delegation:triggerEscalation',
+    description: 'Manually escalate a delegation contract for human review. Use this when automated verification is insufficient or when manual_required verification policy is in effect. Creates an escalation ticket and marks contract for human attention. Requires bearer token authentication (authToken).',
+    parameters: z.object({
+        authToken: z.string().optional().describe('Bearer token for write authorization'),
+        contractId: z.string().describe('Delegation contract to escalate'),
+        reason: z.string().describe('Reason for escalation (human-readable)'),
+        priority: z
+            .enum(['low', 'medium', 'high', 'critical'])
+            .optional()
+            .default('medium')
+            .describe('Escalation priority level'),
+        requestedReviewer: z.string().optional().describe('Specific human reviewer to assign'),
+        additionalContext: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe('Additional context for reviewer'),
+    }),
+    annotations: {
+        readOnlyHint: false,
+        openWorldHint: false,
+    },
+    execute: async (args, { log }) => {
+        try {
+            validateWriteToken(args.authToken);
+            const { result, durationMs } = await measurePerformance(async () => {
+                // Get contract
+                const contract = contractManager.getContract(args.contractId);
+                if (!contract) {
+                    throw new Error(`Contract not found: ${args.contractId}`);
+                }
+                // Create escalation ticket
+                const escalation_id = `esc_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+                const escalationData = {
+                    escalation_id,
+                    contract_id: args.contractId,
+                    task_id: contract.task_id,
+                    reason: args.reason,
+                    priority: args.priority || 'medium',
+                    requested_reviewer: args.requestedReviewer,
+                    status: 'pending',
+                    created_at: new Date().toISOString(),
+                    contract_status: contract.status,
+                    delegatee: contract.delegatee_agent_id,
+                    verification_policy: contract.verification_policy,
+                    tlp_classification: contract.tlp_classification,
+                    additional_context: args.additionalContext || {},
+                };
+                // Log escalation event (telemetry integration pending)
+                // Note: Actual telemetry method would be called here once API is finalized
+                // Update contract metadata with escalation
+                await contractManager.updateContract(args.contractId, {
+                    metadata: {
+                        ...contract.metadata,
+                        escalation_id,
+                        escalated_at: new Date().toISOString(),
+                        escalation_reason: args.reason,
+                    },
+                });
+                return {
+                    success: true,
+                    escalation_id,
+                    contract_id: args.contractId,
+                    status: 'pending_review',
+                    priority: args.priority,
+                    message: 'Escalation created successfully',
+                    next_steps: [
+                        'Human reviewer will be notified',
+                        'Contract execution may be paused pending review',
+                        'Use delegation:getTaskStatus to check escalation status',
+                    ],
+                    escalation_details: escalationData,
+                };
+            }, 'triggerEscalation');
+            logToolExecution('delegation:triggerEscalation', args, true, durationMs);
+            return JSON.stringify(result, null, 2);
+        }
+        catch (error) {
+            logToolExecution('delegation:triggerEscalation', args, false);
+            return handleToolError(error);
+        }
+    },
+});
+// ============================================================================
+// Tool 5: Query Sessions By Mode (Phase 3)
+// ============================================================================
+server.addTool({
+    name: 'delegation:querySessionsByMode',
+    description: 'Query delegation sessions (contracts) filtered by execution mode (interactive, background, async). Returns session IDs, status, and metadata.',
+    parameters: z.object({
+        mode: z
+            .enum(['interactive', 'background', 'async'])
+            .describe('Execution mode to filter by'),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .default(20)
+            .describe('Maximum number of sessions to return'),
+    }),
+    async execute(args) {
+        const startTime = performance.now();
+        try {
+            const { mode, limit } = args;
+            const sessions = contractManager.querySessionsByMode(mode);
+            const limited = sessions.slice(0, limit);
+            const result = {
+                mode,
+                total_found: sessions.length,
+                returned: limited.length,
+                sessions: limited.map((c) => ({
+                    contract_id: c.contract_id ?? c.id,
+                    session_id: (() => {
+                        try {
+                            return JSON.parse(c.metadata ?? '{}').session_id ?? null;
+                        }
+                        catch {
+                            return null;
+                        }
+                    })(),
+                    status: c.status,
+                    task_id: c.task_id,
+                    delegatee: c.delegatee_agent_id ?? c.delegatee?.agent_id,
+                    created_at: c.created_at,
+                })),
+                generated_at: new Date().toISOString(),
+            };
+            const durationMs = Math.round(performance.now() - startTime);
+            logToolExecution('delegation:querySessionsByMode', args, true, durationMs);
+            return JSON.stringify(result, null, 2);
+        }
+        catch (error) {
+            logToolExecution('delegation:querySessionsByMode', args, false);
+            return handleToolError(error);
+        }
+    },
+});
+// ============================================================================
+// Tool 6: Get Session Handoff History (Phase 3)
+// ============================================================================
+server.addTool({
+    name: 'delegation:getSessionHandoffHistory',
+    description: 'Retrieve the execution mode handoff history for a delegation session. Returns the chain of contracts created by session handoffs.',
+    parameters: z.object({
+        sessionId: z
+            .string()
+            .min(1)
+            .describe('Session ID to retrieve handoff history for (stored in contract metadata)'),
+    }),
+    async execute(args) {
+        const startTime = performance.now();
+        try {
+            const { sessionId } = args;
+            const history = contractManager.getSessionHandoffHistory(sessionId);
+            const result = {
+                sessionId,
+                handoffCount: history.length,
+                history,
+                generated_at: new Date().toISOString(),
+            };
+            const durationMs = Math.round(performance.now() - startTime);
+            logToolExecution('delegation:getSessionHandoffHistory', args, true, durationMs);
+            return JSON.stringify(result, null, 2);
+        }
+        catch (error) {
+            logToolExecution('delegation:getSessionHandoffHistory', args, false);
+            return handleToolError(error);
+        }
+    },
+});
+// ============================================================================
+// Tool 7: Trigger Session Handoff (Phase 3)
+// ============================================================================
+server.addTool({
+    name: 'delegation:triggerSessionHandoff',
+    description: 'Trigger an execution mode transition for a delegation session. Creates a new contract in the target mode and archives the current one.',
+    parameters: z.object({
+        fromContractId: z
+            .string()
+            .min(1)
+            .describe('Contract ID of the session to hand off from'),
+        toExecutionMode: z
+            .enum(['interactive', 'background', 'async'])
+            .describe('Target execution mode for the new session'),
+        handoffReason: z
+            .string()
+            .min(5)
+            .describe('Human-readable reason for the handoff (min 5 chars)'),
+        authToken: z
+            .string()
+            .optional()
+            .describe('Bearer token for authentication (required unless DELEGATION_MCP_WRITE_TOKEN is unset)'),
+    }),
+    async execute(args) {
+        const startTime = performance.now();
+        try {
+            validateWriteToken(args.authToken);
+            const newContract = await contractManager.triggerSessionHandoff({
+                fromContractId: args.fromContractId,
+                toExecutionMode: args.toExecutionMode,
+                handoffReason: args.handoffReason,
+            });
+            const result = {
+                success: true,
+                handoff: {
+                    fromContractId: args.fromContractId,
+                    toContractId: newContract.contract_id,
+                    toExecutionMode: args.toExecutionMode,
+                    handoffReason: args.handoffReason,
+                    handedOffAt: new Date().toISOString(),
+                },
+                newContract: {
+                    contract_id: newContract.contract_id,
+                    status: newContract.status,
+                    task_id: newContract.task_id,
+                },
+            };
+            const durationMs = Math.round(performance.now() - startTime);
+            logToolExecution('delegation:triggerSessionHandoff', args, true, durationMs);
+            return JSON.stringify(result, null, 2);
+        }
+        catch (error) {
+            logToolExecution('delegation:triggerSessionHandoff', args, false);
+            return handleToolError(error);
+        }
+    },
+});
+// ============================================================================
+// Resource 1: Active Contracts
+// ============================================================================
+server.addResource({
+    uri: 'delegation://contracts/active',
+    name: 'Active Delegation Contracts',
+    description: 'List of currently active delegation contracts',
+    mimeType: 'application/json',
+    async load() {
+        try {
+            const activeContracts = contractManager.queryContracts({
+                status: ['active', 'pending'],
+                limit: 50,
+                sort_by: 'created_at',
+                sort_order: 'desc',
+            });
+            const summary = {
+                total_active: activeContracts.length,
+                contracts: activeContracts.map((c) => ({
+                    contract_id: c.contract_id,
+                    task_id: c.task_id,
+                    status: c.status,
+                    delegatee: c.delegatee?.agent_id || c.delegatee_agent_id,
+                    verification_policy: c.verification_policy,
+                    created_at: c.created_at,
+                    tlp: c.tlp_classification,
+                })),
+                generated_at: new Date().toISOString(),
+            };
+            return { text: JSON.stringify(summary, null, 2) };
+        }
+        catch (error) {
+            return { text: handleToolError(error) };
+        }
+    },
+});
+// ============================================================================
+// Resource 2: Top Performers
+// ============================================================================
+server.addResource({
+    uri: 'delegation://reputation/top',
+    name: 'Top Performing Agents',
+    description: 'Agents with highest reputation scores',
+    mimeType: 'application/json',
+    async load() {
+        try {
+            const topPerformers = reputationEngine.queryProfiles({
+                min_score: 0.7,
+                limit: 20,
+                sort_by: 'overall_score',
+                sort_order: 'desc',
+            });
+            const summary = {
+                total_count: topPerformers.length,
+                profiles: topPerformers.map((p) => ({
+                    agent_id: p.agent_id,
+                    overall_score: p.overall_score,
+                    dimensions: p.dimensions,
+                    tasks_completed: p.tasks_completed,
+                    confidence: p.confidence,
+                })),
+                generated_at: new Date().toISOString(),
+            };
+            return { text: JSON.stringify(summary, null, 2) };
+        }
+        catch (error) {
+            return { text: handleToolError(error) };
+        }
+    },
+});
+// ============================================================================
+// Resource 3: Sessions By Mode (Phase 3)
+// ============================================================================
+server.addResource({
+    uri: 'delegation://sessions/by-mode',
+    name: 'Sessions By Execution Mode',
+    description: 'Delegation sessions grouped by execution mode (interactive, background, async)',
+    mimeType: 'application/json',
+    async load() {
+        try {
+            const modes = ['interactive', 'background', 'async'];
+            const grouped = {};
+            for (const mode of modes) {
+                grouped[mode] = contractManager.querySessionsByMode(mode).map((c) => ({
+                    contract_id: c.contract_id ?? c.id,
+                    status: c.status,
+                    task_id: c.task_id,
+                    delegatee: c.delegatee_agent_id ?? c.delegatee?.agent_id,
+                    created_at: c.created_at,
+                }));
+            }
+            const summary = {
+                interactive: grouped['interactive'],
+                background: grouped['background'],
+                async: grouped['async'],
+                totals: {
+                    interactive: grouped['interactive']?.length ?? 0,
+                    background: grouped['background']?.length ?? 0,
+                    async: grouped['async']?.length ?? 0,
+                },
+                generated_at: new Date().toISOString(),
+            };
+            return { text: JSON.stringify(summary, null, 2) };
+        }
+        catch (error) {
+            return { text: handleToolError(error) };
+        }
+    },
+});
+// ============================================================================
+// Start Server
+// ============================================================================
+server.start({
+    transportType: 'stdio',
+});
+console.warn('✅ Delegation Monitor MCP Server started (stdio mode)');
+//# sourceMappingURL=index.js.map