@vanillagreen/pi-qol 2.1.1 → 2.2.1

package/README.md

@@ -14,11 +14,11 @@ A Pi extension for session controls, prompt editing and notifications. Users can
 source = "kendex"
 ```
 
-Restart Pi after installation. Use `kendex update-pi --check` to preview the installation.
+Requires Pi 0.86.0 or newer. Restart Pi after installation. Use `kendex update-pi --check` to preview the installation.
 
 ## Features
 
-- Show repository, model and context information beside the editor.
+- Show repository, model and context information beside the editor, with the working spinner before the project name.
 - Name and search sessions.
 - Schedule prompts and prepare handoff drafts.
 - Ask before configured shell commands run.
@@ -36,7 +36,7 @@ The settings editor writes project values to `.pi/settings.json`. The default us
 Open `/extensions:settings`; settings appear under the **QOL** tab. Project settings in `.pi/settings.json` apply only after Pi marks the workspace trusted. `glyphStyle` picks `unicode` or `ascii` symbols, and `@vanillagreen/pi-tool-renderer`'s `globalGlyphStyleOverride` wins when set.
 
 - `enabled`: package toggle for everything below.
-- Statusline and editor: `statusline.enabled`, `statusline.showAccount`, `replaceFooter`, `compactPrompt`, `showSessionNameTitle`, `showSessionNameWindow`, `inputBottomPaddingLines`, `gitRefreshTimeoutMs`, `showDirtyMarker`, `newlineOnShiftEnter`, `newlineFallbackKey`, `pendingQueue.asciiGreen`, `showImageChips`, `showAttachmentCountInStatus`.
+- Statusline and editor: `statusline.enabled`, `statusline.showProvider`, `statusline.showAccount`, `replaceFooter`, `compactPrompt`, `showSessionNameTitle`, `showSessionNameWindow`, `inputBottomPaddingLines`, `gitRefreshTimeoutMs`, `showDirtyMarker`, `newlineOnShiftEnter`, `newlineFallbackKey`, `pendingQueue.asciiGreen`, `showImageChips`, `showAttachmentCountInStatus`.
 - Commands: `enableSessionNameCommand`, `enableHandoffCommand`, `enableScheduleCommand`, `enableContextCommand`, `handoffReviewPrompt`.
 - Session naming: `sessionAutoRename.*` (model, fallback model, deterministic fallback, prefix, prompt, limits, notify, debug).
 - Session search: `sessionSearch.*` (shortcut, result and row limits, snippets, overlay width, cache TTL, summary model and limits).
@@ -47,4 +47,6 @@ Open `/extensions:settings`; settings appear under the **QOL** tab. Project sett
   - Pi's own `compaction.enabled` (the top-level `compaction` object in the same settings files, not a QOL key) turns off every automatic compaction: when it is `false`, neither the budget guard nor the idle trigger starts one, and `/qol` reports both as disabled by that key. A manual `/compact` still runs. While it is `true` or absent, both keep the defaults and thresholds above: the budget guard on at `compaction.budgetPercent` 85, the idle trigger off until `compaction.idleEnabled` is set.
 - Thinking: `thinkingLabel.text`, `thinkingTimer.enabled`, `workingIndicator.mode` (`static` if the animated indicator flashes).
 
+**Show model provider** displays a readable provider name before the model, such as `Copilot / GPT 6 Astra`. It is on by default; changes apply on the next render without reloading. Disabling the QOL statusline leaves Pi's standalone working indicator in place.
+
 Maintainer notes are in [DEVELOPMENT.md](DEVELOPMENT.md).

package/extensions/qol/constants.ts

@@ -33,6 +33,8 @@ export const DEFAULT_NOTIFICATION_TITLE = "Pi";
 export const DEFAULT_NOTIFICATION_COOLDOWN_SECONDS = 8;
 export const DEFAULT_NOTIFICATION_BODY_MAX_CHARS = 240;
 export const DEFAULT_TMUX_MESSAGE_DURATION_MS = 5000;
+/** Deadline for each tmux call a notification makes; a stalled server is skipped, not waited on. */
+export const TMUX_COMMAND_TIMEOUT_MS = 1000;
 
 export const DEFAULT_COMPACTION_MODEL = "current";
 export const DEFAULT_COMPACTION_MAX_TOKENS = 8192;

package/extensions/qol/editor.ts

@@ -101,7 +101,25 @@ function syncQolEditorStatus(
 	}
 }
 
-export class QolEditor extends CustomEditor {
+type WorkingStatusIndicator = Parameters<CustomEditor["setWorkingStatusIndicator"]>[0];
+
+// Pi owns the indicator's animation and lifetime. Opt into its embedded-status
+// delivery, but draw in the statusline widget rather than the editor border.
+class QolStatusEditor extends CustomEditor {
+	private statuslineIndicator: WorkingStatusIndicator;
+
+	override setWorkingStatusIndicator(indicator: WorkingStatusIndicator): void {
+		this.statuslineIndicator = indicator;
+	}
+
+	renderWorkingStatus(width: number): string {
+		const indicator = this.statuslineIndicator;
+		if (!indicator || !this.embedWorkingStatus) return "";
+		return indicator.kind === "working" ? indicator.renderSpinnerInBorder(width) : indicator.renderInBorder(width);
+	}
+}
+
+export class QolEditor extends QolStatusEditor {
 	private readonly statusCache: { last?: string } = {};
 	private readonly ctx: ExtensionContext;
 
@@ -111,7 +129,7 @@ export class QolEditor extends CustomEditor {
 		keybindings: KeybindingsManager,
 		ctx: ExtensionContext,
 	) {
-		super(tui, editorTheme, keybindings);
+		super(tui, editorTheme, keybindings, { embedWorkingStatus: settingBoolean("statusline.enabled", true, ctx.cwd) });
 		this.ctx = ctx;
 	}
 
@@ -130,7 +148,7 @@ function isEditorBorderLine(line: string): boolean {
 	return visible.length > 0 && /^[─━╭╮╰╯┌┐└┘]+$/.test(visible);
 }
 
-export class QolCompactPromptEditor extends CustomEditor {
+export class QolCompactPromptEditor extends QolStatusEditor {
 	private readonly statusCache: { last?: string } = {};
 	private readonly inputBottomPaddingLines: number;
 	private readonly ctx: ExtensionContext;
@@ -142,7 +160,7 @@ export class QolCompactPromptEditor extends CustomEditor {
 		inputBottomPaddingLines: number,
 		ctx: ExtensionContext,
 	) {
-		super(tui, editorTheme, keybindings, { paddingX: 0 });
+		super(tui, editorTheme, keybindings, { paddingX: 0, embedWorkingStatus: settingBoolean("statusline.enabled", true, ctx.cwd) });
 		this.inputBottomPaddingLines = inputBottomPaddingLines;
 		this.ctx = ctx;
 	}

package/extensions/qol/notifications.ts

@@ -1,18 +1,22 @@
-import { execFile, execFileSync } from "node:child_process";
-import { writeFileSync } from "node:fs";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { execFile } from "node:child_process";
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
 	DEFAULT_NOTIFICATION_BODY_MAX_CHARS,
 	DEFAULT_NOTIFICATION_COOLDOWN_SECONDS,
 	DEFAULT_NOTIFICATION_TITLE,
 	DEFAULT_TMUX_MESSAGE_DURATION_MS,
 	QUESTION_NOTIFY_DEDUP_MS,
+	TMUX_COMMAND_TIMEOUT_MS,
 } from "./constants.js";
 import { settingBoolean, settingNumber, settingString } from "./settings.js";
 import type { QuestionOpenedEventLike, QuestionRequestLike } from "./bridges.js";
 
 export type QolNotificationKind = "ready" | "direction" | "question" | "task-complete" | "critical" | "test";
 export type QolNotificationLevel = "info" | "warning" | "error";
+/** The one Pi call notifications need: `pi.exec`, whose `timeout` kills a stalled tmux. */
+export type QolNotificationExec = Pick<ExtensionAPI, "exec">;
 
 export interface QolNotificationService {
 	notifyQuestionOpened(ctx: ExtensionContext | undefined, event: QuestionOpenedEventLike): boolean;
@@ -65,54 +69,93 @@ function notificationBellMuted(cwd?: string): boolean {
 	return settingBoolean("notification.muteBellSound", false, cwd);
 }
 
-function sourcePaneTty(): string | undefined {
-	try {
-		if (!process.env.TMUX_PANE) return undefined;
-		const tty = execFileSync("tmux", ["display-message", "-p", "-t", process.env.TMUX_PANE, "#{pane_tty}"], { encoding: "utf8" }).trim();
-		return tty || undefined;
-	} catch {
-		return undefined;
-	}
+/** The source pane as one tmux query reports it when a notification fires. */
+interface TmuxPaneState {
+	paneTty: string;
+	windowActive: boolean;
+	sessionId: string;
+	windowId: string;
+	windowName: string;
 }
 
-function sourceTmuxSession(): string | undefined {
+/** `#W` is last: a window name may hold a tab, so every field after the fourth is the name. */
+const PANE_STATE_FORMAT = "#{pane_tty}\t#{window_active}\t#{session_id}\t#{window_id}\t#W";
+
+/**
+ * Every terminal write joins this chain and runs alone, in queue order. Each
+ * write opens its tty non-blocking, so a full terminal fails the write rather
+ * than holding it, and the chain always advances.
+ */
+let terminalWrites: Promise<void> = Promise.resolve();
+/** Bumped by `clearTmuxWindowMark`; a notification decided before the bump does not mark. */
+let tmuxMarkGeneration = 0;
+
+/**
+ * Runs one tmux command under `TMUX_COMMAND_TIMEOUT_MS`. Undefined means no
+ * answer: a non-zero exit, a timeout, or a Pi runtime that went stale after
+ * session replacement (`pi.exec` then throws). Pi reports a command its
+ * timeout killed with `killed` and, when the signal left no exit status,
+ * with code 0, so `killed` is read first.
+ */
+async function tmux(pi: QolNotificationExec, args: string[]): Promise<string | undefined> {
 	try {
-		if (!process.env.TMUX_PANE) return undefined;
-		const session = execFileSync("tmux", ["display-message", "-p", "-t", process.env.TMUX_PANE, "#{session_name}"], { encoding: "utf8" }).trim();
-		return session || undefined;
+		const result = await pi.exec("tmux", args, { timeout: TMUX_COMMAND_TIMEOUT_MS });
+		if (result.killed || result.code !== 0) return undefined;
+		return result.stdout;
 	} catch {
 		return undefined;
 	}
 }
 
