pi-squire 0.12.0 → 0.13.0

package/src/resume-checks.ts

@@ -0,0 +1,159 @@
+// The checks a resume makes before it launches anything, shared by `resume`
+// and the resume picker so both accept the same delegations: the call-wide
+// prerequisites once, then per record the window, session file, agent, thinking
+// level and model. None of them changes anything; killing an exited window and
+// deciding trust stay with the resume itself.
+import { statSync } from "node:fs";
+import { isAbsolute } from "node:path";
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import type { Agent } from "./agents.ts";
+import { sessionHeaderCwd, sessionIdOf } from "./result-sessions.ts";
+import { deriveState, finishedModel, locateSession, type StartedRecorded } from "./results.ts";
+import type { ResumeDeps, ResumeRequest } from "./resume.ts";
+import { requireTmuxVersion, type TmuxWindow } from "./tmux.ts";
+import { ownWindow, windowState } from "./tracking.ts";
+import type { WindowPlacement } from "./window-placement.ts";
+
+/**
+ * Steps 3 and 4: no process of this delegate is left. A running delegate is
+ * mailed instead; tmux that cannot be asked proves nothing; a window with the
+ * record's id and name that still runs its program is refused, and one whose
+ * program exited is killed first.
+ */
+export function windowCheck(record: StartedRecorded, windows: TmuxWindow[] | undefined): TmuxWindow | undefined {
+	const state = deriveState(record, windowState(windows, record));
+	if (state === "running") {
+		throw new Error(`delegation ${record.id} is running; send it a message instead of resuming it`);
+	}
+	if (windows === undefined || state === "unknown") {
+		throw new Error(`could not ask tmux whether delegation ${record.id}'s window is open, so it is not resumed`);
+	}
+	const own = ownWindow(windows, record);
+	if (own !== undefined && !own.exited) {
+		throw new Error(
+			`delegation ${record.id}'s window ${record.windowName} (${record.windowId}) is still open; its Pi may still be running, so it is not resumed. Close it with delegation_close, or send it a message`,
+		);
+	}
+	return own;
+}
+
+/** Whether `path` is an existing directory. */
+export function isDirectory(path: string): boolean {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+/** A delegate's session file, the directory its header says Pi runs it in, and the session directory to pass. */
+export type SessionFile = { path: string; cwd: string; dir: string };
+
+/** Step 5: the session file, and the directory its header says Pi will run it in. */
+export function sessionFor(record: StartedRecorded, ctx: ExtensionContext): SessionFile {
+	const dir = record.sessionDir ?? ctx.sessionManager.getSessionDir();
+	const path = locateSession(record, ctx.sessionManager.getSessionDir());
+	if (path === undefined) {
+		throw new Error(
+			`no session file for session ${sessionIdOf(record)} was found in ${dir}, so delegation ${record.id} is not resumable`,
+		);
+	}
+	if (!isAbsolute(path) || !isAbsolute(dir)) {
+		throw new Error(
+			`the session file ${path} or its directory ${dir} is not an absolute path, so delegation ${record.id} is not resumable`,
+		);
+	}
+	const cwd = sessionHeaderCwd(path);
+	if (cwd === undefined) {
+		throw new Error(
+			`could not read a working directory from the header of ${path}, so delegation ${record.id} is not resumable`,
+		);
+	}
+	if (!isDirectory(cwd)) {
+		throw new Error(
+			`delegation ${record.id}'s session runs in ${cwd}, which no longer exists, so it is not resumable (a removed worktree cannot be resumed)`,
+		);
+	}
+	return { path, cwd, dir };
+}
+
+/** The model choices: an explicit model alone, else where the delegate ended, then the agent's fallbacks. */
+export function preferredModels(record: StartedRecorded, agent: Agent, sessionPath: string): string[] {
+	const ended = finishedModel(sessionPath) ?? record.result?.finishedModel ?? record.model;
+	return [...new Set([ended, ...agent.fallback])];
+}
+
+/** Steps 5 and 6: the session file and the agent, and no resume of the delegation already under way. */
+export function recordCheck(
+	deps: ResumeDeps,
+	record: StartedRecorded,
+	ctx: ExtensionContext,
+): { session: SessionFile; agent: Agent } {
+	const session = sessionFor(record, ctx);
+	const agent = deps.roster(ctx).agents.find((item) => item.name === record.agent);
+	if (agent === undefined) {
+		throw new Error(
+			`agent ${JSON.stringify(record.agent)} is no longer in the roster, so delegation ${record.id} is not resumed`,
+		);
+	}
+	if (inFlight.has(record.id)) throw new Error(`delegation ${record.id} is already being resumed`);
+	return { session, agent };
+}
+
+/** The thinking level and model a resume runs with; throws when the level is invalid or no model can be used. */
+export async function settleModel(
+	deps: ResumeDeps,
+	input: {
+		record: StartedRecorded;
+		agent: Agent;
+		session: SessionFile;
+		request: Pick<ResumeRequest, "model" | "thinking">;
+	},
+	ctx: ExtensionContext,
+): Promise<{ thinking: string; chosen: Awaited<ReturnType<ResumeDeps["chooseModel"]>> }> {
+	const { record, agent, session, request } = input;
+	const thinking = request.thinking ?? record.thinking;
+	const badThinking = deps.thinkingProblem(thinking);
+	if (badThinking !== undefined) throw new Error(badThinking);
+	const preferred = preferredModels(record, agent, session.path);
+	return { thinking, chosen: await deps.chooseModel(request.model, agent, ctx.modelRegistry, preferred) };
+}
+
+/** The call-wide prerequisites of a resume: inside tmux, a new enough tmux, a valid placement setting (read once). */
+export async function preflight(deps: ResumeDeps): Promise<WindowPlacement> {
+	if (!deps.tmux.insideTmux()) throw new Error(deps.notInTmux);
+	await requireTmuxVersion(deps.tmux);
+	return deps.placement();
+}
+
+/** The delegation ids with a resume under way in this process. */
+export const inFlight = new Set<string>();
+
+/** Whether `record` passes every check a resume makes that changes nothing; the resume's own kill of an exited window and trust prompt are left to it. */
+export async function passes(
+	deps: ResumeDeps,
+	record: StartedRecorded,
+	windows: TmuxWindow[],
+	ctx: ExtensionContext,
+	models: Map<string, boolean>,
+): Promise<boolean> {
+	try {
+		windowCheck(record, windows);
+		const { session, agent } = recordCheck(deps, record, ctx);
+		// Model choice depends on the agent and where the delegate ended, so records alike share one answer.
+		const key = JSON.stringify([record.thinking, agent.name, preferredModels(record, agent, session.path)]);
+		let ok = models.get(key);
+		if (ok === undefined) {
+			ok = await settleModel(deps, { record, agent, session, request: {} }, ctx).then(
+				() => true,
+				() => false,
+			);
+			models.set(key, ok);
+		}
+		return ok;
+	} catch {
+		return false;
+	}
+}

package/src/resume-picker.ts

@@ -0,0 +1,50 @@
+// `/delegate-resume` with no arguments: pick one of the delegations a resume
+// would accept, write the follow-up in the multi-line editor, then resume it
+// the way the command does.
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { recordedName, type StartedRecorded } from "./results.ts";
+
+/** What the picker reads from the resume path in `index.ts`. */
+export type ResumePickerDeps = {
+	/** Why nothing can resume now (not inside tmux), or undefined. */
+	unavailable(): string | undefined;
+	/** The delegations a resume accepts now, newest first. */
+	eligible(ctx: ExtensionContext): Promise<StartedRecorded[]>;
+	/** Resume as the command does, notifying the start or the refusal. */
+	resume(request: { id: string; task: string }, ctx: ExtensionContext): Promise<void>;
+};
+
+/** One picker line; the id prefix keeps two delegations with one name apart. */
+const optionFor = (record: StartedRecorded): string =>
+	`${recordedName(record)} · ${record.agent} · ${record.id.slice(0, 8)}`;
+
+export async function pickResume(ctx: ExtensionContext, deps: ResumePickerDeps): Promise<void> {
+	const unavailable = deps.unavailable();
+	if (unavailable !== undefined) {
+		ctx.ui.notify(`delegate: ${unavailable}`, "error");
+		return;
+	}
+	let records: StartedRecorded[];
+	try {
+		records = await deps.eligible(ctx);
+	} catch (err) {
+		ctx.ui.notify(`delegate: ${(err as Error).message}`, "error");
+		return;
+	}
+	if (records.length === 0) {
+		ctx.ui.notify("delegate: no delegation can be resumed now", "info");
+		return;
+	}
+	const options = records.map(optionFor);
+	const picked = await ctx.ui.select("Resume which delegation?", options);
+	const record = records[options.indexOf(picked ?? "")];
+	if (record === undefined) return;
+	const task = await ctx.ui.editor(`Follow-up for ${recordedName(record)}`);
+	if (task === undefined) return;
+	if (task.trim() === "") {
+		ctx.ui.notify("delegate: a task is required", "error");
+		return;
+	}
+	await deps.resume({ id: record.id, task }, ctx);
+}

package/src/resume.ts

@@ -5,25 +5,24 @@
 // `index.ts` supplies the pieces it shares with a launch: model choice, trust,
 // the task mail and the window.
 import { randomUUID } from "node:crypto";
-import { statSync } from "node:fs";
-import { isAbsolute } from "node:path";
 
 import type { ExtensionContext, ModelRegistry } from "@earendil-works/pi-coding-agent";
 import { type TObject, Type } from "typebox";
 
 import { type Agent, type Roster, THINKING_LEVELS } from "./agents.ts";
-import { sessionHeaderCwd, sessionIdOf } from "./result-sessions.ts";
+import { sessionIdOf } from "./result-sessions.ts";
+import { isStarted, type Results, recordedName, type StartedRecorded } from "./results.ts";
 import {
-	deriveState,
-	finishedModel,
-	isStarted,
-	locateSession,
-	type Results,
-	recordedName,
-	type StartedRecorded,
-} from "./results.ts";
-import { type OpenedWindow, requireTmuxVersion, type TmuxClient } from "./tmux.ts";
-import { listWindows, ownWindow, type ToolDef, toolResult, windowState } from "./tracking.ts";
+	inFlight,
+	passes,
+	preflight,
+	recordCheck,
+	type SessionFile,
+	settleModel,
+	windowCheck,
+} from "./resume-checks.ts";
+import type { OpenedWindow, TmuxClient } from "./tmux.ts";
+import { listWindows, type ToolDef, toolResult } from "./tracking.ts";
 import type { WindowPlacement } from "./window-placement.ts";
 import type { Workspace } from "./workspace.ts";
 
