pi-ui-extend 0.1.34 → 0.1.36

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,
 			)
 

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

@@ -26,7 +26,9 @@ When multiple independent stale sections exist, prefer several focused compressi
 When one older message is huge but the surrounding context is still useful, use message-mode compression for that single message instead of compressing a broad range.
 Summaries should be proportional to future usefulness, not proportional to the amount of text being removed.
 
-Use \`compress\` as steady housekeeping while you work. After any completed implementation + verification slice, compress that closed slice before replying or starting a new task unless the next step needs exact raw logs/diffs. Do not carry large stale tool outputs across task boundaries.
+Use \`compress\` as steady housekeeping while you work. Closed slice => compress now. Do not start a new search, file-read batch, test, verification run, or web lookup while older completed work remains raw.
+
+A closed slice is any finished implementation, verification, config edit, answered exploration, dead-end debugging branch, or test/log inspection. Passing logs are summary-only: preserve command, pass/fail, key failures if any, and whether follow-up is needed; never keep a full passing log in live context. Treat large shell/read/repo/web outputs as disposable evidence once their facts are extracted.
 
 Before compressing while work is unfinished, ensure one \`todo in_progress\` captures the active objective and next step.
 
@@ -38,6 +40,7 @@ CADENCE, SIGNALS, AND LATENCY
 - Prioritize closedness and independence over raw size
 - Prefer smaller, regular compressions over infrequent massive compressions for better latency and summary quality
 - When multiple independent stale sections are ready, batch compressions in parallel
+- Before more exploration, ask whether an older completed slice can become summary-only; if yes, compress first
 
 COMPRESS WHEN
 
@@ -45,6 +48,8 @@ A section is genuinely closed and the raw conversation has served its purpose:
 
 - Research concluded and findings are clear
 - Implementation finished and verified
+- Config/doc edit finished
+- Test, lint, or CI output has been understood, especially passing logs
 - Exploration exhausted and patterns understood
 - Dead-end noise can be discarded without waiting for a whole chapter to close
 
@@ -77,7 +82,10 @@ It is your responsibility to keep a sharp, high-quality context window for optim
 export const COMPRESS_RANGE_DESCRIPTION = `Collapse one or more ranges of the conversation into detailed summaries.
 
 AUTONOMOUS HOUSEKEEPING
