pi-roundtable 0.22.0 → 0.22.2

package/src/core/modules/skills/skill-store.ts

@@ -70,6 +70,11 @@ export class SkillStore {
 	readonly #skills = new Map<string, SkillEntry>();
 	readonly #groups = new Map<string, SkillGroup>();
 	readonly #carried = new Map<string, string[]>();
+	/**
+	 * The tail of the mutations, which run one at a time: each checks the maps, writes, then
+	 * updates the maps from what it committed, and none may interleave with another.
+	 */
+	#queue: Promise<unknown> = Promise.resolve();
 
 	readonly #guild: string;
 
@@ -152,6 +157,12 @@ export class SkillStore {
 			]);
 	}
 
+	#serial<T>(write: () => Promise<T>): Promise<T> {
+		const run = this.#queue.then(write);
+		this.#queue = run.catch(() => undefined);
+		return run;
+	}
+
 	skills(): SkillEntry[] {
 		return [...this.#skills.values()].sort((a, b) =>
 			a.name.localeCompare(b.name),
@@ -189,19 +200,29 @@ export class SkillStore {
 	async addLinked(
 		entries: readonly { name: string; repo: string; path: string }[],
 	): Promise<void> {
-		const taken = entries.filter((entry) => this.#skills.has(entry.name));
-		if (taken.length > 0)
-			throw new AgentError(
-				`Already registered: ${taken.map((entry) => entry.name).join(", ")}. Nothing was linked.`,
-			);
-		await this.#sql.begin(async (tx) => {
+		return this.#serial(async () => {
+			const taken = entries.filter((entry) => this.#skills.has(entry.name));
+			const refuse = (names: string[]) =>
+				new AgentError(
+					`Already registered: ${names.join(", ")}. Nothing was linked.`,
+				);
+			if (taken.length > 0) throw refuse(taken.map((entry) => entry.name));
+			try {
+				await this.#sql.begin(async (tx) => {
+					for (const entry of entries)
+						await tx`
+							INSERT INTO skills (name, kind, repo, path)
+							VALUES (${entry.name}, 'linked', ${entry.repo}, ${entry.path})`;
+				});
+			} catch (error) {
+				// A row the maps do not hold, such as a duplicate within `entries`.
+				if (isUniqueViolation(error))
+					throw refuse(entries.map((entry) => entry.name));
+				throw error;
+			}
 			for (const entry of entries)
-				await tx`
-					INSERT INTO skills (name, kind, repo, path)
-					VALUES (${entry.name}, 'linked', ${entry.repo}, ${entry.path})`;
+				this.#skills.set(entry.name, { kind: "linked", ...entry });
 		});
-		for (const entry of entries)
-			this.#skills.set(entry.name, { kind: "linked", ...entry });
 	}
 
 	async addWritten(skill: {
@@ -209,12 +230,14 @@ export class SkillStore {
 		description: string;
 		body: string;
 	}): Promise<void> {
-		if (this.#skills.has(skill.name))
-			throw new AgentError(`A skill named "${skill.name}" already exists.`);
-		await this.#sql`
-			INSERT INTO skills (name, kind, description, body)
-			VALUES (${skill.name}, 'written', ${skill.description}, ${skill.body})`;
-		this.#skills.set(skill.name, { kind: "written", ...skill });
+		return this.#serial(async () => {
+			if (this.#skills.has(skill.name))
+				throw new AgentError(`A skill named "${skill.name}" already exists.`);
+			await this.#sql`
+				INSERT INTO skills (name, kind, description, body)
+				VALUES (${skill.name}, 'written', ${skill.description}, ${skill.body})`;
+			this.#skills.set(skill.name, { kind: "written", ...skill });
+		});
 	}
 
 	async updateWritten(skill: {
@@ -222,54 +245,84 @@ export class SkillStore {
 		description: string;
 		body: string;
 	}): Promise<void> {
-		await this.#sql`
-			UPDATE skills SET description = ${skill.description}, body = ${skill.body},
-				updated_at = now()
-			WHERE name = ${skill.name} AND kind = 'written'`;
-		this.#skills.set(skill.name, { kind: "written", ...skill });
+		return this.#serial(async () => {
+			await this.#sql`
+				UPDATE skills SET description = ${skill.description}, body = ${skill.body},
+					updated_at = now()
+				WHERE name = ${skill.name} AND kind = 'written'`;
+			this.#skills.set(skill.name, { kind: "written", ...skill });
+		});
 	}
 
 	/** Removes a skill and detaches it from every agent and group. */
 	async remove(name: string): Promise<Detached> {
-		const agents = this.carriers(name);
-		const groups = this.groups().filter((group) => group.skills.includes(name));
-		await this.#sql.begin(async (tx) => {
-			await tx`DELETE FROM skills WHERE name = ${name}`;
-			await tx`DELETE FROM agent_skills WHERE guild_id = ${this.#guild} AND skill = ${name}`;
+		return this.#serial(async () => {
+			const agents = this.carriers(name);
+			const groups = this.groups().filter((group) =>
+				group.skills.includes(name),
+			);
+			await this.#sql.begin(async (tx) => {
+				await tx`DELETE FROM skills WHERE name = ${name}`;
+				await tx`DELETE FROM agent_skills WHERE guild_id = ${this.#guild} AND skill = ${name}`;
+				for (const group of groups)
+					await tx`
+						UPDATE skill_groups
+						SET skills = ${group.skills.filter((s) => s !== name).join(",")}
+						WHERE name = ${group.name}`;
+			});
+			// The maps follow the transaction; reloading them all here would drop a write that
+			// committed after its SELECT.
+			this.#skills.delete(name);
+			for (const agent of agents) {
+				const left = this.carriedBy(agent).filter((s) => s !== name);
+				if (left.length > 0) this.#carried.set(agent, left);
+				else this.#carried.delete(agent);
+			}
 			for (const group of groups)
-				await tx`
-					UPDATE skill_groups
-					SET skills = ${group.skills.filter((s) => s !== name).join(",")}
-					WHERE name = ${group.name}`;
+				this.#groups.set(group.name, {
+					...group,
+					skills: group.skills.filter((s) => s !== name),
+				});
+			return { agents, groups: groups.map((group) => group.name) };
 		});