-export function sourceTmuxWindowActive(): boolean {
-	try {
-		if (!process.env.TMUX_PANE) return false;
-		const active = execFileSync("tmux", ["display-message", "-p", "-t", process.env.TMUX_PANE, "#{window_active}"], { encoding: "utf8" }).trim();
-		return active === "1";
-	} catch {
-		return false;
-	}
+/**
+ * Reads the source pane once per notification. The session and window are
+ * read fresh each time: tmux `break-pane`, `join-pane` and `move-window` move
+ * a pane to another window or session and keep its id and tty.
+ */
+async function sourceTmuxPaneState(pi: QolNotificationExec): Promise<TmuxPaneState | undefined> {
+	const pane = process.env.TMUX_PANE;
+	if (!pane) return undefined;
+	const stdout = await tmux(pi, ["display-message", "-p", "-t", pane, PANE_STATE_FORMAT]);
+	const [paneTty = "", windowActive = "", sessionId = "", windowId = "", ...name] = (stdout ?? "").replace(/\r?\n$/, "").split("\t");
+	if (!paneTty || !sessionId || !windowId) return undefined;
+	return { paneTty, windowActive: windowActive === "1", sessionId, windowId, windowName: name.join("\t") };
+}
+
+async function tmuxClientTtys(pi: QolNotificationExec, pane: TmuxPaneState | undefined): Promise<string[]> {
+	if (!process.env.TMUX) return [];
+	const args = ["list-clients", "-F", "#{client_tty}"];
+	if (pane) args.splice(1, 0, "-t", pane.sessionId);
+	const output = await tmux(pi, args);
+	if (output === undefined) return [];
+	return [...new Set(output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean))];
 }
 
