@pi-unipi/unipi 2.0.3 → 2.0.5

package/packages/compactor/skills/compactor-detail/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: compactor-detail
-description: Full compactor reference — tool parameters, anti-patterns, sandbox languages, FTS5 modes, workflows.
+description: Full compactor reference — tool parameters, anti-patterns, sandbox languages, context budget, workflows.
 ---
 
 # Compactor — Full Reference
@@ -9,70 +9,65 @@ description: Full compactor reference — tool parameters, anti-patterns, sandbo
 
 ### compact
 ```
-compact()
+compact(dryRun?: boolean)
 ```
-Trigger manual context compaction. Zero LLM — pure regex/text processing.
-Returns stats after next `session_compact` event.
+Agent-facing compaction request. Use `dryRun: true` to preview estimated message reduction without compacting.
+
+For user-triggered immediate compaction, prefer the slash command `/unipi:lossless-compact`.
 
 ### session_recall
 ```
 session_recall(query: string, mode?: "bm25" | "regex", limit?: number, offset?: number, expand?: boolean)
 ```
-Search session history. BM25 is default (TF-IDF ranked). Regex is fallback.
+Search current session history. BM25 is default; regex is fallback. The recall path prefers Pi's append-only session branch so it can find messages that are no longer present in live LLM context after compaction.
+
+Deprecated alias: `vcc_recall`.
 
 ### sandbox
 ```
 sandbox(language: string, code: string, timeout?: number)
 ```
-Run code in sandboxed env. Only stdout enters context. 100MB output cap. 30s default timeout.
+Run code in a sandboxed environment. Only stdout enters context. 100MB output cap. 30s default timeout.
+
+Deprecated alias: `ctx_execute`.
 
 ### sandbox_file
 ```
 sandbox_file(language: string, path: string, timeout?: number)
 ```
-Execute file. Content injected as `FILE_CONTENT` variable.
+Execute a file. File content is injected as `FILE_CONTENT`.
 
-### sandbox_batch
-```
-sandbox_batch(items: Array<{type: "execute", language, code} | {type: "search", query}>)
-```
-Atomic batch — all items run, results returned together.
+Deprecated alias: `ctx_execute_file`.
 
-### content_index
+### sandbox_batch
 ```
-content_index(label: string, content?: string, filePath?: string, contentType?: "markdown"|"json"|"plain", chunkSize?: number)
+sandbox_batch(items: Array<{ type: "execute", language: string, code: string, timeout?: number }>)
 ```
-Index content into FTS5. Provide either `content` or `filePath`. Auto-chunks by type.
+Run multiple sandbox executions and return a single combined result.
 
-### content_search
-```
-content_search(query: string, limit?: number, offset?: number)
-```
-Search FTS5 index. Returns ranked results with title, content, source, rank.
-
-### content_fetch
-```
-content_fetch(url: string, label?: string, chunkSize?: number)
-```
-Fetch URL → markdown → index. Auto-indexes for later search.
+Deprecated alias: `ctx_batch_execute`.
 
 ### compactor_stats
 ```
 compactor_stats()
 ```
-Dashboard: session events, compactions, tokens saved, indexed docs, sandbox runs, search queries.
+Dashboard: session events, compactions, tokens saved, compression ratio, sandbox runs, and search queries.
+
+Deprecated alias: `ctx_stats`.
 
 ### compactor_doctor
 ```
 compactor_doctor()
 ```
-Diagnostics: config file, session DB, content store, runtimes (node, python3, bash).
+Diagnostics: config file, session DB, and available runtimes (node, python3, bash).
+
+Deprecated alias: `ctx_doctor`.
 
 ### context_budget
 ```
 context_budget()
 ```
-Estimate remaining context tokens and % full. Returns guidance on whether to compact.
+Estimate remaining context tokens and percent full. Uses Pi's live context usage when available and includes percentage auto-compaction guidance when enabled.
 
 ## Sandbox Language Reference
 
@@ -90,44 +85,34 @@ Estimate remaining context tokens and % full. Returns guidance on whether to com
 | r | Rscript | 30s | - |
 | elixir | elixir | 30s | - |
 
-## FTS5 Search Modes
-
-| Mode | When To Use |
-|------|-------------|
-| **porter** | Exact term matching with stemming |
-| **trigram** | Fuzzy/spelling errors, partial matches |
-| **rrf** | Best overall (Reciprocal Rank Fusion of porter+trigram) |
-| **fuzzy** | Auto-correction of misspellings from vocabulary |
-
-Default: `rrf` (best general-purpose).
-
 ## Anti-Patterns
 
