@vanillagreen/pi-qol 2.2.0 → 2.2.1

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/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.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(),
@@ -381,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;
 	};
@@ -570,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;
 		},
 	};
@@ -579,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;
@@ -601,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);
@@ -673,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;
@@ -683,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);
 	});
@@ -704,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);
@@ -754,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);
@@ -796,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;
@@ -815,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) : [];
@@ -952,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.2.0",
+  "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": [