@cesarus777/opencode-cgp 0.4.0 → 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
@@ -936,6 +1015,51 @@ function executionStatus(known, nativeRunning, evidence) {
   return known ? "idle" : "unknown";
 }
 
+// src/historyclient.ts
+function historyFailure(error, signal) {
+  if (signal?.aborted && signal.reason instanceof DOMException && signal.reason.name === "TimeoutError" || error instanceof DOMException && error.name === "TimeoutError")
+    return new HistoryFailure("timeout");
+  if (error instanceof HistoryFailure)
+    return error;
+  const code = typeof error === "object" && error !== null && "type" in error ? error.type : undefined;
+  return new HistoryFailure(code === "rpc.unavailable" || code === "rpc.method_not_found" ? "unsupported" : code === "rpc.invalid_output" ? "incompatible" : code === "rpc.invalid_input" ? "rejected" : "unavailable");
+}
+function checkedHistory(value, sessionId) {
+  if (!isHistoryResult(value) || value.data.series.some((series) => series.sessionId !== sessionId))
+    throw new HistoryFailure("incompatible");
+  return value;
+}
+function historyStatusLines(input) {
+  const messages = {
+    unsupported: "History service is unavailable in this server location. Check that the owning server has a plugin version with chart history. Press r to check again.",
+    timeout: "History request timed out. Press r to retry.",
+    incompatible: "History response is incompatible. Check client/server plugin versions. Press r to retry.",
+    rejected: "History request was rejected. Check client/server plugin versions. Press r to retry.",
+    unavailable: "History could not be loaded. Press r to retry."
+  };
+  return [
+    ...input.status === "loading" ? [
+      input.loadedAt === undefined ? "Loading retained history\u2026" : "Updating history \xB7 showing previous results"
+    ] : input.status === "disabled" ? [
+      "History recording is disabled in this server location. Press r to check again after configuration changes."
+    ] : input.status === "unavailable" ? [messages[input.reason ?? "unavailable"]] : [],
+    ...input.stale && input.loadedAt !== undefined ? [
+      `Showing previous results \xB7 last loaded ${new Date(input.loadedAt).toISOString()}`
+    ] : []
+  ];
+}
+var HistoryFailure;
+var init_historyclient = __esm(() => {
+  init_rpc();
+  HistoryFailure = class HistoryFailure extends Error {
+    reason;
+    constructor(reason) {
+      super(`History ${reason}`);
+      this.reason = reason;
+    }
+  };
+});
+
 // src/tui/transport.ts
 class SnapshotClient {
   transport;
@@ -1216,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;
@@ -1224,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)
@@ -1542,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);
@@ -1603,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;
@@ -1628,6 +1767,7 @@ class DashboardController {
   pendingHistory;
   historyAbort;
   historyBusy = false;
+  historyReason;
   historyStatus = "idle";
   refreshTimer;
   ageTimer;
@@ -1814,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));
@@ -1889,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();
@@ -1919,6 +2092,7 @@ class DashboardController {
   }
   cancelHistory() {
     this.historyGeneration++;
+    this.historyReason = undefined;
     this.pendingHistory = undefined;
     this.historyAbort?.abort();
   }
@@ -1972,10 +2146,10 @@ class DashboardController {
       }, signal);
       if (signal.aborted || task.generation !== this.historyGeneration)
         return;
