@lexwdex-org/opencode-dcp 3.4.13 → 3.4.14

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAejD,QAAA,MAAM,MAAM,EAAE,MAkDK,CAAA;AAEnB,eAAe,MAAM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAiBjD,QAAA,MAAM,MAAM,EAAE,MA4DK,CAAA;AAEnB,eAAe,MAAM,CAAA"}

package/dist/index.js

@@ -1,3 +1,42 @@
+// 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();
@@ -27,6 +66,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) {
@@ -86,11 +126,13 @@ var AutoPruner = class {
     }
     if (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");
     return signals;
@@ -1461,6 +1503,142 @@ async function resolveSessionModel(client, sessionID) {
   }
 }
 
+// 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;
+  logger;
+  constructor(deps) {
+    this.client = deps.client;
+    this.summarize = deps.summarize;
+    this.activity = deps.activity;
+    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);
+    if (!sessionID) return;
+    if (type === "session.idle") {
+      if (!this.deferred.delete(sessionID)) return;
+      void this.drainQueued(sessionID);
+      return;
+    }
+    if (type === "session.compacted") {
+      this.deferred.delete(sessionID);
+      return;
+    }
+    if (type === "session.deleted") {
+      this.deferred.delete(sessionID);
+      this.activity.dropSession(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.isBusyOnServer(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 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;
+    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 idle boundary", {
+      sessionId: request.sessionID
+    });
+    return { status: "deferred" };
+  }
+  admit(request) {
+    if (request.onBusy === "defer") return { action: "defer" };
+    if (this.activity.state(request.sessionID) === "busy") return { action: "stand-down" };
+    return { action: "go" };
+  }
+  /**
+   * 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;
+    }
+  }
+};
+
 // lib/hooks.ts
 function createSessionCompactingHandler(prompts, logger) {
   return async (input, output) => {
@@ -1500,15 +1678,33 @@ var SIGNAL_LABELS = {
 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 });
+    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;
     }
-    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 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,
@@ -1521,9 +1717,10 @@ function createEventHandler(deps) {
   }
   return async (input) => {
     const event = input.event;
-    const sessionID = event.properties?.sessionID;
-    if (typeof sessionID !== "string" || !sessionID) return;
+    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);
@@ -1546,7 +1743,7 @@ function createEventHandler(deps) {
     }
   };
 }
-function createCommandExecuteHandler(client, summarize, logger) {
+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 +1755,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 +1774,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 {
@@ -1936,33 +2141,37 @@ var PromptStore = class {
 // lib/prune-tool.ts
 import { tool } from "@opencode-ai/plugin";
 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\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`;
 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\u7A7A\u95F2\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 +2188,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 +2233,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,6 +2406,12 @@ 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 autoPruner = new AutoPruner(config.autoPrune);
   logger.info("DCP initialized", {
     commands: config.commands.enabled,
@@ -2191,20 +2423,24 @@ 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 auto prune 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 = {