pi-ui-extend 0.1.34 → 0.1.36

package/external/pi-tools-suite/README.md

@@ -68,12 +68,62 @@ DCP settings are stored only under `dcp` in the user shared config file `~/.conf
       "nudgeFrequency": 1,
       "iterationNudgeThreshold": 6,
       "protectedTools": ["compress", "write", "edit", "subagents"]
+    },
+    "modelOverrides": {
+      "openai-codex/gpt-5.5": {
+        "compress": {
+          "minContextPercent": "28%",
+          "maxContextPercent": "48%"
+        }
+      },
+      "openai-codex/gpt-5.4-mini": {
+        "compress": {
+          "minContextPercent": "20%",
+          "maxContextPercent": "38%"
+        }
+      },
+      "zai/*": {
+        "compress": {
+          "minContextPercent": "16%",
+          "maxContextPercent": "30%"
+        }
+      },
+      "antigravity/*sonnet*": {
+        "compress": {
+          "minContextPercent": "22%",
+          "maxContextPercent": "40%"
+        }
+      },
+      "antigravity/gemini-3.1-pro*": {
+        "compress": {
+          "minContextPercent": "24%",
+          "maxContextPercent": "42%"
+        }
+      },
+      "antigravity/gemini-3-flash*": {
+        "compress": {
+          "minContextPercent": "18%",
+          "maxContextPercent": "34%"
+        }
+      },
+      "antigravity/gemini-2.5-flash*": {
+        "compress": {
+          "minContextPercent": "18%",
+          "maxContextPercent": "32%"
+        }
+      },
+      "antigravity/antigravity-claude-opus-4-6-thinking": {
+        "compress": {
+          "minContextPercent": "26%",
+          "maxContextPercent": "44%"
+        }
+      }
     }
   }
 }
 ```
 
-`minContextPercent` / `maxContextPercent` accept legacy fractions (`0.25`), percent strings (`"25%"`), or absolute token counts when Pi knows the current model context window. `minContextLimit` / `maxContextLimit` and `modelMinContextLimits` / `modelMaxContextLimits` are explicit absolute-or-percent aliases. If `compress.protectUserMessages` is enabled, range compression appends selected user messages verbatim instead of rejecting the range; individual message compression still skips protected raw user messages. Protected tool outputs are copied into summaries for tools protected by name or `protectedFilePatterns`; protected `subagents` result reads also try to include the saved `result.md` artifact when available.
+`minContextPercent` / `maxContextPercent` accept legacy fractions (`0.25`), percent strings (`"25%"`), or absolute token counts when Pi knows the current model context window. `minContextLimit` / `maxContextLimit` and `modelMinContextLimits` / `modelMaxContextLimits` are explicit absolute-or-percent aliases. `modelOverrides` and the `modelMin*` / `modelMax*` maps support exact model keys plus `*` / `?` wildcard patterns; matching is applied from generic to specific so exact bare-model matches override bare wildcards, and exact `provider/model` matches override provider wildcards. Array fields are union-merged, so model-specific `protectedTools` extend the defaults instead of replacing them. If `compress.protectUserMessages` is enabled, range compression appends selected user messages verbatim instead of rejecting the range; individual message compression still skips protected raw user messages. Protected tool outputs are copied into summaries for tools protected by name or `protectedFilePatterns`; protected `subagents` result reads also try to include the saved `result.md` artifact when available.
 
 ## LSP setup
 
@@ -271,6 +321,26 @@ npm run test:e2e
 
 Supporting docs and historical standalone README content are kept in `docs/`; third-party license texts are kept in `licenses/`.
 
+## SDK pin
+
+This suite runs inside the Pi host process, so its `@earendil-works/*`
+peerDependencies (`pi-ai`, `pi-coding-agent`, `pi-tui`) must match the host Pi
+SDK version exactly. Otherwise npm can resolve a stale copy in this package's
+own `node_modules` and cause a double-load (e.g. `0.75.4` here vs `0.79.4` in
+the host).
+
+The host repo keeps these aligned: `npm run sync:sdk-pin` rewrites these
+peerDeps to the host version, and `npm run sync:sdk-pin:check` reports drift
+(non-zero exit). When you bump the Pi SDK in the host `package.json`, the host
+runs `sync:sdk-pin` and then you reinstall here:
+
+```bash
+npm install --ignore-scripts
+```
+
+The suite deliberately does not bump its own `version` field for SDK changes;
+its peerDeps carry the version.
+
 ## Third-party notices
 
 Parts of this extension suite are based on or adapted from code by other vendors and projects. The corresponding license texts and notices are included in `licenses/`.

package/external/pi-tools-suite/package.json

@@ -22,13 +22,13 @@
     "smoke:tools": "PI_OFFLINE=1 pi --no-session -p \"ping\"",
     "smoke": "npm run smoke:explicit && npm run smoke:auto && npm run smoke:tools",
     "test": "bun test test",
