pi-ui-extend 0.1.34 → 0.1.35

package/external/pi-tools-suite/src/async-subagents/index.ts

@@ -9,12 +9,13 @@ import {
 	getSubagentRegistryPath,
 	isBlindModelRef,
 	loadSubagentConfig,
-	listRunDirs,
+	listSubagentSessionRecords,
 	loadSubagentRegistry,
 	removeSubagentRunsFromRegistry,
 	stopAgents,
 	type AgentCompletionHandler,
 	type StopSignal,
+	type SubagentSessionRecord,
 } from "./lib.js";
 import { buildUltraworkPrompt, isUltraworkEnvEnabled, registerCommands } from "./commands.js";
 import { agentStrategyPrompt, appendAgentStrategyPrompt } from "./core/agent-strategy.js";
@@ -46,6 +47,11 @@ interface ShutdownTarget {
 	agentIds?: string[];
 }
 
+interface ShutdownPlan {
+	targets: ShutdownTarget[];
+	runDirsToDelete: string[];
+}
+
 function createLiveStatePayload(
 	liveAgents: Map<string, Map<string, LiveAgent>>,
 	sessionFile: string | undefined,
@@ -81,6 +87,14 @@ function agentMatchesSession(agent: LiveAgent, sessionFile: string | undefined):
 	return pathsEqual(sessionFile, agent.parentSession);
 }
 
