@tonyclaw/agent-inspector 2.1.6 → 2.1.7

package/.output/server/_ssr/{router-sy38X5AX.mjs → router-C0apgqfC.mjs}

@@ -2,17 +2,17 @@ import { c as createRouter, a as createRootRoute, b as createFileRoute, l as laz
 import { j as jsxRuntimeExports } from "../_libs/react.mjs";
 import { S as SWRConfig } from "../_libs/swr.mjs";
 import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync, copyFileSync, unlinkSync, createReadStream, readdirSync, statSync, cpSync, rmSync, createWriteStream } from "node:fs";
-import fs, { mkdir, appendFile, readFile, writeFile, readdir, open, stat, unlink, rename } from "node:fs/promises";
+import fs, { mkdir, appendFile, readFile, writeFile, readdir, open, stat, unlink, rm, rename } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Buffer } from "node:buffer";
-import path, { basename, join, isAbsolute, dirname, resolve, relative } from "node:path";
+import path, { basename, join, dirname, isAbsolute, resolve, relative } from "node:path";
+import { randomUUID as randomUUID$1, createHash } from "node:crypto";
 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, 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";
@@ -108,7 +108,7 @@ function RootDocument({ children }) {
     ] })
   ] });
 }
-const $$splitComponentImporter$1 = () => import("./index-WnsY1fh_.mjs");
+const $$splitComponentImporter$1 = () => import("./index-DtcUTHAX.mjs");
 const Route$C = createFileRoute("/")({
   component: lazyRouteComponent($$splitComponentImporter$1, "component")
 });
