smart-compaction 0.2.3 → 0.3.1

package/README.md

@@ -1,10 +1,25 @@
-# smart-compaction
+<p align="center">
+  <img src="https://raw.githubusercontent.com/JoblessJoe/smart-compaction/main/.github/assets/banner.svg" alt="smart-compaction: dsh auto-compacts mid-task; with smart-compaction the model compacts between tasks" width="100%">
+</p>
 
-A [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (dsh) plugin that gives the
-model two tools: `compact_now`, so it can trigger compaction itself at a point *it* knows is safe
-— right after finishing a step, never mid-edit — instead of only ever being interrupted by dsh's
-automatic token-threshold trigger; and `context_status`, so it can check real, current token
-usage against its actual context window instead of guessing whether a conversation "feels long."
+<p align="center">
+  <a href="https://www.npmjs.com/package/smart-compaction"><img src="https://img.shields.io/npm/v/smart-compaction?color=a78bfa&label=npm" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/smart-compaction"><img src="https://img.shields.io/npm/dm/smart-compaction?color=a78bfa" alt="npm downloads"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/JoblessJoe/smart-compaction?color=a78bfa" alt="MIT license"></a>
+</p>
+
+A [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (dsh) plugin that lets the model decide **when** to compact its own context, instead of being cut off mid-task by a blind token threshold.
+
+- **`compact_now`:** compacts at a point the model knows is safe, e.g. right after finishing a todo. Works mid-turn.
+- **`context_status`:** real token usage against the session's actual context window, so the model stops guessing.
+- **Automatic safe-point compaction:** local models rarely call a tool like this on their own, so the plugin also compacts by itself the moment a todo item is marked done and the context is over half full. No model decision needed.
+- **No config, no core changes:** built only on dsh's public compaction APIs.
+
+```bash
+dsh plugin --profile web add smart-compaction
+```
+
+Restart dsh and you're done. Details and edge cases under [Install](#install).
 
 ## Why
 
@@ -28,11 +43,17 @@ Two tools, both no-argument.
   tool-call-pairing-safe boundary logic dsh's own compaction already guarantees, reimplemented
   here against dsh's *public* APIs only (no dsh core changes, no dependency on
   `compaction-basic`'s internals).
+- Posts a one-line "Compacting now" notice to the chat *before* calling `compactRegion()`, not
+  after — the summarization call is one extra model request and can take a while (minutes, on a
+  local model), and without this the chat just looks stuck between the tool call and its result.
+  Tagged with its own source kind and `form: 'notice'` (the same tagging dsh-compaction-basic's own
+  checkpoint messages and other host-generated asides use), so it renders as a collapsed system aside, not as
+  if the user typed it, and needs no model output of its own.
 - Calls dsh's own `ctx.compaction.compactRegion()` to actually do the compaction — the same
   summarizer, the same durable `compaction/start`/`compaction/end` log events, the same guarantees
   as any other compaction in the session.
 - No-ops harmlessly (`"Not enough compactable history yet."`) if there isn't enough history yet —
-  safe for the model to call speculatively.
+  safe for the model to call speculatively. No notice is posted for a no-op call.
 
 **`context_status`**
 
@@ -49,6 +70,22 @@ Two tools, both no-argument.
   only prior signal was a vague "if the conversation feels long" in `compact_now`'s own
   description.
 
+**Automatic safe-point compaction**
+
+- Watches `todo_write`. When an item flips to `completed`, that's a finished step: a safe place
+  to cut.
+- If usage is past `safePointRatio` (default **0.5**) at that moment, the next step starts on
+  compacted history. Same notice, same `compactRegion()` path as `compact_now`.
+- dsh's own 80% trigger stays as the backstop; this just gets there first, at a clean boundary.
+- A failure here never breaks the turn. It logs a warning and the backstop takes over.
+- Tune or turn it off in your profile's `cordis.patch.yml`:
+
+  ```yaml
+  - id: tool-compact-now
+    config:
+      safePointRatio: 0.6   # or false to disable
+  ```
+
 ## How it works
 
 Two entry points exist on dsh's compaction service: `compactNow()` (what the human `/compact`
@@ -71,19 +108,52 @@ Run the equivalent by hand from the profile directory, e.g. `~/.dsh/profiles/web
 smart-compaction`, then add `"smart-compaction"` to that `package.json`'s `dsh.profile.bundles`
 array yourself.)
 
-No build step, no config. Restart your dsh service after adding it — new bundles are only picked
-up on boot.
-
-**`compact_now` requires a `compaction` service on your profile.** Most profile templates ship
-one, but not all do (e.g. `@deepseek-ai/dsh-web-app`-based profiles don't by default). If yours
-doesn't, `compact_now` still installs cleanly (it won't break your profile's boot) but returns an
-error every time it's called: `"no compaction service is configured on this profile"`. Add a
-`compaction-basic` bundle to get one.
+No build step. Restart your dsh service after adding it — new bundles are only picked up on boot.
+
+<details>
+<summary><b>Requirements and preset-isolated profiles</b> (read this if <code>compact_now</code> says no compaction service is configured)</summary>
+
+**`compact_now` requires a `compaction` service reachable from wherever this plugin itself is
+mounted** — it reads `ctx.get('compaction')` at its own mount point, nothing fancier. Most profile
+templates ship one at the host plane and the ordinary bundle install above is enough. But
+`@deepseek-ai/dsh-web-app`-based profiles are different: they disable the host-plane
+`compaction-basic` row and instead have each **preset** mount its own private instance inside an
+isolated cordis realm (`isolate: { compaction: true }`). Isolation in cordis is strictly downward —
+only a plugin mounted as a *descendant of that exact group* can see it (`vendor/cordis/src/service.ts`).
+A plugin on the host plane, including this one installed the ordinary way, is that isolated
+compaction's ancestor, not a descendant, so it can never see it no matter how cleverly it reads the
+service at call time. The only fix is a second, scoped copy of this plugin mounted as a sibling row
+inside that same isolated group — which safely coexists with the host-plane copy (dsh-tools' scoped
+tool registrations shadow the global one in a separate layer, see `ScopedLayers.merge` in
+`packages/core/scope/src/store.ts`).
+
+This package's own `postinstall` script (`scripts/mount-into-presets.mjs`) does that automatically:
+it scans `$DSH_HOME/.agent-presets/*/agent.cordis.yml` (your local, user-owned preset overrides —
+never a shipped read-only preset under `node_modules`) for any preset that already isolates
+`@deepseek-ai/dsh-compaction-basic`, and inserts a scoped `smart-compaction` row as its sibling if
+one isn't already there. It's idempotent and a no-op (with a one-line log saying so) on profiles
+that don't use presets at all. **Modern npm and pnpm block postinstall scripts by default** —
+you'll need to approve it once: `npm install-scripts approve smart-compaction`, or for pnpm, add
+`smart-compaction: true` under `allowBuilds` in the profile's `pnpm-workspace.yaml` (or run
+`pnpm approve-builds` if your pnpm version offers it) — then reinstall. If you add a new preset
+later, or skipped the approval, re-run it anytime with
+`npx smart-compaction-mount-into-presets` (or `pnpm exec smart-compaction-mount-into-presets` from
+the profile directory).
+
+If `compact_now` still errors with `"no compaction service is configured on this profile"` after
+that, your agent's preset genuinely has no `compaction-basic` anywhere in its scope chain — add one
+(see [`docs/subsystems/compaction.md`](https://github.com/deepseek-ai/deepseek-harness/blob/main/docs/subsystems/compaction.md)
+in the harness repo).
 
 **`context_status` requires `@deepseek-ai/dsh-token-meter` mounted** (it registers the
-`contextPressure` projection this tool reads). It's normally pulled in wherever `compaction-basic`
-is, so if `compact_now` works, `context_status` should too. If it isn't mounted, the tool still
-installs cleanly and just reports `available: false` instead of erroring.
+`contextPressure` projection this tool reads). Unlike `compaction-basic`, the token meter is
+deliberately kept on the **host plane** even on preset-isolated profiles (it owns a process-wide,
+per-session projection table, not something that should come and go with which preset is mounted),
+so the ordinary host-plane install always sees it — no preset patching needed for this one. If it
+isn't mounted at all, the tool still installs cleanly and just reports `available: false` instead of
+erroring.
+
+</details>
 
 ### Tell the model when to use it
 
@@ -97,9 +167,19 @@ an early version of this plugin, which relied entirely on a hand-written `AGENTS
 description alone wasn't a strong enough signal.
 
 That said, standing instructions carry more weight than a tool description competing against
-everything else in a long tool catalog. If you want to reinforce it further, copy
-[`agents-snippet.md`](./agents-snippet.md) into your `AGENTS.md` (or whatever your profile injects
-as standing instructions).
+everything else in a long tool catalog. If you want to reinforce it further, copy this
+into your `AGENTS.md` (or whatever your profile injects as standing instructions):
+
+> After marking a todo item `completed` (never while one is `in_progress`), call `context_status`.
+> Don't just compare the number to a fixed threshold — that's still reactive, and a step that
+> turns out bigger than expected can blow past a comfortable-looking percentage mid-step. Instead,
+> weigh what's left against what the *next* step will actually cost (a big file read, a long diff,
+> a subagent dispatch); if it's not clearly going to fit with room to spare, call `compact_now`
+> now, even while usage still looks moderate. Compacting a little early costs nothing; running out
+> mid-step loses exactly the context that step needed. As a hard backstop, usage past roughly
+> 70-80% of the context window is reason enough to compact regardless. Both tools are safe to call
+> speculatively — `context_status` is read-only, and `compact_now` no-ops if there isn't enough
+> history to compact yet.
 
 Tying this to todo-completion matters: it's a real, already-tracked signal for "I just finished a
 self-contained unit of work," instead of asking the model to estimate its own remaining work or

package/index.js

@@ -17,8 +17,18 @@
 
 import { toolPairingBalancedBefore } from '@deepseek-ai/dsh-compaction'
 import { defineTool } from '@deepseek-ai/dsh-tools'
+import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import { summarizeContextUsage } from './context-status.js'
 import { selectCompactableRange } from './select-range.js'
+import { completedCount, DEFAULT_SAFE_POINT_RATIO, finishedStep, overSafePointRatio } from './safe-point.js'
+
+// dsh 0.2 (session format v4) rejects the old generic `kind: 'plugin'` wrapper:
+// every producer stamps its own kind, like repeat-tool-reminder does.
+const PLUGIN_SOURCE = { kind: 'smart-compaction' }
+const STARTED_NOTICE_TEXT =
+  '⏳ Compacting now — summarizing older history. This runs one extra model '
+  + 'call and can take a while on a local model; the chat will look idle '
+  + 'until it lands.'
 
 export const name = 'tool-compact-now'
 // `compaction` deliberately NOT in `inject`: that would make this plugin's
@@ -44,10 +54,48 @@ const DESCRIPTION =
   + 'Harmless to call speculatively either way — it no-ops if there is not enough history to '
   + 'compact yet.'
 
+/**
+ * Compact the largest safe span of `agent`'s history. Shared by the
+ * `compact_now` tool and the automatic safe-point trigger.
+ * @returns {Promise<{ compacted: false } | { compacted: true, shadowedCount: number, shadowedTokenCount: number }>}
+ */
+async function compactAgent(compaction, agent, signal, notice) {
+  const session = agent.session
+  const range = selectCompactableRange(session, toolPairingBalancedBefore)
+  if (range === null) return { compacted: false }
+  // Posted before the slow part (the summarization model call inside
+  // compactRegion, which can run minutes on a local model), not after:
+  // without this, the chat shows nothing until it lands and looks stuck.
+  // `session.append` publishes synchronously to live observers.
+  // An own `kind` + `form: 'notice'` is the same tagging
+  // dsh-compaction-basic and repeat-tool-reminder use for host-generated
+  // asides — collapsed by default, never rendered as if the user typed it.
+  session.append('user/message', createUserMessage({
+    content: [{ type: 'text', text: notice }],
+    source: { ...PLUGIN_SOURCE, form: 'notice', summary: 'Compacting now' },
+  }), { surfaceOp: 'append' })
+  const result = await compaction.compactRegion(range.start, range.end, agent, signal)
+  return {
+    compacted: true,
+    shadowedCount: result.shadowedSeqs.length,
+    shadowedTokenCount: result.shadowedTokenCount,
+  }
+}
+
+/** Current usage for `session`, via token-meter's contextPressure projection. */
+function usageOf(ctx, session) {
+  const projections = ctx.get('sessionProjections')
+  if (!projections) return { available: false }
+  return summarizeContextUsage(projections.stateOf(session, 'contextPressure'))
+}
+
 /**
  * @param {import('@deepseek-ai/cordis').Context} ctx
+ * @param {{ safePointRatio?: number | false }} [config] - `safePointRatio`:
+ *   usage fraction (0-1) at which finishing a todo item compacts
+ *   automatically; `false` turns the automatic trigger off. Default 0.5.
  */
-export function apply(ctx) {
+export function apply(ctx, config = {}) {
   ctx.tools.register(defineTool({
     name: 'compact_now',
     description: DESCRIPTION,
@@ -77,25 +125,11 @@ export function apply(ctx) {
       if (!exec.agent) {
         throw new Error('compact_now requires an owning agent session')
       }
-      const session = exec.agent.session
-      const range = selectCompactableRange(session, toolPairingBalancedBefore)
-      if (range === null) {
-        return { compacted: false }
-      }
-      let result
       try {
-        result = await compaction.compactRegion(range.start, range.end, exec.agent, exec.signal)
+        return await compactAgent(compaction, exec.agent, exec.signal, STARTED_NOTICE_TEXT)
       } catch (error) {
-        // The four errors compactRegion's own range validation can throw all
-        // indicate this file's range-selection logic disagrees with core's —
-        // a bug here, not an expected runtime outcome. Surface it plainly.
         throw new Error(`compact_now: compaction failed: ${error instanceof Error ? error.message : String(error)}`)
       }
-      return {
-        compacted: true,
-        shadowedCount: result.shadowedSeqs.length,
-        shadowedTokenCount: result.shadowedTokenCount,
-      }
     },
   }))
 
@@ -127,6 +161,48 @@ export function apply(ctx) {
       return summarizeContextUsage(state)
     },
   }))
+
+  // --- automatic safe-point compaction (see safe-point.js) ---------------
+  // Local models rarely call compact_now on their own, so the plugin also
+  // compacts by itself: a todo item flipping to completed marks a safe
+  // boundary, and the next step starts on compacted history if usage is past
+  // `safePointRatio`. Core's own 80% trigger stays as the backstop.
+  const ratio = config.safePointRatio ?? DEFAULT_SAFE_POINT_RATIO
+  if (ratio === false) return
+  if (typeof ratio !== 'number' || !(ratio > 0 && ratio < 1)) {
+    throw new Error(`smart-compaction: safePointRatio must be a number between 0 and 1, or false (got ${ratio})`)
+  }
+  const lastCompleted = new WeakMap()
+  const atSafePoint = new WeakSet()
+
+  ctx.on('tools/post-execute', async (exec, _result, next) => {
+    if (exec.agent && exec.name === 'todo_write') {
+      const done = completedCount(exec.arguments)
+      if (finishedStep(lastCompleted.get(exec.agent), done)) atSafePoint.add(exec.agent)
+      lastCompleted.set(exec.agent, done)
+    }
+    return next()
+  })
+
+  ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
+    if (!atSafePoint.has(agent) || signal.aborted) return next()
+    atSafePoint.delete(agent)
+    // Not mounted next to a compaction service (e.g. the host-plane copy on a
+    // preset-isolated profile): the in-realm copy handles it.
+    const compaction = ctx.get('compaction')
+    if (!compaction) return next()
+    const usage = usageOf(ctx, agent.session)
+    if (!overSafePointRatio(usage, ratio)) return next()
+    try {
+      await compactAgent(compaction, agent, signal,
+        `⏳ Step finished with ${usage.percentUsed}% of the context used — compacting now, `
+        + 'before the next step. This runs one extra model call and can take a while on a local model.')
+    } catch (error) {
+      // Never break the turn: core's own pressure trigger is still the backstop.
+      console.warn(`smart-compaction: safe-point compaction failed: ${error instanceof Error ? error.message : String(error)}`)
+    }
+    return next()
+  })
 }
 
 const CONTEXT_STATUS_DESCRIPTION =

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smart-compaction",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "dsh plugin: a compact_now tool letting the model trigger compaction itself at a safe point, plus a context_status tool so it can check real token usage against its context window, instead of only the automatic token-threshold trigger.",
   "type": "module",
   "main": "./index.js",
@@ -55,15 +55,25 @@
     "index.js",
     "select-range.js",
     "context-status.js",
-    "cordis.patch.yml"
+    "safe-point.js",
+    "cordis.patch.yml",
+    "scripts/mount-into-presets.mjs"
   ],
+  "bin": {
+    "smart-compaction-mount-into-presets": "scripts/mount-into-presets.mjs"
+  },
+  "scripts": {
+    "postinstall": "node scripts/mount-into-presets.mjs"
+  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "*",
     "@deepseek-ai/dsh-compaction": "*",
+    "@deepseek-ai/dsh-llm": "*",
     "@deepseek-ai/dsh-tools": "*"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-compaction": "0.0.1-rc.5",
+    "@deepseek-ai/dsh-llm": "0.0.1-rc.1",
     "@deepseek-ai/dsh-tools": "0.0.1-rc.1"
   }
 }

package/safe-point.js

@@ -0,0 +1,42 @@
+/**
+ * Automatic safe-point compaction: the plugin's answer to "local models
+ * rarely call compact_now on their own". Instead of waiting for the model to
+ * decide, the plugin treats "a todo item just flipped to completed" as the
+ * safe boundary and compacts before the next step whenever usage is already
+ * past `ratio` of the context window — well below core's own 80% trigger,
+ * which fires wherever the step happens to land.
+ *
+ * Pure helpers only; index.js wires them to `tools/post-execute` and
+ * `agent/pre-step`.
+ */
+
+/** Default usage fraction at which a finished todo item triggers compaction. */
+export const DEFAULT_SAFE_POINT_RATIO = 0.5
+
+/**
+ * Number of completed items in a `todo_write` argument list (0 on bad input).
+ * @param {unknown} args
+ */
+export function completedCount(args) {
+  const todos = args !== null && typeof args === 'object' ? /** @type {any} */ (args).todos : undefined
+  return Array.isArray(todos) ? todos.filter(t => t?.status === 'completed').length : 0
+}
+
+/**
+ * Whether a todo_write moved the completed count up (= a step just finished).
+ * A count going down (new turn, rewritten list) only resets the baseline.
+ * @param {number | undefined} before - completed count from this agent's previous todo_write.
+ * @param {number} after
+ */
+export function finishedStep(before, after) {
+  return after > (before ?? 0)
+}
+
+/**
+ * Whether usage is high enough to compact at a safe point.
+ * @param {{ available: boolean, percentUsed?: number }} usage - summarizeContextUsage() output.
+ * @param {number} ratio - 0..1
+ */
+export function overSafePointRatio(usage, ratio) {
+  return usage.available && usage.percentUsed !== undefined && usage.percentUsed >= ratio * 100
+}

package/scripts/mount-into-presets.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * Postinstall: mount smart-compaction inside every local preset that already
+ * has `@deepseek-ai/dsh-compaction-basic` isolated in its own cordis realm
+ * (the shape `@deepseek-ai/dsh-web-app`-based profiles use).
+ *
+ * Why this exists: dsh-web-app disables the host-plane `compaction-basic`
+ * row and each preset mounts its own private instance inside an isolated
+ * cordis group (`isolate: { compaction: true }`). Cordis's isolation is
+ * strictly downward — only plugins mounted as descendants of that exact
+ * group see the private instance (vendor/cordis/src/service.ts's isolate-tag
+ * check). A plugin installed the normal way, as a profile bundle, mounts on
+ * the host plane — an ANCESTOR of every preset's realm, not a descendant —
+ * so it can never see that isolated compaction service, no matter how it
+ * reads it at call time.
+ *
+ * The only fix is mounting a second, scoped copy of this plugin as a sibling
+ * row inside that same isolated group. That row shadows the host-plane one
+ * for any agent running that preset (dsh-tools' scoped registrations shadow
+ * globals in a different layer — see packages/core/scope/src/store.ts's
+ * `ScopedLayers.merge`), so it's safe to coexist with the ordinary
+ * `dsh plugin add` bundle-list install used on profiles that DON'T isolate
+ * compaction (where the host-plane copy just works on its own).
+ *
+ * Patches with plain line surgery, not a parse/reserialize round-trip: a
+ * full YAML library round-trip (tried first) reflowed unrelated parts of the
+ * file (block-scalar indentation, flow-sequence spacing) even though only
+ * one line was meant to change — unacceptable for a script whose whole job
+ * is not surprising the user. This only ever inserts new lines; every byte
+ * of the rest of the file is untouched.
+ *
+ * Idempotent, best-effort, never fails the parent install: skipped entirely
+ * when `$DSH_HOME/.agent-presets` doesn't exist (simple/non-preset profile —
+ * nothing to do), and per-file errors are warned, not thrown. Only ever
+ * touches the user's own local preset overrides, never a shipped read-only
+ * preset under node_modules.
+ * @module scripts/mount-into-presets
+ */
+
+import { readFile, writeFile, readdir } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+const COMPACTION_BASIC_NAME_RE = /name:\s*['"]?@deepseek-ai\/dsh-compaction-basic['"]?\s*$/
+const OUR_NAME = 'smart-compaction'
+const ITEM_START_RE = /^(\s*)-\s/
+
+/**
+ * @param {string} text
+ * @returns {string | null} patched text, or null if nothing to do (already
+ *   mounted, or this preset doesn't isolate compaction-basic at all)
+ */
+function patchPresetText(text) {
+  if (text.includes(`name: ${OUR_NAME}`)) return null // already mounted somewhere
+
+  const lines = text.split('\n')
+  const nameLineIdx = lines.findIndex(line => COMPACTION_BASIC_NAME_RE.test(line))
+  if (nameLineIdx === -1) return null // this preset doesn't isolate compaction-basic
+
+  // Walk back to the "- id: compaction-basic" (or however it's labeled) item start.
+  let itemStartIdx = -1
+  for (let i = nameLineIdx; i >= 0; i--) {
+    if (ITEM_START_RE.test(lines[i])) {
+      itemStartIdx = i
+      break
+    }
+  }
+  if (itemStartIdx === -1) return null // unexpected shape, don't guess
+
+  const indent = lines[itemStartIdx].match(ITEM_START_RE)[1].length
+
+  // Scan forward through this list's siblings (indent >= the item's own indent
+  // keeps nested `config:` sub-blocks in scope); a strictly shallower non-blank
+  // line means the list ended. Track the last non-blank line actually in it so
+  // trailing blank lines before the next section are preserved as-is.
+  let lastNonBlankIdx = itemStartIdx
+  let i = itemStartIdx + 1
+  for (; i < lines.length; i++) {
+    const line = lines[i]
+    if (line.trim() === '') continue
+    const lineIndent = line.length - line.trimStart().length
+    if (lineIndent < indent) break
+    lastNonBlankIdx = i
+  }
+
+  const pad = ' '.repeat(indent)
+  const insertion = ['', `${pad}- id: ${OUR_NAME}`, `${pad}  name: ${OUR_NAME}`]
+  lines.splice(lastNonBlankIdx + 1, 0, ...insertion)
+  return lines.join('\n')
+}
+
+/**
+ * @param {string} filePath
+ * @returns {Promise<'mounted' | 'already-mounted' | 'no-isolated-compaction'>}
+ */
+async function patchPresetFile(filePath) {
+  const text = await readFile(filePath, 'utf8')
+  if (text.includes(`name: ${OUR_NAME}`)) return 'already-mounted'
+  const patched = patchPresetText(text)
+  if (patched === null) return 'no-isolated-compaction'
+  await writeFile(filePath, patched)
+  return 'mounted'
+}
+
+async function main() {
+  const dshHome = process.env.DSH_HOME ?? join(homedir(), '.dsh')
+  const presetsDir = join(dshHome, '.agent-presets')
+  if (!existsSync(presetsDir)) {
+    console.log(`smart-compaction: no local presets at ${presetsDir} — nothing to mount (ordinary profile-bundle install covers this profile).`)
+    return
+  }
+
+  let entries
+  try {
+    entries = await readdir(presetsDir, { withFileTypes: true })
+  } catch (error) {
+    console.warn(`smart-compaction: could not read ${presetsDir}: ${error instanceof Error ? error.message : String(error)}`)
+    return
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const filePath = join(presetsDir, entry.name, 'agent.cordis.yml')
+    if (!existsSync(filePath)) continue
+    try {
+      const result = await patchPresetFile(filePath)
+      if (result === 'mounted') {
+        console.log(`smart-compaction: mounted inside preset "${entry.name}" (${filePath})`)
+      } else if (result === 'already-mounted') {
+        console.log(`smart-compaction: already mounted in preset "${entry.name}" — nothing to do.`)
+      }
+      // 'no-isolated-compaction': this preset doesn't isolate compaction-basic, nothing to do.
+    } catch (error) {
+      console.warn(`smart-compaction: could not patch ${filePath}: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+}
+
+await main()