@cesarus777/opencode-cgp 0.0.0-stage → 0.2.1

package/dist/index.js

@@ -0,0 +1,2565 @@
+// @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/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;
+  while (t < text2.length) {
+    if (pattern[p] === "?" || pattern[p] === text2[t]) {
+      p++;
+      t++;
+    } else if (pattern[p] === "*") {
+      star = p++;
+      retry = t;
+    } else if (star >= 0) {
+      p = star + 1;
+      t = ++retry;
+    } else
+      return false;
+  }
+  while (pattern[p] === "*")
+    p++;
+  return p === pattern.length;
+}
+
+class PolicyResolver {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  resolve(identity) {
+    let result = {
+      threshold: this.config.defaults.threshold,
+      policy: "defaults"
+    };
+    this.config.policies.forEach((p, i) => {
+      const m = p.match;
+      if (m.role && m.role !== (identity.parentId ? "subagent" : "main"))
+        return;
+      if (m.agent && (!identity.agent || !glob(m.agent, identity.agent)))
+        return;
+      if (m.model && (!identity.model || !glob(m.model, identity.model)))
+        return;
+      result = { threshold: p.threshold, policy: `policies[${i}]` };
+    });
+    return result;
+  }
+}
+function usableInput(limits, reserve) {
+  if (!limits)
+    return;
+  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;
+}
+function evaluateThreshold(threshold, measurement2, limits, now, staleMs, model, policy, reserve) {
+  const budget = usableInput(limits, reserve);
+  const base = {
+    crossed: false,
+    reason: "missing-usage",
+    policy,
+    ...budget === undefined ? {} : { budget }
+  };
+  const trigger = threshold.type === "tokens" ? threshold.value : budget === undefined ? undefined : threshold.type === "ratio" ? Math.ceil(budget * threshold.value) : budget - threshold.value;
+  if (trigger !== undefined)
+    base.threshold = trigger;
+  if (!measurement2)
+    return base;
+  if (model !== measurement2.model)
+    return { ...base, reason: "model-changed" };
+  if (!Number.isFinite(measurement2.tokens) || measurement2.tokens < 0)
+    return { ...base, reason: "invalid-usage" };
+  if (now - measurement2.at > staleMs || measurement2.at > now)
+    return { ...base, reason: "stale-usage" };
+  if (budget !== undefined && budget > 0)
+    base.percentage = measurement2.tokens / budget * 100;
+  if (trigger === undefined)
+    return { ...base, reason: "missing-model-budget" };
+  if (trigger <= 0)
+    return { ...base, reason: "incompatible-model-budget" };
+  const crossed = threshold.type === "remaining" ? measurement2.tokens > trigger : measurement2.tokens >= trigger;
+  return {
+    ...base,
+    crossed,
+    reason: crossed ? "threshold-crossed" : "below-threshold"
+  };
+}
+
+// src/snapshot.ts
+function project(s, config, now, revision = 0) {
+  const p = new PolicyResolver(config).resolve(s);
+  const d = evaluateThreshold(p.threshold, s.usage.current, s.limits, now, config.safety.staleMs, s.model, p.policy, config.safety.outputReserveTokens);
+  const c = s.compaction;
+  return freezeSnapshot({
+    sessionId: s.sessionId,
+    revision,
+    observedAt: s.lastSeen,
+    ...s.parentId ? { parentId: s.parentId } : {},
+    ...s.agent ? { agent: s.agent } : {},
+    ...s.model ? { model: s.model } : {},
+    ...s.usage.current ? {
+      measurement: {
+        tokens: s.usage.current.tokens,
+        at: s.usage.current.at,
+        model: s.usage.current.model,
+        provenance: s.usage.current.provenance,
+        confidence: s.usage.current.confidence,
+        scope: s.usage.current.scope,
+        ...s.usage.current.requestId ? { requestId: s.usage.current.requestId } : {}
+      }
+    } : {},
+    ...s.limits ? {
+      limits: {
+        context: s.limits.context,
+        output: s.limits.output,
+        ...s.limits.input === undefined ? {} : { input: s.limits.input }
+      }
+    } : {},
+    ...d.budget === undefined ? {} : { capacityTokens: d.budget },
+    ...config.safety.outputReserveTokens === undefined && !s.limits ? {} : {
+      outputReserveTokens: config.safety.outputReserveTokens ?? s.limits?.output ?? 0
+    },
+    peakTokens: s.usage.peak,
+    policy: {
+      id: p.policy,
+      configured: { type: p.threshold.type, value: p.threshold.value },
+      ...d.threshold === undefined ? {} : { triggerTokens: d.threshold },
+      comparison: p.threshold.type === "remaining" ? ">" : ">=",
+      reason: d.reason,
+      crossed: d.crossed
+    },
+    compaction: {
+      phase: c.phase,
+      count: c.count,
+      armed: c.armed,
+      ...c.blockedReason ? { blockedReason: c.blockedReason } : {},
+      ...c.lastAttempt === undefined ? {} : {
+        lastAttempt: c.lastAttempt,
+        cooldownUntil: c.lastAttempt + config.safety.cooldownMs
+      },
+      ...c.lastCompleted === undefined ? {} : { lastCompleted: c.lastCompleted }
+    },
+    ...s.usage.cumulative ? {
+      cumulative: {
+        input: s.usage.cumulative.input,
+        output: s.usage.cumulative.output,
+        reasoning: s.usage.cumulative.reasoning,
+        cache: {
+          read: s.usage.cumulative.cache.read,
+          write: s.usage.cumulative.cache.write
+        }
+      }
+    } : {},
+    cumulativeScope: s.usage.cumulativeScope,
+    lastObservedActive: s.active
+  });
+}
+
+class SnapshotStore {
+  config;
+  sessions;
+  now;
+  performanceSnapshot;
+  epoch;
+  sequence = 0;
+  revision = 0;
+  rows = new Map;
+  deleted = new Set;
+  dirty = new Set;
+  listeners = new Set;
+  healthKey = "";
+  reasons = new Set;
+  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() {
+    return {
+      enabled: this.config.enabled,
+      mode: this.config.mode,
+      enforcement: !this.config.enabled ? "disabled" : this.reasons.has("event-stream-gap") || this.reasons.has("persistence-unavailable") ? "suspended" : this.config.mode === "observe" ? "observing" : "available",
+      reasons: [...this.reasons].sort(),
+      staleMs: this.config.safety.staleMs,
+      maxSessions: this.config.safety.maxSessions
+    };
+  }
+  degrade(reason) {
+    this.reasons.add(reason);
+  }
+  recover(reason) {
+    this.reasons.delete(reason);
+  }
+  mark(id) {
+    if (this.dirty.size < this.config.safety.maxSessions)
+      this.dirty.add(id);
+  }
+  markAll() {
+    for (const id of this.sessions().keys())
+      this.mark(id);
+  }
+  remove(id) {
+    if (this.rows.has(id))
+      this.deleted.add(id);
+  }
+  listen(fn) {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+  batch(upserts, removed) {
+    return {
+      schemaVersion: 1,
+      epoch: this.epoch,
+      sequence: this.sequence,
+      generatedAt: this.now(),
+      health: this.health(),
+      upserts,
+      removed
+    };
+  }
+  flush() {
+    const upserts = [], removed = [];
+    const resident = this.sessions();
+    for (const [id, old] of this.rows)
+      if (old.measurement && old.policy.reason !== "stale-usage" && this.now() - old.measurement.at > this.config.safety.staleMs)
+        this.mark(id);
+    for (const id of resident.keys())
+      if (!this.rows.has(id))
+        this.mark(id);
+    for (const id of this.dirty) {
+      const s = resident.get(id);
+      if (!s)
+        continue;
+      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;
+      const row2 = freezeSnapshot({ ...next, revision: ++this.revision });
+      this.rows.set(id, row2);
+      upserts.push(row2);
+    }
+    for (const id of this.rows.keys())
+      if (!resident.has(id)) {
+        this.rows.delete(id);
+        removed.push({
+          sessionId: id,
+          revision: ++this.revision,
+          reason: this.deleted.has(id) ? "deleted" : "evicted"
+        });
+      }
+    this.deleted.clear();
+    this.dirty.clear();
+    const healthKey = JSON.stringify(this.health()), changed = healthKey !== this.healthKey;
+    this.healthKey = healthKey;
+    const changes = [
+      ...upserts.map((row2) => ({ kind: "upsert", row: row2 })),
+      ...removed.map((row2) => ({ kind: "remove", row: row2 }))
+    ];
+    for (let i = 0;i < Math.max(changes.length, changed ? 1 : 0); i += 128) {
+      this.sequence++;
+      const slice = changes.slice(i, i + 128);
+      const batch = this.batch(slice.flatMap((change) => change.kind === "upsert" ? [change.row] : []), slice.flatMap((change) => change.kind === "remove" ? [change.row] : []));
+      for (const fn of this.listeners) {
+        try {
+          fn(structuredClone(batch));
+        } catch {
+        }
+      }
+    }
+  }
+  read(input) {
+    this.flush();
+    const ids = [...new Set(input.sessionIds)];
+    return structuredClone({
+      ...this.batch(ids.flatMap((id) => {
+        const row2 = this.rows.get(id);
+        return row2 ? [row2] : [];
+      }), []),
+      unavailable: ids.filter((id) => !this.rows.has(id)).map((sessionId) => ({ sessionId, reason: "not-monitored" }))
+    });
+  }
+}
+function freezeSnapshot(row2) {
+  if (row2.performance)
+    Object.freeze(row2.performance);
+  if (row2.measurement)
+    Object.freeze(row2.measurement);
+  if (row2.limits)
+    Object.freeze(row2.limits);
+  Object.freeze(row2.policy.configured);
+  Object.freeze(row2.policy);
+  Object.freeze(row2.compaction);
+  if (row2.cumulative) {
+    Object.freeze(row2.cumulative.cache);
+    Object.freeze(row2.cumulative);
+  }
+  return Object.freeze(row2);
+}
+
+// src/snapshotserver.ts
+async function serveSnapshots(rpc, store, performance = false) {
+  if (!rpc)
+    return () => {
+    };
+  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 raw = store.read(input);
+      const result = performance ? raw : stripPerformance(raw);
+      if (!resultValid(result))
+        throw new Error("Invalid snapshot projection");
+      return result;
+    }
+  });
+  const queue = [];
+  const capacity = Math.ceil(store.health().maxSessions / 128) + 2;
+  let busy = false, stopped = false;
+  let retry;
+  let pending = Promise.resolve();
+  function send() {
+    if (busy || stopped || !queue.length)
+      return;
+    const batch = queue[0];
+    if (!batch)
+      return;
+    busy = true;
+    pending = registration.events.emit("changed", { ...batch }).then(() => {
+      if (queue[0] === batch)
+        queue.shift();
+    }, () => {
+      if (!stopped)
+        scheduleRetry();
+    }).finally(() => {
+      busy = false;
+      if (!retry && !stopped)
+        send();
+    });
+  }
+  const unlisten = store.listen((raw) => {
+    const batch = performance ? raw : stripPerformance(raw);
+    if (!batchValid(batch))
+      return;
+    queue.push(batch);
+    if (queue.length > capacity)
+      queue.shift();
+    if (!retry)
+      send();
+  });
+  const retrySend = () => {
+    retry = undefined;
+    send();
+  };
+  function scheduleRetry() {
+    retry = setTimeout(retrySend, 100);
+  }
+  return async () => {
+    stopped = true;
+    unlisten();
+    clearTimeout(retry);
+    queue.length = 0;
+    await pending;
+    await registration.dispose();
+  };
+}
+
+// src/config.ts
+function object2(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${path}: expected object`);
+  return value;
+}
+function keys(o, allowed, path) {
+  for (const key of Object.keys(o))
+    if (!allowed.includes(key))
+      throw new Error(`${path}.${key}: unknown option`);
+}
+function number(v, fallback, path, min = 0) {
+  if (v === undefined)
+    return fallback;
+  if (typeof v !== "number" || !Number.isSafeInteger(v) || v < min)
+    throw new Error(`${path}: expected integer >= ${min}`);
+  return v;
+}
+function bool(v, fallback, path) {
+  if (v === undefined)
+    return fallback;
+  if (typeof v !== "boolean")
+    throw new Error(`${path}: expected boolean`);
+  return v;
+}
+function selector(v, path) {
+  if (typeof v !== "string" || !v.length || v.length > 256 || /[\[\]{}\\]/.test(v))
+    throw new Error(`${path}: expected selector (only * and ? wildcards)`);
+  return v;
+}
+function threshold(v, path) {
+  const o = object2(v, path);
+  keys(o, ["type", "value"], path);
+  if (o.type !== "tokens" && o.type !== "ratio" && o.type !== "remaining")
+    throw new Error(`${path}.type: invalid threshold`);
+  if (typeof o.value !== "number" || !Number.isFinite(o.value) || o.value <= 0 || (o.type === "ratio" ? o.value > 1 : !Number.isSafeInteger(o.value)))
+    throw new Error(`${path}.value: invalid threshold`);
+  return { type: o.type, value: o.value };
+}
+function parseConfig(value = {}) {
+  const o = object2(value, "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");
+  keys(d, ["threshold"], "defaults");
+  const s = object2(o.safety ?? {}, "safety");
+  keys(s, [
+    "cooldownMs",
+    "minReclaimTokens",
+    "maxConsecutiveFailures",
+    "pendingTimeoutMs",
+    "staleMs",
+    "maxSessions",
+    "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("/")))
+    throw new Error("telemetry.path: expected absolute path");
+  if (o.policies !== undefined && (!Array.isArray(o.policies) || o.policies.length > 256))
+    throw new Error("policies: expected array of at most 256 policies");
+  const policies = (o.policies ?? []).map((v, i) => {
+    const p = object2(v, `policies[${i}]`);
+    keys(p, ["match", "threshold"], `policies[${i}]`);
+    const m = object2(p.match, "match");
+    keys(m, ["role", "model", "agent"], "match");
+    if (!Object.keys(m).length)
+      throw new Error("match: at least one selector required");
+    const match = {};
+    if (m.role !== undefined) {
+      if (m.role !== "main" && m.role !== "subagent")
+        throw new Error("match.role: invalid");
+      match.role = m.role;
+    }
+    if (m.model !== undefined) {
+      match.model = selector(m.model, "match.model");
+      if (!match.model.includes("/"))
+        throw new Error("match.model: use provider/model");
+    }
+    if (m.agent !== undefined)
+      match.agent = selector(m.agent, "match.agent");
+    return { match, threshold: threshold(p.threshold, "threshold") };
+  });
+  const config = {
+    enabled: bool(o.enabled, true, "enabled"),
+    mode: o.mode ?? "observe",
+    defaults: {
+      threshold: threshold(d.threshold ?? { type: "tokens", value: 131072 }, "defaults.threshold")
+    },
+    policies,
+    safety: {
+      cooldownMs: number(s.cooldownMs, 60000, "cooldownMs"),
+      minReclaimTokens: number(s.minReclaimTokens, 8192, "minReclaimTokens"),
+      maxConsecutiveFailures: number(s.maxConsecutiveFailures, 3, "maxConsecutiveFailures", 1),
+      pendingTimeoutMs: number(s.pendingTimeoutMs, 300000, "pendingTimeoutMs", 1),
+      staleMs: number(s.staleMs, 300000, "staleMs", 1),
+      maxSessions: number(s.maxSessions, 1024, "maxSessions", 1),
+      sessionTtlMs: number(s.sessionTtlMs, 86400000, "sessionTtlMs", 1),
+      ...s.outputReserveTokens === undefined ? {} : {
+        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"),
+      maxBytes: number(t.maxBytes, 8 * 1024 * 1024, "maxBytes", 4096),
+      ...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");
+  }
+  if (!config.telemetry.jsonl && config.telemetry.path)
+    throw new Error("telemetry.path requires jsonl");
+  return config;
+}
+
+// src/types.ts
+class NoopBudgetController {
+  evaluate(_input) {
+    return { type: "continue" };
+  }
+}
+
+// src/monitor.ts
+function promptTokens(t) {
+  const fields = [t.input, t.output, t.reasoning, t.cache.read, t.cache.write];
+  if (fields.some((x) => !Number.isSafeInteger(x) || x < 0))
+    return;
+  const total = t.input + t.cache.read + t.cache.write;
+  return total > 0 && Number.isSafeInteger(total) ? total : undefined;
+}
+
+class ContextMonitor {
+  config;
+  scheduler;
+  sink;
+  now;
+  budget;
+  sessions = new Map;
+  resolver;
+  constructor(config, scheduler, sink, now = Date.now, budget = new NoopBudgetController) {
+    this.config = config;
+    this.scheduler = scheduler;
+    this.sink = sink;
+    this.now = now;
+    this.budget = budget;
+    this.resolver = new PolicyResolver(config);
+  }
+  touch(identity, limits) {
+    let s = this.sessions.get(identity.sessionId);
+    if (!s) {
+      this.cleanup();
+      if (this.sessions.size >= this.config.safety.maxSessions) {
+        this.sink.emit({
+          time: this.now(),
+          type: "capacity-exceeded",
+          detail: "New session not monitored; increase safety.maxSessions"
+        });
+        return;
+      }
+      s = {
+        ...identity,
+        lastSeen: this.now(),
+        sequence: -1,
+        active: false,
+        usage: {
+          cumulativeScope: "unknown",
+          peak: 0,
+          modelRequests: 0,
+          toolCalls: 0,
+          countersSince: this.now()
+        },
+        compaction: {
+          phase: "idle",
+          armed: true,
+          count: 0,
+          failures: 0,
+          consecutiveFailures: 0
+        }
+      };
+      this.sessions.set(identity.sessionId, s);
+    }
+    if (identity.model && identity.model !== s.model) {
+      delete s.usage.current;
+      delete s.limits;
+    }
+    Object.assign(s, identity);
+    s.lastSeen = this.now();
+    if (limits)
+      s.limits = { ...limits };
+    return s;
+  }
+  accept(s, sequence) {
+    if (sequence <= s.sequence)
+      return false;
+    s.sequence = sequence;
+    s.lastSeen = this.now();
+    return true;
+  }
+  measure(s, measurement2, cumulative) {
+    if (s.usage.current && measurement2.at < s.usage.current.at)
+      return;
+    s.usage.current = measurement2;
+    s.usage.peak = Math.max(s.usage.peak, measurement2.tokens);
+    if (cumulative) {
+      s.usage.cumulative = cumulative;
+      s.usage.cumulativeScope = "session";
+    }
+    this.evaluate(s);
+  }
+  evaluate(s) {
+    const p = this.resolver.resolve(s);
+    s.decision = evaluateThreshold(p.threshold, s.usage.current, s.limits, this.now(), this.config.safety.staleMs, s.model, p.policy, this.config.safety.outputReserveTokens);
+    this.scheduler.measured(s);
+    const action = this.budget.evaluate({
+      session: s,
+      now: this.now(),
+      elapsedMs: this.now() - s.usage.countersSince
+    });
+    if (action.type !== "continue")
+      this.sink.emit({
+        time: this.now(),
+        type: `budget.${action.type}`,
+        session: s,
+        detail: "Advisory extension; only context policies execute in this release"
+      });
+    this.sink.emit({
+      time: this.now(),
+      type: this.config.mode === "observe" && s.decision.crossed ? "would-compact" : "usage",
+      session: s
+    });
+    this.scheduler.consider(s);
+  }
+  remove(id) {
+    const s = this.sessions.get(id);
+    if (s) {
+      s.active = false;
+      s.compaction.phase = "blocked";
+      s.compaction.blockedReason = "session-removed";
+      this.sink.emit({ time: this.now(), type: "session.removed", session: s });
+      this.sessions.delete(id);
+    }
+  }
+  cleanup() {
+    for (const [id, s] of this.sessions) {
+      this.scheduler.tick(s);
+      if (!s.active && ["idle", "blocked"].includes(s.compaction.phase) && this.now() - s.lastSeen > this.config.safety.sessionTtlMs)
+        this.remove(id);
+    }
+  }
+  async getUsage(id) {
+    const s = this.sessions.get(id);
+    if (!s)
+      throw new Error("Unknown session");
+    return structuredClone(s.usage);
+  }
+}
+
+// src/scheduler.ts
+class CompactionScheduler {
+  config;
+  port;
+  sink;
+  now;
+  id;
+  stopped = false;
+  jobs = new Set;
+  constructor(config, port, sink, now = Date.now, id = () => `msg_${crypto.randomUUID().replaceAll("-", "")}`) {
+    this.config = config;
+    this.port = port;
+    this.sink = sink;
+    this.now = now;
+    this.id = id;
+  }
+  consider(s) {
+    if (this.stopped || !this.config.enabled || this.config.mode !== "enforce" || !s.decision?.crossed)
+      return;
+    const c = s.compaction, time = this.now();
+    if (c.phase !== "idle" || !c.armed || c.consecutiveFailures >= this.config.safety.maxConsecutiveFailures)
+      return;
+    if (c.lastAttempt !== undefined && time - c.lastAttempt < this.config.safety.cooldownMs)
+      return;
+    c.phase = "requesting";
+    c.lastAttempt = time;
+    c.requestId = this.id();
+    c.before = s.usage.current?.tokens;
+    c.beforeModel = s.model;
+    c.beforeConfidence = s.usage.current?.confidence;
+    c.armed = false;
+    this.emit("compaction.requesting", s);
+    const requestId = c.requestId;
+    const job = new Promise((resolve) => setTimeout(resolve, 0)).then(async () => {
+      if (this.stopped || c.phase !== "requesting")
+        return;
+      try {
+        await this.port.compact(s.sessionId, requestId);
+        if (c.phase === "requesting")
+          c.phase = "accepted";
+        this.emit("compaction.accepted", s);
+      } catch {
+        if (c.phase === "requesting") {
+          c.phase = "uncertain";
+          c.blockedReason = "admission-outcome-unknown";
+          c.failures++;
+          c.consecutiveFailures++;
+          this.emit("compaction.uncertain", s);
+        }
+      }
+    }).finally(() => this.jobs.delete(job));
+    this.jobs.add(job);
+  }
+  lifecycle(s, event, at) {
+    const c = s.compaction;
+    if (event === "started") {
+      if (c.phase !== "requesting" && c.phase !== "accepted") {
+        c.before = s.usage.current?.tokens;
+        c.beforeModel = s.model;
+        c.beforeConfidence = s.usage.current?.confidence;
+      }
+      c.phase = "running";
+      c.armed = false;
+      c.lastAttempt = at;
+    } else if (event === "ended") {
+      c.phase = "awaiting-measurement";
+      c.lastCompleted = at;
+      c.count++;
+      c.consecutiveFailures = 0;
+      delete s.usage.current;
+    } else {
+      c.failures++;
+      c.consecutiveFailures++;
+      c.lastAttempt = at;
+      c.armed = true;
+      c.phase = c.consecutiveFailures >= this.config.safety.maxConsecutiveFailures ? "blocked" : "idle";
+      c.blockedReason = "compaction-failed";
+      delete s.usage.current;
+    }
+    this.emit(`compaction.${event}`, s);
+  }
+  measured(s) {
+    const c = s.compaction, m = s.usage.current;
+    if (!m)
+      return;
+    if (c.phase === "awaiting-measurement") {
+      if (m.confidence !== "reported" || m.at < (c.lastCompleted ?? 0))
+        return;
+      if (c.beforeModel !== m.model || c.before === undefined || c.beforeConfidence !== "reported") {
+        c.phase = "blocked";
+        c.blockedReason = "reclaim-unverifiable";
+      } else if (c.before - m.tokens < this.config.safety.minReclaimTokens) {
+        c.phase = "blocked";
+        c.blockedReason = "insufficient-reclaim";
+      } else {
+        c.phase = "idle";
+        c.armed = false;
+        delete c.blockedReason;
+      }
+    }
+    const resetAt = (s.decision?.threshold ?? 0) - this.config.safety.minReclaimTokens;
+    if (m.tokens <= resetAt && (c.phase === "idle" || c.phase === "blocked" && c.blockedReason !== "compaction-failed")) {
+      c.armed = true;
+      c.phase = "idle";
+      delete c.blockedReason;
+    }
+  }
+  tick(s) {
+    const c = s.compaction;
+    if ((c.phase === "accepted" || c.phase === "running" || c.phase === "requesting") && this.now() - (c.lastAttempt ?? this.now()) > this.config.safety.pendingTimeoutMs) {
+      c.phase = "uncertain";
+      c.blockedReason = "completion-event-timeout";
+      this.emit("compaction.uncertain", s);
+    }
+  }
+  emit(type, session) {
+    this.sink.emit({ type, time: this.now(), session });
+  }
+  async flush() {
+    await Promise.all(this.jobs);
+  }
+  stop() {
+    this.stopped = true;
+  }
+}
+
+// src/estimate.ts
+function estimate(value, maxChars = 2000000) {
+  let chars = 0, nodes = 0;
+  function visit(v, depth) {
+    if (++nodes > 1e5 || depth > 30 || chars > maxChars)
+      return false;
+    if (typeof v === "string")
+      chars += v.length;
+    else if (typeof v === "number" || typeof v === "boolean")
+      chars += 8;
+    else if (Array.isArray(v)) {
+      for (const item of v)
+        if (!visit(item, depth + 1))
+          return false;
+    } else if (v && typeof v === "object") {
+      if (ArrayBuffer.isView(v) || v instanceof ArrayBuffer)
+        return false;
+      for (const [key, item] of Object.entries(v)) {
+        chars += key.length + 4;
+        if (!visit(item, depth + 1))
+          return false;
+      }
+    }
+    return chars <= maxChars;
+  }
+  return visit(value, 0) ? Math.ceil(chars / 3) : undefined;
+}
+
+// src/recovery.ts
+function record2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function nonnegative2(v) {
+  return typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
+}
+function decodeRecovery(v, max) {
+  if (!Array.isArray(v))
+    return [];
+  const result = [];
+  for (const item of v.slice(0, max)) {
+    if (!record2(item) || typeof item.sessionId !== "string" || !record2(item.compaction))
+      continue;
+    const c = item.compaction;
+    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 = {
+      phase,
+      armed: c.armed,
+      count: c.count,
+      failures: c.failures,
+      consecutiveFailures: c.consecutiveFailures
+    };
+    if (nonnegative2(c.lastAttempt))
+      compaction.lastAttempt = c.lastAttempt;
+    if (nonnegative2(c.lastCompleted))
+      compaction.lastCompleted = c.lastCompleted;
+    if (typeof c.requestId === "string")
+      compaction.requestId = c.requestId;
+    if (typeof c.blockedReason === "string")
+      compaction.blockedReason = c.blockedReason;
+    if (phase === "uncertain")
+      compaction.blockedReason = "restart-needs-lifecycle-evidence";
+    result.push({
+      sessionId: item.sessionId,
+      compaction,
+      ...nonnegative2(item.sequence) ? { sequence: item.sequence } : {}
+    });
+  }
+  return result;
+}
+function encodeRecovery(rows) {
+  return rows.map(({ sessionId, compaction: c, sequence }) => ({
+    sessionId,
+    sequence: sequence ?? -1,
+    compaction: {
+      requestId: c.requestId ?? null,
+      phase: c.phase,
+      armed: c.armed,
+      count: c.count,
+      failures: c.failures,
+      consecutiveFailures: c.consecutiveFailures,
+      lastAttempt: c.lastAttempt ?? null,
+      lastCompleted: c.lastCompleted ?? null,
+      blockedReason: c.blockedReason ?? null
+    }
+  }));
+}
+
+// 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/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 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) {
+      try {
+        if (event.session)
+          store.mark(event.session.sessionId);
+        if ([
+          "event-stream-gap",
+          "persistence-unavailable",
+          "capacity-exceeded",
+          "model-metadata-unavailable"
+        ].includes(event.type)) {
+          if (event.type === "event-stream-gap")
+            store.degrade("event-stream-gap");
+          if (event.type === "persistence-unavailable")
+            store.degrade("persistence-unavailable");
+          if (event.type === "capacity-exceeded")
+            store.degrade("capacity-exceeded");
+          if (event.type === "model-metadata-unavailable")
+            store.degrade("model-metadata-unavailable");
+        }
+      } catch {
+      }
+      diagnostics.emit(event);
+    }
+  };
+  const stopV1 = await serveSnapshots(ctx.rpc, store).catch(() => {
+    diagnostics.emit({
+      time: Date.now(),
+      type: "snapshot-service-unavailable"
+    });
+    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 () => {
+      await stopSnapshots();
+      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();
+  const serialized = (task) => {
+    const next = work.then(task);
+    work = next.catch(() => {
+    });
+    return next;
+  };
+  const requests = new Map;
+  const saved = await ctx.storage.get("safety").catch(() => {
+    persistenceHealthy = false;
+    return;
+  });
+  const decoded = decodeRecovery(saved, config.safety.maxSessions);
+  if (saved !== undefined && (!Array.isArray(saved) || saved.length !== decoded.length)) {
+    persistenceHealthy = false;
+  }
+  const recoveries = new Map(decoded.map((s) => [s.sessionId, s]));
+  let persistChain = Promise.resolve();
+  const persist = () => {
+    if (!persistenceHealthy)
+      return persistChain;
+    const rows = [...monitor?.sessions.values() ?? []].filter((s) => s.compaction.lastAttempt !== undefined || s.compaction.phase !== "idle").map((s) => ({
+      sessionId: s.sessionId,
+      sequence: s.sequence,
+      compaction: { ...s.compaction }
+    }));
+    const missing = [...recoveries].filter(([id]) => !monitor?.sessions.has(id)).map(([, recovery]) => recovery);
+    const data = encodeRecovery([...rows, ...missing].slice(0, config.safety.maxSessions));
+    persistChain = persistChain.then(() => ctx.storage.set("safety", data)).catch(() => {
+      persistenceHealthy = false;
+      sink.emit({ time: Date.now(), type: "persistence-unavailable" });
+    });
+    return persistChain;
+  };
+  const scheduler = new CompactionScheduler(config, {
+    compact: async (sessionId, id) => {
+      if (!persistenceHealthy)
+        throw new Error("Safety persistence unavailable");
+      await persist();
+      if (!monitor?.sessions.has(sessionId) || monitor?.sessions.get(sessionId)?.compaction.phase !== "requesting")
+        throw new Error("Session no longer requesting");
+      if (!persistenceHealthy || stopped)
+        throw new Error("Safety persistence unavailable");
+      await ctx.session.compact({ sessionID: sessionId, id, delivery: "steer" }, { signal: controller.signal });
+    }
+  }, sink);
+  monitor = new ContextMonitor(config, scheduler, sink);
+  const activeMonitor = monitor;
+  let models = new Map, modelAt = 0, modelRetryAt = 0, modelRetryMs = 1000;
+  async function refreshModels(retryMissing = false) {
+    const now = Date.now();
+    if (now - modelAt < 60000 && (!retryMissing || now < modelRetryAt))
+      return;
+    modelAt = now;
+    modelRetryAt = now + modelRetryMs;
+    modelRetryMs = Math.min(60000, modelRetryMs * 2);
+    try {
+      models = new Map((await ctx.model.list(undefined, { signal: controller.signal })).data.map((m) => [`${m.providerID}/${m.id}`, { ...m.limit }]));
+      let missing = false;
+      for (const s of activeMonitor.sessions.values()) {
+        const limits = s.model ? models.get(s.model) : undefined;
+        if (limits)
+          s.limits = { ...limits };
+        else {
+          delete s.limits;
+          missing ||= s.model !== undefined;
+        }
+        store.mark(s.sessionId);
+      }
+      if (!missing)
+        modelRetryMs = 1000;
+      store.recover("model-metadata-unavailable");
+    } catch {
+      models.clear();
+      for (const s of activeMonitor.sessions.values()) {
+        delete s.limits;
+        store.mark(s.sessionId);
+      }
+      sink.emit({ time: Date.now(), type: "model-metadata-unavailable" });
+    }
+  }
+  async function discover(sessionId) {
+    const info = await ctx.session.get({ sessionID: sessionId }, { signal: controller.signal });
+    if (info.location.directory !== ctx.location.directory)
+      return;
+    const identity = {
+      sessionId,
+      ...info.parentID ? { parentId: info.parentID } : {},
+      ...info.agent ? { agent: info.agent } : {},
+      ...info.model ? { model: `${info.model.providerID}/${info.model.id}` } : {}
+    };
+    if (!activeMonitor.sessions.has(sessionId) && !recoveries.has(sessionId) && activeMonitor.sessions.size + recoveries.size >= config.safety.maxSessions) {
+      sink.emit({ time: Date.now(), type: "capacity-exceeded" });
+      return;
+    }
+    const s = activeMonitor.touch(identity, identity.model ? models.get(identity.model) : undefined);
+    if (s) {
+      if (!identity.model || !models.has(identity.model))
+        delete s.limits;
+      const recovery = recoveries.get(sessionId);
+      if (recovery) {
+        s.compaction = recovery.compaction;
+        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);
+    }
+    return s;
+  }
+  const pending = new Map;
+  let draining = false;
+  async function drainHooks() {
+    if (stopped)
+      return;
+    try {
+      await refreshModels([...activeMonitor.sessions.values()].some((s) => s.model !== undefined && !models.has(s.model)));
+      for (const [id, h] of pending) {
+        pending.delete(id);
+        try {
+          const s = activeMonitor.sessions.get(id) ?? await discover(id);
+          if (!s)
+            continue;
+          if (h.at <= Math.max(s.lastExecutionEnd ?? 0, s.compaction.lastCompleted ?? 0))
+            continue;
+          activeMonitor.touch(h.identity, h.identity.model ? models.get(h.identity.model) : undefined);
+          s.active = true;
+          if ((!s.usage.current || Date.now() - s.usage.current.at > config.safety.staleMs) && h.estimate !== undefined && s.model)
+            activeMonitor.measure(s, {
+              tokens: h.estimate,
+              at: h.at,
+              model: s.model,
+              confidence: "approximate",
+              provenance: "serialized-estimate",
+              scope: "prepared-request"
+            });
+          else
+            activeMonitor.evaluate(s);
+        } catch {
+          sink.emit({ time: Date.now(), type: "session-observation-failed" });
+        }
+      }
+    } finally {
+      draining = false;
+    }
+  }
+  const hook = (event) => {
+    if (stopped)
+      return;
+    const id = event.sessionID, model = `${event.model.providerID}/${event.model.id}`, current = activeMonitor.sessions.get(id)?.usage.current;
+    if (!pending.has(id) && pending.size >= config.safety.maxSessions) {
+      sink.emit({ time: Date.now(), type: "hook-capacity-exceeded" });
+      return;
+    }
+    const fallback = !current || current.model !== model || Date.now() - current.at > config.safety.staleMs;
+    const tokens = fallback ? estimate([event.system, event.messages, event.tools]) : undefined;
+    pending.set(id, {
+      identity: { sessionId: id, agent: event.agent, model },
+      at: Date.now(),
+      ...tokens === undefined ? {} : { estimate: tokens }
+    });
+  };
+  const registrations = [];
+  try {
+    registrations.push(await ctx.session.hook("context", hook));
+    registrations.push(await ctx.session.hook("compaction", (e) => {
+      const s = activeMonitor.sessions.get(e.sessionID);
+      if (s) {
+        s.compaction.phase = "running";
+        s.compaction.armed = false;
+        store.mark(s.sessionId);
+      }
+    }));
+  } 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",
+    "session.compaction.ended",
+    "session.compaction.failed",
+    "session.execution.started",
+    "session.execution.succeeded",
+    "session.execution.failed",
+    "session.execution.interrupted",
+    "session.deleted",
+    "session.model.selected",
+    "session.agent.selected",
+    "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);
+      recoveries.delete(id);
+      await persist();
+      return;
+    }
+    await refreshModels();
+    const s = await discover(id);
+    if (!s)
+      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,
+          model: `${event.data.model.providerID}/${event.data.model.id}`
+        }, models.get(`${event.data.model.providerID}/${event.data.model.id}`));
+        requests.set(id, {
+          id: event.data.assistantMessageID,
+          model: `${event.data.model.providerID}/${event.data.model.id}`
+        });
+        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)
+          activeMonitor.measure(s, {
+            tokens,
+            at: event.created,
+            requestId: event.data.assistantMessageID,
+            model: request.model,
+            confidence: "reported",
+            provenance: "provider-normalized",
+            scope: "completed-request"
+          });
+        else {
+          delete s.usage.current;
+          sink.emit({
+            time: Date.now(),
+            type: "provider-usage-unavailable",
+            session: s
+          });
+        }
+        break;
+      }
+      case "session.compaction.started":
+        scheduler.lifecycle(s, "started", event.created);
+        break;
+      case "session.compaction.ended":
+        scheduler.lifecycle(s, "ended", event.created);
+        break;
+      case "session.compaction.failed":
+        scheduler.lifecycle(s, "failed", event.created);
+        break;
+      case "session.execution.started":
+        s.active = true;
+        break;
+      case "session.execution.succeeded":
+      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":
+        s.usage.toolCalls++;
+        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;
+    draining = true;
+    serialized(async () => {
+      await drainHooks();
+      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);
+    }).catch(() => {
+      draining = false;
+    });
+  }, 100);
+  timer.unref();
+  const events = (async () => {
+    while (!stopped) {
+      try {
+        for await (const event of ctx.event.subscribe({
+          signal: controller.signal
+        })) {
+          if (stopped)
+            break;
+          await serialized(() => handle(event));
+        }
+      } 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",
+          detail: "Enforcement suspended until reload; measurements may be incomplete"
+        });
+        scheduler.stop();
+        await new Promise((resolve) => {
+          const finish = () => {
+            clearTimeout(t);
+            controller.signal.removeEventListener("abort", finish);
+            resolve();
+          };
+          const t = setTimeout(finish, 1000);
+          controller.signal.addEventListener("abort", finish, { once: true });
+        });
+      }
+    }
+  })();
+  if (!persistenceHealthy)
+    sink.emit({
+      time: Date.now(),
+      type: "persistence-unavailable",
+      detail: "Enforcement disabled; safety state could not be read"
+    });
+  if (!injectedSink)
+    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}; metrics=${history.path}`
+  });
+  return async () => {
+    stopped = true;
+    scheduler.stop();
+    controller.abort();
+    clearInterval(timer);
+    pending.clear();
+    const disposed = await Promise.allSettled(registrations.map((r) => r.dispose()));
+    if (disposed.some((r) => r.status === "rejected"))
+      sink.emit({ time: Date.now(), type: "registration-cleanup-failed" });
+    await events;
+    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: (ctx, injectedSink) => setup({ ...ctx, historyRpc: ctx.rpc }, injectedSink)
+});
+export {
+  src_default as default
+};