@oh-my-pi/pi-coding-agent 15.4.3 → 15.5.1

package/src/prompts/tools/hashline.md

@@ -1,109 +1,59 @@
 Your patch language is a compact, line-anchored edit format.
 
-A patch contains one or more file sections. Each anchored section starts with `¶PATH#HASH`, copied verbatim from the latest `read`/`search` output. `HASH` is a 4-hex file hash; `¶PATH` without `#HASH` is allowed only for new-file / `BOF` / `EOF` boundary inserts.
-
-Operations reference lines by bare line number (`5`, `123`). Payload text is verbatim — NEVER escape unicode. The tool has NO awareness of language, indentation, brackets, fences, or table widths. Emit valid syntax in replacements/insertions.
+<payload>
+Patch payload is a series of hunks: `¶PATH#HASH` header followed by any number of operations. `HASH` should be copied as is from read/search. Missing? Re-`read`.
+- No context rows, no gutters.
+- NEVER prefix payload with diff syntax.
+- NEVER restate unchanged lines "for context".
+- Payload indentation is literal.
+</payload>
 
 <ops>
-¶PATH#HASH     header: subsequent anchored ops apply to PATH at file hash HASH
-¶PATH          unbound header: only BOF/EOF boundary inserts
-LINE↑PAYLOAD   insert ABOVE the anchored line (or BOF)
-LINE↓PAYLOAD   insert BELOW the anchored line (or EOF)
-A-B:PAYLOAD    replace the inclusive range A..B with PAYLOAD
-A:PAYLOAD      shorthand for A-A:PAYLOAD
-A-B!           delete the inclusive range A..B (payload forbidden)
-A!             shorthand for A-A!
+LINE↑PAYLOAD   insert before (or BOF↑)
+LINE↓PAYLOAD   insert after  (or EOF↓)
+A-B:PAYLOAD    replace A..B  (or A: == A..A)
+A-B!           delete A..B   (or A! == A..A)
 </ops>
 
-<payload>
-- The first payload line is whatever follows the sigil on the op line. Additional payload lines follow on the next lines and append after the first.
-- An empty inline IS an empty first line. So bare `A↓` / `A↑` insert one blank line; bare `A:` / `A-B:` replace with one blank line. `A↓\nfoo` inserts blank-then-`foo`, NOT just `foo`.
-- Payload ends at the next op, next `¶PATH`, envelope marker, or EOF. Blank lines immediately before a next op or `¶PATH` are dropped; blank lines between content lines are preserved.
-</payload>
-
 <rules>
-- The sigil tells where content lands: `↑` above, `↓` below, `:` replaces, `!` deletes.
-- **Payload is only what's NEW relative to your range.** `:` replaces inside; `↑`/`↓` add at anchor. NEVER repeat the anchor line or neighbors — that duplicates them.
-- **Pick a self-contained unit.** Touching a multiline construct (return, array, brace block, JSX element)? Widen the range to span it. Don't bisect.
-- Smallest op wins: add with `↑`/`↓`; replace with `:`; delete with `!`.
-- Anchors reference the file as last read. ONE patch, ONE coordinate space — later ops still use original line numbers.
+- **Payload is only what's NEW.** `:` replaces inside; `↑`/`↓` add at anchor. NEVER repeat anchor lines or neighbors.
+- **Go small.** Add → `↑`/`↓`; replace → `:`; delete → `!`.
+- **Line numbers are frozen references to what you have seen.** Later ops still use original line numbers.
 </rules>
 
 <common-failures>
-- **NEVER replay past your range.** Stop before B+1; extend B if it must go.
-- **NEVER duplicate chunks inside one payload.**
-- **Read lines look like replace ops.** `84:content` already means "make line 84 equal to content" — don't echo a context line before it.
+- **NEVER replay past your range.** Stop before B+1; extend B if needed.
+- **Read lines look like replace ops.** `84:content` = "make line 84 content" — don't echo context before it.
 - **NEVER fabricate file hashes.** Missing? Re-`read`.
-- **`A!` deletes silently.** Deleting a line that closes/opens a block (`}`, `} else {`, `})`, `*/`) breaks structure with no parse error.
 </common-failures>
 
