@bastani/atomic 0.9.15 → 0.9.16-alpha.2

package/dist/builtin/workflows/src/extension/public-types.ts

@@ -5,7 +5,7 @@ import type { SessionManager } from "../shared/persistence-restore.js";
 import type { RunStatus, StageStatus } from "../shared/store-types.js";
 import type { WorkflowBudget, WorkflowInputValues } from "../shared/types.js";
 import type { WidgetFactory } from "../tui/store-widget-installer.js";
-import type { RenderResultOpts, WorkflowToolResult } from "./render-result.js";
+import type { RenderResultOpts, WorkflowRegisteredToolResult } from "./render-result.js";
 import type { PiUISurface } from "./wiring.js";
 
 export type PiTheme = Record<string, string>;
@@ -231,4 +231,4 @@ export interface WorkflowToolArgs {
 	reason?: string;
 }
 
-export type WorkflowExecuteToolResult = PiAgentToolResult<WorkflowToolResult>;
+export type WorkflowExecuteToolResult = PiAgentToolResult<WorkflowRegisteredToolResult>;

package/dist/builtin/workflows/src/extension/render-result.ts

@@ -197,6 +197,15 @@ export interface ModelCatalogEntry {
 }
 type ModelsResult = { action: "models"; models: ModelCatalogEntry[] };
 
+export type WorkflowTimeoutResult = {
+	action: NonNullable<import("./public-types.js").WorkflowToolArgs["action"]>;
+	status: "failed";
+	code: "WORKFLOW_TIMEOUT";
+	timeoutMs: number;
+	runId?: string;
+	error: string;
+};
+
 export type WorkflowToolResult =
 	| ListResult
 	| StatusResult
@@ -216,6 +225,8 @@ export type WorkflowToolResult =
 	| ToolNodeControlResult
 	| ModelsResult;
 
+export type WorkflowRegisteredToolResult = WorkflowToolResult | WorkflowTimeoutResult;
+
 export interface RenderResultOpts {
 	isPartial?: boolean;
 	/**
@@ -310,7 +321,7 @@ function transcriptNoticeText(result: TranscriptResult): string {
 	return entriesText;
 }
 
-export function renderResult(result: WorkflowToolResult, opts?: RenderResultOpts): string {
+export function renderResult(result: WorkflowRegisteredToolResult | null | undefined, opts?: RenderResultOpts): string {
 	const partial = opts?.isPartial === true;
 	const themed = opts?.plain !== true;
 
@@ -319,9 +330,12 @@ export function renderResult(result: WorkflowToolResult, opts?: RenderResultOpts
 	// paths that return content without a structured payload. Dereferencing a
 	// missing `action` here previously threw and crashed the TUI render loop, so
 	// degrade gracefully instead.
-	if (result === null || typeof result !== "object" || typeof (result as { action?: unknown }).action !== "string") {
+	if (result === null || result === undefined || typeof result.action !== "string") {
 		return partial ? "" : renderNotice("WORKFLOW", "no result", opts, themed);
 	}
+	if ("code" in result && result.code === "WORKFLOW_TIMEOUT") {
+		return renderNotice("WORKFLOW TIMEOUT", result.error, opts, themed);
+	}
 
 	switch (result.action) {
 		case "list": {

package/dist/builtin/workflows/src/extension/runtime.ts

@@ -40,6 +40,7 @@ import {
 	releaseActiveBlockedClaim,
 } from "./runtime-active-block-claim.js";
 import { createDurableResumeRuntime, type DurableResumeRuntime } from "./runtime-durable-resume.js";
+import { raceWorkflowRequestAbort } from "./workflow-request-abort.js";
 
 // ---------------------------------------------------------------------------
 // Options
@@ -122,6 +123,10 @@ export interface RuntimeDispatchOptions {
 	readonly actor?: WorkflowActor;
 	/** Run-level budget override used when a continuation is launched. */
 	readonly budget?: WorkflowBudget;
+	/** Cancels only the public request/admission wait, never detached execution after acknowledgement. */
+	readonly signal?: AbortSignal;
+	/** Reports the exact detached identity before startup admission is awaited. */
+	readonly onRunAccepted?: (runId: string) => void;
 }
 // ---------------------------------------------------------------------------
 // Factory
