@cesarus777/opencode-cgp 0.4.1 → 0.4.3

package/dist/index.js

@@ -473,15 +473,109 @@ async function segments(directory) {
   return (await Promise.all(names.filter((n) => filename.test(n)).map(async (name) => ({
     name,
     time: Number(filename.exec(name)?.[1]),
-    bytes: (await stat(join(directory, name))).size
+    ...fileIdentity(await stat(join(directory, name)))
   })))).sort((a, b) => a.time - b.time || a.name.localeCompare(b.name));
 }
+function fileIdentity(info) {
+  return {
+    bytes: info.size,
+    dev: info.dev,
+    ino: info.ino,
+    mtimeMs: info.mtimeMs,
+    ctimeMs: info.ctimeMs
+  };
+}
+function scanScheduler(signal, options = {}) {
+  const now = options.now ?? (() => performance.now());
+  const pause = options.yield ?? (() => new Promise((done) => setTimeout(done, 0)));
+  let started = now();
+  return () => {
+    signal?.throwIfAborted();
+    if (now() - started >= 4)
+      return pause().then(() => {
+        signal?.throwIfAborted();
+        started = now();
+      });
+  };
+}
+function matchesHistory(value, filter) {
+  return !(filter.sessionId !== undefined && value.sessionId !== filter.sessionId && value.sessionId !== "__history__" || value.type !== "gap" && filter.agent !== undefined && (value.performance?.requestAgent ?? value.agent) !== filter.agent || value.type !== "gap" && filter.model !== undefined && (value.performance?.requestModel ?? value.model) !== filter.model || filter.from !== undefined && value.time < filter.from || filter.to !== undefined && value.time > filter.to);
+}
+async function scanHistorySegment(handle, size, filter = {}, options = {}, start = 0) {
+  const records = [];
+  let malformedRecords = 0, position = start, boundary = start;
+  let pending = Buffer.alloc(0);
+  const checkpoint = scanScheduler(filter.signal, options);
+  function parse(line) {
+    if (!line.length)
+      return;
+    options.onParse?.();
+    let value;
+    try {
+      value = JSON.parse(line.toString("utf8"));
+    } catch {
+      malformedRecords++;
+      return;
+    }
+    if (!isHistoryRecord(value)) {
+      malformedRecords++;
+      return;
+    }
+    if (matchesHistory(value, filter))
+      records.push(value);
+  }
+  while (position < size) {
+    {
+      const waiting = checkpoint();
+      if (waiting)
+        await waiting;
+    }
+    const buffer = Buffer.alloc(Math.min(options.chunkBytes ?? 65536, size - position));
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+    if (!bytesRead)
+      throw new Error("Archive changed during read");
+    options.onRead?.(bytesRead);
+    position += bytesRead;
+    const chunk = pending.length ? Buffer.concat([pending, buffer.subarray(0, bytesRead)]) : buffer.subarray(0, bytesRead);
+    let offset = 0;
+    for (;; ) {
+      const end = chunk.indexOf(10, offset);
+      if (end < 0)
+        break;
+      {
+        const waiting = checkpoint();
+        if (waiting)
+          await waiting;
+      }
+      parse(chunk.subarray(offset, end));
+      offset = end + 1;
+    }
+    pending = Buffer.from(chunk.subarray(offset));
+    boundary = position - pending.length;
+  }
+  const completeRecords = records.length, completeMalformed = malformedRecords;
+  {
+    const waiting = checkpoint();
+    if (waiting)
+      await waiting;
+  }
+  parse(pending);
+  filter.signal?.throwIfAborted();
+  return {
+    records,
+    malformedRecords,
+    boundary,
+    completeRecords,
+    completeMalformed
+  };
+}
 
 class PerformanceHistory {
   path;
   config;
   now;
   report;
+  changed;
   pending = [];
   working;
   active;
@@ -491,11 +585,13 @@ class PerformanceHistory {
   dropped = 0;
   droppedTotal = 0;
   constructor(path, config, now = Date.now, report = () => {
+  }, changed = () => {
   }) {
     this.path = path;
     this.config = config;
     this.now = now;
     this.report = report;
+    this.changed = changed;
   }
   emit(record2) {
     if (!this.config.enabled || this.disabled)
@@ -544,6 +640,7 @@ class PerformanceHistory {
       if (file.time >= this.now() - this.config.retentionDays * 86400000 && total + incoming <= this.config.maxBytes)
         break;
       await unlink(join(this.path, file.name));
+      this.changed(file.name);
       if (file.name === this.active) {
         this.active = undefined;
         this.bytes = 0;
@@ -594,6 +691,7 @@ class PerformanceHistory {
       const file = await open(join(this.path, this.active), "a", 384);
       try {
         await file.writeFile(line);
+        this.changed(this.active);
       } finally {
         await file.close();
       }
@@ -648,7 +746,8 @@ function scalarPerformance(p) {
     }))
   };
 }
-async function readPerformanceHistory(directory, filter = {}) {
+async function readPerformanceHistory(directory, filter = {}, options = {}) {
+  filter.signal?.throwIfAborted();
   const records = [];
   const files = await segments(directory);
   filter.signal?.throwIfAborted();
@@ -666,36 +765,16 @@ async function readPerformanceHistory(directory, filter = {}) {
   for (const file of selected) {
     filter.signal?.throwIfAborted();
     const handle = await open(join(directory, file.name), "r");
-    let source;
     try {
-      const buffer = Buffer.alloc(file.bytes);
-      const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-      source = buffer.subarray(0, bytesRead).toString("utf8");
+      const result = await scanHistorySegment(handle, file.bytes, filter, options);
+      for (const record2 of result.records)
+        records.push(record2);
+      malformedRecords += result.malformedRecords;
     } finally {
       await handle.close();
     }
-    let scannedLines = 0;
-    for (const line of source.split("\n")) {
-      if (filter.signal && ++scannedLines % 256 === 0) {
-        await new Promise((done) => setTimeout(done, 0));
-        filter.signal.throwIfAborted();
-      }
-      if (!line)
-        continue;
-      try {
-        const value = JSON.parse(line);
-        if (!isHistoryRecord(value)) {
-          malformedRecords++;
-          continue;
-        }
-        if (filter.sessionId !== undefined && value.sessionId !== filter.sessionId && value.sessionId !== "__history__" || value.type !== "gap" && filter.agent !== undefined && (value.performance?.requestAgent ?? value.agent) !== filter.agent || value.type !== "gap" && filter.model !== undefined && (value.performance?.requestModel ?? value.model) !== filter.model || filter.from !== undefined && value.time < filter.from || filter.to !== undefined && value.time > filter.to)
-          continue;
-        records.push(value);
-      } catch {
-        malformedRecords++;
-      }
-    }
   }
+  filter.signal?.throwIfAborted();
   const metadata = {
     schema: 1,
     ...files[0] ? { retainedFrom: files[0].time } : {},
@@ -713,7 +792,13 @@ function isHistoryRecord(value) {
   if (!isRecord(value))
     return false;
   const r = value;
-  const allowed = new Set([
+  return Object.keys(r).every((k) => historyFields.has(k)) && r.schema === 1 && typeof r.recordId === "string" && typeof r.time === "number" && Number.isSafeInteger(r.time) && r.time >= 0 && typeof r.sessionId === "string" && typeof r.type === "string" && ["sample", "request", "lifecycle", "gap", "terminal"].includes(r.type) && ["parentId", "agent", "model", "event"].every((k) => r[k] === undefined || typeof r[k] === "string") && (r.performance === undefined || isPerformanceSnapshot(r.performance)) && (r.droppedRecords === undefined || typeof r.droppedRecords === "number" && Number.isSafeInteger(r.droppedRecords) && r.droppedRecords >= 0);
+}
+var filename, historyFields;
+var init_history = __esm(() => {
+  init_rpc();
+  filename = /^([0-9]+)-[a-f0-9-]+\.jsonl$/;
+  historyFields = new Set([
     "schema",
     "recordId",
     "time",
@@ -726,12 +811,6 @@ function isHistoryRecord(value) {
     "performance",
     "droppedRecords"
   ]);
-  return Object.keys(r).every((k) => allowed.has(k)) && r.schema === 1 && typeof r.recordId === "string" && typeof r.time === "number" && Number.isSafeInteger(r.time) && r.time >= 0 && typeof r.sessionId === "string" && typeof r.type === "string" && ["sample", "request", "lifecycle", "gap", "terminal"].includes(r.type) && ["parentId", "agent", "model", "event"].every((k) => r[k] === undefined || typeof r[k] === "string") && (r.performance === undefined || isPerformanceSnapshot(r.performance)) && (r.droppedRecords === undefined || typeof r.droppedRecords === "number" && Number.isSafeInteger(r.droppedRecords) && r.droppedRecords >= 0);
-}
-var filename;
-var init_history = __esm(() => {
-  init_rpc();
-  filename = /^([0-9]+)-[a-f0-9-]+\.jsonl$/;
 });
 
 // src/modelanalytics.ts
@@ -778,6 +857,11 @@ function reconcile(a, b) {
   };
 }
 function analyzeModelRequests(records, options) {
+  const accumulator = createModelAccumulator(options);
+  accumulator.append(records);
+  return accumulator.result();
+}
+function createModelAccumulator(options) {
   const maxRequests = options.maxRequests ?? 1e5;
   if (!Number.isSafeInteger(maxRequests) || maxRequests < 1 || maxRequests > 1e6)
     throw new Error("maxRequests must be an integer from 1 to 1000000");
@@ -788,7 +872,7 @@ function analyzeModelRequests(records, options) {
       throw new Error("Invalid analytics timestamp");
   if (options.from !== undefined && options.to !== undefined && options.from > options.to)
     throw new Error("--from must precede --to");
-  const coverage = {
+  const counters = {
     source: "retained-request-records",
     scannedRecords: 0,
     unscannedRecords: 0,
@@ -802,74 +886,98 @@ function analyzeModelRequests(records, options) {
     partial: false
   };
   const requests = new Map;
-  for (const record2 of records) {
-    coverage.scannedRecords++;
-    if (record2.type === "gap") {
-      coverage.gapRecords++;
-      continue;
-    }
-    if (record2.type !== "request")
-      continue;
-    const fact = requestFact(record2);
-    if (!fact) {
-      coverage.missingIdentityRecords++;
-      continue;
-    }
-    fact.location = options.location;
-    const key = JSON.stringify([
-      fact.sessionId,
-      fact.requestId,
-      fact.startedAt
-    ]);
-    const previous = requests.get(key);
-    if (previous) {
-      coverage.duplicateRecords++;
-      const merged = reconcile(previous.fact, fact);
-      if (!merged)
-        previous.conflict = true;
-      else
-        previous.fact = merged;
-    } else {
-      if (requests.size === maxRequests) {
-        coverage.scannedRecords--;
-        coverage.unscannedRecords = records.length - coverage.scannedRecords;
+  let totalRecords = 0, stopped = false;
+  function append(records) {
+    totalRecords += records.length;
+    for (const record2 of records) {
+      if (stopped)
         break;
+      counters.scannedRecords++;
+      if (record2.type === "gap") {
+        counters.gapRecords++;
+        continue;
+      }
+      if (record2.type !== "request")
+        continue;
+      const fact = requestFact(record2);
+      if (!fact) {
+        counters.missingIdentityRecords++;
+        continue;
+      }
+      fact.location = options.location;
+      const key = JSON.stringify([
+        fact.sessionId,
+        fact.requestId,
+        fact.startedAt
+      ]);
+      const previous = requests.get(key);
+      if (previous) {
+        counters.duplicateRecords++;
+        const merged = reconcile(previous.fact, fact);
+        if (!merged)
+          previous.conflict = true;
+        else
+          previous.fact = merged;
+      } else {
+        if (requests.size === maxRequests) {
+          counters.scannedRecords--;
+          stopped = true;
+          break;
+        }
+        requests.set(key, { fact, conflict: false });
       }
-      requests.set(key, { fact, conflict: false });
     }
   }
-  const accepted = [];
-  for (const { fact: r, conflict } of requests.values()) {
-    if (conflict) {
-      coverage.conflictingRequests++;
-      continue;
-    }
-    if (r.completedAt === undefined) {
-      coverage.incompleteRequests++;
-      continue;
-    }
-    const duration = r.completedAt - r.startedAt;
-    if (!nonnegative2(r.completedAt) || !Number.isFinite(duration) || duration <= 0) {
-      coverage.invalidTimingRequests++;
-      continue;
+  function* steps() {
+    const coverage = {
+      ...counters,
+      unscannedRecords: totalRecords - counters.scannedRecords
+    };
+    const accepted = [];
+    for (const { fact: r, conflict } of requests.values()) {
+      yield;
+      if (conflict) {
+        coverage.conflictingRequests++;
+        continue;
+      }
+      if (r.completedAt === undefined) {
+        coverage.incompleteRequests++;
+        continue;
+      }
+      const duration = r.completedAt - r.startedAt;
+      if (!nonnegative2(r.completedAt) || !Number.isFinite(duration) || duration <= 0) {
+        coverage.invalidTimingRequests++;
+        continue;
+      }
+      if (options.from !== undefined && r.completedAt < options.from || options.to !== undefined && r.completedAt >= options.to || options.model !== undefined && r.model !== options.model || options.agent !== undefined && r.agent !== options.agent)
+        continue;
+      accepted.push({ ...r, completedAt: r.completedAt });
     }
-    if (options.from !== undefined && r.completedAt < options.from || options.to !== undefined && r.completedAt >= options.to || options.model !== undefined && r.model !== options.model || options.agent !== undefined && r.agent !== options.agent)
-      continue;
-    accepted.push({ ...r, completedAt: r.completedAt });
+    const models = yield* summarizeModelRequestSteps(accepted);
+    coverage.partial = coverage.unscannedRecords > 0 || coverage.conflictingRequests > 0 || coverage.missingIdentityRecords > 0 || coverage.incompleteRequests > 0 || coverage.invalidTimingRequests > 0 || coverage.gapRecords > 0 || models.some((s) => s.partialRequests > 0 || s.legacyAttributionRequests > 0 || s.excludedTpsRequests > 0 || s.excludedTtftRequests > 0 || !s.model);
+    return {
+      schemaVersion: 1,
+      location: options.location,
+      models,
+      coverage,
+      requests: accepted
+    };
   }
-  const models = summarizeModelRequests(accepted);
-  coverage.partial = coverage.unscannedRecords > 0 || coverage.conflictingRequests > 0 || coverage.missingIdentityRecords > 0 || coverage.incompleteRequests > 0 || coverage.invalidTimingRequests > 0 || coverage.gapRecords > 0 || models.some((s) => s.partialRequests > 0 || s.legacyAttributionRequests > 0 || s.excludedTpsRequests > 0 || s.excludedTtftRequests > 0 || !s.model);
-  return {
-    schemaVersion: 1,
-    location: options.location,
-    models,
-    coverage,
-    requests: accepted
-  };
+  return { append, steps, result: () => finishSteps(steps()) };
+}
+function finishSteps(steps) {
+  let step = steps.next();
+  while (!step.done)
+    step = steps.next();
+  return step.value;
 }
 function summarizeModelRequests(requests) {
+  return finishSteps(summarizeModelRequestSteps(requests));
+}
+function* summarizeModelRequestSteps(requests) {
   const groups = new Map;
   for (const r of requests) {
+    yield;
     const duration = r.completedAt - r.startedAt;
     let group = groups.get(r.model);
     if (!group) {
@@ -936,6 +1044,324 @@ var nonnegative2 = (n) => n !== undefined && Number.isFinite(n) && n >= 0;
 // src/index.ts
 import { Plugin } from "@opencode/plugin";
 
+// src/archive.ts
+init_history();
+import { open as open2 } from "fs/promises";
+import { join as join2 } from "path";
+var signature = (file) => JSON.stringify(file);
+var sameFile = (a, b) => a.dev === b.dev && a.ino === b.ino;
+function freezeRecord(record2) {
+  if (record2.performance)
+    Object.freeze(record2.performance);
+  return Object.freeze(record2);
+}
+
+class PerformanceArchive {
+  path;
+  options;
+  entries = new Map;
+  generation = 0;
+  stopped = false;
+  dirty = new Map;
+  forcedGeneration = 0;
+  job;
+  stats = {
+    readBytes: 0,
+    parsedRecords: 0,
+    cacheBytes: 0,
+    cacheRecords: 0
+  };
+  constructor(path, options = {}) {
+    this.path = path;
+    this.options = options;
+  }
+  invalidate(name) {
+    this.generation++;
+    if (name) {
+      if (this.dirty.size >= 256 && !this.dirty.has(name)) {
+        this.entries.clear();
+        this.dirty.clear();
+        this.forcedGeneration = this.generation;
+      }
+      this.dirty.set(name, this.generation);
+    } else {
+      this.entries.clear();
+      this.dirty.clear();
+      this.forcedGeneration = this.generation;
+    }
+    this.account();
+  }
+  dispose() {
+    this.stopped = true;
+    this.job?.controller.abort();
+    this.entries.clear();
+    this.dirty.clear();
+    this.account();
+  }
+  account() {
+    this.stats.cacheBytes = [...this.entries.values()].reduce((n, e) => n + e.file.bytes, 0);
+    this.stats.cacheRecords = [...this.entries.values()].reduce((n, e) => n + e.records.length, 0);
+  }
+  retain(name, entry) {
+    this.entries.delete(name);
+    this.entries.set(name, entry);
+    this.account();
+    while (this.entries.size > (this.options.maxCacheSegments ?? 256) || this.stats.cacheBytes > (this.options.maxCacheBytes ?? 64 * 1024 * 1024) || this.stats.cacheRecords > (this.options.maxCacheRecords ?? 200000)) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest === undefined)
+        break;
+      this.entries.delete(oldest);
+      this.dirty.delete(oldest);
+      this.account();
+    }
+  }
+  validCapture(expected, actual, generation) {
+    return signature(expected) === signature(actual) || sameFile(expected, actual) && actual.bytes > expected.bytes && (this.dirty.get(expected.name) ?? -1) > generation;
+  }
+  async scan(maxBytes, signal) {
+    for (let attempt = 0;attempt < 3; attempt++) {
+      try {
+        signal.throwIfAborted();
+        const generation = this.generation;
+        const files = await segments(this.path);
+        signal.throwIfAborted();
+        const names = new Set(files.map((f) => f.name));
+        for (const name of this.entries.keys())
+          if (!names.has(name)) {
+            this.entries.delete(name);
+            this.dirty.delete(name);
+          }
+        this.account();
+        const selected = [];
+        let bytes = 0, skippedBytes = 0, malformedRecords = 0;
+        for (const file of files.slice().reverse()) {
+          if (bytes + file.bytes > maxBytes) {
+            skippedBytes += file.bytes;
+            continue;
+          }
+          selected.unshift(file);
+          bytes += file.bytes;
+        }
+        const parts = [];
+        let unstable = false;
+        for (const file of selected) {
+          signal.throwIfAborted();
+          const handle = await open2(join2(this.path, file.name), "r");
+          try {
+            const captured = {
+              name: file.name,
+              time: file.time,
+              ...fileIdentity(await handle.stat())
+            };
+            if (!this.validCapture(file, captured, generation)) {
+              unstable = true;
+              break;
+            }
+            const previous = this.entries.get(file.name);
+            let entry;
+            if (previous && previous.generation >= this.forcedGeneration && !this.dirty.has(file.name) && signature(previous.file) === signature(file)) {
+              entry = previous;
+            } else {
+              const append = previous && previous.generation >= this.forcedGeneration && sameFile(previous.file, file) && file.bytes > previous.file.bytes && this.dirty.has(file.name);
+              const parsed = await scanHistorySegment(handle, file.bytes, { signal }, {
+                ...this.options,
+                onRead: (n) => {
+                  this.stats.readBytes += n;
+                  this.options.onRead?.(n);
+                },
+                onParse: () => {
+                  this.stats.parsedRecords++;
+                  this.options.onParse?.();
+                }
+              }, append ? previous.boundary : 0);
+              entry = {
+                ...parsed,
+                file,
+                generation,
+                sessions: new Map,
+                minTime: Infinity,
+                maxTime: -Infinity
+              };
+              if (append) {
+                entry.records = [
+                  ...previous.records.slice(0, previous.completeRecords),
+                  ...parsed.records
+                ];
+                entry.malformedRecords += previous.completeMalformed;
+                entry.completeRecords += previous.completeRecords;
+                entry.completeMalformed += previous.completeMalformed;
+              }
+              const checkpoint = scanScheduler(signal, this.options);
+              for (const [index, record2] of entry.records.entries()) {
+                if (index % 64 === 0) {
+                  const waiting = checkpoint();
+                  if (waiting)
+                    await waiting;
+                }
+                freezeRecord(record2);
+                entry.minTime = Math.min(entry.minTime, record2.time);
+                entry.maxTime = Math.max(entry.maxTime, record2.time);
+                const list = entry.sessions.get(record2.sessionId) ?? [];
+                list.push(index);
+                entry.sessions.set(record2.sessionId, list);
+              }
+              Object.freeze(entry.records);
+            }
+            const after = {
+              name: file.name,
+              time: file.time,
+              ...fileIdentity(await handle.stat())
+            };
+            if (!this.validCapture(file, after, generation)) {
+              unstable = true;
+              break;
+            }
+            signal.throwIfAborted();
+            this.retain(file.name, entry);
+            parts.push(entry);
+            malformedRecords += entry.malformedRecords;
+          } finally {
+            await handle.close();
+          }
+        }
+        signal.throwIfAborted();
+        const current = await segments(this.path);
+        const currentByName = new Map(current.map((file) => [file.name, file]));
+        const originalNames = new Set(files.map((file) => file.name));
+        if (unstable || this.forcedGeneration > generation || files.some((file) => {
+          const actual = currentByName.get(file.name);
+          return !actual || !this.validCapture(file, actual, generation);
+        }) || current.some((file) => !originalNames.has(file.name) && (this.dirty.get(file.name) ?? -1) <= generation))
+          continue;
+        for (const [name, changedAt] of this.dirty)
+          if (changedAt <= generation)
+            this.dirty.delete(name);
+        const metadata = {
+          schema: 1,
+          ...files[0] ? { retainedFrom: files[0].time } : {},
+          retainedBytes: files.reduce((n, f) => n + f.bytes, 0),
+          skippedBytes,
+          malformedRecords,
+          completeness: "bounded-retention"
+        };
+        Object.freeze(metadata);
+        let flattened;
+        return Object.freeze({
+          revision: JSON.stringify([generation, maxBytes, files]),
+          metadata,
+          parts,
+          get records() {
+            if (!flattened) {
+              flattened = [];
+              for (const part of parts)
+                for (const record2 of part.records)
+                  flattened.push(record2);
+              Object.freeze(flattened);
+            }
+            return flattened;
+          }
+        });
+      } catch (error) {
+        signal.throwIfAborted();
+        if (!(error instanceof Error && ("code" in error) && error.code === "ENOENT"))
+          throw error;
+      }
+    }
+    throw new Error("Archive changed repeatedly during read; retry later");
+  }
+  async read(filter = {}) {
+    filter.signal?.throwIfAborted();
+    if (this.stopped)
+      throw new Error("Archive stopped");
+    const key = filter.maxBytes ?? 64 * 1024 * 1024;
+    if (this.job && this.job.key !== key) {
+      await this.wait(this.job, filter.signal);
+      return this.read(filter);
+    }
+    if (this.job?.controller.signal.aborted) {
+      await this.job.promise.catch(() => {
+      });
+      return this.read(filter);
+    }
+    if (!this.job) {
+      const controller = new AbortController;
+      const job = {
+        key,
+        controller,
+        waiters: 0,
+        promise: Promise.resolve().then(() => this.scan(key, controller.signal))
+      };
+      job.promise = job.promise.finally(() => {
+        if (this.job === job)
+          this.job = undefined;
+      });
+      this.job = job;
+    }
+    const snapshot = await this.wait(this.job, filter.signal);
+    const parts = snapshot.parts;
+    const source = { revision: snapshot.revision, metadata: snapshot.metadata };
+    if (filter.sessionId === undefined && filter.agent === undefined && filter.model === undefined && filter.from === undefined && filter.to === undefined)
+      return Object.freeze({
+        ...source,
+        get records() {
+          return snapshot.records;
+        },
+        *iterateRecords() {
+          for (const part of parts)
+            for (const record2 of part.records)
+              yield record2;
+        }
+      });
+    const records = [];
+    const checkpoint = scanScheduler(filter.signal, this.options);
+    for (const part of parts) {
+      if (filter.from !== undefined && part.maxTime < filter.from || filter.to !== undefined && part.minTime > filter.to)
+        continue;
+      const offsets = filter.sessionId === undefined ? undefined : [
+        ...part.sessions.get(filter.sessionId) ?? [],
+        ...filter.sessionId === "__history__" ? [] : part.sessions.get("__history__") ?? []
+      ].sort((a, b) => a - b);
+      const candidates = offsets ? offsets.map((i) => part.records[i]).filter((r) => r !== undefined) : part.records;
+      for (const record2 of candidates) {
+        {
+          const waiting = checkpoint();
+          if (waiting)
+            await waiting;
+        }
+        if (matchesHistory(record2, filter))
+          records.push(record2);
+      }
+    }
+    filter.signal?.throwIfAborted();
+    Object.freeze(records);
+    return Object.freeze({ ...source, records });
+  }
+  async wait(job, signal) {
+    job.waiters++;
+    let onAbort = () => {
+    };
+    try {
+      return await Promise.race([
+        job.promise,
+        new Promise((_resolve, reject) => {
+          onAbort = () => reject(signal?.reason ?? job.controller.signal.reason ?? new Error("Archive read cancelled"));
+          signal?.addEventListener("abort", onAbort, { once: true });
+          job.controller.signal.addEventListener("abort", onAbort, {
+            once: true
+          });
+          if (signal?.aborted || job.controller.signal.aborted)
+            onAbort();
+        })
+      ]);
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+      job.controller.signal.removeEventListener("abort", onAbort);
+      if (--job.waiters === 0)
+        job.controller.abort();
+    }
+  }
+}
+
 // src/performance.ts
 var valid2 = (n) => Number.isFinite(n) && n >= 0;
 var rate = (tokens, ms) => valid2(tokens) && ms > 0 ? tokens * 1000 / ms : undefined;
@@ -1322,10 +1748,11 @@ function buildChartData(records, options = {}) {
 // src/historyserver.ts
 init_history();
 init_rpc();
-async function serveHistory(rpc, path, enabled, now = Date.now, authorize = async () => true) {
+async function serveHistory(rpc, path, enabled, now = Date.now, authorize = async () => true, reader = readPerformanceHistory) {
   if (!rpc)
     return () => {
     };
+  const shutdown = new AbortController;
   let reading = false, stopped = false;
   const registration = await rpc.register(historyRpc, {
     read: async (input, context) => {
@@ -1333,12 +1760,15 @@ async function serveHistory(rpc, path, enabled, now = Date.now, authorize = asyn
         throw new Error("Invalid history request (maximum window: seven days)");
       if (reading || stopped)
         throw new Error("History service busy or stopped; retry later");
+      const signal = AbortSignal.any([context.signal, shutdown.signal]);
+      signal.throwIfAborted();
       reading = true;
       try {
-        const allowed = !enabled || await authorize(input.sessionId, context.signal);
+        const allowed = !enabled || await authorize(input.sessionId, signal);
         if (!allowed)
           throw new Error("Session is outside this location");
-        const result = enabled ? await readPerformanceHistory(path, {
+        const result = enabled ? await reader(path, {
+          signal,
           sessionId: input.sessionId,
           from: input.from,
           to: input.to
@@ -1381,6 +1811,7 @@ async function serveHistory(rpc, path, enabled, now = Date.now, authorize = asyn
   });
   return async () => {
     stopped = true;
+    shutdown.abort();
     await registration.dispose();
   };
 }
@@ -1422,15 +1853,62 @@ var metadata = {
   malformedRecords: 0,
   completeness: "bounded-retention"
 };
+async function responsive(steps, signal) {
+  const checkpoint = scanScheduler(signal);
+  let step = steps.next(), iterations = 0;
+  while (!step.done) {
+    if (++iterations % 64 === 0) {
+      const waiting = checkpoint();
+      if (waiting)
+        await waiting;
+    }
+    step = steps.next();
+  }
+  signal.throwIfAborted();
+  return step.value;
+}
+function* collectRecords(values) {
+  const records = [];
+  for (const record2 of values) {
+    yield;
+    records.push(record2);
+  }
+  return records;
+}
+function* sortRequests(requests) {
+  const compare = (a, b) => b.completedAt - a.completedAt || a.sessionId.localeCompare(b.sessionId) || a.requestId.localeCompare(b.requestId) || a.startedAt - b.startedAt;
+  let source = requests, target = requests.slice();
+  for (let size = 1;size < requests.length; size *= 2) {
+    for (let start = 0;start < requests.length; start += 2 * size) {
+      const middle = Math.min(start + size, requests.length), end = Math.min(start + 2 * size, requests.length);
+      let left = start, right = middle;
+      for (let output = start;output < end; output++) {
+        yield;
+        const a = source[left], b = source[right];
+        if (left < middle && a && (right >= end || !b || compare(a, b) <= 0)) {
+          target[output] = a;
+          left++;
+        } else if (b) {
+          target[output] = b;
+          right++;
+        }
+      }
+    }
+    [source, target] = [target, source];
+  }
+  return source;
+}
 function createAnalyticsService(path, location, enabled, options = {}) {
   const now = options.now ?? Date.now;
   const reader = options.read ?? readPerformanceHistory;
   const snapshots = new Map;
-  let stopped = false;
+  const shutdown = new AbortController;
+  let stopped = false, projecting = 0;
   let archive;
   let scan;
+  let incremental;
   async function load(signal) {
-    if (archive && now() - archive.at < 30000)
+    if (archive && !options.revisioned && now() - archive.at < 30000)
       return archive;
     if (!scan || scan.controller.signal.aborted) {
       const controller = new AbortController;
@@ -1442,12 +1920,35 @@ function createAnalyticsService(path, location, enabled, options = {}) {
           controller.signal.throwIfAborted();
           if (stopped)
             throw new Error("Analytics service stopped");
-          const analysis = analyzeModelRequests(source.records, { location });
+          const revision = "revision" in source && typeof source.revision === "string" ? source.revision : undefined;
+          if (archive && revision !== undefined && archive.revision === revision) {
+            archive = { ...archive, at: now() };
+            return archive;
+          }
+          const records = source.iterateRecords ? await responsive(collectRecords(source.iterateRecords()), controller.signal) : source.records;
+          const previous = incremental;
+          incremental = undefined;
+          const append = previous && records.length >= previous.prefix.length && previous.prefix.every((record2, index) => records[index] === record2);
+          const accumulator = append ? previous.accumulator : createModelAccumulator({ location });
+          const checkpoint = scanScheduler(controller.signal);
+          for (let index = append ? previous.prefix.length : 0;index < records.length; index += 256) {
+            {
+              const waiting = checkpoint();
+              if (waiting)
+                await waiting;
+            }
+            accumulator.append(records.slice(index, index + 256));
+          }
+          const analysis = await responsive(accumulator.steps(), controller.signal);
+          controller.signal.throwIfAborted();
+          if (records.length <= 1e5 && records.every((r) => Object.isFrozen(r) && (!r.performance || Object.isFrozen(r.performance))))
+            incremental = { prefix: records.slice(), accumulator };
           const result = {
             at: now(),
+            ...revision === undefined ? {} : { revision },
             source: {
               metadata: source.metadata,
-              records: source.records.filter((r) => r.type === "gap")
+              records: records.filter((r) => r.type === "gap")
             },
             analysis
           };
@@ -1505,48 +2006,82 @@ function createAnalyticsService(path, location, enabled, options = {}) {
       signal.throwIfAborted();
       if (stopped)
         throw new Error("Analytics service stopped");
+      signal = AbortSignal.any([signal, shutdown.signal]);
       for (const [id, item] of snapshots)
         if (item.expiresAt <= now())
           snapshots.delete(id);
-      let snapshot = input.snapshotId ? snapshots.get(input.snapshotId) : [...snapshots.values()].find((s) => s.key === queryKey(input) && now() - s.generatedAt < 30000);
+      const current = options.revisioned && !input.snapshotId ? await load(signal) : undefined;
+      let snapshot = input.snapshotId ? snapshots.get(input.snapshotId) : [...snapshots.values()].find((s) => s.key === queryKey(input) && (current ? s.revision === current.revision : now() - s.generatedAt < 30000));
       if (input.snapshotId && (!snapshot || snapshot.key !== queryKey(input)))
         throw new Error("Analytics snapshot expired; refresh Models");
       if (!snapshot) {
-        const data = await load(signal);
-        signal.throwIfAborted();
-        const requests2 = data.analysis.requests.filter((r) => r.completedAt >= input.from && r.completedAt < input.to && (!input.agent || r.agent === input.agent));
-        requests2.sort((a, b) => b.completedAt - a.completedAt || a.sessionId.localeCompare(b.sessionId) || a.requestId.localeCompare(b.requestId) || a.startedAt - b.startedAt);
-        const gaps = data.source.records.filter((r) => r.time >= input.from && r.time < input.to).map((r) => r.time);
-        snapshot = {
-          id: crypto.randomUUID(),
-          key: queryKey(input),
-          generatedAt: data.at,
-          expiresAt: now() + 90000,
-          requests: requests2,
-          models: summarizeModelRequests(requests2),
-          coverage: data.analysis.coverage,
-          metadata: data.source.metadata,
-          gaps: gaps.slice(-128),
-          omittedGaps: Math.max(0, gaps.length - 128)
-        };
-        snapshots.set(snapshot.id, snapshot);
-        if (snapshots.size > 2) {
-          const oldest = snapshots.keys().next().value;
-          if (oldest)
-            snapshots.delete(oldest);
+        if (projecting >= 2)
+          throw new Error("Analytics service busy; retry later");
+        projecting++;
+        try {
+          const data = current ?? await load(signal);
+          signal.throwIfAborted();
+          let requests2 = data.analysis.requests.filter((r) => r.completedAt >= input.from && r.completedAt < input.to && (!input.agent || r.agent === input.agent));
+          requests2 = await responsive(sortRequests(requests2), signal);
+          const gaps = data.source.records.filter((r) => r.time >= input.from && r.time < input.to).map((r) => r.time);
+          snapshot = {
+            id: crypto.randomUUID(),
+            key: queryKey(input),
+            generatedAt: data.at,
+            expiresAt: now() + 90000,
+            requests: requests2,
+            models: await responsive(summarizeModelRequestSteps(requests2), signal),
+            coverage: data.analysis.coverage,
+            metadata: data.source.metadata,
+            gaps: gaps.slice(-128),
+            omittedGaps: Math.max(0, gaps.length - 128),
+            ...data.revision === undefined ? {} : { revision: data.revision },
+            sorted: new Map,
+            variants: new Map
+          };
+          signal.throwIfAborted();
+          snapshots.set(snapshot.id, snapshot);
+          if (snapshots.size > 2) {
+            const oldest = snapshots.keys().next().value;
+            if (oldest)
+              snapshots.delete(oldest);
+          }
+        } finally {
+          projecting--;
         }
       }
       const sort = input.sort ?? "requests";
-      const models = [...snapshot.models].sort((a, b) => {
+      const models = snapshot.sorted.get(sort) ?? [...snapshot.models].sort((a, b) => {
         const key = sort === "tps" ? "averageTps" : sort === "ttft" ? "p95TtftMs" : "completedRequests";
         return (sort === "identity" ? 0 : (b[key] ?? -Infinity) - (a[key] ?? -Infinity)) || (a.model ?? "").localeCompare(b.model ?? "");
       });
+      snapshot.sorted.set(sort, models);
       const modelOffset = pageOffset(input.modelCursor, snapshot, "models", sort);
       const selected = input.unknownModel ? models.find((m) => m.model === undefined) : input.model ? models.find((m) => m.model === input.model) : models[modelOffset];
       const selection = selected?.model ?? "";
-      const requests = selected ? snapshot.requests.filter((r) => r.model === selected.model) : [];
+      const variantKey = JSON.stringify([
+        selected?.model ?? null,
+        !!selected,
+        input.buckets
+      ]);
+      let variant = snapshot.variants.get(variantKey);
+      if (!variant) {
+        const requests2 = selected ? snapshot.requests.filter((r) => r.model === selected.model) : [];
+        variant = {
+          requests: requests2,
+          buckets: selected ? bucketModelRequests(requests2, input.from, input.to, input.buckets) : []
+        };
+      }
+      snapshot.variants.delete(variantKey);
+      snapshot.variants.set(variantKey, variant);
+      if (snapshot.variants.size > 8) {
+        const oldest = snapshot.variants.keys().next().value;
+        if (oldest !== undefined)
+          snapshot.variants.delete(oldest);
+      }
+      const requests = variant.requests;
       const requestOffset = pageOffset(input.requestCursor, snapshot, "requests", selection);
-      const buckets = selected ? bucketModelRequests(requests, input.from, input.to, input.buckets) : [];
+      const buckets = structuredClone(variant.buckets);
       const result = {
         schemaVersion: 1,
         generatedAt: snapshot.generatedAt,
@@ -1584,17 +2119,19 @@ function createAnalyticsService(path, location, enabled, options = {}) {
     },
     dispose() {
       stopped = true;
+      shutdown.abort();
       scan?.controller.abort();
       snapshots.clear();
       archive = undefined;
+      incremental = undefined;
     }
   };
 }
-async function serveModelAnalytics(port, path, location, enabled) {
+async function serveModelAnalytics(port, path, location, enabled, options = {}) {
   if (!port)
     return () => {
     };
-  const service = createAnalyticsService(path, location, enabled);
+  const service = createAnalyticsService(path, location, enabled, options);
   const registration = await port.register(analyticsRpc, {
     read: async (input, context) => {
       if (!isAnalyticsRead(input))
@@ -1847,10 +2384,10 @@ class SnapshotStore {
       const s = resident.get(id);
       if (!s)
         continue;
-      const performance = this.performanceSnapshot?.(id);
+      const performance2 = this.performanceSnapshot?.(id);
       const next = freezeSnapshot({
         ...project(s, this.config, this.now()),
-        ...performance ? { performance } : {}
+        ...performance2 ? { performance: performance2 } : {}
       });
       const old = this.rows.get(id);
       if (old && JSON.stringify({ ...old, revision: 0 }) === JSON.stringify(next))
@@ -1919,7 +2456,7 @@ function freezeSnapshot(row2) {
 
 // src/snapshotserver.ts
 init_rpc();
-async function serveSnapshots(rpc, store, performance = false, prepareRead) {
+async function serveSnapshots(rpc, store, performance2 = false, prepareRead) {
   if (!rpc)
     return () => {
     };
@@ -1927,15 +2464,15 @@ async function serveSnapshots(rpc, store, performance = false, prepareRead) {
     ...batch,
     upserts: batch.upserts.map(({ performance: _performance, ...row2 }) => row2)
   });
-  const batchValid = performance ? isPerformanceBatch : isBatch;
-  const resultValid = performance ? isPerformanceResult : isResult;
-  const registration = await rpc.register(performance ? performanceRpc : monitorRpc, {
+  const batchValid = performance2 ? isPerformanceBatch : isBatch;
+  const resultValid = performance2 ? isPerformanceResult : isResult;
+  const registration = await rpc.register(performance2 ? performanceRpc : monitorRpc, {
     read: async (input, context) => {
       if (!isRead(input))
         throw new Error("Invalid snapshot request");
       await prepareRead?.(input.sessionIds, context.signal);
       const raw = store.read(input);
-      const result = performance ? raw : stripPerformance(raw);
+      const result = performance2 ? raw : stripPerformance(raw);
       if (!resultValid(result))
         throw new Error("Invalid snapshot projection");
       return result;
@@ -1966,7 +2503,7 @@ async function serveSnapshots(rpc, store, performance = false, prepareRead) {
     });
   }
   const unlisten = store.listen((raw) => {
-    const batch = performance ? raw : stripPerformance(raw);
+    const batch = performance2 ? raw : stripPerformance(raw);
     if (!batchValid(batch))
       return;
     queue.push(batch);
@@ -2498,13 +3035,13 @@ function encodeRecovery(rows) {
 }
 
 // src/telemetry.ts
-import { mkdir as mkdir2, open as open2, rename, stat as stat2 } from "fs/promises";
-import { dirname, join as join2 } from "path";
+import { mkdir as mkdir2, open as open3, rename, stat as stat2 } from "fs/promises";
+import { dirname, join as join3 } from "path";
 import { homedir } from "os";
 import { createHash as createHash2 } from "crypto";
 function defaultPath(directory) {
   const key = createHash2("sha256").update(directory).digest("hex").slice(0, 16);
-  return join2(process.env.XDG_STATE_HOME || join2(homedir(), ".local/state"), "opencode-context-guard", `${key}.jsonl`);
+  return join3(process.env.XDG_STATE_HOME || join3(homedir(), ".local/state"), "opencode-context-guard", `${key}.jsonl`);
 }
 
 class JsonlTelemetrySink {
@@ -2563,7 +3100,7 @@ class JsonlTelemetrySink {
           });
           this.bytes = 0;
         }
-        const file = await open2(this.path, "a", 384);
+        const file = await open3(this.path, "a", 384);
         try {
           await file.writeFile(line);
         } finally {
@@ -2588,7 +3125,7 @@ async function readJournal(path, maxBytes = 16 * 1024 * 1024) {
     const size = await stat2(name).then((s) => s.size).catch(() => 0);
     if (!size)
       continue;
-    const file = await open2(name, "r");
+    const file = await open3(name, "r");
     const buffer = Buffer.alloc(Math.min(size, maxBytes));
     try {
       await file.read(buffer, 0, buffer.length, Math.max(0, size - maxBytes));
@@ -2615,8 +3152,8 @@ async function setup(ctx, injectedSink) {
   const config = parseConfig(ctx.options);
   const disk = new JsonlTelemetrySink(config.telemetry.path ?? defaultPath(ctx.location.directory), config.telemetry);
   const diagnostics = injectedSink ?? disk;
-  const performance = new PerformanceTracker(config.safety.maxSessions, config.metrics.rollingWindowMs);
-  const store = new SnapshotStore(config, () => monitor?.sessions ?? new Map, Date.now, crypto.randomUUID(), config.metrics.enabled ? (id) => performance.snapshot(id) : undefined);
+  const performance2 = new PerformanceTracker(config.safety.maxSessions, config.metrics.rollingWindowMs);
+  const store = new SnapshotStore(config, () => monitor?.sessions ?? new Map, Date.now, crypto.randomUUID(), config.metrics.enabled ? (id) => performance2.snapshot(id) : undefined);
   let monitor;
   const sink = {
     emit(event) {
@@ -2662,15 +3199,17 @@ async function setup(ctx, injectedSink) {
     return () => {
     };
   });
+  const archive = new PerformanceArchive(config.history.path ?? `${defaultPath(ctx.location.directory)}.metrics`);
+  const archiveRead = (_path, filter) => archive.read(filter);
   const stopHistory = await serveHistory(ctx.historyRpc, config.history.path ?? `${defaultPath(ctx.location.directory)}.metrics`, config.enabled && config.metrics.enabled && config.history.enabled, Date.now, async (sessionId, signal) => {
     const info = await ctx.session.get({ sessionID: sessionId }, { signal });
     return info.location.directory === ctx.location.directory;
-  }).catch(() => {
+  }, archiveRead).catch(() => {
     diagnostics.emit({ time: Date.now(), type: "history-service-unavailable" });
     return () => {
     };
   });
-  const stopAnalytics = await serveModelAnalytics(ctx.analyticsRpc, config.history.path ?? `${defaultPath(ctx.location.directory)}.metrics`, ctx.location.directory, config.enabled && config.metrics.enabled && config.history.enabled).catch(() => {
+  const stopAnalytics = await serveModelAnalytics(ctx.analyticsRpc, config.history.path ?? `${defaultPath(ctx.location.directory)}.metrics`, ctx.location.directory, config.enabled && config.metrics.enabled && config.history.enabled, { read: archiveRead, revisioned: true }).catch(() => {
     diagnostics.emit({
       time: Date.now(),
       type: "analytics-service-unavailable"
@@ -2679,8 +3218,13 @@ async function setup(ctx, injectedSink) {
     };
   });
   const stopSnapshots = async () => {
-    await stopAnalytics();
-    await stopHistory();
+    const archives = await Promise.allSettled([stopAnalytics(), stopHistory()]);
+    archive.dispose();
+    if (archives.some((result) => result.status === "rejected"))
+      diagnostics.emit({
+        time: Date.now(),
+        type: "registration-cleanup-failed"
+      });
     await stopV2();
     await stopV1();
   };
@@ -2694,10 +3238,10 @@ async function setup(ctx, injectedSink) {
   const history = new PerformanceHistory(config.history.path ?? `${defaultPath(ctx.location.directory)}.metrics`, {
     ...config.history,
     enabled: config.history.enabled && config.metrics.enabled
-  }, Date.now, (type) => diagnostics.emit({ time: Date.now(), type }));
+  }, Date.now, (type) => diagnostics.emit({ time: Date.now(), type }), (name) => archive.invalidate(name));
   await history.initialize();
   if (config.metrics.enabled) {
-    performance.restore(await ctx.storage.get("performance.v1").catch(() => {
+    performance2.restore(await ctx.storage.get("performance.v1").catch(() => {
       return;
     }));
   }
@@ -2705,7 +3249,7 @@ async function setup(ctx, injectedSink) {
   const recordPerformance = (id, type, event) => {
     if (!config.metrics.enabled)
       return;
-    const state = monitor?.sessions.get(id), snapshot = performance.snapshot(id);
+    const state = monitor?.sessions.get(id), snapshot = performance2.snapshot(id);
     if (!state || !snapshot)
       return;
     history.emit({
@@ -2724,7 +3268,7 @@ async function setup(ctx, injectedSink) {
   const persistPerformance = async () => {
     if (!config.metrics.enabled)
       return;
-    await ctx.storage.set("performance.v1", performance.checkpoint().map((row2) => ({ ...row2 }))).catch(() => {
+    await ctx.storage.set("performance.v1", performance2.checkpoint().map((row2) => ({ ...row2 }))).catch(() => {
       diagnostics.emit({
         time: Date.now(),
         type: "performance-persistence-unavailable"
@@ -2907,12 +3451,12 @@ async function setup(ctx, injectedSink) {
         recoveries.delete(sessionId);
       }
       if (config.metrics.enabled) {
-        if (!performance.snapshot(sessionId) && [...performance.ids()].length >= config.safety.maxSessions) {
-          const dormant = [...performance.ids()].find((id) => !performanceResidents.has(id));
+        if (!performance2.snapshot(sessionId) && [...performance2.ids()].length >= config.safety.maxSessions) {
+          const dormant = [...performance2.ids()].find((id) => !performanceResidents.has(id));
           if (dormant)
-            performance.remove(dormant);
+            performance2.remove(dormant);
         }
-        performance.observe(sessionId, info.time.created, outputTokens(info.tokens));
+        performance2.observe(sessionId, info.time.created, outputTokens(info.tokens));
         performanceResidents.add(sessionId);
       }
       s.usage.cumulative = info.tokens;
@@ -3015,7 +3559,7 @@ async function setup(ctx, injectedSink) {
       return;
     if (event.type === "session.text.delta" || event.type === "session.reasoning.delta") {
       if (config.metrics.enabled)
-        performance.delta(event.data.sessionID, event.data.assistantMessageID, event.id, event.created, event.data.delta.length);
+        performance2.delta(event.data.sessionID, event.data.assistantMessageID, event.id, event.created, event.data.delta.length);
       return;
     }
     if (!relevant.has(event.type) || !("sessionID" in event.data))
@@ -3025,7 +3569,7 @@ async function setup(ctx, injectedSink) {
       return;
     if (event.type === "session.deleted") {
       recordPerformance(id, "terminal", "session.deleted");
-      performance.remove(id);
+      performance2.remove(id);
       performanceResidents.delete(id);
       await persistPerformance();
       store.remove(id);
@@ -3041,11 +3585,11 @@ async function setup(ctx, injectedSink) {
       return;
     if ("durable" in event && event.durable && !activeMonitor.accept(s, event.durable.seq))
       return;
-    const perfAccepted = config.metrics.enabled && (!("durable" in event) || !event.durable || performance.accept(id, event.durable.seq));
+    const perfAccepted = config.metrics.enabled && (!("durable" in event) || !event.durable || performance2.accept(id, event.durable.seq));
     switch (event.type) {
       case "session.step.started":
         if (perfAccepted)
-          performance.start(id, event.data.assistantMessageID, event.data.agent, `${event.data.model.providerID}/${event.data.model.id}`, event.data.started);
+          performance2.start(id, event.data.assistantMessageID, event.data.agent, `${event.data.model.providerID}/${event.data.model.id}`, event.data.started);
         activeMonitor.touch({
           sessionId: id,
           agent: event.data.agent,
@@ -3060,12 +3604,12 @@ async function setup(ctx, injectedSink) {
         break;
       case "session.step.streamed":
         if (perfAccepted)
-          performance.streamed(id, event.data.assistantMessageID, event.created);
+          performance2.streamed(id, event.data.assistantMessageID, event.created);
         break;
       case "session.step.ended":
       case "session.step.failed": {
         if (perfAccepted)
-          performance.settle(id, event.data.assistantMessageID, event.data.tokens ? outputTokens(event.data.tokens) : undefined);
+          performance2.settle(id, event.data.assistantMessageID, event.data.tokens ? outputTokens(event.data.tokens) : undefined);
         const tokens = event.data.tokens && promptTokens(event.data.tokens);
         const request = requests.get(id);
         if (tokens !== undefined && request?.id === event.data.assistantMessageID && request.model === s.model)
@@ -3104,8 +3648,8 @@ async function setup(ctx, injectedSink) {
       case "session.execution.failed":
       case "session.execution.interrupted":
         s.active = false;
-        if (performance.snapshot(id)?.tokenSource === "estimated")
-          performance.gap(id);
+        if (performance2.snapshot(id)?.tokenSource === "estimated")
+          performance2.gap(id);
         s.lastExecutionEnd = event.created;
         break;
       case "session.tool.called":
@@ -3126,7 +3670,7 @@ async function setup(ctx, injectedSink) {
       lastPerformanceSample = now;
       for (const id of performanceResidents) {
         store.mark(id);
-        const snapshot = performance.snapshot(id);
+        const snapshot = performance2.snapshot(id);
         if (now - lastHistorySample >= 1000 && snapshot && (snapshot.status === "waiting" || snapshot.status === "streaming"))
           recordPerformance(id, "sample");
       }
@@ -3144,7 +3688,7 @@ async function setup(ctx, injectedSink) {
         store.recover("capacity-exceeded");
       for (const id of performanceResidents)
         if (!activeMonitor.sessions.has(id)) {
-          performance.remove(id);
+          performance2.remove(id);
           performanceResidents.delete(id);
         }
       for (const id of requests.keys())
@@ -3168,7 +3712,7 @@ async function setup(ctx, injectedSink) {
       } catch {
       }
       if (!stopped) {
-        performance.gap();
+        performance2.gap();
         for (const id of performanceResidents) {
           store.mark(id);
           recordPerformance(id, "gap", "event-stream-gap");