feat: reclaimable cost map, in-place recondense, and long-session freeze fix

.gitattributes

@@ -0,0 +1,12 @@
+* text=auto
+
+*.ts text eol=lf
+*.tsx text eol=lf
+*.js text eol=lf
+*.json text eol=lf
+*.jsonc text eol=lf
+*.md text eol=lf
+*.sh text eol=lf
+*.mjs text eol=lf
+*.yml text eol=lf
+*.yaml text eol=lf

README.md

@@ -45,6 +45,20 @@ DCP supports two compression modes:
 
 In `range` mode, when a new compression overlaps an earlier one, the earlier summary is nested inside the new one so information is preserved through layers of compression rather than diluted away. In both modes, protected tool outputs (such as subagents and skills) and protected file patterns are kept in compression summaries, ensuring that the most important information is never lost. You can also enable `protectUserMessages` to preserve your messages verbatim during compression, though note that large prompts (e.g. copy-pasting log files in the prompt) will then never be compressed away.
 
+### Recursive Condensation
+
+By default, nesting a previously compressed block (`bN`) into a new compression expands the child block's full summary into the parent. This preserves information perfectly, but the parent is never smaller than the sum of its children, so deeply nested compressions grow rather than shrink.
+
+Enable `compress.recursiveCondense` to change this behavior. When active, the model condenses each referenced block's content directly into its own summary text, and `(bN)` placeholders become compact `[condensed block bN]` references instead of full expansions. Each merge layer is then meaningfully smaller than the sum of its children. Protected content (protected tool outputs, user messages, and protected prompt information) from child blocks is still preserved automatically.
+
+### Fork / Inherited Session Recovery
+
+When opencode forks a session, the child inherits the parent's raw messages but not the DCP state file (keyed by sessionId), so the inherited prefix - often dominated by large read/grep/webfetch outputs - was never covered by any compression block. DCP now replays the session's own history on first load: completed `compress` tool parts persist their full input arguments, so the same blocks are rebuilt deterministically (deduplicated by `compressCallId`, stale `mNNNN` references skipped with a warning). No configuration needed.
+
+### Context Accounting (`/dcp context`)
+
+`/dcp context` now also prints a Context Accounting Snapshot captured on every messages transform: raw vs transformed message/token counts, active compression-block coverage, the largest uncovered tool outputs, provider-reported token totals, the effective max/min thresholds, whether a compression just completed, and whether the reported total is stale relative to the last DCP compression. Use this to explain the gap between the UI percentage and DCP's own pruning instead of guessing.
+
 ### Deduplication
 
 Identifies repeated tool calls (same tool, same arguments) and keeps only the most recent output. Recalculated when the compress tool runs, so prompt cache is only impacted alongside compression.
@@ -155,13 +169,26 @@ Each level overrides the previous, so project settings take priority over global
         // Controls how likely compression is after user messages
         // ("strong" = more likely, "soft" = less likely)
         "nudgeForce": "soft",
+        // Number of consecutive tool-only assistant turns (no new user
+        // message) after which the emergency max-context nudge is
+        // suppressed. Prevents re-nudging during poll loops. 0 disables.
+        "pollCooldown": 3,
         // Tool names whose completed outputs are appended to the compression
         "protectedTools": [],
         // Preserve text wrapped in <protect>...</protect> when compressed
         "protectTags": false,
         // Preserve your messages during compression.
         // Warning: large copy-pasted prompts will never be compressed away
         "protectUserMessages": false,
+        // When merging an already-compressed block, condense its content
+        // instead of expanding its full summary into the parent. Keeps each
+        // compression layer smaller than the sum of its children.
+        "recursiveCondense": false,
+        // When true, reject a compression whose summary is not smaller
+        // than the content it replaces (default false). Disabled by
+        // default because it can cause retry loops when a range cannot
+        // shrink; prefer the prompt guidance instead.
+        "enforceSummaryShrink": false,
     },
     // Automatic pruning strategies
     "strategies": {

dcp.schema.json

@@ -114,6 +114,16 @@
                     "type": "boolean",
                     "default": false,
                     "description": "Enable user-editable prompt overrides under dcp-prompts directories"
+                },
+                "contextAccounting": {
+                    "type": "boolean",
+                    "default": false,
+                    "description": "Compute the detailed context accounting snapshot on every message transform (expensive on long sessions; use /dcp context with this enabled, or enable only when debugging). Default false keeps the transform hot path cheap."
+                },
+                "recoverInherited": {
+                    "type": "boolean",
+                    "default": false,
+                    "description": "Replay completed compress tool parts from session history on first load to rebuild compression blocks for forked/inherited sessions. Expensive on long histories; default false (opt-in diagnostic)."
                 }
             },
             "default": {
@@ -230,6 +240,12 @@
                     "default": "soft",
                     "description": "Controls how likely compression is after user messages. 'strong' is more likely, 'soft' is less likely."
                 },
