@tonyclaw/agent-inspector 3.0.45 → 3.0.46

package/src/proxy/rawStreamCapture.ts

@@ -12,8 +12,28 @@ import {
 
 const DEFAULT_MEMORY_LIMIT_BYTES = 1024 * 1024;
 const FILE_WRITE_BATCH_BYTES = 64 * 1024;
+const DEFAULT_QUEUE_MAX_MESSAGES = 256;
+const DEFAULT_QUEUE_MAX_BYTES = 8 * 1024 * 1024;
+const DEFAULT_GLOBAL_QUEUE_MAX_MESSAGES = 4096;
+const DEFAULT_GLOBAL_QUEUE_MAX_BYTES = 64 * 1024 * 1024;
 const activeCaptures = new Set<RawStreamCapture>();
 
+export type RawStreamCaptureGapReason = "capacity-exceeded" | "pipeline-closed" | "write-failed";
+
+export type RawStreamCaptureStatus = {
+  incomplete: boolean;
+  droppedChunks: number;
+  droppedBytes: number;
+  reason: RawStreamCaptureGapReason | null;
+};
+
+export type RawStreamCaptureOptions = {
+  memoryLimitBytes?: number;
+  queueMaxMessages?: number;
+  queueMaxBytes?: number;
+  globalBudget?: RawStreamObservationBudget;
+};
+
 export type RawStreamSource =
   | {
       type: "memory";
@@ -32,6 +52,62 @@ function resolveMemoryLimitBytes(): number {
   return parsed;
 }
 
+function resolvePositiveIntegerEnv(name: string, fallback: number): number {
+  const raw = process.env[name];
+  if (raw === undefined || raw === "") return fallback;
+  const parsed = Number(raw);
+  if (!Number.isSafeInteger(parsed) || parsed < 1) return fallback;
+  return parsed;
+}
+
+function defaultQueueMaxMessages(): number {
+  return resolvePositiveIntegerEnv(
+    "AGENT_INSPECTOR_OBSERVATION_QUEUE_MESSAGES",
+    DEFAULT_QUEUE_MAX_MESSAGES,
+  );
+}
+
+function defaultQueueMaxBytes(): number {
+  return resolvePositiveIntegerEnv(
+    "AGENT_INSPECTOR_OBSERVATION_QUEUE_BYTES",
+    DEFAULT_QUEUE_MAX_BYTES,
+  );
+}
+
+export class RawStreamObservationBudget {
+  private messages = 0;
+  private bytes = 0;
+
+  constructor(
+    private readonly maxMessages: number,
+    private readonly maxBytes: number,
+  ) {}
+
+  tryAcquire(bytes: number): (() => void) | null {
+    if (this.messages + 1 > this.maxMessages || this.bytes + bytes > this.maxBytes) return null;
+    this.messages += 1;
+    this.bytes += bytes;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.messages -= 1;
+      this.bytes -= bytes;
+    };
+  }
+}
+
+const globalObservationBudget = new RawStreamObservationBudget(
+  resolvePositiveIntegerEnv(
+    "AGENT_INSPECTOR_OBSERVATION_GLOBAL_QUEUE_MESSAGES",
+    DEFAULT_GLOBAL_QUEUE_MAX_MESSAGES,
+  ),
+  resolvePositiveIntegerEnv(
+    "AGENT_INSPECTOR_OBSERVATION_GLOBAL_QUEUE_BYTES",
+    DEFAULT_GLOBAL_QUEUE_MAX_BYTES,
+  ),
+);
+
 function getRawStreamDir(): string {
   return join(getDataDir(), "raw-streams");
 }
@@ -42,6 +118,9 @@ function createRawStreamPath(): string {
 
 export class RawStreamCapture {
   private readonly memoryLimitBytes: number;
+  private readonly queueMaxMessages: number;
+  private readonly queueMaxBytes: number;
+  private readonly globalBudget: RawStreamObservationBudget;
   private chunks: string[] = [];
   private byteLength = 0;
   private filePath: string | null = null;
@@ -49,11 +128,22 @@ export class RawStreamCapture {
   private pendingFileChunks: string[] = [];
   private pendingFileBytes = 0;
   private operation = Promise.resolve();
+  private accepting = true;
   private closed = false;
   private sawChunk = false;
+  private queuedMessages = 0;
+  private queuedBytes = 0;
+  private incomplete = false;
+  private storageFailed = false;
+  private droppedChunks = 0;
+  private droppedBytes = 0;
+  private gapReason: RawStreamCaptureGapReason | null = null;
 
-  constructor(memoryLimitBytes: number = resolveMemoryLimitBytes()) {
-    this.memoryLimitBytes = memoryLimitBytes;
+  constructor(options: RawStreamCaptureOptions = {}) {
+    this.memoryLimitBytes = options.memoryLimitBytes ?? resolveMemoryLimitBytes();
+    this.queueMaxMessages = options.queueMaxMessages ?? defaultQueueMaxMessages();
+    this.queueMaxBytes = options.queueMaxBytes ?? defaultQueueMaxBytes();
+    this.globalBudget = options.globalBudget ?? globalObservationBudget;
     activeCaptures.add(this);
   }
 
@@ -61,6 +151,21 @@ export class RawStreamCapture {
     return this.sawChunk;
   }
 
+  get status(): RawStreamCaptureStatus {
+    return {
+      incomplete: this.incomplete,
+      droppedChunks: this.droppedChunks,
+      droppedBytes: this.droppedBytes,
+      reason: this.gapReason,
+    };
+  }
+
+  recordDroppedObservation(reason: RawStreamCaptureGapReason, observedBytes: number): void {
+    const safeObservedBytes =
+      Number.isSafeInteger(observedBytes) && observedBytes >= 0 ? observedBytes : 0;
+    this.recordGap(reason, safeObservedBytes, safeObservedBytes > 0);
+  }
+
   async append(text: string): Promise<void> {
     if (text === "") return;
     const next = this.operation.then(() => this.appendInternal(text));
@@ -68,7 +173,63 @@ export class RawStreamCapture {
     return next;
   }
 
+  /**
+   * Submit an observation without waiting for file I/O. Once capacity is exceeded, capture remains
+   * incomplete and all later chunks are counted as dropped so the persisted value is an honest
+   * prefix rather than a misleading stream with an unmarked hole.
+   */
+  tryAppend(text: string, observedBytes: number): boolean {
+    const safeObservedBytes =
+      Number.isSafeInteger(observedBytes) && observedBytes >= 0 ? observedBytes : 0;
+    const queuedBytes = Math.max(safeObservedBytes, Buffer.byteLength(text, "utf-8"));
+
+    if (!this.accepting || this.closed) {
+      this.recordGap("pipeline-closed", safeObservedBytes, safeObservedBytes > 0 || text !== "");
+      return false;
+    }
+    if (this.incomplete) {
+      this.recordGap("capacity-exceeded", safeObservedBytes, safeObservedBytes > 0 || text !== "");
+      return false;
+    }
+    if (text === "") return true;
+    if (
+      this.queuedMessages + 1 > this.queueMaxMessages ||
+      this.queuedBytes + queuedBytes > this.queueMaxBytes
+    ) {
+      this.recordGap("capacity-exceeded", safeObservedBytes, true);
+      return false;
+    }
+
+    const releaseGlobal = this.globalBudget.tryAcquire(queuedBytes);
+    if (releaseGlobal === null) {
+      this.recordGap("capacity-exceeded", safeObservedBytes, true);
+      return false;
+    }
+
+    this.queuedMessages += 1;
+    this.queuedBytes += queuedBytes;
+    this.operation = this.operation
+      .then(async () => {
+        if (this.storageFailed) {
+          this.recordGap("write-failed", safeObservedBytes, true);
+          return;
+        }
+        await this.appendInternal(text);
+      })
+      .catch(() => {
+        this.storageFailed = true;
+        this.recordGap("write-failed", safeObservedBytes, true);
+      })
+      .finally(() => {
+        this.queuedMessages -= 1;
+        this.queuedBytes -= queuedBytes;
+        releaseGlobal();
+      });
+    return true;
+  }
+
   async finalize(): Promise<RawStreamSource> {
+    this.accepting = false;
     const next = this.operation.then(() => this.finalizeInternal());
     this.operation = next.then(
       () => undefined,
@@ -100,14 +261,29 @@ export class RawStreamCapture {
     }
   }
 
+  private recordGap(
+    reason: RawStreamCaptureGapReason,
+    observedBytes: number,
+    countChunk: boolean,
+  ): void {
+    this.incomplete = true;
+    this.gapReason ??= reason;
+    if (countChunk) this.droppedChunks += 1;
+    this.droppedBytes += observedBytes;
+  }
+
   private async finalizeInternal(): Promise<RawStreamSource> {
     if (!this.closed) {
       this.closed = true;
       await this.flushFileBuffer();
       if (this.fileHandle !== null) {
-        await this.fileHandle.sync();
-        await this.fileHandle.close();
+        const handle = this.fileHandle;
         this.fileHandle = null;
+        try {
+          await handle.sync();
+        } finally {
+          await handle.close();
+        }
       }
     }
     if (this.filePath !== null) {
@@ -120,16 +296,21 @@ export class RawStreamCapture {
     const path = createRawStreamPath();
     assert(ensurePrivateDirectorySync(getRawStreamDir()), "Could not secure raw-stream directory");
     const handle = await open(path, "wx", PRIVATE_FILE_MODE);
-    const memoryText = this.chunks.join("");
-    if (memoryText.length > 0) await handle.write(memoryText, undefined, "utf-8");
-    if (!securePrivateFileSync(path)) {
-      await handle.close();
-      await unlink(path);
-      assert(false, "Could not secure raw-stream file");
+    let committed = false;
+    try {
+      const memoryText = this.chunks.join("");
+      if (memoryText.length > 0) await handle.write(memoryText, undefined, "utf-8");
+      assert(securePrivateFileSync(path), "Could not secure raw-stream file");
+      this.filePath = path;
+      this.fileHandle = handle;
+      this.chunks = [];
+      committed = true;
+    } finally {
+      if (!committed) {
+        await handle.close().catch(() => undefined);
+        await unlink(path).catch(() => undefined);
+      }
     }
-    this.filePath = path;
-    this.fileHandle = handle;
-    this.chunks = [];
   }
 
   private async flushFileBuffer(): Promise<void> {

package/src/proxy/runtimeAdmission.ts

@@ -1,3 +1,5 @@
+import { MAX_ACTIVE_PROXY_REQUESTS } from "../lib/resourceLimits";
+
 export type RuntimeRequestLease = {
   release: () => void;
 };
@@ -13,7 +15,7 @@ function notifyDrained(): void {
 }
 
 export function acquireRuntimeRequest(): RuntimeRequestLease | null {
-  if (!acceptingRequests) return null;
+  if (!acceptingRequests || activeRequests >= MAX_ACTIVE_PROXY_REQUESTS) return null;
   activeRequests += 1;
   let released = false;
   return {
@@ -41,8 +43,9 @@ export async function waitForRuntimeTrafficDrain(): Promise<void> {
 export function getRuntimeAdmissionState(): {
   acceptingRequests: boolean;
   activeRequests: number;
+  capacity: number;
 } {
-  return { acceptingRequests, activeRequests };
+  return { acceptingRequests, activeRequests, capacity: MAX_ACTIVE_PROXY_REQUESTS };
 }
 
 export function _resetRuntimeAdmissionForTests(): void {

package/src/proxy/runtimeHealth.ts

@@ -5,6 +5,9 @@ import { getDataDir } from "./dataDir";
 import { getFinalizerRuntimeHealth } from "./logFinalizer";
 import { ensurePrivateDirectorySync, PRIVATE_FILE_MODE } from "./privateDataPath";
 import { isSqliteLogIndexReady } from "./sqliteLogIndex";
+import { recoverCapturedLogStorage } from "./jsonlRecovery";
+import { resolveLogDir } from "./logger";
+import { loadIndex } from "./logIndex";
 
 const DEFAULT_CACHE_MS = 2_000;
 const DEFAULT_MIN_DISK_HEADROOM_BYTES = 256 * 1024 * 1024;
@@ -118,7 +121,17 @@ function checkQueue(): Promise<ReadinessCheckLevel> {
 }
 
 async function checkIndex(): Promise<ReadinessCheckLevel> {
-  return (await isSqliteLogIndexReady()) ? "ok" : "degraded";
+  const recovery = await recoverCapturedLogStorage(resolveLogDir());
+  if (recovery.level === "unavailable") return "unavailable";
+
+  try {
+    await loadIndex();
+  } catch {
+    return "unavailable";
+  }
+
+  const sqliteReady = await isSqliteLogIndexReady();
+  return recovery.level === "degraded" || !sqliteReady ? "degraded" : "ok";
 }
 
 function checkShutdown(): Promise<ReadinessCheckLevel> {

package/src/proxy/runtimeShutdown.ts

@@ -15,6 +15,11 @@ import {
   type ShutdownResult,
 } from "./shutdownCoordinator";
 import { destroyAllSessionProcesses } from "./sessionProcess";
+import {
+  beginEcosystemTaskShutdown,
+  forceCloseEcosystemTasks,
+  waitForEcosystemTasksToClose,
+} from "./ecosystemTasks";
 import { flushSessionTasks } from "./sessionRuntime";
 import { closeSqliteLogIndex } from "./sqliteLogIndex";
 import { flushSessionArchiveWrites } from "./store";
@@ -45,6 +50,7 @@ async function flushPersistence(): Promise<void> {
 }
 
 async function closeResources(): Promise<void> {
+  await waitForEcosystemTasksToClose();
   await closeLogFinalizerWorkers();
   destroyAllSessionProcesses();
   closeSqliteLogIndex();
@@ -52,6 +58,7 @@ async function closeResources(): Promise<void> {
 }
 
 function forceCloseResources(): void {
+  forceCloseEcosystemTasks();
   forceCloseLogFinalizerWorkers();
   destroyAllSessionProcesses();
   closeSqliteLogIndex();
@@ -59,7 +66,10 @@ function forceCloseResources(): void {
 
 const runtimeShutdownCoordinator = createShutdownCoordinator(
   {
-    markShuttingDown: () => setRuntimeShuttingDown(true),
+    markShuttingDown: () => {
+      setRuntimeShuttingDown(true);
+      beginEcosystemTaskShutdown();
+    },
     stopAdmission: stopRuntimeAdmission,
     drainTraffic: waitForRuntimeTrafficDrain,
     drainFinalizers,

package/src/proxy/schemas.ts

@@ -1,9 +1,15 @@
 import { z } from "zod";
 
-export { CapturedLogSchema, JsonValueSchema, StreamingChunkSchema } from "../contracts";
+export {
+  CaptureIncompleteReasonSchema,
+  CapturedLogSchema,
+  JsonValueSchema,
+  StreamingChunkSchema,
+} from "../contracts";
 export type {
   CapturedLog,
   ApiFormat,
+  CaptureIncompleteReason,
   JsonValue,
   StreamingChunk,
   TokenUsage,

package/src/proxy/sessionArchive.ts

@@ -40,6 +40,7 @@ ON CONFLICT(id) DO UPDATE SET
 `;
 
 let didLogUnavailable = false;
+let cachedArchiveMax: { root: string; maxId: number } | null = null;
 
 export function getSessionArchiveRoot(): string {
   return join(resolveLogDir(), SESSION_ARCHIVE_DIR);
@@ -236,23 +237,49 @@ async function openSessionArchiveDb(filePath: string, create: boolean): Promise<
   }
 }
 
-export async function archiveSessionLog(log: CapturedLog): Promise<boolean> {
-  const sessionId = log.sessionId;
-  if (sessionId === null || sessionId.trim().length === 0) return false;
+export async function archiveSessionLogs(logs: readonly CapturedLog[]): Promise<number> {
+  const bySession = new Map<string, CapturedLog[]>();
+  for (const log of logs) {
+    const sessionId = log.sessionId;
+    if (sessionId === null || sessionId.trim().length === 0) continue;
+    const existing = bySession.get(sessionId);
+    if (existing === undefined) bySession.set(sessionId, [log]);
+    else existing.push(log);
+  }
 
-  const db = await openSessionArchiveDb(getSessionArchivePath(sessionId), true);
-  if (db === null) return false;
+  let archivedCount = 0;
+  for (const [sessionId, sessionLogs] of bySession) {
+    const db = await openSessionArchiveDb(getSessionArchivePath(sessionId), true);
+    if (db === null || !execSql(db, "BEGIN IMMEDIATE")) {
+      if (db !== null) closeDatabase(db);
+      continue;
+    }
 
-  try {
-    return runPrepared(db, UPSERT_SQL, [
-      log.id,
-      sessionId,
-      JSON.stringify(log),
-      new Date().toISOString(),
-    ]);
-  } finally {
-    closeDatabase(db);
+    let committed = false;
+    try {
+      const updatedAt = new Date().toISOString();
+      const archived = sessionLogs.every((log) =>
+        runPrepared(db, UPSERT_SQL, [log.id, sessionId, JSON.stringify(log), updatedAt]),
+      );
+      if (archived && execSql(db, "COMMIT")) {
+        committed = true;
+        archivedCount += sessionLogs.length;
+        if (cachedArchiveMax?.root === getSessionArchiveRoot()) {
+          for (const log of sessionLogs) {
+            cachedArchiveMax.maxId = Math.max(cachedArchiveMax.maxId, log.id);
+          }
+        }
+      }
+    } finally {
+      if (!committed) void execSql(db, "ROLLBACK");
+      closeDatabase(db);
+    }
   }
+  return archivedCount;
+}
+
+export async function archiveSessionLog(log: CapturedLog): Promise<boolean> {
+  return (await archiveSessionLogs([log])) === 1;
 }
 
 function readString(row: unknown, name: string): string | null {
@@ -343,6 +370,36 @@ async function listArchiveDatabasePaths(): Promise<string[]> {
   }
 }
 
+/**
+ * Return the highest ID retained by an authoritative session archive. The global SQLite index is a
+ * rebuildable projection and must never influence ID allocation, while archive IDs must remain
+ * reserved even after their corresponding global JSONL records have aged out.
+ */
+export async function getSessionArchiveMaxLogId(): Promise<number> {
+  const root = getSessionArchiveRoot();
+  if (cachedArchiveMax?.root === root) return cachedArchiveMax.maxId;
+
+  let maxId = 0;
+  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 MAX(id) AS max_id FROM session_logs");
+      const archiveMax = readNumber(rows[0], "max_id");
+      if (archiveMax !== null && Number.isSafeInteger(archiveMax) && archiveMax >= 0) {
+        maxId = Math.max(maxId, archiveMax);
+      }
+    } finally {
+      closeDatabase(db);
+    }
+  }
+
+  cachedArchiveMax = { root, maxId };
+  return maxId;
+}
+
 export async function findArchivedLogById(id: number): Promise<CapturedLog | null> {
   const archivePaths = await listArchiveDatabasePaths();
   for (const archivePath of archivePaths) {
@@ -405,6 +462,8 @@ export async function deleteArchivedLogsByIds(ids: ReadonlySet<number>): Promise
     }
   }
 
+  if (removedIds.size > 0) cachedArchiveMax = null;
+
   return removedIds;
 }
 
@@ -415,9 +474,14 @@ export async function clearSessionArchives(): Promise<number> {
   const archivePaths = await listArchiveDatabasePaths();
   try {
     await rm(root, { recursive: true, force: true });
+    cachedArchiveMax = null;
     return archivePaths.length;
   } catch (err) {
     logger.warn("[sessionArchive] Failed to clear session archives:", String(err));
     return 0;
   }
 }
+
+export function _resetSessionArchiveCacheForTests(): void {
+  cachedArchiveMax = null;
+}

package/src/proxy/sqliteLogIndex.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { logger, resolveLogDir } from "./logger";
-import type { ApiFormat } from "./schemas";
+import type { ApiFormat, CaptureIncompleteReason } from "./schemas";
 import type { LogIndexEntry, LogIndexSummary } from "./logIndex";
 import { ensurePrivateDirectorySync, securePrivateFileSync } from "./privateDataPath";
 
@@ -47,6 +47,10 @@ CREATE TABLE IF NOT EXISTS log_index (
   streaming_chunks_path TEXT,
   raw_request_body_bytes INTEGER,
   response_text_bytes INTEGER,
+  capture_incomplete INTEGER NOT NULL DEFAULT 0,
+  dropped_chunks INTEGER NOT NULL DEFAULT 0,
+  dropped_bytes INTEGER NOT NULL DEFAULT 0,
+  capture_incomplete_reason TEXT,
   warnings_json TEXT,
   error TEXT
 );
@@ -89,10 +93,14 @@ INSERT INTO log_index (
   streaming_chunks_path,
   raw_request_body_bytes,
   response_text_bytes,
+  capture_incomplete,
+  dropped_chunks,
+  dropped_bytes,
+  capture_incomplete_reason,
   warnings_json,
   error
 ) VALUES (
-  ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+  ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
 )
 ON CONFLICT(id) DO UPDATE SET
   file = excluded.file,
@@ -126,6 +134,10 @@ ON CONFLICT(id) DO UPDATE SET
   streaming_chunks_path = excluded.streaming_chunks_path,
   raw_request_body_bytes = excluded.raw_request_body_bytes,
   response_text_bytes = excluded.response_text_bytes,
+  capture_incomplete = excluded.capture_incomplete,
+  dropped_chunks = excluded.dropped_chunks,
+  dropped_bytes = excluded.dropped_bytes,
+  capture_incomplete_reason = excluded.capture_incomplete_reason,
   warnings_json = excluded.warnings_json,
   error = excluded.error
 `;
@@ -215,6 +227,30 @@ function execSql(db: unknown, sql: string): boolean {
   return result !== undefined;
 }
 
+const REQUIRED_SCHEMA_COLUMNS = [
+  { name: "capture_incomplete", definition: "INTEGER NOT NULL DEFAULT 0" },
+  { name: "dropped_chunks", definition: "INTEGER NOT NULL DEFAULT 0" },
+  { name: "dropped_bytes", definition: "INTEGER NOT NULL DEFAULT 0" },
+  { name: "capture_incomplete_reason", definition: "TEXT" },
+];
+
+function ensureSchemaColumns(db: unknown): boolean {
+  const rows = allPrepared(db, "PRAGMA table_info(log_index)");
+  if (rows === null) return false;
+  const existing = new Set<string>();
+  for (const row of rows) {
+    const name = readProperty(row, "name");
+    if (typeof name === "string") existing.add(name);
+  }
+  for (const column of REQUIRED_SCHEMA_COLUMNS) {
+    if (existing.has(column.name)) continue;
+    if (!execSql(db, `ALTER TABLE log_index ADD COLUMN ${column.name} ${column.definition}`)) {
+      return false;
+    }
+  }
+  return true;
+}
+
 function sqliteConstructorFromModule(
   moduleValue: unknown,
   exportName: "default" | "Database",
@@ -316,6 +352,9 @@ async function initializeSqliteState(): Promise<SqliteState> {
     if (!execSql(db, CREATE_SCHEMA_SQL)) {
       return { status: "unavailable", path, reason: "SQLite schema initialization failed" };
     }
+    if (!ensureSchemaColumns(db)) {
+      return { status: "unavailable", path, reason: "SQLite schema migration failed" };
+    }
     activeDb = db;
     return { status: "ready", db, path };
   } catch (err) {
@@ -394,6 +433,10 @@ function entryParams(entry: LogIndexEntry): readonly unknown[] {
     summary?.streamingChunksPath ?? null,
     summary?.rawRequestBodyBytes ?? null,
     summary?.responseTextBytes ?? null,
+    boolToInt(summary?.captureIncomplete ?? false),
+    summary?.droppedChunks ?? 0,
+    summary?.droppedBytes ?? 0,
+    summary?.captureIncompleteReason ?? null,
     warningJson(summary?.warnings),
     summary?.error ?? null,
   ];
@@ -428,6 +471,22 @@ function readApiFormat(row: unknown): ApiFormat {
   }
 }
 
+function readCaptureIncompleteReason(row: unknown): CaptureIncompleteReason | null {
+  const value = readString(row, "capture_incomplete_reason");
+  switch (value) {
+    case "capacity-exceeded":
+    case "pipeline-closed":
+    case "write-failed":
+    case "finalize-failed":
+    case "upstream-stream-error":
+    case "shutdown":
+      return value;
+    case null:
+    default:
+      return null;
+  }
+}
+
 function readWarnings(row: unknown): string[] | undefined {
   const value = readString(row, "warnings_json");
   if (value === null) return undefined;
@@ -481,6 +540,10 @@ function summaryFromRow(row: unknown, id: number): LogIndexSummary {
     streamingChunksPath: readString(row, "streaming_chunks_path"),
     rawRequestBodyBytes: readNumber(row, "raw_request_body_bytes"),
     responseTextBytes: readNumber(row, "response_text_bytes"),
+    captureIncomplete: readBoolean(row, "capture_incomplete"),
+    droppedChunks: readNumber(row, "dropped_chunks") ?? 0,
+    droppedBytes: readNumber(row, "dropped_bytes") ?? 0,
+    captureIncompleteReason: readCaptureIncompleteReason(row),
     warnings: readWarnings(row),
     error: readString(row, "error"),
   };