pi-squire 0.14.0 → 0.16.0

package/src/child-tasks.ts

@@ -0,0 +1,221 @@
+// The direct parent's durable task facts and processing inbox. Not a tree
+// index: the shared registry can publish these facts without owning answers.
+import { join } from "node:path";
+import {
+	type ContextEvent,
+	type ContextEventResult,
+	type ExtensionAPI,
+	type ExtensionContext,
+	getAgentDir,
+} from "@earendil-works/pi-coding-agent";
+import { readState, writeState } from "./local-state.ts";
+import type { Recorded } from "./result-types.ts";
+import type { MessageDetails } from "./results.ts";
+
+export type ChildOutcome = {
+	key: string;
+	content: string;
+	details: MessageDetails;
+	/** Root display was queued; processing still waits for a model request/settle. */
+	delivered?: boolean;
+};
+type State = { records: Recorded[]; outcomes: ChildOutcome[]; paused?: boolean };
+export function readChildRecords(session: string): Recorded[] {
+	const path = join(getAgentDir(), "squire", "child-tasks", `${encodeURIComponent(session)}.json`);
+	const state = readState<State>(path);
+	if (state !== undefined && (!state || !Array.isArray(state.records) || !Array.isArray(state.outcomes)))
+		throw new Error(`invalid child task record for ${session}`);
+	return state?.records ?? [];
+}
+export class ChildTasks {
+	path: string | undefined;
+	outcomes: ChildOutcome[] = [];
+	observed = new Set<string>();
+	failed = false;
+	unreadable = false;
+	restoreFailure: string | undefined;
+	paused = false;
+
+	blockRestore(error: unknown): void {
+		this.restoreFailure ??= String(error);
+		this.failed = true;
+	}
+
+	restore(session: string): Recorded[] {
+		this.path = join(getAgentDir(), "squire", "child-tasks", `${encodeURIComponent(session)}.json`);
+		this.outcomes = [];
+		this.paused = false;
+		this.observed.clear();
+		this.failed = false;
+		this.unreadable = false;
+		this.restoreFailure = undefined;
+		try {
+			const state = readState<State>(this.path);
+			if (state !== undefined && (!state || !Array.isArray(state.records) || !Array.isArray(state.outcomes)))
+				throw new Error("invalid child task record: expected records and outcomes arrays");
+			if (state?.paused !== undefined && typeof state.paused !== "boolean") throw new Error("invalid root stop state");
+			this.paused = state?.paused === true;
+			this.outcomes = state?.outcomes ?? [];
+			return state?.records ?? [];
+		} catch (error) {
+			this.failed = true;
+			this.unreadable = true;
+			throw error;
+		}
+	}
+
+	save(records: Recorded[]): void {
+		try {
+			if (this.restoreFailure)
+				throw new Error(`child task restoration failed: ${this.restoreFailure}; repair storage and reopen`);
+			if (this.unreadable) throw new Error("child tasks were unreadable; repair storage and reload before continuing");
+			if (!this.path) throw new Error("child task state has not been restored");
+			writeState(this.path, { records, outcomes: this.outcomes, paused: this.paused } satisfies State);
+			this.failed = false;
+		} catch (error) {
+			this.failed = true;
+			throw error;
+		}
+	}
+
+	storageProblem(): string | undefined {
+		if (this.unreadable) return "child tasks were unreadable; repair storage and reload before launching";
+		if (this.restoreFailure)
+			return `child task restoration failed: ${this.restoreFailure}; repair storage and reopen before launching`;
+		if (this.failed) return "child task storage failed; repair storage and reload before launching";
+		if (!this.path) return "child task storage has not been restored";
+		return undefined;
+	}
+
+	delivered(key: string): void {
+		for (const outcome of this.outcomes) if (outcome.key === key) outcome.delivered = true;
+	}
+
+	wakeAllowed(coordinator: boolean): boolean {
+		return coordinator || !this.paused;
+	}
+
+	replay(pi: ExtensionAPI, coordinator: boolean): void {
+		if (!this.wakeAllowed(coordinator)) return;
+		let wake = false;
+		for (const outcome of this.outcomes) {
+			if (!coordinator && outcome.delivered) {
+				wake = true;
+				continue;
+			}
+			pi.sendMessage(
+				{ customType: "delegate", content: outcome.content, details: outcome.details, display: true },
+				{ triggerTurn: true, deliverAs: "steer" },
+			);
+			this.delivered(outcome.key);
+		}
+		if (wake)
+			pi.sendMessage(
+				{
+					customType: "delegate-recovery",
+					display: false,
+					content: "[delegate] Saved delegate outcomes still need processing. Continue with them before settling.",
+				},
+				{ triggerTurn: true, deliverAs: "steer" },
+			);
+	}
+
+	observe(): void {
+		this.observed = new Set(this.outcomes.map(({ key }) => key));
+	}
+
+	settled(records: Recorded[], stopped: boolean): void {
+		if (this.restoreFailure || this.unreadable) throw new Error(this.storageProblem());
+		if (stopped) return;
+		this.outcomes = this.outcomes.filter(({ key }) => !this.observed.has(key));
+		this.observed.clear();
+		this.save(records);
+	}
+
+	needsProcessing(): boolean {
+		return this.outcomes.some(({ key }) => !this.observed.has(key));
+	}
+
+	/** Each exact model request receives all unprocessed direct-child outcomes. */
+	context(event: ContextEvent): ContextEventResult | undefined {
+		this.paused = false;
+		this.observe();
+		const missing = this.outcomes.filter(
+			({ details }) =>
+				!event.messages.some(
+					(message) =>
+						message.role === "custom" &&
+						message.customType === "delegate" &&
+						(message.details as MessageDetails | undefined)?.id === details.id &&
+						(message.details as MessageDetails | undefined)?.kind === details.kind,
+				),
+		);
+		if (!missing.length) return;
+		return {
+			messages: [
+				...event.messages,
+				...missing.map(({ content, details }) => ({
+					role: "custom" as const,
+					customType: "delegate",
+					content,
+					details,
+					display: true,
+					timestamp: Date.now(),
+				})),
+			],
+		};
+	}
+
+	register(
+		pi: ExtensionAPI,
+		records: () => Recorded[],
+		context: () => ExtensionContext | undefined,
+		coordinator: () => boolean = () => false,
+	): void {
+		let stopped = false;
+		pi.on("context", (event) => this.context(event));
+		pi.on("agent_end", (event, ctx) => {
+			const last = event.messages.findLast((message) => message.role === "assistant");
+			stopped = last?.stopReason === "aborted" || ctx.signal?.aborted === true;
+			if (stopped && !coordinator()) {
+				this.paused = true;
+				try {
+					this.save(records());
+				} catch (error) {
+					ctx.ui.notify(
+						`delegate: could not persist root user stop: ${String(error)}; completion is blocked.`,
+						"error",
+					);
+				}
+			}
+		});
+		pi.on("agent_before_settle", () => {
+			if (stopped || this.failed || !this.wakeAllowed(coordinator()) || !this.needsProcessing()) return;
+			// A bare continue can be rejected when the transcript ends with an
+			// assistant. Supply runnable context; context() supplies the outcomes.
+			return {
+				continue: true,
+				entries: [
+					{
+						type: "custom_message",
+						customType: "delegate",
+						content: coordinator()
+							? "[delegate] Child outcomes arrived after the last model request. Process them before your final task report."
+							: "[delegate] Delegate outcomes arrived after the last model request. Process them before finishing this response.",
+						display: true,
+					},
+				],
+			};
+		});
+		pi.on("agent_settled", () => {
+			try {
+				this.settled(records(), stopped);
+			} catch (error) {
+				context()?.ui.notify(
+					`delegate: could not persist child-result processing: ${String(error)}; completion is blocked.`,
+					"error",
+				);
+			}
+		});
+	}
+}

