pi-squire 0.10.0 → 0.11.0

package/src/resume.ts

@@ -0,0 +1,448 @@
+// Resuming an exited delegate: the eligibility checks, the launch that reopens
+// its own session file, and the `delegation_resume` tool. A resume is recorded
+// as a new delegation (`resumedFrom` the old id) that keeps the old session id
+// (`sessionId`), so mail, replies and usage-limit marks still find the session.
+// `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 {
+	deriveState,
+	finishedModel,
+	isStarted,
+	locateSession,
+	type Results,
+	recordedName,
+	type StartedRecorded,
+} from "./results.ts";
+import type { TmuxClient } from "./tmux.ts";
+import { listWindows, ownWindow, type ToolDef, toolResult, windowState } from "./tracking.ts";
+import type { Workspace } from "./workspace.ts";
+
+/** What a resume asks for; the fields after `task` are optional overrides. */
+export type ResumeRequest = {
+	id: string;
+	task: string;
+	model?: string;
+	thinking?: string;
+	autoExit?: boolean;
+	/** The `delegation_resume` tool call that asked for it; undefined from the command. */
+	toolCallId?: string;
+};
+
+/** A candidate model passed over, as `chooseModel` reports it. */
+type Skipped = { model: string; why: string; reason: string };
+
+/** What a resume reads from the launch path in `index.ts`. */
+export type ResumeDeps = {
+	results: Results;
+	tmux: TmuxClient;
+	/** The `delegate` tool's result schema, which a resume's result extends. */
+	delegateSchema: TObject;
+	/** The refusal text for a session outside tmux. */
+	notInTmux: string;
+	startPolling(): void;
+	roster(ctx: ExtensionContext): Roster;
+	chooseModel(
+		explicit: string | undefined,
+		agent: Agent,
+		models: ModelRegistry,
+		preferred: readonly string[],
+	): Promise<{ model: string; skipped: Skipped[]; notices: string[]; rest: string[] }>;
+	thinkingProblem(value: string): string | undefined;
+	/** The workspace and trust for an existing directory, deciding trust again. */
+	prepareDirectory(
+		cwd: string,
+		ctx: ExtensionContext,
+		signal: AbortSignal | undefined,
+	): Promise<{ workspace: Workspace; trusted: boolean }>;
+	/** Mail the task to a session id; returns the request id. */
+	sendTask(to: string, task: string): string;
+	/** Open the window with `--session <path>`; returns its id. */
+	open(input: {
+		id: string;
+		name: string;
+		sessionPath: string;
+		workspace: Workspace;
+		trusted: boolean;
+		cwd: string;
+		sessionDir: string;
+		start: { agent: Agent; model: string; rest: string[]; thinking: string; autoExit: boolean };
+		toolCallId: string | undefined;
+		ctx: ExtensionContext;
+	}): Promise<string>;
+};
+
+/** A started resume: what the tool and the command report. */
+export type Resumed = {
+	id: string;
+	resumedFrom: string;
+	agent: string;
+	model: string;
+	skipped: { model: string; reason: string }[];
+	notices: string[];
+	thinking: string;
+	autoExit: boolean;
+	windowId: string;
+	windowName: string;
+	cwd: string;
+	sessionDir: string;
+	workspace: Workspace;
+	/** The sentence naming a fallback model, or "". */
+	fallbackNote: string;
+};
+
+/** The started records, in the order recorded. */
+function startedRecords(results: Results): StartedRecorded[] {
+	return results.list().filter(isStarted);
+}
+
+/** The record a `/delegate-resume` id can name: started, with no later resume of it. */
+export function resumableIds(results: Results): string[] {
+	const started = startedRecords(results);
+	return started.filter((record) => !started.some((item) => item.resumedFrom === record.id)).map(({ id }) => id);
+}
+
+/** Steps 1 and 2: the id names a started delegation that nothing resumed. */
+function newestStarted(results: Results, id: string): StartedRecorded {
+	const record = results.find(id);
+	if (record === undefined) {
+		const known = results.list().map((item) => item.id);
+		throw new Error(`no delegation ${JSON.stringify(id)}; known: ${known.join(", ") || "none"}`);
+	}
+	if (!isStarted(record)) {
+		throw new Error(
+			`delegation ${id} is a workspace attempt (${record.attempt.phase}), not a started delegate, so there is no session to resume`,
+		);
+	}
+	const started = startedRecords(results);
+	let newest = record;
+	for (let next = started.find((item) => item.resumedFrom === newest.id); next !== undefined; ) {
+		newest = next;
+		next = started.find((item) => item.resumedFrom === newest.id);
+	}
+	if (newest !== record) {
+		throw new Error(
+			`delegation ${id} was already resumed; resume its newest delegation ${newest.id} instead (it continues the same session)`,
+		);
+	}
+	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.
+ */
+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);
+	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) {
+		throw new Error(
+			`could not kill the exited window ${record.windowName} (${record.windowId}): ${(err as Error).message}`,
+		);
+	}
+}
+
+/** 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({
+		...delegateSchema.properties,
+		resumedFrom: Type.String({ description: "The delegation whose session this one reopened." }),
+	});
+}
+
+/** The model, thinking and auto-exit a resume runs with, and the directory and workspace it opens in. */
+type Plan = {
+	start: { agent: Agent; model: string; rest: string[]; thinking: string; autoExit: boolean };
+	chosen: Awaited<ReturnType<ResumeDeps["chooseModel"]>>;
+	workspace: Workspace;
+	trusted: boolean;
+};
+
+/** Settle the request's overrides against the record, and decide trust again for the session's directory. */
+async function planResume(
+	deps: ResumeDeps,
+	input: { record: StartedRecorded; agent: Agent; session: SessionFile; request: ResumeRequest },
+	ctx: ExtensionContext,
+	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 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.
+	const workspace = record.workspace?.cwd === prepared.workspace.cwd ? record.workspace : prepared.workspace;
+	return {
+		start: { agent, model: chosen.model, rest: chosen.rest, thinking, autoExit },
+		chosen,
+		workspace,
+		trusted: prepared.trusted,
+	};
+}
+
+/** Mail the task, open the window on the session file and record the new delegation. */
+/**
+ * Mail the task to a window already open. Unlike a launch, a resume mails
+ * after the window opens: the session's inbox outlives a failed attempt, so
+ * mail sent for a window that never opened would reach the next resume as a
+ * second task. The reopened session's provider still delivers mail that
+ * arrives after it starts. A failed send kills the window, which has no task.
+ */
+async function mailTask(deps: ResumeDeps, windowId: string, sessionId: string, task: string): Promise<string> {
+	try {
+		return deps.sendTask(sessionId, task);
+	} catch (err) {
+		await deps.tmux.kill(windowId).catch(() => {});
+		throw err;
+	}
+}
+
+async function startResume(
+	deps: ResumeDeps,
+	input: { record: StartedRecorded; session: SessionFile; plan: Plan; task: string; toolCallId: string | undefined },
+	ctx: ExtensionContext,
+): Promise<Resumed> {
+	const { record, session, plan, task, toolCallId } = input;
+	const { start, chosen, workspace } = plan;
+	const id = randomUUID();
+	const sessionId = sessionIdOf(record);
+	const name = recordedName(record);
+	const windowId = await deps.open({
+		id,
+		name,
+		sessionPath: session.path,
+		workspace,
+		trusted: plan.trusted,
+		cwd: workspace.cwd,
+		sessionDir: session.dir,
+		start,
+		toolCallId,
+		ctx,
+	});
+	const requestId = await mailTask(deps, windowId, sessionId, task);
+	deps.results.recordStart(
+		{
+			id,
+			agent: start.agent.name,
+			model: start.model,
+			thinking: start.thinking,
+			name,
+			windowId,
+			windowName: name,
+			requestId,
+			autoExit: start.autoExit,
+			cwd: workspace.cwd,
+			sessionDir: session.dir,
+			workspace,
+			resumedFrom: record.id,
+			sessionId,
+		},
+		ctx,
+	);
+	deps.startPolling();
+	return {
+		id,
+		resumedFrom: record.id,
+		agent: start.agent.name,
+		model: start.model,
+		skipped: chosen.skipped.map(({ model, reason }) => ({ model, reason })),
+		notices: chosen.notices,
+		thinking: start.thinking,
+		autoExit: start.autoExit,
+		windowId,
+		windowName: name,
+		cwd: workspace.cwd,
+		sessionDir: session.dir,
+		workspace,
+		fallbackNote:
+			chosen.skipped.length === 0
+				? ""
+				: `Used fallback ${chosen.model} because ${chosen.skipped.map((item) => `${item.model} is ${item.why}`).join("; ")}.`,
+	};
+}
+
+/** 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,
+	request: ResumeRequest,
+	ctx: ExtensionContext,
+	signal: AbortSignal | undefined,
+): Promise<Resumed> {
+	if (!deps.tmux.insideTmux()) throw new Error(deps.notInTmux);
+	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`);
+	inFlight.add(record.id);
+	try {
+		const plan = await planResume(deps, { record, agent, session, request }, ctx, signal);
+		return await startResume(deps, { record, session, plan, task: request.task, toolCallId: request.toolCallId }, ctx);
+	} finally {
+		inFlight.delete(record.id);
+	}
+}
+
+/** The one line the command and the tool tell the user. */
+export function startedLine(resumed: Resumed): string {
+	return `delegate: resumed ${resumed.resumedFrom} as ${resumed.id}: ${resumed.agent} in window ${resumed.windowName}${resumed.fallbackNote === "" ? "" : `. ${resumed.fallbackNote}`}${resumed.notices.map((line) => `. ${line}`).join("")}`;
+}
+
+/** The `delegation_resume` tool. */
+function resumeTool(deps: ResumeDeps): ToolDef {
+	return {
+		name: "delegation_resume",
+		label: "Resume delegation",
+		description:
+			"Continue an exited delegate with a follow-up task: reopen its own session, so it keeps the context it built, in a new window. The follow-up is recorded as a new delegation, and its result arrives as a message on its own, like a delegate's. Use it when the next task needs what the delegate already read or decided; for unrelated work, use delegate. It refuses a delegation that is still running (send it a message instead), one whose window is still open, an older delegation of a chain that was already resumed (it names the newest), and one whose working directory is gone, a removed worktree included. A delegate whose window was killed mid-turn can be resumed.",
+		parameters: Type.Object({
+			id: Type.String({ description: "The delegation to resume, from a delegate result or delegation_status." }),
+			task: Type.String({
+				description: "The follow-up task. The delegate sees its earlier conversation plus this.",
+			}),
+			model: Type.Optional(
+				Type.String({
+					description:
+						"provider/id to resume on; used as given. Omit to continue on the model the delegate finished on, or its agent's next fallback when that one is unavailable.",
+				}),
+			),
+			thinking: Type.Optional(
+				Type.String({ description: `Thinking level (${THINKING_LEVELS.join(", ")}); defaults to the delegation's.` }),
+			),
+			auto_exit: Type.Optional(
+				Type.Boolean({ description: "Close the window once it finishes; defaults to the delegation's setting." }),
+			),
+		}),
+		outputSchema: resultSchema(deps.delegateSchema),
+		// Opens a window and removes nothing but an exited window of the old run; each call starts another run.
+		annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+		async execute(
+			toolCallId: string,
+			params: { id: string; task: string; model?: string | null; thinking?: string | null; auto_exit?: boolean | null },
+			signal: AbortSignal | undefined,
+			_onUpdate: unknown,
+			ctx: ExtensionContext,
+		): Promise<ReturnType<typeof toolResult>> {
+			const resumed = await resume(deps, { ...requestFrom(params), toolCallId }, ctx, signal);
+			const { fallbackNote, ...details } = resumed;
+			ctx.ui.notify(startedLine(resumed), "info");
+			return toolResult(
+				`Resumed delegation ${resumed.resumedFrom} as ${resumed.id}: ${resumed.agent} (${resumed.model}, thinking ${resumed.thinking}) in window ${resumed.windowName}. It runs in the background, and its result arrives as a message that starts your next turn on its own; delegation_close ends it.${fallbackNote === "" ? "" : ` ${fallbackNote}`}${resumed.notices.map((line) => ` ${line}`).join("")}`,
+				{ outcome: "started", ...details },
+			);
+		},
+	};
+}
+
+/** The request a tool call makes; some models fill every optional field with null or the string "null", and both mean unset. */
+function requestFrom(params: {
+	id: string;
+	task: string;
+	model?: string | null;
+	thinking?: string | null;
+	auto_exit?: boolean | null;
+}): ResumeRequest {
+	const given = (value: string | null | undefined): string | undefined =>
+		value == null || value === "null" ? undefined : value;
+	return {
+		id: params.id,
+		task: params.task ?? "",
+		model: given(params.model),
+		thinking: given(params.thinking),
+		autoExit: typeof params.auto_exit === "boolean" ? params.auto_exit : undefined,
+	};
+}
+
+/** 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>;
+	tool(): ToolDef;
+} {
+	return {
+		resume: (request: ResumeRequest, ctx: ExtensionContext, signal?: AbortSignal) => resume(deps, request, ctx, signal),
+		tool: () => resumeTool(deps),
+	};
+}

package/src/tracking-text.ts

@@ -0,0 +1,41 @@
+// How `delegation_status` words a delegation's state, auto-exit and age.
+import type { DelegationState, StartedRecorded } from "./results.ts";
+
+/** Records from before auto-exit existed kept their windows open, so they read off. */
+export function autoExitLine(record: StartedRecorded): string {
+	return record.autoExit === true
+		? "on — the delegate closes its window after a normal completion unless the user took over there"
+		: "off — the window stays open after the result";
+}
+
+/** The state, worded for the `state:` line. */
+export function stateLine(state: DelegationState, record: StartedRecorded): string {
+	switch (state) {
+		case "running":
+			return "running — the window is open and no result has arrived";
+		case "gone":
+			return "closed without a result — the window is gone and no reply arrived; a late reply would make it done";
+		case "done":
+			return `done — result status: ${record.result?.status ?? "unknown"}; the result reaches this session as a [delegate] message on its own`;
+		case "closed":
+			return "closed — delegation_close recorded it";
+		case "window-closed":
+			return "closed — the window is gone";
+		case "unknown":
+			return "unknown — tmux could not be asked whether the window is open";
+		case "planned":
+		case "created":
+		case "rolled-back":
+		case "retained":
+		case "interrupted":
+			return `${state} — no window id/start was recorded; a window may still exist`;
+	}
+}
+
+/** How long ago, worded for the `state:` line: `just now`, `N min ago` or `N h M min ago`. */
+export function ago(ms: number): string {
+	const minutes = Math.floor(ms / 60_000);
+	if (minutes < 1) return "just now";
+	if (minutes < 60) return `${minutes} min ago`;
+	return `${Math.floor(minutes / 60)} h ${minutes % 60} min ago`;
+}