+                "pollCooldown": {
+                    "type": "number",
+                    "default": 3,
+                    "minimum": 0,
+                    "description": "Number of consecutive tool-only assistant turns (no new user message) after which the emergency max-context nudge is suppressed. 0 disables the cooldown."
+                },
                 "protectedTools": {
                     "type": "array",
                     "items": {
@@ -247,6 +263,11 @@
                     "type": "boolean",
                     "default": false,
                     "description": "When enabled, your messages are never lost during compression"
+                },
+                "recursiveCondense": {
+                    "type": "boolean",
+                    "default": false,
+                    "description": "When enabled, merging an already-compressed block into a new compression does not expand the child block's full summary into the parent. Instead the model condenses the child block's content directly into its own summary text, so each merge layer is meaningfully smaller than the sum of its children. Protected content from child blocks is still preserved automatically."
                 }
             },
             "default": {
@@ -261,7 +282,8 @@
                 "nudgeForce": "soft",
                 "protectedTools": [],
                 "protectTags": false,
-                "protectUserMessages": false
+                "protectUserMessages": false,
+                "recursiveCondense": false
             }
         },
         "strategies": {

lib/commands/context.ts

@@ -47,6 +47,7 @@ import { formatTokenCount } from "../ui/utils"
 import { isIgnoredUserMessage } from "../messages/query"
 import { isMessageCompacted } from "../state/utils"
 import { countTokens, extractCompletedToolOutput, getCurrentParams } from "../token-utils"
+import { formatContextSnapshot } from "../context/accounting"
 import type { AssistantMessage, TextPart, ToolPart } from "@opencode-ai/sdk/v2"
 
 export interface ContextCommandContext {
@@ -298,7 +299,11 @@ export async function handleContextCommand(ctx: ContextCommandContext): Promise<
 
     const breakdown = analyzeContextTokens(state, messages)
 
-    const message = formatContextMessage(breakdown)
+    let message = formatContextMessage(breakdown)
+
+    if (state.lastContextSnapshot) {
+        message += "\n\n" + formatContextSnapshot(state.lastContextSnapshot)
+    }
 
     const params = getCurrentParams(state, messages, logger)
     await sendIgnoredMessage(client, sessionId, message, params, logger)

lib/commands/manual.ts

@@ -33,10 +33,11 @@ function getTriggerPrompt(
     state: SessionState,
     config: PluginConfig,
     userFocus?: string,
+    messages?: WithParts[],
 ): string {
     const base = COMPRESS_TRIGGER_PROMPT
     const compressedBlockGuidance =
-        config.compress.mode === "message" ? "" : buildCompressedBlockGuidance(state)
+        config.compress.mode === "message" ? "" : buildCompressedBlockGuidance(state, messages)
 
     const sections = [base, compressedBlockGuidance]
     if (userFocus && userFocus.trim().length > 0) {
@@ -87,7 +88,7 @@ export async function handleManualTriggerCommand(
     tool: "compress",
     userFocus?: string,
 ): Promise<string | null> {
-    return getTriggerPrompt(tool, ctx.state, ctx.config, userFocus)
+    return getTriggerPrompt(tool, ctx.state, ctx.config, userFocus, ctx.messages)
 }
 
 export function applyPendingManualTrigger(

lib/compress/message.ts

@@ -13,6 +13,7 @@ import {
     wrapCompressedSummary,
 } from "./state"
 import type { CompressMessageToolArgs } from "./types"
+import type { ProtectedContent } from "../state"
 
 function buildSchema(format: IdFormat) {
     return {
@@ -77,6 +78,7 @@ export function createCompressMessageTool(ctx: ToolContext): ReturnType<typeof t
             const preparedPlans: Array<{
                 plan: (typeof plans)[number]
                 summaryWithTools: string
+                protectedContent: ProtectedContent[]
             }> = []
 
             for (const plan of plans) {
@@ -92,7 +94,7 @@ export function createCompressMessageTool(ctx: ToolContext): ReturnType<typeof t
                     ctx.client,
                     ctx.state,
                     ctx.config.experimental.allowSubAgents,
-                    summaryWithPromptInfo,
+                    summaryWithPromptInfo.summaryText,
                     plan.selection,
                     searchContext,
                     ctx.config.compress.protectedTools,
@@ -101,13 +103,14 @@ export function createCompressMessageTool(ctx: ToolContext): ReturnType<typeof t
 
                 preparedPlans.push({
                     plan,
-                    summaryWithTools,
+                    summaryWithTools: summaryWithTools.summaryText,
+                    protectedContent: summaryWithTools.protectedContent,
                 })
             }
 
             const runId = allocateRunId(ctx.state)
 
-            for (const { plan, summaryWithTools } of preparedPlans) {
+            for (const { plan, summaryWithTools, protectedContent } of preparedPlans) {
                 const blockId = allocateBlockId(ctx.state)
                 const storedSummary = wrapCompressedSummary(
                     blockId,
@@ -134,6 +137,7 @@ export function createCompressMessageTool(ctx: ToolContext): ReturnType<typeof t
                     blockId,
                     storedSummary,
                     [],
+                    protectedContent,
                 )
 
                 notifications.push({

lib/compress/pipeline.ts

@@ -65,6 +65,7 @@ export async function prepareSession(
         ctx.logger,
         rawMessages,
         ctx.config.manualMode.enabled,
+        ctx.config,
     )
 
     assignMessageRefs(ctx.state, rawMessages)
@@ -85,6 +86,10 @@ export async function finalizeSession(
     entries: NotificationEntry[],
     batchTopic: string | undefined,
 ): Promise<void> {
+    if (entries.length > 0) {
+        ctx.state.lastDcpCompression = Date.now()
+    }
+
     if (ctx.state.manualMode === "compress-pending") {
         ctx.state.manualMode = false
         await refreshManualMode(