@lexwdex-org/opencode-dcp 3.4.14 → 3.5.0

package/dist/index.js

@@ -1,42 +1,3 @@
-// lib/activity.ts
-var BUSY_TTL_MS = 10 * 6e4;
-var MAX_TRACKED_SESSIONS = 500;
-var SessionActivityTracker = class {
-  sessions = /* @__PURE__ */ new Map();
-  now;
-  constructor(now) {
-    this.now = now ?? Date.now;
-  }
-  observe(type, properties) {
-    const sessionID = properties?.sessionID;
-    if (typeof sessionID !== "string" || !sessionID) return;
-    if (type === "session.status") {
-      const status = properties?.status?.type;
-      if (status === "busy" || status === "retry") this.set(sessionID, "busy");
-      else if (status === "idle") this.set(sessionID, "idle");
-      return;
-    }
-    if (type === "session.idle") this.set(sessionID, "idle");
-  }
-  state(sessionID) {
-    const activity = this.sessions.get(sessionID);
-    if (!activity) return "unknown";
-    if (activity.state === "busy" && this.now() - activity.at > BUSY_TTL_MS) return "unknown";
-    return activity.state;
-  }
-  dropSession(sessionID) {
-    this.sessions.delete(sessionID);
-  }
-  set(sessionID, state) {
-    if (this.sessions.has(sessionID)) this.sessions.delete(sessionID);
-    this.sessions.set(sessionID, { state, at: this.now() });
-    if (this.sessions.size > MAX_TRACKED_SESSIONS) {
-      const oldest = this.sessions.keys().next().value;
-      if (oldest !== void 0) this.sessions.delete(oldest);
-    }
-  }
-};
-
 // lib/auto-prune.ts
 function tokenize(text) {
   const tokens = /* @__PURE__ */ new Set();
@@ -121,10 +82,11 @@ 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);
       if (current.size >= MIN_DRIFT_TOKENS) {
         let max = 0;
@@ -134,7 +96,7 @@ var AutoPruner = class {
         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) {
@@ -1019,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,
@@ -1039,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",
@@ -1213,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;
@@ -1233,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)` : "";
@@ -1390,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),
@@ -1413,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 }
   };
 }
@@ -1480,164 +1485,232 @@ 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 };
-    }
-  }
-  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
-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;
-}
-var PruneService = class {
-  deferred = /* @__PURE__ */ new Set();
-  client;
-  summarize;
-  activity;
+// 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.client = deps.client;
-    this.summarize = deps.summarize;
-    this.activity = deps.activity;
+    this.probeBusy = deps.probeBusy;
     this.logger = deps.logger;
-  }
-  /**
-   * Feed every host event through here. Drains the deferral queue on
-   * `session.idle` and forgets queued prunes once a compaction (or the
-   * session itself) is gone.
-   */
-  observeEvent(type, properties) {
-    this.activity.observe(type, properties);
-    const sessionID = eventSessionID(properties);
+    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;
-    if (type === "session.idle") {
-      if (!this.deferred.delete(sessionID)) return;
-      void this.drainQueued(sessionID);
+    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 (type === "session.compacted") {
-      this.deferred.delete(sessionID);
-      return;
+    if (statusType === "idle") {
+      this.observeIdle(sessionID, entry, "status");
     }
-    if (type === "session.deleted") {
-      this.deferred.delete(sessionID);
-      this.activity.dropSession(sessionID);
+  }
+  /** 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;
   }
-  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.isBusyOnServer(request.sessionID);
-    if (serverBusy === true) {
-      const fallback = await this.outcomeFor(request, { action: "stand-down" });
-      if (fallback) return fallback;
+  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;
     }
-    const result = await this.summarize.summarize({ sessionID: request.sessionID, model });
-    if (result.status === "rejected") {
-      return { status: "busy" };
+    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;
     }
-    return result;
-  }
-  /** One admission check; `null` means the request may proceed. */
-  gate(request) {
-    return this.outcomeFor(request, this.admit(request));
+    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
+    });
   }
-  /**
-   * Executes a queued prune at the idle 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 idle
-   * 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;
+  async onWindowExpiry(sessionID, entry) {
+    if (entry.phase !== "pending-rest") return;
+    const generation = entry.generation;
+    let busy;
     try {
-      outcome = await this.request({ sessionID, onBusy: "proceed" });
-    } catch (error) {
-      this.logger.warn("Queued prune drain failed; the prune was not retried", {
+      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,
-        error: error instanceof Error ? error.message : String(error)
+        generation
       });
       return;
     }
-    if (outcome.status === "busy") {
-      this.deferred.add(sessionID);
+    if (busy === true) {
+      this.transition(sessionID, entry, "busy", "probe-busy");
       return;
     }
-    this.logger.debug("Queued prune drain finished", {
+    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,
-      status: outcome.status
+      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)
+        });
+      }
+    }
   }
-  /**
-   * 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 idle boundary", {
-      sessionId: request.sessionID
-    });
-    return { status: "deferred" };
+  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;
   }
-  admit(request) {
-    if (request.onBusy === "defer") return { action: "defer" };
-    if (this.activity.state(request.sessionID) === "busy") return { action: "stand-down" };
-    return { action: "go" };
+  refresh(sessionID, entry) {
+    this.sessions.delete(sessionID);
+    this.sessions.set(sessionID, entry);
+    this.evictIfNeeded(sessionID);
   }
-  /**
-   * Queries the host's live session status. Returns `null` when the answer
-   * is unknown (endpoint or SDK method missing, request failed) — callers
-   * must fail open in that case.
-   */
-  async isBusyOnServer(sessionID) {
-    try {
-      const statusFn = this.client.session.status;
-      if (typeof statusFn !== "function") return null;
-      const response = await statusFn.call(
-        this.client.session
-      );
-      const map = response?.data ?? response;
-      const info = map?.[sessionID];
-      return info?.type === "busy" || info?.type === "retry";
-    } catch {
-      return null;
-    }
+  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
 function createSessionCompactingHandler(prompts, logger) {
@@ -1676,57 +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 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 });
-  }
   return async (input) => {
     const event = input.event;
-    const sessionID = eventSessionID(event.properties);
-    if (!sessionID) return;
     try {
       deps.prune.observeEvent(event.type, event.properties);
-      if (event.type === "session.idle") {
-        if (!deps.config.enabled) return;
-        const signals = deps.autoPruner.consumePending(sessionID);
-        if (signals) await triggerAutoPrune(sessionID, signals);
-        return;
-      }
+      const sessionID = eventSessionID(event.properties);
+      if (!sessionID) return;
       if (event.type === "session.compacted") {
         deps.autoPruner.markPruned(sessionID);
         return;
@@ -1737,12 +1765,57 @@ function createEventHandler(deps) {
     } catch (error) {
       deps.logger.warn("Event handler failed", {
         type: event.type,
-        sessionId: sessionID,
         error: error instanceof Error ? error.message : String(error)
       });
     }
   };
 }
+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;
@@ -2140,6 +2213,184 @@ 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 = `\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
 
@@ -2147,7 +2398,7 @@ var PRUNE_TOOL_DESCRIPTION = `\u628A\u5F53\u524D\u4F1A\u8BDD\u7684\u65E7\u5BF9\u
 - \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
 - \u7528\u6237\u660E\u786E\u8981\u6C42\u538B\u7F29\u4E0A\u4E0B\u6587\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\u7A7A\u95F2\u8FB9\u754C\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`;
+\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,
@@ -2162,7 +2413,7 @@ function createPruneTool(deps) {
         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\u7A7A\u95F2\u8FB9\u754C\u5C1D\u8BD5\u81EA\u52A8\u6267\u884C\uFF1B\u5F53\u524D\u4E0A\u4E0B\u6587\u4E0D\u53D7\u5F71\u54CD\u3002";
+        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";
@@ -2406,13 +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,
-    activity: new SessionActivityTracker(),
-    logger
-  });
+  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,
@@ -2425,14 +2682,13 @@ var server = (async (ctx) => {
     ...config.autoPrune.enabled && {
       "chat.message": createChatMessageHandler(autoPruner)
     },
-    // The event feed drives both auto prune and the tool's deferred prunes,
-    // so it stays registered whenever either surface is on.
+    // 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,
         prune,
         autoPruner,
-        config: config.autoPrune,
         logger
       })
     },