-1. **Don't call `compact` in a tight loop.** It triggers the full compaction pipeline. Call once before complex work.
-2. **Don't search without indexing.** `content_search` has nothing to search until you `content_index` or `content_fetch`.
-3. **Don't use `sandbox` for file ops.** Use bash instead. Sandbox is for computation.
-4. **Don't use `session_recall` with empty query.** It needs meaningful search terms.
-5. **Don't index node_modules.** Stick to source files and documentation.
-6. **Don't compact mid-task.** Wait for a natural break point.
+1. **Don't compact in a tight loop.** Use `context_budget` first and compact at natural break points.
+2. **Don't use `session_recall` for project-wide code search.** It searches the conversation/session. Use CocoIndex (`cocoindex_search`) for indexed files when installed.
+3. **Don't use `sandbox` for file operations.** Use normal file tools for reads/writes; sandbox is for computation or quick scripts.
+4. **Don't use empty or vague recall queries.** Search for specific filenames, issue numbers, commands, or decisions.
+5. **Don't compact mid-thought if avoidable.** Finish the current step, then compact.
 
 ## Workflow Patterns
 
-### Research → Index → Search → Test
-1. `content_fetch(url)` — index reference docs
-2. `content_search(query)` — find relevant sections
-3. `sandbox(lang, code)` — test hypotheses
-
-### Diagnose → Fix → Verify
-1. `compactor_doctor` — check system health
-2. Fix issues (install runtimes, rebuild index)
-3. `compactor_stats` — verify metrics
-
 ### Before Complex Work
-1. `compact` — free up context
-2. `content_index` — index relevant files
-3. `session_recall("goals")` — load context
-
-### After Long Session
-1. `compactor_stats` — check savings
-2. `compact` — compact if needed
-3. `session_recall(topic)` — verify recall quality
+1. `context_budget` — check pressure.
+2. `session_recall("goal files decisions")` — recover relevant prior context.
+3. `compact(dryRun: true)` — preview if context is tight.
+4. `/unipi:lossless-compact` or `compact` at a clean boundary.
+
+### Diagnose Compactor Health
+1. `compactor_doctor` — check config, DB, runtimes.
+2. Fix reported issues.
+3. `compactor_stats` — verify counters and savings.
+
+### Long Session Recovery
+1. `session_recall(query)` — find older details hidden by compaction.
+2. `context_budget` — decide whether another compaction is needed.
+3. `compactor_stats` — confirm compactions/savings are recorded.
+
+### Project Search
+Compactor no longer owns project content indexing. Use the CocoIndex package if installed:
+1. `/unipi:cocoindex-init`
+2. `/unipi:cocoindex-update`
+3. `cocoindex_search(query)`

package/packages/compactor/skills/compactor-doctor/SKILL.md

@@ -1,55 +1,53 @@
 ---
 name: compactor-doctor
-description: Diagnostics — validate config, DB, FTS5, runtimes, troubleshoot issues.
+description: Diagnostics — validate config, session DB, runtimes, and troubleshoot compactor issues.
 ---
 
 # Compactor Doctor
 
 Run diagnostics and troubleshoot compactor issues.
 
-## Commands
+## Commands and Tools
 
-- `/unipi:compact-doctor` — run all checks
-- `ctx_doctor` tool — agent-callable diagnostics
+- `/unipi:compact-doctor` — user-facing diagnostics
+- `compactor_doctor` tool — agent-callable diagnostics
+- `ctx_doctor` tool — deprecated alias
 
 ## Checks Performed
 
 | Check | What It Validates |
 |-------|-------------------|
-| **Config file** | `~/.unipi/config/compactor/config.json` exists and is valid |
-| **Session DB** | SQLite connection works, schema correct |
-| **Content Store** | FTS5 index accessible, tables exist |
-| **Runtime: node** | Node.js available for sandbox |
-| **Runtime: python3** | Python 3 available for sandbox |
-| **Runtime: bash** | Bash available for sandbox |
+| **Config file** | `~/.unipi/config/compactor/config.json` exists or defaults can be used |
+| **Session DB** | SQLite connection works and session schema is usable |
+| **Runtime: node** | Node.js available for sandbox/runtime helpers |
+| **Runtime: python3** | Python 3 available for Python sandbox execution |
+| **Runtime: bash** | Bash available for shell sandbox execution |
 
 ## Status Icons
 
 - ✅ **pass** — check succeeded
