@vanillagreen/pi-qol 2.2.0 → 2.3.2

package/README.md

@@ -29,6 +29,17 @@ Requires Pi 0.86.0 or newer. Restart Pi after installation. Use `kendex update-p
 
 The extension reads your enabled features when Pi starts. It adds their editor controls, commands and event handlers. Session actions update the session or queue messages for the agent. Notifications report events through your selected channels. Compaction settings control when long conversations are summarized.
 
+## Memory use
+
+- A session without a UI loads no session-search index. With a UI, the index is loaded shortly after start and kept for `sessionSearch.cacheTtlSeconds` (default 300 seconds; 0 keeps it until the session ends). A search after the index was released opens at once and fills in when the index has loaded again.
+- The index keeps at most 32,768 characters of message text per session and 8,388,608 characters in total, newest session first. A session past the total is searched by name, path and first prompt only.
+- Where Pi cannot switch sessions directly, a chosen resume or fork waits as one `/search:resume-pending` command in the editor. Only the latest one is kept, and it is dropped when the session ends.
+- Parsed prompts are kept for at most 64 sessions, and finished thinking times for at most 256 blocks. Thinking labels are released at the end of each agent run, and notification cooldown entries once their cooldown has passed and all of them when the session ends.
+
+## Saved files
+
+At session start, the extension deletes budget handoff files whose recorded working directory no longer exists. It also deletes files older than 5 days. Both timestamped snapshots and `latest.json` follow this rule.
+
 ## Settings
 
 The settings editor writes project values to `.pi/settings.json`. The default user file is `~/.pi/agent/settings.json`. `PI_CODING_AGENT_DIR` changes the user directory. Package values are stored under `kendex.extensionManager.config["@vanillagreen/pi-qol"]`.

package/extensions/qol/compaction-handoff.ts

@@ -4,11 +4,12 @@
 // drops something critical. The pure data-building + write logic lives here
 // so it can be unit-tested without the pi-coding-agent / pi-ai peer deps.
 
-import { mkdirSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
+import { writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
 
+import { openLaneDir } from "../../scripts/lane-retention.js";
 import { QOL_BUDGET_HANDOFF_FOLDER, QOL_BUDGET_HANDOFF_LATEST } from "./constants.js";
-import { expandHome } from "./settings.js";
+import { piUserDir } from "./package-config.js";
 
 export interface QolBudgetHandoff {
 	reason: string;
@@ -22,17 +23,6 @@ export interface QolBudgetHandoff {
 	model?: string;
 }
 
-/** Root-anchored as `crates/core/src/harness/pi.rs::pi_root_is_absolute_for`
- * means it, which `isAbsolute` is not: it calls a driveless `\root` absolute
- * where the renderer does not, putting the two on different roots. Hoisted, so
- * a circular import cannot reach it inside a temporal dead zone. */
-function rootAnchored(path: string, windows: boolean): boolean { return windows ? /^(?:[A-Za-z]:[\\/]|[\\/]{2}[^\\/]+[\\/][^\\/]+)/.test(path) : path.startsWith("/"); }
-
-export function piUserDir(): string {
-	const override = expandHome(process.env.PI_CODING_AGENT_DIR?.trim() || "");
-	return resolve(rootAnchored(override, process.platform === "win32") ? override : expandHome("~/.pi/agent"));
-}
-
 export function safeFileName(value: string): string {
 	return value.replace(/[^\w.-]+/g, "_");
 }
@@ -157,16 +147,13 @@ export function handoffBaseDir(sessionId: string, root: string = piUserDir()): s
 
 export interface WriteHandoffOptions {
 	enabled: boolean;
+	cwd: string;
 	root?: string;
 	/** Injection point so tests can stub fs without mocking node:fs. */
 	writer?: (path: string, payload: string) => void;
 	mkdir?: (path: string) => void;
 }
 
-function defaultMkdir(path: string): void {
-	mkdirSync(path, { recursive: true, mode: 0o700 });
-}
-
 function defaultWriter(path: string, payload: string): void {
 	writeFileSync(path, payload, { mode: 0o600 });
 }
@@ -176,7 +163,7 @@ export function writeBudgetHandoffArtifact(handoff: QolBudgetHandoff, options: W
 	const baseDir = handoffBaseDir(handoff.sessionId, options.root);
 	const stampedPath = handoffStampedPath(baseDir, handoff.timestamp);
 	const latestPath = join(dirname(baseDir), basename(baseDir), QOL_BUDGET_HANDOFF_LATEST);
-	const mkdir = options.mkdir ?? defaultMkdir;
+	const mkdir = options.mkdir ?? ((path: string) => openLaneDir(path, options.cwd));
 	const writer = options.writer ?? defaultWriter;
 	try {
 		mkdir(baseDir);

package/extensions/qol/compaction.ts

@@ -252,7 +252,7 @@ export function buildBudgetHandoff(ctx: ExtensionContext, options: {
 
 export function writeBudgetHandoffArtifact(ctx: ExtensionContext, handoff: QolBudgetHandoff): HandoffWriteResult {
 	const enabled = settingBoolean("compaction.handoffArtifactEnabled", true, ctx.cwd);
-	const result = writeBudgetHandoffArtifactRaw(handoff, { enabled });
+	const result = writeBudgetHandoffArtifactRaw(handoff, { cwd: ctx.cwd, enabled });
 	if (result.error) {
 		compactionNotify(ctx, `QOL handoff artifact write failed: ${result.error}`, "warning");
 	}

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;
@@ -72,7 +74,18 @@ export const DEFAULT_SESSION_SEARCH_PREVIEW_SNIPPETS = 6;
 export const DEFAULT_SESSION_SEARCH_SHORTCUT = "f2";
 export const DEFAULT_SESSION_SEARCH_SUMMARY_INPUT_CHARS = 180_000;
 export const DEFAULT_SESSION_SEARCH_SUMMARY_MAX_TOKENS = 4096;
-export const DEFAULT_SESSION_SEARCH_CACHE_TTL_SECONDS = 0;
+/** How long a loaded session-search index is kept. Past it the index is
+ *  released, and the next search loads it again. */
+export const DEFAULT_SESSION_SEARCH_CACHE_TTL_SECONDS = 300;
+/** Characters of one session's message text the search index keeps. */
+export const SESSION_SEARCH_TEXT_MAX_CHARS_PER_SESSION = 32_768;
+/** Characters of message text the whole search index keeps, newest session
+ *  first; sessions past it are searched by name, path and first prompt only. */
+export const SESSION_SEARCH_TEXT_MAX_CHARS = 8_388_608;
+/** Sessions whose user prompts the search overlay keeps parsed. */
+export const SESSION_SEARCH_USER_MESSAGES_MAX_SESSIONS = 64;
+/** Finished thinking blocks whose time a redrawn message can show again. */
+export const THINKING_TIMER_MAX_DURATIONS = 256;
 export const SESSION_SEARCH_OVERLAY_HEIGHT_RATIO = 0.9;
 
 export const DEFAULT_AUTO_RENAME_MODEL = "openai-codex/gpt-5.4-mini";

package/extensions/qol/glyphs.ts

@@ -1,4 +1,4 @@
-import { readPackageConfig } from "./settings.js";
+import { readPackageConfig } from "./package-config.js";
 
 export type GlyphStyle = "unicode" | "ascii";
 export type GlobalGlyphStyleOverride = "inherit" | GlyphStyle;

package/extensions/qol/images.ts

@@ -3,7 +3,8 @@ import { basename, resolve } from "node:path";
 import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { applyVisibleReplacements, buildVisibleMap, type VisibleReplacement } from "./ansi.js";
 import { IMAGE_EXTENSIONS, IMAGE_PATH_PATTERN } from "./constants.js";
-import { expandHome, settingBoolean } from "./settings.js";
+import { expandHome } from "./package-config.js";
+import { settingBoolean } from "./settings.js";
 
 function stripAtPrefix(path: string): string {
 	return path.startsWith("@") ? path.slice(1) : path;

package/extensions/qol/notifications.ts

@@ -1,23 +1,30 @@
-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;
 }
 
+/** Last send time per notification key, for the cooldown. An entry older than
+ *  the cooldown suppresses nothing, so each send drops those; question keys
+ *  carry a request id, so without the drop the map grows per question. */
 const lastNotificationAt = new Map<string, number>();
 const lastQuestionNotificationAt = new Map<string, number>();
 let tmuxMarkedTarget: string | undefined;
@@ -65,54 +72,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 queueTerminalWrite(write: () => Promise<void>): Promise<void> {
+	const queued = terminalWrites.then(write);
+	terminalWrites = queued.catch(() => undefined);
+	return queued;
 }
 
-function tmuxClientTtys(): string[] {
+/**
+ * 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 +167,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 +181,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 +222,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 +291,51 @@ function notificationEnabledFor(kind: QolNotificationKind, cwd?: string): boolea
 	}
 }
 
-export function sendQolNotification(ctx: ExtensionContext | undefined, kind: QolNotificationKind, body: string, level: QolNotificationLevel = "info", key: string = kind): void {
+/** Forget every notification cooldown and question dedup key; they belong to
+ *  the session that sent them. */
+export function resetQolNotificationCooldowns(): void {
+	lastNotificationAt.clear();
+	lastQuestionNotificationAt.clear();
+}
+
+/**
+ * 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;
-	lastNotificationAt.set(key, now);
+	if (cooldownMs > 0 && now - last < cooldownMs) return Promise.resolve();
+	for (const [storedKey, sentAt] of lastNotificationAt) {
+		if (now - sentAt >= cooldownMs) lastNotificationAt.delete(storedKey);
+	}
+	if (cooldownMs > 0) 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 +344,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 +354,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);
 }