fix: 22 bug fixes for non-Anthropic provider compatibility and compression reliability

[ranxianglei]

DCP Plugin: Comprehensive Bug Fix — Persistence, Token Heuristics, and Compression Stability

This PR fixes 18 bugs across the Dynamic Context Pruning plugin that collectively rendered DCP unreliable in production. The issues span three failure domains: persistence (compression state lost across restarts and compaction), token measurement (inflated counts causing false warnings on non-Anthropic providers), and compression block lifecycle (blocks deactivating spuriously, summaries silently dropped, re-compression impossible). Together, these fixes make DCP's compression behavior stable across long sessions, restarts, and multi-provider setups.

Key themes:

• State that should survive restarts (messageIds, compression blocks, lastCompaction) now does.
• Token usage calculation is now provider-aware instead of Anthropic-only.
• Compression blocks persist through opencode compaction and message windowing — they are only deactivated by explicit user action.

---

Test Environment

Item	Value
Models tested	Claude Sonnet 4, GLM-5.1 (204K context)
Session types	Fresh start, restart mid-session, post-compaction, long-running (50+ turns)
Providers	Anthropic, ZhipuAI
DCP modes	message and replace

---

🔴 CRITICAL Fixes

Bug	Files	What Happens	Root Cause	Fix
#3	`sync.ts`	Compression blocks deactivate at random over time. Summaries vanish, original messages return to full context.	`syncCompressionBlocks()` checks if `compressMessageId` (the assistant msg containing the compress tool call) still exists in the current message list. When opencode truncates/removes old assistant messages — normal behavior — the ID disappears and the block is deactivated, even though the compression data is intact.	Removed the `compressMessageId` presence check entirely. Blocks are only deactivated by explicit user action (`deactivatedByUser`) or if the anchor message is confirmed absent from both current messages AND persisted data (see Bug #19).
#6	`prune.ts`	Messages silently disappear from context — compressed range is pruned but no summary is injected. Complete data loss.	`filterCompressedRanges()` calls `getLastUserMessage()` to find a user message to attach the synthetic summary to. If no user message exists at or before the anchor (conversation start, post-compaction), it returns `null`. The warning branch logs but does not inject a summary, while the subsequent code still prunes the range. Messages removed, no summary → silent data loss.	Fallback: when `getLastUserMessage()` returns null, use the anchor message itself as the base for `createSyntheticUserMessage()`. Summary is always injected.
#17	`inject/utils.ts`, `token-utils.ts`	DCP reports context at 105% (triggers CRITICAL WARNING) when actual usage is ~36%. Forces constant, premature compression on non-Anthropic providers.	`getCurrentTokenUsage()` returns `input + output + reasoning + cacheRead + cacheWrite`. For Anthropic, `input` includes cached tokens so adding `cacheRead` double-counts a small amount. For other providers, `input` is only new non-cached tokens while `cacheRead` is the cumulative cached count ≈ actual context size. Adding them produces roughly 2× the real usage.	Provider-aware heuristic: if `cacheRead > input && input > 0`, return `cacheRead` (non-Anthropic: `cacheRead ≈ actual context size`). Otherwise return `input + output + reasoning` (Anthropic: `input` already includes the full context). See Design Decisions section.

---

🟠 HIGH Fixes

Bug	Files	What Happens	Root Cause	Fix
#1	`persistence.ts`, `state.ts`	After restarting opencode, compress fails with `"startId m0043 is not available"`. Compression completely broken post-restart.	`saveSessionState()` only persists `prune`, `nudges`, `stats` — NOT `messageIds`. On restart, `assignMessageRefs()` starts from `m0001`. But the model references old mNNNN IDs from block summaries still in context. `resolveBoundaryIds()` can't find them.	Persist `messageIds` (`byRawId`, `byRef`, `nextRef`) and `lastCompaction` to the session JSON. Restore on load.
#2	`utils.ts`	When opencode's internal compaction runs, all DCP compression blocks vanish. Previously compressed context returns to full size.	`resetOnCompaction()` wipes everything including `prune.messages` (ALL compression blocks). Clearing it destroys all DCP compression summaries — effectively undoing all compression work.	`resetOnCompaction()` now only resets transient state. `prune.messages` (compression blocks) is preserved through compaction.
#7	`hooks.ts`	In message mode, compressed summaries accumulate but can never be re-compressed. Context fills with uncompressible summaries.	Synthetic summary messages are created AFTER the `assignMessageRefs` pass. They never get mNNNN IDs. In message mode, block IDs are replaced with "BLOCKED" — so the summary has no mNNNN AND no usable block ID. Completely unreferenceable.	Added a second `assignMessageRefs` pass after the prune step.
#18	`hooks.ts`	Percentage thresholds fire at wrong levels. A 45% config triggers at ~17% actual context.	`createSystemPromptHandler()` sets `modelContextLimit = computeInputBudget(limit)`. For models with context=204800 and output=131072: inputBudget = 73,728. So 45% of 73,728 = 33,178 tokens (17% of actual 204K). Related to #522.	Use `input.model.limit.context` directly instead of computed inputBudget.
#19	`sync.ts`	Compression blocks deactivate when anchor messages fall outside opencode's current message window.	`syncCompressionBlocks()` checks `messageIds.has(block.anchorMessageId)` where `messageIds` only contains IDs from the current API response. Historical anchors not in the window → false deactivation.	Secondary check against DCP's persisted `byMessageId` index. If anchor exists there, keep block active.

---

🟡 MEDIUM Fixes

