@townco/debugger 0.1.38 → 0.1.48

package/src/server.ts

@@ -1,5 +1,6 @@
 import { resetDb } from "@townco/otlp-server/db";
 import { createOtlpServer } from "@townco/otlp-server/http";
+import type { Serve } from "bun";
 import { serve } from "bun";
 import { AnalysisDb } from "./analysis-db";
 import { ComparisonDb } from "./comparison-db";
@@ -17,287 +18,323 @@ import type {
 export const DEFAULT_DEBUGGER_PORT = 4000;
 export const DEFAULT_OTLP_PORT = 4318;
 
-export interface DebuggerServerOptions {
-  port?: number;
-  otlpPort?: number;
+/**
+ * Creates the debugger API routes. Can be used standalone without starting a
+ * server.
+ */
+export function createDebuggerRoutes(options: {
   dbPath: string;
-  agentName?: string;
-  agentServerUrl?: string;
-}
-
-export interface DebuggerServerResult {
-  server: ReturnType<typeof serve>;
-  otlpServer: ReturnType<typeof serve>;
-  stop: () => void;
-}
-
-export function startDebuggerServer(
-  options: DebuggerServerOptions,
-): DebuggerServerResult {
-  const {
-    port = DEFAULT_DEBUGGER_PORT,
-    otlpPort = DEFAULT_OTLP_PORT,
-    dbPath,
-    agentName = "Agent",
-    agentServerUrl = "http://localhost:3100",
-  } = options;
-
-  // Start OTLP server (initializes database internally)
-  const otlpApp = createOtlpServer({ dbPath });
-  const otlpServer = serve({
-    fetch: otlpApp.fetch,
-    hostname: Bun.env.BIND_HOST || "localhost",
-    port: otlpPort,
-  });
+  agentName: string;
+  agentServerUrl: string;
+}) {
+  const { dbPath, agentName, agentServerUrl } = options;
 
-  // Create debugger database connection for reading
+  // Initialize databases
   const db = new DebuggerDb(dbPath);
-
-  // Create comparison database for Town Hall feature
   const comparisonDbPath = dbPath.replace(/\.db$/, "-comparison.db");
   const comparisonDb = new ComparisonDb(comparisonDbPath);
-
-  // Create analysis database - uses main debugger database
   const analysisDb = new AnalysisDb(dbPath);
 
-  // Helper to fetch agent config from agent server
-  async function fetchAgentConfig(): Promise<AgentConfig | null> {
-    try {
-      // Call agent's initialize RPC to get config
-      const response = await fetch(`${agentServerUrl}/rpc`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          id: "debugger-config",
-          method: "initialize",
-          params: {
-            protocolVersion: 1, // ACP protocol version as number
-            clientCapabilities: {},
-          },
-        }),
-      });
-
-      if (!response.ok) {
-        console.error("Failed to fetch agent config:", response.statusText);
-        return null;
-      }
-
-      const data = await response.json();
-
-      // Check for JSON-RPC error
-      if (data.error) {
-        console.error("Agent RPC error:", data.error);
-        return null;
-      }
-
-      const result = data.result;
-      if (!result) {
-        console.error("No result in agent response");
-        return null;
-      }
-
-      // Extract config from initialize response
-      return {
-        model: result._meta?.model || "unknown",
-        systemPrompt: result._meta?.systemPrompt || null,
-        tools: result._meta?.tools || [],
-      };
-    } catch (error) {
-      console.error("Error fetching agent config:", error);
-      return null;
-    }
-  }
+  const fetchAgentConfig = () => fetchAgentConfigFromServer(agentServerUrl);
 