-    "test:async-subagents-e2e": "ASYNC_SUBAGENTS_E2E=1 ASYNC_SUBAGENTS_MODEL=zai/glm-5-turbo bun test --concurrent --max-concurrency=30 test/async-subagents",
+    "test:async-subagents-e2e": "ASYNC_SUBAGENTS_E2E=1 ASYNC_SUBAGENTS_DEBUG_LOGS=1 ASYNC_SUBAGENTS_MODEL=zai/glm-5-turbo bun test --concurrent --max-concurrency=30 test/async-subagents",
     "test:async-subagents-selection-e2e": "ASYNC_SUBAGENTS_SELECTION_E2E=1 ASYNC_SUBAGENTS_MODEL=zai/glm-5-turbo bun test --concurrent --max-concurrency=30 test/async-subagents/selection-e2e.test.ts",
     "bench:locate": "PI_LOCATE_BENCH_ITERATIONS=5 PI_LOCATE_BENCH_FAKE_IDX=0 PI_LOCATE_BENCH_MODEL=zai/glm-5-turbo PI_LOCATE_BENCH_MODES=direct-read-grep,ast-structural,repo-search-hybrid,repo-discovery,subagent-search,unrestricted-suite node test/fixtures/hard-to-find-project/benchmark/run-locate-benchmark.mjs",
     "bench:locate:analyze": "node test/fixtures/hard-to-find-project/benchmark/analyze-locate-benchmark.mjs",
     "test:locate-benchmark-e2e": "PI_LOCATE_BENCH_E2E=1 PI_LOCATE_BENCH_MODEL=zai/glm-5-turbo bun test test/locate-benchmark-e2e.test.ts",
     "test:tool-selection-e2e": "TOOL_SELECTION_E2E=1 TOOL_SELECTION_E2E_MODEL=zai/glm-5-turbo bun test --concurrent --max-concurrency=30 test/tool-selection-e2e.test.ts",
-    "test:e2e": "TOOL_SELECTION_E2E=1 TOOL_SELECTION_E2E_MODEL=zai/glm-5-turbo ASYNC_SUBAGENTS_E2E=1 ASYNC_SUBAGENTS_MODEL=zai/glm-5-turbo bun test --concurrent --max-concurrency=5 test/tool-selection-e2e.test.ts test/async-subagents/e2e.test.ts test/async-subagents/selection-e2e.test.ts test/todo-persistence-e2e.test.ts",
+    "test:e2e": "TOOL_SELECTION_E2E=1 TOOL_SELECTION_E2E_MODEL=zai/glm-5-turbo ASYNC_SUBAGENTS_E2E=1 ASYNC_SUBAGENTS_DEBUG_LOGS=1 ASYNC_SUBAGENTS_MODEL=zai/glm-5-turbo bun test --concurrent --max-concurrency=5 test/tool-selection-e2e.test.ts test/async-subagents/e2e.test.ts test/async-subagents/selection-e2e.test.ts test/todo-persistence-e2e.test.ts",
     "typecheck:async-subagents": "bash scripts/typecheck-source.sh",
     "check": "npm run smoke"
   },
@@ -38,9 +38,9 @@
     "vscode-languageserver-protocol": "^3.17.5"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*",
+    "@earendil-works/pi-ai": "0.79.4",
+    "@earendil-works/pi-coding-agent": "0.79.4",
+    "@earendil-works/pi-tui": "0.79.4",
     "typebox": "*"
   },
   "devDependencies": {

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

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { ignoreStaleExtensionContextError } from "../context-usage.js";
 import {
 	copySubagentConfigSample,
 	ensureSessionFileLink,
@@ -172,12 +173,17 @@ async function triggerOrchestrationPrompt(
 			? `${basePrompt}\n\nObjective:\n${objective}`
 			: basePrompt;
 
-	if (typeof pi.sendUserMessage === "function") {
-		pi.sendUserMessage(prompt);
-	} else if (typeof pi.sendMessage === "function") {
-		pi.sendMessage({ customType: `async-subagents-${modeName}`, content: prompt, display: false }, { triggerTurn: true, deliverAs: "followUp" });
-	} else {
-		ctx.ui.notify(`Cannot trigger /${modeName}: this Pi runtime does not expose sendUserMessage/sendMessage.`, "error");
+	try {
+		if (typeof pi.sendUserMessage === "function") {
+			pi.sendUserMessage(prompt);
+		} else if (typeof pi.sendMessage === "function") {
+			pi.sendMessage({ customType: `async-subagents-${modeName}`, content: prompt, display: false }, { triggerTurn: true, deliverAs: "followUp" });
+		} else {
+			ctx.ui.notify(`Cannot trigger /${modeName}: this Pi runtime does not expose sendUserMessage/sendMessage.`, "error");
+			return;
+		}
+	} catch (error) {
+		ignoreStaleExtensionContextError(error);
 		return;
 	}
 

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,