@tonyclaw/agent-inspector 2.1.3 → 2.1.5

package/.output/server/_ssr/{router-DRZPhZB6.mjs → router-C8DJ5pQZ.mjs}

@@ -5,14 +5,14 @@ import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync, copyFil
 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, resolve, relative } from "node:path";
+import path, { basename, join, isAbsolute, dirname, resolve, relative } from "node:path";
 import { execFile, exec, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { C as Conf } from "../_libs/conf.mjs";
 import { randomUUID } from "crypto";
 import { promisify } from "node:util";
 import { Worker } from "node:worker_threads";
-import { randomUUID as randomUUID$1 } from "node:crypto";
+import { randomUUID as randomUUID$1, createHash } from "node:crypto";
 import { M as McpServer, W as WebStandardStreamableHTTPServerTransport, R as ResourceTemplate } from "../_libs/modelcontextprotocol__server.mjs";
 import { J as JSZip } from "../_libs/jszip.mjs";
 import { homedir } from "node:os";
@@ -65,8 +65,8 @@ import "../_libs/immediate.mjs";
 import "../_libs/setimmediate.mjs";
 import "../_libs/pako.mjs";
 const faviconSvg = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2024%2024'%20role='img'%20aria-label='Agent%20Inspector'%3e%3cg%20fill='none'%20stroke='%23f59e0b'%20stroke-width='1.5'%20stroke-linecap='round'%20stroke-linejoin='round'%20%3e%3cpath%20d='M5%2013%20C5%209%208%207%2012%207%20C16%207%2019%209%2019%2013%20C19%2016%2016%2018%2012%2018%20C8%2018%205%2016%205%2013%20Z'%20/%3e%3cpath%20d='M5%2011%20C3.5%209.5%201.5%2010%202%2012.5%20C2.5%2014%204%2013.5%205%2012.5'%20/%3e%3cpath%20d='M19%2011%20C20.5%209.5%2022.5%2010%2022%2012.5%20C21.5%2014%2020%2013.5%2019%2012.5'%20/%3e%3cline%20x1='10'%20y1='7'%20x2='9.5'%20y2='5'%20/%3e%3cline%20x1='14'%20y1='7'%20x2='14.5'%20y2='5'%20/%3e%3cline%20x1='6.5'%20y1='16'%20x2='4.5'%20y2='19.5'%20/%3e%3cline%20x1='9'%20y1='17.5'%20x2='8'%20y2='20.5'%20/%3e%3cline%20x1='15'%20y1='17.5'%20x2='16'%20y2='20.5'%20/%3e%3cline%20x1='17.5'%20y1='16'%20x2='19.5'%20y2='19.5'%20/%3e%3c/g%3e%3ccircle%20cx='9.5'%20cy='4.5'%20r='0.9'%20fill='%23f59e0b'%20/%3e%3ccircle%20cx='14.5'%20cy='4.5'%20r='0.9'%20fill='%23f59e0b'%20/%3e%3c/svg%3e";
-const appCss = "/assets/index-B-MZ9lQM.css";
-const Route$z = createRootRoute({
+const appCss = "/assets/index-Bcq8bZoK.css";
+const Route$D = createRootRoute({
   head: () => ({
     meta: [
       { charSet: "utf-8" },
@@ -108,8 +108,8 @@ function RootDocument({ children }) {
     ] })
   ] });
 }
-const $$splitComponentImporter$1 = () => import("./index-6eY__la9.mjs");
-const Route$y = createFileRoute("/")({
+const $$splitComponentImporter$1 = () => import("./index-CHTchkrO.mjs");
+const Route$C = createFileRoute("/")({
   component: lazyRouteComponent($$splitComponentImporter$1, "component")
 });
 const B64URL_RE = /^[A-Za-z0-9_-]+$/;
@@ -151,8 +151,8 @@ function decodeSessionIdFromPath(encoded) {
 function getSessionPath(sessionId) {
   return `/session/${encodeSessionIdForPath(sessionId)}`;
 }
-const $$splitComponentImporter = () => import("../_sessionId-DnOYbKO7.mjs");
-const Route$x = createFileRoute("/session/$sessionId")({
+const $$splitComponentImporter = () => import("../_sessionId-COVUf_EG.mjs");
+const Route$B = createFileRoute("/session/$sessionId")({
   component: lazyRouteComponent($$splitComponentImporter, "component"),
   parseParams: (params) => ({
     sessionId: decodeSessionIdFromPath(params.sessionId)
@@ -385,6 +385,19 @@ const StreamingChunksArraySchema = object({
   chunks: array(StreamingChunkSchema$1),
   truncated: boolean().optional().default(false)
 });
+const LogBodyPartSchema = _enum(["request", "response"]);
+const LogBodyChunkSchema = object({
+  logId: number().int().positive(),
+  part: LogBodyPartSchema,
+  text: string(),
+  offset: number().int().nonnegative(),
+  limit: number().int().positive(),
+  totalBytes: number().int().nonnegative(),
+  textBytes: number().int().nonnegative(),
+  nextOffset: number().int().nonnegative().nullable(),
+  hasMore: boolean(),
+  contentMode: _enum(["empty", "partial", "full"])
+});
 const CapturedLogSchema = object({
   id: number(),
   timestamp: string(),
@@ -851,12 +864,530 @@ function readChunks(path2) {
     return null;
   }
 }
+const SQLITE_INDEX_FILE = "inspector.sqlite";
+const SQLITE_PACKAGE_NAME = "better-sqlite3";
+const BUN_SQLITE_MODULE_NAME = "bun:sqlite";
+const CREATE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS log_index (
+  id INTEGER PRIMARY KEY,
+  file TEXT NOT NULL,
+  byte_offset INTEGER NOT NULL,
+  byte_length INTEGER NOT NULL,
+  session_id TEXT,
+  model TEXT,
+  timestamp TEXT NOT NULL,
+  method TEXT NOT NULL,
+  path TEXT NOT NULL,
+  response_status INTEGER,
+  input_tokens INTEGER,
+  output_tokens INTEGER,
+  cache_creation_input_tokens INTEGER,
+  cache_read_input_tokens INTEGER,
+  elapsed_ms INTEGER,
+  first_chunk_ms INTEGER,
+  total_stream_ms INTEGER,
+  tokens_per_second REAL,
+  streaming INTEGER NOT NULL,
+  user_agent TEXT,
+  origin TEXT,
+  api_format TEXT NOT NULL,
+  is_test INTEGER NOT NULL,
+  replay_of_log_id INTEGER,
+  provider_name TEXT,
+  client_port INTEGER,
+  client_pid INTEGER,
+  client_cwd TEXT,
+  client_project_folder TEXT,
+  streaming_chunks_path TEXT,
+  raw_request_body_bytes INTEGER,
+  response_text_bytes INTEGER,
+  warnings_json TEXT,
+  error TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_log_index_session_id_id ON log_index(session_id, id);
+CREATE INDEX IF NOT EXISTS idx_log_index_model_id ON log_index(model, id);
+CREATE INDEX IF NOT EXISTS idx_log_index_timestamp ON log_index(timestamp);
+`;
+const UPSERT_SQL = `
+INSERT INTO log_index (
+  id,
+  file,
+  byte_offset,
+  byte_length,
+  session_id,
+  model,
+  timestamp,
+  method,
+  path,
+  response_status,
+  input_tokens,
+  output_tokens,
+  cache_creation_input_tokens,
+  cache_read_input_tokens,
+  elapsed_ms,
+  first_chunk_ms,
+  total_stream_ms,
+  tokens_per_second,
+  streaming,
+  user_agent,
+  origin,
+  api_format,
+  is_test,
+  replay_of_log_id,
+  provider_name,
+  client_port,
+  client_pid,
+  client_cwd,
+  client_project_folder,
+  streaming_chunks_path,
+  raw_request_body_bytes,
+  response_text_bytes,
+  warnings_json,
+  error
+) VALUES (
+  ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+)
+ON CONFLICT(id) DO UPDATE SET
+  file = excluded.file,
+  byte_offset = excluded.byte_offset,
+  byte_length = excluded.byte_length,
+  session_id = excluded.session_id,
+  model = excluded.model,
+  timestamp = excluded.timestamp,
+  method = excluded.method,
+  path = excluded.path,
+  response_status = excluded.response_status,
+  input_tokens = excluded.input_tokens,
+  output_tokens = excluded.output_tokens,
+  cache_creation_input_tokens = excluded.cache_creation_input_tokens,
+  cache_read_input_tokens = excluded.cache_read_input_tokens,
+  elapsed_ms = excluded.elapsed_ms,
+  first_chunk_ms = excluded.first_chunk_ms,
+  total_stream_ms = excluded.total_stream_ms,
+  tokens_per_second = excluded.tokens_per_second,
+  streaming = excluded.streaming,
+  user_agent = excluded.user_agent,
+  origin = excluded.origin,
+  api_format = excluded.api_format,
+  is_test = excluded.is_test,
+  replay_of_log_id = excluded.replay_of_log_id,
+  provider_name = excluded.provider_name,
+  client_port = excluded.client_port,
+  client_pid = excluded.client_pid,
+  client_cwd = excluded.client_cwd,
+  client_project_folder = excluded.client_project_folder,
+  streaming_chunks_path = excluded.streaming_chunks_path,
+  raw_request_body_bytes = excluded.raw_request_body_bytes,
+  response_text_bytes = excluded.response_text_bytes,
+  warnings_json = excluded.warnings_json,
+  error = excluded.error
+`;
+let sqliteStatePromise = null;
+let sqliteStatePath = null;
+let activeDb = null;
+let didLogUnavailable = false;
+function isSqliteLogIndexEnabled() {
+  const configured = process.env["AGENT_INSPECTOR_SQLITE_INDEX"];
+  if (configured === "1") return true;
+  if (configured === "0") return false;
+  return process.env["NODE_ENV"] !== "test";
+}
+function getSqlitePath() {
+  return join(resolveLogDir(), SQLITE_INDEX_FILE);
+}
+function objectFromUnknown(value) {
+  if (value === null) return null;
+  if (typeof value === "object" || typeof value === "function") return value;
+  return null;
+}
+function readProperty$1(value, name) {
+  let current = objectFromUnknown(value);
+  while (current !== null) {
+    const desc = Object.getOwnPropertyDescriptor(current, name);
+    if (desc !== void 0) {
+      const propertyValue = Reflect.get(current, name);
+      return propertyValue;
+    }
+    const nextPrototype = Object.getPrototypeOf(current);
+    current = objectFromUnknown(nextPrototype);
+  }
+  return void 0;
+}
+function readFunction(value, name) {
+  const property = readProperty$1(value, name);
+  return typeof property === "function" ? property : null;
+}
+function callMethod(target, methodName, args) {
+  const method = readFunction(target, methodName);
+  if (method === null) return void 0;
+  try {
+    return Reflect.apply(method, target, [...args]);
+  } catch (err) {
+    logger.warn("[sqliteLogIndex] SQLite method failed:", methodName, String(err));
+    return void 0;
+  }
+}
+function prepareStatement(db, sql) {
+  return callMethod(db, "prepare", [sql]);
+}
+function runPrepared(db, sql, params = []) {
+  const statement = prepareStatement(db, sql);
+  if (statement === void 0) return false;
+  const result = callMethod(statement, "run", params);
+  callMethod(statement, "finalize", []);
+  return result !== void 0;
+}
+function getPrepared(db, sql, params = []) {
+  const statement = prepareStatement(db, sql);
+  if (statement === void 0) return void 0;
+  const result = callMethod(statement, "get", params);
+  callMethod(statement, "finalize", []);
+  return result;
+}
+function allPrepared(db, sql, params = []) {
+  const statement = prepareStatement(db, sql);
+  if (statement === void 0) return null;
+  const result = callMethod(statement, "all", params);
+  callMethod(statement, "finalize", []);
+  return Array.isArray(result) ? result : null;
+}
+function execSql(db, sql) {
+  const result = callMethod(db, "exec", [sql]);
+  return result !== void 0;
+}
+function sqliteConstructorFromModule(moduleValue, exportName) {
+  const exportedValue = readProperty$1(moduleValue, exportName);
+  if (typeof exportedValue === "function") {
+    return (path2) => Reflect.construct(exportedValue, [path2]);
+  }
+  return null;
+}
+async function loadSqliteModuleConstructor(moduleName, exportName) {
+  try {
+    const importedModule = await import(
+      /* @vite-ignore */
+      moduleName
+    );
+    const exportedConstructor = sqliteConstructorFromModule(importedModule, exportName);
+    if (exportedConstructor !== null) return { constructor: exportedConstructor, reason: null };
+    if (exportName === "default" && typeof importedModule === "function") {
+      return {
+        constructor: (path2) => Reflect.construct(importedModule, [path2]),
+        reason: null
+      };
+    }
+    return { constructor: null, reason: `${moduleName} did not expose ${exportName}` };
+  } catch (err) {
+    return { constructor: null, reason: String(err) };
+  }
+}
+async function loadSqliteConstructor() {
+  const bunRuntimeDesc = Object.getOwnPropertyDescriptor(process.versions, "bun");
+  if (bunRuntimeDesc !== void 0) {
+    const bunSqlite2 = await loadSqliteModuleConstructor(BUN_SQLITE_MODULE_NAME, "Database");
+    if (bunSqlite2.constructor !== null) return bunSqlite2;
+    const betterSqlite2 = await loadSqliteModuleConstructor(SQLITE_PACKAGE_NAME, "default");
+    if (betterSqlite2.constructor !== null) return betterSqlite2;
+    const reason2 = [bunSqlite2.reason, betterSqlite2.reason].filter((item) => item !== null).join("; ");
+    if (!didLogUnavailable) {
+      didLogUnavailable = true;
+      logger.warn("[sqliteLogIndex] Optional SQLite index unavailable:", reason2);
+    }
+    return { constructor: null, reason: reason2 };
+  }
+  const betterSqlite = await loadSqliteModuleConstructor(SQLITE_PACKAGE_NAME, "default");
+  if (betterSqlite.constructor !== null) return betterSqlite;
+  const bunSqlite = await loadSqliteModuleConstructor(BUN_SQLITE_MODULE_NAME, "Database");
+  if (bunSqlite.constructor !== null) return bunSqlite;
+  const reason = [betterSqlite.reason, bunSqlite.reason].filter((item) => item !== null).join("; ");
+  if (!didLogUnavailable) {
+    didLogUnavailable = true;
+    logger.warn("[sqliteLogIndex] Optional SQLite index unavailable:", reason);
+  }
+  return { constructor: null, reason };
+}
+async function initializeSqliteState() {
+  const path2 = getSqlitePath();
+  if (!isSqliteLogIndexEnabled()) {
+    return { status: "unavailable", path: path2, reason: "SQLite log index is disabled" };
+  }
+  const sqliteConstructor = await loadSqliteConstructor();
+  if (sqliteConstructor.constructor === null) {
+    return {
+      status: "unavailable",
+      path: path2,
+      reason: sqliteConstructor.reason ?? "SQLite runtime is not available"
+    };
+  }
+  try {
+    await mkdir(dirname(path2), { recursive: true });
+    const db = sqliteConstructor.constructor(path2);
+    execSql(db, "PRAGMA journal_mode = WAL");
+    execSql(db, "PRAGMA synchronous = NORMAL");
+    if (!execSql(db, CREATE_SCHEMA_SQL)) {
+      return { status: "unavailable", path: path2, reason: "SQLite schema initialization failed" };
+    }
+    activeDb = db;
+    return { status: "ready", db, path: path2 };
+  } catch (err) {
+    logger.warn("[sqliteLogIndex] Failed to initialize SQLite index:", String(err));
+    return { status: "unavailable", path: path2, reason: String(err) };
+  }
+}
+async function getSqliteState() {
+  const path2 = getSqlitePath();
+  if (sqliteStatePromise !== null && sqliteStatePath !== path2) {
+    closeSqliteLogIndex();
+  }
+  if (sqliteStatePromise === null) {
+    sqliteStatePath = path2;
+    sqliteStatePromise = initializeSqliteState();
+  }
+  return await sqliteStatePromise;
+}
+function closeSqliteLogIndex() {
+  if (activeDb !== null) {
+    callMethod(activeDb, "close", []);
+  }
+  activeDb = null;
+  sqliteStatePromise = null;
+  sqliteStatePath = null;
+}
+function warningJson(warnings) {
+  return warnings === void 0 ? null : JSON.stringify(warnings);
+}
+function boolToInt(value) {
+  return value ? 1 : 0;
+}
+function entryParams(entry) {
+  const summary = entry.summary;
+  return [
+    entry.id,
+    entry.file,
+    entry.byteOffset,
+    entry.byteLength,
+    entry.sessionId ?? summary?.sessionId ?? null,
+    entry.model ?? summary?.model ?? null,
+    summary?.timestamp ?? "",
+    summary?.method ?? "",
+    summary?.path ?? "",
+    summary?.responseStatus ?? null,
+    summary?.inputTokens ?? null,
+    summary?.outputTokens ?? null,
+    summary?.cacheCreationInputTokens ?? null,
+    summary?.cacheReadInputTokens ?? null,
+    summary?.elapsedMs ?? null,
+    summary?.firstChunkMs ?? null,
+    summary?.totalStreamMs ?? null,
+    summary?.tokensPerSecond ?? null,
+    boolToInt(summary?.streaming ?? false),
+    summary?.userAgent ?? null,
+    summary?.origin ?? null,
+    summary?.apiFormat ?? "unknown",
+    boolToInt(summary?.isTest ?? false),
+    summary?.replayOfLogId ?? null,
+    summary?.providerName ?? null,
+    summary?.clientPort ?? null,
+    summary?.clientPid ?? null,
+    summary?.clientCwd ?? null,
+    summary?.clientProjectFolder ?? null,
+    summary?.streamingChunksPath ?? null,
+    summary?.rawRequestBodyBytes ?? null,
+    summary?.responseTextBytes ?? null,
+    warningJson(summary?.warnings),
+    summary?.error ?? null
+  ];
+}
+function readNumber(row, name) {
+  const value = readProperty$1(row, name);
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readString$1(row, name) {
+  const value = readProperty$1(row, name);
+  return typeof value === "string" ? value : null;
+}
+function readBoolean(row, name) {
+  return readNumber(row, name) === 1;
+}
+function readApiFormat(row) {
+  const value = readString$1(row, "api_format");
+  switch (value) {
+    case "anthropic":
+      return "anthropic";
+    case "openai":
+      return "openai";
+    case "unknown":
+    case null:
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+function readWarnings(row) {
+  const value = readString$1(row, "warnings_json");
+  if (value === null) return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    if (!Array.isArray(parsed)) return void 0;
+    const warnings = [];
+    for (const item of parsed) {
+      if (typeof item !== "string") return void 0;
+      warnings.push(item);
+    }
+    return warnings;
+  } catch {
+    return void 0;
+  }
+}
+function readRequiredNumber(row, name) {
+  const value = readNumber(row, name);
+  return value === null || !Number.isInteger(value) ? null : value;
+}
+function summaryFromRow(row, id) {
+  return {
+    id,
+    timestamp: readString$1(row, "timestamp") ?? "",
+    method: readString$1(row, "method") ?? "",
+    path: readString$1(row, "path") ?? "",
+    model: readString$1(row, "model"),
+    sessionId: readString$1(row, "session_id"),
+    responseStatus: readNumber(row, "response_status"),
+    inputTokens: readNumber(row, "input_tokens"),
+    outputTokens: readNumber(row, "output_tokens"),
+    cacheCreationInputTokens: readNumber(row, "cache_creation_input_tokens"),
+    cacheReadInputTokens: readNumber(row, "cache_read_input_tokens"),
+    elapsedMs: readNumber(row, "elapsed_ms"),
+    firstChunkMs: readNumber(row, "first_chunk_ms"),
+    totalStreamMs: readNumber(row, "total_stream_ms"),
+    tokensPerSecond: readNumber(row, "tokens_per_second"),
+    streaming: readBoolean(row, "streaming"),
+    userAgent: readString$1(row, "user_agent"),
+    origin: readString$1(row, "origin"),
+    apiFormat: readApiFormat(row),
+    isTest: readBoolean(row, "is_test"),
+    replayOfLogId: readNumber(row, "replay_of_log_id"),
+    providerName: readString$1(row, "provider_name"),
+    clientPort: readNumber(row, "client_port"),
+    clientPid: readNumber(row, "client_pid"),
+    clientCwd: readString$1(row, "client_cwd"),
+    clientProjectFolder: readString$1(row, "client_project_folder"),
+    streamingChunksPath: readString$1(row, "streaming_chunks_path"),
+    rawRequestBodyBytes: readNumber(row, "raw_request_body_bytes"),
+    responseTextBytes: readNumber(row, "response_text_bytes"),
+    warnings: readWarnings(row),
+    error: readString$1(row, "error")
+  };
+}
+function entryFromRow(row) {
+  const id = readRequiredNumber(row, "id");
+  const file = readString$1(row, "file");
+  const byteOffset = readRequiredNumber(row, "byte_offset");
+  const byteLength = readRequiredNumber(row, "byte_length");
+  if (id === null || file === null || byteOffset === null || byteLength === null) return null;
+  return {
+    id,
+    file,
+    byteOffset,
+    byteLength,
+    sessionId: readString$1(row, "session_id"),
+    model: readString$1(row, "model"),
+    summary: summaryFromRow(row, id)
+  };
+}
+async function getSqliteLogIndexMaxId() {
+  const state = await getSqliteState();
+  if (state.status !== "ready") return null;
+  const row = getPrepared(state.db, "SELECT MAX(id) AS max_id FROM log_index");
+  return readNumber(row, "max_id") ?? 0;
+}
+async function upsertSqliteLogIndexEntry(entry) {
+  if (entry.summary === void 0) return false;
+  const state = await getSqliteState();
+  if (state.status !== "ready") return false;
+  return runPrepared(state.db, UPSERT_SQL, entryParams(entry));
+}
+async function syncSqliteLogIndexEntries(entries) {
+  const state = await getSqliteState();
+  if (state.status !== "ready") return false;
+  if (entries.length === 0) return true;
+  if (!execSql(state.db, "BEGIN IMMEDIATE")) return false;
+  try {
+    for (const entry of entries) {
+      if (entry.summary === void 0) continue;
+      if (!runPrepared(state.db, UPSERT_SQL, entryParams(entry))) {
+        execSql(state.db, "ROLLBACK");
+        return false;
+      }
+    }
+    return execSql(state.db, "COMMIT");
+  } catch (err) {
+    execSql(state.db, "ROLLBACK");
+    logger.warn("[sqliteLogIndex] Failed to sync SQLite index:", String(err));
+    return false;
+  }
+}
+async function findSqliteLogIndexEntry(id) {
+  const state = await getSqliteState();
+  if (state.status !== "ready") return null;
+  const row = getPrepared(state.db, "SELECT * FROM log_index WHERE id = ?", [id]);
+  return entryFromRow(row);
+}
+async function listSqliteLogIndexEntries({
+  sessionId,
+  model
+} = {}) {
+  const state = await getSqliteState();
+  if (state.status !== "ready") return null;
+  const clauses = [];
+  const params = [];
+  if (sessionId !== void 0) {
+    clauses.push("session_id = ?");
+    params.push(sessionId);
+  }
+  if (model !== void 0) {
+    clauses.push("model = ?");
+    params.push(model);
+  }
+  const where = clauses.length === 0 ? "" : ` WHERE ${clauses.join(" AND ")}`;
+  const rows = allPrepared(state.db, `SELECT * FROM log_index${where} ORDER BY id ASC`, params);
+  if (rows === null) return null;
+  const entries = [];
+  for (const row of rows) {
+    const entry = entryFromRow(row);
+    if (entry !== null) entries.push(entry);
+  }
+  return entries;
+}
+async function replaceSqliteLogIndexEntries(entries) {
+  const state = await getSqliteState();
+  if (state.status !== "ready") return false;
+  if (!execSql(state.db, "BEGIN IMMEDIATE")) return false;
+  try {
+    if (!runPrepared(state.db, "DELETE FROM log_index")) {
+      execSql(state.db, "ROLLBACK");
+      return false;
+    }
+    for (const entry of entries) {
+      if (entry.summary === void 0) continue;
+      if (!runPrepared(state.db, UPSERT_SQL, entryParams(entry))) {
+        execSql(state.db, "ROLLBACK");
+        return false;
+      }
+    }
+    return execSql(state.db, "COMMIT");
+  } catch (err) {
+    execSql(state.db, "ROLLBACK");
+    logger.warn("[sqliteLogIndex] Failed to replace SQLite index:", String(err));
+    return false;
+  }
+}
 const INDEX_VERSION = 1;
 const INDEX_FILE = "logs.idx";
 function getIndexPath() {
   return join(resolveLogDir(), INDEX_FILE);
 }
 let cachedIndex = null;
+let sqliteBackfillScheduledMaxId = 0;
 function textByteLength$2(value) {
   return value === null ? null : Buffer.byteLength(value, "utf8");
 }
@@ -950,10 +1481,12 @@ async function saveIndex(index) {
 }
 async function addToIndex(id, file, byteOffset, byteLength, metadata) {
   const index = await loadIndex();
-  index.entries[id] = metadata === void 0 ? { id, file, byteOffset, byteLength } : { id, file, byteOffset, byteLength, ...metadata };
+  const entry = metadata === void 0 ? { id, file, byteOffset, byteLength } : { id, file, byteOffset, byteLength, ...metadata };
+  index.entries[id] = entry;
   if (id > index.maxId) {
     index.maxId = id;
   }
+  void upsertSqliteLogIndexEntry(entry);
   scheduleIndexFlush();
 }
 let indexFlushScheduled = false;
@@ -981,13 +1514,50 @@ async function flushIndex() {
   await saveIndex(index);
 }
 async function findInIndex(id) {
+  const sqliteEntry = await findSqliteLogIndexEntry(id);
+  if (sqliteEntry !== null) return sqliteEntry;
   const index = await loadIndex();
   return index.entries[id] ?? null;
 }
 async function listIndexEntries() {
   const index = await loadIndex();
+  const sqliteMaxId = await getSqliteLogIndexMaxId();
+  if (sqliteMaxId !== null && sqliteMaxId >= index.maxId) {
+    const sqliteEntries = await listSqliteLogIndexEntries();
+    if (sqliteEntries !== null) return sqliteEntries;
+  }
+  maybeBackfillSqliteIndex(index, sqliteMaxId);
   return Object.values(index.entries).sort((left, right) => left.id - right.id);
 }
+async function listFilteredIndexEntries({
+  sessionId,
+  model
+}) {
+  const index = await loadIndex();
+  const sqliteMaxId = await getSqliteLogIndexMaxId();
+  if (sqliteMaxId !== null && sqliteMaxId >= index.maxId) {
+    const sqliteEntries = await listSqliteLogIndexEntries({ sessionId, model });
+    if (sqliteEntries !== null) return sqliteEntries;
+  }
+  maybeBackfillSqliteIndex(index, sqliteMaxId);
+  return Object.values(index.entries).sort((left, right) => left.id - right.id).filter((entry) => {
+    if (sessionId !== void 0 && entry.sessionId !== sessionId) return false;
+    if (model !== void 0 && entry.model !== model) return false;
+    return true;
+  });
+}
+function maybeBackfillSqliteIndex(index, sqliteMaxId) {
+  if (sqliteMaxId === null) return;
+  if (index.maxId <= sqliteMaxId) return;
+  if (index.maxId <= sqliteBackfillScheduledMaxId) return;
+  sqliteBackfillScheduledMaxId = index.maxId;
+  const entries = Object.values(index.entries);
+  void syncSqliteLogIndexEntries(entries).then((ok) => {
+    if (!ok && sqliteMaxId < sqliteBackfillScheduledMaxId) {
+      sqliteBackfillScheduledMaxId = sqliteMaxId;
+    }
+  });
+}
 function readStringOrNullField(entry, field) {
   const desc = Object.getOwnPropertyDescriptor(entry, field);
   if (desc === void 0) return null;
@@ -1113,6 +1683,7 @@ async function rebuildIndex() {
   if (!existsSync(logDir)) {
     cachedIndex = newIndex;
     await saveIndex(newIndex);
+    await replaceSqliteLogIndexEntries([]);
     return newIndex;
   }
   const files = (await readdir(logDir)).filter((f) => f.endsWith(".jsonl")).sort();
@@ -1127,6 +1698,7 @@ async function rebuildIndex() {
   }
   cachedIndex = newIndex;
   await saveIndex(newIndex);
+  await replaceSqliteLogIndexEntries(Object.values(newIndex.entries));
   return newIndex;
 }
 let idGenerationPromise = null;
@@ -1155,7 +1727,8 @@ async function getNextLogId() {
   await acquireLock();
   try {
     const index = await loadIndex();
-    const nextId = index.maxId + 1;
+    const sqliteMaxId = await getSqliteLogIndexMaxId();
+    const nextId = Math.max(index.maxId, sqliteMaxId ?? 0) + 1;
     index.maxId = nextId;
     cachedIndex = index;
     return nextId;
@@ -1624,7 +2197,7 @@ function rememberLogSession(log) {
   knownLogSessions.set(log.id, sessionId);
   return true;
 }
-function isFailedLog(log) {
+function isFailedLog$1(log) {
   const hasError = log.error !== null && log.error !== void 0 && log.error.length > 0;
   const hasErrorStatus = log.responseStatus !== null && log.responseStatus >= 400;
   return hasError || hasErrorStatus;
@@ -1648,7 +2221,7 @@ function markSessionFinished(log, sourceOverride) {
     completedLogIds.add(log.id);
     session.completedRequests += 1;
   }
-  if (isFailedLog(log) && failedLogIds.has(log.id) === false) {
+  if (isFailedLog$1(log) && failedLogIds.has(log.id) === false) {
     failedLogIds.add(log.id);
     session.failedRequests += 1;
   }
@@ -1798,8 +2371,8 @@ function compactLogForList(log) {
     rawHeaders: void 0,
     headers: void 0,
     streamingChunks: void 0,
-    rawRequestBodyBytes: textByteLength$1(log.rawRequestBody),
-    responseTextBytes: textByteLength$1(log.responseText),
+    rawRequestBodyBytes: log.rawRequestBodyBytes ?? textByteLength$1(log.rawRequestBody),
+    responseTextBytes: log.responseTextBytes ?? textByteLength$1(log.responseText),
     bodyContentMode: "compact"
   };
 }
@@ -1874,6 +2447,19 @@ async function addTestLogEntry(entry) {
   emitLogUpdate(log);
   return log;
 }
+async function importCapturedLogs(entries, sessionId) {
+  const imported = [];
+  for (const entry of entries) {
+    const log = await addTestLogEntry({
+      ...entry,
+      sessionId,
+      isTest: false,
+      replayOfLogId: null
+    });
+    imported.push(log);
+  }
+  return imported;
+}
 async function createLog(method, path2, requestBody, headers, clientInfo, rawHeaders, upstreamHeaders, apiFormat = "unknown", model = null, sessionId = null, preAcquiredId) {
   const userAgent = headers.get("user-agent");
   const origin = headers.get("origin");
@@ -2164,10 +2750,10 @@ function matchesLogIndexEntryFilters(entry, sessionId, model) {
   return true;
 }
 async function buildLogCursorPageIndexFromLogIndex(options, allowRebuild) {
-  let entries = await listIndexEntries();
+  let entries = await listFilteredIndexEntries(options);
   if (entries.length === 0 && allowRebuild) {
     await rebuildIndex();
-    entries = await listIndexEntries();
+    entries = await listFilteredIndexEntries(options);
   }
   if (entries.some((entry) => !hasLogIndexFilterMetadata(entry))) {
     if (!allowRebuild) return null;
@@ -2325,7 +2911,7 @@ async function collectSessionLogSummaries(sessionId, includeHistory) {
   return [...summariesById.values()];
 }
 async function collectIndexedSessionLogSummaries(sessionId) {
-  let entries = await listIndexEntries();
+  let entries = await listFilteredIndexEntries({ sessionId });
   if (entries.length === 0) return [];
   const needsMetadataRebuild = entries.some((entry) => !hasLogIndexFilterMetadata(entry));
   const needsSummaryRebuild = entries.some((entry) => {
@@ -2334,7 +2920,7 @@ async function collectIndexedSessionLogSummaries(sessionId) {
   });
   if (needsMetadataRebuild || needsSummaryRebuild) {
     await rebuildIndex();
-    entries = await listIndexEntries();
+    entries = await listFilteredIndexEntries({ sessionId });
   }
   const summaries = [];
   for (const entry of entries) {
@@ -2430,6 +3016,7 @@ function clearAllLogs() {
   memoryCache.clear();
   clearLogCursorPageIndexes();
   clearSessionRegistry();
+  closeSqliteLogIndex();
   return { cleared: count };
 }
 async function deleteMatchingFiles(dir, shouldDelete) {
@@ -2460,7 +3047,7 @@ async function clearPersistedLogStorage() {
     const [logFilesDeleted, chunkFilesDeleted] = await Promise.all([
       deleteMatchingFiles(
         resolveLogDir(),
-        (fileName) => fileName.endsWith(".jsonl") || fileName === "logs.idx"
+        (fileName) => fileName.endsWith(".jsonl") || fileName === "logs.idx" || fileName === "inspector.sqlite" || fileName.startsWith("inspector.sqlite-")
       ),
       deleteMatchingFiles(
         getChunksDir(),
@@ -4604,7 +5191,7 @@ function firstChunkMsFromChunks(chunks) {
   if (!Number.isFinite(first.timestamp) || first.timestamp < 0) return null;
   return Math.floor(first.timestamp);
 }
-function parseJson(raw) {
+function parseJson$1(raw) {
   if (raw === null) return { ok: false };
   try {
     return { ok: true, value: JSON.parse(raw) };
@@ -4963,8 +5550,8 @@ function uniqueWarnings(warnings) {
   return unique2;
 }
 function analyzeToolSchemaWarnings(input) {
-  const request = parseJson(input.rawRequestBody);
-  const response = parseJson(input.responseText);
+  const request = parseJson$1(input.rawRequestBody);
+  const response = parseJson$1(input.responseText);
   if (!request.ok || !response.ok) return [];
   const toolSchemas = extractToolSchemas(request.value, input.apiFormat);
   const toolCalls = extractToolCalls(response.value, input.apiFormat);
@@ -5794,7 +6381,7 @@ async function handleProxy(req) {
   }
   return handleStreamingResponse(upstreamRes, req, startTime, upstreamUrl, log, captureFullDetails);
 }
-const Route$w = createFileRoute("/proxy/$")({
+const Route$A = createFileRoute("/proxy/$")({
   server: {
     handlers: {
       GET: ({ request }) => handleProxy(request),
@@ -5806,7 +6393,7 @@ const Route$w = createFileRoute("/proxy/$")({
     }
   }
 });
-function parsePositiveInt$2(value) {
+function parsePositiveInt$4(value) {
   if (value === null) return void 0;
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed < 1) return void 0;
@@ -5815,7 +6402,7 @@ function parsePositiveInt$2(value) {
 function parseBooleanFlag(value) {
   return value === "1" || value === "true";
 }
-const Route$v = createFileRoute("/api/sessions")({
+const Route$z = createFileRoute("/api/sessions")({
   server: {
     handlers: {
       GET: async ({ request }) => {
@@ -5828,7 +6415,7 @@ const Route$v = createFileRoute("/api/sessions")({
           const info = await getSessionInfo(sessionId, {
             baseUrl: url.origin,
             includeHistory: parseBooleanFlag(url.searchParams.get("includeHistory")),
-            latestLogLimit: parsePositiveInt$2(url.searchParams.get("limit"))
+            latestLogLimit: parsePositiveInt$4(url.searchParams.get("limit"))
           });
           if (info === null) {
             return Response.json({ error: "Session not found" }, { status: 404 });
@@ -6571,6 +7158,7 @@ const InspectorGroupEvidenceSummarySchema = object({
 const GroupEvidenceReadResponseSchema = object({
   group: InspectorGroupSchema,
   evidence: InspectorGroupEvidenceSchema,
+  members: array(InspectorGroupExportMemberSchema).nullable(),
   markdown: string(),
   summary: InspectorGroupEvidenceSummarySchema.nullable(),
   report: EvidenceReportSchema.nullable()
@@ -7246,19 +7834,19 @@ async function readJsonBody$6(request) {
     return { ok: false };
   }
 }
-function parsePositiveInt$1(value, fallback) {
+function parsePositiveInt$3(value, fallback) {
   if (value === null) return fallback;
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed < 1) return fallback;
   return parsed;
 }
-const Route$u = createFileRoute("/api/runs")({
+const Route$y = createFileRoute("/api/runs")({
   server: {
     handlers: {
       GET: ({ request }) => {
         const url = new URL(request.url);
         if (url.searchParams.get("failures") === "1") {
-          const limit = parsePositiveInt$1(
+          const limit = parsePositiveInt$3(
             url.searchParams.get("limit"),
             RECENT_FAILURES_DEFAULT_LIMIT
           );
@@ -7297,7 +7885,7 @@ const ProviderInputSchema = object({
   modelMetadata: array(ProviderModelMetadataSchema).optional(),
   source: _enum(["company", "personal"]).optional()
 });
-const Route$t = createFileRoute("/api/providers")({
+const Route$x = createFileRoute("/api/providers")({
   server: {
     handlers: {
       GET: ({ request }) => {
@@ -7331,14 +7919,14 @@ const Route$t = createFileRoute("/api/providers")({
     }
   }
 });
-const Route$s = createFileRoute("/api/models")({
+const Route$w = createFileRoute("/api/models")({
   server: {
     handlers: {
       GET: () => Response.json(getModels())
     }
   }
 });
-const version = "2.1.3";
+const version = "2.1.5";
 const packageJson = {
   version
 };
@@ -7483,7 +8071,7 @@ function isCompletedMember(member) {
   const status = memberEffectiveStatus(member);
   return status === "completed";
 }
-function isFailedMember(member) {
+function isFailedMember$1(member) {
   const status = memberEffectiveStatus(member);
   return status === "failed" || status === "cancelled";
 }
@@ -7527,7 +8115,7 @@ function buildSummary(members) {
       members.flatMap((member) => [member.member.provider, ...member.session?.providers ?? []])
     ),
     completedMembers: members.filter(isCompletedMember).length,
-    failedMembers: members.filter(isFailedMember).length,
+    failedMembers: members.filter(isFailedMember$1).length,
     runningMembers: members.filter(isRunningMember).length
   };
 }
@@ -7764,6 +8352,7 @@ function readInspectorGroupEvidence(groupId) {
   return serviceOk({
     group,
     evidence: group.evidence,
+    members: document?.members ?? null,
     markdown,
     summary: document?.summary ?? null,
     report: document?.jenkinsReport ?? null
@@ -9839,7 +10428,7 @@ const PROMPT_NAMES = [
   "inspector_generate_group_report",
   "inspector_extract_repro_steps"
 ];
-const Route$r = createFileRoute("/api/mcp")({
+const Route$v = createFileRoute("/api/mcp")({
   server: {
     handlers: {
       // The SDK may issue either POST, GET, or DELETE. TanStack Start only
@@ -9855,15 +10444,15 @@ 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) {
+function clampPositiveInt$1(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);
+  return clampPositiveInt$1(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);
+  return clampPositiveInt$1(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);
@@ -9944,7 +10533,7 @@ function parseNonNegativeInt(value, fallback) {
   if (!Number.isInteger(parsed) || parsed < 0) return fallback;
   return parsed;
 }
-function parsePositiveInt(value, fallback) {
+function parsePositiveInt$2(value, fallback) {
   if (value === null) return fallback;
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed < 1) return fallback;
@@ -9956,7 +10545,7 @@ function parseOptionalPositiveInt(value) {
   if (!Number.isInteger(parsed) || parsed < 1) return { ok: false };
   return { ok: true, value: parsed };
 }
-const Route$q = createFileRoute("/api/logs")({
+const Route$u = createFileRoute("/api/logs")({
   server: {
     handlers: {
       GET: async ({ request }) => {
@@ -9978,8 +10567,8 @@ const Route$q = createFileRoute("/api/logs")({
         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(
+          const limit2 = parsePositiveInt$2(url.searchParams.get("limit"), LOG_SEARCH_DEFAULT_LIMIT);
+          const scanLimit = parsePositiveInt$2(
             url.searchParams.get("scanLimit"),
             LOG_SEARCH_DEFAULT_SCAN_LIMIT
           );
@@ -9987,7 +10576,7 @@ const Route$q = createFileRoute("/api/logs")({
             await searchLogsPage({ query, sessionId, model, offset, limit: limit2, scanLimit })
           );
         }
-        const limit = parsePositiveInt(url.searchParams.get("limit"), 50);
+        const limit = parsePositiveInt$2(url.searchParams.get("limit"), 50);
         const includeBodies = url.searchParams.get("compact") !== "1";
         if (url.searchParams.get("cursor") === "1" || url.searchParams.get("cursor") === "true") {
           const beforeLogId = parseOptionalPositiveInt(url.searchParams.get("beforeLogId"));
@@ -10057,7 +10646,7 @@ const Route$q = createFileRoute("/api/logs")({
   }
 });
 logger.debug("Health endpoint loaded");
-const Route$p = createFileRoute("/api/health")({
+const Route$t = createFileRoute("/api/health")({
   server: {
     handlers: {
       GET: () => {
@@ -10075,7 +10664,7 @@ async function readJsonBody$5(request) {
     return { ok: false };
   }
 }
-const Route$o = createFileRoute("/api/groups")({
+const Route$s = createFileRoute("/api/groups")({
   server: {
     handlers: {
       GET: () => Response.json(listInspectorGroups()),
@@ -10105,7 +10694,7 @@ const RuntimeConfigPatchSchema = object({
 }).strict().refine((v) => Object.keys(v).length > 0, {
   message: "At least one field must be provided"
 });
-const Route$n = createFileRoute("/api/config")({
+const Route$r = createFileRoute("/api/config")({
   server: {
     handlers: {
       GET: () => {
@@ -10134,107 +10723,703 @@ const Route$n = createFileRoute("/api/config")({
     }
   }
 });
-async function readJsonBody$4(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$m = createFileRoute("/api/runs/$runId")({
-  server: {
-    handlers: {
-      GET: ({ params }) => {
-        const run = getInspectorRun(params.runId);
-        if (!run.ok) {
-          return Response.json({ error: run.message }, { status: run.status });
-        }
-        return Response.json(run.value);
-      },
-      PATCH: async ({ params, request }) => {
-        const body = await readJsonBody$4(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 = updateInspectorRun(params.runId, parsed.data);
-        if (!updated.ok) {
-          return Response.json({ error: updated.message }, { status: updated.status });
-        }
-        return Response.json(updated.value);
-      }
-    }
-  }
+const AlertSeveritySchema = _enum(["critical", "warning", "notice"]);
+const AlertStatusSchema = _enum(["open"]);
+const AlertSourceSchema = _enum(["proxy", "tool-schema", "run", "group"]);
+const AlertCategorySchema = _enum([
+  "request-failure",
+  "request-timeout",
+  "slow-response",
+  "tool-schema",
+  "run-failure",
+  "group-failure",
+  "group-incomplete"
+]);
+const AlertEvidenceKindSchema = _enum(["log", "session", "run", "group"]);
+const AlertApiFormatSchema = _enum(["anthropic", "openai", "unknown"]);
+const AlertEvidenceLinkSchema = object({
+  kind: AlertEvidenceKindSchema,
+  id: string(),
+  label: string(),
+  href: string().nullable()
 });
-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";
-function readJsonSafe(filePath) {
-  try {
-    if (!existsSync(filePath)) return null;
-    const raw = readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    return isPlainRecord(parsed) ? parsed : null;
-  } catch {
-    return null;
+const AlertSchema = object({
+  id: string(),
+  fingerprint: string(),
+  severity: AlertSeveritySchema,
+  category: AlertCategorySchema,
+  source: AlertSourceSchema,
+  status: AlertStatusSchema,
+  title: string(),
+  message: string(),
+  count: number().int().positive(),
+  firstSeenAt: string(),
+  lastSeenAt: string(),
+  logIds: array(number().int().positive()),
+  sessionIds: array(string()),
+  runIds: array(string()),
+  groupIds: array(string()),
+  provider: string().nullable(),
+  model: string().nullable(),
+  apiFormat: AlertApiFormatSchema.nullable(),
+  evidence: array(AlertEvidenceLinkSchema),
+  metadata: record(string(), JsonValueSchema)
+});
+const AlertCategoryCountSchema = object({
+  category: AlertCategorySchema,
+  count: number().int().nonnegative()
+});
+const AlertSummarySchema = object({
+  total: number().int().nonnegative(),
+  open: number().int().nonnegative(),
+  critical: number().int().nonnegative(),
+  warning: number().int().nonnegative(),
+  notice: number().int().nonnegative(),
+  byCategory: array(AlertCategoryCountSchema)
+});
+const AlertListResponseSchema = object({
+  alerts: array(AlertSchema),
+  total: number().int().nonnegative(),
+  limit: number().int().positive(),
+  summary: AlertSummarySchema
+});
+const DEFAULT_ALERT_LIMIT = 50;
+const MAX_ALERT_LIMIT = 200;
+const DEFAULT_ALERT_SCAN_LIMIT = 500;
+const MAX_ALERT_SCAN_LIMIT = 2e3;
+function clampPositiveInt(value, fallback, max) {
+  if (value === void 0) return fallback;
+  if (!Number.isInteger(value) || value < 1) return fallback;
+  return Math.min(value, max);
+}
+function clampAlertLimit(value) {
+  return clampPositiveInt(value, DEFAULT_ALERT_LIMIT, MAX_ALERT_LIMIT);
+}
+function clampAlertScanLimit(value) {
+  return clampPositiveInt(value, DEFAULT_ALERT_SCAN_LIMIT, MAX_ALERT_SCAN_LIMIT);
+}
+function alertIdFor(value) {
+  const digest = createHash("sha1").update(value).digest("hex").slice(0, 16);
+  return `alert_${digest}`;
+}
+function sanitizeFingerprintPart(value) {
+  if (value === null) return "-";
+  return String(value).trim().toLowerCase().replace(/\s+/g, " ").slice(0, 240);
+}
+function fingerprint(parts) {
+  return parts.map(sanitizeFingerprintPart).join("|");
+}
+function uniqueStrings$1(values) {
+  return [...new Set(values)].sort();
+}
+function uniqueNumbers(values) {
+  return [...new Set(values)].sort((left, right) => left - right);
+}
+function logEvidence(logId) {
+  const id = String(logId);
+  return { kind: "log", id, label: `Log #${id}`, href: `#log-${id}` };
+}
+function sessionEvidence(sessionId) {
+  return {
+    kind: "session",
+    id: sessionId,
+    label: `Session ${sessionId}`,
+    href: getSessionPath(sessionId)
+  };
+}
+function runEvidence(runId) {
+  return { kind: "run", id: runId, label: `Run ${runId}`, href: null };
+}
+function groupEvidence(groupId) {
+  return { kind: "group", id: groupId, label: `Group ${groupId}`, href: null };
+}
+function baseEvidence(logId, sessionId, runId, groupId) {
+  const links = [];
+  if (logId !== null) links.push(logEvidence(logId));
+  if (sessionId !== null) links.push(sessionEvidence(sessionId));
+  if (runId !== null) links.push(runEvidence(runId));
+  if (groupId !== null) links.push(groupEvidence(groupId));
+  return links;
+}
+function hasEquivalentEvidence(links, candidate) {
+  return links.some((link) => link.kind === candidate.kind && link.id === candidate.id);
+}
+function mergeEvidence(left, right) {
+  const merged = [...left];
+  for (const link of right) {
+    if (!hasEquivalentEvidence(merged, link)) merged.push(link);
   }
+  return merged;
 }
-function getEnvValue(envObj, key) {
-  if (!isPlainRecord(envObj)) return void 0;
-  const val = envObj[key];
-  return typeof val === "string" ? val.trim() : void 0;
+function firstString(left, right) {
+  return left ?? right;
 }
-const KNOWN_PROVIDER_NAMES = {
-  deepseek: "DeepSeek",
-  minimaxi: "MiniMax",
-  openai: "OpenAI",
-  anthropic: "Anthropic",
-  openrouter: "OpenRouter",
-  groq: "Groq",
-  together: "Together",
-  fireworks: "Fireworks",
-  bedrock: "Bedrock",
-  vertexai: "Vertex AI",
-  azure: "Azure",
-  moonshot: "Moonshot",
-  zhipu: "ZhipuAI",
-  zhipuai: "ZhipuAI",
-  bigmodel: "ZhipuAI",
-  zai: "Z.AI",
-  qwen: "Qwen",
-  baichuan: "Baichuan",
-  iflytek: "iFlytek",
-  doubao: "Doubao",
-  lingyiwanwu: "LingyiWanwu",
-  stepfun: "StepFun"
-};
-function deriveNameFromUrl(url) {
-  try {
-    const hostname = new URL(url).hostname;
-    const parts = hostname.split(".");
-    const domain = parts.length >= 2 ? parts[parts.length - 2] ?? hostname : hostname;
-    const domainLower = domain.toLowerCase();
-    if (KNOWN_PROVIDER_NAMES[domainLower] !== void 0) {
-      return KNOWN_PROVIDER_NAMES[domainLower];
-    }
-    return domain.charAt(0).toUpperCase() + domain.slice(1);
-  } catch {
-    return "Imported Provider";
+function mergeAlert(existing, observation) {
+  const logIds = observation.logId === null ? existing.logIds : [...existing.logIds, observation.logId];
+  const sessionIds = observation.sessionId === null ? existing.sessionIds : [...existing.sessionIds, observation.sessionId];
+  const runIds = observation.runId === null ? existing.runIds : [...existing.runIds, observation.runId];
+  const groupIds = observation.groupId === null ? existing.groupIds : [...existing.groupIds, observation.groupId];
+  return {
+    ...existing,
+    count: existing.count + 1,
+    firstSeenAt: observation.observedAt < existing.firstSeenAt ? observation.observedAt : existing.firstSeenAt,
+    lastSeenAt: observation.observedAt > existing.lastSeenAt ? observation.observedAt : existing.lastSeenAt,
+    logIds: uniqueNumbers(logIds),
+    sessionIds: uniqueStrings$1(sessionIds),
+    runIds: uniqueStrings$1(runIds),
+    groupIds: uniqueStrings$1(groupIds),
+    provider: firstString(existing.provider, observation.provider),
+    model: firstString(existing.model, observation.model),
+    apiFormat: existing.apiFormat ?? observation.apiFormat,
+    evidence: mergeEvidence(existing.evidence, observation.evidence),
+    metadata: { ...existing.metadata, ...observation.metadata }
+  };
+}
+function observationToAlert(observation) {
+  return {
+    id: alertIdFor(observation.fingerprint),
+    fingerprint: observation.fingerprint,
+    severity: observation.severity,
+    category: observation.category,
+    source: observation.source,
+    status: "open",
+    title: observation.title,
+    message: observation.message,
+    count: 1,
+    firstSeenAt: observation.observedAt,
+    lastSeenAt: observation.observedAt,
+    logIds: observation.logId === null ? [] : [observation.logId],
+    sessionIds: observation.sessionId === null ? [] : [observation.sessionId],
+    runIds: observation.runId === null ? [] : [observation.runId],
+    groupIds: observation.groupId === null ? [] : [observation.groupId],
+    provider: observation.provider,
+    model: observation.model,
+    apiFormat: observation.apiFormat,
+    evidence: observation.evidence,
+    metadata: observation.metadata
+  };
+}
+function addObservation(map, observation) {
+  const existing = map.get(observation.fingerprint);
+  if (existing === void 0) {
+    map.set(observation.fingerprint, observationToAlert(observation));
+    return;
   }
+  map.set(observation.fingerprint, mergeAlert(existing, observation));
 }
-function detectClaudeCodeProviders() {
-  const home = homedir();
-  const results = [];
-  const globalConfig = readJsonSafe(join(home, ".claude", "settings.json"));
-  const localConfig = readJsonSafe(join(home, ".claude", "settings.local.json"));
+function lowerText(value) {
+  if (value === null || value === void 0) return "";
+  return value.toLowerCase();
+}
+function isTimeoutStatus(status) {
+  return status === 408 || status === 504;
+}
+function isTimeoutLog(log) {
+  const text = `${lowerText(log.error)} ${lowerText(log.responseText)}`;
+  return isTimeoutStatus(log.responseStatus) || text.includes("timeout") || text.includes("timed out") || text.includes("abort");
+}
+function hasFailureStatus(status) {
+  return status !== null && status >= 400;
+}
+function isFailedLog(log) {
+  return log.error !== null && log.error !== void 0 && log.error.length > 0 ? true : hasFailureStatus(log.responseStatus);
+}
+function statusLabel(status) {
+  return status === null ? "no status" : `HTTP ${String(status)}`;
+}
+function errorDetail(log) {
+  if (log.error !== null && log.error !== void 0 && log.error.length > 0) return log.error;
+  return statusLabel(log.responseStatus);
+}
+function requestFailureTitle(log, timeout) {
+  if (log.isTest === true && timeout) return "Provider test timed out";
+  if (log.isTest === true) return "Provider test failed";
+  return timeout ? "Request timed out" : "Request failed";
+}
+function requestFailureCategory(timeout) {
+  return timeout ? "request-timeout" : "request-failure";
+}
+function logProvider(log) {
+  return log.providerName ?? null;
+}
+function requestFailureObservation(log) {
+  if (!isFailedLog(log)) return null;
+  const timeout = isTimeoutLog(log);
+  const category = requestFailureCategory(timeout);
+  const message = `${errorDetail(log)} while calling ${log.path}.`;
+  return {
+    fingerprint: fingerprint([
+      "proxy",
+      category,
+      logProvider(log),
+      log.model,
+      log.responseStatus,
+      errorDetail(log)
+    ]),
+    severity: "critical",
+    category,
+    source: "proxy",
+    title: requestFailureTitle(log, timeout),
+    message,
+    observedAt: log.timestamp,
+    logId: log.id,
+    sessionId: log.sessionId,
+    runId: null,
+    groupId: null,
+    provider: logProvider(log),
+    model: log.model,
+    apiFormat: log.apiFormat,
+    evidence: baseEvidence(log.id, log.sessionId, null, null),
+    metadata: {
+      path: log.path,
+      status: log.responseStatus,
+      error: log.error ?? null,
+      isTest: log.isTest,
+      streaming: log.streaming
+    }
+  };
+}
+function slowResponseObservation(log, slowResponseThresholdSeconds) {
+  if (slowResponseThresholdSeconds <= 0) return null;
+  if (isFailedLog(log)) return null;
+  if (log.elapsedMs === null) return null;
+  const thresholdMs = slowResponseThresholdSeconds * 1e3;
+  if (log.elapsedMs < thresholdMs) return null;
+  const elapsedSeconds = (log.elapsedMs / 1e3).toFixed(1);
+  return {
+    fingerprint: fingerprint(["proxy", "slow-response", logProvider(log), log.model, log.path]),
+    severity: "warning",
+    category: "slow-response",
+    source: "proxy",
+    title: "Slow model response",
+    message: `Response took ${elapsedSeconds}s, above the ${String(
+      slowResponseThresholdSeconds
+    )}s threshold.`,
+    observedAt: log.timestamp,
+    logId: log.id,
+    sessionId: log.sessionId,
+    runId: null,
+    groupId: null,
+    provider: logProvider(log),
+    model: log.model,
+    apiFormat: log.apiFormat,
+    evidence: baseEvidence(log.id, log.sessionId, null, null),
+    metadata: {
+      path: log.path,
+      elapsedMs: log.elapsedMs,
+      thresholdMs,
+      streaming: log.streaming,
+      firstChunkMs: log.firstChunkMs ?? null,
+      totalStreamMs: log.totalStreamMs ?? null
+    }
+  };
+}
+function warningObservation(log, warning) {
+  return {
+    fingerprint: fingerprint(["tool-schema", logProvider(log), log.model, warning]),
+    severity: "warning",
+    category: "tool-schema",
+    source: "tool-schema",
+    title: "Tool calling argument warning",
+    message: warning,
+    observedAt: log.timestamp,
+    logId: log.id,
+    sessionId: log.sessionId,
+    runId: null,
+    groupId: null,
+    provider: logProvider(log),
+    model: log.model,
+    apiFormat: log.apiFormat,
+    evidence: baseEvidence(log.id, log.sessionId, null, null),
+    metadata: {
+      path: log.path,
+      warning
+    }
+  };
+}
+function addLogObservations(map, logs, slowResponseThresholdSeconds) {
+  for (const log of logs) {
+    const failure = requestFailureObservation(log);
+    if (failure !== null) addObservation(map, failure);
+    const slow = slowResponseObservation(log, slowResponseThresholdSeconds);
+    if (slow !== null) addObservation(map, slow);
+    for (const warning of log.warnings ?? []) {
+      addObservation(map, warningObservation(log, warning));
+    }
+  }
+}
+function alertSeverityFromFailure(failure) {
+  switch (failure.classification.severity) {
+    case "high":
+      return "critical";
+    case "medium":
+    case "low":
+      return "warning";
+    case "none":
+      return "notice";
+  }
+}
+function providerFromRun(failure) {
+  const provider = failure.run.metadata["provider"] ?? failure.run.metadata["providerName"];
+  return typeof provider === "string" && provider.length > 0 ? provider : null;
+}
+function modelFromRun(failure) {
+  const model = failure.run.metadata["model"] ?? failure.run.metadata["modelName"];
+  return typeof model === "string" && model.length > 0 ? model : null;
+}
+function runFailureObservation(failure) {
+  const groupId = failure.run.groupId;
+  const logEvidenceLinks = failure.classification.evidenceLogIds.map(logEvidence);
+  const links = mergeEvidence(
+    baseEvidence(null, failure.sessionId, failure.run.id, groupId),
+    logEvidenceLinks
+  );
+  return {
+    fingerprint: fingerprint(["run", failure.run.id, failure.classification.category]),
+    severity: alertSeverityFromFailure(failure),
+    category: "run-failure",
+    source: "run",
+    title: `Run ${failure.run.status}`,
+    message: failure.classification.summary,
+    observedAt: failure.updatedAt,
+    logId: failure.classification.evidenceLogIds[0] ?? null,
+    sessionId: failure.sessionId,
+    runId: failure.run.id,
+    groupId,
+    provider: providerFromRun(failure),
+    model: modelFromRun(failure),
+    apiFormat: null,
+    evidence: links,
+    metadata: {
+      runStatus: failure.run.status,
+      failureCategory: failure.classification.category,
+      evidenceMarkdownPath: failure.evidenceMarkdownPath
+    }
+  };
+}
+function addRunFailureObservations(map, recentFailures) {
+  for (const failure of recentFailures) {
+    addObservation(map, runFailureObservation(failure));
+  }
+}
+function memberProvider(member) {
+  return member.provider !== null && member.provider.length > 0 ? member.provider : null;
+}
+function memberModel(member) {
+  return member.model !== null && member.model.length > 0 ? member.model : null;
+}
+function isFailedMember(member) {
+  return member.status === "failed" || member.status === "cancelled";
+}
+function groupFailureObservation(group) {
+  if (group.status !== "failed" && group.status !== "cancelled") return null;
+  return {
+    fingerprint: fingerprint(["group", group.id, group.status]),
+    severity: "critical",
+    category: "group-failure",
+    source: "group",
+    title: `Group ${group.status}`,
+    message: `${group.title} is marked ${group.status}.`,
+    observedAt: group.updatedAt,
+    logId: null,
+    sessionId: null,
+    runId: null,
+    groupId: group.id,
+    provider: null,
+    model: null,
+    apiFormat: null,
+    evidence: baseEvidence(null, null, null, group.id),
+    metadata: {
+      groupStatus: group.status,
+      memberCount: group.members.length
+    }
+  };
+}
+function groupMemberFailureObservation(group, member) {
+  return {
+    fingerprint: fingerprint(["group-member", group.id, member.id, member.status]),
+    severity: "critical",
+    category: "group-failure",
+    source: "group",
+    title: "Group member failed",
+    message: `${member.label ?? member.sessionId} is marked ${member.status ?? "unknown"}.`,
+    observedAt: member.updatedAt,
+    logId: null,
+    sessionId: member.sessionId,
+    runId: member.runId,
+    groupId: group.id,
+    provider: memberProvider(member),
+    model: memberModel(member),
+    apiFormat: null,
+    evidence: baseEvidence(null, member.sessionId, member.runId, group.id),
+    metadata: {
+      groupTitle: group.title,
+      memberId: member.id,
+      memberStatus: member.status
+    }
+  };
+}
+function groupIncompleteObservation(group, missingStatusCount) {
+  return {
+    fingerprint: fingerprint(["group-incomplete", group.id, missingStatusCount]),
+    severity: "notice",
+    category: "group-incomplete",
+    source: "group",
+    title: "Group has unclassified members",
+    message: `${group.title} has ${String(missingStatusCount)} member(s) without a final status.`,
+    observedAt: group.updatedAt,
+    logId: null,
+    sessionId: null,
+    runId: null,
+    groupId: group.id,
+    provider: null,
+    model: null,
+    apiFormat: null,
+    evidence: baseEvidence(null, null, null, group.id),
+    metadata: {
+      groupTitle: group.title,
+      missingStatusCount
+    }
+  };
+}
+function addGroupObservations(map, groups) {
+  for (const group of groups) {
+    const groupFailure = groupFailureObservation(group);
+    if (groupFailure !== null) addObservation(map, groupFailure);
+    let missingStatusCount = 0;
+    for (const member of group.members) {
+      if (isFailedMember(member)) {
+        addObservation(map, groupMemberFailureObservation(group, member));
+      }
+      if (member.status === null) missingStatusCount += 1;
+    }
+    if (missingStatusCount > 0) {
+      addObservation(map, groupIncompleteObservation(group, missingStatusCount));
+    }
+  }
+}
+function alertMatchesFilters(alert, filters) {
+  if (filters.severity !== void 0 && alert.severity !== filters.severity) return false;
+  if (filters.category !== void 0 && alert.category !== filters.category) return false;
+  if (filters.source !== void 0 && alert.source !== filters.source) return false;
+  return true;
+}
+function sortAlerts(alerts) {
+  return [...alerts].sort((left, right) => {
+    const timeCompare = right.lastSeenAt.localeCompare(left.lastSeenAt);
+    if (timeCompare !== 0) return timeCompare;
+    return left.id.localeCompare(right.id);
+  });
+}
+function buildAlertSummary(alerts) {
+  let critical = 0;
+  let warning = 0;
+  let notice = 0;
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const alert of alerts) {
+    switch (alert.severity) {
+      case "critical":
+        critical += 1;
+        break;
+      case "warning":
+        warning += 1;
+        break;
+      case "notice":
+        notice += 1;
+        break;
+    }
+    byCategory.set(alert.category, (byCategory.get(alert.category) ?? 0) + 1);
+  }
+  return {
+    total: alerts.length,
+    open: alerts.length,
+    critical,
+    warning,
+    notice,
+    byCategory: [...byCategory.entries()].map(([category, count]) => ({ category, count })).sort(
+      (left, right) => right.count - left.count || left.category.localeCompare(right.category)
+    )
+  };
+}
+function collectAlertsFromEvidence(input) {
+  const map = /* @__PURE__ */ new Map();
+  addLogObservations(map, input.logs, input.slowResponseThresholdSeconds);
+  addRunFailureObservations(map, input.recentFailures);
+  addGroupObservations(map, input.groups);
+  return sortAlerts([...map.values()]);
+}
+function filterAlerts(alerts, filters) {
+  return alerts.filter((alert) => alertMatchesFilters(alert, filters));
+}
+async function listAlerts(options = {}) {
+  const limit = clampAlertLimit(options.limit);
+  const scanLimit = clampAlertScanLimit(options.scanLimit);
+  const logPage = await listLogsCursorPage({
+    limit: scanLimit,
+    includeBodies: false,
+    anchor: "newest"
+  });
+  const config = getConfig();
+  const alerts = collectAlertsFromEvidence({
+    logs: logPage.logs,
+    recentFailures: listRecentFailures(scanLimit).failures,
+    groups: listGroups(),
+    slowResponseThresholdSeconds: config.slowResponseThresholdSeconds
+  });
+  const filtered = filterAlerts(alerts, options);
+  return {
+    alerts: filtered.slice(0, limit),
+    total: filtered.length,
+    limit,
+    summary: buildAlertSummary(filtered)
+  };
+}
+async function getAlertSummary(options = {}) {
+  const response = await listAlerts({
+    limit: MAX_ALERT_LIMIT,
+    scanLimit: options.scanLimit
+  });
+  return response.summary;
+}
+function listInspectorAlerts(options) {
+  return listAlerts(options);
+}
+function getInspectorAlertSummary(options) {
+  return getAlertSummary(options);
+}
+function parsePositiveInt$1(value) {
+  if (value === null) return void 0;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) return void 0;
+  return parsed;
+}
+function parseFilters(url) {
+  const severityResult = AlertSeveritySchema.safeParse(url.searchParams.get("severity"));
+  const categoryResult = AlertCategorySchema.safeParse(url.searchParams.get("category"));
+  const sourceResult = AlertSourceSchema.safeParse(url.searchParams.get("source"));
+  return {
+    severity: severityResult.success ? severityResult.data : void 0,
+    category: categoryResult.success ? categoryResult.data : void 0,
+    source: sourceResult.success ? sourceResult.data : void 0
+  };
+}
+const Route$q = createFileRoute("/api/alerts")({
+  server: {
+    handlers: {
+      GET: async ({ request }) => {
+        const url = new URL(request.url);
+        return Response.json(
+          await listInspectorAlerts({
+            ...parseFilters(url),
+            limit: parsePositiveInt$1(url.searchParams.get("limit")),
+            scanLimit: parsePositiveInt$1(url.searchParams.get("scanLimit"))
+          })
+        );
+      }
+    }
+  }
+});
+async function readJsonBody$4(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$p = createFileRoute("/api/runs/$runId")({
+  server: {
+    handlers: {
+      GET: ({ params }) => {
+        const run = getInspectorRun(params.runId);
+        if (!run.ok) {
+          return Response.json({ error: run.message }, { status: run.status });
+        }
+        return Response.json(run.value);
+      },
+      PATCH: async ({ params, request }) => {
+        const body = await readJsonBody$4(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 = updateInspectorRun(params.runId, parsed.data);
+        if (!updated.ok) {
+          return Response.json({ error: updated.message }, { status: updated.status });
+        }
+        return Response.json(updated.value);
+      }
+    }
+  }
+});
+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";
+function readJsonSafe(filePath) {
+  try {
+    if (!existsSync(filePath)) return null;
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return isPlainRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function getEnvValue(envObj, key) {
+  if (!isPlainRecord(envObj)) return void 0;
+  const val = envObj[key];
+  return typeof val === "string" ? val.trim() : void 0;
+}
+const KNOWN_PROVIDER_NAMES = {
+  deepseek: "DeepSeek",
+  minimaxi: "MiniMax",
+  openai: "OpenAI",
+  anthropic: "Anthropic",
+  openrouter: "OpenRouter",
+  groq: "Groq",
+  together: "Together",
+  fireworks: "Fireworks",
+  bedrock: "Bedrock",
+  vertexai: "Vertex AI",
+  azure: "Azure",
+  moonshot: "Moonshot",
+  zhipu: "ZhipuAI",
+  zhipuai: "ZhipuAI",
+  bigmodel: "ZhipuAI",
+  zai: "Z.AI",
+  qwen: "Qwen",
+  baichuan: "Baichuan",
+  iflytek: "iFlytek",
+  doubao: "Doubao",
+  lingyiwanwu: "LingyiWanwu",
+  stepfun: "StepFun"
+};
+function deriveNameFromUrl(url) {
+  try {
+    const hostname = new URL(url).hostname;
+    const parts = hostname.split(".");
+    const domain = parts.length >= 2 ? parts[parts.length - 2] ?? hostname : hostname;
+    const domainLower = domain.toLowerCase();
+    if (KNOWN_PROVIDER_NAMES[domainLower] !== void 0) {
+      return KNOWN_PROVIDER_NAMES[domainLower];
+    }
+    return domain.charAt(0).toUpperCase() + domain.slice(1);
+  } catch {
+    return "Imported Provider";
+  }
+}
+function detectClaudeCodeProviders() {
+  const home = homedir();
+  const results = [];
+  const globalConfig = readJsonSafe(join(home, ".claude", "settings.json"));
+  const localConfig = readJsonSafe(join(home, ".claude", "settings.local.json"));
   const mergedEnv = {};
   if (isPlainRecord(globalConfig)) {
     const env = globalConfig["env"];
@@ -10600,7 +11785,7 @@ function scanExternalProviders() {
   }
   return { providers: filteredProviders, warnings };
 }
-const Route$l = createFileRoute("/api/providers/scan")({
+const Route$o = createFileRoute("/api/providers/scan")({
   server: {
     handlers: {
       GET: () => {
@@ -10621,7 +11806,7 @@ const Route$l = createFileRoute("/api/providers/scan")({
   }
 });
 union([string(), object({ providers: unknown() })]);
-const Route$k = createFileRoute("/api/providers/import")({
+const Route$n = createFileRoute("/api/providers/import")({
   server: {
     handlers: {
       POST: async ({ request }) => {
@@ -10654,7 +11839,7 @@ const Route$k = createFileRoute("/api/providers/import")({
     }
   }
 });
-const Route$j = createFileRoute("/api/providers/export")({
+const Route$m = createFileRoute("/api/providers/export")({
   server: {
     handlers: {
       GET: ({ request }) => {
@@ -10687,7 +11872,7 @@ const ProviderUpdateSchema = object({
   modelMetadata: array(ProviderModelMetadataSchema).optional(),
   source: _enum(["company", "personal"]).optional()
 });
-const Route$i = createFileRoute("/api/providers/$providerId")({
+const Route$l = createFileRoute("/api/providers/$providerId")({
   server: {
     handlers: {
       GET: ({ params, request }) => {
@@ -10722,7 +11907,7 @@ const Route$i = createFileRoute("/api/providers/$providerId")({
   }
 });
 const INITIAL_STREAM_LOG_LIMIT = 100;
-const Route$h = createFileRoute("/api/logs/stream")({
+const Route$k = createFileRoute("/api/logs/stream")({
   server: {
     handlers: {
       GET: ({ request }) => {
@@ -10795,7 +11980,411 @@ const Route$h = createFileRoute("/api/logs/stream")({
     }
   }
 });
-const Route$g = createFileRoute("/api/logs/$id")({
+const ManifestSchema = object({
+  version: string().optional(),
+  exportedAt: string().optional(),
+  mode: string().optional(),
+  redacted: boolean().optional(),
+  logIds: array(number().int().positive()).optional()
+}).passthrough();
+const LogsArraySchema = array(CapturedLogSchema);
+const LogsEnvelopeSchema = object({ logs: array(CapturedLogSchema) }).passthrough();
+const StreamingChunksImportSchema = object({
+  chunks: array(StreamingChunkSchema$1),
+  truncated: boolean().optional().default(false)
+});
+const SEMVER_MAJOR_PATTERN = /^([0-9]+)\.[0-9]+\.[0-9]+(?:[-+].*)?$/;
+function readRecordProperty(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const desc = Object.getOwnPropertyDescriptor(value, name);
+  return desc === void 0 ? void 0 : desc.value;
+}
+function parseJson(text) {
+  if (text === null) return null;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function parseJsonLogs(text) {
+  const parsed = parseJson(text);
+  const direct = LogsArraySchema.safeParse(parsed);
+  if (direct.success) return direct.data;
+  const envelope = LogsEnvelopeSchema.safeParse(parsed);
+  if (envelope.success) return envelope.data.logs;
+  return null;
+}
+function parseJsonlLogs(text) {
+  const logs = [];
+  let skipped = 0;
+  for (const line of text.split(/\r?\n/)) {
+    if (line.trim() === "") continue;
+    const parsed = CapturedLogSchema.safeParse(parseJson(line));
+    if (parsed.success) {
+      logs.push(parsed.data);
+    } else {
+      skipped += 1;
+    }
+  }
+  return { logs, skipped };
+}
+function readStringProperty(value, name) {
+  const property = readRecordProperty(value, name);
+  return typeof property === "string" ? property : null;
+}
+function hasProperty(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  return Object.getOwnPropertyDescriptor(value, name) !== void 0;
+}
+function modelFromRequestText(requestText) {
+  return readStringProperty(parseJson(requestText), "model");
+}
+function inferApiFormatFromBody(path2, model, requestText) {
+  const pathFormat = apiFormatForPath(path2);
+  if (pathFormat !== "unknown") return pathFormat;
+  const normalizedModel = model?.toLowerCase() ?? "";
+  if (normalizedModel.startsWith("claude-")) return "anthropic";
+  if (normalizedModel.startsWith("gpt-") || normalizedModel.startsWith("o1-") || normalizedModel.startsWith("o3-") || normalizedModel.startsWith("o4-") || normalizedModel.startsWith("deepseek-") || normalizedModel.startsWith("glm-") || normalizedModel.startsWith("qwen")) {
+    return "openai";
+  }
+  const parsedRequest = parseJson(requestText);
+  if (hasProperty(parsedRequest, "system") || hasProperty(parsedRequest, "max_tokens")) {
+    return "anthropic";
+  }
+  return "openai";
+}
+function defaultPathForApiFormat(apiFormat) {
+  switch (apiFormat) {
+    case "anthropic":
+      return "/v1/messages";
+    case "openai":
+      return "/v1/chat/completions";
+    case "unknown":
+      return "/v1/chat/completions";
+  }
+}
+function normalizeTimestamp(value, fallback) {
+  return Number.isNaN(new Date(value).getTime()) ? fallback : value;
+}
+function responseStatusFromText(responseText) {
+  if (responseText === null) return null;
+  const parsed = parseJson(responseText);
+  return hasProperty(parsed, "error") ? 500 : 200;
+}
+function mergeWarnings(existing, generated) {
+  const values = [];
+  for (const warning of existing ?? []) {
+    if (!values.includes(warning)) values.push(warning);
+  }
+  for (const warning of generated) {
+    if (!values.includes(warning)) values.push(warning);
+  }
+  return values.length === 0 ? void 0 : values;
+}
+function withToolWarnings(log) {
+  const warnings = analyzeToolSchemaWarnings({
+    rawRequestBody: log.rawRequestBody,
+    responseText: log.responseText,
+    apiFormat: log.apiFormat
+  });
+  return {
+    ...log,
+    warnings: mergeWarnings(log.warnings, warnings)
+  };
+}
+function streamingChunksFromText(text) {
+  const parsed = StreamingChunksImportSchema.safeParse(parseJson(text));
+  return parsed.success ? parsed.data : void 0;
+}
+function draftFromCapturedLog(log, requestText, responseText, streamingChunks) {
+  const rawRequestBody = requestText ?? log.rawRequestBody;
+  const response = responseText ?? log.responseText;
+  const model = log.model ?? modelFromRequestText(rawRequestBody);
+  const apiFormat = log.apiFormat === "unknown" ? inferApiFormatFromBody(log.path, model, rawRequestBody) : log.apiFormat;
+  const path2 = log.path.trim() === "" ? defaultPathForApiFormat(apiFormat) : log.path;
+  return withToolWarnings({
+    timestamp: normalizeTimestamp(log.timestamp, (/* @__PURE__ */ new Date()).toISOString()),
+    method: log.method.trim() === "" ? "POST" : log.method,
+    path: path2,
+    model,
+    sessionId: null,
+    rawRequestBody,
+    responseStatus: log.responseStatus ?? responseStatusFromText(response),
+    responseText: response,
+    inputTokens: log.inputTokens,
+    outputTokens: log.outputTokens,
+    cacheCreationInputTokens: log.cacheCreationInputTokens,
+    cacheReadInputTokens: log.cacheReadInputTokens,
+    elapsedMs: log.elapsedMs,
+    firstChunkMs: log.firstChunkMs ?? null,
+    totalStreamMs: log.totalStreamMs ?? null,
+    tokensPerSecond: log.tokensPerSecond ?? null,
+    streaming: log.streaming || streamingChunks !== void 0,
+    userAgent: log.userAgent,
+    origin: log.origin,
+    rawHeaders: log.rawHeaders,
+    headers: log.headers,
+    apiFormat,
+    isTest: false,
+    replayOfLogId: null,
+    providerName: log.providerName ?? null,
+    clientPort: log.clientPort ?? null,
+    clientPid: log.clientPid ?? null,
+    clientCwd: log.clientCwd ?? null,
+    clientProjectFolder: log.clientProjectFolder ?? null,
+    streamingChunks,
+    streamingChunksPath: null,
+    rawRequestBodyBytes: log.rawRequestBodyBytes,
+    responseTextBytes: log.responseTextBytes,
+    bodyContentMode: "full",
+    warnings: log.warnings,
+    error: log.error ?? null
+  });
+}
+function legacyDraftFromParts(input) {
+  const model = modelFromRequestText(input.requestText);
+  const apiFormat = inferApiFormatFromBody("", model, input.requestText);
+  return withToolWarnings({
+    timestamp: input.exportedAt,
+    method: "POST",
+    path: defaultPathForApiFormat(apiFormat),
+    model,
+    sessionId: null,
+    rawRequestBody: input.requestText,
+    responseStatus: responseStatusFromText(input.responseText),
+    responseText: input.responseText,
+    inputTokens: null,
+    outputTokens: null,
+    cacheCreationInputTokens: null,
+    cacheReadInputTokens: null,
+    elapsedMs: null,
+    firstChunkMs: null,
+    totalStreamMs: null,
+    tokensPerSecond: null,
+    streaming: input.streamingChunks !== void 0,
+    userAgent: "agent-inspector-import",
+    origin: null,
+    apiFormat,
+    isTest: false,
+    replayOfLogId: null,
+    providerName: null,
+    clientPort: null,
+    clientPid: null,
+    clientCwd: null,
+    clientProjectFolder: null,
+    streamingChunks: input.streamingChunks,
+    streamingChunksPath: null,
+    bodyContentMode: "full",
+    error: null
+  });
+}
+async function readZipText(zip, path2) {
+  const file = zip.file(path2);
+  return file === null ? null : await file.async("text");
+}
+async function readManifest(zip) {
+  const text = await readZipText(zip, "manifest.json");
+  const parsed = ManifestSchema.safeParse(parseJson(text));
+  return parsed.success ? parsed.data : null;
+}
+function versionMajor(version2) {
+  const match = SEMVER_MAJOR_PATTERN.exec(version2);
+  if (match === null) return null;
+  const major = match[1];
+  return major === void 0 ? null : Number.parseInt(major, 10);
+}
+function validateManifestVersion(manifest) {
+  const exportedVersion = manifest?.version;
+  if (exportedVersion === void 0) {
+    return {
+      ok: true,
+      warning: "Imported legacy export without version metadata. Compatibility could not be verified."
+    };
+  }
+  const exportedMajor = versionMajor(exportedVersion);
+  if (exportedMajor === null) {
+    return {
+      ok: false,
+      message: `Unsupported export version "${exportedVersion}".`
+    };
+  }
+  const currentMajor = versionMajor(packageJson.version);
+  if (currentMajor === null) {
+    return {
+      ok: true,
+      warning: `Current Agent Inspector version "${packageJson.version}" could not be verified against export version "${exportedVersion}".`
+    };
+  }
+  if (exportedMajor !== currentMajor) {
+    return {
+      ok: false,
+      message: `Export version mismatch: archive was created by Agent Inspector v${exportedVersion}, current version is v${packageJson.version}. Import with a matching major version.`
+    };
+  }
+  if (exportedVersion !== packageJson.version) {
+    return {
+      ok: true,
+      warning: `Imported export from Agent Inspector v${exportedVersion}; current version is v${packageJson.version}.`
+    };
+  }
+  return { ok: true, warning: null };
+}
+async function parseZipLogImport(data) {
+  const warnings = [];
+  const zip = await JSZip.loadAsync(data);
+  const manifest = await readManifest(zip);
+  const versionCheck = validateManifestVersion(manifest);
+  if (!versionCheck.ok) {
+    return {
+      ok: false,
+      message: versionCheck.message,
+      warnings
+    };
+  }
+  if (versionCheck.warning !== null) {
+    warnings.push(versionCheck.warning);
+  }
+  const exportedAt = normalizeTimestamp(manifest?.exportedAt ?? "", (/* @__PURE__ */ new Date()).toISOString());
+  if (manifest?.redacted === true) {
+    warnings.push("Imported redacted export. Secrets and some replay details may be unavailable.");
+  }
+  const metadataText2 = await readZipText(zip, "logs.json");
+  const metadataLogs = metadataText2 === null ? null : parseJsonLogs(metadataText2);
+  const logs = [];
+  let skipped = 0;
+  if (metadataLogs !== null) {
+    for (const log of metadataLogs) {
+      const requestText = await readZipText(zip, `#${String(log.id)}.Request.json`);
+      const responseText = await readZipText(zip, `#${String(log.id)}.Response.json`);
+      const streamingText = await readZipText(zip, `#${String(log.id)}.SSE.Response.json`);
+      logs.push(
+        draftFromCapturedLog(
+          log,
+          requestText,
+          responseText,
+          streamingChunksFromText(streamingText)
+        )
+      );
+    }
+    return { ok: true, logs, skipped, warnings };
+  }
+  for (const originalId of manifest?.logIds ?? []) {
+    const requestText = await readZipText(zip, `#${String(originalId)}.Request.json`);
+    const responseText = await readZipText(zip, `#${String(originalId)}.Response.json`);
+    const streamingText = await readZipText(zip, `#${String(originalId)}.SSE.Response.json`);
+    if (requestText === null && responseText === null && streamingText === null) {
+      skipped += 1;
+      continue;
+    }
+    logs.push(
+      legacyDraftFromParts({
+        exportedAt,
+        requestText,
+        responseText,
+        streamingChunks: streamingChunksFromText(streamingText)
+      })
+    );
+  }
+  if (logs.length === 0) {
+    return {
+      ok: false,
+      message: "No importable logs were found in the archive.",
+      warnings
+    };
+  }
+  return { ok: true, logs, skipped, warnings };
+}
+function looksLikeZip(data, fileName) {
+  if (fileName.toLowerCase().endsWith(".zip")) return true;
+  return data[0] === 80 && data[1] === 75;
+}
+function parseTextLogImport(text) {
+  const jsonLogs = parseJsonLogs(text);
+  if (jsonLogs !== null) {
+    return {
+      ok: true,
+      logs: jsonLogs.map((log) => draftFromCapturedLog(log, null, null, void 0)),
+      skipped: 0,
+      warnings: []
+    };
+  }
+  const jsonl = parseJsonlLogs(text);
+  if (jsonl.logs.length > 0) {
+    return {
+      ok: true,
+      logs: jsonl.logs.map((log) => draftFromCapturedLog(log, null, null, void 0)),
+      skipped: jsonl.skipped,
+      warnings: []
+    };
+  }
+  return {
+    ok: false,
+    message: "Unsupported import file. Use an Agent Inspector export ZIP, logs.json, or JSONL file.",
+    warnings: []
+  };
+}
+async function parseImportedLogFile(input) {
+  try {
+    if (looksLikeZip(input.data, input.fileName)) {
+      return await parseZipLogImport(input.data);
+    }
+    return parseTextLogImport(new TextDecoder("utf-8").decode(input.data));
+  } catch (err) {
+    return {
+      ok: false,
+      message: err instanceof Error ? err.message : "Failed to parse import file.",
+      warnings: []
+    };
+  }
+}
+function sessionNameFromImportFileName(fileName) {
+  const normalized = fileName.replaceAll("\\", "/");
+  const base = basename(normalized).replace(/\.(zip|json|jsonl)$/i, "").trim();
+  return base === "" ? `import-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}` : base;
+}
+function isUploadedFile(value) {
+  return value instanceof File;
+}
+const Route$j = createFileRoute("/api/logs/import")({
+  server: {
+    handlers: {
+      POST: async ({ request }) => {
+        let formData;
+        try {
+          formData = await request.formData();
+        } catch {
+          return Response.json({ error: "Expected multipart form data" }, { status: 400 });
+        }
+        const upload = formData.get("file");
+        if (!isUploadedFile(upload)) {
+          return Response.json({ error: "Missing import file" }, { status: 400 });
+        }
+        const sessionId = sessionNameFromImportFileName(upload.name);
+        const parsed = await parseImportedLogFile({
+          fileName: upload.name,
+          data: Buffer.from(await upload.arrayBuffer())
+        });
+        if (!parsed.ok) {
+          return Response.json(
+            { error: parsed.message, warnings: parsed.warnings },
+            { status: 400 }
+          );
+        }
+        const imported = await importCapturedLogs(parsed.logs, sessionId);
+        return Response.json({
+          sessionId,
+          imported: imported.length,
+          skipped: parsed.skipped,
+          warnings: parsed.warnings,
+          logs: imported.map((log) => compactLogForList(log))
+        });
+      }
+    }
+  }
+});
+const Route$i = createFileRoute("/api/logs/$id")({
   server: {
     handlers: {
       GET: async ({ params }) => {
@@ -11332,7 +12921,7 @@ const SearchBodySchema = object({
   query: string().min(1),
   project: string().optional()
 });
-const Route$f = createFileRoute("/api/knowledge/search")({
+const Route$h = createFileRoute("/api/knowledge/search")({
   server: {
     handlers: {
       GET: async ({ request }) => {
@@ -11354,7 +12943,7 @@ const Route$f = createFileRoute("/api/knowledge/search")({
     }
   }
 });
-const Route$e = createFileRoute("/api/knowledge/project-context")({
+const Route$g = createFileRoute("/api/knowledge/project-context")({
   server: {
     handlers: {
       GET: async ({ request }) => {
@@ -11436,7 +13025,7 @@ function updateCandidateDraft(id, updates) {
   candidates.set(id, updated);
   return updated;
 }
-const Route$d = createFileRoute("/api/knowledge/candidates")({
+const Route$f = createFileRoute("/api/knowledge/candidates")({
   server: {
     handlers: {
       GET: () => Response.json({ candidates: listCandidates() })
@@ -11471,7 +13060,7 @@ function readDeleteEvidenceFlag(request) {
     return { ok: false };
   }
 }
-const Route$c = createFileRoute("/api/groups/$groupId")({
+const Route$e = createFileRoute("/api/groups/$groupId")({
   server: {
     handlers: {
       GET: ({ params }) => {
@@ -11518,7 +13107,7 @@ const Route$c = createFileRoute("/api/groups/$groupId")({
     }
   }
 });
-const Route$b = createFileRoute("/api/config/paths")({
+const Route$d = createFileRoute("/api/config/paths")({
   server: {
     handlers: {
       GET: () => {
@@ -11529,6 +13118,26 @@ const Route$b = createFileRoute("/api/config/paths")({
     }
   }
 });
+function parsePositiveInt(value) {
+  if (value === null) return void 0;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) return void 0;
+  return parsed;
+}
+const Route$c = createFileRoute("/api/alerts/summary")({
+  server: {
+    handlers: {
+      GET: async ({ request }) => {
+        const url = new URL(request.url);
+        return Response.json(
+          await getInspectorAlertSummary({
+            scanLimit: parsePositiveInt(url.searchParams.get("scanLimit"))
+          })
+        );
+      }
+    }
+  }
+});
 async function readJsonBody$2(request) {
   try {
     const raw = await request.text();
@@ -11538,7 +13147,7 @@ async function readJsonBody$2(request) {
     return { ok: false };
   }
 }
-const Route$a = createFileRoute("/api/runs/$runId/evidence")({
+const Route$b = createFileRoute("/api/runs/$runId/evidence")({
   server: {
     handlers: {
       GET: ({ params }) => {
@@ -12189,7 +13798,7 @@ async function testStreamingEndpoint(baseUrl, provider, path2, model, isOpenAI)
     clearTimeout(timeoutId);
   }
 }
-const Route$9 = createFileRoute("/api/providers/$providerId/test")({
+const Route$a = createFileRoute("/api/providers/$providerId/test")({
   server: {
     handlers: {
       POST: async ({ params }) => {
@@ -12283,7 +13892,7 @@ async function readRegistryJson(response) {
     return null;
   }
 }
-const Route$8 = createFileRoute("/api/providers/$providerId/model-metadata")({
+const Route$9 = createFileRoute("/api/providers/$providerId/model-metadata")({
   server: {
     handlers: {
       POST: async ({ params, request }) => {
@@ -12373,7 +13982,7 @@ const Route$8 = createFileRoute("/api/providers/$providerId/model-metadata")({
 const ReplayRequestSchema = object({
   modifiedBody: string()
 });
-const Route$7 = createFileRoute("/api/logs/$id/replay")({
+const Route$8 = createFileRoute("/api/logs/$id/replay")({
   server: {
     handlers: {
       POST: async ({ params, request }) => {
@@ -12574,7 +14183,7 @@ const Route$7 = createFileRoute("/api/logs/$id/replay")({
     }
   }
 });
-const Route$6 = createFileRoute("/api/logs/$id/chunks")({
+const Route$7 = createFileRoute("/api/logs/$id/chunks")({
   server: {
     handlers: {
       GET: async ({ params }) => {
@@ -12600,6 +14209,116 @@ const Route$6 = createFileRoute("/api/logs/$id/chunks")({
     }
   }
 });
+const DEFAULT_LOG_BODY_CHUNK_BYTES = 256 * 1024;
+const MAX_LOG_BODY_CHUNK_BYTES = 1024 * 1024;
+function normalizeLogBodyChunkOffset(offset) {
+  if (!Number.isInteger(offset) || offset < 0) return 0;
+  return offset;
+}
+function normalizeLogBodyChunkLimit(limit) {
+  if (!Number.isInteger(limit) || limit < 1) return DEFAULT_LOG_BODY_CHUNK_BYTES;
+  return Math.min(limit, MAX_LOG_BODY_CHUNK_BYTES);
+}
+function bodyTextForPart(log, part) {
+  switch (part) {
+    case "request":
+      return log.rawRequestBody;
+    case "response":
+      return log.responseText;
+  }
+}
+function isUtf8ContinuationByte(byte) {
+  return byte !== void 0 && (byte & 192) === 128;
+}
+function expandToUtf8Boundary(buffer, end) {
+  if (end >= buffer.byteLength) return buffer.byteLength;
+  let safeEnd = end;
+  while (safeEnd < buffer.byteLength && isUtf8ContinuationByte(buffer[safeEnd])) {
+    safeEnd++;
+  }
+  return safeEnd;
+}
+function createLogBodyChunk({
+  log,
+  part,
+  offset,
+  limit
+}) {
+  const text = bodyTextForPart(log, part);
+  const normalizedLimit = normalizeLogBodyChunkLimit(limit);
+  if (text === null || text === "") {
+    return {
+      logId: log.id,
+      part,
+      text: "",
+      offset: 0,
+      limit: normalizedLimit,
+      totalBytes: 0,
+      textBytes: 0,
+      nextOffset: null,
+      hasMore: false,
+      contentMode: "empty"
+    };
+  }
+  const bodyBytes = Buffer.from(text, "utf8");
+  const totalBytes = bodyBytes.byteLength;
+  const normalizedOffset = Math.min(normalizeLogBodyChunkOffset(offset), totalBytes);
+  const end = expandToUtf8Boundary(
+    bodyBytes,
+    Math.min(normalizedOffset + normalizedLimit, totalBytes)
+  );
+  const chunkText = bodyBytes.toString("utf8", normalizedOffset, end);
+  const textBytes = end - normalizedOffset;
+  const hasMore = end < totalBytes;
+  const contentMode = hasMore || normalizedOffset > 0 ? "partial" : "full";
+  return {
+    logId: log.id,
+    part,
+    text: chunkText,
+    offset: normalizedOffset,
+    limit: normalizedLimit,
+    totalBytes,
+    textBytes,
+    nextOffset: hasMore ? end : null,
+    hasMore,
+    contentMode
+  };
+}
+function parseIntegerParam(value, fallback) {
+  if (value === null) return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) return fallback;
+  return parsed;
+}
+const Route$6 = createFileRoute("/api/logs/$id/body")({
+  server: {
+    handlers: {
+      GET: async ({ params, request }) => {
+        const id = Number(params.id);
+        if (!Number.isInteger(id) || id <= 0) {
+          return Response.json({ error: "Invalid log ID" }, { status: 400 });
+        }
+        const url = new URL(request.url);
+        const partResult = LogBodyPartSchema.safeParse(url.searchParams.get("part"));
+        if (!partResult.success) {
+          return Response.json({ error: "Invalid body part" }, { status: 400 });
+        }
+        const log = await getLogById(id);
+        if (log === null) {
+          return Response.json({ error: "Log not found" }, { status: 404 });
+        }
+        return Response.json(
+          createLogBodyChunk({
+            log,
+            part: partResult.data,
+            offset: parseIntegerParam(url.searchParams.get("offset"), 0),
+            limit: parseIntegerParam(url.searchParams.get("limit"), 0)
+          })
+        );
+      }
+    }
+  }
+});
 const CandidateUpdateSchema = object({
   type: KnowledgeCandidateTypeSchema.optional(),
   title: string().trim().min(1).max(160).optional(),
@@ -13144,151 +14863,171 @@ const Route = createFileRoute("/api/knowledge/candidates/$candidateId/promote")(
     }
   }
 });
-const IndexRoute = Route$y.update({
+const IndexRoute = Route$C.update({
   id: "/",
   path: "/",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const SessionSessionIdRoute = Route$x.update({
+const SessionSessionIdRoute = Route$B.update({
   id: "/session/$sessionId",
   path: "/session/$sessionId",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ProxySplatRoute = Route$w.update({
+const ProxySplatRoute = Route$A.update({
   id: "/proxy/$",
   path: "/proxy/$",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiSessionsRoute = Route$v.update({
+const ApiSessionsRoute = Route$z.update({
   id: "/api/sessions",
   path: "/api/sessions",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiRunsRoute = Route$u.update({
+const ApiRunsRoute = Route$y.update({
   id: "/api/runs",
   path: "/api/runs",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiProvidersRoute = Route$t.update({
+const ApiProvidersRoute = Route$x.update({
   id: "/api/providers",
   path: "/api/providers",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiModelsRoute = Route$s.update({
+const ApiModelsRoute = Route$w.update({
   id: "/api/models",
   path: "/api/models",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiMcpRoute = Route$r.update({
+const ApiMcpRoute = Route$v.update({
   id: "/api/mcp",
   path: "/api/mcp",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiLogsRoute = Route$q.update({
+const ApiLogsRoute = Route$u.update({
   id: "/api/logs",
   path: "/api/logs",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiHealthRoute = Route$p.update({
+const ApiHealthRoute = Route$t.update({
   id: "/api/health",
   path: "/api/health",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiGroupsRoute = Route$o.update({
+const ApiGroupsRoute = Route$s.update({
   id: "/api/groups",
   path: "/api/groups",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiConfigRoute = Route$n.update({
+const ApiConfigRoute = Route$r.update({
   id: "/api/config",
   path: "/api/config",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiRunsRunIdRoute = Route$m.update({
+const ApiAlertsRoute = Route$q.update({
+  id: "/api/alerts",
+  path: "/api/alerts",
+  getParentRoute: () => Route$D
+});
+const ApiRunsRunIdRoute = Route$p.update({
   id: "/$runId",
   path: "/$runId",
   getParentRoute: () => ApiRunsRoute
 });
-const ApiProvidersScanRoute = Route$l.update({
+const ApiProvidersScanRoute = Route$o.update({
   id: "/scan",
   path: "/scan",
   getParentRoute: () => ApiProvidersRoute
 });
-const ApiProvidersImportRoute = Route$k.update({
+const ApiProvidersImportRoute = Route$n.update({
   id: "/import",
   path: "/import",
   getParentRoute: () => ApiProvidersRoute
 });
-const ApiProvidersExportRoute = Route$j.update({
+const ApiProvidersExportRoute = Route$m.update({
   id: "/export",
   path: "/export",
   getParentRoute: () => ApiProvidersRoute
 });
-const ApiProvidersProviderIdRoute = Route$i.update({
+const ApiProvidersProviderIdRoute = Route$l.update({
   id: "/$providerId",
   path: "/$providerId",
   getParentRoute: () => ApiProvidersRoute
 });
-const ApiLogsStreamRoute = Route$h.update({
+const ApiLogsStreamRoute = Route$k.update({
   id: "/stream",
   path: "/stream",
   getParentRoute: () => ApiLogsRoute
 });
-const ApiLogsIdRoute = Route$g.update({
+const ApiLogsImportRoute = Route$j.update({
+  id: "/import",
+  path: "/import",
+  getParentRoute: () => ApiLogsRoute
+});
+const ApiLogsIdRoute = Route$i.update({
   id: "/$id",
   path: "/$id",
   getParentRoute: () => ApiLogsRoute
 });
-const ApiKnowledgeSearchRoute = Route$f.update({
+const ApiKnowledgeSearchRoute = Route$h.update({
   id: "/api/knowledge/search",
   path: "/api/knowledge/search",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiKnowledgeProjectContextRoute = Route$e.update({
+const ApiKnowledgeProjectContextRoute = Route$g.update({
   id: "/api/knowledge/project-context",
   path: "/api/knowledge/project-context",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiKnowledgeCandidatesRoute = Route$d.update({
+const ApiKnowledgeCandidatesRoute = Route$f.update({
   id: "/api/knowledge/candidates",
   path: "/api/knowledge/candidates",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
-const ApiGroupsGroupIdRoute = Route$c.update({
+const ApiGroupsGroupIdRoute = Route$e.update({
   id: "/$groupId",
   path: "/$groupId",
   getParentRoute: () => ApiGroupsRoute
 });
-const ApiConfigPathsRoute = Route$b.update({
+const ApiConfigPathsRoute = Route$d.update({
   id: "/paths",
   path: "/paths",
   getParentRoute: () => ApiConfigRoute
 });
-const ApiRunsRunIdEvidenceRoute = Route$a.update({
+const ApiAlertsSummaryRoute = Route$c.update({
+  id: "/summary",
+  path: "/summary",
+  getParentRoute: () => ApiAlertsRoute
+});
+const ApiRunsRunIdEvidenceRoute = Route$b.update({
   id: "/evidence",
   path: "/evidence",
   getParentRoute: () => ApiRunsRunIdRoute
 });
-const ApiProvidersProviderIdTestRoute = Route$9.update({
+const ApiProvidersProviderIdTestRoute = Route$a.update({
   id: "/test",
   path: "/test",
   getParentRoute: () => ApiProvidersProviderIdRoute
 });
-const ApiProvidersProviderIdModelMetadataRoute = Route$8.update({
+const ApiProvidersProviderIdModelMetadataRoute = Route$9.update({
   id: "/model-metadata",
   path: "/model-metadata",
   getParentRoute: () => ApiProvidersProviderIdRoute
 });
-const ApiLogsIdReplayRoute = Route$7.update({
+const ApiLogsIdReplayRoute = Route$8.update({
   id: "/replay",
   path: "/replay",
   getParentRoute: () => ApiLogsIdRoute
 });
-const ApiLogsIdChunksRoute = Route$6.update({
+const ApiLogsIdChunksRoute = Route$7.update({
   id: "/chunks",
   path: "/chunks",
   getParentRoute: () => ApiLogsIdRoute
 });
+const ApiLogsIdBodyRoute = Route$6.update({
+  id: "/body",
+  path: "/body",
+  getParentRoute: () => ApiLogsIdRoute
+});
 const ApiKnowledgeCandidatesCandidateIdRoute = Route$5.update({
   id: "/$candidateId",
   path: "/$candidateId",
@@ -13312,13 +15051,19 @@ const ApiProvidersProviderIdTestLogRoute = Route$2.update({
 const ApiKnowledgeSessionsSessionIdCandidatesRoute = Route$1.update({
   id: "/api/knowledge/sessions/$sessionId/candidates",
   path: "/api/knowledge/sessions/$sessionId/candidates",
-  getParentRoute: () => Route$z
+  getParentRoute: () => Route$D
 });
 const ApiKnowledgeCandidatesCandidateIdPromoteRoute = Route.update({
   id: "/promote",
   path: "/promote",
   getParentRoute: () => ApiKnowledgeCandidatesCandidateIdRoute
 });
+const ApiAlertsRouteChildren = {
+  ApiAlertsSummaryRoute
+};
+const ApiAlertsRouteWithChildren = ApiAlertsRoute._addFileChildren(
+  ApiAlertsRouteChildren
+);
 const ApiConfigRouteChildren = {
   ApiConfigPathsRoute
 };
@@ -13337,6 +15082,7 @@ const ApiGroupsRouteWithChildren = ApiGroupsRoute._addFileChildren(
   ApiGroupsRouteChildren
 );
 const ApiLogsIdRouteChildren = {
+  ApiLogsIdBodyRoute,
   ApiLogsIdChunksRoute,
   ApiLogsIdReplayRoute
 };
@@ -13345,6 +15091,7 @@ const ApiLogsIdRouteWithChildren = ApiLogsIdRoute._addFileChildren(
 );
 const ApiLogsRouteChildren = {
   ApiLogsIdRoute: ApiLogsIdRouteWithChildren,
+  ApiLogsImportRoute,
   ApiLogsStreamRoute
 };
 const ApiLogsRouteWithChildren = ApiLogsRoute._addFileChildren(ApiLogsRouteChildren);
@@ -13394,6 +15141,7 @@ const ApiKnowledgeCandidatesRouteWithChildren = ApiKnowledgeCandidatesRoute._add
 );
 const rootRouteChildren = {
   IndexRoute,
+  ApiAlertsRoute: ApiAlertsRouteWithChildren,
   ApiConfigRoute: ApiConfigRouteWithChildren,
   ApiGroupsRoute: ApiGroupsRouteWithChildren,
   ApiHealthRoute,
@@ -13410,7 +15158,7 @@ const rootRouteChildren = {
   ApiKnowledgeSearchRoute,
   ApiKnowledgeSessionsSessionIdCandidatesRoute
 };
-const routeTree = Route$z._addFileChildren(rootRouteChildren)._addFileTypes();
+const routeTree = Route$D._addFileChildren(rootRouteChildren)._addFileTypes();
 function getRouter() {
   const router2 = createRouter({
     routeTree,
@@ -13442,32 +15190,35 @@ export {
   GroupEvidenceReadResponseSchema as G,
   InspectorGroupsListResponseSchema as I,
   KnowledgeCandidateSchema as K,
+  LogBodyChunkSchema as L,
   MAX_SLOW_RESPONSE_THRESHOLD_SECONDS as M,
   OpenAIRequestSchema as O,
   ProviderConfigSchema as P,
-  Route$x as R,
+  Route$B as R,
   TimeDisplayFormatSchema as T,
   DEFAULT_SLOW_RESPONSE_THRESHOLD_SECONDS as a,
   DEFAULT_PROVIDER_TEST_TIMEOUT_SECONDS as b,
   DEFAULT_TIME_DISPLAY_FORMAT as c,
   RuntimeConfigSchema as d,
   AnthropicRequestSchema as e,
-  apiFormatForPath as f,
-  getSessionPath as g,
-  stripClaudeCodeBillingHeader as h,
-  GroupEvidenceExportResultSchema as i,
-  DeleteInspectorGroupResponseSchema as j,
-  providerHasContextMetadata as k,
-  findProviderModelMetadata as l,
-  maskApiKey as m,
-  createPendingProviderTestResults as n,
-  ProviderTestResultsSchema as o,
-  parseOpenAIResponse as p,
-  createFailedProviderTestResults as q,
-  MAX_PROVIDER_TEST_TIMEOUT_SECONDS as r,
+  parseOpenAIResponse as f,
+  apiFormatForPath as g,
+  getSessionPath as h,
+  stripClaudeCodeBillingHeader as i,
+  AlertSummarySchema as j,
+  AlertListResponseSchema as k,
+  GroupEvidenceExportResultSchema as l,
+  DeleteInspectorGroupResponseSchema as m,
+  providerHasContextMetadata as n,
+  findProviderModelMetadata as o,
+  packageJson as p,
+  maskApiKey as q,
+  createPendingProviderTestResults as r,
   safeGetOwnProperty as s,
-  resolveProviderContextWindow as t,
-  isPlainRecord as u,
-  packageJson as v,
-  router as w
+  ProviderTestResultsSchema as t,
+  createFailedProviderTestResults as u,
+  MAX_PROVIDER_TEST_TIMEOUT_SECONDS as v,
+  resolveProviderContextWindow as w,
+  isPlainRecord as x,
+  router as y
 };