-<case file="mod.ts">
-¶mod.ts#1a2b
-{{hline 1 'const TITLE = "Mr";'}}
-{{hline 2 'export function greet(name) {'}}
-{{hline 3 '	return ['}}
-{{hline 4 '		TITLE,'}}
-{{hline 5 '		name?.trim() || "guest",'}}
-{{hline 6 '	].join(" ");'}}
-{{hline 7 "}"}}
-</case>
-
-<examples>
-# Replace one line (inline payload preserves original indentation)
-¶mod.ts#1a2b
-{{hrefr 1}}:const TITLE = "Mrs";
-
-# Replace a multiline statement — first line inline, rest below
-¶mod.ts#1a2b
-{{hrefr 3}}-{{hrefr 6}}:	return [
-		"Mrs",
-		name?.trim() || "guest",
-	].join(" ");
-
-# Insert ABOVE / BELOW a line
-¶mod.ts#1a2b
-{{hrefr 4}}↓		"Dr",
-{{hrefr 5}}↑		"Dr",
-
-# Delete one line / blank a line / insert a blank line
-¶mod.ts#1a2b
-{{hrefr 5}}!
-{{hrefr 6}}:
-{{hrefr 7}}↑
-
-# Create a file / append to one (hash optional for boundary-only inserts)
-¶new.ts
-BOF↓export const done = true;
-¶mod.ts
-EOF↓export const done = true;
-
-# Multi-file patch
-¶src/a.ts#1a2b
-12:const enabled = true;
-¶src/b.ts#3c4d
-20!
-</examples>
+<example>
+```a.ts#1a2b
+1:const X = "a";
+2:export function f() { return X; }
+```
+
+# replace, insert after, delete
+```
+¶a.ts#1a2b
+1:const X = "b";
+1↓const Y = "c";
+2!
+```
+</example>
 
 <anti-pattern>
