@cesarus777/opencode-cgp 0.0.0-stage → 0.1.0

package/dist/core.js

@@ -0,0 +1,826 @@
+// @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"], "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 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")
+      }
+    },
+    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 } : {}
+    }
+  };
+  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;
+  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()) {
+    this.config = config;
+    this.sessions = sessions;
+    this.now = now;
+    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 next = project(s, this.config, this.now());
+      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.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";
+}
+export {
+  usableInput,
+  promptTokens,
+  project,
+  parseConfig,
+  metric,
+  glob,
+  familyRows,
+  executionStatus,
+  evaluateThreshold,
+  estimate,
+  SnapshotStore,
+  PolicyResolver,
+  NoopBudgetController,
+  ContextMonitor,
+  CompactionScheduler
+};