@serkanalgur/opencodev2-slim 2.0.13 → 2.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serkanalgur/opencodev2-slim",
-  "version": "2.0.13",
+  "version": "2.0.14",
   "description": "Smart context management plugin for OpenCode v2 - semantic compression, cost-aware pruning, adaptive thresholds",
   "keywords": [
     "opencode",

package/src/index.ts

@@ -1,15 +1,25 @@
 import { Plugin } from "@opencode/plugin"
-import { loadConfig, createDefaultConfig, resolveTokenLimit } from "./lib/config"
 import {
-    loadSessionState,
-    saveSessionState,
-    addCompressionRecord,
-} from "./lib/state"
-import { countTokens, shouldCompress, getMessageText, getToolResultContent } from "./lib/compress"
-import { pruneMessages } from "./lib/strategies"
-import { getSystemPrompt, getCompressToolDescription, getNudgeMessage } from "./lib/prompts"
+    loadConfig,
+    createDefaultConfig,
+    resolveTokenLimit,
+    resolveCompressLimits,
+} from "./lib/config"
+import { loadSessionState, saveSessionState, addCompressionRecord } from "./lib/state"
+import { countTokens, getMessageText, getToolResultContent } from "./lib/compress"
+import {
+    syncCompressionBlocks,
+    applyCompressedRanges,
+    registerCompressionBlock,
+    buildCompressionSummary,
+    purgeStaleToolErrors,
+    pruneInPlace,
+    injectLimitNudges,
+    findLastUserMessage,
+} from "./lib/strategies"
+import { getSystemPrompt, getCompressToolDescription } from "./lib/prompts"
 import { buildPanelData, renderPanel } from "./lib/tui"
-import type { SlimConfig, SessionState, MessageWithParts } from "./lib/types"
+import type { SlimConfig, SessionState, MessageWithParts, CompressionBlock } from "./lib/types"
 
 // ─── State Management ───────────────────────────────────────────────────────
 
