@cesarus777/opencode-cgp 0.3.1 → 0.4.1

package/dist/cli.js

@@ -44,6 +44,12 @@ function isHistoryRead(value) {
 function isHistoryResult(value) {
   return valid(value, historyResultSchema);
 }
+function isAnalyticsRead(value) {
+  return valid(value, analyticsReadSchema) && record(value) && typeof value.from === "number" && typeof value.to === "number" && value.from < value.to && value.to - value.from <= 604800000 && !(value.model !== undefined && value.unknownModel === true) && (!(value.modelCursor || value.requestCursor) || typeof value.snapshotId === "string");
+}
+function isAnalyticsResult(value) {
+  return valid(value, analyticsResultSchema);
+}
 function record(x) {
   return typeof x === "object" && x !== null && !Array.isArray(x);
 }
@@ -101,7 +107,7 @@ var count, text, enumeration = (...values) => ({ type: "string", enum: values })
   type: "array",
   items,
   maxItems
-}), measurement, row, batchFields, readSchema, batchSchema, resultSchema, monitorRpc, nonnegative, performanceSchema, performanceRow, performanceBatchSchema, performanceResultSchema, performanceRpc, chartPointSchema, chartRequestSchema, historyReadSchema, historyResultSchema, historyRpc;
+}), measurement, row, batchFields, readSchema, batchSchema, resultSchema, monitorRpc, nonnegative, performanceSchema, performanceRow, performanceBatchSchema, performanceResultSchema, performanceRpc, chartPointSchema, chartRequestSchema, historyReadSchema, historyResultSchema, historyRpc, modelSummarySchema, analyticsReadSchema, analyticsResultSchema, analyticsRpc;
 var init_rpc = __esm(() => {
   count = {
     type: "integer",
@@ -337,6 +343,123 @@ var init_rpc = __esm(() => {
     methods: { read: { input: historyReadSchema, output: historyResultSchema } },
     events: {}
   });
+  modelSummarySchema = object({
+    model: text,
+    sessions: count,
+    completedRequests: count,
+    partialRequests: count,
+    legacyAttributionRequests: count,
+    tpsRequests: count,
+    ttftRequests: count,
+    excludedTpsRequests: count,
+    excludedTtftRequests: count,
+    outputTokens: nonnegative,
+    durationMs: nonnegative,
+    averageTps: nonnegative,
+    meanTtftMs: nonnegative,
+    medianTtftMs: nonnegative,
+    p95TtftMs: nonnegative
+  }, [
+    "sessions",
+    "completedRequests",
+    "partialRequests",
+    "legacyAttributionRequests",
+    "tpsRequests",
+    "ttftRequests",
+    "excludedTpsRequests",
+    "excludedTtftRequests",
+    "outputTokens",
+    "durationMs"
+  ]);
+  analyticsReadSchema = object({
+    schemaVersion: { const: 1 },
+    from: count,
+    to: count,
+    buckets: { type: "integer", minimum: 1, maximum: 240 },
+    agent: text,
+    model: text,
+    unknownModel: { type: "boolean" },
+    sort: enumeration("requests", "tps", "ttft", "identity"),
+    snapshotId: text,
+    modelCursor: text,
+    requestCursor: text
+  }, ["schemaVersion", "from", "to", "buckets"]);
+  analyticsResultSchema = object({
+    schemaVersion: { const: 1 },
+    generatedAt: count,
+    expiresAt: count,
+    snapshotId: text,
+    enabled: { type: "boolean" },
+    from: count,
+    to: count,
+    agent: text,
+    models: array(modelSummarySchema, 50),
+    totalModels: count,
+    nextModelsCursor: text,
+    selected: modelSummarySchema,
+    buckets: array(object({ from: nonnegative, to: nonnegative, summary: modelSummarySchema }, ["from", "to"]), 240),
+    requests: array(object({
+      location: text,
+      sessionId: text,
+      requestId: text,
+      startedAt: count,
+      completedAt: count,
+      model: text,
+      agent: text,
+      attribution: enumeration("request", "legacy-record", "unknown"),
+      partial: { type: "boolean" },
+      outputTokens: nonnegative,
+      ttftMs: nonnegative
+    }, [
+      "location",
+      "sessionId",
+      "requestId",
+      "startedAt",
+      "completedAt",
+      "attribution",
+      "partial"
+    ]), 50),
+    nextRequestsCursor: text,
+    coverage: object({
+      source: enumeration("retained-request-records"),
+      scannedRecords: count,
+      unscannedRecords: count,
+      duplicateRecords: count,
+      conflictingRequests: count,
+      missingIdentityRecords: count,
+      incompleteRequests: count,
+      invalidTimingRequests: count,
+      gapRecords: count,
+      maxRequests: count,
+      partial: { type: "boolean" }
+    }),
+    metadata: historyResultSchema.properties.metadata ?? {},
+    gaps: array(count, 128),
+    omittedGaps: count
+  }, [
+    "schemaVersion",
+    "generatedAt",
+    "expiresAt",
+    "snapshotId",
+    "enabled",
+    "from",
+    "to",
+    "models",
+    "totalModels",
+    "buckets",
+    "requests",
+    "coverage",
+    "metadata",
+    "gaps",
+    "omittedGaps"
+  ]);
+  analyticsRpc = Rpc.define({
+    id: "context-guard.analytics.v1",
+    methods: {
+      read: { input: analyticsReadSchema, output: analyticsResultSchema }
+    },
+    events: {}
+  });
 });
 
 // src/history.ts
@@ -529,6 +652,7 @@ function scalarPerformance(p) {
 async function readPerformanceHistory(directory, filter = {}) {
   const records = [];
   const files = await segments(directory);
+  filter.signal?.throwIfAborted();
   const maxBytes = filter.maxBytes ?? 64 * 1024 * 1024;
   let bytes = 0, skippedBytes = 0, malformedRecords = 0;
   const selected = [];
@@ -541,6 +665,7 @@ async function readPerformanceHistory(directory, filter = {}) {
     selected.unshift(file);
   }
   for (const file of selected) {
+    filter.signal?.throwIfAborted();
     const handle = await open(join(directory, file.name), "r");
     let source;
     try {
@@ -550,7 +675,12 @@ async function readPerformanceHistory(directory, filter = {}) {
     } 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 {
@@ -671,8 +801,9 @@ Open a read-only live terminal dashboard for an existing OpenCode server.
 
 Start here
   1. Keep an OpenCode server running with Context Guard registered.
-  2. Close OpenCode's native TUI before opening the standalone dashboard.
-  3. In the owning project directory, run: context-guard dashboard tui
+  2. Open a separate terminal tab, window or pane for the dashboard.
+  3. In the same project directory, run: context-guard dashboard tui
+  Keep working in OpenCode; the dashboard reads live updates from its server.
 
 Options
   --directory PATH   Owning project directory (local default: current directory)
@@ -695,8 +826,10 @@ Authentication (explicit servers)
   CONTEXT_GUARD_USERNAME   Server username (default: opencode)
 
 Keys
-  1/2/3 overview/detail/history; arrows or j/k move; / search; f filters;
-  l location; w history window; r refresh; ? help; q or Ctrl+C quit.`;
+  1/2/3/4 overview/detail/history/models; arrows or j/k move; Enter detail/chart;
+  Models: Left/Right metric, [/] bucket, d requests, n/p pages, s sort;
+  / session search; f filters (Models: agent); l location; w time window;
+  r refresh; ? help; q or Ctrl+C quit.`;
 var init_command = () => {
 };
 
@@ -803,6 +936,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;
@@ -1164,6 +1342,249 @@ var init_inventory = __esm(() => {
   });
 });
 
+// src/dashboard/port.ts
+var AnalyticsUnavailable;
+var init_port = __esm(() => {
+  AnalyticsUnavailable = class AnalyticsUnavailable extends Error {
+    reason;
+    constructor(reason) {
+      super(`Model analytics ${reason}`);
+      this.reason = reason;
+    }
+  };
+});
+
+// src/dashboard/models.ts
+class ModelsController {
+  changed;
+  port;
+  active = false;
+  key = "";
+  agent = "";
+  seedModel = "";
+  selection;
+  resolution = 120;
+  from = 0;
+  to = 1;
+  generation = 0;
+  abort;
+  pending;
+  modelPages = [undefined];
+  requestPages = [undefined];
+  state = {
+    status: "idle",
+    stale: false,
+    sort: "requests",
+    windowMs: 300000,
+    modelPage: 0,
+    requestPage: 0
+  };
+  constructor(changed) {
+    this.changed = changed;
+  }
+  getView() {
+    return this.state;
+  }
+  configure(port, active, windowMs, agent, seedModel, now) {
+    const key = JSON.stringify([
+      port.location.directory,
+      windowMs,
+      agent,
+      seedModel
+    ]);
+    const different = key !== this.key;
+    const preserveSelection = this.port?.location.directory === port.location.directory && this.agent === agent && this.seedModel === seedModel;
+    const entering = active && !this.active;
+    if (different || !active)
+      this.cancel();
+    this.port = port;
+    this.active = active;
+    if (different) {
+      this.key = key;
+      this.agent = agent;
+      this.seedModel = seedModel;
+      if (!preserveSelection)
+        this.selection = seedModel || undefined;
+      this.modelPages = [undefined];
+      this.requestPages = [undefined];
+      this.state = {
+        status: "idle",
+        stale: false,
+        sort: this.state.sort,
+        windowMs,
+        modelPage: 0,
+        requestPage: 0
+      };
+    }
+    if (active && (different || entering))
+      this.refresh(now);
+  }
+  cancel() {
+    this.generation++;
+    this.abort?.abort();
+    this.abort = undefined;
+    this.pending = undefined;
+  }
+  stop() {
+    this.cancel();
+    this.active = false;
+    this.state = { ...this.state, stale: Boolean(this.state.result) };
+  }
+  async refresh(now) {
+    if (!this.active || !this.port)
+      return;
+    if (this.pending)
+      return this.pending;
+    this.to = Math.max(1, Math.floor(now));
+    this.from = Math.max(0, this.to - this.state.windowMs);
+    this.modelPages = [undefined];
+    this.requestPages = [undefined];
+    this.state = { ...this.state, modelPage: 0, requestPage: 0 };
+    return this.query(false);
+  }
+  setWidth(width) {
+    const next = Math.max(1, Math.min(120, Math.floor(width) - 10));
+    if (next === this.resolution)
+      return;
+    this.resolution = next;
+    if (this.active && this.state.result)
+      this.query(true);
+  }
+  select(model) {
+    if (!this.active || model === this.selection)
+      return;
+    this.selection = model;
+    this.requestPages = [undefined];
+    this.state = { ...this.state, requestPage: 0 };
+    this.query(true);
+  }
+  sort() {
+    const sorts = ["requests", "tps", "ttft", "identity"];
+    this.modelPages = [undefined];
+    this.state = {
+      ...this.state,
+      sort: sorts[(sorts.indexOf(this.state.sort) + 1) % sorts.length] ?? "requests",
+      modelPage: 0
+    };
+    this.query(true);
+  }
+  page(kind, direction) {
+    if (this.state.status !== "ready")
+      return;
+    const pages = kind === "models" ? this.modelPages : this.requestPages;
+    const index = kind === "models" ? this.state.modelPage : this.state.requestPage;
+    const next = kind === "models" ? this.state.result?.nextModelsCursor : this.state.result?.nextRequestsCursor;
+    if (direction < 0 && index === 0 || direction > 0 && !next)
+      return;
+    if (direction > 0)
+      pages[index + 1] = next;
+    this.state = {
+      ...this.state,
+      ...kind === "models" ? { modelPage: index + direction, requestPage: 0 } : { requestPage: index + direction }
+    };
+    if (kind === "models") {
+      this.selection = undefined;
+      this.requestPages = [undefined];
+    }
+    this.query(true);
+  }
+  query(reuse) {
+    this.cancel();
+    const port = this.port;
+    if (!this.active || !port)
+      return Promise.resolve();
+    if (!port.analytics) {
+      this.state = { ...this.state, status: "unsupported", stale: false };
+      this.changed();
+      return Promise.resolve();
+    }
+    const read = port.analytics.bind(port);
+    const controller = new AbortController;
+    this.abort = controller;
+    const generation = this.generation;
+    const signal = AbortSignal.any([
+      controller.signal,
+      AbortSignal.timeout(15000)
+    ]);
+    const modelCursor = this.modelPages[this.state.modelPage];
+    const requestCursor = this.requestPages[this.state.requestPage];
+    const input = {
+      schemaVersion: 1,
+      from: this.from,
+      to: this.to,
+      buckets: this.resolution,
+      sort: this.state.sort,
+      ...this.agent ? { agent: this.agent } : {},
+      ...this.selection === "" ? { unknownModel: true } : this.selection ? { model: this.selection } : {},
+      ...reuse && this.state.result ? { snapshotId: this.state.result.snapshotId } : {},
+      ...reuse && modelCursor ? { modelCursor } : {},
+      ...reuse && requestCursor ? { requestCursor } : {}
+    };
+    this.state = {
+      ...this.state,
+      status: "loading",
+      stale: Boolean(this.state.result)
+    };
+    this.changed();
+    const task = Promise.resolve().then(async () => {
+      try {
+        let result;
+        try {
+          result = await read(input, signal);
+        } catch (error) {
+          if (!input.snapshotId || signal.aborted || error instanceof AnalyticsUnavailable && error.reason === "unsupported")
+            throw error;
+          const {
+            snapshotId: _id,
+            modelCursor: _m,
+            requestCursor: _r,
+            ...fresh
+          } = input;
+          result = await read(fresh, signal);
+          if (generation !== this.generation)
+            return;
+          signal.throwIfAborted();
+          this.modelPages = [undefined];
+          this.requestPages = [undefined];
+          this.state = { ...this.state, modelPage: 0, requestPage: 0 };
+        }
+        if (generation !== this.generation)
+          return;
+        signal.throwIfAborted();
+        if (!isAnalyticsResult(result) || result.from !== input.from || result.to !== input.to || result.agent !== input.agent || result.requests.some((r) => r.location !== port.location.directory))
+          throw new Error("Invalid analytics response");
+        if (result.selected)
+          this.selection = result.selected.model ?? "";
+        this.state = {
+          ...this.state,
+          result: structuredClone(result),
+          status: result.enabled ? "ready" : "disabled",
+          stale: false
+        };
+      } catch (error) {
+        if (generation !== this.generation || controller.signal.aborted)
+          return;
+        this.state = {
+          ...this.state,
+          status: error instanceof AnalyticsUnavailable && error.reason === "unsupported" && !this.state.result ? "unsupported" : "unavailable",
+          stale: Boolean(this.state.result)
+        };
+      } finally {
+        if (generation === this.generation) {
+          this.pending = undefined;
+          this.changed();
+        }
+      }
+    });
+    this.pending = task;
+    return task;
+  }
+}
+var init_models = __esm(() => {
+  init_rpc();
+  init_port();
+});
+
 // src/dashboard/view.ts
 function immutableView(value) {
   const copy = structuredClone(value);
@@ -1252,10 +1673,12 @@ class DashboardController {
   pendingHistory;
   historyAbort;
   historyBusy = false;
+  historyReason;
   historyStatus = "idle";
   refreshTimer;
   ageTimer;
   view;
+  models;
   constructor(port, options = {}) {
     this.limits = { ...options.limits ?? inventoryLimits };
     validateInventoryLimits(this.limits);
@@ -1266,6 +1689,7 @@ class DashboardController {
       throw new Error("Invalid dashboard refresh interval");
     this.state = this.createLocation(port);
     this.locations.set(port.location.directory, this.state);
+    this.models = new ModelsController(() => this.publish());
     this.view = this.buildView();
   }
   createLocation(port) {
@@ -1315,6 +1739,7 @@ class DashboardController {
     await this.refresh();
   }
   stop() {
+    this.models.stop();
     this.running = false;
     this.generation++;
     this.scope?.abort();
@@ -1349,6 +1774,7 @@ class DashboardController {
     this.locations.delete(directory);
     this.locations.set(directory, next);
     this.state = next;
+    this.configureModels();
     if (this.locations.size > 4) {
       const oldest = this.locations.keys().next().value;
       if (oldest !== undefined)
@@ -1370,11 +1796,12 @@ class DashboardController {
     this.publish();
   }
   setScreen(screen) {
-    if (!["overview", "detail", "history"].includes(screen))
+    if (!["overview", "detail", "history", "models"].includes(screen))
       throw new Error("Invalid dashboard screen");
     if (screen === this.screen)
       return;
     this.screen = screen;
+    this.configureModels();
     this.queueHistory();
     this.publish();
   }
@@ -1384,6 +1811,7 @@ class DashboardController {
     if (windowMs === this.windowMs)
       return;
     this.windowMs = windowMs;
+    this.configureModels();
     this.queueHistory();
     this.publish();
   }
@@ -1396,11 +1824,18 @@ class DashboardController {
       agent: filters.agent ?? this.filters.agent,
       model: filters.model ?? this.filters.model
     };
+    this.configureModels();
     this.publish();
   }
+  configureModels() {
+    this.models.configure(this.state.port, this.running && this.screen === "models", this.windowMs, this.filters.agent, this.filters.model, this.serverNow());
+  }
   async refresh() {
     if (!this.running || !this.scope)
       return;
+    this.configureModels();
+    if (this.screen === "models")
+      this.models.refresh(this.serverNow());
     for (const cached of this.cache.values())
       if (cached.directory === this.state.port.location.directory)
         cached.valid = false;
@@ -1530,6 +1965,7 @@ class DashboardController {
   }
   cancelHistory() {
     this.historyGeneration++;
+    this.historyReason = undefined;
     this.pendingHistory = undefined;
     this.historyAbort?.abort();
   }
@@ -1583,10 +2019,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,
@@ -1598,12 +2034,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;
@@ -1688,12 +2128,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",
@@ -1701,6 +2142,7 @@ class DashboardController {
           "maximum-500-points-and-requests"
         ]
       },
+      models: this.models.getView(),
       notices: [
         ...!state.complete ? ["partial-inventory"] : [],
         ...state.connection !== "live" ? ["live-data-stale"] : [],
@@ -1710,9 +2152,10 @@ class DashboardController {
   }
 }
 var init_controller = __esm(() => {
-  init_rpc();
+  init_historyclient();
   init_transport();
   init_inventory();
+  init_models();
   init_view();
 });
 
@@ -1865,16 +2308,28 @@ async function connectDashboard(options, discovery = Service) {
           }
         };
       },
+      async analytics(input, signal) {
+        if (!isAnalyticsRead(input))
+          throw new Error("Invalid analytics request");
+        try {
+          const result = await client.rpc(analyticsRpc).read(input, { location, signal: deadline(signal) });
+          if (!isAnalyticsResult(result))
+            throw new Error("Invalid analytics response");
+          return result;
+        } catch (error) {
+          const missing = typeof error === "object" && error !== null && "type" in error && (error.type === "rpc.unavailable" || error.type === "rpc.method_not_found");
+          throw new AnalyticsUnavailable(missing ? "unsupported" : "unavailable");
+        }
+      },
       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);
         }
       }
     };
@@ -1891,7 +2346,212 @@ 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
@@ -1921,22 +2581,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)
@@ -1947,22 +2591,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) {
@@ -1999,22 +2650,16 @@ 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
-function columns(points, from, to, width, gaps = []) {
+function columns(points, from, to, width, gaps = [], halfOpen = false) {
   const size = Math.max(1, Math.min(120, Math.floor(width))), values = Array.from({ length: size });
-  const column = (time) => Math.max(0, Math.min(size - 1, Math.floor((time - from) / Math.max(1, to - from) * (size - 1))));
+  const column = (time) => Math.max(0, Math.min(size - 1, Math.floor((time - from) / Math.max(1, to - from) * (halfOpen ? size : size - 1))));
   let min = Infinity, max = -Infinity;
   for (const point of points) {
     if (point.time < from || point.time > to || point.value === undefined || !Number.isFinite(point.value) || point.value < 0)
@@ -2038,12 +2683,12 @@ function sparkline(points, from, to, width, gaps = []) {
       chars[column(time)] = "\u2506";
   return { line: chars.join(""), ...min === Infinity ? {} : { min, max } };
 }
-function metricPlot(points, from, to, width, gaps = []) {
+function metricPlot(points, from, to, width, gaps = [], halfOpen = false) {
   const label = (value) => value >= 1e6 ? `${(value / 1e6).toFixed(1)}M` : value >= 1000 ? `${(value / 1000).toFixed(1)}k` : value.toFixed(1);
   const peak = Math.max(0, ...points.filter((p) => p.time >= from && p.time <= to && Number.isFinite(p.value)).map((p) => p.value ?? 0));
   const scale = Math.max(1, peak);
   const gutter = width >= 20 ? Math.max(label(scale).length, 3) : 0;
-  const { values, column } = columns(points, from, to, Math.max(1, width - gutter - 2), gaps);
+  const { values, column } = columns(points, from, to, Math.max(1, halfOpen ? Math.min(points.length, width - gutter - 2) : width - gutter - 2), gaps, halfOpen);
   const gapColumns = new Set(gaps.filter((time) => time >= from && time <= to).map(column));
   const height = 6;
   const blocks = " \u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
@@ -2120,11 +2765,259 @@ var init_chartformat = __esm(() => {
   ];
 });
 
+// src/dashboard/modelview.ts
+function metricValue(summary, metric2) {
+  if (metric2.key === "outputTokens" && !summary?.tpsRequests)
+    return;
+  const value = summary?.[metric2.key];
+  return value === undefined ? undefined : value / metric2.divisor;
+}
+function terminalModelRow(model, focused) {
+  return [
+    `${focused ? "> " : "  "}${model.model ?? "unknown model attribution"}`,
+    `  ${stats(model)}`,
+    `  TPS eligible ${model.tpsRequests}; TTFT eligible ${model.ttftRequests}; partial ${model.partialRequests}; legacy attribution ${model.legacyAttributionRequests}`
+  ];
+}
+function terminalModels(view, width, detail, metricIndex, sample, focus, requests) {
+  const state = view.models;
+  const result = state.result;
+  const lines = [
+    `Models \xB7 ${state.status}${state.stale ? " \xB7 STALE cached results" : ""} \xB7 ${state.windowMs / 60000} minutes \xB7 retained history`,
+    `Agent: ${(result?.agent ?? view.filters.agent) || "all"} \xB7 sort ${state.sort} \xB7 location ${view.location}`,
+    "4 Models \xB7 Enter chart \xB7 Esc model list/overview \xB7 w window \xB7 f agent \xB7 r refresh"
+  ];
+  if (state.status === "unsupported")
+    return [
+      ...lines,
+      "Models requires a server with context-guard.analytics.v1; update the server plugin. Overview and session history remain available."
+    ];
+  if (state.status === "disabled")
+    return [
+      ...lines,
+      "Retained performance recording is disabled on this server."
+    ];
+  if (!result)
+    return [
+      ...lines,
+      state.status === "loading" ? "Loading model aggregates\u2026" : "Model analytics unavailable; press r to retry."
+    ];
+  lines.push(`${new Date(result.from).toISOString()} \u2192 ${new Date(result.to).toISOString()} (UTC; completion time)`);
+  const partial = result.coverage.partial || result.metadata.skippedBytes > 0 || result.metadata.malformedRecords > 0 || result.gaps.length > 0 || result.omittedGaps > 0;
+  lines.push(`Coverage: ${partial ? "PARTIAL" : "bounded observations"}; 64 MiB scan limit; ${result.coverage.maxRequests} request identities maximum; no pre-observation reconstruction.`);
+  lines.push(`Archive retained since ${result.metadata.retainedFrom === undefined ? "unknown" : new Date(result.metadata.retainedFrom).toISOString()}; snapshot observed at ${new Date(result.generatedAt).toISOString()}.`);
+  lines.push(`Scan: ${result.coverage.scannedRecords} records; ${result.metadata.skippedBytes} bytes skipped; ${result.metadata.malformedRecords} malformed; ${result.coverage.conflictingRequests} conflicting; ${result.coverage.incompleteRequests} incomplete; ${result.coverage.invalidTimingRequests} invalid timing; gaps ${result.gaps.length}${result.omittedGaps ? ` (+${result.omittedGaps} omitted)` : ""}.`);
+  if (!detail) {
+    lines.push(`Model page ${state.modelPage + 1} \xB7 ${result.totalModels} models \xB7 Up/Down scroll/select \xB7 n/p pages \xB7 s sort`);
+    if (!result.models.length)
+      lines.push("No completed requests match this range and agent filter.");
+    result.models.forEach((model, index) => {
+      lines.push(...terminalModelRow(model, index === focus));
+    });
+    return lines;
+  }
+  const selected = result.selected;
+  if (!selected)
+    return [
+      ...lines,
+      "No completed requests for this model in the selected range."
+    ];
+  lines.push(`Model: ${selected.model ?? "unknown model attribution"}`, stats(selected));
+  lines.push(`Reported output ${number(selected.tpsRequests ? selected.outputTokens : undefined)} tokens; matched duration ${number(selected.tpsRequests ? selected.durationMs / 1000 : undefined)}s; TPS eligible/excluded ${selected.tpsRequests}/${selected.excludedTpsRequests}; TTFT eligible/excluded ${selected.ttftRequests}/${selected.excludedTtftRequests}; partial ${selected.partialRequests}; legacy attribution ${selected.legacyAttributionRequests}`);
+  if (requests) {
+    lines.push(`Request page ${state.requestPage + 1} \xB7 n/p pages \xB7 d chart \xB7 completed stream \u2260 task success`);
+    result.requests.forEach((r) => lines.push(`Request ${r.requestId} \xB7 session ${r.sessionId}`, `Completed ${new Date(r.completedAt).toISOString()} \xB7 ${r.agent ?? "unknown agent"} \xB7 output ${number(r.outputTokens)} \xB7 duration ${number((r.completedAt - r.startedAt) / 1000)}s \xB7 TTFT ${number(r.ttftMs === undefined ? undefined : r.ttftMs / 1000)}s ~ \xB7 ${r.attribution}${r.partial ? " \xB7 partial" : ""}`));
+    return lines;
+  }
+  const metric2 = modelMetrics[metricIndex] ?? modelMetrics[0];
+  lines.push(`\u2039 ${metric2.label} (${metric2.unit}) \u203A \xB7 Left/Right metric \xB7 [/] bucket \xB7 d requests`);
+  lines.push(...metricPlot(result.buckets.map((bucket2) => {
+    const value = metricValue(bucket2.summary, metric2);
+    return {
+      time: (bucket2.from + bucket2.to) / 2,
+      ...value === undefined ? {} : { value }
+    };
+  }), result.from, result.to, width, result.gaps, true));
+  lines.push("UTC buckets \xB7 blank = no eligible observations \xB7 \u2506 = retained gap; partial coverage may hide other gaps.");
+  lines.push("TPS = reported output / summed matched request durations (includes TTFT); concurrent durations add. In-flight requests enter after stream completion.");
+  const bucket = result.buckets[Math.min(sample, Math.max(0, result.buckets.length - 1))];
+  if (bucket) {
+    lines.push(`Bucket ${Math.min(sample + 1, result.buckets.length)}/${result.buckets.length}: ${new Date(bucket.from).toISOString()} \u2192 ${new Date(bucket.to).toISOString()}`);
+    lines.push(bucket.summary ? stats(bucket.summary) : "No eligible observations; measurements unknown.");
+    lines.push(`Selected ${metric2.label}: ${number(metricValue(bucket.summary, metric2))} ${metric2.unit}`);
+    if (bucket.summary)
+      lines.push(`Bucket eligibility: TPS ${bucket.summary.tpsRequests}/${bucket.summary.completedRequests}; TTFT ${bucket.summary.ttftRequests}/${bucket.summary.completedRequests}; partial ${bucket.summary.partialRequests}`);
+  }
+  return lines;
+}
+var modelMetrics, number = (n) => n === undefined ? "?" : Number.isInteger(n) ? String(n) : n.toFixed(2), stats = (m) => `${m.sessions} sessions \xB7 ${m.completedRequests} completed \xB7 weighted TPS ${number(m.averageTps)} \xB7 TTFT median/p95 ${number(m.medianTtftMs === undefined ? undefined : m.medianTtftMs / 1000)}/${number(m.p95TtftMs === undefined ? undefined : m.p95TtftMs / 1000)}s ~`;
+var init_modelview = __esm(() => {
+  init_chartformat();
+  modelMetrics = [
+    { key: "averageTps", label: "Weighted request TPS", unit: "t/s", divisor: 1 },
+    { key: "medianTtftMs", label: "TTFT median ~", unit: "s", divisor: 1000 },
+    { key: "p95TtftMs", label: "TTFT p95 ~", unit: "s", divisor: 1000 },
+    {
+      key: "completedRequests",
+      label: "Completed requests",
+      unit: "requests",
+      divisor: 1
+    },
+    { key: "outputTokens", label: "Reported output", unit: "tokens", divisor: 1 }
+  ];
+});
+
+// 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 overviewRowLines(row2, width, selected, label, position, maxLines = 3) {
+  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 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 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)
+  ] : [`${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;
@@ -2139,8 +3032,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))}`),
@@ -2149,6 +3045,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],
@@ -2177,14 +3075,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,
@@ -2196,25 +3095,45 @@ 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) {
-  return lines.flatMap((line) => line ? wrap(line, Math.max(1, width)) : [""]);
+  const available = Math.max(1, width);
+  return lines.flatMap((line) => {
+    const clean = clip(line, Math.max(available, cells(line)));
+    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",
@@ -2282,8 +3201,14 @@ var init_terminalview = __esm(() => {
   ];
   terminalHelp = [
     "Context Guard standalone dashboard \u2014 keyboard help",
-    "1 overview \xB7 2 detail \xB7 3 history \xB7 Enter detail",
+    "1 overview \xB7 2 detail \xB7 3 history \xB7 4 models \xB7 Enter detail/chart",
+    "Models: Up/Down scroll tall rows, then select \xB7 Enter aggregate chart \xB7 Esc model list \xB7 s sort",
+    "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",
@@ -2312,11 +3237,18 @@ class TerminalShell {
   scroll = 0;
   metric = 0;
   sample = 0;
+  modelDetail = false;
+  modelRequests = false;
+  modelFocus = 0;
+  modelFocusId;
+  modelViewport;
   help = false;
   editor;
   input = "";
   notice = "";
   rowOffset = 0;
+  overviewScope = "";
+  overviewPage = 1;
   historyIdentity = "";
   constructor(controller, quit) {
     this.controller = controller;
@@ -2357,7 +3289,7 @@ class TerminalShell {
           this.task(this.controller.selectLocation(this.input));
         } else
           this.controller.setFilters({ [editor]: this.input });
-        this.editor = editor === "agent" ? "model" : undefined;
+        this.editor = editor === "agent" && view.screen !== "models" ? "model" : undefined;
         this.input = this.editor === "model" ? view.filters.model : "";
         this.scroll = 0;
         this.notice = "";
@@ -2377,6 +3309,11 @@ class TerminalShell {
     if (name === "escape") {
       this.help = false;
       this.scroll = 0;
+      if (view.screen === "models" && this.modelDetail) {
+        this.modelDetail = false;
+        this.modelRequests = false;
+        return;
+      }
       this.controller.setScreen("overview");
       return;
     }
@@ -2399,6 +3336,81 @@ class TerminalShell {
       this.task(this.controller.refresh());
       return;
     }
+    if (name === "4") {
+      this.help = false;
+      this.scroll = 0;
+      this.modelDetail = false;
+      this.modelRequests = false;
+      this.controller.setScreen("models");
+      return;
+    }
+    if (view.screen === "models" && !this.help) {
+      if (name === "enter" || name === "return") {
+        const model = view.models.result?.models[this.modelFocus];
+        if (model) {
+          this.controller.models.select(model.model ?? "");
+          this.modelDetail = true;
+          this.modelRequests = false;
+          this.sample = 0;
+          this.scroll = 0;
+        }
+        return;
+      }
+      if (name === "w") {
+        this.controller.setWindow(historyWindows[(historyWindows.indexOf(view.models.windowMs) + 1) % historyWindows.length] ?? historyWindows[0]);
+        this.sample = 0;
+        this.scroll = 0;
+        return;
+      }
+      if (name === "s" && !this.modelDetail) {
+        this.controller.models.sort();
+        this.scroll = 0;
+        return;
+      }
+      if (name === "n" || name === "p") {
+        if (!this.modelDetail || this.modelRequests) {
+          this.controller.models.page(this.modelDetail ? "requests" : "models", name === "n" ? 1 : -1);
+          if (!this.modelDetail) {
+            this.modelFocus = 0;
+            this.modelFocusId = undefined;
+          }
+          this.scroll = 0;
+        }
+        return;
+      }
+      if (this.modelDetail) {
+        if (name === "d") {
+          this.modelRequests = !this.modelRequests;
+          this.scroll = 0;
+          return;
+        }
+        if (name === "left" || name === "right") {
+          this.metric = (this.metric + modelMetrics.length + (name === "left" ? -1 : 1)) % modelMetrics.length;
+          this.sample = 0;
+          this.scroll = 0;
+          return;
+        }
+        if (name === "[" || name === "]") {
+          this.sample = Math.max(0, Math.min((view.models.result?.buckets.length ?? 1) - 1, this.sample + (name === "[" ? -1 : 1)));
+          return;
+        }
+      } else if (["up", "down", "j", "k", "home", "end", "pageup", "pagedown"].includes(name)) {
+        const models = view.models.result?.models ?? [];
+        const delta2 = name === "down" || name === "j" ? 1 : name === "up" || name === "k" ? -1 : name === "pagedown" ? page : -page;
+        const viewport = this.modelViewport;
+        if (viewport?.focus === this.modelFocus && viewport.end - viewport.start > viewport.height && name !== "home" && name !== "end" && (delta2 > 0 ? this.scroll + viewport.height < viewport.end : this.scroll > viewport.start)) {
+          this.scroll = Math.max(viewport.start, Math.min(viewport.end - viewport.height, this.scroll + delta2));
+          return;
+        }
+        if (name === "home")
+          this.scroll = 0;
+        if (name === "end")
+          this.scroll = Number.MAX_SAFE_INTEGER;
+        this.modelFocus = Math.max(0, Math.min(models.length - 1, name === "home" ? 0 : name === "end" ? models.length - 1 : this.modelFocus + delta2));
+        this.modelFocusId = models[this.modelFocus]?.model ?? "";
+        return;
+      }
+    }
     if (["1", "2", "3", "return", "enter"].includes(name)) {
       this.help = false;
       this.scroll = 0;
@@ -2425,7 +3437,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);
@@ -2435,27 +3447,47 @@ class TerminalShell {
   frame(width, height) {
     width = Math.max(1, width);
     height = Math.max(1, height);
+    this.controller.models.setWidth(width);
     const view = this.controller.getView();
-    const identity = `${view.location}\0${view.selectedSessionId}\0${view.history.windowMs}`;
+    if (view.screen === "models") {
+      const models = view.models.result?.models ?? [];
+      const identity2 = this.modelFocusId ?? view.models.result?.selected?.model ?? "";
+      const focused = models.findIndex((m) => (m.model ?? "") === identity2);
+      this.modelFocus = Math.max(0, focused < 0 ? Math.min(this.modelFocus, models.length - 1) : focused);
+      if (view.models.status === "ready" && models.length)
+        this.modelFocusId = models[this.modelFocus]?.model ?? "";
+    }
+    const identity = view.screen === "models" ? JSON.stringify([
+      view.location,
+      view.models.windowMs,
+      view.filters.agent,
+      view.models.result?.selected?.model
+    ]) : `${view.location}\0${view.selectedSessionId}\0${view.history.windowMs}`;
     if (identity !== this.historyIdentity) {
       this.sample = 0;
       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 \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] : [],
-      ...Object.values(view.filters).some(Boolean) ? [
+      ...view.screen !== "models" && Object.values(view.filters).some(Boolean) ? [
         `Filters: search=${view.filters.search} agent=${view.filters.agent} model=${view.filters.model}`
       ] : []
     ];
@@ -2463,23 +3495,38 @@ 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 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 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)));
       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);
       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,
+        ...flat.length ? flat.slice(this.rowOffset, this.rowOffset + budget) : [
+          clip("No matching sessions; / search, f filters, r refresh.", width)
+        ]
       ];
       return [
         ...header,
@@ -2490,8 +3537,28 @@ class TerminalShell {
     } else
       body = wrapped([
         ...notices,
-        ...view.screen === "detail" ? terminalDetail(view.selected) : terminalHistory(view, width, this.metric, this.sample)
+        ...view.screen === "detail" ? terminalDetail(view.selected) : view.screen === "models" ? terminalModels(view, width, this.modelDetail, this.metric, this.sample, this.modelFocus, this.modelRequests) : terminalHistory(view, width, this.metric, this.sample)
       ], width);
+    this.modelViewport = undefined;
+    if (view.screen === "models" && !this.modelDetail && !this.help && view.models.result?.models.length) {
+      const heights = (view.models.result?.models ?? []).map((model, index) => wrapped(terminalModelRow(model, index === this.modelFocus), width).length);
+      const start = body.length - heights.slice(this.modelFocus).reduce((a, b) => a + b, 0);
+      const end = start + (heights[this.modelFocus] ?? 0);
+      this.modelViewport = {
+        focus: this.modelFocus,
+        start,
+        end,
+        height: available
+      };
+      if (end - start > available) {
+        this.scroll = Math.max(start, Math.min(this.scroll, end - available));
+      } else {
+        if (start < this.scroll)
+          this.scroll = start;
+        if (end > this.scroll + available)
+          this.scroll = end - available;
+      }
+    }
     this.scroll = Math.max(0, Math.min(this.scroll, Math.max(0, body.length - available)));
     return [
       ...header,
@@ -2621,6 +3688,7 @@ var init_terminal = __esm(() => {
   init_connection();
   init_command();
   init_view();
+  init_modelview();
   init_format();
   init_terminalview();
 });
@@ -2668,7 +3736,7 @@ function reconcile(a, b) {
     partial: a.partial || b.partial
   };
 }
-function aggregateModels(records, options) {
+function analyzeModelRequests(records, 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");
@@ -2729,7 +3797,7 @@ function aggregateModels(records, options) {
       requests.set(key, { fact, conflict: false });
     }
   }
-  const groups = new Map;
+  const accepted = [];
   for (const { fact: r, conflict } of requests.values()) {
     if (conflict) {
       coverage.conflictingRequests++;
@@ -2746,6 +3814,22 @@ function aggregateModels(records, options) {
     }
     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 = 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
+  };
+}
+function summarizeModelRequests(requests) {
+  const groups = new Map;
+  for (const r of requests) {
+    const duration = r.completedAt - r.startedAt;
     let group = groups.get(r.model);
     if (!group) {
       group = {
@@ -2800,8 +3884,11 @@ function aggregateModels(records, options) {
     }
     return s;
   }).sort((a, b) => (a.model ?? "").localeCompare(b.model ?? ""));
-  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 };
+  return models;
+}
+function aggregateModels(records, options) {
+  const { requests: _requests, ...result } = analyzeModelRequests(records, options);
+  return result;
 }
 var nonnegative2 = (n) => n !== undefined && Number.isFinite(n) && n >= 0;