-# WRONG — replaces 2 lines just to add one.
-¶mod.ts#1a2b
-{{hrefr 1}}-{{hrefr 2}}:const TITLE = "Mr";
-const DEBUG = false;
-export function greet(name) {
-
-# RIGHT — one-line insert
-¶mod.ts#1a2b
-{{hrefr 1}}↓const DEBUG = false;
-
-# WRONG — bisects a multiline statement
-¶mod.ts#1a2b
-{{hrefr 4}}-{{hrefr 5}}:		"Dr",
-		name?.trim() || "guest",
-
-# RIGHT — widen to the full statement
-¶mod.ts#1a2b
-{{hrefr 3}}-{{hrefr 6}}:	return [
-		"Dr",
-		name?.trim() || "guest",
-	].join(" ");
+# WRONG — INSERT used to change a line (old line survives)
+1↓const X = "b";
+# WRONG — echoing read-style lines as context before the real op
+1:const X = "a";
+1-2:const X = "b";
+export const Y = X;
 </anti-pattern>
+
+<critical>
+- One op per range, ever.
+- Pick op precisely. Update: `:`, add: `↑`/`↓`, remove: `!`.
+- Payload is only what's NEW; never repeat anchor lines or neighbors.
+- Anchor exactly; don't anchor neighbors.
+</critical>

package/src/sdk.ts

@@ -60,7 +60,6 @@ import {
 } from "./extensibility/custom-commands";
 import { discoverAndLoadCustomTools } from "./extensibility/custom-tools";
 import type { CustomTool, CustomToolContext, CustomToolSessionEvent } from "./extensibility/custom-tools/types";
-import { CustomToolAdapter } from "./extensibility/custom-tools/wrapper";
 import {
 	discoverAndLoadExtensions,
 	type ExtensionContext,
@@ -343,6 +342,9 @@ export interface CreateAgentSessionOptions {
 	 * `@opentelemetry/api` package returns a no-op tracer in that case.
 	 */
 	telemetry?: AgentTelemetryConfig;
+
+	/** Whether to auto-approve all tool calls (--auto-approve CLI flag). Default: false */
+	autoApprove?: boolean;
 }
 
 /** Result from createAgentSession */
@@ -835,7 +837,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// buffer — so we can't rely on it to catch startup events for the extension runner.
 	const startupCredentialDisabledEvents: CredentialDisabledEvent[] = [];
 	let credentialDisabledTarget: ExtensionRunner | undefined;
-	let unsubscribeCredentialDisabled: (() => void) | undefined = authStorage.onCredentialDisabled(event => {
+	const unsubscribeCredentialDisabled: (() => void) | undefined = authStorage.onCredentialDisabled(event => {
 		if (credentialDisabledTarget) {
 			// Discard return: any handler error is routed through runner.onError listeners.
 			void credentialDisabledTarget.emitCredentialDisabled(event);
@@ -1455,29 +1457,25 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 		}
 
-		let extensionRunner: ExtensionRunner | undefined;
-		if (extensionsResult.extensions.length > 0) {
-			extensionRunner = new ExtensionRunner(
-				extensionsResult.extensions,
-				extensionsResult.runtime,
-				cwd,
-				sessionManager,
-				modelRegistry,
-			);
-		}
+		// The runner is created unconditionally — even with zero extensions loaded — because the
+		// `ExtensionToolWrapper` installed below is the only place the per-tool approval gate runs.
+		// A conditional runner means the approval system silently disappears for users with no
+		// extensions, contradicting non-yolo `tools.approvalMode` settings without feedback.
+		// (Today `createAutoresearchExtension` is unconditionally pushed below, so this scenario
+		// is unreachable; the unconditional construction makes that invariant explicit instead of
+		// implicit, so a future change to make autoresearch optional cannot silently re-open the hole.)
+		const extensionRunner: ExtensionRunner = new ExtensionRunner(
+			extensionsResult.extensions,
+			extensionsResult.runtime,
+			cwd,
+			sessionManager,
+			modelRegistry,
+		);
 
-		if (extensionRunner) {
-			credentialDisabledTarget = extensionRunner;
-			for (const event of startupCredentialDisabledEvents.splice(0)) {
-				// Discard return: any handler error is routed through runner.onError listeners.
-				void extensionRunner.emitCredentialDisabled(event);
-			}
-		} else {
-			// No runner to forward to; release our subscription. The embedder's own
-			// onCredentialDisabled (if any) keeps firing through its own subscription.
-			startupCredentialDisabledEvents.length = 0;
-			unsubscribeCredentialDisabled?.();
-			unsubscribeCredentialDisabled = undefined;
+		credentialDisabledTarget = extensionRunner;
+		for (const event of startupCredentialDisabledEvents.splice(0)) {
+			// Discard return: any handler error is routed through runner.onError listeners.
+			void extensionRunner.emitCredentialDisabled(event);
 		}
 
 		const getSessionContext = () => ({
@@ -1490,38 +1488,19 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				session.abort();
 			},
 			settings,
+			autoApprove: options.autoApprove ?? false,
 		});
 		const toolContextStore = new ToolContextStore(getSessionContext);
 
-		const registeredTools = extensionRunner?.getAllRegisteredTools() ?? [];
-		let wrappedExtensionTools: Tool[];
-
-		if (extensionRunner) {
-			// With extension runner: convert CustomTools to ToolDefinitions and wrap all together
-			const allCustomTools = [
-				...registeredTools,
-				...(options.customTools?.map(tool => {
-					const definition = isCustomTool(tool) ? customToolToDefinition(tool) : tool;
-					return { definition, extensionPath: "<sdk>" };
-				}) ?? []),
-			];
-			wrappedExtensionTools = wrapRegisteredTools(allCustomTools, extensionRunner);
-		} else {
-			// Without extension runner: wrap CustomTools directly with CustomToolAdapter
-			// ToolDefinition items require ExtensionContext and cannot be used without a runner
-			const customToolContext = (): CustomToolContext => ({
-				sessionManager,
-				modelRegistry,
-				model: agent?.state.model,
-				isIdle: () => !session?.isStreaming,
-				hasQueuedMessages: () => (session?.queuedMessageCount ?? 0) > 0,
-				abort: () => session?.abort(),
-				settings,
-			});
-			wrappedExtensionTools = (options.customTools ?? [])
-				.filter(isCustomTool)
-				.map(tool => CustomToolAdapter.wrap(tool, customToolContext));
-		}
+		const registeredTools = extensionRunner.getAllRegisteredTools();
+		const allCustomTools = [
+			...registeredTools,
+			...(options.customTools?.map(tool => {
+				const definition = isCustomTool(tool) ? customToolToDefinition(tool) : tool;
+				return { definition, extensionPath: "<sdk>" };
+			}) ?? []),
+		];
+		const wrappedExtensionTools: Tool[] = wrapRegisteredTools(allCustomTools, extensionRunner);
 
 		// All built-in tools are active (conditional tools like git/ask return null from factory if disabled)
 		const toolRegistry = new Map<string, Tool>();
@@ -1537,10 +1516,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		for (const tool of wrappedExtensionTools) {
 			toolRegistry.set(tool.name, tool);
 		}
-		if (extensionRunner) {
-			for (const tool of toolRegistry.values()) {
-				toolRegistry.set(tool.name, new ExtensionToolWrapper(tool, extensionRunner));
-			}
+		// Wrap every tool with `ExtensionToolWrapper` so the per-tool approval gate runs on every
+		// call site, regardless of whether any user extensions are loaded. See the runner-construction
+		// comment above for the safety invariant this enforces.
+		for (const tool of toolRegistry.values()) {
+			toolRegistry.set(tool.name, new ExtensionToolWrapper(tool, extensionRunner));
 		}
 		if (model?.provider === "cursor") {
 			toolRegistry.delete("edit");
@@ -1564,7 +1544,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			})) as unknown as AgentTool | null;
 			if (!sshTool) return null;
 			const wrapped = wrapToolWithMetaNotice(sshTool);
-			return (extensionRunner ? new ExtensionToolWrapper(wrapped, extensionRunner) : wrapped) as AgentTool;
+			return new ExtensionToolWrapper(wrapped, extensionRunner) as AgentTool;
 		};
 
 		let cursorEventEmitter: ((event: AgentEvent) => void) | undefined;
@@ -1824,21 +1804,15 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			if (!obfuscator?.hasSecrets()) return converted;
 			return obfuscateMessages(obfuscator, converted);
 		};
-		const transformContext = extensionRunner
-			? async (messages: AgentMessage[], _signal?: AbortSignal) => {
-					return await extensionRunner.emitContext(messages);
-				}
-			: undefined;
-		const onPayload = extensionRunner
-			? async (payload: unknown, _model?: Model) => {
-					return await extensionRunner.emitBeforeProviderRequest(payload);
-				}
-			: undefined;
-		const onResponse: SimpleStreamOptions["onResponse"] | undefined = extensionRunner
-			? async (response, model) => {
-					await extensionRunner.emitAfterProviderResponse(response, model);
-				}
-			: undefined;
+		const transformContext = async (messages: AgentMessage[], _signal?: AbortSignal) => {
+			return await extensionRunner.emitContext(messages);
+		};
+		const onPayload = async (payload: unknown, _model?: Model) => {
+			return await extensionRunner.emitBeforeProviderRequest(payload);
+		};
+		const onResponse: SimpleStreamOptions["onResponse"] = async (response, model) => {
+			await extensionRunner.emitAfterProviderResponse(response, model);
+		};
 
 		const setToolUIContext = (uiContext: ExtensionUIContext, hasUI: boolean) => {
 			toolContextStore.setUIContext(uiContext, hasUI);

package/src/session/agent-session.ts

@@ -898,7 +898,7 @@ export class AgentSession {
 	 *  combined with `Date.now()` so tags stay unique even across rapid
 	 *  same-tick enqueues. */
 	#customDisplayTagCounter = 0;
-	#postPromptTasks = new Set<Promise<void>>();
+	#postPromptTasks = new Set<Promise<unknown>>();
 	#postPromptTasksPromise: Promise<void> | undefined = undefined;
 	#postPromptTasksResolve: (() => void) | undefined = undefined;
 	#postPromptTasksAbortController = new AbortController();
@@ -1786,12 +1786,19 @@ export class AgentSession {
 
 			const compactionTask = this.#checkCompaction(msg);
 			this.#trackPostPromptTask(compactionTask);
-			await compactionTask;
+			const compactionDeferredHandoff = await compactionTask;
 			// Check for incomplete todos only after a final assistant stop, not intermediate tool-use turns.
 			const hasToolCalls = msg.content.some(content => content.type === "toolCall");
 			if (hasToolCalls) {
 				return;
 			}
+			// When checkCompaction scheduled a deferred handoff, skip the rewind/todo passes:
+			// any reminder we append here would race the handoff's session reset, and
+			// #scheduleAgentContinue would start a fresh streaming turn alongside the handoff
+			// LLM call (visible as "Auto-handoff" loader + an assistant message still streaming).
+			if (compactionDeferredHandoff) {
+				return;
+			}
 			if (msg.stopReason !== "error" && msg.stopReason !== "aborted") {
 				if (this.#enforceRewindBeforeYield()) {
 					return;
@@ -1840,7 +1847,7 @@ export class AgentSession {
 		this.#postPromptTasksPromise = undefined;
 	}
 
-	#trackPostPromptTask(task: Promise<void>): void {
+	#trackPostPromptTask(task: Promise<unknown>): void {
 		this.#postPromptTasks.add(task);
 		this.#ensurePostPromptTasksPromise();
 		void task
@@ -1889,8 +1896,17 @@ export class AgentSession {
 	}): void {
 		this.#schedulePostPromptTask(
 			async () => {
+				// Defense in depth: if compaction/handoff slipped onto the post-prompt queue
+				// alongside us (e.g. via a scheduler we don't own), refuse to start a fresh
+				// streaming turn — agent.continue() here would race the handoff's session
+				// reset. The first-class fix is in #checkCompaction/the agent_end handler,
+				// but this guard catches anything that bypasses that path.
+				if (this.isCompacting || this.isGeneratingHandoff) {
+					options?.onSkip?.();
+					return;
+				}
 				if (options?.shouldContinue && !options.shouldContinue()) {
-					options.onSkip?.();
+					options?.onSkip?.();
 					return;
 				}
 				try {
@@ -2756,6 +2772,21 @@ export class AgentSession {
 		} catch (error) {
 			logger.warn("Failed to emit session_shutdown event", { error: String(error) });
 		}
+		// Abort post-prompt work so the drain below can complete. Without this, a
+		// deferred-handoff task that has already advanced into
+		// `await this.handoff(...) → generateHandoff(...)` keeps awaiting a live LLM stream
+		// — Promise.allSettled() in #cancelPostPromptTasks then waits forever, freezing
+		// /exit and Ctrl+C-double-tap. The post-prompt task's own AbortSignal does not
+		// propagate into the inner handoff/compaction controllers, so we abort them
+		// explicitly. agent.abort() is needed for an agent.continue() that may have
+		// raced the deferred handoff (its streaming loop is awaited by the wrapper IIFE).
+		//
+		// Tool work (bash/eval/python) is NOT aborted here — those have their own
+		// dispose paths and shared kernels are contractually allowed to survive a
+		// session's dispose.
+		this.abortRetry();
+		this.abortCompaction();
+		this.agent.abort();
 		await this.#cancelPostPromptTasks();
 		// Cancel jobs this agent registered so a subagent's teardown doesn't
 		// leak its background bash/task work into the parent's manager. Only
@@ -4050,10 +4081,13 @@ export class AgentSession {
 				);
 			}
 
-			// Check if we need to compact before sending (catches aborted responses)
+			// Check if we need to compact before sending (catches aborted responses). Run
+			// inline (allowDefer=false) so the handoff/maintenance fully settles before this
+			// prompt's agent loop starts — otherwise a deferred handoff would fire on the
+			// next microtask alongside the new turn.
 			const lastAssistant = this.#findLastAssistantMessage();
 			if (lastAssistant && !options?.skipCompactionCheck) {
-				await this.#checkCompaction(lastAssistant, false);
+				await this.#checkCompaction(lastAssistant, false, false);
 			}
 
 			// Build messages array (session context, eager todo prelude, then active prompt message)
@@ -5602,10 +5636,23 @@ export class AgentSession {
 	 *
 	 * @param assistantMessage The assistant message to check
 	 * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
+	 * @param allowDefer If true, threshold-driven handoff strategy may schedule itself as a
+	 *   deferred post-prompt task instead of running inline. Callers running inside the
+	 *   `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.
+	 * @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
+	 *   stream into the soon-to-be-discarded session.
 	 */
-	async #checkCompaction(assistantMessage: AssistantMessage, skipAbortedCheck = true): Promise<void> {
+	async #checkCompaction(
+		assistantMessage: AssistantMessage,
+		skipAbortedCheck = true,
+		allowDefer = true,
+	): Promise<boolean> {
 		// Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
-		if (skipAbortedCheck && assistantMessage.stopReason === "aborted") return;
+		if (skipAbortedCheck && assistantMessage.stopReason === "aborted") return false;
 		const contextWindow = this.model?.contextWindow ?? 0;
 		const generation = this.#promptGeneration;
 		// Skip overflow check if the message came from a different model.
@@ -5634,22 +5681,22 @@ export class AgentSession {
 			if (promoted) {
 				// Retry on the promoted (larger) model without compacting
 				this.#scheduleAgentContinue({ delayMs: 100, generation });
-				return;
+				return false;
 			}
 
 			// 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);
+				await this.#runAutoCompaction("overflow", true, false, allowDefer);
 			}
-			return;
+			return false;
 		}
 		const compactionSettings = this.settings.getGroup("compaction");
-		if (!compactionSettings.enabled || compactionSettings.strategy === "off") return;
+		if (!compactionSettings.enabled || compactionSettings.strategy === "off") return false;
 
 		// Case 2: Threshold - turn succeeded but context is getting large
 		// Skip if this was an error (non-overflow errors don't have usage data)
-		if (assistantMessage.stopReason === "error") return;
+		if (assistantMessage.stopReason === "error") return false;
 		const pruneResult = await this.#pruneToolOutputs();
 		let contextTokens = calculateContextTokens(assistantMessage.usage);
 		if (pruneResult) {
@@ -5659,9 +5706,10 @@ export class AgentSession {
 			// Try promotion first — if a larger model is available, switch instead of compacting
 			const promoted = await this.#tryContextPromotion(assistantMessage);
 			if (!promoted) {
-				await this.#runAutoCompaction("threshold", false);
+				return await this.#runAutoCompaction("threshold", false, false, allowDefer);
 			}
 		}
+		return false;
 	}
 	#assistantEndedWithSuccessfulYield(assistantMessage: AssistantMessage): boolean {
 		const toolCallId = this.#lastSuccessfulYieldToolCallId;
@@ -6352,17 +6400,34 @@ export class AgentSession {
 
 	/**
 	 * Internal: Run auto-compaction with events.
+	 *
+	 * @param allowDefer If true (default), threshold-driven handoff strategy is allowed to
+	 *   schedule itself as a deferred post-prompt task and return `true` immediately. The
+	 *   caller MUST treat that as "compaction will happen async — do not also schedule
+	 *   `agent.continue()` for this turn", otherwise the deferred handoff races a fresh
+	 *   streaming turn (the symptom: "Auto-handoff" loader + assistant message still
+	 *   streaming). Callers on a path that is about to start a new agent turn (e.g.
+	 *   the pre-prompt check in `#promptWithMessage`) pass `false` to force inline
+	 *   execution so the handoff completes before the new turn begins.
+	 * @returns true when a deferred handoff was scheduled. Inline runs always return false.
 	 */
 	async #runAutoCompaction(
 		reason: "overflow" | "threshold" | "idle",
 		willRetry: boolean,
 		deferred = false,
-	): Promise<void> {
+		allowDefer = true,
+	): Promise<boolean> {
 		const compactionSettings = this.settings.getGroup("compaction");
-		if (compactionSettings.strategy === "off") return;
-		if (reason !== "idle" && !compactionSettings.enabled) return;
+		if (compactionSettings.strategy === "off") return false;
+		if (reason !== "idle" && !compactionSettings.enabled) return false;
 		const generation = this.#promptGeneration;
-		if (!deferred && reason !== "overflow" && reason !== "idle" && compactionSettings.strategy === "handoff") {
+		if (
+			!deferred &&
+			allowDefer &&
+			reason !== "overflow" &&
+			reason !== "idle" &&
+			compactionSettings.strategy === "handoff"
+		) {
 			this.#schedulePostPromptTask(
 				async signal => {
 					await Promise.resolve();
@@ -6371,7 +6436,7 @@ export class AgentSession {
 				},
 				{ generation },
 			);
-			return;
+			return true;
 		}
 
 		let action: "context-full" | "handoff" =
@@ -6400,7 +6465,7 @@ export class AgentSession {
 							aborted: true,
 							willRetry: false,
 						});
-						return;
+						return false;
 					}
 					logger.warn("Auto-handoff returned no document; falling back to context-full maintenance", {
 						reason,
@@ -6418,7 +6483,7 @@ export class AgentSession {
 					if (!autoCompactionSignal.aborted && reason !== "idle" && compactionSettings.autoContinue !== false) {
 						this.#scheduleAutoContinuePrompt(generation);
 					}
-					return;
+					return false;
 				}
 			}
 
@@ -6431,7 +6496,7 @@ export class AgentSession {
 					willRetry: false,
 					skipped: true,
 				});
-				return;
+				return false;
 			}
 
 			const availableModels = this.#modelRegistry.getAvailable();
@@ -6444,7 +6509,7 @@ export class AgentSession {
 					willRetry: false,
 					skipped: true,
 				});
-				return;
+				return false;
 			}
 
 			const pathEntries = this.sessionManager.getBranch();
@@ -6466,7 +6531,7 @@ export class AgentSession {
 						shouldContinue: () => this.agent.hasQueuedMessages(),
 					});
 				}
-				return;
+				return false;
 			}
 
 			let hookCompaction: CompactionResult | undefined;
@@ -6490,7 +6555,7 @@ export class AgentSession {
 						aborted: true,
 						willRetry: false,
 					});
-					return;
+					return false;
 				}
 
 				if (hookResult?.compaction) {
@@ -6621,7 +6686,7 @@ export class AgentSession {
 					aborted: true,
 					willRetry: false,
 				});
-				return;
+				return false;
 			}
 
 			this.sessionManager.appendCompaction(
@@ -6692,7 +6757,7 @@ export class AgentSession {
 					aborted: true,
 					willRetry: false,
 				});
