pi-squire 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -6,6 +6,22 @@ follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.11.0] - 2026-10-26
+
+### Added
+
+- The `session:launch` payload gains a read-only `toolCallId`, the ID of the
+  `delegate` tool call that started the launch, so a listener can tie a
+  delegate's window to that call. It is `undefined` for a launch from the
+  `/delegate` command.
+- `delegation_resume` and `/delegate-resume <id> [--model …] [--thinking …] [--auto-exit|--no-auto-exit] <task>` reopen an exited delegate's own session (`pi --session <path>`) in a new window with a follow-up task. The resume is recorded as a new delegation with `resumedFrom`; mail, replies and usage-limit marks use the delegation's session id, so records from before resuming read as before. A delegate whose working directory is gone, one still running, one whose window is open and an older delegation of a resumed chain are refused. `delegation_status` shows `resumed from` and `resumed as`, results and closed-without-a-result messages name `resumedFrom`, and the latter point to `delegation_resume`. The `delegate` tool's description mentions it, and `--session` joins the launch invariants listed for `session:launch`. A resume emits `session:launch`
+  too, with `toolCallId` set to the `delegation_resume` call, or `undefined`
+  from `/delegate-resume`; unlike a launch's, it comes before the task is sent,
+  because a resume mails the task only once its window is open (mail for a
+  window that never opened would otherwise reach the next resume as a second
+  task; a failed send kills the new window). A resumed delegation is never
+  reported closed without a result.
+
 ## [0.10.0] - 2026-10-24
 
 ### Added