@@ -142,28 +141,10 @@ function newestStarted(results: Results, id: string): StartedRecorded {
 	return record;
 }
 
-/**
- * Steps 3 and 4: no process of this delegate is left. A running delegate is
- * mailed instead; tmux that cannot be asked proves nothing; a window with the
- * record's id and name that still runs its program is refused, and one whose
- * program exited is killed first.
- */
+/** Steps 3 and 4, then the kill of an exited window; `windowCheck` is the part the picker shares. */
 async function ensureExited(record: StartedRecorded, tmux: TmuxClient): Promise<void> {
-	const windows = await listWindows(tmux);
-	const state = deriveState(record, windowState(windows, record));
-	if (state === "running") {
-		throw new Error(`delegation ${record.id} is running; send it a message instead of resuming it`);
-	}
-	if (windows === undefined || state === "unknown") {
-		throw new Error(`could not ask tmux whether delegation ${record.id}'s window is open, so it is not resumed`);
-	}
-	const own = ownWindow(windows, record);
+	const own = windowCheck(record, await listWindows(tmux));
 	if (own === undefined) return;
-	if (!own.exited) {
-		throw new Error(
-			`delegation ${record.id}'s window ${record.windowName} (${record.windowId}) is still open; its Pi may still be running, so it is not resumed. Close it with delegation_close, or send it a message`,
-		);
-	}
 	try {
 		await tmux.kill(own.id);
 	} catch (err) {
@@ -173,52 +154,6 @@ async function ensureExited(record: StartedRecorded, tmux: TmuxClient): Promise<
 	}
 }
 
