@serkanalgur/opencodev2-slim 2.0.14 → 2.1.0

package/package.json

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

package/src/index.ts

@@ -16,6 +16,7 @@ import {
     pruneInPlace,
     injectLimitNudges,
     findLastUserMessage,
+    autoCompress,
 } from "./lib/strategies"
 import { getSystemPrompt, getCompressToolDescription } from "./lib/prompts"
 import { buildPanelData, renderPanel } from "./lib/tui"
@@ -46,27 +47,40 @@ function getConfig(sessionId: string): SlimConfig {
 }
 
 // Resolve the active model's real context limit instead of hard-coding 200k.
-// ctx.model.default() returns { data: ModelInfo | null }, where ModelInfo.limit.context
-// holds the model's context window. Use it directly and only fall back when missing.
-async function resolveModelContextLimit(ctx: any): Promise<number> {
+// ctx.model.default() only returns { providerID, modelID } — no limit info.
+// Use ctx.model.list() to find the full Model.Info which includes limit.context.
+export async function resolveModelContextLimit(ctx: any): Promise<number> {
     try {
-        const selected: { data?: { limit?: { context?: number } } | null } | undefined =
-            await ctx.model.default()
-        const limit = selected?.data?.limit?.context
-        return typeof limit === "number" && limit > 0 ? limit : DEFAULT_MODEL_LIMIT
+        const defaultRef: { providerID?: string; modelID?: string } | undefined =
+            typeof ctx.model.default === "function" ? await ctx.model.default() : undefined
+        const providerID = defaultRef?.providerID
+        const modelID = defaultRef?.modelID
+
+        if (providerID && modelID && typeof ctx.model.list === "function") {
+            const models: Array<{ providerID: string; modelID: string; limit?: { context?: number } }> =
+                ctx.model.list()
+            const found = models.find(
+                (m) => m.providerID === providerID && m.modelID === modelID,
+            )
+            const limit = found?.limit?.context
+            if (typeof limit === "number" && limit > 0) return limit
+        }
+
+        // Fallback: try model.list() for any model with a limit
+        if (typeof ctx.model.list === "function") {
+            const models: Array<{ limit?: { context?: number } }> = ctx.model.list()
+            for (const m of models) {
+                const limit = m.limit?.context
+                if (typeof limit === "number" && limit > 0) return limit
+            }
+        }
     } catch {
-        return DEFAULT_MODEL_LIMIT
+        // Fall through to default
     }
+    return DEFAULT_MODEL_LIMIT
 }
 
-// Compose the exact text used to summarize a transcript (used by compaction).
-function stringifyTranscript(v: unknown): string {
-    // A compact but useful representation of the transcript to be summarized.
-    const text = String(v)
-    return text.length > 4000 ? `${text.slice(0, 4000)}\n…` : text
-}
-
-// ─── Helpers ────────────────────────────────────────────────────────────────
+// ─── State Management ───────────────────────────────────────────────────────
 
 // Register a DCP-style compression block for the selected range. The range is
 // covered (removed from future outgoing requests) and the summary is injected
@@ -109,18 +123,109 @@ function registerBlockForRange(
     })
 }
 