package/src/child.ts

@@ -7,21 +7,27 @@
 // exits too (the parent gets the error and the session file stays); only a
 // run the user stopped never exits. A run that ends on a usage limit first
 // moves to the agent's next fallback, from `PI_DELEGATE_FALLBACK`, and
-// continues there; it exits only when no fallback is left. The user
+// continues there; it exits only when no fallback is left. An entry that is
+// an alias resolves to one model through Pi's own `--model` resolver. The user
 // taking over — typing here, or stopping a run — turns it off for the rest of
-// the session, with a notice; `/auto-exit` turns it back on. Modelled on
-// edxeth/pi-subagents' `auto-exit` (README "Child lifecycle", `cf6dbf4`).
+// the session, with a notice; `/auto-exit` turns it back on.
 //
 // It also takes over the parent's task request on `message:inbound` and sends
 // it as a user prompt, so the task starts through the same path as a typed
 // prompt, labelled `[delegate]`. Pi 1.2.0 already prepares the system prompt
 // for custom-message runs (earendil-works/pi#5581); this takeover remains the
-// package's pinned startup delivery path. The provider still arms the
-// automatic answer for a request a listener took over.
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-
+// package's pinned startup delivery path. task-replies.ts owns the answer.
+import type { Api, Model } from "@earendil-works/pi-ai";
+import {
+	type ExtensionAPI,
+	type ExtensionContext,
+	type ModelRegistry,
+	type ModelRuntime,
+	resolveCliModel,
+} from "@earendil-works/pi-coding-agent";
+import { type Identity, writeIdentity } from "./identity.ts";
 import { activeMark, classify, type Response, recordLimit } from "./limits.ts";
