@lexwdex-org/opencode-dcp 3.4.13 → 3.5.0

package/dist/index.js

@@ -27,6 +27,7 @@ function jaccard(a, b) {
 }
 var WINDOW_SIZE = 4;
 var DRIFT_BASELINE = 3;
+var MIN_DRIFT_TOKENS = 6;
 function extractText(parts) {
   const texts = [];
   for (const part of parts) {
@@ -81,18 +82,21 @@ var AutoPruner = class {
   evaluate(state, text, at) {
     if (state.count + 1 < this.config.minMessages) return [];
     const signals = [];
-    if (state.count > 0 && at - state.lastAt >= this.config.idleGapMs) {
+    const enabled = this.config.signals;
+    if (enabled.idleGap && state.count > 0 && at - state.lastAt >= this.config.idleGapMs) {
       signals.push("idle-gap");
     }
-    if (state.count >= DRIFT_BASELINE && text) {
+    if (enabled.topicDrift && state.count >= DRIFT_BASELINE && text) {
       const current = tokenize(text);
-      let max = 0;
-      for (let index = Math.max(0, state.window.length - DRIFT_BASELINE); index < state.window.length; index++) {
-        max = Math.max(max, jaccard(current, tokenize(state.window[index])));
+      if (current.size >= MIN_DRIFT_TOKENS) {
+        let max = 0;
+        for (let index = Math.max(0, state.window.length - DRIFT_BASELINE); index < state.window.length; index++) {
+          max = Math.max(max, jaccard(current, tokenize(state.window[index])));
+        }
+        if (max < this.config.driftThreshold) signals.push("topic-drift");
       }
-      if (max < this.config.driftThreshold) signals.push("topic-drift");
     }
-    if (state.count + 1 >= this.config.volumeThreshold) signals.push("volume");
+    if (enabled.volume && state.count + 1 >= this.config.volumeThreshold) signals.push("volume");
     return signals;
   }
   state(sessionID) {
@@ -977,6 +981,7 @@ var ParseErrorCode;
 var DEFAULT_FAILURE_COOLDOWN_MS = 3e4;
 var DEFAULT_AUTO_PRUNE = {
   enabled: true,
+  signals: { topicDrift: true, volume: false, idleGap: false },
   minMessages: 8,
   volumeThreshold: 30,
   driftThreshold: 0.18,
@@ -997,6 +1002,10 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "summarize.failureCooldownMs",
   "autoPrune",
   "autoPrune.enabled",
+  "autoPrune.signals",
+  "autoPrune.signals.topicDrift",
+  "autoPrune.signals.volume",
+  "autoPrune.signals.idleGap",
   "autoPrune.minMessages",
   "autoPrune.volumeThreshold",
   "autoPrune.driftThreshold",
@@ -1171,6 +1180,27 @@ function validateConfigTypes(config) {
           });
         }
       }
+      const signals = autoPrune.signals;
+      if (signals !== void 0) {
+        if (typeof signals !== "object" || signals === null || Array.isArray(signals)) {
+          errors.push({
+            key: "autoPrune.signals",
+            expected: "object",
+            actual: typeof signals
+          });
+        } else {
+          for (const key of ["topicDrift", "volume", "idleGap"]) {
+            const value = signals[key];
+            if (value !== void 0 && typeof value !== "boolean") {
+              errors.push({
+                key: `autoPrune.signals.${key}`,
+                expected: "boolean",
+                actual: typeof value
+              });
+            }
+          }
+        }
+      }
     }
   }
   const tool2 = config.tool;
@@ -1191,15 +1221,25 @@ function validateConfigTypes(config) {
   }
   return errors;
 }
+function needsSignalsMigrationHint(configData) {
+  const autoPrune = configData.autoPrune;
+  return autoPrune !== null && typeof autoPrune === "object" && !Array.isArray(autoPrune) && autoPrune.enabled === true && autoPrune.signals === void 0;
+}
 function showConfigWarnings(ctx, configPath, configData, isProject) {
   const invalidKeys = getInvalidConfigKeys(configData);
   const deprecatedKeys = getDeprecatedConfigKeys(configData);
   const typeErrors = validateConfigTypes(configData);
-  if (invalidKeys.length === 0 && deprecatedKeys.length === 0 && typeErrors.length === 0) {
+  const signalsHint = needsSignalsMigrationHint(configData);
+  if (!signalsHint && invalidKeys.length === 0 && deprecatedKeys.length === 0 && typeErrors.length === 0) {
     return;
   }
   const configType = isProject ? "project config" : "config";
   const messages = [];
+  if (signalsHint) {
+    messages.push(
+      "auto-prune signals `volume` and `idleGap` are now disabled by default; re-enable via autoPrune.signals.*"
+    );
+  }
   if (deprecatedKeys.length > 0) {
     const keyList = deprecatedKeys.slice(0, 3).join(", ");
     const suffix = deprecatedKeys.length > 3 ? ` (+${deprecatedKeys.length - 3} more)` : "";
@@ -1348,8 +1388,15 @@ function mergeAutoPrune(base, override) {
     return base;
   }
   const number = (key, min, max = Number.POSITIVE_INFINITY) => typeof override[key] === "number" && Number.isFinite(override[key]) && override[key] >= min && override[key] <= max ? override[key] : base[key];
+  const signalsOverride = override.signals;
+  const signals = signalsOverride && typeof signalsOverride === "object" && !Array.isArray(signalsOverride) ? {
+    topicDrift: typeof signalsOverride.topicDrift === "boolean" ? signalsOverride.topicDrift : base.signals.topicDrift,
+    volume: typeof signalsOverride.volume === "boolean" ? signalsOverride.volume : base.signals.volume,
+    idleGap: typeof signalsOverride.idleGap === "boolean" ? signalsOverride.idleGap : base.signals.idleGap
+  } : base.signals;
   return {
     enabled: typeof override.enabled === "boolean" ? override.enabled : base.enabled,
+    signals,
     minMessages: number("minMessages", 1),
     volumeThreshold: number("volumeThreshold", 2),
     driftThreshold: number("driftThreshold", 0, 1),
@@ -1371,7 +1418,7 @@ function deepCloneConfig(config) {
     commands: { ...config.commands },
     experimental: { ...config.experimental },
     summarize: { ...config.summarize },
-    autoPrune: { ...config.autoPrune },
+    autoPrune: { ...config.autoPrune, signals: { ...config.autoPrune.signals } },
     tool: { ...config.tool }
   };
 }
@@ -1438,27 +1485,231 @@ Using previous/default values`
   return config;
 }
 
-// lib/session-model.ts
-function latestUserModel(messages) {
-  if (!Array.isArray(messages)) return null;
-  for (let index = messages.length - 1; index >= 0; index--) {
-    const info = messages[index]?.info;
-    if (info?.role !== "user") continue;
-    const providerID = info.model?.providerID;
-    const modelID = info.model?.modelID;
-    if (typeof providerID === "string" && typeof modelID === "string") {
-      return { providerID, modelID };
+// lib/session-boundary.ts
+var BOUNDARY_QUIET_MS = 2e3;
+var PROBE_TIMEOUT_MS = 2e3;
+var BUSY_EVIDENCE_TTL_MS = 10 * 6e4;
+var MAX_TRACKED_SESSIONS = 500;
+var SessionBoundaryTracker = class {
+  sessions = /* @__PURE__ */ new Map();
+  listeners = [];
+  probeBusy;
+  logger;
+  now;
+  setTimer;
+  clearTimer;
+  constructor(deps) {
+    this.probeBusy = deps.probeBusy;
+    this.logger = deps.logger;
+    this.now = deps.now ?? Date.now;
+    this.setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimer = deps.clearTimer ?? ((t) => clearTimeout(t));
+  }
+  /** Register an at-rest listener; listeners fire in registration order
+   * (1. deferred drain, 2. heuristic auto prune) and are individually
+   * error-isolated: a throw or rejection is warn-logged and never blocks
+   * later listeners nor escapes into the timer callback. */
+  onAtRest(listener) {
+    this.listeners.push(listener);
+  }
+  /** Primary input: `session.status` event payload status type. */
+  observeStatus(sessionID, statusType) {
+    if (!sessionID) return;
+    const entry = this.entry(sessionID);
+    entry.sawStatus = true;
+    if (statusType === "busy" || statusType === "retry") {
+      this.transition(
+        sessionID,
+        entry,
+        "busy",
+        statusType === "retry" ? "retry-observed" : "busy-observed"
+      );
+      return;
+    }
+    if (statusType === "idle") {
+      this.observeIdle(sessionID, entry, "status");
     }
   }
-  return null;
-}
-async function resolveSessionModel(client, sessionID) {
-  try {
-    const response = await client.session.messages({ path: { id: sessionID } });
-    return latestUserModel(response.data ?? response);
-  } catch {
-    return null;
+  /** First-class input: legacy `session.idle`. Absorbed by dedup on hosts
+   * that dual-publish; the only boundary signal on status-less hosts (T3). */
+  observeLegacyIdle(sessionID) {
+    if (!sessionID) return;
+    this.observeIdle(sessionID, this.entry(sessionID), "legacy-idle");
+  }
+  /** Lifecycle: cancel any pending window and forget the session. */
+  observeDeleted(sessionID) {
+    if (!sessionID) return;
+    const entry = this.sessions.get(sessionID);
+    if (!entry) return;
+    this.cancelWindow(entry);
+    this.sessions.delete(sessionID);
+    this.logger.debug("Boundary session dropped", { sessionId: sessionID, reason: "deleted" });
+  }
+  /** Lifecycle: compaction ended; reset to unknown so the next idle opens a
+   * fresh window. */
+  observeCompacted(sessionID) {
+    if (!sessionID) return;
+    const entry = this.sessions.get(sessionID);
+    if (!entry) return;
+    const from = entry.phase;
+    this.cancelWindow(entry);
+    entry.phase = "unknown";
+    delete entry.busyAt;
+    this.logger.debug("Boundary transition", {
+      sessionId: sessionID,
+      from,
+      to: "unknown",
+      reason: "compacted"
+    });
+  }
+  /** Absorbed busy-evidence cache: `busy` decays to `unknown` after the TTL;
+   * the table is LRU-bounded (pending-rest/at-rest entries have no TTL exit
+   * and rely on the cap). */
+  state(sessionID) {
+    const entry = this.sessions.get(sessionID);
+    if (!entry) return "unknown";
+    if (entry.phase === "busy" && entry.busyAt !== void 0 && this.now() - entry.busyAt > BUSY_EVIDENCE_TTL_MS) {
+      return "unknown";
+    }
+    return entry.phase;
+  }
+  dispose(sessionID) {
+    this.observeDeleted(sessionID);
+  }
+  observeIdle(sessionID, entry, source) {
+    if (entry.phase === "pending-rest") {
+      this.logger.debug("Boundary duplicate idle ignored", { sessionId: sessionID, source });
+      return;
+    }
+    if (entry.phase === "at-rest") {
+      if (source === "legacy-idle" && !entry.sawStatus) {
+        this.armWindow(sessionID, entry, "degrade-rearm");
+      } else {
+        this.logger.debug("Boundary duplicate idle ignored", {
+          sessionId: sessionID,
+          source
+        });
+      }
+      return;
+    }
+    this.armWindow(sessionID, entry, "idle-observed");
+  }
+  armWindow(sessionID, entry, reason) {
+    this.cancelWindow(entry);
+    entry.phase = "pending-rest";
+    entry.timer = this.setTimer(() => {
+      entry.timer = void 0;
+      void this.onWindowExpiry(sessionID, entry);
+    }, BOUNDARY_QUIET_MS);
+    this.refresh(sessionID, entry);
+    this.logger.debug("Boundary quiet window armed", {
+      sessionId: sessionID,
+      reason,
+      generation: entry.generation
+    });
+  }
+  async onWindowExpiry(sessionID, entry) {
+    if (entry.phase !== "pending-rest") return;
+    const generation = entry.generation;
+    let busy;
+    try {
+      busy = await this.probeBusy(sessionID);
+    } catch {
+      busy = null;
+    }
+    if (entry.phase !== "pending-rest" || entry.generation !== generation || this.sessions.get(sessionID) !== entry) {
+      this.logger.debug("Boundary probe result discarded", {
+        sessionId: sessionID,
+        generation
+      });
+      return;
+    }
+    if (busy === true) {
+      this.transition(sessionID, entry, "busy", "probe-busy");
+      return;
+    }
+    const reason = busy === false ? "window-expired" : "probe-failopen";
+    const from = entry.phase;
+    entry.phase = "at-rest";
+    this.refresh(sessionID, entry);
+    this.logger.debug("Boundary transition", {
+      sessionId: sessionID,
+      from,
+      to: "at-rest",
+      reason
+    });
+    this.fireAtRest(sessionID, reason);
+  }
+  transition(sessionID, entry, phase, reason) {
+    const from = entry.phase;
+    this.cancelWindow(entry);
+    entry.phase = phase;
+    if (phase === "busy") entry.busyAt = this.now();
+    else delete entry.busyAt;
+    this.refresh(sessionID, entry);
+    this.logger.debug("Boundary transition", { sessionId: sessionID, from, to: phase, reason });
+  }
+  cancelWindow(entry) {
+    if (entry.timer !== void 0) {
+      this.clearTimer(entry.timer);
+      entry.timer = void 0;
+    }
+    entry.generation += 1;
+  }
+  fireAtRest(sessionID, reason) {
+    for (const listener of this.listeners) {
+      try {
+        const result = listener(sessionID, reason);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            this.logger.warn("At-rest listener rejected", {
+              sessionId: sessionID,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          });
+        }
+      } catch (error) {
+        this.logger.warn("At-rest listener failed", {
+          sessionId: sessionID,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
   }
+  entry(sessionID) {
+    let entry = this.sessions.get(sessionID);
+    if (!entry) {
+      entry = { phase: "unknown", generation: 0, sawStatus: false };
+      this.sessions.set(sessionID, entry);
+      this.evictIfNeeded(sessionID);
+      return entry;
+    }
+    this.refresh(sessionID, entry);
+    return entry;
+  }
+  refresh(sessionID, entry) {
+    this.sessions.delete(sessionID);
+    this.sessions.set(sessionID, entry);
+    this.evictIfNeeded(sessionID);
+  }
+  evictIfNeeded(kept) {
+    if (this.sessions.size <= MAX_TRACKED_SESSIONS) return;
+    const oldest = this.sessions.keys().next().value;
+    if (oldest === void 0 || oldest === kept) return;
+    const victim = this.sessions.get(oldest);
+    if (victim?.timer !== void 0) this.clearTimer(victim.timer);
+    this.sessions.delete(oldest);
+  }
+};
+function retrySeconds(retryAfterMs) {
+  return Math.ceil(retryAfterMs / 1e3);
+}
+function eventSessionID(properties) {
+  const direct = properties?.sessionID;
+  if (typeof direct === "string" && direct) return direct;
+  const info = properties?.info?.id;
+  if (typeof info === "string" && info) return info;
+  return void 0;
 }
 
 // lib/hooks.ts
@@ -1498,38 +1749,12 @@ var SIGNAL_LABELS = {
   "idle-gap": "\u957F\u65F6\u95F4\u4E2D\u65AD\u540E\u6062\u590D"
 };
 function createEventHandler(deps) {
-  async function triggerAutoPrune(sessionID, signals) {
-    const reason = signals.map((signal) => SIGNAL_LABELS[signal]).join("\u3001");
-    const model = await resolveSessionModel(deps.client, sessionID);
-    if (!model) {
-      deps.logger.debug("Auto prune skipped; no session model yet", { sessionId: sessionID });
-      return;
-    }
-    const result = await deps.summarize.summarize({ sessionID, model });
-    deps.autoPruner.markPruned(sessionID);
-    if (result.status === "succeeded") {
-      await showToast(deps.client, "DCP \u81EA\u52A8\u538B\u7F29", `\u68C0\u6D4B\u5230${reason}\uFF0C\u5DF2\u751F\u6210\u65B0\u7684\u8BED\u4E49\u68C0\u67E5\u70B9\u3002`);
-    } else {
-      await showToast(
-        deps.client,
-        "DCP \u81EA\u52A8\u538B\u7F29",
-        `\u68C0\u6D4B\u5230${reason}\uFF0C\u4F46\u538B\u7F29\u5931\u8D25\uFF1B\u539F\u59CB\u4E0A\u4E0B\u6587\u4FDD\u6301\u4E0D\u53D8\u3002`,
-        "warning"
-      );
-    }
-    deps.logger.debug("Auto prune finished", { sessionId: sessionID, status: result.status });
-  }
   return async (input) => {
     const event = input.event;
-    const sessionID = event.properties?.sessionID;
-    if (typeof sessionID !== "string" || !sessionID) return;
     try {
-      if (event.type === "session.idle") {
-        if (!deps.config.enabled) return;
-        const signals = deps.autoPruner.consumePending(sessionID);
-        if (signals) await triggerAutoPrune(sessionID, signals);
-        return;
-      }
+      deps.prune.observeEvent(event.type, event.properties);
+      const sessionID = eventSessionID(event.properties);
+      if (!sessionID) return;
       if (event.type === "session.compacted") {
         deps.autoPruner.markPruned(sessionID);
         return;
@@ -1540,13 +1765,58 @@ function createEventHandler(deps) {
     } catch (error) {
       deps.logger.warn("Event handler failed", {
         type: event.type,
-        sessionId: sessionID,
         error: error instanceof Error ? error.message : String(error)
       });
     }
   };
 }
-function createCommandExecuteHandler(client, summarize, logger) {
+async function triggerAutoPrune(deps, sessionID, signals) {
+  const reason = signals.map((signal) => SIGNAL_LABELS[signal]).join("\u3001");
+  const result = await deps.prune.request({ sessionID, onBusy: "proceed" });
+  const attempted = result.status === "succeeded" || result.status === "failed" || result.status === "cooldown";
+  if (!attempted) {
+    if (result.status === "busy") {
+      await showToast(
+        deps.client,
+        "DCP \u81EA\u52A8\u538B\u7F29",
+        `\u68C0\u6D4B\u5230${reason}\uFF0C\u4F46\u4F1A\u8BDD\u6B63\u5FD9\uFF0C\u672C\u6B21\u5DF2\u8DF3\u8FC7\uFF1B\u539F\u59CB\u4E0A\u4E0B\u6587\u4FDD\u6301\u4E0D\u53D8\u3002`,
+        "warning"
+      );
+    }
+    deps.logger.debug("Auto prune skipped", {
+      sessionId: sessionID,
+      status: result.status
+    });
+    return;
+  }
+  deps.autoPruner.markPruned(sessionID);
+  if (result.status === "succeeded") {
+    await showToast(deps.client, "DCP \u81EA\u52A8\u538B\u7F29", `\u68C0\u6D4B\u5230${reason}\uFF0C\u5DF2\u751F\u6210\u65B0\u7684\u8BED\u4E49\u68C0\u67E5\u70B9\u3002`);
+  } else if (result.status === "cooldown") {
+    await showToast(
+      deps.client,
+      "DCP \u81EA\u52A8\u538B\u7F29",
+      `\u68C0\u6D4B\u5230${reason}\uFF0C\u4F46\u4E0A\u4E00\u6B21\u538B\u7F29\u5931\u8D25\uFF1B${retrySeconds(result.retryAfterMs)} \u79D2\u540E\u53EF\u91CD\u8BD5\u3002`,
+      "warning"
+    );
+  } else {
+    await showToast(
+      deps.client,
+      "DCP \u81EA\u52A8\u538B\u7F29",
+      `\u68C0\u6D4B\u5230${reason}\uFF0C\u4F46\u538B\u7F29\u5931\u8D25\uFF1B\u539F\u59CB\u4E0A\u4E0B\u6587\u4FDD\u6301\u4E0D\u53D8\u3002`,
+      "warning"
+    );
+  }
+  deps.logger.debug("Auto prune finished", { sessionId: sessionID, status: result.status });
+}
+function createAtRestAutoPruneListener(deps) {
+  return async (sessionID, _reason) => {
+    if (!deps.config.enabled) return;
+    const signals = deps.autoPruner.consumePending(sessionID);
+    if (signals) await triggerAutoPrune(deps, sessionID, signals);
+  };
+}
+function createCommandExecuteHandler(client, prune, logger) {
   return async (input, _output) => {
     if (input.command !== "dcp") return;
     const subcommand = (input.arguments ?? "").trim().split(/\s+/, 1)[0]?.toLowerCase();
@@ -1558,8 +1828,17 @@ function createCommandExecuteHandler(client, summarize, logger) {
       );
       throw new Error("__DCP_HELP_HANDLED__");
     }
-    const model = await resolveSessionModel(client, input.sessionID);
-    if (!model) {
+    const result = await prune.request({ sessionID: input.sessionID, onBusy: "proceed" });
+    if (result.status === "busy") {
+      await showToast(
+        client,
+        "DCP summarize",
+        "Session is busy; the prune will not interrupt the current turn. Try again once it finishes.",
+        "warning"
+      );
+      throw new Error("__DCP_SUMMARIZE_HANDLED__");
+    }
+    if (result.status === "no-model") {
       await showToast(
         client,
         "DCP summarize",
@@ -1568,14 +1847,13 @@ function createCommandExecuteHandler(client, summarize, logger) {
       );
       throw new Error("__DCP_SUMMARIZE_NO_MODEL__");
     }
-    const result = await summarize.summarize({ sessionID: input.sessionID, model });
     if (result.status === "succeeded") {
       await showToast(client, "DCP summarize", "Semantic pruning checkpoint created.");
     } else if (result.status === "cooldown") {
       await showToast(
         client,
         "DCP summarize",
-        `Previous attempt failed; retry in ${Math.ceil(result.retryAfterMs / 1e3)}s.`,
+        `Previous attempt failed; retry in ${retrySeconds(result.retryAfterMs)}s.`,
         "warning"
       );
     } else {
@@ -1935,34 +2213,216 @@ var PromptStore = class {
 
 // lib/prune-tool.ts
 import { tool } from "@opencode-ai/plugin";
+
+// lib/session-model.ts
+function latestUserModel(messages) {
+  if (!Array.isArray(messages)) return null;
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const info = messages[index]?.info;
+    if (info?.role !== "user") continue;
+    const providerID = info.model?.providerID;
+    const modelID = info.model?.modelID;
+    if (typeof providerID === "string" && typeof modelID === "string") {
+      return { providerID, modelID };
+    }
+  }
+  return null;
+}
+async function resolveSessionModel(client, sessionID) {
+  try {
+    const response = await client.session.messages({ path: { id: sessionID } });
+    return latestUserModel(response.data ?? response);
+  } catch {
+    return null;
+  }
+}
+
+// lib/prune-service.ts
+var PruneService = class {
+  deferred = /* @__PURE__ */ new Set();
+  client;
+  summarize;
+  logger;
+  probeTimeoutMs;
+  /** THE single busy/idle event state machine (absorbed the former
+   * SessionActivityTracker — no second busy cache may exist). */
+  boundary;
+  constructor(deps) {
+    this.client = deps.client;
+    this.summarize = deps.summarize;
+    this.logger = deps.logger;
+    this.probeTimeoutMs = deps.probeTimeoutMs ?? PROBE_TIMEOUT_MS;
+    this.boundary = new SessionBoundaryTracker({
+      probeBusy: (sessionID) => this.probeBusy(sessionID),
+      logger: deps.logger,
+      now: deps.now,
+      setTimer: deps.setTimer,
+      clearTimer: deps.clearTimer
+    });
+    this.boundary.onAtRest((sessionID) => {
+      if (!this.deferred.delete(sessionID)) return;
+      void this.drainQueued(sessionID);
+    });
+  }
+  /**
+   * Feed every host event through here. `session.status` and legacy
+   * `session.idle` feed the boundary tracker (quiet window + expiry probe);
+   * the deferral queue drains at the confirmed at-rest classification, and
+   * queued prunes are forgotten once a compaction (or the session itself)
+   * is gone.
+   */
+  observeEvent(type, properties) {
+    const sessionID = eventSessionID(properties);
+    if (type === "session.status") {
+      this.boundary.observeStatus(sessionID, properties?.status?.type);
+      return;
+    }
+    if (type === "session.idle") {
+      this.boundary.observeLegacyIdle(sessionID);
+      return;
+    }
+    if (!sessionID) return;
+    if (type === "session.compacted") {
+      this.deferred.delete(sessionID);
+      this.boundary.observeCompacted(sessionID);
+      return;
+    }
+    if (type === "session.deleted") {
+      this.deferred.delete(sessionID);
+      this.boundary.observeDeleted(sessionID);
+    }
+  }
+  async request(request) {
+    const beforeModel = await this.gate(request);
+    if (beforeModel) return beforeModel;
+    const model = await resolveSessionModel(this.client, request.sessionID);
+    if (!model) return { status: "no-model" };
+    const afterModel = await this.gate(request);
+    if (afterModel) return afterModel;
+    const serverBusy = await this.probeBusy(request.sessionID);
+    if (serverBusy === true) {
+      const fallback = await this.outcomeFor(request, { action: "stand-down" });
+      if (fallback) return fallback;
+    }
+    const result = await this.summarize.summarize({ sessionID: request.sessionID, model });
+    if (result.status === "rejected") {
+      return { status: "busy" };
+    }
+    return result;
+  }
+  /** One admission check; `null` means the request may proceed. */
+  gate(request) {
+    return this.outcomeFor(request, this.admit(request));
+  }
+  /**
+   * Executes a queued prune at the confirmed at-rest boundary. The tool
+   * already promised its caller this prune would run; losing the busy race
+   * must not silently break that promise, so a busy outcome re-queues for
+   * the next at-rest boundary. Every other outcome is terminal: it is
+   * logged and never retried — new prune demand arrives through new
+   * triggers only. Execution is re-guarded on every attempt, so re-queueing
+   * never violates the never-interrupt invariant.
+   */
+  async drainQueued(sessionID) {
+    let outcome;
+    try {
+      outcome = await this.request({ sessionID, onBusy: "proceed" });
+    } catch (error) {
+      this.logger.warn("Queued prune drain failed; the prune was not retried", {
+        sessionId: sessionID,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+    if (outcome.status === "busy") {
+      this.deferred.add(sessionID);
+      return;
+    }
+    this.logger.debug("Queued prune drain finished", {
+      sessionId: sessionID,
+      status: outcome.status
+    });
+  }
+  /**
+   * Turns an admission decision into a terminal outcome, or `null` when the
+   * request may proceed. Deferral additionally enqueues the session.
+   */
+  async outcomeFor(request, admission) {
+    if (admission.action === "go") return null;
+    if (admission.action === "stand-down") return { status: "busy" };
+    this.deferred.add(request.sessionID);
+    this.logger.debug("Prune deferred to the next session at-rest boundary", {
+      sessionId: request.sessionID
+    });
+    return { status: "deferred" };
+  }
+  admit(request) {
+    if (request.onBusy === "defer") return { action: "defer" };
+    if (this.boundary.state(request.sessionID) === "busy") return { action: "stand-down" };
+    return { action: "go" };
+  }
+  /**
+   * THE single live busy probe, reused verbatim by the boundary tracker's
+   * expiry check. Bounded by a finite deadline: a never-returning probe
+   * resolves `null` within the timeout (fail-open). Returns `null` when the
+   * answer is unknown (endpoint or SDK method missing, request failed,
+   * timeout) — callers must fail open in that case.
+   */
+  async probeBusy(sessionID) {
+    const statusFn = this.client.session.status;
+    if (typeof statusFn !== "function") return null;
+    const query = (async () => {
+      try {
+        return await statusFn.call(
+          this.client.session
+        );
+      } catch {
+        return null;
+      }
+    })();
+    const response = await Promise.race([
+      query,
+      new Promise((resolve) => setTimeout(() => resolve(null), this.probeTimeoutMs))
+    ]);
+    const map = response?.data ?? response;
+    const info = map?.[sessionID];
+    return info?.type === "busy" || info?.type === "retry";
+  }
+};
+
+// lib/prune-tool.ts
 var PRUNE_TOOL_NAME = "dcp_prune";
-var PRUNE_TOOL_DESCRIPTION = `\u7ACB\u5373\u5BF9\u5F53\u524D\u4F1A\u8BDD\u6267\u884C\u8BED\u4E49\u4E0A\u4E0B\u6587\u538B\u7F29\uFF1A\u628A\u65E7\u5BF9\u8BDD\u524D\u7F00\u6298\u53E0\u4E3A\u4E00\u4E2A\u6EDA\u52A8\u68C0\u67E5\u70B9\uFF08\u4FDD\u7559\u7CFB\u7EDF\u7EA7\u89C4\u5219\u3001\u538B\u7F29\u4E2D\u90E8\u5386\u53F2\u3001\u8BE6\u8FF0\u8FDB\u884C\u4E2D\u7684\u4EFB\u52A1\uFF09\uFF0C\u8FD1\u671F\u5C3E\u90E8\u4E0D\u53D7\u5F71\u54CD\u3002
+var PRUNE_TOOL_DESCRIPTION = `\u628A\u5F53\u524D\u4F1A\u8BDD\u7684\u65E7\u5BF9\u8BDD\u524D\u7F00\u6298\u53E0\u4E3A\u4E00\u4E2A\u6EDA\u52A8\u68C0\u67E5\u70B9\uFF08\u4FDD\u7559\u7CFB\u7EDF\u7EA7\u89C4\u5219\u3001\u538B\u7F29\u4E2D\u90E8\u5386\u53F2\u3001\u8BE6\u8FF0\u8FDB\u884C\u4E2D\u7684\u4EFB\u52A1\uFF09\uFF0C\u8FD1\u671F\u5C3E\u90E8\u4E0D\u53D7\u5F71\u54CD\u3002
 
-\u6EE1\u8DB3\u4EFB\u4E00\u542F\u53D1\u5F0F\u6761\u4EF6\u65F6\uFF0C\u5FC5\u987B\u7ACB\u5373\u8C03\u7528\u672C\u5DE5\u5177\uFF1A
+\u4EC5\u5728\u8FD9\u4E9B\u60C5\u51B5\u4E0B\u8C03\u7528\uFF1A
 - \u5BF9\u8BDD\u8BDD\u9898\u53D1\u751F\u660E\u663E\u53D8\u66F4\uFF1A\u5F00\u59CB\u5904\u7406\u65B0\u7684\u95EE\u9898\u57DF\u3001\u5207\u6362\u5230\u53E6\u4E00\u4E2A\u6A21\u5757/\u4ED3\u5E93/\u4EFB\u52A1\uFF1B
-- \u5F53\u524D\u4EFB\u52A1\u521A\u6536\u5C3E\u5B8C\u6210\uFF0C\u5373\u5C06\u5F00\u542F\u4E0B\u4E00\u9879\u5DE5\u4F5C\uFF1B
-- \u5BF9\u8BDD\u8F6E\u6570\u6216\u4E0A\u4E0B\u6587\u660E\u663E\u53D8\u957F\uFF0C\u65E9\u671F\u7EC6\u8282\u5DF2\u4E0D\u9700\u8981\u9010\u5B57\u4FDD\u7559\u3002
+- \u7528\u6237\u660E\u786E\u8981\u6C42\u538B\u7F29\u4E0A\u4E0B\u6587\u3002
 
-\u8C03\u7528\u662F\u5B89\u5168\u7684\uFF1A\u5E76\u53D1\u8BF7\u6C42\u4F1A\u81EA\u52A8\u5408\u5E76\uFF0C\u5931\u8D25\u4E0D\u4F1A\u7834\u574F\u73B0\u6709\u4E0A\u4E0B\u6587\u3002\u4E0D\u8981\u4E3A\u540C\u4E00\u8BDD\u9898\u53CD\u590D\u8FDE\u7EED\u8C03\u7528\u3002`;
+\u540C\u4E00\u4EFB\u52A1\u5185\u7684\u591A\u8F6E\u8FFD\u95EE\u3001\u53C2\u6570\u5FAE\u8C03\u3001\u5EF6\u7EED\u5F53\u524D\u5DE5\u4F5C\uFF0C\u90FD\u4E0D\u8981\u8C03\u7528\u3002\u8C03\u7528\u4E0D\u4F1A\u6253\u65AD\u5F53\u524D\u5DE5\u4F5C\uFF1A\u538B\u7F29\u4F1A\u6392\u961F\uFF0C\u5E76\u5728\u4E0B\u4E00\u4E2A\u786E\u8BA4\u7684\u9759\u606F\u8FB9\u754C\uFF08\u77ED\u6682\u9759\u9ED8\u7A97\u53E3\u52A0\u5B9E\u65F6\u72B6\u6001\u68C0\u67E5\uFF09\u5C1D\u8BD5\u6267\u884C\uFF1B\u5E76\u53D1\u8BF7\u6C42\u81EA\u52A8\u5408\u5E76\uFF0C\u5931\u8D25\u4E0D\u4F1A\u7834\u574F\u73B0\u6709\u4E0A\u4E0B\u6587\u3002\u4E0D\u8981\u4E3A\u540C\u4E00\u8BDD\u9898\u53CD\u590D\u8C03\u7528\u3002`;
 function createPruneTool(deps) {
   return tool({
     description: PRUNE_TOOL_DESCRIPTION,
     args: {},
     execute: async (_args, context) => {
       const sessionID = context.sessionID;
-      const model = await resolveSessionModel(deps.client, sessionID);
-      if (!model) {
-        return "DCP\uFF1A\u4F1A\u8BDD\u4E2D\u8FD8\u6CA1\u6709\u53EF\u7528\u7684\u6A21\u578B\u4FE1\u606F\uFF0C\u65E0\u6CD5\u6267\u884C\u538B\u7F29\u3002";
-      }
-      const result = await deps.summarize.summarize({ sessionID, model });
+      const result = await deps.prune.request({ sessionID, onBusy: "defer" });
       if (result.status === "succeeded") {
         deps.logger.debug("Prune tool triggered native compaction", {
           sessionId: sessionID
         });
         return "DCP\uFF1A\u8BED\u4E49\u538B\u7F29\u5B8C\u6210\uFF0C\u65E7\u4E0A\u4E0B\u6587\u5DF2\u6298\u53E0\u4E3A\u65B0\u68C0\u67E5\u70B9\u3002";
       }
+      if (result.status === "deferred") {
+        return "DCP\uFF1A\u4F1A\u8BDD\u4ECD\u5728\u5DE5\u4F5C\u4E2D\uFF0C\u538B\u7F29\u5DF2\u6392\u961F\uFF0C\u5C06\u5728\u4E0B\u4E00\u4E2A\u786E\u8BA4\u7684\u9759\u606F\u8FB9\u754C\u5C1D\u8BD5\u81EA\u52A8\u6267\u884C\uFF1B\u5F53\u524D\u4E0A\u4E0B\u6587\u4E0D\u53D7\u5F71\u54CD\u3002";
+      }
+      if (result.status === "busy") {
+        return "DCP\uFF1A\u4F1A\u8BDD\u6B63\u5FD9\uFF0C\u4E3A\u907F\u514D\u6253\u65AD\u5F53\u524D\u5DE5\u4F5C\uFF0C\u672C\u6B21\u672A\u6267\u884C\u538B\u7F29\u3002";
+      }
       if (result.status === "cooldown") {
-        return `DCP\uFF1A\u4E0A\u4E00\u6B21\u538B\u7F29\u5931\u8D25\uFF0C${Math.ceil(result.retryAfterMs / 1e3)} \u79D2\u540E\u624D\u80FD\u91CD\u8BD5\u3002`;
+        return `DCP\uFF1A\u4E0A\u4E00\u6B21\u538B\u7F29\u5931\u8D25\uFF0C${retrySeconds(result.retryAfterMs)} \u79D2\u540E\u624D\u80FD\u91CD\u8BD5\u3002`;
+      }
+      if (result.status === "no-model") {
+        return "DCP\uFF1A\u4F1A\u8BDD\u4E2D\u8FD8\u6CA1\u6709\u53EF\u7528\u7684\u6A21\u578B\u4FE1\u606F\uFF0C\u65E0\u6CD5\u6267\u884C\u538B\u7F29\u3002";
       }
       return `DCP\uFF1A\u538B\u7F29\u5931\u8D25\uFF08${result.error}\uFF09\uFF0C\u539F\u59CB\u4E0A\u4E0B\u6587\u4FDD\u6301\u4E0D\u53D8\u3002`;
     }
@@ -1979,6 +2439,16 @@ function errorMessage(error) {
     return "Unknown native compaction error";
   }
 }
+function isBusyRejection(error) {
+  if (error instanceof Error && /\bbusy\b/i.test(error.message)) return true;
+  if (typeof error === "string" && /\bbusy\b/i.test(error)) return true;
+  const structured = error;
+  if (!structured || typeof structured !== "object") return false;
+  if (structured.status === 409 || structured.statusCode === 409 || structured.code === 409) {
+    return true;
+  }
+  return typeof structured.name === "string" && /busy/i.test(structured.name);
+}
 var SummarizeCoordinator = class {
   constructor(client, logger, options) {
     this.client = client;
@@ -2014,12 +2484,19 @@ var SummarizeCoordinator = class {
         path: { id: request.sessionID },
         body: request.model
       });
-      if (response?.error || response?.data !== true) {
-        throw new Error(errorMessage(response?.error ?? "Native summarize returned false"));
+      const nativeError = response?.error;
+      if (nativeError && isBusyRejection(nativeError)) {
+        return { status: "rejected", reason: "busy" };
+      }
+      if (nativeError || response?.data !== true) {
+        throw new Error(errorMessage(nativeError ?? "Native summarize returned false"));
       }
       this.failedAt.delete(request.sessionID);
       return { status: "succeeded" };
     } catch (error) {
+      if (isBusyRejection(error)) {
+        return { status: "rejected", reason: "busy" };
+      }
       this.failedAt.set(request.sessionID, this.now());
       const message = errorMessage(error);
       await this.logger.warn("Native summarize failed; context remains unchanged", {
@@ -2180,7 +2657,19 @@ var server = (async (ctx) => {
   const summarize = new SummarizeCoordinator(ctx.client, logger, {
     failureCooldownMs: config.summarize.failureCooldownMs
   });
+  const prune = new PruneService({ client: ctx.client, summarize, logger });
   const autoPruner = new AutoPruner(config.autoPrune);
+  if (config.autoPrune.enabled) {
+    prune.boundary.onAtRest(
+      createAtRestAutoPruneListener({
+        client: ctx.client,
+        prune,
+        autoPruner,
+        config: config.autoPrune,
+        logger
+      })
+    );
+  }
   logger.info("DCP initialized", {
     commands: config.commands.enabled,
     autoPrune: config.autoPrune.enabled,
@@ -2191,20 +2680,23 @@ var server = (async (ctx) => {
   return {
     "experimental.session.compacting": createSessionCompactingHandler(prompts, logger),
     ...config.autoPrune.enabled && {
-      "chat.message": createChatMessageHandler(autoPruner),
+      "chat.message": createChatMessageHandler(autoPruner)
+    },
+    // The event feed drives both the boundary classification (status/idle
+    // observations) and the tool's deferred prunes, so it stays registered
+    // whenever either surface is on.
+    ...(config.autoPrune.enabled || config.tool.enabled) && {
       event: createEventHandler({
-        client: ctx.client,
-        summarize,
+        prune,
         autoPruner,
-        config: config.autoPrune,
         logger
       })
     },
     ...config.tool.enabled && {
-      tool: { [PRUNE_TOOL_NAME]: createPruneTool({ client: ctx.client, summarize, logger }) }
+      tool: { [PRUNE_TOOL_NAME]: createPruneTool({ prune, logger }) }
     },
     ...config.commands.enabled && {
-      "command.execute.before": createCommandExecuteHandler(ctx.client, summarize, logger),
+      "command.execute.before": createCommandExecuteHandler(ctx.client, prune, logger),
       config: async (opencodeConfig) => {
         opencodeConfig.command ??= {};
         opencodeConfig.command.dcp = {