+/**
+ * Wraps any message format into MessageWithParts for internal processing.
+ * Handles both:
+ * - Raw Message format (from context hook): { id, role, parts/content }
+ * - SessionMessageInfo format (from session.context()): { id, type, text/content }
+ * - Transcript format (from TUI): { type, text, content }
+ */
 function wrapAsMessageWithParts(msg: any): MessageWithParts {
-    const msgInfo = msg.info
-    const id = (msg && (msg.id || msgInfo?.id)) || ""
-    const role = (msg && (msg.role || msgInfo?.role)) || "user"
+    // Determine the role from various possible fields
+    let role = "assistant"
+    if (msg?.role) {
+        role = msg.role
+    } else if (msg?.type) {
+        // SessionMessageInfo / transcript format: type -> role mapping
+        const type = msg.type as string
+        if (type === "user" || type === "shell" || type === "synthetic") {
+            role = "user"
+        } else if (type === "assistant") {
+            role = "assistant"
+        } else if (type === "compaction" || type === "agent" || type === "model" || type === "skill") {
+            role = "system"
+        } else {
+            role = "assistant"
+        }
+    }
+
+    // Extract ID
+    const id = msg?.id ?? msg?.info?.id ?? ""
+
+    // Build parts array from whatever format we receive
+    const parts: any[] = []
+
+    if (role === "user") {
+        // User messages: text can be in msg.text, msg.content, or msg.parts
+        if (typeof msg.text === "string" && msg.text) {
+            parts.push({ type: "text", text: msg.text })
+        } else if (Array.isArray(msg.parts)) {
+            for (const p of msg.parts) {
+                if (p?.type === "text" && p.text) {
+                    parts.push({ type: "text", text: p.text })
+                }
+            }
+        } else if (Array.isArray(msg.content)) {
+            for (const p of msg.content) {
+                if (p?.type === "text" && p.text) {
+                    parts.push({ type: "text", text: p.text })
+                }
+            }
+        }
+    } else if (role === "assistant") {
+        // Assistant messages: content can be an array of parts
+        const contentArr = msg.content ?? msg.parts ?? []
+        if (Array.isArray(contentArr)) {
+            for (const p of contentArr) {
+                if (p?.type === "text") {
+                    parts.push({ type: "text", text: p.text || "" })
+                } else if (p?.type === "tool") {
+                    // SessionMessageAssistantTool format: has callID, name, state
+                    const state = p.state
+                    if (state?.status === "completed") {
+                        parts.push({
+                            type: "tool-result",
+                            toolCallID: p.callID,
+                            result: { value: state.content ?? state.output ?? "" },
+                        })
+                    } else if (state?.status === "error") {
+                        parts.push({
+                            type: "tool-result",
+                            toolCallID: p.callID,
+                            result: { type: "error", value: state.error ?? "Unknown error" },
+                        })
+                    }
+                    // Tool call part
+                    parts.push({
+                        type: "tool-call",
+                        name: p.name || p.tool || "",
+                        input: state?.input ?? {},
+                        toolCallID: p.callID,
+                    })
+                } else if (p?.type === "tool-call") {
+                    parts.push(p)
+                } else if (p?.type === "tool-result") {
+                    parts.push(p)
+                }
+            }
+        }
+    } else if (role === "system") {
+        // System / compaction messages
+        if (typeof msg.summary === "string" && msg.summary) {
+            parts.push({ type: "text", text: msg.summary })
+        } else if (typeof msg.text === "string" && msg.text) {
+            parts.push({ type: "text", text: msg.text })
+        }
+    }
+
     return {
         info: {
             id,
             role,
-            sessionID: (msg && (msg.sessionID || msgInfo?.sessionID)) || "",
+            sessionID: msg?.sessionID ?? msg?.info?.sessionID ?? "",
             time: { created: Date.now() },
         } as any,
-        parts: (msg && (msg.parts || msg.content)) || [],
+        parts,
     }
 }
 