Bug	Files	What Happens	Root Cause	Fix
#5	`inject/utils.ts`	DCP forces compression CRITICAL WARNING even at low context (e.g., 36%).	`overMinLimit` defaults to `true` when `modelContextLimit` is undefined. "Always over limit" when the limit can't be calculated.	Default to `false` — fail open, not closed.
#8	`token-utils.ts`	Context nudges never fire on the first turn or after full compaction.	`getCurrentTokenUsage()` returns 0 when no assistant message has `output > 0`. `0 > maxLimit = false`.	Fallback estimation from message content length.
#9	`persistence.ts`	Compress tool reports success, but on restart the compression is gone.	`saveSessionState()` wraps write in try/catch that only logs without re-throwing. Model sees no error.	Removed try/catch — errors propagate to callers.
#10	`hooks.ts`	After crash/restart, previously deactivated blocks become active again.	`syncCompressionBlocks()` deactivates blocks but no `saveSessionState()` follows. Next save only on nudge/compress.	Save state immediately after sync if blocks were deactivated.
#11	`decompress.ts`	User decompresses a block, sees "Also restored nested compression A", but A stays compressed.	Target block gets `deactivatedByUser=true` but consumed inner blocks don't. During sync, inner blocks pass the guard and get re-activated.	Recursively mark all consumed inner blocks as `deactivatedByUser=true`.
#20	`inject/utils.ts`	After compressing, model immediately gets another CRITICAL WARNING and compresses again in a loop.	API response token count doesn't immediately reflect reduced context. DCP still sees `overMax=true`.	Cooldown: if last 3 messages contain a compress tool call, suppress `overMax`.
#21	`compress-range.ts`	Model uses old mNNNN IDs from block summaries/nudges → "startId not available".	Tool description wasn't strong enough about using only visible IDs.	Strengthened prompt with explicit stale-ID warnings.

---

🟢 LOW Fixes

Bug	Files	What Happens	Root Cause	Fix
#12	`utils.ts`	`isMessageCompacted()` and `getCurrentTokenUsage()` disagree on compaction boundary.	Strict `<` vs `<=` comparison for the compaction summary message.	Added `summary === true` check to `isMessageCompacted()`.
#13	`utils.ts`	Stale `activeBlockIds` loaded from persistence for deactivated blocks.	Dual loading from persistence and `blocksById` without clearing.	Skip persisted loading — derive from `blocksById` only.
#14	`reasoning-strip.ts`	Metadata stripped from all assistant messages when `modelID`/`providerID` undefined.	`undefined === "id"` is always `false`.	Added undefined guard.

---

Design Decisions

1. Provider-Aware Token Heuristic (Bug #17)

Different providers report token counts with different semantics:

Field	Anthropic	Other providers (e.g. GLM-5.1)
`input`	Full context tokens (includes cached)	Only new non-cached tokens
`cacheRead`	Subset of `input` (redundant)	Cumulative cached tokens ≈ actual context size

The heuristic: if `cacheRead > input && input > 0`, the provider uses split reporting where `cacheRead` is the better proxy. Otherwise `input` already contains the full context. This is deliberately simple and observable.

2. Anchor Persistence Strategy (Bugs #1, #19)

DCP now maintains its own persisted `byMessageId` index, decoupling block validity from opencode's message windowing:

• Current messages → primary check (fast, in-memory)
• Persisted index → fallback (covers historical anchors)
• Deactivation → only via explicit user action or confirmed absence from both sources

3. Compaction Coexistence (Bug #2)

`resetOnCompaction()` now preserves `prune.messages` (compression blocks) while resetting transient state. After compaction, DCP reassigns refs and re-syncs blocks — but compression summaries survive.

---

Files Changed

File	Bugs	Nature of Change
`sync.ts`	#3, #10, #19	Remove compressMessageId check, add persisted anchor fallback, save on deactivation
`persistence.ts`	#1, #9, #13	Persist messageIds/lastCompaction, remove error swallowing, fix activeBlockIds loading
`prune.ts`	#6	Fallback to anchor message when no preceding user message
`hooks.ts`	#7, #18	Second assignMessageRefs pass, use raw context limit
`inject/utils.ts`	#5, #20	overMinLimit default, compress cooldown
`token-utils.ts`	#8, #17	Provider-aware token heuristic, token fallback estimation
`utils.ts`	#2, #12	Preserve prune.messages, fix isMessageCompacted boundary
`decompress.ts`	#11	Recursive deactivatedByUser for consumed blocks
`reasoning-strip.ts`	#14	Undefined guard on modelID/providerID
`compress-range.ts`	#21	Strengthened compress tool prompt

---

Notes for Reviewers

• `[FIX Bug N]` markers: Each code change is annotated with the bug number. Search for `[FIX Bug` to navigate.
• Debug logs removed: Temporary diagnostic statements have been removed.
• No new dependencies: All fixes are logic changes within existing code.
• Migration: Existing session files without `messageIds` in persistence are handled gracefully — fields default to empty and are populated on the next message transform.

Reproduction Recipes (for QA)

Bug #1: Start session → compress messages → restart opencode → attempt compress → `startId not available`
Bug #3: Start session → compress → continue 20+ turns → observe blocks deactivating
Bug #6: Compress messages near conversation start (first 5 messages) → observe messages vanish with no summary
Bug #17: Use non-Anthropic provider → observe CRITICAL WARNING at low context usage
Bug #18: Use model with large output budget (204K context, 131K output) → observe 45% threshold firing at ~17%
Bug #20: Compress at high context → observe model immediately re-compressing