-import { STATUS_KEY } from "./results.ts";
+import type { TaskReplies } from "./task-replies.ts";
 
 /** The launch variable that carries the parent's resolved setting. */
 export const AUTO_EXIT_ENV = "PI_DELEGATE_AUTO_EXIT";
@@ -36,8 +42,6 @@ const ON_NOTICE = "delegate: auto-exit is on; this delegate closes after its nex
 
 type Message = { role?: string; stopReason?: unknown; errorMessage?: unknown; provider?: unknown; model?: unknown };
 
-type Inbound = { envelope?: { from?: unknown; kind?: unknown; body?: unknown }; handled?: boolean };
-
 /** A run that ended on a usage-limit error leaves a mark for every Pi session. */
 function recordUsageLimit(last: Message, ctx: ExtensionContext, response?: Response): void {
 	const { provider, model, errorMessage } = last;
@@ -55,52 +59,75 @@ function recordUsageLimit(last: Message, ctx: ExtensionContext, response?: Respo
 	}
 }
 
-/** Switch to the first of `fallback` that is usable and not marked, taking each off the list; the one switched to, if any. */
-async function switchModel(pi: ExtensionAPI, ctx: ExtensionContext, fallback: string[]): Promise<string | undefined> {
+/**
+ * The one model a fallback entry names, as Pi's `--model` resolves it: an
+ * exact `provider/id`, or a bare id or alias such as `sonnet`. Undefined when
+ * the registry has no such model; a custom model id Pi would make up for an
+ * unknown one is not used.
+ */
+function resolveEntry(registry: ModelRegistry, entry: string): Model<Api> | undefined {
+	// The resolver reads only these two from the runtime; the registry is the extension's view of it.
+	const runtime = {
+		getModels: () => registry.getAll(),
+		hasConfiguredAuth: (provider: string) =>
+			registry.getAll().some((model) => model.provider === provider && registry.hasConfiguredAuth(model)),
+	} as unknown as ModelRuntime;
+	try {
+		const { model } = resolveCliModel({ cliModel: entry, modelRuntime: runtime });
+		return model === undefined ? undefined : registry.find(model.provider, model.id);
+	} catch {
+		return undefined; // an entry Pi cannot read is passed over like one that names no model
+	}
+}
+
+/**
+ * Switch to the first model `fallback` names that is usable, not marked and
+ * not tried yet, taking each entry off the list in order. Returns the
+ * `provider/id` switched to, if any.
+ */
+async function switchModel(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	fallback: string[],
+	tried: Set<string>,
+): Promise<string | undefined> {
 	for (let next = fallback.shift(); next !== undefined; next = fallback.shift()) {
-		const slash = next.indexOf("/");
-		const model = ctx.modelRegistry.find(next.slice(0, slash), next.slice(slash + 1));
-		if (model === undefined || !ctx.modelRegistry.hasConfiguredAuth(model)) continue;
+		const model = resolveEntry(ctx.modelRegistry, next);
+		if (model === undefined) continue;
+		const name = `${model.provider}/${model.id}`;
+		if (tried.has(name)) continue;
+		tried.add(name);
+		if (!ctx.modelRegistry.hasConfiguredAuth(model)) continue;
 		if (activeMark(ctx.modelRegistry, model.provider, model.id) !== undefined) continue;
-		if (await pi.setModel(model)) return next;
+		if (await pi.setModel(model)) return name;
 	}
 	return undefined;
 }
 
-/** Take over the parent's task request and send it as a user prompt. */
-function registerTakeover(pi: ExtensionAPI, parent: string): void {
-	let current: ExtensionContext | undefined;
-	pi.on("session_start", async (_event, ctx) => {
-		current = ctx;
-	});
-	pi.events.on("message:inbound", (data) => {
-		const payload = data as Inbound;
-		const envelope = payload?.envelope;
-		if (payload.handled === true || envelope?.kind !== "request" || envelope.from !== parent) return;
-		payload.handled = true;
-		const text = `[delegate] Your task, from the session that started you (${parent}). Your final message this turn goes back to it automatically.\n\n${String(envelope.body ?? "")}`;
-		Promise.resolve(pi.sendUserMessage(text, { deliverAs: "steer" })).catch((err) =>
-			current?.ui.notify(`delegate: could not start the task: ${(err as Error).message}`, "error"),
-		);
-	});
-}
-
 /**
  * A usage limit or an unavailable endpoint moves the run to the next fallback
  * that is usable and not marked, and continues it in this session; each
- * fallback is tried once. Returns the setter for what ended the last run, as
+ * model is tried once, and never the one that just failed. Returns the setter
+ * for what ended the last run: the failed model as `provider/id`, and why as
  * `<provider/model> <what happened>`.
  */
-function registerFallback(pi: ExtensionAPI): (failure: string | undefined) => void {
-	/** The models still to move to on a usage limit, in order. */
-	const fallback = (process.env[FALLBACK_ENV] ?? "").split(",").filter((model) => model.includes("/"));
-	let failure: string | undefined;
+function registerFallback(pi: ExtensionAPI): (failure: Failure | undefined) => void {
+	/** The entries still to move to on a usage limit, in order: models or aliases. */
+	const fallback = (process.env[FALLBACK_ENV] ?? "")
+		.split(",")
+		.map((entry) => entry.trim())
+		.filter((entry) => entry !== "");
+	/** The models already switched to or failed on, as `provider/id`. */
+	const tried = new Set<string>();
+	let failure: Failure | undefined;
 	pi.on("agent_before_settle", async (_event, ctx) => {
 		const from = failure;
 		failure = undefined;
-		const next = from === undefined ? undefined : await switchModel(pi, ctx, fallback);
+		if (from === undefined) return;
+		tried.add(from.model);
+		const next = await switchModel(pi, ctx, fallback, tried);
 		if (next === undefined) return;
-		const content = `[delegate] ${from}, so this session switched to ${next}. Carry on with the task from where it stopped.`;
+		const content = `[delegate] ${from.reason}, so this session switched to ${next}. Carry on with the task from where it stopped.`;
 		return { continue: true, entries: [{ type: "custom_message", customType: "delegate", content, display: true }] };
 	});
 	return (value) => {
@@ -108,48 +135,66 @@ function registerFallback(pi: ExtensionAPI): (failure: string | undefined) => vo
 	};
 }
 
-/** Why a failed run should move to a fallback, as `<provider/model> <what happened>`; undefined when it should not. */
-function fallbackReason(last: Message | undefined): string | undefined {
+/** A failed run that should move to a fallback: the model it failed on, and why. */
+type Failure = { model: string; reason: string };
+
+/** Why a failed run should move to a fallback, with `reason` as `<provider/model> <what happened>`; undefined when it should not. */
+function fallbackReason(last: Message | undefined): Failure | undefined {
 	const error = last?.errorMessage;
 	if (typeof error !== "string") return undefined;
 	const model = `${String(last?.provider)}/${String(last?.model)}`;
-	if (classify(error) !== undefined) return `${model} hit a usage limit`;
+	if (classify(error) !== undefined) return { model, reason: `${model} hit a usage limit` };
 	// Pi has already retried an unavailable endpoint; it marks nothing, but this run moves on.
-	if (/unavailable/i.test(error)) return `${model} was unavailable (${error})`;
+	if (/unavailable/i.test(error)) return { model, reason: `${model} was unavailable (${error})` };
 	return undefined;
 }
 
 /** This delegate's footer icon, picked once per load. */
 const ICON = Math.random() < 0.5 ? "👦" : "👧";
 
-function showStatus(ctx: ExtensionContext, armed: boolean): void {
+function showStatus(ctx: ExtensionContext, armed: boolean, agent?: string): void {
 	const { theme } = ctx.ui;
-	const agent = process.env[AGENT_ENV];
 	const label = agent === undefined || agent === "" ? "delegate" : `${theme.fg("accent", agent)} delegate`;
 	ctx.ui.setStatus(
-		STATUS_KEY,
+		"delegate-self",
 		armed
 			? `${ICON} ${label} · auto-exit ${theme.fg("success", "on")}`
 			: `${ICON} ${label} · auto-exit ${theme.fg("dim", "off")}`,
 	);
 }
 
-export function registerChild(pi: ExtensionAPI, parent: string): void {
-	registerTakeover(pi, parent);
+function shutdownWhenActive(ctx: ExtensionContext, active: () => boolean): void {
+	setImmediate(() => {
+		if (active()) ctx.shutdown();
+	});
+}
+
+export function registerChild(
+	pi: ExtensionAPI,
+	replies: TaskReplies,
+	identity: () => Identity | undefined,
+	active: () => boolean = () => true,
+): void {
 	const setFailure = registerFallback(pi);
 
-	let armed = process.env[AUTO_EXIT_ENV] === "1";
+	let armed = false;
 	/** Whether the run that just ended finished without the user stopping it. */
 	let completed = false;
 
 	// Reload and session replacement clear extension statuses, then start again.
-	pi.on("session_start", async (_event, ctx) => showStatus(ctx, armed));
+	pi.on("session_start", async (_event, ctx) => {
+		const own = identity();
+		armed = own?.autoExit === true;
+		if (own) showStatus(ctx, armed, own.agent);
+	});
 
 	function disarm(ctx: ExtensionContext): void {
 		if (!armed) return;
 		armed = false;
+		const own = identity();
+		if (own) writeIdentity(ctx.sessionManager.getSessionId(), { ...own, autoExit: false });
 		ctx.ui.notify(OFF_NOTICE, "info");
-		showStatus(ctx, armed);
+		showStatus(ctx, armed, identity()?.agent);
 	}
 
 	// Typed text and RPC input are the user's; a prompt an extension sends is not.
@@ -170,11 +215,8 @@ export function registerChild(pi: ExtensionAPI, parent: string): void {
 	// call Pi 0.99.1 ends with an `error` message, and only the signal tells a
 	// stop from a real error. Either way it is the user taking over.
 	pi.on("agent_end", async (event, ctx) => {
-		let last: Message | undefined;
-		for (let i = event.messages.length - 1; i >= 0 && last === undefined; i--) {
-			const message = event.messages[i] as Message;
-			if (message?.role === "assistant") last = message;
-		}
+		const last = event.messages.findLast((message) => message.role === "assistant") as Message | undefined;
+		if (!identity()) return;
 		const stopped = last?.stopReason === "aborted" || ctx.signal?.aborted === true;
 		if (stopped) disarm(ctx);
 		if (!stopped && last?.stopReason === "error") recordUsageLimit(last, ctx, response);
@@ -184,19 +226,22 @@ export function registerChild(pi: ExtensionAPI, parent: string): void {
 	});
 
 	pi.on("agent_settled", async (_event, ctx) => {
-		const exit = armed && completed;
+		const exit = armed && completed && replies.handled();
 		completed = false;
 		if (!exit) return;
-		// Later settle handlers (the `message:*` provider's reply among them) run first.
-		setImmediate(() => ctx.shutdown());
+		// Task settlement and its synchronous reply write have succeeded.
+		shutdownWhenActive(ctx, active);
 	});
 
 	pi.registerCommand("auto-exit", {
 		description: "Close this delegate after its next normal completion",
 		handler: async (_args, ctx) => {
+			if (!identity()) return ctx.ui.notify("auto-exit is available inside a delegate session", "error");
 			armed = true;
+			const own = identity();
+			if (own) writeIdentity(ctx.sessionManager.getSessionId(), { ...own, autoExit: true });
 			ctx.ui.notify(ON_NOTICE, "info");
-			showStatus(ctx, armed);
+			showStatus(ctx, armed, identity()?.agent);
 		},
 	});
 }

package/src/completion-holds.ts

@@ -0,0 +1,104 @@
+// Process-local completion composition. Providers own hold readiness; Squire
+// advertises only its active exact-session runtime and never owns provider rows.
+import { randomUUID } from "node:crypto";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const KEY: symbol = Symbol.for("pi.completion-holds.v1");
+type Hold = { provider: string; ready: boolean };
+type Table = {
+	version: 1;
+	hosts: Map<string, Map<string, string>>;
+	holds: Map<string, Map<string, Hold>>;
+};
+const shared: Record<symbol, unknown> = globalThis as unknown as Record<symbol, unknown>;
+
+function table(create: boolean): Table | undefined {
+	const value: unknown = shared[KEY];
+	if (value === undefined) {
+		if (!create) return undefined;
+		const fresh: Table = { version: 1, hosts: new Map(), holds: new Map() };
+		shared[KEY] = fresh;
+		return fresh;
+	}
+	if (
+		typeof value !== "object" ||
+		value === null ||
+		!("version" in value) ||
+		value.version !== 1 ||
+		!("hosts" in value) ||
+		!(value.hosts instanceof Map) ||
+		!("holds" in value) ||
+		!(value.holds instanceof Map)
+	)
+		throw new Error("invalid pi.completion-holds.v1 table; completion is blocked");
+	return value as Table;
+}
+
+function validHosts(hosts: unknown): hosts is Map<string, string> {
+	return (
+		hosts instanceof Map &&
+		[...hosts].every(
+			([name, runtime]) => typeof name === "string" && !!name && typeof runtime === "string" && !!runtime,
+		)
+	);
+}
+
+/** Missing table/no holds preserves normal completion; malformed data refuses. */
+export function externalHoldsReady(sessionId: string): boolean {
+	try {
+		const current: Table | undefined = table(false);
+		if (!current) return true;
+		const hosts: unknown = current.hosts.get(sessionId);
+		if (hosts !== undefined && !validHosts(hosts)) return false;
+		const holds: Map<string, Hold> | undefined = current.holds.get(sessionId);
+		if (holds === undefined) return true;
+		if (!(holds instanceof Map)) return false;
+		for (const [id, hold] of holds) {
+			if (
+				typeof id !== "string" ||
+				!id ||
+				typeof hold !== "object" ||
+				hold === null ||
+				typeof hold.provider !== "string" ||
+				!hold.provider ||
+				hold.ready !== true
+			)
+				return false;
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function removeHost(sessionId: string, token: string): void {
+	// Clean our own token even if another field/version has become malformed.
+	const value: unknown = shared[KEY];
+	if (typeof value !== "object" || value === null || !("hosts" in value) || !(value.hosts instanceof Map)) return;
+	const hosts: unknown = value.hosts.get(sessionId);
+	if (!(hosts instanceof Map) || hosts.get("pi-squire") !== token) return;
+	hosts.delete("pi-squire");
+	if (hosts.size === 0) value.hosts.delete(sessionId);
+}
+
+/** Call with ownedAPI: a losing duplicate runtime must never advertise support. */
+export function registerCompletionHost(pi: ExtensionAPI): () => boolean {
+	const token: string = randomUUID();
+	let sessionId: string | undefined;
+	pi.on("session_start", (_event, ctx) => {
+		if (sessionId !== undefined) removeHost(sessionId, token);
+		sessionId = ctx.sessionManager.getSessionId();
+		const current: Table | undefined = table(true);
+		if (!current) throw new Error("completion hold table is unavailable");
+		const saved: Map<string, string> | undefined = current.hosts.get(sessionId);
+		if (saved !== undefined && !validHosts(saved)) throw new Error("invalid completion hold hosts");
+		const hosts: Map<string, string> = saved ?? new Map();
+		hosts.set("pi-squire", token);
+		current.hosts.set(sessionId, hosts);
+	});
+	pi.on("session_shutdown", () => {
+		if (sessionId !== undefined) removeHost(sessionId, token);
+		sessionId = undefined;
+	});
+	return (): boolean => sessionId !== undefined && externalHoldsReady(sessionId);
+}