-/** Whether `path` is an existing directory. */
-function isDirectory(path: string): boolean {
-	try {
-		return statSync(path).isDirectory();
-	} catch {
-		return false;
-	}
-}
-
-/** A delegate's session file, the directory its header says Pi runs it in, and the session directory to pass. */
-type SessionFile = { path: string; cwd: string; dir: string };
-
-/** Step 5: the session file, and the directory its header says Pi will run it in. */
-function sessionFor(record: StartedRecorded, ctx: ExtensionContext): SessionFile {
-	const dir = record.sessionDir ?? ctx.sessionManager.getSessionDir();
-	const path = locateSession(record, ctx.sessionManager.getSessionDir());
-	if (path === undefined) {
-		throw new Error(
-			`no session file for session ${sessionIdOf(record)} was found in ${dir}, so delegation ${record.id} is not resumable`,
-		);
-	}
-	if (!isAbsolute(path) || !isAbsolute(dir)) {
-		throw new Error(
-			`the session file ${path} or its directory ${dir} is not an absolute path, so delegation ${record.id} is not resumable`,
-		);
-	}
-	const cwd = sessionHeaderCwd(path);
-	if (cwd === undefined) {
-		throw new Error(
-			`could not read a working directory from the header of ${path}, so delegation ${record.id} is not resumable`,
-		);
-	}
-	if (!isDirectory(cwd)) {
-		throw new Error(
-			`delegation ${record.id}'s session runs in ${cwd}, which no longer exists, so it is not resumable (a removed worktree cannot be resumed)`,
-		);
-	}
-	return { path, cwd, dir };
-}
-
-/** The model choices: an explicit model alone, else where the delegate ended, then the agent's fallbacks. */
-function preferredModels(record: StartedRecorded, agent: Agent, sessionPath: string): string[] {
-	const ended = finishedModel(sessionPath) ?? record.result?.finishedModel ?? record.model;
-	return [...new Set([ended, ...agent.fallback])];
-}
-
 /** The tool's result: the `delegate` tool's plus the delegation it resumed. */
 function resultSchema(delegateSchema: TObject): TObject {
 	return Type.Object({
@@ -243,11 +178,7 @@ async function planResume(
 	signal: AbortSignal | undefined,
 ): Promise<Plan> {
 	const { record, agent, session, request } = input;
-	const thinking = request.thinking ?? record.thinking;
-	const badThinking = deps.thinkingProblem(thinking);
-	if (badThinking !== undefined) throw new Error(badThinking);
-	const preferred = preferredModels(record, agent, session.path);
-	const chosen = await deps.chooseModel(request.model, agent, ctx.modelRegistry, preferred);
+	const { thinking, chosen } = await settleModel(deps, input, ctx);
 	const autoExit = request.autoExit ?? record.autoExit === true;
 	const prepared = await deps.prepareDirectory(session.cwd, ctx, signal);
 	// A managed worktree keeps its launch facts while the session still runs in it.
@@ -350,9 +281,6 @@ async function startResume(
 	};
 }
 
-/** The delegation ids with a resume under way in this process. */
-const inFlight = new Set<string>();
-
 /** Resume `request.id`: every eligibility check in order, then the launch. */
 async function resume(
 	deps: ResumeDeps,
@@ -360,20 +288,11 @@ async function resume(
 	ctx: ExtensionContext,
 	signal: AbortSignal | undefined,
 ): Promise<Resumed> {
-	if (!deps.tmux.insideTmux()) throw new Error(deps.notInTmux);
-	await requireTmuxVersion(deps.tmux);
-	const placement = deps.placement(); // read once, before the exited window is killed or anything is mailed
+	const placement = await preflight(deps); // read once, before the exited window is killed or anything is mailed
 	if (request.task.trim() === "") throw new Error("a task is required");
 	const record = newestStarted(deps.results, request.id);
 	await ensureExited(record, deps.tmux);
-	const session = sessionFor(record, ctx);
-	const agent = deps.roster(ctx).agents.find((item) => item.name === record.agent);
-	if (agent === undefined) {
-		throw new Error(
-			`agent ${JSON.stringify(record.agent)} is no longer in the roster, so delegation ${record.id} is not resumed`,
-		);
-	}
-	if (inFlight.has(record.id)) throw new Error(`delegation ${record.id} is already being resumed`);
+	const { session, agent } = recordCheck(deps, record, ctx);
 	inFlight.add(record.id);
 	try {
 		const plan = await planResume(deps, { record, agent, session, request }, ctx, signal);
@@ -387,6 +306,25 @@ async function resume(
 	}
 }
 
+/**
+ * The delegations that pass every check `resume` makes, newest first, read
+ * with one `listWindows` and changing nothing: an exited window is left for
+ * the resume itself to kill and trust is left for its prompt. The call-wide
+ * prerequisites are checked once and refuse as `resume` does.
+ */
+async function eligible(deps: ResumeDeps, ctx: ExtensionContext): Promise<StartedRecorded[]> {
+	await preflight(deps);
+	const windows = await listWindows(deps.tmux);
+	if (windows === undefined) return [];
+	const ids = new Set(resumableIds(deps.results));
+	const models = new Map<string, boolean>();
+	const found: StartedRecorded[] = [];
+	for (const record of startedRecords(deps.results)) {
+		if (ids.has(record.id) && (await passes(deps, record, windows, ctx, models))) found.push(record);
+	}
+	return found.reverse();
+}
+
 /** The session a window opened in, for the start text. */
 const inSession = (session: string | undefined): string => (session === undefined ? "" : ` in session ${session}`);
 
@@ -463,9 +401,12 @@ function requestFrom(params: {
 /** Resuming as a function for the command, and the tool for the model. */
 export function createResume(deps: ResumeDeps): {
 	resume(request: ResumeRequest, ctx: ExtensionContext, signal?: AbortSignal): Promise<Resumed>;
+	/** The delegations a resume would accept now, newest first. */
+	eligible(ctx: ExtensionContext): Promise<StartedRecorded[]>;
 	tool(): ToolDef;
 } {
 	return {
+		eligible: (ctx: ExtensionContext) => eligible(deps, ctx),
 		resume: (request: ResumeRequest, ctx: ExtensionContext, signal?: AbortSignal) => resume(deps, request, ctx, signal),
 		tool: () => resumeTool(deps),
 	};

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 } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 
 import type { WindowPlacement } from "./window-placement.ts";
 
@@ -62,6 +62,12 @@ 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 };
+
 export interface TmuxClient {
 	/** Whether this process runs in a tmux pane. */
 	insideTmux(): boolean;
@@ -77,6 +83,24 @@ export interface TmuxClient {
 	listWindows(): Promise<TmuxWindow[]>;
 	/** Kill a window. */
 	kill(windowId: string): Promise<void>;
+	/** The session the parent's pane is in; undefined when it cannot be told. */
+	ownSession(): Promise<OwnSession | undefined>;
+	/** The most recently active client attached to the session named `session`; undefined when none is. */
+	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>;
 }
 
 /** Run one tmux command and return its stdout; never a shell. */
@@ -115,6 +139,48 @@ 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}`]);
 
@@ -184,6 +250,54 @@ 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"> {
+	return {
+		async ownSession() {
+			const parent = await parentSession(run);
+			return parent === undefined || parent.name === "" ? undefined : { id: parent.id, name: parent.name };
+		},
+
+		async clientFor(session) {
+			const out = await run(["list-clients", "-t", `=${session}:`, "-F", "#{client_activity}\t#{client_name}"]);
+			let best: { activity: number; name: string } | undefined;
+			for (const line of out.split("\n")) {
+				const [activity, ...name] = line.split("\t");
+				const at = Number(activity);
+				if (name.length === 0 || Number.isNaN(at)) continue;
+				if (best === undefined || at > best.activity) best = { activity: at, name: name.join("\t") };
+			}
+			return best?.name;
+		},
+
+		async switchTo(client, windowId) {
+			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]);
+		},
+	};
+}
+
 /**
  * The real client. A window is opened relative to the session of the pane in
  * `TMUX_PANE`, not whatever session a client happens to have attached, so it
@@ -239,5 +353,7 @@ export function createTmuxClient(options: { timeoutMs?: number } = {}): TmuxClie
 		async kill(windowId) {
 			await run(["kill-window", "-t", windowId]);
 		},
+
+		...navigation(run),
 	};
 }