feat: configurable auto-compact threshold with Ctrl+L keybinding

[aboimpinto]

Problem

At ~99.6% context saturation, the TUI becomes completely unresponsive (no keypresses, no UI updates) while the model is mid-turn. The status bar shows Memory 100% and Context 995.8K / 1M tokens, but the TUI event loop is effectively starved.

Root Cause

Two independent guardrails are both disabled by default since v0.8.11:

Layer	Setting	Default	Effect when OFF
Capacity controller	[capacity].enabled	false	No TargetedContextRefresh, no VerifyAndReplan
Compaction subsystem	auto_compact	false	should_compact() returns false unconditionally

With both disabled, the only compaction trigger is the model suggesting /compact in its response — which becomes impossible at ~99.6% context saturation (chicken-and-egg deadlock).

Additionally, the pre-send auto-compact check (should_auto_compact_before_send()) fires at 95% (CONTEXT_CRITICAL_THRESHOLD_PERCENT), which is already in the danger zone where the model struggles to produce tokens. The system prompt tells the model to suggest /compact at 60%, but the engine does nothing automatic at that threshold.

Solution

This PR adds a configurable auto-compact threshold and a manual compaction keybinding, closing the gap between model guidance and engine action.

Changes

1. New auto_compact_threshold_percent setting (default 70%)

   • Configurable via config.toml or /set auto_compact_threshold 70 --save
   • Validated to range 10–100
   • Respects the existing 500K-token hard floor (MINIMUM_AUTO_COMPACTION_TOKENS) so small sessions are never auto-compacted

2. should_auto_compact_before_send() now uses the configurable threshold

   • Was: hardcoded to 95% (CONTEXT_CRITICAL_THRESHOLD_PERCENT)
   • Now: uses app.auto_compact_threshold_pct (default 70%) + checks 500K floor
   • Compaction fires before the danger zone, while the model is still responsive

3. Early context-pressure warning at 60%

   • New CONTEXT_SUGGEST_COMPACT_THRESHOLD_PERCENT = 60.0
   • Non-intrusive status message: "Context building: 60% — Consider enabling auto_compact or use /compact."
   • Only shows when status_message is empty (never stomps on more important messages)

4. Ctrl+L keybinding for manual compaction

   • Works even when the model is mid-turn (streaming)
   • Breaks the chicken-and-egg deadlock: user can compact without model assistance
   • Status: "Compacting context (Ctrl+L)..."

5. Updated system prompt guidance

   • Model now knows about auto-compact threshold and Ctrl+L
   • "If auto_compact is enabled, the engine will automatically compact before the next send when context crosses the configured threshold (default 70%). The user can also press Ctrl+L at any time."

Files Changed

File	Lines	Description
crates/tui/src/settings.rs	+25	New field, default, set handler with validation, help text
crates/tui/src/tui/app.rs	+3	auto_compact_threshold_pct field + wiring from settings
crates/tui/src/tui/ui.rs	+49	Constants, maybe_warn_context_pressure() early warning, should_auto_compact_before_send() configurable threshold, Ctrl+L keybinding
crates/tui/src/prompts.rs	+1/-1	System prompt updates

Configuration

# ~/.deepseek/config.toml
auto_compact = true                     # master switch (still defaults to false)
auto_compact_threshold_percent = 70     # fires at 70% (NEW — default 70)

Or in-session:

/set auto_compact true --save
/set auto_compact_threshold 70 --save

Behavior Flow

Context %	auto_compact=true	auto_compact=false
60%	Status: "Auto-compaction will fire before next send."	Status: "Consider enabling auto_compact or use /compact."
70%	Engine compacts before next send (if >500K tokens)	Status: same 60% message
85%	Status: "Context high — Auto-compaction is enabled."	Status: "Context high — Consider /compact or /clear."
95%	Status: "Context critical" (already compacted at 70%)	Status: "Context critical — Consider /compact or /clear."
Any	Ctrl+L → manual compaction	Ctrl+L → manual compaction

Backward Compatibility

• auto_compact still defaults to false — existing users see no change
• auto_compact_threshold_percent defaults to 70.0 — only active when auto_compact = true
• 500K hard floor unchanged — protects small/medium sessions from unnecessary cache destruction
• Existing /compact slash command unchanged

Related

• Closes the gap identified in the context-pressure UI freeze analysis
• Complements the v0.8.11 decision to disable auto-compact by default (Context-limit handoff as a default replacement for routine compaction #664) by making it safer to re-enable
• V4 prefix-cache economics preserved: 500K floor + 70% default threshold ensures compaction only fires when cache is already pressured

[aboimpinto]

Update 2026-05-21: Minidump Analysis Overturns Initial Hypothesis

A fourth freeze event occurred on 2026-05-21 (Event #4) in a YOLO-mode session at ~70%% context usage after 6 rapid exec_shell calls. A full minidump (210 MB) was captured from the frozen process and analyzed with WinDbg.

Key finding: The freeze is not a crossterm console-handle issue

The main thread stack trace shows the TUI is not stuck in event::poll() / WaitForSingleObject(console_handle). Instead:

ntdll!ZwWaitForAlertByThreadId+0x14
ntdll!RtlWaitOnAddress+0x213
KERNELBASE!WaitOnAddress+0x38
deepseek_tui!aws_lc_0_40_0_...       ← AWS-LC crypto library (rustls TLS provider)
(4+ deepseek_tui frames)
kernel32!BaseThreadInitThunk+0x17
ntdll!RtlUserThreadStart+0x2c

WaitOnAddress is the Windows API used by Rust std::sync::Condvar / Mutex — a memory-address wait, not a handle-based wait. This is not a console input starvation issue.

All other 31 threads (28 tokio workers + 3 helper threads) are in normal idle/parked states — the tokio runtime, engine, and HTTP client are healthy.

What this means

This is a Rust-level synchronization deadlock inside the aws-lc / rustls TLS layer. The trigger pattern (rapid exec_shell calls) suggests lock contention between the main thread and a tokio worker over an internal aws-lc mutex or condition variable.

This is a separate freeze mechanism from the context-pressure scenario (99.6%% saturation). The auto-compact threshold mitigation (this PR) addresses the context-pressure freeze but does not resolve this TLS deadlock.

Suggested investigation

1. Build the release binary with PDB symbols and re-analyze the existing minidump to identify the exact Rust function
2. Audit aws-lc / rustls for global locks (CRNG, entropy) that could contend between the main thread and tokio workers
3. Consider isolating all TLS/crypto operations exclusively to the tokio runtime