Context Window Manager Pro

The free version tells you WHEN to compact. The Pro version gives you 5 compression algorithms, a budget tracker, and a session handoff protocol that makes compaction invisible.

Free vs Pro

The free manager teaches the agent to recognize compaction thresholds and write handoff notes. Pro makes it mechanical: five deterministic compression algorithms (semantic truncation, structured summarization, code dedup, priority pruning, budget tuning) instead of judgment calls, a token budget tracker with per-session spend accounting, benchmarked before/after ratios, and project anchor templates that survive dozens of compaction cycles. Free is the awareness layer — Pro is the enforcement layer.

Upgrade Path

Start free to see where your sessions actually hit the wall. If compaction happens more than twice a day, the Pro compression engine and budget tracker pay for themselves in reclaimed context within the first week.

The Problem

You know your agent's context is filling up. The free Context Window Manager teaches you to recognize the thresholds and write handoff notes. But recognizing the problem and solving it are different things. You need actual compression algorithms — semantic truncation, structured summarization, code deduplication, priority pruning — plus a budget tracker that monitors token usage across sessions, and reusable templates so compaction becomes a mechanical operation, not a judgment call under pressure.

What You Get

• 5 compression strategies — Semantic Truncation (embedding-similarity-based removal), Structured Summarization (verbose→concise), Code Deduplication (pattern→reference), Priority-Based Pruning (scored section dropping), and Token-Budget Tuning (per-section ratio optimization).
• Token budget tracker — initialize sessions with context limits, log each call's input/output tokens, and monitor remaining budget with real-time status.
• Session handoff template — structured HANDOFF.md format capturing open tasks, files touched, decisions with rationale, known-broken paths, and active constraints.
• Project anchoring templates — compact architectural maps (module boundaries, interfaces, naming rules) that survive compaction cycles.
• Compression benchmarks — pre-computed before/after token counts for each strategy across common content types (logs, code, markdown, mixed).
• Agent-specific integration notes — configuration for Claude Code, Cursor, and Codex CLI compaction behavior.

Why This Beats Prompting It Yourself

Telling an agent "compact the context" produces vibes-based summarization — the agent decides what matters at the moment its judgment is most degraded. This skill externalizes the decision into 5 deterministic compression algorithms with explicit keep/drop criteria, a budget tracker that tells you exactly how much headroom remains, and templates that survive compaction instead of being the first thing summarized away.

Example Session

You: "We're 4 hours into the payments refactor. Context is at 82%. Compact and hand off to a fresh session."

Agent:

CONTEXT AUDIT
  Current: 82% (164k / 200k tokens)
  Largest: 4 full-file reads (auth.ts, ledger.ts, retry.ts, jobs/queue.ts)
  Stale: stack traces from initial failing test run (~11k tokens)
  Verdict: compact → Strategy B (Structured Summarization) + Strategy D (Priority Pruning)

COMPACTION (Strategy B: Structured Summarization)
  Before: 164,000 tokens
  Reduced: full-file reads → interface signatures (4 files, 11k → 2.1k)
  Reduced: stack traces → error summary (11k → 0.8k)
  Reduced: diff logs → commit hash + status (8k → 0.4k)
  After: 68,200 tokens (58% reduction)

BUDGET STATUS
  Session: payments-refactor
  Used: 68,200 / 200,000 (34%)
  Remaining: 131,800 tokens (~6 more files of real work)
  Rate: ~1,200 tokens/turn average
  ETA at current rate: ~110 turns before compaction needed

HANDOFF.md (written)
  Task:            Add Stripe webhook retry handler
  Done:            LedgerClient extracted; 47/47 tests passing at a91c3f2
  Open:            retry policy not implemented; WebhookEvent.attempts unpopulated
  Constraints:     all writes through unitOfWork; idempotent by event ID; no new deps
  Files in play:   src/payments/webhook.ts, src/jobs/queue.ts, src/ledger/client.ts
  Known broken:    integration test retry_on_5xx — skipped, not passing

VERIFICATION
  Anchor re-read: ✓  Constraints restated: 3/3 match  Drift: none

Use Cases

• Multi-hour Claude Code refactors where you'd otherwise restart the session every 90 minutes.
• Production LLM pipelines with predictable token budgets and cost tracking requirements.
• Handing a half-finished task to a teammate via structured HANDOFF.md.
• Migration projects with hard invariants that must survive dozens of compaction cycles.
• Cost optimization for API-billed workflows where every token has a dollar cost.

Known Limitations

Compression ratios are estimates based on content type heuristics; actual ratios vary by content structure. Semantic Truncation requires embedding similarity computation (adds latency). The budget tracker monitors input/output tokens but cannot track internal reasoning tokens. Agent-specific integration notes cover Claude Code, Cursor, and Codex CLI; other agents may need manual configuration.