-function tmuxClientTtys(): string[] {
+function queueTerminalWrite(write: () => Promise<void>): Promise<void> {
+	const queued = terminalWrites.then(write);
+	terminalWrites = queued.catch(() => undefined);
+	return queued;
+}
+
+/**
+ * Writes to a terminal without waiting on it. A tmux client whose SSH link
+ * dropped stays attached with a full tty buffer, and a blocking write to it
+ * would hang until the link times out; non-blocking, it fails with `EAGAIN`.
+ * `O_NOCTTY` keeps the open from making the tty Pi's controlling terminal.
+ */
+async function writeTty(path: string, output: string): Promise<void> {
+	const handle = await open(path, constants.O_WRONLY | constants.O_NONBLOCK | constants.O_NOCTTY);
 	try {
-		if (!process.env.TMUX) return [];
-		const session = sourceTmuxSession();
-		const args = ["list-clients", "-F", "#{client_tty}"];
-		if (session) args.splice(1, 0, "-t", session);
-		const output = execFileSync("tmux", args, { encoding: "utf8" });
-		return [...new Set(output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean))];
-	} catch {
-		return [];
+		await handle.writeFile(output, "utf8");
+	} finally {
+		await handle.close();
 	}
 }
 
-function writeRawToPaths(paths: string[], output: string): boolean {
+async function writeRawToPaths(paths: string[], output: string): Promise<boolean> {
 	let wrote = false;
 	for (const path of paths) {
 		try {
-			writeFileSync(path, output, "utf8");
+			await writeTty(path, output);
 			wrote = true;
 		} catch {
 			// Try remaining paths.
@@ -121,10 +164,9 @@ function writeRawToPaths(paths: string[], output: string): boolean {
 	return wrote;
 }
 
-function writeToTerminal(output: string): void {
-	const tty = sourcePaneTty();
+async function writeToTerminal(pane: TmuxPaneState | undefined, output: string): Promise<void> {
 	try {
-		writeFileSync(tty ?? "/dev/tty", output, "utf8");
+		await writeTty(pane?.paneTty ?? "/dev/tty", output);
 		return;
 	} catch {
 		// Fall through to stdout best-effort.
@@ -136,38 +178,40 @@ function writeToTerminal(output: string): void {
 	}
 }
 
-function writeTerminalSequence(sequence: string, cwd?: string): void {
-	if (process.env.TMUX && settingBoolean("notification.tmuxNativeClientTty", true, cwd)) {
-		// Inactive tmux windows do not forward arbitrary OSC output to the terminal.
-		// Send native terminal notifications straight to attached tmux client TTYs,
-		// while the explicit terminal bell still goes through the source pane when unmuted.
-		if (writeRawToPaths(tmuxClientTtys(), sequence)) return;
-	}
+async function writeTerminalSequence(pi: QolNotificationExec, pane: TmuxPaneState | undefined, sequence: string, cwd?: string): Promise<void> {
+	// Inactive tmux windows do not forward arbitrary OSC output to the terminal.
+	// Send native terminal notifications straight to attached tmux client TTYs,
+	// while the explicit terminal bell still goes through the source pane when unmuted.
+	const clientTtys = process.env.TMUX && settingBoolean("notification.tmuxNativeClientTty", true, cwd) ? await tmuxClientTtys(pi, pane) : [];
 	const output = process.env.TMUX && settingBoolean("notification.tmuxPassthrough", true, cwd) ? tmuxPassthrough(sequence) : sequence;
-	writeToTerminal(output);
+	await queueTerminalWrite(async () => {
+		if (await writeRawToPaths(clientTtys, sequence)) return;
+		await writeToTerminal(pane, output);
+	});
 }
 
-function writeTerminalBell(cwd?: string): void {
+function writeTerminalBell(pane: TmuxPaneState | undefined, cwd?: string): Promise<void> {
 	// Match Claude-style hooks: resolve the source pane TTY and write raw BEL there.
 	// This lets tmux set window_bell_flag for the correct source window.
 	const sequence = terminalBellSequence(notificationBellMuted(cwd));
-	if (sequence) writeToTerminal(sequence);
+	if (!sequence) return Promise.resolve();
+	return queueTerminalWrite(() => writeToTerminal(pane, sequence));
 }
 
-function notifyOSC777(title: string, body: string, cwd?: string): void {
-	writeTerminalSequence(osc777NotificationSequence(title, body, notificationBellMuted(cwd)), cwd);
+function notifyOSC777(pi: QolNotificationExec, pane: TmuxPaneState | undefined, title: string, body: string, cwd?: string): Promise<void> {
+	return writeTerminalSequence(pi, pane, osc777NotificationSequence(title, body, notificationBellMuted(cwd)), cwd);
 }
 
-function notifyOSC99(title: string, body: string, cwd?: string): void {
-	writeTerminalSequence(`\x1b]99;i=1:d=0;${title}\x1b\\`, cwd);
-	writeTerminalSequence(`\x1b]99;i=1:p=body;${body}\x1b\\`, cwd);
+async function notifyOSC99(pi: QolNotificationExec, pane: TmuxPaneState | undefined, title: string, body: string, cwd?: string): Promise<void> {
+	await writeTerminalSequence(pi, pane, `\x1b]99;i=1:d=0;${title}\x1b\\`, cwd);
+	await writeTerminalSequence(pi, pane, `\x1b]99;i=1:p=body;${body}\x1b\\`, cwd);
 }
 
 function notifyWindows(title: string, body: string): void {
 	execFile("powershell.exe", ["-NoProfile", "-Command", windowsToastScript(title, body)], () => undefined);
 }
 
-function notifyNativeTerminal(title: string, body: string, cwd?: string): void {
+async function notifyNativeTerminal(pi: QolNotificationExec, pane: TmuxPaneState | undefined, title: string, body: string, cwd?: string): Promise<void> {
 	const protocol = settingString("notification.oscProtocol", "auto", cwd);
 	if (process.env.WT_SESSION) {
 		notifyWindows(title, body);
@@ -175,60 +219,61 @@ function notifyNativeTerminal(title: string, body: string, cwd?: string): void {
 	}
 	if (protocol === "off") return;
 	if (protocol === "osc99" || (protocol === "auto" && process.env.KITTY_WINDOW_ID)) {
-		notifyOSC99(title, body, cwd);
+		await notifyOSC99(pi, pane, title, body, cwd);
 		return;
 	}
-	notifyOSC777(title, body, cwd);
+	await notifyOSC777(pi, pane, title, body, cwd);
 }
 
-function notifyTmux(title: string, body: string, cwd?: string): void {
+function notifyTmux(pi: QolNotificationExec, title: string, body: string, cwd?: string): void {
 	if (!process.env.TMUX && !process.env.TMUX_PANE) return;
 	const duration = Math.max(500, Math.floor(settingNumber("notification.tmuxMessageDurationMs", DEFAULT_TMUX_MESSAGE_DURATION_MS, cwd)));
 	const message = `${title}: ${body}`;
 	const args = ["display-message", "-d", String(duration)];
 	if (process.env.TMUX_PANE) args.push("-t", process.env.TMUX_PANE);
 	args.push(message);
-	execFile("tmux", args, () => undefined);
+	void tmux(pi, args);
 }
 
-export function clearTmuxWindowMark(): void {
-	if (tmuxWindowMarkTimer) clearTimeout(tmuxWindowMarkTimer);
-	tmuxWindowMarkTimer = undefined;
+/** Renames the marked window back, if one is marked. */
+function unmarkTmuxWindow(pi: QolNotificationExec): void {
 	const target = tmuxMarkedTarget;
 	const original = tmuxOriginalWindowName;
 	tmuxMarkedTarget = undefined;
 	tmuxOriginalWindowName = undefined;
 	if (!target || !original) return;
-	execFile("tmux", ["rename-window", "-t", target, original], () => undefined);
+	void tmux(pi, ["rename-window", "-t", target, original]);
+}
+
+/** Removes the window mark, and keeps a notification still in flight from setting one. */
+export function clearTmuxWindowMark(pi: QolNotificationExec): void {
+	tmuxMarkGeneration += 1;
+	if (tmuxWindowMarkTimer) clearTimeout(tmuxWindowMarkTimer);
+	tmuxWindowMarkTimer = undefined;
+	unmarkTmuxWindow(pi);
 }
 
-function markTmuxWindow(cwd?: string): void {
+function markTmuxWindow(pi: QolNotificationExec, pane: TmuxPaneState | undefined, generation: number, cwd?: string): void {
 	if (!settingBoolean("notification.tmuxWindowMark", false, cwd)) return;
-	if (!process.env.TMUX || !process.env.TMUX_PANE) return;
+	if (!process.env.TMUX || !pane || generation !== tmuxMarkGeneration) return;
 	const mark = sanitizeNotificationPart(settingString("notification.tmuxWindowMarkText", "!", cwd), 12) || "!";
 	const prefix = `${mark} `;
-	execFile("tmux", ["display-message", "-p", "-t", process.env.TMUX_PANE, "#{session_name}:#{window_index}"], (targetError, targetStdout) => {
-		if (targetError) return;
-		const target = targetStdout.trim();
-		if (!target) return;
-		execFile("tmux", ["display-message", "-p", "-t", process.env.TMUX_PANE!, "#W"], (nameError, nameStdout) => {
-			if (nameError) return;
-			const current = nameStdout.replace(/\r?\n$/, "");
-			if (!current) return;
-			const original = current.startsWith(prefix) ? current.slice(prefix.length) : current;
-			if (!tmuxMarkedTarget || tmuxMarkedTarget !== target) {
-				tmuxMarkedTarget = target;
-				tmuxOriginalWindowName = original;
-			}
-			if (!current.startsWith(prefix)) execFile("tmux", ["rename-window", "-t", target, `${prefix}${current}`], () => undefined);
-			const duration = Math.max(0, Math.floor(settingNumber("notification.tmuxWindowMarkDurationMs", 0, cwd)));
-			if (tmuxWindowMarkTimer) clearTimeout(tmuxWindowMarkTimer);
-			if (duration > 0) {
-				tmuxWindowMarkTimer = setTimeout(clearTmuxWindowMark, duration);
-				tmuxWindowMarkTimer.unref?.();
-			}
-		});
-	});
+	const target = pane.windowId;
+	const current = pane.windowName;
+	if (!current) return;
+	// The pane moved to another window since the last mark: that window gets its name back.
+	if (tmuxMarkedTarget && tmuxMarkedTarget !== target) unmarkTmuxWindow(pi);
+	if (!tmuxMarkedTarget) {
+		tmuxMarkedTarget = target;
+		tmuxOriginalWindowName = current.startsWith(prefix) ? current.slice(prefix.length) : current;
+	}
+	if (!current.startsWith(prefix)) void tmux(pi, ["rename-window", "-t", target, `${prefix}${current}`]);
+	const duration = Math.max(0, Math.floor(settingNumber("notification.tmuxWindowMarkDurationMs", 0, cwd)));
+	if (tmuxWindowMarkTimer) clearTimeout(tmuxWindowMarkTimer);
+	if (duration > 0) {
+		tmuxWindowMarkTimer = setTimeout(() => clearTmuxWindowMark(pi), duration);
+		tmuxWindowMarkTimer.unref?.();
+	}
 }
 
 function notificationEnabledFor(kind: QolNotificationKind, cwd?: string): boolean {
@@ -243,24 +288,41 @@ function notificationEnabledFor(kind: QolNotificationKind, cwd?: string): boolea
 	}
 }
 
-export function sendQolNotification(ctx: ExtensionContext | undefined, kind: QolNotificationKind, body: string, level: QolNotificationLevel = "info", key: string = kind): void {
+/**
+ * The window mark and the tmux message never touch the terminal, so they start
+ * beside the terminal writes rather than behind them.
+ */
+async function deliverTerminalNotification(pi: QolNotificationExec, title: string, text: string, markGeneration: number, cwd?: string): Promise<void> {
+	const pane = await sourceTmuxPaneState(pi);
+	const windowActive = pane?.windowActive ?? false;
+	if (!windowActive) markTmuxWindow(pi, pane, markGeneration, cwd);
+	if (settingBoolean("notification.tmux", false, cwd)) notifyTmux(pi, title, text, cwd);
+	if (settingBoolean("notification.bell", true, cwd) && (!windowActive || settingBoolean("notification.bellWhenActive", false, cwd))) await writeTerminalBell(pane, cwd);
+	if (settingBoolean("notification.native", true, cwd)) await notifyNativeTerminal(pi, pane, title, text, cwd);
+}
+
+/**
+ * Decides and records the notification synchronously, then delivers the
+ * terminal and tmux channels in the background: the returned promise settles
+ * when delivery is done, and no caller on Pi's event path awaits it, so a
+ * stalled tmux server or terminal never holds up a turn end.
+ */
+export function sendQolNotification(pi: QolNotificationExec, ctx: ExtensionContext | undefined, kind: QolNotificationKind, body: string, level: QolNotificationLevel = "info", key: string = kind): Promise<void> {
 	const cwd = ctx?.cwd;
-	if (ctx && !ctx.hasUI) return;
-	if (!notificationEnabledFor(kind, cwd)) return;
+	if (ctx && !ctx.hasUI) return Promise.resolve();
+	if (!notificationEnabledFor(kind, cwd)) return Promise.resolve();
 	const cooldownMs = Math.max(0, settingNumber("notification.cooldownSeconds", DEFAULT_NOTIFICATION_COOLDOWN_SECONDS, cwd) * 1000);
 	const now = Date.now();
 	const last = lastNotificationAt.get(key) ?? 0;
-	if (cooldownMs > 0 && now - last < cooldownMs) return;
+	if (cooldownMs > 0 && now - last < cooldownMs) return Promise.resolve();
 	lastNotificationAt.set(key, now);
 
 	const title = sanitizeNotificationPart(settingString("notification.title", DEFAULT_NOTIFICATION_TITLE, cwd), 80) || DEFAULT_NOTIFICATION_TITLE;
 	const text = sanitizeNotificationPart(body, Math.max(40, Math.floor(settingNumber("notification.bodyMaxChars", DEFAULT_NOTIFICATION_BODY_MAX_CHARS, cwd))));
-	const tmuxWindowActive = sourceTmuxWindowActive();
-	if (settingBoolean("notification.bell", true, cwd) && (!tmuxWindowActive || settingBoolean("notification.bellWhenActive", false, cwd))) writeTerminalBell(cwd);
-	if (settingBoolean("notification.native", true, cwd)) notifyNativeTerminal(title, text, cwd);
-	if (!tmuxWindowActive) markTmuxWindow(cwd);
-	if (settingBoolean("notification.tmux", false, cwd)) notifyTmux(title, text, cwd);
 	if (ctx?.hasUI && settingBoolean("notification.piUi", false, cwd)) ctx.ui.notify(text, level);
+	// Every channel already absorbs its own failure; this catch keeps an
+	// unexpected throw from becoming an unhandled rejection, which ends Pi.
+	return deliverTerminalNotification(pi, title, text, tmuxMarkGeneration, cwd).catch(() => undefined);
 }
 
 function questionNotificationTitle(request?: QuestionRequestLike): string {
@@ -269,7 +331,7 @@ function questionNotificationTitle(request?: QuestionRequestLike): string {
 	return "Question";
 }
 
-export function notifyQuestionOpened(ctx: ExtensionContext | undefined, event: QuestionOpenedEventLike, keyPrefix = "question"): void {
+export function notifyQuestionOpened(pi: QolNotificationExec, ctx: ExtensionContext | undefined, event: QuestionOpenedEventLike, keyPrefix = "question"): void {
 	const title = questionNotificationTitle(event.request);
 	const key = `${keyPrefix}:${event.requestId ?? title}`;
 	const now = Date.now();
@@ -279,5 +341,5 @@ export function notifyQuestionOpened(ctx: ExtensionContext | undefined, event: Q
 	for (const [storedKey, timestamp] of lastQuestionNotificationAt) {
 		if (now - timestamp > 60_000) lastQuestionNotificationAt.delete(storedKey);
 	}
-	sendQolNotification(ctx, "question", `Input required: ${title}`, "warning", key);
+	void sendQolNotification(pi, ctx, "question", `Input required: ${title}`, "warning", key);
 }

package/extensions/qol/pending-queue.ts

@@ -9,6 +9,19 @@ interface PendingQueueThemePatch {
 	cwd?: string;
 }
 
+interface StatusTextAlignmentPatch {
+	originalRender: (this: unknown, width: number) => string[];
+}
+
+function isStatusTextAlignmentPatch(value: unknown): value is StatusTextAlignmentPatch {
+	return typeof value === "object" && value !== null && typeof (value as Partial<StatusTextAlignmentPatch>).originalRender === "function";
+}
+
+interface StatusTextClassification {
+	text: string;
+	status: boolean;
+}
+
 function isPendingQueuePreviewText(text: string): boolean {
 	const plain = stripAnsi(text);
 	return plain.startsWith("Steering: ") || plain.startsWith("Follow-up: ");
@@ -28,15 +41,33 @@ function isQueuedMessageStatusText(text: string): boolean {
 	return /^Restored \d+ queued messages? to editor$/.test(plain) || plain === "No queued messages to restore";
 }
 
-export function installStatusTextAlignmentPatch(): void {
+/**
+ * Pads Pi's dequeue status line ("Restored N queued messages to editor") flush
+ * with the pending-queue preview. The patch wraps every pi-tui `Text`, so the
+ * classification is cached per instance and recomputed only when its text
+ * changes: an unchanged `Text`, which pi-tui answers from its own render
+ * cache, pays one string comparison, not a scan of its whole text.
+ */
+export function installStatusTextAlignmentPatch(ctx: ExtensionContext): void {
+	if (!ctx.hasUI) return;
 	const proto = Text.prototype as unknown as Record<PropertyKey, any>;
-	if (proto[STATUS_TEXT_ALIGNMENT_PATCH_SYMBOL]) return;
+	// Any marker already here keeps its wrapper, including pi-qol 2.2.0's `true`.
+	if (proto[STATUS_TEXT_ALIGNMENT_PATCH_SYMBOL] !== undefined) return;
 	const originalRender = proto.render;
 	if (typeof originalRender !== "function") return;
-	proto[STATUS_TEXT_ALIGNMENT_PATCH_SYMBOL] = true;
+	const classifications = new WeakMap<object, StatusTextClassification>();
+	const isStatusText = (component: object, text: string): boolean => {
+		const cached = classifications.get(component);
+		if (cached && cached.text === text) return cached.status;
+		const status = isQueuedMessageStatusText(text);
+		classifications.set(component, { text, status });
+		return status;
+	};
+	const patch: StatusTextAlignmentPatch = { originalRender };
+	proto[STATUS_TEXT_ALIGNMENT_PATCH_SYMBOL] = patch;
 	proto.render = function patchedQolStatusTextRender(this: any, width: number): string[] {
 		const text = typeof this?.text === "string" ? this.text : "";
-		if (!isQueuedMessageStatusText(text)) return originalRender.call(this, width);
+		if (!isStatusText(this, text)) return originalRender.call(this, width);
 		const originalPaddingX = this.paddingX;
 		try {
 			this.paddingX = 0;
@@ -49,6 +80,20 @@ export function installStatusTextAlignmentPatch(): void {
 	};
 }
 
+/**
+ * Removes the patch, but only one this module's install wrote. Any other
+ * marker keeps its wrapper: pi-qol 2.2.0 marked the prototype with `true` and
+ * kept no original render, and Pi's `/reload` carries that marker into this
+ * module because pi-tui's prototype outlives the reload.
+ */
+export function restoreStatusTextAlignmentPatch(): void {
+	const proto = Text.prototype as unknown as Record<PropertyKey, any>;
+	const patch: unknown = proto[STATUS_TEXT_ALIGNMENT_PATCH_SYMBOL];
+	if (!isStatusTextAlignmentPatch(patch)) return;
+	proto.render = patch.originalRender;
+	delete proto[STATUS_TEXT_ALIGNMENT_PATCH_SYMBOL];
+}
+
 export function installPendingQueueThemePatch(ctx: ExtensionContext): void {
 	if (!ctx.hasUI) return;
 	const proto = Theme.prototype as unknown as Record<PropertyKey, unknown>;

package/extensions/qol/statusline.ts

@@ -39,6 +39,34 @@ function formatModelName(ctx: ExtensionContext): string {
 	return name;
 }
 
+const PROVIDER_NAMES: Record<string, string> = {
+	"github-copilot": "Copilot",
+	"openai": "OpenAI",
+	"openai-codex": "Codex",
+	"anthropic": "Anthropic",
+	"pi-claude": "Claude",
+	"google": "Google",
+	"google-gemini-cli": "Gemini CLI",
+	"google-antigravity": "Antigravity",
+	"google-vertex": "Vertex AI",
+	"amazon-bedrock": "Bedrock",
+	"azure-openai-responses": "Azure OpenAI",
+	"openrouter": "OpenRouter",
+	"vercel-ai-gateway": "Vercel AI Gateway",
+	"xai": "xAI",
+	"groq": "Groq",
+	"cerebras": "Cerebras",
+	"mistral": "Mistral",
+	"deepseek": "DeepSeek",
+	"zai": "Z.AI",
+	"ollama": "Ollama",
+};
+
+function formatProviderName(provider: string): string {
+	const name = stripAnsi(provider).replace(/[\x00-\x1f\x7f]/g, " ").trim();
+	return Object.hasOwn(PROVIDER_NAMES, name) ? PROVIDER_NAMES[name] : name.replace(/[-_]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase()).replace(/\s+/g, " ").trim();
+}
+
 type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 type ThinkingThemeToken = "thinkingOff" | "thinkingMinimal" | "thinkingLow" | "thinkingMedium" | "thinkingHigh" | "thinkingXhigh" | "thinkingMax";
 const THINKING_TOKEN: Record<ThinkingLevel, ThinkingThemeToken> = {
@@ -204,24 +232,23 @@ function cavemanIconTone(mode: string, active: boolean): "muted" | "text" | "suc
 	}
 }
 
-export function renderStatusLine(width: number, ctx: ExtensionContext, git: GitState, pi: ExtensionAPI, theme: Pick<Theme, "fg">): string {
+export function renderStatusLine(width: number, ctx: ExtensionContext, git: GitState, pi: ExtensionAPI, theme: Pick<Theme, "fg">, workingIndicator = ""): string {
 	const { label: contextLabel, percent } = statuslineContextInfo(ctx);
-	const projectChunk = `${git.projectName}${gitBadge(git, settingBoolean("showDirtyMarker", true, ctx.cwd))} ${formatModelName(ctx)}`;
+	const provider = settingBoolean("statusline.showProvider", true, ctx.cwd) && ctx.model ? formatProviderName(ctx.model.provider) : "";
+	const projectChunk = `${git.projectName}${gitBadge(git, settingBoolean("showDirtyMarker", true, ctx.cwd))} ${provider ? `${provider} / ` : ""}${formatModelName(ctx)}`;
+	const workingPrefix = workingIndicator ? `${workingIndicator} ` : "";
 	const statusSeparator = " / ";
 	const thinkingLevel = normalizeThinkingLevel(pi.getThinkingLevel());
 	const thinkingChunk = thinkingLevel;
 	const contextChunk = ` ${contextLabel}`;
 	const account = accountLabel(ctx);
-	const accountSegment = account ? `${statusSeparator}${account}` : "";
 	const cavemanBridge = readCavemanBridge();
 	const cavemanVisible = !!cavemanBridge && (cavemanBridge.isStatusBadgeEnabled?.(ctx.cwd) ?? true);
 	const caveman = cavemanVisible ? cavemanBridge : undefined;
 	const cavemanActive = caveman?.isActive() ?? false;
 	const cavemanGlyph = caveman ? (cavemanActive ? CAVEMAN_ICON_ACTIVE : CAVEMAN_ICON_INACTIVE) : "";
 	const cavemanTone = cavemanIconTone(caveman?.getMode() ?? "off", cavemanActive);
-	const cavemanSegment = caveman ? `${statusSeparator}${cavemanGlyph}` : "";
 	const contextSeparator = caveman ? ` ${statusSeparator}` : "";
-	const leftPlain = `${projectChunk}${statusSeparator}${thinkingChunk}${cavemanSegment}${contextSeparator}${contextChunk.trimStart()}${accountSegment}`;
 	const percentPlain = percent === null ? `${glyphs(ctx.cwd).ellipsis}%` : `${percent}%`;
 	const subagentMarker = subagentStatuslineMarker(ctx.cwd);
 	const rightPlain = subagentMarker ? `${percentPlain} ${subagentMarker.plain}` : percentPlain;
@@ -234,9 +261,9 @@ export function renderStatusLine(width: number, ctx: ExtensionContext, git: GitS
 		: `${theme.fg("accent", projectChunk)}${separatorColored}${theme.fg(thinkingToken, thinkingChunk)}${theme.fg("accent", contextChunk)}${accountColored}`;
 	const right = subagentMarker ? `${theme.fg(percentColor, percentPlain)} ${subagentMarker.styled}` : theme.fg(percentColor, percentPlain);
 	const minimumGap = 1;
-	const gapWidth = Math.max(minimumGap, width - visibleWidth(leftPlain) - visibleWidth(rightPlain) - 2);
+	const gapWidth = Math.max(minimumGap, width - visibleWidth(workingPrefix + leftColored) - visibleWidth(rightPlain) - 2);
 	const filled = percent === null ? 0 : Math.round(gapWidth * (percent / 100));
 	const empty = Math.max(0, gapWidth - filled);
 	const bar = " ".repeat(empty) + theme.fg("warning", glyphs(ctx.cwd).line.repeat(filled));
-	return truncateToWidth(`${leftColored} ${bar} ${right}`, width, "");
+	return truncateToWidth(`${workingPrefix}${leftColored} ${bar} ${right}`, width, "");
 }

package/extensions/qol.ts

@@ -46,6 +46,7 @@ import {
 	installPendingQueueThemePatch,
 	installStatusTextAlignmentPatch,
 	restorePendingQueueThemePatch,
+	restoreStatusTextAlignmentPatch,
 } from "./qol/pending-queue.js";
 import { permissionGateMatch, permissionGatePrompt } from "./qol/permission-gate.js";
 import { createRateLimitAutoResumeController, RATE_LIMIT_AUTO_RESUME_EVENT } from "./qol/rate-limit-auto-resume.js";
@@ -102,7 +103,6 @@ export default function qol(pi: ExtensionAPI): void {
 	if (!settingBoolean("enabled", true)) return;
 
 	installThinkingTimerPatch();
-	installStatusTextAlignmentPatch();
 	const thinkingTimerStore: ThinkingTimerStore = {
 		enabled: false,
 		starts: new Map(),
@@ -121,6 +121,7 @@ export default function qol(pi: ExtensionAPI): void {
 	let autoRenameInProgress = false;
 	let autoRenameGeneration = 0;
 	let latestSystemPromptOptions: unknown;
+	let statusEditor: QolEditor | QolCompactPromptEditor | undefined;
 
 	const resetAutoRename = () => {
 		autoRenameAttempted = false;
@@ -217,15 +218,9 @@ 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.
+	// Pi's Loader starts no animation timer for a single-frame indicator.
+	// Keep static mode available for terminals where frequent redraws flash,
+	// whether the indicator is embedded in QOL or in Pi's standalone row.
 	const applyWorkingIndicatorMode = (ctx: ExtensionContext): void => {
 		if (!ctx.hasUI) return;
 		const mode = settingString("workingIndicator.mode", "animated", ctx.cwd);
@@ -386,7 +381,7 @@ export default function qol(pi: ExtensionAPI): void {
 		if (!service) return false;
 		questionUnsubscribe = service.subscribe((event: any) => {
 			if (event?.action !== "opened") return;
-			notifyQuestionOpened(ctx, { requestId: event.requestId, request: event.request, source: event.source }, "question");
+			notifyQuestionOpened(pi, ctx, { requestId: event.requestId, request: event.request, source: event.source }, "question");
 		});
 		return true;
 	};
@@ -547,6 +542,7 @@ export default function qol(pi: ExtensionAPI): void {
 		ctx.ui.setHeader(undefined);
 		ctx.ui.setFooter(undefined);
 		activeTui = undefined;
+		statusEditor = undefined;
 	};
 
 	const maybeNotifyTaskCompletion = (_ctx: ExtensionContext, state: any) => {
@@ -574,7 +570,7 @@ export default function qol(pi: ExtensionAPI): void {
 	};
 	const notificationService: QolNotificationService = {
 		notifyQuestionOpened(ctx, event) {
-			notifyQuestionOpened(ctx ?? currentCtx, event, "question");
+			notifyQuestionOpened(pi, ctx ?? currentCtx, event, "question");
 			return true;
 		},
 	};
@@ -583,7 +579,7 @@ export default function qol(pi: ExtensionAPI): void {
 	pi.events.on(QUESTION_OPENED_EVENT, (data: unknown) => {
 		if (!data || typeof data !== "object") return;
 		const event = data as QuestionOpenedEventLike;
-		notifyQuestionOpened(currentCtx, event, "question");
+		notifyQuestionOpened(pi, currentCtx, event, "question");
 	});
 	pi.events.on(RATE_LIMIT_AUTO_RESUME_EVENT, (payload: unknown) => {
 		if (!currentCtx) return;
@@ -605,6 +601,7 @@ export default function qol(pi: ExtensionAPI): void {
 		void consumePendingSessionSearchContext(pi, ctx, event.reason);
 		installAutocompleteHintStyling(ctx);
 		installPendingQueueThemePatch(ctx);
+		installStatusTextAlignmentPatch(ctx);
 		if (ctx.hasUI) {
 			ctx.ui.setHiddenThinkingLabel(hiddenThinkingLabel(ctx.ui.theme, ctx.cwd));
 			applyWorkingIndicatorMode(ctx);
@@ -615,9 +612,10 @@ export default function qol(pi: ExtensionAPI): void {
 			installSessionTitleSync(ctx);
 			ctx.ui.setEditorComponent((tui, theme, keybindings) => {
 				activeTui = tui;
-				return settingBoolean("compactPrompt", true, ctx.cwd)
+				statusEditor = settingBoolean("compactPrompt", true, ctx.cwd)
 					? new QolCompactPromptEditor(tui, theme, keybindings, Math.max(0, Math.floor(settingNumber("inputBottomPaddingLines", DEFAULT_INPUT_BOTTOM_PADDING_LINES, ctx.cwd))), ctx)
 					: new QolEditor(tui, theme, keybindings, ctx);
+				return statusEditor;
 			});
 			if (showStatusline || scheduleEnabled || rateLimitAutoResumeEnabled) {
 				const statusWidgetTimer = setTimeout(() => {
@@ -629,7 +627,7 @@ export default function qol(pi: ExtensionAPI): void {
 								const lines = rateLimitAutoResumeController.enabled(ctx) ? rateLimitAutoResumeController.renderPreviewLines(width) : [];
 								if (scheduleEnabled) lines.push(...scheduleController.renderPreviewLines(width));
 								if (budgetGuardStatus) lines.push(truncateToWidth(ansiGreen(`┃ ${budgetGuardStatus}`), width, ""));
-								if (showStatusline) lines.push(renderStatusLine(width, ctx, gitState ?? makeFallbackGitState(ctx.cwd), pi, theme));
+								if (showStatusline) lines.push(renderStatusLine(width, ctx, gitState ?? makeFallbackGitState(ctx.cwd), pi, theme, statusEditor?.renderWorkingStatus(width)));
 								return lines;
 							},
 						};
@@ -676,7 +674,7 @@ export default function qol(pi: ExtensionAPI): void {
 		if (sessionSearchWarmupTimer) clearTimeout(sessionSearchWarmupTimer);
 		sessionSearchWarmupTimer = undefined;
 		resetThinkingTimer(undefined);
-		clearTmuxWindowMark();
+		clearTmuxWindowMark(pi);
 		questionUnsubscribe?.();
 		questionUnsubscribe = undefined;
 		currentCtx = undefined;
@@ -686,6 +684,7 @@ export default function qol(pi: ExtensionAPI): void {
 		ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, undefined);
 		ctx.ui.setStatus("qol-budget-guard", undefined);
 		restorePendingQueueThemePatch(ctx);
+		restoreStatusTextAlignmentPatch();
 		resetStatuslineUi(ctx);
 		ctx.ui.setEditorComponent(undefined);
 	});
@@ -707,7 +706,7 @@ export default function qol(pi: ExtensionAPI): void {
 	});
 	pi.on("agent_start", (_event, ctx) => {
 		clearIdleCompactionTimer();
-		clearTmuxWindowMark();
+		clearTmuxWindowMark(pi);
 		rateLimitAutoResumeController.noteAgentStart(ctx);
 		if (ctx.hasUI) {
 			void refreshStatusline(ctx);
@@ -757,21 +756,21 @@ export default function qol(pi: ExtensionAPI): void {
 		const critical = criticalInfo(text);
 		if (critical) {
 			pendingTaskCompleteNotification = undefined;
-			sendQolNotification(ctx, "critical", `Critical: ${critical}`, "error", `critical:${critical.slice(0, 80)}`);
+			void sendQolNotification(pi, ctx, "critical", `Critical: ${critical}`, "error", `critical:${critical.slice(0, 80)}`);
 			return;
 		}
 		if (pendingTaskCompleteNotification) {
 			const body = pendingTaskCompleteNotification;
 			pendingTaskCompleteNotification = undefined;
-			sendQolNotification(ctx, "task-complete", body, "info", "task-complete");
+			void sendQolNotification(pi, ctx, "task-complete", body, "info", "task-complete");
 			return;
 		}
 		if (ctx.hasPendingMessages?.()) return;
 		if (needsDirection(text)) {
-			sendQolNotification(ctx, "direction", "Pi is awaiting your direction.", "warning", "direction");
+			void sendQolNotification(pi, ctx, "direction", "Pi is awaiting your direction.", "warning", "direction");
 			return;
 		}
-		sendQolNotification(ctx, "ready", settingString("notification.readyMessage", "Ready for input", ctx.cwd), "info", "ready");
+		void sendQolNotification(pi, ctx, "ready", settingString("notification.readyMessage", "Ready for input", ctx.cwd), "info", "ready");
 	});
 	pi.on("agent_settled", async (_event, ctx) => {
 		await fireStagedBudgetGuard(ctx);
@@ -799,7 +798,7 @@ export default function qol(pi: ExtensionAPI): void {
 	pi.on("session_before_tree", (event, ctx) => handleQolBranchSummary(event, ctx));
 	pi.on("tool_call", async (event: any, ctx) => {
 		if (event?.toolName === "question") {
-			notifyQuestionOpened(ctx, { requestId: event.input?.id ?? event.toolCallId, request: event.input, source: "tool_call" }, "question");
+			notifyQuestionOpened(pi, ctx, { requestId: event.input?.id ?? event.toolCallId, request: event.input, source: "tool_call" }, "question");
 			return undefined;
 		}
 		if (!settingBoolean("permissionGate.enabled", false, ctx.cwd)) return undefined;
@@ -818,7 +817,7 @@ export default function qol(pi: ExtensionAPI): void {
 	});
 
 	pi.on("input", async (event) => {
-		clearTmuxWindowMark();
+		clearTmuxWindowMark(pi);
 		if (event.source === "extension") return { action: "continue" };
 		const text = event.text ?? "";
 		const paths = currentCtx?.cwd ? resolveSubmittedImagePaths(text, currentCtx.cwd) : [];
@@ -955,7 +954,7 @@ export default function qol(pi: ExtensionAPI): void {
 			return;
 		}
 		if (sub === "notify-test") {
-			sendQolNotification(ctx, "test", "QOL notification test", "info", `test:${Date.now()}`);
+			void sendQolNotification(pi, ctx, "test", "QOL notification test", "info", `test:${Date.now()}`);
 			ctx.ui.notify("Sent QOL notification test.", "info");
 			return;
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanillagreen/pi-qol",
-  "version": "2.1.1",
+  "version": "2.2.1",
   "description": "Pi quality-of-life extension: compact statusline/π prompt, reliable multiline input, styled pasted-image chips, session naming/search/context import, scheduled prompts, handoff, permission prompts, notifications, custom compaction, and a collapsed-thinking timer.",
   "license": "MIT",
   "keywords": [
@@ -56,6 +56,15 @@
           "apply": "reload",
           "requiresReload": true
         },
+        {
+          "key": "statusline.showProvider",
+          "label": "Show model provider",
+          "description": "Show a readable provider name before the model, for example Copilot / GPT 6 Astra.",
+          "type": "boolean",
+          "default": true,
+          "category": "Statusline",
+          "apply": "live"
+        },
         {
           "key": "statusline.showAccount",
           "label": "Show account email",
@@ -957,7 +966,7 @@
         {
           "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.",
+          "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 indicator visible without the 80ms timer. It appears before the project name when the QOL statusline is enabled, or in Pi's working row otherwise.",
           "type": "enum",
           "enumValues": [
             "animated",
@@ -974,7 +983,7 @@
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",
     "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": ">=0.80.4",
+    "@earendil-works/pi-coding-agent": ">=0.86.0",
     "@earendil-works/pi-tui": "*"
   },
   "files": [