@cesarus777/opencode-cgp 0.2.5 → 0.3.1

package/dist/cli.js

@@ -1,176 +1,34 @@
 #!/usr/bin/env bun
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/rpc.ts
 import { Rpc } from "@opencode/plugin/rpc";
-var count = {
-  type: "integer",
-  minimum: 0,
-  maximum: Number.MAX_SAFE_INTEGER
-};
-var text = { type: "string", minLength: 1, maxLength: 512 };
-var enumeration = (...values) => ({ type: "string", enum: values });
-var object = (properties, required = Object.keys(properties)) => ({
-  type: "object",
-  properties,
-  required,
-  additionalProperties: false
-});
-var array = (items, maxItems = 128) => ({
-  type: "array",
-  items,
-  maxItems
-});
-var measurement = object({
-  tokens: count,
-  at: count,
-  model: text,
-  requestId: text,
-  provenance: enumeration("provider-normalized", "serialized-estimate"),
-  confidence: enumeration("reported", "approximate"),
-  scope: enumeration("completed-request", "prepared-request")
-}, ["tokens", "at", "model", "provenance", "confidence", "scope"]);
-var row = object({
-  sessionId: text,
-  revision: count,
-  observedAt: count,
-  parentId: text,
-  agent: text,
-  model: text,
-  measurement,
-  limits: object({ context: count, input: count, output: count }, [
-    "context",
-    "output"
-  ]),
-  capacityTokens: count,
-  outputReserveTokens: count,
-  peakTokens: count,
-  policy: object({
-    id: text,
-    configured: object({
-      type: enumeration("tokens", "ratio", "remaining"),
-      value: { type: "number", minimum: 0 }
-    }),
-    triggerTokens: { type: "number" },
-    comparison: enumeration(">=", ">"),
-    reason: enumeration("missing-usage", "model-changed", "invalid-usage", "stale-usage", "missing-model-budget", "incompatible-model-budget", "threshold-crossed", "below-threshold"),
-    crossed: { type: "boolean" }
-  }, ["id", "configured", "comparison", "reason", "crossed"]),
-  compaction: object({
-    phase: enumeration("idle", "requesting", "accepted", "running", "awaiting-measurement", "blocked", "uncertain"),
-    count,
-    armed: { type: "boolean" },
-    blockedReason: enumeration("session-removed", "compaction-failed", "reclaim-unverifiable", "insufficient-reclaim", "completion-event-timeout", "admission-outcome-unknown", "restart-needs-lifecycle-evidence"),
-    lastAttempt: count,
-    lastCompleted: count,
-    cooldownUntil: count
-  }, ["phase", "armed"]),
-  cumulative: object({
-    input: count,
-    output: count,
-    reasoning: count,
-    cache: object({ read: count, write: count })
-  }),
-  cumulativeScope: enumeration("session", "unknown"),
-  lastObservedActive: { type: "boolean" }
-}, [
-  "sessionId",
-  "revision",
-  "observedAt",
-  "policy",
-  "compaction",
-  "cumulativeScope",
-  "lastObservedActive"
-]);
-var batchFields = {
-  schemaVersion: { const: 1 },
-  epoch: text,
-  sequence: count,
-  generatedAt: count,
-  health: object({
-    enabled: { type: "boolean" },
-    mode: enumeration("observe", "enforce"),
-    enforcement: enumeration("observing", "available", "suspended", "disabled"),
-    reasons: array(enumeration("event-stream-gap", "persistence-unavailable", "capacity-exceeded", "model-metadata-unavailable"), 8),
-    staleMs: count,
-    maxSessions: count
-  }),
-  upserts: array(row),
-  removed: array(object({
-    sessionId: text,
-    revision: count,
-    reason: enumeration("deleted", "evicted")
-  }))
-};
-var readSchema = object({
-  schemaVersion: { const: 1 },
-  sessionIds: { ...array(text), uniqueItems: true }
-});
-var batchSchema = object(batchFields);
-var resultSchema = object({
-  ...batchFields,
-  unavailable: array(object({ sessionId: text, reason: enumeration("not-monitored") }))
-});
-var monitorRpc = Rpc.define({
-  id: "context-guard.monitor.v1",
-  methods: { read: { input: readSchema, output: resultSchema } },
-  events: { changed: { schema: batchSchema } }
-});
-var nonnegative = { type: "number", minimum: 0 };
-var performanceSchema = object({
-  observedSince: count,
-  at: count,
-  sessionCreatedAt: count,
-  sessionOutputTokens: count,
-  status: enumeration("waiting", "streaming", "idle", "unavailable"),
-  partial: { type: "boolean" },
-  liveTps: nonnegative,
-  averageModelTps: nonnegative,
-  averageSessionTps: nonnegative,
-  ttftMs: nonnegative,
-  latestRequestTps: nonnegative,
-  requestId: text,
-  requestAgent: text,
-  requestModel: text,
-  requestOutputTokens: count,
-  requestStartedAt: count,
-  firstOutputAt: count,
-  streamEndedAt: count,
-  estimatedOutputTokens: nonnegative,
-  modelOutputTokens: nonnegative,
-  modelDurationMs: nonnegative,
-  completedRequests: count,
-  tokenSource: enumeration("estimated", "reported", "unavailable")
-}, [
-  "sessionCreatedAt",
-  "observedSince",
-  "at",
-  "status",
-  "partial",
-  "estimatedOutputTokens",
-  "modelOutputTokens",
-  "modelDurationMs",
-  "completedRequests",
-  "tokenSource"
-]);
-var performanceRow = {
-  ...row,
-  properties: { ...row.properties, performance: performanceSchema }
-};
-var performanceBatchSchema = object({
-  ...batchFields,
-  upserts: array(performanceRow)
-});
-var performanceResultSchema = object({
-  ...batchFields,
-  upserts: array(performanceRow),
-  unavailable: resultSchema.properties.unavailable ?? {}
-});
-var performanceRpc = Rpc.define({
-  id: "context-guard.monitor.v2",
-  methods: { read: { input: readSchema, output: performanceResultSchema } },
-  events: { changed: { schema: performanceBatchSchema } }
-});
 function isPerformanceBatch(value) {
   return valid(value, performanceBatchSchema) && uniqueRows(value);
 }
@@ -180,84 +38,6 @@ function isPerformanceResult(value) {
 function isPerformanceSnapshot(value) {
   return valid(value, performanceSchema);
 }
-var chartPointSchema = object({
-  time: count,
-  agent: text,
-  model: text,
-  breakBefore: { type: "boolean" },
-  partial: { type: "boolean" },
-  liveTps: nonnegative,
-  averageModelTps: nonnegative,
-  averageSessionTps: nonnegative,
-  sessionOutputTokens: count
-}, ["time", "breakBefore", "partial"]);
-var chartRequestSchema = object({
-  time: count,
-  requestId: text,
-  started: count,
-  agent: text,
-  model: text,
-  ttftMs: nonnegative,
-  outputTokens: count,
-  durationMs: nonnegative,
-  tps: nonnegative,
-  partial: { type: "boolean" }
-}, ["time", "requestId", "started", "partial"]);
-var historyReadSchema = object({
-  schemaVersion: { const: 1 },
-  sessionId: text,
-  from: count,
-  to: count,
-  maxPoints: { type: "integer", minimum: 16, maximum: 500 }
-});
-var historyResultSchema = object({
-  schemaVersion: { const: 1 },
-  generatedAt: count,
-  enabled: { type: "boolean" },
-  truncated: { type: "boolean" },
-  metadata: object({
-    schema: { const: 1 },
-    retainedFrom: count,
-    retainedBytes: count,
-    skippedBytes: count,
-    malformedRecords: count,
-    completeness: enumeration("bounded-retention")
-  }, [
-    "schema",
-    "retainedBytes",
-    "skippedBytes",
-    "malformedRecords",
-    "completeness"
-  ]),
-  data: object({
-    schema: { const: 1 },
-    omittedSessions: count,
-    omittedGaps: count,
-    maxPoints: count,
-    gaps: array(object({ time: count, sessionId: text, reason: text }), 128),
-    series: array(object({
-      sessionId: text,
-      parentId: text,
-      agents: array(text, 1024),
-      models: array(text, 1024),
-      points: array(chartPointSchema, 500),
-      requests: array(chartRequestSchema, 500),
-      originalPoints: count
-    }, [
-      "sessionId",
-      "agents",
-      "models",
-      "points",
-      "requests",
-      "originalPoints"
-    ]), 1)
-  }, ["schema", "omittedSessions", "maxPoints", "gaps", "series"])
-});
-var historyRpc = Rpc.define({
-  id: "context-guard.history.v1",
-  methods: { read: { input: historyReadSchema, output: historyResultSchema } },
-  events: {}
-});
 function isHistoryRead(value) {
   return valid(value, historyReadSchema) && record(value) && typeof value.from === "number" && typeof value.to === "number" && value.from <= value.to && value.to - value.from <= 7 * 86400000;
 }
@@ -312,858 +92,3414 @@ function uniqueRows(value) {
   const ids = [...value.upserts, ...value.removed].map((v) => record(v) ? v.sessionId : undefined);
   return ids.length <= 128 && new Set(ids).size === ids.length;
 }
+var count, text, enumeration = (...values) => ({ type: "string", enum: values }), object = (properties, required = Object.keys(properties)) => ({
+  type: "object",
+  properties,
+  required,
+  additionalProperties: false
+}), array = (items, maxItems = 128) => ({
+  type: "array",
+  items,
+  maxItems
+}), measurement, row, batchFields, readSchema, batchSchema, resultSchema, monitorRpc, nonnegative, performanceSchema, performanceRow, performanceBatchSchema, performanceResultSchema, performanceRpc, chartPointSchema, chartRequestSchema, historyReadSchema, historyResultSchema, historyRpc;
+var init_rpc = __esm(() => {
+  count = {
+    type: "integer",
+    minimum: 0,
+    maximum: Number.MAX_SAFE_INTEGER
+  };
+  text = { type: "string", minLength: 1, maxLength: 512 };
+  measurement = object({
+    tokens: count,
+    at: count,
+    model: text,
+    requestId: text,
+    provenance: enumeration("provider-normalized", "serialized-estimate"),
+    confidence: enumeration("reported", "approximate"),
+    scope: enumeration("completed-request", "prepared-request")
+  }, ["tokens", "at", "model", "provenance", "confidence", "scope"]);
+  row = object({
+    sessionId: text,
+    revision: count,
+    observedAt: count,
+    parentId: text,
+    agent: text,
+    model: text,
+    measurement,
+    limits: object({ context: count, input: count, output: count }, [
+      "context",
+      "output"
+    ]),
+    capacityTokens: count,
+    outputReserveTokens: count,
+    peakTokens: count,
+    policy: object({
+      id: text,
+      configured: object({
+        type: enumeration("tokens", "ratio", "remaining"),
+        value: { type: "number", minimum: 0 }
+      }),
+      triggerTokens: { type: "number" },
+      comparison: enumeration(">=", ">"),
+      reason: enumeration("missing-usage", "model-changed", "invalid-usage", "stale-usage", "missing-model-budget", "incompatible-model-budget", "threshold-crossed", "below-threshold"),
+      crossed: { type: "boolean" }
+    }, ["id", "configured", "comparison", "reason", "crossed"]),
+    compaction: object({
+      phase: enumeration("idle", "requesting", "accepted", "running", "awaiting-measurement", "blocked", "uncertain"),
+      count,
+      armed: { type: "boolean" },
+      blockedReason: enumeration("session-removed", "compaction-failed", "reclaim-unverifiable", "insufficient-reclaim", "completion-event-timeout", "admission-outcome-unknown", "restart-needs-lifecycle-evidence"),
+      lastAttempt: count,
+      lastCompleted: count,
+      cooldownUntil: count
+    }, ["phase", "armed"]),
+    cumulative: object({
+      input: count,
+      output: count,
+      reasoning: count,
+      cache: object({ read: count, write: count })
+    }),
+    cumulativeScope: enumeration("session", "unknown"),
+    lastObservedActive: { type: "boolean" }
+  }, [
+    "sessionId",
+    "revision",
+    "observedAt",
+    "policy",
+    "compaction",
+    "cumulativeScope",
+    "lastObservedActive"
+  ]);
+  batchFields = {
+    schemaVersion: { const: 1 },
+    epoch: text,
+    sequence: count,
+    generatedAt: count,
+    health: object({
+      enabled: { type: "boolean" },
+      mode: enumeration("observe", "enforce"),
+      enforcement: enumeration("observing", "available", "suspended", "disabled"),
+      reasons: array(enumeration("event-stream-gap", "persistence-unavailable", "capacity-exceeded", "model-metadata-unavailable"), 8),
+      staleMs: count,
+      maxSessions: count
+    }),
+    upserts: array(row),
+    removed: array(object({
+      sessionId: text,
+      revision: count,
+      reason: enumeration("deleted", "evicted")
+    }))
+  };
+  readSchema = object({
+    schemaVersion: { const: 1 },
+    sessionIds: { ...array(text), uniqueItems: true }
+  });
+  batchSchema = object(batchFields);
+  resultSchema = object({
+    ...batchFields,
+    unavailable: array(object({ sessionId: text, reason: enumeration("not-monitored") }))
+  });
+  monitorRpc = Rpc.define({
+    id: "context-guard.monitor.v1",
+    methods: { read: { input: readSchema, output: resultSchema } },
+    events: { changed: { schema: batchSchema } }
+  });
+  nonnegative = { type: "number", minimum: 0 };
+  performanceSchema = object({
+    observedSince: count,
+    at: count,
+    sessionCreatedAt: count,
+    sessionOutputTokens: count,
+    status: enumeration("waiting", "streaming", "idle", "unavailable"),
+    partial: { type: "boolean" },
+    liveTps: nonnegative,
+    averageModelTps: nonnegative,
+    averageSessionTps: nonnegative,
+    ttftMs: nonnegative,
+    latestRequestTps: nonnegative,
+    requestId: text,
+    requestAgent: text,
+    requestModel: text,
+    requestOutputTokens: count,
+    requestStartedAt: count,
+    firstOutputAt: count,
+    streamEndedAt: count,
+    estimatedOutputTokens: nonnegative,
+    modelOutputTokens: nonnegative,
+    modelDurationMs: nonnegative,
+    completedRequests: count,
+    tokenSource: enumeration("estimated", "reported", "unavailable")
+  }, [
+    "sessionCreatedAt",
+    "observedSince",
+    "at",
+    "status",
+    "partial",
+    "estimatedOutputTokens",
+    "modelOutputTokens",
+    "modelDurationMs",
+    "completedRequests",
+    "tokenSource"
+  ]);
+  performanceRow = {
+    ...row,
+    properties: { ...row.properties, performance: performanceSchema }
+  };
+  performanceBatchSchema = object({
+    ...batchFields,
+    upserts: array(performanceRow)
+  });
+  performanceResultSchema = object({
+    ...batchFields,
+    upserts: array(performanceRow),
+    unavailable: resultSchema.properties.unavailable ?? {}
+  });
+  performanceRpc = Rpc.define({
+    id: "context-guard.monitor.v2",
+    methods: { read: { input: readSchema, output: performanceResultSchema } },
+    events: { changed: { schema: performanceBatchSchema } }
+  });
+  chartPointSchema = object({
+    time: count,
+    agent: text,
+    model: text,
+    breakBefore: { type: "boolean" },
+    partial: { type: "boolean" },
+    liveTps: nonnegative,
+    averageModelTps: nonnegative,
+    averageSessionTps: nonnegative,
+    sessionOutputTokens: count
+  }, ["time", "breakBefore", "partial"]);
+  chartRequestSchema = object({
+    time: count,
+    requestId: text,
+    started: count,
+    agent: text,
+    model: text,
+    ttftMs: nonnegative,
+    outputTokens: count,
+    durationMs: nonnegative,
+    tps: nonnegative,
+    partial: { type: "boolean" }
+  }, ["time", "requestId", "started", "partial"]);
+  historyReadSchema = object({
+    schemaVersion: { const: 1 },
+    sessionId: text,
+    from: count,
+    to: count,
+    maxPoints: { type: "integer", minimum: 16, maximum: 500 }
+  });
+  historyResultSchema = object({
+    schemaVersion: { const: 1 },
+    generatedAt: count,
+    enabled: { type: "boolean" },
+    truncated: { type: "boolean" },
+    metadata: object({
+      schema: { const: 1 },
+      retainedFrom: count,
+      retainedBytes: count,
+      skippedBytes: count,
+      malformedRecords: count,
+      completeness: enumeration("bounded-retention")
+    }, [
+      "schema",
+      "retainedBytes",
+      "skippedBytes",
+      "malformedRecords",
+      "completeness"
+    ]),
+    data: object({
+      schema: { const: 1 },
+      omittedSessions: count,
+      omittedGaps: count,
+      maxPoints: count,
+      gaps: array(object({ time: count, sessionId: text, reason: text }), 128),
+      series: array(object({
+        sessionId: text,
+        parentId: text,
+        agents: array(text, 1024),
+        models: array(text, 1024),
+        points: array(chartPointSchema, 500),
+        requests: array(chartRequestSchema, 500),
+        originalPoints: count
+      }, [
+        "sessionId",
+        "agents",
+        "models",
+        "points",
+        "requests",
+        "originalPoints"
+      ]), 1)
+    }, ["schema", "omittedSessions", "maxPoints", "gaps", "series"])
+  });
+  historyRpc = Rpc.define({
+    id: "context-guard.history.v1",
+    methods: { read: { input: historyReadSchema, output: historyResultSchema } },
+    events: {}
+  });
+});
 
-// src/cli.ts
-import { writeFile } from "fs/promises";
-import { resolve } from "path";
-
-// src/charts.ts
-var rateFields = [
-  "liveTps",
-  "averageModelTps",
-  "averageSessionTps",
-  "sessionOutputTokens"
-];
-function downsamplePoints(points, limit) {
-  if (!Number.isSafeInteger(limit) || limit < 16 || limit > 5000)
-    throw new Error("maxPoints must be an integer from 16 to 5000");
-  if (points.length <= limit)
-    return [...points];
-  const buckets = Math.max(1, Math.floor(limit / (2 + rateFields.length * 2)));
-  const selected = new Set;
-  for (let b = 0;b < buckets; b++) {
-    const start = Math.floor(b * points.length / buckets), end = Math.floor((b + 1) * points.length / buckets);
-    selected.add(start);
-    selected.add(end - 1);
-    for (const field of rateFields) {
-      let low, high;
-      for (let i = start;i < end; i++) {
-        const value = points[i]?.[field];
-        if (value === undefined)
-          continue;
-        if (low === undefined || value < (points[low]?.[field] ?? Infinity))
-          low = i;
-        if (high === undefined || value > (points[high]?.[field] ?? -Infinity))
-          high = i;
-      }
-      if (low !== undefined)
-        selected.add(low);
-      if (high !== undefined)
-        selected.add(high);
-    }
-  }
-  let previous = -1;
-  return [...selected].sort((a, b) => a - b).flatMap((index) => {
-    const point = points[index];
-    if (!point)
+// src/history.ts
+import { mkdir, readdir, stat, open, unlink } from "fs/promises";
+import { join } from "path";
+async function segments(directory) {
+  const names = await readdir(directory).catch((error) => {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return [];
-    const skippedGap = points.slice(previous + 1, index + 1).some((p) => p.breakBefore);
-    previous = index;
-    return [{ ...point, breakBefore: point.breakBefore || skippedGap }];
+    throw error;
   });
+  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
+  })))).sort((a, b) => a.time - b.time || a.name.localeCompare(b.name));
 }
