@serkanalgur/opencodev2-slim 2.0.13 → 2.0.15

package/package.json

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

package/src/index.ts

@@ -1,15 +1,26 @@
 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,
+    autoCompress,
+} 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 +69,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))
-                }
-            }
-        }
-    }
-
-    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("")
+// 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 (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 +241,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 +285,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 {
@@ -362,8 +386,12 @@ export default Plugin.define({
             event.system.push({ type: "text", text: getSystemPrompt() })
         })
 
-        // ─── Messages Transform Hook (sync) ──────────────────────────────
-        await ctx.session.hook("context", (event) => {
+        // ─── Messages Transform Hook (sync → async) ─────────────────────────
+        // 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", async (event) => {
             const sessionId = event.sessionID
             const config = getConfig(sessionId)
             if (!config.enabled) return
@@ -371,71 +399,59 @@ 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)
+
+            // 5) Auto-compress: when over the max limit, directly compress old
+            //    messages without waiting for the model to call the compress tool.
+            //    Registers a compression block so future requests use the summary.
+            if (totalTokens > limits.max) {
+                try {
+                    await autoCompress(state, config, event.messages, totalTokens, limits)
+                } catch {
+                    // Best-effort: auto-compress failure should never break the request.
+                }
             }
 
             saveSessionState(state, config.persistence.directory)

package/src/lib/config.ts

@@ -2,19 +2,24 @@ 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"],
+        keepRecent: 5,
     },
     strategies: {
         deduplication: {
@@ -46,7 +51,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 +111,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 +137,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 {