@tonyclaw/agent-inspector 2.0.25 → 2.0.27

package/.output/server/_ssr/{router-Cvv7SJnd.mjs → router-DCPg8ykx.mjs}

@@ -1,11 +1,11 @@
 import { c as createRouter, a as createRootRoute, b as createFileRoute, l as lazyRouteComponent, O as Outlet, H as HeadContent, S as Scripts } from "../_libs/tanstack__react-router.mjs";
 import { j as jsxRuntimeExports } from "../_libs/react.mjs";
 import { S as SWRConfig } from "../_libs/swr.mjs";
-import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync, copyFileSync, unlinkSync, readdirSync, statSync, createReadStream, cpSync, rmSync, createWriteStream } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, renameSync, copyFileSync, unlinkSync, createReadStream, readdirSync, statSync, cpSync, rmSync, createWriteStream } from "node:fs";
 import fs, { mkdir, appendFile, readFile, writeFile, readdir, open, stat, unlink, rename } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Buffer } from "node:buffer";
-import path, { join, isAbsolute, dirname } from "node:path";
+import path, { join, dirname, isAbsolute } from "node:path";
 import { execFile, exec, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { C as Conf } from "../_libs/conf.mjs";
@@ -13,9 +13,9 @@ import { randomUUID } from "crypto";
 import { promisify } from "node:util";
 import { Worker } from "node:worker_threads";
 import { randomUUID as randomUUID$1 } from "node:crypto";
-import { M as McpServer, W as WebStandardStreamableHTTPServerTransport } from "../_libs/modelcontextprotocol__server.mjs";
+import { M as McpServer, W as WebStandardStreamableHTTPServerTransport, R as ResourceTemplate } from "../_libs/modelcontextprotocol__server.mjs";
 import { homedir } from "node:os";
-import { d as object, b as string, a as array, _ as _enum, u as union, n as number, c as boolean, e as unknown, l as literal, r as record, g as discriminatedUnion, h as _null, k as lazy } from "../_libs/zod.mjs";
+import { d as object, b as string, a as array, r as record, _ as _enum, u as union, n as number, c as boolean, e as unknown, l as literal, k as lazy, g as discriminatedUnion, h as _null } from "../_libs/zod.mjs";
 import "../_libs/tiny-warning.mjs";
 import "../_libs/tanstack__router-core.mjs";
 import "../_libs/cookie-es.mjs";
@@ -51,7 +51,7 @@ import "../_libs/semver.mjs";
 import "../_libs/uint8array-extras.mjs";
 const faviconSvg = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2064%2064'%20role='img'%20aria-label='Agent%20Inspector'%3e%3crect%20width='64'%20height='64'%20rx='14'%20fill='%23111827'%20/%3e%3cg%20fill='none'%20stroke='%23f59e0b'%20stroke-width='4.2'%20stroke-linecap='round'%20stroke-linejoin='round'%3e%3cpath%20fill='%23f59e0b'%20d='M15%2036c0-11%207-18%2017-18s17%207%2017%2018c0%208-7%2013-17%2013s-17-5-17-13z'%20/%3e%3cpath%20d='M16%2031c-6-5-12-3-12%204%200%205%206%206%2011%202'%20/%3e%3cpath%20d='M48%2031c6-5%2012-3%2012%204%200%205-6%206-11%202'%20/%3e%3cpath%20d='M27%2019l-3-7'%20/%3e%3cpath%20d='M37%2019l3-7'%20/%3e%3cpath%20d='M19%2045l-6%209'%20/%3e%3cpath%20d='M27%2048l-3%209'%20/%3e%3cpath%20d='M37%2048l3%209'%20/%3e%3cpath%20d='M45%2045l6%209'%20/%3e%3c/g%3e%3cpath%20d='M14%2047l9-8%208%209c-5%203.5-12%203-17-1z'%20fill='%232f6b3f'%20opacity='.95'%20/%3e%3cpath%20d='M18%2046l5-5%205%206c-3%201.6-7%201.4-10-1z'%20fill='%236fb36f'%20opacity='.95'%20/%3e%3cpath%20d='M23%2041v10'%20fill='none'%20stroke='%23d6b45f'%20stroke-width='1.6'%20stroke-linecap='round'%20/%3e%3ccircle%20cx='31'%20cy='48'%20r='1.8'%20fill='%23c2412d'%20/%3e%3cpath%20d='M24%2044l13-11%2014%2013c-8%205.8-18%205.3-27-2z'%20fill='%232f6b3f'%20opacity='.97'%20/%3e%3cpath%20d='M30%2043l7-7%209%209c-5%202.7-11%202.5-16-2z'%20fill='%236fb36f'%20opacity='.95'%20/%3e%3cpath%20d='M37%2036v14'%20fill='none'%20stroke='%23d6b45f'%20stroke-width='2'%20stroke-linecap='round'%20/%3e%3cpath%20d='M30%2043c5-2%2011-1.5%2016%202'%20fill='none'%20stroke='%239fca78'%20stroke-width='1.8'%20stroke-linecap='round'%20/%3e%3ccircle%20cx='51'%20cy='46'%20r='2'%20fill='%23c2412d'%20/%3e%3cpath%20d='M40%2050l8-8%207%208c-4.2%203.2-10%203-15%200z'%20fill='%232f6b3f'%20opacity='.95'%20/%3e%3cpath%20d='M43%2049l5-5%204.5%205.5c-3%201.5-6%201.2-9.5-.5z'%20fill='%236fb36f'%20opacity='.95'%20/%3e%3cpath%20d='M48%2044v9'%20fill='none'%20stroke='%23d6b45f'%20stroke-width='1.5'%20stroke-linecap='round'%20/%3e%3ccircle%20cx='55'%20cy='50'%20r='1.7'%20fill='%23c2412d'%20/%3e%3ccircle%20cx='24'%20cy='11'%20r='3.2'%20fill='%23f59e0b'%20/%3e%3ccircle%20cx='40'%20cy='11'%20r='3.2'%20fill='%23f59e0b'%20/%3e%3ccircle%20cx='25'%20cy='34'%20r='2.1'%20fill='%23111827'%20/%3e%3ccircle%20cx='39'%20cy='34'%20r='2.1'%20fill='%23111827'%20/%3e%3c/svg%3e";
 const appCss = "/assets/index-DsiKfWCp.css";
-const Route$s = createRootRoute({
+const Route$v = createRootRoute({
   head: () => ({
     meta: [
       { charSet: "utf-8" },
@@ -93,8 +93,8 @@ function RootDocument({ children }) {
     ] })
   ] });
 }
-const $$splitComponentImporter$1 = () => import("./index-Ef5mCuww.mjs");
-const Route$r = createFileRoute("/")({
+const $$splitComponentImporter$1 = () => import("./index-Dik2Mc3h.mjs");
+const Route$u = createFileRoute("/")({
   component: lazyRouteComponent($$splitComponentImporter$1, "component")
 });
 const B64URL_RE = /^[A-Za-z0-9_-]+$/;
@@ -136,8 +136,8 @@ function decodeSessionIdFromPath(encoded) {
 function getSessionPath(sessionId) {
   return `/session/${encodeSessionIdForPath(sessionId)}`;
 }
-const $$splitComponentImporter = () => import("../_sessionId-CYKaI68v.mjs");
-const Route$q = createFileRoute("/session/$sessionId")({
+const $$splitComponentImporter = () => import("../_sessionId-DZH8SrEZ.mjs");
+const Route$t = createFileRoute("/session/$sessionId")({
   component: lazyRouteComponent($$splitComponentImporter, "component"),
   parseParams: (params) => ({
     sessionId: decodeSessionIdFromPath(params.sessionId)
@@ -1030,6 +1030,184 @@ function getCurrentLogFile() {
   const dd = String(now.getUTCDate()).padStart(2, "0");
   return `${yyyy}-${mm}-${dd}.jsonl`;
 }
+const SESSION_INFO_DEFAULT_LATEST_LOG_LIMIT = 10;
+const SESSION_INFO_MAX_LATEST_LOG_LIMIT = 50;
+function clampSessionInfoLogLimit(input) {
+  if (input === void 0) return SESSION_INFO_DEFAULT_LATEST_LOG_LIMIT;
+  if (!Number.isFinite(input) || input < 1) return 1;
+  return Math.min(Math.floor(input), SESSION_INFO_MAX_LATEST_LOG_LIMIT);
+}
+function normalizeString(value) {
+  if (value === null || value === void 0 || value.length === 0) return null;
+  return value;
+}
+function truncateError(value) {
+  const normalized = normalizeString(value);
+  if (normalized === null) return null;
+  if (normalized.length <= 500) return normalized;
+  return `${normalized.slice(0, 500)}...`;
+}
+function hasLogError(log) {
+  const error = normalizeString(log.error);
+  if (error !== null) return true;
+  return log.responseStatus !== null && log.responseStatus >= 400;
+}
+function buildSessionLogSummary(log) {
+  return {
+    id: log.id,
+    timestamp: log.timestamp,
+    provider: normalizeString(log.providerName),
+    model: normalizeString(log.model),
+    apiFormat: log.apiFormat,
+    method: log.method,
+    path: log.path,
+    status: log.responseStatus,
+    isStreaming: log.streaming,
+    hasError: hasLogError(log),
+    error: truncateError(log.error),
+    latencyMs: log.elapsedMs,
+    tokens: {
+      input: log.inputTokens,
+      output: log.outputTokens,
+      cacheCreate: log.cacheCreationInputTokens,
+      cacheRead: log.cacheReadInputTokens
+    },
+    sessionId: normalizeString(log.sessionId)
+  };
+}
+function nonNegativeInteger(value) {
+  if (value === null || !Number.isFinite(value) || value < 0) return 0;
+  return Math.floor(value);
+}
+function addTokenUsage(total, summary) {
+  const input = nonNegativeInteger(summary.tokens.input);
+  const output = nonNegativeInteger(summary.tokens.output);
+  const cacheCreate = nonNegativeInteger(summary.tokens.cacheCreate);
+  const cacheRead = nonNegativeInteger(summary.tokens.cacheRead);
+  return {
+    input: total.input + input,
+    output: total.output + output,
+    cacheCreate: total.cacheCreate + cacheCreate,
+    cacheRead: total.cacheRead + cacheRead,
+    total: total.total + input + output + cacheCreate + cacheRead
+  };
+}
+function buildRelativePath(pathname, params) {
+  const query = params.toString();
+  return query.length > 0 ? `${pathname}?${query}` : pathname;
+}
+function buildAbsoluteUrl(baseUrl, path2) {
+  try {
+    return new URL(path2, baseUrl).toString();
+  } catch {
+    return path2;
+  }
+}
+function buildApiPath(sessionId) {
+  return buildRelativePath("/api/sessions", new URLSearchParams({ sessionId }));
+}
+function buildCompactLogsPath(sessionId) {
+  return buildRelativePath("/api/logs", new URLSearchParams({ compact: "1", sessionId }));
+}
+function collectSortedValues(values) {
+  const set = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (value !== null && value.length > 0) {
+      set.add(value);
+    }
+  }
+  return [...set].sort();
+}
+function countCompletedLogs(summaries) {
+  let count = 0;
+  for (const summary of summaries) {
+    if (summary.status !== null || summary.latencyMs !== null) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function countErrorLogs(summaries) {
+  let count = 0;
+  for (const summary of summaries) {
+    if (summary.hasError) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function deriveSessionStatus(input) {
+  if (input.activeRequests > 0 || input.runningTasks > 0) return "active";
+  if (input.failedRequests > 0 || input.errorCount > 0 || input.lastTaskError !== null) {
+    return "failed";
+  }
+  if (input.completedRequests > 0 || input.logCount > 0) return "completed";
+  return "empty";
+}
+function buildSessionInfo(input) {
+  const latestLogLimit = clampSessionInfoLogLimit(input.latestLogLimit);
+  const summaries = [...input.summaries].sort((left, right) => right.id - left.id);
+  const latestLog = summaries[0] ?? null;
+  const oldestLog = summaries.length > 0 ? summaries[summaries.length - 1] : null;
+  const logCount = input.logCoverage === "history" ? summaries.length : Math.max(input.snapshot?.requestCount ?? 0, summaries.length);
+  const errorCount = Math.max(countErrorLogs(summaries), input.snapshot?.failedRequests ?? 0);
+  const completedLogCount = countCompletedLogs(summaries);
+  const tokenUsage = summaries.reduce(
+    (total, summary) => addTokenUsage(total, summary),
+    { input: 0, output: 0, cacheCreate: 0, cacheRead: 0, total: 0 }
+  );
+  const requestCount = Math.max(input.snapshot?.requestCount ?? 0, logCount);
+  const activeRequests = input.snapshot?.activeRequests ?? 0;
+  const completedRequests = Math.max(input.snapshot?.completedRequests ?? 0, completedLogCount);
+  const failedRequests = Math.max(input.snapshot?.failedRequests ?? 0, errorCount);
+  const queuedTasks = input.snapshot?.queuedTasks ?? 0;
+  const runningTasks = input.snapshot?.runningTasks ?? 0;
+  const lastTaskError = normalizeString(input.snapshot?.lastTaskError);
+  const inspectorPath = getSessionPath(input.sessionId);
+  const apiPath = buildApiPath(input.sessionId);
+  const compactLogsPath = buildCompactLogsPath(input.sessionId);
+  return {
+    id: input.sessionId,
+    status: deriveSessionStatus({
+      activeRequests,
+      runningTasks,
+      failedRequests,
+      errorCount,
+      lastTaskError,
+      completedRequests,
+      logCount
+    }),
+    logCoverage: input.logCoverage,
+    source: input.snapshot?.source ?? null,
+    runtimeMode: input.snapshot?.runtimeMode ?? null,
+    createdAt: input.snapshot?.createdAt ?? oldestLog?.timestamp ?? null,
+    updatedAt: input.snapshot?.updatedAt ?? latestLog?.timestamp ?? null,
+    requestCount,
+    activeRequests,
+    completedRequests,
+    failedRequests,
+    queuedTasks,
+    runningTasks,
+    lastTaskError,
+    logCount,
+    errorCount,
+    models: collectSortedValues(summaries.map((summary) => summary.model)),
+    providers: collectSortedValues(summaries.map((summary) => summary.provider)),
+    tokenUsage,
+    lastLogId: input.snapshot?.lastLogId ?? latestLog?.id ?? null,
+    lastModel: normalizeString(input.snapshot?.lastModel) ?? latestLog?.model ?? null,
+    clientPid: input.snapshot?.clientPid ?? null,
+    clientProjectFolder: normalizeString(input.snapshot?.clientProjectFolder),
+    inspectorPath,
+    inspectorUrl: buildAbsoluteUrl(input.baseUrl, inspectorPath),
+    apiPath,
+    apiUrl: buildAbsoluteUrl(input.baseUrl, apiPath),
+    compactLogsPath,
+    compactLogsUrl: buildAbsoluteUrl(input.baseUrl, compactLogsPath),
+    latestLogLimit,
+    latestLogs: summaries.slice(0, latestLogLimit)
+  };
+}
 const IDLE_TIMEOUT_MS = Number(process.env["SESSION_PROCESS_IDLE_MS"]) || 5 * 60 * 1e3;
 const MAX_RESTARTS = 3;
 const _processes = /* @__PURE__ */ new Map();
@@ -1222,11 +1400,14 @@ function upsertSession(log, sourceOverride) {
   if (source === null) return null;
   const existing = sessions.get(identity.id);
   const session = existing ?? createSessionRecord(identity.id, source, log);
-  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  session.lastLogId = log.id;
-  session.lastModel = log.model ?? session.lastModel;
-  session.clientPid = log.clientPid ?? session.clientPid;
-  session.clientProjectFolder = log.clientProjectFolder ?? session.clientProjectFolder;
+  const isSameOrNewerLog = session.lastLogId === null || log.id >= session.lastLogId;
+  if (isSameOrNewerLog) {
+    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    session.lastLogId = log.id;
+    session.lastModel = log.model ?? session.lastModel;
+    session.clientPid = log.clientPid ?? session.clientPid;
+    session.clientProjectFolder = log.clientProjectFolder ?? session.clientProjectFolder;
+  }
   sessions.set(identity.id, session);
   return session;
 }
@@ -1644,6 +1825,53 @@ async function listLogsPage(options) {
     limit: options.limit
   };
 }
+function findSessionSnapshot(sessionId) {
+  for (const snapshot of getSessionSnapshots()) {
+    if (snapshot.id === sessionId) return snapshot;
+  }
+  return null;
+}
+async function collectSessionLogSummaries(sessionId, includeHistory) {
+  const summariesById = /* @__PURE__ */ new Map();
+  const observeMatchingLog = (log) => {
+    if (!matchesLogFilters(log, sessionId, void 0)) return;
+    summariesById.set(log.id, buildSessionLogSummary(log));
+  };
+  if (includeHistory) {
+    await visitPersistedLogs((log) => {
+      observeSessionLog(log);
+      observeMatchingLog(log);
+    });
+  }
+  for (const log of memoryCache.values()) {
+    observeMatchingLog(log);
+  }
+  return [...summariesById.values()];
+}
+async function includeSnapshotLastLogSummary(sessionId, snapshot, summaries) {
+  if (snapshot === null || snapshot.lastLogId === null) return summaries;
+  for (const summary of summaries) {
+    if (summary.id === snapshot.lastLogId) return summaries;
+  }
+  const log = await getLogById(snapshot.lastLogId);
+  if (log === null || !matchesLogFilters(log, sessionId, void 0)) return summaries;
+  return [...summaries, buildSessionLogSummary(log)];
+}
+async function getSessionInfo(sessionId, options) {
+  const includeHistory = options.includeHistory === true;
+  const collectedSummaries = await collectSessionLogSummaries(sessionId, includeHistory);
+  const snapshot = findSessionSnapshot(sessionId);
+  const summaries = includeHistory ? collectedSummaries : await includeSnapshotLastLogSummary(sessionId, snapshot, collectedSummaries);
+  if (snapshot === null && summaries.length === 0) return null;
+  return buildSessionInfo({
+    sessionId,
+    baseUrl: options.baseUrl,
+    snapshot,
+    summaries,
+    logCoverage: includeHistory ? "history" : "recent",
+    latestLogLimit: options.latestLogLimit
+  });
+}
 function getSessions() {
   return getSessionIds();
 }
@@ -4644,7 +4872,7 @@ async function handleProxy(req) {
   }
   return handleStreamingResponse(upstreamRes, req, startTime, upstreamUrl, log, captureFullDetails);
 }
-const Route$p = createFileRoute("/proxy/$")({
+const Route$s = createFileRoute("/proxy/$")({
   server: {
     handlers: {
       GET: ({ request }) => handleProxy(request),
@@ -4656,11 +4884,35 @@ const Route$p = createFileRoute("/proxy/$")({
     }
   }
 });
-const Route$o = createFileRoute("/api/sessions")({
+function parsePositiveInt$2(value) {
+  if (value === null) return void 0;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) return void 0;
+  return parsed;
+}
+function parseBooleanFlag(value) {
+  return value === "1" || value === "true";
+}
+const Route$r = createFileRoute("/api/sessions")({
   server: {
     handlers: {
-      GET: ({ request }) => {
+      GET: async ({ request }) => {
         const url = new URL(request.url);
+        const sessionId = url.searchParams.get("sessionId");
+        if (sessionId !== null) {
+          if (sessionId.length === 0) {
+            return Response.json({ error: "sessionId is required" }, { status: 400 });
+          }
+          const info = await getSessionInfo(sessionId, {
+            baseUrl: url.origin,
+            includeHistory: parseBooleanFlag(url.searchParams.get("includeHistory")),
+            latestLogLimit: parsePositiveInt$2(url.searchParams.get("limit"))
+          });
+          if (info === null) {
+            return Response.json({ error: "Session not found" }, { status: 404 });
+          }
+          return Response.json(info);
+        }
         const details = url.searchParams.get("details");
         if (details === "true" || details === "1") {
           return Response.json(getSessionSnapshots());
@@ -4670,6 +4922,415 @@ const Route$o = createFileRoute("/api/sessions")({
     }
   }
 });
+const SessionTokenUsageSchema = object({
+  input: number().int().nonnegative(),
+  output: number().int().nonnegative(),
+  cacheCreate: number().int().nonnegative(),
+  cacheRead: number().int().nonnegative(),
+  total: number().int().nonnegative()
+});
+const SessionLogSummarySchema = object({
+  id: number().int().positive(),
+  timestamp: string(),
+  provider: string().nullable(),
+  model: string().nullable(),
+  apiFormat: _enum(["anthropic", "openai", "unknown"]),
+  method: string(),
+  path: string(),
+  status: number().nullable(),
+  isStreaming: boolean(),
+  hasError: boolean(),
+  error: string().nullable(),
+  latencyMs: number().nullable(),
+  tokens: object({
+    input: number().nullable(),
+    output: number().nullable(),
+    cacheCreate: number().nullable(),
+    cacheRead: number().nullable()
+  }),
+  sessionId: string().nullable()
+});
+const SessionInfoSchema = object({
+  id: string(),
+  status: _enum(["active", "failed", "completed", "empty"]),
+  logCoverage: _enum(["recent", "history"]),
+  source: _enum(["explicit", "client-process", "client-connection", "provider-test"]).nullable(),
+  runtimeMode: _enum(["in-process", "worker-thread", "child-process"]).nullable(),
+  createdAt: string().nullable(),
+  updatedAt: string().nullable(),
+  requestCount: number().int().nonnegative(),
+  activeRequests: number().int().nonnegative(),
+  completedRequests: number().int().nonnegative(),
+  failedRequests: number().int().nonnegative(),
+  queuedTasks: number().int().nonnegative(),
+  runningTasks: number().int().nonnegative(),
+  lastTaskError: string().nullable(),
+  logCount: number().int().nonnegative(),
+  errorCount: number().int().nonnegative(),
+  models: array(string()),
+  providers: array(string()),
+  tokenUsage: SessionTokenUsageSchema,
+  lastLogId: number().nullable(),
+  lastModel: string().nullable(),
+  clientPid: number().nullable(),
+  clientProjectFolder: string().nullable(),
+  inspectorPath: string(),
+  inspectorUrl: string(),
+  apiPath: string(),
+  apiUrl: string(),
+  compactLogsPath: string(),
+  compactLogsUrl: string(),
+  latestLogLimit: number().int().positive(),
+  latestLogs: array(SessionLogSummarySchema)
+});
+const InspectorRunStatusSchema = _enum([
+  "created",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+const InspectorRunEvidenceSchema = object({
+  jsonPath: string(),
+  markdownPath: string(),
+  htmlPath: string(),
+  exportedAt: string()
+});
+const RunTimelineEventKindSchema = _enum([
+  "run-created",
+  "session-started",
+  "request",
+  "session-finished",
+  "evidence-exported"
+]);
+const RunTimelineEventSeveritySchema = _enum(["info", "success", "warning", "error"]);
+const RunTimelineEventSchema = object({
+  timestamp: string(),
+  kind: RunTimelineEventKindSchema,
+  severity: RunTimelineEventSeveritySchema,
+  title: string(),
+  details: string(),
+  logId: number().int().positive().nullable(),
+  status: number().nullable(),
+  model: string().nullable(),
+  provider: string().nullable(),
+  latencyMs: number().nullable(),
+  isStreaming: boolean().nullable()
+});
+const FailureCategorySchema = _enum([
+  "none",
+  "active",
+  "provider-timeout",
+  "provider-http-error",
+  "provider-auth-error",
+  "provider-rate-limit",
+  "network-or-container",
+  "streaming-mismatch",
+  "context-pressure",
+  "runtime-task-error",
+  "model-output-error",
+  "unknown-failure",
+  "no-session-data"
+]);
+const FailureClassificationSchema = object({
+  outcome: _enum(["success", "failure", "active", "unknown"]),
+  severity: _enum(["none", "low", "medium", "high"]),
+  category: FailureCategorySchema,
+  summary: string(),
+  evidenceLogIds: array(number().int().positive()),
+  hints: array(string())
+});
+const JenkinsReportSchema = object({
+  status: _enum(["PASS", "FAIL", "RUNNING", "UNKNOWN"]),
+  summary: string(),
+  markdown: string()
+});
+const InspectorRunSchema = object({
+  id: string(),
+  sessionId: string(),
+  title: string(),
+  task: string().nullable(),
+  project: string().nullable(),
+  agent: string().nullable(),
+  status: InspectorRunStatusSchema,
+  tags: array(string()),
+  metadata: record(string(), JsonValueSchema),
+  evidence: InspectorRunEvidenceSchema.nullable(),
+  createdAt: string(),
+  updatedAt: string()
+});
+const CreateInspectorRunInputSchema = object({
+  runId: string().min(1).optional(),
+  sessionId: string().min(1).optional(),
+  title: string().min(1).optional(),
+  task: string().nullable().optional(),
+  project: string().nullable().optional(),
+  agent: string().nullable().optional(),
+  status: InspectorRunStatusSchema.optional(),
+  tags: array(string()).optional(),
+  metadata: record(string(), JsonValueSchema).optional()
+}).optional();
+const UpdateInspectorRunInputSchema = object({
+  sessionId: string().min(1).optional(),
+  title: string().min(1).optional(),
+  task: string().nullable().optional(),
+  project: string().nullable().optional(),
+  agent: string().nullable().optional(),
+  status: InspectorRunStatusSchema.optional(),
+  tags: array(string()).optional(),
+  metadata: record(string(), JsonValueSchema).optional()
+});
+const EvidenceExportOptionsSchema = object({
+  includeHistory: boolean().optional(),
+  latestLogLimit: number().int().positive().max(50).optional()
+}).optional();
+const EvidenceExportResultSchema = object({
+  run: InspectorRunSchema,
+  evidence: InspectorRunEvidenceSchema,
+  session: SessionInfoSchema.nullable(),
+  timeline: array(RunTimelineEventSchema),
+  classification: FailureClassificationSchema,
+  jenkinsReport: JenkinsReportSchema
+});
+const RecentFailureSchema = object({
+  run: InspectorRunSchema,
+  classification: FailureClassificationSchema,
+  evidence: InspectorRunEvidenceSchema.nullable(),
+  jenkinsReport: JenkinsReportSchema.nullable(),
+  sessionId: string(),
+  inspectorUrl: string().nullable(),
+  evidenceMarkdownPath: string().nullable(),
+  updatedAt: string()
+});
+const RecentFailuresResponseSchema = object({
+  failures: array(RecentFailureSchema),
+  total: number().int().nonnegative(),
+  limit: number().int().positive()
+});
+const RunsFileSchema = object({
+  runs: array(InspectorRunSchema)
+});
+function runsFilePath() {
+  return join(getDataDir(), "runs.json");
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function stableId(input) {
+  return input.trim().replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+function createRunId() {
+  return `run_${Date.now().toString(36)}_${randomUUID$1().slice(0, 8)}`;
+}
+function normalizeRunId(input) {
+  if (input === void 0) return createRunId();
+  const normalized = stableId(input);
+  return normalized.length > 0 ? normalized : createRunId();
+}
+function normalizeSessionId(input, runId) {
+  if (input === void 0 || input.trim().length === 0) return runId;
+  return input.trim();
+}
+function readRuns() {
+  const filePath = runsFilePath();
+  if (!existsSync(filePath)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    const result = RunsFileSchema.safeParse(parsed);
+    return result.success ? result.data.runs : [];
+  } catch {
+    return [];
+  }
+}
+function writeRuns(runs) {
+  const filePath = runsFilePath();
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify({ runs }, null, 2)}
+`, "utf8");
+}
+function listRuns() {
+  return readRuns().sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+function getRun(runId) {
+  return readRuns().find((run) => run.id === runId) ?? null;
+}
+function createRun(input) {
+  const parsed = CreateInspectorRunInputSchema.parse(input);
+  const runId = normalizeRunId(parsed?.runId);
+  const existing = getRun(runId);
+  if (existing !== null) return existing;
+  const timestamp = nowIso();
+  const sessionId = normalizeSessionId(parsed?.sessionId, runId);
+  const run = {
+    id: runId,
+    sessionId,
+    title: parsed?.title ?? `Inspector Run ${runId}`,
+    task: parsed?.task ?? null,
+    project: parsed?.project ?? null,
+    agent: parsed?.agent ?? null,
+    status: parsed?.status ?? "created",
+    tags: parsed?.tags ?? [],
+    metadata: parsed?.metadata ?? {},
+    evidence: null,
+    createdAt: timestamp,
+    updatedAt: timestamp
+  };
+  writeRuns([...readRuns(), run]);
+  return run;
+}
+function updateRunEvidence(runId, evidence) {
+  const runs = readRuns();
+  let updatedRun = null;
+  const updatedRuns = runs.map((run) => {
+    if (run.id !== runId) return run;
+    updatedRun = {
+      ...run,
+      evidence,
+      updatedAt: evidence.exportedAt
+    };
+    return updatedRun;
+  });
+  if (updatedRun === null) return null;
+  writeRuns(updatedRuns);
+  return updatedRun;
+}
+function updateRun(runId, input) {
+  const parsed = UpdateInspectorRunInputSchema.parse(input);
+  const runs = readRuns();
+  let updatedRun = null;
+  const updatedAt = nowIso();
+  const updatedRuns = runs.map((run) => {
+    if (run.id !== runId) return run;
+    updatedRun = {
+      ...run,
+      sessionId: parsed.sessionId === void 0 ? run.sessionId : normalizeSessionId(parsed.sessionId, run.id),
+      title: parsed.title ?? run.title,
+      task: parsed.task === void 0 ? run.task : parsed.task,
+      project: parsed.project === void 0 ? run.project : parsed.project,
+      agent: parsed.agent === void 0 ? run.agent : parsed.agent,
+      status: parsed.status ?? run.status,
+      tags: parsed.tags ?? run.tags,
+      metadata: parsed.metadata === void 0 ? run.metadata : { ...run.metadata, ...parsed.metadata },
+      updatedAt
+    };
+    return updatedRun;
+  });
+  if (updatedRun === null) return null;
+  writeRuns(updatedRuns);
+  return updatedRun;
+}
+const RECENT_FAILURES_DEFAULT_LIMIT = 5;
+const RECENT_FAILURES_MAX_LIMIT = 20;
+function clampRecentFailuresLimit(value) {
+  if (!Number.isInteger(value) || value < 1) return RECENT_FAILURES_DEFAULT_LIMIT;
+  return Math.min(value, RECENT_FAILURES_MAX_LIMIT);
+}
+function readEvidenceDocument(run) {
+  const path2 = run.evidence?.jsonPath;
+  if (path2 === void 0 || !existsSync(path2)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path2, "utf8"));
+    const result = EvidenceExportResultSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}
+function syntheticFailedClassification(run) {
+  return {
+    outcome: "failure",
+    severity: "high",
+    category: "unknown-failure",
+    summary: `Run ${run.id} is marked ${run.status}, but no exported evidence document was available.`,
+    evidenceLogIds: [],
+    hints: [
+      "Call inspector_export_evidence for this run to collect session metrics, failing log ids, and artifact paths.",
+      "Confirm the run's sessionId matches the coding agent traffic captured by Inspector."
+    ]
+  };
+}
+function shouldIncludeRun(run, document, classification) {
+  if (run.status === "failed" || run.status === "cancelled") return true;
+  if (document === null) return false;
+  return classification.outcome !== "success";
+}
+function evidenceFor(run, document) {
+  return document?.evidence ?? run.evidence;
+}
+function jenkinsReportFor(document) {
+  return document?.jenkinsReport ?? null;
+}
+function failureFromRun(run) {
+  const document = readEvidenceDocument(run);
+  const classification = document === null ? syntheticFailedClassification(run) : document.classification;
+  if (!shouldIncludeRun(run, document, classification)) return null;
+  const evidence = evidenceFor(run, document);
+  return {
+    run,
+    classification,
+    evidence,
+    jenkinsReport: jenkinsReportFor(document),
+    sessionId: run.sessionId,
+    inspectorUrl: document?.session?.inspectorUrl ?? null,
+    evidenceMarkdownPath: evidence?.markdownPath ?? null,
+    updatedAt: evidence?.exportedAt ?? run.updatedAt
+  };
+}
+function listRecentFailures(limit) {
+  const failures = listRuns().map(failureFromRun).filter((failure) => failure !== null).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+  const clampedLimit = clampRecentFailuresLimit(limit);
+  return {
+    failures: failures.slice(0, clampedLimit),
+    total: failures.length,
+    limit: clampedLimit
+  };
+}
+async function readJsonBody$2(request) {
+  try {
+    const raw = await request.text();
+    if (raw.trim().length === 0) return { ok: true, value: void 0 };
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    return { ok: false };
+  }
+}
+function parsePositiveInt$1(value, fallback) {
+  if (value === null) return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) return fallback;
+  return parsed;
+}
+const Route$q = createFileRoute("/api/runs")({
+  server: {
+    handlers: {
+      GET: ({ request }) => {
+        const url = new URL(request.url);
+        if (url.searchParams.get("failures") === "1") {
+          const limit = parsePositiveInt$1(
+            url.searchParams.get("limit"),
+            RECENT_FAILURES_DEFAULT_LIMIT
+          );
+          return Response.json(listRecentFailures(limit));
+        }
+        return Response.json({ runs: listRuns() });
+      },
+      POST: async ({ request }) => {
+        const body = await readJsonBody$2(request);
+        if (!body.ok) {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+        const parsed = CreateInspectorRunInputSchema.safeParse(body.value);
+        if (!parsed.success) {
+          return Response.json(
+            { error: "Invalid request body", details: parsed.error.format() },
+            { status: 400 }
+          );
+        }
+        return Response.json(createRun(parsed.data), { status: 201 });
+      }
+    }
+  }
+});
 const ProviderInputSchema = object({
   name: string().min(1, "Name is required"),
   apiKey: string().min(1, "API key is required"),
@@ -4684,7 +5345,7 @@ const ProviderInputSchema = object({
   modelMetadata: array(ProviderModelMetadataSchema).optional(),
   source: _enum(["company", "personal"]).optional()
 });
-const Route$n = createFileRoute("/api/providers")({
+const Route$p = createFileRoute("/api/providers")({
   server: {
     handlers: {
       GET: ({ request }) => {
@@ -4718,7 +5379,7 @@ const Route$n = createFileRoute("/api/providers")({
     }
   }
 });
-const Route$m = createFileRoute("/api/models")({
+const Route$o = createFileRoute("/api/models")({
   server: {
     handlers: {
       GET: () => Response.json(getModels())
@@ -4881,6 +5542,14 @@ const LogsListResponseSchema = object({
   offset: number().optional(),
   limit: number().optional()
 });
+const SearchLogsResponseSchema = object({
+  query: string(),
+  logs: array(CapturedLogSchema),
+  total: number(),
+  offset: number(),
+  limit: number(),
+  scanned: number().optional()
+});
 const PAGINATION_DEFAULTS = { offset: 0, limit: 3 };
 const LIMIT_HARD_CAP = 5;
 const LOG_DETAIL_TEXT_LIMIT = 2e5;
@@ -4985,6 +5654,33 @@ async function listLogsImpl(callApi2, args) {
   const logs = parsed.data.logs ?? [];
   return textJson(logs.map(buildLogSummary));
 }
+async function searchLogsImpl(callApi2, args) {
+  const offset = args.offset ?? PAGINATION_DEFAULTS.offset;
+  const limit = clampLimit(args.limit);
+  const params = new URLSearchParams({
+    q: args.query ?? "",
+    offset: String(offset),
+    limit: String(limit)
+  });
+  if (args.scanLimit !== void 0) {
+    params.set("scanLimit", String(args.scanLimit));
+  }
+  if (args.sessionId !== void 0 && args.sessionId.length > 0) {
+    params.set("sessionId", args.sessionId);
+  }
+  if (args.model !== void 0 && args.model.length > 0) {
+    params.set("model", args.model);
+  }
+  const res = await callApi2(`/api/logs?${params.toString()}`);
+  if (!res.ok) return toolError(`GET /api/logs search returned ${res.status}`);
+  const rawBody = await res.json();
+  const parsed = SearchLogsResponseSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("GET /api/logs search returned an unparseable shape");
+  return textJson({
+    ...parsed.data,
+    logs: parsed.data.logs.map(buildLogSummary)
+  });
+}
 async function getLogImpl(callApi2, id) {
   const res = await callApi2(`/api/logs/${id}`);
   if (!res.ok) return toolError(`GET /api/logs/${id} returned ${res.status}`);
@@ -5005,6 +5701,87 @@ async function listSessionsImpl(callApi2) {
   if (!res.ok) return toolError(`GET /api/sessions returned ${res.status}`);
   return textJson(await res.json());
 }
+async function getSessionImpl(callApi2, args) {
+  const params = new URLSearchParams({ sessionId: args.sessionId });
+  if (args.latestLogLimit !== void 0) {
+    params.set("limit", String(args.latestLogLimit));
+  }
+  if (args.includeHistory === true) {
+    params.set("includeHistory", "1");
+  }
+  const path2 = `/api/sessions?${params.toString()}`;
+  const res = await callApi2(path2);
+  if (!res.ok) return toolError(`GET ${path2} returned ${res.status}`);
+  const rawBody = await res.json();
+  const parsed = SessionInfoSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("GET /api/sessions returned an unparseable session info");
+  return textJson(parsed.data);
+}
+async function createRunImpl(callApi2, args) {
+  const res = await callApi2("/api/runs", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(args ?? {})
+  });
+  if (!res.ok) return toolError(`POST /api/runs returned ${res.status}`);
+  const rawBody = await res.json();
+  const parsed = InspectorRunSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("POST /api/runs returned an unparseable run");
+  return textJson(parsed.data);
+}
+async function getRunImpl(callApi2, args) {
+  const path2 = `/api/runs/${encodeURIComponent(args.runId)}`;
+  const res = await callApi2(path2);
+  if (!res.ok) return toolError(`GET ${path2} returned ${res.status}`);
+  const rawBody = await res.json();
+  const parsed = InspectorRunSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("GET /api/runs/{runId} returned an unparseable run");
+  return textJson(parsed.data);
+}
+async function updateRunImpl(callApi2, args) {
+  const { runId, ...patch } = args;
+  const path2 = `/api/runs/${encodeURIComponent(runId)}`;
+  const res = await callApi2(path2, {
+    method: "PATCH",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(patch)
+  });
+  if (!res.ok) return toolError(`PATCH ${path2} returned ${res.status}`);
+  const rawBody = await res.json();
+  const parsed = InspectorRunSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("PATCH /api/runs/{runId} returned an unparseable run");
+  return textJson(parsed.data);
+}
+async function getRecentFailuresImpl(callApi2, args) {
+  const limit = args.limit ?? 5;
+  const params = new URLSearchParams({ failures: "1", limit: String(limit) });
+  const res = await callApi2(`/api/runs?${params.toString()}`);
+  if (!res.ok) return toolError(`GET /api/runs?failures=1 returned ${res.status}`);
+  const rawBody = await res.json();
+  const parsed = RecentFailuresResponseSchema.safeParse(rawBody);
+  if (!parsed.success) {
+    return toolError("GET /api/runs?failures=1 returned an unparseable failure list");
+  }
+  return textJson(parsed.data);
+}
+async function exportEvidenceImpl(callApi2, args) {
+  const path2 = `/api/runs/${encodeURIComponent(args.runId)}/evidence`;
+  const res = await callApi2(path2, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      includeHistory: args.includeHistory,
+      latestLogLimit: args.latestLogLimit
+    })
+  });
+  if (!res.ok) return toolError(`POST ${path2} returned ${res.status}`);
+  const rawBody = await res.json();
+  const parsed = EvidenceExportResultSchema.safeParse(rawBody);
+  if (!parsed.success) {
+    return toolError("POST /api/runs/{runId}/evidence returned an unparseable evidence result");
+  }
+  return textJson(parsed.data);
+}
 async function listModelsImpl(callApi2) {
   const res = await callApi2("/api/models");
   if (!res.ok) return toolError(`GET /api/models returned ${res.status}`);
@@ -5135,9 +5912,11 @@ let initPromise = null;
 function buildServer() {
   const server = new McpServer(
     { name: "agent-inspector", version: "1.0.0" },
-    { capabilities: { tools: {} } }
+    { capabilities: { tools: {}, resources: {}, prompts: {} } }
   );
   registerTools(server);
+  registerResources(server);
+  registerPrompts(server);
   const transport = new WebStandardStreamableHTTPServerTransport({
     sessionIdGenerator: void 0
     // stateless — see module docstring
@@ -5185,6 +5964,129 @@ Returns: array of "thick summary" objects, each containing:
 
 Either preview field is null when the body is unknown format, unparseable, or the relevant content is non-text (e.g., image-only).`;
 const PROVIDER_WRITE_WARNING = "⚠ This tool mutates provider configuration. Confirm with the user before invoking.";
+const RunsListResponseSchema = object({
+  runs: array(InspectorRunSchema)
+});
+const LogResourceListResponseSchema = object({
+  logs: array(object({ id: number().int().positive() }))
+});
+const EvidenceReadResponseSchema = object({
+  markdown: string()
+});
+function textResource(uri, mimeType, text) {
+  return {
+    contents: [{ uri: uri.href, mimeType, text }]
+  };
+}
+function jsonResource(uri, data) {
+  return textResource(uri, "application/json", JSON.stringify(data, null, 2));
+}
+function variableString(variables, name) {
+  const value = variables[name];
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value ?? null;
+}
+function listResult(resources) {
+  return { resources };
+}
+async function readApiJsonResource(uri, path2) {
+  try {
+    const response = await callApi(path2);
+    if (!response.ok) {
+      return textResource(uri, "text/plain", `GET ${path2} returned ${response.status}`);
+    }
+    return jsonResource(uri, await response.json());
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return textResource(uri, "text/plain", `Resource read failed: ${message}`);
+  }
+}
+async function listSessionResources() {
+  try {
+    const response = await callApi("/api/sessions");
+    if (!response.ok) return listResult([]);
+    const parsed = array(string()).safeParse(await response.json());
+    if (!parsed.success) return listResult([]);
+    return listResult(
+      parsed.data.map((sessionId) => ({
+        uri: `inspector://sessions/${encodeURIComponent(sessionId)}`,
+        name: `session:${sessionId}`,
+        title: `Inspector session ${sessionId}`,
+        mimeType: "application/json"
+      }))
+    );
+  } catch {
+    return listResult([]);
+  }
+}
+async function listLogResources() {
+  try {
+    const response = await callApi("/api/logs?offset=0&limit=5&compact=1");
+    if (!response.ok) return listResult([]);
+    const parsed = LogResourceListResponseSchema.safeParse(await response.json());
+    if (!parsed.success) return listResult([]);
+    return listResult(
+      parsed.data.logs.map((log) => ({
+        uri: `inspector://logs/${String(log.id)}`,
+        name: `log:${String(log.id)}`,
+        title: `Inspector log ${String(log.id)}`,
+        mimeType: "application/json"
+      }))
+    );
+  } catch {
+    return listResult([]);
+  }
+}
+async function listRunResources() {
+  try {
+    const response = await callApi("/api/runs");
+    if (!response.ok) return listResult([]);
+    const parsed = RunsListResponseSchema.safeParse(await response.json());
+    if (!parsed.success) return listResult([]);
+    return listResult(
+      parsed.data.runs.map((run) => ({
+        uri: `inspector://runs/${encodeURIComponent(run.id)}`,
+        name: `run:${run.id}`,
+        title: run.title,
+        mimeType: "application/json"
+      }))
+    );
+  } catch {
+    return listResult([]);
+  }
+}
+async function listEvidenceResources() {
+  try {
+    const response = await callApi("/api/runs");
+    if (!response.ok) return listResult([]);
+    const parsed = RunsListResponseSchema.safeParse(await response.json());
+    if (!parsed.success) return listResult([]);
+    return listResult(
+      parsed.data.runs.filter((run) => run.evidence !== null).map((run) => ({
+        uri: `inspector://evidence/${encodeURIComponent(run.id)}`,
+        name: `evidence:${run.id}`,
+        title: `${run.title} evidence pack`,
+        mimeType: "text/markdown",
+        description: run.evidence?.markdownPath
+      }))
+    );
+  } catch {
+    return listResult([]);
+  }
+}
+function userPrompt(text) {
+  return {
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text
+        }
+      }
+    ]
+  };
+}
 function registerTools(server) {
   server.registerTool(
     "inspector_list_logs",
@@ -5201,12 +6103,28 @@ function registerTools(server) {
     (args) => safeCall(() => listLogsImpl(callApi, args))
   );
   server.registerTool(
-    "inspector_get_log",
+    "inspector_search_logs",
     {
-      title: "Get a single captured log by id",
-      description: "Returns the full CapturedLog for the given id, including rawRequestBody and responseText with no truncation. SSE streaming chunks are NOT included — use inspector_get_log_chunks for those. Returns an error if the id does not exist.",
+      title: "Search captured logs",
+      description: "Searches recent compact proxy logs by id, session, model, provider, API path, status, error text, and client context. Results are bounded summaries; call inspector_get_log for full details after locating a candidate id.",
       inputSchema: object({
-        id: number().int().positive().describe("The log id.")
+        query: string().optional().describe("Search terms. Empty or omitted returns the newest scanned logs."),
+        offset: number().int().nonnegative().optional().describe("Skip this many matches."),
+        limit: number().int().positive().optional().describe("How many summaries to return. Hard-capped at 5 by the MCP handler."),
+        scanLimit: number().int().positive().max(1e3).optional().describe("How many recent compact logs to scan before filtering. Default 200."),
+        sessionId: string().optional().describe("Optional session/affinity id filter."),
+        model: string().optional().describe("Optional model name filter.")
+      })
+    },
+    (args) => safeCall(() => searchLogsImpl(callApi, args))
+  );
+  server.registerTool(
+    "inspector_get_log",
+    {
+      title: "Get a single captured log by id",
+      description: "Returns the full CapturedLog for the given id, including rawRequestBody and responseText with no truncation. SSE streaming chunks are NOT included — use inspector_get_log_chunks for those. Returns an error if the id does not exist.",
+      inputSchema: object({
+        id: number().int().positive().describe("The log id.")
       })
     },
     ({ id }) => safeCall(() => getLogImpl(callApi, id))
@@ -5231,6 +6149,84 @@ function registerTools(server) {
     },
     () => safeCall(() => listSessionsImpl(callApi))
   );
+  server.registerTool(
+    "inspector_get_session",
+    {
+      title: "Get Inspector session info",
+      description: "Returns a lightweight, evidence-friendly summary for one Inspector session: clickable inspectorUrl, compact logs URL, status, request/error counts, token totals, models/providers, and the latest compact log summaries. Defaults to recent in-memory/cache data for speed; set includeHistory=true only when you explicitly want to scan persisted jsonl history. It avoids raw request/response bodies so it is safe to use in evaluation artifacts.",
+      inputSchema: object({
+        sessionId: string().min(1).describe("The Inspector session id."),
+        includeHistory: boolean().optional().describe("Scan persisted jsonl history for this session. Slower; default false."),
+        latestLogLimit: number().int().positive().max(50).optional().describe("How many latest compact log summaries to include. Max 50, default 10.")
+      })
+    },
+    (args) => safeCall(() => getSessionImpl(callApi, args))
+  );
+  server.registerTool(
+    "inspector_create_run",
+    {
+      title: "Create or declare an Inspector run",
+      description: "Creates an evaluation-friendly run record before a coding-agent task starts. Use this when a benchmark or Jenkins job wants a stable runId/sessionId pair instead of inferring a task after the fact from logs.",
+      inputSchema: object({
+        runId: string().min(1).optional().describe("Stable run id. Generated when omitted."),
+        sessionId: string().min(1).optional().describe("Inspector session id to attach. Defaults to the run id."),
+        title: string().min(1).optional().describe("Human-readable run title."),
+        task: string().nullable().optional().describe("Task statement or benchmark case."),
+        project: string().nullable().optional().describe("Project or repository under test."),
+        agent: string().nullable().optional().describe("Coding agent name, e.g. Codex/OpenCode."),
+        status: InspectorRunStatusSchema.optional().describe("Initial run status."),
+        tags: array(string()).optional().describe("Free-form run labels."),
+        metadata: record(string(), JsonValueSchema).optional().describe("JSON metadata.")
+      })
+    },
+    (args) => safeCall(() => createRunImpl(callApi, args))
+  );
+  server.registerTool(
+    "inspector_get_run",
+    {
+      title: "Get an Inspector run",
+      description: "Returns one declared Inspector run, including its session binding and exported evidence paths when available.",
+      inputSchema: object({
+        runId: string().min(1).describe("The Inspector run id.")
+      })
+    },
+    (args) => safeCall(() => getRunImpl(callApi, args))
+  );
+  server.registerTool(
+    "inspector_update_run",
+    {
+      title: "Update an Inspector run",
+      description: "PATCH-style update for a declared run. Use this during a coding-agent task to mark status transitions such as running, failed, completed, or to attach refined task metadata. Supplied metadata keys are merged into existing metadata.",
+      inputSchema: UpdateInspectorRunInputSchema.extend({
+        runId: string().min(1).describe("The Inspector run id.")
+      })
+    },
+    (args) => safeCall(() => updateRunImpl(callApi, args))
+  );
+  server.registerTool(
+    "inspector_export_evidence",
+    {
+      title: "Export an Inspector evidence pack",
+      description: "Exports one run's evidence pack to local JSON, Markdown, and HTML files under <dataDir>/evidence/<runId> and returns the paths plus session summary.",
+      inputSchema: object({
+        runId: string().min(1).describe("The Inspector run id."),
+        includeHistory: boolean().optional().describe("Scan persisted jsonl history for the bound session. Slower; default false."),
+        latestLogLimit: number().int().positive().max(50).optional().describe("How many compact log summaries to include in the evidence pack. Max 50.")
+      })
+    },
+    (args) => safeCall(() => exportEvidenceImpl(callApi, args))
+  );
+  server.registerTool(
+    "inspector_get_recent_failures",
+    {
+      title: "Get recent Inspector failures",
+      description: "Returns recent declared runs that are failed/cancelled or have non-success exported evidence, including classification, Jenkins summary, Inspector link, and evidence paths when available.",
+      inputSchema: object({
+        limit: number().int().positive().max(20).optional().describe("Maximum failures to return. Default 5, max 20.")
+      })
+    },
+    (args) => safeCall(() => getRecentFailuresImpl(callApi, args))
+  );
   server.registerTool(
     "inspector_list_models",
     {
@@ -5382,7 +6378,211 @@ PATCH-style update: only the fields you supply are changed. Returns the updated
     (args) => safeCall(() => getProjectContextImpl(callApi, args))
   );
 }
-const Route$l = createFileRoute("/api/mcp")({
+function registerResources(server) {
+  server.registerResource(
+    "inspector_sessions",
+    "inspector://sessions",
+    {
+      title: "Inspector sessions",
+      description: "Observed Inspector session ids.",
+      mimeType: "application/json"
+    },
+    (uri) => readApiJsonResource(uri, "/api/sessions")
+  );
+  server.registerResource(
+    "inspector_session",
+    new ResourceTemplate("inspector://sessions/{sessionId}", { list: listSessionResources }),
+    {
+      title: "Inspector session",
+      description: "Evidence-friendly session summary with Inspector URL, compact logs URL, counts, models, providers, token totals, and recent compact logs.",
+      mimeType: "application/json"
+    },
+    (uri, variables) => {
+      const sessionId = variableString(variables, "sessionId");
+      if (sessionId === null) return textResource(uri, "text/plain", "Missing sessionId");
+      const params = new URLSearchParams({ sessionId, limit: "10" });
+      return readApiJsonResource(uri, `/api/sessions?${params.toString()}`);
+    }
+  );
+  server.registerResource(
+    "inspector_log",
+    new ResourceTemplate("inspector://logs/{id}", { list: listLogResources }),
+    {
+      title: "Inspector log",
+      description: "Single captured proxy log by numeric id.",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const id = variableString(variables, "id");
+      const parsed = id === null ? Number.NaN : Number(id);
+      if (!Number.isInteger(parsed) || parsed <= 0) {
+        return textResource(uri, "text/plain", "Invalid log id");
+      }
+      const result = await getLogImpl(callApi, parsed);
+      const first = result.content[0];
+      const text = first?.text ?? "";
+      return textResource(uri, result.isError === true ? "text/plain" : "application/json", text);
+    }
+  );
+  server.registerResource(
+    "inspector_runs",
+    "inspector://runs",
+    {
+      title: "Inspector runs",
+      description: "Declared Inspector evaluation runs.",
+      mimeType: "application/json"
+    },
+    (uri) => readApiJsonResource(uri, "/api/runs")
+  );
+  server.registerResource(
+    "inspector_recent_failures",
+    "inspector://failures/recent",
+    {
+      title: "Recent Inspector failures",
+      description: "Recent declared runs with failed/cancelled status or non-success exported evidence.",
+      mimeType: "application/json"
+    },
+    (uri) => readApiJsonResource(uri, "/api/runs?failures=1&limit=10")
+  );
+  server.registerResource(
+    "inspector_run",
+    new ResourceTemplate("inspector://runs/{runId}", { list: listRunResources }),
+    {
+      title: "Inspector run",
+      description: "One declared Inspector run, including session binding and evidence paths.",
+      mimeType: "application/json"
+    },
+    (uri, variables) => {
+      const runId = variableString(variables, "runId");
+      if (runId === null) return textResource(uri, "text/plain", "Missing runId");
+      return readApiJsonResource(uri, `/api/runs/${encodeURIComponent(runId)}`);
+    }
+  );
+  server.registerResource(
+    "inspector_evidence",
+    new ResourceTemplate("inspector://evidence/{runId}", { list: listEvidenceResources }),
+    {
+      title: "Inspector evidence pack",
+      description: "Markdown evidence pack for a declared Inspector run. Generate it first with inspector_export_evidence.",
+      mimeType: "text/markdown"
+    },
+    async (uri, variables) => {
+      const runId = variableString(variables, "runId");
+      if (runId === null) return textResource(uri, "text/plain", "Missing runId");
+      const path2 = `/api/runs/${encodeURIComponent(runId)}/evidence`;
+      try {
+        const response = await callApi(path2);
+        if (!response.ok) {
+          return textResource(uri, "text/plain", `GET ${path2} returned ${response.status}`);
+        }
+        const parsed = EvidenceReadResponseSchema.safeParse(await response.json());
+        if (!parsed.success) {
+          return textResource(uri, "text/plain", "Evidence endpoint returned an unparseable body");
+        }
+        return textResource(uri, "text/markdown", parsed.data.markdown);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return textResource(uri, "text/plain", `Resource read failed: ${message}`);
+      }
+    }
+  );
+}
+function registerPrompts(server) {
+  server.registerPrompt(
+    "inspector_analyze_session_failure",
+    {
+      title: "Analyze session failure",
+      description: "Use Inspector session/log resources to explain why a coding-agent session failed.",
+      argsSchema: object({
+        sessionId: string().min(1).describe("The Inspector session id."),
+        includeHistory: boolean().optional().describe("When true, call inspector_get_session with includeHistory=true if needed.")
+      })
+    },
+    ({ sessionId, includeHistory }) => userPrompt(`Analyze this Agent Inspector session and explain why it failed.
+
+Evidence to read:
+- Session resource: inspector://sessions/${encodeURIComponent(sessionId)}
+- Relevant log resources: inspector://logs/{id} for the failing or suspicious log ids
+
+If includeHistory is ${includeHistory === true ? "true" : "false"} or the session summary looks incomplete, call inspector_get_session with includeHistory=true and latestLogLimit=50.
+
+Return:
+1. Outcome and severity
+2. Most likely root cause
+3. Evidence bullets with log ids, models, providers, status codes, and error text
+4. Concrete fix or next diagnostic step
+5. Confidence and what evidence is still missing`)
+  );
+  server.registerPrompt(
+    "inspector_triage_recent_failures",
+    {
+      title: "Triage recent failures",
+      description: "Use the recent failures resource and log search tool to prioritize coding-agent failures.",
+      argsSchema: object({
+        limit: number().int().positive().max(20).optional().describe("How many failures to triage.")
+      })
+    },
+    ({ limit }) => userPrompt(`Triage recent Agent Inspector failures.
+
+Evidence to read:
+- Recent failures resource: inspector://failures/recent
+- For missing details, call inspector_get_recent_failures with limit=${String(limit ?? 5)}
+- For suspicious sessions/models/providers, call inspector_search_logs and then inspector_get_log for cited ids
+
+Return:
+1. Highest-priority failure first
+2. Run id, session id, category, severity, and evidence links
+3. Likely root cause and concrete next action
+4. Whether evidence is sufficient or inspector_export_evidence should be run again`)
+  );
+  server.registerPrompt(
+    "inspector_generate_jenkins_report",
+    {
+      title: "Generate Jenkins report",
+      description: "Generate a Jenkins-friendly Markdown report from an Inspector run and evidence pack.",
+      argsSchema: object({
+        runId: string().min(1).describe("The Inspector run id.")
+      })
+    },
+    ({ runId }) => userPrompt(`Generate a Jenkins-ready Markdown report for this Inspector run.
+
+Evidence to read:
+- Run resource: inspector://runs/${encodeURIComponent(runId)}
+- Evidence pack resource: inspector://evidence/${encodeURIComponent(runId)}
+
+If the evidence pack resource says it has not been exported, call inspector_export_evidence for this run first.
+
+The report should include:
+1. Build/run status summary
+2. Run id, session id, Inspector URLs, and artifact paths
+3. Models/providers used, token totals, request counts, and error counts
+4. Failure analysis or success evidence
+5. Reproducible next action for a developer`)
+  );
+  server.registerPrompt(
+    "inspector_extract_repro_steps",
+    {
+      title: "Extract reproducible steps",
+      description: "Turn an Inspector session into concise repro steps for a developer or evaluator.",
+      argsSchema: object({
+        sessionId: string().min(1).describe("The Inspector session id.")
+      })
+    },
+    ({ sessionId }) => userPrompt(`Extract reproducible steps from this Agent Inspector session.
+
+Evidence to read:
+- Session resource: inspector://sessions/${encodeURIComponent(sessionId)}
+- Relevant log resources: inspector://logs/{id}
+
+Return:
+1. Preconditions and environment assumptions
+2. Ordered user/agent actions that led to the behavior
+3. Exact model/provider/API path details needed to reproduce
+4. Expected vs actual result
+5. Minimal verification command or UI check`)
+  );
+}
+const Route$n = createFileRoute("/api/mcp")({
   server: {
     handlers: {
       // The SDK may issue either POST, GET, or DELETE. TanStack Start only
@@ -5394,6 +6594,89 @@ const Route$l = createFileRoute("/api/mcp")({
     }
   }
 });
+const LOG_SEARCH_DEFAULT_LIMIT = 10;
+const LOG_SEARCH_MAX_LIMIT = 50;
+const LOG_SEARCH_DEFAULT_SCAN_LIMIT = 200;
+const LOG_SEARCH_MAX_SCAN_LIMIT = 1e3;
+function clampPositiveInt(value, fallback, max) {
+  if (!Number.isInteger(value) || value < 1) return fallback;
+  return Math.min(value, max);
+}
+function clampLogSearchLimit(value) {
+  return clampPositiveInt(value, LOG_SEARCH_DEFAULT_LIMIT, LOG_SEARCH_MAX_LIMIT);
+}
+function clampLogSearchScanLimit(value) {
+  return clampPositiveInt(value, LOG_SEARCH_DEFAULT_SCAN_LIMIT, LOG_SEARCH_MAX_SCAN_LIMIT);
+}
+function queryTerms(query) {
+  return query.trim().toLowerCase().split(/\s+/).filter((term) => term.length > 0);
+}
+function optionalText(value) {
+  if (value === null || value === void 0) return null;
+  return String(value);
+}
+function searchableFields(log) {
+  return [
+    String(log.id),
+    log.timestamp,
+    log.method,
+    log.path,
+    optionalText(log.model),
+    optionalText(log.sessionId),
+    optionalText(log.responseStatus),
+    optionalText(log.elapsedMs),
+    optionalText(log.streaming),
+    log.streaming ? "streaming" : "non-streaming",
+    log.apiFormat,
+    optionalText(log.providerName),
+    optionalText(log.userAgent),
+    optionalText(log.origin),
+    optionalText(log.clientPid),
+    optionalText(log.clientCwd),
+    optionalText(log.clientProjectFolder),
+    optionalText(log.error)
+  ].filter((value) => value !== null && value.length > 0);
+}
+function matchesTerms(log, terms) {
+  if (terms.length === 0) return true;
+  const haystack = searchableFields(log).join("\n").toLowerCase();
+  return terms.every((term) => haystack.includes(term));
+}
+function sortNewestFirst(logs) {
+  return logs.sort((left, right) => {
+    const timestampCompare = right.timestamp.localeCompare(left.timestamp);
+    return timestampCompare !== 0 ? timestampCompare : right.id - left.id;
+  });
+}
+async function searchLogsPage(options) {
+  const limit = clampLogSearchLimit(options.limit);
+  const scanLimit = clampLogSearchScanLimit(Math.max(options.scanLimit, options.offset + limit));
+  const firstPage = await listLogsPage({
+    sessionId: options.sessionId,
+    model: options.model,
+    offset: 0,
+    limit: 1,
+    includeBodies: false
+  });
+  const scanOffset = Math.max(firstPage.total - scanLimit, 0);
+  const scanPage = await listLogsPage({
+    sessionId: options.sessionId,
+    model: options.model,
+    offset: scanOffset,
+    limit: scanLimit,
+    includeBodies: false
+  });
+  const terms = queryTerms(options.query);
+  const matches = sortNewestFirst(scanPage.logs.filter((log) => matchesTerms(log, terms)));
+  return {
+    query: options.query,
+    logs: matches.slice(options.offset, options.offset + limit),
+    total: matches.length,
+    offset: options.offset,
+    limit,
+    scanned: scanPage.logs.length
+  };
+}
 const DeleteBodySchema = object({
   ids: array(number().int().positive()).optional()
 }).optional();
@@ -5409,7 +6692,7 @@ function parsePositiveInt(value, fallback) {
   if (!Number.isInteger(parsed) || parsed < 1) return fallback;
   return parsed;
 }
-const Route$k = createFileRoute("/api/logs")({
+const Route$m = createFileRoute("/api/logs")({
   server: {
     handlers: {
       GET: async ({ request }) => {
@@ -5428,7 +6711,18 @@ const Route$k = createFileRoute("/api/logs")({
         }
         const sessionId = url.searchParams.get("sessionId") ?? void 0;
         const model = url.searchParams.get("model") ?? void 0;
+        const query = url.searchParams.get("q") ?? url.searchParams.get("search");
         const offset = parseNonNegativeInt(url.searchParams.get("offset"), 0);
+        if (query !== null) {
+          const limit2 = parsePositiveInt(url.searchParams.get("limit"), LOG_SEARCH_DEFAULT_LIMIT);
+          const scanLimit = parsePositiveInt(
+            url.searchParams.get("scanLimit"),
+            LOG_SEARCH_DEFAULT_SCAN_LIMIT
+          );
+          return Response.json(
+            await searchLogsPage({ query, sessionId, model, offset, limit: limit2, scanLimit })
+          );
+        }
         const limit = parsePositiveInt(url.searchParams.get("limit"), 50);
         const includeBodies = url.searchParams.get("compact") !== "1";
         return Response.json(
@@ -5474,7 +6768,7 @@ const Route$k = createFileRoute("/api/logs")({
   }
 });
 logger.debug("Health endpoint loaded");
-const Route$j = createFileRoute("/api/health")({
+const Route$l = createFileRoute("/api/health")({
   server: {
     handlers: {
       GET: () => {
@@ -5492,7 +6786,7 @@ const RuntimeConfigPatchSchema = object({
 }).strict().refine((v) => Object.keys(v).length > 0, {
   message: "At least one field must be provided"
 });
-const Route$i = createFileRoute("/api/config")({
+const Route$k = createFileRoute("/api/config")({
   server: {
     handlers: {
       GET: () => {
@@ -5521,6 +6815,46 @@ const Route$i = createFileRoute("/api/config")({
     }
   }
 });
+async function readJsonBody$1(request) {
+  try {
+    const raw = await request.text();
+    if (raw.trim().length === 0) return { ok: true, value: {} };
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    return { ok: false };
+  }
+}
+const Route$j = createFileRoute("/api/runs/$runId")({
+  server: {
+    handlers: {
+      GET: ({ params }) => {
+        const run = getRun(params.runId);
+        if (run === null) {
+          return Response.json({ error: "Run not found" }, { status: 404 });
+        }
+        return Response.json(run);
+      },
+      PATCH: async ({ params, request }) => {
+        const body = await readJsonBody$1(request);
+        if (!body.ok) {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+        const parsed = UpdateInspectorRunInputSchema.safeParse(body.value);
+        if (!parsed.success) {
+          return Response.json(
+            { error: "Invalid request body", details: parsed.error.format() },
+            { status: 400 }
+          );
+        }
+        const updated = updateRun(params.runId, parsed.data);
+        if (updated === null) {
+          return Response.json({ error: "Run not found" }, { status: 404 });
+        }
+        return Response.json(updated);
+      }
+    }
+  }
+});
 const ZHIPU_OPENAI_BASE_URL = "https://open.bigmodel.cn/api/paas/v4";
 const ZHIPU_CODING_OPENAI_BASE_URL = "https://open.bigmodel.cn/api/coding/paas/v4";
 const ZHIPU_CODING_ANTHROPIC_BASE_URL = "https://open.bigmodel.cn/api/anthropic";
@@ -5947,7 +7281,7 @@ function scanExternalProviders() {
   }
   return { providers: filteredProviders, warnings };
 }
-const Route$h = createFileRoute("/api/providers/scan")({
+const Route$i = createFileRoute("/api/providers/scan")({
   server: {
     handlers: {
       GET: () => {
@@ -5968,7 +7302,7 @@ const Route$h = createFileRoute("/api/providers/scan")({
   }
 });
 union([string(), object({ providers: unknown() })]);
-const Route$g = createFileRoute("/api/providers/import")({
+const Route$h = createFileRoute("/api/providers/import")({
   server: {
     handlers: {
       POST: async ({ request }) => {
@@ -6001,7 +7335,7 @@ const Route$g = createFileRoute("/api/providers/import")({
     }
   }
 });
-const Route$f = createFileRoute("/api/providers/export")({
+const Route$g = createFileRoute("/api/providers/export")({
   server: {
     handlers: {
       GET: ({ request }) => {
@@ -6034,7 +7368,7 @@ const ProviderUpdateSchema = object({
   modelMetadata: array(ProviderModelMetadataSchema).optional(),
   source: _enum(["company", "personal"]).optional()
 });
-const Route$e = createFileRoute("/api/providers/$providerId")({
+const Route$f = createFileRoute("/api/providers/$providerId")({
   server: {
     handlers: {
       GET: ({ params, request }) => {
@@ -6069,7 +7403,7 @@ const Route$e = createFileRoute("/api/providers/$providerId")({
   }
 });
 const INITIAL_STREAM_LOG_LIMIT = 100;
-const Route$d = createFileRoute("/api/logs/stream")({
+const Route$e = createFileRoute("/api/logs/stream")({
   server: {
     handlers: {
       GET: ({ request }) => {
@@ -6142,7 +7476,7 @@ const Route$d = createFileRoute("/api/logs/stream")({
     }
   }
 });
-const Route$c = createFileRoute("/api/logs/$id")({
+const Route$d = createFileRoute("/api/logs/$id")({
   server: {
     handlers: {
       GET: async ({ params }) => {
@@ -6484,10 +7818,10 @@ function normalizePathSegment(value, fallback) {
   const segment = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96);
   return segment === "" ? fallback : segment;
 }
-function formatNullable(value) {
+function formatNullable$1(value) {
   return value === null || value === "" ? "unknown" : value;
 }
-function formatList(values) {
+function formatList$2(values) {
   return values.length === 0 ? "none" : values.join(", ");
 }
 function buildEvidenceLink(candidate) {
@@ -6510,16 +7844,16 @@ function buildOpenClawMemoryMarkdown(candidate) {
     "",
     `- Type: ${sanitized.type}`,
     `- Status: ${sanitized.status}`,
-    `- Project: ${formatNullable(sanitized.evidence.project)}`,
+    `- Project: ${formatNullable$1(sanitized.evidence.project)}`,
     `- Session: ${sanitized.sessionId}`,
     `- Log IDs: ${sanitized.logIds.join(", ")}`,
-    `- Models: ${formatList(sanitized.evidence.models)}`,
-    `- Tags: ${formatList(sanitized.tags)}`,
+    `- Models: ${formatList$2(sanitized.evidence.models)}`,
+    `- Tags: ${formatList$2(sanitized.tags)}`,
     `- Created: ${sanitized.createdAt}`,
     `- Updated: ${sanitized.updatedAt}`,
     `- Evidence: ${buildEvidenceLink(sanitized)}`,
     `- Redacted: ${String(sanitized.redaction.redacted)}`,
-    `- Redaction patterns: ${formatList(sanitized.redaction.patterns)}`,
+    `- Redaction patterns: ${formatList$2(sanitized.redaction.patterns)}`,
     "",
     "## Durable Knowledge Candidate",
     "",
@@ -6679,7 +8013,7 @@ const SearchBodySchema = object({
   query: string().min(1),
   project: string().optional()
 });
-const Route$b = createFileRoute("/api/knowledge/search")({
+const Route$c = createFileRoute("/api/knowledge/search")({
   server: {
     handlers: {
       GET: async ({ request }) => {
@@ -6701,7 +8035,7 @@ const Route$b = createFileRoute("/api/knowledge/search")({
     }
   }
 });
-const Route$a = createFileRoute("/api/knowledge/project-context")({
+const Route$b = createFileRoute("/api/knowledge/project-context")({
   server: {
     handlers: {
       GET: async ({ request }) => {
@@ -6783,14 +8117,14 @@ function updateCandidateDraft(id, updates) {
   candidates.set(id, updated);
   return updated;
 }
-const Route$9 = createFileRoute("/api/knowledge/candidates")({
+const Route$a = createFileRoute("/api/knowledge/candidates")({
   server: {
     handlers: {
       GET: () => Response.json({ candidates: listCandidates() })
     }
   }
 });
-const Route$8 = createFileRoute("/api/config/paths")({
+const Route$9 = createFileRoute("/api/config/paths")({
   server: {
     handlers: {
       GET: () => {
@@ -6801,6 +8135,653 @@ const Route$8 = createFileRoute("/api/config/paths")({
     }
   }
 });
+function formatNullable(value) {
+  return value === null ? "n/a" : String(value);
+}
+function formatList$1(values) {
+  return values.length > 0 ? values.join(", ") : "n/a";
+}
+function lower(value) {
+  return value.toLowerCase();
+}
+function logEvidenceText(log) {
+  return lower(
+    [
+      log.error,
+      log.path,
+      log.model,
+      log.provider,
+      log.status === null ? null : String(log.status),
+      log.isStreaming ? "streaming" : "non-streaming"
+    ].filter((value) => value !== null).join(" ")
+  );
+}
+function collectErrorCandidates(session) {
+  const candidates2 = session.latestLogs.filter((log) => log.hasError).map((log) => ({ log, text: logEvidenceText(log) }));
+  if (session.lastTaskError !== null) {
+    candidates2.push({ log: null, text: lower(session.lastTaskError) });
+  }
+  return candidates2;
+}
+function hasText(candidates2, patterns) {
+  return candidates2.some(
+    (candidate) => patterns.some((pattern) => candidate.text.includes(pattern))
+  );
+}
+function hasStatus(session, predicate) {
+  return session.latestLogs.some((log) => log.status !== null && predicate(log.status));
+}
+function evidenceIds(candidates2) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const candidate of candidates2) {
+    if (candidate.log !== null) {
+      ids.add(candidate.log.id);
+    }
+  }
+  return [...ids].sort((left, right) => left - right);
+}
+function hasStreamingMismatch(session) {
+  for (const failed of session.latestLogs.filter((log) => log.hasError)) {
+    const matchingSuccess = session.latestLogs.some(
+      (log) => !log.hasError && log.model === failed.model && log.provider === failed.provider && log.isStreaming !== failed.isStreaming
+    );
+    if (matchingSuccess) return true;
+  }
+  return false;
+}
+function categorySummary(category) {
+  switch (category) {
+    case "none":
+      return "Session completed without captured errors.";
+    case "active":
+      return "Session still has active requests or running tasks.";
+    case "provider-timeout":
+      return "Provider call appears to have timed out.";
+    case "provider-http-error":
+      return "Provider returned an HTTP error.";
+    case "provider-auth-error":
+      return "Provider authentication or API key configuration appears invalid.";
+    case "provider-rate-limit":
+      return "Provider rejected the request because of rate limit or quota pressure.";
+    case "network-or-container":
+      return "Network connectivity looks suspicious; check container boundaries and localhost use.";
+    case "streaming-mismatch":
+      return "Streaming and non-streaming behavior differ for the same provider/model.";
+    case "context-pressure":
+      return "The failure looks related to context window or token pressure.";
+    case "runtime-task-error":
+      return "Inspector session runtime reported a task error.";
+    case "model-output-error":
+      return "The model output or upstream payload shape appears invalid.";
+    case "unknown-failure":
+      return "Inspector captured errors, but the root cause is not yet classified.";
+    case "no-session-data":
+      return "No Inspector session data was available for this run.";
+  }
+}
+function categoryHints(category) {
+  switch (category) {
+    case "none":
+      return ["Keep the evidence pack as the success proof for CI or release notes."];
+    case "active":
+      return ["Wait for the session to settle, then export evidence again."];
+    case "provider-timeout":
+      return [
+        "Increase the provider test timeout for slow models.",
+        "Compare streaming and non-streaming probes for the same model."
+      ];
+    case "provider-http-error":
+      return [
+        "Open the cited log ids and inspect upstream status, response body, and provider URL."
+      ];
+    case "provider-auth-error":
+      return ["Verify the provider API key, auth header mode, and configured base URL."];
+    case "provider-rate-limit":
+      return [
+        "Retry after provider quota recovers or switch to a less constrained provider/model."
+      ];
+    case "network-or-container":
+      return [
+        "If the coding agent and Inspector are in different containers, replace localhost with a reachable host.",
+        "Check DNS, proxy, firewall, and container network routes."
+      ];
+    case "streaming-mismatch":
+      return [
+        "Compare the streaming and non-streaming captured logs side by side.",
+        "Check whether the provider's OpenAI-compatible endpoint handles stream=false differently."
+      ];
+    case "context-pressure":
+      return [
+        "Reduce prompt/tool schema/history size or configure the model context window metadata."
+      ];
+    case "runtime-task-error":
+      return ["Inspect the session runtime error and retry after clearing stuck session tasks."];
+    case "model-output-error":
+      return ["Inspect the raw response and schema parsing details for the cited log ids."];
+    case "unknown-failure":
+      return [
+        "Open the cited logs and inspect error/status/latency fields to refine the diagnosis."
+      ];
+    case "no-session-data":
+      return [
+        "Confirm the run's sessionId matches captured traffic and that history scanning is enabled when needed."
+      ];
+  }
+}
+function classifyCategory(session, candidates2) {
+  if (session.status === "active") return "active";
+  if (session.errorCount === 0 && session.failedRequests === 0 && session.lastTaskError === null) {
+    return "none";
+  }
+  if (hasStreamingMismatch(session)) return "streaming-mismatch";
+  if (hasText(candidates2, [
+    "timeout",
+    "timed out",
+    "etimedout",
+    "deadline",
+    "aborterror",
+    "econnaborted"
+  ])) {
+    return "provider-timeout";
+  }
+  if (hasText(candidates2, ["localhost", "econnrefused", "enotfound", "network", "fetch failed"])) {
+    return "network-or-container";
+  }
+  if (hasStatus(session, (status) => status === 401 || status === 403)) {
+    return "provider-auth-error";
+  }
+  if (hasText(candidates2, ["unauthorized", "forbidden", "invalid api key", "api key"])) {
+    return "provider-auth-error";
+  }
+  if (hasStatus(session, (status) => status === 429)) return "provider-rate-limit";
+  if (hasText(candidates2, ["rate limit", "quota"])) return "provider-rate-limit";
+  if (hasText(candidates2, ["context", "too many tokens", "token limit", "maximum context"])) {
+    return "context-pressure";
+  }
+  if (session.lastTaskError !== null) return "runtime-task-error";
+  if (hasText(candidates2, ["invalid json", "schema", "parse", "malformed"])) {
+    return "model-output-error";
+  }
+  if (hasStatus(session, (status) => status >= 400)) return "provider-http-error";
+  return "unknown-failure";
+}
+function severityFor(category) {
+  switch (category) {
+    case "none":
+      return "none";
+    case "active":
+      return "low";
+    case "provider-timeout":
+    case "provider-http-error":
+    case "provider-auth-error":
+    case "provider-rate-limit":
+    case "network-or-container":
+    case "streaming-mismatch":
+    case "runtime-task-error":
+      return "high";
+    case "context-pressure":
+    case "model-output-error":
+    case "unknown-failure":
+    case "no-session-data":
+      return "medium";
+  }
+}
+function outcomeFor$1(category) {
+  switch (category) {
+    case "none":
+      return "success";
+    case "active":
+      return "active";
+    case "no-session-data":
+      return "unknown";
+    case "provider-timeout":
+    case "provider-http-error":
+    case "provider-auth-error":
+    case "provider-rate-limit":
+    case "network-or-container":
+    case "streaming-mismatch":
+    case "context-pressure":
+    case "runtime-task-error":
+    case "model-output-error":
+    case "unknown-failure":
+      return "failure";
+  }
+}
+function classifyRunFailure(run, session) {
+  if (session === null) {
+    const category2 = "no-session-data";
+    return {
+      outcome: outcomeFor$1(category2),
+      severity: severityFor(category2),
+      category: category2,
+      summary: `${categorySummary(category2)} Run ${run.id} is bound to session ${run.sessionId}.`,
+      evidenceLogIds: [],
+      hints: categoryHints(category2)
+    };
+  }
+  const candidates2 = collectErrorCandidates(session);
+  const category = classifyCategory(session, candidates2);
+  const summary = category === "none" ? `${categorySummary(category)} ${String(session.requestCount)} request(s), ${String(
+    session.tokenUsage.total
+  )} token(s).` : `${categorySummary(category)} ${String(session.errorCount)} error log(s), ${String(
+    session.failedRequests
+  )} failed request(s).`;
+  return {
+    outcome: outcomeFor$1(category),
+    severity: severityFor(category),
+    category,
+    summary,
+    evidenceLogIds: evidenceIds(candidates2),
+    hints: categoryHints(category)
+  };
+}
+function logTitle(log) {
+  if (log.hasError) return `Request failed: log ${String(log.id)}`;
+  if (log.status !== null && log.status >= 200 && log.status < 400) {
+    return `Request succeeded: log ${String(log.id)}`;
+  }
+  return `Request captured: log ${String(log.id)}`;
+}
+function logDetails(log) {
+  const parts = [
+    `path=${log.path}`,
+    `status=${formatNullable(log.status)}`,
+    `model=${formatNullable(log.model)}`,
+    `provider=${formatNullable(log.provider)}`,
+    `streaming=${log.isStreaming ? "yes" : "no"}`,
+    `latencyMs=${formatNullable(log.latencyMs)}`
+  ];
+  if (log.error !== null) {
+    parts.push(`error=${log.error}`);
+  }
+  return parts.join(", ");
+}
+function buildRunTimeline(run, session, exportedAt) {
+  const events = [
+    {
+      timestamp: run.createdAt,
+      kind: "run-created",
+      severity: "info",
+      title: "Run declared",
+      details: `Run ${run.id} was declared for session ${run.sessionId}.`,
+      logId: null,
+      status: null,
+      model: null,
+      provider: null,
+      latencyMs: null,
+      isStreaming: null
+    }
+  ];
+  if (session !== null && session.createdAt !== null) {
+    events.push({
+      timestamp: session.createdAt,
+      kind: "session-started",
+      severity: "info",
+      title: "Session started",
+      details: `Inspector session ${session.id} started with source ${session.source ?? "unknown"}.`,
+      logId: null,
+      status: null,
+      model: null,
+      provider: null,
+      latencyMs: null,
+      isStreaming: null
+    });
+  }
+  if (session !== null) {
+    const logs = [...session.latestLogs].sort(
+      (left, right) => left.timestamp.localeCompare(right.timestamp)
+    );
+    for (const log of logs) {
+      events.push({
+        timestamp: log.timestamp,
+        kind: "request",
+        severity: log.hasError ? "error" : "success",
+        title: logTitle(log),
+        details: logDetails(log),
+        logId: log.id,
+        status: log.status,
+        model: log.model,
+        provider: log.provider,
+        latencyMs: log.latencyMs,
+        isStreaming: log.isStreaming
+      });
+    }
+    if (session.updatedAt !== null) {
+      events.push({
+        timestamp: session.updatedAt,
+        kind: "session-finished",
+        severity: session.status === "failed" ? "error" : session.status === "active" ? "warning" : "success",
+        title: `Session ${session.status}`,
+        details: `${String(session.requestCount)} request(s), ${String(
+          session.errorCount
+        )} error(s), ${String(session.tokenUsage.total)} token(s).`,
+        logId: session.lastLogId,
+        status: null,
+        model: session.lastModel,
+        provider: null,
+        latencyMs: null,
+        isStreaming: null
+      });
+    }
+  }
+  events.push({
+    timestamp: exportedAt,
+    kind: "evidence-exported",
+    severity: "info",
+    title: "Evidence exported",
+    details: `Evidence pack exported at ${exportedAt}.`,
+    logId: null,
+    status: null,
+    model: null,
+    provider: null,
+    latencyMs: null,
+    isStreaming: null
+  });
+  return events.sort((left, right) => left.timestamp.localeCompare(right.timestamp));
+}
+function reportStatus(classification) {
+  switch (classification.outcome) {
+    case "success":
+      return "PASS";
+    case "failure":
+      return "FAIL";
+    case "active":
+      return "RUNNING";
+    case "unknown":
+      return "UNKNOWN";
+  }
+}
+function timelineMarkdown(timeline) {
+  if (timeline.length === 0) return ["No timeline events were available."];
+  return [
+    "| Time | Event | Severity | Evidence |",
+    "| --- | --- | --- | --- |",
+    ...timeline.map((event) => {
+      const evidence = event.logId === null ? "n/a" : `log ${String(event.logId)}`;
+      return `| ${event.timestamp} | ${event.title} | ${event.severity} | ${evidence} |`;
+    })
+  ];
+}
+function buildJenkinsReport(input) {
+  const status = reportStatus(input.classification);
+  const session = input.session;
+  const summary = `[${status}] ${input.classification.summary}`;
+  const lines = [
+    `# Jenkins Report: ${input.run.title}`,
+    "",
+    `- Status: ${status}`,
+    `- Run ID: ${input.run.id}`,
+    `- Session ID: ${input.run.sessionId}`,
+    `- Inspector URL: ${session?.inspectorUrl ?? "n/a"}`,
+    `- Category: ${input.classification.category}`,
+    `- Severity: ${input.classification.severity}`,
+    `- Summary: ${input.classification.summary}`,
+    `- Evidence Logs: ${input.classification.evidenceLogIds.length > 0 ? input.classification.evidenceLogIds.map((id) => `#${String(id)}`).join(", ") : "n/a"}`,
+    "",
+    "## Session Metrics",
+    "",
+    `- Requests: ${String(session?.requestCount ?? 0)}`,
+    `- Errors: ${String(session?.errorCount ?? 0)}`,
+    `- Models: ${formatList$1(session?.models ?? [])}`,
+    `- Providers: ${formatList$1(session?.providers ?? [])}`,
+    `- Tokens: ${String(session?.tokenUsage.total ?? 0)}`,
+    "",
+    "## Timeline",
+    "",
+    ...timelineMarkdown(input.timeline),
+    "",
+    "## Artifacts",
+    "",
+    `- JSON: ${input.evidencePaths.jsonPath}`,
+    `- Markdown: ${input.evidencePaths.markdownPath}`,
+    `- HTML: ${input.evidencePaths.htmlPath}`,
+    "",
+    "## Next Actions",
+    "",
+    ...input.classification.hints.map((hint) => `- ${hint}`),
+    ""
+  ];
+  return {
+    status,
+    summary,
+    markdown: lines.join("\n")
+  };
+}
+function analyzeEvidence(input) {
+  const classification = classifyRunFailure(input.run, input.session);
+  const timeline = buildRunTimeline(input.run, input.session, input.exportedAt);
+  const jenkinsReport = buildJenkinsReport({
+    run: input.run,
+    session: input.session,
+    timeline,
+    classification,
+    evidencePaths: input.evidencePaths
+  });
+  return { classification, timeline, jenkinsReport };
+}
+function evidenceDir(runId) {
+  return join(getDataDir(), "evidence", runId);
+}
+function jsonPath(runId) {
+  return join(evidenceDir(runId), "evidence.json");
+}
+function markdownPath(runId) {
+  return join(evidenceDir(runId), "evidence.md");
+}
+function htmlPath(runId) {
+  return join(evidenceDir(runId), "evidence.html");
+}
+function formatList(values) {
+  return values.length > 0 ? values.join(", ") : "n/a";
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function buildMarkdown(document) {
+  const session = document.session;
+  const lines = [
+    `# ${document.run.title}`,
+    "",
+    `- Run ID: ${document.run.id}`,
+    `- Session ID: ${document.run.sessionId}`,
+    `- Status: ${document.run.status}`,
+    `- Project: ${document.run.project ?? "n/a"}`,
+    `- Agent: ${document.run.agent ?? "n/a"}`,
+    `- Created: ${document.run.createdAt}`,
+    "",
+    `- Outcome: ${document.classification.outcome}`,
+    `- Failure Category: ${document.classification.category}`,
+    `- Severity: ${document.classification.severity}`,
+    `- Evidence JSON: ${document.evidence.jsonPath}`,
+    `- Evidence HTML: ${document.evidence.htmlPath}`,
+    ""
+  ];
+  if (document.run.task !== null) {
+    lines.push("## Task", "", document.run.task, "");
+  }
+  if (session === null) {
+    lines.push("## Session", "", "No Inspector session data was available for this run.", "");
+  } else {
+    lines.push(
+      "## Session",
+      "",
+      `- Inspector URL: ${session.inspectorUrl}`,
+      `- Compact Logs URL: ${session.compactLogsUrl}`,
+      `- Status: ${session.status}`,
+      `- Coverage: ${session.logCoverage}`,
+      `- Requests: ${session.requestCount}`,
+      `- Errors: ${session.errorCount}`,
+      `- Models: ${formatList(session.models)}`,
+      `- Providers: ${formatList(session.providers)}`,
+      `- Tokens: ${session.tokenUsage.total}`,
+      "",
+      "## Failure Classification",
+      "",
+      document.classification.summary,
+      "",
+      "### Evidence Logs",
+      "",
+      document.classification.evidenceLogIds.length > 0 ? document.classification.evidenceLogIds.map((id) => `- #${id}`).join("\n") : "No failing log ids were identified.",
+      "",
+      "### Suggested Next Actions",
+      "",
+      ...document.classification.hints.map((hint) => `- ${hint}`),
+      "",
+      "## Run Timeline",
+      "",
+      "| Time | Event | Severity | Evidence |",
+      "| --- | --- | --- | --- |",
+      ...document.timeline.map((event) => {
+        const evidence = event.logId === null ? "n/a" : `log ${event.logId}`;
+        return `| ${event.timestamp} | ${event.title} | ${event.severity} | ${evidence} |`;
+      }),
+      "",
+      "## Latest Logs",
+      ""
+    );
+    if (session.latestLogs.length === 0) {
+      lines.push("No compact logs were available.", "");
+    } else {
+      lines.push(
+        "| ID | Status | Model | Latency | Path | Error |",
+        "| --- | --- | --- | --- | --- | --- |"
+      );
+      for (const log of session.latestLogs) {
+        lines.push(
+          `| ${log.id} | ${log.status ?? "n/a"} | ${log.model ?? "n/a"} | ${log.latencyMs ?? "n/a"} | ${log.path} | ${log.hasError ? "yes" : "no"} |`
+        );
+      }
+      lines.push("");
+    }
+  }
+  lines.push("## Jenkins Report", "", document.jenkinsReport.markdown, "");
+  return `${lines.join("\n")}
+`;
+}
+function buildHtml(markdown, title) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>${escapeHtml(title)}</title>
+  <style>
+    body { font-family: system-ui, sans-serif; max-width: 960px; margin: 40px auto; line-height: 1.5; }
+    pre { white-space: pre-wrap; background: #f6f8fa; padding: 16px; border-radius: 8px; }
+  </style>
+</head>
+<body>
+  <pre>${escapeHtml(markdown)}</pre>
+</body>
+</html>
+`;
+}
+async function exportRunEvidence(run, options, baseUrl) {
+  const session = await getSessionInfo(run.sessionId, {
+    baseUrl,
+    includeHistory: options?.includeHistory,
+    latestLogLimit: options?.latestLogLimit
+  });
+  const exportedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const evidence = {
+    jsonPath: jsonPath(run.id),
+    markdownPath: markdownPath(run.id),
+    htmlPath: htmlPath(run.id),
+    exportedAt
+  };
+  const documentRun = {
+    ...run,
+    evidence,
+    updatedAt: exportedAt
+  };
+  const analysis = analyzeEvidence({
+    run: documentRun,
+    session,
+    exportedAt,
+    evidencePaths: {
+      jsonPath: evidence.jsonPath,
+      markdownPath: evidence.markdownPath,
+      htmlPath: evidence.htmlPath
+    }
+  });
+  const document = {
+    run: documentRun,
+    evidence,
+    session,
+    timeline: analysis.timeline,
+    classification: analysis.classification,
+    jenkinsReport: analysis.jenkinsReport
+  };
+  const markdown = buildMarkdown(document);
+  mkdirSync(evidenceDir(run.id), { recursive: true });
+  writeFileSync(
+    evidence.jsonPath,
+    `${JSON.stringify({ ...document, evidence }, null, 2)}
+`,
+    "utf8"
+  );
+  writeFileSync(evidence.markdownPath, markdown, "utf8");
+  writeFileSync(evidence.htmlPath, buildHtml(markdown, run.title), "utf8");
+  const updatedRun = updateRunEvidence(run.id, evidence) ?? documentRun;
+  return { ...document, run: updatedRun };
+}
+function readEvidenceMarkdown(run) {
+  const path2 = run.evidence?.markdownPath;
+  if (path2 === void 0 || !existsSync(path2)) return null;
+  try {
+    return readFileSync(path2, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function readJsonBody(request) {
+  try {
+    const raw = await request.text();
+    if (raw.trim().length === 0) return { ok: true, value: void 0 };
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    return { ok: false };
+  }
+}
+const Route$8 = createFileRoute("/api/runs/$runId/evidence")({
+  server: {
+    handlers: {
+      GET: ({ params }) => {
+        const run = getRun(params.runId);
+        if (run === null) {
+          return Response.json({ error: "Run not found" }, { status: 404 });
+        }
+        const markdown = readEvidenceMarkdown(run);
+        if (run.evidence === null || markdown === null) {
+          return Response.json(
+            { error: "Evidence has not been exported for this run" },
+            { status: 404 }
+          );
+        }
+        return Response.json({ run, evidence: run.evidence, markdown });
+      },
+      POST: async ({ params, request }) => {
+        const run = getRun(params.runId);
+        if (run === null) {
+          return Response.json({ error: "Run not found" }, { status: 404 });
+        }
+        const body = await readJsonBody(request);
+        if (!body.ok) {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+        const parsed = EvidenceExportOptionsSchema.safeParse(body.value);
+        if (!parsed.success) {
+          return Response.json(
+            { error: "Invalid request body", details: parsed.error.format() },
+            { status: 400 }
+          );
+        }
+        return Response.json(
+          await exportRunEvidence(run, parsed.data, new URL(request.url).origin)
+        );
+      }
+    }
+  }
+});
 const MEMORY_PROBE_FACTS = [
   "Project fact: Agent Inspector captures LLM traffic and turns it into Raw Trace, Session Episode, and Memory Candidate layers.",
   "Procedure: before release, run bun test, npm run typecheck, npm run lint, npm run build, and openspec validate --all --strict.",
@@ -8220,106 +10201,121 @@ const Route = createFileRoute("/api/knowledge/candidates/$candidateId/promote")(
     }
   }
 });
-const IndexRoute = Route$r.update({
+const IndexRoute = Route$u.update({
   id: "/",
   path: "/",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
-const SessionSessionIdRoute = Route$q.update({
+const SessionSessionIdRoute = Route$t.update({
   id: "/session/$sessionId",
   path: "/session/$sessionId",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
-const ProxySplatRoute = Route$p.update({
+const ProxySplatRoute = Route$s.update({
   id: "/proxy/$",
   path: "/proxy/$",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
-const ApiSessionsRoute = Route$o.update({
+const ApiSessionsRoute = Route$r.update({
   id: "/api/sessions",
   path: "/api/sessions",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
-const ApiProvidersRoute = Route$n.update({
+const ApiRunsRoute = Route$q.update({
+  id: "/api/runs",
+  path: "/api/runs",
+  getParentRoute: () => Route$v
+});
+const ApiProvidersRoute = Route$p.update({
   id: "/api/providers",
   path: "/api/providers",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
-const ApiModelsRoute = Route$m.update({
+const ApiModelsRoute = Route$o.update({
   id: "/api/models",
   path: "/api/models",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
-const ApiMcpRoute = Route$l.update({
+const ApiMcpRoute = Route$n.update({
   id: "/api/mcp",
   path: "/api/mcp",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
-const ApiLogsRoute = Route$k.update({
+const ApiLogsRoute = Route$m.update({
   id: "/api/logs",
   path: "/api/logs",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
-const ApiHealthRoute = Route$j.update({
+const ApiHealthRoute = Route$l.update({
   id: "/api/health",
   path: "/api/health",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
-const ApiConfigRoute = Route$i.update({
+const ApiConfigRoute = Route$k.update({
   id: "/api/config",
   path: "/api/config",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
+});
+const ApiRunsRunIdRoute = Route$j.update({
+  id: "/$runId",
+  path: "/$runId",
+  getParentRoute: () => ApiRunsRoute
 });
-const ApiProvidersScanRoute = Route$h.update({
+const ApiProvidersScanRoute = Route$i.update({
   id: "/scan",
   path: "/scan",
   getParentRoute: () => ApiProvidersRoute
 });
-const ApiProvidersImportRoute = Route$g.update({
+const ApiProvidersImportRoute = Route$h.update({
   id: "/import",
   path: "/import",
   getParentRoute: () => ApiProvidersRoute
 });
-const ApiProvidersExportRoute = Route$f.update({
+const ApiProvidersExportRoute = Route$g.update({
   id: "/export",
   path: "/export",
   getParentRoute: () => ApiProvidersRoute
 });
-const ApiProvidersProviderIdRoute = Route$e.update({
+const ApiProvidersProviderIdRoute = Route$f.update({
   id: "/$providerId",
   path: "/$providerId",
   getParentRoute: () => ApiProvidersRoute
 });
-const ApiLogsStreamRoute = Route$d.update({
+const ApiLogsStreamRoute = Route$e.update({
   id: "/stream",
   path: "/stream",
   getParentRoute: () => ApiLogsRoute
 });
-const ApiLogsIdRoute = Route$c.update({
+const ApiLogsIdRoute = Route$d.update({
   id: "/$id",
   path: "/$id",
   getParentRoute: () => ApiLogsRoute
 });
-const ApiKnowledgeSearchRoute = Route$b.update({
+const ApiKnowledgeSearchRoute = Route$c.update({
   id: "/api/knowledge/search",
   path: "/api/knowledge/search",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
-const ApiKnowledgeProjectContextRoute = Route$a.update({
+const ApiKnowledgeProjectContextRoute = Route$b.update({
   id: "/api/knowledge/project-context",
   path: "/api/knowledge/project-context",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
-const ApiKnowledgeCandidatesRoute = Route$9.update({
+const ApiKnowledgeCandidatesRoute = Route$a.update({
   id: "/api/knowledge/candidates",
   path: "/api/knowledge/candidates",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
-const ApiConfigPathsRoute = Route$8.update({
+const ApiConfigPathsRoute = Route$9.update({
   id: "/paths",
   path: "/paths",
   getParentRoute: () => ApiConfigRoute
 });
+const ApiRunsRunIdEvidenceRoute = Route$8.update({
+  id: "/evidence",
+  path: "/evidence",
+  getParentRoute: () => ApiRunsRunIdRoute
+});
 const ApiProvidersProviderIdTestRoute = Route$7.update({
   id: "/test",
   path: "/test",
@@ -8353,7 +10349,7 @@ const ApiProvidersProviderIdTestLogRoute = Route$2.update({
 const ApiKnowledgeSessionsSessionIdCandidatesRoute = Route$1.update({
   id: "/api/knowledge/sessions/$sessionId/candidates",
   path: "/api/knowledge/sessions/$sessionId/candidates",
-  getParentRoute: () => Route$s
+  getParentRoute: () => Route$v
 });
 const ApiKnowledgeCandidatesCandidateIdPromoteRoute = Route.update({
   id: "/promote",
@@ -8400,6 +10396,16 @@ const ApiProvidersRouteChildren = {
 const ApiProvidersRouteWithChildren = ApiProvidersRoute._addFileChildren(
   ApiProvidersRouteChildren
 );
+const ApiRunsRunIdRouteChildren = {
+  ApiRunsRunIdEvidenceRoute
+};
+const ApiRunsRunIdRouteWithChildren = ApiRunsRunIdRoute._addFileChildren(
+  ApiRunsRunIdRouteChildren
+);
+const ApiRunsRouteChildren = {
+  ApiRunsRunIdRoute: ApiRunsRunIdRouteWithChildren
+};
+const ApiRunsRouteWithChildren = ApiRunsRoute._addFileChildren(ApiRunsRouteChildren);
 const ApiKnowledgeCandidatesCandidateIdRouteChildren = {
   ApiKnowledgeCandidatesCandidateIdPromoteRoute
 };
@@ -8420,6 +10426,7 @@ const rootRouteChildren = {
   ApiMcpRoute,
   ApiModelsRoute,
   ApiProvidersRoute: ApiProvidersRouteWithChildren,
+  ApiRunsRoute: ApiRunsRouteWithChildren,
   ApiSessionsRoute,
   ProxySplatRoute,
   SessionSessionIdRoute,
@@ -8428,7 +10435,7 @@ const rootRouteChildren = {
   ApiKnowledgeSearchRoute,
   ApiKnowledgeSessionsSessionIdCandidatesRoute
 };
-const routeTree = Route$s._addFileChildren(rootRouteChildren)._addFileTypes();
+const routeTree = Route$v._addFileChildren(rootRouteChildren)._addFileTypes();
 function getRouter() {
   const router2 = createRouter({
     routeTree,
@@ -8448,7 +10455,7 @@ export {
   MAX_SLOW_RESPONSE_THRESHOLD_SECONDS as M,
   OpenAIRequestSchema as O,
   ProviderConfigSchema as P,
-  Route$q as R,
+  Route$t as R,
   TimeDisplayFormatSchema as T,
   DEFAULT_SLOW_RESPONSE_THRESHOLD_SECONDS as a,
   DEFAULT_PROVIDER_TEST_TIMEOUT_SECONDS as b,