+function isStaleExtensionContextError(error: unknown): boolean {
+	return error instanceof Error && /ctx is stale|stale ctx|stale after session replacement|stale after.*reload/i.test(error.message);
+}
+
+function ignoreStaleExtensionContextError(error: unknown): void {
+	if (!isStaleExtensionContextError(error)) throw error;
+}
+
 export default function (pi: ExtensionAPI) {
 	const liveAgents = new Map<string, Map<string, LiveAgent>>();
 	const subagentOverlay = new SubagentOverlay(liveAgents);
@@ -90,11 +104,15 @@ export default function (pi: ExtensionAPI) {
 	publishSubagentPresetsStartupSection();
 
 	function refreshSubagentOverlay(): void {
-		reconcileLiveAgentCompletions();
-		const liveState = createLiveStatePayload(liveAgents, currentSessionFile);
-		pi.events?.emit?.(SUBAGENTS_LIVE_COUNT_EVENT, { count: liveState.count });
-		pi.events?.emit?.(SUBAGENTS_LIVE_STATE_EVENT, liveState);
-		updateCompletionWatcher();
+		try {
+			reconcileLiveAgentCompletions();
+			const liveState = createLiveStatePayload(liveAgents, currentSessionFile);
+			pi.events?.emit?.(SUBAGENTS_LIVE_COUNT_EVENT, { count: liveState.count });
+			pi.events?.emit?.(SUBAGENTS_LIVE_STATE_EVENT, liveState);
+			updateCompletionWatcher();
+		} catch (error) {
+			ignoreStaleExtensionContextError(error);
+		}
 	}
 
 	function removeLiveAgent(runDir: string, agentId: string): void {
@@ -147,10 +165,14 @@ export default function (pi: ExtensionAPI) {
 	registerCommands(pi);
 
 	pi.on("session_start", async (_event, ctx) => {
-		sawAutoUltraworkCandidate = false;
-		currentSessionFile = sessionFileFromContext(ctx);
-		subagentOverlay.restoreRunningAgents(ctx.cwd, currentSessionFile);
-		refreshSubagentOverlay();
+		try {
+			sawAutoUltraworkCandidate = false;
+			currentSessionFile = sessionFileFromContext(ctx);
+			subagentOverlay.restoreRunningAgents(ctx.cwd, currentSessionFile);
+			refreshSubagentOverlay();
+		} catch (error) {
+			ignoreStaleExtensionContextError(error);
+		}
 	});
 
 	pi.on("tool_execution_end", async (event) => {
@@ -207,18 +229,23 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("session_shutdown", async (event, ctx) => {
-		subagentOverlay.dispose();
-		if (completionWatchTimer) {
-			clearInterval(completionWatchTimer);
-			completionWatchTimer = undefined;
-		}
-		if (event?.reason === "reload" || event?.reason === "fork") return;
 		try {
-			await cleanupProjectSubagentState(ctx.cwd, liveAgents);
-			liveAgents.clear();
-			refreshSubagentOverlay();
-		} catch {
-			// Shutdown cleanup is best-effort and must never block the main session from closing.
+			subagentOverlay.dispose();
+			if (completionWatchTimer) {
+				clearInterval(completionWatchTimer);
+				completionWatchTimer = undefined;
+			}
+			if (event?.reason === "reload" || event?.reason === "fork") return;
+			try {
+				const shutdownSessionFile = sessionFileFromContext(ctx) ?? currentSessionFile;
+				await cleanupProjectSubagentState(ctx.cwd, liveAgents, { parentSession: shutdownSessionFile });
+				liveAgents.clear();
+				refreshSubagentOverlay();
+			} catch {
+				// Shutdown cleanup is best-effort and must never block the main session from closing.
+			}
+		} catch (error) {
+			ignoreStaleExtensionContextError(error);
 		}
 	});
 }
@@ -394,31 +421,100 @@ function selectedToolsInclude(event: unknown, toolName: string): boolean {
 	return !Array.isArray(selectedTools) || selectedTools.includes(toolName);
 }
 
-async function cleanupProjectSubagentState(cwd: string, liveAgents: Map<string, Map<string, LiveAgent>>): Promise<void> {
-	const shutdownTargets = collectShutdownTargets(cwd, liveAgents);
-	const signaled = signalShutdownTargets(shutdownTargets, "SIGTERM");
+async function cleanupProjectSubagentState(
+	cwd: string,
+	liveAgents: Map<string, Map<string, LiveAgent>>,
+	options: { parentSession?: string } = {},
+): Promise<void> {
+	const shutdownPlan = collectShutdownPlan(cwd, liveAgents, options.parentSession);
+	const signaled = signalShutdownTargets(shutdownPlan.targets, "SIGTERM");
 	if (signaled > 0) await sleep(SESSION_SHUTDOWN_KILL_GRACE_MS);
-	signalShutdownTargets(shutdownTargets, "SIGKILL");
+	signalShutdownTargets(shutdownPlan.targets, "SIGKILL");
 
-	const runDirs = listRunDirs(cwd);
-	for (const runDir of runDirs) stopRunBestEffort(runDir, undefined, "SIGKILL");
-	deleteRunDirs(runDirs);
-	removeSubagentRunsFromRegistry(cwd, runDirs);
+	for (const target of shutdownPlan.targets) stopRunBestEffort(target.runDir, target.agentIds, "SIGKILL");
+	deleteRunDirs(shutdownPlan.runDirsToDelete);
+	removeSubagentRunsFromRegistry(cwd, shutdownPlan.runDirsToDelete);
 	removeEmptySubagentState(cwd);
 }
 
-function collectShutdownTargets(cwd: string, liveAgents: Map<string, Map<string, LiveAgent>>): ShutdownTarget[] {
-	const targets = new Map<string, Set<string> | undefined>();
-	for (const runDir of listRunDirs(cwd)) targets.set(runDir, undefined);
+
+function collectShutdownPlan(
+	cwd: string,
+	liveAgents: Map<string, Map<string, LiveAgent>>,
+	parentSession: string | undefined,
+): ShutdownPlan {
+	if (!parentSession) return collectLiveShutdownPlan(liveAgents);
+
+	const targets = new Map<string, Set<string>>();
+	const runDirsToDelete = new Set<string>();
+	const recordsByRun = groupRecordsByRun(listSubagentSessionRecords(cwd));
+
+	for (const [runDir, records] of recordsByRun) {
+		const matchingRecords = records.filter((record) => recordMatchesSession(record, parentSession));
+		if (matchingRecords.length === 0) continue;
+		mergeTargetIds(targets, runDir, matchingRecords.map((record) => record.agentId));
+		const liveRun = liveAgents.get(runDir);
+		if (records.every((record) => recordMatchesSession(record, parentSession)) && liveRunMatchesSession(liveRun, parentSession)) {
+			runDirsToDelete.add(runDir);
+		}
+	}
+
 	for (const [runDir, liveRun] of liveAgents) {
-		const existing = targets.get(runDir);
-		if (existing === undefined && targets.has(runDir)) continue;
-		targets.set(runDir, new Set(liveRun.keys()));
+		const matchingIds = [...liveRun.values()]
+			.filter((agent) => liveAgentMatchesSession(agent, parentSession))
+			.map((agent) => agent.agentId);
+		if (matchingIds.length === 0) continue;
+		mergeTargetIds(targets, runDir, matchingIds);
+		const records = recordsByRun.get(runDir) ?? [];
+		if (records.every((record) => recordMatchesSession(record, parentSession)) && liveRunMatchesSession(liveRun, parentSession)) {
+			runDirsToDelete.add(runDir);
+		}
 	}
-	return [...targets].map(([runDir, agentIds]) => ({
+
+	return {
+		targets: targetMapToTargets(targets),
+		runDirsToDelete: [...runDirsToDelete],
+	};
+}
+
+function collectLiveShutdownPlan(liveAgents: Map<string, Map<string, LiveAgent>>): ShutdownPlan {
+	const targets = [...liveAgents.entries()].map(([runDir, liveRun]) => ({
 		runDir,
-		...(agentIds ? { agentIds: [...agentIds] } : {}),
+		agentIds: [...liveRun.keys()],
 	}));
+	return { targets, runDirsToDelete: targets.map((target) => target.runDir) };
+}
+
+function groupRecordsByRun(records: SubagentSessionRecord[]): Map<string, SubagentSessionRecord[]> {
+	const grouped = new Map<string, SubagentSessionRecord[]>();
+	for (const record of records) {
+		const existing = grouped.get(record.runDir) ?? [];
+		existing.push(record);
+		grouped.set(record.runDir, existing);
+	}
+	return grouped;
+}
+
+function recordMatchesSession(record: SubagentSessionRecord, sessionFile: string): boolean {
+	return Boolean(record.parentSession && pathsEqual(record.parentSession, sessionFile));
+}
+
+function liveAgentMatchesSession(agent: LiveAgent, sessionFile: string): boolean {
+	return Boolean(agent.parentSession && pathsEqual(agent.parentSession, sessionFile));
+}
+
+function liveRunMatchesSession(liveRun: Map<string, LiveAgent> | undefined, sessionFile: string): boolean {
+	return !liveRun || [...liveRun.values()].every((agent) => liveAgentMatchesSession(agent, sessionFile));
+}
+
+function mergeTargetIds(targets: Map<string, Set<string>>, runDir: string, agentIds: string[]): void {
+	const target = targets.get(runDir) ?? new Set<string>();
+	for (const agentId of agentIds) target.add(agentId);
+	targets.set(runDir, target);
+}
+
+function targetMapToTargets(targets: Map<string, Set<string>>): ShutdownTarget[] {
+	return [...targets.entries()].map(([runDir, agentIds]) => ({ runDir, agentIds: [...agentIds] }));
 }
 
 function signalShutdownTargets(targets: ShutdownTarget[], signal: StopSignal): number {

package/external/pi-tools-suite/src/context-usage.ts

@@ -10,13 +10,18 @@ export interface ContextUsageProvider {
 
 export function isStaleExtensionContextError(error: unknown): boolean {
 	if (!(error instanceof Error)) return false
-	return /ctx is stale|stale after session replacement|stale after.*reload/i.test(error.message)
+	return /ctx is stale|stale ctx|stale after session replacement|stale after.*reload/i.test(error.message)
 }
 
 export function ignoreStaleExtensionContextError(error: unknown): void {
 	if (!isStaleExtensionContextError(error)) throw error
 }
 
+export function isAgentBusyRaceError(error: unknown): boolean {
+	if (!(error instanceof Error)) return false
+	return /Agent is already processing(?: a prompt)?\.|Wait for completion before continuing|Specify streamingBehavior/i.test(error.message)
+}
+
 // Fork/newSession/switchSession/reload can invalidate a runner while late UI or
 // context events from the old runner are still unwinding. In that race,
 // ctx.getContextUsage() throws the Pi stale-ctx guard; treat it as unavailable

package/external/pi-tools-suite/src/dcp/commands.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent"
 import type { AutocompleteItem } from "@earendil-works/pi-tui"
 import type { DcpState } from "./state.js"
-import type { DcpConfig } from "./config.js"
+import { modelKeysFromContext, resolveModelConfig, type DcpConfig } from "./config.js"
 import type { DcpNudgeType } from "./pruner-types.js"
 import { isToolRecordProtected, markToolPruned } from "./pruner.js"
 import { safeGetContextUsage } from "../context-usage.js"
@@ -540,6 +540,7 @@ export function registerCommands(
     async handler(args: string, ctx: ExtensionCommandContext): Promise<void> {
       const parts = args.trim().split(/\s+/).filter(Boolean)
       const sub = parts[0] ?? ""
+      const effectiveConfig = resolveModelConfig(config, modelKeysFromContext(ctx))
 
       try {
         switch (sub) {
@@ -559,7 +560,7 @@ export function registerCommands(
           case "sweep": {
             const rawN = parts[1] !== undefined ? parseInt(parts[1], 10) : 0
             const n = isNaN(rawN) || rawN < 0 ? 0 : rawN
-            await handleSweep(ctx, state, config, n)
+            await handleSweep(ctx, state, effectiveConfig, n)
             break
           }
 

package/external/pi-tools-suite/src/dcp/compress-tool.ts

@@ -5,7 +5,7 @@
 import { Type } from "typebox"
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
 import type { DcpState } from "./state.js"
-import type { DcpConfig } from "./config.js"
+import { modelKeysFromContext, resolveModelConfig, type DcpConfig } from "./config.js"
 import { clearDcpNudgeAnchors } from "./pruner.js"
 import type { DcpCompressionVisualDetails } from "./ui.js"
 import { normalizeDcpContextUsage } from "./ui.js"
@@ -149,6 +149,11 @@ export function registerCompressTool(
     }),
 
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const effectiveConfig = resolveModelConfig(config, modelKeysFromContext(ctx))
+      if (!effectiveConfig.enabled) {
+        throw new Error("DCP is disabled for the active model")
+      }
+
       const newBlockIds: number[] = []
       const ranges = Array.isArray(params.ranges) ? params.ranges : []
       const messages = Array.isArray(params.messages) ? params.messages : []
@@ -215,7 +220,7 @@ export function registerCompressTool(
           anchorMessageId: anchor.stableId,
           createdByToolCallId: _toolCallId,
           state,
-          config,
+          config: effectiveConfig,
           mode: "range",
         })
         const block = created.block
@@ -260,7 +265,7 @@ export function registerCompressTool(
           skippedMessageIssues.push({ kind: "non-finite", messageId })
           continue
         }
-        if (config.compress.protectUserMessages && meta.role === "user") {
+        if (effectiveConfig.compress.protectUserMessages && meta.role === "user") {
           skippedMessageIssues.push({ kind: "protected-user", messageId })
           continue
         }
@@ -291,7 +296,7 @@ export function registerCompressTool(
           anchorMessageId: anchor.stableId,
           createdByToolCallId: _toolCallId,
           state,
-          config,
+          config: effectiveConfig,
           mode: "message",
           validatePlaceholders: false,
           expandPlaceholders: false,

package/external/pi-tools-suite/src/dcp/config.ts

@@ -25,7 +25,7 @@ export interface DcpConfig {
     modelMinContextLimits?: Record<string, number | string> // same formats as modelMinContextPercent; checked before modelMinContextPercent
     summaryBuffer: boolean
     nudgeFrequency: number // inject nudge every N context events (default: 2)
-    iterationNudgeThreshold: number // nudge after N tool calls since last user msg (default: 8)
+    iterationNudgeThreshold: number // nudge after N tool calls since last user msg (default: 4)
     nudgeForce: "strong" | "soft"
     protectedTools: string[] // these tool outputs always protected from pruning
     protectTags: boolean
@@ -67,8 +67,17 @@ export interface DcpConfig {
   }
   protectedFilePatterns: string[]
   pruneNotification: "off" | "minimal" | "detailed"
+  modelOverrides: Record<string, DcpConfigOverride>
 }
 
+export type DcpConfigOverride = DeepPartial<Omit<DcpConfig, "modelOverrides">>
+
+type DeepPartial<T> = T extends Array<infer U>
+  ? Array<DeepPartial<U>>
+  : T extends object
+    ? { [K in keyof T]?: DeepPartial<T[K]> }
+    : T
+
 // ---------------------------------------------------------------------------
 // Defaults
 // ---------------------------------------------------------------------------
@@ -87,7 +96,7 @@ const DEFAULT_CONFIG: DcpConfig = {
     modelMinContextPercent: {},
     summaryBuffer: true,
     nudgeFrequency: 1,
-    iterationNudgeThreshold: 6,
+    iterationNudgeThreshold: 4,
     nudgeForce: "soft",
     protectedTools: ["compress", "write", "edit"],
     protectTags: false,
@@ -95,14 +104,14 @@ const DEFAULT_CONFIG: DcpConfig = {
     autoCandidates: {
       enabled: true,
       minContextPercent: 0.20,
-      keepRecentTurns: 2,
+      keepRecentTurns: 1,
       minMessages: 6,
       minTokens: 1500,
     },
     messageMode: {
       enabled: true,
       minContextPercent: 0.20,
-      keepRecentTurns: 2,
+      keepRecentTurns: 1,
       mediumTokens: 500,
       highTokens: 5000,
       maxSuggestions: 5,
@@ -120,13 +129,17 @@ const DEFAULT_CONFIG: DcpConfig = {
     },
     autoToolPruning: {
       enabled: true,
-      maxOutputTokens: 2000,
-      keepRecentTurns: 2,
+      maxOutputTokens: 1200,
+      keepRecentTurns: 1,
       readLikeTools: [
         "read",
+        "shell",
+        "bash",
         "grep",
         "find",
         "ls",
+        "web_search",
+        "web_fetch",
         "repo_architecture",
         "repo_structure",
         "repo_ast",
@@ -141,6 +154,7 @@ const DEFAULT_CONFIG: DcpConfig = {
   },
   protectedFilePatterns: [],
   pruneNotification: "detailed",
+  modelOverrides: {},
 }
 
 // ---------------------------------------------------------------------------
@@ -226,6 +240,128 @@ function mergeSuiteDcpConfig(config: DcpConfig, filePath: string): DcpConfig {
   return deepMerge(config, raw as Partial<DcpConfig>)
 }
 
+function normalizeModelKey(key: string | undefined): string | undefined {
+  if (typeof key !== "string") return undefined
+  const trimmed = key.trim()
+  return trimmed.length > 0 ? trimmed : undefined
+}
+
+function escapeRegExp(text: string): string {
+  return text.replace(/[|\\{}()[\]^$+?.]/g, "\\$&")
+}
+
+function globToRegExp(pattern: string): RegExp {
+  let source = "^"
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i]!
+    if (char === "*") {
+      source += ".*"
+    } else if (char === "?") {
+      source += "."
+    } else {
+      source += escapeRegExp(char)
+    }
+  }
+  source += "$"
+  return new RegExp(source)
+}
+
+function isWildcardPattern(pattern: string): boolean {
+  return pattern.includes("*") || pattern.includes("?")
+}
+
+function modelPatternMatches(pattern: string, candidate: string): boolean {
+  return globToRegExp(pattern).test(candidate)
+}
+
+function uniqueModelCandidates(modelKeys: Array<string | undefined>): string[] {
+  return modelKeys
+    .map((key) => normalizeModelKey(key))
+    .filter((key, index, array): key is string => typeof key === "string" && array.indexOf(key) === index)
+}
+
+export function matchingModelEntries<T>(
+  record: Record<string, T> | undefined,
+  modelKeys: Array<string | undefined> = [],
+): Array<[string, T]> {
+  if (!record || Object.keys(record).length === 0) return []
+
+  const candidates = uniqueModelCandidates(modelKeys)
+  if (candidates.length === 0) return []
+
+  const exactEntries = new Map<string, T>()
+  const wildcardEntries: Array<[string, T]> = []
+
+  for (const [rawKey, value] of Object.entries(record)) {
+    const key = normalizeModelKey(rawKey)
+    if (!key) continue
+    if (isWildcardPattern(key)) wildcardEntries.push([key, value])
+    else exactEntries.set(key, value)
+  }
+
+  const fullCandidates = candidates.filter((candidate) => candidate.includes("/"))
+  const bareCandidates = candidates.filter((candidate) => !candidate.includes("/"))
+  const matches: Array<[string, T]> = []
+
+  for (const candidate of bareCandidates) {
+    for (const entry of wildcardEntries) {
+      if (entry[0].includes("/")) continue
+      if (modelPatternMatches(entry[0], candidate)) matches.push(entry)
+    }
+  }
+
+  for (const candidate of bareCandidates) {
+    const value = exactEntries.get(candidate)
+    if (value !== undefined) matches.push([candidate, value])
+  }
+
+  for (const candidate of fullCandidates) {
+    for (const entry of wildcardEntries) {
+      if (!entry[0].includes("/")) continue
+      if (modelPatternMatches(entry[0], candidate)) matches.push(entry)
+    }
+  }
+
+  for (const candidate of fullCandidates) {
+    const value = exactEntries.get(candidate)
+    if (value !== undefined) matches.push([candidate, value])
+  }
+
+  return matches
+}
+
+export function modelKeysFromContext(ctx: unknown): string[] {
+  const ctxModel = (ctx as any)?.model
+  const provider = normalizeModelKey(
+    ctxModel?.provider ?? ctxModel?.providerId ?? ctxModel?.providerID,
+  )
+  const model = normalizeModelKey(
+    ctxModel?.id ?? ctxModel?.model ?? ctxModel?.modelId ?? ctxModel?.modelID,
+  )
+
+  return [provider && model ? `${provider}/${model}` : undefined, model].filter(
+    (key): key is string => typeof key === "string",
+  )
+}
+
+export function resolveModelConfig(
+  config: DcpConfig,
+  modelKeys: Array<string | undefined> = [],
+): DcpConfig {
+  const overrides = config.modelOverrides
+  if (!overrides || Object.keys(overrides).length === 0) return config
+
+  const matches = matchingModelEntries(overrides, modelKeys)
+  if (matches.length === 0) return config
+
+  let resolved = deepMerge(config, {})
+  for (const [, override] of matches) {
+    resolved = deepMerge(resolved, override as Partial<DcpConfig>)
+  }
+
+  return resolved
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------

package/external/pi-tools-suite/src/dcp/index.ts

@@ -3,7 +3,7 @@
 // ---------------------------------------------------------------------------
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
-import { loadConfig } from "./config.js"
+import { loadConfig, modelKeysFromContext, resolveModelConfig } from "./config.js"
 import {
 	createState,
 	resetState,
@@ -102,8 +102,12 @@ function isDcpControlPlaneMessage(message: any): boolean {
 export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 	// ── 1. Load config ────────────────────────────────────────────────────────
 	const config = loadConfig()
+	const configForContext = (ctx: unknown) => resolveModelConfig(config, modelKeysFromContext(ctx))
+	const hasEnabledModelOverride = Object.values(config.modelOverrides).some(
+		(override) => override.enabled === true,
+	)
 
-	if (!config.enabled) return
+	if (!config.enabled && !hasEnabledModelOverride) return
 
 	// ── 2. Create state ───────────────────────────────────────────────────────
 	const state = createState()
@@ -175,6 +179,9 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 
 	// ── 7. before_agent_start: inject system prompt ───────────────────────────
 	pi.on("before_agent_start", async (event, _ctx) => {
+		const effectiveConfig = configForContext(_ctx)
+		if (!effectiveConfig.enabled) return { systemPrompt: event.systemPrompt }
+
 		const promptAddition = state.manualMode
 			? MANUAL_MODE_SYSTEM_PROMPT
 			: SYSTEM_PROMPT
@@ -239,11 +246,15 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 
 	// ── 10. context: apply pruning and inject nudges ──────────────────────────
 	pi.on("context", async (event, ctx) => {
+		const effectiveConfig = configForContext(ctx)
 		const contextMessages = event.messages.filter((message: any) =>
 			!isUserVisibleOnlyMessage(message) && !isDcpControlPlaneMessage(message)
 		)
+		if (!effectiveConfig.enabled) {
+			return { messages: contextMessages }
+		}
 		annotateMessagesWithBranchEntryIds(contextMessages, ctx)
-		let prunedMessages = applyPruning(contextMessages, state, config)
+		let prunedMessages = applyPruning(contextMessages, state, effectiveConfig)
 		let candidate = null as ReturnType<typeof detectCompressionCandidate>
 		let messageCandidates = [] as ReturnType<typeof detectMessageCompressionCandidates>
 
@@ -273,11 +284,11 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 			const ctxModel = (ctx as any).model
 			const provider = ctxModel?.provider ?? ctxModel?.providerId ?? ctxModel?.providerID
 			const model = ctxModel?.id ?? ctxModel?.model ?? ctxModel?.modelId ?? ctxModel?.modelID
-			const thresholds = resolveContextThresholds(config, [
+			const thresholds = resolveContextThresholds(effectiveConfig, [
 				provider && model ? `${provider}/${model}` : undefined,
 				model,
 			], usage.contextWindow)
-			if (config.compress.summaryBuffer) {
+			if (effectiveConfig.compress.summaryBuffer) {
 				const summaryBonus = getActiveSummaryTokenEstimate(state) / usage.contextWindow
 				thresholds.maxContextPercent += Math.min(summaryBonus, SUMMARY_BUFFER_MAX_CONTEXT_BONUS)
 			}
@@ -292,7 +303,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 			const nudgeType = getNudgeType(
 				contextPercent,
 				state,
-				config,
+				effectiveConfig,
 				toolCallsSinceLastUser,
 				thresholds,
 			)
@@ -304,12 +315,13 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 			candidate = detectCompressionCandidate(
 				prunedMessages,
 				state,
-				config,
+				effectiveConfig,
 				contextPercent,
 			)
 			messageCandidates = detectMessageCompressionCandidates(
 				prunedMessages,
-				config,
+				state,
+				effectiveConfig,
 				contextPercent,
 			)