pi-ui-extend 0.1.38 → 0.1.41

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

@@ -351,7 +351,7 @@ function visionCapabilityPrompt(event: unknown, ctx: unknown): string | undefine
 		: "The current parent model cannot inspect images/screenshots directly.";
 	const delegation = subagentsAvailable
 		? visionSubagentDelegationText(bridge?.attachments ?? [])
-		: "If visual understanding is required, ask the user to switch to a vision-capable model or provide a path that can be inspected by a vision-capable helper.";
+		: "If visual understanding is required, use the lookup tool if available; otherwise ask the user to switch to a vision-capable model or provide an inspectable image path.";
 	const bridgeWarning = visionBridgeWarning(bridge);
 	return [
 		"Vision capability constraint:",
@@ -360,8 +360,8 @@ function visionCapabilityPrompt(event: unknown, ctx: unknown): string | undefine
 		bridgeWarning,
 		delegation,
 		bridge?.attachments.length
-			? "Use those bridged paths exactly as imagePaths if delegating."
-			: "If an image only arrived as an attachment and no local file path/reference is available to subagents, ask the user for a file path or to switch the parent model to one with image input support.",
+		? "Use those bridged paths exactly as lookup imagePaths if needed."
+		: "If an image only arrived as an attachment and no local file path/reference is available to lookup, ask the user for a file path or to switch the parent model to one with image input support.",
 	].filter(Boolean).join(" ");
 }
 
