pi-ui-extend 0.1.37 → 0.1.39

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

@@ -15,7 +15,7 @@ export interface PiToolsSuiteConfig {
 	enabled: boolean;
 	disabledModules: string[];
 	todoThinking: boolean;
-	/** Vision-capable model used by the GLM lookup tool; unset disables lookup. */
+	/** Vision-capable model used by the coding-discipline lookup tool; unset disables lookup. */
 	lookupModel?: string;
 	telegramMirror?: TelegramMirrorConfig;
 }

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

@@ -0,0 +1,368 @@
+// ---------------------------------------------------------------------------
+// Dynamic Context Pruning (DCP) — auto-compress fallback
+//
+// When a model ignores repeated context-strong nudges above the emergency
+// threshold (observed with gpt-5.5 in session 019edfe3: 59 strong nudges,
+// 0 compress calls), DCP creates a compression block itself instead of
+// waiting for the model. This is the model-independent safety net.
+//
+// Lossy and irreversible within a session; disabled by default and gated by a
+// patience counter + the emergency threshold. The summary can be produced
+// either by a deterministic programmatic digest (default) or by a configured
+// list of summarizer models (e.g. a cheap model like zai/glm-5.2), with
+// automatic fallback to the programmatic digest on any failure/timeout.
+// ---------------------------------------------------------------------------
+
+import { complete } from "@earendil-works/pi-ai"
+import type { Model, Api } from "@earendil-works/pi-ai"
+import type { DcpState } from "./state.js"
+import type { DcpConfig } from "./config.js"
+import type { CompressionCandidate } from "./pruner-types.js"
+import {
+	createRangeCompressionBlock,
+	resolveAnchorBoundary,
+} from "./compression-blocks.js"
+
+/**
+ * Pure decision: should the auto-compress fallback fire this pass?
+ *
+ * Fires when ALL hold:
+ *  - the master switch `autoCompress.enabled` is on,
+ *  - the model has ignored at least `patience` consecutive context-strong
+ *    nudges (`consecutiveIgnoredStrongNudges > patience` — the model gets
+ *    `patience` genuine strong chances before DCP takes over),
+ *  - context is still above the emergency threshold (maxContextPercent),
+ *  - a safe compression candidate exists outside the recent turns.
+ */
+export function decideAutoCompress(
+	state: DcpState,
+	config: DcpConfig,
+	contextPercent: number,
+	maxContextPercent: number,
+	candidate: CompressionCandidate | null,
+): { shouldFire: boolean; reason: string } {
+	const settings = config.compress.autoCompress
+	if (!settings?.enabled) return { shouldFire: false, reason: "disabled" }
+	if (state.consecutiveIgnoredStrongNudges <= settings.patience) {
+		return { shouldFire: false, reason: "below-patience" }
+	}
+	if (!(contextPercent > maxContextPercent)) {
+		return { shouldFire: false, reason: "below-emergency-threshold" }
+	}
+	if (!candidate) return { shouldFire: false, reason: "no-candidate" }
+	return { shouldFire: true, reason: "ignored-strongs" }
+}
+
+/** Flatten a single message's content blocks into plain text. */
+function messageToText(message: any): string {
+	const content = message?.content
+	if (typeof content === "string") return content
+	if (!Array.isArray(content)) return ""
+	return content
+		.map((block: any) => {
+			if (typeof block === "string") return block
+			if (block?.type === "text") return block.text ?? ""
+			if (block?.type === "toolCall") {
+				const name = block.name ?? block.function?.name ?? "tool"
+				return `[tool call: ${name}]`
+			}
+			if (block?.type === "toolResult" || block?.role === "toolResult") {
+				return block.text ?? ""
+			}
+			return ""
+		})
+		.join("\n")
+		.trim()
+}
+
+/** Extract a short tool-usage digest from messages in the range. */
+function toolUsageDigest(messages: any[]): string {
+	const counts = new Map<string, number>()
+	for (const msg of messages) {
+		const content = msg?.content
+		if (!Array.isArray(content)) continue
+		for (const block of content) {
+			if (block?.type === "toolCall" && typeof block.name === "string") {
+				counts.set(block.name, (counts.get(block.name) ?? 0) + 1)
+			}
+		}
+	}
+	if (counts.size === 0) return ""
+	const entries = [...counts.entries()].sort((a, b) => b[1] - a[1])
+	return entries.map(([name, n]) => `${name}×${n}`).join(", ")
+}
+
+/**
+ * Deterministic, model-free summary of the compressed range. Deliberately
+ * short: `createRangeCompressionBlock` appends protected user messages and
+ * protected tool outputs on top of this, so the digest itself only needs to
+ * label the slice and record the tool-call shape.
+ */
+export function buildProgrammaticSummary(
+	topic: string,
+	candidate: CompressionCandidate,
+	messagesInRange: any[],
+): string {
+	const toolDigest = toolUsageDigest(messagesInRange)
+	const lines = [
+		`[Auto-compressed by DCP — model did not compress after repeated context-strong nudges]`,
+		`Topic: ${topic}`,
+		`Range: ${candidate.startId}..${candidate.endId} (${candidate.messageCount} messages, ~${candidate.estimatedTokens} tokens)`,
+	]
+	if (toolDigest) lines.push(`Tool calls in range: ${toolDigest}`)
+	lines.push(
+		`This slice was summarized automatically to protect the context window. Protected user messages and tool outputs are preserved below by the compression block.`,
+	)
+	return lines.join("\n")
+}
+
+const SUMMARIZER_SYSTEM_PROMPT = `You summarize a slice of a coding agent's conversation so it can replace the raw messages in context. Produce a dense, continuation-focused summary: preserve user intent, decisions made, files/symbols changed or inspected, exact errors still actionable, verification status, and next steps. Drop full logs, repeated output, and incidental detail. Be concise (roughly 4-10 bullets). Output ONLY the summary text, no preamble.`
+
+/** Outcome of one summarizer-model attempt, surfaced in DCP debug logs. */
+export interface ModelSummaryAttempt {
+	ref: string
+	outcome: "ok" | "no-model" | "no-auth" | "empty" | "error"
+	error?: string
+}
+
+/** Result of {@link generateModelSummary}: optional text plus per-model attempts. */
+export interface ModelSummaryResult {
+	text?: string
+	/** Model ref that produced {@link text}, if any. */
+	usedModelRef?: string
+	/** One entry per model ref tried, in order, for debug visibility. */
+	attempts: ModelSummaryAttempt[]
+}
+
+/**
+ * Try to produce a model-generated summary by calling each model in
+ * `modelRefs` in order. On success returns `{ text, usedModelRef, attempts }`;
+ * if every model fails, returns `{ attempts }` with `text` undefined so the
+ * caller falls back to the programmatic digest while still recording which
+ * models were tried and why.
+ *
+ * Never throws: a summarizer failure must never block the agent — the
+ * programmatic digest is always available as a floor.
+ */
+export async function generateModelSummary(
+	modelRefs: string[],
+	modelRegistry: any,
+	signal: AbortSignal | undefined,
+	topic: string,
+	messagesInRange: any[],
+	timeoutMs: number,
+): Promise<ModelSummaryResult> {
+	const attempts: ModelSummaryAttempt[] = []
+	if (!modelRefs || modelRefs.length === 0) return { attempts }
+	if (!modelRegistry || typeof modelRegistry.find !== "function" || typeof modelRegistry.getApiKeyAndHeaders !== "function") {
+		return { attempts }
+	}
+
+	// Build a compact transcript from the range. Cap token budget so the
+	// summarizer call stays cheap and bounded.
+	const transcript = messagesInRange
+		.map((msg, i) => {
+			const role = msg?.role ?? "message"
+			return `### ${role} #${i + 1}\n${messageToText(msg)}`
+		})
+		.join("\n\n")
+	const userPrompt = `Summarize this conversation slice (topic: ${topic}).\n\nTranscript:\n${transcript}`
+
+	let lastError: unknown
+	for (const ref of modelRefs) {
+		const parsed = parseModelRef(ref)
+		if (!parsed) continue
+		const model: Model<Api> | undefined = modelRegistry.find(parsed.provider, parsed.id)
+		if (!model) {
+			attempts.push({ ref, outcome: "no-model" })
+			continue
+		}
+
+		let auth
+		try {
+			auth = await modelRegistry.getApiKeyAndHeaders(model)
+		} catch (error) {
+			lastError = error
+			attempts.push({ ref, outcome: "no-auth", error: error instanceof Error ? error.message : String(error) })
+			continue
+		}
+		if (!auth?.ok || !auth.apiKey) {
+			attempts.push({ ref, outcome: "no-auth" })
+			continue
+		}
+
+		// Combine the agent signal with a local timeout so a slow summarizer
+		// cannot stall the context event indefinitely.
+		const controller = new AbortController()
+		const timer = setTimeout(() => controller.abort(), Math.max(1000, timeoutMs))
+		const onParentAbort = () => controller.abort()
+		if (signal) {
+			if (signal.aborted) controller.abort()
+			else signal.addEventListener("abort", onParentAbort, { once: true })
+		}
+
+		try {
+			const result = await complete(
+				model,
+				{ systemPrompt: SUMMARIZER_SYSTEM_PROMPT, messages: [{ role: "user", content: userPrompt, timestamp: Date.now() }] },
+				{
+					apiKey: auth.apiKey,
+					headers: auth.headers,
+					env: auth.env,
+					signal: controller.signal,
+					maxRetries: 0,
+				} as any,
+			)
+			const text = extractAssistantText(result)
+			if (text) {
+				attempts.push({ ref, outcome: "ok" })
+				return { text, usedModelRef: ref, attempts }
+			}
+			attempts.push({ ref, outcome: "empty" })
+		} catch (error) {
+			lastError = error
+			attempts.push({ ref, outcome: "error", error: error instanceof Error ? error.message : String(error) })
+			// try next model in the fallback list
+		} finally {
+			clearTimeout(timer)
+			if (signal) signal.removeEventListener("abort", onParentAbort)
+		}
+	}
+
+	if (lastError) {
+		// Swallowed on purpose: callers use the programmatic digest floor.
+	}
+	return { attempts }
+}
+
+function extractAssistantText(result: any): string | undefined {
+	const content = result?.content
+	if (!Array.isArray(content)) return undefined
+	const text = content
+		.filter((block: any) => block?.type === "text" && typeof block.text === "string")
+		.map((block: any) => block.text)
+		.join("\n")
+		.trim()
+	return text.length > 0 ? text : undefined
+}
+
+function parseModelRef(ref: string): { provider: string; id: string } | undefined {
+	const trimmed = ref.trim()
+	const slash = trimmed.lastIndexOf("/")
+	if (slash <= 0 || slash === trimmed.length - 1) return undefined
+	return { provider: trimmed.slice(0, slash), id: trimmed.slice(slash + 1) }
+}
+
+export interface CreateAutoCompressionBlockOptions {
+	candidate: CompressionCandidate
+	topic: string
+	state: DcpState
+	config: DcpConfig
+	messages: any[]
+	modelRegistry?: any
+	signal?: AbortSignal
+}
+
+export interface AutoCompressionResult {
+	blockId: number
+	summaryMode: "programmatic" | "model" | "programmatic_fallback"
+	summaryTokens: number
+	removedTokenEstimate: number
+	/** Model ref that produced the summary; set only when `summaryMode === "model"`. */
+	summarizerModelRef?: string
+	/** Per-model attempts, surfaced for DCP debug visibility on fallback. */
+	summarizerAttempts?: ModelSummaryAttempt[]
+}
+
+/**
+ * Create the auto-compression block. Selects the summary source based on
+ * `config.compress.autoCompress.summarizerModel`: empty → programmatic digest;
+ * non-empty → model summary with programmatic fallback. Then delegates block
+ * creation to the shared `createRangeCompressionBlock` path so protected
+ * content (user messages, tool outputs, prompt info) is handled identically to
+ * a model-initiated compress.
+ */
+export async function createAutoCompressionBlock(
+	options: CreateAutoCompressionBlockOptions,
+): Promise<AutoCompressionResult> {
+	const { candidate, topic, state, config, messages, modelRegistry, signal } = options
+	const settings = config.compress.autoCompress
+
+	// Resolve candidate message IDs (mNNN) to timestamps via the snapshot.
+	const startMeta = state.messageMetaSnapshot.get(candidate.startId)
+	const endMeta = state.messageMetaSnapshot.get(candidate.endId)
+	const rawStart = startMeta?.timestamp ?? state.messageIdSnapshot.get(candidate.startId)
+	const rawEnd = endMeta?.timestamp ?? state.messageIdSnapshot.get(candidate.endId)
+
+	if (!Number.isFinite(rawStart) || !Number.isFinite(rawEnd)) {
+		throw new Error(
+			`Auto-compress candidate ${candidate.startId}..${candidate.endId} did not resolve to finite timestamps`,
+		)
+	}
+	const startTimestamp: number = rawStart as number
+	const endTimestamp: number = rawEnd as number
+
+	const messagesInRange = messages.filter(
+		(msg) =>
+			Number.isFinite(msg?.timestamp) && msg.timestamp >= startTimestamp && msg.timestamp <= endTimestamp,
+	)
+
+	// Summary source selection. `summaryMode` distinguishes three cases so the
+	// DCP debug log can tell a real model summary from a programmatic fallback
+	// caused by summarizer failure:
+	//   - "model": a configured model produced the summary.
+	//   - "programmatic": no summarizer models configured (floor by design).
+	//   - "programmatic_fallback": models were configured but all failed/empty.
+	let summary = buildProgrammaticSummary(topic, candidate, messagesInRange)
+	let summaryMode: "programmatic" | "model" | "programmatic_fallback" = "programmatic"
+	let summarizerModelRef: string | undefined
+	let summarizerAttempts: ModelSummaryAttempt[] | undefined
+
+	const modelRefs = settings.summarizerModel
+	if (modelRefs.length > 0) {
+		const modelResult = await generateModelSummary(
+			modelRefs,
+			modelRegistry,
+			signal,
+			topic,
+			messagesInRange,
+			settings.timeoutMs,
+		)
+		summarizerAttempts = modelResult.attempts.length > 0 ? modelResult.attempts : undefined
+		if (modelResult.text) {
+			summary = modelResult.text
+			summaryMode = "model"
+			summarizerModelRef = modelResult.usedModelRef
+		} else {
+			// All configured models failed or returned empty — fall back to the
+			// programmatic digest, but mark the mode distinctly so the fallback
+			// is visible in DCP debug logs.
+			summaryMode = "programmatic_fallback"
+		}
+	}
+
+	const anchor = resolveAnchorBoundary(endTimestamp, state)
+	const created = createRangeCompressionBlock({
+		topic,
+		summary,
+		startTimestamp,
+		endTimestamp,
+		startMessageId: startMeta?.stableId,
+		endMessageId: endMeta?.stableId,
+		anchorTimestamp: anchor.timestamp,
+		anchorMessageId: anchor.stableId,
+		createdByToolCallId: undefined,
+		state,
+		config,
+		mode: "range",
+	})
+
+	return {
+		blockId: created.block.id,
+		summaryMode,
+		summaryTokens: created.summaryTokenEstimate,
+		removedTokenEstimate: created.removedTokenEstimate,
+		summarizerModelRef,
+		summarizerAttempts,
+	}
+}

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