@@ -151,7 +151,7 @@ function decodeSessionIdFromPath(encoded) {
 function getSessionPath(sessionId) {
   return `/session/${encodeSessionIdForPath(sessionId)}`;
 }
-const $$splitComponentImporter = () => import("../_sessionId-CIXQGim9.mjs");
+const $$splitComponentImporter = () => import("../_sessionId-D5HNwb9A.mjs");
 const Route$B = createFileRoute("/session/$sessionId")({
   component: lazyRouteComponent($$splitComponentImporter, "component"),
   parseParams: (params) => ({
@@ -865,9 +865,9 @@ function readChunks(path2) {
   }
 }
 const SQLITE_INDEX_FILE = "inspector.sqlite";
-const SQLITE_PACKAGE_NAME = "better-sqlite3";
-const BUN_SQLITE_MODULE_NAME = "bun:sqlite";
-const CREATE_SCHEMA_SQL = `
+const SQLITE_PACKAGE_NAME$1 = "better-sqlite3";
+const BUN_SQLITE_MODULE_NAME$1 = "bun:sqlite";
+const CREATE_SCHEMA_SQL$1 = `
 CREATE TABLE IF NOT EXISTS log_index (
   id INTEGER PRIMARY KEY,
   file TEXT NOT NULL,
@@ -908,7 +908,7 @@ CREATE INDEX IF NOT EXISTS idx_log_index_session_id_id ON log_index(session_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 = `
+const UPSERT_SQL$1 = `
 INSERT INTO log_index (
   id,
   file,
@@ -985,7 +985,7 @@ ON CONFLICT(id) DO UPDATE SET
 let sqliteStatePromise = null;
 let sqliteStatePath = null;
 let activeDb = null;
-let didLogUnavailable = false;
+let didLogUnavailable$1 = false;
 function isSqliteLogIndexEnabled() {
   const configured = process.env["AGENT_INSPECTOR_SQLITE_INDEX"];
   if (configured === "1") return true;
@@ -995,13 +995,13 @@ function isSqliteLogIndexEnabled() {
 function getSqlitePath() {
   return join(resolveLogDir(), SQLITE_INDEX_FILE);
 }
-function objectFromUnknown(value) {
+function objectFromUnknown$1(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);
+function readProperty$2(value, name) {
+  let current = objectFromUnknown$1(value);
   while (current !== null) {
     const desc = Object.getOwnPropertyDescriptor(current, name);
     if (desc !== void 0) {
@@ -1009,16 +1009,16 @@ function readProperty$1(value, name) {
       return propertyValue;
     }
     const nextPrototype = Object.getPrototypeOf(current);
-    current = objectFromUnknown(nextPrototype);
+    current = objectFromUnknown$1(nextPrototype);
   }
   return void 0;
 }
-function readFunction(value, name) {
-  const property = readProperty$1(value, name);
+function readFunction$1(value, name) {
+  const property = readProperty$2(value, name);
   return typeof property === "function" ? property : null;
 }
-function callMethod(target, methodName, args) {
-  const method = readFunction(target, methodName);
+function callMethod$1(target, methodName, args) {
+  const method = readFunction$1(target, methodName);
   if (method === null) return void 0;
   try {
     return Reflect.apply(method, target, [...args]);
@@ -1027,48 +1027,48 @@ function callMethod(target, methodName, args) {
     return void 0;
   }
 }
-function prepareStatement(db, sql) {
-  return callMethod(db, "prepare", [sql]);
+function prepareStatement$1(db, sql) {
+  return callMethod$1(db, "prepare", [sql]);
 }
-function runPrepared(db, sql, params = []) {
-  const statement = prepareStatement(db, sql);
+function runPrepared$1(db, sql, params = []) {
+  const statement = prepareStatement$1(db, sql);
   if (statement === void 0) return false;
-  const result = callMethod(statement, "run", params);
-  callMethod(statement, "finalize", []);
+  const result = callMethod$1(statement, "run", params);
+  callMethod$1(statement, "finalize", []);
   return result !== void 0;
 }
 function getPrepared(db, sql, params = []) {
-  const statement = prepareStatement(db, sql);
+  const statement = prepareStatement$1(db, sql);
   if (statement === void 0) return void 0;
-  const result = callMethod(statement, "get", params);
-  callMethod(statement, "finalize", []);
+  const result = callMethod$1(statement, "get", params);
+  callMethod$1(statement, "finalize", []);
   return result;
 }
-function allPrepared(db, sql, params = []) {
-  const statement = prepareStatement(db, sql);
+function allPrepared$1(db, sql, params = []) {
+  const statement = prepareStatement$1(db, sql);
   if (statement === void 0) return null;
-  const result = callMethod(statement, "all", params);
-  callMethod(statement, "finalize", []);
+  const result = callMethod$1(statement, "all", params);
+  callMethod$1(statement, "finalize", []);
   return Array.isArray(result) ? result : null;
 }
-function execSql(db, sql) {
-  const result = callMethod(db, "exec", [sql]);
+function execSql$1(db, sql) {
+  const result = callMethod$1(db, "exec", [sql]);
   return result !== void 0;
 }
-function sqliteConstructorFromModule(moduleValue, exportName) {
-  const exportedValue = readProperty$1(moduleValue, exportName);
+function sqliteConstructorFromModule$1(moduleValue, exportName) {
+  const exportedValue = readProperty$2(moduleValue, exportName);
   if (typeof exportedValue === "function") {
     return (path2) => Reflect.construct(exportedValue, [path2]);
   }
   return null;
 }
-async function loadSqliteModuleConstructor(moduleName, exportName) {
+async function loadSqliteModuleConstructor$1(moduleName, exportName) {
   try {
     const importedModule = await import(
       /* @vite-ignore */
       moduleName
     );
-    const exportedConstructor = sqliteConstructorFromModule(importedModule, exportName);
+    const exportedConstructor = sqliteConstructorFromModule$1(importedModule, exportName);
     if (exportedConstructor !== null) return { constructor: exportedConstructor, reason: null };
     if (exportName === "default" && typeof importedModule === "function") {
       return {
@@ -1081,27 +1081,27 @@ async function loadSqliteModuleConstructor(moduleName, exportName) {
     return { constructor: null, reason: String(err) };
   }
 }
-async function loadSqliteConstructor() {
+async function loadSqliteConstructor$1() {
   const bunRuntimeDesc = Object.getOwnPropertyDescriptor(process.versions, "bun");
   if (bunRuntimeDesc !== void 0) {
-    const bunSqlite2 = await loadSqliteModuleConstructor(BUN_SQLITE_MODULE_NAME, "Database");
+    const bunSqlite2 = await loadSqliteModuleConstructor$1(BUN_SQLITE_MODULE_NAME$1, "Database");
     if (bunSqlite2.constructor !== null) return bunSqlite2;
-    const betterSqlite2 = await loadSqliteModuleConstructor(SQLITE_PACKAGE_NAME, "default");
+    const betterSqlite2 = await loadSqliteModuleConstructor$1(SQLITE_PACKAGE_NAME$1, "default");
     if (betterSqlite2.constructor !== null) return betterSqlite2;
     const reason2 = [bunSqlite2.reason, betterSqlite2.reason].filter((item) => item !== null).join("; ");
-    if (!didLogUnavailable) {
-      didLogUnavailable = true;
+    if (!didLogUnavailable$1) {
+      didLogUnavailable$1 = true;
       logger.warn("[sqliteLogIndex] Optional SQLite index unavailable:", reason2);
     }
     return { constructor: null, reason: reason2 };
   }
-  const betterSqlite = await loadSqliteModuleConstructor(SQLITE_PACKAGE_NAME, "default");
+  const betterSqlite = await loadSqliteModuleConstructor$1(SQLITE_PACKAGE_NAME$1, "default");
   if (betterSqlite.constructor !== null) return betterSqlite;
-  const bunSqlite = await loadSqliteModuleConstructor(BUN_SQLITE_MODULE_NAME, "Database");
+  const bunSqlite = await loadSqliteModuleConstructor$1(BUN_SQLITE_MODULE_NAME$1, "Database");
   if (bunSqlite.constructor !== null) return bunSqlite;
   const reason = [betterSqlite.reason, bunSqlite.reason].filter((item) => item !== null).join("; ");
-  if (!didLogUnavailable) {
-    didLogUnavailable = true;
+  if (!didLogUnavailable$1) {
+    didLogUnavailable$1 = true;
     logger.warn("[sqliteLogIndex] Optional SQLite index unavailable:", reason);
   }
   return { constructor: null, reason };
@@ -1111,7 +1111,7 @@ async function initializeSqliteState() {
   if (!isSqliteLogIndexEnabled()) {
     return { status: "unavailable", path: path2, reason: "SQLite log index is disabled" };
   }
-  const sqliteConstructor = await loadSqliteConstructor();
+  const sqliteConstructor = await loadSqliteConstructor$1();
   if (sqliteConstructor.constructor === null) {
     return {
       status: "unavailable",
@@ -1122,9 +1122,9 @@ async function initializeSqliteState() {
   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)) {
+    execSql$1(db, "PRAGMA journal_mode = WAL");
+    execSql$1(db, "PRAGMA synchronous = NORMAL");
+    if (!execSql$1(db, CREATE_SCHEMA_SQL$1)) {
       return { status: "unavailable", path: path2, reason: "SQLite schema initialization failed" };
     }
     activeDb = db;
@@ -1147,7 +1147,7 @@ async function getSqliteState() {
 }
 function closeSqliteLogIndex() {
   if (activeDb !== null) {
-    callMethod(activeDb, "close", []);
+    callMethod$1(activeDb, "close", []);
   }
   activeDb = null;
   sqliteStatePromise = null;
@@ -1198,19 +1198,19 @@ function entryParams(entry) {
     summary?.error ?? null
   ];
 }
-function readNumber(row, name) {
-  const value = readProperty$1(row, name);
+function readNumber$1(row, name) {
+  const value = readProperty$2(row, name);
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
-function readString$1(row, name) {
-  const value = readProperty$1(row, name);
+function readString$2(row, name) {
+  const value = readProperty$2(row, name);
   return typeof value === "string" ? value : null;
 }
 function readBoolean(row, name) {
-  return readNumber(row, name) === 1;
+  return readNumber$1(row, name) === 1;
 }
 function readApiFormat(row) {
-  const value = readString$1(row, "api_format");
+  const value = readString$2(row, "api_format");
   switch (value) {
     case "anthropic":
       return "anthropic";
@@ -1224,7 +1224,7 @@ function readApiFormat(row) {
   }
 }
 function readWarnings(row) {
-  const value = readString$1(row, "warnings_json");
+  const value = readString$2(row, "warnings_json");
   if (value === null) return void 0;
   try {
     const parsed = JSON.parse(value);
@@ -1240,47 +1240,47 @@ function readWarnings(row) {
   }
 }
 function readRequiredNumber(row, name) {
-  const value = readNumber(row, name);
+  const value = readNumber$1(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"),
+    timestamp: readString$2(row, "timestamp") ?? "",
+    method: readString$2(row, "method") ?? "",
+    path: readString$2(row, "path") ?? "",
+    model: readString$2(row, "model"),
+    sessionId: readString$2(row, "session_id"),
+    responseStatus: readNumber$1(row, "response_status"),
+    inputTokens: readNumber$1(row, "input_tokens"),
+    outputTokens: readNumber$1(row, "output_tokens"),
+    cacheCreationInputTokens: readNumber$1(row, "cache_creation_input_tokens"),
+    cacheReadInputTokens: readNumber$1(row, "cache_read_input_tokens"),
+    elapsedMs: readNumber$1(row, "elapsed_ms"),
+    firstChunkMs: readNumber$1(row, "first_chunk_ms"),
+    totalStreamMs: readNumber$1(row, "total_stream_ms"),
+    tokensPerSecond: readNumber$1(row, "tokens_per_second"),
     streaming: readBoolean(row, "streaming"),
-    userAgent: readString$1(row, "user_agent"),
-    origin: readString$1(row, "origin"),
+    userAgent: readString$2(row, "user_agent"),
+    origin: readString$2(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"),
+    replayOfLogId: readNumber$1(row, "replay_of_log_id"),
+    providerName: readString$2(row, "provider_name"),
+    clientPort: readNumber$1(row, "client_port"),
+    clientPid: readNumber$1(row, "client_pid"),
+    clientCwd: readString$2(row, "client_cwd"),
+    clientProjectFolder: readString$2(row, "client_project_folder"),
+    streamingChunksPath: readString$2(row, "streaming_chunks_path"),
+    rawRequestBodyBytes: readNumber$1(row, "raw_request_body_bytes"),
+    responseTextBytes: readNumber$1(row, "response_text_bytes"),
     warnings: readWarnings(row),
-    error: readString$1(row, "error")
+    error: readString$2(row, "error")
   };
 }
 function entryFromRow(row) {
   const id = readRequiredNumber(row, "id");
-  const file = readString$1(row, "file");
+  const file = readString$2(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;
@@ -1289,8 +1289,8 @@ function entryFromRow(row) {
     file,
     byteOffset,
     byteLength,
-    sessionId: readString$1(row, "session_id"),
-    model: readString$1(row, "model"),
+    sessionId: readString$2(row, "session_id"),
+    model: readString$2(row, "model"),
     summary: summaryFromRow(row, id)
   };
 }
@@ -1298,30 +1298,30 @@ 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;
+  return readNumber$1(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));
+  return runPrepared$1(state.db, UPSERT_SQL$1, 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;
+  if (!execSql$1(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");
+      if (!runPrepared$1(state.db, UPSERT_SQL$1, entryParams(entry))) {
+        execSql$1(state.db, "ROLLBACK");
         return false;
       }
     }
-    return execSql(state.db, "COMMIT");
+    return execSql$1(state.db, "COMMIT");
   } catch (err) {
-    execSql(state.db, "ROLLBACK");
+    execSql$1(state.db, "ROLLBACK");
     logger.warn("[sqliteLogIndex] Failed to sync SQLite index:", String(err));
     return false;
   }
@@ -1349,7 +1349,7 @@ async function listSqliteLogIndexEntries({
     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);
+  const rows = allPrepared$1(state.db, `SELECT * FROM log_index${where} ORDER BY id ASC`, params);
   if (rows === null) return null;
   const entries = [];
   for (const row of rows) {
@@ -1361,22 +1361,22 @@ async function listSqliteLogIndexEntries({
 async function replaceSqliteLogIndexEntries(entries) {
   const state = await getSqliteState();
   if (state.status !== "ready") return false;
-  if (!execSql(state.db, "BEGIN IMMEDIATE")) return false;
+  if (!execSql$1(state.db, "BEGIN IMMEDIATE")) return false;
   try {
-    if (!runPrepared(state.db, "DELETE FROM log_index")) {
-      execSql(state.db, "ROLLBACK");
+    if (!runPrepared$1(state.db, "DELETE FROM log_index")) {
+      execSql$1(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");
+      if (!runPrepared$1(state.db, UPSERT_SQL$1, entryParams(entry))) {
+        execSql$1(state.db, "ROLLBACK");
         return false;
       }
     }
-    return execSql(state.db, "COMMIT");
+    return execSql$1(state.db, "COMMIT");
   } catch (err) {
-    execSql(state.db, "ROLLBACK");
+    execSql$1(state.db, "ROLLBACK");
     logger.warn("[sqliteLogIndex] Failed to replace SQLite index:", String(err));
     return false;
   }
@@ -1986,6 +1986,342 @@ function apiFormatForPath(path2) {
 formatRegistry.registerPath(PATH_V1_MESSAGES, "anthropic");
 formatRegistry.registerPath(PATH_V1_CHAT_COMPLETIONS, "openai");
 formatRegistry.registerPath(PATH_CHAT_COMPLETIONS, "openai");
+const SESSION_ARCHIVE_DIR = "sessions";
+const SESSION_ARCHIVE_FILE = "session.sqlite";
+const SQLITE_PACKAGE_NAME = "better-sqlite3";
+const BUN_SQLITE_MODULE_NAME = "bun:sqlite";
+const CREATE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS session_logs (
+  id INTEGER PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  log_json TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_session_logs_session_id_id ON session_logs(session_id, id);
+`;
+const UPSERT_SQL = `
+INSERT INTO session_logs (
+  id,
+  session_id,
+  log_json,
+  updated_at
+) VALUES (?, ?, ?, ?)
+ON CONFLICT(id) DO UPDATE SET
+  session_id = excluded.session_id,
+  log_json = excluded.log_json,
+  updated_at = excluded.updated_at
+`;
+let didLogUnavailable = false;
+function getSessionArchiveRoot() {
+  return join(resolveLogDir(), SESSION_ARCHIVE_DIR);
+}
+function hashSessionId(sessionId) {
+  return createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
+}
+function sanitizeSessionPrefix(sessionId) {
+  const trimmed = sessionId.trim();
+  if (trimmed.length === 0) return "session";
+  const normalized = trimmed.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  if (normalized.length === 0) return "session";
+  return normalized.slice(0, 48);
+}
+function sessionArchiveKey(sessionId) {
+  return `${sanitizeSessionPrefix(sessionId)}--${hashSessionId(sessionId)}`;
+}
+function getSessionArchivePath(sessionId) {
+  return join(getSessionArchiveRoot(), sessionArchiveKey(sessionId), SESSION_ARCHIVE_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("[sessionArchive] 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 allPrepared(db, sql, params = []) {
+  const statement = prepareStatement(db, sql);
+  if (statement === void 0) return [];
+  const result = callMethod(statement, "all", params);
+  callMethod(statement, "finalize", []);
+  return Array.isArray(result) ? result : [];
+}
+function execSql(db, sql) {
+  const result = callMethod(db, "exec", [sql]);
+  return result !== void 0;
+}
+function closeDatabase(db) {
+  callMethod(db, "close", []);
+}
+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;
+    return {
+      constructor: null,
+      reason: [bunSqlite2.reason, betterSqlite2.reason].filter((item) => item !== null).join("; ")
+    };
+  }
+  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;
+  return {
+    constructor: null,
+    reason: [betterSqlite.reason, bunSqlite.reason].filter((item) => item !== null).join("; ")
+  };
+}
+function logUnavailableOnce(reason) {
+  if (didLogUnavailable) return;
+  didLogUnavailable = true;
+  logger.warn("[sessionArchive] Optional session archive unavailable:", reason);
+}
+async function openSessionArchiveDb(filePath, create) {
+  if (!create && !existsSync(filePath)) return null;
+  const sqliteConstructor = await loadSqliteConstructor();
+  if (sqliteConstructor.constructor === null) {
+    logUnavailableOnce(sqliteConstructor.reason ?? "SQLite runtime is not available");
+    return null;
+  }
+  try {
+    if (create) await mkdir(dirname(filePath), { recursive: true });
+    const db = sqliteConstructor.constructor(filePath);
+    execSql(db, "PRAGMA journal_mode = WAL");
+    execSql(db, "PRAGMA synchronous = NORMAL");
+    if (!execSql(db, CREATE_SCHEMA_SQL)) {
+      closeDatabase(db);
+      logger.warn("[sessionArchive] Failed to initialize schema:", filePath);
+      return null;
+    }
+    return db;
+  } catch (err) {
+    logger.warn("[sessionArchive] Failed to open session archive:", filePath, String(err));
+    return null;
+  }
+}
+async function archiveSessionLog(log) {
+  const sessionId = log.sessionId;
+  if (sessionId === null || sessionId.trim().length === 0) return false;
+  const db = await openSessionArchiveDb(getSessionArchivePath(sessionId), true);
+  if (db === null) return false;
+  try {
+    return runPrepared(db, UPSERT_SQL, [
+      log.id,
+      sessionId,
+      JSON.stringify(log),
+      (/* @__PURE__ */ new Date()).toISOString()
+    ]);
+  } finally {
+    closeDatabase(db);
+  }
+}
+function readString$1(row, name) {
+  const value = readProperty$1(row, name);
+  return typeof value === "string" ? value : null;
+}
+function readNumber(row, name) {
+  const value = readProperty$1(row, name);
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function logFromJson(value) {
+  if (value === null) return null;
+  try {
+    const parsed = JSON.parse(value);
+    const result = CapturedLogSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}
+function logsFromRows(rows) {
+  const logs = [];
+  for (const row of rows) {
+    const log = logFromJson(readString$1(row, "log_json"));
+    if (log !== null) logs.push(log);
+  }
+  return logs;
+}
+async function listArchivedSessionLogs(sessionId) {
+  const db = await openSessionArchiveDb(getSessionArchivePath(sessionId), false);
+  if (db === null) return [];
+  try {
+    const rows = allPrepared(
+      db,
+      "SELECT log_json FROM session_logs WHERE session_id = ? ORDER BY id ASC",
+      [sessionId]
+    );
+    return logsFromRows(rows);
+  } finally {
+    closeDatabase(db);
+  }
+}
+async function listArchivedSessionIds() {
+  const archivePaths = await listArchiveDatabasePaths();
+  const sessionIds = /* @__PURE__ */ new Set();
+  for (const archivePath of archivePaths) {
+    const db = await openSessionArchiveDb(archivePath, false);
+    if (db === null) continue;
+    try {
+      const rows = allPrepared(
+        db,
+        "SELECT DISTINCT session_id FROM session_logs ORDER BY session_id ASC"
+      );
+      for (const row of rows) {
+        const sessionId = readString$1(row, "session_id");
+        if (sessionId !== null && sessionId.length > 0) sessionIds.add(sessionId);
+      }
+    } finally {
+      closeDatabase(db);
+    }
+  }
+  return [...sessionIds].sort();
+}
+async function listArchiveDatabasePaths() {
+  const root = getSessionArchiveRoot();
+  if (!existsSync(root)) return [];
+  try {
+    const entries = await readdir(root, { withFileTypes: true });
+    const paths = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const candidate = join(root, entry.name, SESSION_ARCHIVE_FILE);
+      if (existsSync(candidate)) paths.push(candidate);
+    }
+    return paths;
+  } catch (err) {
+    logger.warn("[sessionArchive] Failed to list session archives:", String(err));
+    return [];
+  }
+}
+async function findArchivedLogById(id) {
+  const archivePaths = await listArchiveDatabasePaths();
+  for (const archivePath of archivePaths) {
+    const db = await openSessionArchiveDb(archivePath, false);
+    if (db === null) continue;
+    try {
+      const rows = allPrepared(db, "SELECT log_json FROM session_logs WHERE id = ? LIMIT 1", [id]);
+      const first = logsFromRows(rows)[0];
+      if (first !== void 0) return first;
+    } finally {
+      closeDatabase(db);
+    }
+  }
+  return null;
+}
+function placeholders(count) {
+  return Array.from({ length: count }, () => "?").join(", ");
+}
+function idsFromRows(rows) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const id = readNumber(row, "id");
+    if (id !== null && Number.isInteger(id)) ids.add(id);
+  }
+  return ids;
+}
+async function deleteArchivedLogsByIds(ids) {
+  if (ids.size === 0) return /* @__PURE__ */ new Set();
+  const removedIds = /* @__PURE__ */ new Set();
+  const idValues = [...ids];
+  const sqlPlaceholders = placeholders(idValues.length);
+  const archivePaths = await listArchiveDatabasePaths();
+  for (const archivePath of archivePaths) {
+    const db = await openSessionArchiveDb(archivePath, false);
+    if (db === null) continue;
+    try {
+      const matchingRows = allPrepared(
+        db,
+        `SELECT id FROM session_logs WHERE id IN (${sqlPlaceholders})`,
+        idValues
+      );
+      const matchingIds = idsFromRows(matchingRows);
+      if (matchingIds.size === 0) continue;
+      if (runPrepared(db, `DELETE FROM session_logs WHERE id IN (${sqlPlaceholders})`, idValues)) {
+        for (const id of matchingIds) {
+          removedIds.add(id);
+        }
+      }
+    } finally {
+      closeDatabase(db);
+    }
+  }
+  return removedIds;
+}
+async function clearSessionArchives() {
+  const root = getSessionArchiveRoot();
+  if (!existsSync(root)) return 0;
+  const archivePaths = await listArchiveDatabasePaths();
+  try {
+    await rm(root, { recursive: true, force: true });
+    return archivePaths.length;
+  } catch (err) {
+    logger.warn("[sessionArchive] Failed to clear session archives:", String(err));
+    return 0;
+  }
+}
 const IDLE_TIMEOUT_MS = Number(process.env["SESSION_PROCESS_IDLE_MS"]) || 5 * 60 * 1e3;
 const MAX_RESTARTS = 3;
 const _processes = /* @__PURE__ */ new Map();
@@ -2286,6 +2622,7 @@ const MAX_MEMORY_CACHE = 100;
 const memoryCache = /* @__PURE__ */ new Map();
 const MAX_CURSOR_PAGE_INDEXES = 16;
 const logCursorPageIndexes = /* @__PURE__ */ new Map();
+let sessionArchiveQueue = Promise.resolve();
 function cursorPageIndexKey(options) {
   return JSON.stringify({
     sessionId: options.sessionId ?? null,
@@ -2355,6 +2692,17 @@ function addToCache(log) {
   upsertLogCursorPageIndexes(cachedLog);
   evictOldestIfNeeded();
 }
+function archiveLogSnapshot(log) {
+  const archivedLog = normalizeLog(log);
+  sessionArchiveQueue = sessionArchiveQueue.catch(() => void 0).then(async () => {
+    await archiveSessionLog(archivedLog);
+  }).catch((err) => {
+    logger.warn("[store] Failed to archive session log:", String(err));
+  });
+}
+async function flushSessionArchiveWrites() {
+  await sessionArchiveQueue;
+}
 function removeFromCache(id) {
   memoryCache.delete(id);
   removeLogsFromCursorPageIndexes(/* @__PURE__ */ new Set([id]));
@@ -2443,6 +2791,7 @@ async function addTestLogEntry(entry) {
     await addToIndex(id, logFile, -1, -1, createLogIndexEntryMetadata(log));
   });
   addToCache(log);
+  archiveLogSnapshot(log);
   observeSessionLog(log, session.source);
   emitLogUpdate(log);
   return log;
@@ -2506,15 +2855,26 @@ async function createLog(method, path2, requestBody, headers, clientInfo, rawHea
     await addToIndex(id, logFile, -1, -1, createLogIndexEntryMetadata(log));
   });
   addToCache(log);
+  archiveLogSnapshot(log);
   markSessionStarted(log, session.source);
   emitLogUpdate(log);
   return log;
 }
 function finalizeLogUpdate(log) {
   addToCache(log);
+  archiveLogSnapshot(log);
   markSessionFinished(log);
   emitLogUpdate(log);
 }
+async function getArchivedLogByIdForStore(id) {
+  await flushSessionArchiveWrites();
+  const archivedLog = await findArchivedLogById(id);
+  if (archivedLog === null) return null;
+  const normalized = normalizeLog(archivedLog);
+  addToCache(normalized);
+  observeSessionLog(normalized);
+  return normalized;
+}
 async function getLogById(id) {
   const cached = memoryCache.get(id);
   if (cached !== void 0) {
@@ -2522,12 +2882,12 @@ async function getLogById(id) {
   }
   const entry = await findInIndex(id);
   if (entry === null) {
-    return null;
+    return await getArchivedLogByIdForStore(id);
   }
   try {
     const filePath = join(resolveLogDir(), entry.file);
     if (!existsSync(filePath)) {
-      return null;
+      return await getArchivedLogByIdForStore(id);
     }
     if (entry.byteOffset >= 0 && entry.byteLength > 0) {
       const fh = await open(filePath, "r");
@@ -2559,7 +2919,7 @@ async function getLogById(id) {
   } catch (err) {
     logger.error("[store] Failed to read log from disk:", String(err));
   }
-  return null;
+  return await getArchivedLogByIdForStore(id);
 }
 async function scanLogFileForId(filePath, id) {
   let lastMatch = null;
@@ -2634,6 +2994,16 @@ async function visitPersistedLogFile(filePath, visitor) {
     logger.error("[store] Failed to read persisted log file:", filePath, String(err));
   }
 }
+async function visitArchivedSessionLogs(sessionId, visitor) {
+  if (sessionId === void 0) return;
+  await flushSessionArchiveWrites();
+  const logs = await listArchivedSessionLogs(sessionId);
+  for (const archivedLog of logs) {
+    const log = normalizeLog(archivedLog);
+    observeSessionLog(log);
+    visitor(log);
+  }
+}
 function canUseIndexedListPage(options) {
   return options.sessionId === void 0 && options.model === void 0;
 }
@@ -2698,6 +3068,7 @@ async function listLogsPage(options) {
     observeSessionLog(log);
     visitLog(log);
   });
+  await visitArchivedSessionLogs(options.sessionId, visitLog);
   for (const log of memoryCache.values()) {
     visitLog(log);
   }
@@ -2785,6 +3156,17 @@ async function buildLogCursorPageIndexFromLogIndex(options, allowRebuild) {
     idsById.add(log.id);
     logsById.set(log.id, log);
   }
+  if (options.sessionId !== void 0) {
+    await flushSessionArchiveWrites();
+    const archivedLogs = await listArchivedSessionLogs(options.sessionId);
+    for (const archivedLog of archivedLogs) {
+      const log = normalizeLog(archivedLog);
+      if (!matchesLogFilters(log, options.sessionId, options.model)) continue;
+      observeSessionLog(log);
+      idsById.add(log.id);
+      logsById.set(log.id, log);
+    }
+  }
   return {
     key: cursorPageIndexKey(options),
     sessionId: options.sessionId,
@@ -2807,6 +3189,7 @@ async function buildLogCursorPageIndex(options) {
     observeSessionLog(log);
     visitLog(log);
   });
+  await visitArchivedSessionLogs(options.sessionId, visitLog);
   for (const log of memoryCache.values()) {
     visitLog(log);
   }
@@ -2899,6 +3282,15 @@ async function collectSessionLogSummaries(sessionId, includeHistory) {
   for (const summary of indexedSummaries) {
     summariesById.set(summary.id, summary);
   }
+  await flushSessionArchiveWrites();
+  const archivedLogs = await listArchivedSessionLogs(sessionId);
+  for (const archivedLog of archivedLogs) {
+    const log = normalizeLog(archivedLog);
+    observeSessionLog(log);
+    if (!summariesById.has(log.id)) {
+      summariesById.set(log.id, buildSessionLogSummary(log));
+    }
+  }
   if (includeHistory && summariesById.size === 0) {
     await visitPersistedLogs((log) => {
       observeSessionLog(log);
@@ -2954,8 +3346,13 @@ async function getSessionInfo(sessionId, options) {
     latestLogLimit: options.latestLogLimit
   });
 }
-function getSessions() {
-  return getSessionIds();
+async function listSessions() {
+  await flushSessionArchiveWrites();
+  const sessionIds = new Set(getSessionIds());
+  for (const sessionId of await listArchivedSessionIds()) {
+    sessionIds.add(sessionId);
+  }
+  return [...sessionIds].sort();
 }
 function getModels() {
   const set = /* @__PURE__ */ new Set();
@@ -2999,8 +3396,13 @@ function collectDirectoryStats(dir, shouldCount) {
 function getLogStorageStats() {
   const logDir = resolveLogDir();
   const chunkDir = getChunksDir();
+  const sessionArchiveDir = getSessionArchiveRoot();
   const logStats = collectDirectoryStats(logDir, (fileName) => fileName.endsWith(".jsonl"));
   const chunkStats = collectDirectoryStats(chunkDir, (fileName) => fileName.endsWith(".json"));
+  const sessionArchiveStats = collectDirectoryStats(
+    sessionArchiveDir,
+    (fileName) => fileName === "session.sqlite" || fileName.startsWith("session.sqlite-")
+  );
   return {
     memoryCount: memoryCache.size,
     logDir,
@@ -3008,7 +3410,10 @@ function getLogStorageStats() {
     logBytes: logStats.bytes,
     chunkDir,
     chunkFileCount: chunkStats.fileCount,
-    chunkBytes: chunkStats.bytes
+    chunkBytes: chunkStats.bytes,
+    sessionArchiveDir,
+    sessionArchiveFileCount: sessionArchiveStats.fileCount,
+    sessionArchiveBytes: sessionArchiveStats.bytes
   };
 }
 function clearAllLogs() {
@@ -3043,8 +3448,9 @@ async function deleteMatchingFiles(dir, shouldDelete) {
 async function clearPersistedLogStorage() {
   return await runWithFlushedLogWriteLock(async () => {
     await flushIndex();
+    await flushSessionArchiveWrites();
     const result = clearAllLogs();
-    const [logFilesDeleted, chunkFilesDeleted] = await Promise.all([
+    const [logFilesDeleted, chunkFilesDeleted, sessionArchiveFilesDeleted] = await Promise.all([
       deleteMatchingFiles(
         resolveLogDir(),
         (fileName) => fileName.endsWith(".jsonl") || fileName === "logs.idx" || fileName === "inspector.sqlite" || fileName.startsWith("inspector.sqlite-")
@@ -3052,13 +3458,15 @@ async function clearPersistedLogStorage() {
       deleteMatchingFiles(
         getChunksDir(),
         (fileName) => fileName.endsWith(".json") || fileName.startsWith(".") && fileName.endsWith(".tmp")
-      )
+      ),
+      clearSessionArchives()
     ]);
     await rebuildIndex();
     return {
       cleared: result.cleared,
       logFilesDeleted,
-      chunkFilesDeleted
+      chunkFilesDeleted,
+      sessionArchiveFilesDeleted
     };
   });
 }
@@ -3214,18 +3622,25 @@ async function deleteChunkFilesByIds(ids) {
 async function clearPersistedLogsByIds(ids) {
   const uniqueIds = new Set(ids);
   if (uniqueIds.size === 0) {
-    return { cleared: 0, logFilesRewritten: 0, chunkFilesDeleted: 0 };
+    return {
+      cleared: 0,
+      logFilesRewritten: 0,
+      chunkFilesDeleted: 0,
+      sessionArchiveLogsDeleted: 0
+    };
   }
   return await runWithFlushedLogWriteLock(async () => {
     await flushIndex();
+    await flushSessionArchiveWrites();
     const memoryRemovedIds = /* @__PURE__ */ new Set();
     for (const id of uniqueIds) {
       if (memoryCache.has(id)) memoryRemovedIds.add(id);
     }
     const result = clearLogsByIds([...uniqueIds]);
-    const [rewriteResult, chunkFilesDeleted] = await Promise.all([
+    const [rewriteResult, chunkFilesDeleted, archivedRemovedIds] = await Promise.all([
       rewriteLogFilesWithoutIds(uniqueIds),
-      deleteChunkFilesByIds(uniqueIds)
+      deleteChunkFilesByIds(uniqueIds),
+      deleteArchivedLogsByIds(uniqueIds)
     ]);
     await rebuildIndex();
     clearLogCursorPageIndexes();
@@ -3235,10 +3650,14 @@ async function clearPersistedLogsByIds(ids) {
         clearedIds.add(id);
       }
     }
+    for (const id of archivedRemovedIds) {
+      clearedIds.add(id);
+    }
     return {
       cleared: clearedIds.size,
       logFilesRewritten: rewriteResult.logFilesRewritten,
-      chunkFilesDeleted
+      chunkFilesDeleted,
+      sessionArchiveLogsDeleted: archivedRemovedIds.size
     };
   });
 }
@@ -6426,7 +6845,7 @@ const Route$z = createFileRoute("/api/sessions")({
         if (details === "true" || details === "1") {
           return Response.json(getSessionSnapshots());
         }
-        return Response.json(getSessions());
+        return Response.json(await listSessions());
       }
     }
   }
@@ -7926,7 +8345,7 @@ const Route$w = createFileRoute("/api/models")({
     }
   }
 });
-const version = "2.1.6";
+const version = "2.1.7";
 const packageJson = {
   version
 };
@@ -10631,7 +11050,8 @@ const Route$u = createFileRoute("/api/logs")({
             success: true,
             cleared: result2.cleared,
             logFilesRewritten: result2.logFilesRewritten,
-            chunkFilesDeleted: result2.chunkFilesDeleted
+            chunkFilesDeleted: result2.chunkFilesDeleted,
+            sessionArchiveLogsDeleted: result2.sessionArchiveLogsDeleted
           });
         }
         const result = await clearPersistedLogStorage();
@@ -10639,7 +11059,8 @@ const Route$u = createFileRoute("/api/logs")({
           success: true,
           cleared: result.cleared,
           logFilesDeleted: result.logFilesDeleted,
-          chunkFilesDeleted: result.chunkFilesDeleted
+          chunkFilesDeleted: result.chunkFilesDeleted,
+          sessionArchiveFilesDeleted: result.sessionArchiveFilesDeleted
         });
       }
     }