-function buildChartData(records, options = {}) {
-  const maxPoints = options.maxPoints ?? 1000, maxSessions = options.maxSessions ?? 128;
-  if (!Number.isSafeInteger(maxSessions) || maxSessions < 1 || maxSessions > 1024)
-    throw new Error("maxSessions must be from 1 to 1024");
-  downsamplePoints([], maxPoints);
-  const sorted = [...records].sort((a, b) => a.time - b.time || a.recordId.localeCompare(b.recordId));
-  const lastSeen = new Map;
-  for (const r of sorted)
-    if (r.performance && (!options.sessionId || r.sessionId === options.sessionId))
-      lastSeen.set(r.sessionId, r.time);
-  const sessions = [...lastSeen].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
-  const selected = new Set(sessions.slice(0, maxSessions).map(([id]) => id));
-  const series = new Map, gaps = [];
-  const seen = new Set, requestSeen = new Set;
-  const pendingGaps = new Set;
-  const observedSince = new Map;
-  for (const r of sorted) {
-    if (seen.has(r.recordId))
-      continue;
-    seen.add(r.recordId);
-    if (r.type === "gap") {
-      if (r.sessionId === "__history__" || selected.has(r.sessionId)) {
-        gaps.push({
-          time: r.time,
-          sessionId: r.sessionId,
-          reason: r.event ?? "observation-gap"
-        });
-        if (r.sessionId === "__history__")
-          for (const id of selected)
-            pendingGaps.add(id);
-        else
-          pendingGaps.add(r.sessionId);
-      }
-      continue;
+
+class PerformanceHistory {
+  path;
+  config;
+  now;
+  report;
+  pending = [];
+  working;
+  active;
+  bytes = 0;
+  started = 0;
+  disabled = false;
+  dropped = 0;
+  droppedTotal = 0;
+  constructor(path, config, now = Date.now, report = () => {
+  }) {
+    this.path = path;
+    this.config = config;
+    this.now = now;
+    this.report = report;
+  }
+  emit(record2) {
+    if (!this.config.enabled || this.disabled)
+      return;
+    const line = JSON.stringify({
+      schema: 1,
+      recordId: record2.recordId,
+      time: record2.time,
+      type: record2.type,
+      sessionId: record2.sessionId,
+      ...record2.parentId ? { parentId: record2.parentId } : {},
+      ...record2.agent ? { agent: record2.agent } : {},
+      ...record2.model ? { model: record2.model } : {},
+      ...record2.event ? { event: record2.event } : {},
+      ...record2.droppedRecords === undefined ? {} : { droppedRecords: record2.droppedRecords },
+      ...record2.performance ? { performance: scalarPerformance(record2.performance) } : {}
+    }) + "\n";
+    if (this.pending.length >= 256 || Buffer.byteLength(line) > Math.min(4 * 1024 * 1024, this.config.maxBytes)) {
+      this.dropped++;
+      this.droppedTotal++;
+      if (this.dropped === 1)
+        this.report("history-records-dropped");
+      return;
     }
-    const p = r.performance;
-    if (!p || !selected.has(r.sessionId))
-      continue;
-    let s = series.get(r.sessionId);
-    if (!s) {
-      s = {
-        sessionId: r.sessionId,
-        ...r.parentId ? { parentId: r.parentId } : {},
-        agents: [],
-        models: [],
-        points: [],
-        requests: [],
-        originalPoints: 0
-      };
-      series.set(r.sessionId, s);
+    this.pending.push(line);
+    this.kick();
+  }
+  kick() {
+    if (this.working || this.disabled)
+      return;
+    this.working = this.drain().catch(() => {
+      this.disabled = true;
+      this.pending = [];
+      this.report("history-unavailable");
+    }).finally(() => {
+      this.working = undefined;
+      if (this.pending.length)
+        this.kick();
+    });
+  }
+  async prune(incoming = 0) {
+    const files = await segments(this.path);
+    let total = files.reduce((n, f) => n + f.bytes, 0);
+    let truncated = false;
+    for (const file of files) {
+      if (file.time >= this.now() - this.config.retentionDays * 86400000 && total + incoming <= this.config.maxBytes)
+        break;
+      await unlink(join(this.path, file.name));
+      if (file.name === this.active) {
+        this.active = undefined;
+        this.bytes = 0;
+      }
+      total -= file.bytes;
+      truncated = true;
     }
-    const agent = p.requestAgent ?? r.agent, model = p.requestModel ?? r.model;
-    if (agent && !s.agents.includes(agent))
-      s.agents.push(agent);
-    if (model && !s.models.includes(model))
-      s.models.push(model);
-    const previous = s.points.at(-1);
-    const restart = observedSince.has(r.sessionId) && observedSince.get(r.sessionId) !== p.observedSince;
-    const reset = previous?.sessionOutputTokens !== undefined && p.sessionOutputTokens !== undefined && p.sessionOutputTokens < previous.sessionOutputTokens;
-    const discontinuity = pendingGaps.has(r.sessionId) || restart || reset || !previous || previous.partial !== p.partial || previous.liveTps === undefined || p.liveTps === undefined || r.time - previous.time > 2500 || previous.agent !== agent || previous.model !== model;
-    const point = {
-      time: r.time,
-      ...agent ? { agent } : {},
-      ...model ? { model } : {},
-      breakBefore: discontinuity,
-      partial: p.partial,
-      ...p.liveTps === undefined ? {} : { liveTps: p.liveTps },
-      ...p.averageModelTps === undefined ? {} : { averageModelTps: p.averageModelTps },
-      ...p.averageSessionTps === undefined ? {} : { averageSessionTps: p.averageSessionTps },
-      ...p.sessionOutputTokens === undefined ? {} : { sessionOutputTokens: p.sessionOutputTokens }
-    };
-    if (previous?.time === point.time)
-      s.points[s.points.length - 1] = {
-        ...point,
-        breakBefore: point.breakBefore || previous.breakBefore
-      };
-    else
-      s.points.push(point);
-    observedSince.set(r.sessionId, p.observedSince);
-    pendingGaps.delete(r.sessionId);
-    if (r.type === "request" && p.requestId !== undefined && p.requestStartedAt !== undefined) {
-      const key = JSON.stringify([
-        r.sessionId,
-        p.requestId,
-        p.requestStartedAt
-      ]);
-      if (requestSeen.has(key))
+    if (truncated)
+      this.report("history-truncated");
+  }
+  gapLine(event, droppedRecords) {
+    return JSON.stringify({
+      schema: 1,
+      recordId: crypto.randomUUID(),
+      time: this.now(),
+      type: "gap",
+      sessionId: "__history__",
+      event,
+      ...droppedRecords === undefined ? {} : { droppedRecords }
+    }) + "\n";
+  }
+  async drain() {
+    await mkdir(this.path, { recursive: true, mode: 448 });
+    await this.prune();
+    while (this.pending.length) {
+      let line = this.pending.shift();
+      if (!line)
         continue;
-      requestSeen.add(key);
-      const duration = p.streamEndedAt === undefined ? undefined : p.streamEndedAt - p.requestStartedAt;
-      const validDuration = duration !== undefined && duration > 0;
-      const output = p.tokenSource === "reported" ? p.requestOutputTokens : undefined;
-      s.requests.push({
-        time: r.time,
-        requestId: p.requestId,
-        started: p.requestStartedAt,
-        ...agent ? { agent } : {},
-        ...model ? { model } : {},
-        partial: p.partial,
-        ...p.ttftMs === undefined ? {} : { ttftMs: p.ttftMs },
-        ...output === undefined ? {} : { outputTokens: output },
-        ...validDuration ? { durationMs: duration } : {},
-        ...output !== undefined && validDuration ? { tps: output * 1000 / duration } : {}
-      });
+      if (this.dropped > 0) {
+        this.pending.unshift(line);
+        line = this.gapLine("history-records-dropped", this.dropped);
+        this.dropped = 0;
+      }
+      const size = Buffer.byteLength(line);
+      const now = this.now();
+      if (!this.active || this.bytes + size > Math.min(4 * 1024 * 1024, this.config.maxBytes) || now - this.started >= 3600000) {
+        this.active = undefined;
+        this.bytes = 0;
+        await this.prune(size);
+        this.started = now;
+        this.active = `${now}-${crypto.randomUUID()}.jsonl`;
+      } else
+        await this.prune(size);
+      if (!this.active) {
+        this.started = now;
+        this.active = `${now}-${crypto.randomUUID()}.jsonl`;
+      }
+      const file = await open(join(this.path, this.active), "a", 384);
+      try {
+        await file.writeFile(line);
+      } finally {
+        await file.close();
+      }
+      this.bytes += size;
     }
   }
+  health() {
+    return { unavailable: this.disabled, droppedRecords: this.droppedTotal };
+  }
+  async flush() {
+    while (this.working)
+      await this.working;
+  }
+  async initialize() {
+    if (!this.config.enabled)
+      return;
+    await mkdir(this.path, { recursive: true, mode: 448 }).then(() => this.prune()).catch(() => {
+      this.disabled = true;
+      this.report("history-unavailable");
+    });
+  }
+}
+function scalarPerformance(p) {
   return {
-    schema: 1,
-    series: [...series.values()].map((s) => ({
-      ...s,
-      originalPoints: s.points.length,
-      points: downsamplePoints(s.points, maxPoints)
-    })),
-    gaps: gaps.slice(-1024),
-    omittedGaps: Math.max(0, gaps.length - 1024),
-    omittedSessions: Math.max(0, sessions.length - selected.size),
-    maxPoints
+    observedSince: p.observedSince,
+    sessionCreatedAt: p.sessionCreatedAt,
+    at: p.at,
+    status: p.status,
+    partial: p.partial,
+    estimatedOutputTokens: p.estimatedOutputTokens,
+    modelOutputTokens: p.modelOutputTokens,
+    modelDurationMs: p.modelDurationMs,
+    completedRequests: p.completedRequests,
+    tokenSource: p.tokenSource,
+    ...Object.fromEntries([
+      "sessionOutputTokens",
+      "liveTps",
+      "averageModelTps",
+      "averageSessionTps",
+      "ttftMs",
+      "latestRequestTps",
+      "requestId",
+      "requestAgent",
+      "requestModel",
+      "requestOutputTokens",
+      "requestStartedAt",
+      "firstOutputAt",
+      "streamEndedAt"
+    ].flatMap((key) => {
+      const value = p[key];
+      return value === undefined ? [] : [[key, value]];
+    }))
   };
 }
-
-// src/chartreport.ts
-function renderChartReport(report) {
-  const payload = JSON.stringify(report).replace(/[<>&\u2028\u2029]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
-  return `<!doctype html>
-<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
-<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src blob: data:; connect-src 'none'">
-<title>Context Guard \xB7 Performance history</title>
-<style>
-:root{color-scheme:dark;font-family:system-ui,sans-serif;background:#0b1120;color:#e2e8f0}*{box-sizing:border-box}body{max-width:1600px;margin:auto;padding:28px}h1{font-size:28px;letter-spacing:-.03em;margin:8px 0}h2{font-size:16px;margin:0}p{color:#a8b5cb;line-height:1.6;margin:8px 0}.eyebrow{color:#7dd3fc;font-size:12px;letter-spacing:.13em;text-transform:uppercase}.toolbar,.stats,.charts{display:grid;gap:14px;margin-top:22px}.toolbar{grid-template-columns:2fr 1fr 1fr 1.4fr 1.4fr auto;align-items:end}label{font-size:12px;color:#a8b5cb;display:grid;gap:7px}select,input,button{background:#172338;border:1px solid #33435a;border-radius:7px;color:inherit;padding:10px;min-width:0;font:inherit}button{cursor:pointer;font-size:12px}button:hover,button:focus-visible{border-color:#7dd3fc}select:focus-visible,input:focus-visible{outline:2px solid #7dd3fc}.stats{grid-template-columns:repeat(4,1fr)}.stat,.chart{background:#111c2e;border:1px solid #26354e;border-radius:12px;padding:18px}.stat strong{font-size:24px;display:block;margin-top:7px}.stat span{font-size:12px;color:#a8b5cb}.charts{grid-template-columns:repeat(2,minmax(0,1fr))}.charthead{display:flex;justify-content:space-between;align-items:center;gap:10px}.chart p{font-size:12px;min-height:38px}.chart svg{display:block;width:100%;height:auto}.notice{padding:12px 15px;border-left:3px solid #fbbf24;background:#201f2d;font-size:13px;margin-top:15px}.legend{display:flex;flex-wrap:wrap;gap:8px 18px;margin-top:18px;font-size:12px}.legend span{overflow-wrap:anywhere}.dot{display:inline-block;width:9px;height:9px;border-radius:50%;margin-right:7px}.empty{padding:30px;text-align:center;color:#a8b5cb}.tooltip{position:fixed;z-index:5;pointer-events:none;background:#e2e8f0;color:#0b1120;border-radius:7px;padding:10px;max-width:360px;white-space:pre-wrap;font-size:12px;box-shadow:0 8px 30px #0008}footer{margin-top:25px;font-size:12px;color:#a8b5cb}svg circle:focus{outline:none;stroke:white;stroke-width:3}@media(max-width:1000px){.toolbar{grid-template-columns:repeat(2,minmax(0,1fr))}.charts{grid-template-columns:1fr}}@media(max-width:600px){body{padding:16px}.stats{grid-template-columns:repeat(2,1fr)}}@media print{button,.toolbar,.tooltip{display:none}body{padding:0}.chart{break-inside:avoid}.charts{grid-template-columns:1fr}}
-</style></head><body>
-<header><span class="eyebrow">Context Guard / Local analysis</span><h1>Performance history</h1><p>Compare agent instances over time. All timestamps are UTC. This report is an offline snapshot of retained metrics.</p></header>
-<section class="toolbar" aria-label="Chart filters">
-<label>Session instance<select id="session"></select></label><label>Agent<select id="agent"></select></label><label>Model<select id="model"></select></label>
-<label>From (UTC)<input id="from" type="datetime-local" step="1"></label><label>To (UTC)<input id="to" type="datetime-local" step="1"></label><button id="reset">Reset filters</button>
-</section>
-<div id="notice" class="notice" role="status"></div><section id="stats" class="stats" aria-label="Request statistics"></section>
-<div id="legend" class="legend"></div><main id="charts" class="charts"></main>
-<footer>Live TPS uses a character estimate; TTFT includes output publication delay. Dashed curves mark estimates or partial observations. Gaps and missing samples are never filled with zero. Request statistics use retained matching requests; average curves retain the session's original cumulative totals. Agent/model filters select observations, not recomputed lifetime averages. Exported SVGs reflect the current filters. Regenerate this report to include new history.</footer>
-<div id="tooltip" class="tooltip" hidden role="tooltip"></div>
-<script id="chart-data" type="application/json">${payload}</script>
-<script>(${chartClient.toString()})(JSON.parse(document.getElementById("chart-data").textContent));</script>
-</body></html>`;
-}
-function chartClient(report) {
-  const { data, metadata } = report;
-  const element = (id, kind) => {
-    const node = document.getElementById(id);
-    if (!(node instanceof kind))
-      throw new Error(`Missing report element ${id}`);
-    return node;
-  };
-  const session = element("session", HTMLSelectElement), agent = element("agent", HTMLSelectElement), model = element("model", HTMLSelectElement);
-  const from = element("from", HTMLInputElement), to = element("to", HTMLInputElement);
-  const charts = element("charts", HTMLElement), stats = element("stats", HTMLElement), legend = element("legend", HTMLElement);
-  const notice = element("notice", HTMLElement), tooltip = element("tooltip", HTMLElement);
-  const color = (index) => `hsl(${(index * 137.508 + 195) % 360}, 78%, 68%)`;
-  const date = (value) => {
-    const d = new Date(value);
-    return Number.isFinite(d.getTime()) ? d.toISOString() : String(value);
-  };
-  const number = (n, digits = 1) => n === undefined ? "Unavailable" : n.toLocaleString("en-US", { maximumFractionDigits: digits });
-  function options(select, values) {
-    for (const v of values) {
-      const o = document.createElement("option");
-      o.value = v.value;
-      o.textContent = v.label;
-      select.append(o);
+async function readPerformanceHistory(directory, filter = {}) {
+  const records = [];
+  const files = await segments(directory);
+  const maxBytes = filter.maxBytes ?? 64 * 1024 * 1024;
+  let bytes = 0, skippedBytes = 0, malformedRecords = 0;
+  const selected = [];
+  for (const file of files.slice().reverse()) {
+    if (bytes + file.bytes > maxBytes) {
+      skippedBytes += file.bytes;
+      continue;
     }
+    bytes += file.bytes;
+    selected.unshift(file);
   }
-  options(session, [
-    { value: "*", label: "Compare sessions (up to 12)" },
-    ...data.series.map((s) => ({
-      value: s.sessionId,
-      label: `${s.agents.join(", ") || "Agent"} \xB7 ${s.sessionId}`
-    }))
-  ]);
-  options(agent, [
-    { value: "*", label: "All agents" },
-    ...[...new Set(data.series.flatMap((s) => s.agents))].sort().map((v) => ({ value: v, label: v }))
-  ]);
-  options(model, [
-    { value: "*", label: "All models" },
-    ...[...new Set(data.series.flatMap((s) => s.models))].sort().map((v) => ({ value: v, label: v }))
-  ]);
-  function reset() {
-    session.value = data.series[0]?.sessionId ?? "*";
-    agent.value = report.agent ?? "*";
-    model.value = report.model ?? "*";
-    from.value = report.from === undefined ? "" : date(report.from).slice(0, 19);
-    to.value = report.to === undefined ? "" : date(report.to).slice(0, 19);
-  }
-  const timestamp = (value) => value ? Date.parse(`${value}Z`) : undefined;
-  function matches2(p, start, end) {
-    return (agent.value === "*" || p.agent === agent.value) && (model.value === "*" || p.model === model.value) && (start === undefined || p.time >= start) && (end === undefined || p.time <= end);
+  for (const file of selected) {
+    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");
+    } finally {
+      await handle.close();
+    }
+    for (const line of source.split("\n")) {
+      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++;
+      }
+    }
   }
-  const ns = "http://www.w3.org/2000/svg";
-  function svgNode(name, attrs = {}, text2) {
-    const n = document.createElementNS(ns, name);
-    for (const [key, value] of Object.entries(attrs))
-      n.setAttribute(key, String(value));
-    if (text2 !== undefined)
-      n.textContent = text2;
-    return n;
+  const metadata = {
+    schema: 1,
+    ...files[0] ? { retainedFrom: files[0].time } : {},
+    retainedBytes: files.reduce((n, f) => n + f.bytes, 0),
+    skippedBytes,
+    malformedRecords,
+    completeness: "bounded-retention"
+  };
+  return { metadata, records };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isHistoryRecord(value) {
+  if (!isRecord(value))
+    return false;
+  const r = value;
+  const allowed = new Set([
+    "schema",
+    "recordId",
+    "time",
+    "type",
+    "sessionId",
+    "parentId",
+    "agent",
+    "model",
+    "event",
+    "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
+var exports_command = {};
+__export(exports_command, {
+  parseDashboardArgs: () => parseDashboardArgs,
+  loadTerminalRenderer: () => loadTerminalRenderer,
+  dashboardHelp: () => dashboardHelp,
+  checkTerminalRuntime: () => checkTerminalRuntime
+});
+import { isAbsolute, resolve } from "path";
+function parseDashboardArgs(args, cwd, env) {
+  if (args[0] !== "tui") {
+    if (args.length === 1 && args[0] === "--help")
+      return "help";
+    throw new Error("Use context-guard dashboard tui; only tui is supported");
   }
-  function showTooltip(text2, x, y) {
-    tooltip.textContent = text2;
-    tooltip.hidden = false;
-    tooltip.style.left = `${Math.max(8, Math.min(x + 12, window.innerWidth - 370))}px`;
-    tooltip.style.top = `${Math.max(8, Math.min(y + 12, window.innerHeight - tooltip.offsetHeight - 10))}px`;
+  let server, directory;
+  const seen = new Set;
+  for (let i = 1;i < args.length; i++) {
+    const flag = args[i];
+    if (flag === "--help" && args.length === 2)
+      return "help";
+    if (flag !== "--server" && flag !== "--directory")
+      throw new Error("Unknown dashboard option; use dashboard tui --help");
+    if (seen.has(flag))
+      throw new Error("Duplicate dashboard option");
+    seen.add(flag);
+    const value = args[++i];
+    if (!value || value.startsWith("--"))
+      throw new Error(`Missing value for ${flag}`);
+    if (flag === "--server")
+      server = value;
+    else
+      directory = value;
   }
-  const definitions = [
-    {
-      key: "liveTps",
-      title: "Live TPS",
-      unit: "tokens / second",
-      description: "Estimated text + reasoning throughput in the rolling collection window.",
-      requests: false,
-      estimated: true
-    },
-    {
-      key: "averageModelTps",
-      title: "Average model throughput",
-      unit: "tokens / second",
-      description: "Session output / matched model-request time, including TTFT and excluding subsequent tool time.",
-      requests: false,
-      estimated: false
-    },
-    {
-      key: "averageSessionTps",
-      title: "Average session throughput",
-      unit: "tokens / second",
-      description: "Session output / elapsed session lifetime, including tools and idle time.",
-      requests: false,
-      estimated: false
-    },
-    {
-      key: "ttftMs",
-      title: "Time to first output",
-      unit: "seconds",
-      description: "One point per request with observed text/reasoning output. Includes publication delay.",
-      requests: true,
-      estimated: true
-    },
-    {
-      key: "tps",
-      title: "Completed request throughput",
-      unit: "tokens / second",
-      description: "Reported output + reasoning / request duration. Requests are never joined into a continuous curve.",
-      requests: true,
-      estimated: false
-    },
-    {
-      key: "sessionOutputTokens",
-      title: "Cumulative output",
-      unit: "tokens",
-      description: "Authoritative session output + reasoning totals. Lifecycle and sample records are snapshots, not increments.",
-      requests: false,
-      estimated: false
+  if (server !== undefined && (!directory || !isAbsolute(directory)))
+    throw new Error("Explicit servers require --directory with an absolute server path");
+  return {
+    directory: server === undefined ? resolve(cwd, directory ?? ".") : directory ?? cwd,
+    ...server === undefined ? {} : {
+      server,
+      ...env.CONTEXT_GUARD_PASSWORD === undefined ? {} : {
+        password: env.CONTEXT_GUARD_PASSWORD,
+        username: env.CONTEXT_GUARD_USERNAME ?? "opencode"
+      }
     }
-  ];
-  function render() {
-    tooltip.hidden = true;
-    charts.replaceChildren();
-    stats.replaceChildren();
-    legend.replaceChildren();
-    const start = timestamp(from.value), end = timestamp(to.value);
-    if (start !== undefined && !Number.isFinite(start) || end !== undefined && !Number.isFinite(end) || start !== undefined && end !== undefined && start > end) {
-      notice.textContent = "Choose a valid time range with From before To.";
+  };
+}
+function checkTerminalRuntime(version, interactive) {
+  const [major = 0, minor = 0] = version.split(".").map(Number);
+  if (major < 1 || major === 1 && minor < 3 || !Number.isFinite(major + minor))
+    throw new Error("dashboard tui requires Bun >=1.3.0; other commands support Bun >=1.1.34");
+  if (!interactive)
+    throw new Error("dashboard tui requires an interactive input and output terminal; run it directly in a terminal");
+}
+async function loadTerminalRenderer() {
+  try {
+    return await import("@opentui/core");
+  } catch {
+    throw new Error("Terminal renderer unavailable; reinstall @cesarus777/opencode-cgp with optional dependencies enabled for its platform renderer, using Bun >=1.3.0");
+  }
+}
+var dashboardHelp = `Usage: context-guard dashboard tui [options]
+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
+
+Options
+  --directory PATH   Owning project directory (local default: current directory)
+  --server URL       Connect to an explicit server; requires --directory with
+                     an absolute server-side project path. Use HTTPS except
+                     on loopback. Credentials in URLs are rejected.
+  -h, --help         Show this help
+
+Examples
+  context-guard dashboard tui
+  context-guard dashboard tui --directory /absolute/project
+  context-guard dashboard tui --server https://server.example --directory /server/project
+
+Requirements
+  Interactive terminal and Bun >=1.3.0. The OpenTUI renderer is installed
+  automatically with CGP. This command never starts a server.
+
+Authentication (explicit servers)
+  CONTEXT_GUARD_PASSWORD   Server password
+  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.`;
+var init_command = () => {
+};
+
+// src/family.ts
+function metric(snapshot, now, staleMs) {
+  const m = snapshot?.measurement;
+  const freshness = !m ? "missing" : m.model !== snapshot?.model || m.at > now ? "invalid" : now - m.at > staleMs ? "stale" : "fresh";
+  const t = snapshot?.policy.triggerTokens;
+  const valid2 = freshness === "fresh" && m !== undefined;
+  const displayable = valid2 || freshness === "stale" && m !== undefined;
+  const pressureRatio = valid2 && t !== undefined && t > 0 ? m.tokens / t : undefined;
+  const crossed = valid2 && t !== undefined && t > 0 && (snapshot?.policy.comparison === ">" ? m.tokens > t : m.tokens >= t);
+  return {
+    freshness,
+    pressure: pressureRatio === undefined ? "unknown" : crossed ? "crossed" : pressureRatio >= 0.9 ? "near" : "normal",
+    ...pressureRatio === undefined ? {} : { pressureRatio },
+    ...displayable && snapshot?.capacityTokens && snapshot.capacityTokens > 0 ? { utilizationPercent: m.tokens / snapshot.capacityTokens * 100 } : {},
+    ...valid2 && t !== undefined ? { triggerDeltaTokens: t - m.tokens } : {}
+  };
+}
+function familyRows(nodes, snapshots, current, now, staleMs, expanded = new Set, limit = 1024, timing, stableOrder = []) {
+  const byId = new Map(nodes.map((n) => [n.sessionId, n]));
+  const children = new Map;
+  for (const n of byId.values()) {
+    const parent = n.parentId && byId.has(n.parentId) ? n.parentId : "";
+    const list = children.get(parent) ?? [];
+    list.push(n);
+    children.set(parent, list);
+  }
+  const metrics = new Map([...byId.keys()].map((id) => [
+    id,
+    metric(snapshots.get(id), timing?.(id).now ?? now, timing?.(id).staleMs ?? staleMs)
+  ]));
+  const protectedIds = new Set;
+  let ancestor = byId.get(current);
+  while (ancestor && !protectedIds.has(ancestor.sessionId)) {
+    protectedIds.add(ancestor.sessionId);
+    ancestor = ancestor.parentId ? byId.get(ancestor.parentId) : undefined;
+  }
+  const scores = new Map, sensitive = new Map, sizes = new Map;
+  const calculate = (n, seen) => {
+    if (seen.has(n.sessionId))
+      return -1;
+    if (scores.has(n.sessionId))
+      return scores.get(n.sessionId) ?? -1;
+    const path = new Set(seen).add(n.sessionId), m = metrics.get(n.sessionId);
+    let score = m?.pressureRatio ?? -1, size = 1;
+    let keep = protectedIds.has(n.sessionId) || n.status === "running" || m?.pressure === "crossed" || ["blocked", "uncertain"].includes(snapshots.get(n.sessionId)?.compaction.phase ?? "");
+    for (const child of children.get(n.sessionId) ?? []) {
+      score = Math.max(score, calculate(child, path));
+      size += sizes.get(child.sessionId) ?? 0;
+      keep ||= sensitive.get(child.sessionId) ?? false;
+    }
+    scores.set(n.sessionId, score);
+    sizes.set(n.sessionId, size);
+    sensitive.set(n.sessionId, keep);
+    return score;
+  };
+  for (const n of byId.values())
+    calculate(n, new Set);
+  const visited = new Set, rows = [];
+  const visit = (n, depth) => {
+    if (visited.has(n.sessionId) || rows.length >= limit || depth > 64)
       return;
+    visited.add(n.sessionId);
+    const snapshot = snapshots.get(n.sessionId), m = metrics.get(n.sessionId) ?? metric(undefined, now, staleMs);
+    const collapsed = n.status === "completed" && !sensitive.get(n.sessionId) && !expanded.has(n.sessionId);
+    rows.push({
+      node: n,
+      ...snapshot ? { snapshot } : {},
+      depth,
+      current: n.sessionId === current,
+      ...m,
+      hidden: collapsed ? (sizes.get(n.sessionId) ?? 1) - 1 : 0
+    });
+    if (collapsed) {
+      const pending = [...children.get(n.sessionId) ?? []];
+      while (pending.length) {
+        const child = pending.pop();
+        if (!child || visited.has(child.sessionId))
+          continue;
+        visited.add(child.sessionId);
+        pending.push(...children.get(child.sessionId) ?? []);
+      }
     }
-    const selected = data.series.filter((s) => (session.value === "*" || s.sessionId === session.value) && s.points.some((p) => matches2(p, start, end)) || (session.value === "*" || s.sessionId === session.value) && s.requests.some((p) => matches2(p, start, end)));
-    const visible = selected.slice(0, 12);
-    const requests = visible.flatMap((s) => s.requests.filter((r) => matches2(r, start, end)));
-    const matched = requests.filter((r) => r.outputTokens !== undefined && r.durationMs !== undefined && r.durationMs > 0);
-    const duration = matched.reduce((sum, r) => sum + (r.durationMs ?? 0), 0), tokens = matched.reduce((sum, r) => sum + (r.outputTokens ?? 0), 0);
-    const ttfts = requests.flatMap((r) => r.ttftMs === undefined ? [] : [r.ttftMs]).sort((a, b) => a - b);
-    const percentile = (q) => ttfts.length ? (ttfts[Math.max(0, Math.ceil(ttfts.length * q) - 1)] ?? 0) / 1000 : undefined;
-    for (const [label, value] of [
-      ["Matched / observed requests", `${matched.length} / ${requests.length}`],
-      [
-        "Retained request throughput",
-        duration ? `${number(tokens * 1000 / duration)} t/s` : "Unavailable"
-      ],
-      [
-        "Median observed TTFT",
-        ttfts.length ? `${number(percentile(0.5), 2)}s` : "Unavailable"
-      ],
-      [
-        "95th percentile TTFT",
-        ttfts.length ? `${number(percentile(0.95), 2)}s` : "Unavailable"
-      ]
-    ]) {
-      const box = document.createElement("div");
-      box.className = "stat";
-      const name = document.createElement("span"), valueNode = document.createElement("strong");
-      name.textContent = label ?? "";
-      valueNode.textContent = value ?? "";
-      box.append(name, valueNode);
-      stats.append(box);
+    if (!collapsed)
+      for (const child of sorted(children.get(n.sessionId) ?? []))
+        visit(child, depth + 1);
+  };
+  const ranks = new Map(stableOrder.map((id, i) => [id, i]));
+  const sorted = (items) => [...items].sort((a, b) => (stableOrder.length ? (ranks.get(a.sessionId) ?? Infinity) - (ranks.get(b.sessionId) ?? Infinity) : 0) || (scores.get(b.sessionId) ?? -1) - (scores.get(a.sessionId) ?? -1) || a.sessionId.localeCompare(b.sessionId));
+  for (const n of sorted(children.get("") ?? []))
+    visit(n, 0);
+  for (const n of byId.values())
+    if (!visited.has(n.sessionId) && rows.length < limit)
+      visit(n, 0);
+  return rows;
+}
+function executionStatus(known, nativeRunning, evidence) {
+  if (nativeRunning || evidence.startedAt !== undefined && evidence.startedAt > (evidence.terminalAt ?? -1))
+    return "running";
+  if (evidence.outcome && (evidence.terminalAt ?? -1) >= (evidence.startedAt ?? -1))
+    return evidence.outcome === "succeeded" ? "completed" : evidence.outcome === "failed" ? "failed" : "unknown";
+  return known ? "idle" : "unknown";
+}
+
+// src/tui/transport.ts
+class SnapshotClient {
+  transport;
+  changed;
+  elapsed;
+  rows = new Map;
+  health;
+  connection = "loading";
+  epoch;
+  sequence = -1;
+  revisions = new Map;
+  baselines = new Map;
+  controller;
+  generation = 0;
+  ids = [];
+  location = "";
+  refreshTimer;
+  reading;
+  buffered = [];
+  overflow = false;
+  retryTimer;
+  failures = 0;
+  serverAt = 0;
+  receivedAt = 0;
+  refreshAgain = false;
+  subscriptionActive = false;
+  constructor(transport, changed, elapsed = () => performance.now()) {
+    this.transport = transport;
+    this.changed = changed;
+    this.elapsed = elapsed;
+  }
+  now() {
+    return this.serverAt + Math.max(0, this.elapsed() - this.receivedAt);
+  }
+  setIds(ids) {
+    const next = [...new Set(ids)].slice(0, 2048);
+    if (JSON.stringify(next) === JSON.stringify(this.ids))
+      return;
+    this.ids = next;
+    const selected = new Set(next);
+    for (const id of new Set([
+      ...this.revisions.keys(),
+      ...this.baselines.keys()
+    ]))
+      if (!selected.has(id)) {
+        this.revisions.delete(id);
+        this.baselines.delete(id);
+        this.rows.delete(id);
+      }
+    if (this.reading)
+      this.refreshAgain = true;
+    else
+      this.refresh();
+  }
+  start(location, ids) {
+    this.stop();
+    this.location = location;
+    this.ids = [...new Set(ids)].slice(0, 2048);
+    this.rows.clear();
+    this.revisions.clear();
+    this.baselines.clear();
+    this.health = undefined;
+    this.epoch = undefined;
+    this.sequence = -1;
+    this.failures = 0;
+    this.connection = "loading";
+    const controller = new AbortController;
+    this.controller = controller;
+    const generation = ++this.generation;
+    this.supervise(generation, controller.signal);
+    this.refreshTimer = setInterval(() => {
+      this.refresh();
+    }, 15000);
+    this.refresh();
+  }
+  merge(batch, baseline = false, requested = []) {
+    if (this.epoch !== batch.epoch) {
+      if (!baseline) {
+        this.connection = "reconnecting";
+        this.refreshAgain = true;
+        return;
+      }
+      this.rows.clear();
+      this.revisions.clear();
+      this.baselines.clear();
+      this.epoch = batch.epoch;
+      this.sequence = -1;
     }
-    const gaps = data.gaps.filter((g) => (g.sessionId === "__history__" || visible.some((s) => s.sessionId === g.sessionId)) && (start === undefined || g.time >= start) && (end === undefined || g.time <= end));
-    const notes = [
-      `Bounded retained history: ${metadata.retainedFrom === undefined ? "empty archive" : `segments since ${date(metadata.retainedFrom)}`}.`,
-      `${gaps.length} recorded gap markers.`
-    ];
-    if (metadata.skippedBytes)
-      notes.push(`${number(metadata.skippedBytes, 0)} bytes excluded by the read limit.`);
-    if (metadata.malformedRecords)
-      notes.push(`${metadata.malformedRecords} malformed/partial records skipped.`);
-    if (data.omittedGaps)
-      notes.push(`${data.omittedGaps} older gap markers omitted; curve discontinuities remain preserved.`);
-    if (data.omittedSessions)
-      notes.push(`${data.omittedSessions} sessions omitted from the report limit; regenerate with --session to inspect one.`);
-    if (selected.length > 12)
-      notes.push(`Showing 12 of ${selected.length} matching sessions; select a session for detail.`);
-    if (visible.some((s) => s.originalPoints > s.points.length))
-      notes.push(`Curves downsampled to at most ${data.maxPoints} observations per session, preserving extrema and gaps.`);
-    if (visible.some((s) => s.points.some((p) => p.partial && matches2(p, start, end))))
-      notes.push("Partial timing coverage is present.");
-    if (!visible.length)
-      notes.push("No observations match these filters.");
-    notice.textContent = notes.join(" ");
-    visible.forEach((s, index) => {
-      const item = document.createElement("span"), dot = document.createElement("i");
-      dot.className = "dot";
-      dot.style.backgroundColor = color(index);
-      item.append(dot, document.createTextNode(`${s.agents.join(", ") || "Agent"} \xB7 ${s.sessionId}${s.parentId ? ` (child of ${s.parentId})` : ""}`));
-      legend.append(item);
+    if (!baseline && batch.sequence > this.sequence + 1) {
+      this.connection = "reconnecting";
+      this.refreshAgain = true;
+    }
+    if (batch.sequence >= this.sequence) {
+      this.sequence = batch.sequence;
+      this.health = batch.health;
+      this.serverAt = batch.generatedAt;
+      this.receivedAt = this.elapsed();
+    }
+    const selected = new Set(baseline ? requested.filter((id) => this.ids.includes(id)) : this.ids);
+    for (const row2 of batch.upserts)
+      if (selected.has(row2.sessionId) && (baseline || batch.sequence > (this.baselines.get(row2.sessionId) ?? -1)) && row2.revision > (this.revisions.get(row2.sessionId) ?? -1)) {
+        this.rows.set(row2.sessionId, row2);
+        this.revisions.set(row2.sessionId, row2.revision);
+      }
+    for (const row2 of batch.removed)
+      if (selected.has(row2.sessionId) && (baseline || batch.sequence > (this.baselines.get(row2.sessionId) ?? -1)) && row2.revision > (this.revisions.get(row2.sessionId) ?? -1)) {
+        this.rows.delete(row2.sessionId);
+        this.revisions.set(row2.sessionId, row2.revision);
+      }
+    this.changed();
+  }
+  refresh() {
+    if (this.reading)
+      return this.reading;
+    const controller = this.controller, generation = this.generation, location = this.location;
+    if (!controller)
+      return Promise.resolve();
+    clearTimeout(this.retryTimer);
+    const requestedIds = [...this.ids];
+    this.reading = (async () => {
+      const signal = AbortSignal.any([
+        controller.signal,
+        AbortSignal.timeout(5000)
+      ]);
+      const chunks = [];
+      for (let i = 0;i < requestedIds.length; i += 128)
+        chunks.push(requestedIds.slice(i, i + 128));
+      if (!chunks.length)
+        chunks.push([]);
+      const results = [];
+      for (let i = 0;i < chunks.length; i += 2) {
+        const reads = await Promise.all(chunks.slice(i, i + 2).map(async (ids) => {
+          const value = await abortable(this.transport.read(location, ids, signal), signal);
+          if (generation !== this.generation)
+            throw new Error("Obsolete read");
+          if (!isPerformanceResult(value)) {
+            this.connection = "incompatible";
+            throw new Error("Incompatible snapshot");
+          }
+          const answered = [
+            ...value.upserts.map((row2) => row2.sessionId),
+            ...value.unavailable.map((row2) => row2.sessionId)
+          ];
+          if (value.removed.length || answered.length !== ids.length || new Set(answered).size !== ids.length || answered.some((id) => !ids.includes(id)))
+            throw new Error("Incomplete snapshot read");
+          return { ids, result: value };
+        }));
+        results.push(...reads);
+      }
+      if (generation !== this.generation || signal.aborted)
+        return;
+      if (new Set(results.map((r) => r.result.epoch)).size !== 1)
+        throw new Error("Epoch changed during read");
+      for (const { ids, result } of results) {
+        this.merge(result, true, ids);
+        for (const missing of result.unavailable)
+          if (this.ids.includes(missing.sessionId))
+            this.rows.delete(missing.sessionId);
+        for (const id of ids)
+          if (this.ids.includes(id))
+            this.baselines.set(id, result.sequence);
+      }
+      const buffered = this.buffered;
+      this.buffered = [];
+      if (buffered.some((b) => b.epoch !== this.epoch) || this.overflow) {
+        this.overflow = false;
+        throw new Error("Stream changed during read");
+      }
+      for (const batch of buffered)
+        this.merge(batch);
+      this.failures = 0;
+      this.connection = this.refreshAgain || !this.subscriptionActive ? "reconnecting" : "live";
+      this.changed();
+    })().catch(() => {
+      if (generation === this.generation && !controller.signal.aborted) {
+        this.buffered = [];
+        this.overflow = false;
+        if (this.connection !== "incompatible")
+          this.connection = this.rows.size ? "reconnecting" : "unavailable";
+        this.changed();
+        this.retryTimer = setTimeout(() => {
+          this.refresh();
+        }, Math.min(30000, 1000 * 2 ** Math.min(this.failures++, 5)));
+      }
+    }).finally(() => {
+      if (generation === this.generation) {
+        this.reading = undefined;
+        if (this.refreshAgain) {
+          this.refreshAgain = false;
+          this.refresh();
+        }
+      }
     });
-    const times = visible.flatMap((s) => [...s.points, ...s.requests].filter((p) => matches2(p, start, end)).map((p) => p.time));
-    let minTime = start ?? times.reduce((a, t) => Math.min(a, t), Infinity), maxTime = end ?? times.reduce((a, t) => Math.max(a, t), -Infinity);
-    if (!Number.isFinite(minTime))
-      minTime = 0;
-    if (!Number.isFinite(maxTime))
-      maxTime = minTime + 1000;
-    if (maxTime <= minTime)
-      maxTime = minTime + 1000;
-    for (const def of definitions) {
-      const card = document.createElement("section");
-      card.className = "chart";
-      const heading = document.createElement("div");
-      heading.className = "charthead";
-      const title = document.createElement("h2");
-      title.textContent = def.title;
-      const download = document.createElement("button");
-      download.textContent = "Save SVG";
-      download.setAttribute("aria-label", `Save ${def.title} as SVG`);
-      heading.append(title, download);
-      const desc = document.createElement("p");
-      desc.textContent = def.description;
-      card.append(heading, desc);
-      charts.append(card);
-      const plots = visible.map((s) => {
-        if (def.requests)
-          return s.requests.filter((p) => matches2(p, start, end)).map((p) => {
-            const raw = def.key === "ttftMs" ? p.ttftMs : p.tps;
-            return {
-              ...p,
-              breakBefore: true,
-              ...raw === undefined ? {} : { value: def.key === "ttftMs" ? raw / 1000 : raw }
-            };
+    return this.reading;
+  }
+  async supervise(generation, signal) {
+    let retry = 0;
+    while (!signal.aborted && generation === this.generation) {
+      try {
+        this.subscriptionActive = true;
+        if (retry)
+          queueMicrotask(() => {
+            if (generation === this.generation && !signal.aborted)
+              this.refresh();
           });
-        let skipped = false;
-        return s.points.flatMap((p) => {
-          if (!matches2(p, start, end)) {
-            skipped = true;
-            return [];
+        for await (const value of this.transport.subscribe(this.location, signal)) {
+          if (signal.aborted || generation !== this.generation)
+            return;
+          if (!isPerformanceBatch(value)) {
+            this.connection = "incompatible";
+            this.changed();
+            continue;
           }
-          const key = def.key;
-          const value = key === "liveTps" ? p.liveTps : key === "averageModelTps" ? p.averageModelTps : key === "averageSessionTps" ? p.averageSessionTps : p.sessionOutputTokens;
-          const point = {
-            ...p,
-            breakBefore: p.breakBefore || skipped,
-            ...value === undefined ? {} : { value }
-          };
-          skipped = false;
-          return [point];
-        });
-      });
-      const drawn = plots.map((points) => {
-        if (!def.requests || points.length <= data.maxPoints)
-          return points;
-        const bins = Math.max(1, Math.floor(data.maxPoints / 4)), chosen = new Set;
-        for (let b = 0;b < bins; b++) {
-          const first = Math.floor(b * points.length / bins), last = Math.floor((b + 1) * points.length / bins) - 1;
-          chosen.add(first);
-          chosen.add(last);
-          let low = first, high = first;
-          for (let i = first;i <= last; i++) {
-            if ((points[i]?.value ?? Infinity) < (points[low]?.value ?? Infinity))
-              low = i;
-            if ((points[i]?.value ?? -Infinity) > (points[high]?.value ?? -Infinity))
-              high = i;
+          if (this.reading || !this.epoch) {
+            if (this.buffered.length < 256)
+              this.buffered.push(value);
+            else
+              this.overflow = true;
+          } else {
+            this.merge(value);
+            if (this.refreshAgain) {
+              this.refreshAgain = false;
+              this.refresh();
+            }
           }
-          chosen.add(low);
-          chosen.add(high);
+          retry = 0;
         }
-        return [...chosen].sort((a, b) => a - b).flatMap((i) => points[i] ? [points[i]] : []);
-      });
-      const maxValue = drawn.reduce((maximum, points) => points.reduce((n, p) => Math.max(n, p.value ?? 0), maximum), 1) * 1.08;
-      const w = 720, h = 300, left = 64, right = 20, top = 24, bottom = 47;
-      const x = (t) => left + (t - minTime) / (maxTime - minTime) * (w - left - right);
-      const y = (v) => h - bottom - v / maxValue * (h - top - bottom);
-      const svg = svgNode("svg", {
-        viewBox: `0 0 ${w} ${h}`,
-        role: "img",
-        "aria-label": `${def.title} over UTC timestamps`,
-        xmlns: ns
-      });
-      svg.append(svgNode("rect", { width: w, height: h, fill: "#111c2e" }), svgNode("title", {}, `${def.title}. ${def.description}`));
-      svg.append(svgNode("text", {
-        x: left,
-        y: 14,
-        fill: "#a8b5cb",
-        "font-size": 11,
-        "font-family": "system-ui,sans-serif"
-      }, def.unit));
-      for (let tick = 0;tick <= 4; tick++) {
-        const v = maxValue * tick / 4;
-        svg.append(svgNode("line", {
-          x1: left,
-          x2: w - right,
-          y1: y(v),
-          y2: y(v),
-          stroke: "#2a3950",
-          "stroke-width": 1
-        }));
-        svg.append(svgNode("text", {
-          x: left - 8,
-          y: y(v) + 4,
-          fill: "#a8b5cb",
-          "text-anchor": "end",
-          "font-size": 11,
-          "font-family": "system-ui,sans-serif"
-        }, v >= 1e4 ? `${number(v / 1000)}k` : number(v)));
-        const t = minTime + (maxTime - minTime) * tick / 4;
-        const label = maxTime - minTime > 86400000 ? date(t).slice(5, 16).replace("T", " ") : date(t).slice(11, 19);
-        svg.append(svgNode("text", {
-          x: x(t),
-          y: h - 22,
-          fill: "#a8b5cb",
-          "text-anchor": tick === 0 ? "start" : tick === 4 ? "end" : "middle",
-          "font-size": 11,
-          "font-family": "system-ui,sans-serif"
-        }, label));
+      } catch {
       }
-      for (const gap of gaps)
-        if (gap.time >= minTime && gap.time <= maxTime) {
-          const line = svgNode("line", {
-            x1: x(gap.time),
-            x2: x(gap.time),
-            y1: top,
-            y2: h - bottom,
-            stroke: "#fb7185",
-            "stroke-dasharray": "3 5",
-            opacity: 0.65
-          });
-          line.append(svgNode("title", {}, `${date(gap.time)} \xB7 ${gap.reason}`));
-          svg.append(line);
-        }
-      let count2 = 0;
-      drawn.forEach((points, index) => {
-        let run = [];
-        const flush = () => {
-          if (run.length > 1)
-            svg.append(svgNode("polyline", {
-              points: run.map((p) => `${x(p.time)},${y(p.value ?? 0)}`).join(" "),
-              fill: "none",
-              stroke: color(index),
-              "stroke-width": 1.8,
-              ...def.estimated || run.some((p) => p.partial) ? { "stroke-dasharray": "5 4" } : {}
-            }));
-          run = [];
+      if (signal.aborted || generation !== this.generation)
+        return;
+      this.subscriptionActive = false;
+      this.connection = "reconnecting";
+      this.changed();
+      await this.refresh();
+      await new Promise((resolve2) => {
+        const finish = () => {
+          clearTimeout(timer);
+          signal.removeEventListener("abort", finish);
+          resolve2();
         };
-        for (const point of points) {
-          if (point.breakBefore || point.value === undefined)
-            flush();
-          if (point.value === undefined)
-            continue;
-          count2++;
-          if (!def.requests)
-            run.push(point);
-          const label = `${date(point.time)}\n${visible[index]?.sessionId ?? ""}${point.agent ? ` \xB7 ${point.agent}` : ""}${point.model ? `\n${point.model}` : ""}\n${def.title}: ${def.estimated ? "~" : ""}${number(point.value, 3)} ${def.unit}${point.requestId ? `\nRequest: ${point.requestId}` : ""}${point.partial ? "\nPartial observation coverage" : ""}`;
-          const dot = svgNode("circle", {
-            cx: x(point.time),
-            cy: y(point.value),
-            r: def.requests ? 3 : 2.5,
-            fill: color(index),
-            tabindex: 0,
-            "aria-label": label
-          });
-          dot.append(svgNode("title", {}, label));
-          dot.addEventListener("mouseenter", (e) => showTooltip(label, e.clientX, e.clientY));
-          dot.addEventListener("mouseleave", () => {
-            tooltip.hidden = true;
-          });
-          dot.addEventListener("focus", () => {
-            const box = dot.getBoundingClientRect();
-            showTooltip(label, box.x, box.y);
+        const timer = setTimeout(finish, Math.min(30000, 1000 * 2 ** Math.min(retry++, 5)));
+        signal.addEventListener("abort", finish, { once: true });
+        if (signal.aborted)
+          finish();
+      });
+    }
+  }
+  stop() {
+    this.generation++;
+    this.controller?.abort();
+    this.controller = undefined;
+    clearInterval(this.refreshTimer);
+    clearTimeout(this.retryTimer);
+    this.reading = undefined;
+    this.buffered = [];
+    this.overflow = false;
+    this.refreshAgain = false;
+  }
+}
+function abortable(promise, signal) {
+  return new Promise((resolve2, reject) => {
+    const abort = () => reject(new Error("Snapshot request cancelled"));
+    if (signal.aborted) {
+      abort();
+      return;
+    }
+    signal.addEventListener("abort", abort, { once: true });
+    promise.then(resolve2, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
+var init_transport = __esm(() => {
+  init_rpc();
+});
+
+// src/dashboard/inventory.ts
+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) {
+  validateInventoryLimits(limits);
+  const sessions = new Map;
+  const notices = new Set;
+  const queue = [{ parent: null, depth: 0, cursors: [] }];
+  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;
+        }
+        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: []
           });
-          dot.addEventListener("blur", () => {
-            tooltip.hidden = true;
+        else
+          notices.add("depth-limit");
+      }
+      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]
           });
-          svg.append(dot);
-        }
-        flush();
-      });
-      if (!count2)
-        svg.append(svgNode("text", {
-          x: w / 2,
-          y: h / 2,
-          fill: "#a8b5cb",
-          "text-anchor": "middle",
-          "font-size": 14,
-          "font-family": "system-ui,sans-serif"
-        }, "No measurements in this selection"));
-      card.append(svg);
-      download.onclick = () => {
-        const blob = new Blob([new XMLSerializer().serializeToString(svg)], {
-          type: "image/svg+xml"
-        });
-        const url = URL.createObjectURL(blob);
-        const link = document.createElement("a");
-        link.href = url;
-        link.download = `context-guard-${def.key}.svg`;
-        link.click();
-        setTimeout(() => URL.revokeObjectURL(url), 1000);
-      };
+      }
+    } catch {
+      signal.throwIfAborted();
+      notices.add("inventory-unavailable");
     }
   }
-  for (const control of [session, agent, model, from, to])
-    control.addEventListener("change", render);
-  element("reset", HTMLButtonElement).onclick = () => {
-    reset();
-    render();
+  if (queue.length)
+    notices.add("page-limit");
+  return {
+    sessions: [...sessions.values()],
+    complete: !notices.size,
+    pages,
+    notices: [...notices]
   };
-  reset();
-  render();
 }
+var inventoryLimits;
+var init_inventory = __esm(() => {
+  inventoryLimits = Object.freeze({
+    maxNodes: 1024,
+    maxPages: 100,
+    maxDepth: 64
+  });
+});
 
-// src/history.ts
-import { mkdir, readdir, stat, open, unlink } from "fs/promises";
-import { join } from "path";
-var filename = /^([0-9]+)-[a-f0-9-]+\.jsonl$/;
-async function segments(directory) {
-  const names = await readdir(directory).catch((error) => {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT")
-      return [];
-    throw error;
+// 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;
+}
+function projectHistory(result, filters) {
+  const match = (point) => (!filters.agent || point.agent === filters.agent) && (!filters.model || point.model === filters.model);
+  const series = result.data.series.map((series2) => {
+    let gap = false;
+    const points = series2.points.flatMap((point) => {
+      gap ||= point.breakBefore;
+      if (!match(point))
+        return [];
+      const next = { ...point, breakBefore: gap };
+      gap = false;
+      return [next];
+    });
+    return { ...series2, points, requests: series2.requests.filter(match) };
   });
-  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
-  })))).sort((a, b) => a.time - b.time || a.name.localeCompare(b.name));
+  const requests = series.flatMap((series2) => series2.requests);
+  const matched = requests.filter((request) => request.outputTokens !== undefined && request.durationMs !== undefined && request.durationMs > 0);
+  const output = matched.reduce((sum, request) => sum + (request.outputTokens ?? 0), 0);
+  const duration = matched.reduce((sum, request) => sum + (request.durationMs ?? 0), 0);
+  const partial = result.truncated || result.metadata.skippedBytes > 0 || result.metadata.malformedRecords > 0 || result.data.omittedSessions > 0 || requests.some((request) => request.partial) || matched.length !== requests.length || result.data.gaps.length > 0 || (result.data.omittedGaps ?? 0) > 0;
+  const notices = [
+    "bounded-retention",
+    "maximum-seven-days",
+    "maximum-500-points-and-requests"
+  ];
+  if (!result.enabled)
+    notices.push("history-disabled");
+  if (result.truncated || result.metadata.skippedBytes || result.metadata.malformedRecords || result.data.omittedSessions)
+    notices.push("partial-history");
+  if (result.data.gaps.length || result.data.omittedGaps || result.data.series.some((series2) => series2.points.some((point) => point.breakBefore)))
+    notices.push("history-gaps");
+  if (result.data.series.some((series2) => series2.originalPoints > series2.points.length))
+    notices.push("downsampled-history");
+  if (result.data.series.some((series2) => series2.points.some((point) => point.partial)) || requests.some((request) => request.partial))
+    notices.push("partial-measurements");
+  return {
+    result: { ...result, data: { ...result.data, series } },
+    summary: {
+      source: "matched-request-records",
+      observedRequests: requests.length,
+      matchedRequests: matched.length,
+      partial,
+      ...matched.length ? {
+        outputTokens: output,
+        durationMs: duration,
+        averageModelTps: output * 1000 / duration
+      } : {}
+    },
+    notices
+  };
 }
+var historyWindows;
+var init_view = __esm(() => {
+  historyWindows = [300000, 3600000, 86400000, 604800000];
+});
 
-class PerformanceHistory {
-  path;
-  config;
+// src/dashboard/controller.ts
+class DashboardController {
+  locations = new Map;
+  cache = new Map;
+  listeners = new Set;
+  limits;
   now;
-  report;
-  pending = [];
-  working;
-  active;
-  bytes = 0;
-  started = 0;
-  disabled = false;
-  dropped = 0;
-  droppedTotal = 0;
-  constructor(path, config, now = Date.now, report = () => {
-  }) {
-    this.path = path;
-    this.config = config;
-    this.now = now;
-    this.report = report;
+  elapsed;
+  refreshIntervalMs;
+  state;
+  scope;
+  running = false;
+  screen = "overview";
+  filters = { search: "", agent: "", model: "" };
+  windowMs = 300000;
+  generation = 0;
+  historyGeneration = 0;
+  pendingHistory;
+  historyAbort;
+  historyBusy = false;
+  historyStatus = "idle";
+  refreshTimer;
+  ageTimer;
+  view;
+  constructor(port, options = {}) {
+    this.limits = { ...options.limits ?? inventoryLimits };
+    validateInventoryLimits(this.limits);
+    this.now = options.now ?? Date.now;
+    this.elapsed = options.elapsed ?? (() => performance.now());
+    this.refreshIntervalMs = options.refreshIntervalMs ?? 30000;
+    if (!Number.isSafeInteger(this.refreshIntervalMs) || this.refreshIntervalMs < 0)
+      throw new Error("Invalid dashboard refresh interval");
+    this.state = this.createLocation(port);
+    this.locations.set(port.location.directory, this.state);
+    this.view = this.buildView();
   }
-  emit(record2) {
-    if (!this.config.enabled || this.disabled)
+  createLocation(port) {
+    return {
+      port,
+      nodes: new Map,
+      rows: new Map,
+      connection: "loading",
+      complete: false,
+      stale: true,
+      pages: 0,
+      notices: []
+    };
+  }
+  getView() {
+    return this.view;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.view);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  publish() {
+    this.view = this.buildView();
+    for (const listener of this.listeners) {
+      try {
+        listener(this.view);
+      } catch {
+      }
+    }
+  }
+  async start() {
+    if (this.running)
       return;
-    const line = JSON.stringify({
-      schema: 1,
-      recordId: record2.recordId,
-      time: record2.time,
-      type: record2.type,
-      sessionId: record2.sessionId,
-      ...record2.parentId ? { parentId: record2.parentId } : {},
-      ...record2.agent ? { agent: record2.agent } : {},
-      ...record2.model ? { model: record2.model } : {},
-      ...record2.event ? { event: record2.event } : {},
-      ...record2.droppedRecords === undefined ? {} : { droppedRecords: record2.droppedRecords },
-      ...record2.performance ? { performance: scalarPerformance(record2.performance) } : {}
-    }) + "\n";
-    if (this.pending.length >= 256 || Buffer.byteLength(line) > Math.min(4 * 1024 * 1024, this.config.maxBytes)) {
-      this.dropped++;
-      this.droppedTotal++;
-      if (this.dropped === 1)
-        this.report("history-records-dropped");
+    this.running = true;
+    this.scope = new AbortController;
+    if (this.refreshIntervalMs) {
+      this.refreshTimer = setInterval(() => {
+        this.refresh();
+      }, this.refreshIntervalMs);
+      this.ageTimer = setInterval(() => {
+        this.publish();
+      }, 1000);
+    }
+    await this.refresh();
+  }
+  stop() {
+    this.running = false;
+    this.generation++;
+    this.scope?.abort();
+    this.scope = undefined;
+    this.cancelHistory();
+    clearInterval(this.refreshTimer);
+    clearInterval(this.ageTimer);
+    for (const state of this.locations.values()) {
+      state.client?.stop();
+      delete state.client;
+      delete state.scanning;
+      delete state.probing;
+      state.stale = true;
+      state.connection = "unavailable";
+    }
+    this.publish();
+  }
+  async selectLocation(directory) {
+    if (directory === this.state.port.location.directory)
       return;
+    const port = this.state.port.atLocation(directory);
+    this.scope?.abort();
+    this.state.client?.stop();
+    delete this.state.client;
+    delete this.state.scanning;
+    delete this.state.probing;
+    this.state.stale = true;
+    this.state.connection = "reconnecting";
+    this.cancelHistory();
+    this.generation++;
+    const next = this.locations.get(directory) ?? this.createLocation(port);
+    this.locations.delete(directory);
+    this.locations.set(directory, next);
+    this.state = next;
+    if (this.locations.size > 4) {
+      const oldest = this.locations.keys().next().value;
+      if (oldest !== undefined)
+        this.locations.delete(oldest);
     }
-    this.pending.push(line);
-    this.kick();
+    this.scope = this.running ? new AbortController : undefined;
+    this.historyStatus = "idle";
+    this.publish();
+    if (this.running)
+      await this.refresh();
   }
-  kick() {
-    if (this.working || this.disabled)
+  selectSession(id) {
+    if (!this.state.nodes.has(id))
+      throw new Error("Unknown dashboard session");
+    if (id === this.state.selected)
       return;
-    this.working = this.drain().catch(() => {
-      this.disabled = true;
-      this.pending = [];
-      this.report("history-unavailable");
-    }).finally(() => {
-      this.working = undefined;
-      if (this.pending.length)
-        this.kick();
-    });
+    this.state.selected = id;
+    this.queueHistory();
+    this.publish();
   }
-  async prune(incoming = 0) {
-    const files = await segments(this.path);
-    let total = files.reduce((n, f) => n + f.bytes, 0);
-    let truncated = false;
-    for (const file of files) {
-      if (file.time >= this.now() - this.config.retentionDays * 86400000 && total + incoming <= this.config.maxBytes)
-        break;
-      await unlink(join(this.path, file.name));
-      if (file.name === this.active) {
-        this.active = undefined;
-        this.bytes = 0;
-      }
-      total -= file.bytes;
-      truncated = true;
-    }
-    if (truncated)
-      this.report("history-truncated");
+  setScreen(screen) {
+    if (!["overview", "detail", "history"].includes(screen))
+      throw new Error("Invalid dashboard screen");
+    if (screen === this.screen)
+      return;
+    this.screen = screen;
+    this.queueHistory();
+    this.publish();
   }
-  gapLine(event, droppedRecords) {
-    return JSON.stringify({
-      schema: 1,
-      recordId: crypto.randomUUID(),
-      time: this.now(),
-      type: "gap",
-      sessionId: "__history__",
-      event,
-      ...droppedRecords === undefined ? {} : { droppedRecords }
-    }) + "\n";
+  setWindow(windowMs) {
+    if (!historyWindows.includes(windowMs))
+      throw new Error("Invalid dashboard history window");
+    if (windowMs === this.windowMs)
+      return;
+    this.windowMs = windowMs;
+    this.queueHistory();
+    this.publish();
   }
-  async drain() {
-    await mkdir(this.path, { recursive: true, mode: 448 });
-    await this.prune();
-    while (this.pending.length) {
-      let line = this.pending.shift();
-      if (!line)
-        continue;
-      if (this.dropped > 0) {
-        this.pending.unshift(line);
-        line = this.gapLine("history-records-dropped", this.dropped);
-        this.dropped = 0;
-      }
-      const size = Buffer.byteLength(line);
-      const now = this.now();
-      if (!this.active || this.bytes + size > Math.min(4 * 1024 * 1024, this.config.maxBytes) || now - this.started >= 3600000) {
-        this.active = undefined;
-        this.bytes = 0;
-        await this.prune(size);
-        this.started = now;
-        this.active = `${now}-${crypto.randomUUID()}.jsonl`;
-      } else
-        await this.prune(size);
-      if (!this.active) {
-        this.started = now;
-        this.active = `${now}-${crypto.randomUUID()}.jsonl`;
+  setFilters(filters) {
+    for (const value of Object.values(filters))
+      if (typeof value !== "string" || value.length > 512)
+        throw new Error("Invalid dashboard filter");
+    this.filters = {
+      search: filters.search ?? this.filters.search,
+      agent: filters.agent ?? this.filters.agent,
+      model: filters.model ?? this.filters.model
+    };
+    this.publish();
+  }
+  async refresh() {
+    if (!this.running || !this.scope)
+      return;
+    for (const cached of this.cache.values())
+      if (cached.directory === this.state.port.location.directory)
+        cached.valid = false;
+    this.queueHistory();
+    const state = this.state, generation = this.generation, signal = this.scope.signal;
+    await Promise.all([
+      this.scan(state, generation, signal),
+      this.monitor(state, generation, signal)
+    ]);
+    if (this.current(state, generation, signal))
+      await state.client?.refresh();
+  }
+  current(state, generation, signal) {
+    return this.running && this.state === state && generation === this.generation && !signal.aborted;
+  }
+  scan(state, generation, signal) {
+    if (state.scanning)
+      return state.scanning;
+    state.scanning = (async () => {
+      try {
+        const scanSignal = AbortSignal.any([
+          signal,
+          AbortSignal.timeout(15000)
+        ]);
+        const result = await discoverInventory(state.port, scanSignal, this.limits);
+        let active;
+        try {
+          active = new Set(await state.port.activeSessions(result.sessions.map((session) => session.sessionId), scanSignal));
+        } catch {
+        }
+        if (!this.current(state, generation, signal))
+          return;
+        const nodes = new Map;
+        for (const session of result.sessions)
+          nodes.set(session.sessionId, {
+            ...session,
+            status: active ? executionStatus(true, active.has(session.sessionId), {
+              ...session.outcome ? { outcome: session.outcome } : {},
+              ...session.terminalAt === undefined ? {} : { terminalAt: session.terminalAt }
+            }) : state.nodes.get(session.sessionId)?.status ?? "unknown",
+            inventoryStale: active === undefined
+          });
+        if (!result.complete) {
+          for (const [id, node] of state.nodes)
+            if (!nodes.has(id) && nodes.size < this.limits.maxNodes)
+              nodes.set(id, { ...node, inventoryStale: true });
+        }
+        state.nodes = nodes;
+        state.complete = result.complete && active !== undefined;
+        state.stale = !state.complete;
+        state.pages = result.pages;
+        state.notices = active ? result.notices : [...new Set([...result.notices, "inventory-unavailable"])];
+        if (!state.selected || !nodes.has(state.selected)) {
+          const previous = state.selected;
+          const first = nodes.keys().next().value;
+          if (first === undefined)
+            delete state.selected;
+          else
+            state.selected = first;
+          if (previous !== state.selected)
+            this.queueHistory();
+        }
+        state.client?.setIds([...nodes.keys()]);
+      } catch {
+        if (!this.current(state, generation, signal))
+          return;
+        state.complete = false;
+        state.stale = true;
+        state.nodes = new Map([...state.nodes].map(([id, node]) => [
+          id,
+          { ...node, inventoryStale: true }
+        ]));
+        state.notices = ["inventory-unavailable"];
+      } finally {
+        if (this.current(state, generation, signal)) {
+          delete state.scanning;
+          this.publish();
+        }
       }
-      const file = await open(join(this.path, this.active), "a", 384);
+    })();
+    this.publish();
+    return state.scanning;
+  }
+  monitor(state, generation, signal) {
+    if (state.client)
+      return Promise.resolve();
+    if (state.probing)
+      return state.probing;
+    state.probing = (async () => {
       try {
-        await file.writeFile(line);
+        const monitor = await state.port.monitor(signal);
+        if (!this.current(state, generation, signal))
+          return;
+        state.version = monitor.version;
+        const client = new SnapshotClient(monitor.transport, () => {
+          if (!this.current(state, generation, signal))
+            return;
+          state.connection = client.connection;
+          if (client.health) {
+            state.rows = new Map(client.rows);
+            state.health = client.health;
+            state.serverAt = client.now();
+            state.receivedAt = this.elapsed();
+          }
+          this.publish();
+        }, this.elapsed);
+        state.client = client;
+        client.start(state.port.location.directory, [...state.nodes.keys()]);
+      } catch {
+        if (this.current(state, generation, signal)) {
+          state.connection = state.rows.size ? "reconnecting" : "unavailable";
+          this.publish();
+        }
       } finally {
-        await file.close();
+        if (this.current(state, generation, signal))
+          delete state.probing;
       }
-      this.bytes += size;
-    }
+    })();
+    return state.probing;
   }
-  health() {
-    return { unavailable: this.disabled, droppedRecords: this.droppedTotal };
+  cacheKey() {
+    return JSON.stringify([
+      this.state.port.location.directory,
+      this.state.selected,
+      this.windowMs
+    ]);
   }
-  async flush() {
-    while (this.working)
-      await this.working;
+  cancelHistory() {
+    this.historyGeneration++;
+    this.pendingHistory = undefined;
+    this.historyAbort?.abort();
   }
-  async initialize() {
-    if (!this.config.enabled)
+  queueHistory() {
+    this.cancelHistory();
+    const sessionId = this.state.selected;
+    if (!this.running || !this.scope || this.screen !== "history" || !sessionId) {
+      this.historyStatus = "idle";
       return;
-    await mkdir(this.path, { recursive: true, mode: 448 }).then(() => this.prune()).catch(() => {
-      this.disabled = true;
-      this.report("history-unavailable");
+    }
+    const key = this.cacheKey(), cached = this.cache.get(key);
+    if (cached?.valid) {
+      this.cache.delete(key);
+      this.cache.set(key, cached);
+      this.historyStatus = cached.result.enabled ? "ready" : "disabled";
+      return;
+    }
+    this.historyStatus = "loading";
+    this.pendingHistory = {
+      key,
+      state: this.state,
+      sessionId,
+      windowMs: this.windowMs,
+      generation: this.historyGeneration,
+      scope: this.scope.signal
+    };
+    this.pumpHistory();
+  }
+  async pumpHistory() {
+    if (this.historyBusy || !this.pendingHistory)
+      return;
+    const task = this.pendingHistory;
+    this.pendingHistory = undefined;
+    this.historyBusy = true;
+    const controller = new AbortController;
+    this.historyAbort = controller;
+    const signal = AbortSignal.any([
+      controller.signal,
+      task.scope,
+      AbortSignal.timeout(5000)
+    ]);
+    const to = Math.max(0, Math.floor(this.serverNow()));
+    const from = Math.max(0, to - task.windowMs);
+    try {
+      const result = await task.state.port.history({
+        schemaVersion: 1,
+        sessionId: task.sessionId,
+        from,
+        to,
+        maxPoints: 500
+      }, 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");
+      this.cache.set(task.key, {
+        directory: task.state.port.location.directory,
+        valid: true,
+        result: structuredClone(result),
+        from,
+        to
+      });
+      if (this.cache.size > 16) {
+        const oldest = this.cache.keys().next().value;
+        if (oldest !== undefined)
+          this.cache.delete(oldest);
+      }
+      this.historyStatus = result.enabled ? "ready" : "disabled";
+    } catch {
+      if (task.generation === this.historyGeneration && !task.scope.aborted)
+        this.historyStatus = "unavailable";
+    } finally {
+      if (task.generation === this.historyGeneration && signal.aborted && !task.scope.aborted)
+        this.historyStatus = "unavailable";
+      this.historyBusy = false;
+      if (this.historyAbort === controller)
+        this.historyAbort = undefined;
+      if (this.running)
+        this.publish();
+      this.pumpHistory();
+    }
+  }
+  serverNow() {
+    if (this.state.client?.health)
+      return this.state.client.now();
+    if (this.state.serverAt !== undefined && this.state.receivedAt !== undefined)
+      return this.state.serverAt + Math.max(0, this.elapsed() - this.state.receivedAt);
+    return this.now();
+  }
+  buildView() {
+    const state = this.state, now = this.serverNow();
+    const nodes = [...state.nodes.values()].map((node) => {
+      const snapshot = state.rows.get(node.sessionId);
+      const agent = snapshot?.agent ?? node.agent;
+      const model = snapshot?.model ?? node.model;
+      return {
+        sessionId: node.sessionId,
+        status: node.status,
+        ...node.parentId ? { parentId: node.parentId } : {},
+        ...agent ? { agent } : {},
+        ...model ? { model } : {},
+        ...node.outcome === "interrupted" ? { interrupted: true } : {}
+      };
+    });
+    const rows = familyRows(nodes, state.rows, state.selected ?? "", now, state.health?.staleMs ?? 300000, new Set(state.nodes.keys()), this.limits.maxNodes).map((row2) => {
+      const liveStale = !this.running || state.connection !== "live";
+      const measurement2 = row2.snapshot?.measurement;
+      let snapshot = row2.snapshot;
+      if (snapshot && state.version === 1) {
+        const { performance: _, ...context } = snapshot;
+        snapshot = context;
+      }
+      const stale = liveStale && row2.freshness === "fresh";
+      const p = snapshot?.performance;
+      const { pressureRatio, triggerDeltaTokens, ...retained } = row2;
+      return {
+        ...stale ? { ...retained, freshness: "stale", pressure: "unknown" } : row2,
+        ...snapshot ? { snapshot } : {},
+        inventoryStale: !this.running || state.stale || (state.nodes.get(row2.node.sessionId)?.inventoryStale ?? true),
+        liveStale,
+        ...measurement2 && now >= measurement2.at ? { measurementAgeMs: now - measurement2.at } : {},
+        performanceAvailable: state.version === 2 && snapshot?.performance !== undefined,
+        performanceFreshness: !p ? "missing" : p.at > now ? "invalid" : liveStale || now - p.at > (state.health?.staleMs ?? 300000) ? "stale" : "fresh"
+      };
+    });
+    const search = this.filters.search.toLowerCase();
+    const visible = rows.filter((row2) => (!search || [row2.node.sessionId, row2.node.agent, row2.node.model].some((value) => value?.toLowerCase().includes(search))) && (!this.filters.agent || row2.node.agent === this.filters.agent) && (!this.filters.model || row2.node.model === this.filters.model));
+    const cached = this.cache.get(this.cacheKey());
+    const projected = cached ? projectHistory(cached.result, this.filters) : undefined;
+    const selected = rows.find((row2) => row2.node.sessionId === state.selected);
+    return immutableView({
+      schemaVersion: 1,
+      generatedAt: now,
+      running: this.running,
+      location: state.port.location.directory,
+      locations: [...this.locations.keys()],
+      screen: this.screen,
+      filters: this.filters,
+      connection: state.connection,
+      ...state.version === undefined ? {} : { monitorVersion: state.version },
+      ...state.health ? { health: state.health } : {},
+      inventory: {
+        refreshing: state.scanning !== undefined,
+        complete: state.complete,
+        stale: state.stale,
+        pages: state.pages,
+        total: rows.length,
+        visible: visible.length,
+        monitored: rows.filter((row2) => row2.snapshot).length,
+        active: rows.filter((row2) => row2.node.status === "running").length,
+        ...this.limits,
+        notices: state.notices
+      },
+      rows: visible,
+      ...state.selected ? { selectedSessionId: state.selected } : {},
+      ...selected ? { selected } : {},
+      history: {
+        status: this.historyStatus,
+        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 } : {},
+        ...projected ? { result: projected.result, summary: projected.summary } : {},
+        notices: projected?.notices ?? [
+          "bounded-retention",
+          "maximum-seven-days",
+          "maximum-500-points-and-requests"
+        ]
+      },
+      notices: [
+        ...!state.complete ? ["partial-inventory"] : [],
+        ...state.connection !== "live" ? ["live-data-stale"] : [],
+        ...state.version === 1 ? ["performance-unavailable-v1"] : []
+      ]
     });
   }
 }
-function scalarPerformance(p) {
+var init_controller = __esm(() => {
+  init_rpc();
+  init_transport();
+  init_inventory();
+  init_view();
+});
+
+// src/dashboard/connection.ts
+import { OpenCode } from "@opencode/client";
+import { Service } from "@opencode/client/service";
+import { isAbsolute as isAbsolute2 } from "path";
+function serverUrl(value) {
+  try {
+    const url = new URL(value);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || url.protocol === "http:" && !["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))
+      throw new Error;
+    return url.href;
+  } catch {
+    throw new Error("Use an HTTPS server URL or loopback HTTP URL without credentials, query or fragment");
+  }
+}
+async function connectDashboard(options, discovery = Service) {
+  if (!isAbsolute2(options.directory))
+    throw new Error("Dashboard directory must be an absolute path on the server");
+  if (!options.server && (options.password !== undefined || options.username !== undefined))
+    throw new Error("Explicit credentials require an explicit server URL");
+  let endpoint;
+  if (options.server !== undefined) {
+    endpoint = {
+      url: serverUrl(options.server),
+      ...options.password === undefined ? {} : {
+        auth: {
+          type: "basic",
+          username: options.username ?? "opencode",
+          password: options.password
+        }
+      }
+    };
+  } else {
+    let found;
+    try {
+      found = await discovery.discover(options.serviceFile === undefined ? {} : { file: options.serviceFile });
+    } catch {
+      throw new Error("Local OpenCode service discovery failed");
+    }
+    if (!found)
+      throw new Error("No compatible local OpenCode service found; start OpenCode or supply --server");
+    endpoint = {
+      url: serverUrl(found.url),
+      ...found.auth ? { auth: found.auth } : {}
+    };
+  }
+  const headers = discovery.headers(endpoint);
+  const request = discovery.fetch ?? globalThis.fetch;
+  const client = OpenCode.make({
+    baseUrl: endpoint.url,
+    ...headers ? { headers } : {},
+    fetch: Object.assign((input, init) => request(input, { ...init, redirect: "error" }), { preconnect: request.preconnect })
+  });
+  const deadline = (signal) => AbortSignal.any([signal, AbortSignal.timeout(5000)]);
+  function atLocation(directory) {
+    if (!isAbsolute2(directory))
+      throw new Error("Dashboard directory must be an absolute path on the server");
+    const location = Object.freeze({ directory });
+    return {
+      location,
+      atLocation,
+      async listSessions(input, signal) {
+        if (input.limit !== undefined && (!Number.isInteger(input.limit) || input.limit < 1 || input.limit > 100))
+          throw new Error("Session page limit must be between 1 and 100");
+        try {
+          const page = await client.session.list({
+            ...input,
+            directory: location.directory,
+            order: "desc",
+            limit: input.limit ?? 100
+          }, { signal: deadline(signal) });
+          return {
+            data: page.data.map((session) => ({
+              sessionId: session.id,
+              directory: session.location.directory,
+              ...session.parentID ? { parentId: session.parentID } : {},
+              ...session.agent ? { agent: session.agent } : {},
+              ...session.model ? { model: `${session.model.providerID}/${session.model.id}` } : {},
+              ...session.outcome ? { outcome: session.outcome } : {},
+              ...session.time.idle === undefined ? {} : { terminalAt: session.time.idle }
+            })),
+            ...page.cursor?.next === undefined ? {} : { cursor: { next: page.cursor.next } }
+          };
+        } catch {
+          throw new Error("Dashboard session inventory unavailable");
+        }
+      },
+      async activeSessions(ids, signal) {
+        try {
+          const active = await client.session.active({
+            signal: deadline(signal)
+          });
+          return ids.filter((id) => active[id]?.type === "running");
+        } catch {
+          throw new Error("Dashboard execution state unavailable");
+        }
+      },
+      async monitor(signal) {
+        let source = client.rpc(performanceRpc);
+        let version = 2;
+        try {
+          const result = await source.read({ schemaVersion: 1, sessionIds: [] }, { location, signal: deadline(signal) });
+          if (!isPerformanceResult(result))
+            throw new Error;
+        } catch {
+          if (signal.aborted)
+            throw new Error("Dashboard monitor probe cancelled");
+          source = client.rpc(monitorRpc);
+          version = 1;
+          try {
+            const result = await source.read({ schemaVersion: 1, sessionIds: [] }, { location, signal: deadline(signal) });
+            if (!isResult(result))
+              throw new Error;
+          } catch {
+            throw new Error("Context Guard monitor unavailable or incompatible in this location");
+          }
+        }
+        const rpc = source;
+        const checkLocation = (directory2) => {
+          if (directory2 !== location.directory)
+            throw new Error("Dashboard location mismatch");
+        };
+        return {
+          version,
+          transport: {
+            async read(directory2, ids, requestSignal) {
+              checkLocation(directory2);
+              try {
+                return await rpc.read({ schemaVersion: 1, sessionIds: [...ids] }, { location, signal: deadline(requestSignal) });
+              } catch {
+                throw new Error("Dashboard monitor read failed");
+              }
+            },
+            async* subscribe(directory2, requestSignal) {
+              checkLocation(directory2);
+              try {
+                for await (const event of rpc.events.subscribe("changed", {
+                  signal: requestSignal
+                })) {
+                  if (event.location?.directory === location.directory)
+                    yield event.data;
+                }
+              } catch {
+                if (!requestSignal.aborted)
+                  throw new Error("Dashboard monitor stream interrupted");
+              }
+            }
+          }
+        };
+      },
+      async history(input, signal) {
+        if (!isHistoryRead(input))
+          throw new Error("History requires one session, at most seven days and 16\u2013500 points");
+        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");
+        }
+      }
+    };
+  }
   return {
-    observedSince: p.observedSince,
-    sessionCreatedAt: p.sessionCreatedAt,
-    at: p.at,
-    status: p.status,
-    partial: p.partial,
-    estimatedOutputTokens: p.estimatedOutputTokens,
-    modelOutputTokens: p.modelOutputTokens,
-    modelDurationMs: p.modelDurationMs,
-    completedRequests: p.completedRequests,
-    tokenSource: p.tokenSource,
-    ...Object.fromEntries([
-      "sessionOutputTokens",
-      "liveTps",
-      "averageModelTps",
-      "averageSessionTps",
-      "ttftMs",
-      "latestRequestTps",
-      "requestId",
-      "requestAgent",
-      "requestModel",
-      "requestOutputTokens",
-      "requestStartedAt",
-      "firstOutputAt",
-      "streamEndedAt"
-    ].flatMap((key) => {
-      const value = p[key];
-      return value === undefined ? [] : [[key, value]];
-    }))
+    ...atLocation(options.directory),
+    async info(signal) {
+      try {
+        return await client.server.info({ signal: deadline(signal) });
+      } catch {
+        throw new Error("Dashboard server connection failed");
+      }
+    }
   };
 }
-async function readPerformanceHistory(directory, filter = {}) {
-  const records = [];
-  const files = await segments(directory);
-  const maxBytes = filter.maxBytes ?? 64 * 1024 * 1024;
-  let bytes = 0, skippedBytes = 0, malformedRecords = 0;
-  const selected = [];
-  for (const file of files.slice().reverse()) {
-    if (bytes + file.bytes > maxBytes) {
-      skippedBytes += file.bytes;
-      continue;
+var init_connection = __esm(() => {
+  init_rpc();
+});
+
+// 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);
+}
+function cells(value) {
+  return [...segmenter.segment(value)].reduce((n, { segment }) => n + graphemeWidth(segment), 0);
+}
+function graphemeWidth(s) {
+  const cp = s.codePointAt(0) ?? 0;
+  if (/^[\p{Mark}\u200d\ufe0f]+$/u.test(s))
+    return 0;
+  return /[\p{Extended_Pictographic}\p{Regional_Indicator}\u20e3]/u.test(s) || cp >= 4352 && (cp <= 4447 || cp >= 9001 && cp <= 9002 || cp >= 11904 && cp <= 42191 || cp >= 44032 && cp <= 55203 || cp >= 63744 && cp <= 64255 || cp >= 65040 && cp <= 65135 || cp >= 65281 && cp <= 65376 || cp >= 131072) ? 2 : 1;
+}
+function clip(value, width) {
+  const clean = sanitize(value);
+  if (cells(clean) <= width)
+    return clean;
+  let result = "", used = 0;
+  for (const { segment } of segmenter.segment(clean)) {
+    const size = graphemeWidth(segment);
+    if (used + size > Math.max(0, width - 3))
+      break;
+    result += segment;
+    used += size;
+  }
+  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)
+    return wrap("Loading session family...", width);
+  if (!s)
+    return [
+      ...wrap(`${row2.node.agent ?? row2.node.sessionId} / ${row2.node.model ?? "?"}`, width),
+      ...wrap("Guard: not monitored / unavailable", width)
+    ];
+  const threshold = s.policy.configured;
+  const headroom = row2.triggerDeltaTokens;
+  const lines = [
+    `${s.agent ?? "?"} / ${s.model ?? "?"}`,
+    ...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}` : ""
+  ];
+  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)}`);
+  return lines.filter(Boolean).flatMap((line) => wrap(line, width));
+}
+function sanitize(value) {
+  return value.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, "");
+}
+function wrap(value, width) {
+  const result = [];
+  let part = "";
+  for (const word of sanitize(value).split(" ")) {
+    if (part && cells(part + " " + word) > width) {
+      result.push(part);
+      part = "";
+    }
+    for (const { segment } of segmenter.segment((part ? " " : "") + word)) {
+      if (part && cells(part + segment) > width) {
+        result.push(part);
+        part = "";
+      }
+      part += cells(segment) <= width ? segment : "?";
     }
-    bytes += file.bytes;
-    selected.unshift(file);
   }
-  for (const file of selected) {
-    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");
-    } finally {
-      await handle.close();
+  if (part)
+    result.push(part);
+  return result;
+}
+function performanceLines(row2, width) {
+  const p = row2.snapshot?.performance;
+  if (!p)
+    return [];
+  const value = (n) => n === undefined ? "?" : n.toFixed(1);
+  return [
+    ...wrap(`TPS ${p.status === "waiting" ? "waiting" : `${p.status === "streaming" ? "~" : ""}${value(p.liveTps)}`} \xB7 ${p.status}${p.partial ? " \xB7 partial" : ""}`, width),
+    ...wrap(`Avg model ${value(p.averageModelTps)} \xB7 Avg session ${value(p.averageSessionTps)}`, 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 init_format = __esm(() => {
+  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 = []) {
+  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))));
+  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)
+      continue;
+    min = Math.min(min, point.value);
+    max = Math.max(max, point.value);
+    const i = column(point.time);
+    values[i] = Math.max(values[i] ?? -Infinity, point.value);
+  }
+  for (const time of gaps)
+    if (time >= from && time <= to)
+      values[column(time)] = undefined;
+  return { values, column, min, max };
+}
+function sparkline(points, from, to, width, gaps = []) {
+  const { values, column, min, max } = columns(points, from, to, width, gaps);
+  const bars = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+  const chars = values.map((v) => v === undefined ? " " : bars[Math.min(7, Math.floor(v / Math.max(1, max) * 7))] ?? "\u2581");
+  for (const time of gaps)
+    if (time >= from && time <= to)
+      chars[column(time)] = "\u2506";
+  return { line: chars.join(""), ...min === Infinity ? {} : { min, max } };
+}
+function metricPlot(points, from, to, width, gaps = []) {
+  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 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";
+  const lines = Array.from({ length: height }, (_, row2) => {
+    const axis = gutter ? (row2 === 0 ? label(scale) : row2 === height - 1 ? "0.0" : "").padStart(gutter) : "";
+    return `${axis}\u2502${values.map((value, i) => {
+      if (gapColumns.has(i))
+        return "\u2506";
+      if (value === undefined)
+        return " ";
+      const fill = Math.max(0, Math.min(8, Math.ceil((value / scale * height - (height - row2 - 1)) * 8)));
+      return value === 0 && row2 === height - 1 ? "\u2581" : blocks[fill];
+    }).join("")}\u2502`;
+  });
+  lines.push(`${" ".repeat(gutter)}\u2514${"\u2500".repeat(values.length)}\u2518`);
+  const start = new Date(from).toISOString().slice(11, 16), end = new Date(to).toISOString().slice(11, 16);
+  const axisWidth = values.length + 2;
+  if (axisWidth >= 11)
+    lines.push(`${" ".repeat(gutter)}${start}${" ".repeat(axisWidth - 10)}${end}`);
+  return lines;
+}
+function historyChartLines(result, width, from, to, metricIndex = 0) {
+  if (!result.enabled)
+    return wrap("History recording is disabled on this server.", width);
+  const series = result.data.series[0];
+  if (!series)
+    return wrap("No retained measurements in this window.", width);
+  const gaps = result.data.gaps.map((g) => g.time);
+  const observations = (key) => series.points.map((p) => ({
+    time: p.time,
+    ...p[key] === undefined ? {} : { value: p[key] }
+  }));
+  const requests = (key) => series.requests.map((p) => ({
+    time: p.time,
+    ...p[key] === undefined ? {} : { value: key === "ttftMs" ? p[key] / 1000 : p[key] }
+  }));
+  const metric2 = chartMetrics[metricIndex] ?? chartMetrics[0];
+  const points = metric2.source === "points" ? observations(metric2.key) : requests(metric2.key);
+  const plotted = sparkline(points, from, to, width - 2, gaps);
+  return [
+    ...wrap(`\u2039 ${metric2.label} \u203A \xB7 ${metricIndex + 1}/${chartMetrics.length}`, width),
+    ...wrap(plotted.min === undefined ? "No measurements for this metric." : `${plotted.min.toFixed(1)}\u2013${plotted.max?.toFixed(1)} ${metric2.unit} \xB7 observed range`, width),
+    "",
+    ...metricPlot(points, from, to, width, gaps),
+    "",
+    ...wrap("UTC time \u2192 \xB7 peaks per column", width),
+    ...wrap("blank = no sample \xB7 \u2506 = gap", width),
+    ...wrap(`${new Date(from).toISOString()} \u2192 ${new Date(to).toISOString()}`, width),
+    ...series.points.some((p) => p.partial) ? wrap("Partial timing coverage; averages include only matched model durations.", width) : [],
+    ...result.truncated ? wrap("Downsampled/bounded history; some older requests or gap markers may be omitted.", width) : [],
+    ...result.metadata.malformedRecords ? wrap(`${result.metadata.malformedRecords} malformed/partial records skipped.`, width) : []
+  ];
+}
+var chartMetrics;
+var init_chartformat = __esm(() => {
+  init_format();
+  chartMetrics = [
+    { label: "Live TPS ~", unit: "t/s", key: "liveTps", source: "points" },
+    { label: "Avg model", unit: "t/s", key: "averageModelTps", source: "points" },
+    {
+      label: "Avg session",
+      unit: "t/s",
+      key: "averageSessionTps",
+      source: "points"
+    },
+    { label: "TTFT ~", unit: "s", key: "ttftMs", source: "requests" },
+    { label: "Request throughput", unit: "t/s", key: "tps", source: "requests" },
+    {
+      label: "Cumulative output",
+      unit: "tokens",
+      key: "sessionOutputTokens",
+      source: "points"
     }
-    for (const line of source.split("\n")) {
-      if (!line)
-        continue;
-      try {
-        const value = JSON.parse(line);
-        if (!isHistoryRecord(value)) {
-          malformedRecords++;
+  ];
+});
+
+// src/dashboard/terminalview.ts
+function overviewRow(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` : ""}`;
+}
+function pathValue(object2, path) {
+  let value = object2;
+  for (const key of path.split(".")) {
+    if (value === null || typeof value !== "object")
+      return;
+    value = Reflect.get(value, key);
+  }
+  return value;
+}
+function terminalDetail(row2) {
+  if (!row2)
+    return ["No selected session; choose one in overview."];
+  return [
+    overviewRow(row2),
+    `Session ID: ${row2.node.sessionId}`,
+    `Parent ID: ${row2.node.parentId ?? "unknown/unavailable"}`,
+    "All snapshot fields (timestamps are Unix milliseconds):",
+    ...snapshotFields.map((path) => `${path}: ${scalar(pathValue(row2.snapshot, path))}`),
+    "Compaction count records completed lifecycle events; admission is not completion."
+  ];
+}
+function historyObservations(view, metricIndex) {
+  const metric2 = chartMetrics[metricIndex] ?? chartMetrics[0];
+  return view.history.result?.data.series.flatMap((series) => metric2.source === "points" ? series.points.map((point) => ({
+    time: point.time,
+    value: point[metric2.key],
+    details: {
+      sessionId: series.sessionId,
+      ...point,
+      tokenSource: "per-sample source not retained; live TPS estimated; cumulative output reported; rates use matched timing"
+    }
+  })) : series.requests.map((request) => ({
+    time: request.time,
+    value: metric2.key === "ttftMs" ? request.ttftMs === undefined ? undefined : request.ttftMs / 1000 : request.tps,
+    details: {
+      sessionId: series.sessionId,
+      ...request,
+      tokenSource: "reported output; observed timing"
+    }
+  }))).sort((a, b) => a.time - b.time) ?? [];
+}
+function terminalHistory(view, width, metricIndex, sample) {
+  const h = view.history;
+  const metric2 = chartMetrics[metricIndex] ?? chartMetrics[0];
+  const observations = historyObservations(view, metricIndex);
+  const gaps = [
+    ...h.result?.data.gaps.map((gap) => gap.time) ?? [],
+    ...h.result?.data.series.flatMap((series) => series.points.filter((p) => p.breakBefore).map((p) => p.time)) ?? []
+  ];
+  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})`,
+    "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 ? [
+      `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 ? [] : [
+      `${new Date(h.from).toISOString()} \u2192 ${new Date(h.to).toISOString()}`,
+      ...metricPlot(observations.map((p) => ({
+        time: p.time,
+        ...p.value === undefined ? {} : { value: p.value }
+      })), h.from, h.to, width, gaps),
+      "blank = no sample; \u2506 = gap; observed column peaks; no interpolation"
+    ],
+    ...selected ? [
+      `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}`
+    ] : [
+      "No retained measurements for this metric; values unknown/unavailable."
+    ]
+  ];
+}
+function wrapped(lines, width) {
+  return lines.flatMap((line) => line ? wrap(line, Math.max(1, width)) : [""]);
+}
+function headerLines(view, 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)
+  ];
+}
+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_chartformat();
+  init_format();
+  snapshotFields = [
+    "sessionId",
+    "parentId",
+    "agent",
+    "model",
+    "revision",
+    "observedAt",
+    "measurement.tokens",
+    "measurement.at",
+    "measurement.model",
+    "measurement.provenance",
+    "measurement.scope",
+    "measurement.confidence",
+    "measurement.requestId",
+    "limits.input",
+    "limits.context",
+    "limits.output",
+    "capacityTokens",
+    "outputReserveTokens",
+    "peakTokens",
+    "policy.id",
+    "policy.configured.type",
+    "policy.configured.value",
+    "policy.triggerTokens",
+    "policy.comparison",
+    "policy.reason",
+    "policy.crossed",
+    "compaction.phase",
+    "compaction.count",
+    "compaction.armed",
+    "compaction.blockedReason",
+    "compaction.lastAttempt",
+    "compaction.lastCompleted",
+    "compaction.cooldownUntil",
+    "cumulativeScope",
+    "cumulative.input",
+    "cumulative.output",
+    "cumulative.reasoning",
+    "cumulative.cache.read",
+    "cumulative.cache.write",
+    "lastObservedActive",
+    "performance.sessionCreatedAt",
+    "performance.sessionOutputTokens",
+    "performance.observedSince",
+    "performance.at",
+    "performance.status",
+    "performance.partial",
+    "performance.liveTps",
+    "performance.averageModelTps",
+    "performance.averageSessionTps",
+    "performance.ttftMs",
+    "performance.latestRequestTps",
+    "performance.requestId",
+    "performance.requestAgent",
+    "performance.requestModel",
+    "performance.requestOutputTokens",
+    "performance.requestStartedAt",
+    "performance.firstOutputAt",
+    "performance.streamEndedAt",
+    "performance.estimatedOutputTokens",
+    "performance.modelOutputTokens",
+    "performance.modelDurationMs",
+    "performance.completedRequests",
+    "performance.tokenSource"
+  ];
+  terminalHelp = [
+    "Context Guard standalone dashboard \u2014 keyboard help",
+    "1 overview \xB7 2 detail \xB7 3 history \xB7 Enter detail",
+    "Up/Down or j/k: select session in overview; scroll other screens",
+    "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",
+    "/: search session identity \xB7 f: agent filter, then model filter (exact matches)",
+    "l: owning absolute location directory; Tab cycles up to four remembered locations",
+    "Remembered locations are not complete server-wide discovery.",
+    "Editors: type/paste text; Backspace deletes; Enter applies; Escape cancels",
+    "r: refresh \xB7 ?: help \xB7 Escape: overview \xB7 q / Ctrl+C: quit",
+    "Detail scrolls through full identifiers and every exposed snapshot field.",
+    "Unknown metrics are unavailable, not zero. Stale occupancy is retained; pressure is unknown."
+  ];
+});
+
+// src/dashboard/terminal.ts
+var exports_terminal = {};
+__export(exports_terminal, {
+  runTerminal: () => runTerminal,
+  mountTerminal: () => mountTerminal,
+  TerminalShell: () => TerminalShell
+});
+import { isAbsolute as isAbsolute3 } from "path";
+
+class TerminalShell {
+  controller;
+  quit;
+  scroll = 0;
+  metric = 0;
+  sample = 0;
+  help = false;
+  editor;
+  input = "";
+  notice = "";
+  rowOffset = 0;
+  historyIdentity = "";
+  constructor(controller, quit) {
+    this.controller = controller;
+    this.quit = quit;
+  }
+  task(task) {
+    task.catch(() => {
+      this.notice = "Dashboard action unavailable; refresh to retry.";
+    });
+  }
+  paste(text2) {
+    if (this.editor)
+      this.input = (this.input + clip(text2, 2048)).slice(0, this.editor === "location" ? 4096 : 512);
+  }
+  key(key, page = 10) {
+    const view = this.controller.getView();
+    const name = key.name;
+    if (key.ctrl && name === "c") {
+      this.quit();
+      return;
+    }
+    if (this.editor) {
+      if (name === "escape") {
+        this.editor = undefined;
+        this.notice = "";
+      } else if (name === "backspace")
+        this.input = Array.from(this.input).slice(0, -1).join("");
+      else if (name === "tab" && this.editor === "location") {
+        const i = view.locations.indexOf(this.input);
+        this.input = view.locations[(i + 1) % view.locations.length] ?? view.location;
+      } else if (name === "return" || name === "enter") {
+        const editor = this.editor;
+        if (editor === "location") {
+          if (!isAbsolute3(this.input)) {
+            this.notice = "Location must be an owning absolute server directory.";
+            return;
+          }
+          this.task(this.controller.selectLocation(this.input));
+        } else
+          this.controller.setFilters({ [editor]: this.input });
+        this.editor = editor === "agent" ? "model" : undefined;
+        this.input = this.editor === "model" ? view.filters.model : "";
+        this.scroll = 0;
+        this.notice = "";
+      } else if (!key.ctrl && !key.meta && key.sequence && !/[\x00-\x1f\x7f-\x9f]/.test(key.sequence))
+        this.paste(key.sequence);
+      return;
+    }
+    if (name === "q") {
+      this.quit();
+      return;
+    }
+    if (name === "?" || key.sequence === "?") {
+      this.help = !this.help;
+      this.scroll = 0;
+      return;
+    }
+    if (name === "escape") {
+      this.help = false;
+      this.scroll = 0;
+      this.controller.setScreen("overview");
+      return;
+    }
+    if (name === "/" || key.sequence === "/") {
+      this.editor = "search";
+      this.input = view.filters.search;
+      return;
+    }
+    if (name === "f") {
+      this.editor = "agent";
+      this.input = view.filters.agent;
+      return;
+    }
+    if (name === "l") {
+      this.editor = "location";
+      this.input = view.location;
+      return;
+    }
+    if (name === "r") {
+      this.task(this.controller.refresh());
+      return;
+    }
+    if (["1", "2", "3", "return", "enter"].includes(name)) {
+      this.help = false;
+      this.scroll = 0;
+      this.controller.setScreen(name === "1" ? "overview" : name === "3" ? "history" : "detail");
+      return;
+    }
+    if (view.screen === "history" && !this.help) {
+      if (name === "left" || name === "right") {
+        this.metric = (this.metric + (name === "left" ? 5 : 1)) % 6;
+        this.sample = 0;
+        this.scroll = 0;
+        return;
+      }
+      if (name === "w") {
+        this.controller.setWindow(historyWindows[(historyWindows.indexOf(view.history.windowMs) + 1) % historyWindows.length] ?? historyWindows[0]);
+        this.sample = 0;
+        return;
+      }
+      if (name === "[" || name === "]") {
+        this.sample = Math.max(0, Math.min(historyObservations(view, this.metric).length - 1, this.sample + (name === "[" ? -1 : 1)));
+        return;
+      }
+    }
+    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 row2 = view.rows[next];
+      if (row2 && (delta || name === "home" || name === "end"))
+        this.controller.selectSession(row2.node.sessionId);
+    } else
+      this.scroll = name === "home" ? 0 : name === "end" ? Number.MAX_SAFE_INTEGER : Math.max(0, this.scroll + delta);
+  }
+  frame(width, height) {
+    width = Math.max(1, width);
+    height = Math.max(1, height);
+    const view = this.controller.getView();
+    const identity = `${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";
+    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 notices = [
+      ...view.notices,
+      ...view.inventory.notices,
+      ...view.health?.reasons ?? [],
+      ...this.notice ? [this.notice] : [],
+      ...Object.values(view.filters).some(Boolean) ? [
+        `Filters: search=${view.filters.search} agent=${view.filters.agent} model=${view.filters.model}`
+      ] : []
+    ];
+    let body;
+    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 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)));
+      body = [
+        ...status.slice(0, available - budget),
+        ...flat.length ? flat.slice(this.rowOffset, this.rowOffset + budget) : ["No matching sessions; / search, f filters, r refresh."]
+      ];
+      return [
+        ...header,
+        ...body,
+        ...Array.from({ length: Math.max(0, available - body.length) }, () => ""),
+        clip(footer, width)
+      ].join("\n");
+    } else
+      body = wrapped([
+        ...notices,
+        ...view.screen === "detail" ? terminalDetail(view.selected) : terminalHistory(view, width, this.metric, this.sample)
+      ], width);
+    this.scroll = Math.max(0, Math.min(this.scroll, Math.max(0, body.length - available)));
+    return [
+      ...header,
+      ...body.slice(this.scroll, this.scroll + available),
+      ...Array.from({ length: Math.max(0, available - body.length) }, () => ""),
+      clip(footer, width)
+    ].join("\n");
+  }
+}
+function mountTerminal(controller, renderer, text2, finished) {
+  let closed = false;
+  let unsubscribe = () => {
+  };
+  const shutdown = (failed = false) => {
+    if (closed)
+      return;
+    closed = true;
+    unsubscribe();
+    controller.stop();
+    renderer.keyInput.off("keypress", key);
+    renderer.keyInput.off("paste", paste);
+    renderer.off("resize", draw);
+    renderer.off("render:error", fail);
+    renderer.off("handler:error", fail);
+    renderer.off("destroy", destroyed);
+    for (const signal of signals)
+      process.off(signal, onSignal);
+    process.off("uncaughtException", fail);
+    process.off("unhandledRejection", fail);
+    try {
+      renderer.destroy();
+    } finally {
+      finished(failed);
+    }
+  };
+  const shell = new TerminalShell(controller, () => shutdown());
+  const fail = () => shutdown(true);
+  const destroyed = () => shutdown();
+  const onSignal = () => shutdown();
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+  const draw = () => {
+    if (closed)
+      return;
+    try {
+      text2.content = shell.frame(renderer.width, renderer.height);
+    } catch {
+      fail();
+    }
+  };
+  const key = (event) => {
+    try {
+      shell.key(event, Math.max(1, renderer.height - 4));
+      draw();
+    } catch {
+      fail();
+    }
+  };
+  const paste = (event) => {
+    shell.paste(new TextDecoder().decode(event.bytes));
+    draw();
+  };
+  try {
+    renderer.root.add(text2);
+    renderer.keyInput.on("keypress", key);
+    renderer.keyInput.on("paste", paste);
+    renderer.on("resize", draw);
+    renderer.on("render:error", fail);
+    renderer.on("handler:error", fail);
+    renderer.on("destroy", destroyed);
+    for (const signal of signals)
+      process.on(signal, onSignal);
+    process.on("uncaughtException", fail);
+    process.on("unhandledRejection", fail);
+    unsubscribe = controller.subscribe(draw);
+    if (closed) {
+      unsubscribe();
+      return { shell, shutdown };
+    }
+    controller.start().catch(fail);
+  } catch {
+    shutdown(true);
+  }
+  return { shell, shutdown };
+}
+async function runTerminal(options) {
+  const { createCliRenderer, TextRenderable } = await loadTerminalRenderer();
+  const connection = await connectDashboard(options);
+  await connection.info(AbortSignal.timeout(15000));
+  const controller = new DashboardController(connection);
+  const renderer = await createCliRenderer({
+    exitOnCtrlC: false,
+    exitSignals: [],
+    useMouse: false,
+    screenMode: "alternate-screen",
+    consoleMode: "disabled",
+    openConsoleOnError: false
+  });
+  let failed = false;
+  let app;
+  try {
+    await new Promise((done) => {
+      const text2 = new TextRenderable(renderer, {
+        id: "dashboard",
+        width: "100%",
+        height: "100%",
+        content: "",
+        wrapMode: "none"
+      });
+      app = mountTerminal(controller, renderer, text2, (error) => {
+        failed = error;
+        done();
+      });
+    });
+  } finally {
+    if (app)
+      app.shutdown();
+    else {
+      controller.stop();
+      renderer.destroy();
+    }
+  }
+  if (failed)
+    throw new Error("Terminal dashboard stopped after a runtime failure; terminal restored");
+}
+var init_terminal = __esm(() => {
+  init_controller();
+  init_connection();
+  init_command();
+  init_view();
+  init_format();
+  init_terminalview();
+});
+
+// src/modelanalytics.ts
+function requestFact(record2) {
+  const p = record2.performance;
+  if (!p?.requestId || !record2.sessionId || !nonnegative2(p.requestStartedAt))
+    return;
+  const model = p.requestModel || record2.model;
+  const agent = p.requestAgent || record2.agent;
+  const ttft = p.ttftMs ?? (p.firstOutputAt === undefined ? undefined : p.firstOutputAt - p.requestStartedAt);
+  return {
+    location: "",
+    sessionId: record2.sessionId,
+    requestId: p.requestId,
+    startedAt: p.requestStartedAt,
+    ...p.streamEndedAt === undefined ? {} : { completedAt: p.streamEndedAt },
+    ...model ? { model } : {},
+    ...agent ? { agent } : {},
+    attribution: p.requestModel ? "request" : model ? "legacy-record" : "unknown",
+    partial: p.partial,
+    ...p.tokenSource === "reported" && nonnegative2(p.requestOutputTokens) ? { outputTokens: p.requestOutputTokens } : {},
+    ...ttft === undefined ? {} : { ttftMs: ttft }
+  };
+}
+function reconcile(a, b) {
+  for (const field of [
+    "completedAt",
+    "outputTokens",
+    "ttftMs",
+    "agent"
+  ])
+    if (a[field] !== undefined && b[field] !== undefined && a[field] !== b[field])
+      return;
+  if (a.model && b.model && a.model !== b.model)
+    return;
+  const rank = { unknown: 0, "legacy-record": 1, request: 2 };
+  const preferred = rank[b.attribution] > rank[a.attribution] ? b : a;
+  return {
+    ...a,
+    ...b,
+    ...preferred.model ? { model: preferred.model } : {},
+    attribution: preferred.attribution,
+    partial: a.partial || b.partial
+  };
+}
+function aggregateModels(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");
+  if (!options.location)
+    throw new Error("Analytics requires a location identity");
+  for (const value of [options.from, options.to])
+    if (value !== undefined && (!Number.isSafeInteger(value) || value < 0))
+      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 = {
+    source: "retained-request-records",
+    scannedRecords: 0,
+    unscannedRecords: 0,
+    duplicateRecords: 0,
+    conflictingRequests: 0,
+    missingIdentityRecords: 0,
+    incompleteRequests: 0,
+    invalidTimingRequests: 0,
+    gapRecords: 0,
+    maxRequests,
+    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;
+        break;
+      }
+      requests.set(key, { fact, conflict: false });
+    }
+  }
+  const groups = new Map;
+  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;
+    }
+    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;
+    let group = groups.get(r.model);
+    if (!group) {
+      group = {
+        summary: {
+          ...r.model ? { model: r.model } : {},
+          sessions: 0,
+          completedRequests: 0,
+          partialRequests: 0,
+          legacyAttributionRequests: 0,
+          tpsRequests: 0,
+          ttftRequests: 0,
+          excludedTpsRequests: 0,
+          excludedTtftRequests: 0,
+          outputTokens: 0,
+          durationMs: 0
+        },
+        sessions: new Set,
+        ttfts: []
+      };
+      groups.set(r.model, group);
+    }
+    const s = group.summary;
+    group.sessions.add(r.sessionId);
+    s.completedRequests++;
+    if (r.partial)
+      s.partialRequests++;
+    if (r.attribution === "legacy-record")
+      s.legacyAttributionRequests++;
+    if (r.outputTokens !== undefined) {
+      s.tpsRequests++;
+      s.outputTokens += r.outputTokens;
+      s.durationMs += duration;
+    } else
+      s.excludedTpsRequests++;
+    if (nonnegative2(r.ttftMs) && r.ttftMs <= duration)
+      group.ttfts.push(r.ttftMs);
+    else
+      s.excludedTtftRequests++;
+  }
+  const models = [...groups.values()].map(({ summary: s, sessions, ttfts }) => {
+    s.sessions = sessions.size;
+    s.ttftRequests = ttfts.length;
+    if (s.tpsRequests)
+      s.averageTps = s.outputTokens * 1000 / s.durationMs;
+    ttfts.sort((a, b) => a - b);
+    if (ttfts.length) {
+      s.meanTtftMs = ttfts.reduce((sum, n) => sum + n, 0) / ttfts.length;
+      s.medianTtftMs = ((ttfts[Math.floor((ttfts.length - 1) / 2)] ?? 0) + (ttfts[Math.floor(ttfts.length / 2)] ?? 0)) / 2;
+      const p95 = ttfts[Math.ceil(ttfts.length * 0.95) - 1];
+      if (p95 !== undefined)
+        s.p95TtftMs = p95;
+    }
+    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 };
+}
+var nonnegative2 = (n) => n !== undefined && Number.isFinite(n) && n >= 0;
+
+// src/modelcli.ts
+var exports_modelcli = {};
+__export(exports_modelcli, {
+  inspectModels: () => inspectModels
+});
+import { isAbsolute as isAbsolute4, resolve as resolve2 } from "path";
+async function inspectModels(args) {
+  const directory = args[0];
+  if (!directory || !isAbsolute4(directory))
+    throw new Error("Use context-guard models --help for usage and examples; the history directory must be an absolute path");
+  const values = new Map;
+  let csv = false, json = false;
+  for (let i = 1;i < args.length; i++) {
+    const name = args[i];
+    if (name === "--csv" || name === "--json") {
+      if (name === "--csv" && csv || name === "--json" && json)
+        throw new Error(`Duplicate option ${name}`);
+      if (name === "--csv")
+        csv = true;
+      else
+        json = true;
+    } else if (name && ["--model", "--agent", "--from", "--to"].includes(name)) {
+      if (values.has(name))
+        throw new Error(`Duplicate option ${name}`);
+      const value = args[++i];
+      if (!value || value.startsWith("--"))
+        throw new Error(`Missing value for ${name}`);
+      values.set(name, value);
+    } else
+      throw new Error(`Unknown models option ${name}`);
+  }
+  if (csv && json)
+    throw new Error("Choose JSON or CSV export");
+  const timestamp = (value) => {
+    if (value === undefined)
+      return;
+    const n = /^\d+$/.test(value) ? Number(value) : Date.parse(value);
+    if (!Number.isSafeInteger(n) || n < 0)
+      throw new Error("Invalid timestamp");
+    return n;
+  };
+  const from = timestamp(values.get("--from")), to = timestamp(values.get("--to"));
+  if (from !== undefined && to !== undefined && from > to)
+    throw new Error("--from must precede --to");
+  const model = values.get("--model"), agent = values.get("--agent");
+  const history = await readPerformanceHistory(directory);
+  const result = aggregateModels(history.records, {
+    location: resolve2(directory),
+    ...from === undefined ? {} : { from },
+    ...to === undefined ? {} : { to },
+    ...model === undefined ? {} : { model },
+    ...agent === undefined ? {} : { agent }
+  });
+  const metadata = {
+    ...history.metadata,
+    ...result.coverage,
+    partial: result.coverage.partial || history.metadata.skippedBytes > 0 || history.metadata.malformedRecords > 0,
+    requested: { from, to, model, agent },
+    timeBasis: "stream-completion-[from,to)",
+    tpsBasis: "reported-output-plus-reasoning-over-summed-request-duration",
+    ttftBasis: "observed-approximate-timing",
+    percentileMethod: "nearest-rank-p95-midpoint-median",
+    notices: [
+      "bounded-retention",
+      "scan-limit-64-MiB",
+      "no-pre-observation-reconstruction"
+    ]
+  };
+  if (!csv) {
+    console.log(JSON.stringify({
+      schemaVersion: 1,
+      location: result.location,
+      metadata,
+      models: result.models
+    }, null, 2));
+    return;
+  }
+  console.error(JSON.stringify(metadata));
+  const fields = [
+    "model",
+    "sessions",
+    "completedRequests",
+    "partialRequests",
+    "legacyAttributionRequests",
+    "tpsRequests",
+    "ttftRequests",
+    "excludedTpsRequests",
+    "excludedTtftRequests",
+    "outputTokens",
+    "durationMs",
+    "averageTps",
+    "meanTtftMs",
+    "medianTtftMs",
+    "p95TtftMs"
+  ];
+  console.log(fields.join(","));
+  for (const row2 of result.models)
+    console.log(fields.map((field) => `"${String(row2[field] ?? "").replaceAll('"', '""')}"`).join(","));
+}
+var init_modelcli = __esm(() => {
+  init_history();
+});
+
+// src/cli.ts
+import { writeFile } from "fs/promises";
+import { resolve as resolve3 } from "path";
+
+// src/charts.ts
+var rateFields = [
+  "liveTps",
+  "averageModelTps",
+  "averageSessionTps",
+  "sessionOutputTokens"
+];
+function downsamplePoints(points, limit) {
+  if (!Number.isSafeInteger(limit) || limit < 16 || limit > 5000)
+    throw new Error("maxPoints must be an integer from 16 to 5000");
+  if (points.length <= limit)
+    return [...points];
+  const buckets = Math.max(1, Math.floor(limit / (2 + rateFields.length * 2)));
+  const selected = new Set;
+  for (let b = 0;b < buckets; b++) {
+    const start = Math.floor(b * points.length / buckets), end = Math.floor((b + 1) * points.length / buckets);
+    selected.add(start);
+    selected.add(end - 1);
+    for (const field of rateFields) {
+      let low, high;
+      for (let i = start;i < end; i++) {
+        const value = points[i]?.[field];
+        if (value === undefined)
           continue;
+        if (low === undefined || value < (points[low]?.[field] ?? Infinity))
+          low = i;
+        if (high === undefined || value > (points[high]?.[field] ?? -Infinity))
+          high = i;
+      }
+      if (low !== undefined)
+        selected.add(low);
+      if (high !== undefined)
+        selected.add(high);
+    }
+  }
+  let previous = -1;
+  return [...selected].sort((a, b) => a - b).flatMap((index) => {
+    const point = points[index];
+    if (!point)
+      return [];
+    const skippedGap = points.slice(previous + 1, index + 1).some((p) => p.breakBefore);
+    previous = index;
+    return [{ ...point, breakBefore: point.breakBefore || skippedGap }];
+  });
+}
+function buildChartData(records, options = {}) {
+  const maxPoints = options.maxPoints ?? 1000, maxSessions = options.maxSessions ?? 128;
+  if (!Number.isSafeInteger(maxSessions) || maxSessions < 1 || maxSessions > 1024)
+    throw new Error("maxSessions must be from 1 to 1024");
+  downsamplePoints([], maxPoints);
+  const sorted = [...records].sort((a, b) => a.time - b.time || a.recordId.localeCompare(b.recordId));
+  const lastSeen = new Map;
+  for (const r of sorted)
+    if (r.performance && (!options.sessionId || r.sessionId === options.sessionId))
+      lastSeen.set(r.sessionId, r.time);
+  const sessions = [...lastSeen].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  const selected = new Set(sessions.slice(0, maxSessions).map(([id]) => id));
+  const series = new Map, gaps = [];
+  const seen = new Set, requestSeen = new Set;
+  const pendingGaps = new Set;
+  const observedSince = new Map;
+  for (const r of sorted) {
+    if (seen.has(r.recordId))
+      continue;
+    seen.add(r.recordId);
+    if (r.type === "gap") {
+      if (r.sessionId === "__history__" || selected.has(r.sessionId)) {
+        gaps.push({
+          time: r.time,
+          sessionId: r.sessionId,
+          reason: r.event ?? "observation-gap"
+        });
+        if (r.sessionId === "__history__")
+          for (const id of selected)
+            pendingGaps.add(id);
+        else
+          pendingGaps.add(r.sessionId);
+      }
+      continue;
+    }
+    const p = r.performance;
+    if (!p || !selected.has(r.sessionId))
+      continue;
+    let s = series.get(r.sessionId);
+    if (!s) {
+      s = {
+        sessionId: r.sessionId,
+        ...r.parentId ? { parentId: r.parentId } : {},
+        agents: [],
+        models: [],
+        points: [],
+        requests: [],
+        originalPoints: 0
+      };
+      series.set(r.sessionId, s);
+    }
+    const agent = p.requestAgent ?? r.agent, model = p.requestModel ?? r.model;
+    if (agent && !s.agents.includes(agent))
+      s.agents.push(agent);
+    if (model && !s.models.includes(model))
+      s.models.push(model);
+    const previous = s.points.at(-1);
+    const restart = observedSince.has(r.sessionId) && observedSince.get(r.sessionId) !== p.observedSince;
+    const reset = previous?.sessionOutputTokens !== undefined && p.sessionOutputTokens !== undefined && p.sessionOutputTokens < previous.sessionOutputTokens;
+    const discontinuity = pendingGaps.has(r.sessionId) || restart || reset || !previous || previous.partial !== p.partial || previous.liveTps === undefined || p.liveTps === undefined || r.time - previous.time > 2500 || previous.agent !== agent || previous.model !== model;
+    const point = {
+      time: r.time,
+      ...agent ? { agent } : {},
+      ...model ? { model } : {},
+      breakBefore: discontinuity,
+      partial: p.partial,
+      ...p.liveTps === undefined ? {} : { liveTps: p.liveTps },
+      ...p.averageModelTps === undefined ? {} : { averageModelTps: p.averageModelTps },
+      ...p.averageSessionTps === undefined ? {} : { averageSessionTps: p.averageSessionTps },
+      ...p.sessionOutputTokens === undefined ? {} : { sessionOutputTokens: p.sessionOutputTokens }
+    };
+    if (previous?.time === point.time)
+      s.points[s.points.length - 1] = {
+        ...point,
+        breakBefore: point.breakBefore || previous.breakBefore
+      };
+    else
+      s.points.push(point);
+    observedSince.set(r.sessionId, p.observedSince);
+    pendingGaps.delete(r.sessionId);
+    if (r.type === "request" && p.requestId !== undefined && p.requestStartedAt !== undefined) {
+      const key = JSON.stringify([
+        r.sessionId,
+        p.requestId,
+        p.requestStartedAt
+      ]);
+      if (requestSeen.has(key))
+        continue;
+      requestSeen.add(key);
+      const duration = p.streamEndedAt === undefined ? undefined : p.streamEndedAt - p.requestStartedAt;
+      const validDuration = duration !== undefined && duration > 0;
+      const output = p.tokenSource === "reported" ? p.requestOutputTokens : undefined;
+      s.requests.push({
+        time: r.time,
+        requestId: p.requestId,
+        started: p.requestStartedAt,
+        ...agent ? { agent } : {},
+        ...model ? { model } : {},
+        partial: p.partial,
+        ...p.ttftMs === undefined ? {} : { ttftMs: p.ttftMs },
+        ...output === undefined ? {} : { outputTokens: output },
+        ...validDuration ? { durationMs: duration } : {},
+        ...output !== undefined && validDuration ? { tps: output * 1000 / duration } : {}
+      });
+    }
+  }
+  return {
+    schema: 1,
+    series: [...series.values()].map((s) => ({
+      ...s,
+      originalPoints: s.points.length,
+      points: downsamplePoints(s.points, maxPoints)
+    })),
+    gaps: gaps.slice(-1024),
+    omittedGaps: Math.max(0, gaps.length - 1024),
+    omittedSessions: Math.max(0, sessions.length - selected.size),
+    maxPoints
+  };
+}
+
+// src/chartreport.ts
+function renderChartReport(report) {
+  const payload = JSON.stringify(report).replace(/[<>&\u2028\u2029]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src blob: data:; connect-src 'none'">
+<title>Context Guard \xB7 Performance history</title>
+<style>
+:root{color-scheme:dark;font-family:system-ui,sans-serif;background:#0b1120;color:#e2e8f0}*{box-sizing:border-box}body{max-width:1600px;margin:auto;padding:28px}h1{font-size:28px;letter-spacing:-.03em;margin:8px 0}h2{font-size:16px;margin:0}p{color:#a8b5cb;line-height:1.6;margin:8px 0}.eyebrow{color:#7dd3fc;font-size:12px;letter-spacing:.13em;text-transform:uppercase}.toolbar,.stats,.charts{display:grid;gap:14px;margin-top:22px}.toolbar{grid-template-columns:2fr 1fr 1fr 1.4fr 1.4fr auto;align-items:end}label{font-size:12px;color:#a8b5cb;display:grid;gap:7px}select,input,button{background:#172338;border:1px solid #33435a;border-radius:7px;color:inherit;padding:10px;min-width:0;font:inherit}button{cursor:pointer;font-size:12px}button:hover,button:focus-visible{border-color:#7dd3fc}select:focus-visible,input:focus-visible{outline:2px solid #7dd3fc}.stats{grid-template-columns:repeat(4,1fr)}.stat,.chart{background:#111c2e;border:1px solid #26354e;border-radius:12px;padding:18px}.stat strong{font-size:24px;display:block;margin-top:7px}.stat span{font-size:12px;color:#a8b5cb}.charts{grid-template-columns:repeat(2,minmax(0,1fr))}.charthead{display:flex;justify-content:space-between;align-items:center;gap:10px}.chart p{font-size:12px;min-height:38px}.chart svg{display:block;width:100%;height:auto}.notice{padding:12px 15px;border-left:3px solid #fbbf24;background:#201f2d;font-size:13px;margin-top:15px}.legend{display:flex;flex-wrap:wrap;gap:8px 18px;margin-top:18px;font-size:12px}.legend span{overflow-wrap:anywhere}.dot{display:inline-block;width:9px;height:9px;border-radius:50%;margin-right:7px}.empty{padding:30px;text-align:center;color:#a8b5cb}.tooltip{position:fixed;z-index:5;pointer-events:none;background:#e2e8f0;color:#0b1120;border-radius:7px;padding:10px;max-width:360px;white-space:pre-wrap;font-size:12px;box-shadow:0 8px 30px #0008}footer{margin-top:25px;font-size:12px;color:#a8b5cb}svg circle:focus{outline:none;stroke:white;stroke-width:3}@media(max-width:1000px){.toolbar{grid-template-columns:repeat(2,minmax(0,1fr))}.charts{grid-template-columns:1fr}}@media(max-width:600px){body{padding:16px}.stats{grid-template-columns:repeat(2,1fr)}}@media print{button,.toolbar,.tooltip{display:none}body{padding:0}.chart{break-inside:avoid}.charts{grid-template-columns:1fr}}
+</style></head><body>
+<header><span class="eyebrow">Context Guard / Local analysis</span><h1>Performance history</h1><p>Compare agent instances over time. All timestamps are UTC. This report is an offline snapshot of retained metrics.</p></header>
+<section class="toolbar" aria-label="Chart filters">
+<label>Session instance<select id="session"></select></label><label>Agent<select id="agent"></select></label><label>Model<select id="model"></select></label>
+<label>From (UTC)<input id="from" type="datetime-local" step="1"></label><label>To (UTC)<input id="to" type="datetime-local" step="1"></label><button id="reset">Reset filters</button>
+</section>
+<div id="notice" class="notice" role="status"></div><section id="stats" class="stats" aria-label="Request statistics"></section>
+<div id="legend" class="legend"></div><main id="charts" class="charts"></main>
+<footer>Live TPS uses a character estimate; TTFT includes output publication delay. Dashed curves mark estimates or partial observations. Gaps and missing samples are never filled with zero. Request statistics use retained matching requests; average curves retain the session's original cumulative totals. Agent/model filters select observations, not recomputed lifetime averages. Exported SVGs reflect the current filters. Regenerate this report to include new history.</footer>
+<div id="tooltip" class="tooltip" hidden role="tooltip"></div>
+<script id="chart-data" type="application/json">${payload}</script>
+<script>(${chartClient.toString()})(JSON.parse(document.getElementById("chart-data").textContent));</script>
+</body></html>`;
+}
+function chartClient(report) {
+  const { data, metadata } = report;
+  const element = (id, kind) => {
+    const node = document.getElementById(id);
+    if (!(node instanceof kind))
+      throw new Error(`Missing report element ${id}`);
+    return node;
+  };
+  const session = element("session", HTMLSelectElement), agent = element("agent", HTMLSelectElement), model = element("model", HTMLSelectElement);
+  const from = element("from", HTMLInputElement), to = element("to", HTMLInputElement);
+  const charts = element("charts", HTMLElement), stats = element("stats", HTMLElement), legend = element("legend", HTMLElement);
+  const notice = element("notice", HTMLElement), tooltip = element("tooltip", HTMLElement);
+  const color = (index) => `hsl(${(index * 137.508 + 195) % 360}, 78%, 68%)`;
+  const date = (value) => {
+    const d = new Date(value);
+    return Number.isFinite(d.getTime()) ? d.toISOString() : String(value);
+  };
+  const number = (n, digits = 1) => n === undefined ? "Unavailable" : n.toLocaleString("en-US", { maximumFractionDigits: digits });
+  function options(select, values) {
+    for (const v of values) {
+      const o = document.createElement("option");
+      o.value = v.value;
+      o.textContent = v.label;
+      select.append(o);
+    }
+  }
+  options(session, [
+    { value: "*", label: "Compare sessions (up to 12)" },
+    ...data.series.map((s) => ({
+      value: s.sessionId,
+      label: `${s.agents.join(", ") || "Agent"} \xB7 ${s.sessionId}`
+    }))
+  ]);
+  options(agent, [
+    { value: "*", label: "All agents" },
+    ...[...new Set(data.series.flatMap((s) => s.agents))].sort().map((v) => ({ value: v, label: v }))
+  ]);
+  options(model, [
+    { value: "*", label: "All models" },
+    ...[...new Set(data.series.flatMap((s) => s.models))].sort().map((v) => ({ value: v, label: v }))
+  ]);
+  function reset() {
+    session.value = data.series[0]?.sessionId ?? "*";
+    agent.value = report.agent ?? "*";
+    model.value = report.model ?? "*";
+    from.value = report.from === undefined ? "" : date(report.from).slice(0, 19);
+    to.value = report.to === undefined ? "" : date(report.to).slice(0, 19);
+  }
+  const timestamp = (value) => value ? Date.parse(`${value}Z`) : undefined;
+  function matches2(p, start, end) {
+    return (agent.value === "*" || p.agent === agent.value) && (model.value === "*" || p.model === model.value) && (start === undefined || p.time >= start) && (end === undefined || p.time <= end);
+  }
+  const ns = "http://www.w3.org/2000/svg";
+  function svgNode(name, attrs = {}, text2) {
+    const n = document.createElementNS(ns, name);
+    for (const [key, value] of Object.entries(attrs))
+      n.setAttribute(key, String(value));
+    if (text2 !== undefined)
+      n.textContent = text2;
+    return n;
+  }
+  function showTooltip(text2, x, y) {
+    tooltip.textContent = text2;
+    tooltip.hidden = false;
+    tooltip.style.left = `${Math.max(8, Math.min(x + 12, window.innerWidth - 370))}px`;
+    tooltip.style.top = `${Math.max(8, Math.min(y + 12, window.innerHeight - tooltip.offsetHeight - 10))}px`;
+  }
+  const definitions = [
+    {
+      key: "liveTps",
+      title: "Live TPS",
+      unit: "tokens / second",
+      description: "Estimated text + reasoning throughput in the rolling collection window.",
+      requests: false,
+      estimated: true
+    },
+    {
+      key: "averageModelTps",
+      title: "Average model throughput",
+      unit: "tokens / second",
+      description: "Session output / matched model-request time, including TTFT and excluding subsequent tool time.",
+      requests: false,
+      estimated: false
+    },
+    {
+      key: "averageSessionTps",
+      title: "Average session throughput",
+      unit: "tokens / second",
+      description: "Session output / elapsed session lifetime, including tools and idle time.",
+      requests: false,
+      estimated: false
+    },
+    {
+      key: "ttftMs",
+      title: "Time to first output",
+      unit: "seconds",
+      description: "One point per request with observed text/reasoning output. Includes publication delay.",
+      requests: true,
+      estimated: true
+    },
+    {
+      key: "tps",
+      title: "Completed request throughput",
+      unit: "tokens / second",
+      description: "Reported output + reasoning / request duration. Requests are never joined into a continuous curve.",
+      requests: true,
+      estimated: false
+    },
+    {
+      key: "sessionOutputTokens",
+      title: "Cumulative output",
+      unit: "tokens",
+      description: "Authoritative session output + reasoning totals. Lifecycle and sample records are snapshots, not increments.",
+      requests: false,
+      estimated: false
+    }
+  ];
+  function render() {
+    tooltip.hidden = true;
+    charts.replaceChildren();
+    stats.replaceChildren();
+    legend.replaceChildren();
+    const start = timestamp(from.value), end = timestamp(to.value);
+    if (start !== undefined && !Number.isFinite(start) || end !== undefined && !Number.isFinite(end) || start !== undefined && end !== undefined && start > end) {
+      notice.textContent = "Choose a valid time range with From before To.";
+      return;
+    }
+    const selected = data.series.filter((s) => (session.value === "*" || s.sessionId === session.value) && s.points.some((p) => matches2(p, start, end)) || (session.value === "*" || s.sessionId === session.value) && s.requests.some((p) => matches2(p, start, end)));
+    const visible = selected.slice(0, 12);
+    const requests = visible.flatMap((s) => s.requests.filter((r) => matches2(r, start, end)));
+    const matched = requests.filter((r) => r.outputTokens !== undefined && r.durationMs !== undefined && r.durationMs > 0);
+    const duration = matched.reduce((sum, r) => sum + (r.durationMs ?? 0), 0), tokens = matched.reduce((sum, r) => sum + (r.outputTokens ?? 0), 0);
+    const ttfts = requests.flatMap((r) => r.ttftMs === undefined ? [] : [r.ttftMs]).sort((a, b) => a - b);
+    const percentile = (q) => ttfts.length ? (ttfts[Math.max(0, Math.ceil(ttfts.length * q) - 1)] ?? 0) / 1000 : undefined;
+    for (const [label, value] of [
+      ["Matched / observed requests", `${matched.length} / ${requests.length}`],
+      [
+        "Retained request throughput",
+        duration ? `${number(tokens * 1000 / duration)} t/s` : "Unavailable"
+      ],
+      [
+        "Median observed TTFT",
+        ttfts.length ? `${number(percentile(0.5), 2)}s` : "Unavailable"
+      ],
+      [
+        "95th percentile TTFT",
+        ttfts.length ? `${number(percentile(0.95), 2)}s` : "Unavailable"
+      ]
+    ]) {
+      const box = document.createElement("div");
+      box.className = "stat";
+      const name = document.createElement("span"), valueNode = document.createElement("strong");
+      name.textContent = label ?? "";
+      valueNode.textContent = value ?? "";
+      box.append(name, valueNode);
+      stats.append(box);
+    }
+    const gaps = data.gaps.filter((g) => (g.sessionId === "__history__" || visible.some((s) => s.sessionId === g.sessionId)) && (start === undefined || g.time >= start) && (end === undefined || g.time <= end));
+    const notes = [
+      `Bounded retained history: ${metadata.retainedFrom === undefined ? "empty archive" : `segments since ${date(metadata.retainedFrom)}`}.`,
+      `${gaps.length} recorded gap markers.`
+    ];
+    if (metadata.skippedBytes)
+      notes.push(`${number(metadata.skippedBytes, 0)} bytes excluded by the read limit.`);
+    if (metadata.malformedRecords)
+      notes.push(`${metadata.malformedRecords} malformed/partial records skipped.`);
+    if (data.omittedGaps)
+      notes.push(`${data.omittedGaps} older gap markers omitted; curve discontinuities remain preserved.`);
+    if (data.omittedSessions)
+      notes.push(`${data.omittedSessions} sessions omitted from the report limit; regenerate with --session to inspect one.`);
+    if (selected.length > 12)
+      notes.push(`Showing 12 of ${selected.length} matching sessions; select a session for detail.`);
+    if (visible.some((s) => s.originalPoints > s.points.length))
+      notes.push(`Curves downsampled to at most ${data.maxPoints} observations per session, preserving extrema and gaps.`);
+    if (visible.some((s) => s.points.some((p) => p.partial && matches2(p, start, end))))
+      notes.push("Partial timing coverage is present.");
+    if (!visible.length)
+      notes.push("No observations match these filters.");
+    notice.textContent = notes.join(" ");
+    visible.forEach((s, index) => {
+      const item = document.createElement("span"), dot = document.createElement("i");
+      dot.className = "dot";
+      dot.style.backgroundColor = color(index);
+      item.append(dot, document.createTextNode(`${s.agents.join(", ") || "Agent"} \xB7 ${s.sessionId}${s.parentId ? ` (child of ${s.parentId})` : ""}`));
+      legend.append(item);
+    });
+    const times = visible.flatMap((s) => [...s.points, ...s.requests].filter((p) => matches2(p, start, end)).map((p) => p.time));
+    let minTime = start ?? times.reduce((a, t) => Math.min(a, t), Infinity), maxTime = end ?? times.reduce((a, t) => Math.max(a, t), -Infinity);
+    if (!Number.isFinite(minTime))
+      minTime = 0;
+    if (!Number.isFinite(maxTime))
+      maxTime = minTime + 1000;
+    if (maxTime <= minTime)
+      maxTime = minTime + 1000;
+    for (const def of definitions) {
+      const card = document.createElement("section");
+      card.className = "chart";
+      const heading = document.createElement("div");
+      heading.className = "charthead";
+      const title = document.createElement("h2");
+      title.textContent = def.title;
+      const download = document.createElement("button");
+      download.textContent = "Save SVG";
+      download.setAttribute("aria-label", `Save ${def.title} as SVG`);
+      heading.append(title, download);
+      const desc = document.createElement("p");
+      desc.textContent = def.description;
+      card.append(heading, desc);
+      charts.append(card);
+      const plots = visible.map((s) => {
+        if (def.requests)
+          return s.requests.filter((p) => matches2(p, start, end)).map((p) => {
+            const raw = def.key === "ttftMs" ? p.ttftMs : p.tps;
+            return {
+              ...p,
+              breakBefore: true,
+              ...raw === undefined ? {} : { value: def.key === "ttftMs" ? raw / 1000 : raw }
+            };
+          });
+        let skipped = false;
+        return s.points.flatMap((p) => {
+          if (!matches2(p, start, end)) {
+            skipped = true;
+            return [];
+          }
+          const key = def.key;
+          const value = key === "liveTps" ? p.liveTps : key === "averageModelTps" ? p.averageModelTps : key === "averageSessionTps" ? p.averageSessionTps : p.sessionOutputTokens;
+          const point = {
+            ...p,
+            breakBefore: p.breakBefore || skipped,
+            ...value === undefined ? {} : { value }
+          };
+          skipped = false;
+          return [point];
+        });
+      });
+      const drawn = plots.map((points) => {
+        if (!def.requests || points.length <= data.maxPoints)
+          return points;
+        const bins = Math.max(1, Math.floor(data.maxPoints / 4)), chosen = new Set;
+        for (let b = 0;b < bins; b++) {
+          const first = Math.floor(b * points.length / bins), last = Math.floor((b + 1) * points.length / bins) - 1;
+          chosen.add(first);
+          chosen.add(last);
+          let low = first, high = first;
+          for (let i = first;i <= last; i++) {
+            if ((points[i]?.value ?? Infinity) < (points[low]?.value ?? Infinity))
+              low = i;
+            if ((points[i]?.value ?? -Infinity) > (points[high]?.value ?? -Infinity))
+              high = i;
+          }
+          chosen.add(low);
+          chosen.add(high);
         }
-        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++;
+        return [...chosen].sort((a, b) => a - b).flatMap((i) => points[i] ? [points[i]] : []);
+      });
+      const maxValue = drawn.reduce((maximum, points) => points.reduce((n, p) => Math.max(n, p.value ?? 0), maximum), 1) * 1.08;
+      const w = 720, h = 300, left = 64, right = 20, top = 24, bottom = 47;
+      const x = (t) => left + (t - minTime) / (maxTime - minTime) * (w - left - right);
+      const y = (v) => h - bottom - v / maxValue * (h - top - bottom);
+      const svg = svgNode("svg", {
+        viewBox: `0 0 ${w} ${h}`,
+        role: "img",
+        "aria-label": `${def.title} over UTC timestamps`,
+        xmlns: ns
+      });
+      svg.append(svgNode("rect", { width: w, height: h, fill: "#111c2e" }), svgNode("title", {}, `${def.title}. ${def.description}`));
+      svg.append(svgNode("text", {
+        x: left,
+        y: 14,
+        fill: "#a8b5cb",
+        "font-size": 11,
+        "font-family": "system-ui,sans-serif"
+      }, def.unit));
+      for (let tick = 0;tick <= 4; tick++) {
+        const v = maxValue * tick / 4;
+        svg.append(svgNode("line", {
+          x1: left,
+          x2: w - right,
+          y1: y(v),
+          y2: y(v),
+          stroke: "#2a3950",
+          "stroke-width": 1
+        }));
+        svg.append(svgNode("text", {
+          x: left - 8,
+          y: y(v) + 4,
+          fill: "#a8b5cb",
+          "text-anchor": "end",
+          "font-size": 11,
+          "font-family": "system-ui,sans-serif"
+        }, v >= 1e4 ? `${number(v / 1000)}k` : number(v)));
+        const t = minTime + (maxTime - minTime) * tick / 4;
+        const label = maxTime - minTime > 86400000 ? date(t).slice(5, 16).replace("T", " ") : date(t).slice(11, 19);
+        svg.append(svgNode("text", {
+          x: x(t),
+          y: h - 22,
+          fill: "#a8b5cb",
+          "text-anchor": tick === 0 ? "start" : tick === 4 ? "end" : "middle",
+          "font-size": 11,
+          "font-family": "system-ui,sans-serif"
+        }, label));
       }
+      for (const gap of gaps)
+        if (gap.time >= minTime && gap.time <= maxTime) {
+          const line = svgNode("line", {
+            x1: x(gap.time),
+            x2: x(gap.time),
+            y1: top,
+            y2: h - bottom,
+            stroke: "#fb7185",
+            "stroke-dasharray": "3 5",
+            opacity: 0.65
+          });
+          line.append(svgNode("title", {}, `${date(gap.time)} \xB7 ${gap.reason}`));
+          svg.append(line);
+        }
+      let count2 = 0;
+      drawn.forEach((points, index) => {
+        let run = [];
+        const flush = () => {
+          if (run.length > 1)
+            svg.append(svgNode("polyline", {
+              points: run.map((p) => `${x(p.time)},${y(p.value ?? 0)}`).join(" "),
+              fill: "none",
+              stroke: color(index),
+              "stroke-width": 1.8,
+              ...def.estimated || run.some((p) => p.partial) ? { "stroke-dasharray": "5 4" } : {}
+            }));
+          run = [];
+        };
+        for (const point of points) {
+          if (point.breakBefore || point.value === undefined)
+            flush();
+          if (point.value === undefined)
+            continue;
+          count2++;
+          if (!def.requests)
+            run.push(point);
+          const label = `${date(point.time)}\n${visible[index]?.sessionId ?? ""}${point.agent ? ` \xB7 ${point.agent}` : ""}${point.model ? `\n${point.model}` : ""}\n${def.title}: ${def.estimated ? "~" : ""}${number(point.value, 3)} ${def.unit}${point.requestId ? `\nRequest: ${point.requestId}` : ""}${point.partial ? "\nPartial observation coverage" : ""}`;
+          const dot = svgNode("circle", {
+            cx: x(point.time),
+            cy: y(point.value),
+            r: def.requests ? 3 : 2.5,
+            fill: color(index),
+            tabindex: 0,
+            "aria-label": label
+          });
+          dot.append(svgNode("title", {}, label));
+          dot.addEventListener("mouseenter", (e) => showTooltip(label, e.clientX, e.clientY));
+          dot.addEventListener("mouseleave", () => {
+            tooltip.hidden = true;
+          });
+          dot.addEventListener("focus", () => {
+            const box = dot.getBoundingClientRect();
+            showTooltip(label, box.x, box.y);
+          });
+          dot.addEventListener("blur", () => {
+            tooltip.hidden = true;
+          });
+          svg.append(dot);
+        }
+        flush();
+      });
+      if (!count2)
+        svg.append(svgNode("text", {
+          x: w / 2,
+          y: h / 2,
+          fill: "#a8b5cb",
+          "text-anchor": "middle",
+          "font-size": 14,
+          "font-family": "system-ui,sans-serif"
+        }, "No measurements in this selection"));
+      card.append(svg);
+      download.onclick = () => {
+        const blob = new Blob([new XMLSerializer().serializeToString(svg)], {
+          type: "image/svg+xml"
+        });
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement("a");
+        link.href = url;
+        link.download = `context-guard-${def.key}.svg`;
+        link.click();
+        setTimeout(() => URL.revokeObjectURL(url), 1000);
+      };
     }
   }
-  const metadata = {
-    schema: 1,
-    ...files[0] ? { retainedFrom: files[0].time } : {},
-    retainedBytes: files.reduce((n, f) => n + f.bytes, 0),
-    skippedBytes,
-    malformedRecords,
-    completeness: "bounded-retention"
+  for (const control of [session, agent, model, from, to])
+    control.addEventListener("change", render);
+  element("reset", HTMLButtonElement).onclick = () => {
+    reset();
+    render();
   };
-  return { metadata, records };
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function isHistoryRecord(value) {
-  if (!isRecord(value))
-    return false;
-  const r = value;
-  const allowed = new Set([
-    "schema",
-    "recordId",
-    "time",
-    "type",
-    "sessionId",
-    "parentId",
-    "agent",
-    "model",
-    "event",
-    "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);
+  reset();
+  render();
 }
 
+// src/cli.ts
+init_history();
+
 // src/telemetry.ts
 import { mkdir as mkdir2, open as open2, rename, stat as stat2 } from "fs/promises";
 import { dirname, join as join2 } from "path";
@@ -1277,14 +3613,147 @@ async function readJournal(path, maxBytes = 16 * 1024 * 1024) {
   return records;
 }
 
+// src/clihelp.ts
+var mainHelp = `Context Guard \u2014 context monitoring for OpenCode V2
+
+Start here
+  In your project, run: opencode
+  Inside OpenCode, enter: /context-guard
+  The plugin loads with OpenCode; observe mode is the default.
+
+Usage: context-guard <command> [options]
+       context-guard <journal.jsonl> [--history | --json]
+
+Commands
+  dashboard tui   Open the standalone live terminal dashboard
+  models          Compare models across retained history
+  metrics         Export retained performance records as JSON or CSV
+  charts          Generate an interactive HTML report
+  <journal.jsonl> Inspect diagnostic session records
+
+Examples
+  context-guard dashboard tui
+  context-guard models /absolute/history-directory
+  context-guard charts /absolute/history-directory --output report.html
+  context-guard /absolute/events.jsonl --history
+
+Help
+  context-guard <command> --help   Show options and examples
+  context-guard help journal      Explain diagnostic inspection
+  -h, --help                     Show help
+
+Requires Bun >=1.1.34; the standalone dashboard requires Bun >=1.3.0.
+From a source checkout, replace context-guard with bun run inspect.`;
+var filterOptions = `  --agent NAME       Filter by exact agent name
+  --model PROVIDER/MODEL
+                     Filter by exact model ID
+  --from ISO-or-ms    Start time: ISO timestamp or Unix milliseconds
+  --to ISO-or-ms      End time: ISO timestamp or Unix milliseconds`;
+var historyOptions = `  --session ID       Filter by session
+${filterOptions}`;
+var historyPath = `Use the owning location's history.path directory, not its diagnostic JSONL
+file. By default it is a location-hashed directory under
+\$XDG_STATE_HOME/opencode-context-guard (or ~/.local/state/opencode-context-guard).
+A custom telemetry.path does not change the history directory.`;
+var commandHelp = {
+  models: `Usage: context-guard models <history-directory> [options]
+Compare model throughput and time to first token across retained sessions.
+The history directory must be an absolute path. Output defaults to JSON.
+
+Options
+${filterOptions}
+  --csv              Export CSV; coverage metadata goes to stderr
+  --json             Export JSON (default); cannot combine with --csv
+  -h, --help         Show this help
+
+Example
+  context-guard models /absolute/history-directory --agent build --csv
+
+${historyPath}`,
+  metrics: `Usage: context-guard metrics <history-directory> [options]
+Read retained performance records. Output defaults to JSON.
+
+Options
+${historyOptions}
+  --csv              Export CSV; coverage metadata goes to stderr
+  --chart FILE.html  Generate an HTML report instead (see charts --help)
+  -h, --help         Show this help
+
+Example
+  context-guard metrics /absolute/history-directory --csv > metrics.csv
+
+${historyPath}`,
+  charts: `Usage: context-guard charts <history-directory> [options]
+Generate a self-contained interactive HTML report, then open it in a browser.
+
+Options
+${historyOptions}
+  --output FILE.html Write the report (default: context-guard-charts.html)
+  --max-points N     Points per series: 16\u20135000 (default: 1000)
+  --max-sessions N   Session instances: 1\u20131024 (default: 128)
+  --force            Overwrite an existing report
+  -h, --help         Show this help
+
+Example
+  context-guard charts /absolute/history-directory --output report.html
+
+${historyPath}`,
+  journal: `Usage: context-guard <journal.jsonl> [options]
+Inspect the diagnostic journal reported in OpenCode's Context Guard startup log.
+By default, print the latest retained record for each session, one JSON per line.
+
+Options
+  --json             Print latest session records as a JSON array
+  --history          Print all retained journal records as a JSON array
+  -h, --help         Show this help
+
+Example
+  context-guard /absolute/path/from/startup.jsonl --history
+
+This reads a diagnostic file, not a performance history directory.`
+};
+
 // src/cli.ts
 var args = process.argv.slice(2);
-if (!args[0] || args.includes("--help")) {
-  console.log("Usage: bun run inspect /absolute/path/to/journal.jsonl [--history] [--json]\nThe ready log reports the location-specific journal path.\nMetrics: inspect metrics /absolute/history-directory [--session ID] [--from ISO-or-ms] [--to ISO-or-ms] [--csv]\nCharts: inspect charts /absolute/history-directory --output report.html [--session ID] [--agent NAME] [--model provider/model] [--from ISO-or-ms] [--to ISO-or-ms] [--max-points 1000] [--force]");
+var helpRequested = args.some((arg) => arg === "--help" || arg === "-h");
+var helpTopic = args[0] === "help" ? args[1] : args[0];
+if (!args[0] || args[0] === "help" || helpRequested || args.length === 1 && (args[0] === "dashboard" || Object.hasOwn(commandHelp, args[0]))) {
+  if (helpTopic === "dashboard") {
+    const { dashboardHelp: dashboardHelp2 } = await Promise.resolve().then(() => (init_command(), exports_command));
+    console.log(dashboardHelp2);
+  } else if (helpTopic && Object.hasOwn(commandHelp, helpTopic)) {
+    console.log(commandHelp[helpTopic]);
+  } else if (args[0] === "help" && helpTopic) {
+    console.error(`Unknown help topic. Use context-guard --help for commands.`);
+    process.exitCode = 1;
+  } else if (helpRequested && helpTopic && !helpTopic.startsWith("-")) {
+    console.log(commandHelp.journal);
+  } else
+    console.log(mainHelp);
+} else if (args[0] === "dashboard") {
+  const { parseDashboardArgs: parseDashboardArgs2, dashboardHelp: dashboardHelp2, checkTerminalRuntime: checkTerminalRuntime2 } = await Promise.resolve().then(() => (init_command(), exports_command));
+  try {
+    const options = parseDashboardArgs2(args.slice(1), process.cwd(), process.env);
+    if (options === "help")
+      console.log(dashboardHelp2);
+    else {
+      checkTerminalRuntime2(Bun.version, Boolean(process.stdin.isTTY && process.stdout.isTTY));
+      const { runTerminal: runTerminal2 } = await Promise.resolve().then(() => (init_terminal(), exports_terminal));
+      await runTerminal2(options);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "";
+    const safe = /^(Use context-guard|Unknown dashboard|Duplicate dashboard|Missing value for --|Explicit servers require|dashboard tui requires|Terminal renderer unavailable|Terminal dashboard stopped|Dashboard directory must|Explicit credentials require|Use an HTTPS|No running|Dashboard server connection failed)/.test(message);
+    console.error(safe ? message : "Dashboard startup failed; check server, owning directory, authentication and renderer installation");
+    process.exitCode = 1;
+  }
+} else if (args[0] === "models") {
+  const { inspectModels: inspectModels2 } = await Promise.resolve().then(() => (init_modelcli(), exports_modelcli));
+  await inspectModels2(args.slice(1));
 } else if (args[0] === "metrics" || args[0] === "charts") {
   const directory = args[1];
   if (!directory || directory.startsWith("--"))
-    throw new Error("Usage: inspect metrics /absolute/history-directory [--session ID] [--from ISO-or-ms] [--to ISO-or-ms] [--csv]");
+    throw new Error(`Use context-guard ${args[0]} --help for usage and examples`);
   const option = (name) => {
     const index = args.indexOf(name);
     if (index < 0)
@@ -1324,7 +3793,7 @@ if (!args[0] || args.includes("--help")) {
     ...to === undefined ? {} : { to }
   });
   if (chart) {
-    const output = resolve(option("--chart") ?? option("--output") ?? "context-guard-charts.html");
+    const output = resolve3(option("--chart") ?? option("--output") ?? "context-guard-charts.html");
     if (!output.toLowerCase().endsWith(".html"))
       throw new Error("Chart output must use an .html extension");
     const data = buildChartData(result.records, { maxPoints, maxSessions });