@cesarus777/opencode-cgp 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1507 @@
+// @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 } }
+});
+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/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 valid2 = (n) => n !== undefined && Number.isFinite(n) && n > 0;
+  const output = reserve ?? (valid2(limits.output) ? limits.output : undefined);
+  const contextBudget = valid2(limits.context) && output !== undefined ? Math.max(0, limits.context - output) : undefined;
+  if (valid2(limits.input))
+    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;
+  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 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.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) {
+  if (!rpc)
+    return () => {
+    };
+  const registration = await rpc.register(monitorRpc, {
+    read: async (input) => {
+      if (!isRead(input))
+        throw new Error("Invalid snapshot request");
+      const result = store.read(input);
+      if (!isResult(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((batch) => {
+    if (!isBatch(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"], "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 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")
+      }
+    },
+    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/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 nonnegative(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 (!nonnegative(c.count) || !nonnegative(c.failures) || !nonnegative(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 (nonnegative(c.lastAttempt))
+      compaction.lastAttempt = c.lastAttempt;
+    if (nonnegative(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,
+      ...nonnegative(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, open, rename, stat } from "fs/promises";
+import { dirname, join } from "path";
+import { createHash } from "crypto";
+function defaultPath(directory) {
+  const key = createHash("sha256").update(directory).digest("hex").slice(0, 16);
+  return join("/home/julius/.local/state", "opencode-context-guard", `${key}.jsonl`);
+}
+
+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 mkdir(dirname(this.path), { recursive: true, mode: 448 });
+        this.bytes = await stat(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 open(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;
+  }
+}
+
+// src/adapter.ts
+async function setup(ctx, injectedSink) {
+  const config = parseConfig(ctx.options);
+  const disk = new JsonlTelemetrySink(config.telemetry.path ?? defaultPath(ctx.location.directory), config.telemetry);
+  const diagnostics = injectedSink ?? disk;
+  const store = new SnapshotStore(config, () => monitor?.sessions ?? new Map);
+  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 stopSnapshots = await serveSnapshots(ctx.rpc, store).catch(() => {
+    diagnostics.emit({
+      time: Date.now(),
+      type: "snapshot-service-unavailable"
+    });
+    return () => {
+    };
+  });
+  if (!config.enabled) {
+    sink.emit({ time: Date.now(), type: "disabled" });
+    return async () => {
+      await stopSnapshots();
+      await disk.flush();
+    };
+  }
+  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);
+      }
+      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 stopSnapshots();
+    throw error;
+  }
+  const relevant = new Set([
+    "session.created",
+    "session.step.started",
+    "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 (!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") {
+      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;
+    switch (event.type) {
+      case "session.step.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.ended":
+      case "session.step.failed": {
+        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;
+        s.lastExecutionEnd = event.created;
+        break;
+      case "session.tool.called":
+        s.usage.toolCalls++;
+        break;
+    }
+    sink.emit({ time: Date.now(), type: "session-state", session: s });
+    await persist();
+  }
+  const timer = setInterval(() => {
+    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 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) {
+        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}`);
+  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}`
+  });
+  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 stopSnapshots();
+    await disk.flush();
+  };
+}
+
+// src/index.ts
+var src_default = Plugin.define({ id: "context-guard", setup });
+export {
+  src_default as default
+};