Feature: configurable auto-compaction threshold

[virafb]

Feature request

Allow users to configure the context window percentage at which auto-compaction triggers, via a setting in settings.json (user or project level).

{
  "autoCompactionThreshold": 80
}

If not specified, the current default behavior applies.

Motivation

With the statusLine feature, users can now monitor context window usage in real time. However, there's no way to control when auto-compaction fires. In my experience, compaction triggered at ~76% used (24% remaining) — well before the context window was exhausted.

For long-running sessions with heavy context (architecture decisions, multi-file reviews), earlier compaction discards useful context prematurely. For other workflows, later compaction might risk losing important state.

A configurable threshold would let users tune the trade-off between context preservation and safety margin based on their workflow.

Proposed behavior

• New optional setting: autoCompactionThreshold (integer, 1–99, percentage of context used)
• When context usage reaches the threshold, auto-compaction fires as it does today
• If omitted, current default behavior is unchanged
• Could be set at user level (~/.claude/settings.json) or project level (.claude/settings.json)

[yurukusa]

+1 on this. I've been running Claude Code autonomously for 140+ hours and context management is critical.

As a workaround until this is natively supported, you can build this with a PostToolUse hook that monitors context usage after every tool call:

#!/bin/bash
# context-monitor.sh — warn when context window is running low
# Add to settings.json as a PostToolUse hook

THRESHOLD_WARN=20   # warn at 20% remaining
THRESHOLD_CRITICAL=5 # critical at 5% remaining

# Parse context info from hook input (stdin JSON)
remaining=$(cat /dev/stdin | python3 -c "
import json,sys
try:
    d=json.load(sys.stdin)
    # Access context percentage if available in hook payload
    print(d.get('context_remaining_percent', ''))
except: pass
" 2>/dev/null)

if [ -n "$remaining" ] && [ "$remaining" -le "$THRESHOLD_CRITICAL" ] 2>/dev/null; then
    echo '{"decision":"block","reason":"⚠️ CRITICAL: Context at '${remaining}'%. Run /compact immediately."}' 
elif [ -n "$remaining" ] && [ "$remaining" -le "$THRESHOLD_WARN" ] 2>/dev/null; then
    echo '{"decision":"warn","reason":"Context at '${remaining}'% remaining. Consider /compact soon."}' 
fi

This gives you configurable thresholds at the userland level. I run a similar hook (context-monitor) that has saved me from losing work multiple times when context was about to hit the wall.

That said, a native autoCompactionThreshold setting would be much cleaner — the hook approach can only warn or block, not actually control when compaction fires.

[AbdoKnbGit]

cc-memory addresses this with a different approach that's already working.

Instead of improving compaction, it moves context outside the window entirely:

• Full conversation turns stored in SQLite + ChromaDB (not summarized,
  just moved out)
• Semantic retrieval injects only relevant prior context back when needed
• Tiered injection: pinned decisions always included, past context
  scored by relevance
• Cerebras compresses history for free before hitting Anthropic —
  no token cost from your subscription
• Smart compaction with adaptive threshold — the proxy monitors context
  density and only triggers compaction when the window crosses a dynamic
  threshold. The threshold itself adjusts based on content type:
  decision-heavy turns raise it, tool output-heavy turns lower it.
  Compaction never fires blindly at a fixed percentage
• Density check before compaction — if the context is thin or mostly
  recoverable content, compaction is skipped entirely
• Tool result summarization — bulky file reads and command outputs get
  summarized before they bloat the window, recoverable content evicted first
• Second dedup pass after compression — if two turns converge after
  cleaning, the duplicate never hits the API

The result: Claude remembers schema decisions, variable names,
architectural rationale across sessions — not just within one session.
Compaction becomes a last resort, not a constant interruption.

Working implementation if you want to try it today:
https://github.com.AbdoKnbGit/claude-code-memory

[iuriguilherme]

settings.json should use the same syntax as the API already uses:

{
    "context_management": {
        "edits": [
            {
                "type": "compact_20260112",
                "trigger": {
                    "type": "input_tokens",
                    "value": 150000
                },
            }
        ]
    }
}

[iuriguilherme]

Previously closed issue with the same feature request: #10948

[joelpoloney]

+1 on this. I got to 250k context usage and queries were so slow, Claude Code became unusable until I compacted manually. Would be great to have the auto-compact feature back at a configurable threshold

[junaidtitan]

We wanted this exact feature and ended up building it ourselves — so we open-sourced it: Cozempic.

The guard daemon monitors your session and triggers pruning at a configurable threshold before compaction gets a chance to fire:

cozempic guard --threshold 50    # prune at 50% context (hard)
                                  # soft prune at 30% (no reload)

It's tiered — a gentle prune runs at 30% with no reload, a full prune runs at 50% with optional auto-reload into a clean session. Team state (TaskCreate, SendMessage, subagents) is always protected.

pip install cozempic

Would love feedback on whether the threshold controls map to what you're looking for here.

[yurukusa]

A PostToolUse hook can implement configurable auto-compaction:

COUNTER="/tmp/.cc-tool-count-$$"
COUNT=$(($(cat "$COUNTER" 2>/dev/null || echo 0) + 1))
echo "$COUNT" > "$COUNTER"
THRESHOLD=${CC_COMPACT_THRESHOLD:-300}
if [ "$COUNT" -eq "$THRESHOLD" ]; then
    echo '{"hookSpecificOutput":{"additionalContext":"Context threshold reached ('"$COUNT"' tool calls). Consider running /compact to free context space."}}'
fi
if [ "$COUNT" -eq $((THRESHOLD + 50)) ]; then
    echo '{"hookSpecificOutput":{"additionalContext":"⚠ Context critically full ('"$COUNT"' calls). Run /compact NOW or start a new session."}}'
fi
exit 0

{
  "hooks": {
    "PostToolUse": [{"hooks": [{"type": "command", "command": "bash ~/.claude/hooks/auto-compact.sh"}]}],
    "Notification": [{"matcher": "start", "hooks": [{"type": "command", "command": "echo 0 > /tmp/.cc-tool-count-$$"}]}]
  }
}

Set CC_COMPACT_THRESHOLD=200 to compact earlier, or 500 for longer sessions. The hook warns at the threshold and urgently at threshold+50.

[junaidtitan]

The tool-count approach is a useful signal but has a blind spot: a single Read of a large file can consume more context than 200 lightweight tool calls, so the threshold fires at the wrong time in file-heavy sessions. Cozempic's guard monitors actual token estimates from the JSONL tail rather than call count, which catches those asymmetric cases.

The other difference is what happens at threshold — the hook warns and asks Claude to /compact, but Cozempic prunes the JSONL directly before compaction fires: stripping progress bars, tool output noise, stale reads, and thinking blocks while protecting team state. The session stays lean enough that compaction either doesn't fire or lands on a much smaller file.

Both approaches are useful — the hook pattern @yurukusa described is a good lightweight complement for sessions where you don't want to install anything. pip install cozempic && cozempic guard if you want the token-aware version with active pruning.