@@ -397,7 +402,7 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
 		},
 
 		async dispatch(args: WorkflowToolArgs, options?: RuntimeDispatchOptions): Promise<WorkflowToolResult> {
-			await ensureDbosReady();
+			await raceWorkflowRequestAbort(ensureDbosReady(), options?.signal);
 			const defaultSessionDir = resolveDefaultStageSessionDir?.();
 			return dispatch(args, {
 				registry,
@@ -411,6 +416,8 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
 				models,
 				policy: options?.policy,
 				...(options?.origin === undefined ? {} : { origin: options.origin }),
+				...(options?.signal === undefined ? {} : { signal: options.signal }),
+				...(options?.onRunAccepted === undefined ? {} : { onRunAccepted: options.onRunAccepted }),
 				cwd: runtimeCwd,
 				...(defaultSessionDir !== undefined ? { defaultSessionDir } : {}),
 			});

package/dist/builtin/workflows/src/extension/workflow-request-abort.ts

@@ -0,0 +1,15 @@
+export function raceWorkflowRequestAbort<T>(operation: Promise<T>, signal: AbortSignal | undefined): Promise<T> {
+	if (signal === undefined) return operation;
+	if (signal.aborted) {
+		void operation.catch(() => {});
+		return Promise.reject(signal.reason ?? new DOMException("Workflow request aborted", "AbortError"));
+	}
+	const abort = Promise.withResolvers<never>();
+	const onAbort = (): void => {
+		abort.reject(signal.reason ?? new DOMException("Workflow request aborted", "AbortError"));
+	};
+	signal.addEventListener("abort", onAbort, { once: true });
+	return Promise.race([operation, abort.promise]).finally(() => {
+		signal.removeEventListener("abort", onAbort);
+	});
+}

package/dist/builtin/workflows/src/extension/workflow-tool-content.ts

@@ -4,12 +4,12 @@ import type { RunSnapshot } from "../shared/store-types.js";
 import type { WorkflowSerializableValue } from "../shared/types.js";
 import { fmtDuration, statusIcon } from "../tui/status-helpers.js";
 import type { WorkflowToolArgs } from "./public-types.js";
-import type { WorkflowToolResult } from "./render-result.js";
+import type { WorkflowRegisteredToolResult, WorkflowToolResult } from "./render-result.js";
 import type { ExtensionRuntime } from "./runtime.js";
 import type { WorkflowRunStatusSummary, WorkflowStatusAwaitingInput } from "./workflow-status-summary.js";
 import { getWorkflowStatusRenderRuns } from "./workflow-status-summary.js";
 
-function stringifyWorkflowToolResult(result: WorkflowToolResult): string {
+function stringifyWorkflowToolResult(result: WorkflowRegisteredToolResult): string {
 	return JSON.stringify(result, null, 2);
 }
 
@@ -212,8 +212,9 @@ function renderStageToolContent(result: Extract<WorkflowToolResult, { action: "s
 	return lines.join("\n");
 }
 
-export function renderWorkflowToolContent(result: WorkflowToolResult, args: WorkflowToolArgs): string {
+export function renderWorkflowToolContent(result: WorkflowRegisteredToolResult, args: WorkflowToolArgs): string {
 	if (args.format === "json") return stringifyWorkflowToolResult(result);
+	if ("code" in result && result.code === "WORKFLOW_TIMEOUT") return stringifyWorkflowToolResult(result);
 	switch (result.action) {
 		case "transcript":
 			return renderTranscriptToolContent(result);

package/dist/builtin/workflows/src/extension/workflow-tool-registration.ts

@@ -1,35 +1,127 @@
-import type { ExtensionAPI, PiExecuteContext, WorkflowToolArgs } from "./public-types.js";
+import type { ExtensionAPI, PiExecuteContext, PiToolOpts, WorkflowToolArgs } from "./public-types.js";
 import { renderCall } from "./render-call.js";
 import { dynamicTextRenderComponent } from "./render-component.js";
-import type { WorkflowToolResult } from "./render-result.js";
+import type { WorkflowRegisteredToolResult, WorkflowTimeoutResult, WorkflowToolResult } from "./render-result.js";
 import { renderResult } from "./render-result.js";
 import { workflowPolicyFromContext } from "./workflow-policy.js";
 import { DEFAULT_PROMPT_GUIDANCE, WORKFLOW_TOOL_DESCRIPTION } from "./workflow-prompts.js";
+import { raceWorkflowRequestAbort } from "./workflow-request-abort.js";
 import { WorkflowParametersSchema } from "./workflow-schema.js";
 import { renderWorkflowToolContent } from "./workflow-tool-content.js";
 
+interface WorkflowToolRegistrationOptions {
+	/** Internal fixture seam; production registrations always use the fixed default. */
+	readonly requestTimeoutMs?: number;
+}
+
+export type WorkflowToolRegistrar = Pick<ExtensionAPI, "registerTool">;
+
+export const WORKFLOW_TOOL_REQUEST_TIMEOUT_MS = 30_000;
+
+type WorkflowToolExecutor = (
+	args: WorkflowToolArgs,
+	ctx: PiExecuteContext,
+	signal?: AbortSignal,
+	onRunAccepted?: (runId: string) => void,
+) => Promise<WorkflowToolResult>;
+
+const MUTATING_WORKFLOW_ACTIONS = new Set<NonNullable<WorkflowToolArgs["action"]>>([
+	"reload",
+	"run",
+	"send",
+	"pause",
+	"resume",
+	"interrupt",
+	"quit",
+]);
+
+function workflowToolTimeoutResult(
+	args: WorkflowToolArgs,
+	timeoutMs: number,
+	runId: string | undefined,
+): WorkflowTimeoutResult {
+	const action = args.action ?? "run";
+	const prefix = `Workflow ${action} request timed out after ${timeoutMs}ms.`;
+	return {
+		action,
+		status: "failed",
+		code: "WORKFLOW_TIMEOUT",
+		timeoutMs,
+		...(runId === undefined ? {} : { runId }),
+		error: MUTATING_WORKFLOW_ACTIONS.has(action)
+			? `${prefix} The outcome is unknown. Inspect workflow status before retrying.`
+			: prefix,
+	};
+}
+
+async function executeWithWorkflowToolDeadline(
+	executeWorkflowTool: WorkflowToolExecutor,
+	params: WorkflowToolArgs,
+	ctx: PiExecuteContext,
+	callerSignal: AbortSignal | undefined,
+	timeoutMs: number,
+): Promise<WorkflowRegisteredToolResult> {
+	callerSignal?.throwIfAborted();
+	const deadlineController = new AbortController();
+	const operationSignal =
+		callerSignal === undefined
+			? deadlineController.signal
+			: AbortSignal.any([callerSignal, deadlineController.signal]);
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	let acceptedRunId: string | undefined;
+	const timeout = new Promise<WorkflowRegisteredToolResult>((resolve) => {
+		timer = setTimeout(() => {
+			const result = workflowToolTimeoutResult(params, timeoutMs, acceptedRunId);
+			resolve(result);
+			deadlineController.abort(new Error(result.error));
+		}, timeoutMs);
+	});
+	try {
+		return await raceWorkflowRequestAbort(
+			Promise.race([
+				executeWorkflowTool(params, ctx, operationSignal, (runId) => {
+					acceptedRunId = runId;
+				}),
+				timeout,
+			]),
+			callerSignal,
+		);
+	} finally {
+		if (timer !== undefined) clearTimeout(timer);
+	}
+}
+
 export function registerWorkflowTool(
-	pi: ExtensionAPI,
-	executeWorkflowTool: (args: WorkflowToolArgs, ctx: PiExecuteContext) => Promise<WorkflowToolResult>,
+	pi: WorkflowToolRegistrar,
+	executeWorkflowTool: WorkflowToolExecutor,
 	runWithLifecycleSuppressedForPolicy: <T>(
 		policy: ReturnType<typeof workflowPolicyFromContext>,
 		fn: () => Promise<T>,
 	) => Promise<T>,
-): void {
-	if (typeof pi.registerTool !== "function") return;
-	pi.registerTool<WorkflowToolArgs, WorkflowToolResult>({
+	options: WorkflowToolRegistrationOptions = {},
+): PiToolOpts<WorkflowToolArgs, WorkflowRegisteredToolResult> | undefined {
+	if (typeof pi.registerTool !== "function") return undefined;
+	const tool: PiToolOpts<WorkflowToolArgs, WorkflowRegisteredToolResult> = {
 		name: "workflow",
 		label: "workflow",
 		description: WORKFLOW_TOOL_DESCRIPTION,
 		parameters: WorkflowParametersSchema,
 		promptGuidelines: DEFAULT_PROMPT_GUIDANCE,
 		renderShell: "self",
-		execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => {
+		execute: async (_toolCallId, params, signal, _onUpdate, ctx) => {
 			const policy = workflowPolicyFromContext(ctx);
-			const details =
-				(params.action ?? "run") === "run"
-					? await runWithLifecycleSuppressedForPolicy(policy, () => executeWorkflowTool(params, ctx))
-					: await executeWorkflowTool(params, ctx);
+			const details = await executeWithWorkflowToolDeadline(
+				(actionParams, actionContext, operationSignal, onRunAccepted) =>
+					(actionParams.action ?? "run") === "run"
+						? runWithLifecycleSuppressedForPolicy(policy, () =>
+								executeWorkflowTool(actionParams, actionContext, operationSignal, onRunAccepted),
+							)
+						: executeWorkflowTool(actionParams, actionContext, operationSignal, onRunAccepted),
+				params,
+				ctx,
+				signal,
+				options.requestTimeoutMs ?? WORKFLOW_TOOL_REQUEST_TIMEOUT_MS,
+			);
 			return {
 				content: [{ type: "text", text: renderWorkflowToolContent(details, params) }],
 				details,
@@ -47,5 +139,7 @@ export function registerWorkflowTool(
 				}),
 			);
 		},
-	});
+	};
+	pi.registerTool(tool);
+	return tool;
 }

package/dist/builtin/workflows/src/extension/workflow-tool.ts

@@ -8,6 +8,7 @@ import type { ExtensionRuntime } from "./runtime.js";
 import { formatWorkflowResourceLoadWarning } from "./workflow-command-surfaces.js";
 import { workflowPolicyFromContext } from "./workflow-policy.js";
 import type { WorkflowReloadReport } from "./workflow-reload-report.js";
+import { raceWorkflowRequestAbort } from "./workflow-request-abort.js";
 import { buildWorkflowStatusListing, setWorkflowStatusRenderRuns } from "./workflow-status-summary.js";
 import { isWorkflowStageToolContext, resolveRunId, topLevelExpandedSnapshots } from "./workflow-targets.js";
 import { workflowGetResult } from "./workflow-tool-content.js";
@@ -66,10 +67,17 @@ export function makeExecuteWorkflowTool(
 	reloadWorkflowResources: () => Promise<WorkflowReloadReport | undefined> | undefined,
 	ensureWorkflowResourcesLoaded: () => Promise<void> | void = () => {},
 	sendDeps: WorkflowSendDeps = {},
-): (args: WorkflowToolArgs, ctx: PiExecuteContext) => Promise<WorkflowToolResult> {
+): (
+	args: WorkflowToolArgs,
+	ctx: PiExecuteContext,
+	signal?: AbortSignal,
+	onRunAccepted?: (runId: string) => void,
+) => Promise<WorkflowToolResult> {
 	return async function executeWorkflowTool(
 		args: WorkflowToolArgs,
 		ctx: PiExecuteContext,
+		signal?: AbortSignal,
+		onRunAccepted?: (runId: string) => void,
 	): Promise<WorkflowToolResult> {
 		const action = args.action ?? "run";
 		const runId = args.runId ?? "";
@@ -84,10 +92,12 @@ export function makeExecuteWorkflowTool(
 		}
 		const policy: WorkflowExecutionPolicy = workflowPolicyFromContext(ctx);
 		const getRuntime = (): ExtensionRuntime => (typeof runtime === "function" ? runtime(ctx) : runtime);
+		const awaitRequest = <T>(operation: Promise<T>): Promise<T> => raceWorkflowRequestAbort(operation, signal);
 		const ensureWorkflowResourcesVisible = async (): Promise<void> => {
 			try {
-				await ensureWorkflowResourcesLoaded();
+				await awaitRequest(Promise.resolve(ensureWorkflowResourcesLoaded()));
 			} catch (error) {
+				if (signal?.aborted === true) throw signal.reason ?? error;
 				ctx.ui?.notify?.(formatWorkflowResourceLoadWarning(error), "warning");
 			}
 		};
@@ -111,13 +121,13 @@ export function makeExecuteWorkflowTool(
 			case "list":
 			case "inputs": {
 				await ensureWorkflowResourcesVisible();
-				return getRuntime().dispatch(args, { policy });
+				return awaitRequest(getRuntime().dispatch(args, { policy, signal }));
 			}
 			case "run": {
 				await ensureWorkflowResourcesVisible();
 				// A tool launch is the agent's own action: it is attributed as such and
 				// the tool result already reports the run, so it raises no chat notice.
-				return getRuntime().dispatch(args, { policy, origin: "agent" });
+				return awaitRequest(getRuntime().dispatch(args, { policy, origin: "agent", signal, onRunAccepted }));
 			}
 			case "status": {
 				const target = args.runId;
@@ -127,7 +137,7 @@ export function makeExecuteWorkflowTool(
 						return { action: "statusDetail", runId: target, error: resolved.message };
 					}
 					if (resolved.kind === "not_found") {
-						const durable = await getRuntime().inspectDurableWorkflow(target);
+						const durable = await awaitRequest(getRuntime().inspectDurableWorkflow(target));
 						return durable.kind === "found"
 							? { action: "statusDetail", runId: target, detail: durable.detail }
 							: { action: "statusDetail", runId: target, error: durable.message };
@@ -150,7 +160,7 @@ export function makeExecuteWorkflowTool(
 			case "stages":
 			case "stage":
 			case "transcript": {
-				const resolved = await resolveDurableInspectionSource(args, getRuntime());
+				const resolved = await awaitRequest(resolveDurableInspectionSource(args, getRuntime()));
 				if (resolved.kind === "error") return durableInspectionError(action, args.runId ?? "", resolved.message);
 				const source = resolved.kind === "durable" ? resolved.source : undefined;
 				if (action === "stages") return workflowStagesResult(args, source);
@@ -158,17 +168,17 @@ export function makeExecuteWorkflowTool(
 				return workflowTranscriptResult(args, source);
 			}
 			case "send":
-				return workflowSendAction(args, sendDeps);
+				return awaitRequest(workflowSendAction(args, sendDeps));
 			case "pause":
-				return workflowPauseAction(args);
+				return awaitRequest(workflowPauseAction(args));
 			case "reload":
-				return workflowReloadAction(args, { reloadWorkflowResources });
+				return awaitRequest(workflowReloadAction(args, { reloadWorkflowResources }));
 			case "quit":
-				return workflowQuitAction(args);
+				return awaitRequest(workflowQuitAction(args));
 			case "interrupt":
-				return workflowInterruptAction(args);
+				return awaitRequest(workflowInterruptAction(args));
 			case "resume":
-				return workflowResumeAction(args, { getRuntime, policy, ensureWorkflowResourcesLoaded });
+				return awaitRequest(workflowResumeAction(args, { getRuntime, policy, ensureWorkflowResourcesLoaded }));
 			default: {
 				const _exhaustive: never = action;
 				throw new Error(`Workflow extension: unknown action "${_exhaustive}"`);

package/dist/builtin/workflows/src/tui/widget.ts

@@ -6,7 +6,7 @@
  *    badges (`✓ n  ● n  ○ n  ✗ n`) in the title.
  *  - One compact rounded card per run:
  *      title: `<status glyph>  <full id>`
- *      row 1: `<name> · <dim mode · progress · duration>`
+ *      row 1: `<name> · <dim mode · progress · live tool nodes · duration>`
  *  - Collapsed single-line form below 80 cells:
  *      `▾  N background · X ●` in dim+warning.
  *
@@ -215,6 +215,17 @@ function elapsedLabel(run: RunSnapshot, now: number): string {
 	return "";
 }
 
+function activeToolNodes(run: RunSnapshot): NonNullable<RunSnapshot["toolNodes"]> {
+	return (run.toolNodes ?? []).filter((node) => node.status === "pending" || node.status === "running");
+}
+
+function activeToolLabel(run: RunSnapshot): string | undefined {
+	const nodes = activeToolNodes(run);
+	if (nodes.length === 0) return undefined;
+	const details = nodes.map((node) => `${node.name} · ${node.status}`).join(", ");
+	return nodes.length === 1 ? details : `${nodes.length} tools · ${details}`;
+}
+
 function metaLine(run: RunSnapshot, now: number): string {
 	if (run.endedAt !== undefined) {
 		return elapsedLabel(run, now);
@@ -224,6 +235,8 @@ function metaLine(run: RunSnapshot, now: number): string {
 	const parts: string[] = [modeLabel(run)];
 	const prog = progressLabel(run);
 	if (prog) parts.push(prog);
+	const tools = activeToolLabel(run);
+	if (tools) parts.push(tools);
 	const elapsed = elapsedLabel(run, now);
 	if (elapsed) parts.push(elapsed);
 	return parts.join(" · ");
@@ -306,7 +319,7 @@ function plainRunLines(run: RunSnapshot, now: number, allRuns: readonly RunSnaps
 // Collapsed (< 80 cell) form
 // ---------------------------------------------------------------------------
 
-function themedCollapsed(counts: RunCounts, theme: GraphTheme): string {
+function themedCollapsed(counts: RunCounts, activeTools: number, theme: GraphTheme): string {
 	const mauve = hexToAnsi(theme.mauve);
 	const dim = hexToAnsi(theme.dim);
 	const muted = hexToAnsi(theme.textMuted);
@@ -316,15 +329,18 @@ function themedCollapsed(counts: RunCounts, theme: GraphTheme): string {
 	const paused = counts.paused > 0 ? `${dim} · ${RESET}${warning}${counts.paused} ❚❚${RESET}` : "";
 	const quit = counts.quit > 0 ? `${dim} · ${RESET}${warning}${counts.quit} quit${RESET}` : "";
 	const blocked = counts.blocked > 0 ? `${dim} · ${RESET}${warning}${counts.blocked} ↑${RESET}` : "";
-	return ` ${mauve}▾${RESET}  ${muted}${total} background${RESET}${dim} · ${RESET}${warning}${active} ●${RESET}${paused}${quit}${blocked}`;
+	const tools =
+		activeTools > 0 ? `${dim} · ${RESET}${warning}${activeTools} tool${activeTools === 1 ? "" : "s"}${RESET}` : "";
+	return ` ${mauve}▾${RESET}  ${muted}${total} background${RESET}${dim} · ${RESET}${warning}${active} ●${RESET}${paused}${quit}${blocked}${tools}`;
 }
 
-function plainCollapsed(counts: RunCounts): string {
+function plainCollapsed(counts: RunCounts, activeTools: number): string {
 	const total = counts.active + counts.paused + counts.quit + counts.done + counts.blocked + counts.failed;
 	const paused = counts.paused > 0 ? ` · ${counts.paused} ❚❚` : "";
 	const quit = counts.quit > 0 ? ` · ${counts.quit} quit` : "";
 	const blocked = counts.blocked > 0 ? ` · ${counts.blocked} ↑` : "";
-	return ` ▾  ${total} background · ${counts.active} ●${paused}${quit}${blocked}`;
+	const tools = activeTools > 0 ? ` · ${activeTools} tool${activeTools === 1 ? "" : "s"}` : "";
+	return ` ▾  ${total} background · ${counts.active} ●${paused}${quit}${blocked}${tools}`;
 }
 
 // ---------------------------------------------------------------------------
@@ -369,10 +385,13 @@ export function buildThemedWidgetLines(
 
 	const themed = piTheme !== undefined;
 	const graphTheme = deriveGraphTheme({});
+	const activeTools = display.filter(isActive).reduce((total, run) => total + activeToolNodes(run).length, 0);
 
 	// Collapsed single-line form for narrow terminals.
 	if (width < COLLAPSED_BREAKPOINT_COLS) {
-		return [themed ? themedCollapsed(visibleCounts, graphTheme) : plainCollapsed(visibleCounts)];
+		return [
+			themed ? themedCollapsed(visibleCounts, activeTools, graphTheme) : plainCollapsed(visibleCounts, activeTools),
+		];
 	}
 
 	const total = display.length;

package/dist/core/agent-session-auto-compaction.js

@@ -287,17 +287,17 @@ export function _schedulePostAutoCompactionContinuationProbe(_reason, willRetry)
     pending = new Promise((resolve) => {
         setTimeout(() => {
             void (async () => {
-                const restoreIfOwned = async () => {
+                const settleIfOwned = async () => {
                     if (fallbackScopeGeneration === undefined ||
                         this._fallbackOriginGeneration !== fallbackScopeGeneration ||
-                        typeof this._restoreFallbackModel !== "function")
+                        typeof this._settleFallbackModelScope !== "function")
                         return;
                     try {
-                        await this._restoreFallbackModel();
+                        await this._settleFallbackModelScope();
                     }
                     catch {
-                        // A listener must not strand the continuation waiter. The model
-                        // state was already restored before lifecycle notifications ran.
+                        // A listener must not strand the continuation waiter. The fallback
+                        // state was already settled before lifecycle notifications ran.
                     }
                 };
                 try {
@@ -314,12 +314,12 @@ export function _schedulePostAutoCompactionContinuationProbe(_reason, willRetry)
                         if (this.isCompacting || this.isStreaming)
                             return;
                         if (!this.agent.hasQueuedMessages()) {
-                            await restoreIfOwned();
+                            await settleIfOwned();
                             return;
                         }
-                        // A queued message starts the next user turn. Restore before
-                        // Agent snapshots the next request's model.
-                        await restoreIfOwned();
+                        // A queued message starts the next user turn. Settle before Agent
+                        // snapshots the next request's model.
+                        await settleIfOwned();
                     }
                     if (this._pendingPostCompactionContinuation !== pending)
                         return;
@@ -329,7 +329,7 @@ export function _schedulePostAutoCompactionContinuationProbe(_reason, willRetry)
                     this._pendingPostCompactionContinuation = undefined;
                     await this._resumeAfterAutoCompaction();
                     if (willRetry && this._pendingPostCompactionContinuation === undefined) {
-                        await restoreIfOwned();
+                        await settleIfOwned();
                     }
                 }
                 finally {