-- ⚠️ **warn** — non-critical issue (e.g., optional runtime missing)
-- ❌ **fail** — critical issue, feature may not work
+- ⚠️ **warn** — non-critical issue, such as an optional runtime missing
+- ❌ **fail** — critical issue; a feature may not work
 
 ## Common Issues
 
 ### "Config file: Using defaults"
-- Normal on first run
-- Config auto-created on next settings save
-- Fix: `/unipi:compact-settings` → save
+
+- Normal on first run.
+- Config is created by the extension or on settings save.
+- Fix: open `/unipi:compact-settings`, adjust if desired, then save.
 
 ### "Session DB: Connection failed"
-- SQLite not available
-- Check if `better-sqlite3` is installed
-- Fix: `npm install better-sqlite3`
 
-### "Content Store: FTS5 error"
-- SQLite FTS5 extension not available
-- Requires SQLite 3.9+ with FTS5
-- Fix: Update system SQLite
+- SQLite or `better-sqlite3` may be unavailable.
+- Compaction can still degrade gracefully, but stats/recall may be limited.
+- Fix: verify dependencies and run package install/build steps.
 
 ### "Runtime: python3 Not found"
-- Python not installed or not in PATH
-- Only needed for Python sandbox execution
-- Fix: Install Python 3 or ignore if not needed
+
+- Python is not installed or not in `PATH`.
+- Only needed for Python sandbox execution.
+- Fix: install Python 3 or ignore if not needed.
 
 ## Manual Diagnostics
 
@@ -63,12 +61,11 @@ cat ~/.unipi/config/compactor/config.json
 ls -la ~/.unipi/db/compactor/
 ```
 
-### Check SQLite version
+### Check runtimes
 ```bash
-sqlite3 --version
+node --version
+python3 --version
+bash --version
 ```
 
-### Test FTS5
-```bash
-sqlite3 ':memory:' "CREATE VIRTUAL TABLE t USING fts5(x); SELECT 1;"
-```
+Project content indexing diagnostics live in the CocoIndex package, not compactor.

package/packages/compactor/skills/compactor-stats/SKILL.md

@@ -1,49 +1,51 @@
 ---
 name: compactor-stats
-description: Stats display — context savings, session metrics, index health.
+description: Stats display — context savings, session metrics, compactions, sandbox and recall/search counters.
 ---
 
 # Compactor Stats
 
 Display and interpret compactor statistics.
 
-## Commands
+## Commands and Tools
 
-- `/unipi:compact-stats` — quick dashboard
-- `ctx_stats` tool — detailed stats (agent-callable)
+- `/unipi:compact-stats` — user-facing dashboard
+- `compactor_stats` tool — agent-callable stats
+- `ctx_stats` tool — deprecated alias
 
 ## Metrics Explained
 
 | Metric | Description |
 |--------|-------------|
-| **Session events** | Total events tracked in current session |
-| **Compactions** | Number of times context was compacted |
-| **Tokens saved** | Estimated tokens freed by compaction |
-| **Indexed docs** | Number of files/sources in FTS5 index |
-| **Indexed chunks** | Total searchable chunks |
-| **Sandbox runs** | Code executions in sandbox |
-| **Search queries** | FTS5 searches performed |
+| **Session events** | Events tracked for the current session in the compactor session DB |
+| **Compactions** | Number of compaction events recorded |
+| **Tokens saved** | Estimated tokens freed by compaction, using Pi token counts when available and DB fallbacks otherwise |
+| **Compression ratio** | Approximate before/kept ratio from stored compaction stats |
+| **Sandbox runs** | Agent sandbox executions recorded in runtime counters/DB |
+| **Search queries** | Session recall/search queries recorded in runtime counters/DB |
 
 ## Health Indicators
 
-- **Compactions > 0** on long sessions = working correctly
-- **Indexed chunks > 0** = search available
-- **Sandbox runs** = code execution active
+- **Compactions > 0** on long sessions = compaction is happening.
+- **Tokens saved > 0** after compaction = savings were recorded.
+- **Sandbox runs** increasing = sandbox tool usage is tracked.
+- **Search queries** increasing = recall/search activity is tracked.
 
 ## Reading Stats
 
-```
+```text
 📊 Compactor Stats
 Session events: 42
 Compactions: 3
 Tokens saved: 15000
-Indexed docs: 12 (48 chunks)
 Sandbox runs: 7
 Search queries: 15
 ```
 
 This means:
