pi-squire 0.11.0 → 0.13.0

package/CHANGELOG.md

@@ -6,6 +6,45 @@ follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.13.0] - 2026-10-26
+
+### Added
+
+- `/delegates`, also on `alt+shift+d`, opens a panel of the delegations whose
+  window is open (newest first): `enter` opens one in a tmux popup, or switches
+  to it when it is in your own session; `p` peeks at its pane in an overlay (`r` refreshes,
+  `enter` opens); `s` switches your client to it; `x` closes it, asking only
+  while it runs; `n` opens the new-delegate form. `/delegate-open <id> [--popup|--switch|--peek]` does one of
+  these directly. Popup and switch act on the most recently active client of the
+  parent's session; the parent closes a popup once its delegate's window is gone.
+  Commands and a shortcut only: the model gets no new tool.
+- `/delegate` with no arguments opens a new-delegate form: pick an agent, write
+  the task, name it, then a settings screen for model, thinking level (only the
+  levels the model supports, clamped, visibly, when the agent's default or a new model does not support it), auto-exit,
+  working directory and worktree. It launches through the same path as the
+  typed command. `/delegate-resume` with no arguments opens a picker of the
+  delegations that can be resumed, then an editor for the follow-up. Typed
+  commands and the tools are unchanged; the two commands no longer print
+  their usage when typed bare.
+- `@earendil-works/pi-ai` is now a peer dependency (`*`), supplied by Pi.
+
+## [0.12.0] - 2026-10-26
+
+### Changed
+
+- Delegates open in a companion tmux session, `<your session>-squire`, instead
+  of your own session, created on demand and removed by tmux with its last
+  window. pi-squire marks the session it creates (tmux session option
+  `@squire-companion`), so only a marked session counts as a companion: your
+  own session called `pi-squire` gets `pi-squire-squire`. Set
+  `"windowPlacement": "current"` in `<agent dir>/squire/settings.json` to open
+  them in your session as before; any other value refuses the launch.
+  The start message, `delegation_status` and the delegate card name the session,
+  and the `delegate` and `delegation_resume` results and the status details gain
+  an optional `windowSession`. `session:launch` is unchanged.
+- tmux 3.2 or later is now required (it was 3.0); `/delegate`, `/delegate-resume`
+  and the tools refuse an older tmux with its version.
+
 ## [0.11.0] - 2026-10-26
 
 ### Added
@@ -474,7 +513,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.11.0...HEAD
+[Unreleased]: https://github.com/gvanderclay/pi-squire/compare/v0.13.0...HEAD
+[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
 [0.10.0]: https://github.com/gvanderclay/pi-squire/compare/v0.9.5...v0.10.0
 [0.9.5]: https://github.com/gvanderclay/pi-squire/compare/v0.9.4...v0.9.5

package/README.md

@@ -16,9 +16,11 @@ You need:
   options the parent guidance uses, and the extension APIs the package relies
   on. Pi supplies the peer dependencies `@earendil-works/pi-coding-agent` and
   `typebox`.
-- tmux 3.0 or later, with the Pi session running in a tmux pane. That is the
-  first version with `new-window -e`. A window is opened in the pane's
-  session, so a client attached elsewhere does not matter.
+- 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
+  relative to the pane's session (see [Where delegate windows
+  open](#where-delegate-windows-open)), so a client attached elsewhere does
+  not matter.
 - A provider of `message:*`;
   [pi-session-mail](https://github.com/gvanderclay/pi-session-mail) is one
   example. Without a provider there is no way to send the task or get an
@@ -73,6 +75,20 @@ When the delegate finishes, its answer reaches the parent as one `[delegate]`
 message that quotes the task (see [Results](#results)), and the delegate then
 closes its own window ([auto-exit](#auto-exit)).
 
+`/delegate` with no arguments opens a form instead: pick an agent, write the
+task in the multi-line editor, give it an optional label (empty for the
+default name), then a settings screen. Its first row, Start, launches; the rows
+below it all begin at the agent's defaults: Model (a filterable list of the
+models your Pi has credentials for), Thinking (only the levels the selected
+model supports; a level the model does not support, whether from the agent's
+default or after changing the model, moves to the nearest supported one and says so), Auto-exit, Working directory (your own, to change)
+and Worktree (a new branch name, empty for none). A worktree and a changed
+working directory exclude each other; the base, source and fallbacks stay
+command-only. The form starts the delegate through the same path as the
+command, in the background, with the same start message. The label and
+directory are checked as `--label` and `--cwd` are, before anything is sent
+or opened.
+
 ## How a delegation works
 
 `/delegate <agent> [--model <provider/id>] [--thinking <level>] [--label <name>] [--cwd <dir> | --worktree <branch> [--worktree-source <dir>] [--worktree-base <commit-ish>]] [--auto-exit | --no-auto-exit] <task…>`
@@ -130,6 +146,67 @@ temporary folder, not as text on the command line.
   missing. In print mode (`pi -p`) Pi does not show the refusal notices, so
   the refusal is silent there.
 
+## Where delegate windows open
+
+By default a delegate's window opens in a **companion session** named after
+yours with `-squire` added: from the session `work`, delegates go to
+`work-squire`. Your own session stays as it is, even when its name already
+ends in `-squire`: a session called `pi-squire` gets `pi-squire-squire`.
+pi-squire marks each companion session it creates with the tmux session
+option `@squire-companion`; a parent that runs in a marked session uses it, so
+a delegate that delegates does not make `work-squire-squire`.
+
+- The session is created on demand, by the launch that needs it, and tmux
+  removes it with its last window, so it does not outlive its delegates.
+- `detach-on-destroy` is set to `off` (and the mark set) on that session only: if you are
+  looking at it when its last delegate exits, tmux moves you to your most
+  recent other session instead of detaching you. Your sessions and tmux's
+  global options are never changed.
+- The start message, the delegate card and the `delegate` and
+  `delegation_resume` results show the session the window opened in, as the
+  optional `windowSession`; they keep that name. `delegation_status` looks it
+  up each time, so it follows a window you move to another session, which is
+  still found, closed and resumed.
+
+To open windows in your own session, as before, set `windowPlacement` in
+`<agent dir>/squire/settings.json`, beside `worktreeRoot`:
+
+```json
+{ "windowPlacement": "current" }
+```
+
+The values are `companion` (the default when the setting is absent) and
+`current`. The file is read at each launch. Any other value refuses the launch
+with an error naming the file, before the task is sent or a window opens.
+
+## Reaching delegates
+
+Delegate windows sit out of your way, so reach them from the parent. `/delegates`
+(or `alt+shift+d`) opens a panel of the delegations whose window is open: running,
+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) |
+| `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.
+
+`/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.
+
 ## Working directory
 
 `--cwd <dir>` (the `delegate` tool's `cwd`) runs the delegate in an existing
@@ -791,6 +868,15 @@ The model does the same with `delegation_resume` (`id` and `task`, optionally
 `model`, `thinking` and `auto_exit`), which returns the `delegate` tool's result
 plus `resumedFrom`. The command completes the ids that can still be resumed.
 
+`/delegate-resume` with no arguments opens a picker instead: the delegations
+that pass every check below (newest first, from one look at tmux), then the
+multi-line editor for the follow-up. The checks change nothing: it refuses as the
+command does when tmux is older than 3.2 or `windowPlacement` is invalid, and leaves out a
+delegation whose recorded thinking level is invalid or whose model and fallbacks cannot be used
+(credentials, usage limits). An exited window is left for the resume to close, and trust is
+asked only when you resume. The model, thinking level and auto-exit are the delegation's own,
+and it resumes as the command does.
+
 - The delegate's own session file is reopened with `pi --session <absolute path>`
   and the recorded `--session-dir`, in a new window named like the first. The
   delegate keeps everything it read and decided; Pi appends to the same file.
@@ -958,7 +1044,11 @@ Other extensions may rely on:
 - the `delegate`, `delegation_status`, `delegation_close` and `delegation_resume` tool names,
   parameters, the recorded `workspace` shape and the `workspaceSnapshot`
   shape in results and status;
-- the `/delegate` and `/delegate-resume` syntax and flags;
+- the `/delegate` and `/delegate-resume` syntax and flags, and their
+  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;
 - 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.11.0",
+	"version": "0.13.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",
@@ -44,12 +44,14 @@
 		"access": "public"
 	},
 	"peerDependencies": {
+		"@earendil-works/pi-ai": "*",
 		"@earendil-works/pi-coding-agent": ">=1.3.0",
 		"@earendil-works/pi-tui": "*",
 		"typebox": "*"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.5.14",
+		"@earendil-works/pi-ai": "1.3.0",
 		"@earendil-works/pi-coding-agent": "1.3.0",
 		"@earendil-works/pi-tui": "1.3.0",
 		"@types/node": "26.6.3",

package/src/index.ts

@@ -53,12 +53,16 @@ import { Type } from "typebox";
 import { type Agent, isThinking, type Roster, readRoster, THINKING_LEVELS } from "./agents.ts";
 import { AGENT_ENV, AUTO_EXIT_ENV, FALLBACK_ENV, registerChild } from "./child.ts";
 import { activeMark, clearMarks, isFree, readMarks } from "./limits.ts";
+import { createNavigator, OPEN_USAGE, openCompletions, parseOpen } from "./navigator.ts";
+import { type NewDelegateDeps, type NewRequest, startNewDelegate } from "./new-delegate.ts";
 import { dirtyNotice, renderDelegateCall, renderDelegateResult, resourceLine } from "./render.ts";
 import { createResults, delegateName, type WorkspaceAttempt } from "./results.ts";
 import { createResume, type ResumeRequest, resumableIds, startedLine } from "./resume.ts";
-import { createTmuxClient, type TmuxClient, WindowOpenError } from "./tmux.ts";
+import { pickResume } from "./resume-picker.ts";
+import { createTmuxClient, type OpenedWindow, requireTmuxVersion, type TmuxClient, WindowOpenError } from "./tmux.ts";
 import { createTracking, toolResult } from "./tracking.ts";
 import { createProactive, createUsageClient, type Proactive, type UsageClient } from "./usage.ts";
+import { type WindowPlacement, windowPlacement } from "./window-placement.ts";
 import {
 	normalizeWorkspaceValue,
 	prepareDirectory,
@@ -149,6 +153,9 @@ export const DelegateSchema = Type.Object({
 	autoExit: Type.Boolean(),
 	windowId: Type.String(),
 	windowName: Type.String(),
+	windowSession: Type.Optional(
+		Type.String({ description: "The tmux session the window opened in, as tmux named it then." }),
+	),
 	cwd: Type.String({ description: "The directory the delegate's window opened in." }),
 	sessionDir: Type.String({ description: "The session-storage directory the delegate was told to use." }),
 	workspace: WorkspaceSchema,
@@ -216,6 +223,8 @@ type Launched = {
 	name: string;
 	windowId: string;
 	windowName: string;
+	/** The session the window opened in; undefined when tmux could not say. */
+	windowSession: string | undefined;
 	requestId: string;
 	cwd: string;
 	sessionDir: string;
@@ -581,19 +590,19 @@ export default function delegate(
 		return roster;
 	}
 
+	/** The refusal for an empty roster. */
+	const noAgents = (): string =>
+		`no agents are defined; add ${join(
+			getAgentDir(),
+			"squire",
+			"agents",
+			"<name>",
+			"AGENT.md",
+		)} with frontmatter description, model and thinking (optionally auto-exit, exclude-tools, tools, extensions and fallback), and the prompt as its body`;
+
 	/** The request as a start, or an error naming what to fix. */
 	async function validate(request: Parsed, roster: Roster, models: ModelRegistry): Promise<Start> {
-		if (roster.agents.length === 0) {
-			throw new Error(
-				`no agents are defined; add ${join(
-					getAgentDir(),
-					"squire",
-					"agents",
-					"<name>",
-					"AGENT.md",
-				)} with frontmatter description, model and thinking (optionally auto-exit, exclude-tools, tools, extensions and fallback), and the prompt as its body`,
-			);
-		}
+		if (roster.agents.length === 0) throw new Error(noAgents());
 		const agent = roster.agents.find((candidate) => candidate.name === request.agent);
 		if (agent === undefined) {
 			throw new Error(
@@ -640,7 +649,7 @@ export default function delegate(
 
 	/**
 	 * Build the delegate's command line and environment, emit `session:launch`
-	 * and open its window; returns the window id. A launch and a resume share
+	 * and open its window; returns the window id and session. A launch and a resume share
 	 * it and differ only in `session`, the arguments that choose the session:
 	 * `--session-id <id> --name <name>` for a new one, `--session <path>` to reopen.
 	 */
@@ -656,9 +665,24 @@ export default function delegate(
 		/** The tool call that started this launch or resume; undefined from a command. */
 		toolCallId: string | undefined;
 		ctx: ExtensionContext;
+		/** Chosen once, when the launch or resume began, so no later settings change can refuse it after mail. */
+		placement: WindowPlacement;
 		onWindowOpened?: () => void;
-	}): Promise<string> {
-		const { id, name, session, workspace, trusted, cwd, sessionDir, start, toolCallId, ctx, onWindowOpened } = input;
+	}): Promise<OpenedWindow> {
+		const {
+			id,
+			name,
+			session,
+			workspace,
+			trusted,
+			cwd,
+			sessionDir,
+			start,
+			toolCallId,
+			ctx,
+			placement,
+			onWindowOpened,
+		} = input;
 		const parent = ctx.sessionManager.getSessionId();
 		const managedContext =
 			workspace.mode === "managed"
@@ -699,9 +723,9 @@ export default function delegate(
 		// Listeners may only append to `args` and add to `env`; there is no veto.
 		const payload: LaunchPayload = { args: argv, env, agent: start.agent.name, cwd, toolCallId };
 		pi.events.emit(LAUNCH, payload);
-		let windowId: string;
+		let opened: OpenedWindow;
 		try {
-			windowId = await tmux.openWindow({ name, cwd, argv: payload.args, env: payload.env });
+			opened = await tmux.openWindow({ name, cwd, argv: payload.args, env: payload.env }, placement);
 			onWindowOpened?.();
 		} catch (err) {
 			if (err instanceof WindowOpenError) {
@@ -709,7 +733,7 @@ export default function delegate(
 			}
 			throw new WindowOpenError(`could not open window ${name} for ${id}: ${(err as Error).message}`, "unknown");
 		}
-		return windowId;
+		return opened;
 	}
 
 	async function launchWindow(input: {
@@ -722,11 +746,13 @@ export default function delegate(
 		start: Start;
 		toolCallId: string | undefined;
 		ctx: ExtensionContext;
+		placement: WindowPlacement;
 		onWindowOpened: () => void;
 	}): Promise<Launched> {
-		const { id, requestId, workspace, trusted, cwd, sessionDir, start, toolCallId, ctx, onWindowOpened } = input;
+		const { id, requestId, workspace, trusted, cwd, sessionDir, start, toolCallId, ctx, placement, onWindowOpened } =
+			input;
 		const name = delegateName(start.agent.name, id, start.label);
-		const windowId = await openChild({
+		const { id: windowId, session: windowSession } = await openChild({
 			id,
 			name,
 			session: ["--session-id", id, "--name", name],
@@ -737,6 +763,7 @@ export default function delegate(
 			start,
 			toolCallId,
 			ctx,
+			placement,
 			onWindowOpened,
 		});
 		// No task text in the record: the request copy in `sent/` has it.
@@ -758,7 +785,7 @@ export default function delegate(
 			ctx,
 		);
 		tracking.startPolling();
-		return { id, name, windowId, windowName: name, requestId, cwd, sessionDir, workspace };
+		return { id, name, windowId, windowName: name, windowSession, requestId, cwd, sessionDir, workspace };
 	}
 
 	async function launch(
@@ -768,6 +795,9 @@ export default function delegate(
 		toolCallId?: string,
 	): Promise<Launched> {
 		if (!tmux.insideTmux()) throw new Error(NOT_IN_TMUX);
+		await requireTmuxVersion(tmux);
+		// Read once, before anything is created or mailed; the launch keeps this value.
+		const placement = windowPlacement(getAgentDir());
 		const sessionDir = ctx.sessionManager.getSessionDir();
 		if (!isAbsolute(sessionDir))
 			throw new Error(
@@ -878,6 +908,7 @@ export default function delegate(
 				start,
 				toolCallId,
 				ctx,
+				placement,
 				onWindowOpened: () => {
 					windowOpened = true;
 				},
@@ -949,12 +980,13 @@ export default function delegate(
 		delegateSchema: DelegateSchema,
 		notInTmux: NOT_IN_TMUX,
 		startPolling: tracking.startPolling,
+		placement: () => windowPlacement(getAgentDir()),
 		roster: rosterFor,
 		chooseModel: (explicit, agent, models, preferred) => chooseModel(explicit, agent, models, proactive, preferred),
 		thinkingProblem,
 		prepareDirectory: (cwd, ctx, signal) => prepareDirectory({ cwd, signal }, ctx, getAgentDir()),
 		sendTask,
-		open: ({ id, name, sessionPath, workspace, trusted, cwd, sessionDir, start, toolCallId, ctx }) =>
+		open: ({ id, name, sessionPath, workspace, trusted, cwd, sessionDir, start, toolCallId, ctx, placement }) =>
 			openChild({
 				id,
 				name,
@@ -966,32 +998,32 @@ export default function delegate(
 				start,
 				toolCallId,
 				ctx,
+				placement,
 			}),
 	});
 
+	/** The session a window opened in, for the start text. */
+	const inSession = (session: string | undefined): string => (session === undefined ? "" : ` in session ${session}`);
+
 	/** Where a selected directory put the delegate, for the start text; inherited starts stay compact. */
 	const placedIn = (launched: Launched): string =>
 		launched.workspace.mode !== "inherited" ? ` in ${launched.cwd}` : "";
 
 	const started = (launched: Launched, start: Start): string =>
-		`delegate: ${start.agent.name} ${launched.id} started in window ${launched.windowName}${placedIn(launched)}${launched.workspace.mode === "managed" ? `. Branch ${launched.workspace.createdBranch} starts at ${launched.workspace.baseCommit}. ${dirtyNotice(launched.workspace.sourceDirty)}` : ""}${start.skipped.length > 0 ? `. ${fallbackNote(start)}` : ""}${start.notices.map((line) => `. ${line}`).join("")}`;
+		`delegate: ${start.agent.name} ${launched.id} started in window ${launched.windowName}${inSession(launched.windowSession)}${placedIn(launched)}${launched.workspace.mode === "managed" ? `. Branch ${launched.workspace.createdBranch} starts at ${launched.workspace.baseCommit}. ${dirtyNotice(launched.workspace.sourceDirty)}` : ""}${start.skipped.length > 0 ? `. ${fallbackNote(start)}` : ""}${start.notices.map((line) => `. ${line}`).join("")}`;
 
-	async function command(input: string, ctx: ExtensionContext): Promise<void> {
+	/** Start a delegate from a parsed `/delegate` or the form, telling the user how it went. */
+	async function runDelegate(parsed: Parsed, ctx: ExtensionContext): Promise<void> {
 		const fail = (message: string) => ctx.ui.notify(`delegate: ${message}`, "error");
-		const outcome = parse(input);
-		if ("error" in outcome) {
-			fail(outcome.error);
-			return;
-		}
 		try {
-			const cwd = normalizeWorkspaceValue(outcome.parsed.cwd, "--cwd");
-			const worktree_source = normalizeWorkspaceValue(outcome.parsed.worktree_source, "--worktree-source");
-			const worktree_base = normalizeWorkspaceValue(outcome.parsed.worktree_base, "--worktree-base");
-			const worktree = normalizeWorkspaceValue(outcome.parsed.worktree, "--worktree");
+			const cwd = normalizeWorkspaceValue(parsed.cwd, "--cwd");
+			const worktree_source = normalizeWorkspaceValue(parsed.worktree_source, "--worktree-source");
+			const worktree_base = normalizeWorkspaceValue(parsed.worktree_base, "--worktree-base");
+			const worktree = normalizeWorkspaceValue(parsed.worktree, "--worktree");
 			if (worktree_source !== undefined && worktree === undefined)
 				throw new Error("--worktree-source requires --worktree");
 			const start = await validate(
-				{ ...outcome.parsed, cwd, worktree, worktree_base, worktree_source },
+				{ ...parsed, cwd, worktree, worktree_base, worktree_source },
 				rosterFor(ctx),
 				ctx.modelRegistry,
 			);
@@ -1002,7 +1034,44 @@ export default function delegate(
 		}
 	}
 
+	/** What the new-delegate form needs, shared by `/delegate` and the panel's `n`. */
+	const newDelegateDeps: NewDelegateDeps = {
+		unavailable: () => (tmux.insideTmux() ? undefined : NOT_IN_TMUX),
+		roster: rosterFor,
+		noAgents,
+		labelProblem,
+		start: (request: NewRequest, context) => runDelegate(request, context),
+	};
+
+	/** `/delegate`: with no arguments the new-delegate form, otherwise the typed request. */
+	async function command(input: string, ctx: ExtensionContext): Promise<void> {
+		if (input.trim() === "") {
+			await startNewDelegate(ctx, newDelegateDeps);
+			return;
+		}
+		const outcome = parse(input);
+		if ("error" in outcome) {
+			ctx.ui.notify(`delegate: ${outcome.error}`, "error");
+			return;
+		}
+		await runDelegate(outcome.parsed, ctx);
+	}
+
 	async function resumeCommand(input: string, ctx: ExtensionContext): Promise<void> {
+		if (input.trim() === "") {
+			await pickResume(ctx, {
+				unavailable: () => (tmux.insideTmux() ? undefined : NOT_IN_TMUX),
+				eligible: resumer.eligible,
+				resume: async (request, context) => {
+					try {
+						context.ui.notify(startedLine(await resumer.resume(request, context)), "info");
+					} catch (err) {
+						context.ui.notify(`delegate: ${(err as Error).message}`, "error");
+					}
+				},
+			});
+			return;
+		}
 		const outcome = parseResume(input);
 		if ("error" in outcome) {
 			ctx.ui.notify(`delegate: ${outcome.error}`, "error");
@@ -1115,7 +1184,7 @@ export default function delegate(
 			const launched = await launch(start, ctx, signal, toolCallId);
 			ctx.ui.notify(started(launched, start), "info");
 			return toolResult(
-				`Started delegation ${launched.id}: ${start.agent.name} (${start.model}, thinking ${start.thinking}) in window ${launched.windowName}${placedIn(launched)}.${launched.workspace.mode === "managed" ? ` Branch ${launched.workspace.createdBranch} starts at ${launched.workspace.baseCommit}. ${dirtyNotice(launched.workspace.sourceDirty)}` : ""} It runs in the background, and its result arrives as a message that starts your next turn on its own; delegation_close ends it.${start.skipped.length > 0 ? ` ${fallbackNote(start)}` : ""}${start.notices.map((line) => ` ${line}`).join("")}`,
+				`Started delegation ${launched.id}: ${start.agent.name} (${start.model}, thinking ${start.thinking}) in window ${launched.windowName}${inSession(launched.windowSession)}${placedIn(launched)}.${launched.workspace.mode === "managed" ? ` Branch ${launched.workspace.createdBranch} starts at ${launched.workspace.baseCommit}. ${dirtyNotice(launched.workspace.sourceDirty)}` : ""} It runs in the background, and its result arrives as a message that starts your next turn on its own; delegation_close ends it.${start.skipped.length > 0 ? ` ${fallbackNote(start)}` : ""}${start.notices.map((line) => ` ${line}`).join("")}`,
 				{
 					outcome: "started",
 					id: launched.id,
@@ -1127,6 +1196,7 @@ export default function delegate(
 					autoExit: start.autoExit,
 					windowId: launched.windowId,
 					windowName: launched.windowName,
+					...(launched.windowSession === undefined ? {} : { windowSession: launched.windowSession }),
 					cwd: launched.cwd,
 					sessionDir: launched.sessionDir,
 					workspace: launched.workspace,
@@ -1209,6 +1279,30 @@ export default function delegate(
 		handler: resumeCommand,
 	});
 
+	const navigator = createNavigator(results, tmux, tracking, (ctx: ExtensionContext) =>
+		startNewDelegate(ctx, newDelegateDeps),
+	);
+
+	pi.registerCommand("delegates", {
+		description: "Open the panel of delegates whose window is open: popup, peek, switch, close",
+		handler: async (_args: string, ctx: ExtensionContext) => navigator.panel(ctx),
+	});
+
+	pi.registerShortcut("alt+shift+d", {
+		description: "Open the delegates panel",
+		handler: (ctx: ExtensionContext) => navigator.panel(ctx),
+	});
+
+	pi.registerCommand("delegate-open", {
+		description: `Reach one open delegate: ${OPEN_USAGE}`,
+		getArgumentCompletions: async (prefix: string) => openCompletions(prefix, await navigator.openIds()),
+		handler: async (args: string, ctx: ExtensionContext) => {
+			const parsed = parseOpen(args);
+			if ("error" in parsed) return ctx.ui.notify(`delegate: ${parsed.error}`, "error");
+			await navigator.openDelegate(ctx, parsed.id, parsed.mode);
+		},
+	});
+
 	pi.registerCommand("delegate-clear", {
 		description: "Clear usage-limit marks: all, a provider, or a provider/model",
 		getArgumentCompletions: (prefix: string) => {