@cesarus777/opencode-cgp 0.2.5 → 0.3.1

package/dist/index.js

@@ -1,174 +1,33 @@
 // @bun
-// 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 __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 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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
 };
-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 } }
-});
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/rpc.ts
+import { Rpc } from "@opencode/plugin/rpc";
 function isPerformanceBatch(value) {
   return valid(value, performanceBatchSchema) && uniqueRows(value);
 }
@@ -178,84 +37,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;
 }
@@ -310,656 +91,908 @@ 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/index.ts
-import { Plugin } from "@opencode/plugin";
-
-// src/performance.ts
-var valid2 = (n) => Number.isFinite(n) && n >= 0;
-var rate = (tokens, ms) => valid2(tokens) && ms > 0 ? tokens * 1000 / ms : undefined;
-function outputTokens(tokens) {
-  const n = tokens.output + tokens.reasoning;
-  return Number.isSafeInteger(tokens.output) && tokens.output >= 0 && Number.isSafeInteger(tokens.reasoning) && tokens.reasoning >= 0 && Number.isSafeInteger(n) ? n : undefined;
+// 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 [];
+    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));
 }
 
-class PerformanceTracker {
-  maxSessions;
-  windowMs;
+class PerformanceHistory {
+  path;
+  config;
   now;
-  rows = new Map;
-  constructor(maxSessions, windowMs = 2000, now = Date.now) {
-    this.maxSessions = maxSessions;
-    this.windowMs = windowMs;
+  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;
   }
-  observe(id, created, cumulative) {
-    let row2 = this.rows.get(id);
-    if (!row2) {
-      if (this.rows.size >= this.maxSessions)
-        return;
-      row2 = {
-        observedSince: this.now(),
-        created,
-        partial: cumulative !== 0,
-        output: 0,
-        duration: 0,
-        completed: 0,
-        sequence: -1
-      };
-      this.rows.set(id, row2);
-    }
-    if (valid2(created))
-      row2.created = created;
-    if (cumulative !== undefined && valid2(cumulative))
-      row2.cumulative = cumulative;
-  }
-  accept(id, sequence) {
-    const row2 = this.rows.get(id);
-    if (!row2 || sequence <= row2.sequence)
-      return false;
-    row2.sequence = sequence;
-    return true;
-  }
-  start(id, requestId, agent, model, started) {
-    const row2 = this.rows.get(id);
-    if (!row2 || !valid2(started))
-      return;
-    const old = row2.request;
-    if (old?.id === requestId && old.started === started)
+  emit(record2) {
+    if (!this.config.enabled || this.disabled)
       return;
-    if (old && !old.settled)
-      row2.partial = true;
-    row2.request = {
-      id: requestId,
-      agent,
-      model,
-      started,
-      chars: 0,
-      settled: false,
-      events: new Set,
-      buckets: new Map
-    };
-  }
-  delta(id, requestId, eventId, at, characters) {
-    const row2 = this.rows.get(id), r = row2?.request;
-    if (!row2 || !r || r.id !== requestId || r.settled || r.ended !== undefined || !valid2(at) || at < r.started || !valid2(characters) || !characters || r.events.has(eventId))
+    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;
-    if (r.events.size >= 256)
-      r.events.delete(r.events.values().next().value ?? "");
-    r.events.add(eventId);
-    r.first = r.first === undefined ? at : Math.min(r.first, at);
-    r.chars += characters;
-    const bucket = Math.floor(at / 100) * 100;
-    r.buckets.set(bucket, (r.buckets.get(bucket) ?? 0) + characters);
-    this.prune(r, Math.max(at, this.now()));
-    while (r.buckets.size > Math.ceil(this.windowMs / 100) + 2) {
-      r.buckets.delete(Math.min(...r.buckets.keys()));
     }
+    this.pending.push(line);
+    this.kick();
   }
-  streamed(id, requestId, at) {
-    const row2 = this.rows.get(id), r = row2?.request;
-    if (!row2 || !r || r.id !== requestId || r.settled || r.ended !== undefined)
-      return;
-    if (!valid2(at) || at <= r.started || r.first !== undefined && at < r.first) {
-      row2.partial = true;
+  kick() {
+    if (this.working || this.disabled)
       return;
-    }
-    r.ended = at;
+    this.working = this.drain().catch(() => {
+      this.disabled = true;
+      this.pending = [];
+      this.report("history-unavailable");
+    }).finally(() => {
+      this.working = undefined;
+      if (this.pending.length)
+        this.kick();
+    });
   }
-  settle(id, requestId, tokens) {
-    const row2 = this.rows.get(id), r = row2?.request;
-    if (!row2)
-      return;
-    if (!r || r.id !== requestId) {
-      row2.partial = true;
-      return;
+  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 (r.settled)
-      return;
-    r.settled = true;
-    if (tokens !== undefined && valid2(tokens))
-      r.output = tokens;
-    if (tokens !== undefined && valid2(tokens) && r.ended !== undefined) {
-      row2.output += tokens;
-      row2.duration += r.ended - r.started;
-      row2.completed++;
-    } else
-      row2.partial = true;
-    const snapshot = this.snapshot(id);
-    if (snapshot) {
-      const { latestRequestTps: _previousRate, ...current } = snapshot;
-      row2.latest = {
-        ...current,
-        tokenSource: tokens === undefined ? "unavailable" : "reported",
-        ...tokens !== undefined && r.ended !== undefined ? { latestRequestTps: tokens * 1000 / (r.ended - r.started) } : {}
-      };
-    }
-    r.events.clear();
-    r.buckets.clear();
+    if (truncated)
+      this.report("history-truncated");
   }
-  gap(id) {
-    for (const [key, row2] of this.rows) {
-      if (id !== undefined && key !== id)
+  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;
-      row2.partial = true;
-      delete row2.request;
+      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;
     }
   }
-  prune(r, at) {
-    for (const time of r.buckets.keys())
-      if (time < at - this.windowMs)
-        r.buckets.delete(time);
-  }
-  snapshot(id) {
-    const row2 = this.rows.get(id);
-    if (!row2)
-      return;
-    const at = this.now(), r = row2.request;
-    const active = r && !r.settled && r.ended === undefined;
-    if (r)
-      this.prune(r, at);
-    const live = active ? rate([...r.buckets.values()].reduce((a, b) => a + b, 0) / 4, Math.min(this.windowMs, at - r.started)) : 0;
-    const averageModelTps = rate(row2.output, row2.duration);
-    const averageSessionTps = row2.cumulative === undefined ? undefined : rate(row2.cumulative, at - row2.created);
-    return {
-      observedSince: row2.observedSince,
-      at,
-      sessionCreatedAt: row2.created,
-      ...row2.cumulative === undefined ? {} : { sessionOutputTokens: row2.cumulative },
-      status: active ? r.first === undefined ? "waiting" : "streaming" : !r && row2.partial ? "unavailable" : "idle",
-      partial: row2.partial,
-      ...live === undefined || !r && row2.partial ? {} : { liveTps: live },
-      ...averageModelTps === undefined ? {} : { averageModelTps },
-      ...averageSessionTps === undefined ? {} : { averageSessionTps },
-      ...r ? {
-        requestId: r.id,
-        requestAgent: r.agent,
-        requestModel: r.model,
-        requestStartedAt: r.started,
-        ...r.output === undefined ? {} : { requestOutputTokens: r.output },
-        ...r.first === undefined ? {} : { firstOutputAt: r.first, ttftMs: r.first - r.started },
-        ...r.ended === undefined ? {} : { streamEndedAt: r.ended }
-      } : row2.latest ? {
-        ...row2.latest.ttftMs === undefined ? {} : { ttftMs: row2.latest.ttftMs }
-      } : {},
-      ...row2.latest?.latestRequestTps === undefined ? {} : { latestRequestTps: row2.latest.latestRequestTps },
-      estimatedOutputTokens: r ? r.chars / 4 : 0,
-      modelOutputTokens: row2.output,
-      modelDurationMs: row2.duration,
-      completedRequests: row2.completed,
-      tokenSource: r && !r.settled ? "estimated" : row2.latest?.tokenSource ?? "unavailable"
-    };
+  health() {
+    return { unavailable: this.disabled, droppedRecords: this.droppedTotal };
   }
-  checkpoint() {
-    return [...this.rows].map(([sessionId, r]) => ({
-      sessionId,
-      observedSince: r.observedSince,
-      created: r.created,
-      output: r.output,
-      duration: r.duration,
-      completed: r.completed,
-      sequence: r.sequence
-    }));
+  async flush() {
+    while (this.working)
+      await this.working;
   }
-  restore(value) {
-    if (!Array.isArray(value))
+  async initialize() {
+    if (!this.config.enabled)
       return;
-    for (const item of value.slice(0, this.maxSessions)) {
-      if (!item || typeof item !== "object")
-        continue;
-      const r = item;
-      if (typeof r.sessionId !== "string" || !r.sessionId.length || r.sessionId.length > 512 || ![r.observedSince, r.created, r.output, r.duration, r.completed].every((n) => typeof n === "number" && Number.isSafeInteger(n) && n >= 0) || typeof r.sequence !== "number" || !Number.isSafeInteger(r.sequence) || r.sequence < -1)
-        continue;
-      const { observedSince, created, output, duration, completed, sequence } = r;
-      if (typeof observedSince !== "number" || typeof created !== "number" || typeof output !== "number" || typeof duration !== "number" || typeof completed !== "number")
-        continue;
-      this.rows.set(r.sessionId, {
-        observedSince,
-        created,
-        output,
-        duration,
-        completed,
-        sequence,
-        partial: true
-      });
-    }
-  }
-  remove(id) {
-    this.rows.delete(id);
-  }
-  ids() {
-    return this.rows.keys();
+    await mkdir(this.path, { recursive: true, mode: 448 }).then(() => this.prune()).catch(() => {
+      this.disabled = true;
+      this.report("history-unavailable");
+    });
   }
 }
-
-// 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)
+function scalarPerformance(p) {
+  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]];
+    }))
+  };
+}
+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);
+  }
+  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 (low === undefined || value < (points[low]?.[field] ?? Infinity))
-          low = i;
-        if (high === undefined || value > (points[high]?.[field] ?? -Infinity))
-          high = i;
+        }
+        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++;
       }
