pi-squire 0.13.0 → 0.14.0

package/CHANGELOG.md

@@ -6,6 +6,37 @@ follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.14.0] - 2026-10-27
+
+### Removed
+
+- The delegate popup: `enter` in `/delegates` and `/delegate-open --popup` no
+  longer open a tmux popup, and the popup title from 0.13.1 (the close key in
+  its title) goes with it. `--popup` is now an unknown-flag usage error. The
+  poll runs again only while a delegation is running. The close hint was hard to
+  see in some themes, and a switch covers the need.
+
+### Changed
+
+- `enter` in the `/delegates` panel, and in its peek, now switches your tmux
+  client to the delegate's window (the notice says your tmux last-session key returns you); `/delegate-open
+  <id>` with no flag switches too. The `s` key is gone. With no client attached,
+  switch still refuses; peek and close still work. tmux 3.2 stays the minimum,
+  for `new-session -e`.
+- Tests changed with it: in `test/navigator.test.ts` the panel hint, `enter`,
+  peek, no-client, failure, `/delegate-open` parsing, default and completion
+  tests now expect a switch, and the popup lifecycle tests are replaced by one
+  test that the poll runs only while a delegation does; `test/tmux.test.ts` no
+  longer tests `popup` and `closePopup`, and `test/popup-parent.ts` and the
+  fake's popup support are gone.
+
+## [0.13.1] - 2026-10-27
+
+### Changed
+
+- A delegate's popup title names the key that closes it, with your tmux prefix,
+  for example `scout-first · C-b d to close`.
+
 ## [0.13.0] - 2026-10-26
 
 ### Added
@@ -513,7 +544,9 @@ author's dotfiles; the changes below are against that copy.
 
 - The published file list includes `child.ts`, which `index.ts` imports.
 
-[Unreleased]: https://github.com/gvanderclay/pi-squire/compare/v0.13.0...HEAD
+[Unreleased]: https://github.com/gvanderclay/pi-squire/compare/v0.14.0...HEAD
+[0.14.0]: https://github.com/gvanderclay/pi-squire/compare/v0.13.1...v0.14.0
+[0.13.1]: https://github.com/gvanderclay/pi-squire/compare/v0.13.0...v0.13.1
 [0.13.0]: https://github.com/gvanderclay/pi-squire/compare/v0.12.0...v0.13.0
 [0.12.0]: https://github.com/gvanderclay/pi-squire/compare/v0.11.0...v0.12.0
 [0.11.0]: https://github.com/gvanderclay/pi-squire/compare/v0.10.0...v0.11.0

package/README.md

@@ -17,7 +17,7 @@ You need:
   on. Pi supplies the peer dependencies `@earendil-works/pi-coding-agent` and
   `typebox`.
 - tmux 3.2 or later, with the Pi session running in a tmux pane. That is the
-  first version with `new-session -e` and `display-popup`. Windows are placed
+  first version with `new-session -e`. Windows are placed
   relative to the pane's session (see [Where delegate windows
   open](#where-delegate-windows-open)), so a client attached elsewhere does
   not matter.
@@ -188,24 +188,21 @@ or done with auto-exit off, newest first. The model has no tool for any of this.
 | Key | Does |
 |---|---|
 | `↑` / `↓` | select a delegation; `esc` leaves the panel |
-| `enter` | open: a popup over your terminal, or a switch when the window is in the parent's own session |
-| `p` | peek: a snapshot of the window's pane (`capture-pane`) in an overlay; `r` refreshes, `enter` opens, `esc` returns to the list |
-| `s` | switch your tmux client to the window; `prefix L` returns you (tmux's last-session key) |
+| `enter` | switch your tmux client to the window |
+| `p` | peek: a snapshot of the window's pane (`capture-pane`) in an overlay; `r` refreshes, `enter` switches, `esc` returns to the list |
 | `x` | close the delegation as `delegation_close` does; asks first only while it is running |
 | `n` | new delegate: the same form `/delegate` opens with no arguments (see [First use](#first-use)) |
 
-Popup and switch act on the most recently active tmux client attached to the
-parent's session. With none attached they refuse with a notice; peek and close
-still work. The popup attaches to the window's session at that window, and
-detaching in it (`prefix d`) closes it. When the delegate's window goes, the parent
-closes the popup within one poll (up to 5 s). No tmux key bindings or options are
-added.
+Switch acts on the most recently active tmux client attached to the parent's
+session. With none attached it refuses with a notice; peek and close still
+work. No tmux key bindings or options are added.
 
-`/delegate-open <id> [--popup|--switch|--peek]` does one of these on one
-delegation without the panel: with no flag or with `--popup`, what `enter` does (a popup, or a
-switch for a window in the parent's own session, since a popup of one's own session would show it
-inside itself); `--switch` always switches; `--peek` opens the peek overlay. Ids complete from the
-open delegations.
+To come back, use your own tmux last-session key (tmux's default is `prefix L`,
+often rebound); the notice after a switch says so.
+
+`/delegate-open <id> [--switch|--peek]` does one of these on one delegation
+without the panel: with no flag or with `--switch`, it switches; `--peek` opens
+the peek overlay. Ids complete from the open delegations.
 
 ## Working directory
 
@@ -1048,7 +1045,7 @@ Other extensions may rely on:
   no-argument forms: `/delegate` opens the new-delegate form and
   `/delegate-resume` the resume picker;
 - the `/delegates` command and its `alt+shift+d` shortcut, and `/delegate-open <id>` with its
-  `--popup`, `--switch` and `--peek` flags;
+  `--switch` and `--peek` flags;
 - the `[delegate]` result text and the closed-without-a-result text;
 - `AGENT.md`'s frontmatter keys and its location,
   `<agent dir>/squire/agents/<name>/AGENT.md`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-squire",
-	"version": "0.13.0",
+	"version": "0.14.0",
 	"description": "Starts a delegate Pi session in a background tmux window, sends it the task over message:*, and shows the parent its result",
 	"keywords": [
 		"pi-package",

package/src/index.ts

@@ -1284,7 +1284,7 @@ export default function delegate(
 	);
 
 	pi.registerCommand("delegates", {
-		description: "Open the panel of delegates whose window is open: popup, peek, switch, close",
+		description: "Open the panel of delegates whose window is open: switch, peek, close",
 		handler: async (_args: string, ctx: ExtensionContext) => navigator.panel(ctx),
 	});
 

package/src/navigator.ts

@@ -1,7 +1,6 @@
 // The delegate navigator: the `/delegates` panel and `/delegate-open`. It lists
-// the delegations whose window is open and reaches one of them: a popup over
-// the user's tmux client, a switch of that client, a peek at the pane, or a
-// close. Everything here is a command or a key; the model gets no tool that
+// the delegations whose window is open and reaches one of them: a switch of
+// the user's tmux client to its window, a peek at the pane, or a close. Everything here is a command or a key; the model gets no tool that
 // moves the user's terminal.
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type Component, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
@@ -10,11 +9,11 @@ import { type DelegationState, deriveState, isStarted, type Results, recordedNam
 import type { TmuxClient, TmuxWindow } from "./tmux.ts";
 import { listWindows, ownWindow, type Tracking } from "./tracking.ts";
 
-/** What `/delegate-open` does: `auto` is what enter does in the panel. */
-export type OpenMode = "auto" | "popup" | "switch" | "peek";
+/** What `/delegate-open` does; switch is what enter does in the panel. */
+export type OpenMode = "switch" | "peek";
 
-export const OPEN_USAGE = "/delegate-open <id> [--popup|--switch|--peek]";
-const OPEN_FLAGS = ["--popup", "--switch", "--peek"] as const;
+export const OPEN_USAGE = "/delegate-open <id> [--switch|--peek]";
+const OPEN_FLAGS = ["--switch", "--peek"] as const;
 
 /** One delegation whose window is open. */
 type OpenDelegate = {
@@ -26,14 +25,14 @@ type OpenDelegate = {
 };
 
 /** What the panel hands back: the action the user chose on one delegation, or none. */
-type PanelResult = { action: "open" | "switch" | "close" | "peek"; id: string } | { action: "new" } | undefined;
+type PanelResult = { action: "switch" | "close" | "peek"; id: string } | { action: "new" } | undefined;
 
-/** What the peek hands back: open the delegate, or nothing. */
-type PeekResult = { action: "open" } | undefined;
+/** What the peek hands back: switch to the delegate, or nothing. */
+type PeekResult = { action: "switch" } | undefined;
 
-const HINT = "↑↓ select · enter open · p peek · s switch · x close · n new · esc leave";
+const HINT = "↑↓ select · enter switch · p peek · x close · n new · esc leave";
 const EMPTY = "No open delegates · n new · esc close";
-const PEEK_HINT = "r refresh · enter open · esc back";
+const PEEK_HINT = "r refresh · enter switch · esc back";
 
 /** Where a peek shows: over the panel or the editor, not in its place. */
 const PEEK_OPTIONS = { overlay: true, overlayOptions: { width: "90%", maxHeight: "90%", anchor: "center" } } as const;
@@ -82,9 +81,8 @@ class Panel implements Component {
 		else if (item === undefined) return;
 		else if (matchesKey(data, "up")) this.selected = (this.selected + count - 1) % count;
 		else if (matchesKey(data, "down")) this.selected = (this.selected + 1) % count;
-		else if (matchesKey(data, "enter")) this.done({ action: "open", id: item.id });
+		else if (matchesKey(data, "enter")) this.done({ action: "switch", id: item.id });
 		else if (matchesKey(data, "p")) this.done({ action: "peek", id: item.id });
-		else if (matchesKey(data, "s")) this.done({ action: "switch", id: item.id });
 		else if (matchesKey(data, "x")) this.done({ action: "close", id: item.id });
 		this.redraw();
 	}
@@ -101,7 +99,7 @@ class Panel implements Component {
 	}
 }
 
-/** A snapshot of one delegate's pane, shown as an overlay: `r` refreshes, enter opens, esc returns. */
+/** A snapshot of one delegate's pane, shown as an overlay: `r` refreshes, enter switches, esc returns. */
 class PeekView implements Component {
 	private capture: Capture = { text: "", error: undefined, loading: true };
 	private readonly item: OpenDelegate;
@@ -147,7 +145,7 @@ class PeekView implements Component {
 	handleInput(data: string): void {
 		if (matchesKey(data, "escape")) this.done(undefined);
 		else if (matchesKey(data, "r")) this.refresh();
-		else if (matchesKey(data, "enter")) this.done({ action: "open" });
+		else if (matchesKey(data, "enter")) this.done({ action: "switch" });
 		this.redraw();
 	}
 
@@ -176,10 +174,10 @@ export function parseOpen(text: string): { id: string; mode: OpenMode } | { erro
 	const ids = words.filter((word) => !word.startsWith("-"));
 	const unknown = flags.find((flag) => !(OPEN_FLAGS as readonly string[]).includes(flag));
 	if (unknown !== undefined) return { error: `unknown flag ${unknown}; ${OPEN_USAGE}` };
-	if (flags.length > 1) return { error: `give at most one of --popup, --switch and --peek; ${OPEN_USAGE}` };
+	if (flags.length > 1) return { error: `give at most one of --switch and --peek; ${OPEN_USAGE}` };
 	if (ids.length !== 1) return { error: `give one delegation id; ${OPEN_USAGE}` };
 	const flag = flags[0];
-	return { id: ids[0], mode: flag === undefined ? "auto" : (flag.slice(2) as OpenMode) };
+	return { id: ids[0], mode: flag === undefined ? "switch" : (flag.slice(2) as OpenMode) };
 }
 
 /** Completions for `/delegate-open`: ids first, then the mode flags not yet given. */
@@ -194,7 +192,7 @@ export function openCompletions(prefix: string, ids: readonly string[]): { value
 	return hits.length > 0 ? hits.map((value) => ({ value: head + value, label: value })) : null;
 }
 
-type Env = { results: Results; tmux: TmuxClient; tracking: Pick<Tracking, "trackPopup" | "close"> };
+type Env = { results: Results; tmux: TmuxClient; tracking: Pick<Tracking, "close"> };
 
 /** The open delegations, newest first, from the records and one listing; undefined when tmux cannot be asked. */
 async function openDelegates({ results, tmux }: Env): Promise<OpenDelegate[] | undefined> {
@@ -233,24 +231,6 @@ async function clientOf(tmux: TmuxClient): Promise<{ client: string } | { refusa
 	}
 }
 
-async function popup(env: Env, ctx: ExtensionContext, item: OpenDelegate): Promise<void> {
-	const found = await clientOf(env.tmux);
-	if ("refusal" in found) return ctx.ui.notify(`delegate: cannot open a popup: ${found.refusal}`, "warning");
-	// Tracked before it launches, so a popup that closes at once is forgotten too.
-	const forget = env.tracking.trackPopup({
-		windowId: item.window.id,
-		windowName: item.window.name,
-		client: found.client,
-	});
-	try {
-		// Resolves once the popup is up, not when it closes; `forget` runs when it closes.
-		await env.tmux.popup(found.client, { id: item.window.id, name: item.window.name }, forget);
-	} catch (err) {
-		forget();
-		return ctx.ui.notify(`delegate: could not open a popup: ${(err as Error).message}`, "error");
-	}
-}
-
 async function switchTo(env: Env, ctx: ExtensionContext, item: OpenDelegate): Promise<void> {
 	const found = await clientOf(env.tmux);
 	if ("refusal" in found) return ctx.ui.notify(`delegate: cannot switch: ${found.refusal}`, "warning");
@@ -259,13 +239,10 @@ async function switchTo(env: Env, ctx: ExtensionContext, item: OpenDelegate): Pr
 	} catch (err) {
 		return ctx.ui.notify(`delegate: could not switch: ${(err as Error).message}`, "error");
 	}
-	ctx.ui.notify(`delegate: switched to ${item.name} (${item.window.id}) · prefix L returns you`, "info");
-}
-
-/** Enter's behaviour: a switch inside the parent's own session, else a popup. */
-async function open(env: Env, ctx: ExtensionContext, item: OpenDelegate): Promise<void> {
-	const own = await ownSessionName(env.tmux);
-	return own !== undefined && own === item.window.session ? switchTo(env, ctx, item) : popup(env, ctx, item);
+	ctx.ui.notify(
+		`delegate: switched to ${item.name} (${item.window.id}) · your tmux last-session key returns you`,
+		"info",
+	);
 }
 
 /** Close through the `delegation_close` path, asking first only while the delegate runs. */
@@ -294,7 +271,7 @@ function show(ctx: ExtensionContext, items: readonly OpenDelegate[]): Promise<Pa
 	);
 }
 
-/** Peek at a delegate's pane in an overlay; true when the user chose to open it. */
+/** Peek at a delegate's pane in an overlay; true when the user chose to switch to it. */
 async function peek(env: Env, ctx: ExtensionContext, item: OpenDelegate): Promise<boolean> {
 	const result = await ctx.ui.custom<PeekResult>(
 		(tui, theme, _keybindings, done): PeekView =>
@@ -308,7 +285,7 @@ async function peek(env: Env, ctx: ExtensionContext, item: OpenDelegate): Promis
 			}),
 		PEEK_OPTIONS,
 	);
-	return result?.action === "open";
+	return result?.action === "switch";
 }
 
 const noUi = (ctx: ExtensionContext): void => ctx.ui.notify("delegate: this needs an interactive session", "error");
@@ -335,10 +312,10 @@ async function act(
 	}
 	if (result.action === "peek") {
 		if (!(await peek(env, ctx, item))) return true; // back to the panel
-		await open(env, ctx, item);
+		await switchTo(env, ctx, item);
 		return false;
 	}
-	await (result.action === "switch" ? switchTo(env, ctx, item) : open(env, ctx, item));
+	await switchTo(env, ctx, item);
 	return false;
 }
 
@@ -352,16 +329,15 @@ async function openOne(env: Env, ctx: ExtensionContext, id: string, mode: OpenMo
 		return ctx.ui.notify(`delegate: no open delegate ${JSON.stringify(id)}; open: ${known}`, "error");
 	}
 	if (mode === "switch") return switchTo(env, ctx, item);
-	if (mode !== "peek") return open(env, ctx, item); // --popup follows enter's rule too
 	if (!ctx.hasUI) return noUi(ctx);
-	if (await peek(env, ctx, item)) await open(env, ctx, item);
+	if (await peek(env, ctx, item)) await switchTo(env, ctx, item);
 }
 
 /** The navigator over the records, tmux and tracking. `startNew` is the new-delegate flow, wired by the entry. */
 export function createNavigator(
 	results: Results,
 	tmux: TmuxClient,
-	tracking: Pick<Tracking, "trackPopup" | "close">,
+	tracking: Pick<Tracking, "close">,
 	startNew: (ctx: ExtensionContext) => Promise<void> | void,
 ): Navigator {
 	const env: Env = { results, tmux, tracking };

package/src/poll.ts

@@ -1,9 +1,8 @@
 // The poll: every few seconds the parent checks its running delegations,
-// declares gone those whose window is gone, and closes the popups of windows
-// that went. It runs while a delegation is running or a popup is open.
+// declares gone those whose window is gone. It runs only while a delegation is
+// running.
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
-import { createPopups, type Popup, type Popups } from "./popups.ts";
 import type { Results } from "./results.ts";
 import type { TmuxClient, TmuxWindow } from "./tmux.ts";
 import { listWindows, windowState } from "./windows.ts";
@@ -24,27 +23,16 @@ function declareGone(pi: ExtensionAPI, results: Results, windows: TmuxWindow[] |
 	}
 }
 
-/** One sweep: claim waiting replies, declare gone every delegation whose window is missing or exited with still no result, and close the popups of gone windows. */
-async function sweep(
-	pi: ExtensionAPI,
-	results: Results,
-	tmux: TmuxClient,
-	popups: Popups,
-	live: () => boolean,
-): Promise<void> {
-	let windows: TmuxWindow[] | undefined;
-	let asked = false;
+/** One sweep: claim waiting replies, declare gone every delegation whose window is missing or exited with still no result. */
+async function sweep(pi: ExtensionAPI, results: Results, tmux: TmuxClient, live: () => boolean): Promise<void> {
 	if (results.running().length > 0) {
 		const scan: { scanned?: boolean } = {};
 		pi.events.emit(SCAN, scan);
 		// No message:* provider: a waiting reply cannot be ruled out, so nothing is declared gone.
 		if (scan.scanned === true) {
-			windows = await listWindows(tmux); // one ask per tick
-			asked = true;
-			declareGone(pi, results, windows, live);
+			declareGone(pi, results, await listWindows(tmux), live); // one ask per tick
 		}
 	}
-	if (popups.count() > 0) await popups.closeGone(asked ? windows : await listWindows(tmux));
 }
 
 /** The poll over the records and tmux. `arm` readies it for a new session; `stop` ends it for good. */
@@ -52,13 +40,12 @@ export function createPoll(
 	pi: ExtensionAPI,
 	results: Results,
 	tmux: TmuxClient,
-): { start(): void; stop(): void; arm(): void; track(popup: Popup): () => void } {
-	/** The poll timer; set only while something is running or a popup is open. */
+): { start(): void; stop(): void; arm(): void } {
+	/** The poll timer; set only while a delegation is running. */
 	let poll: ReturnType<typeof setInterval> | undefined;
 	let ticking = false;
 	/** False once the session shuts down, so a tick still awaiting tmux declares nothing. */
 	let live = true;
-	const popups = createPopups(tmux);
 
 	function stopPolling(): void {
 		if (poll !== undefined) clearInterval(poll);
@@ -66,21 +53,21 @@ export function createPoll(
 	}
 
 	/** Whether the poll has anything left to watch. */
-	const busy = (): boolean => results.running().length > 0 || popups.count() > 0;
+	const busy = (): boolean => results.running().length > 0;
 
 	async function tick(): Promise<void> {
 		if (ticking) return;
 		ticking = true;
 		try {
 			if (!busy()) return stopPolling();
-			await sweep(pi, results, tmux, popups, () => live);
+			await sweep(pi, results, tmux, () => live);
 			if (!busy()) stopPolling();
 		} finally {
 			ticking = false;
 		}
 	}
 
-	/** Start the timer when something is running or a popup is open; it never keeps the process alive. */
+	/** Start the timer while a delegation is running; it never keeps the process alive. */
 	function startPolling(): void {
 		if (poll !== undefined || !busy()) return;
 		poll = setInterval(() => void tick(), POLL_MS);
@@ -89,22 +76,12 @@ export function createPoll(
 
 	return {
 		start: startPolling,
-		track(popup: Popup): () => void {
-			const forget = popups.track(popup);
-			startPolling();
-			return (): void => {
-				forget();
-				if (!busy()) stopPolling();
-			};
-		},
 		stop(): void {
 			live = false;
 			stopPolling();
-			popups.clear();
 		},
 		arm(): void {
 			stopPolling();
-			popups.clear();
 			live = true;
 		},
 	};

package/src/tmux.ts

@@ -1,6 +1,6 @@
 // The tmux operations `delegate` needs, behind an interface so tests can use a
 // fake. This client talks to tmux with `execFile` and no shell.
-import { execFile, spawn } from "node:child_process";
+import { execFile } from "node:child_process";
 
 import type { WindowPlacement } from "./window-placement.ts";
 
@@ -18,7 +18,7 @@ export type TmuxWindow = { id: string; session: string; name: string; exited: bo
 /** A window just opened: its id and the name of the session it is in, when known. */
 export type OpenedWindow = { id: string; session: string | undefined };
 
-/** The oldest tmux delegate windows need: `new-session -e` and `display-popup` arrived in 3.2. */
+/** The oldest tmux delegate windows need: `new-session -e` arrived in 3.2. */
 export const MIN_TMUX = { major: 3, minor: 2 } as const;
 
 export type TmuxVersion = { text: string; major: number; minor: number };
@@ -62,9 +62,6 @@ export class WindowOpenError extends Error {
 	}
 }
 
-/** A window as the popup needs it: its id and its name, which titles the popup. */
-export type PopupWindow = { id: string; name: string };
-
 /** The session the parent's pane is in: its id (`$N`) and name. */
 export type OwnSession = { id: string; name: string };
 
@@ -89,16 +86,6 @@ export interface TmuxClient {
 	clientFor(session: string): Promise<string | undefined>;
 	/** Show the window to a client: `switch-client -c <client> -t @N`. */
 	switchTo(client: string, windowId: string): Promise<void>;
-	/**
-	 * Open a popup over a client that attaches to the window's session at the
-	 * window. `display-popup` returns only when the popup closes, so this
-	 * resolves once the popup was launched, not when it ends, and a launch that
-	 * fails at once rejects. `onExit` runs when the popup's process ends, however
-	 * the popup was closed, and not when the launch failed.
-	 */
-	popup(client: string, window: PopupWindow, onExit: () => void): Promise<void>;
-	/** Close the popup on a client (`display-popup -C`). */
-	closePopup(client: string): Promise<void>;
 	/** The window's visible pane as text (`capture-pane -p`). */
 	capture(windowId: string): Promise<string>;
 }
@@ -139,48 +126,6 @@ async function parentSession(run: Run): Promise<Parent | undefined> {
 	return id.trim() === "" ? undefined : { id: id.trim(), name: name.join("\t"), companion: marker === "1" };
 }
 
-/** How long a launched popup may take to fail before it counts as shown. */
-const POPUP_SETTLE_MS = 300;
-
-/**
- * Launch `display-popup`, which blocks until the popup closes, detached and
- * outside `runTmux`'s timeout. Resolves once it is up; rejects on a spawn
- * error or an exit within the settle time. Its stderr is read only until then
- * and then released, so the open popup keeps nothing of this process alive;
- * `onExit` runs when the popup's process ends, however it was closed.
- */
-function launchPopup(args: string[], onExit: () => void): Promise<void> {
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		let stderr = "";
-		const child = spawn("tmux", args, { detached: true, stdio: ["ignore", "ignore", "pipe"] });
-		const onData = (chunk: Buffer): void => {
-			if (stderr.length < 4096) stderr += chunk.toString();
-		};
-		child.stderr?.on("data", onData);
-		const settle = (error?: Error): void => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			child.stderr?.off("data", onData);
-			child.stderr?.destroy();
-			if (error === undefined) resolve();
-			else reject(error);
-		};
-		const timer = setTimeout(() => settle(), POPUP_SETTLE_MS);
-		child.on("error", (err) => settle(err));
-		child.on("close", (code) => {
-			if (!settled && code !== 0) {
-				settle(new Error(stderr.trim() !== "" ? stderr.trim() : `tmux display-popup exited with ${code}`));
-				return;
-			}
-			settle();
-			onExit();
-		});
-		child.unref();
-	});
-}
-
 const envArgs = (spec: WindowSpec): string[] =>
 	Object.entries(spec.env).flatMap(([key, value]) => ["-e", `${key}=${value}`]);
 
@@ -250,10 +195,8 @@ function openCurrent(run: Run, spec: WindowSpec, parent: Parent | undefined): Pr
 	return create(run, args);
 }
 
-/** The methods that reach a delegate's window from the user's terminal: clients, switch, popup, capture. */
-function navigation(
-	run: Run,
-): Pick<TmuxClient, "ownSession" | "clientFor" | "switchTo" | "popup" | "closePopup" | "capture"> {
+/** The methods that reach a delegate's window from the user's terminal: clients, switch, capture. */
+function navigation(run: Run): Pick<TmuxClient, "ownSession" | "clientFor" | "switchTo" | "capture"> {
 	return {
 		async ownSession() {
 			const parent = await parentSession(run);
@@ -276,22 +219,6 @@ function navigation(
 			await run(["switch-client", "-c", client, "-t", windowId]);
 		},
 
-		async popup(client, window, onExit) {
-			if (!/^@[0-9]+$/.test(window.id)) throw new Error(`${window.id} is not a tmux window id`);
-			const sessionId = (await run(["display-message", "-p", "-t", window.id, "-F", "#{session_id}"])).trim();
-			if (!/^\$[0-9]+$/.test(sessionId)) throw new Error(`tmux reported an invalid session id for ${window.id}`);
-			// Ids are `@N` and `$N` only; quoted so the popup's shell does not expand `$N`.
-			const command = `tmux select-window -t '${window.id}' \\; attach-session -t '${sessionId}'`;
-			await launchPopup(
-				["display-popup", "-c", client, "-E", "-w", "90%", "-h", "90%", "-T", window.name, command],
-				onExit,
-			);
-		},
-
-		async closePopup(client) {
-			await run(["display-popup", "-C", "-c", client]);
-		},
-
 		async capture(windowId) {
 			return run(["capture-pane", "-p", "-t", windowId]);
 		},

package/src/tracking.ts

@@ -9,7 +9,6 @@ import { type Static, Type } from "typebox";
 
 import { type Mark, readMarks } from "./limits.ts";
 import { createPoll } from "./poll.ts";
-import type { Popup } from "./popups.ts";
 import { attemptLines, cwdLine, modelLabel, snapshotLines, workspaceLine } from "./render.ts";
 import {
 	type DelegationState,
@@ -37,10 +36,8 @@ export { listWindows, ownWindow, windowState };
 export type Tracking = {
 	/** Register `delegation_status` and `delegation_close`. */
 	registerTools(): void;
-	/** Start the poll when something is running or a popup is open. */
+	/** Start the poll when a delegation is running. */
 	startPolling(): void;
-	/** Remember a popup the parent opened; the poll closes it once its window is gone. Returns the call that forgets it when its process ends. */
-	trackPopup(popup: Popup): () => void;
 	/** Close one delegation as `delegation_close` does; throws as the tool does. */
 	close(id: string): Promise<CloseResult>;
 	/** On `session_start`: rebuild the records and restart the poll. */
@@ -410,7 +407,6 @@ export function createTracking(
 			pi.registerTool(closeTool(results, tmux) as never);
 		},
 		startPolling: poll.start,
-		trackPopup: poll.track,
 		close: (id: string): Promise<CloseResult> => closeDelegation(results, tmux, id),
 		restore(ctx: ExtensionContext): void {
 			poll.arm();

package/src/popups.ts

@@ -1,49 +0,0 @@
-// The popups the parent opened over the user's tmux clients. tmux closes a
-// popup's contents when the delegate's window goes, but not the popup itself:
-// the poll closes it, through this registry, once its window is gone. A client
-// shows one popup at a time, so the registry holds the current popup per
-// client; a new popup replaces the old record, and a record is dropped when
-// its own popup's process ends, so a stale record never closes a newer popup.
-import type { TmuxClient, TmuxWindow } from "./tmux.ts";
-
-/** A popup the parent opened: the window it shows and the client it is on. */
-export type Popup = { windowId: string; windowName: string; client: string };
-
-export type Popups = {
-	/** Remember a popup as its client's current one; returns the call that forgets exactly this popup. */
-	track(popup: Popup): () => void;
-	/** How many popups are remembered. */
-	count(): number;
-	/** Forget every popup, closing none. */
-	clear(): void;
-	/** Close each current popup whose window is not in `windows`; a failed listing (undefined) keeps them all for the next tick. */
-	closeGone(windows: TmuxWindow[] | undefined): Promise<void>;
-};
-
-export function createPopups(tmux: TmuxClient): Popups {
-	const current = new Map<string, Popup>();
-	return {
-		track(popup: Popup): () => void {
-			const entry = { ...popup };
-			current.set(entry.client, entry);
-			return (): void => {
-				if (current.get(entry.client) === entry) current.delete(entry.client);
-			};
-		},
-		count: (): number => current.size,
-		clear: (): void => current.clear(),
-		async closeGone(windows: TmuxWindow[] | undefined): Promise<void> {
-			if (windows === undefined) return;
-			for (const entry of [...current.values()]) {
-				const here = windows.some((window) => window.id === entry.windowId && window.name === entry.windowName);
-				if (here || current.get(entry.client) !== entry) continue;
-				current.delete(entry.client); // forgotten first, so nothing closes it twice
-				try {
-					await tmux.closePopup(entry.client);
-				} catch {
-					// The popup may already be closed or its client gone; one try, then forgotten.
-				}
-			}
-		},
-	};
-}