@cesarus777/opencode-cgp 0.1.0 → 0.2.2

package/dist/index.js

@@ -114,6 +114,154 @@ var monitorRpc = Rpc.define({
   methods: { read: { input: readSchema, output: resultSchema } },
   events: { changed: { schema: batchSchema } }
 });
+var nonnegative = { type: "number", minimum: 0 };
+var performanceSchema = object({
+  observedSince: count,
+  at: count,
+  sessionCreatedAt: count,
+  sessionOutputTokens: count,
+  status: enumeration("waiting", "streaming", "idle", "unavailable"),
+  partial: { type: "boolean" },
+  liveTps: nonnegative,
+  averageModelTps: nonnegative,
+  averageSessionTps: nonnegative,
+  ttftMs: nonnegative,
+  latestRequestTps: nonnegative,
+  requestId: text,
+  requestAgent: text,
+  requestModel: text,
+  requestOutputTokens: count,
+  requestStartedAt: count,
+  firstOutputAt: count,
+  streamEndedAt: count,
+  estimatedOutputTokens: nonnegative,
+  modelOutputTokens: nonnegative,
+  modelDurationMs: nonnegative,
+  completedRequests: count,
+  tokenSource: enumeration("estimated", "reported", "unavailable")
+}, [
+  "sessionCreatedAt",
+  "observedSince",
+  "at",
+  "status",
+  "partial",
+  "estimatedOutputTokens",
+  "modelOutputTokens",
+  "modelDurationMs",
+  "completedRequests",
+  "tokenSource"
+]);
+var performanceRow = {
+  ...row,
+  properties: { ...row.properties, performance: performanceSchema }
+};
+var performanceBatchSchema = object({
+  ...batchFields,
+  upserts: array(performanceRow)
+});
+var performanceResultSchema = object({
+  ...batchFields,
+  upserts: array(performanceRow),
+  unavailable: resultSchema.properties.unavailable ?? {}
+});
+var performanceRpc = Rpc.define({
+  id: "context-guard.monitor.v2",
+  methods: { read: { input: readSchema, output: performanceResultSchema } },
+  events: { changed: { schema: performanceBatchSchema } }
+});
+function isPerformanceBatch(value) {
+  return valid(value, performanceBatchSchema) && uniqueRows(value);
+}
+function isPerformanceResult(value) {
+  return valid(value, performanceResultSchema) && uniqueRows(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;
+}
+function isHistoryResult(value) {
+  return valid(value, historyResultSchema);
+}
 function record(x) {
   return typeof x === "object" && x !== null && !Array.isArray(x);
 }
@@ -166,6 +314,715 @@ function uniqueRows(value) {
 // 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 PerformanceTracker {
+  maxSessions;
+  windowMs;
+  now;
+  rows = new Map;
+  constructor(maxSessions, windowMs = 2000, now = Date.now) {
+    this.maxSessions = maxSessions;
+    this.windowMs = windowMs;
+    this.now = now;
+  }
+  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)
+      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()));
+    }
+  }
+  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;
+      return;
+    }
+    r.ended = at;
+  }
+  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 (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();
+  }
+  gap(id) {
+    for (const [key, row2] of this.rows) {
+      if (id !== undefined && key !== id)
+        continue;
+      row2.partial = true;
+      delete row2.request;
+    }
+  }
+  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;
+      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;
+      }
+      if (low !== undefined)
+        selected.add(low);
+      if (high !== undefined)
+        selected.add(high);
+    }
+  }
+  let previous = -1;
+  return [...selected].sort((a, b) => a - b).flatMap((index) => {
+    const point = points[index];
+    if (!point)
+      return [];
+    const skippedGap = points.slice(previous + 1, index + 1).some((p) => p.breakBefore);
+    previous = index;
+    return [{ ...point, breakBefore: point.breakBefore || skippedGap }];
+  });
+}
+function buildChartData(records, options = {}) {
+  const maxPoints = options.maxPoints ?? 1000, maxSessions = options.maxSessions ?? 128;
+  if (!Number.isSafeInteger(maxSessions) || maxSessions < 1 || maxSessions > 1024)
+    throw new Error("maxSessions must be from 1 to 1024");
+  downsamplePoints([], maxPoints);
+  const sorted = [...records].sort((a, b) => a.time - b.time || a.recordId.localeCompare(b.recordId));
+  const lastSeen = new Map;
+  for (const r of sorted)
+    if (r.performance && (!options.sessionId || r.sessionId === options.sessionId))
+      lastSeen.set(r.sessionId, r.time);
+  const sessions = [...lastSeen].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  const selected = new Set(sessions.slice(0, maxSessions).map(([id]) => id));
+  const series = new Map, gaps = [];
+  const seen = new Set, requestSeen = new Set;
+  const pendingGaps = new Set;
+  const observedSince = new Map;
+  for (const r of sorted) {
+    if (seen.has(r.recordId))
+      continue;
+    seen.add(r.recordId);
+    if (r.type === "gap") {
+      if (r.sessionId === "__history__" || selected.has(r.sessionId)) {
+        gaps.push({
+          time: r.time,
+          sessionId: r.sessionId,
+          reason: r.event ?? "observation-gap"
+        });
+        if (r.sessionId === "__history__")
+          for (const id of selected)
+            pendingGaps.add(id);
+        else
+          pendingGaps.add(r.sessionId);
+      }
+      continue;
+    }
+    const p = r.performance;
+    if (!p || !selected.has(r.sessionId))
+      continue;
+    let s = series.get(r.sessionId);
+    if (!s) {
+      s = {
+        sessionId: r.sessionId,
+        ...r.parentId ? { parentId: r.parentId } : {},
+        agents: [],
+        models: [],
+        points: [],
+        requests: [],
+        originalPoints: 0
+      };
+      series.set(r.sessionId, s);
+    }
+    const agent = p.requestAgent ?? r.agent, model = p.requestModel ?? r.model;
+    if (agent && !s.agents.includes(agent))
+      s.agents.push(agent);
+    if (model && !s.models.includes(model))
+      s.models.push(model);
+    const previous = s.points.at(-1);
+    const restart = observedSince.has(r.sessionId) && observedSince.get(r.sessionId) !== p.observedSince;
+    const reset = previous?.sessionOutputTokens !== undefined && p.sessionOutputTokens !== undefined && p.sessionOutputTokens < previous.sessionOutputTokens;
+    const discontinuity = pendingGaps.has(r.sessionId) || restart || reset || !previous || previous.partial !== p.partial || previous.liveTps === undefined || p.liveTps === undefined || r.time - previous.time > 2500 || previous.agent !== agent || previous.model !== model;
+    const point = {
+      time: r.time,
+      ...agent ? { agent } : {},
+      ...model ? { model } : {},
+      breakBefore: discontinuity,
+      partial: p.partial,
+      ...p.liveTps === undefined ? {} : { liveTps: p.liveTps },
+      ...p.averageModelTps === undefined ? {} : { averageModelTps: p.averageModelTps },
+      ...p.averageSessionTps === undefined ? {} : { averageSessionTps: p.averageSessionTps },
+      ...p.sessionOutputTokens === undefined ? {} : { sessionOutputTokens: p.sessionOutputTokens }
+    };
+    if (previous?.time === point.time)
+      s.points[s.points.length - 1] = {
+        ...point,
+        breakBefore: point.breakBefore || previous.breakBefore
+      };
+    else
+      s.points.push(point);
+    observedSince.set(r.sessionId, p.observedSince);
+    pendingGaps.delete(r.sessionId);
+    if (r.type === "request" && p.requestId !== undefined && p.requestStartedAt !== undefined) {
+      const key = JSON.stringify([
+        r.sessionId,
+        p.requestId,
+        p.requestStartedAt
+      ]);
+      if (requestSeen.has(key))
+        continue;
+      requestSeen.add(key);
+      const duration = p.streamEndedAt === undefined ? undefined : p.streamEndedAt - p.requestStartedAt;
+      const validDuration = duration !== undefined && duration > 0;
+      const output = p.tokenSource === "reported" ? p.requestOutputTokens : undefined;
+      s.requests.push({
+        time: r.time,
+        requestId: p.requestId,
+        started: p.requestStartedAt,
+        ...agent ? { agent } : {},
+        ...model ? { model } : {},
+        partial: p.partial,
+        ...p.ttftMs === undefined ? {} : { ttftMs: p.ttftMs },
+        ...output === undefined ? {} : { outputTokens: output },
+        ...validDuration ? { durationMs: duration } : {},
+        ...output !== undefined && validDuration ? { tps: output * 1000 / duration } : {}
+      });
+    }
+  }
+  return {
+    schema: 1,
+    series: [...series.values()].map((s) => ({
+      ...s,
+      originalPoints: s.points.length,
+      points: downsamplePoints(s.points, maxPoints)
+    })),
+    gaps: gaps.slice(-1024),
+    omittedGaps: Math.max(0, gaps.length - 1024),
+    omittedSessions: Math.max(0, sessions.length - selected.size),
+    maxPoints
+  };
+}
+
+// src/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));
+}
+
+class PerformanceHistory {
+  path;
+  config;
+  now;
+  report;
+  pending = [];
+  working;
+  active;
+  bytes = 0;
+  started = 0;
+  disabled = false;
+  dropped = 0;
+  droppedTotal = 0;
+  constructor(path, config, now = Date.now, report = () => {
+  }) {
+    this.path = path;
+    this.config = config;
+    this.now = now;
+    this.report = report;
+  }
+  emit(record2) {
+    if (!this.config.enabled || this.disabled)
+      return;
+    const line = JSON.stringify({
+      schema: 1,
+      recordId: record2.recordId,
+      time: record2.time,
+      type: record2.type,
+      sessionId: record2.sessionId,
+      ...record2.parentId ? { parentId: record2.parentId } : {},
+      ...record2.agent ? { agent: record2.agent } : {},
+      ...record2.model ? { model: record2.model } : {},
+      ...record2.event ? { event: record2.event } : {},
+      ...record2.droppedRecords === undefined ? {} : { droppedRecords: record2.droppedRecords },
+      ...record2.performance ? { performance: scalarPerformance(record2.performance) } : {}
+    }) + "\n";
+    if (this.pending.length >= 256 || Buffer.byteLength(line) > Math.min(4 * 1024 * 1024, this.config.maxBytes)) {
+      this.dropped++;
+      this.droppedTotal++;
+      if (this.dropped === 1)
+        this.report("history-records-dropped");
+      return;
+    }
+    this.pending.push(line);
+    this.kick();
+  }
+  kick() {
+    if (this.working || this.disabled)
+      return;
+    this.working = this.drain().catch(() => {
+      this.disabled = true;
+      this.pending = [];
+      this.report("history-unavailable");
+    }).finally(() => {
+      this.working = undefined;
+      if (this.pending.length)
+        this.kick();
+    });
+  }
+  async prune(incoming = 0) {
+    const files = await segments(this.path);
+    let total = files.reduce((n, f) => n + f.bytes, 0);
+    let truncated = false;
+    for (const file of files) {
+      if (file.time >= this.now() - this.config.retentionDays * 86400000 && total + incoming <= this.config.maxBytes)
+        break;
+      await unlink(join(this.path, file.name));
+      if (file.name === this.active) {
+        this.active = undefined;
+        this.bytes = 0;
+      }
+      total -= file.bytes;
+      truncated = true;
+    }
+    if (truncated)
+      this.report("history-truncated");
+  }
+  gapLine(event, droppedRecords) {
+    return JSON.stringify({
+      schema: 1,
+      recordId: crypto.randomUUID(),
+      time: this.now(),
+      type: "gap",
+      sessionId: "__history__",
+      event,
+      ...droppedRecords === undefined ? {} : { droppedRecords }
+    }) + "\n";
+  }
+  async drain() {
+    await mkdir(this.path, { recursive: true, mode: 448 });
+    await this.prune();
+    while (this.pending.length) {
+      let line = this.pending.shift();
+      if (!line)
+        continue;
+      if (this.dropped > 0) {
+        this.pending.unshift(line);
+        line = this.gapLine("history-records-dropped", this.dropped);
+        this.dropped = 0;
+      }
+      const size = Buffer.byteLength(line);
+      const now = this.now();
+      if (!this.active || this.bytes + size > Math.min(4 * 1024 * 1024, this.config.maxBytes) || now - this.started >= 3600000) {
+        this.active = undefined;
+        this.bytes = 0;
+        await this.prune(size);
+        this.started = now;
+        this.active = `${now}-${crypto.randomUUID()}.jsonl`;
+      } else
+        await this.prune(size);
+      if (!this.active) {
+        this.started = now;
+        this.active = `${now}-${crypto.randomUUID()}.jsonl`;
+      }
+      const file = await open(join(this.path, this.active), "a", 384);
+      try {
+        await file.writeFile(line);
+      } finally {
+        await file.close();
+      }
+      this.bytes += size;
+    }
+  }
+  health() {
+    return { unavailable: this.disabled, droppedRecords: this.droppedTotal };
+  }
+  async flush() {
+    while (this.working)
+      await this.working;
+  }
+  async initialize() {
+    if (!this.config.enabled)
+      return;
+    await mkdir(this.path, { recursive: true, mode: 448 }).then(() => this.prune()).catch(() => {
+      this.disabled = true;
+      this.report("history-unavailable");
+    });
+  }
+}
+function scalarPerformance(p) {
+  return {
+    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 (filter.sessionId !== undefined && value.sessionId !== filter.sessionId && value.sessionId !== "__history__" || value.type !== "gap" && filter.agent !== undefined && (value.performance?.requestAgent ?? value.agent) !== filter.agent || value.type !== "gap" && filter.model !== undefined && (value.performance?.requestModel ?? value.model) !== filter.model || filter.from !== undefined && value.time < filter.from || filter.to !== undefined && value.time > filter.to)
+          continue;
+        records.push(value);
+      } catch {
+        malformedRecords++;
+      }
+    }
+  }
+  const metadata = {
+    schema: 1,
+    ...files[0] ? { retainedFrom: files[0].time } : {},
+    retainedBytes: files.reduce((n, f) => n + f.bytes, 0),
+    skippedBytes,
+    malformedRecords,
+    completeness: "bounded-retention"
+  };
+  return { metadata, records };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isHistoryRecord(value) {
+  if (!isRecord(value))
+    return false;
+  const r = value;
+  const allowed = new Set([
+    "schema",
+    "recordId",
+    "time",
+    "type",
+    "sessionId",
+    "parentId",
+    "agent",
+    "model",
+    "event",
+    "performance",
+    "droppedRecords"
+  ]);
+  return Object.keys(r).every((k) => allowed.has(k)) && r.schema === 1 && typeof r.recordId === "string" && typeof r.time === "number" && Number.isSafeInteger(r.time) && r.time >= 0 && typeof r.sessionId === "string" && typeof r.type === "string" && ["sample", "request", "lifecycle", "gap", "terminal"].includes(r.type) && ["parentId", "agent", "model", "event"].every((k) => r[k] === undefined || typeof r[k] === "string") && (r.performance === undefined || isPerformanceSnapshot(r.performance)) && (r.droppedRecords === undefined || typeof r.droppedRecords === "number" && Number.isSafeInteger(r.droppedRecords) && r.droppedRecords >= 0);
+}
+
+// src/historyserver.ts
+async function serveHistory(rpc, path, enabled, now = Date.now, authorize = async () => true) {
+  if (!rpc)
+    return () => {
+    };
+  let reading = false, stopped = false;
+  const registration = await rpc.register(historyRpc, {
+    read: async (input, context) => {
+      if (!isHistoryRead(input))
+        throw new Error("Invalid history request (maximum window: seven days)");
+      if (reading || stopped)
+        throw new Error("History service busy or stopped; retry later");
+      reading = true;
+      try {
+        const allowed = !enabled || await authorize(input.sessionId, context.signal);
+        if (!allowed)
+          throw new Error("Session is outside this location");
+        const result = enabled ? await readPerformanceHistory(path, {
+          sessionId: input.sessionId,
+          from: input.from,
+          to: input.to
+        }) : {
+          metadata: {
+            schema: 1,
+            retainedBytes: 0,
+            skippedBytes: 0,
+            malformedRecords: 0,
+            completeness: "bounded-retention"
+          },
+          records: []
+        };
+        if (context.signal.aborted || stopped)
+          throw new Error("History read cancelled");
+        const data = buildChartData(result.records, {
+          sessionId: input.sessionId,
+          maxPoints: input.maxPoints,
+          maxSessions: 1
+        });
+        const truncated = data.gaps.length > 128 || data.series.some((s) => s.requests.length > input.maxPoints || s.originalPoints > s.points.length) || result.metadata.skippedBytes > 0;
+        data.gaps = data.gaps.slice(-128);
+        for (const s of data.series)
+          s.requests = s.requests.slice(-input.maxPoints);
+        const response = {
+          schemaVersion: 1,
+          generatedAt: now(),
+          enabled,
+          truncated,
+          metadata: { ...result.metadata, completeness: "bounded-retention" },
+          data
+        };
+        if (!isHistoryResult(response))
+          throw new Error("History response exceeds the supported bounds");
+        return response;
+      } finally {
+        reading = false;
+      }
+    }
+  });
+  return async () => {
+    stopped = true;
+    await registration.dispose();
+  };
+}
+
 // src/policy.ts
 function glob(pattern, text2) {
   let p = 0, t = 0, star = -1, retry = 0;
@@ -213,10 +1070,10 @@ class PolicyResolver {
 function usableInput(limits, reserve) {
   if (!limits)
     return;
-  const valid2 = (n) => n !== undefined && Number.isFinite(n) && n > 0;
-  const output = reserve ?? (valid2(limits.output) ? limits.output : undefined);
-  const contextBudget = valid2(limits.context) && output !== undefined ? Math.max(0, limits.context - output) : undefined;
-  if (valid2(limits.input))
+  const valid3 = (n) => n !== undefined && Number.isFinite(n) && n > 0;
+  const output = reserve ?? (valid3(limits.output) ? limits.output : undefined);
+  const contextBudget = valid3(limits.context) && output !== undefined ? Math.max(0, limits.context - output) : undefined;
+  if (valid3(limits.input))
     return contextBudget === undefined ? limits.input : Math.min(limits.input, contextBudget);
   return contextBudget;
 }
@@ -327,6 +1184,7 @@ class SnapshotStore {
   config;
   sessions;
   now;
+  performanceSnapshot;
   epoch;
   sequence = 0;
   revision = 0;
@@ -336,10 +1194,11 @@ class SnapshotStore {
   listeners = new Set;
   healthKey = "";
   reasons = new Set;
-  constructor(config, sessions, now = Date.now, epoch = crypto.randomUUID()) {
+  constructor(config, sessions, now = Date.now, epoch = crypto.randomUUID(), performanceSnapshot) {
     this.config = config;
     this.sessions = sessions;
     this.now = now;
+    this.performanceSnapshot = performanceSnapshot;
     this.epoch = epoch;
   }
   health() {
@@ -400,7 +1259,11 @@ class SnapshotStore {
       const s = resident.get(id);
       if (!s)
         continue;
-      const next = project(s, this.config, this.now());
+      const performance = this.performanceSnapshot?.(id);
+      const next = freezeSnapshot({
+        ...project(s, this.config, this.now()),
+        ...performance ? { performance } : {}
+      });
       const old = this.rows.get(id);
       if (old && JSON.stringify({ ...old, revision: 0 }) === JSON.stringify(next))
         continue;
@@ -450,6 +1313,8 @@ class SnapshotStore {
   }
 }
 function freezeSnapshot(row2) {
+  if (row2.performance)
+    Object.freeze(row2.performance);
   if (row2.measurement)
     Object.freeze(row2.measurement);
   if (row2.limits)
@@ -465,16 +1330,23 @@ function freezeSnapshot(row2) {
 }
 
 // src/snapshotserver.ts
-async function serveSnapshots(rpc, store) {
+async function serveSnapshots(rpc, store, performance = false) {
   if (!rpc)
     return () => {
     };
-  const registration = await rpc.register(monitorRpc, {
+  const stripPerformance = (batch) => ({
+    ...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, {
     read: async (input) => {
       if (!isRead(input))
         throw new Error("Invalid snapshot request");
-      const result = store.read(input);
-      if (!isResult(result))
+      const raw = store.read(input);
+      const result = performance ? raw : stripPerformance(raw);
+      if (!resultValid(result))
         throw new Error("Invalid snapshot projection");
       return result;
     }
@@ -503,8 +1375,9 @@ async function serveSnapshots(rpc, store) {
         send();
     });
   }
-  const unlisten = store.listen((batch) => {
-    if (!isBatch(batch))
+  const unlisten = store.listen((raw) => {
+    const batch = performance ? raw : stripPerformance(raw);
+    if (!batchValid(batch))
       return;
     queue.push(batch);
     if (queue.length > capacity)
@@ -570,7 +1443,16 @@ function threshold(v, path) {
 }
 function parseConfig(value = {}) {
   const o = object2(value, "options");
-  keys(o, ["enabled", "mode", "defaults", "policies", "safety", "telemetry"], "options");
+  keys(o, [
+    "enabled",
+    "mode",
+    "defaults",
+    "policies",
+    "safety",
+    "telemetry",
+    "metrics",
+    "history"
+  ], "options");
   if (o.mode !== undefined && o.mode !== "observe" && o.mode !== "enforce")
     throw new Error("mode: expected observe or enforce");
   const d = object2(o.defaults ?? {}, "defaults");
@@ -586,6 +1468,12 @@ function parseConfig(value = {}) {
     "sessionTtlMs",
     "outputReserveTokens"
   ], "safety");
+  const metrics = object2(o.metrics ?? {}, "metrics");
+  keys(metrics, ["enabled", "sampleIntervalMs", "rollingWindowMs"], "metrics");
+  const history = object2(o.history ?? {}, "history");
+  keys(history, ["enabled", "retentionDays", "maxBytes", "path"], "history");
+  if (history.path !== undefined && (typeof history.path !== "string" || !history.path.startsWith("/")))
+    throw new Error("history.path: expected absolute directory path");
   const t = object2(o.telemetry ?? {}, "telemetry");
   keys(t, ["enabled", "jsonl", "path", "maxBytes"], "telemetry");
   if (t.path !== undefined && (typeof t.path !== "string" || !t.path.startsWith("/")))
@@ -633,6 +1521,17 @@ function parseConfig(value = {}) {
         outputReserveTokens: number(s.outputReserveTokens, 0, "outputReserveTokens")
       }
     },
+    metrics: {
+      enabled: bool(metrics.enabled, true, "metrics.enabled"),
+      sampleIntervalMs: number(metrics.sampleIntervalMs, 500, "metrics.sampleIntervalMs", 100),
+      rollingWindowMs: number(metrics.rollingWindowMs, 2000, "metrics.rollingWindowMs", 100)
+    },
+    history: {
+      enabled: bool(history.enabled, true, "history.enabled"),
+      retentionDays: number(history.retentionDays, 7, "history.retentionDays", 1),
+      maxBytes: number(history.maxBytes, 64 * 1024 * 1024, "history.maxBytes", 4096),
+      ...typeof history.path === "string" ? { path: history.path } : {}
+    },
     telemetry: {
       enabled: bool(t.enabled, true, "telemetry.enabled"),
       jsonl: bool(t.jsonl, true, "telemetry.jsonl"),
@@ -640,6 +1539,8 @@ function parseConfig(value = {}) {
       ...typeof t.path === "string" ? { path: t.path } : {}
     }
   };
+  if (config.metrics.rollingWindowMs < config.metrics.sampleIntervalMs || config.metrics.rollingWindowMs > 60000)
+    throw new Error("metrics.rollingWindowMs must be >= sampleIntervalMs and <= 60000");
   for (const policy of [config.defaults, ...config.policies]) {
     if (policy.threshold.type === "tokens" && config.safety.minReclaimTokens >= policy.threshold.value)
       throw new Error("minReclaimTokens must be smaller than each absolute threshold");
@@ -949,7 +1850,7 @@ function estimate(value, maxChars = 2000000) {
 function record2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-function nonnegative(v) {
+function nonnegative2(v) {
   return typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
 }
 function decodeRecovery(v, max) {
@@ -960,7 +1861,7 @@ function decodeRecovery(v, max) {
     if (!record2(item) || typeof item.sessionId !== "string" || !record2(item.compaction))
       continue;
     const c = item.compaction;
-    if (!nonnegative(c.count) || !nonnegative(c.failures) || !nonnegative(c.consecutiveFailures) || typeof c.armed !== "boolean")
+    if (!nonnegative2(c.count) || !nonnegative2(c.failures) || !nonnegative2(c.consecutiveFailures) || typeof c.armed !== "boolean")
       continue;
     const phase = c.phase === "idle" || c.phase === "blocked" ? c.phase : "uncertain";
     const compaction = {
@@ -970,9 +1871,9 @@ function decodeRecovery(v, max) {
       failures: c.failures,
       consecutiveFailures: c.consecutiveFailures
     };
-    if (nonnegative(c.lastAttempt))
+    if (nonnegative2(c.lastAttempt))
       compaction.lastAttempt = c.lastAttempt;
-    if (nonnegative(c.lastCompleted))
+    if (nonnegative2(c.lastCompleted))
       compaction.lastCompleted = c.lastCompleted;
     if (typeof c.requestId === "string")
       compaction.requestId = c.requestId;
@@ -983,7 +1884,7 @@ function decodeRecovery(v, max) {
     result.push({
       sessionId: item.sessionId,
       compaction,
-      ...nonnegative(item.sequence) ? { sequence: item.sequence } : {}
+      ...nonnegative2(item.sequence) ? { sequence: item.sequence } : {}
     });
   }
   return result;
@@ -1007,12 +1908,13 @@ function encodeRecovery(rows) {
 }
 
 // src/telemetry.ts
-import { mkdir, open, rename, stat } from "fs/promises";
-import { dirname, join } from "path";
+import { mkdir as mkdir2, open as open2, rename, stat as stat2 } from "fs/promises";
+import { dirname, join as join2 } from "path";
+import { homedir } from "os";
 import { createHash } from "crypto";
 function defaultPath(directory) {
   const key = createHash("sha256").update(directory).digest("hex").slice(0, 16);
-  return join("/home/julius/.local/state", "opencode-context-guard", `${key}.jsonl`);
+  return join2(process.env.XDG_STATE_HOME || join2(homedir(), ".local/state"), "opencode-context-guard", `${key}.jsonl`);
 }
 
 class JsonlTelemetrySink {
@@ -1053,8 +1955,8 @@ class JsonlTelemetrySink {
   async drain() {
     try {
       if (!this.ready) {
-        await mkdir(dirname(this.path), { recursive: true, mode: 448 });
-        this.bytes = await stat(this.path).then((s) => s.size).catch(() => 0);
+        await mkdir2(dirname(this.path), { recursive: true, mode: 448 });
+        this.bytes = await stat2(this.path).then((s) => s.size).catch(() => 0);
         this.ready = true;
       }
       while (this.pending.length) {
@@ -1071,7 +1973,7 @@ class JsonlTelemetrySink {
           });
           this.bytes = 0;
         }
-        const file = await open(this.path, "a", 384);
+        const file = await open2(this.path, "a", 384);
         try {
           await file.writeFile(line);
         } finally {
@@ -1090,13 +1992,41 @@ class JsonlTelemetrySink {
       await this.working;
   }
 }
+async function readJournal(path, maxBytes = 16 * 1024 * 1024) {
+  const records = [];
+  for (const name of [`${path}.1`, path]) {
+    const size = await stat2(name).then((s) => s.size).catch(() => 0);
+    if (!size)
+      continue;
+    const file = await open2(name, "r");
+    const buffer = Buffer.alloc(Math.min(size, maxBytes));
+    try {
+      await file.read(buffer, 0, buffer.length, Math.max(0, size - maxBytes));
+    } finally {
+      await file.close();
+    }
+    const lines = buffer.toString("utf8").split("\n");
+    if (size > maxBytes)
+      lines.shift();
+    for (const line of lines) {
+      if (!line)
+        continue;
+      try {
+        records.push(JSON.parse(line));
+      } catch {
+      }
+    }
+  }
+  return records;
+}
 
 // src/adapter.ts
 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 store = new SnapshotStore(config, () => monitor?.sessions ?? new Map);
+  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);
   let monitor;
   const sink = {
     emit(event) {
@@ -1123,7 +2053,7 @@ async function setup(ctx, injectedSink) {
       diagnostics.emit(event);
     }
   };
-  const stopSnapshots = await serveSnapshots(ctx.rpc, store).catch(() => {
+  const stopV1 = await serveSnapshots(ctx.rpc, store).catch(() => {
     diagnostics.emit({
       time: Date.now(),
       type: "snapshot-service-unavailable"
@@ -1131,6 +2061,27 @@ async function setup(ctx, injectedSink) {
     return () => {
     };
   });
+  const stopV2 = await serveSnapshots(ctx.rpc, store, true).catch(() => {
+    diagnostics.emit({
+      time: Date.now(),
+      type: "performance-service-unavailable"
+    });
+    return () => {
+    };
+  });
+  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(() => {
+    diagnostics.emit({ time: Date.now(), type: "history-service-unavailable" });
+    return () => {
+    };
+  });
+  const stopSnapshots = async () => {
+    await stopHistory();
+    await stopV2();
+    await stopV1();
+  };
   if (!config.enabled) {
     sink.emit({ time: Date.now(), type: "disabled" });
     return async () => {
@@ -1138,6 +2089,46 @@ async function setup(ctx, injectedSink) {
       await disk.flush();
     };
   }
+  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 }));
+  await history.initialize();
+  if (config.metrics.enabled) {
+    performance.restore(await ctx.storage.get("performance.v1").catch(() => {
+      return;
+    }));
+  }
+  const performanceResidents = new Set;
+  const recordPerformance = (id, type, event) => {
+    if (!config.metrics.enabled)
+      return;
+    const state = monitor?.sessions.get(id), snapshot = performance.snapshot(id);
+    if (!state || !snapshot)
+      return;
+    history.emit({
+      schema: 1,
+      recordId: crypto.randomUUID(),
+      time: Date.now(),
+      type,
+      sessionId: id,
+      ...state.parentId ? { parentId: state.parentId } : {},
+      ...state.agent ? { agent: state.agent } : {},
+      ...state.model ? { model: state.model } : {},
+      ...event ? { event } : {},
+      performance: snapshot
+    });
+  };
+  const persistPerformance = async () => {
+    if (!config.metrics.enabled)
+      return;
+    await ctx.storage.set("performance.v1", performance.checkpoint().map((row2) => ({ ...row2 }))).catch(() => {
+      diagnostics.emit({
+        time: Date.now(),
+        type: "performance-persistence-unavailable"
+      });
+    });
+  };
   const controller = new AbortController;
   let stopped = false, persistenceHealthy = true;
   let work = Promise.resolve();
@@ -1245,6 +2236,15 @@ async function setup(ctx, injectedSink) {
         s.sequence = recovery.sequence ?? -1;
         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 (dormant)
+            performance.remove(dormant);
+        }
+        performance.observe(sessionId, info.time.created, outputTokens(info.tokens));
+        performanceResidents.add(sessionId);
+      }
       s.usage.cumulative = info.tokens;
       s.usage.cumulativeScope = "session";
       store.mark(s.sessionId);
@@ -1317,12 +2317,15 @@ async function setup(ctx, injectedSink) {
   } catch (error) {
     for (const r of registrations)
       await r.dispose();
+    await history.flush();
     await stopSnapshots();
     throw error;
   }
   const relevant = new Set([
+    "session.usage.updated",
     "session.created",
     "session.step.started",
+    "session.step.streamed",
     "session.step.ended",
     "session.step.failed",
     "session.compaction.started",
@@ -1338,12 +2341,23 @@ async function setup(ctx, injectedSink) {
     "session.tool.called"
   ]);
   async function handle(event) {
+    if (event.location && event.location.directory !== ctx.location.directory)
+      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);
+      return;
+    }
     if (!relevant.has(event.type) || !("sessionID" in event.data))
       return;
     const id = event.data.sessionID;
     if (event.location && event.location.directory !== ctx.location.directory)
       return;
     if (event.type === "session.deleted") {
+      recordPerformance(id, "terminal", "session.deleted");
+      performance.remove(id);
+      performanceResidents.delete(id);
+      await persistPerformance();
       store.remove(id);
       requests.delete(id);
       activeMonitor.remove(id);
@@ -1357,8 +2371,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));
     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);
         activeMonitor.touch({
           sessionId: id,
           agent: event.data.agent,
@@ -1371,8 +2388,14 @@ async function setup(ctx, injectedSink) {
         s.usage.modelRequests++;
         s.active = true;
         break;
+      case "session.step.streamed":
+        if (perfAccepted)
+          performance.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);
         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)
@@ -1411,6 +2434,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);
         s.lastExecutionEnd = event.created;
         break;
       case "session.tool.called":
@@ -1418,9 +2443,26 @@ async function setup(ctx, injectedSink) {
         break;
     }
     sink.emit({ time: Date.now(), type: "session-state", session: s });
+    if (perfAccepted) {
+      recordPerformance(id, event.type === "session.step.ended" || event.type === "session.step.failed" ? "request" : event.type.startsWith("session.execution.") && event.type !== "session.execution.started" ? "terminal" : "lifecycle", event.type);
+      await persistPerformance();
+    }
     await persist();
   }
+  let lastPerformanceSample = 0, lastHistorySample = 0;
   const timer = setInterval(() => {
+    const now = Date.now();
+    if (config.metrics.enabled && now - lastPerformanceSample >= config.metrics.sampleIntervalMs) {
+      lastPerformanceSample = now;
+      for (const id of performanceResidents) {
+        store.mark(id);
+        const snapshot = performance.snapshot(id);
+        if (now - lastHistorySample >= 1000 && snapshot && (snapshot.status === "waiting" || snapshot.status === "streaming"))
+          recordPerformance(id, "sample");
+      }
+      if (now - lastHistorySample >= 1000)
+        lastHistorySample = now;
+    }
     store.flush();
     if (draining || stopped)
       return;
@@ -1430,6 +2472,11 @@ async function setup(ctx, injectedSink) {
       activeMonitor.cleanup();
       if (activeMonitor.sessions.size + recoveries.size < config.safety.maxSessions)
         store.recover("capacity-exceeded");
+      for (const id of performanceResidents)
+        if (!activeMonitor.sessions.has(id)) {
+          performance.remove(id);
+          performanceResidents.delete(id);
+        }
       for (const id of requests.keys())
         if (!activeMonitor.sessions.has(id))
           requests.delete(id);
@@ -1451,6 +2498,12 @@ async function setup(ctx, injectedSink) {
       } catch {
       }
       if (!stopped) {
+        performance.gap();
+        for (const id of performanceResidents) {
+          store.mark(id);
+          recordPerformance(id, "gap", "event-stream-gap");
+        }
+        await persistPerformance();
         sink.emit({
           time: Date.now(),
           type: "event-stream-gap",
@@ -1476,11 +2529,11 @@ async function setup(ctx, injectedSink) {
       detail: "Enforcement disabled; safety state could not be read"
     });
   if (!injectedSink)
-    console.error(`context-guard: ${config.mode}; diagnostics ${disk.path}`);
+    console.error(`context-guard: ${config.mode}; diagnostics ${disk.path}; metrics ${history.path}`);
   sink.emit({
     time: Date.now(),
     type: "ready",
-    detail: `SDK 2.0.29; runtime ${ctx.app.version}; ${config.mode}; active-subagent=step-boundary; next-request-barrier=false; journal=${disk.path}`
+    detail: `SDK 2.0.29; runtime ${ctx.app.version}; ${config.mode}; active-subagent=step-boundary; next-request-barrier=false; journal=${disk.path}; metrics=${history.path}`
   });
   return async () => {
     stopped = true;
@@ -1495,13 +2548,18 @@ async function setup(ctx, injectedSink) {
     await work;
     await scheduler.flush();
     await persist();
+    await persistPerformance();
+    await history.flush();
     await stopSnapshots();
     await disk.flush();
   };
 }
 
 // src/index.ts
-var src_default = Plugin.define({ id: "context-guard", setup });
+var src_default = Plugin.define({
+  id: "context-guard",
+  setup: (ctx, injectedSink) => setup({ ...ctx, historyRpc: ctx.rpc }, injectedSink)
+});
 export {
   src_default as default
 };