-Do not wait for context emergencies. After a completed implementation + verification slice, compress that closed slice before replying or starting a new task unless the next step needs exact raw logs/diffs. Do not carry large stale tool outputs across task boundaries.
+Do not wait for context emergencies. Closed slice => compress now. A closed slice includes completed implementation, verification, config/doc edit, answered exploration, dead-end debugging, or finished test/log inspection. Compress before starting the next search/read/test/web lookup unless exact raw text is still needed.
+
+PASSING LOGS AND LARGE OUTPUTS
+Passing check/test/lint/tsc logs are summary-only after you know the result. Preserve command, pass/fail, key failures if any, and follow-up status; drop full passing output. Treat large shell/read/repo/web outputs as disposable evidence once important facts are extracted.
 
 DCP REMINDERS
 If a \`<dcp-system-reminder>\` is present in context, treat it as a direct instruction to evaluate compression immediately. If a safe closed range exists, call this tool before further exploration. Skipping compression is acceptable only when the newest raw context is still needed for the next concrete edit, test, or answer.
@@ -87,7 +95,7 @@ Your summary must be COMPLETE FOR CONTINUATION, not a transcript rewrite. Preser
 
 If active unfinished work exists, start with \`Active objective\` and \`Next step\`.
 
-Default to a compact structured summary (roughly 5-15 bullets for a normal completed work slice). Grow beyond that only when the compressed range contains multiple independent decisions, unresolved blockers, or precise state that is genuinely required to continue.
+Default to a compact structured summary (roughly 4-10 bullets for a normal completed work slice). Grow beyond that only when the compressed range contains multiple independent decisions, unresolved blockers, or precise state that is genuinely required to continue.
 
 Do not copy long raw code, JSON, diffs, logs, or tool output into summaries. Prefer semantic descriptions such as “updated foo.json so scene_assets_1.zai-svg has maxConcurrentRuns set to 5.” Include exact snippets only when the literal text is required for safe continuation, and keep them short and single-line.
 
@@ -98,7 +106,7 @@ USER INTENT FIDELITY
 When the compressed range includes user messages, preserve the user's intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
 Directly quote user messages when they are short enough to include safely. Direct quotes are preferred when they best preserve exact meaning.
 
-Be LEAN. Strip away the noise: failed attempts that led nowhere, verbose tool outputs, back-and-forth exploration, and incidental line-by-line edit history. What remains should be pure signal with enough detail to resume work confidently.
+Be LEAN. Strip away full logs, repeated search/read output, duplicate summaries, incidental failed attempts, and line-by-line edit history. What remains should be pure signal with enough detail to resume work confidently.
 
 TWO COMPRESSION MODES
 You may use either or both modes in one call:
@@ -174,7 +182,7 @@ You are at or beyond the configured max context threshold. This is an emergency
 You MUST use the \`compress\` tool now. Do not continue normal exploration until compression is handled.
 
 If you are in the middle of a critical atomic operation, finish that atomic step first, then compress immediately.
-If a completed implementation+verification slice exists, compress it before replying or starting another task.
+If any closed slice exists (finished implementation, verification, config/doc edit, answered exploration, dead end, or test/log inspection), compress it before replying or starting another task. Passing logs should become command + pass/fail + follow-up status only.
 
 RANGE STRATEGY (MANDATORY)
 Prioritize one large, closed, high-yield compression range first.
@@ -201,9 +209,9 @@ ACTION REQUIRED: Context usage is high.
 
 Before doing more exploration, look for a closed, self-contained range that no longer needs to stay raw and compress it now.
 
-Do not treat this as optional housekeeping. If any completed research, implementation, verification, CI-log inspection, or dead-end debugging slice is present, call the \`compress\` tool before continuing normal work.
+Do not treat this as optional housekeeping. If any completed research, implementation, verification, config/doc edit, CI-log inspection, or dead-end debugging slice is present, call the \`compress\` tool before continuing normal work.
 If a completed implementation+verification slice exists, compress it before replying or starting another task.
-High-priority stale tool outputs must be compressed once no exact raw text is needed.
+High-priority stale shell/read/repo/web outputs must be compressed once no exact raw text is needed. Passing logs should not remain raw after they are understood.
 
 RANGE SELECTION
 Prefer older, resolved history. Avoid the newest active working slice unless it is clearly done.
@@ -225,7 +233,7 @@ If any range is cleanly closed and unlikely to be needed again, use the \`compre
 If direction has shifted, compress earlier ranges that are now less relevant.
 
 Do not defer this across another batch of searches, reads, CI log fetches, or tests. The next safe action should be compression whenever a closed slice exists.
-High-priority stale tool outputs must be compressed once no exact raw text is needed.
+High-priority stale shell/read/repo/web outputs and understood passing logs must be compressed once no exact raw text is needed.
 
 Prefer small, closed-range compressions over one broad compression.
 Use message-mode compression for isolated large stale messages.
@@ -239,7 +247,7 @@ Keep active context uncompressed.
 export const ITERATION_NUDGE = `<dcp-system-reminder>
 ACTION REQUIRED: You've been iterating for a while after the last user message.
 
