@cesarus777/opencode-cgp 0.0.0-stage → 0.2.1

package/dist/core.js

@@ -0,0 +1,1247 @@
+// @bun
+// src/types.ts
+class NoopBudgetController {
+  evaluate(_input) {
+    return { type: "continue" };
+  }
+}
+// src/config.ts
+function object(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 = object(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 = object(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 = object(o.defaults ?? {}, "defaults");
+  keys(d, ["threshold"], "defaults");
+  const s = object(o.safety ?? {}, "safety");
+  keys(s, [
+    "cooldownMs",
+    "minReclaimTokens",
+    "maxConsecutiveFailures",
+    "pendingTimeoutMs",
+    "staleMs",
+    "maxSessions",
+    "sessionTtlMs",
+    "outputReserveTokens"
+  ], "safety");
+  const metrics = object(o.metrics ?? {}, "metrics");
+  keys(metrics, ["enabled", "sampleIntervalMs", "rollingWindowMs"], "metrics");
+  const history = object(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 = object(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 = object(v, `policies[${i}]`);
+    keys(p, ["match", "threshold"], `policies[${i}]`);
+    const m = object(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/policy.ts
+function glob(pattern, text) {
+  let p = 0, t = 0, star = -1, retry = 0;
+  while (t < text.length) {
+    if (pattern[p] === "?" || pattern[p] === text[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 valid = (n) => n !== undefined && Number.isFinite(n) && n > 0;
+  const output = reserve ?? (valid(limits.output) ? limits.output : undefined);
+  const contextBudget = valid(limits.context) && output !== undefined ? Math.max(0, limits.context - output) : undefined;
+  if (valid(limits.input))
+    return contextBudget === undefined ? limits.input : Math.min(limits.input, contextBudget);
+  return contextBudget;
+}
+function evaluateThreshold(threshold2, measurement, limits, now, staleMs, model, policy, reserve) {
+  const budget = usableInput(limits, reserve);
+  const base = {
+    crossed: false,
+    reason: "missing-usage",
+    policy,
+    ...budget === undefined ? {} : { budget }
+  };
+  const trigger = threshold2.type === "tokens" ? threshold2.value : budget === undefined ? undefined : threshold2.type === "ratio" ? Math.ceil(budget * threshold2.value) : budget - threshold2.value;
+  if (trigger !== undefined)
+    base.threshold = trigger;
+  if (!measurement)
+    return base;
+  if (model !== measurement.model)
+    return { ...base, reason: "model-changed" };
+  if (!Number.isFinite(measurement.tokens) || measurement.tokens < 0)
+    return { ...base, reason: "invalid-usage" };
+  if (now - measurement.at > staleMs || measurement.at > now)
+    return { ...base, reason: "stale-usage" };
+  if (budget !== undefined && budget > 0)
+    base.percentage = measurement.tokens / budget * 100;
+  if (trigger === undefined)
+    return { ...base, reason: "missing-model-budget" };
+  if (trigger <= 0)
+    return { ...base, reason: "incompatible-model-budget" };
+  const crossed = threshold2.type === "remaining" ? measurement.tokens > trigger : measurement.tokens >= trigger;
+  return {
+    ...base,
+    crossed,
+    reason: crossed ? "threshold-crossed" : "below-threshold"
+  };
+}
+// 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, measurement, cumulative) {
+    if (s.usage.current && measurement.at < s.usage.current.at)
+      return;
+    s.usage.current = measurement;
+    s.usage.peak = Math.max(s.usage.peak, measurement.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/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 row = freezeSnapshot({ ...next, revision: ++this.revision });
+      this.rows.set(id, row);
+      upserts.push(row);
+    }
+    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((row) => ({ kind: "upsert", row })),
+      ...removed.map((row) => ({ kind: "remove", row }))
+    ];
+    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 row = this.rows.get(id);
+        return row ? [row] : [];
+      }), []),
+      unavailable: ids.filter((id) => !this.rows.has(id)).map((sessionId) => ({ sessionId, reason: "not-monitored" }))
+    });
+  }
+}
+function freezeSnapshot(row) {
+  if (row.performance)
+    Object.freeze(row.performance);
+  if (row.measurement)
+    Object.freeze(row.measurement);
+  if (row.limits)
+    Object.freeze(row.limits);
+  Object.freeze(row.policy.configured);
+  Object.freeze(row.policy);
+  Object.freeze(row.compaction);
+  if (row.cumulative) {
+    Object.freeze(row.cumulative.cache);
+    Object.freeze(row.cumulative);
+  }
+  return Object.freeze(row);
+}
+// src/family.ts
+function metric(snapshot, now, staleMs) {
+  const m = snapshot?.measurement;
+  const freshness = !m ? "missing" : m.model !== snapshot?.model || m.at > now ? "invalid" : now - m.at > staleMs ? "stale" : "fresh";
+  const t = snapshot?.policy.triggerTokens;
+  const valid = freshness === "fresh" && m !== undefined;
+  const pressureRatio = valid && t !== undefined && t > 0 ? m.tokens / t : undefined;
+  const crossed = valid && t !== undefined && t > 0 && (snapshot?.policy.comparison === ">" ? m.tokens > t : m.tokens >= t);
+  return {
+    freshness,
+    pressure: pressureRatio === undefined ? "unknown" : crossed ? "crossed" : pressureRatio >= 0.9 ? "near" : "normal",
+    ...pressureRatio === undefined ? {} : { pressureRatio },
+    ...valid && snapshot?.capacityTokens && snapshot.capacityTokens > 0 ? { utilizationPercent: m.tokens / snapshot.capacityTokens * 100 } : {},
+    ...valid && t !== undefined ? { triggerDeltaTokens: t - m.tokens } : {}
+  };
+}
+function familyRows(nodes, snapshots, current, now, staleMs, expanded = new Set, limit = 1024, timing, stableOrder = []) {
+  const byId = new Map(nodes.map((n) => [n.sessionId, n]));
+  const children = new Map;
+  for (const n of byId.values()) {
+    const parent = n.parentId && byId.has(n.parentId) ? n.parentId : "";
+    const list = children.get(parent) ?? [];
+    list.push(n);
+    children.set(parent, list);
+  }
+  const metrics = new Map([...byId.keys()].map((id) => [
+    id,
+    metric(snapshots.get(id), timing?.(id).now ?? now, timing?.(id).staleMs ?? staleMs)
+  ]));
+  const protectedIds = new Set;
+  let ancestor = byId.get(current);
+  while (ancestor && !protectedIds.has(ancestor.sessionId)) {
+    protectedIds.add(ancestor.sessionId);
+    ancestor = ancestor.parentId ? byId.get(ancestor.parentId) : undefined;
+  }
+  const scores = new Map, sensitive = new Map, sizes = new Map;
+  const calculate = (n, seen) => {
+    if (seen.has(n.sessionId))
+      return -1;
+    if (scores.has(n.sessionId))
+      return scores.get(n.sessionId) ?? -1;
+    const path = new Set(seen).add(n.sessionId), m = metrics.get(n.sessionId);
+    let score = m?.pressureRatio ?? -1, size = 1;
+    let keep = protectedIds.has(n.sessionId) || n.status === "running" || m?.pressure === "crossed" || ["blocked", "uncertain"].includes(snapshots.get(n.sessionId)?.compaction.phase ?? "");
+    for (const child of children.get(n.sessionId) ?? []) {
+      score = Math.max(score, calculate(child, path));
+      size += sizes.get(child.sessionId) ?? 0;
+      keep ||= sensitive.get(child.sessionId) ?? false;
+    }
+    scores.set(n.sessionId, score);
+    sizes.set(n.sessionId, size);
+    sensitive.set(n.sessionId, keep);
+    return score;
+  };
+  for (const n of byId.values())
+    calculate(n, new Set);
+  const visited = new Set, rows = [];
+  const visit = (n, depth) => {
+    if (visited.has(n.sessionId) || rows.length >= limit || depth > 64)
+      return;
+    visited.add(n.sessionId);
+    const snapshot = snapshots.get(n.sessionId), m = metrics.get(n.sessionId) ?? metric(undefined, now, staleMs);
+    const collapsed = n.status === "completed" && !sensitive.get(n.sessionId) && !expanded.has(n.sessionId);
+    rows.push({
+      node: n,
+      ...snapshot ? { snapshot } : {},
+      depth,
+      current: n.sessionId === current,
+      ...m,
+      hidden: collapsed ? (sizes.get(n.sessionId) ?? 1) - 1 : 0
+    });
+    if (collapsed) {
+      const pending = [...children.get(n.sessionId) ?? []];
+      while (pending.length) {
+        const child = pending.pop();
+        if (!child || visited.has(child.sessionId))
+          continue;
+        visited.add(child.sessionId);
+        pending.push(...children.get(child.sessionId) ?? []);
+      }
+    }
+    if (!collapsed)
+      for (const child of sorted(children.get(n.sessionId) ?? []))
+        visit(child, depth + 1);
+  };
+  const ranks = new Map(stableOrder.map((id, i) => [id, i]));
+  const sorted = (items) => [...items].sort((a, b) => (stableOrder.length ? (ranks.get(a.sessionId) ?? Infinity) - (ranks.get(b.sessionId) ?? Infinity) : 0) || (scores.get(b.sessionId) ?? -1) - (scores.get(a.sessionId) ?? -1) || a.sessionId.localeCompare(b.sessionId));
+  for (const n of sorted(children.get("") ?? []))
+    visit(n, 0);
+  for (const n of byId.values())
+    if (!visited.has(n.sessionId) && rows.length < limit)
+      visit(n, 0);
+  return rows;
+}
+function executionStatus(known, nativeRunning, evidence) {
+  if (nativeRunning || evidence.startedAt !== undefined && evidence.startedAt > (evidence.terminalAt ?? -1))
+    return "running";
+  if (evidence.outcome && (evidence.terminalAt ?? -1) >= (evidence.startedAt ?? -1))
+    return evidence.outcome === "succeeded" ? "completed" : evidence.outcome === "failed" ? "failed" : "unknown";
+  return known ? "idle" : "unknown";
+}
+// src/performance.ts
+var valid = (n) => Number.isFinite(n) && n >= 0;
+var rate = (tokens, ms) => valid(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 row = this.rows.get(id);
+    if (!row) {
+      if (this.rows.size >= this.maxSessions)
+        return;
+      row = {
+        observedSince: this.now(),
+        created,
+        partial: cumulative !== 0,
+        output: 0,
+        duration: 0,
+        completed: 0,
+        sequence: -1
+      };
+      this.rows.set(id, row);
+    }
+    if (valid(created))
+      row.created = created;
+    if (cumulative !== undefined && valid(cumulative))
+      row.cumulative = cumulative;
+  }
+  accept(id, sequence) {
+    const row = this.rows.get(id);
+    if (!row || sequence <= row.sequence)
+      return false;
+    row.sequence = sequence;
+    return true;
+  }
+  start(id, requestId, agent, model, started) {
+    const row = this.rows.get(id);
+    if (!row || !valid(started))
+      return;
+    const old = row.request;
+    if (old?.id === requestId && old.started === started)
+      return;
+    if (old && !old.settled)
+      row.partial = true;
+    row.request = {
+      id: requestId,
+      agent,
+      model,
+      started,
+      chars: 0,
+      settled: false,
+      events: new Set,
+      buckets: new Map
+    };
+  }
+  delta(id, requestId, eventId, at, characters) {
+    const row = this.rows.get(id), r = row?.request;
+    if (!row || !r || r.id !== requestId || r.settled || r.ended !== undefined || !valid(at) || at < r.started || !valid(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 row = this.rows.get(id), r = row?.request;
+    if (!row || !r || r.id !== requestId || r.settled || r.ended !== undefined)
+      return;
+    if (!valid(at) || at <= r.started || r.first !== undefined && at < r.first) {
+      row.partial = true;
+      return;
+    }
+    r.ended = at;
+  }
+  settle(id, requestId, tokens) {
+    const row = this.rows.get(id), r = row?.request;
+    if (!row)
+      return;
+    if (!r || r.id !== requestId) {
+      row.partial = true;
+      return;
+    }
+    if (r.settled)
+      return;
+    r.settled = true;
+    if (tokens !== undefined && valid(tokens))
+      r.output = tokens;
+    if (tokens !== undefined && valid(tokens) && r.ended !== undefined) {
+      row.output += tokens;
+      row.duration += r.ended - r.started;
+      row.completed++;
+    } else
+      row.partial = true;
+    const snapshot = this.snapshot(id);
+    if (snapshot) {
+      const { latestRequestTps: _previousRate, ...current } = snapshot;
+      row.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, row] of this.rows) {
+      if (id !== undefined && key !== id)
+        continue;
+      row.partial = true;
+      delete row.request;
+    }
+  }
+  prune(r, at) {
+    for (const time of r.buckets.keys())
+      if (time < at - this.windowMs)
+        r.buckets.delete(time);
+  }
+  snapshot(id) {
+    const row = this.rows.get(id);
+    if (!row)
+      return;
+    const at = this.now(), r = row.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(row.output, row.duration);
+    const averageSessionTps = row.cumulative === undefined ? undefined : rate(row.cumulative, at - row.created);
+    return {
+      observedSince: row.observedSince,
+      at,
+      sessionCreatedAt: row.created,
+      ...row.cumulative === undefined ? {} : { sessionOutputTokens: row.cumulative },
+      status: active ? r.first === undefined ? "waiting" : "streaming" : !r && row.partial ? "unavailable" : "idle",
+      partial: row.partial,
+      ...live === undefined || !r && row.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 }
+      } : row.latest ? {
+        ...row.latest.ttftMs === undefined ? {} : { ttftMs: row.latest.ttftMs }
+      } : {},
+      ...row.latest?.latestRequestTps === undefined ? {} : { latestRequestTps: row.latest.latestRequestTps },
+      estimatedOutputTokens: r ? r.chars / 4 : 0,
+      modelOutputTokens: row.output,
+      modelDurationMs: row.duration,
+      completedRequests: row.completed,
+      tokenSource: r && !r.settled ? "estimated" : row.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
+  };
+}
+export {
+  usableInput,
+  promptTokens,
+  project,
+  parseConfig,
+  outputTokens,
+  metric,
+  glob,
+  familyRows,
+  executionStatus,
+  evaluateThreshold,
+  estimate,
+  downsamplePoints,
+  buildChartData,
+  SnapshotStore,
+  PolicyResolver,
+  PerformanceTracker,
+  NoopBudgetController,
+  ContextMonitor,
+  CompactionScheduler
+};