-      if (!isHistoryResult(result) || result.data.series.some((series) => series.sessionId !== task.sessionId))
-        throw new Error("Invalid history response");
+      checkedHistory(result, task.sessionId);
       this.cache.set(task.key, {
         directory: task.state.port.location.directory,
+        loadedAt: this.now(),
         valid: true,
         result: structuredClone(result),
         from,
@@ -1987,12 +2161,16 @@ class DashboardController {
           this.cache.delete(oldest);
       }
       this.historyStatus = result.enabled ? "ready" : "disabled";
-    } catch {
-      if (task.generation === this.historyGeneration && !task.scope.aborted)
+    } catch (error) {
+      if (task.generation === this.historyGeneration && !task.scope.aborted) {
         this.historyStatus = "unavailable";
+        this.historyReason = historyFailure(error, signal).reason;
+      }
     } finally {
-      if (task.generation === this.historyGeneration && signal.aborted && !task.scope.aborted)
+      if (task.generation === this.historyGeneration && signal.aborted && !task.scope.aborted) {
         this.historyStatus = "unavailable";
+        this.historyReason = historyFailure(undefined, signal).reason;
+      }
       this.historyBusy = false;
       if (this.historyAbort === controller)
         this.historyAbort = undefined;
@@ -2077,12 +2255,13 @@ class DashboardController {
       ...selected ? { selected } : {},
       history: {
         status: this.historyStatus,
+        ...this.historyReason ? { reason: this.historyReason } : {},
         windowMs: this.windowMs,
         maxWindowMs: 604800000,
         maxPoints: 500,
         stale: this.historyStatus === "loading" || this.historyStatus === "unavailable" || !this.running,
         ...state.selected ? { sessionId: state.selected } : {},
-        ...cached ? { from: cached.from, to: cached.to } : {},
+        ...cached ? { from: cached.from, to: cached.to, loadedAt: cached.loadedAt } : {},
         ...projected ? { result: projected.result, summary: projected.summary } : {},
         notices: projected?.notices ?? [
           "bounded-retention",
@@ -2100,7 +2279,7 @@ class DashboardController {
   }
 }
 var init_controller = __esm(() => {
-  init_rpc();
+  init_historyclient();
   init_transport();
   init_inventory();
   init_models();
@@ -2272,13 +2451,12 @@ async function connectDashboard(options, discovery = Service) {
       async history(input, signal) {
         if (!isHistoryRead(input))
           throw new Error("History requires one session, at most seven days and 16\u2013500 points");
+        const requestSignal = deadline(signal);
         try {
-          const result = await client.rpc(historyRpc).read(input, { location, signal: deadline(signal) });
-          if (!isHistoryResult(result))
-            throw new Error;
-          return result;
-        } catch {
-          throw new Error("Context Guard history unavailable or incompatible in this location");
+          const result = await client.rpc(historyRpc).read(input, { location, signal: requestSignal });
+          return checkedHistory(result, input.sessionId);
+        } catch (error) {
+          throw historyFailure(error, requestSignal);
         }
       }
     };
@@ -2295,10 +2473,214 @@ async function connectDashboard(options, discovery = Service) {
   };
 }
 var init_connection = __esm(() => {
+  init_historyclient();
   init_rpc();
   init_port();
 });
 
+// src/tui/quantity.ts
+function tokens(value) {
+  if (value === undefined || !Number.isFinite(value))
+    return "?";
+  const magnitude = Math.abs(value);
+  if (magnitude >= 1e6)
+    return `${+(value / 1e6).toFixed(1)}M`;
+  if (magnitude >= 1000)
+    return `${+(value / 1000).toFixed(1)}K`;
+  return String(value);
+}
+
+// src/tui/statusformat.ts
+function freshnessLabel(row2) {
+  switch (row2?.freshness) {
+    case "fresh":
+      return;
+    case "stale":
+      return "Measurement out of date";
+    case "invalid":
+      return "Usage unavailable";
+    default:
+      return "Usage unknown";
+  }
+}
+function measurementLabel(row2, ageMs) {
+  const m = row2?.snapshot?.measurement;
+  if (!m || row2?.freshness === "missing")
+    return "Usage unknown";
+  if (row2?.freshness === "invalid")
+    return "Usage unavailable";
+  const age = ageMs === undefined ? "" : ` \xB7 measured ${Math.floor(Math.max(0, ageMs) / 1000)}s ago`;
+  return `${m.confidence === "reported" ? "Provider reported" : "Estimated"}${age}${row2?.freshness === "stale" ? " \xB7 out of date" : ""}`;
+}
+function measurementExplanation(row2) {
+  const m = row2.snapshot?.measurement;
+  if (!m || row2.freshness === "missing")
+    return ["No measurement available."];
+  if (row2.freshness === "invalid")
+    return ["Measurement cannot be used for this session."];
+  return [
+    m.scope === "completed-request" ? "Usage from the last completed request; not the next request's size." : "Usage for the prepared request; not a completed request.",
+    m.provenance === "serialized-estimate" ? "Estimate from serialized request content." : "Provider usage includes input and cache tokens."
+  ];
+}
+function compactionLabel(row2, compact = false) {
+  const phase = row2?.snapshot?.compaction.phase;
+  if (!phase || phase === "idle")
+    return;
+  if (compact)
+    return {
+      requesting: "Requesting",
+      accepted: "Waiting",
+      running: "Compacting",
+      "awaiting-measurement": "Checking",
+      blocked: "Retry held",
+      uncertain: "Unconfirmed"
+    }[phase];
+  return {
+    requesting: "Requesting compaction",
+    accepted: "Compaction request accepted \xB7 waiting to start",
+    running: "Compaction running",
+    "awaiting-measurement": "Compaction ended \xB7 checking context reduction",
+    blocked: "Automatic compaction retry suppressed",
+    uncertain: "Completion unconfirmed \xB7 automatic retry suppressed"
+  }[phase];
+}
+function reasonExplanation(reason) {
+  switch (reason) {
+    case "below-threshold":
+      return "Context is below the policy threshold.";
+    case "threshold-crossed":
+      return "Context reached the policy threshold; this does not guarantee compaction.";
+    case "missing-usage":
+      return "No measurement available for the policy decision.";
+    case "model-changed":
+      return "The measurement belongs to a different model.";
+    case "invalid-usage":
+      return "The measurement cannot be used for the policy decision.";
+    case "stale-usage":
+      return "The policy measurement is out of date.";
+    case "missing-model-budget":
+      return "Model capacity is unavailable for this threshold.";
+    case "incompatible-model-budget":
+      return "The threshold is incompatible with model capacity.";
+    case "compaction-failed":
+      return "Compaction failed; automatic retries are limited after repeated failures.";
+    case "reclaim-unverifiable":
+      return "Context reduction could not be verified with comparable provider readings.";
+    case "insufficient-reclaim":
+      return "Measured context reduction was below the required minimum.";
+    case "admission-outcome-unknown":
+      return "Whether the compaction request was accepted is unconfirmed.";
+    case "completion-event-timeout":
+      return "No confirming completion event arrived within the waiting period.";
+    case "restart-needs-lifecycle-evidence":
+      return "The previous request needs confirming lifecycle evidence after restart.";
+    case "event-stream-gap":
+      return "Automatic requests are suspended after an event gap; reload required.";
+    case "persistence-unavailable":
+      return "Safety storage is unavailable; repair storage and reload.";
+    case "capacity-exceeded":
+      return "Monitoring limit reached; some sessions are unavailable.";
+    case "model-metadata-unavailable":
+      return "Some model limits are unavailable.";
+    default:
+      return "See diagnostic codes.";
+  }
+}
+function pressureLabel(row2) {
+  if (row2?.freshness !== "fresh")
+    return "Threshold pressure unknown";
+  switch (row2.pressure) {
+    case "crossed":
+      return "Threshold reached";
+    case "near":
+      return "Near threshold";
+    case "normal":
+      return "Below threshold";
+    default:
+      return "Threshold pressure unknown";
+  }
+}
+function thresholdDistance(row2, compact = false) {
+  const delta = row2?.triggerDeltaTokens;
+  if (row2?.freshness !== "fresh" || row2.pressure === "unknown" || delta === undefined || !Number.isFinite(delta))
+    return "pressure unknown";
+  if (delta === 0)
+    return row2.pressure === "crossed" ? "Threshold reached" : "At threshold \xB7 requires more";
+  if (compact)
+    return `${tokens(Math.abs(delta))} ${delta < 0 ? "over" : "below"}${row2.pressure === "near" ? " \xB7 Near threshold" : delta < 0 ? " \xB7 Threshold reached" : ""}`;
+  return `${tokens(Math.abs(delta))} ${Math.abs(delta) === 1 ? "token" : "tokens"} ${delta < 0 ? "over" : "below"} threshold`;
+}
+function guardStatusLines(health, compact = false) {
+  switch (health?.enforcement) {
+    case "observing":
+      return compact ? ["Observing", "No Guard compact"] : ["Observing \xB7 Guard won't request compaction"];
+    case "available":
+      return compact ? ["Guard requests", "enabled"] : ["Guard automatic requests enabled"];
+    case "disabled":
+      return ["Guard disabled"];
+    case "suspended": {
+      const gap = health.reasons.includes("event-stream-gap");
+      const storage = health.reasons.includes("persistence-unavailable");
+      return compact ? [
+        "Guard suspended",
+        ...storage ? ["Storage: repair"] : [],
+        ...gap ? ["Reload required"] : storage ? ["Then reload"] : ["See Details"]
+      ] : [
+        "Guard suspended" + (storage ? " \xB7 safety storage unavailable; repair storage and reload" : "") + (gap ? " \xB7 reload required" : storage ? "" : " \xB7 see Details")
+      ];
+    }
+    default:
+      return ["Guard status unknown"];
+  }
+}
+function panelStatus(health) {
+  return guardStatusLines(health).join(" \xB7 ");
+}
+function connectionLabel(connection, compact = false) {
+  switch (connection) {
+    case "loading":
+      return "Connecting";
+    case "live":
+      return "Live";
+    case "reconnecting":
+      return "Reconnecting";
+    case "unavailable":
+      return compact ? "Unavailable" : "Connection unavailable";
+    case "incompatible":
+      return compact ? "Unsupported" : "Monitoring unsupported";
+  }
+}
+function connectionNotice(connection, retainedMeasurements, compact = false) {
+  if (connection === "live")
+    return;
+  return retainedMeasurements ? compact ? "Last data shown" : "Showing last received measurements" : compact ? "No measurements" : "No measurements available";
+}
+function monitorStatusLines(connection, health, retainedMeasurements, compact = false) {
+  const notice = connectionNotice(connection, retainedMeasurements, compact);
+  const reasons = health?.reasons ?? [];
+  const limited = reasons.includes("capacity-exceeded");
+  const model = reasons.includes("model-metadata-unavailable");
+  const attention = health?.enforcement !== "suspended" && reasons.length > 0;
+  return [
+    ...health && connection !== "live" ? [compact ? "Last known:" : "Last known Guard:"] : [],
+    ...guardStatusLines(health, compact),
+    ...attention ? compact ? [limited ? "Monitor limit" : model ? "Limits unknown" : "See Details"] : [
+      ...limited ? ["Monitoring limit reached \xB7 some sessions unavailable"] : [],
+      ...model ? ["Some model limits unavailable \xB7 context may be unknown"] : [],
+      ...!limited && !model ? ["Guard needs attention \xB7 see Details"] : []
+    ] : [],
+    ...notice ? [notice] : []
+  ];
+}
+var contextHistoryLegend;
+var init_statusformat = __esm(() => {
+  contextHistoryLegend = [
+    "Recent samples \u2192 now \xB7 \u2504 threshold",
+    "Dim = last known context"
+  ];
+});
+
 // src/tui/format.ts
 function quantity(n) {
   return n === undefined || !Number.isFinite(n) ? "?" : Math.abs(n) >= 1e6 ? `${(n / 1e6).toFixed(1)}m` : Math.abs(n) >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
@@ -2326,22 +2708,6 @@ function clip(value, width) {
   }
   return width < 3 ? ".".repeat(Math.max(0, width)) : result + "...";
 }
-function rowLines(row2, width) {
-  const s = row2.snapshot, m = s?.measurement;
-  const prefix = row2.current ? "* " : row2.depth > 5 ? ".../" : " ".repeat(Math.min(row2.depth, 5)) + "|-";
-  const percent = row2.utilizationPercent === undefined ? "?" : `${row2.utilizationPercent.toFixed(1)}%`;
-  const warning = row2.freshness === "stale" ? " STALE" : row2.pressure === "crossed" ? " !! crossed" : row2.pressure === "near" ? " ! near" : "";
-  const suffix = ` ${statuses[row2.node.status]} ${m?.confidence === "approximate" ? "~" : ""}${percent}${warning}`;
-  const label = clip(`${prefix}${row2.node.agent ?? row2.node.sessionId}`, Math.max(1, width - cells(suffix)));
-  return [
-    clip(`${label}${suffix}`, width),
-    ...performanceLines(row2, width),
-    ...wrap(`${quantity(m?.tokens)}/${quantity(s?.capacityTokens)} input; to ${quantity(row2.triggerDeltaTokens)}`, width),
-    ...s && s.compaction.phase !== "idle" ? wrap(`compact: ${s.compaction.phase}`, width) : [],
-    ...row2.node.interrupted ? [clip("interrupted", width)] : [],
-    ...row2.hidden ? wrap(`+ ${row2.hidden} completed descendants`, width) : []
-  ];
-}
 function detailLines(row2, width, expanded = false, ageMs = 0) {
   const s = row2?.snapshot, m = s?.measurement;
   if (!row2)
@@ -2352,22 +2718,29 @@ function detailLines(row2, width, expanded = false, ageMs = 0) {
       ...wrap("Guard: not monitored / unavailable", width)
     ];
   const threshold = s.policy.configured;
-  const headroom = row2.triggerDeltaTokens;
+  const valid2 = row2.freshness === "fresh" || row2.freshness === "stale";
   const lines = [
     `${s.agent ?? "?"} / ${s.model ?? "?"}`,
+    `${row2.freshness === "stale" ? "Last measured" : "Context"} ${valid2 && m?.confidence === "approximate" ? "~" : ""}${quantity(valid2 ? m?.tokens : undefined)} / ${quantity(s.capacityTokens)} input`,
+    `${valid2 ? row2.utilizationPercent?.toFixed(1) ?? "?" : "?"}% capacity \xB7 ${pressureLabel(row2)}`,
+    `Threshold ${quantity(s.policy.triggerTokens)} \xB7 ${thresholdDistance(row2)}`,
+    measurementLabel(row2, ageMs),
+    ...measurementExplanation(row2),
+    compactionLabel(row2) ?? "No compaction request in progress.",
+    ...s.compaction.blockedReason ? [reasonExplanation(s.compaction.blockedReason)] : [],
+    `Recorded policy decision: ${reasonExplanation(s.policy.reason)}`,
     ...performanceLines(row2, width),
-    `${m?.confidence === "approximate" ? "~" : ""}${quantity(m?.tokens)} / ${quantity(s.capacityTokens)} input`,
-    `${row2.utilizationPercent?.toFixed(1) ?? "?"}% ${row2.pressure === "crossed" ? "!! crossed" : row2.pressure === "near" ? "! near" : row2.freshness.toUpperCase()}`,
-    `Trigger ${threshold.type === "ratio" ? `${threshold.value * 100}%` : `${threshold.value} ${threshold.type}`} (${s.policy.comparison})`,
-    `Resolved trigger ${s.policy.triggerTokens ?? "?"}`,
-    `Until trigger ${quantity(headroom)}`,
-    `Compact: ${s.compaction.phase}`,
-    `${s.compaction.armed ? "armed" : "disarmed"}${s.compaction.blockedReason ? ` / ${s.compaction.blockedReason}` : ""}`,
-    m ? `${m.confidence} ${m.scope}` : "measurement unknown",
-    m ? `${Math.floor(Math.max(0, ageMs) / 1000)}s ago; ${row2.freshness}` : ""
+    ...s.performance ? [
+      "TPS: tokens per second. TTFT: time to first output (text or reasoning); approximate.",
+      "Live TPS is estimated; completed rates use provider output including reasoning and matched timing.",
+      "Model average uses matched request durations; session average includes idle and tool time.",
+      ...s.performance.partial ? [
+        "Incomplete timing coverage for model averages; only matched observed durations are included."
+      ] : []
+    ] : []
   ];
   if (expanded)
-    lines.push(`Policy ${s.policy.id}: ${s.policy.reason}`, `Limits in/context/out ${quantity(s.limits?.input)}/${quantity(s.limits?.context)}/${quantity(s.limits?.output)}`, `Output reserve ${quantity(s.outputReserveTokens)}`, `Provenance ${m?.provenance ?? "?"}`, `Cooldown until ${s.compaction.cooldownUntil ?? "?"}`, `Cumulative (${s.cumulativeScope})`, `Input ${quantity(s.cumulative?.input)} output ${quantity(s.cumulative?.output)}`, `Reasoning ${quantity(s.cumulative?.reasoning)}`, `Cache read ${quantity(s.cumulative?.cache.read)} write ${quantity(s.cumulative?.cache.write)}`);
+    lines.push("Diagnostic codes and accounting:", `Compaction phase: ${s.compaction.phase}`, `Armed: ${s.compaction.armed} (one eligibility condition, not permission to compact)`, `Blocked reason: ${s.compaction.blockedReason ?? "?"}`, `Measurement confidence: ${m?.confidence ?? "?"}`, `Measurement scope: ${m?.scope ?? "?"}`, `Measurement freshness: ${row2.freshness}`, `Trigger ${threshold.type === "ratio" ? `${threshold.value * 100}%` : `${threshold.value} ${threshold.type}`} (${s.policy.comparison})`, `Resolved trigger ${s.policy.triggerTokens ?? "?"}`, `Policy ${s.policy.id}: ${s.policy.reason}`, `Pressure code: ${row2.pressure}`, `Recorded tokens: ${quantity(m?.tokens)}`, `Limits in/context/out ${quantity(s.limits?.input)}/${quantity(s.limits?.context)}/${quantity(s.limits?.output)}`, `Output reserve ${quantity(s.outputReserveTokens)}`, `Provenance ${m?.provenance ?? "?"}`, `Cooldown until ${s.compaction.cooldownUntil ?? "?"}`, `Cumulative (${s.cumulativeScope})`, `Input ${quantity(s.cumulative?.input)} output ${quantity(s.cumulative?.output)}`, `Reasoning ${quantity(s.cumulative?.reasoning)}`, `Cache read ${quantity(s.cumulative?.cache.read)} write ${quantity(s.cumulative?.cache.write)}`);
   return lines.filter(Boolean).flatMap((line) => wrap(line, width));
 }
 function sanitize(value) {
@@ -2404,16 +2777,10 @@ function performanceLines(row2, width) {
     ...wrap(`TTFT ${p.ttftMs === undefined ? "?" : `~${(p.ttftMs / 1000).toFixed(2)}s`}${p.latestRequestTps === undefined ? "" : ` \xB7 Last ${value(p.latestRequestTps)} t/s`}`, width)
   ];
 }
-var segmenter, statuses;
+var segmenter;
 var init_format = __esm(() => {
+  init_statusformat();
   segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-  statuses = {
-    running: "RUN",
-    idle: "IDLE",
-    completed: "DONE",
-    failed: "FAIL",
-    unknown: "?"
-  };
 });
 
 // src/tui/chartformat.ts
@@ -2627,11 +2994,170 @@ var init_modelview = __esm(() => {
   ];
 });
 
+// src/tui/panelformat.ts
+function panelSummary(row2, width, age, compact = false) {
+  if (!row2)
+    return [clip("No sessions available \xB7 r refresh", width)];
+  const snapshot = row2.snapshot;
+  const valid2 = row2.freshness === "fresh" || row2.freshness === "stale";
+  const prefix = row2.freshness === "stale" ? "Last measured" : "Context";
+  const percent = `${row2.utilizationPercent === undefined ? "?" : Math.round(row2.utilizationPercent)}%`;
+  const estimate = valid2 && snapshot?.measurement?.confidence === "approximate" ? "~" : "";
+  const identity = `${width < 28 ? ">" : "Selected:"} ${row2.node.agent ?? row2.node.sessionId}${row2.current ? width < 28 ? " *" : " (current)" : ""}`;
+  const threshold = `Threshold ${tokens(snapshot?.policy.triggerTokens)} \xB7 ${thresholdDistance(row2)}`;
+  const occupancy = compact ? `${prefix} ${estimate}${percent}` : `${prefix} ${estimate}${tokens(valid2 ? snapshot?.measurement?.tokens : undefined)}/${tokens(snapshot?.capacityTokens)} \xB7 ${percent}`;
+  return [
+    clip(identity, width),
+    clip(occupancy, width),
+    ...!compact ? [
+      clip(cells(threshold) <= width ? threshold : thresholdDistance(row2), width),
+      clip(`${row2.node.model ?? snapshot?.model ?? "Model unknown"} \xB7 ${panelStatuses[row2.node.status]}`, width),
+      ...wrap(measurementLabel(row2, age), width)
+    ] : []
+  ];
+}
+function tableLine(identity, status, context, threshold, width) {
+  const pad = (value, size) => {
+    const text2 = clip(value, size);
+    return text2 + " ".repeat(Math.max(0, size - cells(text2)));
+  };
+  return `${pad(identity, width - 47)} ${pad(status, 8)} ${pad(context, 7)} ${pad(threshold, 29)}`;
+}
+function panelRowHeading(label, width) {
+  return width >= 72 ? tableLine(label, "State", "Context", "Threshold", width) : clip(label, width);
+}
+function panelRowLines(row2, width, selected) {
+  const marker = `${selected ? ">" : " "}${row2.current ? "*" : " "}`;
+  const indent = " ".repeat(Math.min(row2.depth, Math.floor(width / 24))) + (row2.depth ? "\u2514 " : "");
+  const identity = `${marker} ${indent}${row2.node.agent ?? row2.node.sessionId}`;
+  const percent = `${(row2.freshness === "fresh" || row2.freshness === "stale") && row2.snapshot?.measurement?.confidence === "approximate" ? "~" : ""}${row2.utilizationPercent === undefined ? "?" : Math.round(row2.utilizationPercent)}%`;
+  const status = width < 28 ? {
+    running: "RUN",
+    idle: "IDLE",
+    completed: "DONE",
+    failed: "FAIL",
+    unknown: "?"
+  }[row2.node.status] : panelStatuses[row2.node.status];
+  const distance = thresholdDistance(row2, true);
+  const pad = (value, size) => {
+    const text2 = clip(value, size);
+    return text2 + " ".repeat(Math.max(0, size - cells(text2)));
+  };
+  const lines = width >= 72 ? [tableLine(identity, status, percent, distance, width)] : [
+    `${pad(identity, Math.max(1, width - status.length - 1))} ${status}`,
+    clip(`${percent} context \xB7 ${distance}`, width)
+  ];
+  const exception = [
+    freshnessLabel(row2),
+    compactionLabel(row2),
+    row2.node.interrupted ? "interrupted" : "",
+    row2.hidden ? `+${row2.hidden} hidden \xB7 Space expands` : ""
+  ].filter(Boolean).join(" \xB7 ");
+  if (exception)
+    lines.push(...wrap(exception, width));
+  return lines.map((line) => clip(line, width));
+}
+var panelStatuses;
+var init_panelformat = __esm(() => {
+  init_format();
+  init_statusformat();
+  init_statusformat();
+  panelStatuses = {
+    running: "RUNNING",
+    idle: "IDLE",
+    completed: "DONE",
+    failed: "FAILED",
+    unknown: "UNKNOWN"
+  };
+});
+
 // src/dashboard/terminalview.ts
-function overviewRow(row2) {
+function diagnosticRow(row2) {
   const s = row2.snapshot;
   const valid2 = row2.freshness === "fresh" || row2.freshness === "stale";
-  return `${" ".repeat(Math.min(row2.depth, 12))}${row2.depth ? "\u2514 " : ""}${row2.node.agent ?? "unknown agent"} / ${row2.node.model ?? "unknown model"} [${row2.node.sessionId}] ${row2.node.status} | prompt ${quantity(valid2 ? s?.measurement?.tokens : undefined)}/${quantity(s?.capacityTokens)} | occupancy ${row2.utilizationPercent?.toFixed(1) ?? "?"}% | trigger ${quantity(s?.policy.triggerTokens)} headroom ${quantity(row2.triggerDeltaTokens)} | pressure ${row2.pressure} | compact ${s?.compaction.phase ?? "unavailable"} | performance ${s?.performance?.status ?? "unavailable"} | live TPS ${quantity(row2.performanceAvailable && row2.performanceFreshness !== "invalid" ? s?.performance?.liveTps : undefined)} | age ${row2.measurementAgeMs === undefined ? "unknown" : `${Math.floor(row2.measurementAgeMs / 1000)}s`} | inventory ${row2.inventoryStale ? "stale" : "fresh"}, live ${row2.liveStale ? "stale" : "fresh"}, usage ${row2.freshness}, performance ${row2.performanceFreshness}${s?.measurement?.confidence === "approximate" ? " estimated" : ""}${s?.performance?.tokenSource === "estimated" ? " estimated TPS" : ""}${s?.performance?.partial ? " partial" : ""}${row2.hidden ? ` | ${row2.hidden} hidden descendants` : ""}`;
+  return `${" ".repeat(Math.min(row2.depth, 12))}${row2.depth ? "\u2514 " : ""}${row2.node.agent ?? "unknown agent"} / ${row2.node.model ?? "unknown model"} [${row2.node.sessionId}] ${row2.node.status} | ${row2.freshness === "stale" ? "Last measured" : "Context"} ${quantity(valid2 ? s?.measurement?.tokens : undefined)}/${quantity(s?.capacityTokens)} | occupancy ${row2.utilizationPercent?.toFixed(1) ?? "?"}% | threshold ${quantity(s?.policy.triggerTokens)} \xB7 ${thresholdDistance(row2)} | ${pressureLabel(row2)} | compact ${s?.compaction.phase ?? "unavailable"} | performance ${s?.performance?.status ?? "unavailable"} | live TPS ${quantity(row2.performanceAvailable && row2.performanceFreshness !== "invalid" ? s?.performance?.liveTps : undefined)} | age ${row2.measurementAgeMs === undefined ? "unknown" : `${Math.floor(row2.measurementAgeMs / 1000)}s`} | inventory ${row2.inventoryStale ? "stale" : "fresh"}, live ${row2.liveStale ? "stale" : "fresh"}, usage ${row2.freshness}, performance ${row2.performanceFreshness}${s?.measurement?.confidence === "approximate" ? " estimated" : ""}${s?.performance?.tokenSource === "estimated" ? " estimated TPS" : ""}${s?.performance?.partial ? " partial" : ""}${row2.hidden ? ` | ${row2.hidden} hidden descendants` : ""}`;
+}
+function pad(value, width) {
+  const text2 = clip(value, width);
+  return text2 + " ".repeat(Math.max(0, width - cells(text2)));
+}
+function overviewColumns(identity, state, context, threshold, width) {
+  return `${pad(identity, width - 44)} ${pad(state, 7)} ${pad(context, 7)} ${pad(threshold, 27)}`;
+}
+function overviewHeading(width) {
+  return width >= 72 ? [overviewColumns("Agent / model", "State", "Context", "Threshold", width)] : [];
+}
+function overviewLabels(rows) {
+  const segmenter2 = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+  const suffixes = rows.map((row2) => [...segmenter2.segment(clip(row2.node.sessionId, 4096))].slice(-8).map((part) => part.segment).join(""));
+  const counts = new Map;
+  for (const suffix of suffixes)
+    counts.set(suffix, (counts.get(suffix) ?? 0) + 1);
+  return suffixes.map((suffix, index) => counts.get(suffix) === 1 ? suffix : `#${index + 1}`);
+}
+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",
+    completed: "DONE",
+    failed: "FAIL",
+    unknown: "?"
+  }[row2.node.status] : panelStatuses[row2.node.status];
+  const identityWidth = width >= 72 ? width - 44 : Math.max(1, width - cells(state) - 1);
+  const marker = selected ? "> " : "  ";
+  const tag = width >= 100 ? ` [${label}]` : ` #${position + 1}`;
+  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 fittedMetric = metrics.find((line) => cells(line) <= width);
+  const lines = width >= 72 ? [
+    overviewColumns(identity, state, row2.freshness === "stale" ? "Last" : percent, threshold, width)
+  ] : [`${pad(identity, identityWidth)} ${state}`, fittedMetric ?? context];
+  const lifecycle = compactionLabel(row2);
+  const exceptions = [
+    ...width >= 72 && row2.freshness === "stale" ? [context] : [],
+    ...width < 72 && !fittedMetric ? [pressure] : [],
+    ...row2.node.status === "failed" ? ["Agent failed"] : [],
+    ...row2.node.interrupted ? ["Interrupted"] : [],
+    ...lifecycle ? [cells(lifecycle) <= width - 6 ? lifecycle : compactionLabel(row2, true)] : [],
+    ...row2.freshness !== "fresh" ? [freshnessLabel(row2)] : [],
+    ...row2.inventoryStale ? ["Inventory stale"] : [],
+    ...row2.liveStale ? ["Live data stale"] : [],
+    ...row2.hidden ? [`${row2.hidden} hidden descendants`] : []
+  ].filter((value) => value !== undefined);
+  if (exceptions.length) {
+    let shown = 1;
+    let text2 = exceptions[0] ?? "";
+    while (shown < exceptions.length && cells(text2 + " \xB7 " + exceptions[shown]) <= width - 6) {
+      text2 += " \xB7 " + exceptions[shown++];
+    }
+    const more = shown < exceptions.length ? ` +${exceptions.length - shown}` : "";
+    lines.push(clip(text2, Math.max(0, width - cells(more))) + more);
+  }
+  return lines.slice(0, Math.max(1, maxLines)).map((line) => clip(line, width));
 }
 function pathValue(object2, path) {
   let value = object2;
@@ -2646,8 +3172,11 @@ function terminalDetail(row2) {
   if (!row2)
     return ["No selected session; choose one in overview."];
   return [
-    overviewRow(row2),
     `Session ID: ${row2.node.sessionId}`,
+    ...detailLines(row2, 4096, false, row2.measurementAgeMs),
+    ...row2.node.interrupted ? ["Agent execution interrupted"] : [],
+    "Diagnostic codes and accounting:",
+    diagnosticRow(row2),
     `Parent ID: ${row2.node.parentId ?? "unknown/unavailable"}`,
     "All snapshot fields (timestamps are Unix milliseconds):",
     ...snapshotFields.map((path) => `${path}: ${scalar(pathValue(row2.snapshot, path))}`),
@@ -2656,6 +3185,8 @@ function terminalDetail(row2) {
 }
 function historyObservations(view, metricIndex) {
   const metric2 = chartMetrics[metricIndex] ?? chartMetrics[0];
+  if (!view.history.result?.enabled)
+    return [];
   return view.history.result?.data.series.flatMap((series) => metric2.source === "points" ? series.points.map((point) => ({
     time: point.time,
     value: point[metric2.key],
@@ -2684,14 +3215,15 @@ function terminalHistory(view, width, metricIndex, sample) {
   ];
   const selected = observations[Math.min(sample, Math.max(0, observations.length - 1))];
   return [
-    `History: ${h.status}${h.stale ? " \xB7 stale cached results" : ""} \xB7 ${h.windowMs / 60000} minutes \xB7 ${metric2.label} (${metric2.unit})`,
+    `History: ${h.status} \xB7 ${h.windowMs / 60000} minutes \xB7 ${metric2.label} (${metric2.unit})`,
+    ...historyStatusLines(h),
     "Left/Right metric \xB7 w window \xB7 [/] exact sample/request \xB7 Up/Down scroll",
     "Retention bounded to seven days; maximum 500 points and 500 requests per session.",
     ...h.notices,
-    ...h.summary ? [
+    ...h.result?.enabled && h.summary ? [
       `Matched requests ${h.summary.matchedRequests}/${h.summary.observedRequests}; output ${scalar(h.summary.outputTokens)}; duration ms ${scalar(h.summary.durationMs)}; average model TPS ${scalar(h.summary.averageModelTps)}${h.summary.partial ? " \xB7 partial" : ""}`
     ] : [],
-    ...h.from === undefined || h.to === undefined ? [] : [
+    ...!h.result?.enabled || h.from === undefined || h.to === undefined ? [] : [
       `${new Date(h.from).toISOString()} \u2192 ${new Date(h.to).toISOString()}`,
       ...metricPlot(observations.map((p) => ({
         time: p.time,
@@ -2703,9 +3235,9 @@ function terminalHistory(view, width, metricIndex, sample) {
       `Exact ${metric2.source === "points" ? "sample" : "request"} ${Math.min(sample + 1, observations.length)}/${observations.length}:`,
       ...Object.entries(selected.details).map(([key, value]) => `${key}: ${scalar(value)}`),
       `Selected ${metric2.label}: ${scalar(selected.value)} ${metric2.unit}`
-    ] : [
+    ] : h.status === "ready" && h.result?.enabled ? [
       "No retained measurements for this metric; values unknown/unavailable."
-    ]
+    ] : []
   ];
 }
 function wrapped(lines, width) {
@@ -2715,17 +3247,33 @@ function wrapped(lines, width) {
     return cells(clean) <= available ? [clean] : wrap(clean, available);
   });
 }
-function headerLines(view, width) {
+function headerLines(view, width, height = 24) {
+  const compact = width < 28;
+  const small = height < 18;
+  if (width < 16 || height < 8)
+    return [
+      clip(connectionLabel(view.connection, true), width),
+      clip(panelStatus(view.health), width),
+      clip(`Location: ${view.location}`, width)
+    ];
   return [
-    clip(`Context Guard \xB7 ${view.screen} \xB7 ${view.connection} \xB7 enforcement ${view.health?.enforcement ?? "unknown"}`, width),
-    clip(`Known ${view.inventory.total} \xB7 monitored ${view.inventory.monitored} \xB7 active ${view.inventory.active} \xB7 inventory ${view.inventory.stale ? "stale" : "fresh"}${view.inventory.complete ? "" : " / partial"}`, width),
-    clip(`Location: ${view.location}`, width)
+    clip(`${connectionLabel(view.connection, compact)} \xB7 ${compact ? width >= 20 ? "Context Guard" : "Guard" : `Context Guard \xB7 ${view.screen}`}`, width),
+    ...monitorStatusLines(view.connection, view.health, view.rows.some((row2) => row2.snapshot?.measurement !== undefined), compact).flatMap((line) => wrap(line, width)),
+    ...small ? [
+      clip(`Selected: ${view.selected?.node.agent ?? view.selectedSessionId ?? "none"}`, width)
+    ] : [
+      clip(`Known ${view.inventory.total} \xB7 monitored ${view.inventory.monitored} \xB7 active ${view.inventory.active} \xB7 inventory ${view.inventory.stale ? "stale" : "fresh"}${view.inventory.complete ? "" : " / partial"}`, width),
+      clip(`Location: ${view.location}`, width)
+    ]
   ];
 }
 var snapshotFields, scalar = (value) => value === undefined || value === null ? "unknown/unavailable" : typeof value === "number" && !Number.isFinite(value) ? "invalid" : String(value), terminalHelp;
 var init_terminalview = __esm(() => {
+  init_historyclient();
   init_chartformat();
   init_format();
+  init_statusformat();
+  init_panelformat();
   snapshotFields = [
     "sessionId",
     "parentId",
@@ -2798,6 +3346,9 @@ var init_terminalview = __esm(() => {
     "Models charts: Left/Right metric \xB7 w window \xB7 [/] bucket \xB7 d request details",
     "Models list/request details: n/p pages \xB7 f exact agent filter \xB7 r refresh",
     "Up/Down or j/k: select session in overview; scroll other screens",
+    "Overview: compact columns/cards; Enter or 2 for full identity and diagnostics",
+    "Overview PageUp/PageDown selects by visible rows; #N identifies a row in narrow layouts",
+    "Overview T means threshold; +N means more diagnostics in Details",
     "PageUp/PageDown: move by a page \xB7 Home/End: first/last",
     "Left/Right: history metric (six metrics) \xB7 w: cycle 5m/1h/24h/7d",
     "[ / ]: previous/next exact history sample or request",
@@ -2823,6 +3374,7 @@ import { isAbsolute as isAbsolute3 } from "path";
 class TerminalShell {
   controller;
   quit;
+  work = { formattedOverviewRows: 0 };
   scroll = 0;
   metric = 0;
   sample = 0;
@@ -2836,6 +3388,11 @@ class TerminalShell {
   input = "";
   notice = "";
   rowOffset = 0;
+  overviewScope = "";
+  overviewPage = 1;
+  labelKey = "";
+  labels = [];
+  layouts = new Map;
   historyIdentity = "";
   constructor(controller, quit) {
     this.controller = controller;
@@ -3024,7 +3581,7 @@ class TerminalShell {
     const delta = name === "down" || name === "j" ? 1 : name === "up" || name === "k" ? -1 : name === "pagedown" ? page : name === "pageup" ? -page : 0;
     if (view.screen === "overview" && !this.help) {
       const index = view.rows.findIndex((row3) => row3.node.sessionId === view.selectedSessionId);
-      const next = name === "home" ? 0 : name === "end" ? view.rows.length - 1 : Math.max(0, Math.min(view.rows.length - 1, index + delta));
+      const next = name === "home" ? 0 : name === "end" ? view.rows.length - 1 : Math.max(0, Math.min(view.rows.length - 1, index + (name === "pagedown" ? this.overviewPage : name === "pageup" ? -this.overviewPage : delta)));
       const row2 = view.rows[next];
       if (row2 && (delta || name === "home" || name === "end"))
         this.controller.selectSession(row2.node.sessionId);
@@ -3055,18 +3612,24 @@ class TerminalShell {
       this.scroll = 0;
       this.historyIdentity = identity;
     }
-    const footer = this.editor ? `${this.editor}> ${this.input} [Enter apply; Esc cancel${this.editor === "location" ? "; Tab remembered" : ""}]` : "? help q quit \xB7 1 overview 2 detail 3 history 4 models \xB7 / search f filters l location r refresh";
+    const footer = this.editor ? `${this.editor}> ${this.input} [Enter apply; Esc cancel${this.editor === "location" ? "; Tab remembered" : ""}]` : view.screen === "overview" && !this.help ? width < 40 ? width >= 22 ? "2 detail ? help q quit" : "2 detail ? q quit" : width < 72 ? "2 detail \xB7 q quit \xB7 ? help \xB7 \u2191\u2193 select" : "Enter detail \xB7 q quit \xB7 ? help \xB7 \u2191\u2193 select \xB7 3 history 4 models / search f filters l location r refresh" : width < 40 ? "? help q quit" : "? help q quit \xB7 1 overview 2 detail 3 history 4 models \xB7 / search f filters l location r refresh";
     if (height < 5)
       return [
         clip("Context Guard \xB7 ? help \xB7 q quit", width),
         ...wrapped([footer], width)
       ].slice(0, height).join("\n");
-    const header = headerLines(view, width);
-    const available = height - header.length - 1;
+    const header = headerLines(view, width, height);
+    if (view.screen === "overview" && !this.help) {
+      while (header.length > height - 2 && /^(Known |Location: |Selected: )/.test(header.at(-1) ?? ""))
+        header.pop();
+      header.splice(Math.max(0, height - 2));
+    }
+    const available = Math.max(0, height - header.length - 1);
     const notices = [
+      ...view.screen === "overview" && view.selectedSessionId && !view.rows.some((row2) => row2.node.sessionId === view.selectedSessionId) ? ["Selection hidden by filters \xB7 \u2191\u2193 selects a visible session"] : [],
       ...view.notices,
       ...view.inventory.notices,
-      ...view.health?.reasons ?? [],
+      ...view.screen === "detail" ? view.health?.reasons.map((reason) => `Health reason code: ${reason}`) ?? [] : [],
       ...this.notice ? [this.notice] : [],
       ...view.screen !== "models" && Object.values(view.filters).some(Boolean) ? [
         `Filters: search=${view.filters.search} agent=${view.filters.agent} model=${view.filters.model}`
@@ -3076,23 +3639,86 @@ class TerminalShell {
     if (this.help)
       body = wrapped(terminalHelp, width);
     else if (view.screen === "overview") {
-      const rows = view.rows.map((row2) => wrapped([
-        `${row2.node.sessionId === view.selectedSessionId ? "> " : "  "}${overviewRow(row2)}`
-      ], width));
+      const scope = JSON.stringify([view.location, view.filters]);
+      if (scope !== this.overviewScope) {
+        this.rowOffset = 0;
+        this.overviewScope = scope;
+      }
+      const heading = available >= 4 ? overviewHeading(width) : [];
+      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 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 status = wrapped(notices, width);
-      const budget = Math.max(1, available - Math.min(status.length, Math.floor(available / 3)));
+      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)));
+      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.slice(0, available - budget),
-        ...flat.length ? flat.slice(this.rowOffset, this.rowOffset + budget) : ["No matching sessions; / search, f filters, r refresh."]
+        ...status,
+        ...heading,
+        ...total ? visible : [
+          clip("No matching sessions; / search, f filters, r refresh.", width)
+        ]
       ];
       return [
         ...header,
@@ -3135,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) => {
@@ -3166,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);
@@ -3198,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 };
@@ -3303,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");
@@ -3313,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,
@@ -3327,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) {