@cesarus777/opencode-cgp 0.4.1 → 0.4.2

package/dist/cli.js

@@ -474,15 +474,109 @@ async function segments(directory) {
   return (await Promise.all(names.filter((n) => filename.test(n)).map(async (name) => ({
     name,
     time: Number(filename.exec(name)?.[1]),
-    bytes: (await stat(join(directory, name))).size
+    ...fileIdentity(await stat(join(directory, name)))
   })))).sort((a, b) => a.time - b.time || a.name.localeCompare(b.name));
 }
+function fileIdentity(info) {
+  return {
+    bytes: info.size,
+    dev: info.dev,
+    ino: info.ino,
+    mtimeMs: info.mtimeMs,
+    ctimeMs: info.ctimeMs
+  };
+}
+function scanScheduler(signal, options = {}) {
+  const now = options.now ?? (() => performance.now());
+  const pause = options.yield ?? (() => new Promise((done) => setTimeout(done, 0)));
+  let started = now();
+  return () => {
+    signal?.throwIfAborted();
+    if (now() - started >= 4)
+      return pause().then(() => {
+        signal?.throwIfAborted();
+        started = now();
+      });
+  };
+}
+function matchesHistory(value, filter) {
+  return !(filter.sessionId !== undefined && value.sessionId !== filter.sessionId && value.sessionId !== "__history__" || value.type !== "gap" && filter.agent !== undefined && (value.performance?.requestAgent ?? value.agent) !== filter.agent || value.type !== "gap" && filter.model !== undefined && (value.performance?.requestModel ?? value.model) !== filter.model || filter.from !== undefined && value.time < filter.from || filter.to !== undefined && value.time > filter.to);
+}
+async function scanHistorySegment(handle, size, filter = {}, options = {}, start = 0) {
+  const records = [];
+  let malformedRecords = 0, position = start, boundary = start;
+  let pending = Buffer.alloc(0);
+  const checkpoint = scanScheduler(filter.signal, options);
+  function parse(line) {
+    if (!line.length)
+      return;
+    options.onParse?.();
+    let value;
+    try {
+      value = JSON.parse(line.toString("utf8"));
+    } catch {
+      malformedRecords++;
+      return;
+    }
+    if (!isHistoryRecord(value)) {
+      malformedRecords++;
+      return;
+    }
+    if (matchesHistory(value, filter))
+      records.push(value);
+  }
+  while (position < size) {
+    {
+      const waiting = checkpoint();
+      if (waiting)
+        await waiting;
+    }
+    const buffer = Buffer.alloc(Math.min(options.chunkBytes ?? 65536, size - position));
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+    if (!bytesRead)
+      throw new Error("Archive changed during read");
+    options.onRead?.(bytesRead);
+    position += bytesRead;
+    const chunk = pending.length ? Buffer.concat([pending, buffer.subarray(0, bytesRead)]) : buffer.subarray(0, bytesRead);
+    let offset = 0;
+    for (;; ) {
+      const end = chunk.indexOf(10, offset);
+      if (end < 0)
+        break;
+      {
+        const waiting = checkpoint();
+        if (waiting)
+          await waiting;
+      }
+      parse(chunk.subarray(offset, end));
+      offset = end + 1;
+    }
+    pending = Buffer.from(chunk.subarray(offset));
+    boundary = position - pending.length;
+  }
+  const completeRecords = records.length, completeMalformed = malformedRecords;
+  {
+    const waiting = checkpoint();
+    if (waiting)
+      await waiting;
+  }
+  parse(pending);
+  filter.signal?.throwIfAborted();
+  return {
+    records,
+    malformedRecords,
+    boundary,
+    completeRecords,
+    completeMalformed
+  };
+}
 
 class PerformanceHistory {
   path;
   config;
   now;
   report;
+  changed;
   pending = [];
   working;
   active;
@@ -492,11 +586,13 @@ class PerformanceHistory {
   dropped = 0;
   droppedTotal = 0;
   constructor(path, config, now = Date.now, report = () => {
+  }, changed = () => {
   }) {
     this.path = path;
     this.config = config;
     this.now = now;
     this.report = report;
+    this.changed = changed;
   }
   emit(record2) {
     if (!this.config.enabled || this.disabled)
@@ -545,6 +641,7 @@ class PerformanceHistory {
       if (file.time >= this.now() - this.config.retentionDays * 86400000 && total + incoming <= this.config.maxBytes)
         break;
       await unlink(join(this.path, file.name));
+      this.changed(file.name);
       if (file.name === this.active) {
         this.active = undefined;
         this.bytes = 0;
@@ -595,6 +692,7 @@ class PerformanceHistory {
       const file = await open(join(this.path, this.active), "a", 384);
       try {
         await file.writeFile(line);
+        this.changed(this.active);
       } finally {
         await file.close();
       }
@@ -649,7 +747,8 @@ function scalarPerformance(p) {
     }))
   };
 }
-async function readPerformanceHistory(directory, filter = {}) {
+async function readPerformanceHistory(directory, filter = {}, options = {}) {
+  filter.signal?.throwIfAborted();
   const records = [];
   const files = await segments(directory);
   filter.signal?.throwIfAborted();
@@ -667,36 +766,16 @@ async function readPerformanceHistory(directory, filter = {}) {
   for (const file of selected) {
     filter.signal?.throwIfAborted();
     const handle = await open(join(directory, file.name), "r");
-    let source;
     try {
-      const buffer = Buffer.alloc(file.bytes);
-      const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-      source = buffer.subarray(0, bytesRead).toString("utf8");
+      const result = await scanHistorySegment(handle, file.bytes, filter, options);
+      for (const record2 of result.records)
+        records.push(record2);
+      malformedRecords += result.malformedRecords;
     } finally {
       await handle.close();
     }
-    let scannedLines = 0;
-    for (const line of source.split("\n")) {
-      if (filter.signal && ++scannedLines % 256 === 0) {
-        await new Promise((done) => setTimeout(done, 0));
-        filter.signal.throwIfAborted();
-      }
-      if (!line)
-        continue;
-      try {
-        const value = JSON.parse(line);
-        if (!isHistoryRecord(value)) {
-          malformedRecords++;
-          continue;
-        }
-        if (filter.sessionId !== undefined && value.sessionId !== filter.sessionId && value.sessionId !== "__history__" || value.type !== "gap" && filter.agent !== undefined && (value.performance?.requestAgent ?? value.agent) !== filter.agent || value.type !== "gap" && filter.model !== undefined && (value.performance?.requestModel ?? value.model) !== filter.model || filter.from !== undefined && value.time < filter.from || filter.to !== undefined && value.time > filter.to)
-          continue;
-        records.push(value);
-      } catch {
-        malformedRecords++;
-      }
-    }
   }
+  filter.signal?.throwIfAborted();
   const metadata = {
     schema: 1,
     ...files[0] ? { retainedFrom: files[0].time } : {},
@@ -714,7 +793,13 @@ function isHistoryRecord(value) {
   if (!isRecord(value))
     return false;
   const r = value;
-  const allowed = new Set([
+  return Object.keys(r).every((k) => historyFields.has(k)) && r.schema === 1 && typeof r.recordId === "string" && typeof r.time === "number" && Number.isSafeInteger(r.time) && r.time >= 0 && typeof r.sessionId === "string" && typeof r.type === "string" && ["sample", "request", "lifecycle", "gap", "terminal"].includes(r.type) && ["parentId", "agent", "model", "event"].every((k) => r[k] === undefined || typeof r[k] === "string") && (r.performance === undefined || isPerformanceSnapshot(r.performance)) && (r.droppedRecords === undefined || typeof r.droppedRecords === "number" && Number.isSafeInteger(r.droppedRecords) && r.droppedRecords >= 0);
+}
+var filename, historyFields;
+var init_history = __esm(() => {
+  init_rpc();
+  filename = /^([0-9]+)-[a-f0-9-]+\.jsonl$/;
+  historyFields = new Set([
     "schema",
     "recordId",
     "time",
@@ -727,12 +812,6 @@ function isHistoryRecord(value) {
     "performance",
     "droppedRecords"
   ]);
-  return Object.keys(r).every((k) => allowed.has(k)) && r.schema === 1 && typeof r.recordId === "string" && typeof r.time === "number" && Number.isSafeInteger(r.time) && r.time >= 0 && typeof r.sessionId === "string" && typeof r.type === "string" && ["sample", "request", "lifecycle", "gap", "terminal"].includes(r.type) && ["parentId", "agent", "model", "event"].every((k) => r[k] === undefined || typeof r[k] === "string") && (r.performance === undefined || isPerformanceSnapshot(r.performance)) && (r.droppedRecords === undefined || typeof r.droppedRecords === "number" && Number.isSafeInteger(r.droppedRecords) && r.droppedRecords >= 0);
-}
-var filename;
-var init_history = __esm(() => {
-  init_rpc();
-  filename = /^([0-9]+)-[a-f0-9-]+\.jsonl$/;
 });
 
 // src/dashboard/command.ts
@@ -1261,7 +1340,7 @@ function validateInventoryLimits(limits) {
   if (!Number.isInteger(limits.maxNodes) || limits.maxNodes < 1 || limits.maxNodes > 2048 || !Number.isInteger(limits.maxPages) || limits.maxPages < 1 || limits.maxPages > 100 || !Number.isInteger(limits.maxDepth) || limits.maxDepth < 0 || limits.maxDepth > 64)
     throw new Error("Invalid dashboard inventory limits");
 }
-async function discoverInventory(port, signal, limits = inventoryLimits) {
+async function discoverInventory(port, signal, limits = inventoryLimits, progress) {
   validateInventoryLimits(limits);
   const sessions = new Map;
   const notices = new Set;
@@ -1269,59 +1348,75 @@ async function discoverInventory(port, signal, limits = inventoryLimits) {
   let pages = 0;
   while (queue.length && pages < limits.maxPages) {
     signal.throwIfAborted();
-    const branch = queue.shift();
-    if (!branch)
-      break;
-    try {
-      pages++;
-      const page = await port.listSessions({
-        parentID: branch.parent,
-        limit: 100,
-        ...branch.cursor ? { cursor: branch.cursor } : {}
-      }, signal);
-      signal.throwIfAborted();
-      for (const session of page.data) {
-        if (session.directory !== port.location.directory) {
-          notices.add("foreign-location");
-          continue;
-        }
-        if ((session.parentId ?? null) !== branch.parent || sessions.has(session.sessionId)) {
-          notices.add("invalid-hierarchy");
-          continue;
+    const batch = queue.splice(0, Math.min(queue[0]?.parent === null ? 1 : 4, limits.maxPages - pages));
+    pages += batch.length;
+    const results = await Promise.allSettled(batch.map(async (branch) => port.listSessions({
+      parentID: branch.parent,
+      limit: 100,
+      ...branch.cursor ? { cursor: branch.cursor } : {}
+    }, signal)));
+    signal.throwIfAborted();
+    for (const [index, branch] of batch.entries()) {
+      try {
+        const result = results[index];
+        if (!result || result.status === "rejected")
+          throw new Error("Inventory unavailable");
+        const page = result.value;
+        signal.throwIfAborted();
+        for (const session of page.data) {
+          if (session.directory !== port.location.directory) {
+            notices.add("foreign-location");
+            continue;
+          }
+          if ((session.parentId ?? null) !== branch.parent || sessions.has(session.sessionId)) {
+            notices.add("invalid-hierarchy");
+            continue;
+          }
+          if (sessions.size >= limits.maxNodes) {
+            notices.add("node-limit");
+            return {
+              sessions: [...sessions.values()],
+              complete: false,
+              pages,
+              notices: [...notices]
+            };
+          }
+          sessions.set(session.sessionId, session);
+          if (branch.depth < limits.maxDepth)
+            queue.push({
+              parent: session.sessionId,
+              depth: branch.depth + 1,
+              cursors: []
+            });
+          else
+            notices.add("depth-limit");
         }
-        if (sessions.size >= limits.maxNodes) {
-          notices.add("node-limit");
-          return {
-            sessions: [...sessions.values()],
-            complete: false,
-            pages,
-            notices: [...notices]
-          };
+        const cursor = page.cursor?.next;
+        if (cursor) {
+          if (cursor === branch.cursor || branch.cursors.includes(cursor))
+            notices.add("repeated-cursor");
+          else
+            queue.unshift({
+              ...branch,
+              cursor,
+              cursors: [...branch.cursors, cursor]
+            });
         }
-        sessions.set(session.sessionId, session);
-        if (branch.depth < limits.maxDepth)
-          queue.push({
-            parent: session.sessionId,
-            depth: branch.depth + 1,
-            cursors: []
-          });
-        else
-          notices.add("depth-limit");
+      } catch {
+        signal.throwIfAborted();
+        notices.add("inventory-unavailable");
       }
-      const cursor = page.cursor?.next;
-      if (cursor) {
-        if (cursor === branch.cursor || branch.cursors.includes(cursor))
-          notices.add("repeated-cursor");
-        else
-          queue.unshift({
-            ...branch,
-            cursor,
-            cursors: [...branch.cursors, cursor]
-          });
+    }
+    if (progress) {
+      try {
+        progress({
+          sessions: [...sessions.values()],
+          complete: false,
+          pages,
+          notices: [...notices]
+        });
+      } catch {
       }
-    } catch {
-      signal.throwIfAborted();
-      notices.add("inventory-unavailable");
     }
   }
   if (queue.length)
@@ -1587,16 +1682,13 @@ var init_models = __esm(() => {
 
 // src/dashboard/view.ts
 function immutableView(value) {
-  const copy = structuredClone(value);
-  const freeze = (item) => {
-    if (item === null || typeof item !== "object")
-      return;
-    for (const child of Object.values(item))
-      freeze(child);
-    Object.freeze(item);
-  };
-  freeze(copy);
-  return copy;
+  if (value === null || typeof value !== "object" || owned.has(value))
+    return value;
+  const copy = Object.assign(Array.isArray(value) ? [] : {}, value);
+  for (const key in copy)
+    copy[key] = immutableView(copy[key]);
+  owned.add(copy);
+  return Object.freeze(copy);
 }
 function projectHistory(result, filters) {
   const match = (point) => (!filters.agent || point.agent === filters.agent) && (!filters.model || point.model === filters.model);
@@ -1648,13 +1740,15 @@ function projectHistory(result, filters) {
     notices
   };
 }
-var historyWindows;
+var historyWindows, owned;
 var init_view = __esm(() => {
   historyWindows = [300000, 3600000, 86400000, 604800000];
+  owned = new WeakSet;
 });
 
 // src/dashboard/controller.ts
 class DashboardController {
+  snapshots = new WeakMap;
   locations = new Map;
   cache = new Map;
   listeners = new Set;
@@ -1860,7 +1954,33 @@ class DashboardController {
           signal,
           AbortSignal.timeout(15000)
         ]);
-        const result = await discoverInventory(state.port, scanSignal, this.limits);
+        const result = await discoverInventory(state.port, scanSignal, this.limits, (partial) => {
+          if (!this.current(state, generation, scanSignal))
+            return;
+          for (const session of partial.sessions) {
+            const previous = state.nodes.get(session.sessionId);
+            if (!previous && state.nodes.size >= this.limits.maxNodes)
+              continue;
+            state.nodes.set(session.sessionId, {
+              ...session,
+              status: previous?.status ?? "unknown",
+              inventoryStale: true
+            });
+          }
+          state.complete = false;
+          state.stale = true;
+          state.pages = partial.pages;
+          state.notices = partial.notices;
+          if (!state.selected) {
+            const first = state.nodes.keys().next().value;
+            if (first !== undefined) {
+              state.selected = first;
+              this.queueHistory();
+            }
+          }
+          state.client?.setIds([...state.nodes.keys()]);
+          this.publish();
+        });
         let active;
         try {
           active = new Set(await state.port.activeSessions(result.sessions.map((session) => session.sessionId), scanSignal));
@@ -1935,7 +2055,14 @@ class DashboardController {
             return;
           state.connection = client.connection;
           if (client.health) {
-            state.rows = new Map(client.rows);
+            state.rows = new Map([...client.rows].map(([id, row2]) => {
+              let snapshot = this.snapshots.get(row2);
+              if (!snapshot) {
+                snapshot = immutableView(row2);
+                this.snapshots.set(row2, snapshot);
+              }
+              return [id, snapshot];
+            }));
             state.health = client.health;
             state.serverAt = client.now();
             state.receivedAt = this.elapsed();
@@ -2968,12 +3095,30 @@ function overviewLabels(rows) {
     counts.set(suffix, (counts.get(suffix) ?? 0) + 1);
   return suffixes.map((suffix, index) => counts.get(suffix) === 1 ? suffix : `#${index + 1}`);
 }
-function overviewRowLines(row2, width, selected, label, position, maxLines = 3) {
+function overviewMetrics(row2) {
   const valid2 = row2.freshness === "fresh" || row2.freshness === "stale";
   const percent = `${valid2 && row2.snapshot?.measurement?.confidence === "approximate" ? "~" : ""}${valid2 && row2.utilizationPercent !== undefined ? Math.round(row2.utilizationPercent) : "?"}%`;
   const context = `${row2.freshness === "stale" ? "Last measured " : ""}${percent}`;
   const distance = thresholdDistance(row2, true);
   const threshold = (distance === "At threshold \xB7 requires more" ? "At threshold; requires more" : distance).replace(" \xB7 Threshold reached", " \xB7 reached");
+  const metric2 = `${context} context \xB7 ${threshold}`;
+  const shortThreshold = threshold.replace("pressure unknown", "?").replace("At threshold; requires more", "At; needs more").replace(" \xB7 Near threshold", " near").replace(" \xB7 reached", " reached").replace("Threshold reached", "Reached");
+  const shortMetric = `${context} \xB7 T ${shortThreshold}`;
+  const pressure = row2.freshness !== "fresh" || row2.pressure === "unknown" ? "Threshold ?" : row2.pressure === "crossed" ? "Reached" : row2.triggerDeltaTokens === 0 ? "At; needs more" : row2.pressure === "near" ? "Near threshold" : "Below threshold";
+  const metrics = [metric2, shortMetric, `${context} \xB7 ${pressure}`];
+  return { percent, context, threshold, pressure, metrics };
+}
+function overviewRowHeight(row2, width, maxLines) {
+  const base = width >= 72 ? 1 : 2;
+  const exception = row2.freshness !== "fresh" || row2.node.status === "failed" || row2.node.interrupted || !!compactionLabel(row2) || row2.inventoryStale || row2.liveStale || row2.hidden > 0;
+  if (exception)
+    return Math.min(maxLines, base + 1);
+  if (width < 72 && !overviewMetrics(row2).metrics.some((line) => cells(line) <= width))
+    return Math.min(maxLines, base + 1);
+  return Math.min(maxLines, base);
+}
+function overviewRowLines(row2, width, selected, label, position, maxLines = 3) {
+  const { percent, context, threshold, pressure, metrics } = overviewMetrics(row2);
   const state = width < 28 ? {
     running: "RUN",
     idle: "IDLE",
@@ -2987,11 +3132,6 @@ function overviewRowLines(row2, width, selected, label, position, maxLines = 3)
   const indent = row2.depth && identityWidth >= 22 ? `${" ".repeat(Math.min(row2.depth, Math.max(0, Math.floor(identityWidth / 8) - 1)))}\u2514 ` : "";
   const name = `${row2.node.agent ?? "unknown agent"}${width >= 40 ? ` / ${row2.node.model ?? "unknown model"}` : ""}`;
   const identity = marker + indent + clip(name, Math.max(1, identityWidth - cells(marker + indent + tag))) + tag;
-  const metric2 = `${context} context \xB7 ${threshold}`;
-  const shortThreshold = threshold.replace("pressure unknown", "?").replace("At threshold; requires more", "At; needs more").replace(" \xB7 Near threshold", " near").replace(" \xB7 reached", " reached").replace("Threshold reached", "Reached");
-  const shortMetric = `${context} \xB7 T ${shortThreshold}`;
-  const pressure = row2.freshness !== "fresh" || row2.pressure === "unknown" ? "Threshold ?" : row2.pressure === "crossed" ? "Reached" : row2.triggerDeltaTokens === 0 ? "At; needs more" : row2.pressure === "near" ? "Near threshold" : "Below threshold";
-  const metrics = [metric2, shortMetric, `${context} \xB7 ${pressure}`];
   const fittedMetric = metrics.find((line) => cells(line) <= width);
   const lines = width >= 72 ? [
     overviewColumns(identity, state, row2.freshness === "stale" ? "Last" : percent, threshold, width)
@@ -3234,6 +3374,7 @@ import { isAbsolute as isAbsolute3 } from "path";
 class TerminalShell {
   controller;
   quit;
+  work = { formattedOverviewRows: 0 };
   scroll = 0;
   metric = 0;
   sample = 0;
@@ -3249,6 +3390,9 @@ class TerminalShell {
   rowOffset = 0;
   overviewScope = "";
   overviewPage = 1;
+  labelKey = "";
+  labels = [];
+  layouts = new Map;
   historyIdentity = "";
   constructor(controller, quit) {
     this.controller = controller;
@@ -3504,27 +3648,75 @@ class TerminalShell {
       const noticeBudget = Math.min(notices.length, Math.floor((available - heading.length) / 4));
       const status = notices.slice(0, noticeBudget).map((notice, index) => clip(index === noticeBudget - 1 && notices.length > noticeBudget ? `${notices.length} notices \xB7 see Details` : notice, width));
       const budget = Math.max(1, available - heading.length - status.length);
-      const labels = overviewLabels(view.rows);
-      const rows = view.rows.map((row2, index) => overviewRowLines(row2, width, row2.node.sessionId === view.selectedSessionId, labels[index] ?? `#${index + 1}`, index, budget));
+      const labelKey = view.rows.map((row2) => row2.node.sessionId).join("\0");
+      if (labelKey !== this.labelKey) {
+        this.labels = overviewLabels(view.rows);
+        this.labelKey = labelKey;
+      }
+      const ids = new Set(view.rows.map((row2) => row2.node.sessionId));
+      for (const id of this.layouts.keys())
+        if (!ids.has(id))
+          this.layouts.delete(id);
+      const heights = view.rows.map((row2) => {
+        const key = JSON.stringify([
+          width,
+          budget,
+          row2.node,
+          row2.depth,
+          row2.freshness,
+          row2.pressure,
+          row2.triggerDeltaTokens,
+          row2.utilizationPercent,
+          row2.snapshot?.measurement?.confidence,
+          row2.snapshot?.compaction,
+          row2.inventoryStale,
+          row2.liveStale,
+          row2.hidden
+        ]);
+        let layout = this.layouts.get(row2.node.sessionId);
+        if (!layout || layout.key !== key) {
+          layout = { key, height: overviewRowHeight(row2, width, budget) };
+          this.layouts.set(row2.node.sessionId, layout);
+        }
+        return layout.height;
+      });
       const selected = view.rows.findIndex((row2) => row2.node.sessionId === view.selectedSessionId);
-      const start = rows.slice(0, Math.max(0, selected)).reduce((n, row2) => n + row2.length, 0);
-      const end = start + (rows[selected]?.length ?? 0);
+      const start = heights.slice(0, Math.max(0, selected)).reduce((n, h) => n + h, 0);
+      const end = start + (heights[selected] ?? 0);
       if (start < this.rowOffset)
         this.rowOffset = start;
       if (end > this.rowOffset + budget)
         this.rowOffset = Math.max(start, end - budget);
-      const flat = rows.flat();
-      this.rowOffset = Math.max(0, Math.min(this.rowOffset, Math.max(0, flat.length - budget)));
-      let cursor = 0;
-      this.overviewPage = Math.max(1, rows.filter((row2) => {
-        const start2 = cursor;
-        cursor += row2.length;
-        return start2 >= this.rowOffset && cursor <= this.rowOffset + budget;
-      }).length);
+      const total = heights.reduce((n, h) => n + h, 0);
+      this.rowOffset = Math.max(0, Math.min(this.rowOffset, Math.max(0, total - budget)));
+      const visible = [];
+      let cursor = 0, page = 0;
+      for (const [index, row2] of view.rows.entries()) {
+        const rowHeight = heights[index] ?? 1;
+        if (cursor >= this.rowOffset && cursor + rowHeight <= this.rowOffset + budget)
+          page++;
+        if (cursor + rowHeight > this.rowOffset && cursor < this.rowOffset + budget) {
+          const layout = this.layouts.get(row2.node.sessionId);
+          const chosen = row2.node.sessionId === view.selectedSessionId;
+          const label = this.labels[index] ?? `#${index + 1}`;
+          if (layout) {
+            if (!layout.lines || layout.selected !== chosen || layout.label !== label || layout.position !== index) {
+              this.work.formattedOverviewRows++;
+              layout.lines = overviewRowLines(row2, width, chosen, label, index, budget);
+              layout.selected = chosen;
+              layout.label = label;
+              layout.position = index;
+            }
+            visible.push(...layout.lines.slice(Math.max(0, this.rowOffset - cursor), this.rowOffset + budget - cursor));
+          }
+        }
+        cursor += rowHeight;
+      }
+      this.overviewPage = Math.max(1, page);
       body = [
         ...status,
         ...heading,
-        ...flat.length ? flat.slice(this.rowOffset, this.rowOffset + budget) : [
+        ...total ? visible : [
           clip("No matching sessions; / search, f filters, r refresh.", width)
         ]
       ];
@@ -3569,7 +3761,7 @@ class TerminalShell {
   }
 }
 function mountTerminal(controller, renderer, text2, finished) {
-  let closed = false;
+  let closed = false, pendingDraw = false, drawing = false;
   let unsubscribe = () => {
   };
   const shutdown = (failed = false) => {
@@ -3600,25 +3792,38 @@ function mountTerminal(controller, renderer, text2, finished) {
   const onSignal = () => shutdown();
   const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
   const draw = () => {
-    if (closed)
+    if (closed || drawing)
       return;
+    pendingDraw = false;
+    drawing = true;
     try {
       text2.content = shell.frame(renderer.width, renderer.height);
     } catch {
       fail();
+    } finally {
+      drawing = false;
     }
   };
+  const scheduleDraw = () => {
+    if (pendingDraw || closed || drawing)
+      return;
+    pendingDraw = true;
+    queueMicrotask(() => {
+      if (pendingDraw)
+        draw();
+    });
+  };
   const key = (event) => {
     try {
       shell.key(event, Math.max(1, renderer.height - 4));
-      draw();
+      scheduleDraw();
     } catch {
       fail();
     }
   };
   const paste = (event) => {
     shell.paste(new TextDecoder().decode(event.bytes));
-    draw();
+    scheduleDraw();
   };
   try {
     renderer.root.add(text2);
@@ -3632,7 +3837,8 @@ function mountTerminal(controller, renderer, text2, finished) {
       process.on(signal, onSignal);
     process.on("uncaughtException", fail);
     process.on("unhandledRejection", fail);
-    unsubscribe = controller.subscribe(draw);
+    unsubscribe = controller.subscribe(scheduleDraw);
+    draw();
     if (closed) {
       unsubscribe();
       return { shell, shutdown };
@@ -3737,6 +3943,11 @@ function reconcile(a, b) {
   };
 }
 function analyzeModelRequests(records, options) {
+  const accumulator = createModelAccumulator(options);
+  accumulator.append(records);
+  return accumulator.result();
+}
+function createModelAccumulator(options) {
   const maxRequests = options.maxRequests ?? 1e5;
   if (!Number.isSafeInteger(maxRequests) || maxRequests < 1 || maxRequests > 1e6)
     throw new Error("maxRequests must be an integer from 1 to 1000000");
@@ -3747,7 +3958,7 @@ function analyzeModelRequests(records, options) {
       throw new Error("Invalid analytics timestamp");
   if (options.from !== undefined && options.to !== undefined && options.from > options.to)
     throw new Error("--from must precede --to");
-  const coverage = {
+  const counters = {
     source: "retained-request-records",
     scannedRecords: 0,
     unscannedRecords: 0,
@@ -3761,74 +3972,98 @@ function analyzeModelRequests(records, options) {
     partial: false
   };
   const requests = new Map;
-  for (const record2 of records) {
-    coverage.scannedRecords++;
-    if (record2.type === "gap") {
-      coverage.gapRecords++;
-      continue;
-    }
-    if (record2.type !== "request")
-      continue;
-    const fact = requestFact(record2);
-    if (!fact) {
-      coverage.missingIdentityRecords++;
-      continue;
-    }
-    fact.location = options.location;
-    const key = JSON.stringify([
-      fact.sessionId,
-      fact.requestId,
-      fact.startedAt
-    ]);
-    const previous = requests.get(key);
-    if (previous) {
-      coverage.duplicateRecords++;
-      const merged = reconcile(previous.fact, fact);
-      if (!merged)
-        previous.conflict = true;
-      else
-        previous.fact = merged;
-    } else {
-      if (requests.size === maxRequests) {
-        coverage.scannedRecords--;
-        coverage.unscannedRecords = records.length - coverage.scannedRecords;
+  let totalRecords = 0, stopped = false;
+  function append(records) {
+    totalRecords += records.length;
+    for (const record2 of records) {
+      if (stopped)
         break;
+      counters.scannedRecords++;
+      if (record2.type === "gap") {
+        counters.gapRecords++;
+        continue;
+      }
+      if (record2.type !== "request")
+        continue;
+      const fact = requestFact(record2);
+      if (!fact) {
+        counters.missingIdentityRecords++;
+        continue;
+      }
+      fact.location = options.location;
+      const key = JSON.stringify([
+        fact.sessionId,
+        fact.requestId,
+        fact.startedAt
+      ]);
+      const previous = requests.get(key);
+      if (previous) {
+        counters.duplicateRecords++;
+        const merged = reconcile(previous.fact, fact);
+        if (!merged)
+          previous.conflict = true;
+        else
+          previous.fact = merged;
+      } else {
+        if (requests.size === maxRequests) {
+          counters.scannedRecords--;
+          stopped = true;
+          break;
+        }
+        requests.set(key, { fact, conflict: false });
       }
-      requests.set(key, { fact, conflict: false });
     }
   }
-  const accepted = [];
-  for (const { fact: r, conflict } of requests.values()) {
-    if (conflict) {
-      coverage.conflictingRequests++;
-      continue;
-    }
-    if (r.completedAt === undefined) {
-      coverage.incompleteRequests++;
-      continue;
-    }
-    const duration = r.completedAt - r.startedAt;
-    if (!nonnegative2(r.completedAt) || !Number.isFinite(duration) || duration <= 0) {
-      coverage.invalidTimingRequests++;
-      continue;
+  function* steps() {
+    const coverage = {
+      ...counters,
+      unscannedRecords: totalRecords - counters.scannedRecords
+    };
+    const accepted = [];
+    for (const { fact: r, conflict } of requests.values()) {
+      yield;
+      if (conflict) {
+        coverage.conflictingRequests++;
+        continue;
+      }
+      if (r.completedAt === undefined) {
+        coverage.incompleteRequests++;
+        continue;
+      }
+      const duration = r.completedAt - r.startedAt;
+      if (!nonnegative2(r.completedAt) || !Number.isFinite(duration) || duration <= 0) {
+        coverage.invalidTimingRequests++;
+        continue;
+      }
+      if (options.from !== undefined && r.completedAt < options.from || options.to !== undefined && r.completedAt >= options.to || options.model !== undefined && r.model !== options.model || options.agent !== undefined && r.agent !== options.agent)
+        continue;
+      accepted.push({ ...r, completedAt: r.completedAt });
     }
-    if (options.from !== undefined && r.completedAt < options.from || options.to !== undefined && r.completedAt >= options.to || options.model !== undefined && r.model !== options.model || options.agent !== undefined && r.agent !== options.agent)
-      continue;
-    accepted.push({ ...r, completedAt: r.completedAt });
+    const models = yield* summarizeModelRequestSteps(accepted);
+    coverage.partial = coverage.unscannedRecords > 0 || coverage.conflictingRequests > 0 || coverage.missingIdentityRecords > 0 || coverage.incompleteRequests > 0 || coverage.invalidTimingRequests > 0 || coverage.gapRecords > 0 || models.some((s) => s.partialRequests > 0 || s.legacyAttributionRequests > 0 || s.excludedTpsRequests > 0 || s.excludedTtftRequests > 0 || !s.model);
+    return {
+      schemaVersion: 1,
+      location: options.location,
+      models,
+      coverage,
+      requests: accepted
+    };
   }
-  const models = summarizeModelRequests(accepted);
-  coverage.partial = coverage.unscannedRecords > 0 || coverage.conflictingRequests > 0 || coverage.missingIdentityRecords > 0 || coverage.incompleteRequests > 0 || coverage.invalidTimingRequests > 0 || coverage.gapRecords > 0 || models.some((s) => s.partialRequests > 0 || s.legacyAttributionRequests > 0 || s.excludedTpsRequests > 0 || s.excludedTtftRequests > 0 || !s.model);
-  return {
-    schemaVersion: 1,
-    location: options.location,
-    models,
-    coverage,
-    requests: accepted
-  };
+  return { append, steps, result: () => finishSteps(steps()) };
+}
+function finishSteps(steps) {
+  let step = steps.next();
+  while (!step.done)
+    step = steps.next();
+  return step.value;
 }
 function summarizeModelRequests(requests) {
+  return finishSteps(summarizeModelRequestSteps(requests));
+}
+function* summarizeModelRequestSteps(requests) {
   const groups = new Map;
   for (const r of requests) {
+    yield;
     const duration = r.completedAt - r.startedAt;
     let group = groups.get(r.model);
     if (!group) {