dsh-compact-after-task

A DSH (Cordis) plugin that auto-compacts a conversation after the current task finishes, whenever context pressure crosses a threshold you set (default 50% of the routed model's context window). Install it and stop manually clicking "compress" — and stop letting the context (and the bill) grow unchecked.

The problem it solves

In a long conversation the model re-receives the entire history on every turn. As the conversation grows, this bites harder and harder:

• No compaction → exploding cost. The bigger the context, the more tokens each turn re-sends. Even with a provider KV cache (cheaper than fresh input, still not free), the history is re-transmitted and re-billed every single turn. Rolling from tens of thousands to hundreds of thousands of tokens quietly multiplies per-turn cost — the longer you talk, the more each reply costs, without you noticing.
• Manual compaction is tedious and easy to forget. /compact or the UI compress button works, but you have to remember to use it — and people only remember once things are already slow and expensive, after several huge turns have been paid for.
• The built-in auto-compaction is a late, mid-task safety net. dsh-compaction-basic only fires at 80% of the context window, and only at a step boundary while a task is running — by then you've already paid for several enormous requests, and the compaction interrupts work in progress.
• Slower responses. Longer prefixes mean more processing per request and a noticeably sluggish feel.

This plugin automates the "remember to compress" chore: after each task finishes (the agent returns to idle) it checks the pressure and compacts at your chosen threshold — dealing with cost before it hurts, not after.

How it relates to the built-in compaction (complementary, not a replacement)

The compaction itself is identical to /compact: it calls ctx.compaction.compactNow(), produces one <compacted-summary> checkpoint, and the conversation UI shows the usual "compacted N history items" card.

Requirements

• DSH Desktop / DSH profile with the base bundle (dsh-base), which provides dsh-compaction-basic, dsh-token-meter, dsh-agent and dsh-llm.

Install (profile-local)

1. Copy this package into the profile and make it resolvable from the profile's node_modules (same way dshmarket is installed):

   # from the DSH home, e.g. C:\Users\you\.dsh\profiles\desktop
   Copy-Item -Recurse <path-to>\dsh-compact-after-task .\plugins\dsh-compact-after-task
   New-Item -ItemType Junction -Path .\node_modules\dsh-compact-after-task -Target .\plugins\dsh-compact-after-task

2. Add the plugin row to the profile's cordis.patch.yml (your user patch layer, applied after every bundle layer):

   - insert:
       - id: compact-after-task
         name: 'dsh-compact-after-task'
         config:
           enabled: true
           thresholdRatio: 0.5

3. Declare the dependency in the profile's package.json so a later pnpm install does not prune it:

   "dependencies": {
     "dsh-compact-after-task": "file:plugins/dsh-compact-after-task"
   }

4. Restart DSH Desktop for the profile change to take effect.

Configuration

Picking a threshold

Set it from "the max per-turn re-send you can tolerate ÷ the model's context window":

• DeepSeek's default 1M window: 0.3–0.6 is the sweet spot; 0.5 is a conservative default.
• Want each turn to re-send ≤ 400K tokens → 0.4; ≤ 250K → 0.25.
• Don't go ≥ 0.8: the built-in compaction already fires at 0.8 at a step boundary, so a higher threshold here is meaningless.
• Small-window models (128K/64K): raise to 0.6–0.8, or you'll squeeze out useful working context.
• Too low (below ~0.1) means compressing after every small task, and the summary swallows details that were still useful.

Tune by feel after a couple of long tasks: compressing after every little task / summaries getting coarse → raise it; still re-sending hundreds of thousands of tokens per turn → lower it. Edit thresholdRatio in cordis.patch.yml and restart.

Behavior details

• Listens to the agent/status event and acts only on the idle transition — i.e. the current task's drive has fully drained. This is the "compress after finishing the current task" moment; it never interrupts a running task.
• Uses the same pressure measurement as the built-in engine: tokenMeter.measure(session).totalTokens vs contextWindow × thresholdRatio (context window resolved via llm.resolveModelInfo).
• Compaction is a single ctx.compaction.compactNow(agent, signal) call — the same operation /compact runs; compactNow reserves next-turn admission, so queued messages are correctly deferred until the compaction finishes.
• Expected failures are silent: busy (agent busy / a compaction already running) and cancelled are skipped; anything else is logged as a warning without disturbing agent lifecycle events.

Test

npm install
node test-compact-after-task.mjs

The unit test stubs the services and covers: idle + above threshold compacts, below threshold does not, running does not, busy is silent, disabled does nothing, onlyRoots filters subagents.

License

MIT