compaction: buffer of 180,904 reduces 200k window ceiling to just 15k tokens #58774

Summary

Automatic context compression triggers far too early (after ~15k tokens) despite a 200k token context window, because the configured compaction.buffer is subtracted directly from the model's input limit, leaving only 195,904 − 180,904 = 15,000 tokens of headroom before compaction fires.

Environment

• opencode version: 2.1.3
• OS: Darwin 27.0.0 (darwin arm64)
• Terminal: Unavailable (terminal environment variables not set)
• Shell: /bin/zsh
• Install/channel: latest
• Active plugins: -opencode.browser, /Users/thtesche/.config/openchamber/run/instances/52345/agent-tool/openchamber-agent-tool, @openchamber/opencode-claude@^1
• Active model: strata/qwen3.8-flash-next-q2_0 (context: 200,000 / input: 195,904 / output: 4,096)
• User config: compaction: { auto: true, buffer: 180904 }

Reproduction

1. Set compaction.buffer to a large value close to the model's input limit (e.g. 180904 of 195904).
2. Start a session and exchange enough messages that the measured context passes ~15k tokens.
3. Observe automatic compaction firing on nearly every turn, well before the 200k window is approached.

Expected Behavior

With a 200k context window and buffer unset, automatic compaction should not fire until roughly 85% of the window is used (~166k tokens). A large buffer should not collapse the ceiling to ~15k tokens.

Actual Behavior

The ceiling is calculated as window - buffer = 15,000 tokens, so due() returns true as soon as estimateContext(context) >= 15,000. Compaction fires after only a few exchanges, repeatedly rewriting history and discarding prompt-cache benefits.

Root Cause

calculateCeiling in packages/core/src/session/compaction.ts (introduced 2026-10-23 in commit 33726e8, PR #58313):

const calculateCeiling = (limit, buffer) => {
  const window = limit.input || limit.context   // 195,904
  if (buffer !== undefined && buffer < window)  // 180,904 < 195,904 → true
    return window - buffer                       // 195,904 − 180,904 = 15,000
  return window - Math.max(Math.floor(window * RESERVE_SHARE), RESERVE_MIN)
}

When buffer is set but still smaller than window, it is subtracted in full. The fallback to RESERVE_SHARE (15%) only applies when buffer >= window or buffer is unset.

The same day's commit added a guard ("ignore a compaction buffer that leaves the model no room"), but it only ignores buffers >= window. A buffer of 180,904 against an input limit of 195,904 still passes the buffer < window check, so the 15k ceiling stands.

Additional Context

• Evidence from opencode.db: two local sessions exist, both measured well under the current 15k ceiling; the active strata/qwen3.8 session shows input 707 / output 8847 / reasoning 3165 / cache read 245141 / cache write 127909 — cache-heavy, so estimateContext climbs quickly.
• The event table in opencode.db is empty; compaction events are not persisted there, so the DB alone cannot confirm trigger counts. The code path is sufficient evidence.
• This is not issue compaction: auto-compaction loops when provider reports input tokens above the model's context limit #50474 (auto-compaction loop on provider-reported overflow). This is a config/ceiling interaction: a user-set buffer collapses the trigger threshold.
• Suggested fix: validate compaction.buffer so it cannot reduce the ceiling below a sane floor (e.g. RESERVE_SHARE of the window), or document that buffer values close to input will cause near-immediate compaction.