@oh-my-pi/pi-coding-agent 15.7.3 → 15.7.6

package/src/modes/theme/theme-schema.json

@@ -404,6 +404,36 @@
 					"additionalProperties": {
 						"type": "string"
 					}
+				},
+				"spinnerFrames": {
+					"description": "Override the spinner frames. Use a flat array to set both `status` and `activity`, or an object to override each independently. Frames are advanced ~12.5fps for status spinners and ~60fps for activity spinners.",
+					"oneOf": [
+						{
+							"type": "array",
+							"minItems": 1,
+							"items": { "type": "string", "minLength": 1 }
+						},
+						{
+							"type": "object",
+							"properties": {
+								"status": {
+									"type": "array",
+									"minItems": 1,
+									"items": { "type": "string", "minLength": 1 }
+								},
+								"activity": {
+									"type": "array",
+									"minItems": 1,
+									"items": { "type": "string", "minLength": 1 }
+								}
+							},
+							"additionalProperties": false,
+							"anyOf": [
+								{ "required": ["status"] },
+								{ "required": ["activity"] }
+							]
+						}
+					]
 				}
 			},
 			"additionalProperties": false

package/src/modes/theme/theme.ts

@@ -812,6 +812,25 @@ const SPINNER_FRAMES: Record<SymbolPreset, Record<SpinnerType, string[]>> = {
 	},
 };
 
+/**
+ * Shape accepted by `themeJson.symbols.spinnerFrames`. A flat array applies to
+ * both spinner types; an object lets a theme override `status` and/or
+ * `activity` independently. Anything not specified falls back to the symbol
+ * preset's default frames.
+ */
+type SpinnerFramesOverride = string[] | { status?: string[]; activity?: string[] };
+
+function normalizeSpinnerFramesOverride(
+	value: SpinnerFramesOverride | undefined,
+): Partial<Record<SpinnerType, string[]>> {
+	if (value === undefined) return {};
+	if (Array.isArray(value)) return { status: value, activity: value };
+	const result: Partial<Record<SpinnerType, string[]>> = {};
+	if (value.status) result.status = value.status;
+	if (value.activity) result.activity = value.activity;
+	return result;
+}
+
 // ============================================================================
 // Types & Schema
 // ============================================================================
@@ -898,6 +917,19 @@ const themeColorsSchema = z.object(
 	},
 );
 