-Pause before the next non-atomic tool call. If there is a closed portion that is unlikely to be referenced immediately (for example, finished research before implementation, completed CI-log triage, a verified fix, or a dead-end investigation), use the \`compress\` tool on it now.
+Pause before the next non-atomic tool call. If there is a closed portion that is unlikely to be referenced immediately (for example, finished research before implementation, completed config edit, completed CI-log triage, a verified fix, or a dead-end investigation), use the \`compress\` tool on it now.
 
 Do not keep accumulating tool outputs while a completed slice remains raw. If a range is closed, compression is the next safe action.
 If a completed implementation+verification slice exists, compress it before replying or starting another task.

package/external/pi-tools-suite/src/dcp/pruner-candidates.ts

@@ -17,6 +17,55 @@ interface CandidateBoundary {
   isSystemReminder: boolean;
 }
 
+function hasAddressableSnapshot(state: DcpState): boolean {
+  return state.messageMetaSnapshot.size > 0 || state.messageIdSnapshot.size > 0;
+}
+
+function isActiveBlockId(blockId: number, state: DcpState): boolean {
+  return state.compressionBlocks.some((block) => block.id === blockId && block.active);
+}
+
+function findCurrentMessageId(msg: any, state: DcpState): string | undefined {
+  const role = msg?.role ?? "";
+  const timestamp = msg?.timestamp;
+  if (!Number.isFinite(timestamp)) return undefined;
+
+  for (const [id, meta] of state.messageMetaSnapshot) {
+    if (meta.timestamp === timestamp && meta.role === role && meta.blockId === undefined) return id;
+  }
+
+  for (const [id, ts] of state.messageIdSnapshot) {
+    if (ts === timestamp) return id;
+  }
+
+  return undefined;
+}
+
+function resolveAddressableBoundaryId(
+  msg: any,
+  state: DcpState,
+  options: { allowBlocks: boolean },
+): { id: string; blockId?: number; text: string } | null {
+  const text = messageText(msg);
+  const blockId = extractBlockId(text);
+  if (blockId !== undefined) {
+    if (options.allowBlocks && isActiveBlockId(blockId, state)) return { id: `b${blockId}`, blockId, text };
+    if (!hasAddressableSnapshot(state) && options.allowBlocks) return { id: `b${blockId}`, blockId, text };
+    return null;
+  }
+
+  const messageId = extractMessageId(text);
+  if (!messageId) return null;
+  if (!hasAddressableSnapshot(state)) return { id: messageId, text };
+
+  if (state.messageMetaSnapshot.has(messageId) || state.messageIdSnapshot.has(messageId)) {
+    return { id: messageId, text };
+  }
+
+  const currentId = findCurrentMessageId(msg, state);
+  return currentId ? { id: currentId, text } : null;
+}
+
 export function detectCompressionCandidate(
   messages: any[],
   _state: DcpState,
@@ -29,19 +78,16 @@ export function detectCompressionCandidate(
 
   const boundaries: CandidateBoundary[] = [];
   for (const msg of messages) {
-    const text = messageText(msg);
-    const blockId = extractBlockId(text);
-    const messageId = extractMessageId(text);
-    const id = blockId !== undefined ? `b${blockId}` : messageId;
-    if (!id) continue;
+    const boundary = resolveAddressableBoundaryId(msg, _state, { allowBlocks: true });
+    if (!boundary) continue;
     if (!Number.isFinite(msg.timestamp)) continue;
     boundaries.push({
-      id,
+      id: boundary.id,
       role: msg.role ?? "",
       timestamp: msg.timestamp,
       tokenEstimate: estimateMessageTokens(msg),
-      blockId,
-      isSystemReminder: text.includes("<dcp-system-reminder>"),
+      blockId: boundary.blockId,
+      isSystemReminder: boundary.text.includes("<dcp-system-reminder>"),
     });
   }
 
@@ -102,6 +148,7 @@ export function formatCompressionCandidateHint(candidate: CompressionCandidate):
 
 export function detectMessageCompressionCandidates(
   messages: any[],
+  state: DcpState,
   config: DcpConfig,
   contextPercent: number,
 ): MessageCompressionCandidate[] {
@@ -111,18 +158,15 @@ export function detectMessageCompressionCandidates(
 
   const boundaries: CandidateBoundary[] = [];
   for (const msg of messages) {
-    const text = messageText(msg);
-    const blockId = extractBlockId(text);
-    const messageId = extractMessageId(text);
-    if (!messageId || blockId !== undefined) continue;
+    const boundary = resolveAddressableBoundaryId(msg, state, { allowBlocks: false });
+    if (!boundary || boundary.blockId !== undefined) continue;
     if (!Number.isFinite(msg.timestamp)) continue;
     boundaries.push({
-      id: messageId,
+      id: boundary.id,
       role: msg.role ?? "",
       timestamp: msg.timestamp,
       tokenEstimate: estimateMessageTokens(msg),
-      blockId,
-      isSystemReminder: text.includes("<dcp-system-reminder>"),
+      isSystemReminder: boundary.text.includes("<dcp-system-reminder>"),
     });
   }
 

package/external/pi-tools-suite/src/dcp/pruner-metadata.ts

@@ -1,4 +1,4 @@
-import type { DcpConfig } from "./config.js";
+import { matchingModelEntries, type DcpConfig } from "./config.js";
 import type { DcpState } from "./state.js";
 import type { NudgeThresholds } from "./pruner-types.js";
 import { createRequire } from "node:module";
@@ -107,8 +107,6 @@ export function resolveContextThresholds(
   modelKeys: Array<string | undefined> = [],
   contextWindow?: number,
 ): Required<NudgeThresholds> {
-  const candidates = modelKeys.filter((key): key is string => typeof key === "string" && key.length > 0);
-
   const resolveThresholdValue = (value: number | string | undefined): number | undefined => {
     if (typeof value === "string") {
       const trimmed = value.trim();
@@ -130,12 +128,12 @@ export function resolveContextThresholds(
   };
 
   const resolveOverride = (map: Record<string, number | string> | undefined): number | undefined => {
-    if (!map) return undefined;
-    for (const key of candidates) {
-      const value = resolveThresholdValue(map[key]);
-      if (value !== undefined) return value;
+    let resolved: number | undefined;
+    for (const [, rawValue] of matchingModelEntries(map, modelKeys)) {
+      const value = resolveThresholdValue(rawValue);
+      if (value !== undefined) resolved = value;
     }
-    return undefined;
+    return resolved;
   };
 
   const min =

package/external/pi-tools-suite/src/dcp/pruner-nudge.ts

@@ -157,7 +157,7 @@ function formatCandidateActions(
 
   if (candidate) {
     parts.push(
-      `Recommended range candidate: ${candidate.startId}..${candidate.endId} (${candidate.messageCount} messages, ~${candidate.estimatedTokens} tokens, ${candidate.reason}). Compress this before the next search/read/test if it is closed.`,
+      `Recommended range candidate: ${candidate.startId}..${candidate.endId} (${candidate.messageCount} messages, ~${candidate.estimatedTokens} tokens, ${candidate.reason}). Compress this before the next search/read/test/web lookup if it is closed.`,
     );
     if (candidate.includedBlockIds.length > 0) {
       parts.push(
@@ -172,7 +172,7 @@ function formatCandidateActions(
     parts.push(
       `Recommended message candidates: ${listedMessages
         .map((item) => `${item.messageId} (${item.priority}, ${item.role}, ~${item.estimatedTokens} tokens)`)
-        .join(", ")}. High-priority stale messages MUST be compressed once their full text is no longer needed. Batch multiple messages in one compress call when possible.`,
+        .join(", ")}. High-priority stale messages MUST be compressed once their full text is no longer needed; passing logs should become command + pass/fail + follow-up status only. Batch multiple messages in one compress call when possible.`,
     );
   }
 
@@ -180,7 +180,7 @@ function formatCandidateActions(
   if (activeBlocks) parts.push(activeBlocks);
 
   if (parts.length === 0) {
-    parts.push("No automatic candidate is certain; scan the older closed context now and compress any completed research, implementation, verification, CI-log inspection, or dead-end debugging slice before accumulating more tool output.");
+    parts.push("No automatic candidate is certain; scan the older closed context now and compress any completed research, implementation, config/doc edit, verification, CI-log inspection, or dead-end debugging slice before accumulating more tool output.");
   }
 
   return [`CONCRETE NEXT ACTION`, ...parts].join("\n");

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

@@ -19,11 +19,61 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
   "dcp": {
     "enabled": true,
     "manualMode": { "enabled": false, "automaticStrategies": true },
+    "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%"
+        }
+      }
+    },
     "compress": {
       "minContextPercent": "20%",
       "maxContextPercent": "55%",
       "nudgeFrequency": 1,
-      "iterationNudgeThreshold": 6,
+      "iterationNudgeThreshold": 4,
       "autoCandidates": { "minContextPercent": 0.2 },
       "messageMode": { "minContextPercent": 0.2 }
     }