-				return;
+				return false;
 			}
 			const errorMessage = error instanceof Error ? error.message : "compaction failed";
 			await this.#emitSessionEvent({
@@ -6711,6 +6776,7 @@ export class AgentSession {
 				this.#autoCompactionAbortController = undefined;
 			}
 		}
+		return false;
 	}
 
 	/**

package/src/session/streaming-output.ts

@@ -9,7 +9,7 @@ import { sanitizeWithOptionalSixelPassthrough } from "../utils/sixel";
 
 export const DEFAULT_MAX_LINES = 3000;
 export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
-export const DEFAULT_MAX_COLUMN = 1024; // Max chars per grep match line
+export const DEFAULT_MAX_COLUMN = 512; // Max chars per grep match line
 
 const NL = "\n";
 const ELLIPSIS = "…";

package/src/slash-commands/helpers/usage-report.ts

@@ -56,7 +56,9 @@ function renderUsageReports(reports: UsageReport[], nowMs: number): string {
 				lines.push(`- ${limit.label}${tier}${window ? ` — ${window}` : ""}`);
 				lines.push(`  ${formatUsageReportAccount(report, limit, index)}: ${formatUsageAmount(limit)}`);
 				lines.push(`  ${renderAsciiBar(limit.amount.usedFraction)}`);
-				if (limit.window?.resetsAt) lines.push(`  resets in ${formatDuration(limit.window.resetsAt - nowMs)}`);
+				if (limit.window?.resetsAt && limit.window.resetsAt > nowMs) {
+					lines.push(`  resets in ${formatDuration(limit.window.resetsAt - nowMs)}`);
+				}
 				if (limit.notes && limit.notes.length > 0) lines.push(`  ${limit.notes.join(" • ")}`);
 			}
 		}