@cesarus777/opencode-cgp 0.1.0 → 0.2.2

package/dist/cli.js

@@ -0,0 +1,1411 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/rpc.ts
+import { Rpc } from "@opencode/plugin/rpc";
+var count = {
+  type: "integer",
+  minimum: 0,
+  maximum: Number.MAX_SAFE_INTEGER
+};
+var text = { type: "string", minLength: 1, maxLength: 512 };
+var enumeration = (...values) => ({ type: "string", enum: values });
+var object = (properties, required = Object.keys(properties)) => ({
+  type: "object",
+  properties,
+  required,
+  additionalProperties: false
+});
+var array = (items, maxItems = 128) => ({
+  type: "array",
+  items,
+  maxItems
+});
+var measurement = object({
+  tokens: count,
+  at: count,
+  model: text,
+  requestId: text,
+  provenance: enumeration("provider-normalized", "serialized-estimate"),
+  confidence: enumeration("reported", "approximate"),
+  scope: enumeration("completed-request", "prepared-request")
+}, ["tokens", "at", "model", "provenance", "confidence", "scope"]);
+var row = object({
+  sessionId: text,
+  revision: count,
+  observedAt: count,
+  parentId: text,
+  agent: text,
+  model: text,
+  measurement,
+  limits: object({ context: count, input: count, output: count }, [
+    "context",
+    "output"
+  ]),
+  capacityTokens: count,
+  outputReserveTokens: count,
+  peakTokens: count,
+  policy: object({
+    id: text,
+    configured: object({
+      type: enumeration("tokens", "ratio", "remaining"),
+      value: { type: "number", minimum: 0 }
+    }),
+    triggerTokens: { type: "number" },
+    comparison: enumeration(">=", ">"),
+    reason: enumeration("missing-usage", "model-changed", "invalid-usage", "stale-usage", "missing-model-budget", "incompatible-model-budget", "threshold-crossed", "below-threshold"),
+    crossed: { type: "boolean" }
+  }, ["id", "configured", "comparison", "reason", "crossed"]),
+  compaction: object({
+    phase: enumeration("idle", "requesting", "accepted", "running", "awaiting-measurement", "blocked", "uncertain"),
+    count,
+    armed: { type: "boolean" },
+    blockedReason: enumeration("session-removed", "compaction-failed", "reclaim-unverifiable", "insufficient-reclaim", "completion-event-timeout", "admission-outcome-unknown", "restart-needs-lifecycle-evidence"),
+    lastAttempt: count,
+    lastCompleted: count,
+    cooldownUntil: count
+  }, ["phase", "armed"]),
+  cumulative: object({
+    input: count,
+    output: count,
+    reasoning: count,
+    cache: object({ read: count, write: count })
+  }),
+  cumulativeScope: enumeration("session", "unknown"),
+  lastObservedActive: { type: "boolean" }
+}, [
+  "sessionId",
+  "revision",
+  "observedAt",
+  "policy",
+  "compaction",
+  "cumulativeScope",
+  "lastObservedActive"
+]);
+var batchFields = {
+  schemaVersion: { const: 1 },
+  epoch: text,
+  sequence: count,
+  generatedAt: count,
+  health: object({
+    enabled: { type: "boolean" },
+    mode: enumeration("observe", "enforce"),
+    enforcement: enumeration("observing", "available", "suspended", "disabled"),
+    reasons: array(enumeration("event-stream-gap", "persistence-unavailable", "capacity-exceeded", "model-metadata-unavailable"), 8),
+    staleMs: count,
+    maxSessions: count
+  }),
+  upserts: array(row),
+  removed: array(object({
+    sessionId: text,
+    revision: count,
+    reason: enumeration("deleted", "evicted")
+  }))
+};
+var readSchema = object({
+  schemaVersion: { const: 1 },
+  sessionIds: { ...array(text), uniqueItems: true }
+});
+var batchSchema = object(batchFields);
+var resultSchema = object({
+  ...batchFields,
+  unavailable: array(object({ sessionId: text, reason: enumeration("not-monitored") }))
+});
+var monitorRpc = Rpc.define({
+  id: "context-guard.monitor.v1",
+  methods: { read: { input: readSchema, output: resultSchema } },
+  events: { changed: { schema: batchSchema } }
+});
+var nonnegative = { type: "number", minimum: 0 };
+var performanceSchema = object({
+  observedSince: count,
+  at: count,
+  sessionCreatedAt: count,
+  sessionOutputTokens: count,
+  status: enumeration("waiting", "streaming", "idle", "unavailable"),
+  partial: { type: "boolean" },
+  liveTps: nonnegative,
+  averageModelTps: nonnegative,
+  averageSessionTps: nonnegative,
+  ttftMs: nonnegative,
+  latestRequestTps: nonnegative,
+  requestId: text,
+  requestAgent: text,
+  requestModel: text,
+  requestOutputTokens: count,
+  requestStartedAt: count,
+  firstOutputAt: count,
+  streamEndedAt: count,
+  estimatedOutputTokens: nonnegative,
+  modelOutputTokens: nonnegative,
+  modelDurationMs: nonnegative,
+  completedRequests: count,
+  tokenSource: enumeration("estimated", "reported", "unavailable")
+}, [
+  "sessionCreatedAt",
+  "observedSince",
+  "at",
+  "status",
+  "partial",
+  "estimatedOutputTokens",
+  "modelOutputTokens",
+  "modelDurationMs",
+  "completedRequests",
+  "tokenSource"
+]);
+var performanceRow = {
+  ...row,
+  properties: { ...row.properties, performance: performanceSchema }
+};
+var performanceBatchSchema = object({
+  ...batchFields,
+  upserts: array(performanceRow)
+});
+var performanceResultSchema = object({
+  ...batchFields,
+  upserts: array(performanceRow),
+  unavailable: resultSchema.properties.unavailable ?? {}
+});
+var performanceRpc = Rpc.define({
+  id: "context-guard.monitor.v2",
+  methods: { read: { input: readSchema, output: performanceResultSchema } },
+  events: { changed: { schema: performanceBatchSchema } }
+});
+function isPerformanceBatch(value) {
+  return valid(value, performanceBatchSchema) && uniqueRows(value);
+}
+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);
+}
+function matches(value, schema) {
+  if (!record(schema))
+    return false;
+  if ("const" in schema && value !== schema.const)
+    return false;
+  if (Array.isArray(schema.enum) && !schema.enum.includes(value))
+    return false;
+  if (schema.type === "number" || schema.type === "integer")
+    return typeof value === "number" && Number.isFinite(value) && (schema.type !== "integer" || Number.isSafeInteger(value)) && (typeof schema.minimum !== "number" || value >= schema.minimum) && (typeof schema.maximum !== "number" || value <= schema.maximum);
+  if (schema.type === "string")
+    return typeof value === "string" && value.length > 0 && value.length <= 512;
+  if (schema.type === "boolean")
+    return typeof value === "boolean";
+  if (schema.type === "array")
+    return Array.isArray(value) && value.length <= Number(schema.maxItems) && (!schema.uniqueItems || new Set(value).size === value.length) && value.every((v) => matches(v, schema.items));
+  if (schema.type === "object") {
+    if (!record(value) || !record(schema.properties) || !Array.isArray(schema.required))
+      return false;
+    const properties = schema.properties;
+    return schema.required.every((k) => typeof k === "string" && (k in value)) && Object.keys(value).every((k) => (k in properties) && matches(value[k], properties[k]));
+  }
+  return "const" in schema;
+}
+function valid(value, schema) {
+  try {
+    return JSON.stringify(value).length <= 524288 && matches(value, schema);
+  } catch {
+    return false;
+  }
+}
+function isRead(value) {
+  return valid(value, readSchema);
+}
+function isBatch(value) {
+  return valid(value, batchSchema) && uniqueRows(value);
+}
+function isResult(value) {
+  return valid(value, resultSchema) && uniqueRows(value);
+}
+function uniqueRows(value) {
+  if (!record(value) || !Array.isArray(value.upserts) || !Array.isArray(value.removed))
+    return false;
+  const ids = [...value.upserts, ...value.removed].map((v) => record(v) ? v.sessionId : undefined);
+  return ids.length <= 128 && new Set(ids).size === ids.length;
+}
+
+// src/cli.ts
+import { writeFile } from "fs/promises";
+import { resolve } from "path";
+
+// src/charts.ts
+var rateFields = [
+  "liveTps",
+  "averageModelTps",
+  "averageSessionTps",
+  "sessionOutputTokens"
+];
+function downsamplePoints(points, limit) {
+  if (!Number.isSafeInteger(limit) || limit < 16 || limit > 5000)
+    throw new Error("maxPoints must be an integer from 16 to 5000");
+  if (points.length <= limit)
+    return [...points];
+  const buckets = Math.max(1, Math.floor(limit / (2 + rateFields.length * 2)));
+  const selected = new Set;
+  for (let b = 0;b < buckets; b++) {
+    const start = Math.floor(b * points.length / buckets), end = Math.floor((b + 1) * points.length / buckets);
+    selected.add(start);
+    selected.add(end - 1);
+    for (const field of rateFields) {
+      let low, high;
+      for (let i = start;i < end; i++) {
+        const value = points[i]?.[field];
+        if (value === undefined)
+          continue;
+        if (low === undefined || value < (points[low]?.[field] ?? Infinity))
+          low = i;
+        if (high === undefined || value > (points[high]?.[field] ?? -Infinity))
+          high = i;
+      }
+      if (low !== undefined)
+        selected.add(low);
+      if (high !== undefined)
+        selected.add(high);
+    }
+  }
+  let previous = -1;
+  return [...selected].sort((a, b) => a - b).flatMap((index) => {
+    const point = points[index];
+    if (!point)
+      return [];
+    const skippedGap = points.slice(previous + 1, index + 1).some((p) => p.breakBefore);
+    previous = index;
+    return [{ ...point, breakBefore: point.breakBefore || skippedGap }];
+  });
+}
+function buildChartData(records, options = {}) {
+  const maxPoints = options.maxPoints ?? 1000, maxSessions = options.maxSessions ?? 128;
+  if (!Number.isSafeInteger(maxSessions) || maxSessions < 1 || maxSessions > 1024)
+    throw new Error("maxSessions must be from 1 to 1024");
+  downsamplePoints([], maxPoints);
+  const sorted = [...records].sort((a, b) => a.time - b.time || a.recordId.localeCompare(b.recordId));
+  const lastSeen = new Map;
+  for (const r of sorted)
+    if (r.performance && (!options.sessionId || r.sessionId === options.sessionId))
+      lastSeen.set(r.sessionId, r.time);
+  const sessions = [...lastSeen].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  const selected = new Set(sessions.slice(0, maxSessions).map(([id]) => id));
+  const series = new Map, gaps = [];
+  const seen = new Set, requestSeen = new Set;
+  const pendingGaps = new Set;
+  const observedSince = new Map;
+  for (const r of sorted) {
+    if (seen.has(r.recordId))
+      continue;
+    seen.add(r.recordId);
+    if (r.type === "gap") {
+      if (r.sessionId === "__history__" || selected.has(r.sessionId)) {
+        gaps.push({
+          time: r.time,
+          sessionId: r.sessionId,
+          reason: r.event ?? "observation-gap"
+        });
+        if (r.sessionId === "__history__")
+          for (const id of selected)
+            pendingGaps.add(id);
+        else
+          pendingGaps.add(r.sessionId);
+      }
+      continue;
+    }
+    const p = r.performance;
+    if (!p || !selected.has(r.sessionId))
+      continue;
+    let s = series.get(r.sessionId);
+    if (!s) {
+      s = {
+        sessionId: r.sessionId,
+        ...r.parentId ? { parentId: r.parentId } : {},
+        agents: [],
+        models: [],
+        points: [],
+        requests: [],
+        originalPoints: 0
+      };
+      series.set(r.sessionId, s);
+    }
+    const agent = p.requestAgent ?? r.agent, model = p.requestModel ?? r.model;
+    if (agent && !s.agents.includes(agent))
+      s.agents.push(agent);
+    if (model && !s.models.includes(model))
+      s.models.push(model);
+    const previous = s.points.at(-1);
+    const restart = observedSince.has(r.sessionId) && observedSince.get(r.sessionId) !== p.observedSince;
+    const reset = previous?.sessionOutputTokens !== undefined && p.sessionOutputTokens !== undefined && p.sessionOutputTokens < previous.sessionOutputTokens;
+    const discontinuity = pendingGaps.has(r.sessionId) || restart || reset || !previous || previous.partial !== p.partial || previous.liveTps === undefined || p.liveTps === undefined || r.time - previous.time > 2500 || previous.agent !== agent || previous.model !== model;
+    const point = {
+      time: r.time,
+      ...agent ? { agent } : {},
+      ...model ? { model } : {},
+      breakBefore: discontinuity,
+      partial: p.partial,
+      ...p.liveTps === undefined ? {} : { liveTps: p.liveTps },
+      ...p.averageModelTps === undefined ? {} : { averageModelTps: p.averageModelTps },
+      ...p.averageSessionTps === undefined ? {} : { averageSessionTps: p.averageSessionTps },
+      ...p.sessionOutputTokens === undefined ? {} : { sessionOutputTokens: p.sessionOutputTokens }
+    };
+    if (previous?.time === point.time)
+      s.points[s.points.length - 1] = {
+        ...point,
+        breakBefore: point.breakBefore || previous.breakBefore
+      };
+    else
+      s.points.push(point);
+    observedSince.set(r.sessionId, p.observedSince);
+    pendingGaps.delete(r.sessionId);
+    if (r.type === "request" && p.requestId !== undefined && p.requestStartedAt !== undefined) {
+      const key = JSON.stringify([
+        r.sessionId,
+        p.requestId,
+        p.requestStartedAt
+      ]);
+      if (requestSeen.has(key))
+        continue;
+      requestSeen.add(key);
+      const duration = p.streamEndedAt === undefined ? undefined : p.streamEndedAt - p.requestStartedAt;
+      const validDuration = duration !== undefined && duration > 0;
+      const output = p.tokenSource === "reported" ? p.requestOutputTokens : undefined;
+      s.requests.push({
+        time: r.time,
+        requestId: p.requestId,
+        started: p.requestStartedAt,
+        ...agent ? { agent } : {},
+        ...model ? { model } : {},
+        partial: p.partial,
+        ...p.ttftMs === undefined ? {} : { ttftMs: p.ttftMs },
+        ...output === undefined ? {} : { outputTokens: output },
+        ...validDuration ? { durationMs: duration } : {},
+        ...output !== undefined && validDuration ? { tps: output * 1000 / duration } : {}
+      });
+    }
+  }
+  return {
+    schema: 1,
+    series: [...series.values()].map((s) => ({
+      ...s,
+      originalPoints: s.points.length,
+      points: downsamplePoints(s.points, maxPoints)
+    })),
+    gaps: gaps.slice(-1024),
+    omittedGaps: Math.max(0, gaps.length - 1024),
+    omittedSessions: Math.max(0, sessions.length - selected.size),
+    maxPoints
+  };
+}
+
+// src/chartreport.ts
+function renderChartReport(report) {
+  const payload = JSON.stringify(report).replace(/[<>&\u2028\u2029]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src blob: data:; connect-src 'none'">
+<title>Context Guard \xB7 Performance history</title>
+<style>
+:root{color-scheme:dark;font-family:system-ui,sans-serif;background:#0b1120;color:#e2e8f0}*{box-sizing:border-box}body{max-width:1600px;margin:auto;padding:28px}h1{font-size:28px;letter-spacing:-.03em;margin:8px 0}h2{font-size:16px;margin:0}p{color:#a8b5cb;line-height:1.6;margin:8px 0}.eyebrow{color:#7dd3fc;font-size:12px;letter-spacing:.13em;text-transform:uppercase}.toolbar,.stats,.charts{display:grid;gap:14px;margin-top:22px}.toolbar{grid-template-columns:2fr 1fr 1fr 1.4fr 1.4fr auto;align-items:end}label{font-size:12px;color:#a8b5cb;display:grid;gap:7px}select,input,button{background:#172338;border:1px solid #33435a;border-radius:7px;color:inherit;padding:10px;min-width:0;font:inherit}button{cursor:pointer;font-size:12px}button:hover,button:focus-visible{border-color:#7dd3fc}select:focus-visible,input:focus-visible{outline:2px solid #7dd3fc}.stats{grid-template-columns:repeat(4,1fr)}.stat,.chart{background:#111c2e;border:1px solid #26354e;border-radius:12px;padding:18px}.stat strong{font-size:24px;display:block;margin-top:7px}.stat span{font-size:12px;color:#a8b5cb}.charts{grid-template-columns:repeat(2,minmax(0,1fr))}.charthead{display:flex;justify-content:space-between;align-items:center;gap:10px}.chart p{font-size:12px;min-height:38px}.chart svg{display:block;width:100%;height:auto}.notice{padding:12px 15px;border-left:3px solid #fbbf24;background:#201f2d;font-size:13px;margin-top:15px}.legend{display:flex;flex-wrap:wrap;gap:8px 18px;margin-top:18px;font-size:12px}.legend span{overflow-wrap:anywhere}.dot{display:inline-block;width:9px;height:9px;border-radius:50%;margin-right:7px}.empty{padding:30px;text-align:center;color:#a8b5cb}.tooltip{position:fixed;z-index:5;pointer-events:none;background:#e2e8f0;color:#0b1120;border-radius:7px;padding:10px;max-width:360px;white-space:pre-wrap;font-size:12px;box-shadow:0 8px 30px #0008}footer{margin-top:25px;font-size:12px;color:#a8b5cb}svg circle:focus{outline:none;stroke:white;stroke-width:3}@media(max-width:1000px){.toolbar{grid-template-columns:repeat(2,minmax(0,1fr))}.charts{grid-template-columns:1fr}}@media(max-width:600px){body{padding:16px}.stats{grid-template-columns:repeat(2,1fr)}}@media print{button,.toolbar,.tooltip{display:none}body{padding:0}.chart{break-inside:avoid}.charts{grid-template-columns:1fr}}
+</style></head><body>
+<header><span class="eyebrow">Context Guard / Local analysis</span><h1>Performance history</h1><p>Compare agent instances over time. All timestamps are UTC. This report is an offline snapshot of retained metrics.</p></header>
+<section class="toolbar" aria-label="Chart filters">
+<label>Session instance<select id="session"></select></label><label>Agent<select id="agent"></select></label><label>Model<select id="model"></select></label>
+<label>From (UTC)<input id="from" type="datetime-local" step="1"></label><label>To (UTC)<input id="to" type="datetime-local" step="1"></label><button id="reset">Reset filters</button>
+</section>
+<div id="notice" class="notice" role="status"></div><section id="stats" class="stats" aria-label="Request statistics"></section>
+<div id="legend" class="legend"></div><main id="charts" class="charts"></main>
+<footer>Live TPS uses a character estimate; TTFT includes output publication delay. Dashed curves mark estimates or partial observations. Gaps and missing samples are never filled with zero. Request statistics use retained matching requests; average curves retain the session's original cumulative totals. Agent/model filters select observations, not recomputed lifetime averages. Exported SVGs reflect the current filters. Regenerate this report to include new history.</footer>
+<div id="tooltip" class="tooltip" hidden role="tooltip"></div>
+<script id="chart-data" type="application/json">${payload}</script>
+<script>(${chartClient.toString()})(JSON.parse(document.getElementById("chart-data").textContent));</script>
+</body></html>`;
+}
+function chartClient(report) {
+  const { data, metadata } = report;
+  const element = (id, kind) => {
+    const node = document.getElementById(id);
+    if (!(node instanceof kind))
+      throw new Error(`Missing report element ${id}`);
+    return node;
+  };
+  const session = element("session", HTMLSelectElement), agent = element("agent", HTMLSelectElement), model = element("model", HTMLSelectElement);
+  const from = element("from", HTMLInputElement), to = element("to", HTMLInputElement);
+  const charts = element("charts", HTMLElement), stats = element("stats", HTMLElement), legend = element("legend", HTMLElement);
+  const notice = element("notice", HTMLElement), tooltip = element("tooltip", HTMLElement);
+  const color = (index) => `hsl(${(index * 137.508 + 195) % 360}, 78%, 68%)`;
+  const date = (value) => {
+    const d = new Date(value);
+    return Number.isFinite(d.getTime()) ? d.toISOString() : String(value);
+  };
+  const number = (n, digits = 1) => n === undefined ? "Unavailable" : n.toLocaleString("en-US", { maximumFractionDigits: digits });
+  function options(select, values) {
+    for (const v of values) {
+      const o = document.createElement("option");
+      o.value = v.value;
+      o.textContent = v.label;
+      select.append(o);
+    }
+  }
+  options(session, [
+    { value: "*", label: "Compare sessions (up to 12)" },
+    ...data.series.map((s) => ({
+      value: s.sessionId,
+      label: `${s.agents.join(", ") || "Agent"} \xB7 ${s.sessionId}`
+    }))
+  ]);
+  options(agent, [
+    { value: "*", label: "All agents" },
+    ...[...new Set(data.series.flatMap((s) => s.agents))].sort().map((v) => ({ value: v, label: v }))
+  ]);
+  options(model, [
+    { value: "*", label: "All models" },
+    ...[...new Set(data.series.flatMap((s) => s.models))].sort().map((v) => ({ value: v, label: v }))
+  ]);
+  function reset() {
+    session.value = data.series[0]?.sessionId ?? "*";
+    agent.value = report.agent ?? "*";
+    model.value = report.model ?? "*";
+    from.value = report.from === undefined ? "" : date(report.from).slice(0, 19);
+    to.value = report.to === undefined ? "" : date(report.to).slice(0, 19);
+  }
+  const timestamp = (value) => value ? Date.parse(`${value}Z`) : undefined;
+  function matches2(p, start, end) {
+    return (agent.value === "*" || p.agent === agent.value) && (model.value === "*" || p.model === model.value) && (start === undefined || p.time >= start) && (end === undefined || p.time <= end);
+  }
+  const ns = "http://www.w3.org/2000/svg";
+  function svgNode(name, attrs = {}, text2) {
+    const n = document.createElementNS(ns, name);
+    for (const [key, value] of Object.entries(attrs))
+      n.setAttribute(key, String(value));
+    if (text2 !== undefined)
+      n.textContent = text2;
+    return n;
+  }
+  function showTooltip(text2, x, y) {
+    tooltip.textContent = text2;
+    tooltip.hidden = false;
+    tooltip.style.left = `${Math.max(8, Math.min(x + 12, window.innerWidth - 370))}px`;
+    tooltip.style.top = `${Math.max(8, Math.min(y + 12, window.innerHeight - tooltip.offsetHeight - 10))}px`;
+  }
+  const definitions = [
+    {
+      key: "liveTps",
+      title: "Live TPS",
+      unit: "tokens / second",
+      description: "Estimated text + reasoning throughput in the rolling collection window.",
+      requests: false,
+      estimated: true
+    },
+    {
+      key: "averageModelTps",
+      title: "Average model throughput",
+      unit: "tokens / second",
+      description: "Session output / matched model-request time, including TTFT and excluding subsequent tool time.",
+      requests: false,
+      estimated: false
+    },
+    {
+      key: "averageSessionTps",
+      title: "Average session throughput",
+      unit: "tokens / second",
+      description: "Session output / elapsed session lifetime, including tools and idle time.",
+      requests: false,
+      estimated: false
+    },
+    {
+      key: "ttftMs",
+      title: "Time to first output",
+      unit: "seconds",
+      description: "One point per request with observed text/reasoning output. Includes publication delay.",
+      requests: true,
+      estimated: true
+    },
+    {
+      key: "tps",
+      title: "Completed request throughput",
+      unit: "tokens / second",
+      description: "Reported output + reasoning / request duration. Requests are never joined into a continuous curve.",
+      requests: true,
+      estimated: false
+    },
+    {
+      key: "sessionOutputTokens",
+      title: "Cumulative output",
+      unit: "tokens",
+      description: "Authoritative session output + reasoning totals. Lifecycle and sample records are snapshots, not increments.",
+      requests: false,
+      estimated: false
+    }
+  ];
+  function render() {
+    tooltip.hidden = true;
+    charts.replaceChildren();
+    stats.replaceChildren();
+    legend.replaceChildren();
+    const start = timestamp(from.value), end = timestamp(to.value);
+    if (start !== undefined && !Number.isFinite(start) || end !== undefined && !Number.isFinite(end) || start !== undefined && end !== undefined && start > end) {
+      notice.textContent = "Choose a valid time range with From before To.";
+      return;
+    }
+    const selected = data.series.filter((s) => (session.value === "*" || s.sessionId === session.value) && s.points.some((p) => matches2(p, start, end)) || (session.value === "*" || s.sessionId === session.value) && s.requests.some((p) => matches2(p, start, end)));
+    const visible = selected.slice(0, 12);
+    const requests = visible.flatMap((s) => s.requests.filter((r) => matches2(r, start, end)));
+    const matched = requests.filter((r) => r.outputTokens !== undefined && r.durationMs !== undefined && r.durationMs > 0);
+    const duration = matched.reduce((sum, r) => sum + (r.durationMs ?? 0), 0), tokens = matched.reduce((sum, r) => sum + (r.outputTokens ?? 0), 0);
+    const ttfts = requests.flatMap((r) => r.ttftMs === undefined ? [] : [r.ttftMs]).sort((a, b) => a - b);
+    const percentile = (q) => ttfts.length ? (ttfts[Math.max(0, Math.ceil(ttfts.length * q) - 1)] ?? 0) / 1000 : undefined;
+    for (const [label, value] of [
+      ["Matched / observed requests", `${matched.length} / ${requests.length}`],
+      [
+        "Retained request throughput",
+        duration ? `${number(tokens * 1000 / duration)} t/s` : "Unavailable"
+      ],
+      [
+        "Median observed TTFT",
+        ttfts.length ? `${number(percentile(0.5), 2)}s` : "Unavailable"
+      ],
+      [
+        "95th percentile TTFT",
+        ttfts.length ? `${number(percentile(0.95), 2)}s` : "Unavailable"
+      ]
+    ]) {
+      const box = document.createElement("div");
+      box.className = "stat";
+      const name = document.createElement("span"), valueNode = document.createElement("strong");
+      name.textContent = label ?? "";
+      valueNode.textContent = value ?? "";
+      box.append(name, valueNode);
+      stats.append(box);
+    }
+    const gaps = data.gaps.filter((g) => (g.sessionId === "__history__" || visible.some((s) => s.sessionId === g.sessionId)) && (start === undefined || g.time >= start) && (end === undefined || g.time <= end));
+    const notes = [
+      `Bounded retained history: ${metadata.retainedFrom === undefined ? "empty archive" : `segments since ${date(metadata.retainedFrom)}`}.`,
+      `${gaps.length} recorded gap markers.`
+    ];
+    if (metadata.skippedBytes)
+      notes.push(`${number(metadata.skippedBytes, 0)} bytes excluded by the read limit.`);
+    if (metadata.malformedRecords)
+      notes.push(`${metadata.malformedRecords} malformed/partial records skipped.`);
+    if (data.omittedGaps)
+      notes.push(`${data.omittedGaps} older gap markers omitted; curve discontinuities remain preserved.`);
+    if (data.omittedSessions)
+      notes.push(`${data.omittedSessions} sessions omitted from the report limit; regenerate with --session to inspect one.`);
+    if (selected.length > 12)
+      notes.push(`Showing 12 of ${selected.length} matching sessions; select a session for detail.`);
+    if (visible.some((s) => s.originalPoints > s.points.length))
+      notes.push(`Curves downsampled to at most ${data.maxPoints} observations per session, preserving extrema and gaps.`);
+    if (visible.some((s) => s.points.some((p) => p.partial && matches2(p, start, end))))
+      notes.push("Partial timing coverage is present.");
+    if (!visible.length)
+      notes.push("No observations match these filters.");
+    notice.textContent = notes.join(" ");
+    visible.forEach((s, index) => {
+      const item = document.createElement("span"), dot = document.createElement("i");
+      dot.className = "dot";
+      dot.style.backgroundColor = color(index);
+      item.append(dot, document.createTextNode(`${s.agents.join(", ") || "Agent"} \xB7 ${s.sessionId}${s.parentId ? ` (child of ${s.parentId})` : ""}`));
+      legend.append(item);
+    });
+    const times = visible.flatMap((s) => [...s.points, ...s.requests].filter((p) => matches2(p, start, end)).map((p) => p.time));
+    let minTime = start ?? times.reduce((a, t) => Math.min(a, t), Infinity), maxTime = end ?? times.reduce((a, t) => Math.max(a, t), -Infinity);
+    if (!Number.isFinite(minTime))
+      minTime = 0;
+    if (!Number.isFinite(maxTime))
+      maxTime = minTime + 1000;
+    if (maxTime <= minTime)
+      maxTime = minTime + 1000;
+    for (const def of definitions) {
+      const card = document.createElement("section");
+      card.className = "chart";
+      const heading = document.createElement("div");
+      heading.className = "charthead";
+      const title = document.createElement("h2");
+      title.textContent = def.title;
+      const download = document.createElement("button");
+      download.textContent = "Save SVG";
+      download.setAttribute("aria-label", `Save ${def.title} as SVG`);
+      heading.append(title, download);
+      const desc = document.createElement("p");
+      desc.textContent = def.description;
+      card.append(heading, desc);
+      charts.append(card);
+      const plots = visible.map((s) => {
+        if (def.requests)
+          return s.requests.filter((p) => matches2(p, start, end)).map((p) => {
+            const raw = def.key === "ttftMs" ? p.ttftMs : p.tps;
+            return {
+              ...p,
+              breakBefore: true,
+              ...raw === undefined ? {} : { value: def.key === "ttftMs" ? raw / 1000 : raw }
+            };
+          });
+        let skipped = false;
+        return s.points.flatMap((p) => {
+          if (!matches2(p, start, end)) {
+            skipped = true;
+            return [];
+          }
+          const key = def.key;
+          const value = key === "liveTps" ? p.liveTps : key === "averageModelTps" ? p.averageModelTps : key === "averageSessionTps" ? p.averageSessionTps : p.sessionOutputTokens;
+          const point = {
+            ...p,
+            breakBefore: p.breakBefore || skipped,
+            ...value === undefined ? {} : { value }
+          };
+          skipped = false;
+          return [point];
+        });
+      });
+      const drawn = plots.map((points) => {
+        if (!def.requests || points.length <= data.maxPoints)
+          return points;
+        const bins = Math.max(1, Math.floor(data.maxPoints / 4)), chosen = new Set;
+        for (let b = 0;b < bins; b++) {
+          const first = Math.floor(b * points.length / bins), last = Math.floor((b + 1) * points.length / bins) - 1;
+          chosen.add(first);
+          chosen.add(last);
+          let low = first, high = first;
+          for (let i = first;i <= last; i++) {
+            if ((points[i]?.value ?? Infinity) < (points[low]?.value ?? Infinity))
+              low = i;
+            if ((points[i]?.value ?? -Infinity) > (points[high]?.value ?? -Infinity))
+              high = i;
+          }
+          chosen.add(low);
+          chosen.add(high);
+        }
+        return [...chosen].sort((a, b) => a - b).flatMap((i) => points[i] ? [points[i]] : []);
+      });
+      const maxValue = drawn.reduce((maximum, points) => points.reduce((n, p) => Math.max(n, p.value ?? 0), maximum), 1) * 1.08;
+      const w = 720, h = 300, left = 64, right = 20, top = 24, bottom = 47;
+      const x = (t) => left + (t - minTime) / (maxTime - minTime) * (w - left - right);
+      const y = (v) => h - bottom - v / maxValue * (h - top - bottom);
+      const svg = svgNode("svg", {
+        viewBox: `0 0 ${w} ${h}`,
+        role: "img",
+        "aria-label": `${def.title} over UTC timestamps`,
+        xmlns: ns
+      });
+      svg.append(svgNode("rect", { width: w, height: h, fill: "#111c2e" }), svgNode("title", {}, `${def.title}. ${def.description}`));
+      svg.append(svgNode("text", {
+        x: left,
+        y: 14,
+        fill: "#a8b5cb",
+        "font-size": 11,
+        "font-family": "system-ui,sans-serif"
+      }, def.unit));
+      for (let tick = 0;tick <= 4; tick++) {
+        const v = maxValue * tick / 4;
+        svg.append(svgNode("line", {
+          x1: left,
+          x2: w - right,
+          y1: y(v),
+          y2: y(v),
+          stroke: "#2a3950",
+          "stroke-width": 1
+        }));
+        svg.append(svgNode("text", {
+          x: left - 8,
+          y: y(v) + 4,
+          fill: "#a8b5cb",
+          "text-anchor": "end",
+          "font-size": 11,
+          "font-family": "system-ui,sans-serif"
+        }, v >= 1e4 ? `${number(v / 1000)}k` : number(v)));
+        const t = minTime + (maxTime - minTime) * tick / 4;
+        const label = maxTime - minTime > 86400000 ? date(t).slice(5, 16).replace("T", " ") : date(t).slice(11, 19);
+        svg.append(svgNode("text", {
+          x: x(t),
+          y: h - 22,
+          fill: "#a8b5cb",
+          "text-anchor": tick === 0 ? "start" : tick === 4 ? "end" : "middle",
+          "font-size": 11,
+          "font-family": "system-ui,sans-serif"
+        }, label));
+      }
+      for (const gap of gaps)
+        if (gap.time >= minTime && gap.time <= maxTime) {
+          const line = svgNode("line", {
+            x1: x(gap.time),
+            x2: x(gap.time),
+            y1: top,
+            y2: h - bottom,
+            stroke: "#fb7185",
+            "stroke-dasharray": "3 5",
+            opacity: 0.65
+          });
+          line.append(svgNode("title", {}, `${date(gap.time)} \xB7 ${gap.reason}`));
+          svg.append(line);
+        }
+      let count2 = 0;
+      drawn.forEach((points, index) => {
+        let run = [];
+        const flush = () => {
+          if (run.length > 1)
+            svg.append(svgNode("polyline", {
+              points: run.map((p) => `${x(p.time)},${y(p.value ?? 0)}`).join(" "),
+              fill: "none",
+              stroke: color(index),
+              "stroke-width": 1.8,
+              ...def.estimated || run.some((p) => p.partial) ? { "stroke-dasharray": "5 4" } : {}
+            }));
+          run = [];
+        };
+        for (const point of points) {
+          if (point.breakBefore || point.value === undefined)
+            flush();
+          if (point.value === undefined)
+            continue;
+          count2++;
+          if (!def.requests)
+            run.push(point);
+          const label = `${date(point.time)}\n${visible[index]?.sessionId ?? ""}${point.agent ? ` \xB7 ${point.agent}` : ""}${point.model ? `\n${point.model}` : ""}\n${def.title}: ${def.estimated ? "~" : ""}${number(point.value, 3)} ${def.unit}${point.requestId ? `\nRequest: ${point.requestId}` : ""}${point.partial ? "\nPartial observation coverage" : ""}`;
+          const dot = svgNode("circle", {
+            cx: x(point.time),
+            cy: y(point.value),
+            r: def.requests ? 3 : 2.5,
+            fill: color(index),
+            tabindex: 0,
+            "aria-label": label
+          });
+          dot.append(svgNode("title", {}, label));
+          dot.addEventListener("mouseenter", (e) => showTooltip(label, e.clientX, e.clientY));
+          dot.addEventListener("mouseleave", () => {
+            tooltip.hidden = true;
+          });
+          dot.addEventListener("focus", () => {
+            const box = dot.getBoundingClientRect();
+            showTooltip(label, box.x, box.y);
+          });
+          dot.addEventListener("blur", () => {
+            tooltip.hidden = true;
+          });
+          svg.append(dot);
+        }
+        flush();
+      });
+      if (!count2)
+        svg.append(svgNode("text", {
+          x: w / 2,
+          y: h / 2,
+          fill: "#a8b5cb",
+          "text-anchor": "middle",
+          "font-size": 14,
+          "font-family": "system-ui,sans-serif"
+        }, "No measurements in this selection"));
+      card.append(svg);
+      download.onclick = () => {
+        const blob = new Blob([new XMLSerializer().serializeToString(svg)], {
+          type: "image/svg+xml"
+        });
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement("a");
+        link.href = url;
+        link.download = `context-guard-${def.key}.svg`;
+        link.click();
+        setTimeout(() => URL.revokeObjectURL(url), 1000);
+      };
+    }
+  }
+  for (const control of [session, agent, model, from, to])
+    control.addEventListener("change", render);
+  element("reset", HTMLButtonElement).onclick = () => {
+    reset();
+    render();
+  };
+  reset();
+  render();
+}
+
+// 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/telemetry.ts
+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 join2(process.env.XDG_STATE_HOME || join2(homedir(), ".local/state"), "opencode-context-guard", `${key}.jsonl`);
+}
+
+class JsonlTelemetrySink {
+  path;
+  config;
+  pending = [];
+  working;
+  disabled = false;
+  bytes = 0;
+  ready = false;
+  constructor(path, config) {
+    this.path = path;
+    this.config = config;
+  }
+  emit(event) {
+    if (!this.config.enabled || this.disabled)
+      return;
+    const line = JSON.stringify({ schema: 1, ...event }) + "\n";
+    if (!this.config.jsonl) {
+      console.error(line.trimEnd());
+      return;
+    }
+    if (this.pending.length >= 256) {
+      console.error("context-guard: telemetry queue full; record dropped");
+      return;
+    }
+    this.pending.push(line);
+    this.kick();
+  }
+  kick() {
+    if (!this.working && !this.disabled)
+      this.working = this.drain().finally(() => {
+        this.working = undefined;
+        if (this.pending.length)
+          this.kick();
+      });
+  }
+  async drain() {
+    try {
+      if (!this.ready) {
+        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) {
+        const line = this.pending.shift();
+        if (!line)
+          continue;
+        const size = Buffer.byteLength(line);
+        if (size > this.config.maxBytes)
+          continue;
+        if (this.bytes + size > this.config.maxBytes) {
+          await rename(this.path, `${this.path}.1`).catch((e) => {
+            if (e.code !== "ENOENT")
+              throw e;
+          });
+          this.bytes = 0;
+        }
+        const file = await open2(this.path, "a", 384);
+        try {
+          await file.writeFile(line);
+        } finally {
+          await file.close();
+        }
+        this.bytes += size;
+      }
+    } catch {
+      this.disabled = true;
+      this.pending = [];
+      console.error("context-guard: telemetry unavailable (check path and permissions)");
+    }
+  }
+  async flush() {
+    while (this.working)
+      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/cli.ts
+var args = process.argv.slice(2);
+if (!args[0] || args.includes("--help")) {
+  console.log("Usage: bun run inspect /absolute/path/to/journal.jsonl [--history] [--json]\nThe ready log reports the location-specific journal path.\nMetrics: inspect metrics /absolute/history-directory [--session ID] [--from ISO-or-ms] [--to ISO-or-ms] [--csv]\nCharts: inspect charts /absolute/history-directory --output report.html [--session ID] [--agent NAME] [--model provider/model] [--from ISO-or-ms] [--to ISO-or-ms] [--max-points 1000] [--force]");
+} else if (args[0] === "metrics" || args[0] === "charts") {
+  const directory = args[1];
+  if (!directory || directory.startsWith("--"))
+    throw new Error("Usage: inspect metrics /absolute/history-directory [--session ID] [--from ISO-or-ms] [--to ISO-or-ms] [--csv]");
+  const option = (name) => {
+    const index = args.indexOf(name);
+    if (index < 0)
+      return;
+    const value = args[index + 1];
+    if (!value || value.startsWith("--"))
+      throw new Error(`Missing value for ${name}`);
+    return value;
+  };
+  const timestamp = (value) => {
+    if (value === undefined)
+      return;
+    const n = /^\d+$/.test(value) ? Number(value) : Date.parse(value);
+    if (!Number.isSafeInteger(n) || n < 0)
+      throw new Error("Invalid timestamp");
+    return n;
+  };
+  const sessionId = option("--session"), agent = option("--agent"), model = option("--model"), from = timestamp(option("--from")), to = timestamp(option("--to"));
+  if (from !== undefined && to !== undefined && from > to)
+    throw new Error("--from must precede --to");
+  const chart = args[0] === "charts" || args.includes("--chart") || args.includes("--output");
+  if (chart && args.includes("--csv"))
+    throw new Error("Choose charts or CSV export");
+  const positiveInteger = (name, fallback, min, max) => {
+    const raw = option(name), n = raw === undefined ? fallback : Number(raw);
+    if (!Number.isSafeInteger(n) || n < min || n > max)
+      throw new Error(`${name} must be an integer from ${min} to ${max}`);
+    return n;
+  };
+  const maxPoints = positiveInteger("--max-points", 1000, 16, 5000);
+  const maxSessions = positiveInteger("--max-sessions", 128, 1, 1024);
+  const result = await readPerformanceHistory(directory, {
+    ...sessionId === undefined ? {} : { sessionId },
+    ...agent === undefined ? {} : { agent },
+    ...model === undefined ? {} : { model },
+    ...from === undefined ? {} : { from },
+    ...to === undefined ? {} : { to }
+  });
+  if (chart) {
+    const output = resolve(option("--chart") ?? option("--output") ?? "context-guard-charts.html");
+    if (!output.toLowerCase().endsWith(".html"))
+      throw new Error("Chart output must use an .html extension");
+    const data = buildChartData(result.records, { maxPoints, maxSessions });
+    const report = renderChartReport({
+      data,
+      metadata: result.metadata,
+      ...agent === undefined ? {} : { agent },
+      ...model === undefined ? {} : { model },
+      ...from === undefined ? {} : { from },
+      ...to === undefined ? {} : { to }
+    });
+    await writeFile(output, report, {
+      flag: args.includes("--force") ? "w" : "wx",
+      mode: 384
+    });
+    console.log(`Charts written to ${output} (${data.series.length} session instances). Open this file in a browser. No server or external assets are needed.`);
+  } else if (args.includes("--csv")) {
+    console.error(JSON.stringify(result.metadata));
+    const keys = [
+      "recordId",
+      "time",
+      "type",
+      "sessionId",
+      "parentId",
+      "agent",
+      "model",
+      "event",
+      "at",
+      "sessionCreatedAt",
+      "sessionOutputTokens",
+      "requestId",
+      "requestAgent",
+      "requestModel",
+      "requestOutputTokens",
+      "requestStartedAt",
+      "firstOutputAt",
+      "streamEndedAt",
+      "liveTps",
+      "averageModelTps",
+      "averageSessionTps",
+      "ttftMs",
+      "latestRequestTps",
+      "estimatedOutputTokens",
+      "modelOutputTokens",
+      "modelDurationMs",
+      "completedRequests",
+      "observedSince",
+      "status",
+      "partial",
+      "tokenSource"
+    ];
+    console.log(keys.join(","));
+    for (const record2 of result.records) {
+      if (!record2 || typeof record2 !== "object")
+        continue;
+      const row2 = {
+        ...record2,
+        ..."performance" in record2 && record2.performance && typeof record2.performance === "object" ? record2.performance : {}
+      };
+      console.log(keys.map((key) => '"' + String(row2[key] ?? "").replaceAll('"', '""') + '"').join(","));
+    }
+  } else
+    console.log(JSON.stringify(result, null, 2));
+} else {
+  const records = await readJournal(args[0]);
+  const sessions = new Map;
+  const history = [];
+  for (const record2 of records) {
+    history.push(record2);
+    if (!record2 || typeof record2 !== "object" || !("session" in record2))
+      continue;
+    const s = record2.session;
+    if (!s || typeof s !== "object" || !("sessionId" in s) || typeof s.sessionId !== "string")
+      continue;
+    sessions.set(s.sessionId, { ...s });
+  }
+  if (args.includes("--history"))
+    console.log(JSON.stringify(history, null, 2));
+  else if (args.includes("--json"))
+    console.log(JSON.stringify([...sessions.values()], null, 2));
+  else
+    for (const s of sessions.values())
+      console.log(JSON.stringify(s));
+}