feat(compress): add max/min nudge limits

Author: Tarquinen

README.md

@@ -124,16 +124,27 @@ DCP uses its own config file:
         "permission": "allow",
         // Show compression content in a chat notification
         "showCompression": false,
-        // Token limit at which the model compresses session context
-        // to keep the model in the "smart zone" (not a hard limit)
-        // Accepts: number or "X%" (percentage of model's context window)
-        "contextLimit": 100000,
-        // Optional per-model overrides by exact providerID/modelID
-        // Accepts: number or "X%"
+        // Soft upper threshold: above this, DCP keeps injecting strong
+        // compression nudges (based on nudgeFrequency), so compression is
+        // much more likely. Accepts: number or "X%" of model context window.
+        "maxContextLimit": 100000,
+        // Soft lower threshold for reminder nudges: below this, turn/iteration
+        // reminders are off (compression less likely). At/above this, reminders
+        // are on. Accepts: number or "X%" of model context window.
+        "minContextLimit": 30000,
+        // Optional per-model override for maxContextLimit by providerID/modelID.
+        // If present, this wins over the global maxContextLimit.
+        // Accepts: number or "X%".
         // Example:
-        // "modelLimits": {
-        //     "openai/gpt-5": 120000,
-        //     "anthropic/claude-3-7-sonnet": "80%"
+        // "modelMaxLimits": {
+        //     "openai/gpt-5.3-codex": 120000,
+        //     "anthropic/claude-sonnet-4.6": "80%"
+        // },
+        // Optional per-model override for minContextLimit.
+        // If present, this wins over the global minContextLimit.
+        // "modelMinLimits": {
+        //     "openai/gpt-5.3-codex": 30000,
+        //     "anthropic/claude-sonnet-4.6": "25%"
         // },
         // How often the context-limit nudge fires (1 = every fetch, 5 = every 5th)
         "nudgeFrequency": 5,

dcp.schema.json

@@ -133,8 +133,8 @@
                     "default": false,
                     "description": "Show compression summaries in notifications"
                 },