-		await this.#reload();
-		return { agents, groups: groups.map((group) => group.name) };
 	}
 
 	async setGroup(group: SkillGroup): Promise<void> {
-		await this.#sql`
-			INSERT INTO skill_groups (name, description, skills)
-			VALUES (${group.name}, ${group.description}, ${group.skills.join(",")})
-			ON CONFLICT (name) DO UPDATE
-			SET description = EXCLUDED.description, skills = EXCLUDED.skills`;
-		this.#groups.set(group.name, { ...group, skills: [...group.skills] });
+		return this.#serial(async () => {
+			await this.#sql`
+				INSERT INTO skill_groups (name, description, skills)
+				VALUES (${group.name}, ${group.description}, ${group.skills.join(",")})
+				ON CONFLICT (name) DO UPDATE
+				SET description = EXCLUDED.description, skills = EXCLUDED.skills`;
+			this.#groups.set(group.name, { ...group, skills: [...group.skills] });
+		});
 	}
 
 	async removeGroup(name: string): Promise<void> {
-		await this.#sql`DELETE FROM skill_groups WHERE name = ${name}`;
-		this.#groups.delete(name);
+		return this.#serial(async () => {
+			await this.#sql`DELETE FROM skill_groups WHERE name = ${name}`;
+			this.#groups.delete(name);
+		});
 	}
 
 	/** Replaces the registered skills an agent carries. */
 	async setCarried(agent: string, skills: readonly string[]): Promise<void> {
 		// pi-lens-ignore: no-sort-without-comparator — skill names sort by code unit, the same order on every machine
 		const sorted = [...new Set(skills)].sort();
-		await this.#sql.begin(async (tx) => {
-			await tx`DELETE FROM agent_skills WHERE guild_id = ${this.#guild} AND agent = ${agent}`;
-			for (const skill of sorted)
-				await tx`INSERT INTO agent_skills (guild_id, agent, skill) VALUES (${this.#guild}, ${agent}, ${skill})`;
+		return this.#serial(async () => {
+			await this.#sql.begin(async (tx) => {
+				await tx`DELETE FROM agent_skills WHERE guild_id = ${this.#guild} AND agent = ${agent}`;
+				for (const skill of sorted)
+					await tx`INSERT INTO agent_skills (guild_id, agent, skill) VALUES (${this.#guild}, ${agent}, ${skill})`;
+			});
+			if (sorted.length > 0) this.#carried.set(agent, sorted);
+			else this.#carried.delete(agent);
 		});
