@vikrant82/opencode-cache-keepalive 0.1.6 → 0.2.0

package/dist/index.js

@@ -25,66 +25,99 @@ function configureClientAuth(client) {
 // lib/config.ts
 var DEFAULTS = {
   enabled: true,
-  intervalMs: 27e4,
-  // 4.5 min — below the shortest supported cache TTL
-  windowMs: 33e5,
-  // 55 min — the Copilot Claude write/read break-even
-  injectSystemInstruction: true,
-  pingToken: "~",
-  revertPing: true,
+  intervals: { claude: 285e3, gpt: 168e4 },
+  hosts: ["githubcopilot.com"],
+  cacheReadFactor: 0.1,
+  missFactor: 1,
+  maxReplaysPerGap: "auto",
   includeChildSessions: false,
-  debug: false,
-  providerAllowlist: ["copilot"],
-  modelAllowlist: ["claude", "anthropic", "sonnet", "opus", "haiku", "gpt"]
+  replayTimeoutMs: 6e4,
+  maxStoredBytes: 67108864,
+  debug: false
 };
-function getConfig(options) {
-  const o = options ?? {};
+var DEPRECATED = [
+  "intervalMs",
+  "intervalSeconds",
+  "windowMs",
+  "windowMinutes",
+  "revertPing",
+  "pingToken",
+  "injectSystemInstruction",
+  "providerAllowlist",
+  "modelAllowlist",
+  "claudeBusyWarm",
+  "claudeBusyWarmIntervalMs",
+  "claudeBusyWarmWindowMs"
+];
+var warnedDeprecated = /* @__PURE__ */ new Set();
+function getConfig(options, warn = () => {
+}) {
+  const option = options ?? {};
   const env = process.env;
+  for (const key of DEPRECATED) {
+    if (key in option && !warnedDeprecated.has(key)) {
+      warnedDeprecated.add(key);
+      warn(`deprecated option ${key} is ignored`);
+    }
+  }
+  const parseJson = (raw) => {
+    if (!raw) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  };
+  const intervals = objectOption(
+    option.intervals ?? parseJson(env.OPENCODE_KEEPALIVE_INTERVALS),
+    DEFAULTS.intervals
+  );
+  const hosts = listOption(
+    option.hosts ?? parseJson(env.OPENCODE_KEEPALIVE_HOSTS),
+    DEFAULTS.hosts
+  );
+  const maxRaw = option.maxReplaysPerGap ?? env.OPENCODE_KEEPALIVE_MAX_REPLAYS_PER_GAP;
+  const maxReplaysPerGap = maxRaw === "auto" ? "auto" : positiveNumber(maxRaw) !== void 0 ? positiveNumber(maxRaw) : DEFAULTS.maxReplaysPerGap;
   return {
-    enabled: boolOpt(o.enabled, env.OPENCODE_KEEPALIVE_ENABLED !== "false" && DEFAULTS.enabled),
-    intervalMs: durationOpt(
-      o.intervalMs,
-      o.intervalSeconds,
-      numEnv(env.OPENCODE_KEEPALIVE_INTERVAL_MS, DEFAULTS.intervalMs)
-    ),
-    windowMs: durationOpt(
-      o.windowMs,
-      o.windowMinutes ? Number(o.windowMinutes) * 60 : void 0,
-      numEnv(env.OPENCODE_KEEPALIVE_WINDOW_MS, DEFAULTS.windowMs)
+    enabled: boolOption(
+      option.enabled,
+      env.OPENCODE_KEEPALIVE_ENABLED === void 0 ? DEFAULTS.enabled : env.OPENCODE_KEEPALIVE_ENABLED !== "false"
     ),
-    injectSystemInstruction: boolOpt(
-      o.injectSystemInstruction,
-      DEFAULTS.injectSystemInstruction
+    intervals,
+    hosts,
+    cacheReadFactor: positiveNumber(option.cacheReadFactor ?? env.OPENCODE_KEEPALIVE_CACHE_READ_FACTOR) ?? DEFAULTS.cacheReadFactor,
+    missFactor: positiveNumber(option.missFactor ?? env.OPENCODE_KEEPALIVE_MISS_FACTOR) ?? DEFAULTS.missFactor,
+    maxReplaysPerGap,
+    includeChildSessions: boolOption(
+      option.includeChildSessions,
+      env.OPENCODE_KEEPALIVE_INCLUDE_CHILD_SESSIONS === "true" || DEFAULTS.includeChildSessions
     ),
-    pingToken: typeof o.pingToken === "string" && o.pingToken.length > 0 ? o.pingToken : DEFAULTS.pingToken,
-    revertPing: boolOpt(
-      o.revertPing,
-      env.OPENCODE_KEEPALIVE_REVERT_PING !== "false" && DEFAULTS.revertPing
-    ),
-    includeChildSessions: boolOpt(o.includeChildSessions, DEFAULTS.includeChildSessions),
-    debug: boolOpt(o.debug, env.OPENCODE_KEEPALIVE_DEBUG === "true"),
-    providerAllowlist: listOpt(o.providerAllowlist, DEFAULTS.providerAllowlist),
-    modelAllowlist: listOpt(o.modelAllowlist, DEFAULTS.modelAllowlist)
+    replayTimeoutMs: positiveNumber(option.replayTimeoutMs ?? env.OPENCODE_KEEPALIVE_REPLAY_TIMEOUT_MS) ?? DEFAULTS.replayTimeoutMs,
+    maxStoredBytes: positiveNumber(option.maxStoredBytes ?? env.OPENCODE_KEEPALIVE_MAX_STORED_BYTES) ?? DEFAULTS.maxStoredBytes,
+    debug: boolOption(option.debug, env.OPENCODE_KEEPALIVE_DEBUG === "true")
   };
 }
-function boolOpt(value, fallback) {
+function boolOption(value, fallback) {
   return typeof value === "boolean" ? value : fallback;
 }
-function listOpt(value, fallback) {
-  if (!Array.isArray(value)) return fallback;
-  const filtered = value.filter((item) => typeof item === "string");
-  return filtered.length > 0 ? filtered : fallback;
+function positiveNumber(value) {
+  const parsed = typeof value === "string" ? Number(value) : value;
+  return typeof parsed === "number" && Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
 }
-function durationOpt(ms, seconds, fallback) {
-  if (typeof ms === "number" && Number.isFinite(ms) && ms > 0) return ms;
-  if (typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0)
-    return seconds * 1e3;
-  return fallback;
+function objectOption(value, fallback) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return fallback;
+  const entries = Object.entries(value).flatMap(([key, interval]) => {
+    const parsed = positiveNumber(interval);
+    return parsed === void 0 ? [] : [[key.toLowerCase(), parsed]];
+  });
+  return entries.length ? Object.fromEntries(entries) : fallback;
 }
-function numEnv(raw, fallback) {
-  if (!raw) return fallback;
-  const value = Number(raw);
-  return Number.isFinite(value) && value > 0 ? value : fallback;
+function listOption(value, fallback) {
+  if (!Array.isArray(value)) return fallback;
+  const values = value.filter(
+    (item) => typeof item === "string" && item.length > 0
+  );
+  return values.length ? values : fallback;
 }
 
 // lib/control.ts
@@ -97,9 +130,14 @@ import { dirname } from "path";
 import { createHash } from "crypto";
 import { homedir } from "os";
 import { join } from "path";
-function stateFilePath(directory) {
-  const key = createHash("sha256").update(directory).digest("hex").slice(0, 16);
-  return join(stateDirectoryPath(), `state-${key}.json`);
+function stateDirectoryKey(directory) {
+  return createHash("sha256").update(directory).digest("hex").slice(0, 16);
+}
+function instanceStateFilePath(directory, pid, instanceId) {
+  return join(
+    stateDirectoryPath(),
+    `state-v2-${stateDirectoryKey(directory)}-${pid}-${instanceId}.json`
+  );
 }
 function stateDirectoryPath() {
   return join(
@@ -119,558 +157,971 @@ function logFilePath() {
 }
 
 // lib/control.ts
-var MIN_INTERVAL_MS = 6e4;
-var MAX_INTERVAL_MS = 24 * 36e5;
-function isValidInterval(ms) {
-  return typeof ms === "number" && Number.isFinite(ms) && ms >= MIN_INTERVAL_MS && ms <= MAX_INTERVAL_MS;
-}
-function readControl(directory) {
+var VERSION = 2;
+var MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+function readSessionControls(directory, now = Date.now()) {
   try {
     const value = JSON.parse(readFileSync(controlFilePath(directory), "utf8"));
-    if (value?.version !== 1 || typeof value.updatedAt !== "number") return void 0;
-    if (value.enabled !== void 0 && typeof value.enabled !== "boolean") return void 0;
-    return {
-      version: 1,
-      updatedAt: value.updatedAt,
-      ...typeof value.enabled === "boolean" ? { enabled: value.enabled } : {},
-      ...isValidInterval(value.intervalMs) ? { intervalMs: value.intervalMs } : {}
-    };
+    if (value.version !== VERSION || !value.sessions || typeof value.sessions !== "object")
+      return { version: VERSION, sessions: {} };
+    const sessions = {};
+    for (const [id, raw] of Object.entries(value.sessions)) {
+      if (!raw || typeof raw !== "object" || typeof raw.enabled !== "boolean" || typeof raw.updatedAt !== "number" || raw.updatedAt < now - MAX_AGE_MS)
+        continue;
+      sessions[id] = {
+        enabled: raw.enabled,
+        updatedAt: raw.updatedAt
+      };
+    }
+    return { version: VERSION, sessions };
   } catch {
-    return void 0;
+    return { version: VERSION, sessions: {} };
   }
 }
 var updateQueue = Promise.resolve();
 
-// lib/model.ts
-function isEligibleModel(config, providerID, modelID) {
-  if (!providerID || !modelID) return false;
-  const provider = providerID.toLowerCase();
-  const model = modelID.toLowerCase();
-  const providerOk = config.providerAllowlist.some((needle) => provider.includes(needle));
-  const modelOk = config.modelAllowlist.some((needle) => model.includes(needle));
-  return providerOk && modelOk;
-}
-
-// lib/keepalive.ts
-var TICK_MS = 15e3;
-var JITTER_MS = 15e3;
-var CONTROL_POLL_MS = 1e3;
-var STATUS_POLL_MS = 2e3;
-var PING_STATUS_GRACE_MS = 5e3;
-var COLD_AFTER_INTERVALS = 2;
-var MESSAGE_LOOKUP_LIMIT = 50;
-var KeepaliveEngine = class {
-  constructor(client, config, store, logger, directory) {
+// lib/replay-warmer.ts
+var STATE_KEY = /* @__PURE__ */ Symbol.for("opencode-cache-keepalive.replay-warmer");
+var RETRY_MS = 1e4;
+var ReplayWarmer = class {
+  constructor(client, config, sink, logger, directory, now = Date.now) {
     this.client = client;
     this.config = config;
-    this.store = store;
+    this.sink = sink;
     this.logger = logger;
     this.directory = directory;
-    const control = readControl(directory);
-    this.enabled = control?.enabled ?? config.enabled;
-    this.intervalOverride = control?.intervalMs;
-    this.controlUpdatedAt = control?.updatedAt ?? 0;
-    this.store.setEnabled(this.enabled);
-    this.store.setIntervalMs(this.intervalMs);
+    this.now = now;
   }
   client;
   config;
-  store;
+  sink;
   logger;
   directory;
-  timer;
+  now;
+  runtime;
   controlTimer;
-  statusTimer;
-  controlUpdatedAt = 0;
-  reconcilingStatus = false;
-  enabled;
-  intervalOverride;
-  /** Effective ping interval: the runtime override from the control file, else config. */
-  get intervalMs() {
-    return this.intervalOverride ?? this.config.intervalMs;
-  }
+  enabled = false;
   start() {
-    if (this.timer) return;
-    this.timer = setInterval(() => void this.tick(), TICK_MS);
-    this.controlTimer = setInterval(() => this.pollControl(), CONTROL_POLL_MS);
-    this.statusTimer = setInterval(() => void this.reconcileStatus(), STATUS_POLL_MS);
-    this.store.persist();
-    this.logger.info(
-      `started (${this.enabled ? "enabled" : "disabled"}, interval=${Math.round(this.intervalMs / 1e3)}s, window=${Math.round(this.config.windowMs / 6e4)}m)`
-    );
+    if (this.runtime) return;
+    const runtime = getRuntime(this.now);
+    this.enabled = this.config.enabled;
+    runtime.instances.set(this, {
+      enabled: this.enabled,
+      effective: /* @__PURE__ */ new Map(),
+      directory: this.directory,
+      controls: new Map(
+        Object.entries(readSessionControls(this.directory, this.now()).sessions).map(
+          ([id, value]) => [id, value.enabled]
+        )
+      ),
+      hosts: new Set(this.config.hosts.map((host) => host.toLowerCase())),
+      config: this.config,
+      sink: this.sink
+    });
+    runtime.maxStoredBytes = Math.min(runtime.maxStoredBytes, this.config.maxStoredBytes);
+    for (const host of this.config.hosts) runtime.hosts.add(host.toLowerCase());
+    runtime.instancesSet.add(this);
+    this.runtime = runtime;
+    if (!runtime.pruneTimer) {
+      runtime.pruneTimer = setInterval(() => pruneOrphanSessions(runtime), 6e4);
+    }
+    if (runtime.instancesSet.size === 1) {
+      globalThis.fetch = ((input, init) => {
+        let bodySource;
+        let rejection;
+        let shouldRecord = false;
+        try {
+          rejection = cheapEligibilityRejection(runtime, input, init);
+          if (rejection) {
+            if (isCopilotRequest(input))
+              runtime.instancesSet.values().next().value?.debugRecordRejected(rejection);
+          } else if (!rejection) {
+            shouldRecord = true;
+            if (isReplayRequest(input, init) && input instanceof Request && init?.body === void 0) {
+              bodySource = input.clone().text();
+              void bodySource.catch(() => {
+              });
+            }
+          }
+        } catch {
+        }
+        const result = runtime.originalFetch(input, init);
+        if (shouldRecord) {
+          queueMicrotask(() => {
+            void recordRequest(runtime, input, init, bodySource).catch(() => {
+            });
+          });
+        }
+        return result;
+      });
+    }
+    this.controlTimer = setInterval(() => this.syncControl(), 1e3);
   }
-  stop() {
-    if (!this.timer) return;
-    clearInterval(this.timer);
-    this.timer = void 0;
+  dispose() {
     if (this.controlTimer) clearInterval(this.controlTimer);
     this.controlTimer = void 0;
-    if (this.statusTimer) clearInterval(this.statusTimer);
-    this.statusTimer = void 0;
-  }
-  /**
-   * True while a ping turn owns the session, so tool calls must be blocked. Becomes
-   * false as soon as a real user message joins the in-flight ping run: the rest of
-   * that run is real work and needs its tools.
-   */
-  shouldBlockTools(sessionID) {
-    const s = this.store.get(sessionID);
-    return !!s?.warming && !s.ping?.interrupted;
-  }
-  async onEvent(event) {
-    const type = event?.type;
-    if (!type) return;
-    if (type === "session.deleted") {
-      const id = event.properties?.sessionID ?? event.properties?.info?.id;
-      if (id) {
-        this.store.remove(id);
-        this.store.persist();
+    const runtime = this.runtime;
+    this.runtime = void 0;
+    if (!runtime) return;
+    runtime.instancesSet.delete(this);
+    runtime.instances.delete(this);
+    for (const [id, owner] of runtime.owners) {
+      if (owner !== this) continue;
+      const session = runtime.sessions.get(id);
+      if (session) {
+        this.clearTimerFrom(session);
+        session.controller?.abort();
+        runtime.storedBytes = Math.max(
+          0,
+          runtime.storedBytes - bodyBytes(session.request.body)
+        );
+        session.request.body = "";
+      }
+      runtime.owners.delete(id);
+      runtime.sessions.delete(id);
+    }
+    if (runtime.instancesSet.size === 0) {
+      if (runtime.pruneTimer) clearInterval(runtime.pruneTimer);
+      globalThis.fetch = runtime.originalFetch;
+      for (const [id, session] of runtime.sessions) {
+        this.clearTimerFrom(session);
+        session.controller?.abort();
+        runtime.sessions.delete(id);
+      }
+      delete globalThis[STATE_KEY];
+    }
+  }
+  onEvent(event) {
+    const runtime = this.runtime;
+    if (!runtime) return;
+    const props = event?.properties ?? {};
+    const id = props.sessionID ?? props.info?.id ?? props.part?.sessionID;
+    const info = props.info ?? props.session;
+    if (event?.type === "session.created" && typeof info?.id === "string" && info.parentID)
+      runtime.childSessions.add(info.id);
+    if (event?.type === "session.deleted" && typeof id === "string")
+      runtime.childSessions.delete(id);
+    if (typeof id !== "string") return;
+    if (event?.type !== "session.deleted" && !this.sessionEnabled(id)) {
+      const disabled = runtime.sessions.get(id);
+      if (disabled && runtime.owners.get(id) === this) {
+        this.disableSession(runtime, id, disabled);
+      } else if (!disabled && this.config.enabled && this.runtime?.instances.get(this)?.controls.get(id) === false) {
+        runtime.owners.set(id, this);
+        this.sink.upsert({
+          sessionID: id,
+          updatedAt: this.now(),
+          enabled: false,
+          model: "",
+          api: "messages",
+          state: "off",
+          gapId: 0,
+          gapReplays: 0,
+          cap: this.cap,
+          nextReplayAt: null,
+          sessionReplays: 0,
+          avoidedTokens: 0,
+          resumeHits: 0,
+          resumeCount: 0
+        });
       }
       return;
     }
-    if (type === "message.part.updated") {
-      const part = event.properties?.part;
-      const sessionID = part?.sessionID ?? event.properties?.sessionID;
-      if (!sessionID) return;
-      const session = this.store.get(sessionID);
-      if (session?.warming) this.notePingRunPart(session, part);
+    if (!runtime.owners.has(id)) runtime.owners.set(id, this);
+    if (runtime.owners.get(id) !== this) return;
+    const session = runtime.sessions.get(id);
+    if (!session && event.type === "session.deleted") {
+      this.sink.remove(id);
       return;
     }
-    if (type === "message.updated") {
-      const info = event.properties?.info;
-      const sessionID = info?.sessionID ?? event.properties?.sessionID;
-      if (!sessionID) return;
-      const session = this.store.get(sessionID);
-      if (session?.warming) {
-        if (info?.role === "user") this.notePingRunUser(session, info);
-        return;
+    if (!session) return;
+    session.touchedAt = this.now();
+    const type = event.type;
+    if (type === "session.deleted") {
+      this.clearTimer(session);
+      session.controller?.abort();
+      runtime.sessions.delete(id);
+      runtime.storedBytes = Math.max(0, runtime.storedBytes - bodyBytes(session.request.body));
+      session.request.body = "";
+      this.sink.remove(id);
+      return;
+    }
+    if (type === "session.status" || type === "session.idle") {
+      const status = props.status?.type ?? "idle";
+      if (status === "idle") {
+        session.active = false;
+        session.busy = false;
+        session.runningTools.clear();
+        this.updateState(session, "idle");
+        this.schedule(id, session, session.request.sentAt + session.request.intervalMs);
+      } else if (status === "busy" || status === "running") {
+        session.active = session.runningTools.size === 0;
+        session.busy = session.runningTools.size > 0;
+        if (session.active) this.clearTimer(session);
+        this.updateState(session, session.active ? "active" : "busy");
       }
-      const eventAt = info?.time?.completed ?? info?.time?.created;
-      if (session?.lastPingAt && typeof eventAt === "number" && eventAt <= session.lastPingAt)
-        return;
-      if (info?.role === "user") {
-        const s = this.store.ensure(sessionID);
-        if (!isNewUserMessage(s, info)) return;
-        noteUserMessage(s, info);
-        s.busy = true;
-        s.active = false;
-        this.store.persist();
+      return;
+    }
+    if (type === "message.updated") {
+      const info2 = props.info ?? {};
+      const interactionType = String(info2.interactionType ?? props.interactionType ?? "");
+      if (/agent-session-(name|summary)-generation/i.test(interactionType)) return;
+      if (info2.role === "assistant" && (typeof info2.providerID === "string" && !info2.providerID.toLowerCase().replace(/[^a-z]/g, "").includes("copilot") || typeof info2.modelID === "string" && !info2.modelID.toLowerCase().includes(session.request.model.toLowerCase()) && !session.request.model.toLowerCase().includes(info2.modelID.toLowerCase()))) {
+        this.invalidateTarget(runtime, session, this.now());
         return;
       }
-      if (info?.role === "assistant" && typeof info?.time?.completed === "number") {
-        const s = this.store.ensure(sessionID);
-        s.lastResponseAt = info.time.completed;
-        this.store.persist();
+      if (info2.role === "assistant" && info2.time?.completed === void 0) {
+        session.active = true;
+        this.clearTimer(session);
+        this.updateState(session, "active");
       }
       return;
     }
-    if (type === "session.status") {
-      const sessionID = event.properties?.sessionID;
-      const status = event.properties?.status?.type;
-      if (!sessionID || !status) return;
-      const current = this.store.get(sessionID);
-      if (current?.warming || status !== "idle" && current?.lastPingAt && Date.now() - current.lastPingAt < PING_STATUS_GRACE_MS)
-        return;
-      if (status === "idle") {
-        await this.armWindow(sessionID);
-        return;
+    if (type !== "message.part.updated") return;
+    const part = props.part;
+    if (part?.type === "step-start") {
+      session.active = true;
+      this.clearTimer(session);
+      this.updateState(session, "active");
+    } else if (part?.type === "step-finish") {
+      session.active = false;
+      const cache = part.tokens?.cache ?? {};
+      const read = Number(cache.read ?? 0);
+      const prompt = Number(part.tokens?.input ?? 0) + read + Number(cache.write ?? 0);
+      const completedGap = session.pendingResume;
+      if (completedGap) {
+        const hit = read >= 0.9 * completedGap.promptPrev;
+        const avoidedTokens = hit ? completedGap.promptPrev : 0;
+        const resume = {
+          at: this.now(),
+          read,
+          promptPrev: completedGap.promptPrev,
+          hit,
+          replays: completedGap.replays,
+          avoidedTokens,
+          replayReadTokens: completedGap.replayReadTokens
+        };
+        session.entry.resume = resume;
+        session.entry.avoidedTokens += avoidedTokens;
+        session.entry.resumeCount++;
+        if (hit) session.entry.resumeHits++;
+        const totals = this.totals;
+        totals.avoidedTokens += avoidedTokens;
+        totals.replayReadTokens += completedGap.replayReadTokens;
+        if (hit) totals.resumeHits++;
+        else totals.resumeMisses++;
+        this.sink.setTotals(totals);
+        this.logger.info(
+          `resume session=${id} gap=${session.entry.gapId} hit=${hit} read=${read} prev=${completedGap.promptPrev} replays=${completedGap.replays} avoided=${avoidedTokens} replayRead=${completedGap.replayReadTokens}`
+        );
+        session.pendingResume = void 0;
       }
-      const s = this.store.ensure(sessionID);
-      s.busy = true;
-      s.active = false;
-      this.store.persist();
+      session.previousPrompt = prompt;
+      if (session.busy) this.updateState(session, "busy");
+      else {
+        this.updateState(session, "idle");
+        this.schedule(id, session, session.request.sentAt + session.request.intervalMs);
+      }
+    } else if (part?.type === "tool" && typeof part.callID === "string") {
+      if (part.state?.status === "running") session.runningTools.add(part.callID);
+      else if (["completed", "error"].includes(part.state?.status))
+        session.runningTools.delete(part.callID);
+      session.busy = session.runningTools.size > 0;
+      if (session.busy) {
+        session.active = false;
+        this.updateState(session, "busy");
+        this.schedule(id, session, session.request.sentAt + session.request.intervalMs);
+      } else if (!session.active) {
+        this.updateState(session, "idle");
+        this.schedule(id, session, session.request.sentAt + session.request.intervalMs);
+      }
+    }
+  }
+  totals = {
+    replays: 0,
+    avoidedTokens: 0,
+    replayReadTokens: 0,
+    resumeHits: 0,
+    resumeMisses: 0
+  };
+  /** @internal Called asynchronously by the process-wide recorder. */
+  debugRecordRejected(reason) {
+    this.logger.dbg(`record rejected reason=${reason}`);
+  }
+  /** @internal Called asynchronously by the process-wide recorder. */
+  async recordRequest(runtime, input, init, bodySource, selectedBody, selectedParsed) {
+    if (!this.runtime) return;
+    const request = input instanceof Request ? input : void 0;
+    const body = init?.body;
+    const method = (init?.method ?? request?.method ?? "GET").toUpperCase();
+    const url = input instanceof URL ? input.href : typeof input === "string" ? input : input.url;
+    let u;
+    try {
+      u = new URL(url);
+    } catch {
+      this.debugRecordRejected("invalid-url");
+      return;
+    }
+    if (!this.config.hosts.some((host) => {
+      const allowed = host.toLowerCase();
+      const hostname = u.hostname.toLowerCase();
+      return hostname === allowed || hostname.endsWith(`.${allowed}`);
+    })) {
+      if (isCopilotHost(u.hostname)) this.debugRecordRejected("host-not-allowed");
       return;
     }
-    if (type === "session.idle") {
-      const sessionID = event.properties?.sessionID;
-      if (!sessionID) return;
-      if (this.store.get(sessionID)?.warming) return;
-      await this.armWindow(sessionID);
-    }
-  }
-  /**
-   * Track a new user message observed while a ping is in flight. Event order alone
-   * cannot tell the ping's own message from a real prompt racing it, so messages are
-   * held until their text part arrives (see `notePingRunPart`). Any message seen
-   * before the ping is sent, or a second new message, is necessarily a real turn.
-   */
-  notePingRunUser(s, info) {
-    const ping = s.ping;
-    if (!ping || typeof info?.id !== "string") return;
-    const created = info?.time?.created;
-    if (typeof created === "number" && created < ping.startedAt) return;
-    if (info.id === ping.messageID || ping.pending.has(info.id)) return;
-    if (!ping.sent || ping.messageID) {
-      this.interruptPing(s, info);
+    const headers = new Headers(request?.headers);
+    if (init?.headers) new Headers(init.headers).forEach((v, k) => headers.set(k, v));
+    if (/agent-session-(name|summary)-generation/i.test(headers.get("X-Interaction-Type") ?? "")) {
+      if (isCopilotHost(u.hostname)) this.debugRecordRejected("utility-interaction");
       return;
     }
-    ping.pending.set(info.id, info);
-    if (ping.pending.size > 1) this.interruptPing(s);
-  }
-  /**
-   * Classify a pending user message by its first text part: the ping token marks
-   * the ping's own message; any other text is a real turn joining the ping run.
-   * opencode publishes a user message's parts right after the message itself, before
-   * the run reaches any tool call.
-   */
-  notePingRunPart(s, part) {
-    const ping = s.ping;
-    if (!ping || part?.type !== "text" || part?.synthetic) return;
-    const id = part?.messageID;
-    if (typeof id !== "string" || !ping.pending.has(id)) return;
-    const info = ping.pending.get(id);
-    ping.pending.delete(id);
-    if (!ping.messageID && String(part.text ?? "").trim() === this.config.pingToken) {
-      ping.messageID = id;
+    const sessionID = headers.get("X-Session-Id") ?? headers.get("x-session-affinity") ?? headers.get("X-Interaction-Id");
+    if (!sessionID) {
+      if (isCopilotHost(u.hostname)) this.debugRecordRejected("missing-session-id");
       return;
     }
-    this.interruptPing(s, info);
-  }
-  /** A real turn joined the in-flight ping: unblock tools and treat the session as busy. */
-  interruptPing(s, info) {
-    const ping = s.ping;
-    if (!ping) return;
-    if (!ping.interrupted) this.logger.dbg(`real turn joined ping ${short(s.sessionID)}`);
-    ping.interrupted = true;
-    if (info) noteUserMessage(s, info);
-    s.busy = true;
-    s.active = false;
-    this.store.persist();
-  }
-  async armWindow(sessionID) {
-    const s = this.store.ensure(sessionID);
-    if (s.active && !s.busy) return;
-    if (s.arming) return;
-    s.arming = true;
+    const owner = runtime.owners.get(sessionID);
+    if (owner && owner !== this) return;
+    if (!runtime.instances.has(this) || !this.enabled || this.sessionEnabled(sessionID) === false)
+      return;
+    let stringBody;
     try {
-      s.busy = false;
-      await this.resolveSession(s);
-      if (s.busy || !this.enabled || !s.eligible) {
-        s.active = false;
-        this.store.persist();
-        return;
+      stringBody = selectedBody !== void 0 ? selectedBody : typeof body === "string" ? body : body === void 0 && request && isReplayRequest(input, init) ? await (bodySource ?? request.clone().text()) : void 0;
+    } catch {
+      stringBody = void 0;
+    }
+    const instance = runtime.instances.get(this);
+    if (instance) {
+      instance.controls = new Map(
+        Object.entries(readSessionControls(this.directory, this.now()).sessions).map(
+          ([id, value]) => [id, value.enabled]
+        )
+      );
+    }
+    if (!this.runtime || !instance || runtime.owners.has(sessionID) && runtime.owners.get(sessionID) !== this || !this.enabled || this.sessionEnabled(sessionID) === false)
+      return;
+    const session = runtime.sessions.get(sessionID);
+    const sentAt = this.now();
+    if (session) session.touchedAt = sentAt;
+    if (session) {
+      if (session.entry.gapReplays > 0 && session.previousPrompt !== void 0) {
+        session.pendingResume = {
+          promptPrev: session.previousPrompt,
+          replays: session.entry.gapReplays,
+          replayReadTokens: session.replayReadTokens
+        };
       }
-      const now = Date.now();
-      if (!s.lastResponseAt || !this.cacheMayBeWarm(s, now)) {
-        s.active = false;
-        this.store.persist();
-        this.logger.dbg(`not armed ${short(sessionID)} \u2014 no recent real response`);
-        return;
+      this.startGap(session, sentAt);
+      session.entry.gapId++;
+    }
+    if (method !== "POST" || !apiFor(u.pathname)) {
+      if (session) this.invalidateTarget(runtime, session, sentAt);
+      return;
+    }
+    if (stringBody === void 0) {
+      if (isCopilotHost(u.hostname)) this.debugRecordRejected("unsupported-body-type");
+      if (session) {
+        this.invalidateTarget(runtime, session, sentAt);
       }
-      this.openWindow(s, now);
-      this.store.persist();
-      this.logger.dbg(`armed ${short(sessionID)} model=${s.modelLabel}`);
-    } finally {
-      s.arming = false;
-    }
-  }
-  /** Start a warm window anchored on the last real response and the last cache touch. */
-  openWindow(s, now) {
-    s.idleSince = now;
-    s.windowEndsAt = s.lastResponseAt + this.config.windowMs;
-    s.nextPingAt = Math.max(now, lastCacheTouch(s) + this.intervalMs);
-    s.pingsSent = 0;
-    s.lastPing = void 0;
-    s.active = true;
-  }
-  /** False once the cache has gone too long without a request to still be trusted warm. */
-  cacheMayBeWarm(s, now) {
-    const touch = lastCacheTouch(s);
-    return touch > 0 && now - touch <= COLD_AFTER_INTERVALS * this.intervalMs;
-  }
-  async tick() {
-    if (!this.enabled) return;
-    const now = Date.now();
-    for (const s of this.store.all()) {
-      if (!s.eligible || !s.active || s.busy || s.warming) continue;
-      if (now >= s.windowEndsAt) {
-        s.active = false;
-        this.store.persist();
-        this.logger.dbg(
-          `window closed ${short(s.sessionID)} after ${s.pingsSent} ping(s) \u2014 cache may cool`
-        );
-        continue;
+      return;
+    }
+    let parsed;
+    try {
+      if (stringBody === void 0) return;
+      parsed = selectedBody !== void 0 ? selectedParsed : JSON.parse(stringBody);
+    } catch {
+      if (isCopilotHost(u.hostname)) this.debugRecordRejected("invalid-json-body");
+      if (session) {
+        this.invalidateTarget(runtime, session, sentAt);
       }
-      if (now < s.nextPingAt) continue;
-      if (!this.cacheMayBeWarm(s, now)) {
-        s.active = false;
-        this.store.persist();
-        this.logger.dbg(
-          `window closed ${short(s.sessionID)} \u2014 ping overdue, cache presumed cold`
+      return;
+    }
+    this.recordEligible(runtime, sessionID, url, method, headers, stringBody, parsed, u);
+  }
+  recordEligible(runtime, sessionID, url, method, headers, stringBody, parsed, u) {
+    const child = runtime.childSessions.has(sessionID);
+    let session = runtime.sessions.get(sessionID);
+    const sentAt = this.now();
+    if (session) session.touchedAt = sentAt;
+    const eligible = this.sessionEnabled(sessionID) && typeof parsed?.model === "string" && (!child || this.config.includeChildSessions);
+    const model = typeof parsed?.model === "string" ? parsed.model.toLowerCase() : "";
+    const match = Object.entries(this.config.intervals).find(
+      ([key]) => model.includes(key.toLowerCase())
+    );
+    const api = apiFor(u.pathname);
+    if (!eligible || !match || !api) {
+      if (isCopilotHost(u.hostname))
+        this.debugRecordRejected(
+          !this.sessionEnabled(sessionID) ? "session-disabled" : child && !this.config.includeChildSessions ? "child-session" : typeof parsed?.model !== "string" ? "missing-model" : !match ? "model-not-configured" : "unsupported-path"
         );
-        continue;
+      if (session) {
+        this.invalidateTarget(runtime, session, sentAt);
       }
-      void this.firePing(s.sessionID);
+      return;
     }
-  }
-  async firePing(sessionID) {
-    const s = this.store.get(sessionID);
-    if (!s || s.warming || s.busy || !s.active) return;
-    const ping = {
-      startedAt: Date.now(),
-      sent: false,
-      pending: /* @__PURE__ */ new Map(),
-      interrupted: false
+    runtime.instances.get(this).effective.set(sessionID, true);
+    if (!runtime.loggedApis.has(api)) {
+      runtime.loggedApis.add(api);
+      this.logger.info(`record api=${api} host=${u.hostname}${u.pathname}`);
+    }
+    if (session) {
+      session.entry.gapReplays = 0;
+      session.entry.resume = void 0;
+      session.entry.lastReplay = void 0;
+      session.entry.stopReason = void 0;
+      session.entry.stopStatus = void 0;
+      session.entry.state = "active";
+      session.entry.enabled = true;
+      session.entry.model = parsed.model;
+      session.entry.api = api;
+      session.entry.nextReplayAt = null;
+      session.entry.updatedAt = sentAt;
+      session.active = true;
+      session.busy = false;
+      session.retries = 0;
+    }
+    runtime.owners.set(sessionID, this);
+    const oldSession = runtime.sessions.get(sessionID);
+    if (oldSession) {
+      runtime.storedBytes = Math.max(
+        0,
+        runtime.storedBytes - bodyBytes(oldSession.request.body)
+      );
+      oldSession.request = {
+        url,
+        method,
+        headers,
+        body: stringBody,
+        model: parsed.model,
+        api,
+        sentAt,
+        intervalMs: match[1]
+      };
+      runtime.storedBytes += bodyBytes(stringBody);
+      oldSession.child = child;
+      this.publish(oldSession);
+      this.enforceStoredBudget(runtime);
+      return;
+    }
+    session = {
+      request: {
+        url,
+        method,
+        headers,
+        body: stringBody,
+        model: parsed.model,
+        api,
+        sentAt,
+        intervalMs: match[1]
+      },
+      entry: {
+        sessionID,
+        updatedAt: sentAt,
+        enabled: true,
+        model: parsed.model,
+        api,
+        state: "active",
+        gapId: 1,
+        gapReplays: 0,
+        cap: this.cap,
+        nextReplayAt: null,
+        sessionReplays: 0,
+        avoidedTokens: 0,
+        resumeHits: 0,
+        resumeCount: 0
+      },
+      runningTools: /* @__PURE__ */ new Set(),
+      active: true,
+      busy: false,
+      realRequests: 1,
+      retries: 0,
+      child,
+      replayReadTokens: 0,
+      touchedAt: sentAt
     };
-    s.warming = true;
-    s.ping = ping;
-    this.store.persist();
+    runtime.sessions.set(sessionID, session);
+    runtime.owners.set(sessionID, this);
+    runtime.storedBytes += bodyBytes(stringBody);
+    this.publish(session);
+    this.enforceStoredBudget(runtime);
+  }
+  startGap(session, sentAt, model) {
+    const runtime = this.runtime;
+    session.controller?.abort();
+    session.controller = void 0;
+    this.clearTimer(session);
+    runtime.storedBytes = Math.max(0, runtime.storedBytes - bodyBytes(session.request.body));
+    session.request.body = "";
+    session.entry.gapReplays = 0;
+    session.entry.resume = void 0;
+    session.entry.lastReplay = void 0;
+    session.entry.stopReason = void 0;
+    session.entry.stopStatus = void 0;
+    session.entry.nextReplayAt = null;
+    session.replayReadTokens = 0;
+    session.entry.updatedAt = sentAt;
+    session.touchedAt = sentAt;
+    session.entry.model = model ?? session.entry.model;
+    session.active = false;
+    session.busy = false;
+    session.retries = 0;
+  }
+  invalidateTarget(runtime, session, at) {
+    this.clearTimer(session);
+    session.controller?.abort();
+    session.controller = void 0;
+    runtime.storedBytes = Math.max(0, runtime.storedBytes - bodyBytes(session.request.body));
+    session.request.body = "";
+    session.entry.state = this.sessionEnabled(session.entry.sessionID) ? "idle" : "off";
+    session.entry.nextReplayAt = null;
+    session.entry.updatedAt = at;
+    this.publish(session);
+  }
+  enforceStoredBudget(runtime) {
+    while (runtime.storedBytes > runtime.maxStoredBytes) {
+      const oldestID = [...runtime.sessions.keys()].filter((id) => runtime.sessions.get(id).request.body.length > 0).sort(
+        (a, b) => runtime.sessions.get(a).touchedAt - runtime.sessions.get(b).touchedAt
+      )[0];
+      if (!oldestID) break;
+      const session = runtime.sessions.get(oldestID);
+      this.clearTimer(session);
+      session.controller?.abort();
+      runtime.storedBytes -= bodyBytes(session.request.body);
+      session.request.body = "";
+      runtime.owners.get(oldestID)?.logger.info(`evict session=${oldestID}`);
+      session.entry.nextReplayAt = null;
+      session.entry.state = "idle";
+      session.entry.updatedAt = this.now();
+      runtime.owners.get(oldestID)?.publish(session);
+    }
+  }
+  get cap() {
+    return this.config.maxReplaysPerGap === "auto" ? Math.floor(
+      (this.config.missFactor - this.config.cacheReadFactor) / this.config.cacheReadFactor
+    ) : this.config.maxReplaysPerGap;
+  }
+  schedule(id, session, at) {
+    this.clearTimer(session);
+    if (this.runtime?.owners.get(id) !== this || !session.entry.enabled || session.active || session.entry.state === "stopped" || !session.request.body)
+      return;
+    session.entry.nextReplayAt = at;
+    this.publish(session);
+    this.logger.dbg(
+      `schedule session=${id} state=${session.busy ? "busy" : "idle"} next=${new Date(at).toISOString()}`
+    );
+    session.timer = setTimeout(
+      () => void this.replay(id, session),
+      Math.max(0, at - this.now())
+    );
+  }
+  async replay(id, session) {
+    const runtime = this.runtime;
+    if (!runtime || runtime.owners.get(id) !== this || !session.entry.enabled || runtime.sessions.get(id) !== session || session.active)
+      return;
+    const sentAt = this.now();
+    session.request.sentAt = sentAt;
+    session.touchedAt = sentAt;
+    const controller = new AbortController();
+    session.controller = controller;
+    session.entry.nextReplayAt = null;
+    this.updateState(session, session.busy ? "busy" : "idle");
+    let timeout;
+    let latencyMs = 0;
+    let status = 0;
     try {
-      if (!await this.isIdleOnServer(sessionID)) {
-        s.busy = true;
-        s.active = false;
-        this.logger.dbg(`ping ${short(sessionID)} skipped \u2014 session busy`);
+      const timeoutPromise = new Promise((_, reject) => {
+        timeout = setTimeout(() => {
+          controller.abort();
+          reject(new Error("timeout"));
+        }, this.config.replayTimeoutMs);
+      });
+      const response = await Promise.race([
+        runtime.originalFetch(session.request.url, {
+          method: session.request.method,
+          headers: new Headers(session.request.headers),
+          body: session.request.body,
+          signal: controller.signal
+        }),
+        timeoutPromise
+      ]);
+      status = response.status;
+      if ([400, 401, 403].includes(status)) {
+        session.entry.lastReplay = { at: sentAt, status, latencyMs: this.now() - sentAt };
+        this.logger.info(replayLogLine(session, session.entry.lastReplay, "http-status"));
+        this.stopSession(id, session, "rejected-4xx", status);
         return;
       }
-      const request = s.request ?? await this.lookupRequest(s);
-      if (!request) {
-        s.active = false;
-        this.logger.dbg(`ping ${short(sessionID)} skipped \u2014 last real request unknown`);
+      if (!response.ok) {
+        session.entry.lastReplay = { at: sentAt, status, latencyMs: this.now() - sentAt };
+        this.logger.info(replayLogLine(session, session.entry.lastReplay, "http-status"));
+        this.retryOrLapse(id, session, sentAt, void 0, status);
         return;
       }
-      if (ping.interrupted || s.busy || !s.active || !this.enabled) return;
-      ping.sent = true;
-      s.pingsSent += 1;
-      this.store.persist();
-      const res = await this.client.session.prompt({
-        path: { id: sessionID },
-        body: {
-          parts: [{ type: "text", text: this.config.pingToken }],
-          ...request.agent ? { agent: request.agent } : {},
-          model: { providerID: request.providerID, modelID: request.modelID },
-          ...request.variant ? { variant: request.variant } : {}
-        }
-      });
-      const info = res?.data?.info ?? res?.info;
-      if (ping.interrupted) {
-        const completed = info?.time?.completed;
-        if (typeof completed === "number") s.lastResponseAt = completed;
-        this.logger.dbg(
-          `ping ${short(sessionID)} absorbed a real turn \u2014 kept, not reverted`
-        );
+      const result = await Promise.race([
+        readAbortPoint(response, session.request.api, controller),
+        timeoutPromise
+      ]);
+      latencyMs = this.now() - sentAt;
+      if (session.controller !== controller || runtime.sessions.get(id) !== session) return;
+      const { abortEvent, ...usage } = result;
+      const last = { at: sentAt, status, latencyMs, ...usage };
+      session.entry.lastReplay = last;
+      session.entry.gapReplays++;
+      session.entry.sessionReplays++;
+      session.replayReadTokens += result.cacheRead ?? session.previousPrompt ?? 0;
+      this.totals.replays++;
+      this.sink.setTotals(this.totals);
+      session.retries = 0;
+      this.logger.info(replayLogLine(session, last, abortEvent));
+      if (session.request.api === "messages" && result.cacheRead === 0 && (result.cacheWrite ?? 0) > 0) {
+        session.entry.gapReplays--;
+        this.stopSession(id, session, "lapsed");
         return;
       }
-      const cache = info?.tokens?.cache ?? {};
-      const record = {
-        at: Date.now(),
-        hit: Number(cache.read ?? 0) > 0,
-        input: Number(info?.tokens?.input ?? 0),
-        cacheRead: Number(cache.read ?? 0),
-        cacheWrite: Number(cache.write ?? 0),
-        output: Number(info?.tokens?.output ?? 0)
-      };
-      s.lastPing = record;
-      this.logger.dbg(
-        `ping ${short(sessionID)} ${record.hit ? "HIT" : "MISS"} in=${record.input} read=${record.cacheRead} write=${record.cacheWrite} out=${record.output}`
+      if (session.entry.gapReplays >= session.entry.cap) {
+        this.stopSession(id, session, "cap");
+        return;
+      }
+      this.schedule(id, session, sentAt + session.request.intervalMs);
+    } catch (error) {
+      if (runtime.sessions.get(id) !== session || session.controller !== controller) return;
+      const timeoutHit = this.now() - sentAt >= this.config.replayTimeoutMs;
+      session.entry.lastReplay = { at: sentAt, status: 0, latencyMs: this.now() - sentAt };
+      this.logger.info(
+        replayLogLine(
+          session,
+          session.entry.lastReplay,
+          timeoutHit ? "timeout" : "network"
+        )
       );
-      if (this.config.revertPing) await this.revertPing(sessionID, ping);
-    } catch (err) {
-      this.logger.warn(`ping ${short(sessionID)} failed`, errText(err));
+      this.retryOrLapse(id, session, sentAt, timeoutHit ? "timeout" : "network");
     } finally {
-      s.warming = false;
-      s.ping = void 0;
-      const now = Date.now();
-      if (ping.sent) {
-        s.lastPingAt = now;
-        const next = s.nextPingAt + jitter(this.intervalMs);
-        s.nextPingAt = next > now ? next : now + jitter(this.intervalMs);
-      }
-      this.store.persist();
-      if (ping.sent && ping.interrupted) {
-        s.busy = false;
-        s.active = false;
-        void this.armWindow(sessionID);
-      }
+      if (timeout) clearTimeout(timeout);
+      controller.abort();
+      if (session.controller === controller) session.controller = void 0;
     }
   }
-  /** True only when the server positively reports the session idle. */
-  async isIdleOnServer(sessionID) {
-    try {
-      const res = await this.client.session.status();
-      const statuses = res?.data ?? res ?? {};
-      return (statuses?.[sessionID]?.type ?? "idle") === "idle";
-    } catch (err) {
-      this.logger.dbg(`status check ${short(sessionID)} failed`, errText(err));
-      return false;
-    }
-  }
-  /** Recover the last real turn's request settings when no user event was observed. */
-  async lookupRequest(s) {
-    const messages = await this.recentMessages(s.sessionID);
-    if (!messages) return void 0;
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const m = messages[i];
-      if (m?.info?.role !== "user" || this.isPingMessage(m)) continue;
-      const request = requestFrom(m.info);
-      if (request) {
-        s.request = request;
-        return request;
-      }
-    }
-    return void 0;
+  retryOrLapse(id, session, sentAt, reason, status = 0) {
+    session.entry.lastReplay = { at: sentAt, status, latencyMs: this.now() - sentAt };
+    if (session.retries++ === 0) this.schedule(id, session, sentAt + RETRY_MS);
+    else this.stopSession(id, session, "lapsed");
+    if (reason) this.logger.warn(`replay ${reason} session=${id}`);
   }
-  async recentMessages(sessionID) {
-    try {
-      const res = await this.client.session.messages({
-        path: { id: sessionID },
-        query: { limit: MESSAGE_LOOKUP_LIMIT }
-      });
-      const messages = res?.data ?? res;
-      return Array.isArray(messages) ? messages : void 0;
-    } catch (err) {
-      this.logger.warn(`messages ${short(sessionID)} list failed`, errText(err));
-      return void 0;
+  stopSession(id, session, reason, status) {
+    if (session.stopLoggedGap !== session.entry.gapId) {
+      session.stopLoggedGap = session.entry.gapId;
+      this.logger.info(
+        `stop session=${id} reason=${reason}${status === void 0 ? "" : ` status=${status}`}`
+      );
     }
+    this.clearTimer(session);
+    session.controller?.abort();
+    session.entry.state = "stopped";
+    session.entry.stopReason = reason;
+    session.entry.stopStatus = status;
+    session.entry.nextReplayAt = null;
+    session.entry.updatedAt = this.now();
+    if (this.runtime)
+      this.runtime.storedBytes = Math.max(
+        0,
+        this.runtime.storedBytes - bodyBytes(session.request.body)
+      );
+    session.request.body = "";
+    session.request.headers = new Headers();
+    this.publish(session);
   }
-  isPingMessage(m) {
-    const text = (m?.parts ?? []).filter((p) => p?.type === "text").map((p) => p?.text ?? "").join("").trim();
-    return text === this.config.pingToken;
-  }
-  /**
-   * Remove the `~` user + `~` assistant turn so it never enters real context.
-   * Revert drops the target and everything after it (and rolls back file
-   * snapshots), so it is skipped unless only the ping's own replies follow.
-   */
-  async revertPing(sessionID, ping) {
-    const messages = await this.recentMessages(sessionID);
-    if (!messages) return;
-    let index = -1;
-    for (let i = 0; i < messages.length; i++) {
-      const m = messages[i];
-      if (m?.info?.role !== "user") continue;
-      if (ping.messageID ? m.info.id === ping.messageID : this.isRecentPing(m, ping))
-        index = i;
-    }
-    if (index < 0) {
-      this.logger.dbg(`ping ${short(sessionID)} revert: ping message not found`);
-      return;
-    }
-    const target = messages[index].info.id;
-    const foreign = messages.slice(index + 1).some((m) => m?.info?.role !== "assistant" || m?.info?.parentID !== target);
-    if (foreign) {
-      this.logger.warn(`ping ${short(sessionID)} not reverted \u2014 other messages followed it`);
-      return;
+  updateState(session, state) {
+    const enabled = this.sessionEnabled(session.entry.sessionID);
+    session.entry.state = enabled ? state : "off";
+    session.entry.enabled = enabled;
+    session.entry.updatedAt = this.now();
+    session.entry.cap = this.cap;
+    this.publish(session);
+  }
+  publish(session) {
+    this.sink.upsert({ ...session.entry });
+  }
+  clearTimer(session) {
+    if (!session) return;
+    if (session.timer) clearTimeout(session.timer);
+    session.timer = void 0;
+    session.entry.nextReplayAt = null;
+  }
+  clearTimerFrom(session) {
+    if (session.timer) clearTimeout(session.timer);
+    session.timer = void 0;
+    session.entry.nextReplayAt = null;
+  }
+  sessionEnabled(sessionID) {
+    const instance = this.runtime?.instances.get(this);
+    return this.config.enabled && instance?.controls.get(sessionID) !== false;
+  }
+  disableSession(runtime, id, session) {
+    const instance = runtime.instances.get(this);
+    instance.effective.set(id, false);
+    this.clearTimer(session);
+    session.controller?.abort();
+    runtime.storedBytes = Math.max(0, runtime.storedBytes - bodyBytes(session.request.body));
+    session.request.body = "";
+    session.entry.stopReason = "disabled";
+    session.entry.state = "off";
+    session.entry.enabled = false;
+    session.entry.nextReplayAt = null;
+    session.entry.updatedAt = this.now();
+    if (session.stopLoggedGap !== session.entry.gapId) {
+      session.stopLoggedGap = session.entry.gapId;
+      this.logger.info(`stop session=${id} reason=disabled`);
     }
-    try {
-      await this.client.session.revert({
-        path: { id: sessionID },
-        body: { messageID: target }
-      });
-    } catch (err) {
-      this.logger.warn(`ping ${short(sessionID)} revert failed`, errText(err));
+    this.publish(session);
+  }
+  syncControl() {
+    const runtime = this.runtime;
+    if (!runtime) return;
+    const instance = runtime.instances.get(this);
+    const controls = readSessionControls(this.directory, this.now()).sessions;
+    instance.controls = new Map(
+      Object.entries(controls).map(([id, value]) => [id, value.enabled])
+    );
+    for (const [id, session] of runtime.sessions) {
+      if (runtime.owners.get(id) !== this) continue;
+      const enabled = this.sessionEnabled(id);
+      const previous = instance.effective.get(id) ?? session.entry.enabled;
+      instance.effective.set(id, enabled);
+      if (previous === enabled) continue;
+      if (!enabled) {
+        this.disableSession(runtime, id, session);
+      } else {
+        session.entry.stopReason = void 0;
+        session.entry.state = session.active ? "active" : session.busy ? "busy" : "idle";
+        session.entry.enabled = true;
+        session.entry.updatedAt = this.now();
+        this.publish(session);
+      }
     }
   }
-  isRecentPing(m, ping) {
-    return Number(m?.info?.time?.created ?? 0) >= ping.startedAt - 2e3 && this.isPingMessage(m);
+};
+function getRuntime(now) {
+  const target = globalThis;
+  if (target[STATE_KEY]) return target[STATE_KEY];
+  const runtime = {
+    originalFetch: globalThis.fetch,
+    sessions: /* @__PURE__ */ new Map(),
+    owners: /* @__PURE__ */ new Map(),
+    instancesSet: /* @__PURE__ */ new Set(),
+    childSessions: /* @__PURE__ */ new Set(),
+    loggedApis: /* @__PURE__ */ new Set(),
+    now,
+    maxStoredBytes: Number.MAX_SAFE_INTEGER,
+    storedBytes: 0,
+    hosts: /* @__PURE__ */ new Set(),
+    instances: /* @__PURE__ */ new Map()
+  };
+  target[STATE_KEY] = runtime;
+  return runtime;
+}
+async function recordRequest(runtime, input, init, bodySource) {
+  const headers = new Headers(input instanceof Request ? input.headers : init?.headers);
+  if (init?.headers && input instanceof Request)
+    new Headers(init.headers).forEach((value, key) => headers.set(key, value));
+  const id = headers.get("X-Session-Id") ?? headers.get("x-session-affinity") ?? headers.get("X-Interaction-Id");
+  if (!id) return;
+  const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+  const rawUrl = input instanceof URL ? input.href : typeof input === "string" ? input : input.url;
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    return;
   }
-  async resolveSession(s) {
+  const mapped = runtime.owners.get(id);
+  let owner;
+  if (mapped) {
+    const state = runtime.instances.get(mapped);
+    if (!state?.enabled || state.controls.get(id) === false) return;
+    owner = mapped;
+  } else {
+    const hostname = url.hostname.toLowerCase();
+    const eligiblePath = method === "POST" && !!apiFor(url.pathname);
+    const candidates = [...runtime.instances].filter(
+      ([, state]) => state.enabled && state.controls.get(id) !== false && (eligiblePath || runtime.sessions.has(id)) && [...state.hosts].some(
+        (allowed) => hostname === allowed || hostname.endsWith(`.${allowed}`)
+      )
+    );
+    if (!candidates.length) return;
+    let stringBody;
     try {
-      const res = await this.client.session.get({ path: { id: s.sessionID } });
-      const info = res?.data ?? res;
-      if (info?.parentID && !this.config.includeChildSessions) {
-        s.eligible = false;
-        s.modelLabel = info?.model?.id ?? "child";
-        return;
-      }
-      s.modelLabel = info?.model?.id ?? "unknown";
-      s.eligible = isEligibleModel(this.config, info?.model?.providerID, info?.model?.id);
-    } catch (err) {
-      s.eligible = false;
-      this.logger.dbg(`resolve ${short(s.sessionID)} failed`, errText(err));
-    }
-  }
-  pollControl() {
-    const control = readControl(this.directory);
-    if (!control || control.updatedAt <= this.controlUpdatedAt) return;
-    this.controlUpdatedAt = control.updatedAt;
-    const now = Date.now();
-    let changed = false;
-    if (control.intervalMs !== this.intervalOverride) {
-      this.intervalOverride = control.intervalMs;
-      this.store.setIntervalMs(this.intervalMs);
-      for (const session of this.store.all()) {
-        if (session.active && !session.warming)
-          session.nextPingAt = Math.max(now, lastCacheTouch(session) + this.intervalMs);
-      }
-      this.logger.info(
-        `runtime interval ${Math.round(this.intervalMs / 1e3)}s` + (control.intervalMs === void 0 ? " (config)" : "")
-      );
-      changed = true;
-    }
-    const enabled = control.enabled ?? this.config.enabled;
-    if (enabled !== this.enabled) {
-      this.enabled = enabled;
-      this.store.setEnabled(enabled);
-      for (const session of this.store.all()) {
-        if (!enabled) {
-          session.active = false;
-          continue;
-        }
-        if (!session.eligible || session.busy || session.warming) continue;
-        if (!session.lastResponseAt || !this.cacheMayBeWarm(session, now)) continue;
-        this.openWindow(session, now);
-      }
-      this.logger.info(`runtime ${enabled ? "enabled" : "disabled"}`);
-      changed = true;
+      stringBody = typeof init?.body === "string" ? init.body : init?.body === void 0 && input instanceof Request ? await (bodySource ?? input.clone().text()) : void 0;
+    } catch {
+      stringBody = void 0;
     }
-    if (changed) this.store.persist();
-  }
-  /** Recover when a session.status idle event is missed by reconciling with the API. */
-  async reconcileStatus() {
-    if (this.reconcilingStatus) return;
-    const busy = this.store.all().filter((session) => session.busy && !session.warming);
-    if (busy.length === 0) return;
-    this.reconcilingStatus = true;
+    let parsed;
     try {
-      const res = await this.client.session.status();
-      const statuses = res?.data ?? res ?? {};
-      for (const session of busy) {
-        const status = statuses?.[session.sessionID]?.type ?? "idle";
-        if (status === "idle") await this.armWindow(session.sessionID);
-      }
-    } catch (err) {
-      this.logger.dbg("status reconciliation failed", errText(err));
-    } finally {
-      this.reconcilingStatus = false;
+      if (stringBody !== void 0) parsed = JSON.parse(stringBody);
+    } catch {
+      parsed = void 0;
+    }
+    const concurrentOwner = runtime.owners.get(id);
+    if (concurrentOwner) {
+      const state = runtime.instances.get(concurrentOwner);
+      if (!state?.enabled || state.controls.get(id) === false) return;
+      await concurrentOwner.recordRequest(runtime, input, init, void 0, stringBody, parsed);
+      return;
     }
+    const child = runtime.childSessions.has(id);
+    const liveCandidates = candidates.filter(
+      ([instance, state]) => runtime.instances.has(instance) && state.enabled && state.controls.get(id) !== false
+    );
+    if (!liveCandidates.length) return;
+    const fullyEligible = liveCandidates.filter(([, state]) => {
+      if (method !== "POST" || !apiFor(url.pathname)) return false;
+      if (child && !state.config.includeChildSessions) return false;
+      const model = typeof parsed?.model === "string" ? parsed.model.toLowerCase() : "";
+      return Object.entries(state.config.intervals).some(
+        ([key]) => model.includes(key.toLowerCase())
+      ) && (!child || state.config.includeChildSessions);
+    });
+    if (!fullyEligible.length) return;
+    owner = fullyEligible[0][0];
+    runtime.owners.set(id, owner);
+    await owner.recordRequest(runtime, input, init, void 0, stringBody, parsed);
+    return;
   }
-};
-function lastCacheTouch(s) {
-  return Math.max(s.lastResponseAt, s.lastPingAt ?? 0);
+  if (!runtime.instances.has(owner) || runtime.owners.get(id) !== owner) return;
+  await owner.recordRequest(runtime, input, init, bodySource);
 }
-function isNewUserMessage(s, info) {
-  if (typeof info?.id === "string" && info.id === s.lastUserID) return false;
-  const created = info?.time?.created;
-  return typeof created !== "number" || created >= (s.lastUserAt ?? 0);
+function bodyBytes(body) {
+  return new TextEncoder().encode(body).byteLength;
 }
-function noteUserMessage(s, info) {
-  if (typeof info?.id === "string") s.lastUserID = info.id;
-  const created = info?.time?.created;
-  if (typeof created === "number") s.lastUserAt = created;
-  const request = requestFrom(info);
-  if (request) s.request = request;
+function pruneOrphanSessions(runtime) {
+  const cutoff = runtime.now() - 60 * 6e4;
+  for (const [id, session] of runtime.sessions) {
+    if (session.request.body || session.touchedAt >= cutoff) continue;
+    session.timer && clearTimeout(session.timer);
+    session.controller?.abort();
+    const owner = runtime.owners.get(id);
+    if (owner) runtime.instances.get(owner)?.sink.remove(id);
+    runtime.owners.delete(id);
+    runtime.sessions.delete(id);
+  }
 }
-function requestFrom(info) {
-  const model = info?.model;
-  const providerID = model?.providerID;
-  const modelID = model?.modelID ?? model?.id;
-  if (typeof providerID !== "string" || typeof modelID !== "string") return void 0;
-  const variant = model?.variant ?? info?.variant;
-  return {
-    agent: typeof info?.agent === "string" ? info.agent : void 0,
-    providerID,
-    modelID,
-    variant: typeof variant === "string" && variant !== "default" ? variant : void 0
-  };
+function cheapEligibilityRejection(runtime, input, init) {
+  const request = input instanceof Request ? input : void 0;
+  const method = (init?.method ?? request?.method ?? "GET").toUpperCase();
+  const rawUrl = input instanceof URL ? input.href : typeof input === "string" ? input : input.url;
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    return "invalid-url";
+  }
+  const copilotHost = isCopilotHost(url.hostname);
+  const headers = new Headers(request?.headers);
+  if (init?.headers) new Headers(init.headers).forEach((value, key) => headers.set(key, value));
+  const id = headers.get("X-Session-Id") ?? headers.get("x-session-affinity") ?? headers.get("X-Interaction-Id");
+  if (!id) return "missing-session-id";
+  if (/agent-session-(name|summary)-generation/i.test(headers.get("X-Interaction-Type") ?? ""))
+    return "utility-interaction";
+  const hostname = url.hostname.toLowerCase();
+  const owner = runtime.owners.get(id);
+  const allowedHost = owner ? (() => {
+    const state = runtime.instances.get(owner);
+    return !!state?.enabled && state.controls.get(id) !== false && [...state.hosts].some(
+      (allowed) => hostname === allowed || hostname.endsWith(`.${allowed}`)
+    );
+  })() : [...runtime.instances.values()].some(
+    (state) => state.enabled && state.controls.get(id) !== false && [...state.hosts].some(
+      (allowed) => hostname === allowed || hostname.endsWith(`.${allowed}`)
+    )
+  );
+  if (!allowedHost) return "host-not-allowed";
+  if (runtime.owners.has(id) || method === "POST" && !!apiFor(url.pathname)) return void 0;
+  if (!copilotHost) return "ineligible";
+  return method !== "POST" ? "method-not-post" : "unsupported-path";
+}
+function isReplayRequest(input, init) {
+  const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+  const rawUrl = input instanceof URL ? input.href : typeof input === "string" ? input : input.url;
+  try {
+    return method === "POST" && !!apiFor(new URL(rawUrl).pathname);
+  } catch {
+    return false;
+  }
 }
-function short(sessionID) {
-  return sessionID.slice(-6);
+function isCopilotHost(hostname) {
+  const host = hostname.toLowerCase();
+  return host === "githubcopilot.com" || host.endsWith(".githubcopilot.com") || host.startsWith("copilot-api.");
 }
-function jitter(base) {
-  return Math.max(1e3, base + Math.floor((Math.random() * 2 - 1) * JITTER_MS));
+function isCopilotRequest(input) {
+  const rawUrl = input instanceof URL ? input.href : typeof input === "string" ? input : input.url;
+  try {
+    return isCopilotHost(new URL(rawUrl).hostname);
+  } catch {
+    return false;
+  }
+}
+function apiFor(path) {
+  if (/\/v1\/messages\/?$/.test(path)) return "messages";
+  if (/^\/(?:v1\/)?responses\/?$/.test(path)) return "responses";
+  if (/\/chat\/completions\/?$/.test(path)) return "chat";
+}
+async function readAbortPoint(response, api, controller) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    controller.abort();
+    return { abortEvent: "first-chunk" };
+  }
+  let buffer = "";
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      if (api === "chat") {
+        controller.abort();
+        return { abortEvent: "first-chunk" };
+      }
+      buffer += new TextDecoder().decode(value, { stream: true });
+      const events = buffer.split(/\r?\n\r?\n/);
+      buffer = events.pop() ?? "";
+      for (const event of events) {
+        const data = event.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).join("\n");
+        if (!data || data === "[DONE]") continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        if (api === "responses" && ["response.created", "response.in_progress"].includes(parsed.type))
+          continue;
+        if (api === "messages") {
+          if (parsed.type !== "message_start") continue;
+          const usage = parsed.message?.usage ?? {};
+          controller.abort();
+          return {
+            abortEvent: "message_start",
+            cacheRead: numeric(usage.cache_read_input_tokens),
+            cacheWrite: numeric(usage.cache_creation_input_tokens)
+          };
+        }
+        controller.abort();
+        return { abortEvent: String(parsed.type ?? "first-event") };
+      }
+    }
+  } finally {
+    controller.abort();
+    await reader.cancel().catch(() => {
+    });
+  }
+  return { abortEvent: "stream-end" };
 }
-function errText(err) {
-  return err instanceof Error ? err.message : String(err);
+function replayLogLine(session, result, abortEvent) {
+  const usage = result.cacheRead === void 0 && result.cacheWrite === void 0 ? "" : ` cacheRead=${result.cacheRead ?? 0} cacheWrite=${result.cacheWrite ?? 0}`;
+  return `replay session=${session.entry.sessionID} model=${session.entry.model} api=${session.entry.api} gap=${session.entry.gapId} n=${session.entry.gapReplays}/${session.entry.cap} status=${result.status} latency=${result.latencyMs}ms abort=${abortEvent ?? "first-chunk"}${usage}`;
+}
+function numeric(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 
 // lib/logger.ts
@@ -714,94 +1165,114 @@ var Logger = class {
 };
 
 // lib/state.ts
-import { mkdir as mkdir2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname3 } from "path";
-var KeepaliveStore = class {
-  constructor(config, directory) {
-    this.config = config;
-    this.directory = directory;
-    this.enabled = config.enabled;
-    this.intervalMs = config.intervalMs;
-  }
-  config;
-  directory;
-  sessions = /* @__PURE__ */ new Map();
-  writeQueue = Promise.resolve();
-  enabled;
-  intervalMs;
-  setEnabled(enabled) {
-    this.enabled = enabled;
-  }
-  /** Effective ping interval (runtime override or config) reported to the TUI. */
-  setIntervalMs(intervalMs) {
-    this.intervalMs = intervalMs;
-  }
-  get(sessionID) {
-    return this.sessions.get(sessionID);
-  }
-  ensure(sessionID) {
-    const existing = this.sessions.get(sessionID);
-    if (existing) return existing;
-    const created = {
-      sessionID,
-      eligible: false,
-      lastResponseAt: 0,
-      idleSince: 0,
-      windowEndsAt: 0,
-      nextPingAt: 0,
-      pingsSent: 0,
-      busy: false,
-      warming: false,
-      active: false
-    };
-    this.sessions.set(sessionID, created);
-    return created;
-  }
-  remove(sessionID) {
-    this.sessions.delete(sessionID);
-  }
-  all() {
-    return [...this.sessions.values()];
-  }
-  /**
-   * Atomically persist a lean snapshot for the TUI. Never throws or rejects; the
-   * returned promise resolves once this snapshot and every earlier one are written.
-   */
-  persist() {
+import { randomUUID as randomUUID2 } from "crypto";
+import { readdirSync, readFileSync as readFileSync2, unlinkSync } from "fs";
+import { mkdir as mkdir2, rename as rename2, unlink, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join2 } from "path";
+var CLEANUP_INTERVAL_MS = 10 * 6e4;
+var PERSIST_DEBOUNCE_MS = 250;
+function createStateStore(directory, options = {}) {
+  const now = options.now ?? Date.now;
+  const instanceId = randomUUID2();
+  const filePath = instanceStateFilePath(directory, process.pid, instanceId);
+  const sessions = /* @__PURE__ */ new Map();
+  let totals = {
+    replays: 0,
+    avoidedTokens: 0,
+    replayReadTokens: 0,
+    resumeHits: 0,
+    resumeMisses: 0
+  };
+  let timer;
+  let cleanupTimer;
+  let writeQueue = Promise.resolve();
+  let disposed = false;
+  const flush = () => {
+    if (timer) clearTimeout(timer);
+    timer = void 0;
     const snapshot = {
-      version: 1,
-      updatedAt: Date.now(),
-      enabled: this.enabled,
-      intervalMs: this.intervalMs,
-      windowMs: this.config.windowMs,
-      sessions: Object.fromEntries(
-        this.all().map((s) => [
-          s.sessionID,
-          {
-            eligible: s.eligible,
-            modelLabel: s.modelLabel,
-            lastResponseAt: s.lastResponseAt,
-            idleSince: s.idleSince,
-            windowEndsAt: s.windowEndsAt,
-            nextPingAt: s.nextPingAt,
-            intervalMs: this.intervalMs,
-            pingsSent: s.pingsSent,
-            busy: s.busy,
-            warming: s.warming,
-            active: s.active,
-            lastPing: s.lastPing
-          }
-        ])
-      )
+      version: 2,
+      pid: process.pid,
+      instanceId,
+      updatedAt: now(),
+      sessions: Object.fromEntries(sessions),
+      totals
     };
-    const write = () => atomicWrite(stateFilePath(this.directory), JSON.stringify(snapshot));
-    this.writeQueue = this.writeQueue.then(write, write);
-    return this.writeQueue;
+    const write = () => atomicWrite(filePath, JSON.stringify(snapshot));
+    writeQueue = writeQueue.then(write, write);
+    return writeQueue;
+  };
+  const schedule = () => {
+    if (disposed || timer) return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      void flush();
+    }, PERSIST_DEBOUNCE_MS);
+  };
+  const onExit = () => {
+    try {
+      unlinkSync(filePath);
+    } catch {
+    }
+  };
+  cleanupStateFiles(directory, options.logger);
+  cleanupTimer = setInterval(
+    () => cleanupStateFiles(directory, options.logger),
+    CLEANUP_INTERVAL_MS
+  );
+  process.on("exit", onExit);
+  return {
+    upsert(entry) {
+      if (disposed) return;
+      sessions.set(entry.sessionID, { ...entry });
+      schedule();
+    },
+    remove(sessionID) {
+      if (disposed) return;
+      sessions.delete(sessionID);
+      schedule();
+    },
+    setTotals(value) {
+      if (disposed) return;
+      totals = { ...value };
+      schedule();
+    },
+    async dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (timer) clearTimeout(timer);
+      timer = void 0;
+      if (cleanupTimer) clearInterval(cleanupTimer);
+      cleanupTimer = void 0;
+      process.off("exit", onExit);
+      await flush();
+      await unlink(filePath).catch(() => {
+      });
+    }
+  };
+}
+function cleanupStateFiles(directory, logger) {
+  try {
+    const prefix = `state-v2-${stateDirectoryKey(directory)}-`;
+    for (const name of readdirSync(stateDirectoryPath())) {
+      const match = name.match(new RegExp(`^${prefix}(\\d+)-[^/]+\\.json$`));
+      if (!match) continue;
+      const pid = Number(match[1]);
+      try {
+        process.kill(pid, 0);
+      } catch (error) {
+        if (error.code === "ESRCH") {
+          unlinkSync(join2(stateDirectoryPath(), name));
+          logger?.dbg("Removed stale state snapshot", { pid });
+        }
+      }
+    }
+  } catch {
   }
-};
+}
 async function atomicWrite(path, contents) {
   try {
-    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    const tmp = `${path}.${process.pid}.${randomUUID2()}.tmp`;
     await mkdir2(dirname3(path), { recursive: true });
     await writeFile2(tmp, `${contents}
 `, "utf8");
@@ -810,54 +1281,27 @@ async function atomicWrite(path, contents) {
   }
 }
 
-// lib/system.ts
-function keepaliveInstruction(pingToken) {
-  return [
-    "<cache_keepalive>",
-    `A user message consisting of exactly the single token "${pingToken}" is an`,
-    "automated cache-keepalive ping, not a real request. When you receive it,",
-    `reply with exactly "${pingToken}" and nothing else. Do not call any tools,`,
-    "do not explain, and do not take any action.",
-    "</cache_keepalive>"
-  ].join("\n");
-}
-
 // index.ts
 var server = async (ctx, options) => {
-  const config = getConfig(options);
-  const logger = new Logger(config.debug, logFilePath());
-  if (!config.enabled) {
-    logger.info("disabled via config");
-    return {};
-  }
+  const logger = new Logger(false, logFilePath());
+  const config = getConfig(
+    options,
+    (message) => logger.warn(message)
+  );
+  const activeLogger = new Logger(config.debug, logFilePath());
   if (isSecureMode()) configureClientAuth(ctx.client);
-  const store = new KeepaliveStore(config, ctx.directory);
-  const engine = new KeepaliveEngine(ctx.client, config, store, logger, ctx.directory);
+  const store = createStateStore(ctx.directory, { logger: activeLogger });
+  const engine = new ReplayWarmer(ctx.client, config, store, activeLogger, ctx.directory);
   engine.start();
-  const version = true ? "0.1.6" : "dev";
+  const version = true ? "0.2.0" : "dev";
   logger.info(`v${version} ready`);
-  const instruction = keepaliveInstruction(config.pingToken);
   return {
     event: async ({ event }) => {
-      await engine.onEvent(event);
-    },
-    // Keep the system prefix identical between real turns and pings, and make
-    // the model answer a ping with a single token.
-    "experimental.chat.system.transform": async (input, output) => {
-      if (!config.injectSystemInstruction) return;
-      const model = input.model;
-      if (!isEligibleModel(config, model?.providerID, model?.id ?? model?.modelID)) return;
-      output.system.push(instruction);
-    },
-    // Backstop: if the model ignores the instruction and tries a tool during a
-    // ping, block it — the ping turn is going to be reverted anyway.
-    "tool.execute.before": async (input) => {
-      if (engine.shouldBlockTools(input.sessionID)) {
-        throw new Error("cache-keepalive: tools are disabled during a keepalive ping");
-      }
+      engine.onEvent(event);
     },
     dispose: async () => {
-      engine.stop();
+      engine.dispose();
+      await store.dispose();
     }
   };
 };