@defai.digital/cli 13.4.5 → 13.4.8

package/dist/web/api.js

@@ -3,12 +3,45 @@
  *
  * Provides REST API endpoints for the web dashboard.
  * Wraps existing domain services to expose via HTTP.
+ *
+ * KNOWN PERFORMANCE ISSUE (INV-API-PERF-001):
+ * Several handlers use an N+1 query pattern where traces are fetched first,
+ * then events are fetched for each trace individually. This is acceptable for
+ * the local dashboard use case (typically < 200 traces), but would need
+ * refactoring for production scale. Consider batch fetching or pagination
+ * if performance becomes an issue.
+ *
+ * Affected handlers: handleStatus, handleProviderHistory, handleAgentHistory,
+ * handleTraces, handleWorkflowEvents, handleClassificationStats
  */
 import * as os from 'node:os';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { DATA_DIR_NAME, AGENTS_FILENAME, getErrorMessage } from '@defai.digital/contracts';
+// ============================================================================
+// INV-API-VAL-001: Input Validation Constants
+// ============================================================================
+/** Maximum length for any ID parameter to prevent DoS via long strings */
+const MAX_ID_LENGTH = 128;
+/** UUID v4 format regex for trace IDs */
+const UUID_REGEX = /^[a-f0-9]{8}-[a-f0-9]{4}-[4][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i;
+/**
+ * Validates a trace ID is a valid UUID and within length limits
+ * INV-API-VAL-001: Strict UUID validation for trace IDs
+ */
+function isValidTraceId(id) {
+    if (!id || id.length > MAX_ID_LENGTH)
+        return false;
+    return UUID_REGEX.test(id);
+}
+/**
+ * Validates a generic ID (workflow, agent, provider) is within length limits
+ * INV-API-VAL-001: Length validation for all IDs
+ */
+function isValidId(id) {
+    return typeof id === 'string' && id.length > 0 && id.length <= MAX_ID_LENGTH;
+}
 // Get the directory of this module (for finding bundled examples)
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -16,6 +49,7 @@ import { getProviderRegistry, getTraceStore, getSessionManager as getSharedSessi
 import { createPersistentAgentRegistry, } from '@defai.digital/agent-domain';
 import { createWorkflowLoader, findWorkflowDir, } from '@defai.digital/workflow-engine';
 import { CLI_VERSION } from '../commands/help.js';
+import { getProviderStatus as checkProviderHealth } from '../commands/status.js';
 // Workflow loader singleton
 let workflowLoader;
 let workflowLoaderPromise;
@@ -109,6 +143,16 @@ async function getAgentRegistry() {
     }
     return agentRegistryPromise;
 }
+/**
+ * Cached provider status (set at monitor startup)
+ */
+let cachedProviderStatus = null;
+/**
+ * Set the cached provider status (called from monitor.ts at startup)
+ */
+export function setCachedProviderStatus(providers) {
+    cachedProviderStatus = providers;
+}
 /**
  * Create the API handler function
  */
@@ -120,6 +164,7 @@ export function createAPIHandler() {
             let response;
             // Check for parameterized routes first
             const traceTreeMatch = apiPath.match(/^\/traces\/([a-f0-9-]+)\/tree$/i);
+            const traceClassificationMatch = apiPath.match(/^\/traces\/([a-f0-9-]+)\/classification$/i);
             const traceDetailMatch = apiPath.match(/^\/traces\/([a-f0-9-]+)$/i);
             const workflowDetailMatch = apiPath.match(/^\/workflows\/([a-z0-9-]+)$/i);
             const providerHistoryMatch = apiPath.match(/^\/providers\/([a-z0-9-]+)\/history$/i);
@@ -128,31 +173,37 @@ export function createAPIHandler() {
             const workflowEventsMatch = apiPath.match(/^\/workflows\/([a-z0-9-]+)\/events$/i);
             const traceSearchMatch = apiPath.match(/^\/traces\/search\?(.*)$/i) || apiPath.match(/^\/traces\/search$/i);
             // INV-TR-020 through INV-TR-024: Hierarchical trace tree endpoint
-            if (traceTreeMatch && traceTreeMatch[1]) {
+            // INV-API-VAL-001: Validate all IDs before processing
+            if (traceTreeMatch && isValidTraceId(traceTreeMatch[1])) {
                 const traceId = traceTreeMatch[1];
                 response = await handleTraceTree(traceId);
             }
-            else if (traceDetailMatch && traceDetailMatch[1]) {
+            else if (traceClassificationMatch && isValidTraceId(traceClassificationMatch[1])) {
+                // PRD-2026-003: Classification observability endpoint
+                const traceId = traceClassificationMatch[1];
+                response = await handleTraceClassification(traceId);
+            }
+            else if (traceDetailMatch && isValidTraceId(traceDetailMatch[1])) {
                 const traceId = traceDetailMatch[1];
                 response = await handleTraceDetail(traceId);
             }
-            else if (workflowDetailMatch && workflowDetailMatch[1]) {
+            else if (workflowDetailMatch && isValidId(workflowDetailMatch[1])) {
                 const workflowId = workflowDetailMatch[1];
                 response = await handleWorkflowDetail(workflowId);
             }
-            else if (providerHistoryMatch && providerHistoryMatch[1]) {
+            else if (providerHistoryMatch && isValidId(providerHistoryMatch[1])) {
                 const providerId = providerHistoryMatch[1];
                 response = await handleProviderHistory(providerId);
             }
-            else if (agentHistoryMatch && agentHistoryMatch[1]) {
+            else if (agentHistoryMatch && isValidId(agentHistoryMatch[1])) {
                 const agentId = agentHistoryMatch[1];
                 response = await handleAgentHistory(agentId);
             }
-            else if (agentDetailMatch && agentDetailMatch[1]) {
+            else if (agentDetailMatch && isValidId(agentDetailMatch[1])) {
                 const agentId = agentDetailMatch[1];
                 response = await handleAgentDetail(agentId);
             }
-            else if (workflowEventsMatch && workflowEventsMatch[1]) {
+            else if (workflowEventsMatch && isValidId(workflowEventsMatch[1])) {
                 const workflowId = workflowEventsMatch[1];
                 response = await handleWorkflowEvents(workflowId);
             }
@@ -187,6 +238,17 @@ export function createAPIHandler() {
                     case '/providers':
                         response = await handleProviders();
                         break;
+                    case '/providers/refresh':
+                        // POST endpoint to refresh provider health status
+                        if (req.method === 'POST') {
+                            response = await handleProviderRefresh();
+                        }
+                        else {
+                            res.writeHead(405, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ success: false, error: 'Method not allowed' }));
+                            return;
+                        }
+                        break;
                     case '/sessions':
                         response = await handleSessions();
                         break;
@@ -232,12 +294,13 @@ export function createAPIHandler() {
  * Get full system status
  */
 async function handleStatus() {
-    const [providers, sessions, agents, traces, metrics] = await Promise.all([
+    const [providers, sessions, agents, traces, metrics, classificationMetrics] = await Promise.all([
         getProviderData(),
         getSessionData(),
         getAgentData(),
         getTraceData(),
         getMetricsData(),
+        getClassificationMetrics(),
     ]);
     // Determine health status
     const healthyProviders = providers.filter(p => p.available).length;
@@ -256,6 +319,8 @@ async function handleStatus() {
             agents,
             traces,
             metrics,
+            // PRD-2026-003: Classification observability
+            classification: classificationMetrics,
         },
     };
 }
@@ -266,6 +331,50 @@ async function handleProviders() {
     const providers = await getProviderData();
     return { success: true, data: providers };
 }
+/**
+ * Helper to normalize circuit state for dashboard
+ */
+function normalizeCircuitState(state) {
+    if (state === 'halfOpen')
+        return 'half-open';
+    if (state === 'open')
+        return 'open';
+    return 'closed';
+}
+/**
+ * Refresh provider status by running actual health checks
+ * This triggers real LLM calls to test each provider
+ */
+async function handleProviderRefresh() {
+    try {
+        // Run real health checks (sends "hello" to each provider)
+        const providerStatuses = await checkProviderHealth(false);
+        // Convert to dashboard format and update cache
+        const dashboardProviders = providerStatuses.map(p => ({
+            providerId: p.providerId,
+            name: p.providerId,
+            available: p.available,
+            latencyMs: p.latencyMs,
+            circuitState: normalizeCircuitState(p.circuitState),
+            lastUsed: undefined,
+        }));
+        // Update the cached status
+        setCachedProviderStatus(dashboardProviders);
+        return {
+            success: true,
+            data: {
+                providers: dashboardProviders,
+                refreshedAt: new Date().toISOString(),
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: getErrorMessage(error, 'Failed to refresh provider status'),
+        };
+    }
+}
 /**
  * Get sessions
  */
@@ -310,37 +419,85 @@ async function handleAgentDetail(agentId) {
                     totalDurationMs += trace.durationMs;
             }
         }
+        // PRD-2026-004: Build response with all meta-agent fields
+        const responseData = {
+            agentId: agent.agentId,
+            displayName: agent.displayName ?? agent.agentId,
+            description: agent.description,
+            version: agent.version,
+            role: agent.role,
+            team: agent.team,
+            enabled: agent.enabled,
+            capabilities: agent.capabilities ?? [],
+            tags: agent.tags ?? [],
+            systemPrompt: agent.systemPrompt,
+            workflow: agent.workflow?.map(step => ({
+                stepId: step.stepId,
+                name: step.name,
+                type: step.type,
+                config: step.config,
+                dependencies: step.dependencies,
+                condition: step.condition,
+            })) ?? [],
+            orchestration: agent.orchestration,
+            personality: agent.personality,
+            expertise: agent.expertise,
+            // Stats
+            stats: {
+                executionCount,
+                successRate: executionCount > 0 ? successCount / executionCount : 0,
+                avgDurationMs: executionCount > 0 ? Math.round(totalDurationMs / executionCount) : 0,
+            },
+        };
+        // PRD-2026-004: Add meta-agent architecture fields
+        if (agent.metaAgent !== undefined)
+            responseData.metaAgent = agent.metaAgent;
+        if (agent.archetype !== undefined)
+            responseData.archetype = agent.archetype;
+        if (agent.orchestrates?.length)
+            responseData.orchestrates = agent.orchestrates;
+        if (agent.replaces?.length)
+            responseData.replaces = agent.replaces;
+        if (agent.canDelegateToArchetypes?.length)
+            responseData.canDelegateToArchetypes = agent.canDelegateToArchetypes;
+        if (agent.canDelegateToMetaAgents?.length)
+            responseData.canDelegateToMetaAgents = agent.canDelegateToMetaAgents;
+        // PRD-2026-004: Add task classifier config
+        if (agent.taskClassifier) {
+            responseData.taskClassifier = {
+                enabled: agent.taskClassifier.enabled ?? true,
+                rules: agent.taskClassifier.rules?.map(rule => ({
+                    pattern: rule.pattern,
+                    taskType: rule.taskType,
+                    workflow: rule.workflow,
+                    priority: rule.priority ?? 50,
+                })) ?? [],
+                defaultWorkflow: agent.taskClassifier.defaultWorkflow,
+                fuzzyMatching: agent.taskClassifier.fuzzyMatching,
+                minConfidence: agent.taskClassifier.minConfidence,
+            };
+        }
+        // PRD-2026-004: Add dynamic capabilities config
+        if (agent.dynamicCapabilities) {
+            responseData.dynamicCapabilities = agent.dynamicCapabilities;
+        }
+        // PRD-2026-004: Add review modes config
+        if (agent.reviewModes) {
+            responseData.reviewModes = agent.reviewModes;
+        }
+        // PRD-2026-004: Add capability mappings
+        if (agent.capabilityMappings?.length) {
+            responseData.capabilityMappings = agent.capabilityMappings.map(mapping => ({
+                taskType: mapping.taskType,
+                workflowRef: mapping.workflowRef,
+                abilities: mapping.abilities,
+                priority: mapping.priority,
+                description: mapping.description,
+            }));
+        }
         return {
             success: true,
-            data: {
-                agentId: agent.agentId,
-                displayName: agent.displayName ?? agent.agentId,
-                description: agent.description,
-                version: agent.version,
-                role: agent.role,
-                team: agent.team,
-                enabled: agent.enabled,
-                capabilities: agent.capabilities ?? [],
-                tags: agent.tags ?? [],
-                systemPrompt: agent.systemPrompt,
-                workflow: agent.workflow?.map(step => ({
-                    stepId: step.stepId,
-                    name: step.name,
-                    type: step.type,
-                    config: step.config,
-                    dependencies: step.dependencies,
-                    condition: step.condition,
-                })) ?? [],
-                orchestration: agent.orchestration,
-                personality: agent.personality,
-                expertise: agent.expertise,
-                // Stats
-                stats: {
-                    executionCount,
-                    successRate: executionCount > 0 ? successCount / executionCount : 0,
-                    avgDurationMs: executionCount > 0 ? Math.round(totalDurationMs / executionCount) : 0,
-                },
-            },
+            data: responseData,
         };
     }
     catch (error) {
@@ -402,7 +559,9 @@ async function handleTraceDetail(traceId) {
         const context = startEvent?.context;
         // Determine command type and extract relevant info
         const command = startPayload?.command;
-        // First try to detect from explicit command field
+        const tool = startPayload?.tool;
+        const workflowId = context?.workflowId;
+        // First try to detect from explicit command/tool field
         let commandType;
         if (command?.includes('discuss')) {
             commandType = 'discuss';
@@ -413,14 +572,22 @@ async function handleTraceDetail(traceId) {
         else if (command?.includes('call')) {
             commandType = 'call';
         }
+        else if (tool?.startsWith('research') || workflowId?.startsWith('research')) {
+            commandType = 'research';
+        }
+        else if (tool?.startsWith('review') || workflowId?.startsWith('review')) {
+            commandType = 'review';
+        }
         else {
             // Fallback: detect from context/payload fields when command is not set
             const hasAgentId = context?.agentId || startPayload?.agentId;
             const hasTopic = startPayload?.topic;
             const hasPrompt = startPayload?.prompt;
+            const hasQuery = startPayload?.query;
             commandType = hasAgentId ? 'agent' :
                 hasTopic ? 'discuss' :
-                    hasPrompt ? 'call' : 'unknown';
+                    hasQuery ? 'research' :
+                        hasPrompt ? 'call' : 'unknown';
         }
         // Extract input/output based on command type
         let input;
@@ -465,6 +632,8 @@ async function handleTraceDetail(traceId) {
             const agentId = startPayload?.agentId;
             // Support both 'task' (CLI) and 'input' (MCP) field names
             const taskOrInput = startPayload?.task ?? startPayload?.input;
+            // Extract provider from run.end payload (finalProvider)
+            provider = endPayload?.finalProvider;
             input = {
                 agentId,
                 task: taskOrInput,
@@ -473,6 +642,62 @@ async function handleTraceDetail(traceId) {
             output = {
                 stepCount: endPayload?.stepCount,
                 result: endPayload?.result ?? endPayload?.output,
+                // Include rich payload data for dashboard visibility
+                finalContent: endPayload?.finalContent,
+                agentDisplayName: endPayload?.agentDisplayName,
+                agentDescription: endPayload?.agentDescription,
+                inputTask: endPayload?.inputTask,
+                tokenUsage: endPayload?.tokenUsage,
+                stepResults: endPayload?.stepResults,
+                success: endPayload?.success,
+                error: endPayload?.error,
+            };
+        }
+        else if (commandType === 'research') {
+            input = {
+                query: startPayload?.query,
+                tool: startPayload?.tool,
+                sources: startPayload?.sources,
+                maxSources: startPayload?.maxSources,
+                synthesize: startPayload?.synthesize,
+            };
+            output = {
+                // Full artifacts for dashboard visibility
+                query: endPayload?.query,
+                sources: endPayload?.sources,
+                synthesis: endPayload?.synthesis,
+                codeExamples: endPayload?.codeExamples,
+                confidence: endPayload?.confidence,
+                warnings: endPayload?.warnings,
+                // For fetch operations
+                url: endPayload?.url,
+                title: endPayload?.title,
+                contentPreview: endPayload?.contentPreview,
+                codeBlocks: endPayload?.codeBlocks,
+                reliability: endPayload?.reliability,
+                success: endPayload?.success,
+                error: endPayload?.error,
+            };
+        }
+        else if (commandType === 'review') {
+            // Extract provider from run.end payload (providerId)
+            provider = endPayload?.providerId;
+            input = {
+                paths: startPayload?.paths,
+                focus: startPayload?.focus,
+                context: startPayload?.context,
+                tool: startPayload?.tool,
+                dryRun: startPayload?.dryRun,
+            };
+            output = {
+                // Full review results for dashboard visibility
+                summary: endPayload?.summary,
+                comments: endPayload?.comments,
+                filesReviewed: endPayload?.filesReviewed,
+                filesReviewedCount: endPayload?.filesReviewedCount,
+                linesAnalyzed: endPayload?.linesAnalyzed,
+                commentCount: endPayload?.commentCount,
+                providerId: endPayload?.providerId,
                 success: endPayload?.success,
                 error: endPayload?.error,
             };
@@ -499,6 +724,66 @@ async function handleTraceDetail(traceId) {
                 timestamp: step.timestamp,
             };
         });
+        // Extract provider conversations from discussion.provider events
+        // This provides real-time visibility into running discussions
+        const discussionProviderEvents = events.filter(e => e.type === 'discussion.provider');
+        const providerConversations = discussionProviderEvents.map(event => {
+            const payload = event.payload;
+            const context = event.context;
+            const promptValue = payload?.prompt;
+            const contentValue = payload?.content;
+            const durationMsValue = event.durationMs ?? payload?.durationMs;
+            const tokenCountValue = payload?.tokenCount;
+            const result = {
+                provider: (context?.providerId ?? payload?.providerId ?? 'unknown'),
+                round: (payload?.roundNumber ?? 1),
+                success: (payload?.success ?? event.status === 'success'),
+                timestamp: event.timestamp,
+            };
+            // Only add optional fields if they have values
+            if (promptValue !== undefined)
+                result.prompt = promptValue;
+            if (contentValue !== undefined)
+                result.content = contentValue;
+            if (durationMsValue !== undefined)
+                result.durationMs = durationMsValue;
+            if (tokenCountValue !== undefined)
+                result.tokenCount = tokenCountValue;
+            return result;
+        });
+        // Extract agent step conversations from workflow.step events
+        // This provides visibility into agent execution steps with LLM responses
+        const agentStepEvents = events.filter(e => e.type === 'workflow.step');
+        const agentStepConversations = agentStepEvents.map(event => {
+            const payload = event.payload;
+            const context = event.context;
+            const contentValue = payload?.content;
+            const durationMsValue = event.durationMs ?? payload?.durationMs;
+            const tokenUsage = context?.tokenUsage;
+            const result = {
+                stepId: (payload?.stepId ?? 'unknown'),
+                stepIndex: (payload?.stepIndex ?? 0),
+                success: (payload?.success ?? event.status === 'success'),
+                timestamp: event.timestamp,
+            };
+            // Only add optional fields if they have values
+            const providerValue = (context?.providerId ?? payload?.provider);
+            if (providerValue !== undefined)
+                result.provider = providerValue;
+            if (contentValue !== undefined)
+                result.content = contentValue;
+            if (durationMsValue !== undefined)
+                result.durationMs = durationMsValue;
+            if (tokenUsage?.total !== undefined)
+                result.tokenCount = tokenUsage.total;
+            else if (tokenUsage?.input !== undefined && tokenUsage?.output !== undefined) {
+                result.tokenCount = tokenUsage.input + tokenUsage.output;
+            }
+            const errorValue = payload?.error;
+            if (errorValue !== undefined)
+                result.error = errorValue;
+            return result;
+        });
         // Determine status from events
         let status = 'pending';
         if (endEvent) {
@@ -515,6 +800,8 @@ async function handleTraceDetail(traceId) {
             (endEvent && startEvent ?
                 new Date(endEvent.timestamp).getTime() - new Date(startEvent.timestamp).getTime() :
                 undefined);
+        // PRD-2026-003: Extract classification data from start event
+        const classificationData = startPayload?.classification;
         return {
             success: true,
             data: {
@@ -533,12 +820,18 @@ async function handleTraceDetail(traceId) {
                 output,
                 // Workflow steps (for agent runs)
                 workflowSteps: workflowSteps.length > 0 ? workflowSteps : undefined,
+                // Provider conversations from discussion.provider events (for discussions)
+                providerConversations: providerConversations.length > 0 ? providerConversations : undefined,
+                // Agent step conversations from workflow.step events (for agents)
+                agentStepConversations: agentStepConversations.length > 0 ? agentStepConversations : undefined,
                 // Summary
                 summary: {
                     eventCount: events.length,
                     stepCount: stepEvents.length,
                     errorCount: errorEvents.length,
                 },
+                // PRD-2026-003: Classification data
+                classification: classificationData,
                 // Full timeline for advanced view
                 timeline,
             },
@@ -581,6 +874,25 @@ async function handleWorkflowDetail(workflowId) {
                 });
             }
         }
+        // Get recent executions of this workflow from trace store
+        const traceStore = getTraceStore();
+        const allTraces = await traceStore.listTraces(100);
+        const workflowExecutions = [];
+        for (const trace of allTraces) {
+            const events = await traceStore.getTrace(trace.traceId);
+            const startEvent = events.find(e => e.type === 'run.start');
+            const context = startEvent?.context;
+            // Check if this trace is for this workflow
+            if (context?.workflowId === workflowId ||
+                startEvent?.payload?.workflowId === workflowId) {
+                workflowExecutions.push({
+                    traceId: trace.traceId,
+                    status: trace.status,
+                    startTime: trace.startTime,
+                    ...(trace.durationMs !== undefined && { durationMs: trace.durationMs }),
+                });
+            }
+        }
         return {
             success: true,
             data: {
@@ -588,8 +900,22 @@ async function handleWorkflowDetail(workflowId) {
                 version: workflow.version,
                 name: workflow.name,
                 description: workflow.description,
-                steps: workflow.steps,
+                // Full step details with configs
+                steps: workflow.steps.map(step => ({
+                    stepId: step.stepId,
+                    name: step.name ?? step.stepId,
+                    type: step.type,
+                    timeout: step.timeout,
+                    dependencies: step.dependencies,
+                    config: step.config,
+                })),
+                // Metadata if available
+                metadata: workflow.metadata,
+                // DAG for visualization
                 dag: { nodes, edges },
+                // Recent executions
+                recentExecutions: workflowExecutions.slice(0, 10),
+                executionCount: workflowExecutions.length,
             },
         };
     }
@@ -874,6 +1200,74 @@ async function handleTraceTree(traceId) {
         };
     }
 }
+/**
+ * Get classification data for a trace
+ * PRD-2026-003: Classification observability endpoint
+ * INV-TR-030: Classification snapshot is immutable once recorded
+ */
+async function handleTraceClassification(traceId) {
+    try {
+        const traceStore = getTraceStore();
+        const events = await traceStore.getTrace(traceId);
+        if (!events || events.length === 0) {
+            return { success: false, error: `Trace not found: ${traceId}` };
+        }
+        // Find run.start event which contains classification data
+        const startEvent = events.find(e => e.type === 'run.start');
+        if (!startEvent) {
+            return {
+                success: true,
+                data: {
+                    traceId,
+                    hasClassification: false,
+                    message: 'No classification data available for this trace',
+                },
+            };
+        }
+        const payload = startEvent.payload;
+        const classification = payload?.classification;
+        if (!classification) {
+            return {
+                success: true,
+                data: {
+                    traceId,
+                    hasClassification: false,
+                    message: 'No classification data available for this trace',
+                },
+            };
+        }
+        // Calculate guard pass rate
+        const guardResults = classification.guardResults ?? [];
+        const guardPassRate = guardResults.length > 0
+            ? guardResults.filter(g => g.passed).length / guardResults.length
+            : 1.0;
+        return {
+            success: true,
+            data: {
+                traceId,
+                hasClassification: true,
+                classification: {
+                    taskType: classification.taskType,
+                    confidence: classification.confidence,
+                    matchedPatterns: classification.matchedPatterns ?? [],
+                    selectedMapping: classification.selectedMapping,
+                    alternatives: classification.alternatives ?? [],
+                    classificationTimeMs: classification.classificationTimeMs,
+                    guardResults,
+                    guardPassRate,
+                    taskDescription: classification.taskDescription,
+                },
+                timestamp: startEvent.timestamp,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: getErrorMessage(error, 'Failed to fetch classification data'),
+        };
+    }
+}
 /**
  * Get workflow execution events - timeline of a workflow execution
  * Uses workflow.start, workflow.step, workflow.end events (INV-TR-013)
@@ -985,8 +1379,14 @@ async function handleWorkflowEvents(workflowId) {
 }
 /**
  * Fetch provider data
+ * Uses cached status if available (set at monitor startup), otherwise checks CLI availability only
  */
 async function getProviderData() {
+    // Use cached status if available (set at monitor startup with real health check)
+    if (cachedProviderStatus !== null) {
+        return cachedProviderStatus;
+    }
+    // Fallback: quick CLI availability check (no actual LLM call)
     try {
         const registry = getProviderRegistry();
         const providerIds = registry.getProviderIds();
@@ -1060,6 +1460,9 @@ async function getAgentData() {
             capabilities: agent.capabilities ?? [],
             executionCount: 0,
             lastExecuted: undefined,
+            // PRD-2026-004: Meta-agent fields for list display
+            metaAgent: agent.metaAgent,
+            archetype: agent.archetype,
         }));
     }
     catch {
@@ -1172,6 +1575,71 @@ async function getWorkflowData() {
         return [];
     }
 }
+/**
+ * Calculate classification metrics from recent traces
+ * PRD-2026-003: Classification observability
+ */
+async function getClassificationMetrics() {
+    try {
+        const traceStore = getTraceStore();
+        const traces = await traceStore.listTraces(200);
+        let totalClassifications = 0;
+        const byTaskType = {};
+        let totalConfidence = 0;
+        let totalGuardChecks = 0;
+        let passedGuardChecks = 0;
+        let fallbackCount = 0;
+        for (const trace of traces) {
+            try {
+                const events = await traceStore.getTrace(trace.traceId);
+                const startEvent = events.find(e => e.type === 'run.start');
+                if (!startEvent)
+                    continue;
+                const payload = startEvent.payload;
+                const classification = payload?.classification;
+                if (!classification || !classification.taskType)
+                    continue;
+                totalClassifications++;
+                const taskType = classification.taskType;
+                byTaskType[taskType] = (byTaskType[taskType] ?? 0) + 1;
+                if (classification.confidence !== undefined) {
+                    totalConfidence += classification.confidence;
+                }
+                if (classification.selectedMapping === null) {
+                    fallbackCount++;
+                }
+                if (classification.guardResults) {
+                    for (const gate of classification.guardResults) {
+                        totalGuardChecks++;
+                        if (gate.passed)
+                            passedGuardChecks++;
+                    }
+                }
+            }
+            catch {
+                // Ignore individual trace errors
+            }
+        }
+        return {
+            totalClassifications,
+            byTaskType,
+            guardPassRate: totalGuardChecks > 0 ? passedGuardChecks / totalGuardChecks : 1.0,
+            averageConfidence: totalClassifications > 0 ? totalConfidence / totalClassifications : 0,
+            fallbackRate: totalClassifications > 0 ? fallbackCount / totalClassifications : 0,
+            sampleSize: traces.length,
+        };
+    }
+    catch {
+        return {
+            totalClassifications: 0,
+            byTaskType: {},
+            guardPassRate: 1.0,
+            averageConfidence: 0,
+            fallbackRate: 0,
+            sampleSize: 0,
+        };
+    }
+}
 /**
  * Fetch metrics data
  */