-		if (sorted.length > 0) this.#carried.set(agent, sorted);
-		else this.#carried.delete(agent);
 	}
 }
+
+/** PostgreSQL's unique_violation, as Bun's driver reports it. */
+function isUniqueViolation(error: unknown): boolean {
+	const fields = error as { errno?: unknown; code?: unknown } | null;
+	return fields?.errno === "23505" || fields?.code === "23505";
+}

package/src/core/presentation/failure-notice.ts

@@ -0,0 +1,13 @@
+import { TurnTimeoutError } from "../domain/turn-timeout.ts";
+import { messages } from "../i18n/index.ts";
+
+/** What a failed turn posts: the stopped notice for a stop, the reason for a time limit, else the failure notice. */
+export function failureNotice(result: {
+	error: Error;
+	stopped?: true;
+}): string {
+	if (result.stopped) return messages().stoppedNotice;
+	if (result.error instanceof TurnTimeoutError)
+		return messages().turnTimedOutNotice(result.error.timeout);
+	return messages().failureNotice;
+}

package/src/core/routing/conversation-turns.ts

@@ -10,10 +10,10 @@ import type { TurnResult } from "../domain/conversation.ts";
 import type { TurnConversation } from "../domain/ports.ts";
 import type { TurnProgress } from "../domain/progress.ts";
 import { HostStoppingError, PluginError } from "../errors.ts";
-import { messages } from "../i18n/index.ts";
 import { SYSTEM_PRINCIPAL } from "../identity/principal-store.ts";
 import type { Logger } from "../log.ts";
 import type { EventSink } from "../plugin.ts";
+import { failureNotice } from "../presentation/failure-notice.ts";
 import { splitReply } from "../presentation/reply-splitter.ts";
 import { thinkingLine } from "../presentation/thinking-line.ts";
 import { withReplyFiles } from "../reply-files.ts";
