@oh-my-pi/pi-coding-agent 15.11.8 → 15.12.1

package/src/modes/controllers/selector-controller.ts

@@ -841,19 +841,6 @@ export class SelectorController {
 		});
 	}
 
-	#clearTransientSessionUi(): void {
-		if (this.ctx.loadingAnimation) {
-			this.ctx.loadingAnimation.stop();
-			this.ctx.loadingAnimation = undefined;
-		}
-		this.ctx.statusContainer.clear();
-		this.ctx.pendingMessagesContainer.clear();
-		this.ctx.compactionQueuedMessages = [];
-		this.ctx.streamingComponent = undefined;
-		this.ctx.streamingMessage = undefined;
-		this.ctx.pendingTools.clear();
-	}
-
 	#refreshSessionTerminalTitle(): void {
 		const sessionManager = this.ctx.sessionManager as {
 			getSessionName?: () => string | undefined;
@@ -875,7 +862,7 @@ export class SelectorController {
 		}
 		this.#refreshSessionTerminalTitle();
 
-		this.#clearTransientSessionUi();
+		this.ctx.clearTransientSessionUi();
 		this.ctx.statusLine.invalidate();
 		this.ctx.statusLine.setSessionStartTime(Date.now());
 		this.ctx.updateEditorTopBorder();
@@ -887,7 +874,7 @@ export class SelectorController {
 	}
 
 	async handleResumeSession(sessionPath: string): Promise<void> {
-		this.#clearTransientSessionUi();
+		this.ctx.clearTransientSessionUi();
 
 		const previousCwd = this.ctx.sessionManager.getCwd();
 		// Switch session via AgentSession (emits hook and tool session events). The
@@ -1180,16 +1167,25 @@ export class SelectorController {
 		const done = () => {
 			hub?.dispose();
 			overlayHandle?.hide();
+			this.ctx.ui.setFocus(this.ctx.editor);
 			this.ctx.ui.requestRender();
 		};
 
 		hub = new AgentHubOverlayComponent({
 			observers,
 			hubKeys,
+			expandKeys: this.ctx.keybindings.getKeys("app.tools.expand"),
 			onDone: done,
 			requestRender: () => this.ctx.ui.requestRender(),
 			registry: this.ctx.collabGuest?.agentRegistry,
 			remote: this.ctx.collabGuest?.hubRemote,
+			ui: this.ctx.ui,
+			getTool: name => this.ctx.session.getToolByName(name),
+			getMessageRenderer: type => this.ctx.session.extensionRunner?.getMessageRenderer(type),
+			cwd: this.ctx.sessionManager.getCwd(),
+			hideThinkingBlock: () => this.ctx.hideThinkingBlock,
+			focusAgent: id => this.ctx.focusAgentSession(id),
+			sessionFile: this.ctx.sessionManager.getSessionFile() ?? null,
 		});
 
 		overlayHandle = this.ctx.ui.showOverlay(hub, {

package/src/modes/controllers/session-focus-controller.ts

@@ -0,0 +1,112 @@
+/**
+ * SessionFocusController - Weak retargeting primitive between the rendering/
+ * input layer and the AgentSession it displays.
+ *
+ * Focusing re-points the transcript, streaming event subscription, status
+ * line, and editor prompt/interrupt at a subagent's live AgentSession (from
+ * AgentRegistry) without touching the main session underneath; unfocusing
+ * re-attaches the main session and rebuilds the transcript from its
+ * authoritative state.
+ */
+
+import { AgentLifecycleManager } from "../../registry/agent-lifecycle";
+import { AgentRegistry, MAIN_AGENT_ID, type RegistryEvent } from "../../registry/agent-registry";
+import type { AgentSession } from "../../session/agent-session";
+import type { InteractiveModeContext } from "../types";
+
+export class SessionFocusController {
+	#focusedAgentId: string | undefined;
+	/** Session currently attached while focused; undefined when unfocused. */
+	#attachedSession: AgentSession | undefined;
+	#registryUnsubscribe: (() => void) | undefined;
+
+	constructor(
+		private ctx: InteractiveModeContext,
+		private registry: AgentRegistry = AgentRegistry.global(),
+		private lifecycle: () => AgentLifecycleManager = () => AgentLifecycleManager.global(),
+	) {}
+
+	get focusedAgentId(): string | undefined {
+		return this.#focusedAgentId;
+	}
+
+	/** Focused live session, undefined when unfocused. */
+	get target(): AgentSession | undefined {
+		return this.#attachedSession;
+	}
+
+	/** Focus the main view on an agent's live session. Throws an Error with a user-displayable message. */
+	async focusAgent(id: string): Promise<void> {
+		if (this.ctx.collabGuest) throw new Error("Viewing agents is unavailable in a collab session.");
+		if (id === MAIN_AGENT_ID) return this.unfocus();
+		const session = await this.lifecycle().ensureLive(id);
+		if (id === this.#focusedAgentId && session === this.#attachedSession) return;
+		this.#focusedAgentId = id;
+		this.#attachedSession = session;
+		this.#registryUnsubscribe ??= this.registry.onChange(e => this.#onRegistryEvent(e));
+		await this.#attach(session);
+		this.ctx.showStatus(`Viewing agent ${id} — Esc returns to main, ←← hops to parent`);
+	}
+
+	/** Focus the focused agent's parent agent, falling back to the main session. No-op when unfocused. */
+	async focusParent(): Promise<void> {
+		if (!this.#focusedAgentId) return;
+		const parentId = this.registry.get(this.#focusedAgentId)?.parentId;
+		if (parentId && parentId !== MAIN_AGENT_ID && this.registry.get(parentId)) {
+			return this.focusAgent(parentId);
+		}
+		return this.unfocus();
+	}
+
+	/** Return to the main session. No-op when unfocused. */
+	async unfocus(): Promise<void> {
+		if (!this.#focusedAgentId) return;
+		this.#focusedAgentId = undefined;
+		this.#attachedSession = undefined;
+		await this.#attach(this.ctx.session);
+		this.ctx.showStatus("Returned to main session");
+	}
+
+	dispose(): void {
+		this.#registryUnsubscribe?.();
+		this.#registryUnsubscribe = undefined;
+	}
+
+	#onRegistryEvent(event: RegistryEvent): void {
+		if (event.ref.id !== this.#focusedAgentId) return;
+		const gone = event.type === "removed";
+		const dead = event.type === "status_changed" && (event.ref.status === "parked" || event.ref.status === "aborted");
+		if (!gone && !dead) return;
+		void this.unfocus().then(() => {
+			this.ctx.showStatus(`Agent ${event.ref.id} is ${gone ? "gone" : event.ref.status}; returned to main session`);
+		});
+	}
+
+	/** Retarget core, both directions: swap subscription, transcript, and status line onto `target`. */
+	async #attach(target: AgentSession): Promise<void> {
+		this.ctx.unsubscribe?.();
+		this.ctx.clearTransientSessionUi();
+		this.ctx.eventController.resetTranscriptAnchors();
+		// Orphan-delta guard: when attaching mid-turn the message_start for the
+		// in-flight assistant message predates the attach. message_update carries
+		// the full accumulating message, so synthesize the missing start before
+		// the first orphaned update; every other handler is tolerant of unknown
+		// anchors (guarded by streamingComponent/pendingTools lookups).
+		let assistantStreamSynced = false;
+		this.ctx.unsubscribe = target.subscribe(async event => {
+			if (event.type === "message_start" && event.message.role === "assistant") {
+				assistantStreamSynced = true;
+			} else if (event.type === "message_update" && event.message.role === "assistant" && !assistantStreamSynced) {
+				assistantStreamSynced = true;
+				await this.ctx.eventController.handleEvent({ type: "message_start", message: event.message });
+			}
+			await this.ctx.eventController.handleEvent(event);
+		});
+		this.ctx.statusLine.setSession(target, this.#focusedAgentId);
+		this.ctx.renderInitialMessages({ clearTerminalHistory: true });
+		// Mid-turn attach: no agent_start will arrive; arm the loader/turn state manually.
+		if (target.isStreaming) await this.ctx.eventController.handleEvent({ type: "agent_start" });
+		this.ctx.updateEditorBorderColor();
+		this.ctx.ui.requestRender();
+	}
+}

package/src/modes/interactive-mode.ts

@@ -122,6 +122,7 @@ import { InputController } from "./controllers/input-controller";
 import { MCPCommandController } from "./controllers/mcp-command-controller";
 import { OmfgController } from "./controllers/omfg-controller";
 import { SelectorController } from "./controllers/selector-controller";
+import { SessionFocusController } from "./controllers/session-focus-controller";
 import { SSHCommandController } from "./controllers/ssh-command-controller";
 import { TanCommandController } from "./controllers/tan-command-controller";
 import { TodoCommandController } from "./controllers/todo-command-controller";
@@ -285,10 +286,15 @@ class StatusContainer extends Container implements NativeScrollbackLiveRegion {
  * Build the anchored subagent HUD block: a bold accent "Subagents" header plus
  * one hooked row per running agent in the same `Id: description` shape the
  * inline task rows use (muted task preview when no description was given).
+ * Only detached background spawns are listed: a sync task call blocks the
+ * parent turn and its inline tool block already renders progress live, and
+ * eval `agent()` spawns are rendered by their own eval cell tree.
  * Returns an empty array when nothing is running so the container can clear.
  */
 export function renderSubagentHudLines(sessions: ObservableSession[], columns: number): string[] {
-	const running = sessions.filter(session => session.kind === "subagent" && session.status === "active");
+	const running = sessions.filter(
+		session => session.kind === "subagent" && session.status === "active" && session.detached === true,
+	);
 	if (running.length === 0) return [];
 
 	const indent = "  ";
@@ -435,6 +441,34 @@ export class InteractiveMode implements InteractiveModeContext {
 	readonly #extensionUiController: ExtensionUiController;
 	readonly #inputController: InputController;
 	readonly #selectorController: SelectorController;
+	readonly #focusController: SessionFocusController;
+	get viewSession(): AgentSession {
+		return this.#focusController.target ?? this.session;
+	}
+	get focusedAgentId(): string | undefined {
+		return this.#focusController.focusedAgentId;
+	}
+	focusAgentSession(id: string): Promise<void> {
+		return this.#focusController.focusAgent(id);
+	}
+	focusParentSession(): Promise<void> {
+		return this.#focusController.focusParent();
+	}
+	unfocusSession(): Promise<void> {
+		return this.#focusController.unfocus();
+	}
+	clearTransientSessionUi(): void {
+		if (this.loadingAnimation) {
+			this.loadingAnimation.stop();
+			this.loadingAnimation = undefined;
+		}
+		this.statusContainer.clear();
+		this.pendingMessagesContainer.clear();
+		this.compactionQueuedMessages = [];
+		this.streamingComponent = undefined;
+		this.streamingMessage = undefined;
+		this.pendingTools.clear();
+	}
 	readonly #uiHelpers: UiHelpers;
 	#sttController: STTController | undefined;
 	#voiceAnimationInterval: NodeJS.Timeout | undefined;
@@ -560,6 +594,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#commandController = new CommandController(this);
 		this.#todoCommandController = new TodoCommandController(this);
 		this.#selectorController = new SelectorController(this);
+		this.#focusController = new SessionFocusController(this);
 		this.#inputController = new InputController(this);
 		this.#observerRegistry = new SessionObserverRegistry();
 	}
@@ -1155,6 +1190,12 @@ export class InteractiveMode implements InteractiveModeContext {
 				this.editor.borderColor = theme.getThinkingBorderColor(level);
 			}
 		}
+		if (this.focusedAgentId) {
+			// Focused subagent view: faint the outline so the borrowed session is
+			// visually distinct from the main one.
+			const base = this.editor.borderColor;
+			this.editor.borderColor = (str: string) => `\x1b[2m${base(str)}\x1b[22m`;
+		}
 		this.updateEditorTopBorder();
 		this.ui.requestRender();
 	}
@@ -1169,7 +1210,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.chatContainer.clear();
 		// Full-history transcript: compactions render as inline dividers instead
 		// of restarting the visible conversation (the LLM context still resets).
-		const context = this.session.buildTranscriptSessionContext();
+		const context = this.viewSession.buildTranscriptSessionContext();
 		this.renderSessionContext(context);
 		// During the pre-streaming window — after `startPendingSubmission` has
 		// optimistically rendered the user's message but before the user
@@ -2695,6 +2736,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 		this.#btwController.dispose();
 		this.#omfgController.dispose();
+		this.#focusController.dispose();
 
 		// Emit shutdown event to hooks
 		await this.session.dispose();

package/src/modes/session-observer-registry.ts

@@ -11,6 +11,13 @@ export interface ObservableSession {
 	status: "active" | "completed" | "failed" | "aborted";
 	sessionFile?: string;
 	parentToolCallId?: string;
+	/**
+	 * Spawn runs as a detached background job (parent turn not blocked on it).
+	 * The anchored subagent HUD only lists detached spawns: sync task spawns
+	 * and eval `agent()` spawns are already rendered live by their own inline
+	 * tool block / eval cell.
+	 */
+	detached?: boolean;
 	index?: number;
 	lastUpdate: number;
 	/** Latest progress snapshot from the subagent executor */
@@ -146,6 +153,7 @@ export class SessionObserverRegistry {
 					existing.lastUpdate = Date.now();
 					existing.index = payload.index;
 					existing.parentToolCallId = payload.parentToolCallId ?? existing.parentToolCallId;
+					existing.detached = payload.detached ?? existing.detached;
 					if (payload.description) existing.description = payload.description;
 					if (payload.sessionFile) existing.sessionFile = payload.sessionFile;
 				} else {
@@ -158,6 +166,7 @@ export class SessionObserverRegistry {
 						status,
 						sessionFile: payload.sessionFile,
 						parentToolCallId: payload.parentToolCallId,
+						detached: payload.detached,
 						index: payload.index,
 						lastUpdate: Date.now(),
 					});
@@ -179,6 +188,7 @@ export class SessionObserverRegistry {
 					existing.lastUpdate = Date.now();
 					existing.index = payload.index;
 					existing.parentToolCallId = payload.parentToolCallId ?? existing.parentToolCallId;
+					existing.detached = payload.detached ?? existing.detached;
 					existing.progress = progress;
 					if (progress.description) existing.description = progress.description;
 					if (payload.sessionFile) existing.sessionFile = payload.sessionFile;
@@ -192,6 +202,7 @@ export class SessionObserverRegistry {
 						status: "active",
 						sessionFile: payload.sessionFile,
 						parentToolCallId: payload.parentToolCallId,
+						detached: payload.detached,
 						index: payload.index,
 						lastUpdate: Date.now(),
 						progress,

package/src/modes/theme/theme.ts

@@ -107,6 +107,7 @@ export type SymbolKey =
 	| "icon.cost"
 	| "icon.time"
 	| "icon.pi"
+	| "icon.ghost"
 	| "icon.agents"
 	| "icon.job"
 	| "icon.cache"
@@ -305,6 +306,7 @@ const UNICODE_SYMBOLS: SymbolMap = {
 	"icon.cost": "💲",
 	"icon.time": "⏱",
 	"icon.pi": "π",
+	"icon.ghost": "👻",
 	"icon.agents": "👥",
 	"icon.job": "⚙",
 	"icon.cache": "💾",
@@ -569,6 +571,8 @@ const NERD_SYMBOLS: SymbolMap = {
 	"icon.time": "\uf017",
 	// pick:  | alt: π ∏ ∑
 	"icon.pi": "\ue22c",
+	// pick: 󰊠 (nf-md-ghost) | alt: 👻
+	"icon.ghost": "\u{f02a0}",
 	// pick:  | alt: 
 	"icon.agents": "\uf0c0",
 	// pick:  (nf-fa-gear) | alt:  ⚙
@@ -802,6 +806,7 @@ const ASCII_SYMBOLS: SymbolMap = {
 	"icon.cost": "$",
 	"icon.time": "t:",
 	"icon.pi": "pi",
+	"icon.ghost": "@",
 	"icon.agents": "AG",
 	"icon.job": "bg",
 	"icon.cache": "cache",
@@ -1769,6 +1774,7 @@ export class Theme {
 			cost: this.#symbols["icon.cost"],
 			time: this.#symbols["icon.time"],
 			pi: this.#symbols["icon.pi"],
+			ghost: this.#symbols["icon.ghost"],
 			agents: this.#symbols["icon.agents"],
 			job: this.#symbols["icon.job"],
 			cache: this.#symbols["icon.cache"],

package/src/modes/types.ts

@@ -98,6 +98,18 @@ export interface InteractiveModeContext {
 	// Session access
 	session: AgentSession;
 	sessionManager: SessionManager;
+	/** Session the transcript/editor/status are attached to: the focused agent's, else `session`. */
+	readonly viewSession: AgentSession;
+	/** Id of the focused agent, undefined when the main session is attached. */
+	readonly focusedAgentId: string | undefined;
+	/** Focus the main view on an agent's live session (delegates to SessionFocusController.focusAgent). */
+	focusAgentSession(id: string): Promise<void>;
+	/** Focus the focused agent's parent session, falling back to main (delegates to focusParent). */
+	focusParentSession(): Promise<void>;
+	/** Return the view to the main session (delegates to SessionFocusController.unfocus). */
+	unfocusSession(): Promise<void>;
+	/** Clear loader, status/pending containers, streaming state, and pending tools. */
+	clearTransientSessionUi(): void;
 	settings: Settings;
 	keybindings: KeybindingsManager;
 	agent: AgentSession["agent"];

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

@@ -233,7 +233,7 @@ export class UiHelpers {
 						this.ctx.chatContainer.addChild(card);
 						return [card];
 					}
-					const renderer = this.ctx.session.extensionRunner?.getMessageRenderer(message.customType);
+					const renderer = this.ctx.viewSession.extensionRunner?.getMessageRenderer(message.customType);
 					// Both HookMessage and CustomMessage have the same structure, cast for compatibility
 					const component = new CustomMessageComponent(message as CustomMessage<unknown>, renderer);
 					component.setExpanded(this.ctx.toolOutputExpanded);
@@ -284,7 +284,10 @@ export class UiHelpers {
 					const isSynthetic = message.role === "developer" ? true : (message.synthetic ?? false);
 					const imageLinks =
 						options?.imageLinks ??
-						imageLinksForMessage(message, this.ctx.sessionManager.putBlobSync.bind(this.ctx.sessionManager));
+						imageLinksForMessage(
+							message,
+							this.ctx.viewSession.sessionManager.putBlobSync.bind(this.ctx.viewSession.sessionManager),
+						);
 					const userComponent = new UserMessageComponent(textContent, isSynthetic, imageLinks);
 					this.ctx.chatContainer.addChild(userComponent);
 					if (options?.populateHistory && message.role === "user" && !isSynthetic) {
@@ -298,7 +301,7 @@ export class UiHelpers {
 					message,
 					this.ctx.hideThinkingBlock,
 					() => this.ctx.ui.requestRender(),
-					this.ctx.session.extensionRunner?.getAssistantThinkingRenderers(),
+					this.ctx.viewSession.extensionRunner?.getAssistantThinkingRenderers(),
 					this.ctx.ui.imageBudget,
 				);
 				this.ctx.chatContainer.addChild(assistantComponent);
@@ -379,7 +382,7 @@ export class UiHelpers {
 					!isAbortedSilently && (message.stopReason === "aborted" || message.stopReason === "error");
 				const errorMessage = hasErrorStop
 					? message.stopReason === "aborted"
-						? resolveAbortLabel(message.errorMessage, this.ctx.session.retryAttempt)
+						? resolveAbortLabel(message.errorMessage, this.ctx.viewSession.retryAttempt)
 						: message.errorMessage || "Error"
 					: null;
 
@@ -424,7 +427,7 @@ export class UiHelpers {
 
 					readGroup?.seal();
 					readGroup = null;
-					const tool = this.ctx.session.getToolByName(content.name);
+					const tool = this.ctx.viewSession.getToolByName(content.name);
 					const renderArgs =
 						"partialJson" in content
 							? { ...content.arguments, __partialJson: content.partialJson }
@@ -433,7 +436,7 @@ export class UiHelpers {
 						content.name,
 						renderArgs,
 						{
-							snapshots: getFileSnapshotStore(this.ctx.session),
+							snapshots: getFileSnapshotStore(this.ctx.viewSession),
 							showImages: settings.get("terminal.showImages"),
 							editFuzzyThreshold: settings.get("edit.fuzzyThreshold"),
 							editAllowFuzzy: settings.get("edit.fuzzyMatch"),
@@ -441,7 +444,7 @@ export class UiHelpers {
 						},
 						tool,
 						this.ctx.ui,
-						this.ctx.sessionManager.getCwd(),
+						this.ctx.viewSession.sessionManager.getCwd(),
 						content.id,
 					);
 					component.setExpanded(this.ctx.toolOutputExpanded);
@@ -550,14 +553,14 @@ export class UiHelpers {
 
 		// Display always uses the full-history transcript: compactions show as
 		// inline dividers instead of restarting the visible conversation.
-		const context = this.ctx.session.buildTranscriptSessionContext();
+		const context = this.ctx.viewSession.buildTranscriptSessionContext();
 		this.ctx.renderSessionContext(context, {
 			updateFooter: true,
-			populateHistory: true,
+			populateHistory: !this.ctx.focusedAgentId,
 		});
 
 		// Show compaction info if session was compacted
-		const allEntries = this.ctx.sessionManager.getEntries();
+		const allEntries = this.ctx.viewSession.sessionManager.getEntries();
 		let compactionCount = 0;
 		for (const entry of allEntries) {
 			if (entry.type === "compaction") {
@@ -614,7 +617,7 @@ export class UiHelpers {
 
 	updatePendingMessagesDisplay(): void {
 		this.ctx.pendingMessagesContainer.clear();
-		const queuedMessages = this.ctx.session.getQueuedMessages() as QueuedMessages;
+		const queuedMessages = this.ctx.viewSession.getQueuedMessages() as QueuedMessages;
 
 		const steeringMessages: Array<{ message: string; label: string }> = [];
 		for (const message of queuedMessages.steering) {
@@ -800,8 +803,8 @@ export class UiHelpers {
 	}
 
 	findLastAssistantMessage(): AssistantMessage | undefined {
-		for (let i = this.ctx.session.messages.length - 1; i >= 0; i--) {
-			const message = this.ctx.session.messages[i];
+		for (let i = this.ctx.viewSession.messages.length - 1; i >= 0; i--) {
+			const message = this.ctx.viewSession.messages[i];
 			if (message?.role === "assistant") {
 				return message as AssistantMessage;
 			}

package/src/prompts/tools/job.md

@@ -8,7 +8,7 @@ Background job results are delivered automatically when complete. Reach for this
 Use to inspect what's running.
 
 ## `poll: [id, …]`
-Block until the specified jobs finish or the wait window elapses.
+Block until the specified jobs finish or the wait window elapses. Omit `poll` (with no `list`/`cancel`) to wait on ALL running jobs — NEVER enumerate ids you don't need to filter.
 - Use when you are genuinely blocked on a result and have no other work to do.
 - Returns the current snapshot when the timer elapses; running jobs remain running.
 - Completed jobs include their final output in the returned snapshot.

package/src/session/agent-session.ts

@@ -100,6 +100,7 @@ import { modelsAreEqual } from "@oh-my-pi/pi-catalog/models";
 import { countTokens, MacOSPowerAssertion } from "@oh-my-pi/pi-natives";
 import {
 	extractRetryHint,
+	formatDuration,
 	getAgentDbPath,
 	getInstallId,
 	isBunTestRuntime,
@@ -240,7 +241,13 @@ import { normalizeModelContextImages } from "../utils/image-loading";
 import { buildNamedToolChoice } from "../utils/tool-choice";
 import type { AuthStorage } from "./auth-storage";
 import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome } from "./client-bridge";
-import { defaultCodexAutoRedeemCoordinator, evaluateCodexAutoRedeem } from "./codex-auto-reset";
+import {
+	type CodexAutoRedeemRedeemDecision,
+	defaultCodexAutoRedeemCoordinator,
+	evaluateCodexAutoRedeem,
+	shouldEvaluateCodexAutoRedeem,
+	shouldPromptCodexAutoRedeem,
+} from "./codex-auto-reset";
 import {
 	type BashExecutionMessage,
 	type CustomMessage,
@@ -1418,6 +1425,11 @@ export class AgentSession {
 		return this.#ttsrManager;
 	}
 
+	/** Secret obfuscator, when secrets are configured; /share redaction reuses it. */
+	get obfuscator(): SecretObfuscator | undefined {
+		return this.#obfuscator;
+	}
+
 	/** Whether a TTSR abort is pending (stream was aborted to inject rules) */
 	get isTtsrAbortPending(): boolean {
 		return this.#ttsrAbortPending;
@@ -6143,7 +6155,13 @@ export class AgentSession {
 
 	async #pruneToolOutputs(): Promise<{ prunedCount: number; tokensSaved: number } | undefined> {
 		const branchEntries = this.sessionManager.getBranch();
-		const result = pruneToolOutputs(branchEntries, this.#withPlanProtection(DEFAULT_PRUNE_CONFIG));
+		const result = pruneToolOutputs(
+			branchEntries,
+			this.#withPlanProtection({
+				...DEFAULT_PRUNE_CONFIG,
+				pruneUseless: this.settings.getGroup("compaction").dropUseless,
+			}),
+		);
 		if (result.prunedCount === 0) {
 			return undefined;
 		}
@@ -6157,19 +6175,22 @@ export class AgentSession {
 	}
 
 	/**
-	 * Per-turn supersede pass: prune older `read` results that a newer read of
-	 * the same file has made stale. Cache-aware (only fires when the suffix
-	 * after a candidate is small or the session has been idle long enough that
-	 * the provider prompt cache is cold), so it is cheap to run every turn.
-	 * Gated on the `compaction.supersedeReads` setting.
+	 * Per-turn stale-result pass: prune older `read` results that a newer read
+	 * of the same file has made stale, plus results their tool flagged
+	 * contextually useless. Cache-aware (only fires when the suffix after a
+	 * candidate is small or the session has been idle long enough that the
+	 * provider prompt cache is cold), so it is cheap to run every turn. Gated
+	 * on the `compaction.supersedeReads` and `compaction.dropUseless` settings.
 	 */
-	async #pruneSupersededReads(): Promise<{ prunedCount: number; tokensSaved: number } | undefined> {
-		if (!this.settings.getGroup("compaction").supersedeReads) return undefined;
+	async #pruneStaleToolResults(): Promise<{ prunedCount: number; tokensSaved: number } | undefined> {
+		const { supersedeReads, dropUseless } = this.settings.getGroup("compaction");
+		if (!supersedeReads && !dropUseless) return undefined;
 		const branchEntries = this.sessionManager.getBranch();
 		const result = pruneSupersededToolResults(
 			branchEntries,
 			this.#withPlanProtection({
-				supersedeKey: readToolSupersedeKey,
+				supersedeKey: supersedeReads ? readToolSupersedeKey : undefined,
+				pruneUseless: dropUseless,
 				protectedTools: [...DEFAULT_PRUNE_CONFIG.protectedTools],
 			}),
 		);
@@ -6849,9 +6870,10 @@ export class AgentSession {
 			return false;
 		}
 
-		// Supersede pass runs every turn, before any threshold gating: it is cheap
-		// (bails when no candidate) and independent of the compaction setting.
-		const supersedeResult = await this.#pruneSupersededReads();
+		// Stale-result pass runs every turn, before any threshold gating: it is
+		// cheap (bails when no candidate) and independent of the compaction
+		// setting.
+		const supersedeResult = await this.#pruneStaleToolResults();
 
 		const compactionSettings = this.settings.getGroup("compaction");
 		if (!compactionSettings.enabled || compactionSettings.strategy === "off") return false;
@@ -10193,20 +10215,63 @@ export class AgentSession {
 			signal,
 		});
 	}
+	async #confirmCodexAutoRedeem(decision: CodexAutoRedeemRedeemDecision): Promise<boolean> {
+		const runner = this.#extensionRunner;
+		if (!runner?.hasUI()) {
+			this.emitNotice(
+				"warning",
+				"Codex saved reset is eligible, but auto-redeem is unset and no prompt UI is available. Run `/usage reset` or set codexResets.autoRedeem.",
+				"codex-auto-reset",
+			);
+			return false;
+		}
+
+		const who = decision.target.email ?? decision.target.accountId ?? "the active account";
+		const resetLabel = decision.availableCount === 1 ? "reset" : "resets";
+		try {
+			const choice = await runner
+				.getUIContext()
+				.select(
+					`Do you wanna redeem your reset?\n${who} is blocked by the weekly Codex limit for about ${formatDuration(decision.remainingMs)}. Spend 1 of ${decision.availableCount} saved ${resetLabel}?`,
+					[
+						{
+							label: "Yes",
+							description: "Redeem now and remember yes for future eligible Codex weekly blocks.",
+						},
+						{
+							label: "No",
+							description: "Do not auto-redeem saved Codex resets.",
+						},
+					],
+				);
+			if (choice === "Yes") {
+				this.settings.set("codexResets.autoRedeem", "yes");
+				return true;
+			}
+			if (choice === "No") {
+				this.settings.set("codexResets.autoRedeem", "no");
+			}
+		} catch (error) {
+			logger.warn("codex-auto-reset prompt failed", { error: String(error) });
+		}
+		return false;
+	}
 
 	/**
 	 * Auto-redeem hook for {@link AgentSession.#handleRetryableError}'s
 	 * usage-limit branch. Returns `true` only when a saved Codex reset was
-	 * actually spent (so the caller retries immediately). Opt-in, reactive, and
-	 * heavily gated — see `./codex-auto-reset` and the design in
-	 * `local://autoreset-spec.md`. Per-account in-flight dedup lets concurrent
-	 * sessions adopt one redeem instead of double-spending.
+	 * actually spent (so the caller retries immediately). The "unset" mode is
+	 * reactive but asks before spending; "yes" skips that prompt, and "no" avoids
+	 * the eligibility IO entirely. The decision remains heavily gated — see
+	 * `./codex-auto-reset` and the design in `local://autoreset-spec.md`.
+	 * Per-account in-flight dedup lets concurrent sessions adopt one redeem
+	 * instead of double-spending.
 	 */
 	async #maybeAutoRedeemCodexReset(coordinator = defaultCodexAutoRedeemCoordinator): Promise<boolean> {
 		const cfg = this.settings.getGroup("codexResets");
 		const model = this.model;
 		// Cheap exits before any IO.
-		if (!cfg.autoRedeem || !model || model.provider !== "openai-codex") return false;
+		if (!shouldEvaluateCodexAutoRedeem(cfg.autoRedeem) || !model || model.provider !== "openai-codex") return false;
 		const authStorage = this.#modelRegistry.authStorage;
 		// Capture identity BEFORE awaits: markUsageLimitReached leaves the
 		// usage-limit session credential sticky, so this names the blocked account.
@@ -10223,7 +10288,7 @@ export class AgentSession {
 				provider: model.provider,
 				modelId: model.id,
 				settings: {
-					autoRedeem: cfg.autoRedeem,
+					autoRedeem: true,
 					minBlockedMinutes: Math.max(0, cfg.minBlockedMinutes),
 					keepCredits: Math.max(0, Math.trunc(cfg.keepCredits)),
 				},
@@ -10236,6 +10301,9 @@ export class AgentSession {
 				logger.debug("codex-auto-reset: skipped", { reason: decision.reason });
 				return false;
 			}
+			if (shouldPromptCodexAutoRedeem(cfg.autoRedeem) && !(await this.#confirmCodexAutoRedeem(decision))) {
+				return false;
+			}
 			// Commit the attempt BEFORE acting so this block can never re-enter.
 			coordinator.attemptedBlockKeys.add(decision.blockKey);
 			coordinator.lastAttemptAtByAccount.set(decision.accountKey, Date.now());