-  // Start debugger UI server
-  const server = serve({
-    port,
-    idleTimeout: 120, // 2 minutes for long-running LLM analysis requests
-    routes: {
-      "/api/config": {
-        GET() {
-          return Response.json({ agentName });
-        },
+  return defineRoutes({
+    "/api/config": {
+      GET() {
+        return Response.json({ agentName });
       },
+    },
 
-      "/api/reset-database": {
-        POST() {
-          try {
-            resetDb();
-            return new Response("Database reset successfully", { status: 200 });
-          } catch (error) {
-            console.error("Error resetting database:", error);
-            return new Response(
-              `Failed to reset database: ${error instanceof Error ? error.message : String(error)}`,
-              { status: 500 },
-            );
-          }
-        },
+    "/api/reset-database": {
+      POST() {
+        try {
+          resetDb();
+          return new Response("Database reset successfully", { status: 200 });
+        } catch (error) {
+          console.error("Error resetting database:", error);
+          return new Response(
+            `Failed to reset database: ${error instanceof Error ? error.message : String(error)}`,
+            { status: 500 },
+          );
+        }
       },
+    },
 
-      "/api/sessions": {
-        GET(req) {
-          const url = new URL(req.url);
-          const limit = Number.parseInt(
-            url.searchParams.get("limit") || "1000",
-            10,
-          );
-          const offset = Number.parseInt(
-            url.searchParams.get("offset") || "0",
-            10,
-          );
-          const sessions = db.listSessions(limit, offset);
-          return Response.json(sessions);
-        },
+    "/api/sessions": {
+      GET(req) {
+        const url = new URL(req.url);
+        const limit = Number.parseInt(
+          url.searchParams.get("limit") || "1000",
+          10,
+        );
+        const offset = Number.parseInt(
+          url.searchParams.get("offset") || "0",
+          10,
+        );
+        const sessions = db.listSessions(limit, offset);
+        return Response.json(sessions);
       },
+    },
 
-      "/api/traces": {
-        GET(req) {
-          const url = new URL(req.url);
-          const limit = Number.parseInt(
-            url.searchParams.get("limit") || "50",
-            10,
-          );
-          const offset = Number.parseInt(
-            url.searchParams.get("offset") || "0",
-            10,
-          );
-          const sessionId = url.searchParams.get("sessionId") || undefined;
-          const traces = db.listTraces(limit, offset, sessionId);
-          return Response.json(traces);
-        },
+    "/api/traces": {
+      GET(req) {
+        const url = new URL(req.url);
+        const limit = Number.parseInt(
+          url.searchParams.get("limit") || "50",
+          10,
+        );
+        const offset = Number.parseInt(
+          url.searchParams.get("offset") || "0",
+          10,
+        );
+        const sessionId = url.searchParams.get("sessionId") || undefined;
+        const traces = db.listTraces(limit, offset, sessionId);
+        return Response.json(traces);
       },
+    },
 
-      "/api/traces/:traceId": {
-        GET(req) {
-          const traceId = req.params.traceId;
-          const data = db.getTraceById(traceId);
-          if (!data.trace) {
-            return Response.json({ error: "Trace not found" }, { status: 404 });
-          }
-          // Extract messages on the server side
+    "/api/traces/:traceId": {
+      GET(req) {
+        const traceId = req.params.traceId;
+        const data = db.getTraceById(traceId);
+        if (!data.trace) {
+          return Response.json({ error: "Trace not found" }, { status: 404 });
+        }
+        // Extract messages on the server side
+        const messages = extractTurnMessages(data.spans, data.logs);
+        return Response.json({ ...data, messages });
+      },
+    },
+
+    "/api/session-conversation": {
+      GET(req) {
+        const url = new URL(req.url);
+        const sessionId = url.searchParams.get("sessionId");
+        if (!sessionId) {
+          return Response.json(
+            { error: "sessionId parameter is required" },
+            { status: 400 },
+          );
+        }
+
+        // Query traces by session attribute to avoid race conditions
+        const traceIds = db.getTraceIdsBySessionAttribute(sessionId);
+
+        // Extract messages for each trace
+        const conversation: ConversationTrace[] = traceIds.map((traceInfo) => {
+          const data = db.getTraceById(traceInfo.trace_id);
           const messages = extractTurnMessages(data.spans, data.logs);
-          return Response.json({ ...data, messages });
-        },
+          return {
+            trace_id: traceInfo.trace_id,
+            start_time_unix_nano: traceInfo.start_time_unix_nano,
+            userInput: messages.userInput,
+            llmOutput: messages.llmOutput,
+            agentMessages: messages.agentMessages,
+          };
+        });
+
+        return Response.json(conversation);
       },
+    },
 
-      "/api/session-conversation": {
-        GET(req) {
-          const url = new URL(req.url);
-          const sessionId = url.searchParams.get("sessionId");
-          if (!sessionId) {
-            return Response.json(
-              { error: "sessionId parameter is required" },
-              { status: 400 },
-            );
-          }
+    // Town Hall API endpoints
 
-          // Query traces by session attribute to avoid race conditions
-          const traceIds = db.getTraceIdsBySessionAttribute(sessionId);
-
-          // Extract messages for each trace
-          const conversation: ConversationTrace[] = traceIds.map(
-            (traceInfo) => {
-              const data = db.getTraceById(traceInfo.trace_id);
-              const messages = extractTurnMessages(data.spans, data.logs);
-              return {
-                trace_id: traceInfo.trace_id,
-                start_time_unix_nano: traceInfo.start_time_unix_nano,
-                userInput: messages.userInput,
-                llmOutput: messages.llmOutput,
-                agentMessages: messages.agentMessages,
-              };
-            },
+    "/api/agent-config": {
+      async GET() {
+        const config = await fetchAgentConfig();
+        if (!config) {
+          return Response.json(
+            { error: "Failed to fetch agent config" },
+            { status: 503 },
           );
+        }
+        return Response.json(config);
+      },
+    },
 
-          return Response.json(conversation);
-        },
+    "/api/available-models": {
+      GET() {
+        // List of supported models for comparison
+        const models = [
+          // Anthropic models
+          "claude-sonnet-4-5-20250929",
+          "claude-3-5-haiku-20241022",
+          "claude-opus-4-5-20251101",
+          // Google Gemini models
+          "gemini-2.0-flash",
+          "gemini-1.5-pro",
+          "gemini-1.5-flash",
+        ];
+        return Response.json({ models });
       },
+    },
 
-      // Town Hall API endpoints
+    "/api/session-first-message/:sessionId": {
+      GET(req) {
+        const sessionId = req.params.sessionId;
 
-      "/api/agent-config": {
-        async GET() {
-          const config = await fetchAgentConfig();
-          if (!config) {
-            return Response.json(
-              { error: "Failed to fetch agent config" },
-              { status: 503 },
-            );
-          }
-          return Response.json(config);
-        },
+        // Query logs directly by session attribute to avoid race conditions
+        // with trace.session_id association during concurrent sessions
+        const message = db.getFirstUserMessageBySession(sessionId);
+
+        if (!message) {
+          return Response.json(
+            { error: "Session not found or has no user message" },
+            { status: 404 },
+          );
+        }
+
+        return Response.json({ message });
       },
+    },
 
-      "/api/available-models": {
-        GET() {
-          // List of supported models for comparison
-          const models = [
-            // Anthropic models
-            "claude-sonnet-4-5-20250929",
-            "claude-3-5-haiku-20241022",
-            "claude-opus-4-5-20251101",
-            // Google Gemini models
-            "gemini-2.0-flash",
-            "gemini-1.5-pro",
-            "gemini-1.5-flash",
-          ];
-          return Response.json({ models });
-        },
+    "/api/comparison-config": {
+      GET() {
+        const config = comparisonDb.getLatestConfig();
+        return Response.json(config);
       },
+      async POST(req) {
+        try {
+          const body = await req.json();
+          const config: ComparisonConfig = {
+            id: body.id || crypto.randomUUID(),
+            dimensions: body.dimensions || [],
+            controlModel: body.controlModel,
+            variantModel: body.variantModel,
+            variantSystemPrompt: body.variantSystemPrompt,
+            variantTools: body.variantTools,
+            createdAt: body.createdAt || new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+          };
+          comparisonDb.saveConfig(config);
+          return Response.json({ id: config.id });
+        } catch (error) {
+          console.error("Error saving comparison config:", error);
+          return Response.json(
+            { error: "Invalid request body" },
+            { status: 400 },
+          );
+        }
+      },
+    },
 
-      "/api/session-first-message/:sessionId": {
-        GET(req) {
-          const sessionId = req.params.sessionId;
+    "/api/comparison-config/:configId": {
+      GET(req) {
+        const configId = req.params.configId;
+        const config = comparisonDb.getConfig(configId);
+        if (!config) {
+          return Response.json(
+            { error: "Comparison config not found" },
+            { status: 404 },
+          );
+        }
+        return Response.json(config);
+      },
+    },
 
-          // Query logs directly by session attribute to avoid race conditions
-          // with trace.session_id association during concurrent sessions
-          const message = db.getFirstUserMessageBySession(sessionId);
+    "/api/comparison-session-ids": {
+      GET() {
+        const sessionIds = comparisonDb.getComparisonSessionIds();
+        return Response.json({ sessionIds });
+      },
+    },
 
-          if (!message) {
-            return Response.json(
-              { error: "Session not found or has no user message" },
-              { status: 404 },
-            );
-          }
+    "/api/comparison-runs": {
+      GET(req) {
+        const url = new URL(req.url);
+        const limit = Number.parseInt(
+          url.searchParams.get("limit") || "50",
+          10,
+        );
+        const offset = Number.parseInt(
+          url.searchParams.get("offset") || "0",
+          10,
+        );
+        const sourceSessionId = url.searchParams.get("sourceSessionId");
+
+        if (sourceSessionId) {
+          const runs = comparisonDb.listRunsBySourceSession(sourceSessionId);
+          return Response.json(runs);
+        }
 
-          return Response.json({ message });
-        },
+        const runs = comparisonDb.listRuns(limit, offset);
+        return Response.json(runs);
       },
+    },
 
-      "/api/comparison-config": {
-        GET() {
-          const config = comparisonDb.getLatestConfig();
-          return Response.json(config);
-        },
-        async POST(req) {
-          try {
-            const body = await req.json();
-            const config: ComparisonConfig = {
-              id: body.id || crypto.randomUUID(),
-              dimensions: body.dimensions || [],
-              controlModel: body.controlModel,
-              variantModel: body.variantModel,
-              variantSystemPrompt: body.variantSystemPrompt,
-              variantTools: body.variantTools,
-              createdAt: body.createdAt || new Date().toISOString(),
-              updatedAt: new Date().toISOString(),
-            };
-            comparisonDb.saveConfig(config);
-            return Response.json({ id: config.id });
-          } catch (error) {
-            console.error("Error saving comparison config:", error);
+    "/api/comparison-run/:runId": {
+      GET(req) {
+        const runId = req.params.runId;
+        const run = comparisonDb.getRun(runId);
+        if (!run) {
+          return Response.json(
+            { error: "Comparison run not found" },
+            { status: 404 },
+          );
+        }
+
+        const config = comparisonDb.getConfig(run.configId);
+        const controlModel =
+          config?.controlModel ??
+          config?.variantModel ??
+          "claude-sonnet-4-5-20250929";
+        const variantModel =
+          config?.variantModel ??
+          config?.controlModel ??
+          "claude-sonnet-4-5-20250929";
+
+        const maybeRefreshMetrics = (
+          sessionId: string | null,
+          cached: SessionMetrics | null,
+          model: string,
+        ): SessionMetrics | null => {
+          if (!sessionId) return cached;
+          const needsRefresh =
+            !cached ||
+            cached.totalTokens === 0 ||
+            cached.toolCallCount === 0 ||
+            !cached.toolCalls ||
+            cached.toolCalls.length === 0;
+          if (!needsRefresh) return cached;
+
+          const spans = db.getSpansBySessionAttribute(sessionId);
+          if (spans.length === 0) return cached;
+          const traces = db.listTraces(100, 0, sessionId);
+          return extractSessionMetrics(traces, spans, model);
+        };
+
+        const controlMetrics = maybeRefreshMetrics(
+          run.controlSessionId,
+          run.controlMetrics,
+          controlModel,
+        );
+        const variantMetrics = maybeRefreshMetrics(
+          run.variantSessionId,
+          run.variantMetrics,
+          variantModel,
+        );
+
+        return Response.json({
+          ...run,
+          controlMetrics,
+          variantMetrics,
+        });
+      },
+    },
+
+    "/api/run-comparison": {
+      async POST(req) {
+        try {
+          const body = await req.json();
+          const { sessionId, configId } = body;
+
+          if (!sessionId || !configId) {
             return Response.json(
-              { error: "Invalid request body" },
+              { error: "sessionId and configId are required" },
               { status: 400 },
             );
           }
-        },
-      },
 
-      "/api/comparison-config/:configId": {
-        GET(req) {
-          const configId = req.params.configId;
+          // Get the comparison config
           const config = comparisonDb.getConfig(configId);
           if (!config) {
             return Response.json(
@@ -305,733 +342,664 @@ export function startDebuggerServer(
               { status: 404 },
             );
           }
-          return Response.json(config);
-        },
-      },
 
-      "/api/comparison-session-ids": {
-        GET() {
-          const sessionIds = comparisonDb.getComparisonSessionIds();
-          return Response.json({ sessionIds });
-        },
-      },
-
-      "/api/comparison-runs": {
-        GET(req) {
-          const url = new URL(req.url);
-          const limit = Number.parseInt(
-            url.searchParams.get("limit") || "50",
-            10,
-          );
-          const offset = Number.parseInt(
-            url.searchParams.get("offset") || "0",
-            10,
-          );
-          const sourceSessionId = url.searchParams.get("sourceSessionId");
-
-          if (sourceSessionId) {
-            const runs = comparisonDb.listRunsBySourceSession(sourceSessionId);
-            return Response.json(runs);
+          // Get the first user message from the source session
+          const traces = db.listTraces(1, 0, sessionId);
+          if (traces.length === 0) {
+            return Response.json(
+              { error: "Source session not found" },
+              { status: 404 },
+            );
           }
 
-          const runs = comparisonDb.listRuns(limit, offset);
-          return Response.json(runs);
-        },
-      },
-
-      "/api/comparison-run/:runId": {
-        GET(req) {
-          const runId = req.params.runId;
-          const run = comparisonDb.getRun(runId);
-          if (!run) {
+          const trace = traces[0];
+          if (!trace) {
             return Response.json(
-              { error: "Comparison run not found" },
+              { error: "Source session not found" },
               { status: 404 },
             );
           }
 
-          const config = comparisonDb.getConfig(run.configId);
-          const controlModel =
-            config?.controlModel ??
-            config?.variantModel ??
-            "claude-sonnet-4-5-20250929";
-          const variantModel =
-            config?.variantModel ??
-            config?.controlModel ??
-            "claude-sonnet-4-5-20250929";
-
-          const maybeRefreshMetrics = (
-            sessionId: string | null,
-            cached: SessionMetrics | null,
-            model: string,
-          ): SessionMetrics | null => {
-            if (!sessionId) return cached;
-            const needsRefresh =
-              !cached ||
-              cached.totalTokens === 0 ||
-              cached.toolCallCount === 0 ||
-              !cached.toolCalls ||
-              cached.toolCalls.length === 0;
-            if (!needsRefresh) return cached;
+          const data = db.getTraceById(trace.trace_id);
+          const messages = extractTurnMessages(data.spans, data.logs);
 
-            const spans = db.getSpansBySessionAttribute(sessionId);
-            if (spans.length === 0) return cached;
-            const traces = db.listTraces(100, 0, sessionId);
-            return extractSessionMetrics(traces, spans, model);
-          };
+          if (!messages.userInput) {
+            return Response.json(
+              { error: "No user message found in source session" },
+              { status: 400 },
+            );
+          }
 
-          const controlMetrics = maybeRefreshMetrics(
-            run.controlSessionId,
-            run.controlMetrics,
-            controlModel,
-          );
-          const variantMetrics = maybeRefreshMetrics(
-            run.variantSessionId,
-            run.variantMetrics,
-            variantModel,
+          // Create the comparison run
+          const run = comparisonDb.createRun(
+            configId,
+            sessionId,
+            messages.userInput,
           );
 
+          // Return the run info - actual execution will be handled by the frontend
+          // which will create two ACP sessions and run them in parallel
           return Response.json({
-            ...run,
+            runId: run.id,
+            firstUserMessage: run.firstUserMessage,
+            config,
+          });
+        } catch (error) {
+          console.error("Error starting comparison:", error);
+          return Response.json(
+            { error: "Failed to start comparison" },
+            { status: 500 },
+          );
+        }
+      },
+    },
+
+    "/api/comparison-run/:runId/update": {
+      async POST(req) {
+        try {
+          const runId = req.params.runId;
+          const body = await req.json();
+          const {
+            status,
+            controlSessionId,
+            variantSessionId,
             controlMetrics,
             variantMetrics,
+            controlResponse,
+            variantResponse,
+          } = body;
+
+          comparisonDb.updateRunStatus(runId, status, {
+            controlSessionId,
+            variantSessionId,
+            controlMetrics,
+            variantMetrics,
+            controlResponse,
+            variantResponse,
           });
-        },
+
+          return Response.json({ success: true });
+        } catch (_error) {
+          return Response.json(
+            { error: "Failed to update comparison run" },
+            { status: 500 },
+          );
+        }
       },
+    },
 
-      "/api/run-comparison": {
-        async POST(req) {
-          try {
-            const body = await req.json();
-            const { sessionId, configId } = body;
+    "/api/session-metrics/:sessionId": {
+      async GET(req) {
+        const sessionId = req.params.sessionId;
+        const url = new URL(req.url);
+        const model = url.searchParams.get("model") || "unknown";
+
+        // Query spans by their agent.session_id attribute directly
+        // This is more reliable than trace-based lookup because concurrent
+        // sessions can cause race conditions in trace association
+        const allSpans = db.getSpansBySessionAttribute(sessionId);
+
+        if (allSpans.length === 0) {
+          return Response.json(
+            { error: "Session not found or has no traces" },
+            { status: 404 },
+          );
+        }
 
-            if (!sessionId || !configId) {
-              return Response.json(
-                { error: "sessionId and configId are required" },
-                { status: 400 },
-              );
-            }
+        // Get traces for duration calculation (use empty array if not found)
+        const traces = db.listTraces(100, 0, sessionId);
 
-            // Get the comparison config
-            const config = comparisonDb.getConfig(configId);
-            if (!config) {
-              return Response.json(
-                { error: "Comparison config not found" },
-                { status: 404 },
-              );
-            }
+        // Extract metrics
+        const metrics = extractSessionMetrics(traces, allSpans, model);
+        return Response.json(metrics);
+      },
+    },
 
-            // Get the first user message from the source session
-            const traces = db.listTraces(1, 0, sessionId);
-            if (traces.length === 0) {
-              return Response.json(
-                { error: "Source session not found" },
-                { status: 404 },
-              );
-            }
+    "/api/analyze-session/:sessionId": {
+      async POST(req) {
+        const sessionId = req.params.sessionId;
 
-            const trace = traces[0];
-            if (!trace) {
-              return Response.json(
-                { error: "Source session not found" },
-                { status: 404 },
-              );
-            }
+        try {
+          // Import analyzer dynamically to avoid loading at startup
+          const { analyzeSession } = await import("./analysis/analyzer.js");
 
-            const data = db.getTraceById(trace.trace_id);
-            const messages = extractTurnMessages(data.spans, data.logs);
+          // Fetch session from agent server via ACP HTTP API
+          const sessionResponse = await fetch(
+            `${agentServerUrl}/sessions/${sessionId}`,
+          );
 
-            if (!messages.userInput) {
+          if (!sessionResponse.ok) {
+            if (sessionResponse.status === 404) {
               return Response.json(
-                { error: "No user message found in source session" },
-                { status: 400 },
+                { error: "Session not found" },
+                { status: 404 },
               );
             }
-
-            // Create the comparison run
-            const run = comparisonDb.createRun(
-              configId,
-              sessionId,
-              messages.userInput,
-            );
-
-            // Return the run info - actual execution will be handled by the frontend
-            // which will create two ACP sessions and run them in parallel
-            return Response.json({
-              runId: run.id,
-              firstUserMessage: run.firstUserMessage,
-              config,
-            });
-          } catch (error) {
-            console.error("Error starting comparison:", error);
-            return Response.json(
-              { error: "Failed to start comparison" },
-              { status: 500 },
+            throw new Error(
+              `Failed to fetch session: ${sessionResponse.statusText}`,
             );
           }
-        },
-      },
 
-      "/api/comparison-run/:runId/update": {
-        async POST(req) {
-          try {
-            const runId = req.params.runId;
-            const body = await req.json();
-            const {
-              status,
-              controlSessionId,
-              variantSessionId,
-              controlMetrics,
-              variantMetrics,
-              controlResponse,
-              variantResponse,
-            } = body;
-
-            comparisonDb.updateRunStatus(runId, status, {
-              controlSessionId,
-              variantSessionId,
-              controlMetrics,
-              variantMetrics,
-              controlResponse,
-              variantResponse,
-            });
-
-            return Response.json({ success: true });
-          } catch (_error) {
-            return Response.json(
-              { error: "Failed to update comparison run" },
-              { status: 500 },
-            );
-          }
-        },
-      },
+          const sessionData = await sessionResponse.json();
 
-      "/api/session-metrics/:sessionId": {
-        async GET(req) {
-          const sessionId = req.params.sessionId;
-          const url = new URL(req.url);
-          const model = url.searchParams.get("model") || "unknown";
+          // Fetch agent config to get model for cost calculation
+          const agentConfig = await fetchAgentConfig();
+          const model = agentConfig?.model || "unknown";
 
-          // Query spans by their agent.session_id attribute directly
-          // This is more reliable than trace-based lookup because concurrent
-          // sessions can cause race conditions in trace association
+          // Fetch metrics from OTLP spans
           const allSpans = db.getSpansBySessionAttribute(sessionId);
-
-          if (allSpans.length === 0) {
-            return Response.json(
-              { error: "Session not found or has no traces" },
-              { status: 404 },
-            );
-          }
-
-          // Get traces for duration calculation (use empty array if not found)
           const traces = db.listTraces(100, 0, sessionId);
+          const sessionMetrics = extractSessionMetrics(traces, allSpans, model);
+
+          // Convert to AnalysisMetrics format
+          const metrics = {
+            inputTokens: sessionMetrics.inputTokens,
+            outputTokens: sessionMetrics.outputTokens,
+            totalTokens: sessionMetrics.totalTokens,
+            estimatedCost: sessionMetrics.estimatedCost,
+            durationMs: sessionMetrics.durationMs,
+          };
 
-          // Extract metrics
-          const metrics = extractSessionMetrics(traces, allSpans, model);
-          return Response.json(metrics);
-        },
-      },
+          // Convert tool calls to DetailedToolCall format
+          const toolCalls = (sessionMetrics.toolCalls || []).map((tc) => ({
+            name: tc.name,
+            input: tc.input,
+            output: tc.output,
+            startTimeUnixNano: tc.startTimeUnixNano,
+            endTimeUnixNano: tc.endTimeUnixNano,
+          }));
+
+          // Analyze with LLM
+          const analysis = await analyzeSession({
+            session: sessionData,
+            metrics,
+            toolCalls,
+          });
 
-      "/api/analyze-session/:sessionId": {
-        async POST(req) {
-          const sessionId = req.params.sessionId;
+          // Persist to database
+          analysisDb.saveAnalysis(analysis);
 
+          // Generate and save embedding
           try {
-            // Import analyzer dynamically to avoid loading at startup
-            const { analyzeSession } = await import("./analysis/analyzer.js");
-
-            // Fetch session from agent server via ACP HTTP API
-            const sessionResponse = await fetch(
-              `${agentServerUrl}/sessions/${sessionId}`,
+            const { embedAnalysis } = await import("./analysis/embeddings.js");
+            const embedding = await embedAnalysis(analysis);
+            await analysisDb.saveEmbedding(analysis.session_id, embedding);
+          } catch (error) {
+            console.error(
+              `Failed to generate embedding for ${sessionId}:`,
+              error,
             );
+            // Continue - don't fail entire analysis
+          }
 
-            if (!sessionResponse.ok) {
-              if (sessionResponse.status === 404) {
-                return Response.json(
-                  { error: "Session not found" },
-                  { status: 404 },
-                );
-              }
-              throw new Error(
-                `Failed to fetch session: ${sessionResponse.statusText}`,
-              );
-            }
-
-            const sessionData = await sessionResponse.json();
-
-            // Fetch agent config to get model for cost calculation
-            const agentConfig = await fetchAgentConfig();
-            const model = agentConfig?.model || "unknown";
-
-            // Fetch metrics from OTLP spans
-            const allSpans = db.getSpansBySessionAttribute(sessionId);
-            const traces = db.listTraces(100, 0, sessionId);
-            const sessionMetrics = extractSessionMetrics(
-              traces,
-              allSpans,
-              model,
-            );
+          return Response.json(analysis);
+        } catch (error) {
+          console.error("Session analysis error:", error);
+          return Response.json(
+            {
+              error: error instanceof Error ? error.message : "Analysis failed",
+            },
+            { status: 500 },
+          );
+        }
+      },
+    },
 
-            // Convert to AnalysisMetrics format
-            const metrics = {
-              inputTokens: sessionMetrics.inputTokens,
-              outputTokens: sessionMetrics.outputTokens,
-              totalTokens: sessionMetrics.totalTokens,
-              estimatedCost: sessionMetrics.estimatedCost,
-              durationMs: sessionMetrics.durationMs,
-            };
-
-            // Convert tool calls to DetailedToolCall format
-            const toolCalls = (sessionMetrics.toolCalls || []).map((tc) => ({
-              name: tc.name,
-              input: tc.input,
-              output: tc.output,
-              startTimeUnixNano: tc.startTimeUnixNano,
-              endTimeUnixNano: tc.endTimeUnixNano,
-            }));
-
-            // Analyze with LLM
-            const analysis = await analyzeSession({
-              session: sessionData,
-              metrics,
-              toolCalls,
-            });
-
-            // Persist to database
-            analysisDb.saveAnalysis(analysis);
-
-            // Generate and save embedding
-            try {
-              const { embedAnalysis } = await import(
-                "./analysis/embeddings.js"
-              );
-              const embedding = await embedAnalysis(analysis);
-              await analysisDb.saveEmbedding(analysis.session_id, embedding);
-            } catch (error) {
-              console.error(
-                `Failed to generate embedding for ${sessionId}:`,
-                error,
-              );
-              // Continue - don't fail entire analysis
-            }
+    "/api/analyze-all-sessions": {
+      async POST(req) {
+        try {
+          const body = await req.json();
+          const { sessionIds } = body as { sessionIds: string[] };
 
-            return Response.json(analysis);
-          } catch (error) {
-            console.error("Session analysis error:", error);
+          if (!Array.isArray(sessionIds)) {
             return Response.json(
-              {
-                error:
-                  error instanceof Error ? error.message : "Analysis failed",
-              },
-              { status: 500 },
+              { error: "sessionIds must be an array" },
+              { status: 400 },
             );
           }
-        },
-      },
 
-      "/api/analyze-all-sessions": {
-        async POST(req) {
-          try {
-            const body = await req.json();
-            const { sessionIds } = body as { sessionIds: string[] };
+          // Import analyzer dynamically
+          const { analyzeSession } = await import("./analysis/analyzer.js");
 
-            if (!Array.isArray(sessionIds)) {
-              return Response.json(
-                { error: "sessionIds must be an array" },
-                { status: 400 },
-              );
-            }
+          // Fetch agent config once for all sessions
+          const agentConfig = await fetchAgentConfig();
+          const model = agentConfig?.model || "unknown";
 
-            // Import analyzer dynamically
-            const { analyzeSession } = await import("./analysis/analyzer.js");
+          // Process in batches of 25
+          const BATCH_SIZE = 25;
+          const results: Array<{
+            session_id: string;
+            success: boolean;
+            error?: string;
+          }> = [];
 
-            // Fetch agent config once for all sessions
-            const agentConfig = await fetchAgentConfig();
-            const model = agentConfig?.model || "unknown";
+          const totalBatches = Math.ceil(sessionIds.length / BATCH_SIZE);
+          console.log(
+            `✨ Starting batch analysis of ${sessionIds.length} sessions (${totalBatches} batches)...`,
+          );
 
-            // Process in batches of 25
-            const BATCH_SIZE = 25;
-            const results: Array<{
-              session_id: string;
-              success: boolean;
-              error?: string;
-            }> = [];
+          for (let i = 0; i < sessionIds.length; i += BATCH_SIZE) {
+            const batch = sessionIds.slice(i, i + BATCH_SIZE);
+            const batchNum = Math.floor(i / BATCH_SIZE) + 1;
 
-            const totalBatches = Math.ceil(sessionIds.length / BATCH_SIZE);
             console.log(
-              `✨ Starting batch analysis of ${sessionIds.length} sessions (${totalBatches} batches)...`,
+              `📊 Processing batch ${batchNum}/${totalBatches} (${batch.length} sessions)...`,
             );
 
-            for (let i = 0; i < sessionIds.length; i += BATCH_SIZE) {
-              const batch = sessionIds.slice(i, i + BATCH_SIZE);
-              const batchNum = Math.floor(i / BATCH_SIZE) + 1;
+            // Run batch in parallel
+            const batchResults = await Promise.allSettled(
+              batch.map(async (sessionId) => {
+                // Fetch session data
+                const sessionResponse = await fetch(
+                  `${agentServerUrl}/sessions/${sessionId}`,
+                );
 
-              console.log(
-                `📊 Processing batch ${batchNum}/${totalBatches} (${batch.length} sessions)...`,
-              );
+                if (!sessionResponse.ok) {
+                  throw new Error(`Failed to fetch session ${sessionId}`);
+                }
 
-              // Run batch in parallel
-              const batchResults = await Promise.allSettled(
-                batch.map(async (sessionId) => {
-                  // Fetch session data
-                  const sessionResponse = await fetch(
-                    `${agentServerUrl}/sessions/${sessionId}`,
-                  );
+                const sessionData = await sessionResponse.json();
 
-                  if (!sessionResponse.ok) {
-                    throw new Error(`Failed to fetch session ${sessionId}`);
-                  }
+                // Fetch metrics from OTLP spans
+                const allSpans = db.getSpansBySessionAttribute(sessionId);
+                const traces = db.listTraces(100, 0, sessionId);
+                const sessionMetrics = extractSessionMetrics(
+                  traces,
+                  allSpans,
+                  model,
+                );
 
-                  const sessionData = await sessionResponse.json();
+                // Convert to AnalysisMetrics format
+                const metrics = {
+                  inputTokens: sessionMetrics.inputTokens,
+                  outputTokens: sessionMetrics.outputTokens,
+                  totalTokens: sessionMetrics.totalTokens,
+                  estimatedCost: sessionMetrics.estimatedCost,
+                  durationMs: sessionMetrics.durationMs,
+                };
+
+                // Convert tool calls to DetailedToolCall format
+                const toolCalls = (sessionMetrics.toolCalls || []).map(
+                  (tc) => ({
+                    name: tc.name,
+                    input: tc.input,
+                    output: tc.output,
+                    startTimeUnixNano: tc.startTimeUnixNano,
+                    endTimeUnixNano: tc.endTimeUnixNano,
+                  }),
+                );
 
-                  // Fetch metrics from OTLP spans
-                  const allSpans = db.getSpansBySessionAttribute(sessionId);
-                  const traces = db.listTraces(100, 0, sessionId);
-                  const sessionMetrics = extractSessionMetrics(
-                    traces,
-                    allSpans,
-                    model,
-                  );
+                // Analyze
+                const analysis = await analyzeSession({
+                  session: sessionData,
+                  metrics,
+                  toolCalls,
+                });
 
-                  // Convert to AnalysisMetrics format
-                  const metrics = {
-                    inputTokens: sessionMetrics.inputTokens,
-                    outputTokens: sessionMetrics.outputTokens,
-                    totalTokens: sessionMetrics.totalTokens,
-                    estimatedCost: sessionMetrics.estimatedCost,
-                    durationMs: sessionMetrics.durationMs,
-                  };
-
-                  // Convert tool calls to DetailedToolCall format
-                  const toolCalls = (sessionMetrics.toolCalls || []).map(
-                    (tc) => ({
-                      name: tc.name,
-                      input: tc.input,
-                      output: tc.output,
-                      startTimeUnixNano: tc.startTimeUnixNano,
-                      endTimeUnixNano: tc.endTimeUnixNano,
-                    }),
+                // Persist
+                analysisDb.saveAnalysis(analysis);
+
+                // Generate and save embedding
+                try {
+                  const { embedAnalysis } = await import(
+                    "./analysis/embeddings.js"
+                  );
+                  const embedding = await embedAnalysis(analysis);
+                  await analysisDb.saveEmbedding(sessionId, embedding);
+                } catch (error) {
+                  console.error(
+                    `Failed to generate embedding for ${sessionId}:`,
+                    error,
                   );
+                  // Continue - batch processing continues
+                }
 
-                  // Analyze
-                  const analysis = await analyzeSession({
-                    session: sessionData,
-                    metrics,
-                    toolCalls,
-                  });
-
-                  // Persist
-                  analysisDb.saveAnalysis(analysis);
-
-                  // Generate and save embedding
-                  try {
-                    const { embedAnalysis } = await import(
-                      "./analysis/embeddings.js"
-                    );
-                    const embedding = await embedAnalysis(analysis);
-                    await analysisDb.saveEmbedding(sessionId, embedding);
-                  } catch (error) {
-                    console.error(
-                      `Failed to generate embedding for ${sessionId}:`,
-                      error,
-                    );
-                    // Continue - batch processing continues
-                  }
-
-                  return { session_id: sessionId, success: true };
-                }),
-              );
+                return { session_id: sessionId, success: true };
+              }),
+            );
 
-              // Collect results
-              for (let j = 0; j < batchResults.length; j++) {
-                const result = batchResults[j];
-                const sessionId = batch[j];
-                if (!sessionId) continue;
-
-                if (result && result.status === "fulfilled") {
-                  results.push(result.value);
-                } else if (result && result.status === "rejected") {
-                  results.push({
-                    session_id: sessionId,
-                    success: false,
-                    error:
-                      result.reason instanceof Error
-                        ? result.reason.message
-                        : String(result.reason || "Unknown error"),
-                  });
-                }
+            // Collect results
+            for (let j = 0; j < batchResults.length; j++) {
+              const result = batchResults[j];
+              const sessionId = batch[j];
+              if (!sessionId) continue;
+
+              if (result && result.status === "fulfilled") {
+                results.push(result.value);
+              } else if (result && result.status === "rejected") {
+                results.push({
+                  session_id: sessionId,
+                  success: false,
+                  error:
+                    result.reason instanceof Error
+                      ? result.reason.message
+                      : String(result.reason || "Unknown error"),
+                });
               }
-
-              const batchSuccesses = batchResults.filter(
-                (r) => r.status === "fulfilled",
-              ).length;
-              const batchErrors = batchResults.filter(
-                (r) => r.status === "rejected",
-              ).length;
-              console.log(
-                `✅ Batch ${batchNum}/${totalBatches} complete: ${batchSuccesses} successful, ${batchErrors} failed`,
-              );
             }
 
-            const totalSuccesses = results.filter((r) => r.success).length;
-            const totalErrors = results.filter((r) => !r.success).length;
+            const batchSuccesses = batchResults.filter(
+              (r) => r.status === "fulfilled",
+            ).length;
+            const batchErrors = batchResults.filter(
+              (r) => r.status === "rejected",
+            ).length;
             console.log(
-              `🎉 Batch analysis complete: ${totalSuccesses} successful, ${totalErrors} failed`,
-            );
-
-            return Response.json({ results });
-          } catch (error) {
-            console.error("Batch analysis error:", error);
-            return Response.json(
-              {
-                error:
-                  error instanceof Error ? error.message : "Analysis failed",
-              },
-              { status: 500 },
+              `✅ Batch ${batchNum}/${totalBatches} complete: ${batchSuccesses} successful, ${batchErrors} failed`,
             );
           }
-        },
-      },
 
-      "/api/session-analyses": {
-        async GET(req) {
-          try {
-            const url = new URL(req.url);
-            const sessionId = url.searchParams.get("sessionId");
-
-            if (sessionId) {
-              // Get single analysis
-              const analysis = analysisDb.getAnalysis(sessionId);
-              if (!analysis) {
-                return Response.json(
-                  { error: "Analysis not found" },
-                  { status: 404 },
-                );
-              }
-              return Response.json(analysis);
-            }
-
-            // List all analyses
-            const limit = Number.parseInt(
-              url.searchParams.get("limit") || "50",
-              10,
-            );
-            const offset = Number.parseInt(
-              url.searchParams.get("offset") || "0",
-              10,
-            );
+          const totalSuccesses = results.filter((r) => r.success).length;
+          const totalErrors = results.filter((r) => !r.success).length;
+          console.log(
+            `🎉 Batch analysis complete: ${totalSuccesses} successful, ${totalErrors} failed`,
+          );
 
-            const analyses = analysisDb.listAnalyses(limit, offset);
-            return Response.json({ analyses });
-          } catch (error) {
-            console.error("Error retrieving analyses:", error);
-            return Response.json(
-              {
-                error:
-                  error instanceof Error
-                    ? error.message
-                    : "Failed to retrieve analyses",
-              },
-              { status: 500 },
-            );
-          }
-        },
+          return Response.json({ results });
+        } catch (error) {
+          console.error("Batch analysis error:", error);
+          return Response.json(
+            {
+              error: error instanceof Error ? error.message : "Analysis failed",
+            },
+            { status: 500 },
+          );
+        }
       },
+    },
 
-      "/api/session-analyses/:sessionId/similar": {
-        async GET(req) {
-          try {
-            const sessionId = req.params.sessionId;
-            const url = new URL(req.url);
-            const limit = Number.parseInt(
-              url.searchParams.get("limit") || "10",
-              10,
-            );
+    "/api/session-analyses": {
+      async GET(req) {
+        try {
+          const url = new URL(req.url);
+          const sessionId = url.searchParams.get("sessionId");
 
-            // Get embedding for this session
-            const embedding = await analysisDb.getEmbedding(sessionId);
-            if (!embedding) {
+          if (sessionId) {
+            // Get single analysis
+            const analysis = analysisDb.getAnalysis(sessionId);
+            if (!analysis) {
               return Response.json(
-                { error: "No embedding found for this session" },
+                { error: "Analysis not found" },
                 { status: 404 },
               );
             }
+            return Response.json(analysis);
+          }
 
-            // Search for similar sessions
-            const similar = (
-              await analysisDb.searchSimilarSessions(embedding, limit + 1)
-            )
-              .filter((s) => s.session_id !== sessionId)
-              .slice(0, limit);
+          // List all analyses
+          const limit = Number.parseInt(
+            url.searchParams.get("limit") || "50",
+            10,
+          );
+          const offset = Number.parseInt(
+            url.searchParams.get("offset") || "0",
+            10,
+          );
 
-            return Response.json({ similar });
-          } catch (error) {
-            console.error("Error finding similar sessions:", error);
-            return Response.json(
-              {
-                error:
-                  error instanceof Error
-                    ? error.message
-                    : "Failed to find similar sessions",
-              },
-              { status: 500 },
-            );
-          }
-        },
+          const analyses = analysisDb.listAnalyses(limit, offset);
+          return Response.json({ analyses });
+        } catch (error) {
+          console.error("Error retrieving analyses:", error);
+          return Response.json(
+            {
+              error:
+                error instanceof Error
+                  ? error.message
+                  : "Failed to retrieve analyses",
+            },
+            { status: 500 },
+          );
+        }
       },
+    },
 
-      // Comparison analysis endpoints
-      "/api/analyze-comparison/:runId": {
-        async POST(req) {
-          const runId = req.params.runId;
+    "/api/session-analyses/:sessionId/similar": {
+      async GET(req) {
+        try {
+          const sessionId = req.params.sessionId;
+          const url = new URL(req.url);
+          const limit = Number.parseInt(
+            url.searchParams.get("limit") || "10",
+            10,
+          );
 
-          try {
-            // Import analyzer dynamically
-            const { analyzeComparison } = await import(
-              "./analysis/comparison-analyzer.js"
+          // Get embedding for this session
+          const embedding = await analysisDb.getEmbedding(sessionId);
+          if (!embedding) {
+            return Response.json(
+              { error: "No embedding found for this session" },
+              { status: 404 },
             );
+          }
 
-            // Get the comparison run
-            const run = comparisonDb.getRun(runId);
-            if (!run) {
-              return Response.json(
-                { error: "Comparison run not found" },
-                { status: 404 },
-              );
-            }
+          // Search for similar sessions
+          const similar = (
+            await analysisDb.searchSimilarSessions(embedding, limit + 1)
+          )
+            .filter((s) => s.session_id !== sessionId)
+            .slice(0, limit);
+
+          return Response.json({ similar });
+        } catch (error) {
+          console.error("Error finding similar sessions:", error);
+          return Response.json(
+            {
+              error:
+                error instanceof Error
+                  ? error.message
+                  : "Failed to find similar sessions",
+            },
+            { status: 500 },
+          );
+        }
+      },
+    },
 
-            // Get the comparison config
-            const config = comparisonDb.getConfig(run.configId);
-            if (!config) {
-              return Response.json(
-                { error: "Comparison config not found" },
-                { status: 404 },
-              );
-            }
+    // Comparison analysis endpoints
+    "/api/analyze-comparison/:runId": {
+      async POST(req) {
+        const runId = req.params.runId;
 
-            // Verify all sessions exist
-            if (!run.controlSessionId || !run.variantSessionId) {
-              return Response.json(
-                { error: "Comparison run is incomplete - missing session IDs" },
-                { status: 400 },
-              );
-            }
+        try {
+          // Import analyzer dynamically
+          const { analyzeComparison } = await import(
+            "./analysis/comparison-analyzer.js"
+          );
 
-            // Fetch all three sessions from agent server
-            const [originalRes, controlRes, variantRes] = await Promise.all([
-              fetch(`${agentServerUrl}/sessions/${run.sourceSessionId}`),
-              fetch(`${agentServerUrl}/sessions/${run.controlSessionId}`),
-              fetch(`${agentServerUrl}/sessions/${run.variantSessionId}`),
-            ]);
+          // Get the comparison run
+          const run = comparisonDb.getRun(runId);
+          if (!run) {
+            return Response.json(
+              { error: "Comparison run not found" },
+              { status: 404 },
+            );
+          }
 
-            if (!originalRes.ok || !controlRes.ok || !variantRes.ok) {
-              return Response.json(
-                { error: "Failed to fetch one or more sessions" },
-                { status: 500 },
-              );
-            }
+          // Get the comparison config
+          const config = comparisonDb.getConfig(run.configId);
+          if (!config) {
+            return Response.json(
+              { error: "Comparison config not found" },
+              { status: 404 },
+            );
+          }
 
-            const [originalSession, controlSession, variantSession] =
-              await Promise.all([
-                originalRes.json(),
-                controlRes.json(),
-                variantRes.json(),
-              ]);
-
-            // Get agent config for original tools and system prompt
-            const agentConfig = await fetchAgentConfig();
-
-            // Get metrics for each session
-            const getMetrics = (sessionId: string) => {
-              const spans = db.getSpansBySessionAttribute(sessionId);
-              const traces = db.listTraces(100, 0, sessionId);
-              return extractSessionMetrics(
-                traces,
-                spans,
-                agentConfig?.model || "unknown",
-              );
-            };
-
-            const originalMetrics = getMetrics(run.sourceSessionId);
-            const controlMetrics = getMetrics(run.controlSessionId);
-            const variantMetrics = getMetrics(run.variantSessionId);
-
-            // Run the comparison analysis
-            const analysis = await analyzeComparison({
-              runId,
-              hypothesis: config.hypothesis || "",
-              config,
-              originalSession,
-              controlSession,
-              variantSession,
-              originalMetrics,
-              controlMetrics,
-              variantMetrics,
-              originalSystemPrompt: agentConfig?.systemPrompt || undefined,
-              originalTools: agentConfig?.tools?.map((t) => t.name) || [],
-            });
-
-            // Save to database
-            comparisonDb.saveComparisonAnalysis(runId, analysis);
+          // Verify all sessions exist
+          if (!run.controlSessionId || !run.variantSessionId) {
+            return Response.json(
+              { error: "Comparison run is incomplete - missing session IDs" },
+              { status: 400 },
+            );
+          }
 
-            return Response.json(analysis);
-          } catch (error) {
-            console.error("Comparison analysis error:", error);
+          // Fetch all three sessions from agent server
+          const [originalRes, controlRes, variantRes] = await Promise.all([
+            fetch(`${agentServerUrl}/sessions/${run.sourceSessionId}`),
+            fetch(`${agentServerUrl}/sessions/${run.controlSessionId}`),
+            fetch(`${agentServerUrl}/sessions/${run.variantSessionId}`),
+          ]);
+
+          if (!originalRes.ok || !controlRes.ok || !variantRes.ok) {
             return Response.json(
-              {
-                error:
-                  error instanceof Error
-                    ? error.message
-                    : "Comparison analysis failed",
-              },
+              { error: "Failed to fetch one or more sessions" },
               { status: 500 },
             );
           }
-        },
-      },
 
-      "/api/comparison-analysis/:runId": {
-        async GET(req) {
-          try {
-            const runId = req.params.runId;
-            const analysis = comparisonDb.getComparisonAnalysis(runId);
+          const [originalSession, controlSession, variantSession] =
+            await Promise.all([
+              originalRes.json(),
+              controlRes.json(),
+              variantRes.json(),
+            ]);
 
-            if (!analysis) {
-              return Response.json(
-                { error: "Comparison analysis not found" },
-                { status: 404 },
-              );
-            }
+          // Get agent config for original tools and system prompt
+          const agentConfig = await fetchAgentConfig();
 
-            return Response.json(analysis);
-          } catch (error) {
-            console.error("Error fetching comparison analysis:", error);
+          // Get metrics for each session
+          const getMetrics = (sessionId: string) => {
+            const spans = db.getSpansBySessionAttribute(sessionId);
+            const traces = db.listTraces(100, 0, sessionId);
+            return extractSessionMetrics(
+              traces,
+              spans,
+              agentConfig?.model || "unknown",
+            );
+          };
+
+          const originalMetrics = getMetrics(run.sourceSessionId);
+          const controlMetrics = getMetrics(run.controlSessionId);
+          const variantMetrics = getMetrics(run.variantSessionId);
+
+          // Run the comparison analysis
+          const analysis = await analyzeComparison({
+            runId,
+            hypothesis: config.hypothesis || "",
+            config,
+            originalSession,
+            controlSession,
+            variantSession,
+            originalMetrics,
+            controlMetrics,
+            variantMetrics,
+            originalSystemPrompt: agentConfig?.systemPrompt || undefined,
+            originalTools: agentConfig?.tools?.map((t) => t.name) || [],
+          });
+
+          // Save to database
+          comparisonDb.saveComparisonAnalysis(runId, analysis);
+
+          return Response.json(analysis);
+        } catch (error) {
+          console.error("Comparison analysis error:", error);
+          return Response.json(
+            {
+              error:
+                error instanceof Error
+                  ? error.message
+                  : "Comparison analysis failed",
+            },
+            { status: 500 },
+          );
+        }
+      },
+    },
+
+    "/api/comparison-analysis/:runId": {
+      async GET(req) {
+        try {
+          const runId = req.params.runId;
+          const analysis = comparisonDb.getComparisonAnalysis(runId);
+
+          if (!analysis) {
             return Response.json(
-              {
-                error:
-                  error instanceof Error
-                    ? error.message
-                    : "Failed to fetch comparison analysis",
-              },
-              { status: 500 },
+              { error: "Comparison analysis not found" },
+              { status: 404 },
             );
           }
-        },
+
+          return Response.json(analysis);
+        } catch (error) {
+          console.error("Error fetching comparison analysis:", error);
+          return Response.json(
+            {
+              error:
+                error instanceof Error
+                  ? error.message
+                  : "Failed to fetch comparison analysis",
+            },
+            { status: 500 },
+          );
+        }
       },
+    },
 
-      "/api/comparison-analysis/:runId/exists": {
-        async GET(req) {
-          try {
-            const runId = req.params.runId;
-            const exists = comparisonDb.hasComparisonAnalysis(runId);
-            return Response.json({ exists });
-          } catch (_error) {
-            return Response.json({ exists: false });
-          }
-        },
+    "/api/comparison-analysis/:runId/exists": {
+      async GET(req) {
+        try {
+          const runId = req.params.runId;
+          const exists = comparisonDb.hasComparisonAnalysis(runId);
+          return Response.json({ exists });
+        } catch (_error) {
+          return Response.json({ exists: false });
+        }
       },
+    },
+  });
+}
+
+// Enables TypeScript to infer route path parameters. This provides the same
+// type inference that Bun.serve() uses internally.
+function defineRoutes<R extends string>(routes: Serve.Routes<undefined, R>) {
+  return routes;
+}
+
+export interface DebuggerServerOptions {
+  port?: number;
+  otlpPort?: number;
+  dbPath: string;
+  agentName?: string;
+  agentServerUrl?: string;
+}
+
+export interface DebuggerServerResult {
+  server: ReturnType<typeof serve>;
+  otlpServer: ReturnType<typeof serve>;
+  stop: () => void;
+}
 
+export function startDebuggerServer(
+  options: DebuggerServerOptions,
+): DebuggerServerResult {
+  const {
+    port = DEFAULT_DEBUGGER_PORT,
+    otlpPort = DEFAULT_OTLP_PORT,
+    dbPath,
+    agentName = "Agent",
+    agentServerUrl = "http://localhost:3100",
+  } = options;
+
+  // Start OTLP server (initializes database internally)
+  const otlpApp = createOtlpServer({ dbPath });
+  const otlpServer = serve({
+    fetch: otlpApp.fetch,
+    hostname: Bun.env.BIND_HOST || "localhost",
+    port: otlpPort,
+  });
+
+  // Create routes using the factory function
+  const routes = createDebuggerRoutes({
+    dbPath,
+    agentName,
+    agentServerUrl,
+  });
+
+  // Start debugger UI server
+  const server = serve({
+    port,
+    idleTimeout: 120, // 2 minutes for long-running LLM analysis requests
+    routes: {
+      ...routes,
       // Serve index.html for all unmatched routes (SPA routing)
       "/*": index,
     },
@@ -1056,3 +1024,54 @@ export function startDebuggerServer(
 
   return { server, otlpServer, stop };
 }
+
+// Helper to fetch agent config from an agent server
+async function fetchAgentConfigFromServer(
+  agentServerUrl: string,
+): Promise<AgentConfig | null> {
+  try {
+    // Call agent's initialize RPC to get config
+    const response = await fetch(`${agentServerUrl}/rpc`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: "debugger-config",
+        method: "initialize",
+        params: {
+          protocolVersion: 1, // ACP protocol version as number
+          clientCapabilities: {},
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      console.error("Failed to fetch agent config:", response.statusText);
+      return null;
+    }
+
+    const data = await response.json();
+
+    // Check for JSON-RPC error
+    if (data.error) {
+      console.error("Agent RPC error:", data.error);
+      return null;
+    }
+
+    const result = data.result;
+    if (!result) {
+      console.error("No result in agent response");
+      return null;
+    }
+
+    // Extract config from initialize response
+    return {
+      model: result._meta?.model || "unknown",
+      systemPrompt: result._meta?.systemPrompt || null,
+      tools: result._meta?.tools || [],
+    };
+  } catch (error) {
+    console.error("Error fetching agent config:", error);
+    return null;
+  }
+}