@@ -58,70 +68,59 @@ function stringifyTranscript(v: unknown): string {
 
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
-function buildCompressionSummary(messages: MessageWithParts[], focus: string): string {
-    const lines: string[] = []
-    lines.push(`## Compression Summary`)
-    lines.push(`Focus: ${focus}`)
-    lines.push(`Messages compressed: ${messages.length}`)
-    lines.push("")
-
-    const toolCalls: string[] = []
-    const errors: string[] = []
-    const decisions: string[] = []
-
-    for (const msg of messages) {
-        for (const part of msg.parts) {
-            if (part.type === "tool-call") {
-                const toolPart = part as any
-                toolCalls.push(
-                    `${toolPart.name}: ${JSON.stringify(toolPart.input || {}).slice(0, 100)}`,
-                )
-            }
-            if (part.type === "tool-result") {
-                const toolPart = part as any
-                if (toolPart.result?.type === "error") {
-                    errors.push(String(toolPart.result.value).slice(0, 200) || "Unknown error")
-                }
-            }
-            if (part.type === "text") {
-                const textPart = part as any
-                const text = textPart.text || ""
-                if (
-                    text.includes("decided") ||
-                    text.includes("chose") ||
-                    text.includes("implemented")
-                ) {
-                    decisions.push(text.slice(0, 200))
-                }
-            }
-        }
+// Register a DCP-style compression block for the selected range. The range is
+// covered (removed from future outgoing requests) and the summary is injected
+// at the anchor: the first message after the range, or the latest message when
+// the range reaches the end (the active user turn is never replaced).
+function registerBlockForRange(
+    state: SessionState,
+    topic: string,
+    messageWithParts: MessageWithParts[],
+    targetIndices: number[],
+    summary: string,
+    summaryTokens: number,
+): CompressionBlock | null {
+    if (targetIndices.length === 0 || messageWithParts.length === 0) return null
+
+    const sorted = [...targetIndices].sort((a, b) => a - b)
+    const coveredIndices = new Set(sorted)
+
+    let anchorIndex = sorted[sorted.length - 1] + 1
+    if (anchorIndex >= messageWithParts.length) {
+        anchorIndex = messageWithParts.length - 1
+        coveredIndices.delete(anchorIndex)
     }
-
-    if (toolCalls.length > 0) {
-        lines.push("### Tool Calls")
-        toolCalls.slice(0, 10).forEach((tc) => lines.push(`- ${tc}`))
-        lines.push("")
-    }
-
-    if (errors.length > 0) {
-        lines.push("### Errors Encountered")
-        errors.slice(0, 5).forEach((e) => lines.push(`- ${e}`))
-        lines.push("")
-    }
-
-    if (decisions.length > 0) {
-        lines.push("### Key Decisions")
-        decisions.slice(0, 5).forEach((d) => lines.push(`- ${d}`))
-        lines.push("")
-    }
-
-    return lines.join("\n")
+    if (anchorIndex < 0 || anchorIndex >= messageWithParts.length) return null
+
+    const anchorId = messageWithParts[anchorIndex].info?.id
+    if (!anchorId) return null
+
+    const coveredIds = [...coveredIndices]
+        .map((i) => messageWithParts[i].info?.id)
+        .filter((id): id is string => typeof id === "string" && id.length > 0)
+    if (coveredIds.length === 0) return null
+
+    return registerCompressionBlock(state, {
+        coveredIds,
+        anchorMessageId: anchorId,
+        summary,
+        topic,
+        summaryTokens,
+    })
 }
 
 function wrapAsMessageWithParts(msg: any): MessageWithParts {
+    const msgInfo = msg.info
+    const id = (msg && (msg.id || msgInfo?.id)) || ""
+    const role = (msg && (msg.role || msgInfo?.role)) || "user"
     return {
-        info: msg.info || { id: msg.id || "", role: msg.role, sessionID: "", time: { created: Date.now() } },
-        parts: msg.parts || msg.content || [],
+        info: {
+            id,
+            role,
+            sessionID: (msg && (msg.sessionID || msgInfo?.sessionID)) || "",
+            time: { created: Date.now() },
+        } as any,
+        parts: (msg && (msg.parts || msg.content)) || [],
     }
 }
 
@@ -241,10 +240,34 @@ export default Plugin.define({
                         }
 
                         const targetMessages = targetIndices.map((i) => messageWithParts[i])
-                        const summary = buildCompressionSummary(targetMessages, args.focus)
+                        const summary = await buildCompressionSummary(
+                            targetMessages,
+                            args.focus,
+                            config.compress.protectedTools,
+                            config.compress.protectUserMessages,
+                        )
                         const outputTokens = await countTokens(summary)
                         const ratio = inputTokens > 0 ? 1 - outputTokens / inputTokens : 0
 
+                        // DCP: register a compression block so future outgoing
+                        // requests replace this range with the summary.
+                        let blockNote = ""
+                        try {
+                            const block = registerBlockForRange(
+                                state,
+                                args.focus,
+                                messageWithParts,
+                                targetIndices,
+                                summary,
+                                outputTokens,
+                            )
+                            if (block) {
+                                blockNote = `\n\n_Block #${block.blockId}: ${block.coveredMessageIds.length} messages will collapse into this summary on future requests (${Math.round((1 - outputTokens / Math.max(1, inputTokens)) * 100)}% smaller)._\n_To restore them: ask to reset context._`
+                            }
+                        } catch {
+                            // Best-effort: the summary is still returned to the model.
+                        }
+
                         addCompressionRecord(
                             state,
                             {
@@ -261,7 +284,7 @@ export default Plugin.define({
                         saveSessionState(state, config.persistence.directory)
 
                         return {
-                            content: `## Compressed ${targetMessages.length} messages\n\n${summary}\n\n---\n**Stats:** ${inputTokens} → ${outputTokens} tokens (${Math.round(ratio * 100)}% saved) | Mode: ${mode} | Focus: ${args.focus}`,
+                            content: `## Compressed ${targetMessages.length} messages\n\n${summary}\n\n---\n**Stats:** ${inputTokens} → ${outputTokens} tokens (${Math.round(ratio * 100)}% saved) | Mode: ${mode} | Focus: ${args.focus}${blockNote}`,
                         }
                     } catch (error) {
                         return {
@@ -363,6 +386,10 @@ export default Plugin.define({
         })
 
         // ─── Messages Transform Hook (sync) ──────────────────────────────
+        // DCP pipeline for every outgoing request: sync compression blocks,
+        // replace covered ranges with summary placeholders, prune (dedup +
+        // purge errored tool inputs), then apply DCP limit rules as anchored
+        // nudges. Session history is never modified — only this request.
         await ctx.session.hook("context", (event) => {
             const sessionId = event.sessionID
             const config = getConfig(sessionId)
@@ -371,72 +398,49 @@ export default Plugin.define({
             const state = getState(sessionId, config)
             state.modelContextLimit = sessionModelLimits.get(sessionId) || initialModelLimit
 
-            // Apply pruning - work with original OpenCode message format
-            // event.messages contains { role, content: Part[], ... } objects
-            const wrapped = event.messages.map((m: any) => wrapAsMessageWithParts(m))
-            const pruned = pruneMessages(wrapped, config, event.messages.length)
-
-            // Build a Set of pruned message IDs to keep
-            const keepIds = new Set(pruned.map((m) => m.info.id))
-
-            // Remove duplicates in-place, preserving OpenCode's message format
-            for (let i = event.messages.length - 1; i >= 0; i--) {
-                const msg = event.messages[i] as any
-                const id = msg.id || msg.info?.id
-                if (id && !keepIds.has(id)) {
-                    event.messages.splice(i, 1)
-                }
+            // 1) Compression blocks: activate/deactivate and replace ranges.
+            const presentIds = new Set<string>()
+            for (const msg of event.messages) {
+                const id = (msg as any)?.id ?? (msg as any)?.info?.id
+                if (typeof id === "string") presentIds.add(id)
+            }
+            syncCompressionBlocks(state, presentIds)
+            const filtered = applyCompressedRanges(state, event.messages)
+            event.messages.splice(0, event.messages.length, ...filtered)
+
+            // 2) Pruning strategies (each request).
+            pruneInPlace(event.messages, config)
+            if (config.strategies.purgeErrors.enabled) {
+                purgeStaleToolErrors(event.messages, config.strategies.purgeErrors.turns)
             }
 
-            // Quick token estimate (sync, ~4 chars per token). On the first pass
-            // (before the panel has written real numbers into state) this is a
-            // fallback; afterwards we prefer the server-measured value.
+            // 3) Token accounting: prefer the server-measured count; fall back
+            //    to a quick estimate (~4 chars per token).
             let estimatedTokens = 0
             for (const msg of event.messages) {
-                const content = (msg as any).content
+                const content = (msg as any)?.content ?? (msg as any)?.parts
                 if (Array.isArray(content)) {
                     for (const part of content) {
-                        if (part.type === "text" && part.text) {
+                        if (part?.type === "text" && part.text) {
                             estimatedTokens += Math.ceil(part.text.length / 4)
                         }
                     }
                 }
             }
-
-            // Prefer the real measured token count when available; else the estimate.
             const totalTokens =
                 state.currentTokenCount > 0 ? state.currentTokenCount : estimatedTokens
             state.currentTokenCount = totalTokens
 
-            const maxTokens = resolveTokenLimit(
-                config.compress.maxContextLimit,
-                state.modelContextLimit,
-            )
-            const minTokens = resolveTokenLimit(
-                config.compress.minContextLimit,
-                state.modelContextLimit,
-            )
-
-            const shouldComp = shouldCompress(
-                totalTokens,
-                maxTokens,
-                minTokens,
-                state.lastCompressionTime,
-                config.compress.nudgeFrequency,
-                event.messages.length,
-            )
-
-            if (shouldComp.compress && !state.manualMode) {
-                const nudgeMessage = getNudgeMessage(
-                    shouldComp.reason,
-                    totalTokens,
-                    maxTokens,
-                )
-                event.messages.push({
-                    role: "assistant",
-                    content: [{ type: "text", text: nudgeMessage }],
-                } as any)
-            }
+            // 4) DCP limit rules → anchored nudges (max 100k / min 50k by
+            //    default, model overrides supported via modelMax/MinLimits).
+            const lastUser = findLastUserMessage(event.messages)
+            const providerId =
+                lastUser?.model?.providerID ?? lastUser?.model?.id?.split?.("/")[0]
+            const modelId =
+                lastUser?.model?.modelID ??
+                lastUser?.model?.id?.split?.("/").slice(1).join("/")
+            const limits = resolveCompressLimits(config, state, providerId, modelId)
+            injectLimitNudges(state, config, event.messages, totalTokens, limits)
 
             saveSessionState(state, config.persistence.directory)
         })

package/src/lib/config.ts

@@ -2,17 +2,21 @@ import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs"
 import { join } from "path"
 import { homedir } from "os"
 import { parse } from "jsonc-parser/lib/esm/main.js"
-import type { SlimConfig } from "./types"
+import type { SlimConfig, SessionState } from "./types"
 
 const DEFAULT_CONFIG: SlimConfig = {
     enabled: true,
     debug: false,
     compress: {
         enabled: true,
+        mode: "range",
         permission: "allow",
-        maxContextLimit: "80%",
-        minContextLimit: "40%",
+        // DCP defaults: absolute token counts (not percentages).
+        maxContextLimit: 100000,
+        minContextLimit: 50000,
         nudgeFrequency: 5,
+        iterationNudgeThreshold: 15,
+        nudgeForce: "soft",
         protectUserMessages: false,
         protectedTools: ["task", "skill", "todowrite", "todoread"],
     },
@@ -46,7 +50,12 @@ function deepMerge(base: SlimConfig, override: Partial<SlimConfig>): SlimConfig
     return {
         ...base,
         ...override,
-        compress: { ...base.compress, ...override.compress },
+        compress: {
+            ...base.compress,
+            ...override.compress,
+            modelMaxLimits: override.compress?.modelMaxLimits ?? base.compress.modelMaxLimits,
+            modelMinLimits: override.compress?.modelMinLimits ?? base.compress.modelMinLimits,
+        },
         strategies: {
             deduplication: { ...base.strategies.deduplication, ...override.strategies?.deduplication },
             purgeErrors: { ...base.strategies.purgeErrors, ...override.strategies?.purgeErrors },
@@ -101,14 +110,17 @@ export function createDefaultConfig(): void {
             writeFileSync(
                 configPath,
                 `{
-    // Slim Configuration
+    // Slim Configuration (DCP-compatible limit rules)
     "enabled": true,
     "compress": {
         "enabled": true,
+        "mode": "range",
         "permission": "allow",
-        "maxContextLimit": "80%",
-        "minContextLimit": "40%",
-        "nudgeFrequency": 5
+        "maxContextLimit": 100000,
+        "minContextLimit": 50000,
+        "nudgeFrequency": 5,
+        "iterationNudgeThreshold": 15,
+        "nudgeForce": "soft"
     }
 }`,
                 "utf-8",
@@ -124,3 +136,39 @@ export function resolveTokenLimit(value: number | string, contextLimit: number):
     const percent = parseFloat(value.replace("%", "")) / 100
     return Math.floor(contextLimit * percent)
 }
+
+/**
+ * DCP limit resolution. Prefers per-model overrides (compress.modelMinLimits /
+ * compress.modelMaxLimits keyed by "providerId/modelId"), then falls back to the
+ * global max/min limit. Percent strings resolve against the model's context window.
+ */
+export function resolveCompressLimits(
+    config: SlimConfig,
+    state: SessionState,
+    providerId?: string,
+    modelId?: string,
+): { max: number; min: number } {
+    const parseLimit = (value: number | string | undefined): number => {
+        if (value === undefined) {
+            return 0
+        }
+        if (typeof value === "number") {
+            return value
+        }
+        const pct = parseFloat(value.replace("%", ""))
+        if (Number.isNaN(pct)) {
+            return 0
+        }
+        return Math.round((Math.max(0, Math.min(100, pct)) / 100) * state.modelContextLimit)
+    }
+
+    const providerModel = providerId && modelId ? `${providerId}/${modelId}` : undefined
+
+    const modelMin = providerModel ? config.compress.modelMinLimits?.[providerModel] : undefined
+    const modelMax = providerModel ? config.compress.modelMaxLimits?.[providerModel] : undefined
+
+    return {
+        max: parseLimit(modelMax ?? config.compress.maxContextLimit),
+        min: parseLimit(modelMin ?? config.compress.minContextLimit),
+    }
+}

package/src/lib/prompts.ts

@@ -6,12 +6,17 @@ You have access to context management tools. Use them wisely:
 
 ### compress tool
 Use \`compress\` to reduce context size when it gets large. It supports:
+- Range mode: Compress a specific message range (start/end indices) into one summary
+- Topic mode: Compress messages matching a topic keyword
 - Auto mode: Intelligently selects what to compress
-- Range mode: Compress specific message range
-- Topic mode: Compress messages matching a topic
 
 Example: \`compress({ focus: "old exploration" })\`
 
+Compressed ranges are replaced by their summary on outgoing requests, so the
+model keeps the essential information while token usage drops on every
+subsequent request. Protected tool results (task, skill, todowrite, todoread)
+are preserved inside the summary.
+
 ### panel tool
 Use \`panel\` to view current context usage and statistics.
 
@@ -30,19 +35,30 @@ export function getCompressToolDescription(): string {
 - Range mode: Compress specific message range (start/end indices)
 - Topic mode: Compress messages matching a topic keyword
 
-The compression creates a summary preserving key information while removing redundancy.`
+The compression creates a summary preserving key information (including
+protected tool outputs) and replaces the selected messages with that summary on
+future requests, so the context stays small.`
 }
 
-export function getNudgeMessage(reason: string, currentTokens: number, maxTokens: number): string {
-    const percent = Math.round((currentTokens / maxTokens) * 100)
-    return `💡 **Context Optimization Available**
+// ─── DCP-style limit nudges ────────────────────────────────────────────────
+//
+// Every nudge carries a stable marker so the pipeline can detect an existing
+// nudge regardless of its dynamic content (percentages change every request).
 
-${reason} (${percent}% used)
+export const NUDGE_MARKERS = {
+    contextLimit: "[[slim:context-limit]]",
+    turn: "[[slim:turn]]",
+    iteration: "[[slim:iteration]]",
+} as const
 
-Consider using the \`compress\` tool to free up context space:
-\`\`\`
-compress({ focus: "describe what to compress" })
-\`\`\`
+export function contextLimitNudge(percent: number, maxTokens: number): string {
+    return `${NUDGE_MARKERS.contextLimit}\n\n> ⚠️ **Context at capacity: ${percent}% of ${maxTokens.toLocaleString()} tokens.** Older completed work should be compressed now to keep the session efficient. Call \`compress\` with a focus describing the oldest exchange, e.g. \`compress({ focus: "initial exploration" })\`. Past ranges are replaced by summaries to avoid re-sending tokens.`
+}
 
-This will create a summary of older messages, preserving key information while freeing tokens.`
+export function turnNudge(percent: number): string {
+    return `${NUDGE_MARKERS.turn}\n\n> 💡 **Context is getting large (${percent}% of limit).** When you finish the current task, consider calling \`compress\` on the completed portion to keep the session fast and cheap.`
 }
+
+export function iterationNudge(percent: number): string {
+    return `${NUDGE_MARKERS.iteration}\n\n> 💡 **Many tool iterations since the last user message (${percent}% of limit used).** If the explored subtree is done, call \`compress({ focus: "exploration so far" })\` to replace it with a summary.`
+}

package/src/lib/state.ts

@@ -13,6 +13,29 @@ const DEFAULT_STATE: SessionState = {
     compressionHistory: [],
     averageCompressionRatio: 0,
     toolCalls: new Map(),
+    compressionBlocks: [],
+    nextBlockId: 1,
+    nudges: { contextLimitAnchors: [], turnNudgeAnchors: [], iterationNudgeAnchors: [] },
+}
+
+export function normalizeState(state: SessionState): SessionState {
+    state.compressionBlocks = Array.isArray(state.compressionBlocks) ? state.compressionBlocks : []
+    state.nextBlockId =
+        typeof state.nextBlockId === "number" && state.nextBlockId > 0
+            ? state.nextBlockId
+            : state.compressionBlocks.reduce((max, b) => Math.max(max, b.blockId), 0) + 1
+    state.nudges = {
+        contextLimitAnchors: Array.isArray(state.nudges?.contextLimitAnchors)
+            ? state.nudges.contextLimitAnchors
+            : [],
+        turnNudgeAnchors: Array.isArray(state.nudges?.turnNudgeAnchors)
+            ? state.nudges.turnNudgeAnchors
+            : [],
+        iterationNudgeAnchors: Array.isArray(state.nudges?.iterationNudgeAnchors)
+            ? state.nudges.iterationNudgeAnchors
+            : [],
+    }
+    return state
 }
 
 export function loadSessionState(sessionId: string, persistenceDir: string): SessionState {
@@ -26,13 +49,13 @@ export function loadSessionState(sessionId: string, persistenceDir: string): Ses
             if (parsed.toolCalls && Array.isArray(parsed.toolCalls)) {
                 parsed.toolCalls = new Map(parsed.toolCalls)
             }
-            return { ...DEFAULT_STATE, ...parsed, sessionId }
+            return normalizeState({ ...DEFAULT_STATE, ...parsed, sessionId })
         } catch {
             // Use default
         }
     }
 
-    return { ...DEFAULT_STATE, sessionId }
+    return normalizeState({ ...DEFAULT_STATE, sessionId })
 }
 
 export function saveSessionState(state: SessionState, persistenceDir: string): void {

package/src/lib/strategies.ts

@@ -1,8 +1,301 @@
-import type { MessageWithParts, SlimConfig } from "./types"
-import { getToolName, getToolResultContent, getMessageText } from "./compress"
-import { getDuplicateToolCalls, getErroredToolCalls } from "./state"
-import type { SessionState } from "./types"
+import type { MessageWithParts, SlimConfig, SessionState, CompressionBlock } from "./types"
+import { getToolName, getMessageText } from "./compress"
+import { contextLimitNudge, turnNudge, iterationNudge, NUDGE_MARKERS } from "./prompts"
 
+// ─── DCP-style Compression Blocks ───────────────────────────────────────────
+//
+// A compression block replaces a contiguous range of messages with a summary
+// placeholder on every outgoing request. The summary is injected as a synthetic
+// user message at the block's *anchor* message (the first message after the
+// range, or the last message when the range reaches the end). The covered
+// messages are removed from the outgoing request only — session history is
+// never modified. Newer blocks "consume" older ones (nested compression).
+
+/**
+ * Activates/deactivates blocks based on which messages are present in the
+ * current outgoing request. A block is active while both its origin message
+ * (compressMessageId) and its anchor message are still present. A newer active
+ * block deactivates any older block whose anchor falls inside its covered range.
+ */
+export function syncCompressionBlocks(state: SessionState, presentIds: Set<string>): void {
+    const blocks = state.compressionBlocks ?? []
+    if (blocks.length === 0) return
+
+    for (const block of blocks) {
+        const hasOrigin =
+            block.compressMessageId.length > 0 ? presentIds.has(block.compressMessageId) : true
+        block.active = hasOrigin && presentIds.has(block.anchorMessageId)
+    }
+
+    // Nested consumption: newest active block wins over older blocks it covers,
+    // and inherits their covered messages so nothing resurfaces behind the
+    // newest summary. Loop until stable to handle chains (A -> B -> C).
+    const sorted = [...blocks].sort((a, b) => a.blockId - b.blockId)
+    let changed = true
+    while (changed) {
+        changed = false
+        for (const block of sorted) {
+            if (!block.active) continue
+            for (const older of sorted) {
+                if (older.blockId >= block.blockId || !older.active) continue
+                if (block.coveredMessageIds.includes(older.anchorMessageId)) {
+                    older.active = false
+                    for (const id of older.coveredMessageIds) {
+                        if (!block.coveredMessageIds.includes(id)) {
+                            block.coveredMessageIds.push(id)
+                            changed = true
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Orphaned blocks: inactive and none of their referenced messages survive
+    // (e.g. after OpenCode compaction) — safe to forget, otherwise dead entries
+    // accumulate in persisted state forever.
+    const alive = blocks.filter((b) => {
+        if (b.active) return true
+        const refs = [b.anchorMessageId, b.compressMessageId, ...(b.coveredMessageIds ?? [])]
+        return refs.some((id) => typeof id === "string" && presentIds.has(id))
+    })
+    if (alive.length !== blocks.length) {
+        state.compressionBlocks = alive
+    }
+}
+
+/**
+ * Produces the outgoing message list: active blocks inject their summary at the
+ * anchor and drop every covered message. Returns a new array; the caller should
+ * splice it back into the event.
+ */
+export function applyCompressedRanges(state: SessionState, messages: any[]): any[] {
+    const blocks = (state.compressionBlocks ?? []).filter((b) => b.active)
+    if (blocks.length === 0 || messages.length === 0) return messages
+
+    const covered = new Set<string>()
+    const byAnchor = new Map<string, CompressionBlock>()
+    for (const block of blocks) {
+        for (const id of block.coveredMessageIds) covered.add(id)
+        byAnchor.set(block.anchorMessageId, block)
+    }
+
+    const result: any[] = []
+    for (const msg of messages) {
+        const id = (msg && (msg.id ?? msg.info?.id)) as string | undefined
+        if (typeof id === "string") {
+            const block = byAnchor.get(id)
+            if (block && block.summary) {
+                result.push({
+                    role: "user",
+                    id: `slim-summary-${block.blockId}`,
+                    content: [{ type: "text", text: block.summary }],
+                })
+            }
+            if (covered.has(id)) {
+                continue
+            }
+        }
+        result.push(msg)
+    }
+    return result
+}
+
+export interface RegisterBlockOptions {
+    coveredIds: string[]
+    anchorMessageId: string
+    summary: string
+    topic: string
+    compressMessageId?: string
+    summaryTokens?: number
+}
+
+/**
+ * Registers a new compression block. Older active blocks whose anchor lies
+ * inside the new range are consumed (deactivated) so only the newest summary
+ * is injected — information survives through layers of compression.
+ */
+export function registerCompressionBlock(
+    state: SessionState,
+    opts: RegisterBlockOptions,
+): CompressionBlock | null {
+    const blocks = state.compressionBlocks ?? []
+    const nextId =
+        state.nextBlockId ??
+        blocks.reduce((max, b) => Math.max(max, b.blockId), 0) + 1
+
+    const consumed = blocks
+        .filter((b) => b.active && opts.coveredIds.includes(b.anchorMessageId))
+        .map((b) => b.blockId)
+
+    const block: CompressionBlock = {
+        blockId: nextId,
+        topic: opts.topic,
+        summary: opts.summary,
+        anchorMessageId: opts.anchorMessageId,
+        compressMessageId: opts.compressMessageId ?? "",
+        coveredMessageIds: opts.coveredIds,
+        consumedBlockIds: consumed,
+        active: true,
+        createdAt: Date.now(),
+        summaryTokens: opts.summaryTokens ?? 0,
+    }
+
+    blocks.push(block)
+    state.compressionBlocks = blocks
+    state.nextBlockId = nextId + 1
+
+    for (const consumedId of consumed) {
+        const target = blocks.find((b) => b.blockId === consumedId)
+        if (target) {
+            target.active = false
+            // Inherit the consumed block's covered messages so they stay
+            // hidden behind the newer summary (nested compression).
+            for (const id of target.coveredMessageIds) {
+                if (!block.coveredMessageIds.includes(id)) {
+                    block.coveredMessageIds.push(id)
+                }
+            }
+        }
+    }
+
+    return block
+}
+
+// ─── Summary building (with protected content) ─────────────────────────────
+
+/**
+ * Builds the compression summary used as the placeholder. Protected tool
+ * outputs (task, skill, todowrite, todoread, ...) are appended verbatim so the
+ * most important information survives compression — DCP behaviour.
+ */
+export async function buildCompressionSummary(
+    messages: MessageWithParts[],
+    focus: string,
+    protectedTools: string[],
+    protectUserMessages = false,
+): Promise<string> {
+    const lines: string[] = []
+    lines.push(`## Compression Summary`)
+    lines.push(`Focus: ${focus}`)
+    lines.push(`Messages compressed: ${messages.length}`)
+    lines.push("")
+
+    const toolCalls: string[] = []
+    const errors: string[] = []
+    const decisions: string[] = []
+
+    for (const msg of messages) {
+        for (const part of msg.parts) {
+            if (part.type === "tool-call") {
+                toolCalls.push(
+                    `${part.name}: ${JSON.stringify(part.input || {}).slice(0, 100)}`,
+                )
+            }
+            if (part.type === "tool-result") {
+                if (part.result?.type === "error") {
+                    errors.push(String(part.result.value).slice(0, 200) || "Unknown error")
+                }
+            }
+            if (part.type === "text") {
+                const text = part.text || ""
+                if (
+                    text.includes("decided") ||
+                    text.includes("chose") ||
+                    text.includes("implemented")
+                ) {
+                    decisions.push(text.slice(0, 200))
+                }
+            }
+        }
+    }
+
+    if (toolCalls.length > 0) {
+        lines.push("### Tool Calls")
+        toolCalls.slice(0, 10).forEach((tc) => lines.push(`- ${tc}`))
+        lines.push("")
+    }
+
+    if (errors.length > 0) {
+        lines.push("### Errors Encountered")
+        errors.slice(0, 5).forEach((e) => lines.push(`- ${e}`))
+        lines.push("")
+    }
+
+    if (decisions.length > 0) {
+        lines.push("### Key Decisions")
+        decisions.slice(0, 5).forEach((d) => lines.push(`- ${d}`))
+        lines.push("")
+    }
+
+    const protectedContent = collectProtectedToolOutputs(messages, protectedTools)
+    if (protectedContent.length > 0) {
+        lines.push("### Protected Tool Outputs")
+        lines.push(protectedContent)
+        lines.push("")
+    }
+
+    // DCP protectUserMessages: the user's own instructions survive compression
+    // verbatim inside the summary, so nothing the user asked is ever lost to a
+    // lossy paraphrase.
+    if (protectUserMessages) {
+        const userTexts: string[] = []
+        for (const msg of messages) {
+            if (msg.info.role !== "user") continue
+            const text = getMessageText(msg)
+            if (text.trim().length > 0) userTexts.push(text.trim())
+        }
+        if (userTexts.length > 0) {
+            lines.push("### User Messages (preserved verbatim)")
+            userTexts.forEach((t, i) => lines.push(`- [user ${i + 1}] ${t.slice(0, 2000)}`))
+            lines.push("")
+        }
+    }
+
+    return lines.join("\n")
+}
+
+function collectProtectedToolOutputs(
+    messages: MessageWithParts[],
+    protectedTools: string[],
+): string {
+    if (protectedTools.length === 0) return ""
+
+    const resultsByCallId = new Map<string, string>()
+    for (const msg of messages) {
+        for (const part of msg.parts) {
+            if (part.type !== "tool-result") continue
+            const callId = part.toolCallID ?? part.callID
+            if (!callId) continue
+            const val = part.result?.value ?? part.result
+            if (val !== undefined && val !== null && part.result?.type !== "error") {
+                resultsByCallId.set(String(callId), String(val))
+            }
+        }
+    }
+
+    const output: string[] = []
+    for (const msg of messages) {
+        for (const part of msg.parts) {
+            if (part.type !== "tool-call") continue
+            const name = part.name
+            if (!name || !protectedTools.includes(name)) continue
+            const input = JSON.stringify(part.input ?? {}).slice(0, 1000)
+            const callId = part.toolCallID ?? part.callID
+            const result = callId ? resultsByCallId.get(String(callId)) : undefined
+            output.push(
+                result
+                    ? `- [${name}] input: ${input}\n  output: ${result.slice(0, 2000)}`
+                    : `- [${name}] input: ${input}`,
+            )
+        }
+    }
+    return output.join("\n")
+}
+
+// ─── Pruning: dedup + purge errored tool inputs ────────────────────────────
+
+/** Kept for compatibility: pure deduplication over MessageWithParts. */
 export function pruneMessages(
     messages: MessageWithParts[],
     config: SlimConfig,
@@ -10,7 +303,6 @@ export function pruneMessages(
 ): MessageWithParts[] {
     let pruned = [...messages]
 
-    // Apply deduplication
     if (config.strategies.deduplication.enabled) {
         pruned = applyDeduplication(pruned, config.strategies.deduplication.protectedTools)
     }
@@ -18,32 +310,302 @@ export function pruneMessages(
     return pruned
 }
 
-function applyDeduplication(messages: MessageWithParts[], protectedTools: string[]): MessageWithParts[] {
-    const seen = new Map<string, number>()
+export function applyDeduplication(
+    messages: MessageWithParts[],
+    protectedTools: string[],
+): MessageWithParts[] {
+    const seen = new Set<string>()
     const toRemove = new Set<number>()
 
     for (let i = 0; i < messages.length; i++) {
         const msg = messages[i]
         const toolName = getToolName(msg)
 
-        // Skip protected tools
         if (toolName && protectedTools.includes(toolName)) {
             continue
         }
 
-        // Create a fingerprint of the message
-        const text = getMessageText(msg)
-        const toolContent = getToolResultContent(msg)
-        const fingerprint = `${msg.info.role}:${text.slice(0, 200)}:${toolContent.slice(0, 200)}`
-
-        const existingIndex = seen.get(fingerprint)
-        if (existingIndex !== undefined) {
-            // Mark later duplicate for removal
+        // Exact full-content fingerprint: only identical messages are removed.
+        const fingerprint = `${msg.info.role}:${JSON.stringify(msg.parts)}`
+        if (seen.has(fingerprint)) {
             toRemove.add(i)
         } else {
-            seen.set(fingerprint, i)
+            seen.add(fingerprint)
         }
     }
 
     return messages.filter((_, i) => !toRemove.has(i))
 }
+
+/**
+ * DCP purge-errors: for tool calls whose result is an error, remove the large
+ * string inputs once the message is at least `turns` positions behind the end
+ * of the conversation. Error messages themselves are preserved.
+ */
+export function purgeStaleToolErrors(messages: any[], turns: number): void {
+    const n = messages.length
+    if (n === 0) return
+
+    const erroredCallIds = new Set<string>()
+    for (const msg of messages) {
+        for (const part of msg?.content ?? msg?.parts ?? []) {
+            if (part?.type !== "tool-result") continue
+            if (part.result?.type !== "error") continue
+            const callId = part.toolCallID ?? part.callID
+            if (callId) erroredCallIds.add(String(callId))
+        }
+    }
+    if (erroredCallIds.size === 0) return
+
+    const turnsEffective = Math.max(1, Math.floor(turns) || 1)
+    for (let i = 0; i < n; i++) {
+        if (i > n - turnsEffective - 1) continue // too recent — keep
+        const msg = messages[i]
+        for (const part of msg?.content ?? msg?.parts ?? []) {
+            if (part?.type !== "tool-call") continue
+            const callId = part.toolCallID ?? part.callID
+            if (!callId || !erroredCallIds.has(String(callId))) continue
+            const input = part.input
+            if (input && typeof input === "object") {
+                for (const key of Object.keys(input)) {
+                    if (typeof input[key] === "string" && input[key].length > 80) {
+                        input[key] = "[input removed due to failed tool call]"
+                    }
+                }
+            }
+        }
+    }
+}
+
+/** In-place dedup over raw outgoing messages; returns the keep count. */
+export function pruneInPlace(messages: any[], config: SlimConfig): void {
+    if (!config.strategies.deduplication.enabled) return
+
+    const protectedTools = config.strategies.deduplication.protectedTools
+    const seen = new Set<string>()
+    const toRemove = new Set<number>()
+
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i] as any
+        const content = msg?.content ?? msg?.parts ?? []
+
+        // Protected tools (and messages carrying them) are never deduplicated.
+        let toolName: string | null = null
+        for (const part of content) {
+            if (part?.type === "tool-call") {
+                toolName = toolName ?? part.name ?? null
+            }
+        }
+        if (toolName && protectedTools.includes(toolName)) continue
+
+        // Exact full-content fingerprint — only truly identical messages are
+        // removed. Truncated fingerprints would eat distinct messages that share
+        // a common prefix.
+        const fingerprint = `${msg?.role}:${JSON.stringify(content)}`
+        if (seen.has(fingerprint)) {
+            toRemove.add(i)
+        } else {
+            seen.add(fingerprint)
+        }
+    }
+
+    if (toRemove.size === 0) return
+    const kept = messages.filter((_, i) => !toRemove.has(i))
+    messages.splice(0, messages.length, ...kept)
+}
+
+// ─── DCP limit rules → anchored nudges ─────────────────────────────────────
+
+export function messageHasCompress(msg: any): boolean {
+    const content = msg?.content ?? msg?.parts ?? []
+    return content.some(
+        (part: any) => part?.type === "tool-call" && part?.name === "compress",
+    )
+}
+
+export function findLastUserMessage(messages: any[]): any | undefined {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i]?.role === "user") return messages[i]
+    }
+    return undefined
+}
+
+function getNudgeFrequency(config: SlimConfig): number {
+    return Math.max(1, Math.floor(config.compress.nudgeFrequency || 1))
+}
+
+function getIterationThreshold(config: SlimConfig): number {
+    return Math.max(1, Math.floor(config.compress.iterationNudgeThreshold || 1))
+}
+
+function addAnchor(
+    anchors: string[],
+    messageId: string | undefined,
+    index: number,
+    messages: any[],
+    interval: number,
+): boolean {
+    if (!messageId || index < 0) return false
+
+    let latestAnchorIndex = -1
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i] as any
+        const id = m?.id ?? m?.info?.id
+        if (typeof id === "string" && anchors.includes(id)) {
+            latestAnchorIndex = i
+            break
+        }
+    }
+
+    const shouldAdd = latestAnchorIndex < 0 || index - latestAnchorIndex >= interval
+    if (!shouldAdd) return false
+
+    if (!anchors.includes(messageId)) {
+        anchors.push(messageId)
+        return true
+    }
+    return false
+}
+
+function addSpecificAnchor(anchors: string[], messageId: string | undefined): void {
+    if (messageId && !anchors.includes(messageId)) {
+        anchors.push(messageId)
+    }
+}
+
+function messageHasNudge(msg: any, marker: string): boolean {
+    const content = msg?.content ?? msg?.parts ?? []
+    return content.some(
+        (part: any) => part?.type === "text" && typeof part.text === "string" && part.text.includes(marker),
+    )
+}
+
+function appendToMessage(msg: any, nudgeText: string): void {
+    const content = (msg?.content ?? msg?.parts ?? []) as any[]
+    for (const part of content) {
+        if (part?.type === "text") {
+            part.text = `${part.text}\n\n${nudgeText}`
+            return
+        }
+    }
+    content.push({ type: "text", text: nudgeText })
+}
+
+/**
+ * DCP limit rules: compare current usage against maxContextLimit /
+ * minContextLimit and anchor nudges so the model is pushed to compress at most
+ * once per nudgeFrequency messages. If the last assistant turn already ran the
+ * compress tool, all anchors are cleared.
+ */
+export function injectLimitNudges(
+    state: SessionState,
+    config: SlimConfig,
+    messages: any[],
+    currentTokens: number,
+    limits: { max: number; min: number },
+): void {
+    if (config.compress.permission === "deny") return
+    if (state.manualMode) return
+    if (messages.length === 0) return
+
+    const nudges = state.nudges ?? {
+        contextLimitAnchors: [],
+        turnNudgeAnchors: [],
+        iterationNudgeAnchors: [],
+    }
+
+    const lastAssistant = [...messages].reverse().find((m) => (m as any)?.role === "assistant")
+    if (lastAssistant && messageHasCompress(lastAssistant)) {
+        nudges.contextLimitAnchors = []
+        nudges.turnNudgeAnchors = []
+        nudges.iterationNudgeAnchors = []
+        state.nudges = nudges
+        return
+    }
+
+    const overMax = limits.max > 0 && currentTokens > limits.max
+    const overMin = limits.min > 0 && currentTokens >= limits.min
+
+    if (!overMin) {
+        if (nudges.turnNudgeAnchors.length > 0 || nudges.iterationNudgeAnchors.length > 0) {
+            nudges.turnNudgeAnchors = []
+            nudges.iterationNudgeAnchors = []
+        }
+    }
+
+    const lastIndex = messages.length - 1
+    const lastMessage = messages[lastIndex] as any
+    const lastMessageId = lastMessage?.id ?? lastMessage?.info?.id
+
+    if (overMax) {
+        addAnchor(
+            nudges.contextLimitAnchors,
+            lastMessageId,
+            lastIndex,
+            messages,
+            getNudgeFrequency(config),
+        )
+    } else if (overMin) {
+        // Turn nudge: fire at a user/assistant turn boundary.
+        if (lastMessage?.role === "user" && lastAssistant) {
+            addSpecificAnchor(nudges.turnNudgeAnchors, lastMessageId)
+            const lastAssistantId = lastAssistant?.id ?? lastAssistant?.info?.id
+            addSpecificAnchor(nudges.turnNudgeAnchors, lastAssistantId)
+        }
+
+        // Iteration nudge: too many messages since the last user request.
+        const lastUserIndex = messages.findIndex((m) => (m as any)?.role === "user")
+        if (lastUserIndex >= 0 && lastIndex > lastUserIndex) {
+            const sinceUser = lastIndex - lastUserIndex
+            if (sinceUser >= getIterationThreshold(config)) {
+                addAnchor(
+                    nudges.iterationNudgeAnchors,
+                    lastMessageId,
+                    lastIndex,
+                    messages,
+                    getNudgeFrequency(config),
+                )
+            }
+        }
+    }
+
+    const percent = limits.max > 0 ? Math.round((currentTokens / limits.max) * 100) : 0
+    // DCP nudgeForce: "soft" anchors the turn nudge on the assistant message,
+    // "strong" on the user message.
+    const targetRole = config.compress.nudgeForce === "strong" ? "user" : "assistant"
+
+    const injectForAnchors = (anchors: string[], marker: string, text: string, roleFilter?: string) => {
+        if (!text) return
+        for (const anchorId of anchors) {
+            const msg = messages.find((m) => {
+                const id = (m as any)?.id ?? (m as any)?.info?.id
+                return id === anchorId
+            })
+            if (!msg) continue
+            if (roleFilter && (msg as any)?.role !== roleFilter) continue
+            // Idempotency via stable marker: the dynamic part of the nudge
+            // (percentages) changes every request, so match on the marker only.
+            if (messageHasNudge(msg, marker)) continue
+            appendToMessage(msg, text)
+        }
+    }
+
+    injectForAnchors(
+        nudges.contextLimitAnchors,
+        NUDGE_MARKERS.contextLimit,
+        contextLimitNudge(percent, limits.max),
+    )
+    injectForAnchors(
+        nudges.turnNudgeAnchors,
+        NUDGE_MARKERS.turn,
+        turnNudge(percent),
+        targetRole,
+    )
+    injectForAnchors(
+        nudges.iterationNudgeAnchors,
+        NUDGE_MARKERS.iteration,
+        iterationNudge(percent),
+    )
+
+    state.nudges = nudges
+}

package/src/lib/types.ts

@@ -6,13 +6,26 @@ export interface SlimConfig {
     enabled: boolean
     debug: boolean
 
-    // Compression settings
+    // Compression settings (DCP-compatible semantics)
     compress: {
         enabled: boolean
+        /** DCP mode: "range" (contiguous spans) or "message" (surgical, single messages) */
+        mode?: "range" | "message"
         permission: "allow" | "ask" | "deny"
-        maxContextLimit: number | string // number or "80%"
-        minContextLimit: number | string // number or "40%"
+        /** Absolute token count or percent string like "80%" (DCP default: 100000) */
+        maxContextLimit: number | string
+        /** Absolute token count or percent string like "40%" (DCP default: 50000) */
+        minContextLimit: number | string
+        /** Per-model overrides, keyed "providerId/modelId" (DCP: compress.modelMaxLimits) */
+        modelMaxLimits?: Record<string, number | string>
+        /** Per-model overrides, keyed "providerId/modelId" (DCP: compress.modelMinLimits) */
+        modelMinLimits?: Record<string, number | string>
+        /** At most one limit-nudge per this many messages (DCP default: 5) */
         nudgeFrequency: number
+        /** Messages since last user message before iteration nudge fires (DCP default: 15) */
+        iterationNudgeThreshold?: number
+        /** Where the turn nudge is anchored: "strong" -> user, "soft" -> assistant (DCP default: soft) */
+        nudgeForce?: "strong" | "soft"
         protectUserMessages: boolean
         protectedTools: string[]
     }
@@ -67,6 +80,40 @@ export interface SessionState {
 
     // Tool call tracking
     toolCalls: Map<string, ToolCallInfo>
+
+    // DCP-style compression blocks (range -> summary placeholders)
+    compressionBlocks?: CompressionBlock[]
+    nextBlockId?: number
+    // DCP-style nudge anchors
+    nudges?: NudgeState
+}
+
+/**
+ * A DCP-style compression block. When active, the covered messages are
+ * removed from every outgoing request and replaced by a synthetic summary
+ * message injected at the anchor message (the message right after the range).
+ */
+export interface CompressionBlock {
+    blockId: number
+    topic: string
+    summary: string
+    /** Message id where the summary is injected (first message after the range, or the last message when the range reaches the end). */
+    anchorMessageId: string
+    /** The assistant message that executed the compress call; used to deactivate blocks when the source is gone. */
+    compressMessageId: string
+    /** Original message ids covered (excluded) by this block. */
+    coveredMessageIds: string[]
+    /** Older blocks swallowed by this block (nested compression). */
+    consumedBlockIds: number[]
+    active: boolean
+    createdAt: number
+    summaryTokens: number
+}
+
+export interface NudgeState {
+    contextLimitAnchors: string[]
+    turnNudgeAnchors: string[]
+    iterationNudgeAnchors: string[]
 }
 
 export interface CompressionRecord {