pi-squire 0.13.1 → 0.15.0

package/src/navigator.ts

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

package/src/new-delegate.ts

@@ -47,6 +47,8 @@ export type NewDelegateDeps = {
 	roster(ctx: ExtensionContext): Roster;
 	/** The refusal text for an empty roster. */
 	noAgents(): string;
+	/** The model and thinking `agent` runs on when the request names none: its own, else the parent's. */
+	defaults(agent: Agent, ctx: ExtensionContext): { model?: string; thinking: string };
 	/** Why `value` is not a usable label, or undefined; the check `--label` gets. */
 	labelProblem(value: string): string | undefined;
 	/** Start the delegate as `/delegate` would, notifying the start or the refusal. */
@@ -207,12 +209,12 @@ export class SettingsForm implements Component {
 		this.options = options;
 		const { agent, models, style } = options;
 		for (const model of models) this.byId.set(`${model.provider}/${model.id}`, model);
-		this.model = agent.model;
-		this.thinking = agent.thinking;
+		this.model = agent.model ?? "";
+		this.thinking = agent.thinking ?? "";
 		this.autoExit = agent.autoExit;
 		this.cwd = options.cwd;
 		this.clampInitialThinking();
-		const modelItems: SelectItem[] = [...new Set([agent.model, ...this.byId.keys()])].map((value) => ({
+		const modelItems: SelectItem[] = [...new Set([this.model, ...this.byId.keys()])].map((value) => ({
 			value,
 			label: value,
 		}));
@@ -360,8 +362,8 @@ export class SettingsForm implements Component {
 			return;
 		}
 		this.options.done({
-			...(this.model === this.options.agent.model ? {} : { model: this.model }),
-			...(this.thinking === this.options.agent.thinking ? {} : { thinking: this.thinking }),
+			...(this.model === (this.options.agent.model ?? "") ? {} : { model: this.model }),
+			...(this.thinking === (this.options.agent.thinking ?? "") ? {} : { thinking: this.thinking }),
 			...(this.autoExit === this.options.agent.autoExit ? {} : { autoExit: this.autoExit }),
 			...(this.cwd === this.options.cwd ? {} : { cwd: this.cwd }),
 			...(this.worktree === "" ? {} : { worktree: this.worktree }),
@@ -410,14 +412,20 @@ export async function startNewDelegate(ctx: ExtensionContext, deps: NewDelegateD
 	if (unavailable !== undefined) return fail(unavailable);
 	const roster = deps.roster(ctx);
 	if (roster.agents.length === 0) return fail(deps.noAgents());
-	const options = roster.agents.map((agent) => `${agent.name} — ${agent.description}`);
+	const options = roster.agents.map(
+		(agent) =>
+			`${agent.name}${agent.displayName === undefined ? "" : ` (${agent.displayName})`} — ${agent.description}`,
+	);
 	const picked = await ctx.ui.select("New delegate: agent", options);
 	const agent = roster.agents[options.indexOf(picked ?? "")];
 	if (agent === undefined) return;
 	const task = await ctx.ui.editor(`Task for ${agent.name}`);
 	if (task === undefined) return;
 	if (task.trim() === "") return fail("a task is required");
-	const typed = await ctx.ui.input(`Label (optional; empty for ${agent.name}-<id>)`, "letters, digits, _ or -");
+	const typed = await ctx.ui.input(
+		`Label (optional; empty for ${agent.displayName ?? agent.name}-<id>)`,
+		"letters, digits, _ or -",
+	);
 	if (typed === undefined) return;
 	const label = typed.trim() === "" ? undefined : typed.trim();
 	const badLabel = label === undefined ? undefined : deps.labelProblem(label);
@@ -425,7 +433,8 @@ export async function startNewDelegate(ctx: ExtensionContext, deps: NewDelegateD
 	const chosen = await ctx.ui.custom<FormResult | undefined>(
 		(_tui, theme, _keys, done): Component =>
 			new SettingsForm({
-				agent,
+				// The rows start at what a request naming nothing runs on.
+				agent: { ...agent, ...deps.defaults(agent, ctx) } as Agent,
 				models: ctx.modelRegistry.getAvailable() as Model<never>[],
 				cwd: ctx.cwd,
 				style: theme,

package/src/poll.ts

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

package/src/result-sessions.ts

@@ -77,3 +77,42 @@ export function finishedModel(sessionPath: string | undefined): string | undefin
 	}
 	return undefined;
 }
+
+/** One session-file line, as much of it as the branch walk reads. */
+type BranchEntry = { type?: unknown; id?: unknown; parentId?: unknown; thinkingLevel?: unknown };
+
+/**
+ * The thinking level a delegate's session last changed to on its active
+ * branch: Pi records one `thinking_level_change` when a session starts and
+ * one per later change, the clamp to a new model's levels included. The
+ * branch is the leaf, Pi's last entry, back through each `parentId`.
+ * Undefined when the file cannot be read or holds no change on that branch.
+ */
+export function sessionThinking(sessionPath: string): string | undefined {
+	let lines: string[];
+	try {
+		lines = readFileSync(sessionPath, "utf8").split("\n");
+	} catch {
+		return undefined;
+	}
+	const byId = new Map<string, BranchEntry>();
+	let leaf: BranchEntry | undefined;
+	for (const line of lines) {
+		let entry: BranchEntry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (entry?.type === "session" || typeof entry?.id !== "string") continue;
+		byId.set(entry.id, entry);
+		leaf = entry;
+	}
+	const seen = new Set<BranchEntry>();
+	for (let entry = leaf; entry !== undefined && !seen.has(entry); ) {
+		seen.add(entry);
+		if (entry.type === "thinking_level_change" && typeof entry.thinkingLevel === "string") return entry.thinkingLevel;
+		entry = typeof entry.parentId === "string" ? byId.get(entry.parentId) : undefined;
+	}
+	return undefined;
+}

package/src/results.ts

@@ -35,6 +35,8 @@ const INBOUND = "message:inbound";
 export type Delegation = {
 	id: string;
 	agent: string;
+	/** The agent's `display_name` at launch, shown instead of `agent`; absent when it had none. */
+	displayName?: string;
 	model: string;
 	thinking: string;
 	/** The delegate's session and window name; absent in records from before labels, where it was `<agent>-<8 id characters>`. */

package/src/resume-checks.ts

@@ -8,8 +8,8 @@ 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 { type Agent, disabledProblem, isThinking, withoutLocked } from "./agents.ts";
+import { sessionHeaderCwd, sessionIdOf, sessionThinking } 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";
@@ -79,10 +79,35 @@ export function sessionFor(record: StartedRecorded, ctx: ExtensionContext): Sess
 	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])];
+/**
+ * What a resume runs with when the call passes nothing. A field the agent
+ * locks takes the agent file's current value, or the parent's current one when
+ * the file sets none, even when the delegate last ran on another (a fallback
+ * after a usage limit, or a value from before the file changed). A field it
+ * does not lock keeps what the delegate last ran on: the model of its last
+ * answer, and the thinking level its session last changed to, or the
+ * recorded ones when the session does not say. The models are in order, the
+ * agent's fallbacks after the first.
+ */
+export function resumeDefaults(
+	record: StartedRecorded,
+	agent: Agent,
+	sessionPath: string,
+	parent: { model?: string; thinking: string },
+): { models: string[]; thinking: string } {
+	const first = agent.locked.includes("model")
+		? (agent.model ?? parent.model)
+		: (finishedModel(sessionPath) ?? record.result?.finishedModel ?? record.model);
+	const thinking = agent.locked.includes("thinking")
+		? (agent.thinking ?? parent.thinking)
+		: lastThinking(record, sessionPath);
+	return { models: [...new Set([...(first === undefined ? [] : [first]), ...agent.fallback])], thinking };
+}
+
+/** The thinking level the delegate last ran on: its session's last change, else the level recorded at its start. */
+function lastThinking(record: StartedRecorded, sessionPath: string): string {
+	const level = sessionThinking(sessionPath);
+	return level !== undefined && isThinking(level) ? level : record.thinking;
 }
 
 /** Steps 5 and 6: the session file and the agent, and no resume of the delegation already under way. */
@@ -92,7 +117,10 @@ export function recordCheck(
 	ctx: ExtensionContext,
 ): { session: SessionFile; agent: Agent } {
 	const session = sessionFor(record, ctx);
-	const agent = deps.roster(ctx).agents.find((item) => item.name === record.agent);
+	const roster = deps.roster(ctx);
+	const disabled = disabledProblem(roster, record.agent);
+	if (disabled !== undefined) throw new Error(`${disabled}, so delegation ${record.id} is not resumed`);
+	const agent = roster.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`,
@@ -113,12 +141,17 @@ export async function settleModel(
 	},
 	ctx: ExtensionContext,
 ): Promise<{ thinking: string; chosen: Awaited<ReturnType<ResumeDeps["chooseModel"]>> }> {
-	const { record, agent, session, request } = input;
-	const thinking = request.thinking ?? record.thinking;
+	const { record, agent, session } = input;
+	const defaults = resumeDefaults(record, agent, session.path, deps.parentDefaults(ctx));
+	const { request, notice } = withoutLocked(agent, input.request, {
+		model: defaults.models[0],
+		thinking: defaults.thinking,
+	});
+	const thinking = request.thinking ?? defaults.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) };
+	const chosen = await deps.chooseModel(request.model, agent, ctx.modelRegistry, defaults.models);
+	return { thinking, chosen: notice === undefined ? chosen : { ...chosen, notices: [notice, ...chosen.notices] } };
 }
 
 /** The call-wide prerequisites of a resume: inside tmux, a new enough tmux, a valid placement setting (read once). */
@@ -143,7 +176,7 @@ export async function passes(
 		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)]);
+		const key = JSON.stringify([agent.name, resumeDefaults(record, agent, session.path, deps.parentDefaults(ctx))]);
 		let ok = models.get(key);
 		if (ok === undefined) {
 			ok = await settleModel(deps, { record, agent, session, request: {} }, ctx).then(

package/src/resume.ts

@@ -52,6 +52,8 @@ export type ResumeDeps = {
 	/** The window placement for this call; throws on an invalid setting. */
 	placement(): WindowPlacement;
 	roster(ctx: ExtensionContext): Roster;
+	/** The parent's current model and thinking level, which a field the agent locks but does not set keeps. */
+	parentDefaults(ctx: ExtensionContext): { model?: string; thinking: string };
 	chooseModel(
 		explicit: string | undefined,
 		agent: Agent,
@@ -243,6 +245,7 @@ async function startResume(
 		{
 			id,
 			agent: start.agent.name,
+			...(start.agent.displayName === undefined ? {} : { displayName: start.agent.displayName }),
 			model: start.model,
 			thinking: start.thinking,
 			name,
@@ -348,11 +351,13 @@ function resumeTool(deps: ResumeDeps): ToolDef {
 			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.",
+						"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. Not used when the agent locks model: the agent's current model applies.",
 				}),
 			),
 			thinking: Type.Optional(
-				Type.String({ description: `Thinking level (${THINKING_LEVELS.join(", ")}); defaults to the delegation's.` }),
+				Type.String({
+					description: `Thinking level (${THINKING_LEVELS.join(", ")}); defaults to the level the delegate last ran on, from its session. Not used when the agent locks thinking: the agent's current level applies.`,
+				}),
 			),
 			auto_exit: Type.Optional(
 				Type.Boolean({ description: "Close the window once it finishes; defaults to the delegation's setting." }),