@vikrant82/opencode-cache-keepalive 0.1.4 → 0.1.6

package/README.md

@@ -18,6 +18,7 @@ Keep LLM prompt caches warm during idle periods with invisible pings and a live
 - **Live TUI footer**: idle time, pings sent/left, last ping cache hit/miss with token counts
 - **Synthetic ping reversion**: removes `~`/`~` turns from conversation history
 - **Runtime toggle**: `/keepalive-toggle`, `/keepalive-on`, `/keepalive-off` slash commands
+- **Runtime interval override**: set a per-project ping interval with presets, custom durations, or reset to the plugin default
 - **Secure mode support**: works with `OPENCODE_SERVER_PASSWORD`
 - **Configurable provider/model allowlists**
 
@@ -85,7 +86,7 @@ All options can be set via plugin config in `opencode.json` or environment varia
 The plugin registers a sidebar footer showing live keepalive status:
 
 ```
-keepalive armed
+keepalive armed every 4m 30s
 idle 03:42 · sent 2 · left 10
 ✓ hit input 12.4k · read 11.8k · write 0
 ```
@@ -93,6 +94,7 @@ idle 03:42 · sent 2 · left 10
 Metrics:
 
 - **idle**: Time since last real assistant response
+- **every**: Effective ping interval, including any runtime project override
 - **sent**: Ping attempts in current warm window (includes failures)
 - **left**: Estimated pings remaining before window expires
 - **hit/miss**: Cache hit status of last ping with token breakdown
@@ -102,6 +104,7 @@ Slash commands (available in TUI palette):
 - `/keepalive-toggle` — Toggle keepalive on/off at runtime
 - `/keepalive-on` — Enable keepalive
 - `/keepalive-off` — Disable keepalive
+- `/keepalive-interval` — Set this project's ping interval at runtime (presets for 5-minute and 30-minute caches, custom durations, or reset to the plugin default); persists per project until changed
 
 ## How It Works
 

package/dist/index.js

@@ -88,6 +88,7 @@ function numEnv(raw, fallback) {
 }
 
 // lib/control.ts
+import { randomUUID } from "crypto";
 import { readFileSync } from "fs";
 import { mkdir, rename, writeFile } from "fs/promises";
 import { dirname } from "path";
@@ -118,18 +119,27 @@ 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) {
   try {
-    const value = JSON.parse(
-      readFileSync(controlFilePath(directory), "utf8")
-    );
-    if (value.version !== 1 || typeof value.enabled !== "boolean") return void 0;
-    if (typeof value.updatedAt !== "number") return void 0;
-    return value;
+    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 } : {}
+    };
   } catch {
     return void 0;
   }
 }