-                "contextLimit": {
-                    "description": "When session tokens exceed this limit, a compress nudge is injected (\"X%\" uses percentage of the model's context window)",
+                "maxContextLimit": {
+                    "description": "Soft upper threshold. Above this, DCP keeps sending strong compression nudges (based on nudgeFrequency), so the model is pushed to compress. Accepts number or \"X%\" of the model context window.",
                     "default": 100000,
                     "oneOf": [
                         {
@@ -146,8 +146,36 @@
                         }
                     ]
                 },
-                "modelLimits": {
-                    "description": "Model-specific context limits by exact provider/model key. Examples: \"openai/gpt-5\", \"anthropic/claude-3-7-sonnet\", \"ollama/llama3.1\"",
+                "minContextLimit": {
+                    "description": "Soft lower threshold for reminder nudges. Below this, turn/iteration reminders are off (compression is less likely). At or above this, reminders are on. Accepts number or \"X%\" of the model context window.",
+                    "default": 30000,
+                    "oneOf": [
+                        {
+                            "type": "number"
+                        },
+                        {
+                            "type": "string",
+                            "pattern": "^\\d+(?:\\.\\d+)?%$"
+                        }
+                    ]
+                },
+                "modelMaxLimits": {
+                    "description": "Per-model override for maxContextLimit by exact provider/model key. If set, this takes priority over the global maxContextLimit.",
+                    "type": "object",
+                    "additionalProperties": {
+                        "oneOf": [
+                            {
+                                "type": "number"
+                            },
+                            {
+                                "type": "string",
+                                "pattern": "^\\d+(?:\\.\\d+)?%$"
+                            }
+                        ]
+                    }
+                },
+                "modelMinLimits": {
+                    "description": "Per-model override for minContextLimit by exact provider/model key. If set, this takes priority over the global minContextLimit.",
                     "type": "object",
                     "additionalProperties": {
                         "oneOf": [
@@ -165,7 +193,7 @@
                     "type": "number",
                     "default": 5,
                     "minimum": 1,
-                    "description": "How often the context-limit nudge fires when above contextLimit (1 = every fetch, 5 = every 5th fetch)"
+                    "description": "How often the context-limit nudge fires when above maxContextLimit (1 = every fetch, 5 = every 5th fetch)"
                 },
                 "iterationNudgeThreshold": {
                     "type": "number",

lib/config.ts

@@ -14,8 +14,10 @@ export interface Deduplication {
 export interface CompressTool {
     permission: Permission
     showCompression: boolean
-    contextLimit: number | `${number}%`
-    modelLimits?: Record<string, number | `${number}%`>
+    maxContextLimit: number | `${number}%`
+    minContextLimit: number | `${number}%`
+    modelMaxLimits?: Record<string, number | `${number}%`>
+    modelMinLimits?: Record<string, number | `${number}%`>
     nudgeFrequency: number
     iterationNudgeThreshold: number
     nudgeForce: "strong" | "soft"
@@ -105,8 +107,10 @@ export const VALID_CONFIG_KEYS = new Set([
     "compress",
     "compress.permission",
     "compress.showCompression",
-    "compress.contextLimit",
-    "compress.modelLimits",
+    "compress.maxContextLimit",
+    "compress.minContextLimit",
+    "compress.modelMaxLimits",
+    "compress.modelMinLimits",
     "compress.nudgeFrequency",
     "compress.iterationNudgeThreshold",
     "compress.nudgeForce",
@@ -129,8 +133,8 @@ function getConfigKeyPaths(obj: Record<string, any>, prefix = ""): string[] {
         const fullKey = prefix ? `${prefix}.${key}` : key
         keys.push(fullKey)
 
-        // modelLimits is a dynamic map keyed by providerID/modelID; do not recurse into arbitrary IDs.
-        if (fullKey === "compress.modelLimits") {
+        // model*Limits are dynamic maps keyed by providerID/modelID; do not recurse into arbitrary IDs.
+        if (fullKey === "compress.modelMaxLimits" || fullKey === "compress.modelMinLimits") {
             continue
         }
 
@@ -384,47 +388,65 @@ export function validateConfigTypes(config: Record<string, any>): ValidationErro
                 })
             }
 
-            if (compress.contextLimit !== undefined) {
-                const isValidNumber = typeof compress.contextLimit === "number"
-                const isPercentString =
-                    typeof compress.contextLimit === "string" && compress.contextLimit.endsWith("%")
+            const validateLimitValue = (
+                key: string,
+                value: unknown,
+                actualValue: unknown = value,
+            ): void => {
+                const isValidNumber = typeof value === "number"
+                const isPercentString = typeof value === "string" && value.endsWith("%")
 
                 if (!isValidNumber && !isPercentString) {
                     errors.push({
-                        key: "compress.contextLimit",
+                        key,
                         expected: 'number | "${number}%"',
-                        actual: JSON.stringify(compress.contextLimit),
+                        actual: JSON.stringify(actualValue),
                     })
                 }
             }
 
-            if (compress.modelLimits !== undefined) {
-                if (
-                    typeof compress.modelLimits !== "object" ||
-                    compress.modelLimits === null ||
-                    Array.isArray(compress.modelLimits)
-                ) {
+            const validateModelLimits = (
+                key: "compress.modelMaxLimits" | "compress.modelMinLimits",
+                limits: unknown,
+            ): void => {
+                if (limits === undefined) {
+                    return
+                }
+
+                if (typeof limits !== "object" || limits === null || Array.isArray(limits)) {
                     errors.push({
-                        key: "compress.modelLimits",
+                        key,
                         expected: "Record<string, number | ${number}%>",
-                        actual: typeof compress.modelLimits,
+                        actual: typeof limits,
                     })
-                } else {
-                    for (const [providerModelKey, limit] of Object.entries(compress.modelLimits)) {
-                        const isValidNumber = typeof limit === "number"
-                        const isPercentString =
-                            typeof limit === "string" && /^\d+(?:\.\d+)?%$/.test(limit)
-                        if (!isValidNumber && !isPercentString) {
-                            errors.push({
-                                key: `compress.modelLimits.${providerModelKey}`,
-                                expected: 'number | "${number}%"',
-                                actual: JSON.stringify(limit),
-                            })
-                        }
+                    return
+                }
+
+                for (const [providerModelKey, limit] of Object.entries(limits)) {
+                    const isValidNumber = typeof limit === "number"
+                    const isPercentString =
+                        typeof limit === "string" && /^\d+(?:\.\d+)?%$/.test(limit)
+                    if (!isValidNumber && !isPercentString) {
+                        errors.push({
+                            key: `${key}.${providerModelKey}`,
+                            expected: 'number | "${number}%"',
+                            actual: JSON.stringify(limit),
+                        })
                     }
                 }
             }
 
+            if (compress.maxContextLimit !== undefined) {
+                validateLimitValue("compress.maxContextLimit", compress.maxContextLimit)
+            }
+
+            if (compress.minContextLimit !== undefined) {
+                validateLimitValue("compress.minContextLimit", compress.minContextLimit)
+            }
+
+            validateModelLimits("compress.modelMaxLimits", compress.modelMaxLimits)
+            validateModelLimits("compress.modelMinLimits", compress.modelMinLimits)
+
             const validValues = ["ask", "allow", "deny"]
             if (compress.permission !== undefined && !validValues.includes(compress.permission)) {
                 errors.push({
@@ -602,7 +624,8 @@ const defaultConfig: PluginConfig = {
     compress: {
         permission: "allow",
         showCompression: false,
-        contextLimit: 100000,
+        maxContextLimit: 100000,
+        minContextLimit: 30000,
         nudgeFrequency: 5,
         iterationNudgeThreshold: 15,
         nudgeForce: "soft",
@@ -767,8 +790,10 @@ function mergeCompress(
     return {
         permission: override.permission ?? base.permission,
         showCompression: override.showCompression ?? base.showCompression,
-        contextLimit: override.contextLimit ?? base.contextLimit,
-        modelLimits: override.modelLimits ?? base.modelLimits,
+        maxContextLimit: override.maxContextLimit ?? base.maxContextLimit,
+        minContextLimit: override.minContextLimit ?? base.minContextLimit,
+        modelMaxLimits: override.modelMaxLimits ?? base.modelMaxLimits,
+        modelMinLimits: override.modelMinLimits ?? base.modelMinLimits,
         nudgeFrequency: override.nudgeFrequency ?? base.nudgeFrequency,
         iterationNudgeThreshold: override.iterationNudgeThreshold ?? base.iterationNudgeThreshold,
         nudgeForce: override.nudgeForce ?? base.nudgeForce,
@@ -829,7 +854,8 @@ function deepCloneConfig(config: PluginConfig): PluginConfig {
         protectedFilePatterns: [...config.protectedFilePatterns],
         compress: {
             ...config.compress,
-            modelLimits: { ...config.compress.modelLimits },
+            modelMaxLimits: { ...config.compress.modelMaxLimits },
+            modelMinLimits: { ...config.compress.modelMinLimits },
             protectedTools: [...config.compress.protectedTools],
         },
         strategies: {

lib/messages/inject/inject.ts

@@ -20,7 +20,7 @@ import {
     getIterationNudgeThreshold,
     getNudgeFrequency,
     getModelInfo,
-    isContextOverLimit,
+    isContextOverLimits,
     messageHasCompress,
 } from "./utils"
 
@@ -52,9 +52,26 @@ export const insertCompressNudges = (
     const { providerId, modelId } = getModelInfo(messages)
     let anchorsChanged = false
 
-    const contextOverLimit = isContextOverLimit(config, state, providerId, modelId, messages)
+    const { overMaxLimit, overMinLimit } = isContextOverLimits(
+        config,
+        state,
+        providerId,
+        modelId,
+        messages,
+    )
+
+    if (!overMinLimit) {
+        const hadTurnAnchors = state.nudges.turnNudgeAnchors.size > 0
+        const hadIterationAnchors = state.nudges.iterationNudgeAnchors.size > 0
+
+        if (hadTurnAnchors || hadIterationAnchors) {
+            state.nudges.turnNudgeAnchors.clear()
+            state.nudges.iterationNudgeAnchors.clear()
+            anchorsChanged = true
+        }
+    }
 
-    if (contextOverLimit) {
+    if (overMaxLimit) {
         if (lastMessage) {
             const interval = getNudgeFrequency(config)
             const added = addAnchor(
@@ -68,7 +85,7 @@ export const insertCompressNudges = (
                 anchorsChanged = true
             }
         }
-    } else {
+    } else if (overMinLimit) {
         const isLastMessageUser = lastMessage?.message.info.role === "user"
 
         if (isLastMessageUser && lastAssistantMessage) {

lib/messages/inject/utils.ts

@@ -81,11 +81,12 @@ export function getModelInfo(messages: WithParts[]): LastUserModelContext {
     }
 }
 
-function resolveContextLimit(
+function resolveContextTokenLimit(
     config: PluginConfig,
     state: SessionState,
     providerId: string | undefined,
     modelId: string | undefined,
+    threshold: "max" | "min",
 ): number | undefined {
     const parseLimitValue = (limit: number | `${number}%` | undefined): number | undefined => {
         if (limit === undefined) {
@@ -110,7 +111,8 @@ function resolveContextLimit(
         return Math.round((clampedPercent / 100) * state.modelContextLimit)
     }
 
-    const modelLimits = config.compress.modelLimits
+    const modelLimits =
+        threshold === "max" ? config.compress.modelMaxLimits : config.compress.modelMinLimits
     if (modelLimits && providerId !== undefined && modelId !== undefined) {
         const providerModelId = `${providerId}/${modelId}`
         const modelLimit = modelLimits[providerModelId]
@@ -119,23 +121,29 @@ function resolveContextLimit(
         }
     }
 
-    return parseLimitValue(config.compress.contextLimit)
+    const globalLimit =
+        threshold === "max" ? config.compress.maxContextLimit : config.compress.minContextLimit
+    return parseLimitValue(globalLimit)
 }
 
-export function isContextOverLimit(
+export function isContextOverLimits(
     config: PluginConfig,
     state: SessionState,
     providerId: string | undefined,
     modelId: string | undefined,
     messages: WithParts[],
-): boolean {
-    const contextLimit = resolveContextLimit(config, state, providerId, modelId)
-    if (contextLimit === undefined) {
-        return false
-    }
-
+) {
+    const maxContextLimit = resolveContextTokenLimit(config, state, providerId, modelId, "max")
+    const minContextLimit = resolveContextTokenLimit(config, state, providerId, modelId, "min")
     const currentTokens = getCurrentTokenUsage(messages)
-    return currentTokens > contextLimit
+
+    const overMaxLimit = maxContextLimit === undefined ? false : currentTokens > maxContextLimit
+    const overMinLimit = minContextLimit === undefined ? true : currentTokens >= minContextLimit
+
+    return {
+        overMaxLimit,
+        overMinLimit,
+    }
 }
 
 export function addAnchor(