package/src/tracking.ts

@@ -18,12 +18,14 @@ import {
 	type Results,
 	recordedName,
 	type StartedRecorded,
+	sessionIdOf,
 	type WindowState,
 	type WorkspaceAttempt,
 } from "./results.ts";
 import { inspectWorkspace, type WorkspaceSnapshot, WorkspaceSnapshotSchema } from "./snapshot.ts";
 import type { TmuxClient, TmuxWindow } from "./tmux.ts";
 import { AttemptSchema } from "./tracking-attempt.ts";
+import { ago, autoExitLine, stateLine } from "./tracking-text.ts";
 import type { ReadingError } from "./usage.ts";
 import { WorkspaceSchema } from "./workspace.ts";
 
@@ -69,6 +71,7 @@ const StartedSchema = Type.Object({
 	),
 	thinking: Type.String(),
 	autoExit: Type.Boolean(),
+	resumedFrom: Type.Optional(Type.String({ description: "The delegation whose session this one reopened." })),
 	windowId: Type.String(),
 	windowName: Type.String(),
 	cwd: Type.Optional(
@@ -81,7 +84,7 @@ const StartedSchema = Type.Object({
 		STARTED_STATES.map((state) => Type.Literal(state)),
 		{
 			description:
-				"running: window open, no result. done: a result arrived (see status, envelopePath). gone: the window went with no result; a late reply makes it done. closed: delegation_close recorded it. window-closed: the window is gone. unknown: tmux could not be asked. done and closed are final; gone and window-closed turn done if a late reply arrives.",
+				"running: window open, no result. done: a result arrived (see status, envelopePath). gone: the window went with no result; a late reply makes it done. closed: delegation_close recorded it. window-closed: the window is gone. unknown: tmux could not be asked. done and closed are final, though a later delegation_resume continues one as a new delegation; gone and window-closed turn done if a late reply arrives.",
 		},
 	),
 	closed: Type.Boolean(),
@@ -119,7 +122,7 @@ export const CloseSchema = Type.Object({
 });
 
 /** A tool as registered; `execute` takes the tool's own parameters, which the registration call does not check. */
-type ToolDef = {
+export type ToolDef = {
 	name: string;
 	label: string;
 	description: string;
@@ -130,7 +133,7 @@ type ToolDef = {
 };
 
 /** Every window on the server, asked once; a failed ask is `undefined`, never an empty list. */
-async function listWindows(tmux: TmuxClient): Promise<TmuxWindow[] | undefined> {
+export async function listWindows(tmux: TmuxClient): Promise<TmuxWindow[] | undefined> {
 	try {
 		return await tmux.listWindows();
 	} catch {
@@ -139,48 +142,17 @@ async function listWindows(tmux: TmuxClient): Promise<TmuxWindow[] | undefined>
 }
 
 /** The window a delegation owns: one with both its recorded id and its recorded name, since ids restart with every tmux server. */
-function ownWindow(windows: TmuxWindow[], record: StartedRecorded): TmuxWindow | undefined {
+export function ownWindow(windows: TmuxWindow[], record: StartedRecorded): TmuxWindow | undefined {
 	return windows.find((window) => window.id === record.windowId && window.name === record.windowName);
 }
 
 /** What the listing says about a delegation's window; a matching window whose program exited counts as gone. */
-function windowState(windows: TmuxWindow[] | undefined, record: StartedRecorded): WindowState {
+export function windowState(windows: TmuxWindow[] | undefined, record: StartedRecorded): WindowState {
 	if (windows === undefined) return "unknown";
 	const own = ownWindow(windows, record);
 	return own !== undefined && !own.exited ? "open" : "gone";
 }
 
-/** Records from before auto-exit existed kept their windows open, so they read off. */
-function autoExitLine(record: StartedRecorded): string {
-	return record.autoExit === true
-		? "on — the delegate closes its window after a normal completion unless the user took over there"
-		: "off — the window stays open after the result";
-}
-
-/** The state, worded for the `state:` line. */
-function stateLine(state: DelegationState, record: StartedRecorded): string {
-	switch (state) {
-		case "running":
-			return "running — the window is open and no result has arrived";
-		case "gone":
-			return "closed without a result — the window is gone and no reply arrived; a late reply would make it done";
-		case "done":
-			return `done — result status: ${record.result?.status ?? "unknown"}; the result reaches this session as a [delegate] message on its own`;
-		case "closed":
-			return "closed — delegation_close recorded it";
-		case "window-closed":
-			return "closed — the window is gone";
-		case "unknown":
-			return "unknown — tmux could not be asked whether the window is open";
-		case "planned":
-		case "created":
-		case "rolled-back":
-		case "retained":
-		case "interrupted":
-			return `${state} — no window id/start was recorded; a window may still exist`;
-	}
-}
-
 /** One delegation as `delegation_status` reports it; its text and details both read from this. */
 type View = {
 	record: StartedRecorded;
@@ -191,18 +163,17 @@ type View = {
 	lastActive: Date | undefined;
 	/** The checkout observed for this status call; the recorded result keeps its own. */
 	snapshot: WorkspaceSnapshot;
+	/** The delegation that resumed this one, if any. */
+	resumedAs: string | undefined;
 };
 
-/** How long ago, worded for the `state:` line: `just now`, `N min ago` or `N h M min ago`. */
-function ago(ms: number): string {
-	const minutes = Math.floor(ms / 60_000);
-	if (minutes < 1) return "just now";
-	if (minutes < 60) return `${minutes} min ago`;
-	return `${Math.floor(minutes / 60)} h ${minutes % 60} min ago`;
-}
-
 /** The view of a delegation: its state and the fields the text and details share. */
-function view(record: StartedRecorded, windows: TmuxWindow[] | undefined, ctx: ExtensionContext): View {
+function view(
+	record: StartedRecorded,
+	windows: TmuxWindow[] | undefined,
+	ctx: ExtensionContext,
+	resumedAs: string | undefined,
+): View {
 	const state = deriveState(record, windowState(windows, record));
 	const sessionPath = locateSession(record, ctx.sessionManager.getSessionDir());
 	let lastActive: Date | undefined;
@@ -214,16 +185,18 @@ function view(record: StartedRecorded, windows: TmuxWindow[] | undefined, ctx: E
 		}
 	}
 	const snapshot = inspectWorkspace(record.workspace?.cwd, record.workspace?.git);
-	return { record, state, name: recordedName(record), sessionPath, lastActive, snapshot };
+	return { record, state, name: recordedName(record), sessionPath, lastActive, snapshot, resumedAs };
 }
 
 /** The text block for one delegation. */
-function viewText({ record, state, name, sessionPath, lastActive, snapshot }: View): string {
+function viewText({ record, state, name, sessionPath, lastActive, snapshot, resumedAs }: View): string {
 	const [checkout, ...categories] = snapshotLines(snapshot);
 	const seen = lastActive === undefined ? "" : ` (last active ${ago(Date.now() - lastActive.getTime())})`;
 	const lines = [
 		`${record.id} ${record.agent} (${modelLabel(record.model, record.result?.finishedModel)}, thinking ${record.thinking})`,
 		`  name: ${name}`,
+		...(record.resumedFrom === undefined ? [] : [`  resumed from ${record.resumedFrom}`]),
+		...(resumedAs === undefined ? [] : [`  resumed as ${resumedAs}`]),
 		`  state: ${stateLine(state, record)}${seen}`,
 		`  window: ${record.windowName} (${record.windowId})`,
 		`  cwd: ${cwdLine(record.cwd)}`,
@@ -231,7 +204,7 @@ function viewText({ record, state, name, sessionPath, lastActive, snapshot }: Vi
 		`  checkout now: ${checkout}`,
 		...categories.map((line) => `    ${line}`),
 		`  auto-exit: ${autoExitLine(record)}`,
-		`  session: ${sessionPath ?? `${record.id} (no session file yet)`}`,
+		`  session: ${sessionPath ?? `${sessionIdOf(record)} (no session file yet)`}`,
 	];
 	if (record.result !== undefined) lines.push(`  envelope: ${record.result.envelopePath}`);
 	return lines.join("\n");
@@ -248,6 +221,7 @@ function viewDetails({ record, state, name, sessionPath, lastActive, snapshot }:
 		...(record.result?.finishedModel === undefined ? {} : { finishedModel: record.result.finishedModel }),
 		thinking: record.thinking,
 		autoExit: record.autoExit === true,
+		...(record.resumedFrom === undefined ? {} : { resumedFrom: record.resumedFrom }),
 		windowId: record.windowId,
 		windowName: record.windowName,
 		...(record.cwd === undefined ? {} : { cwd: record.cwd }),
@@ -384,7 +358,10 @@ function statusTool(results: Results, tmux: TmuxClient, readingErrors: () => Rea
 		): Promise<ReturnType<typeof toolResult>> {
 			const records = selectRecords(results, params.id);
 			const windows = await listWindows(tmux);
-			const views = records.map((record) => (isStarted(record) ? view(record, windows, ctx) : record));
+			const resumedAs = (id: string) => results.list().find((item) => isStarted(item) && item.resumedFrom === id)?.id;
+			const views = records.map((record) =>
+				isStarted(record) ? view(record, windows, ctx, resumedAs(record.id)) : record,
+			);
 			const marks = activeMarks();
 			const errors = readingErrors();
 			const details = {