@falling-ts/dsh-force-compact 0.2.4 → 0.2.6

package/index.js

@@ -56,6 +56,7 @@ void thinkingDisabled
 import { registerCommand } from './src/hooks/command.js'
 import { handleAgentStatus } from './src/hooks/idle.js'
 import { registerLlmStreamHook } from './src/hooks/wire-rewrite.js'
+import { publishWorkingOnStart } from './src/core/ui-signal.js'
 import { guardFn, installCrashNet } from './src/core/crashnet.js'
 
 /** @type {string} the function plugin's display name. */
@@ -373,6 +374,19 @@ const __applyInner = (ctx) => {
       maybeRegisterSettingsNamespace()
       maybeRegisterCommand()
       maybeInstallWireRewrite()
+      // CONVERSATION-START Live-UI FORCED OVERRIDE (self-healing): this seam is
+      // the FIRST model request of a conversation step, so force-clear any stale
+      // pinned bracket-form text ([强制压缩中>>>] / [压缩完成!] residue left by an
+      // interrupted or failed compaction) with a fresh random working pair
+      // (isImportant=true). Without this the non-important guard inside
+      // publishUiStatus would refuse to overwrite a `[`-prefixed text and the
+      // badge could stay frozen on a stale banner for the whole session. Fire-
+      // and-forget, like the llm/stream watermark: publishWorkingOnStart swallows
+      // its own rejections internally and must never block the request chain.
+      // Mid-request watermarking stays NON-important (publishRandomWorking at the
+      // llm/stream hook) so a live compressing/done banner during an ACTUAL
+      // compaction still survives; only the START of a conversation clears it.
+      void publishWorkingOnStart(ctx)
       return await __agentRequestListenerBody(ctx, payload, next)
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@falling-ts/dsh-force-compact",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "DSH Cordis plugin: hooks the core model-request seam (agent/pre-step + agent/request) to force-compact a session's context and disable thinking per the \"强制压缩配置\" settings namespace (disableThinking, autoThresholdTokens, retainLatestTokens, turnEndForceCompactionEnabled). When the threshold fires (or /force-compact queues while busy), the latest `retainLatestTokens` of the conversation's surface tokens are KEPT VERBATIM and everything before that cutoff is COMPACTED INTO A SINGLE SUMMARY NODE in one LLM call (original span entries become shadowed/skipped). Also compacts at each turn/end and at each session/flush durability checkpoint. Host half is a pure listener; a web client half registers a settings.section (强制压缩 / Force Compact) that reads and writes the same settings namespace.",
   "type": "module",
   "main": "./index.js",

package/src/core/ui-signal.js

@@ -82,7 +82,7 @@ export const WORKING_TEXTS = Object.freeze([
   '正在驯服混沌...',
   '正在召唤赛博大脑...',
   '正在翻阅《天机》...',
-  'CPU 正在冒烟...',
+  'GPU 正在冒烟...',
   '正在跟熵值搏斗...',
   '正在画饼给你吃...',
   '正在偷渡灵感...',
@@ -227,6 +227,32 @@ export async function publishRandomWorking(ctx) {
   await publishUiStatus(ctx, randomWorkingPair())
 }
 
+/**
+ * The conversation-START forced override: publish a fresh random working pair
+ * with `isImportant=true`, so it UNCONDITIONALLY overwrites whatever is
+ * currently displayed — including a stale pinned bracket-form text such as
+ * `[强制压缩中>>>]` left behind by an interrupted/failed compaction (the
+ * non-important guard inside {@link publishUiStatus} refuses to overwrite a
+ * `[`-prefixed text, so such residue would otherwise stick on the badge for
+ * the whole session, forever showing a frozen compressing/done banner instead
+ * of a live working label).
+ *
+ * Call ONCE at the START of a conversation step (the `agent/request` seam —
+ * see index.js): the first model request of a new turn force-clears any
+ * bracket residue so the badge immediately returns to a normal working look.
+ * Only the START uses the forced form; the mid-stream watermark keeps
+ * publishing NON-importantly via {@link publishRandomWorking} (called from the
+ * `llm/stream` hook) so a live `[强制压缩中>>>]` during an ACTUAL compaction
+ * still survives (the guard stays effective while something is really
+ * pressing). Clean, self-healing: a stale `[` never outlives the next
+ * conversation start.
+ * @param {import('@deepseek-ai/cordis').Context} ctx
+ * @returns {Promise<void>}
+ */
+export async function publishWorkingOnStart(ctx) {
+  await publishUiStatus(ctx, randomWorkingPair(), true)
+}
+
 /**
  * Publish the pinned RED "[强制压缩中>>>]" status. Call BEFORE a `compactNow` /
  * `compactRegion` invocation. Passes `isImportant=true` so the pinned

package/src/hooks/guard.js

@@ -618,15 +618,29 @@ async function __forceCompactIfNeededBody(ctx, agent, signal, mode) {
     )
   }
 
-  // At or above the threshold: do NOT request the model. Retain the latest
-  // `retainLatestTokens` of the surface VERBATIM, and send everything before
-  // that cutoff (the head) as ONE BATCH to the LLM summarizer. The loop retries
-  // the step against the shrunken context (retained tail unchanged).
-  ctx.logger.info(
-    `[force-compact] ${session.id}: context ~${total} tokens >= threshold ${settings.autoThresholdTokens}; `
-    + `rejecting the model request and compacting the head while retaining the latest ~${settings.retainLatestTokens} tokens`,
+  // SHORT-CIRCUIT: when the whole current surface window does not exceed the
+  // retention budget, there is no head to compact (the tail-retaining selector
+  // would walk the entire window and return null). The threshold was tripped
+  // by the provider-usage baseline rather than by real surface growth, so an
+  // attempted compaction is a guaranteed no-op — skip it and let the request
+  // proceed without pretending to compact.
+  if (windowSumObserved > 0 && Number.isFinite(windowSumObserved) && windowSumObserved <= settings.retainLatestTokens) {
+    ctx.logger.debug(
+      `[force-compact] ${session.id}: threshold ${settings.autoThresholdTokens} tripped on a surface window (~${Math.round(windowSumObserved)} tokens) that does not exceed retainLatestTokens (~${settings.retainLatestTokens}) — nothing above the retention floor to compact; letting the request proceed`,
+    )
+    return false
+  }
+
+  // At or above the threshold: attempt a retained-tail compaction (the request
+  // itself always proceeds; the plugin never rejects the model call).
+  ctx.logger.debug(
+    `[force-compact] ${session.id}: context ~${total} tokens >= threshold ${settings.autoThresholdTokens} — attempting a retained-tail compaction (success/failure is reported by the backend below; the request itself proceeds regardless)`,
   )
-  const committed = await compactRetainingLatest(ctx, agent, signal, mode, measurement)
+  // NOTE: threshold path has NO originating slash-command, so the 5th argument
+  // (sourceCommandId) must be omitted — passing something else here (e.g. the
+  // `measurement` snapshot, as an earlier revision did) would leak a non-string
+  // into the compaction/* events' sourceCommandId field.
+  const committed = await compactRetainingLatest(ctx, agent, signal, mode)
   if (!committed) {
     // BLANK OUTCOME — nothing shrank, so the NEXT step re-attempts at the same
     // total. That is intentional ("先压缩再说"): a blank result never wedges the