@@ -458,7 +474,8 @@ 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.10.0...HEAD
+[Unreleased]: https://github.com/gvanderclay/pi-squire/compare/v0.11.0...HEAD
+[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
 [0.9.4]: https://github.com/gvanderclay/pi-squire/compare/v0.9.3...v0.9.4

package/README.md

@@ -428,7 +428,7 @@ agent's `auto-exit`.
 
 ## Tools
 
-The model gets three tools. They share the command's launch path and the
+The model gets four tools. They share the command's launch path and the
 session's delegation records. None of them is registered inside a delegate.
 
 | Tool | Parameters | What it does |
@@ -436,6 +436,7 @@ session's delegation records. None of them is registered inside a delegate.
 | `delegate` | `agent`, `task`, optional `model`, `thinking`, `label`, `cwd` and `auto_exit` (boolean) | Validates the call the way the command does, starts the delegation without opening a dialog (except an unresolved [trust question](#project-trust) for `cwd`), and returns the delegation id at once without waiting for a result. |
 | `delegation_status` | optional `id` | Reports each delegation as running, done, closed or closed without a result, with the window, the delegate's session and the result envelope's path. |
 | `delegation_close` | `id` | Kills the window through tmux and records the close, so `delegation_status` reports it closed. |
+| `delegation_resume` | `id`, `task`, optional `model`, `thinking` and `auto_exit` | Reopens an exited delegate's own session in a new window with a follow-up task, and returns the new delegation's id at once (see [Resuming a delegation](#resuming-a-delegation)). |
 
 The `delegate` tool's description lists the current roster, one line per agent:
 its name, description, default model and thinking, auto-exit when it is off,
@@ -778,6 +779,59 @@ session or offer to fork it rather than open it when the delegate ran in
 another directory or its file lives in another storage directory. The
 absolute path opens that file directly.
 
+## Resuming a delegation
+
+An exited delegate can continue its own session with a follow-up task:
+
+```text
+/delegate-resume <id> [--model <provider/id>] [--thinking <level>] [--auto-exit | --no-auto-exit] <task…>
+```
+
+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.
+
+- 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.
+  Opening it yourself is `pi --session <path>`, outside this tool.
+- The resume is recorded as a **new delegation** with its own id and a
+  `resumedFrom` naming the old one. Its task goes to the old session's mail
+  address, and its result arrives as a `[delegate]` message that names
+  `resumed from <id>`. Status shows `resumed from <id>` on the new delegation and
+  `resumed as <id>` on the old one. A late reply to the old request still
+  settles the old delegation only, and a resumed delegation is never reported
+  closed without a result.
+- Unlike a launch, the task is mailed after the window opens: the session's
+  inbox outlives a failed attempt, so a task sent for a window that never
+  opened would reach the next resume as a second task. The reopened delegate
+  receives it once its mailbox starts. If the send fails, the new window is
+  killed and nothing is recorded.
+- A chain resumes from its newest delegation; resuming an older one is refused,
+  naming the newest.
+- It is refused, before anything is sent or opened, unless: the delegation is a
+  started one (not a workspace attempt); it is not `running` (mail a running
+  delegate instead) and tmux can be asked; no window with its id and name still
+  runs a program (an exited one is killed first; a window that merely shares the
+  name is ignored); its session file is found and the working directory in the
+  file's header still exists; its agent is still in the roster; and no other
+  resume of it is under way. A delegate whose window was killed mid-turn can be
+  resumed.
+- A removed working directory, a removed managed worktree included, makes a
+  delegation not resumable: Pi runs a reopened session in its stored directory.
+  The window opens in that directory, with project trust decided again for it as
+  for `cwd` (see [Project trust](#project-trust)); there is no `cwd` or
+  `worktree` for a resume, and no worktree is created.
+- Without `model` it continues on the model the delegate finished on, moving to
+  its agent's fallbacks when that one is unavailable or marked (see
+  [Usage limits](#usage-limits)). An explicit `model` is used alone and refused
+  rather than substituted. `thinking` and `auto_exit` default to the
+  delegation's own. The agent's prompt, tools and extensions are those of the
+  roster now.
+- `session:launch` is emitted as for any launch, with the same payload.
+- Not detected: a Pi process you opened yourself on the same session outside
+  pi-squire's window. Close it before resuming.
+
 ## Hooks
 
 The `js` block below is the contract's worked example, and
@@ -788,8 +842,10 @@ that block.
 
 ### `session:launch`
 
-`pi-squire` provides this hook. It emits `{ args, env, agent, cwd }` after the
-task has been sent and just before it opens the delegate's window.
+`pi-squire` provides this hook. It emits `{ args, env, agent, cwd, toolCallId }`
+just before it opens the delegate's window: for a launch, after the task has
+been sent; for a resume, before it is sent, since a resume mails the task once
+the window is open (see [Resuming a delegation](#resuming-a-delegation)).
 
 | Field | Meaning |
 | --- | --- |
@@ -797,15 +853,17 @@ task has been sent and just before it opens the delegate's window.
 | `env` | the child's environment, as `KEY`/`value` pairs |
 | `agent` | the agent's name, as in `<agent dir>/squire/agents/<name>/AGENT.md`; read it, do not change it |
 | `cwd` | the directory the window opens in, the parent's or the resolved `--cwd`; read it, do not change it |
+| `toolCallId` | the ID of the `delegate` or `delegation_resume` tool call that started the launch; absent when started from the `/delegate` or `/delegate-resume` command; read it, do not change it |
 
 Listeners may only append to `args` and add keys to `env`; there is no veto,
 and `pi-squire` passes both to tmux unchanged. Do all work synchronously: the
 emitter reads the payload the moment `emit` returns.
 
-`cwd`, the trust flag (`--approve` or `--no-approve`) and `--session-dir` are
-launch invariants that `pi-squire` chooses. The window opens in its own `cwd`,
+`cwd`, the trust flag (`--approve` or `--no-approve`), `--session-dir` and the
+session choice (`--session-id` for a new delegate, `--session` for a [resumed](#resuming-a-delegation)
+one) are launch invariants that `pi-squire` chooses. The window opens in its own `cwd`,
 whatever a listener assigns to the payload. A listener must not add another
-trust flag, `--session-dir` or a working-directory change to `args`, since
+trust flag, `--session-dir`, `--session` or `--session-id`, or a working-directory change to `args`, since
 that would launch a child whose trust or session storage the parent did not
 choose and cannot find; append only unrelated settings.
 
@@ -890,16 +948,17 @@ version and is listed under "Breaking" in [CHANGELOG.md](CHANGELOG.md).
 
 Other extensions may rely on:
 
-- the `session:launch` payload `{ args, env, agent, cwd }`, emitted
-  synchronously after the task is sent and before the window opens, with
+- the `session:launch` payload `{ args, env, agent, cwd, toolCallId }`, emitted
+  synchronously before the window opens (after the task is sent for a launch,
+  before it is sent for a resume), with
   `cwd`, the trust flag and `--session-dir` chosen by `pi-squire` (see
   [Hooks](#hooks));
 - the `message:send`, `message:inbound` and `message:scan` hooks, consumed as
   their sections document;
-- the `delegate`, `delegation_status` and `delegation_close` tool names,
+- 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` syntax and flags;
+- the `/delegate` and `/delegate-resume` syntax and 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.10.0",
+	"version": "0.11.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

@@ -21,7 +21,7 @@
 // session has no tool for leaves the agent out of the roster. Its `tools` goes
 // as `--tools` and each of its `extensions` as `-e`, both for the child alone.
 //
-// The model gets three tools. `delegate` takes agent, task and optional model
+// The model gets four tools. `delegate` takes agent, task and optional model
 // and thinking, validates them the way the command does, and starts the
 // delegation at once, opening no dialog, so parallel calls cannot block one
 // another; the one exception is a `cwd` whose project trust is unresolved,
@@ -29,7 +29,9 @@
 // reports each delegation as running (window open, no result yet), done (with
 // its result status) or closed, with the session name, window, session and
 // envelope paths.
-// `delegation_close` kills the window and records the close. Inside a delegate
+// `delegation_close` kills the window and records the close. `delegation_resume`
+// (`resume.ts`) reopens an exited delegate's session in a new window with a
+// follow-up task, recorded as a new delegation. Inside a delegate
 // (`PI_DELEGATE_PARENT` set) the extension registers only `child.ts`'s
 // `/auto-exit` and handlers, so a delegate cannot delegate.
 //
@@ -53,6 +55,7 @@ import { AGENT_ENV, AUTO_EXIT_ENV, FALLBACK_ENV, registerChild } from "./child.t
 import { activeMark, clearMarks, isFree, readMarks } from "./limits.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 { createTracking, toolResult } from "./tracking.ts";
 import { createProactive, createUsageClient, type Proactive, type UsageClient } from "./usage.ts";
@@ -156,9 +159,20 @@ const NOT_IN_TMUX = "this session is not inside tmux; start it in a tmux pane to
 const USAGE =
 	"usage: /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>";
 
+/** The flags `/delegate-resume` takes before the task. */
+const RESUME_FLAGS = ["--model", "--thinking", "--auto-exit", "--no-auto-exit"] as const;
+const RESUME_USAGE =
+	"usage: /delegate-resume <id> [--model <provider/id>] [--thinking <level>] [--auto-exit | --no-auto-exit] <task>";
+
 type SendPayload = { to: unknown; body: unknown; envelope?: { id?: unknown }; error?: unknown };
 /** `cwd` is informational: the window opens in the launch's own value, whatever a listener assigns. */
-type LaunchPayload = { args: string[]; env: Record<string, string>; agent: string; readonly cwd: string };
+type LaunchPayload = {
+	args: string[];
+	env: Record<string, string>;
+	agent: string;
+	readonly cwd: string;
+	readonly toolCallId: string | undefined;
+};
 type Parsed = {
 	agent: string;
 	model?: string;
@@ -194,6 +208,8 @@ type Start = {
 };
 /** A candidate model passed over: `why` finishes "<model> is …", `reason` is the long form for a refusal. */
 type Skipped = { model: string; why: string; reason: string };
+/** What opening a delegate's window reads from a request: a `Start`, or the parts of one a resume decides. */
+type ChildStart = Pick<Start, "agent" | "model" | "rest" | "thinking" | "autoExit">;
 /** A delegation that is open in a tmux window. */
 type Launched = {
 	id: string;
@@ -276,9 +292,14 @@ function word(text: string, from: number): { text: string; start: number; end: n
  * A flag's value at or after `from`: a plain word, or a double-quoted string
  * in which `\"` and `\\` stand for `"` and `\`. No shell expansion of any kind.
  */
-function flagValue(text: string, from: number, flag: string): { value: string; end: number } | { error: string } {
+function flagValue(
+	text: string,
+	from: number,
+	flag: string,
+	usage: string = USAGE,
+): { value: string; end: number } | { error: string } {
 	const next = word(text, from);
-	if (next === undefined || next.text.startsWith("--")) return { error: `${flag} needs a value; ${USAGE}` };
+	if (next === undefined || next.text.startsWith("--")) return { error: `${flag} needs a value; ${usage}` };
 	if (!next.text.startsWith('"')) return { value: next.text, end: next.end };
 	let value = "";
 	let i = next.start + 1;
@@ -287,9 +308,9 @@ function flagValue(text: string, from: number, flag: string): { value: string; e
 		value += escaped ? text[i + 1] : text[i];
 		i += escaped ? 2 : 1;
 	}
-	if (i >= text.length) return { error: `${flag}'s value has no closing quote; ${USAGE}` };
+	if (i >= text.length) return { error: `${flag}'s value has no closing quote; ${usage}` };
 	if (i + 1 < text.length && !/\s/.test(text[i + 1])) {
-		return { error: `${flag}'s quoted value must be followed by a space; ${USAGE}` };
+		return { error: `${flag}'s quoted value must be followed by a space; ${usage}` };
 	}
 	return { value, end: i + 1 };
 }
@@ -336,6 +357,32 @@ function parse(text: string): { parsed: Parsed } | { error: string } {
 	return { parsed };
 }
 
+/** `/delegate-resume`'s arguments: a delegation id, optional flags, then a verbatim task. */
+function parseResume(text: string): { request: ResumeRequest } | { error: string } {
+	const id = word(text, 0);
+	if (id === undefined) return { error: RESUME_USAGE };
+	if (id.text.startsWith("-")) return { error: `the first argument is the delegation id; ${RESUME_USAGE}` };
+	const request: ResumeRequest = { id: id.text, task: "" };
+	let at = id.end;
+	for (let next = word(text, at); next?.text.startsWith("-"); next = word(text, at)) {
+		const flag = next.text;
+		if (flag === "--auto-exit" || flag === "--no-auto-exit") {
+			request.autoExit = flag === "--auto-exit";
+			at = next.end;
+			continue;
+		}
+		if (flag !== "--model" && flag !== "--thinking") return { error: `unknown flag ${flag}; ${RESUME_USAGE}` };
+		const read = flagValue(text, next.end, flag, RESUME_USAGE);
+		if ("error" in read) return read;
+		if (flag === "--model") request.model = read.value;
+		else request.thinking = read.value;
+		at = read.end;
+	}
+	request.task = text.slice(word(text, at)?.start ?? text.length).trim();
+	if (request.task === "") return { error: `a task is required after the id and flags; ${RESUME_USAGE}` };
+	return { request };
+}
+
 /** Why `value` is not a usable model, or undefined when it is. */
 function modelProblem(value: string, registry: ModelRegistry): string | undefined {
 	const slash = value.indexOf("/");
@@ -356,15 +403,17 @@ function modelProblem(value: string, registry: ModelRegistry): string | undefine
  * `modelProblem` and has no active mark wins; the rest are returned as skipped.
  * A paid candidate on a provider with a quota check is read first, and
  * skipped when its quota is used up. Refuses, listing every candidate, when
- * none is left.
+ * none is left. `preferred` replaces the agent's own list when there is no
+ * explicit model, as a resume does.
  */
 async function chooseModel(
 	explicit: string | undefined,
 	agent: Agent,
 	models: ModelRegistry,
 	proactive: Proactive,
+	preferred: readonly string[] = [agent.model, ...agent.fallback],
 ): Promise<{ model: string; skipped: Skipped[]; notices: string[]; rest: string[] }> {
-	const candidates = explicit !== undefined ? [explicit] : [agent.model, ...agent.fallback];
+	const candidates = explicit !== undefined ? [explicit] : [...preferred];
 	const skipped: Skipped[] = [];
 	const notices: string[] = [];
 	for (const model of candidates) {
@@ -475,7 +524,7 @@ function toolDescription(agents: readonly Agent[]): string {
 		),
 		"",
 		"`cwd` runs the delegate in another existing directory. Alternatively, `worktree` creates a new local branch and checkout from this repository's committed HEAD, or `worktree_source` selects another existing Git checkout; `worktree_base` selects a commit in that source. Source dirt is reported but not copied. `cwd` and `worktree` are mutually exclusive, and source/base require worktree.",
-		"`model` and `thinking` override the agent's defaults for this call; an unknown value is refused with close matches. `label` names the delegate's window and session; give one that says what the task is. `delegation_status` reports a delegation, and `delegation_close` ends one.",
+		"`model` and `thinking` override the agent's defaults for this call; an unknown value is refused with close matches. `label` names the delegate's window and session; give one that says what the task is. `delegation_status` reports a delegation, and `delegation_close` ends one. `delegation_resume` continues an exited delegate in its own session with a follow-up task, for work that needs the context it already built.",
 		"`auto_exit` (default the agent's, normally true) closes the delegate's window once it finishes. Set it false when you mean to keep talking to the delegate by mail after its result; the user can also keep a window open by typing in it.",
 		"",
 		"Writing the task: the delegate sees nothing of this session, so the task must stand alone. State the question, the decision its answer feeds, what is already known or ruled out, and the files or paths to start from. When the work produces a report, name the path to write it to and ask for the conclusion back, not the contents.",
@@ -575,20 +624,42 @@ export default function delegate(
 		};
 	}
 
-	async function launchWindow(input: {
+	/** Write the task to the delegate's inbox and return its request id; the delegate finds it at session start. */
+	function sendTask(to: string, task: string): string {
+		const sent: SendPayload = { to, body: task };
+		pi.events.emit(SEND, sent);
+		if (typeof sent.error === "string") throw new Error(`could not send the task to ${to}: ${sent.error}`);
+		if (sent.envelope === undefined)
+			throw new Error(
+				"needs a provider of message:* to send the task; install a mailbox extension (for example pi-session-mail)",
+			);
+		const requestId = sent.envelope.id;
+		if (typeof requestId !== "string") throw new Error(`the message:send provider wrote no request id for ${to}`);
+		return requestId;
+	}
+
+	/**
+	 * 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
+	 * 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.
+	 */
+	async function openChild(input: {
 		id: string;
-		requestId: string;
+		name: string;
+		session: string[];
 		workspace: Workspace;
 		trusted: boolean;
 		cwd: string;
 		sessionDir: string;
-		start: Start;
+		start: ChildStart;
+		/** The tool call that started this launch or resume; undefined from a command. */
+		toolCallId: string | undefined;
 		ctx: ExtensionContext;
-		onWindowOpened: () => void;
-	}): Promise<Launched> {
-		const { id, requestId, workspace, trusted, cwd, sessionDir, start, ctx, onWindowOpened } = input;
+		onWindowOpened?: () => void;
+	}): Promise<string> {
+		const { id, name, session, workspace, trusted, cwd, sessionDir, start, toolCallId, ctx, onWindowOpened } = input;
 		const parent = ctx.sessionManager.getSessionId();
-		const name = delegateName(start.agent.name, id, start.label);
 		const managedContext =
 			workspace.mode === "managed"
 				? `\n\nYour managed worktree is ${workspace.cwd}, branch ${workspace.createdBranch}, based on commit ${workspace.baseCommit}.`
@@ -598,10 +669,7 @@ export default function delegate(
 		const prompt = writePromptFile(`${start.agent.prompt}\n\n${FINAL_LINE}\n\n${parentTrust(parent)}${managedContext}`);
 		const argv = [
 			...parentCommand(),
-			"--session-id",
-			id,
-			"--name",
-			name,
+			...session,
 			// Always explicit, so a permissive global default cannot trust what the parent does not.
 			trusted ? "--approve" : "--no-approve",
 			"--session-dir",
@@ -629,18 +697,48 @@ export default function delegate(
 		const envSessionDir = process.env[SESSION_DIR_ENV];
 		if (envSessionDir !== undefined && envSessionDir !== "") env[SESSION_DIR_ENV] = envSessionDir;
 		// 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 };
+		const payload: LaunchPayload = { args: argv, env, agent: start.agent.name, cwd, toolCallId };
 		pi.events.emit(LAUNCH, payload);
 		let windowId: string;
 		try {
 			windowId = await tmux.openWindow({ name, cwd, argv: payload.args, env: payload.env });
-			onWindowOpened();
+			onWindowOpened?.();
 		} catch (err) {
 			if (err instanceof WindowOpenError) {
 				throw new WindowOpenError(`could not open window ${name} for ${id}: ${err.message}`, err.certainty);
 			}
 			throw new WindowOpenError(`could not open window ${name} for ${id}: ${(err as Error).message}`, "unknown");
 		}
+		return windowId;
+	}
+
+	async function launchWindow(input: {
+		id: string;
+		requestId: string;
+		workspace: Workspace;
+		trusted: boolean;
+		cwd: string;
+		sessionDir: string;
+		start: Start;
+		toolCallId: string | undefined;
+		ctx: ExtensionContext;
+		onWindowOpened: () => void;
+	}): Promise<Launched> {
+		const { id, requestId, workspace, trusted, cwd, sessionDir, start, toolCallId, ctx, onWindowOpened } = input;
+		const name = delegateName(start.agent.name, id, start.label);
+		const windowId = await openChild({
+			id,
+			name,
+			session: ["--session-id", id, "--name", name],
+			workspace,
+			trusted,
+			cwd,
+			sessionDir,
+			start,
+			toolCallId,
+			ctx,
+			onWindowOpened,
+		});
 		// No task text in the record: the request copy in `sent/` has it.
 		results.recordStart(
 			{
@@ -663,7 +761,12 @@ export default function delegate(
 		return { id, name, windowId, windowName: name, requestId, cwd, sessionDir, workspace };
 	}
 
-	async function launch(start: Start, ctx: ExtensionContext, signal?: AbortSignal): Promise<Launched> {
+	async function launch(
+		start: Start,
+		ctx: ExtensionContext,
+		signal?: AbortSignal,
+		toolCallId?: string,
+	): Promise<Launched> {
 		if (!tmux.insideTmux()) throw new Error(NOT_IN_TMUX);
 		const sessionDir = ctx.sessionManager.getSessionDir();
 		if (!isAbsolute(sessionDir))
@@ -760,15 +863,7 @@ export default function delegate(
 			// The task goes on disk before the window exists: the delegate finds it
 			// at session start without a handshake, and a window that fails leaves
 			// mail that is reported rather than cleaned up.
-			const sent: SendPayload = { to: id, body: start.task };
-			pi.events.emit(SEND, sent);
-			if (typeof sent.error === "string") throw new Error(`could not send the task to ${id}: ${sent.error}`);
-			if (sent.envelope === undefined)
-				throw new Error(
-					"needs a provider of message:* to send the task; install a mailbox extension (for example pi-session-mail)",
-				);
-			const requestId = sent.envelope.id;
-			if (typeof requestId !== "string") throw new Error(`the message:send provider wrote no request id for ${id}`);
+			const requestId = sendTask(id, start.task);
 			if (attempt !== undefined) {
 				attempt = { ...attempt, requestId };
 				results.recordAttempt(attempt, ctx);
@@ -781,6 +876,7 @@ export default function delegate(
 				cwd: workspace.cwd,
 				sessionDir,
 				start,
+				toolCallId,
 				ctx,
 				onWindowOpened: () => {
 					windowOpened = true;
@@ -847,6 +943,32 @@ export default function delegate(
 		return inQueue(plan.source.commonDir, combined, runWithRollback);
 	}
 
+	const resumer = createResume({
+		results,
+		tmux,
+		delegateSchema: DelegateSchema,
+		notInTmux: NOT_IN_TMUX,
+		startPolling: tracking.startPolling,
+		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 }) =>
+			openChild({
+				id,
+				name,
+				session: ["--session", sessionPath],
+				workspace,
+				trusted,
+				cwd,
+				sessionDir,
+				start,
+				toolCallId,
+				ctx,
+			}),
+	});
+
 	/** 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}` : "";
@@ -880,6 +1002,19 @@ export default function delegate(
 		}
 	}
 
+	async function resumeCommand(input: string, ctx: ExtensionContext): Promise<void> {
+		const outcome = parseResume(input);
+		if ("error" in outcome) {
+			ctx.ui.notify(`delegate: ${outcome.error}`, "error");
+			return;
+		}
+		try {
+			ctx.ui.notify(startedLine(await resumer.resume(outcome.request, ctx)), "info");
+		} catch (err) {
+			ctx.ui.notify(`delegate: ${(err as Error).message}`, "error");
+		}
+	}
+
 	/** The roster description last registered, so unchanged metadata is not registered again. */
 	let registeredDescription: string | undefined;
 
@@ -937,7 +1072,7 @@ export default function delegate(
 		// Opens a new window each call and removes nothing. Open world: the delegate calls a remote model and runs its agent's tools unattended.
 		annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
 		async execute(
-			_toolCallId: string,
+			toolCallId: string,
 			params: {
 				agent: string;
 				task: string;
@@ -977,7 +1112,7 @@ export default function delegate(
 				rosterFor(ctx),
 				ctx.modelRegistry,
 			);
-			const launched = await launch(start, ctx, signal);
+			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("")}`,
@@ -1054,6 +1189,26 @@ export default function delegate(
 		handler: command,
 	});
 
+	/** Delegation ids, flags, model ids and thinking levels, at the cursor's token. */
+	function resumeCompletions(prefix: string): { value: string; label: string }[] | null {
+		const partial = /(?:^|\s)(\S*)$/.exec(prefix)?.[1] ?? "";
+		const head = prefix.slice(0, prefix.length - partial.length);
+		const tokens = head.trim() === "" ? [] : head.trim().split(/\s+/);
+		const previous = tokens[tokens.length - 1];
+		let values: readonly string[] = RESUME_FLAGS;
+		if (tokens.length === 0) values = resumableIds(results);
+		else if (previous === "--model") values = modelIds(registry);
+		else if (previous === "--thinking") values = THINKING_LEVELS;
+		const hits = values.filter((value) => value.startsWith(partial));
+		return hits.length > 0 ? hits.map((value) => ({ value: head + value, label: value })) : null;
+	}
+
+	pi.registerCommand("delegate-resume", {
+		description: `Reopen an exited delegate's session in a new window with a follow-up task: ${RESUME_USAGE}`,
+		getArgumentCompletions: resumeCompletions,
+		handler: resumeCommand,
+	});
+
 	pi.registerCommand("delegate-clear", {
 		description: "Clear usage-limit marks: all, a provider, or a provider/model",
 		getArgumentCompletions: (prefix: string) => {
@@ -1084,4 +1239,5 @@ export default function delegate(
 
 	registerDelegate(toolDescription(currentRoster().agents));
 	tracking.registerTools();
+	pi.registerTool(resumer.tool() as never);
 }

package/src/render.ts

@@ -154,6 +154,7 @@ function plainLines(text: string): string[] {
 
 function idLines(details: MessageDetails): string[] {
 	const lines = [`delegation ${details.id}`, `request ${details.requestId}`];
+	if (details.resumedFrom !== undefined) lines.splice(1, 0, `resumed from ${details.resumedFrom}`);
 	if (details.kind === "result") lines.push(`envelope ${tilde(details.envelopePath)}`);
 	else lines.push(`window ${details.windowName}`);
 	lines.push(`cwd ${details.cwd === undefined ? cwdLine(undefined) : tilde(details.cwd)}`);
@@ -163,7 +164,7 @@ function idLines(details: MessageDetails): string[] {
 		lines.push(`checkout when the result arrived: ${first}`, ...rest.map((line) => `  ${line}`));
 	}
 	lines.push(
-		`session ${details.sessionPath === undefined ? `${details.id} (no session file found)` : tilde(details.sessionPath)}`,
+		`session ${details.sessionPath === undefined ? `${details.sessionId ?? details.id} (no session file found)` : tilde(details.sessionPath)}`,
 	);
 	return lines;
 }