@@ -197,10 +302,21 @@ export default Plugin.define({
                             return { content: "No messages found in session" }
                         }
 
+                        if (config.debug) {
+                            const first = messages[0] as any
+                            console.log(`[slim] compress: received ${messages.length} messages from session.context()`)
+                            console.log(`[slim] compress: first message type: ${first?.type}, has text: ${typeof first?.text}, has content: ${Array.isArray(first?.content)}`)
+                        }
+
                         const messageWithParts: MessageWithParts[] = messages.map(
                             (m: any) => wrapAsMessageWithParts(m),
                         )
 
+                        if (config.debug) {
+                            const partsCounts = messageWithParts.map((m) => m.parts.length)
+                            console.log(`[slim] compress: parts per message: [${partsCounts.join(", ")}]`)
+                        }
+
                         let targetIndices: number[] = []
                         let inputTokens = 0
 
@@ -385,12 +501,12 @@ export default Plugin.define({
             event.system.push({ type: "text", text: getSystemPrompt() })
         })
 
-        // ─── Messages Transform Hook (sync) ──────────────────────────────
+        // ─── 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", (event) => {
+        await ctx.session.hook("context", async (event) => {
             const sessionId = event.sessionID
             const config = getConfig(sessionId)
             if (!config.enabled) return
@@ -398,6 +514,10 @@ export default Plugin.define({
             const state = getState(sessionId, config)
             state.modelContextLimit = sessionModelLimits.get(sessionId) || initialModelLimit
 
+            if (config.debug) {
+                console.log(`[slim] context hook: session=${sessionId}, messages=${event.messages.length}, modelLimit=${state.modelContextLimit}`)
+            }
+
             // 1) Compression blocks: activate/deactivate and replace ranges.
             const presentIds = new Set<string>()
             for (const msg of event.messages) {
@@ -405,9 +525,14 @@ export default Plugin.define({
                 if (typeof id === "string") presentIds.add(id)
             }
             syncCompressionBlocks(state, presentIds)
+            const beforeCount = event.messages.length
             const filtered = applyCompressedRanges(state, event.messages)
             event.messages.splice(0, event.messages.length, ...filtered)
 
+            if (config.debug && beforeCount !== filtered.length) {
+                console.log(`[slim] compressed ranges: ${beforeCount} -> ${filtered.length} messages`)
+            }
+
             // 2) Pruning strategies (each request).
             pruneInPlace(event.messages, config)
             if (config.strategies.purgeErrors.enabled) {
@@ -418,7 +543,7 @@ export default Plugin.define({
             //    to a quick estimate (~4 chars per token).
             let estimatedTokens = 0
             for (const msg of event.messages) {
-                const content = (msg as any)?.content ?? (msg as any)?.parts
+                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) {
@@ -433,21 +558,49 @@ export default Plugin.define({
 
             // 4) DCP limit rules → anchored nudges (max 100k / min 50k by
             //    default, model overrides supported via modelMax/MinLimits).
+            //    Extract provider/model from the last user message for per-model limits.
             const lastUser = findLastUserMessage(event.messages)
             const providerId =
-                lastUser?.model?.providerID ?? lastUser?.model?.id?.split?.("/")[0]
+                lastUser?.model?.providerID ??
+                state._lastProviderId ??
+                (typeof lastUser?.model?.id === "string" ? lastUser.model.id.split("/")[0] : undefined)
             const modelId =
                 lastUser?.model?.modelID ??
-                lastUser?.model?.id?.split?.("/").slice(1).join("/")
+                state._lastModelId ??
+                (typeof lastUser?.model?.id === "string" ? lastUser.model.id.split("/").slice(1).join("/") : undefined)
             const limits = resolveCompressLimits(config, state, providerId, modelId)
-            injectLimitNudges(state, config, event.messages, totalTokens, limits)
+            injectLimitNudges(state, config, event.messages, totalTokens, limits, providerId, modelId)
+
+            // 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) {
+                if (config.debug) {
+                    console.log(`[slim] auto-compress triggered: ${totalTokens} > ${limits.max} (max)`)
+                }
+                try {
+                    const result = await autoCompress(state, config, event.messages, totalTokens, limits)
+                    if (config.debug && result.compressed) {
+                        console.log(`[slim] auto-compress: compressed ${result.messageCount} messages, saved ~${result.tokensSaved} tokens`)
+                    }
+                } catch (err) {
+                    if (config.debug) {
+                        console.log(`[slim] auto-compress failed:`, err)
+                    }
+                    // Best-effort: auto-compress failure should never break the request.
+                }
+            }
+
+            if (config.debug) {
+                console.log(`[slim] final messages: ${event.messages.length}, tokens: ${totalTokens}, limits: max=${limits.max} min=${limits.min}`)
+            }
 
             saveSessionState(state, config.persistence.directory)
         })
 
         // ─── Compaction Hook ────────────────────────────────────────────
         // Real, persistent context compression: when OpenCode compacts a session,
-        // summarize the transcript so history actually shrinks (unlike the
+        // provide a structured summary so history actually shrinks (unlike the
         // `context` hook, which only affects the outgoing model request).
         await ctx.session.hook("compaction", async (event) => {
             const sessionId = (event as any).sessionID
@@ -460,18 +613,100 @@ export default Plugin.define({
             const state = getState(sessionId, config)
             state.modelContextLimit = sessionModelLimits.get(sessionId) || initialModelLimit
 
-            const summary = stringifyTranscript(messages)
-            const inputTokens = await countTokens(summary)
+            // Build a structured summary instead of just stringifying.
+            const lines: string[] = []
+            lines.push("## Session Summary (Compacted)")
+            lines.push("")
+
+            const summaryParts: string[] = []
+            const toolCallsSummary: string[] = []
+            const keyDecisions: string[] = []
+            let userMessageCount = 0
+            let assistantMessageCount = 0
+
+            for (const msg of messages) {
+                const type = msg?.type ?? msg?.role ?? ""
+                if (type === "user" || type === "shell" || type === "synthetic") {
+                    userMessageCount++
+                    const text = msg.text ?? ""
+                    if (text.trim().length > 0) {
+                        summaryParts.push(`[User]: ${text.slice(0, 300)}`)
+                    }
+                } else if (type === "assistant") {
+                    assistantMessageCount++
+                    const content = msg.content ?? msg.parts ?? []
+                    if (Array.isArray(content)) {
+                        for (const part of content) {
+                            if (part?.type === "text" && part.text) {
+                                const t = part.text
+                                if (t.length > 0) {
+                                    summaryParts.push(`[Assistant]: ${t.slice(0, 300)}`)
+                                }
+                                // Capture decisions
+                                if (t.includes("decided") || t.includes("implemented") || t.includes("created")) {
+                                    keyDecisions.push(t.slice(0, 200))
+                                }
+                            } else if (part?.type === "tool" || part?.type === "tool-call") {
+                                const name = part.name ?? part.tool ?? "unknown"
+                                toolCallsSummary.push(name)
+                            }
+                        }
+                    }
+                } else if (type === "compaction") {
+                    // Previous compaction summary — include verbatim
+                    if (msg.summary) {
+                        summaryParts.push(`[Previous summary]: ${msg.summary.slice(0, 500)}`)
+                    }
+                }
+            }
+
+            // Compose summary
+            lines.push(`Messages: ${userMessageCount} user, ${assistantMessageCount} assistant`)
+            if (toolCallsSummary.length > 0) {
+                const uniqueTools = [...new Set(toolCallsSummary)]
+                lines.push(`Tools used: ${uniqueTools.join(", ")}`)
+            }
+            lines.push("")
+
+            // Key exchanges (first few and last few, skip middle)
+            const keepFirst = Math.min(3, summaryParts.length)
+            const keepLast = Math.min(3, summaryParts.length)
+            if (keepFirst + keepLast < summaryParts.length) {
+                lines.push("### Key exchanges")
+                for (const s of summaryParts.slice(0, keepFirst)) {
+                    lines.push(s)
+                }
+                lines.push("...")
+                for (const s of summaryParts.slice(-keepLast)) {
+                    lines.push(s)
+                }
+            } else {
+                lines.push("### Conversation")
+                for (const s of summaryParts) {
+                    lines.push(s)
+                }
+            }
+
+            if (keyDecisions.length > 0) {
+                lines.push("")
+                lines.push("### Key decisions")
+                for (const d of keyDecisions.slice(0, 5)) {
+                    lines.push(`- ${d}`)
+                }
+            }
+
+            const summary = lines.join("\n")
+            const inputTokens = await countTokens(messages.map((m: any) => m.text ?? "").join("\n"))
             const outputTokens = await countTokens(summary)
 
-            if (outputTokens > 0 && inputTokens > outputTokens) {
+            if (outputTokens > 0 && inputTokens > 0) {
                 addCompressionRecord(
                     state,
                     {
                         timestamp: Date.now(),
                         inputTokens,
                         outputTokens,
-                        ratio: 1 - outputTokens / inputTokens,
+                        ratio: inputTokens > outputTokens ? 1 - outputTokens / inputTokens : 0,
                         messageCount: messages.length,
                         success: true,
                     },

package/src/lib/compress.ts

@@ -2,34 +2,71 @@ import type { MessageWithParts } from "./types"
 
 // ─── Token Counting ─────────────────────────────────────────────────────────
 
-let tokenizer: any = null
+let anthropicTokenizer: any = null
+let tiktokenTokenizer: any = null
 
-async function getTokenizer() {
-    if (!tokenizer) {
+async function getAnthropicTokenizer() {
+    if (!anthropicTokenizer) {
         try {
             const mod = await import("@anthropic-ai/tokenizer")
-            tokenizer = mod
+            anthropicTokenizer = mod
         } catch {
             return null
         }
     }
-    return tokenizer
+    return anthropicTokenizer
 }
 
+async function getTiktoken() {
+    if (!tiktokenTokenizer) {
+        try {
+            const mod = await import("tiktoken")
+            tiktokenTokenizer = mod
+        } catch {
+            return null
+        }
+    }
+    return tiktokenTokenizer
+}
+
+/**
+ * Count tokens for the given text. Tries providers in order:
+ * 1. Anthropic tokenizer (if available) — most accurate for Claude models
+ * 2. tiktoken (if available) — accurate for OpenAI models
+ * 3. Rough estimation: ~4 chars per token (best guess for mixed content)
+ */
 export async function countTokens(text: string): Promise<number> {
     if (!text) return 0
 
-    const tok = await getTokenizer()
-    if (tok && tok.encode) {
+    // Try Anthropic tokenizer first
+    const anth = await getAnthropicTokenizer()
+    if (anth && anth.encode) {
         try {
-            return tok.encode(text).length
+            return anth.encode(text).length
         } catch {
-            // Fallback to estimation
+            // Fall through
         }
     }
 
-    // Rough estimation: ~4 chars per token for English
-    return Math.ceil(text.length / 4)
+    // Try tiktoken
+    const tk = await getTiktoken()
+    if (tk && tk.encoding_for_model) {
+        try {
+            const enc = tk.encoding_for_model("gpt-4")
+            const tokens = enc.encode(text)
+            enc.free()
+            return tokens.length
+        } catch {
+            // Fall through
+        }
+    }
+
+    // Rough estimation: ~4 chars per token for English, ~2-3 for CJK
+    // Count non-ASCII characters for a slightly better estimate
+    const nonAsciiCount = (text.match(/[^\x00-\x7F]/g) || []).length
+    const asciiLen = text.length - nonAsciiCount
+    const estimatedTokens = Math.ceil(asciiLen / 4) + Math.ceil(nonAsciiCount / 2)
+    return Math.max(1, estimatedTokens)
 }
 
 // ─── Message Text Extraction ────────────────────────────────────────────────
@@ -63,6 +100,13 @@ export function getToolResultContent(msg: MessageWithParts): string {
                 results.push(String(val).slice(0, 500))
             }
         }
+        // SessionMessageInfo format: tool with state.status === "completed"
+        if (part.type === "tool" && part.state?.status === "completed") {
+            const output = part.state.content ?? part.state.output
+            if (output !== undefined && output !== null) {
+                results.push(String(output).slice(0, 500))
+            }
+        }
     }
 
     return results.join("\n")
@@ -72,7 +116,7 @@ export function getToolName(msg: MessageWithParts): string | null {
     for (const part of msg.parts) {
         // v1 SDK format
         if (part.type === "tool") {
-            return part.tool || null
+            return part.tool || part.name || null
         }
         // v2 AI format
         if (part.type === "tool-call") {

package/src/lib/config.ts

@@ -19,6 +19,7 @@ const DEFAULT_CONFIG: SlimConfig = {
         nudgeForce: "soft",
         protectUserMessages: false,
         protectedTools: ["task", "skill", "todowrite", "todoread"],
+        keepRecent: 5,
     },
     strategies: {
         deduplication: {

package/src/lib/state.ts

@@ -35,6 +35,9 @@ export function normalizeState(state: SessionState): SessionState {
             ? state.nudges.iterationNudgeAnchors
             : [],
     }
+    // Optional fields — preserve if present, leave undefined if not
+    state._lastProviderId = state._lastProviderId ?? undefined
+    state._lastModelId = state._lastModelId ?? undefined
     return state
 }
 

package/src/lib/strategies.ts

@@ -1,6 +1,7 @@
 import type { MessageWithParts, SlimConfig, SessionState, CompressionBlock } from "./types"
-import { getToolName, getMessageText } from "./compress"
+import { getToolName, getMessageText, getToolResultContent, countTokens } from "./compress"
 import { contextLimitNudge, turnNudge, iterationNudge, NUDGE_MARKERS } from "./prompts"
+import { addCompressionRecord } from "./state"
 
 // ─── DCP-style Compression Blocks ───────────────────────────────────────────
 //
@@ -68,6 +69,8 @@ export function syncCompressionBlocks(state: SessionState, presentIds: Set<strin
  * 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.
+ *
+ * Handles both Message[] (hook format) and SessionMessageInfo[] (transcript format).
  */
 export function applyCompressedRanges(state: SessionState, messages: any[]): any[] {
     const blocks = (state.compressionBlocks ?? []).filter((b) => b.active)
@@ -82,15 +85,30 @@ export function applyCompressedRanges(state: SessionState, messages: any[]): any
 
     const result: any[] = []
     for (const msg of messages) {
+        // Extract ID from various formats
         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 }],
-                })
+                // Detect format: if messages have 'role', it's Message format.
+                // If they have 'type', it's SessionMessageInfo format.
+                const isHookFormat = messages.length > 0 && "role" in (messages[0] ?? {})
+                if (isHookFormat) {
+                    // Hook format: inject as a synthetic user message
+                    result.push({
+                        role: "user",
+                        id: `slim-summary-${block.blockId}`,
+                        content: [{ type: "text", text: block.summary }],
+                    })
+                } else {
+                    // Transcript / SessionMessageInfo format
+                    result.push({
+                        type: "user",
+                        id: `slim-summary-${block.blockId}`,
+                        text: block.summary,
+                        time: { created: Date.now() },
+                    })
+                }
             }
             if (covered.has(id)) {
                 continue
@@ -341,18 +359,32 @@ export function applyDeduplication(
  * 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.
+ * Handles both hook format (content with tool-call/tool-result parts) and
+ * SessionMessageInfo format (content with tool parts).
  */
 export function purgeStaleToolErrors(messages: any[], turns: number): void {
     const n = messages.length
     if (n === 0) return
 
+    // Collect errored call IDs from all message formats
     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))
+        const contentArr = msg?.content ?? msg?.parts ?? []
+        if (!Array.isArray(contentArr)) continue
+
+        for (const part of contentArr) {
+            // Format 1: tool-result with result.type === "error"
+            if (part?.type === "tool-result") {
+                if (part.result?.type === "error") {
+                    const callId = part.toolCallID ?? part.callID
+                    if (callId) erroredCallIds.add(String(callId))
+                }
+            }
+            // Format 2: tool with state.status === "error"
+            if (part?.type === "tool" && part?.state?.status === "error") {
+                const callId = part.callID
+                if (callId) erroredCallIds.add(String(callId))
+            }
         }
     }
     if (erroredCallIds.size === 0) return
@@ -361,15 +393,33 @@ export function purgeStaleToolErrors(messages: any[], turns: number): void {
     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]"
+        const contentArr = msg?.content ?? msg?.parts ?? []
+        if (!Array.isArray(contentArr)) continue
+
+        for (const part of contentArr) {
+            // Format 1: tool-call part
+            if (part?.type === "tool-call") {
+                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]"
+                        }
+                    }
+                }
+            }
+            // Format 2: tool part with state containing input
+            if (part?.type === "tool") {
+                const callId = part.callID
+                if (!callId || !erroredCallIds.has(String(callId))) continue
+                const state = part.state
+                if (state?.input && typeof state.input === "object") {
+                    for (const key of Object.keys(state.input)) {
+                        if (typeof state.input[key] === "string" && state.input[key].length > 80) {
+                            state.input[key] = "[input removed due to failed tool call]"
+                        }
                     }
                 }
             }
@@ -416,11 +466,30 @@ export function pruneInPlace(messages: any[], config: SlimConfig): void {
 
 // ─── DCP limit rules → anchored nudges ─────────────────────────────────────
 
+/**
+ * Detects whether a message contains a compress tool call.
+ * Handles both the hook format (content array with tool-call parts) and the
+ * SessionMessageInfo format (assistant content with tool parts).
+ */
 export function messageHasCompress(msg: any): boolean {
-    const content = msg?.content ?? msg?.parts ?? []
-    return content.some(
+    // Format 1: Hook format — content array with tool-call parts
+    const content1 = msg?.content ?? msg?.parts ?? []
+    const hasInContent = content1.some(
         (part: any) => part?.type === "tool-call" && part?.name === "compress",
     )
+    if (hasInContent) return true
+
+    // Format 2: SessionMessageInfo / transcript format — content array with tool parts
+    const content2 = msg?.content ?? []
+    if (Array.isArray(content2)) {
+        for (const part of content2) {
+            if (part?.type === "tool" && part?.name === "compress") return true
+            // Some formats store tool name inside state or as text
+            if (part?.type === "tool" && typeof part?.text === "string" && part.text.includes('"compress"')) return true
+        }
+    }
+
+    return false
 }
 
 export function findLastUserMessage(messages: any[]): any | undefined {
@@ -503,11 +572,17 @@ export function injectLimitNudges(
     messages: any[],
     currentTokens: number,
     limits: { max: number; min: number },
+    providerId?: string,
+    modelId?: string,
 ): void {
     if (config.compress.permission === "deny") return
     if (state.manualMode) return
     if (messages.length === 0) return
 
+    // Store provider/model info on state for external access
+    if (providerId) state._lastProviderId = providerId
+    if (modelId) state._lastModelId = modelId
+
     const nudges = state.nudges ?? {
         contextLimitAnchors: [],
         turnNudgeAnchors: [],
@@ -608,4 +683,128 @@ export function injectLimitNudges(
     )
 
     state.nudges = nudges
+}
+
+// ─── Auto-compress: directly compress when over limit ───────────────────────
+
+/**
+ * Automatically compresses old messages when context exceeds the max limit.
+ * Called from the context hook when overMax is true — no model cooperation needed.
+ * Registers a compression block so future requests use the summary instead.
+ */
+export async function autoCompress(
+    state: SessionState,
+    config: SlimConfig,
+    messages: any[],
+    currentTokens: number,
+    limits: { max: number; min: number },
+): Promise<{ compressed: boolean; messageCount?: number; tokensSaved?: number }> {
+    if (config.compress.permission === "deny") return { compressed: false }
+    if (state.manualMode) return { compressed: false }
+    if (limits.max <= 0) return { compressed: false }
+    if (currentTokens <= limits.max) return { compressed: false }
+
+    // Throttle: don't auto-compress more than once every 5 minutes
+    const now = Date.now()
+    const lastAuto = (state as any).lastAutoCompressTime ?? 0
+    if (now - lastAuto < 5 * 60 * 1000) return { compressed: false }
+
+    // Don't auto-compress if the model just compressed in the last assistant turn
+    const lastAssistant = [...messages].reverse().find((m: any) => m?.role === "assistant")
+    if (lastAssistant && messageHasCompress(lastAssistant)) return { compressed: false }
+
+    const keepRecent = Math.max(2, config.compress.keepRecent ?? 5)
+    const messageWithParts: MessageWithParts[] = messages.map((m: any) => ({
+        info: {
+            id: m?.id ?? m?.info?.id ?? "",
+            role: m?.role ?? m?.info?.role ?? "user",
+            sessionID: m?.sessionID ?? m?.info?.sessionID ?? "",
+            time: { created: Date.now() },
+        } as any,
+        parts: m?.parts ?? m?.content ?? [],
+    }))
+
+    // Select messages to compress: all except recent ones, with >100 tokens
+    const targetIndices: number[] = []
+    let inputTokens = 0
+    for (let i = 0; i < messageWithParts.length - keepRecent; i++) {
+        const msg = messageWithParts[i]
+        const text = getMessageText(msg) + getToolResultContent(msg)
+        const tokens = await countTokens(text)
+        if (tokens < 100) continue
+        targetIndices.push(i)
+        inputTokens += tokens
+    }
+
+    if (targetIndices.length === 0) {
+        ;(state as any).lastAutoCompressTime = now
+        return { compressed: false }
+    }
+
+    // Build summary
+    const targetMessages = targetIndices.map((i) => messageWithParts[i])
+    const summary = await buildCompressionSummary(
+        targetMessages,
+        "auto-compress: context limit exceeded",
+        config.compress.protectedTools,
+        config.compress.protectUserMessages,
+    )
+    const outputTokens = await countTokens(summary)
+
+    // Register compression block
+    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 (anchorIndex < 0 || anchorIndex >= messageWithParts.length) {
+        ;(state as any).lastAutoCompressTime = now
+        return { compressed: false }
+    }
+
+    const anchorId = messageWithParts[anchorIndex].info?.id
+    if (!anchorId) {
+        ;(state as any).lastAutoCompressTime = now
+        return { compressed: false }
+    }
+
+    const coveredIds = [...coveredIndices]
+        .map((i) => messageWithParts[i].info?.id)
+        .filter((id): id is string => typeof id === "string" && id.length > 0)
+    if (coveredIds.length === 0) {
+        ;(state as any).lastAutoCompressTime = now
+        return { compressed: false }
+    }
+
+    registerCompressionBlock(state, {
+        coveredIds,
+        anchorMessageId: anchorId,
+        summary,
+        topic: "auto-compress",
+        summaryTokens: outputTokens,
+    })
+
+    // Record compression stats
+    const ratio = inputTokens > 0 ? 1 - outputTokens / inputTokens : 0
+    addCompressionRecord(
+        state,
+        {
+            timestamp: now,
+            inputTokens,
+            outputTokens,
+            ratio,
+            messageCount: targetMessages.length,
+            success: true,
+        },
+        config.adaptive.learningRate,
+    )
+
+    ;(state as any).lastAutoCompressTime = now
+    return {
+        compressed: true,
+        messageCount: targetMessages.length,
+        tokensSaved: inputTokens - outputTokens,
+    }
 }

package/src/lib/types.ts

@@ -28,6 +28,8 @@ export interface SlimConfig {
         nudgeForce?: "strong" | "soft"
         protectUserMessages: boolean
         protectedTools: string[]
+        /** Number of recent messages to always keep during auto-compress (default: 5) */
+        keepRecent?: number
     }
 
     // Strategy settings
@@ -86,6 +88,10 @@ export interface SessionState {
     nextBlockId?: number
     // DCP-style nudge anchors
     nudges?: NudgeState
+
+    // Last resolved provider/model (set by injectLimitNudges)
+    _lastProviderId?: string
+    _lastModelId?: string
 }
 
 /**