+const spinnerFramesArraySchema = z.array(z.string().min(1)).min(1);
+const spinnerFramesSchema = z.union([
+	spinnerFramesArraySchema,
+	z
+		.object({
+			status: spinnerFramesArraySchema.optional(),
+			activity: spinnerFramesArraySchema.optional(),
+		})
+		.refine(value => value.status !== undefined || value.activity !== undefined, {
+			message: "spinnerFrames object must define `status` and/or `activity`",
+		}),
+]);
+
 const symbolPresetSchema = z.enum(["unicode", "nerd", "ascii"]);
 
 const themeJsonSchema = z.object({
@@ -916,6 +948,7 @@ const themeJsonSchema = z.object({
 		.object({
 			preset: symbolPresetSchema.optional(),
 			overrides: z.record(z.string(), z.string()).optional(),
+			spinnerFrames: spinnerFramesSchema.optional(),
 		})
 		.optional(),
 });
@@ -1243,6 +1276,7 @@ export class Theme {
 	#fgColors: Record<ThemeColor, string>;
 	#bgColors: Record<ThemeBg, string>;
 	#symbols: SymbolMap;
+	#spinnerFramesOverrides: Partial<Record<SpinnerType, string[]>>;
 
 	constructor(
 		fgColors: Record<ThemeColor, string | number>,
@@ -1250,6 +1284,7 @@ export class Theme {
 		private readonly mode: ColorMode,
 		private readonly symbolPreset: SymbolPreset,
 		symbolOverrides: Partial<Record<SymbolKey, string>>,
+		spinnerFramesOverrides: Partial<Record<SpinnerType, string[]>> = {},
 	) {
 		this.#fgColors = {} as Record<ThemeColor, string>;
 		for (const [key, value] of Object.entries(fgColors) as [ThemeColor, string | number][]) {
@@ -1269,6 +1304,7 @@ export class Theme {
 				logger.debug("Invalid symbol key in override", { key, availableKeys: Object.keys(this.#symbols) });
 			}
 		}
+		this.#spinnerFramesOverrides = spinnerFramesOverrides;
 	}
 
 	fg(color: ThemeColor, text: string): string {
@@ -1563,7 +1599,7 @@ export class Theme {
 	 * Get spinner frames by type.
 	 */
 	getSpinnerFrames(type: SpinnerType = "status"): string[] {
-		return SPINNER_FRAMES[this.symbolPreset][type];
+		return this.#spinnerFramesOverrides[type] ?? SPINNER_FRAMES[this.symbolPreset][type];
 	}
 
 	/**
@@ -1735,7 +1771,8 @@ function createTheme(themeJson: ThemeJson, options: CreateThemeOptions = {}): Th
 	// Extract symbol configuration - settings override takes precedence over theme
 	const symbolPreset: SymbolPreset = symbolPresetOverride ?? themeJson.symbols?.preset ?? "unicode";
 	const symbolOverrides = themeJson.symbols?.overrides ?? {};
-	return new Theme(fgColors, bgColors, colorMode, symbolPreset, symbolOverrides);
+	const spinnerFramesOverrides = normalizeSpinnerFramesOverride(themeJson.symbols?.spinnerFrames);
+	return new Theme(fgColors, bgColors, colorMode, symbolPreset, symbolOverrides, spinnerFramesOverrides);
 }
 
 async function loadTheme(name: string, options: CreateThemeOptions = {}): Promise<Theme> {

package/src/modes/types.ts

@@ -7,6 +7,7 @@ import type { Settings } from "../config/settings";
 import type {
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
+	ExtensionUISelectItem,
 	ExtensionWidgetContent,
 	ExtensionWidgetOptions,
 } from "../extensibility/extensions";
@@ -297,7 +298,7 @@ export interface InteractiveModeContext {
 	setHookStatus(key: string, text: string | undefined): void;
 	showHookSelector(
 		title: string,
-		options: string[],
+		options: ExtensionUISelectItem[],
 		dialogOptions?: ExtensionUIDialogOptions,
 	): Promise<string | undefined>;
 	hideHookSelector(): void;

package/src/modes/utils/ui-helpers.ts

@@ -262,8 +262,11 @@ export class UiHelpers {
 				break;
 			}
 			case "assistant": {
-				const assistantComponent = new AssistantMessageComponent(message, this.ctx.hideThinkingBlock, () =>
-					this.ctx.ui.requestRender(),
+				const assistantComponent = new AssistantMessageComponent(
+					message,
+					this.ctx.hideThinkingBlock,
+					() => this.ctx.ui.requestRender(),
+					this.ctx.session.extensionRunner?.getAssistantThinkingRenderers(),
 				);
 				this.ctx.chatContainer.addChild(assistantComponent);
 				break;

package/src/prompts/system/project-prompt.md

@@ -1,4 +1,6 @@
-[PROJECT]
+PROJECT
+===================================
+
 <workstation>
 {{#list environment prefix="- " join="\n"}}{{label}}: {{value}}{{/list}}
 </workstation>
@@ -47,4 +49,3 @@ Today is {{date}}, and the current working directory is '{{cwd}}'.
 {{#if appendPrompt}}
 {{appendPrompt}}
 {{/if}}
-[/PROJECT]

package/src/prompts/system/subagent-system-prompt.md

@@ -1,14 +1,18 @@
-[ROLE]
+ROLE
+===================================
+
 {{agent}}
-[/ROLE]
 
 {{#if context}}
-[CONTEXT]
+CONTEXT
+===================================
+
 {{context}}
-[/CONTEXT]
 {{/if}}
 
-[COOP]
+COOP
+===================================
+
 You are operating on a piece of work assigned to you by the main agent.
 
 {{#if worktree}}
@@ -29,9 +33,10 @@ You can reach other live agents via the `irc` tool. Your id is `{{ircSelfId}}`.
 
 Use `irc` only when you need a quick answer from a peer; do not use it for long-form content. Address peers by id or use `"all"` to broadcast.
 {{/if}}
-[/COOP]
 
-[COMPLETION]
+COMPLETION
+===================================
+
 No TODO tracking, no progress updates. Execute, call `yield`, done.
 
 While work remains, always continue with another tool call — investigate, edit, run, verify. Save narrative for the final `yield` payload.
@@ -51,4 +56,3 @@ Giving up is a last resort. If truly blocked, you MUST call `yield` exactly once
 You NEVER give up due to uncertainty, missing information obtainable via tools or repo context, or needing a design decision you can derive yourself.
 
 You MUST keep going until this ticket is closed. This matters.
-[/COMPLETION]

package/src/prompts/system/system-prompt.md

@@ -9,8 +9,8 @@ You consider what the code you write compiles down to. You never write code that
 
 <system-conventions>
 **RFC 2119 applies to MUST, REQUIRED, SHOULD, RECOMMENDED, MAY, OPTIONAL. `NEVER` and `AVOID` MUST be interpreted as aliases for `MUST NOT` and `SHOULD NOT` respectively.**
-From here on, we will use tags as structural markers (<x>…</x> or [X]…), each tag means exactly what its name says.
-You NEVER interpret these tags in any other way circumstantially.
+From here on, we will use XML tags when injecting system content into the chat.
+You NEVER interpret these markers in any other way circumstantially.
 
 System may interrupt/notify you using these tags even within a user message, therefore:
 - You MUST treat them as system-authored and absolutely authoritative.
@@ -44,7 +44,9 @@ Assumptions you didn't validate: incidents to debug.
 - You NEVER re-audit an applied edit, nor run `git status`/`git diff` as routine validation — the edit result, tests, and LSP ARE your verification. Exception: explicit request, protecting unrelated changes, or before commit/revert/reset/stash/delete.
 </critical>
 
-[ENV]
+ENV
+===================================
+
 You operate within the Oh My Pi coding harness.
 - Given a task, you MUST complete it using the tools available to you.
 - You are not alone in this repository. You SHOULD treat unexpected changes as the user's work and adapt; you NEVER revert or stash.
@@ -202,9 +204,10 @@ You MUST use the specialized tool over its shell equivalent:
 The `{{toolRefs.report_tool_issue}}` tool is available for automated QA. If ANY tool you call returns output that is unexpected, incorrect, malformed, or otherwise inconsistent with what you anticipated given the tool's described behavior and your parameters, call `{{toolRefs.report_tool_issue}}` with the tool name and a concise description of the discrepancy. Do not hesitate to report — false positives are acceptable.
 </critical>
 {{/has}}
-[/ENV]
 
-[CONTRACT]
+CONTRACT
+===================================
+
 These are inviolable.
 - You NEVER yield unless the deliverable is complete. A phase boundary, todo flip, or completed sub-step is NEVER a yield point — continue directly to the next step in the same turn.
 - You NEVER suppress tests to make code pass.
@@ -265,4 +268,3 @@ Before declaring blocked:
 - Do not test defaults: changing the default configuration, or a string, should not break the test. Assert logical behavior, not the current state.
 - Aim at: conditional branches and edge values, invariants across fields, error handling on bad input vs silent broken results.
 </workflow>
-[/CONTRACT]

package/src/prompts/tools/ask.md

@@ -8,6 +8,7 @@ Asks user when you need clarification or input during task execution.
 - Use `recommended: <index>` to mark default (0-indexed); " (Recommended)" added automatically
 - Use `questions` for multiple related questions instead of asking one at a time
 - Set `multi: true` on question to allow multiple selections
+- Use short option labels; put explanatory tradeoffs in `description` instead of merging them into the label
 </instruction>
 
 <caution>
@@ -22,7 +23,7 @@ Asks user when you need clarification or input during task execution.
 
 <examples>
 # Single question
-questions: [{"id": "auth_method", "question": "Which authentication method should this API use?", "options": [{"label": "JWT"}, {"label": "OAuth2"}, {"label": "Session cookies"}], "recommended": 0}]
+questions: [{"id": "auth_method", "question": "Which authentication method should this API use?", "options": [{"label": "JWT", "description": "Bearer tokens for stateless API clients."}, {"label": "OAuth2", "description": "Delegated authorization with external identity providers."}, {"label": "Session cookies", "description": "Browser-first authentication backed by server-side sessions."}], "recommended": 0}]
 
 # Multiple questions
 questions: [{"id": "storage_type", "question": "Which storage backend?", "options": [{"label": "SQLite"}, {"label": "PostgreSQL"}]}, {"id": "auth_method", "question": "Which auth method?", "options": [{"label": "JWT"}, {"label": "Session cookies"}]}]

package/src/prompts/tools/eval.md

@@ -8,7 +8,7 @@ Cell fields:
 - `language` — {{#if py}}`"py"` for the IPython kernel{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}`"js"` for the persistent JavaScript VM{{/if}}.
 - `code` — cell body, verbatim. Newlines, quotes, and indentation are JSON-encoded; no fences, no headers.
 - `title` (optional) — short label shown in the transcript (e.g. `"imports"`, `"load config"`).
-- `timeout` (optional) — per-cell **inactivity** budget in seconds (1-600). Default 30. The cell is interrupted only after this long with no progress, and every status event (`agent()` updates, `log()`/`phase()`, tool activity) resets the clock — so a long `agent()`/`parallel()` fanout that keeps reporting progress is not killed. Raw `print`/stdout does not reset it; raise `timeout` for a cell that runs long without emitting status.
+- `timeout` (optional) — per-cell wall-clock budget in seconds (1-600). Default 30. It bounds the cell's **own** work, but is paused while an `agent()`/`parallel()`/`llm()` call is in flight — so a long fanout or a slow completion runs to completion, while the cell itself is still bounded. Compute, `print`/stdout, `log()`/`phase()`, and ordinary tool calls all count against the budget; raise `timeout` for a cell that does heavy local work or long non-agent tool calls.
 - `reset` (optional) — wipe this cell's language kernel before running.{{#ifAll py js}} Reset is per-language: a `py` cell's reset does not touch the JavaScript VM and vice versa.{{/ifAll}}
 
 **Work incrementally:**

package/src/session/agent-session.ts

@@ -51,11 +51,8 @@ import {
 	prepareCompaction,
 	type ShakeConfig,
 	type ShakeRegion,
-	type ShakeSummaryComplete,
-	type ShakeSummaryItem,
 	type SummaryOptions,
 	shouldCompact,
-	summarizeShakeRegions,
 } from "@oh-my-pi/pi-agent-core/compaction";
 import { DEFAULT_PRUNE_CONFIG, pruneToolOutputs } from "@oh-my-pi/pi-agent-core/compaction/pruning";
 import type {
@@ -162,6 +159,7 @@ import { containsOrchestrate, ORCHESTRATE_NOTICE } from "../modes/orchestrate";
 import { getCurrentThemeName, theme } from "../modes/theme/theme";
 import { parseTurnBudget } from "../modes/turn-budget";
 import { containsUltrathink, ULTRATHINK_NOTICE } from "../modes/ultrathink";
+import { computeNonMessageTokens } from "../modes/utils/context-usage";
 import { containsWorkflow, WORKFLOW_NOTICE } from "../modes/workflow";
 import type { PlanModeState } from "../plan-mode/state";
 import autoContinuePrompt from "../prompts/system/auto-continue.md" with { type: "text" };
@@ -185,8 +183,7 @@ import {
 	resolveThinkingLevelForModel,
 	toReasoningEffort,
 } from "../thinking";
-import { isTinyMemoryLocalModelKey } from "../tiny/models";
-import { shutdownTinyTitleClient, tinyModelClient } from "../tiny/title-client";
+import { shutdownTinyTitleClient } from "../tiny/title-client";
 import {
 	buildDiscoverableToolSearchIndex,
 	collectDiscoverableTools,
@@ -241,11 +238,11 @@ export type AgentSessionEvent =
 	| {
 			type: "auto_compaction_start";
 			reason: "threshold" | "overflow" | "idle" | "incomplete";
-			action: "context-full" | "handoff" | "shake" | "shake-summary";
+			action: "context-full" | "handoff" | "shake";
 	  }
 	| {
 			type: "auto_compaction_end";
-			action: "context-full" | "handoff" | "shake" | "shake-summary";
+			action: "context-full" | "handoff" | "shake";
 			result: CompactionResult | undefined;
 			aborted: boolean;
 			willRetry: boolean;
@@ -3621,8 +3618,13 @@ export class AgentSession {
 	/**
 	 * Replace MCP tools in the registry and recompute the visible MCP tool set immediately.
 	 * This allows /mcp add/remove/reauth to take effect without restarting the session.
+	 *
+	 * @param mcpTools The new MCP tools to register.
+	 * @param options.activateAll When true, force-activates every newly registered MCP tool
+	 *   regardless of prior selection state. Used when an ACP client provisions MCP servers
+	 *   for a session where MCP discovery is disabled.
 	 */
-	async refreshMCPTools(mcpTools: CustomTool[]): Promise<void> {
+	async refreshMCPTools(mcpTools: CustomTool[], options?: { activateAll?: boolean }): Promise<void> {
 		const previousSelectedMCPToolNames = this.getSelectedMCPToolNames();
 		const existingNames = Array.from(this.#toolRegistry.keys());
 		for (const name of existingNames) {
@@ -3663,6 +3665,18 @@ export class AgentSession {
 			this.#getConfiguredDefaultSelectedMCPToolNames(),
 		);
 
+		if (options?.activateAll) {
+			// Force-activate every newly registered MCP tool. This path is used
+			// when an ACP client provisions MCP servers for a session where MCP
+			// discovery is disabled — without it, getSelectedMCPToolNames()
+			// returns only already-active tools (circular deadlock: tools can
+			// only become active if they're already active).
+			const newMcpNames = mcpTools.map(t => t.name);
+			const nextActive = [...new Set([...this.#getActiveNonMCPToolNames(), ...newMcpNames])];
+			await this.#applyActiveToolsByName(nextActive, { previousSelectedMCPToolNames });
+			return;
+		}
+
 		const nextActive = [...this.#getActiveNonMCPToolNames(), ...this.getSelectedMCPToolNames()];
 		await this.#applyActiveToolsByName(nextActive, { previousSelectedMCPToolNames });
 	}
@@ -4283,7 +4297,7 @@ export class AgentSession {
 			// next microtask alongside the new turn.
 			const lastAssistant = this.#findLastAssistantMessage();
 			if (lastAssistant && !options?.skipCompactionCheck) {
-				await this.#checkCompaction(lastAssistant, false, false);
+				await this.#checkCompaction(lastAssistant, false, false, false);
 			}
 
 			// Build messages array (session context, eager todo prelude, then active prompt message)
@@ -4385,6 +4399,11 @@ export class AgentSession {
 				}
 			}
 
+			await this.#runPrePromptCompactionIfNeeded(messages);
+			if (this.#promptGeneration !== generation) {
+				return;
+			}
+
 			const agentPromptOptions = options?.toolChoice ? { toolChoice: options.toolChoice } : undefined;
 			await this.#promptAgentWithIdleRetry(messages, agentPromptOptions);
 			if (!options?.skipPostPromptRecoveryWait) {
@@ -5659,10 +5678,6 @@ export class AgentSession {
 	 * - `images` delegates to {@link dropImages}.
 	 * - `elide` replaces whole tool-call results and large fenced/XML blocks
 	 *   with short placeholders that embed an `artifact://` recovery link.
-	 * - `summary` extractively compresses the same regions with the configured
-	 *   local on-device model (`providers.shakeSummaryModel`), falling back to
-	 *   the elide placeholder per region (or wholesale when the local model is
-	 *   unavailable). Never calls a remote/cloud LLM.
 	 *
 	 * Mutates the branch in place, persists via `rewriteEntries`, replays the
 	 * rebuilt context through the agent, and tears down provider sessions that
@@ -5683,29 +5698,7 @@ export class AgentSession {
 		}
 
 		const artifactId = await this.#saveShakeArtifact(regions);
-		let replacements: string[];
-		if (mode === "summary") {
-			// Manual `/shake summary` installs the compaction controller so Esc /
-			// `abortCompaction()` can cancel the local-model pass; the auto-shake path
-			// passes its own signal and manages `#autoCompactionAbortController`.
-			let controller: AbortController | undefined;
-			let signal = opts.signal;
-			if (!signal) {
-				if (this.#compactionAbortController) throw new Error("Compaction already in progress");
-				controller = new AbortController();
-				this.#compactionAbortController = controller;
-				signal = controller.signal;
-			}
-			try {
-				replacements = await this.#buildShakeSummaryReplacements(regions, artifactId, signal);
-			} finally {
-				if (controller && this.#compactionAbortController === controller) {
-					this.#compactionAbortController = undefined;
-				}
-			}
-		} else {
-			replacements = regions.map((region, index) => this.#shakeElidePlaceholder(region, index, artifactId));
-		}
+		const replacements = regions.map((region, index) => this.#shakeElidePlaceholder(region, index, artifactId));
 
 		let toolResultsDropped = 0;
 		let blocksDropped = 0;
@@ -5762,56 +5755,6 @@ export class AgentSession {
 		}
 	}
 
-	/**
-	 * Build per-region replacements for summary mode using the configured local
-	 * on-device model (`providers.shakeSummaryModel`) via {@link tinyModelClient}.
-	 * Shake summary never calls a remote/cloud LLM. When the configured model is
-	 * not a known local key, every region falls back to the elide placeholder.
-	 * Otherwise compresses via {@link summarizeShakeRegions}; per region, uses
-	 * the parsed summary (with a recovery footer) or the elide placeholder when
-	 * the local model omitted it / was unavailable. Any thrown failure degrades
-	 * the whole batch to elide so the reduction still happens.
-	 */
-	async #buildShakeSummaryReplacements(
-		regions: ShakeRegion[],
-		artifactId: string | undefined,
-		signal: AbortSignal | undefined,
-	): Promise<string[]> {
-		const elide = (): string[] =>
-			regions.map((region, index) => this.#shakeElidePlaceholder(region, index, artifactId));
-
-		const modelKey = this.settings.get("providers.shakeSummaryModel");
-		if (!isTinyMemoryLocalModelKey(modelKey)) return elide();
-
-		const items: ShakeSummaryItem[] = regions.map((region, index) => ({
-			index,
-			label: region.label,
-			text: region.originalText,
-		}));
-
-		const complete: ShakeSummaryComplete = (promptText, opts) =>
-			tinyModelClient.complete(modelKey, promptText, { maxTokens: opts.maxTokens, signal: opts.signal });
-
-		let summaries: Map<number, string>;
-		try {
-			summaries = await summarizeShakeRegions(items, complete, { signal });
-		} catch (error) {
-			logger.warn("Shake summary compression failed; falling back to elide", {
-				error: error instanceof Error ? error.message : String(error),
-			});
-			return elide();
-		}
-
-		return regions.map((region, index) => {
-			const summary = summaries.get(index);
-			if (!summary) return this.#shakeElidePlaceholder(region, index, artifactId);
-			if (artifactId) {
-				return `${summary}\n\n[recover full: artifact://${artifactId} (region ${index + 1})]`;
-			}
-			return summary;
-		});
-	}
-
 	/**
 	 * Manually compact the session context.
 	 * Aborts current agent operation first.
@@ -6171,6 +6114,34 @@ export class AgentSession {
 		}
 	}
 
+	#estimatePendingPromptTokens(messages: AgentMessage[]): number {
+		let tokens = computeNonMessageTokens(this);
+		for (const message of this.messages) {
+			tokens += estimateTokens(message);
+		}
+		for (const message of messages) {
+			tokens += estimateTokens(message);
+		}
+		return tokens;
+	}
+
+	async #runPrePromptCompactionIfNeeded(messages: AgentMessage[]): Promise<void> {
+		const model = this.model;
+		if (!model) return;
+		const contextWindow = model.contextWindow ?? 0;
+		if (contextWindow <= 0) return;
+		const compactionSettings = this.settings.getGroup("compaction");
+		const contextTokens = this.#estimatePendingPromptTokens(messages);
+		if (!shouldCompact(contextTokens, contextWindow, compactionSettings)) return;
+
+		logger.debug("Pre-prompt context maintenance triggered by pending prompt size", {
+			contextTokens,
+			contextWindow,
+			model: `${model.provider}/${model.id}`,
+		});
+		await this.#runAutoCompaction("threshold", false, false, false, { autoContinue: false });
+	}
+
 	/**
 	 * Check if context maintenance or promotion is needed and run it.
 	 * Called after agent_end and before prompt submission.
@@ -6191,6 +6162,7 @@ export class AgentSession {
 	 *   `agent_end` handler set this to true so `session.prompt()` resolves cleanly; callers
 	 *   on the pre-prompt path (where the next agent turn is about to start) set it to false
 	 *   to avoid racing the deferred handoff against the new turn.
+	 * @param autoContinue Whether maintenance may schedule the agent-authored continuation prompt.
 	 * @returns true when a deferred handoff was scheduled. Callers MUST then skip any
 	 *   subsequent `#scheduleAgentContinue` / reminder appends for this turn — the
 	 *   handoff will replace session state and a concurrent `agent.continue()` would
@@ -6200,6 +6172,7 @@ export class AgentSession {
 		assistantMessage: AssistantMessage,
 		skipAbortedCheck = true,
 		allowDefer = true,
+		autoContinue = true,
 	): Promise<boolean> {
 		// Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
 		if (skipAbortedCheck && assistantMessage.stopReason === "aborted") return false;
@@ -6237,7 +6210,7 @@ export class AgentSession {
 			// No promotion target available fall through to compaction
 			const compactionSettings = this.settings.getGroup("compaction");
 			if (compactionSettings.enabled && compactionSettings.strategy !== "off") {
-				await this.#runAutoCompaction("overflow", true, false, allowDefer);
+				await this.#runAutoCompaction("overflow", true, false, allowDefer, { autoContinue });
 			}
 			return false;
 		}
@@ -6269,7 +6242,7 @@ export class AgentSession {
 					model: `${assistantMessage.provider}/${assistantMessage.model}`,
 					strategy: incompleteCompactionSettings.strategy,
 				});
-				await this.#runAutoCompaction("incomplete", true, false, allowDefer);
+				await this.#runAutoCompaction("incomplete", true, false, allowDefer, { autoContinue });
 			} else {
 				// Neither promotion nor compaction is available — surface the dead-end so
 				// the user understands why the turn yielded with nothing.
@@ -6295,7 +6268,7 @@ export class AgentSession {
 			// Try promotion first — if a larger model is available, switch instead of compacting
 			const promoted = await this.#tryContextPromotion(assistantMessage);
 			if (!promoted) {
-				return await this.#runAutoCompaction("threshold", false, false, allowDefer);
+				return await this.#runAutoCompaction("threshold", false, false, allowDefer, { autoContinue });
 			}
 		}
 		return false;
@@ -7019,17 +6992,18 @@ export class AgentSession {
 		willRetry: boolean,
 		deferred = false,
 		allowDefer = true,
+		options: { autoContinue?: boolean } = {},
 	): Promise<boolean> {
 		const compactionSettings = this.settings.getGroup("compaction");
 		if (compactionSettings.strategy === "off") return false;
 		if (reason !== "idle" && !compactionSettings.enabled) return false;
 		const generation = this.#promptGeneration;
-
-		// Shake strategies run inline (cheap, no remote LLM). On overflow recovery,
-		// if shake reclaims nothing we fall through to the summary-compaction body
-		// below so the oversized input still gets resolved.
-		if (compactionSettings.strategy === "shake" || compactionSettings.strategy === "shake-summary") {
-			const outcome = await this.#runAutoShake(reason, compactionSettings.strategy, willRetry, generation);
+		const shouldAutoContinue = options.autoContinue !== false && compactionSettings.autoContinue !== false;
+		// Shake runs inline (cheap, no remote LLM). On overflow recovery, if shake
+		// reclaims nothing we fall through to the summary-compaction body below so
+		// the oversized input still gets resolved.
+		if (compactionSettings.strategy === "shake") {
+			const outcome = await this.#runAutoShake(reason, willRetry, generation, shouldAutoContinue);
 			if (outcome !== "fallback") return false;
 		}
 		// "overflow" and "incomplete" force inline execution because they are recovery
@@ -7098,7 +7072,7 @@ export class AgentSession {
 						aborted: false,
 						willRetry: false,
 					});
-					if (!autoCompactionSignal.aborted && reason !== "idle" && compactionSettings.autoContinue !== false) {
+					if (!autoCompactionSignal.aborted && reason !== "idle" && shouldAutoContinue) {
 						this.#scheduleAutoContinuePrompt(generation);
 					}
 					return false;
@@ -7350,7 +7324,7 @@ export class AgentSession {
 			};
 			await this.#emitSessionEvent({ type: "auto_compaction_end", action, result, aborted: false, willRetry });
 
-			if (!willRetry && reason !== "idle" && compactionSettings.autoContinue !== false) {
+			if (!willRetry && reason !== "idle" && shouldAutoContinue) {
 				this.#scheduleAutoContinuePrompt(generation);
 			}
 
@@ -7426,20 +7400,18 @@ export class AgentSession {
 	 */
 	async #runAutoShake(
 		reason: "overflow" | "threshold" | "idle" | "incomplete",
-		strategy: "shake" | "shake-summary",
 		willRetry: boolean,
 		generation: number,
+		autoContinue: boolean,
 	): Promise<"handled" | "fallback"> {
-		const action = strategy === "shake-summary" ? "shake-summary" : "shake";
-		const mode = strategy === "shake-summary" ? "summary" : "elide";
+		const action = "shake";
 		await this.#emitSessionEvent({ type: "auto_compaction_start", reason, action });
 		this.#autoCompactionAbortController?.abort();
 		const controller = new AbortController();
 		this.#autoCompactionAbortController = controller;
 		const signal = controller.signal;
-		const compactionSettings = this.settings.getGroup("compaction");
 		try {
-			const result = await this.shake(mode, { config: DEFAULT_SHAKE_CONFIG, signal });
+			const result = await this.shake("elide", { config: DEFAULT_SHAKE_CONFIG, signal });
 			if (signal.aborted) {
 				await this.#emitSessionEvent({
 					type: "auto_compaction_end",
@@ -7473,7 +7445,7 @@ export class AgentSession {
 				skipped: !reclaimed,
 			});
 
-			if (!willRetry && reason !== "idle" && compactionSettings.autoContinue !== false) {
+			if (!willRetry && reason !== "idle" && autoContinue) {
 				this.#scheduleAutoContinuePrompt(generation);
 			}
 			if (willRetry) {

package/src/session/shake-types.ts

@@ -6,14 +6,14 @@
  */
 
 /** Mode selector for `AgentSession.shake`. */
-export type ShakeMode = "elide" | "summary" | "images";
+export type ShakeMode = "elide" | "images";
 
 /** Outcome of an `AgentSession.shake` run. */
 export interface ShakeResult {
 	mode: ShakeMode;
-	/** Whole tool-call results dropped/compressed. */
+	/** Whole tool-call results dropped. */
 	toolResultsDropped: number;
-	/** Large fenced/XML blocks dropped/compressed. */
+	/** Large fenced/XML blocks dropped. */
 	blocksDropped: number;
 	/** Image blocks removed (images mode only). */
 	imagesDropped?: number;
@@ -39,6 +39,5 @@ export function formatShakeSummary(result: ShakeResult): string {
 		parts.push(`${result.blocksDropped} block${result.blocksDropped === 1 ? "" : "s"}`);
 	}
 	if (parts.length === 0) return "Nothing to shake.";
-	const verb = result.mode === "summary" ? "Compressed" : "Shook";
-	return `${verb} ${parts.join(" + ")} (~${result.tokensFreed} tokens freed).`;
+	return `Shook ${parts.join(" + ")} (~${result.tokensFreed} tokens freed).`;
 }