@@ -355,6 +355,9 @@ export function registerCompressTool(
       }
 
       const clearedNudgeAnchors = newBlockIds.length > 0 ? clearDcpNudgeAnchors(state) : 0
+      if (newBlockIds.length > 0) {
+        state.consecutiveIgnoredStrongNudges = 0
+      }
       if (clearedNudgeAnchors > 0) {
         try {
           pi.appendEntry("dcp-nudge", {

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

@@ -49,6 +49,23 @@ export interface DcpConfig {
       highTokens: number
       maxSuggestions: number
     }
+    /**
+     * Auto-compress fallback: when the model ignores repeated context-strong
+     * nudges above the emergency threshold, DCP creates a compression block
+     * itself (without waiting for the model). Lossy and irreversible within a
+     * session — disabled by default; opt in via config.
+     */
+    autoCompress: {
+      enabled: boolean
+      /** Number of context-strong nudges emitted (and ignored) before DCP
+       * auto-compresses. The model gets `patience` genuine strong chances. */
+      patience: number
+      /** Models to try, in order, when producing a model-generated summary.
+       * Empty array → deterministic programmatic digest (no model call). */
+      summarizerModel: string[]
+      /** Hard ceiling in ms for a single summarizer model call. */
+      timeoutMs: number
+    }
   }
   strategies: {
     deduplication: {
@@ -120,6 +137,12 @@ const DEFAULT_CONFIG: DcpConfig = {
       highTokens: 5000,
       maxSuggestions: 5,
     },
+    autoCompress: {
+      enabled: false,
+      patience: 2,
+      summarizerModel: [],
+      timeoutMs: 20000,
+    },
   },
   strategies: {
     deduplication: {

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

@@ -51,6 +51,7 @@ import {
 import { summarizeDcpState, writeDcpDebugLog } from "./debug-log.js"
 import type { DcpNudgeType } from "./pruner-types.js"
 import { registerCompressTool } from "./compress-tool.js"
+import { decideAutoCompress, createAutoCompressionBlock } from "./auto-compress.js"
 import { DCP_STATS_MESSAGE_TYPE, registerCommands } from "./commands.js"
 import { normalizeDcpContextUsage } from "./ui.js"
 import { safeGetContextUsage } from "../context-usage.js"
@@ -417,6 +418,21 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				return finishContext("unknown-context-percent", prunedMessages, { clearedAnchors })
 			}
 
+			// Record the observed context window on EVERY context event (before
+			// any early return) so a mid-session model/window downgrade is
+			// detectable even when earlier passes were below threshold. We
+			// snapshot the previous value first so the downgrade check below
+			// compares against the window the prior pass actually saw.
+			const currentContextWindow = usage.contextWindow
+			const previousContextWindow = state.lastContextWindow
+			if (
+				typeof currentContextWindow === "number" &&
+				Number.isFinite(currentContextWindow) &&
+				currentContextWindow > 0
+			) {
+				state.lastContextWindow = currentContextWindow
+			}
+
 			const ctxModel = (ctx as any).model
 			const provider = ctxModel?.provider ?? ctxModel?.providerId ?? ctxModel?.providerID
 			const model = ctxModel?.id ?? ctxModel?.model ?? ctxModel?.modelId ?? ctxModel?.modelID
@@ -448,13 +464,30 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				if (msg.role === "toolResult") toolCallsSinceLastUser++
 			}
 
-			const nudgeType = getNudgeType(
-				contextPercent,
-				state,
-				effectiveConfig,
-				toolCallsSinceLastUser,
-				thresholds,
-			)
+			// Switch-aware pre-emptive nudge: detect a mid-session context-window
+			// downgrade (e.g. model switch from a 1M window to a 275K window).
+			// Inherited tokens that were cheap on the larger window can suddenly
+			// sit above minContextPercent on the smaller one. When that happens,
+			// force a strong nudge on this pass so the model is told to compress
+			// before the smaller window fills, instead of waiting for cadence.
+			const windowDowngraded =
+				typeof previousContextWindow === "number" &&
+				Number.isFinite(previousContextWindow) &&
+				previousContextWindow > 0 &&
+				typeof currentContextWindow === "number" &&
+				Number.isFinite(currentContextWindow) &&
+				currentContextWindow < previousContextWindow * 0.9 &&
+				contextPercent > thresholds.minContextPercent
+
+			const nudgeType = windowDowngraded
+				? "context-strong"
+				: getNudgeType(
+					contextPercent,
+					state,
+					effectiveConfig,
+					toolCallsSinceLastUser,
+					thresholds,
+				)
 
 			const manualEmergencyOnly =
 				state.manualMode &&
@@ -483,6 +516,78 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				}, ctx)
 			}
 
+			// Track consecutive ignored context-strong nudges for the
+			// auto-compress fallback. A strong nudge is "ignored" if it fires
+			// again on a later context event without a successful compress in
+			// between. Reset on non-strong nudges and when pressure drops below
+			// the emergency threshold (handled by the below-threshold early
+			// return above, which clears anchors; counter is also reset on any
+			// successful compress in the compress tool).
+			if (nudgeType === "context-strong" || nudgeType === "context-soft") {
+				state.consecutiveIgnoredStrongNudges += 1
+			} else if (nudgeType === null) {
+				state.consecutiveIgnoredStrongNudges = 0
+			}
+
+			// Auto-compress fallback: if the model has ignored enough strong
+			// nudges while above the emergency threshold, DCP creates a
+			// compression block itself instead of nudging again.
+			if (!manualEmergencyOnly) {
+				const autoDecision = decideAutoCompress(
+					state,
+					effectiveConfig,
+					contextPercent,
+					thresholds.maxContextPercent,
+					candidate,
+				)
+				if (autoDecision.shouldFire && candidate) {
+					try {
+						const autoResult = await createAutoCompressionBlock({
+							candidate,
+							topic: "Auto-compressed slice",
+							state,
+							config: effectiveConfig,
+							messages: prunedMessages,
+							modelRegistry: (ctx as any).modelRegistry,
+							signal: (ctx as any).signal,
+						})
+						// Re-apply pruning so the new block takes effect on this
+						// same context pass instead of the next one.
+						prunedMessages = applyPruning(prunedMessages, state, effectiveConfig)
+						const clearedAnchors = clearDcpNudgeAnchors(state)
+						state.consecutiveIgnoredStrongNudges = 0
+						await saveDcpState(ctx, state)
+						writeDcpDebugLog(effectiveConfig, "compress.auto", {
+							trigger: autoDecision.reason,
+							blockId: `b${autoResult.blockId}`,
+							summaryMode: autoResult.summaryMode,
+							summarizerModelRef: autoResult.summarizerModelRef,
+							summarizerAttempts: autoResult.summarizerAttempts,
+							summaryTokens: autoResult.summaryTokens,
+							removedTokenEstimate: autoResult.removedTokenEstimate,
+							candidate,
+							clearedAnchors,
+							state: summarizeDcpState(state),
+						}, ctx)
+						return finishContext("compress.auto", prunedMessages, {
+							candidate,
+							messageCandidates,
+							contextPercent,
+							thresholds,
+							clearedAnchors,
+						})
+					} catch (error) {
+						writeDcpDebugLog(effectiveConfig, "compress.auto_failed", {
+							trigger: autoDecision.reason,
+							error: error instanceof Error ? error.message : String(error),
+							candidate,
+							state: summarizeDcpState(state),
+						}, ctx)
+						// Fall through to normal nudge emission on failure.
+					}
+				}
+			}
+
 			if (nudgeType && !manualEmergencyOnly) {
 				const nudgeText = appendConcreteNudgeGuidance(
 					baseNudgeText(nudgeType),

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

@@ -30,6 +30,8 @@ Use \`compress\` as context-pressure housekeeping, not as a reflex after every s
 
 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.
 
+Completed todo/task/subtask milestones are strong boundary signals, not automatic triggers. When context pressure makes compression useful, prefer the range covering a just-finished todo item if it is closed and non-trivial; do not compress merely because a todo was completed while context remains low.
+
 Before compressing while work is unfinished, ensure one \`todo in_progress\` captures the active objective and next step.
 
 When a \`<dcp-system-reminder>\` appears, treat it as a context-pressure signal. Follow critical/high-context reminders promptly. For routine reminders, compress only if a genuinely closed, useful-to-summarize slice exists; otherwise continue the next atomic step and re-check later.
@@ -183,6 +185,7 @@ You MUST use the \`compress\` tool now. Do not continue normal exploration until
 
 If you are in the middle of a critical atomic operation, finish that atomic step first, then compress immediately.
 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.
+Recently completed todo/task/subtask items are preferred boundaries when they form a high-yield closed slice.
 
 RANGE STRATEGY (MANDATORY)
 Prioritize one large, closed, high-yield compression range first.
@@ -210,6 +213,7 @@ ACTION REQUIRED: Context usage is high.
 Before doing more exploration, look for a high-yield closed range that no longer needs to stay raw. Compress it now if one is safe and useful.
 
 This is context-pressure guidance, not a request to compress tiny or still-needed slices. If completed research, implementation, verification, config/doc edit, CI-log inspection, or dead-end debugging is large enough to reduce signal, call the \`compress\` tool before continuing normal work.
+Recently completed todo/task/subtask items are preferred candidates when they form a non-trivial closed slice; do not compress merely because a tiny todo was completed.
 High-priority stale shell/read/repo/web outputs should be compressed once no exact raw text is needed. Passing logs should not remain raw after they are understood.
 
 RANGE SELECTION
@@ -230,6 +234,8 @@ CONTEXT CHECK: Evaluate whether compression would materially improve the live co
 
 If a range is cleanly closed, non-trivial, and unlikely to be needed verbatim again, use the \`compress\` tool. If direction has shifted, consider whether earlier ranges are now less relevant.
 
+If a todo/task/subtask was just completed, treat that completed work as a preferred compression boundary when it is large enough and no longer needed raw; completion alone is not a reason to compress while context is still low.
+
 Do not compress just because a small slice closed while context is still low. Prefer compression before another large batch of searches, reads, CI log fetches, or tests when a high-yield stale slice exists.
 High-priority stale shell/read/repo/web outputs and understood passing logs should be compressed once no exact raw text is needed.
 
@@ -247,6 +253,8 @@ CONTEXT CHECK: You've been iterating for a while after the last user message.
 
 Pause before the next large non-atomic tool batch. If there is a closed portion that is unlikely to be referenced immediately and is worth summarizing (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.
 
+If a todo/task/subtask was just completed, prefer that completed work as the compression boundary when it is non-trivial and safe to summarize; do not compress merely because the todo status changed.
+
 Avoid accumulating large tool outputs while a high-yield completed slice remains raw. If only small or still-needed ranges are closed, continue the next atomic step and re-check later.
 
 Prefer multiple short, closed ranges over one large range when several independent slices are ready.