-- 42 tool calls/events tracked
-- 3 compactions saved ~15K tokens
-- 12 files indexed into 48 searchable chunks
-- 7 code executions, 15 searches performed
+
+- 42 events are tracked for the session.
+- 3 compactions saved roughly 15K tokens.
+- 7 sandbox executions and 15 recall/search queries were recorded.
+
+Project content indexing stats are not owned by compactor anymore; use the CocoIndex package for indexed file search/status.

package/packages/compactor/src/commands/index.ts

@@ -229,9 +229,12 @@ export function registerCommands(pi: ExtensionAPI, deps?: CommandDeps): void {
         "  /unipi:session-recall <query> — search session history\n" +
         "  /unipi:compact-stats — view stats\n" +
         "  /unipi:compact-doctor — run diagnostics\n" +
-        "  /unipi:compact-settings — TUI settings\n" +
+        "  /unipi:compact-settings — TUI settings, including optional % auto-compaction\n" +
         "  /unipi:compact-preset <name> — apply preset\n" +
         "\n" +
+        "Percentage trigger:\n" +
+        "  Disabled by default. Enable in /unipi:compact-settings to compact at a context % before Pi's reserve-token limit.\n" +
+        "\n" +
         "Content indexing has moved to @pi-unipi/cocoindex:\n" +
         "  /unipi:cocoindex-init — initialize pipeline\n" +
         "  /unipi:cocoindex-update — index project files\n" +

package/packages/compactor/src/compaction/auto-trigger.ts

@@ -0,0 +1,306 @@
+/**
+ * Pure percentage auto-compaction trigger decisions.
+ *
+ * The runtime wiring owns Pi ctx access; this module only decides whether a
+ * known context-usage sample should trigger UniPi's zero-LLM compaction.
+ */
+
+import type { AutoCompactionConfig } from "../types.js";
+
+export interface AutoCompactionUsage {
+  tokens?: number | null;
+  percent?: number | null;
+  contextWindow?: number | null;
+}
+
+export interface KnownAutoCompactionUsage {
+  tokens: number;
+  percent: number;
+  contextWindow?: number;
+}
+
+export interface AutoCompactionState {
+  /** Previous known context percentage sample. Null before first known usage. */
+  previousPercent: number | null;
+  /** Previous known context token sample. Null before first known usage. */
+  previousTokens: number | null;
+  /** True after UniPi calls ctx.compact() and before Pi reports completion/error. */
+  inFlight: boolean;
+  /** Timestamp of the last UniPi-triggered compaction attempt. */
+  lastTriggerAt: number | null;
+  /** Context tokens reported at the last UniPi-triggered compaction attempt. */
+  lastTriggerTokens: number | null;
+  /** Baseline used to require meaningful token growth for repeat high-usage triggers. */
+  repeatBaselineTokens: number | null;
+  /** After a successful compaction, consume one known usage sample as a fresh baseline. */
+  awaitingPostCompactionSample: boolean;
+}
+
+export type AutoCompactionDecisionReason =
+  | "disabled"
+  | "unknown_usage"
+  | "in_flight"
+  | "below_threshold"
+  | "post_compaction_baseline"
+  | "threshold_reached"
+  | "threshold_crossed"
+  | "cooldown_active"
+  | "repeat_growth_needed"
+  | "repeat_growth_reached";
+
+export interface AutoCompactionDecision {
+  shouldTrigger: boolean;
+  reason: AutoCompactionDecisionReason;
+  state: AutoCompactionState;
+  thresholdPercent: number;
+  usage?: KnownAutoCompactionUsage;
+  cooldownRemainingMs?: number;
+  tokenGrowth?: number;
+  tokensUntilRepeat?: number;
+}
+
+export interface AutoCompactionDecisionInput {
+  config?: Partial<AutoCompactionConfig> | null;
+  usage?: AutoCompactionUsage | null;
+  state: AutoCompactionState;
+  nowMs?: number;
+}
+
+export const AUTO_COMPACTION_DEFAULTS: AutoCompactionConfig = {
+  enabled: false,
+  thresholdPercent: 80,
+  cooldownMs: 60_000,
+  repeatMinGrowthTokens: 4_000,
+  notify: true,
+};
+
+const clamp = (value: unknown, fallback: number, min: number, max: number): number => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.min(max, Math.max(min, value));
+};
+
+export function normalizeAutoCompactionConfig(config?: Partial<AutoCompactionConfig> | null): AutoCompactionConfig {
+  return {
+    enabled: config?.enabled ?? AUTO_COMPACTION_DEFAULTS.enabled,
+    thresholdPercent: clamp(
+      config?.thresholdPercent,
+      AUTO_COMPACTION_DEFAULTS.thresholdPercent,
+      1,
+      99,
+    ),
+    cooldownMs: Math.round(clamp(
+      config?.cooldownMs,
+      AUTO_COMPACTION_DEFAULTS.cooldownMs,
+      0,
+      24 * 60 * 60 * 1000,
+    )),
+    repeatMinGrowthTokens: Math.round(clamp(
+      config?.repeatMinGrowthTokens,
+      AUTO_COMPACTION_DEFAULTS.repeatMinGrowthTokens,
+      0,
+      10_000_000,
+    )),
+    notify: config?.notify ?? AUTO_COMPACTION_DEFAULTS.notify,
+  };
+}
+
+export function createAutoCompactionState(): AutoCompactionState {
+  return {
+    previousPercent: null,
+    previousTokens: null,
+    inFlight: false,
+    lastTriggerAt: null,
+    lastTriggerTokens: null,
+    repeatBaselineTokens: null,
+    awaitingPostCompactionSample: false,
+  };
+}
+
+function knownUsage(usage?: AutoCompactionUsage | null): KnownAutoCompactionUsage | null {
+  if (!usage) return null;
+  const { tokens, percent, contextWindow } = usage;
+  if (typeof tokens !== "number" || !Number.isFinite(tokens) || tokens < 0) return null;
+  if (typeof percent !== "number" || !Number.isFinite(percent) || percent < 0) return null;
+  const known: KnownAutoCompactionUsage = { tokens, percent };
+  if (typeof contextWindow === "number" && Number.isFinite(contextWindow) && contextWindow > 0) {
+    known.contextWindow = contextWindow;
+  }
+  return known;
+}
+
+function updatePrevious(state: AutoCompactionState, usage: KnownAutoCompactionUsage): AutoCompactionState {
+  return {
+    ...state,
+    previousPercent: usage.percent,
+    previousTokens: usage.tokens,
+  };
+}
+
+function trigger(
+  reason: Extract<AutoCompactionDecisionReason, "threshold_reached" | "threshold_crossed" | "repeat_growth_reached">,
+  state: AutoCompactionState,
+  usage: KnownAutoCompactionUsage,
+  thresholdPercent: number,
+  nowMs: number,
+  tokenGrowth?: number,
+): AutoCompactionDecision {
+  return {
+    shouldTrigger: true,
+    reason,
+    thresholdPercent,
+    usage,
+    tokenGrowth,
+    state: {
+      ...updatePrevious(state, usage),
+      inFlight: true,
+      lastTriggerAt: nowMs,
+      lastTriggerTokens: usage.tokens,
+      repeatBaselineTokens: usage.tokens,
+      awaitingPostCompactionSample: false,
+    },
+  };
+}
+
+/**
+ * Decide whether the current usage sample should trigger auto-compaction.
+ *
+ * Loop safeguards:
+ * - unknown/null usage never triggers and does not erase the previous baseline;
+ * - in-flight compactions suppress further triggers;
+ * - every repeat trigger after a prior attempt observes cooldown;
+ * - if usage remains above threshold after compaction, the first known sample is
+ *   only a baseline, and a repeat requires sufficient token growth.
+ */
+export function decideAutoCompaction(input: AutoCompactionDecisionInput): AutoCompactionDecision {
+  const config = normalizeAutoCompactionConfig(input.config);
+  const nowMs = input.nowMs ?? Date.now();
+
+  if (!config.enabled) {
+    return {
+      shouldTrigger: false,
+      reason: "disabled",
+      thresholdPercent: config.thresholdPercent,
+      state: input.state,
+    };
+  }
+
+  if (input.state.inFlight) {
+    return {
+      shouldTrigger: false,
+      reason: "in_flight",
+      thresholdPercent: config.thresholdPercent,
+      state: input.state,
+    };
+  }
+
+  const usage = knownUsage(input.usage);
+  if (!usage) {
+    return {
+      shouldTrigger: false,
+      reason: "unknown_usage",
+      thresholdPercent: config.thresholdPercent,
+      state: input.state,
+    };
+  }
+
+  let nextState = updatePrevious(input.state, usage);
+
+  if (input.state.awaitingPostCompactionSample) {
+    nextState = {
+      ...nextState,
+      awaitingPostCompactionSample: false,
+      repeatBaselineTokens: usage.percent >= config.thresholdPercent ? usage.tokens : null,
+    };
+    return {
+      shouldTrigger: false,
+      reason: usage.percent >= config.thresholdPercent ? "post_compaction_baseline" : "below_threshold",
+      thresholdPercent: config.thresholdPercent,
+      usage,
+      state: nextState,
+    };
+  }
+
+  if (usage.percent < config.thresholdPercent) {
+    return {
+      shouldTrigger: false,
+      reason: "below_threshold",
+      thresholdPercent: config.thresholdPercent,
+      usage,
+      state: {
+        ...nextState,
+        repeatBaselineTokens: null,
+      },
+    };
+  }
+
+  if (input.state.lastTriggerAt !== null) {
+    const elapsedMs = Math.max(0, nowMs - input.state.lastTriggerAt);
+    if (elapsedMs < config.cooldownMs) {
+      return {
+        shouldTrigger: false,
+        reason: "cooldown_active",
+        thresholdPercent: config.thresholdPercent,
+        usage,
+        cooldownRemainingMs: config.cooldownMs - elapsedMs,
+        state: nextState,
+      };
+    }
+  }
+
+  const previousPercent = input.state.previousPercent;
+  if (previousPercent === null) {
+    return trigger("threshold_reached", input.state, usage, config.thresholdPercent, nowMs);
+  }
+  if (previousPercent < config.thresholdPercent) {
+    return trigger("threshold_crossed", input.state, usage, config.thresholdPercent, nowMs);
+  }
+
+  // We were already above threshold. Re-trigger only after enough growth.
+  if (input.state.lastTriggerAt === null) {
+    return trigger("threshold_reached", input.state, usage, config.thresholdPercent, nowMs);
+  }
+
+  const baselineTokens = input.state.repeatBaselineTokens
+    ?? input.state.lastTriggerTokens
+    ?? input.state.previousTokens
+    ?? usage.tokens;
+  const tokenGrowth = Math.max(0, usage.tokens - baselineTokens);
+
+  if (tokenGrowth < config.repeatMinGrowthTokens) {
+    return {
+      shouldTrigger: false,
+      reason: "repeat_growth_needed",
+      thresholdPercent: config.thresholdPercent,
+      usage,
+      tokenGrowth,
+      tokensUntilRepeat: config.repeatMinGrowthTokens - tokenGrowth,
+      state: nextState,
+    };
+  }
+
+  return trigger(
+    "repeat_growth_reached",
+    input.state,
+    usage,
+    config.thresholdPercent,
+    nowMs,
+    tokenGrowth,
+  );
+}
+
+export function markAutoCompactionComplete(state: AutoCompactionState): AutoCompactionState {
+  return {
+    ...state,
+    inFlight: false,
+    awaitingPostCompactionSample: true,
+  };
+}
+
+export function markAutoCompactionError(state: AutoCompactionState, nowMs?: number): AutoCompactionState {
+  return {
+    ...state,
+    inFlight: false,
+    awaitingPostCompactionSample: false,
+    lastTriggerAt: state.lastTriggerAt ?? nowMs ?? null,
+  };
+}

package/packages/compactor/src/config/manager.ts

@@ -116,6 +116,7 @@ export function migrateConfig(partial: Partial<CompactorConfig>): CompactorConfi
     sandboxExecution: mergeStrategy("sandboxExecution", defaults.sandboxExecution, partial.sandboxExecution),
     toolDisplay: mergeStrategy("toolDisplay", defaults.toolDisplay, partial.toolDisplay),
     pipeline: mergeStrategy("pipeline", defaults.pipeline, (partial as any).pipeline) as any,
+    autoCompaction: mergeStrategy("autoCompaction", defaults.autoCompaction, partial.autoCompaction),
     overrideDefaultCompaction: partial.overrideDefaultCompaction ?? defaults.overrideDefaultCompaction,
     debug: partial.debug ?? defaults.debug,
     showTruncationHints: partial.showTruncationHints ?? defaults.showTruncationHints,