@@ -239,12 +239,7 @@ export function conversationTurns(
 
 /** The default post: the answer with its thinking line, or the failure or stopped notice. */
 function replyOf(result: TurnResult) {
-	if (!result.ok)
-		return {
-			chunks: [
-				result.stopped ? messages().stoppedNotice : messages().failureNotice,
-			],
-		};
+	if (!result.ok) return { chunks: [failureNotice(result)] };
 	const thinking = result.thinking ? thinkingLine(result.thinking) : undefined;
 	return {
 		...(thinking ? { thinking } : {}),

package/src/core/runtime/pi-agent-runtime.ts

@@ -48,7 +48,8 @@ import { promptImages, SteerableRun } from "./steerable-run.ts";
 import { thinkingLevel } from "./thinking-level.ts";
 import { runningCalls } from "./tool-call-scope.ts";
 import { transcriptOf, turnAnswer, unspokenTurn } from "./turn-answer.ts";
-import { runtimeTurnBudget, type TurnBudget } from "./turn-budget.ts";
+import type { TurnBudget } from "./turn-budget.ts";
+import { promptFailed, turnLimits } from "./turn-limits.ts";
 import { progressReporter } from "./turn-progress.ts";
 import { wrapUpTurn } from "./turn-wrapup.ts";
 import { workerReport } from "./worker-task.ts";
@@ -240,6 +241,10 @@ export class PiAgentRuntime implements AgentRuntime {
 		const interim = interimPoster(request, this.#options);
 		// The caller's live view: the text as it streams and each tool, never the thinking.
 		const slot = this.#sessions.slot(key);
+		// Its time limit, not counting time waiting on the owner's cards, follows what it does to say why it fired.
+		const limits = turnLimits(this.#options, slot, request.channel, () =>
+			guard.abort(),
+		);
 		const progress = request.progress
 			? progressReporter(request.progress, {
 					refusalOf: (id) => slot.refusalOf(id),
@@ -247,6 +252,7 @@ export class PiAgentRuntime implements AgentRuntime {
 			: undefined;
 		const unsubscribe = session.subscribe((event) => {
 			progress?.observe(event);
+			limits.observe(event);
 			if (event.type === "tool_execution_start") {
 				toolCalls.push(event.toolName);
 				interim?.toolStart(event.toolName);
@@ -275,10 +281,7 @@ export class PiAgentRuntime implements AgentRuntime {
 				this.#sessions.drop(key, channelSession);
 			},
 		});
-		// Time spent waiting on the owner's cards does not count towards the timeout or the cap.
-		const budget = runtimeTurnBudget(this.#options, slot, request.channel, () =>
-			guard.abort(),
-		);
+		const { budget } = limits;
 		this.#budgets.set(key, budget);
 		const running = new SteerableRun(
 			session,
@@ -307,10 +310,7 @@ export class PiAgentRuntime implements AgentRuntime {
 		} catch (error) {
 			if (running.stopped)
 				return { ok: false, error: new AgentRunError(STOPPED), stopped: true };
-			return {
-				ok: false,
-				error: new AgentRunError(`prompt failed: ${String(error)}`),
-			};
+			return limits.failure() ?? promptFailed(error);
 		} finally {
 			this.#running.delete(key);
 			this.#budgets.delete(key);
@@ -335,7 +335,7 @@ export class PiAgentRuntime implements AgentRuntime {
 
 		if (running.stopped)
 			return { ok: false, error: new AgentRunError(STOPPED), stopped: true };
-		return turnAnswer(turnMessages, running.steered);
+		return limits.failure() ?? turnAnswer(turnMessages, running.steered);
 	}
 
 	async steer(

package/src/core/runtime/prompt-slot.ts

@@ -99,6 +99,14 @@ export class PromptSlot {
 		};
 	}
 
+	/**
+	 * The turn's prompts as bound, an open card not counted as waiting; for a card the turn keeps
+	 * working beside, such as the one its time limit posts.
+	 */
+	get cards(): Prompts | undefined {
+		return this.#prompts;
+	}
+
 	/** Time this turn has spent with at least one card open. */
 	waitedMs(now = Date.now()): number {
 		return this.#waited + (this.#open > 0 ? now - this.#openSince : 0);

package/src/core/runtime/runtime-types.ts

@@ -89,17 +89,25 @@ export interface PiAgentRuntimeOptions {
 	/** The lowest tier that may use each tool; the default names the core's tools and leaves the rest to the owner. */
 	toolTiers?: ToolTiers;
 	/**
-	 * A run that works longer, not counting time spent waiting on the owner's cards, is aborted and
-	 * reported as failed; default 10 minutes. Each message steered into the turn gives it this
+	 * A run that works longer, not counting time spent waiting on the owner's cards, asks the owner
+	 * on a card whether to go on (see `turnTimeoutCardMs`), or, when it cannot show one, is aborted
+	 * and reported as failed with the reason; default 10 minutes. Each message steered into the turn gives it this
 	 * budget again from that moment, up to `turnMaxMs`.
 	 */
 	turnTimeoutMs?: number;
 	/**
 	 * The most one turn may work in all, however often it is steered, not counting time spent
 	 * waiting on the owner's cards; default three times `turnTimeoutMs`. Once it is reached the turn
-	 * takes no more steering (the message waits for the next turn) and is aborted as on its timeout.
+	 * takes no more steering (the message waits for the next turn) and asks or is aborted as on its
+	 * timeout; the owner's Continue moves the cap to a full `turnTimeoutMs` from then.
 	 */
 	turnMaxMs?: number;
+	/**
+	 * How long the card a turn posts when it reaches `turnTimeoutMs` or `turnMaxMs` waits for the
+	 * owner's Continue or Cancel, in wall time, while the turn keeps working; default 5 minutes. With
+	 * no answer by then the turn is aborted. A turn that cannot show a card is aborted at once.
+	 */
+	turnTimeoutCardMs?: number;
 	/**
 	 * How long a turn that was aborted, by its timeout or a stop, gets to end before its session is
 	 * disposed of and the turn is reported failed; default 15 seconds. A model that ignores the

package/src/core/runtime/turn-activity.ts

@@ -0,0 +1,42 @@
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+
+/** What a turn was doing at one moment: tools running and for how long, or compacting, or neither (the model). */
+export interface TurnActivity {
+	/** The tools running, the longest-running first, each with how long it has run. */
+	running: { tool: string; ms: number }[];
+	compacting: boolean;
+	/** Every tool called so far, by name, with how often, in the order first called. */
+	tools: [string, number][];
+}
+
+/** Follows a turn's events to say, when asked, what it is doing; never its inputs. */
+export interface ActivityTracker {
+	observe(event: AgentSessionEvent): void;
+	now(at: number): TurnActivity;
+}
+
+export function activityTracker(
+	clock: () => number = Date.now,
+): ActivityTracker {
+	const running = new Map<string, { tool: string; since: number }>();
+	const tools = new Map<string, number>();
+	let compacting = false;
+	return {
+		observe(event) {
+			if (event.type === "tool_execution_start") {
+				running.set(event.toolCallId, { tool: event.toolName, since: clock() });
+				tools.set(event.toolName, (tools.get(event.toolName) ?? 0) + 1);
+			} else if (event.type === "tool_execution_end") {
+				running.delete(event.toolCallId);
+			} else if (event.type === "compaction_start") compacting = true;
+			else if (event.type === "compaction_end") compacting = false;
+		},
+		now: (at) => ({
+			running: [...running.values()]
+				.sort((a, b) => a.since - b.since)
+				.map(({ tool, since }) => ({ tool, ms: at - since })),
+			compacting,
+			tools: [...tools],
+		}),
+	};
+}

package/src/core/runtime/turn-budget.ts

@@ -1,9 +1,16 @@
+import type {
+	TurnLimit,
+	TurnTimeout,
+	TurnTimeoutEnd,
+} from "../domain/turn-timeout.ts";
+import { messages } from "../i18n/index.ts";
+import type { Approval } from "../interactions/prompts.ts";
 import type { ChannelKey } from "../sessions.ts";
 import type { PromptSlot } from "./prompt-slot.ts";
 import type { PiAgentRuntimeOptions } from "./runtime-types.ts";
+import type { ActivityTracker } from "./turn-activity.ts";
 
-/** Which limit ended a turn: its budget since the start or the last steer, or its cap. */
-export type TurnLimit = "turn" | "turnMax";
+export type { TurnLimit };
 
 /** A turn's time limit, which a steered message renews up to a cap on the whole turn. */
 export interface TurnBudget {
@@ -12,8 +19,15 @@ export interface TurnBudget {
 	 * or undefined when the cap is reached and the turn takes no more steering.
 	 */
 	renew(): number | undefined;
-	/** Whether the turn has worked up to its cap. */
+	/**
+	 * After a limit fired, gives the turn its full budget again from now, as the owner's Continue
+	 * does; with `raiseCap` the cap moves too, to a full budget from now.
+	 */
+	extend(raiseCap: boolean): void;
+	/** Whether the turn has worked up to its cap, or a limit fired and was not extended. */
 	capped(): boolean;
+	/** The turn's work so far, not counting time the slot spent waiting on cards. */
+	workedMs(): number;
 	cancel(): void;
 }
 
@@ -43,13 +57,13 @@ const REARM_FLOOR_MS = 1_000;
 /**
  * Calls `expire` once the turn has worked `ms` since it started or since its last renewal, or
  * `maxMs` in all, whichever comes first; time the slot spent waiting on the owner's cards counts
- * towards neither. `expire` is told which limit fired.
+ * towards neither. `expire` is told which limit fired and its length.
  */
 export function turnBudget(
 	ms: number,
 	maxMs: number,
 	slot: Pick<PromptSlot, "waitedMs">,
-	expire: (limit: TurnLimit) => void,
+	expire: (limit: TurnLimit, limitMs: number) => void,
 	clock: BudgetClock = REAL_CLOCK,
 ): TurnBudget {
 	const started = clock.now();
@@ -57,7 +71,8 @@ export function turnBudget(
 		const now = clock.now();
 		return now - started - slot.waitedMs(now);
 	};
-	let deadline = Math.min(ms, maxMs);
+	let cap = maxMs;
+	let deadline = Math.min(ms, cap);
 	let cancelTimer: (() => void) | undefined;
 	let expired = false;
 	const arm = (delay: number) => {
@@ -65,47 +80,172 @@ export function turnBudget(
 			const left = deadline - worked();
 			if (left > 0) return arm(Math.max(left, REARM_FLOOR_MS));
 			expired = true;
-			expire(deadline >= maxMs ? "turnMax" : "turn");
+			if (deadline >= cap) expire("turnMax", cap);
+			else expire("turn", ms);
 		}, delay);
 	};
 	arm(deadline);
 	return {
 		renew() {
 			const now = worked();
-			if (expired || now >= maxMs) return undefined;
-			deadline = Math.min(now + ms, maxMs);
+			if (expired || now >= cap) return undefined;
+			deadline = Math.min(now + ms, cap);
 			cancelTimer?.();
 			arm(deadline - now);
 			return deadline - now;
 		},
-		capped: () => expired || worked() >= maxMs,
+		extend(raiseCap) {
+			const now = worked();
+			if (raiseCap) cap = Math.max(cap, now + ms);
+			deadline = Math.min(now + ms, cap);
+			expired = false;
+			cancelTimer?.();
+			arm(Math.max(deadline - now, REARM_FLOOR_MS));
+		},
+		capped: () => expired || worked() >= cap,
+		workedMs: worked,
 		cancel: () => cancelTimer?.(),
 	};
 }
 
+/** What the runtime's turn budget needs besides its options: what the turn is doing, and its clock. */
+export interface TurnBudgetSeams {
+	activity: Pick<ActivityTracker, "now">;
+	clock?: BudgetClock;
+}
+
 /**
  * The time limit of one turn of the built-in runtime, from its options: `turnTimeoutMs` (default
- * 10 minutes) renewed by each steer up to `turnMaxMs` (default three times that). It logs each
- * renewal and, when a limit fires, which one before it calls `abort`.
+ * 10 minutes) renewed by each steer up to `turnMaxMs` (default three times that). When a limit
+ * fires on a turn that can show the owner a card, the turn keeps working and a card asks whether
+ * to go on: Continue extends the limit that fired by a full budget from then, Cancel aborts, and
+ * no answer within `turnTimeoutCardMs` (default 5 minutes, wall time) aborts. The card closes
+ * when the turn ends first. Without a card the turn is aborted at once. `abort` is told why.
  */
 export function runtimeTurnBudget(
 	options: Pick<
 		PiAgentRuntimeOptions,
-		"turnTimeoutMs" | "turnMaxMs" | "logger"
+		"turnTimeoutMs" | "turnMaxMs" | "turnTimeoutCardMs" | "logger"
 	>,
-	slot: Pick<PromptSlot, "waitedMs">,
+	slot: Pick<PromptSlot, "waitedMs" | "cards">,
 	channel: ChannelKey,
-	abort: () => void,
+	abort: (timeout: TurnTimeout) => void,
+	seams: TurnBudgetSeams,
 ): TurnBudget {
 	const { logger, turnTimeoutMs = 10 * 60_000 } = options;
 	const turnMaxMs = options.turnMaxMs ?? 3 * turnTimeoutMs;
-	const budget = turnBudget(turnTimeoutMs, turnMaxMs, slot, (limit) => {
+	const graceMs = options.turnTimeoutCardMs ?? 5 * 60_000;
+	const clock = seams.clock ?? REAL_CLOCK;
+	/** Closes the open timeout card, if any, with the footer given. */
+	let closeCard: ((footer: string) => void) | undefined;
+	const reason = (
+		limit: TurnLimit,
+		limitMs: number,
+		end: TurnTimeoutEnd,
+	): TurnTimeout => ({
+		limit,
+		limitMs,
+		workedMs: budget.workedMs(),
+		...seams.activity.now(clock.now()),
+		graceMs,
+		end,
+	});
+	const stop = (timeout: TurnTimeout) => {
 		logger.warn(
-			{ channel, limit, turnTimeoutMs, turnMaxMs },
+			{
+				channel,
+				limit: timeout.limit,
+				turnTimeoutMs,
+				turnMaxMs,
+				workedMs: timeout.workedMs,
+				running: timeout.running,
+				compacting: timeout.compacting,
+				tools: timeout.tools,
+				end: timeout.end,
+			},
 			"turn timed out; aborting",
 		);
-		abort();
-	});
+		abort(timeout);
+	};
+	const budget = turnBudget(
+		turnTimeoutMs,
+		turnMaxMs,
+		slot,
+		(limit, limitMs) => {
+			const prompts = slot.cards;
+			if (!prompts) return stop(reason(limit, limitMs, "timeout"));
+			const m = messages();
+			const asked = reason(limit, limitMs, "timeout");
+			logger.info(
+				{
+					channel,
+					limit,
+					workedMs: asked.workedMs,
+					running: asked.running,
+				},
+				"turn reached its time limit; asking the owner",
+			);
+			const controller = new AbortController();
+			let open = true;
+			const settle = () => {
+				if (!open) return false;
+				open = false;
+				closeCard = undefined;
+				cancelGrace();
+				return true;
+			};
+			const cancelGrace = clock.schedule(() => {
+				if (!settle()) return;
+				const timeout = reason(limit, limitMs, "unanswered");
+				controller.abort(m.turnTimeoutUnanswered(timeout));
+				stop(timeout);
+			}, graceMs);
+			closeCard = (footer) => {
+				if (settle()) controller.abort(footer);
+			};
+			const answered = (approval: Approval) => {
+				if (!settle()) return;
+				if (approval === "approved") {
+					budget.extend(limit === "turnMax");
+					logger.info(
+						{ channel, limit, workedMs: budget.workedMs() },
+						"owner continued the turn past its time limit",
+					);
+				} else
+					stop(
+						reason(
+							limit,
+							limitMs,
+							approval === "declined" ? "cancelled" : "timeout",
+						),
+					);
+			};
+			prompts
+				.confirm(
+					m.turnTimeoutTitle,
+					m.turnTimeoutQuestion(asked, turnTimeoutMs),
+					undefined,
+					"owner",
+					undefined,
+					undefined,
+					{
+						supersede: controller.signal,
+						wording: {
+							approve: m.turnTimeoutContinue,
+							decline: m.turnTimeoutCancel,
+							footer: m.turnTimeoutFooter,
+							approved: m.turnTimeoutContinued,
+							declined: m.turnTimeoutCancelled,
+						},
+					},
+				)
+				.then(answered, (error: unknown) => {
+					logger.warn({ channel, err: error }, "timeout card failed");
+					answered("unavailable");
+				});
+		},
+		clock,
+	);
 	return {
 		...budget,
 		renew() {
@@ -117,5 +257,9 @@ export function runtimeTurnBudget(
 				);
 			return deadlineMs;
 		},
+		cancel() {
+			budget.cancel();
+			closeCard?.(messages().turnTimeoutFinished);
+		},
 	};
 }