@vanillagreen/pi-qol 1.3.0 → 1.4.1

package/README.md

@@ -5,7 +5,21 @@
 ![Session search popup](https://raw.githubusercontent.com/vanillagreencom/vstack/main/pi-extensions/pi-qol/assets/session-search.gif)
 ![/context usage breakdown](https://raw.githubusercontent.com/vanillagreencom/vstack/main/pi-extensions/pi-qol/assets/context-usage.png)
 
-Quality-of-life extension for Pi.
+Quality-of-life extension for Pi: compact statusline, multiline input, session naming and search, notifications, and a permission gate.
+
+## Highlights
+
+- Compact statusline with repo, branch, model, thinking level, and context percent.
+- Shift+Enter inserts a newline. Ctrl+J fallback for terminals that can't distinguish it.
+- Sessions auto-name from your first prompt. `/rename` overrides anytime.
+- `/search` browses previous sessions with snippet previews. F2 opens it instantly.
+- `/context` shows a Claude-style context-window breakdown.
+- `/handoff <goal>` drafts a focused prompt for a new session.
+- Permission gate prompts before risky `bash` commands. Default match: `rm -Rf`.
+- Notifications for ready, questions, blocked states, and task completion.
+- Thinking timer next to collapsed `Thinking...` labels.
+- Caveman badge and Alt+C mode cycling when `pi-caveman` is loaded.
+- Subagent-name badge in `pi-agents-tmux` child panes.
 
 ## Install
 
@@ -24,108 +38,137 @@ vstack add vanillagreencom/vstack --pi-extension pi-qol --harness pi -y
 
 Restart Pi after installation.
 
-## What it provides
-
-- Compact statusline and `π` prompt editor: shows repo/project, branch/dirty state, model, colorized thinking level, optional Caveman badge, context window size, remaining context percent, and (inside `pi-agents-tmux` child panes) an ANSI-background subagent-name badge while replacing Pi's default footer/editor chrome.
-- Reliable multiline input: `Shift+Enter` / `Shift+Return` inserts a newline when the terminal reports it distinctly; `ctrl+j` is the default fallback newline key. `Alt+Enter` is reserved for Pi follow-up messages. QOL can also style Pi's built-in steering/follow-up pending queue preview with an ANSI green left bar while leaving the restore hint muted. When `pi-caveman` is loaded, `Alt+C` cycles Caveman modes.
-- Compact image placeholders: existing pasted image paths can collapse to `[Image #N]` aliases and are attached on submit.
-- Session naming: `/rename [name]` sets or shows the friendly session name; automatic first-prompt naming is enabled by default.
-- Context usage: `/context` prints an inline Claude-style context-window visualization with estimated Pi/model category breakdowns.
-- Previous-session search: `/search` and optional `F2` overlay search prior sessions, preview snippets, resume, inject summarized context, or start a new session with summarized context.
-- Handoff: `/handoff <goal>` drafts a focused prompt for a new session, preserving the latest compaction summary plus retained branch entries.
-- Optional permission gate: when enabled, prompts before configured `bash` tool command fragments run; default match is `rm -Rf`.
-- Notifications: terminal/tmux/native notifications for ready-for-input, questions, direction needed, task completion, and critical/blocked states.
-- Optional custom compaction and idle compaction; disabled by default so Pi's compaction behavior is unchanged until enabled.
-- Thinking timer next to collapsed `Thinking...` labels; enabled by default and falls back to Pi defaults if internals change.
-
 ## Commands
 
 | Command | Action |
 | --- | --- |
-| `/qol` | Open the extension-manager settings popup (falls back to inline status when the manager is not installed). |
+| `/qol` | Open settings (or print status if extension-manager isn't installed). |
 | `/qol notify-test` | Send a test notification. |
-| `/qol:rename` | Regenerate the current session name from the first user prompt. |
-| `/qol:rename:full` | Regenerate the session name from the full conversation. |
-| `/rename [name]` | Set or show the current session's friendly name. |
-| `/context` | Show inline context-window usage, model/context limit, and estimated category breakdowns. |
-| `/search [query]` | Open previous-session search, optionally prefilled with a query. |
+| `/rename [name]` | Set or show the current session's name. |
+| `/qol:rename` | Regenerate the session name from the first prompt. |
+| `/qol:rename:full` | Regenerate from the full conversation. |
+| `/context` | Show context-window usage with category breakdown. |
+| `/search [query]` | Open previous-session search. |
 | `/search:refresh` | Refresh the session search cache. |
-| `/search:resume-pending <id>` | Internal recovery command inserted into the editor when a resume/fork action must be confirmed by pressing Enter. |
-| `/handoff <goal>` | Draft a focused handoff prompt for a new session. |
+| `/handoff <goal>` | Draft a handoff prompt for a new session. |
 
-`/qol` and `/search` arguments support autocomplete.
+Arguments support autocomplete.
 
 ## Settings
 
-Settings are exposed through `pi-extension-manager` under **QOL**.
+All settings live in the extension manager under **QOL**. Names below match the labels shown there.
 
-### Statusline and prompt
+### Statusline
 
-- `replaceFooter`: hide Pi's default footer while QOL's compact statusline is active; default on.
-- `compactPrompt`: use the compact `π` prompt editor; default on.
-- `showSessionNameTitle`: show the named session above the prompt, or in tmux's pane title/border; default on.
-- `showSessionNameWindow`: also rename the current tmux window to `π <session>` so it appears in the tmux status line. Disables `automatic-rename` for the window while active and restores it on shutdown. Requires `showSessionNameTitle`; default on.
-- `inputBottomPaddingLines`: blank lines below the compact prompt; default `0`.
-- Git display knobs: `gitRefreshTimeoutMs`, `showDirtyMarker`.
-- If `pi-caveman` is loaded, QOL reads its bridge to show a Caveman icon in the statusline and to make `Alt+C` cycle Caveman modes. The Caveman package's `showStatusBadge` setting also controls this QOL badge.
-- If `pi-agents-tmux` is loaded inside a child pane, QOL reads its bridge/env metadata to show a trailing subagent-name badge after the context percent. The badge uses the agent `color:` frontmatter (`red`, `green`, `yellow`, `blue`, `magenta`, `cyan`; aliases `orange`, `purple`/`violet`, `teal`) or falls back to automatic color cycling.
+| Setting | What it does |
+| --- | --- |
+| Enable QOL editor helpers | Master toggle for QOL statusline, commands, notifications, search, compaction, and editor helpers. |
+| Replace built-in footer | Hide Pi's default footer while the QOL statusline is active. |
+| Use π prompt editor | Use the compact prompt editor. |
+| Show session name title | Show the session name above the prompt and in the tmux pane title. |
+| Sync session name to tmux window name | Rename the tmux window to `π <session>`. |
+| Input bottom padding | Blank lines below the prompt. |
+| Show dirty marker | Append `*` to the branch when the worktree is dirty. |
 
 ### Input
 
-- `newlineOnShiftEnter`: intercept distinguishable `Shift+Enter` / `Shift+Return` and insert a newline; default on.
-- `newlineFallbackKey`: alternate newline key for terminals that cannot distinguish shifted enter; default `ctrl+j`, or `none` to disable.
-- `pendingQueue.asciiGreen`: style Pi's built-in steering/follow-up pending queue preview with an ANSI green heavy left bar while keeping the Alt+Up restore hint in the theme hint color with a two-space indent; default on.
+| Setting | What it does |
+| --- | --- |
+| Shift+Enter inserts newline | Insert a newline instead of submitting on Shift+Enter. |
+| Fallback newline key | Alternate newline key for terminals that can't send Shift+Enter. |
+| Style pending queue preview | Highlight Pi's pending-queue preview with a green left bar. |
+| Style image chips | Render `[Image #N]` placeholders as distinct chips. |
+| Show attachment count | Show a status badge when the draft has image placeholders. |
 
-### Session auto-rename
+### Session naming
 
-- `sessionAutoRename.enabled`: automatically name unnamed sessions after the first prompt/agent turn; default on.
-- `sessionAutoRename.model`: naming model (`provider/model`, `current`, or `cheapest`); default `openai-codex/gpt-5.4-mini`.
-- `sessionAutoRename.fallbackModel`: fallback model; default `current`, or `none`/`off` to skip.
-- `sessionAutoRename.fallback`: deterministic fallback when model naming fails: `words`, `truncate`, or `none`.
-- Advanced knobs: `prefix`, `maxInputChars`, `maxNameChars`, `maxTokens`, `timeoutMs`, `prompt`, `notify`, and `debug`.
+| Setting | What it does |
+| --- | --- |
+| Enable /rename command | Register the `/rename` command. |
+| Auto-name new sessions | Generate a friendly session name from the first prompt. |
+| Auto-rename model | Model used for title generation. |
+| Auto-rename fallback model | Model tried when the primary fails. |
+| Deterministic fallback | Title-case words, truncated prompt, or none if all model calls fail. |
+| Auto-rename prefix | Optional static prefix on every generated name. |
+| Notify on auto-rename | Show a notification when auto-renaming. |
 
-### Session search
+Advanced: input cap, title length, output tokens, timeout, custom prompt template, and debug logging.
 
-- `sessionSearch.enabled`: register `/search` and the overlay.
-- `sessionSearch.shortcutKey`: shortcut to open search; default `f2`, set `none` to disable.
-- Search ordering: empty search shows prompts by recency; typed search sorts by match quality, then prompt recency.
-- Result/layout knobs: `resultLimit`, `maxVisible`, `messageMaxVisible`, `previewSnippets`, `overlayWidth`, `cacheTtlSeconds`.
-- Summary knobs: `summaryModel`, `summaryMaxTokens`, `summaryInputMaxChars`.
+### Handoff
 
-Search rows use Pi's `/resume`-style title: explicit session name, otherwise first user prompt, otherwise filename. The session cache is warmed on session start/first use and, by default, kept until `/search:refresh`; set `cacheTtlSeconds` above `0` if you want automatic time-based refreshes.
+| Setting | What it does |
+| --- | --- |
+| Enable /handoff command | Register the `/handoff` command. |
+| Review handoff prompt | Open an editor to edit the generated prompt before creating the session. |
+
+### Context window
+
+| Setting | What it does |
+| --- | --- |
+| Enable /context command | Register `/context`. |
 
-### Context usage
+### Session search
 
-- `enableContextCommand`: register `/context`; default on. The display uses Pi's `ctx.getContextUsage()` for total tokens/context window, then estimates the category split from the current system prompt, active tool definitions, session messages, compact summaries, context files, skills, and custom agents when Pi exposes that structured data.
+| Setting | What it does |
+| --- | --- |
+| Enable session search | Register `/search` and the overlay. |
+| Session search shortcut | Shortcut to open search. Default `f2`; set to `none` to disable. |
+| Result limit | Max matching prompts returned. |
+| Visible session rows | Rows shown before scrolling. |
+| Preview snippets | Matching snippets shown on the preview screen. |
+| Session cache TTL | Seconds before the session list refreshes; `0` keeps it until you run `/search:refresh`. |
+
+Summary settings (model, max tokens, input cap) tune the summarizer when you import context from a previous session.
 
 ### Notifications
 
-- Master and trigger toggles: `notification.enabled`, `onAgentReady`, `onDirectionNeeded`, `onQuestion`, `onTaskComplete`, `onCritical`.
-- Channels: BEL, native terminal notifications, tmux client TTY writes, tmux messages, optional tmux window marking, and Pi UI notifications.
-- `notification.oscProtocol`: `auto`, `osc777`, `osc99`, or `off`; `auto` uses Kitty OSC 99 when available, otherwise OSC 777.
-- Tuning: `cooldownSeconds`, `title`, `readyMessage`, `bodyMaxChars`, `tmuxMessageDurationMs`, and tmux mark text/duration.
+Master toggle: **Enable notifications**.
+
+Triggers (notify when): ready, direction needed, question popups, all tasks complete, critical/blocked.
+
+Channels: terminal bell, native terminal notifications (OSC 777/99 or Windows toast), tmux `display-message`, tmux window marking, OSC passthrough, and an optional in-Pi UI notice.
+
+Tuning: cooldown seconds, title, ready message, body length, tmux durations.
+
+Notes:
+
+- **Terminal notification protocol** picks between OSC 99 (Kitty) and OSC 777 automatically.
+- **Bell when tmux window active** is off so you don't get bells while looking at Pi.
+- **tmux native via client TTY** sends OSC notifications to attached tmux clients so notifications still appear when the Pi window is inactive.
 
-Use `/qol notify-test` to verify your terminal/tmux notification path.
+Use `/qol notify-test` to verify your terminal/tmux setup.
 
 ### Permission gate
 
-- `permissionGate.enabled`: ask before matching `bash` tool calls; default off. When enabled, non-interactive matches are blocked.
-- `permissionGate.commands`: comma-separated literal fragments or `/pattern/flags` regexes; default `rm -Rf`.
-- `permissionGate.previewLines` / `permissionGate.previewChars`: cap the approval prompt preview; long commands show a compact head/tail preview while the full command still runs only if approved.
+| Setting | What it does |
+| --- | --- |
+| Prompt before risky bash commands | Ask before bash commands matching the command list. |
+| Commands to prompt for | Comma-separated literal fragments or `/regex/flags`. |
+| Approval preview lines | Cap the approval-prompt preview height. |
+| Approval preview characters | Cap the approval-prompt preview width. |
 
-### Compaction
+Off by default. When enabled, non-interactive matches are blocked.
 
-- `compaction.customEnabled`: use QOL custom summaries for Pi compaction events; default off.
-- `compaction.model`: summarizer model; default `google/gemini-2.5-flash`.
-- `compaction.profile`: `concise`, `balanced`, or `exhaustive`.
-- `compaction.remoteEnabled` / `compaction.remoteEndpoint`: call a remote summarizer with `{ systemPrompt, prompt, maxTokens }` and expect `{ summary }`.
-- `compaction.branchSummaryEnabled`: use the same summarizer for requested `/tree` branch summaries.
-- `compaction.idleEnabled` and related thresholds: extension-managed idle compaction trigger.
+### Compaction
 
-### Thinking timer
+| Setting | What it does |
+| --- | --- |
+| Custom compaction summaries | Use QOL summaries instead of Pi's default. |
+| Compaction model | Summarizer model. |
+| Compaction detail profile | `concise`, `balanced`, or `exhaustive`. |
+| Include previous summary | Pass the previous summary for iterative continuity. |
+| Fallback to Pi default compaction | Run Pi's default compaction if QOL's fails. |
+| Show compaction notifications | Notify on compaction start/fail/complete. |
+| Custom branch summaries | Use the QOL summarizer for `/tree` branch summaries. |
+| Remote compaction endpoint | Call a remote HTTP summarizer instead of a model. |
+| Idle compaction trigger | Auto-compact after the session sits idle above a token threshold. |
 
-- `thinkingTimer.enabled`: show elapsed time next to collapsed `Thinking...` labels when the model emits thinking blocks.
+Idle thresholds (token threshold, idle delay, fixed token limit, percent limit) tune when idle compaction fires.
 
-## Notes
+### Thinking
 
-Pi owns native pending image attachment state and does not expose it to extensions. QOL can attach image paths it collapses itself; native Pi paste/drag attachments remain Pi-owned.
+| Setting | What it does |
+| --- | --- |
+| Hidden thinking label | Label shown when thinking blocks are hidden. |
+| Show thinking timer | Show elapsed time next to collapsed `Thinking...` labels. |
+| Working indicator mode | `animated` ticks every 80ms; switch to `static` if you see flashes when the chat overflows. |

package/extensions/qol/handoff.ts

@@ -6,6 +6,11 @@ import { serializeMessagesForSummary } from "./compaction.js";
 import { HANDOFF_SYSTEM_PROMPT } from "./constants.js";
 import { settingBoolean } from "./settings.js";
 
+function errorMessage(error: unknown): string {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.length > 180 ? `${message.slice(0, 179)}…` : message;
+}
+
 export async function runHandoff(args: string, ctx: ExtensionCommandContext): Promise<void> {
 	if (!ctx.hasUI) {
 		ctx.ui.notify("handoff requires interactive mode", "error");
@@ -36,56 +41,58 @@ export async function runHandoff(args: string, ctx: ExtensionCommandContext): Pr
 
 	const releaseModalLock = acquireVstackModalLock();
 	let result: string | null = null;
+	let generationError: unknown;
 	try {
-	result = await ctx.ui.custom<string | null>((tui: any, theme: any, _kb: any, done: (value: string | null) => void) => {
-		const loader = new BorderedLoader(tui, theme, "Generating handoff prompt...");
-		loader.onAbort = () => done(null);
-
-		const doGenerate = async () => {
-			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model!);
-			if (!auth.ok || !auth.apiKey) {
-				throw new Error(auth.ok ? `No API key for ${ctx.model!.provider}` : auth.error);
-			}
-
-			const userMessage: Message = {
-				role: "user",
-				content: [
-					{
-						type: "text",
-						text: `## Conversation History\n\n${conversationText}\n\n## User's Goal for New Thread\n\n${goal}`,
-					},
-				],
-				timestamp: Date.now(),
+		result = await ctx.ui.custom<string | null>((tui: any, theme: any, _kb: any, done: (value: string | null) => void) => {
+			const loader = new BorderedLoader(tui, theme, "Generating handoff prompt...");
+			loader.onAbort = () => done(null);
+
+			const doGenerate = async () => {
+				const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model!);
+				if (!auth.ok || !auth.apiKey) {
+					throw new Error(auth.ok ? `No API key for ${ctx.model!.provider}` : auth.error);
+				}
+
+				const userMessage: Message = {
+					role: "user",
+					content: [
+						{
+							type: "text",
+							text: `## Conversation History\n\n${conversationText}\n\n## User's Goal for New Thread\n\n${goal}`,
+						},
+					],
+					timestamp: Date.now(),
+				};
+
+				const response = await complete(
+					ctx.model!,
+					{ systemPrompt: HANDOFF_SYSTEM_PROMPT, messages: [userMessage] },
+					{ apiKey: auth.apiKey, headers: auth.headers, signal: loader.signal },
+				);
+
+				if (response.stopReason === "aborted") return null;
+				return response.content
+					.filter((content): content is { type: "text"; text: string } => content.type === "text")
+					.map((content) => content.text)
+					.join("\n");
 			};
 
-			const response = await complete(
-				ctx.model!,
-				{ systemPrompt: HANDOFF_SYSTEM_PROMPT, messages: [userMessage] },
-				{ apiKey: auth.apiKey, headers: auth.headers, signal: loader.signal },
-			);
-
-			if (response.stopReason === "aborted") return null;
-			return response.content
-				.filter((content): content is { type: "text"; text: string } => content.type === "text")
-				.map((content) => content.text)
-				.join("\n");
-		};
-
-		doGenerate()
-			.then(done)
-			.catch((error) => {
-				console.error("Handoff generation failed:", error);
-				done(null);
-			});
-
-		return loader;
-	});
+			doGenerate()
+				.then(done)
+				.catch((error) => {
+					generationError = error;
+					done(null);
+				});
+
+			return loader;
+		});
 	} finally {
 		releaseModalLock();
 	}
 
 	if (result === null) {
-		ctx.ui.notify("Cancelled", "info");
+		if (generationError) ctx.ui.notify(`Handoff generation failed: ${errorMessage(generationError)}`, "error");
+		else ctx.ui.notify("Cancelled", "info");
 		return;
 	}
 

package/extensions/qol/session-rename.ts

@@ -30,6 +30,14 @@ export function autoRenameEnabled(cwd?: string): boolean {
 	return settingBoolean("sessionAutoRename.enabled", true, cwd);
 }
 
+// pi raises this exact prefix when a captured ExtensionContext is touched
+// after newSession / fork / switchSession / reload. Recognising it lets us
+// abort gracefully instead of crashing the host process.
+export function isStaleCtxError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+	return /extension ctx is stale/i.test(message);
+}
+
 function autoRenameCtxAlive(ctx: ExtensionContext): boolean {
 	// Auto-rename runs from a deferred timer / async path, so the captured
 	// extension context can be invalidated mid-flight by newSession / fork /
@@ -44,6 +52,16 @@ function autoRenameCtxAlive(ctx: ExtensionContext): boolean {
 	}
 }
 
+// Read a ctx property without crashing if the ctx has been replaced. Used
+// for the cwd-derived setting reads that downstream helpers depend on.
+function readCtxCwd(ctx: ExtensionContext): string | undefined {
+	try {
+		return ctx.cwd;
+	} catch {
+		return undefined;
+	}
+}
+
 function autoRenameDebug(ctx: ExtensionContext, message: string, level: "info" | "warning" | "error" = "info"): void {
 	if (!autoRenameCtxAlive(ctx)) return;
 	if (settingBoolean("sessionAutoRename.debug", false, ctx.cwd)) ctx.ui.notify(`[auto-rename] ${message}`, level);
@@ -230,7 +248,13 @@ function modelCost(model: any): number {
 }
 
 async function cheapestAvailableAutoRenameModel(ctx: ExtensionContext): Promise<AutoRenameAuth | undefined> {
-	const registry = ctx.modelRegistry as any;
+	let registry: any;
+	try {
+		registry = ctx.modelRegistry as any;
+	} catch (error) {
+		if (isStaleCtxError(error)) return undefined;
+		throw error;
+	}
 	const rawModels = typeof registry.getAvailable === "function" ? registry.getAvailable() : typeof registry.getAll === "function" ? registry.getAll() : [];
 	const models = Array.isArray(rawModels) ? rawModels.filter((model) => model?.input?.includes?.("text") ?? true) : [];
 	models.sort((a, b) => modelCost(a) - modelCost(b) || modelLabel(a).localeCompare(modelLabel(b)));
@@ -239,7 +263,8 @@ async function cheapestAvailableAutoRenameModel(ctx: ExtensionContext): Promise<
 			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
 			const headers = headerRecord(auth.headers);
 			if (auth.ok && (auth.apiKey || headers)) return { apiKey: auth.apiKey, headers, label: modelLabel(model), model, source: "cheapest" };
-		} catch {
+		} catch (error) {
+			if (isStaleCtxError(error)) return undefined;
 			// Try the next available model.
 		}
 	}
@@ -247,48 +272,58 @@ async function cheapestAvailableAutoRenameModel(ctx: ExtensionContext): Promise<
 }
 
 async function resolveAutoRenameModel(ctx: ExtensionContext, configured: string): Promise<AutoRenameAuth | undefined> {
-	if (configured.trim().toLowerCase() === "cheapest") return cheapestAvailableAutoRenameModel(ctx);
-	const model = resolveConfiguredModel(ctx, configured);
-	if (!model) {
-		autoRenameDebug(ctx, `model not found: ${configured}`, "warning");
-		return undefined;
-	}
 	try {
-		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-		const headers = headerRecord(auth.headers);
-		if (!auth.ok) {
-			autoRenameDebug(ctx, `auth unavailable for ${modelLabel(model)}: ${auth.error}`, "warning");
+		if (configured.trim().toLowerCase() === "cheapest") return await cheapestAvailableAutoRenameModel(ctx);
+		const model = resolveConfiguredModel(ctx, configured);
+		if (!model) {
+			autoRenameDebug(ctx, `model not found: ${configured}`, "warning");
 			return undefined;
 		}
-		if (!auth.apiKey && !headers) {
-			autoRenameDebug(ctx, `no auth for ${modelLabel(model)}; use /login or models.json`, "warning");
+		try {
+			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+			const headers = headerRecord(auth.headers);
+			if (!auth.ok) {
+				autoRenameDebug(ctx, `auth unavailable for ${modelLabel(model)}: ${auth.error}`, "warning");
+				return undefined;
+			}
+			if (!auth.apiKey && !headers) {
+				autoRenameDebug(ctx, `no auth for ${modelLabel(model)}; use /login or models.json`, "warning");
+				return undefined;
+			}
+			return { apiKey: auth.apiKey, headers, label: modelLabel(model), model, source: configured };
+		} catch (error) {
+			if (isStaleCtxError(error)) return undefined;
+			autoRenameDebug(ctx, `auth failed for ${modelLabel(model)}: ${stringifyError(error)}`, "warning");
 			return undefined;
 		}
-		return { apiKey: auth.apiKey, headers, label: modelLabel(model), model, source: configured };
 	} catch (error) {
-		autoRenameDebug(ctx, `auth failed for ${modelLabel(model)}: ${stringifyError(error)}`, "warning");
-		return undefined;
+		if (isStaleCtxError(error)) return undefined;
+		throw error;
 	}
 }
 
 export async function generateAutoRenameName(query: string, ctx: ExtensionContext, fullConversation = false): Promise<{ name?: string; source: string }> {
-	const maxNameChars = Math.max(20, Math.floor(settingNumber("sessionAutoRename.maxNameChars", DEFAULT_AUTO_RENAME_NAME_CHARS, ctx.cwd)));
-	const maxTokens = Math.max(16, Math.floor(settingNumber("sessionAutoRename.maxTokens", DEFAULT_AUTO_RENAME_MAX_TOKENS, ctx.cwd)));
+	// Snapshot cwd once. If the ctx has already gone stale, fall through with
+	// undefined cwd — downstream settings reads handle that and the rename
+	// will abort with "none".
+	const cwd = readCtxCwd(ctx);
+	const maxNameChars = Math.max(20, Math.floor(settingNumber("sessionAutoRename.maxNameChars", DEFAULT_AUTO_RENAME_NAME_CHARS, cwd)));
+	const maxTokens = Math.max(16, Math.floor(settingNumber("sessionAutoRename.maxTokens", DEFAULT_AUTO_RENAME_MAX_TOKENS, cwd)));
 	const prompt = fullConversation
 		? `${AUTO_RENAME_SYSTEM_PROMPT}\n\nName this session using the conversation transcript below. Return only the title.\n\n${query}`
-		: autoRenamePrompt(query, ctx.cwd);
+		: autoRenamePrompt(query, cwd);
 	const message: Message = {
 		content: [{ text: prompt, type: "text" }],
 		role: "user",
 		timestamp: Date.now(),
 	};
 
-	for (const configured of autoRenameModelSettings(ctx.cwd)) {
+	for (const configured of autoRenameModelSettings(cwd)) {
 		const resolved = await resolveAutoRenameModel(ctx, configured);
 		if (!resolved) continue;
 		try {
 			const controller = new AbortController();
-			const timeoutMs = Math.max(1000, Math.floor(settingNumber("sessionAutoRename.timeoutMs", DEFAULT_AUTO_RENAME_TIMEOUT_MS, ctx.cwd)));
+			const timeoutMs = Math.max(1000, Math.floor(settingNumber("sessionAutoRename.timeoutMs", DEFAULT_AUTO_RENAME_TIMEOUT_MS, cwd)));
 			const timeout = setTimeout(() => controller.abort(), timeoutMs);
 			timeout.unref?.();
 			try {
@@ -308,12 +343,13 @@ export async function generateAutoRenameName(query: string, ctx: ExtensionContex
 				clearTimeout(timeout);
 			}
 		} catch (error) {
+			if (isStaleCtxError(error)) return { source: "none" };
 			autoRenameDebug(ctx, `${resolved.label} failed: ${stringifyError(error)}`, "warning");
 		}
 	}
 
-	const deterministic = deterministicAutoRenameName(query, ctx.cwd);
-	return deterministic ? { name: deterministic, source: `fallback:${autoRenameFallbackMode(ctx.cwd)}` } : { source: "none" };
+	const deterministic = deterministicAutoRenameName(query, cwd);
+	return deterministic ? { name: deterministic, source: `fallback:${autoRenameFallbackMode(cwd)}` } : { source: "none" };
 }
 
 export function withAutoRenamePrefix(name: string, cwd?: string): string {

package/extensions/qol.ts

@@ -50,6 +50,7 @@ import {
 	conversationTranscriptText,
 	firstUserMessageText,
 	generateAutoRenameName,
+	isStaleCtxError,
 	withAutoRenamePrefix,
 } from "./qol/session-rename.js";
 import {
@@ -122,34 +123,56 @@ export default function qol(pi: ExtensionAPI): void {
 	};
 
 	const attemptAutoRename = async (ctx: ExtensionContext, options: { force?: boolean; fullConversation?: boolean; notify?: boolean } = {}) => {
-		const force = options.force === true;
-		if (!force && !autoRenameEnabled(ctx.cwd)) return;
-		if (autoRenameInProgress) return;
-		if (!force && (autoRenameAttempted || pi.getSessionName())) return;
-		const branch = ctx.sessionManager.getBranch?.() ?? [];
-		const maxInputChars = Math.max(200, Math.floor(settingNumber("sessionAutoRename.maxInputChars", 2000, ctx.cwd)));
-		const sourceText = options.fullConversation ? conversationTranscriptText(branch, maxInputChars) : firstUserMessageText(branch);
-		if (!sourceText) {
-			if (force) autoRenameNotify(ctx, "No user message found to name this session.", "warning", true);
-			return;
-		}
-		const generation = autoRenameGeneration;
-		if (!force) autoRenameAttempted = true;
-		autoRenameInProgress = true;
+		// All ctx reads here can throw if the captured context has been replaced
+		// by newSession / fork / switchSession / reload. Wrap the whole body so
+		// a stale ctx aborts the rename quietly instead of crashing pi (and
+		// killing the in-flight tool dispatch that triggered agent_end).
 		try {
-			const result = await generateAutoRenameName(sourceText, ctx, options.fullConversation === true);
-			if (generation !== autoRenameGeneration) return;
-			if (!result.name) {
-				autoRenameNotify(ctx, "No session name generated.", "warning", options.notify === true || force);
+			const force = options.force === true;
+			let cwd: string | undefined;
+			try {
+				cwd = ctx.cwd;
+			} catch (error) {
+				if (isStaleCtxError(error)) return;
+				throw error;
+			}
+			if (!force && !autoRenameEnabled(cwd)) return;
+			if (autoRenameInProgress) return;
+			if (!force && (autoRenameAttempted || pi.getSessionName())) return;
+			let branch;
+			try {
+				branch = ctx.sessionManager.getBranch?.() ?? [];
+			} catch (error) {
+				if (isStaleCtxError(error)) return;
+				throw error;
+			}
+			const maxInputChars = Math.max(200, Math.floor(settingNumber("sessionAutoRename.maxInputChars", 2000, cwd)));
+			const sourceText = options.fullConversation ? conversationTranscriptText(branch, maxInputChars) : firstUserMessageText(branch);
+			if (!sourceText) {
+				if (force) autoRenameNotify(ctx, "No user message found to name this session.", "warning", true);
 				return;
 			}
-			if (!force && pi.getSessionName()) return;
-			const name = withAutoRenamePrefix(result.name, ctx.cwd);
-			if (!name) return;
-			pi.setSessionName(name);
-			autoRenameNotify(ctx, `Session named: ${name} (${result.source})`, "info", options.notify === true || force);
-		} finally {
-			if (generation === autoRenameGeneration) autoRenameInProgress = false;
+			const generation = autoRenameGeneration;
+			if (!force) autoRenameAttempted = true;
+			autoRenameInProgress = true;
+			try {
+				const result = await generateAutoRenameName(sourceText, ctx, options.fullConversation === true);
+				if (generation !== autoRenameGeneration) return;
+				if (!result.name) {
+					autoRenameNotify(ctx, "No session name generated.", "warning", options.notify === true || force);
+					return;
+				}
+				if (!force && pi.getSessionName()) return;
+				const name = withAutoRenamePrefix(result.name, cwd);
+				if (!name) return;
+				pi.setSessionName(name);
+				autoRenameNotify(ctx, `Session named: ${name} (${result.source})`, "info", options.notify === true || force);
+			} finally {
+				if (generation === autoRenameGeneration) autoRenameInProgress = false;
+			}
+		} catch (error) {
+			if (isStaleCtxError(error)) return;
+			throw error;
 		}
 	};
 
@@ -171,7 +194,10 @@ export default function qol(pi: ExtensionAPI): void {
 
 	const startThinkingTimerTicker = () => {
 		if (thinkingTimerTicker) return;
-		thinkingTimerTicker = setInterval(tickThinkingTimer, 100);
+		// 250ms cadence (was 100ms): user-visible precision of "thinking 1.2s" still feels live,
+		// but render rate drops 2.5x. Every tick mutates an inline chat label, which makes the
+		// pi-tui above-viewport diff (firstChanged < prevViewportTop) fire as full-screen redraws.
+		thinkingTimerTicker = setInterval(tickThinkingTimer, 250);
 		thinkingTimerTicker.unref?.();
 	};
 
@@ -185,6 +211,27 @@ export default function qol(pi: ExtensionAPI): void {
 		thinkingTimerStore.enabled = !!ctx?.hasUI && settingBoolean("thinkingTimer.enabled", true, ctx?.cwd);
 	};
 
+	// Working indicator mode.
+	// The built-in pi-tui Loader ticks every 80ms during streaming. Each tick
+	// mutates a line in statusContainer; once total rendered content exceeds the
+	// terminal viewport (overlay content like /tree, or chat overflow), every tick
+	// trips pi-tui's firstChanged < prevViewportTop branch and triggers a full
+	// screen + scrollback clear (visible flash). This setting lets the user trade
+	// the spinner animation away for a stable display in overflow scenarios.
+	// Implementation note: Loader.restartAnimation() bails out when frames.length
+	// is <= 1, so a single-frame indicator does NOT start the setInterval at all.
+	const applyWorkingIndicatorMode = (ctx: ExtensionContext): void => {
+		if (!ctx.hasUI) return;
+		const mode = settingString("workingIndicator.mode", "animated", ctx.cwd);
+		if (mode === "static") {
+			ctx.ui.setWorkingVisible(true);
+			ctx.ui.setWorkingIndicator({ frames: [ctx.ui.theme.fg("accent", "●")] });
+			return;
+		}
+		ctx.ui.setWorkingVisible(true);
+		ctx.ui.setWorkingIndicator(undefined);
+	};
+
 	const updateThinkingTimerEnabled = (ctx: ExtensionContext): boolean => {
 		thinkingTimerStore.cwd = ctx.cwd;
 		thinkingTimerStore.theme = ctx.ui.theme;
@@ -218,15 +265,36 @@ export default function qol(pi: ExtensionAPI): void {
 		const delayMs = Math.max(1, Math.floor(settingNumber("compaction.idleTimeoutSeconds", DEFAULT_IDLE_COMPACTION_SECONDS, ctx.cwd))) * 1000;
 		idleCompactionTimer = setTimeout(() => {
 			idleCompactionTimer = undefined;
-			if (!ctx.isIdle?.()) return;
+			// Same stale-ctx risk as auto-rename: the captured ctx may be invalidated
+			// by newSession/fork/switchSession/reload between schedule and fire.
+			// Bail silently if so; the next session_start will reschedule.
+			try {
+				if (!ctx.isIdle?.()) return;
+			} catch (error) {
+				if (isStaleCtxError(error)) return;
+				throw error;
+			}
 			const latestReason = compactionTriggerReason(ctx);
 			if (!latestReason) return;
-			if (ctx.hasUI && settingBoolean("compaction.notify", true, ctx.cwd)) ctx.ui.notify(`QOL idle compaction starting: ${latestReason}`, "info");
-			ctx.compact?.({
-				customInstructions: `QOL idle compaction triggered after inactivity because ${latestReason}. Preserve current task state, decisions, files, blockers, and next steps.`,
-				onComplete: () => { if (ctx.hasUI && settingBoolean("compaction.notify", true, ctx.cwd)) ctx.ui.notify("QOL idle compaction completed.", "info"); },
-				onError: (error: Error) => { if (ctx.hasUI && settingBoolean("compaction.notify", true, ctx.cwd)) ctx.ui.notify(`QOL idle compaction failed: ${stringifyError(error)}`, "error"); },
-			});
+			const notifySafely = (message: string, level: "info" | "error") => {
+				try {
+					if (ctx.hasUI && settingBoolean("compaction.notify", true, ctx.cwd)) ctx.ui.notify(message, level);
+				} catch (error) {
+					if (isStaleCtxError(error)) return;
+					throw error;
+				}
+			};
+			notifySafely(`QOL idle compaction starting: ${latestReason}`, "info");
+			try {
+				ctx.compact?.({
+					customInstructions: `QOL idle compaction triggered after inactivity because ${latestReason}. Preserve current task state, decisions, files, blockers, and next steps.`,
+					onComplete: () => notifySafely("QOL idle compaction completed.", "info"),
+					onError: (error: Error) => notifySafely(`QOL idle compaction failed: ${stringifyError(error)}`, "error"),
+				});
+			} catch (error) {
+				if (isStaleCtxError(error)) return;
+				throw error;
+			}
 		}, delayMs);
 		idleCompactionTimer.unref?.();
 	};
@@ -447,6 +515,7 @@ export default function qol(pi: ExtensionAPI): void {
 		installPendingQueueThemePatch(ctx);
 		if (ctx.hasUI) {
 			ctx.ui.setHiddenThinkingLabel(hiddenThinkingLabel(ctx.ui.theme, ctx.cwd));
+			applyWorkingIndicatorMode(ctx);
 			gitState = makeFallbackGitState(ctx.cwd);
 			void refreshStatusline(ctx);
 			installSessionTitle(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanillagreen/pi-qol",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Pi quality-of-life extension: compact statusline/π prompt, reliable multiline input, styled pasted-image chips, session naming/search/context import, handoff, permission prompts, notifications, custom compaction, and a collapsed-thinking timer.",
   "license": "MIT",
   "keywords": [
@@ -800,6 +800,20 @@
           "default": true,
           "category": "Thinking",
           "apply": "live"
+        },
+        {
+          "key": "workingIndicator.mode",
+          "label": "Working indicator mode",
+          "description": "Control Pi's built-in streaming spinner. The default animated spinner ticks every 80ms; in terminals where rendered content overflows the viewport (chat scrolled past the top, /tree open, etc.) each tick can trigger a pi-tui full-screen redraw and visible flash. Use 'static' for a single non-animating dot that keeps the working row visible without the 80ms timer.",
+          "type": "enum",
+          "enumValues": [
+            "animated",
+            "static"
+          ],
+          "default": "animated",
+          "category": "Thinking",
+          "apply": "reload",
+          "requiresReload": true
         }
       ]
     }