@@ -380,16 +380,16 @@ function visionCapableParentPrompt(event: unknown): string | undefined {
 		"Vision capability note:",
 		"The current parent model supports image input.",
 		"If the user provided image attachments or local image file paths, inspect them directly first; for local paths, use the read tool on the image path.",
-		"Do not delegate to a vision sub-agent solely to gain visual access; use a vision sub-agent only when the user explicitly asks to delegate/parallelize or a separate visual review is useful.",
+		"Do not delegate solely to gain visual access; use lookup for focused visual checks and subagents only for broader independent tracks.",
 	].join(" ");
 }
 
 function visionSubagentDelegationText(attachments: BridgedImageAttachment[]): string {
 	if (attachments.length === 0) {
-		return "If visual understanding is required, delegate to the subagents tool with subagentType='vision' plus imagePaths/focus when the image is available as a local file path.";
+		return "If visual understanding is required, use the lookup tool with imagePaths/focus when the image is available as a local file path.";
 	}
 	const imagePaths = attachments.map((attachment) => attachment.relativePath);
-	return `Attached images were saved for vision delegation. If visual understanding is required, delegate to the subagents tool with subagentType='vision' and imagePaths=${JSON.stringify(imagePaths)} plus a focused task/focus.`;
+	return `Attached images were saved for lookup. If visual understanding is required, call lookup with imagePaths=${JSON.stringify(imagePaths)} and a focused question.`;
 }
 
 function visionBridgeWarning(bridge: BridgeImageAttachmentsResult | undefined): string | undefined {

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

@@ -12,7 +12,7 @@ export type {
 } from "./core/types.js";
 
 export { createRunDir, getRunRoot, resolveRunDir, validateBasename } from "./core/paths.js";
-export type { CopySubagentConfigSampleResult, ResolvedAgentTaskConfig, ResolvedSubagentRoutingConfig, ResolveAgentTaskOptions, SubagentConfig, SubagentPreset, SubagentRoutingConfig, SubagentTypeConfig, SubagentVisionConfig } from "./core/config.js";
+export type { CopySubagentConfigSampleResult, ModelByParentEntry, ResolvedAgentTaskConfig, ResolvedSubagentRoutingConfig, ResolveAgentTaskOptions, SubagentConfig, SubagentPreset, SubagentRoutingConfig, SubagentTypeConfig, SubagentVisionConfig } from "./core/config.js";
 export {
 	configFiles,
 	copySubagentConfigSample,

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

@@ -167,12 +167,12 @@ const AgentTaskSchema = Type.Object({
 	id: Type.Optional(Type.String({ description: "Short identifier for this agent (used as directory name). If omitted, the spawn action assigns agent-1, agent-2, etc." })),
 	task: Type.String({ description: "Focused task description for the sub-agent" }),
 	scope: Type.Optional(Type.String({ description: "Relevant files/areas for this task" })),
-	subagentType: Type.Optional(Type.String({ description: "Logical sub-agent type/profile from config. Usually omit this so the router selects from the current config; set only for an explicit user-requested role, vision/image handling, deterministic tests, or another concrete override." })),
+	subagentType: Type.Optional(Type.String({ description: "Logical sub-agent type/profile from config. Usually omit this so the router selects from the current config; set only for an explicit user-requested role, deterministic tests, or another concrete override." })),
 	model: Type.Optional(Type.String({ description: "Explicit model override for this sub-agent. Prefer subagentType for reusable routing." })),
 	thinking: Type.Optional(Type.String({ description: "Per-agent thinking level override (off, minimal, low, medium, high, xhigh)." })),
 	promptAppend: Type.Optional(Type.String({ description: "Extra prompt instructions appended after the generated/type prompt." })),
 	promptOverride: Type.Optional(Type.String({ description: "Full prompt replacement for this sub-agent. Prefer configuring this per subagentType." })),
-	focus: Type.Optional(Type.String({ description: "For vision sub-agents: what to pay special attention to while inspecting attached images." })),
+	focus: Type.Optional(Type.String({ description: "Optional focus/attention instructions for attached images or scoped inspection." })),
 	attention: Type.Optional(Type.String({ description: "Alias for focus, accepted for compatibility." })),
 	imagePaths: Type.Optional(Type.Array(Type.String(), { description: "Local image paths to attach to this sub-agent prompt (jpg, png, gif, or webp). Relative paths resolve from cwd." })),
 	tools: Type.Optional(Type.Array(Type.String(), { description: "Tool names to enable (e.g. ['read','grep','bash'])" })),
@@ -237,12 +237,14 @@ export function registerSpawnTool(
 			}
 			const routed = await routeSubagentTasks(normalized.tasks ?? [], config, ctx as any, signal ?? undefined);
 			const timeoutMs = timeoutMsFromSeconds(params.timeoutSeconds);
+			const parentModel = currentModelRef((ctx as { model?: unknown }).model);
 			const resolvedTasks = routed.tasks.map((task) => applySessionModelFallback(
 				resolveAgentTaskConfig(task, config, {
 					preset: activePreset,
 					thinking: params.thinking,
 					extraArgs: Array.isArray(params.extraArgs) ? params.extraArgs : [],
 					forcedModel,
+					parentModel,
 					timeoutMs,
 				}),
 			));

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

@@ -19,12 +19,12 @@ const AgentTaskSchema = Type.Object({
 	id: Type.Optional(Type.String({ description: "Short identifier for this agent (used as directory name). If omitted, assigns agent-1, agent-2, etc." })),
 	task: Type.String({ description: "Focused task description for the sub-agent" }),
 	scope: Type.Optional(Type.String({ description: "Relevant files/areas for this task" })),
-	subagentType: Type.Optional(Type.String({ description: "Logical sub-agent type/profile from config. Usually omit this so the router selects from the current config; set only for an explicit user-requested role, vision/image handling, deterministic tests, or another concrete override." })),
+	subagentType: Type.Optional(Type.String({ description: "Logical sub-agent type/profile from config. Usually omit this so the router selects from the current config; set only for an explicit user-requested role, deterministic tests, or another concrete override." })),
 	model: Type.Optional(Type.String({ description: "Explicit model override for this sub-agent. Prefer subagentType for reusable routing." })),
 	thinking: Type.Optional(Type.String({ description: "Per-agent thinking level override (off, minimal, low, medium, high, xhigh)." })),
 	promptAppend: Type.Optional(Type.String({ description: "Extra prompt instructions appended after the generated/type prompt." })),
 	promptOverride: Type.Optional(Type.String({ description: "Full prompt replacement for this sub-agent. Prefer configuring this per subagentType." })),
-	focus: Type.Optional(Type.String({ description: "For vision sub-agents: what to pay special attention to while inspecting attached images." })),
+	focus: Type.Optional(Type.String({ description: "Optional focus/attention instructions for attached images or scoped inspection." })),
 	attention: Type.Optional(Type.String({ description: "Alias for focus, accepted for compatibility." })),
 	imagePaths: Type.Optional(Type.Array(Type.String(), { description: "Local image paths to attach to this sub-agent prompt (jpg, png, gif, or webp). Relative paths resolve from cwd." })),
 	tools: Type.Optional(Type.Array(Type.String(), { description: "Tool names to enable (e.g. ['read','grep','bash'])" })),

package/external/pi-tools-suite/src/{glm-coding-discipline → coding-discipline}/index.ts

@@ -59,7 +59,7 @@ const LOOKUP_TOOL_PARAMS = Type.Object(
 );
 
 const QUALITY_DISCIPLINE_LINES = [
-	"GLM TOOL-ONLY CODING AGENT CONTRACT.",
+	"TOOL-ONLY CODING AGENT CONTRACT.",
 	"",
 	"This contract controls the assistant output channel. Follow it literally.",
 	"Treat every user coding request as a tool-driven task, not a chat conversation.",
@@ -126,9 +126,14 @@ const QUALITY_DISCIPLINE_LINES = [
 	"While WORKING, this behavior is internal and expressed only through tool choices, not prose.",
 	"",
 	"Maintain these invariants:",
-	"- preserve existing behavior unless the user asked to change it;",
-	"- make minimal, localized changes;",
-	"- respect project conventions already present in nearby code;",
+	"- make the smallest correct change;",
+	"- keep diffs local; no unrelated refactors, renames, moves, reformatting, or dependency changes;",
+	"- inspect code before editing; do not invent APIs, files, commands, or behavior;",
+	"- before non-trivial edits, know the verification path;",
+	"- for bugs, prefer a failing test or repro first; then make the minimal fix; then verify;",
+	"- high-risk changes need a short spec before coding: goal, scope, behavior, risks, verification;",
+	"- high-risk includes security, privacy, auth/authz, data/schema/migrations, public APIs, external integrations, payments, jobs, concurrency, and irreversible or cross-cutting changes;",
+	"- follow nearby conventions; preserve existing behavior unless explicitly changing it;",
 	"- handle edge cases, errors, cancellation, and async behavior;",
 	"- avoid blocking UI/event loops;",
 	"- avoid duplicate state, duplicate prompts, and repeated side effects.",
@@ -147,6 +152,9 @@ const FINAL_DISCIPLINE_LINES = [
 	"",
 	"When uncertain, test or inspect instead of assuming.",
 	"If blocked by missing required information, ask exactly one concise question.",
+	"Verify every non-trivial change. Never claim tests passed unless they were actually run.",
+	"Report: what changed, what was verified, what was not verified, and any risks.",
+	"Ask at most one blocking question; otherwise proceed with grounded best effort.",
 ];
 
 const SILENCE_REMINDER_TEXT = [
@@ -175,7 +183,7 @@ const LOOKUP_SYSTEM_PROMPT = [
 	"Return concise factual observations and practical implications for the parent agent.",
 ].join("\n");
 
-export default function glmCodingDiscipline(pi: ExtensionAPI) {
+export default function codingDiscipline(pi: ExtensionAPI) {
 	let selectedModelRef: string | undefined;
 	let lookupRegistered = false;
 	let silenceViolationCount = 0;
@@ -226,8 +234,9 @@ export default function glmCodingDiscipline(pi: ExtensionAPI) {
 
 	pi.on("before_provider_request", async (event: { payload?: unknown }, ctx: unknown) => {
 		const modelRef = modelRefFromPayload(event.payload) ?? selectedModelRef ?? modelRefFromContext(ctx);
-		if (!isGlmModel(modelRef)) return undefined;
-		return injectCodingDisciplineIntoPayload(event.payload, { lookupEnabled: Boolean(lookupModelFromConfig(contextCwd(ctx))) });
+		return injectCodingDisciplineIntoPayload(event.payload, {
+			lookupEnabled: isGlmModel(modelRef) && Boolean(lookupModelFromConfig(contextCwd(ctx))),
+		});
 	});
 
 	pi.on("context", async (event: { messages?: unknown[] }, ctx: unknown) => {
@@ -454,7 +463,7 @@ function createSilenceReminderMessage() {
 }
 
 function lookupModelFromConfig(cwd?: string): string | undefined {
-	return loadPiToolsSuiteConfig(["glm-coding-discipline"], { cwd: cwd ?? process.cwd() }).lookupModel;
+	return loadPiToolsSuiteConfig(["coding-discipline"], { cwd: cwd ?? process.cwd() }).lookupModel;
 }
 
 function buildLookupPrompt(params: LookupParams, recentContext: string, imageCount: number, warnings: string[]): string {

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: {