-      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 {
+  const metadata = {
     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
+    ...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/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;
-  });
-  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));
+// src/index.ts
+import { Plugin } from "@opencode/plugin";
+
+// src/performance.ts
+var valid2 = (n) => Number.isFinite(n) && n >= 0;
+var rate = (tokens, ms) => valid2(tokens) && ms > 0 ? tokens * 1000 / ms : undefined;
+function outputTokens(tokens) {
+  const n = tokens.output + tokens.reasoning;
+  return Number.isSafeInteger(tokens.output) && tokens.output >= 0 && Number.isSafeInteger(tokens.reasoning) && tokens.reasoning >= 0 && Number.isSafeInteger(n) ? n : undefined;
 }
 
-class PerformanceHistory {
-  path;
-  config;
+class PerformanceTracker {
+  maxSessions;
+  windowMs;
   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;
+  rows = new Map;
+  constructor(maxSessions, windowMs = 2000, now = Date.now) {
+    this.maxSessions = maxSessions;
+    this.windowMs = windowMs;
     this.now = now;
-    this.report = report;
   }
-  emit(record2) {
-    if (!this.config.enabled || this.disabled)
+  observe(id, created, cumulative) {
+    let row2 = this.rows.get(id);
+    if (!row2) {
+      if (this.rows.size >= this.maxSessions)
+        return;
+      row2 = {
+        observedSince: this.now(),
+        created,
+        partial: cumulative !== 0,
+        output: 0,
+        duration: 0,
+        completed: 0,
+        sequence: -1
+      };
+      this.rows.set(id, row2);
+    }
+    if (valid2(created))
+      row2.created = created;
+    if (cumulative !== undefined && valid2(cumulative))
+      row2.cumulative = cumulative;
+  }
+  accept(id, sequence) {
+    const row2 = this.rows.get(id);
+    if (!row2 || sequence <= row2.sequence)
+      return false;
+    row2.sequence = sequence;
+    return true;
+  }
+  start(id, requestId, agent, model, started) {
+    const row2 = this.rows.get(id);
+    if (!row2 || !valid2(started))
       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");
+    const old = row2.request;
+    if (old?.id === requestId && old.started === started)
+      return;
+    if (old && !old.settled)
+      row2.partial = true;
+    row2.request = {
+      id: requestId,
+      agent,
+      model,
+      started,
+      chars: 0,
+      settled: false,
+      events: new Set,
+      buckets: new Map
+    };
+  }
+  delta(id, requestId, eventId, at, characters) {
+    const row2 = this.rows.get(id), r = row2?.request;
+    if (!row2 || !r || r.id !== requestId || r.settled || r.ended !== undefined || !valid2(at) || at < r.started || !valid2(characters) || !characters || r.events.has(eventId))
       return;
+    if (r.events.size >= 256)
+      r.events.delete(r.events.values().next().value ?? "");
+    r.events.add(eventId);
+    r.first = r.first === undefined ? at : Math.min(r.first, at);
+    r.chars += characters;
+    const bucket = Math.floor(at / 100) * 100;
+    r.buckets.set(bucket, (r.buckets.get(bucket) ?? 0) + characters);
+    this.prune(r, Math.max(at, this.now()));
+    while (r.buckets.size > Math.ceil(this.windowMs / 100) + 2) {
+      r.buckets.delete(Math.min(...r.buckets.keys()));
     }
-    this.pending.push(line);
-    this.kick();
   }
-  kick() {
-    if (this.working || this.disabled)
+  streamed(id, requestId, at) {
+    const row2 = this.rows.get(id), r = row2?.request;
+    if (!row2 || !r || r.id !== requestId || r.settled || r.ended !== undefined)
       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();
-    });
+    if (!valid2(at) || at <= r.started || r.first !== undefined && at < r.first) {
+      row2.partial = true;
+      return;
+    }
+    r.ended = at;
   }
-  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;
+  settle(id, requestId, tokens) {
+    const row2 = this.rows.get(id), r = row2?.request;
+    if (!row2)
+      return;
+    if (!r || r.id !== requestId) {
+      row2.partial = true;
+      return;
     }
-    if (truncated)
-      this.report("history-truncated");
+    if (r.settled)
+      return;
+    r.settled = true;
+    if (tokens !== undefined && valid2(tokens))
+      r.output = tokens;
+    if (tokens !== undefined && valid2(tokens) && r.ended !== undefined) {
+      row2.output += tokens;
+      row2.duration += r.ended - r.started;
+      row2.completed++;
+    } else
+      row2.partial = true;
+    const snapshot = this.snapshot(id);
+    if (snapshot) {
+      const { latestRequestTps: _previousRate, ...current } = snapshot;
+      row2.latest = {
+        ...current,
+        tokenSource: tokens === undefined ? "unavailable" : "reported",
+        ...tokens !== undefined && r.ended !== undefined ? { latestRequestTps: tokens * 1000 / (r.ended - r.started) } : {}
+      };
+    }
+    r.events.clear();
+    r.buckets.clear();
   }
-  gapLine(event, droppedRecords) {
-    return JSON.stringify({
-      schema: 1,
-      recordId: crypto.randomUUID(),
-      time: this.now(),
-      type: "gap",
-      sessionId: "__history__",
-      event,
-      ...droppedRecords === undefined ? {} : { droppedRecords }
-    }) + "\n";
+  gap(id) {
+    for (const [key, row2] of this.rows) {
+      if (id !== undefined && key !== id)
+        continue;
+      row2.partial = true;
+      delete row2.request;
+    }
   }
-  async drain() {
-    await mkdir(this.path, { recursive: true, mode: 448 });
-    await this.prune();
-    while (this.pending.length) {
-      let line = this.pending.shift();
-      if (!line)
+  prune(r, at) {
+    for (const time of r.buckets.keys())
+      if (time < at - this.windowMs)
+        r.buckets.delete(time);
+  }
+  snapshot(id) {
+    const row2 = this.rows.get(id);
+    if (!row2)
+      return;
+    const at = this.now(), r = row2.request;
+    const active = r && !r.settled && r.ended === undefined;
+    if (r)
+      this.prune(r, at);
+    const live = active ? rate([...r.buckets.values()].reduce((a, b) => a + b, 0) / 4, Math.min(this.windowMs, at - r.started)) : 0;
+    const averageModelTps = rate(row2.output, row2.duration);
+    const averageSessionTps = row2.cumulative === undefined ? undefined : rate(row2.cumulative, at - row2.created);
+    return {
+      observedSince: row2.observedSince,
+      at,
+      sessionCreatedAt: row2.created,
+      ...row2.cumulative === undefined ? {} : { sessionOutputTokens: row2.cumulative },
+      status: active ? r.first === undefined ? "waiting" : "streaming" : !r && row2.partial ? "unavailable" : "idle",
+      partial: row2.partial,
+      ...live === undefined || !r && row2.partial ? {} : { liveTps: live },
+      ...averageModelTps === undefined ? {} : { averageModelTps },
+      ...averageSessionTps === undefined ? {} : { averageSessionTps },
+      ...r ? {
+        requestId: r.id,
+        requestAgent: r.agent,
+        requestModel: r.model,
+        requestStartedAt: r.started,
+        ...r.output === undefined ? {} : { requestOutputTokens: r.output },
+        ...r.first === undefined ? {} : { firstOutputAt: r.first, ttftMs: r.first - r.started },
+        ...r.ended === undefined ? {} : { streamEndedAt: r.ended }
+      } : row2.latest ? {
+        ...row2.latest.ttftMs === undefined ? {} : { ttftMs: row2.latest.ttftMs }
+      } : {},
+      ...row2.latest?.latestRequestTps === undefined ? {} : { latestRequestTps: row2.latest.latestRequestTps },
+      estimatedOutputTokens: r ? r.chars / 4 : 0,
+      modelOutputTokens: row2.output,
+      modelDurationMs: row2.duration,
+      completedRequests: row2.completed,
+      tokenSource: r && !r.settled ? "estimated" : row2.latest?.tokenSource ?? "unavailable"
+    };
+  }
+  checkpoint() {
+    return [...this.rows].map(([sessionId, r]) => ({
+      sessionId,
+      observedSince: r.observedSince,
+      created: r.created,
+      output: r.output,
+      duration: r.duration,
+      completed: r.completed,
+      sequence: r.sequence
+    }));
+  }
+  restore(value) {
+    if (!Array.isArray(value))
+      return;
+    for (const item of value.slice(0, this.maxSessions)) {
+      if (!item || typeof item !== "object")
         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`;
-      }
-      const file = await open(join(this.path, this.active), "a", 384);
-      try {
-        await file.writeFile(line);
-      } finally {
-        await file.close();
+      const r = item;
+      if (typeof r.sessionId !== "string" || !r.sessionId.length || r.sessionId.length > 512 || ![r.observedSince, r.created, r.output, r.duration, r.completed].every((n) => typeof n === "number" && Number.isSafeInteger(n) && n >= 0) || typeof r.sequence !== "number" || !Number.isSafeInteger(r.sequence) || r.sequence < -1)
+        continue;
+      const { observedSince, created, output, duration, completed, sequence } = r;
+      if (typeof observedSince !== "number" || typeof created !== "number" || typeof output !== "number" || typeof duration !== "number" || typeof completed !== "number")
+        continue;
+      this.rows.set(r.sessionId, {
+        observedSince,
+        created,
+        output,
+        duration,
+        completed,
+        sequence,
+        partial: true
+      });
+    }
+  }
+  remove(id) {
+    this.rows.delete(id);
+  }
+  ids() {
+    return this.rows.keys();
+  }
+}
+
+// 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;
       }
-      this.bytes += size;
+      if (low !== undefined)
+        selected.add(low);
+      if (high !== undefined)
+        selected.add(high);
     }
   }
-  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 {
-    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]];
-    }))
-  };
+  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 }];
+  });
 }
-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;
+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;
     }
-    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();
+    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);
     }
-    for (const line of source.split("\n")) {
-      if (!line)
+    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;
-      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++;
-      }
+      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 } : {}
+      });
     }
   }
-  const metadata = {
+  return {
     schema: 1,
-    ...files[0] ? { retainedFrom: files[0].time } : {},
-    retainedBytes: files.reduce((n, f) => n + f.bytes, 0),
-    skippedBytes,
-    malformedRecords,
-    completeness: "bounded-retention"
+    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
   };
-  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);
 }
 
 // src/historyserver.ts
+init_history();
+init_rpc();
 async function serveHistory(rpc, path, enabled, now = Date.now, authorize = async () => true) {
   if (!rpc)
     return () => {
@@ -1023,6 +1056,9 @@ async function serveHistory(rpc, path, enabled, now = Date.now, authorize = asyn
   };
 }
 
+// src/adapter.ts
+init_history();
+
 // src/policy.ts
 function glob(pattern, text2) {
   let p = 0, t = 0, star = -1, retry = 0;
@@ -1330,6 +1366,7 @@ function freezeSnapshot(row2) {
 }
 
 // src/snapshotserver.ts
+init_rpc();
 async function serveSnapshots(rpc, store, performance = false, prepareRead) {
   if (!rpc)
     return () => {