+var updateQueue = Promise.resolve();
 
 // lib/model.ts
 function isEligibleModel(config, providerID, modelID) {
@@ -147,7 +157,8 @@ var JITTER_MS = 15e3;
 var CONTROL_POLL_MS = 1e3;
 var STATUS_POLL_MS = 2e3;
 var PING_STATUS_GRACE_MS = 5e3;
-var BUSY_TIMEOUT_MS = 3e5;
+var COLD_AFTER_INTERVALS = 2;
+var MESSAGE_LOOKUP_LIMIT = 50;
 var KeepaliveEngine = class {
   constructor(client, config, store, logger, directory) {
     this.client = client;
@@ -157,8 +168,10 @@ var KeepaliveEngine = class {
     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);
   }
   client;
   config;
@@ -171,6 +184,11 @@ var KeepaliveEngine = class {
   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;
+  }
   start() {
     if (this.timer) return;
     this.timer = setInterval(() => void this.tick(), TICK_MS);
@@ -178,7 +196,7 @@ var KeepaliveEngine = class {
     this.statusTimer = setInterval(() => void this.reconcileStatus(), STATUS_POLL_MS);
     this.store.persist();
     this.logger.info(
-      `started (${this.enabled ? "enabled" : "disabled"}, interval=${Math.round(this.config.intervalMs / 1e3)}s, window=${Math.round(this.config.windowMs / 6e4)}m)`
+      `started (${this.enabled ? "enabled" : "disabled"}, interval=${Math.round(this.intervalMs / 1e3)}s, window=${Math.round(this.config.windowMs / 6e4)}m)`
     );
   }
   stop() {
@@ -190,9 +208,14 @@ var KeepaliveEngine = class {
     if (this.statusTimer) clearInterval(this.statusTimer);
     this.statusTimer = void 0;
   }
-  /** True while a ping is in flight — used to block tool calls during a ping. */
-  isWarming(sessionID) {
-    return !!this.store.get(sessionID)?.warming;
+  /**
+   * 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;
@@ -205,19 +228,31 @@ var KeepaliveEngine = class {
       }
       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);
+      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) return;
+      if (session?.warming) {
+        if (info?.role === "user") this.notePingRunUser(session, info);
+        return;
+      }
       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.busySince = Date.now();
         s.active = false;
         this.store.persist();
         return;
@@ -242,7 +277,6 @@ var KeepaliveEngine = class {
       }
       const s = this.store.ensure(sessionID);
       s.busy = true;
-      s.busySince = Date.now();
       s.active = false;
       this.store.persist();
       return;
@@ -254,6 +288,55 @@ var KeepaliveEngine = class {
       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);
+      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;
+      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;
@@ -261,7 +344,6 @@ var KeepaliveEngine = class {
     s.arming = true;
     try {
       s.busy = false;
-      s.busySince = void 0;
       await this.resolveSession(s);
       if (s.busy || !this.enabled || !s.eligible) {
         s.active = false;
@@ -269,30 +351,37 @@ var KeepaliveEngine = class {
         return;
       }
       const now = Date.now();
-      if (!s.lastResponseAt) s.lastResponseAt = now;
-      s.idleSince = now;
-      s.windowEndsAt = now + this.config.windowMs;
-      s.nextPingAt = now + this.config.intervalMs;
-      s.pingsSent = 0;
-      s.lastPing = void 0;
-      s.active = true;
+      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.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.busy && s.busySince && now - s.busySince > BUSY_TIMEOUT_MS) {
-        this.logger.dbg(`busy timeout ${short(s.sessionID)} \u2014 clearing stuck flag`);
-        s.busy = false;
-        s.busySince = void 0;
-        void this.armWindow(s.sessionID);
-        continue;
-      }
       if (!s.eligible || !s.active || s.busy || s.warming) continue;
       if (now >= s.windowEndsAt) {
         s.active = false;
@@ -302,22 +391,65 @@ var KeepaliveEngine = class {
         );
         continue;
       }
-      if (now >= s.nextPingAt) void this.firePing(s.sessionID);
+      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`
+        );
+        continue;
+      }
+      void this.firePing(s.sessionID);
     }
   }
   async firePing(sessionID) {
     const s = this.store.get(sessionID);
-    if (!s || s.warming || s.busy) return;
+    if (!s || s.warming || s.busy || !s.active) return;
+    const ping = {
+      startedAt: Date.now(),
+      sent: false,
+      pending: /* @__PURE__ */ new Map(),
+      interrupted: false
+    };
     s.warming = true;
-    s.pingsSent += 1;
+    s.ping = ping;
     this.store.persist();
-    const startAt = Date.now();
     try {
+      if (!await this.isIdleOnServer(sessionID)) {
+        s.busy = true;
+        s.active = false;
+        this.logger.dbg(`ping ${short(sessionID)} skipped \u2014 session busy`);
+        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`);
+        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 }] }
+        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`
+        );
+        return;
+      }
       const cache = info?.tokens?.cache ?? {};
       const record = {
         at: Date.now(),
@@ -331,40 +463,94 @@ var KeepaliveEngine = class {
       this.logger.dbg(
         `ping ${short(sessionID)} ${record.hit ? "HIT" : "MISS"} in=${record.input} read=${record.cacheRead} write=${record.cacheWrite} out=${record.output}`
       );
-      if (this.config.revertPing) await this.revertPing(sessionID, startAt);
+      if (this.config.revertPing) await this.revertPing(sessionID, ping);
     } catch (err) {
       this.logger.warn(`ping ${short(sessionID)} failed`, errText(err));
     } finally {
       s.warming = false;
-      s.lastPingAt = Date.now();
-      s.nextPingAt = Math.max(
-        Date.now() + 1e3,
-        s.nextPingAt + jitter(this.config.intervalMs)
-      );
+      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);
+      }
     }
   }
-  /** Remove the `~` user + `~` assistant turn so it never enters real context. */
-  async revertPing(sessionID, startAt) {
-    let messages;
+  /** True only when the server positively reports the session idle. */
+  async isIdleOnServer(sessionID) {
     try {
-      const res = await this.client.session.messages({ path: { id: sessionID } });
-      messages = res?.data ?? res ?? [];
+      const res = await this.client.session.status();
+      const statuses = res?.data ?? res ?? {};
+      return (statuses?.[sessionID]?.type ?? "idle") === "idle";
     } catch (err) {
-      this.logger.warn(`ping ${short(sessionID)} revert: list failed`, errText(err));
-      return;
+      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;
+  }
+  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;
     }
-    let target;
-    for (const m of messages) {
+  }
+  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 (Number(m.info?.time?.created ?? 0) < startAt - 2e3) continue;
-      const text = (m.parts ?? []).filter((p) => p?.type === "text").map((p) => p?.text ?? "").join("").trim();
-      if (text === this.config.pingToken) target = m.info.id;
+      if (ping.messageID ? m.info.id === ping.messageID : this.isRecentPing(m, ping))
+        index = i;
     }
-    if (!target) {
+    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;
+    }
     try {
       await this.client.session.revert({
         path: { id: sessionID },
@@ -374,6 +560,9 @@ var KeepaliveEngine = class {
       this.logger.warn(`ping ${short(sessionID)} revert failed`, errText(err));
     }
   }
+  isRecentPing(m, ping) {
+    return Number(m?.info?.time?.created ?? 0) >= ping.startedAt - 2e3 && this.isPingMessage(m);
+  }
   async resolveSession(s) {
     try {
       const res = await this.client.session.get({ path: { id: s.sessionID } });
@@ -394,26 +583,37 @@ var KeepaliveEngine = class {
     const control = readControl(this.directory);
     if (!control || control.updatedAt <= this.controlUpdatedAt) return;
     this.controlUpdatedAt = control.updatedAt;
-    if (control.enabled === this.enabled) return;
-    this.enabled = control.enabled;
-    this.store.setEnabled(control.enabled);
     const now = Date.now();
-    for (const session of this.store.all()) {
-      if (!control.enabled) {
-        session.active = false;
-        continue;
+    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);
       }
-      if (!session.eligible || session.busy || session.warming) continue;
-      if (!session.lastResponseAt) continue;
-      session.idleSince = now;
-      session.windowEndsAt = now + this.config.windowMs;
-      session.nextPingAt = now + this.config.intervalMs;
-      session.pingsSent = 0;
-      session.lastPing = void 0;
-      session.active = true;
+      this.logger.info(
+        `runtime interval ${Math.round(this.intervalMs / 1e3)}s` + (control.intervalMs === void 0 ? " (config)" : "")
+      );
+      changed = true;
     }
-    this.store.persist();
-    this.logger.info(`runtime ${control.enabled ? "enabled" : "disabled"}`);
+    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;
+    }
+    if (changed) this.store.persist();
   }
   /** Recover when a session.status idle event is missed by reconciling with the API. */
   async reconcileStatus() {
@@ -435,6 +635,34 @@ var KeepaliveEngine = class {
     }
   }
 };
+function lastCacheTouch(s) {
+  return Math.max(s.lastResponseAt, s.lastPingAt ?? 0);
+}
+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 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 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 short(sessionID) {
   return sessionID.slice(-6);
 }
@@ -493,15 +721,21 @@ var KeepaliveStore = class {
     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);
   }
@@ -529,13 +763,16 @@ var KeepaliveStore = class {
   all() {
     return [...this.sessions.values()];
   }
-  /** Atomically persist a lean snapshot for the TUI. Never throws to callers. */
+  /**
+   * 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() {
     const snapshot = {
       version: 1,
       updatedAt: Date.now(),
       enabled: this.enabled,
-      intervalMs: this.config.intervalMs,
+      intervalMs: this.intervalMs,
       windowMs: this.config.windowMs,
       sessions: Object.fromEntries(
         this.all().map((s) => [
@@ -547,7 +784,7 @@ var KeepaliveStore = class {
             idleSince: s.idleSince,
             windowEndsAt: s.windowEndsAt,
             nextPingAt: s.nextPingAt,
-            intervalMs: this.config.intervalMs,
+            intervalMs: this.intervalMs,
             pingsSent: s.pingsSent,
             busy: s.busy,
             warming: s.warming,
@@ -559,6 +796,7 @@ var KeepaliveStore = class {
     };
     const write = () => atomicWrite(stateFilePath(this.directory), JSON.stringify(snapshot));
     this.writeQueue = this.writeQueue.then(write, write);
+    return this.writeQueue;
   }
 };
 async function atomicWrite(path, contents) {
@@ -596,7 +834,7 @@ var server = async (ctx, options) => {
   const store = new KeepaliveStore(config, ctx.directory);
   const engine = new KeepaliveEngine(ctx.client, config, store, logger, ctx.directory);
   engine.start();
-  const version = true ? "0.1.4" : "dev";
+  const version = true ? "0.1.6" : "dev";
   logger.info(`v${version} ready`);
   const instruction = keepaliveInstruction(config.pingToken);
   return {
@@ -614,7 +852,7 @@ var server = async (ctx, options) => {
     // 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.isWarming(input.sessionID)) {
+      if (engine.shouldBlockTools(input.sessionID)) {
         throw new Error("cache-keepalive: tools are disabled during a keepalive ping");
       }
     },