pi-roundtable 0.22.0 → 0.22.2

package/CHANGELOG.md

@@ -5,6 +5,18 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.22.2] - 2026-10-21
+
+### Fixed
+
+- A skill linked while another was removed no longer vanishes from the registry (`pi-roundtable`). `skill_unlink` reloaded the whole skill cache from the database after its delete, so a `skill_link` running at the same time, as two tool calls of one model message do, could commit its row after the reload had read the table and then be dropped from memory: the skill was missing from `skill_list`, unknown to `agent_skills` and `skill_group_set`, and could be neither unlinked nor linked again until a restart. The skill store now updates its memory from what each write committed and runs its writes one at a time, and a link that meets an existing row says "Already registered" instead of PostgreSQL's duplicate-key error. The agent store's seeding no longer reloads its cache either, and its agent and group writes also run one at a time, so an agent archived while its group is updated cannot come back as a member.
+
+## [0.22.1] - 2026-10-21
+
+### Changed
+
+- A turn that reaches its time limit asks before it ends (`pi-roundtable`). When the built-in runtime's 10-minute budget or 30-minute cap fires on a turn that can show the owner a card, the turn keeps working and a card names the limit, the work time, what the turn is doing (the running tool and for how long, waiting on the model, or compacting) and the tools so far, with **Continue** (another full budget from the answer; at the cap the cap moves too) and **Cancel**. No answer within 5 minutes aborts the turn; a turn that finishes first closes the card and replies as usual. A turn that cannot show a card is aborted as before. An aborted turn now fails with `TurnTimeoutError` (an `AgentRunError`, with the reason as `TurnTimeout`: its `TurnLimit`, work time, running tools, tools so far and `TurnTimeoutEnd`), its log warning carries the same fields, and the posted failure says why instead of the generic notice. `ApprovalOptions` gains `wording` (`ApprovalWording`: the buttons' labels and the footers) for a card that is not an approval; the Discord cards honour it. `PiAgentRuntimeOptions` gains `turnTimeoutCardMs`, the card's grace period; the runtime plugin still passes none of the limits, so they stay fixed. See [the turn limits](docs/plugins.md#what-happens-when-the-bot-starts-and-stops).
+
 ## [0.22.0] - 2026-10-21
 
 ### Added

package/docs/plugins.md

@@ -3526,7 +3526,10 @@ On `SIGTERM` or `SIGINT` the bot takes no new work at once, finishes what runs,
 `shutdown()` returns exit code `0`, or `1` if a listener, service, or pool failed to stop.
 Every call shares the same shutdown.
 Give the service manager a stop timeout longer than the drain limit plus about a minute for the steps after it, such as systemd's `TimeoutStopSec=5min` with the default three-minute drain; a shorter one has the manager kill the process in the middle of the drain.
-The built-in runtime aborts a turn that works 10 minutes, not counting time spent waiting on the owner's cards. Each message steered into the running turn gives it the full 10 minutes again from that moment, up to a cap of 30 minutes of work for the whole turn; once the cap is reached the turn takes no more steering, so a message waits for the next turn, and the turn is aborted as on its timeout. Both limits are fixed: the runtime plugin passes no option for them, so a host cannot change them, and a limit that waiting on an owner's card pushed back can fire up to a second late. The log says `steer renewed the turn's time budget` with `deadlineMs`, the work time left, and the timeout warning names the limit that fired (`limit: "turn"` or `"turnMax"`). Task workers (`task.timeoutMs`), coding workers (`workTimeout`) and sandbox guests (their own `turnTimeoutMs`) keep their own limits, which steering does not renew.
+The built-in runtime limits a turn to 10 minutes of work, not counting time spent waiting on the owner's cards. Each message steered into the running turn gives it the full 10 minutes again from that moment, up to a cap of 30 minutes of work for the whole turn; once the cap is reached the turn takes no more steering, so a message waits for the next turn.
+When a limit fires on a turn that can show a card (an owner's turn or a report turn on a surface with cards, the same turns that can ask with `ask_user` or an approval card), the turn is not aborted: it keeps working and a card asks the owner whether to go on. The card names the limit, how long the turn has worked, what it is doing now (the tool running and for how long, or waiting on the model, or compacting the conversation) and the tools it called so far, by name and count, never their inputs. **Continue** gives the turn another full 10 minutes from the answer; at the cap it moves the cap too, to 10 minutes from the answer, so the owner can keep going in steps. **Cancel** aborts the turn. With no answer within 5 minutes of wall time the turn is aborted. The time the card is open counts as work, unlike an `ask_user` or approval card, because the turn keeps working; while it is open the turn takes no steering. If the turn finishes first, the card closes saying so and the reply is posted as usual; a press after that gets the usual "no longer valid" reply. The card's buttons come from `ApprovalOptions.wording` on `Prompts.confirm`, with `supersede` closing it, so a surface that shows approvals shows it; one that ignores `wording` shows its own approve and decline labels.
+A turn that cannot show a card (a schedule's turn, a member's turn, a turn without a surface) is aborted at once, as before. Either way an aborted turn fails with a `TurnTimeoutError` (an `AgentRunError`) whose `timeout` (`TurnTimeout`) holds the limit, the work time, the running tools, whether it was compacting, the tools so far, and how it ended (`end`: `"timeout"`, `"cancelled"` by the owner, or `"unanswered"`); its message says the same in English, and the failure the conversation posts says it in the host's language instead of the generic failure notice.
+The limits are fixed: the runtime plugin passes no option for them, nor for the card's grace period (`turnTimeoutMs`, `turnMaxMs` and `turnTimeoutCardMs` of `PiAgentRuntimeOptions`, for a host that builds the runtime itself), and a limit that waiting on an owner's card pushed back can fire up to a second late. The log says `steer renewed the turn's time budget` with `deadlineMs`, the work time left; `turn reached its time limit; asking the owner` when the card is posted; `owner continued the turn past its time limit` on Continue; and the warning `turn timed out; aborting` names the limit that fired (`limit: "turn"` or `"turnMax"`) with `workedMs`, `running`, `compacting`, `tools` and `end`. Task workers (`task.timeoutMs`), coding workers (`workTimeout`) and sandbox guests (their own `turnTimeoutMs`) keep their own limits, which steering does not renew and which post no card.
 A turn whose model ignores its abort (a subprocess that does not exit) is given up on too: a turn that outlives its timeout, or is stopped, gets `turnAbortGraceMs` (15 seconds by default) to end, and then its session is disposed of and the turn is reported failed, so it cannot hold the queue.
 `listen()`, called by the command line and a host's own entry point, exits the process with that code.
 
@@ -3737,6 +3740,7 @@ Import from the entries listed below; source area files are internal.
 | `ApprovalDetails` | `pi-roundtable` | type |
 | `ApprovalFile` | `pi-roundtable` | type |
 | `ApprovalOptions` | `pi-roundtable` | type |
+| `ApprovalWording` | `pi-roundtable` | type |
 | `ApprovedBy` | `pi-roundtable` | type |
 | `AskOption` | `pi-roundtable` | type |
 | `AskSupport` | `pi-roundtable` | type |
@@ -3963,6 +3967,10 @@ Import from the entries listed below; source area files are internal.
 | `TurnRequest` | `pi-roundtable` | type |
 | `TurnResult` | `pi-roundtable` | type |
 | `TurnSelection` | `pi-roundtable` | type |
+| `TurnLimit` | `pi-roundtable` | type |
+| `TurnTimeout` | `pi-roundtable` | type |
+| `TurnTimeoutEnd` | `pi-roundtable` | type |
+| `TurnTimeoutError` | `pi-roundtable` | value |
 | `WebSocketAccept` | `pi-roundtable` | type |
 | `WebSocketRoute` | `pi-roundtable` | type |
 | `WebSocketSendResult` | `pi-roundtable` | type |

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable",
-	"version": "0.22.0",
+	"version": "0.22.2",
 	"description": "A plugin-driven Pi agent server for one owner, reached through Discord or the web",
 	"type": "module",
 	"license": "MIT",

package/src/core/agents/agent-store.ts

@@ -58,6 +58,8 @@ export class PgAgentStore implements AgentDirectory {
 	readonly #sql: SQL;
 	readonly #agents = new Map<string, Agent>();
 	readonly #groups = new Map<string, AgentGroup>();
+	/** The tail of the agent and group writes, which run one at a time so none reads a map another is about to change. */
+	#queue: Promise<unknown> = Promise.resolve();
 
 	readonly #guild: string;
 	readonly #messages: GroupMessages;
@@ -97,18 +99,27 @@ export class PgAgentStore implements AgentDirectory {
 
 	/** Inserts seed agents that do not exist yet; existing rows, edited or not, are left alone. */
 	async seed(seeds: readonly AgentSeed[]): Promise<string[]> {
-		const added: string[] = [];
-		for (const seed of seeds) {
-			const rows: unknown[] = await this.#sql`
+		return this.#serial(async () => {
+			const added: string[] = [];
+			for (const seed of seeds) {
+				const rows: AgentRow[] = await this.#sql`
 				INSERT INTO agents (guild_id, name, display_name, prompt, avatar_prompt, channel_id)
 				VALUES (${this.#guild}, ${seed.name}, ${seed.displayName}, ${seed.prompt}, ${seed.avatarPrompt},
 					${seed.channelId ?? null})
 				ON CONFLICT DO NOTHING
-				RETURNING name`;
-			if (rows.length > 0) added.push(seed.name);
-		}
-		await this.#reload();
-		return added;
+				RETURNING *`;
+				// Only the inserted rows join the map: reloading it whole would drop a write that
+				// committed after its SELECT.
+				if (rows[0]) added.push(this.#keepAgent(rows[0]).name);
+			}
+			return added;
+		});
+	}
+
+	#serial<T>(write: () => Promise<T>): Promise<T> {
+		const run = this.#queue.then(write);
+		this.#queue = run.catch(() => undefined);
+		return run;
 	}
 
 	agents(): Agent[] {
@@ -178,18 +189,20 @@ export class PgAgentStore implements AgentDirectory {
 		avatarPrompt: string;
 		channelId: string;
 	}): Promise<Agent> {
-		checkAgentName(agent.name);
-		checkDisplayName(agent.displayName);
-		checkPrompt(agent.prompt);
-		// An agent of a host without an image provider has no avatar prompt.
-		if (agent.avatarPrompt !== "") checkAvatarPrompt(agent.avatarPrompt);
-		this.#checkFree(agent.name);
-		const rows: AgentRow[] = await this.#sql`
+		return this.#serial(async () => {
+			checkAgentName(agent.name);
+			checkDisplayName(agent.displayName);
+			checkPrompt(agent.prompt);
+			// An agent of a host without an image provider has no avatar prompt.
+			if (agent.avatarPrompt !== "") checkAvatarPrompt(agent.avatarPrompt);
+			this.#checkFree(agent.name);
+			const rows: AgentRow[] = await this.#sql`
 			INSERT INTO agents (guild_id, name, display_name, prompt, avatar_prompt, channel_id)
 			VALUES (${this.#guild}, ${agent.name}, ${agent.displayName.trim()}, ${agent.prompt}, ${agent.avatarPrompt},
 				${agent.channelId})
 			RETURNING *`;
-		return this.#keepAgent(rows[0]);
+			return this.#keepAgent(rows[0]);
+		});
 	}
 
 	/** A name that createAgent would accept, checked before its channel is made. */
@@ -211,20 +224,22 @@ export class PgAgentStore implements AgentDirectory {
 			thinking?: ThinkingLevel | null;
 		},
 	): Promise<Agent> {
-		const current = this.activeAgent(name);
-		if (change.displayName !== undefined) checkDisplayName(change.displayName);
-		if (change.prompt !== undefined) checkPrompt(change.prompt);
-		if (change.avatarPrompt !== undefined)
-			checkAvatarPrompt(change.avatarPrompt);
-		if (change.model) checkModelRef(change.model);
-		if (change.thinking) checkThinking(change.thinking);
-		const model =
-			change.model === undefined ? (current.model ?? null) : change.model;
-		const thinking =
-			change.thinking === undefined
-				? (current.thinking ?? null)
-				: change.thinking;
-		const rows: AgentRow[] = await this.#sql`
+		return this.#serial(async () => {
+			const current = this.activeAgent(name);
+			if (change.displayName !== undefined)
+				checkDisplayName(change.displayName);
+			if (change.prompt !== undefined) checkPrompt(change.prompt);
+			if (change.avatarPrompt !== undefined)
+				checkAvatarPrompt(change.avatarPrompt);
+			if (change.model) checkModelRef(change.model);
+			if (change.thinking) checkThinking(change.thinking);
+			const model =
+				change.model === undefined ? (current.model ?? null) : change.model;
+			const thinking =
+				change.thinking === undefined
+					? (current.thinking ?? null)
+					: change.thinking;
+			const rows: AgentRow[] = await this.#sql`
 			UPDATE agents SET
 				display_name = ${change.displayName?.trim() ?? current.displayName},
 				prompt = ${change.prompt ?? current.prompt},
@@ -236,29 +251,33 @@ export class PgAgentStore implements AgentDirectory {
 				updated_at = now()
 			WHERE guild_id = ${this.#guild} AND name = ${name}
 			RETURNING *`;
-		return this.#keepAgent(rows[0]);
+			return this.#keepAgent(rows[0]);
+		});
 	}
 
 	/** Archives an agent and takes it out of every group; says which groups it left. */
 	async archiveAgent(name: string): Promise<AgentGroup[]> {
-		const rows: AgentRow[] = await this.#sql`
+		return this.#serial(async () => {
+			const rows: AgentRow[] = await this.#sql`
 			UPDATE agents SET status = 'archived', updated_at = now()
 			WHERE guild_id = ${this.#guild} AND name = ${name} RETURNING *`;
-		this.#keepAgent(rows[0]);
-		const left: AgentGroup[] = [];
-		for (const group of this.groups()) {
-			if (group.status !== "active" || !group.members.includes(name)) continue;
-			const members = group.members.filter((m) => m !== name);
-			const host = group.host === name ? (members[0] ?? name) : group.host;
-			left.push(
-				await this.#writeGroup(group.name, {
-					members,
-					host,
-					status: members.length < MIN_GROUP_MEMBERS ? "archived" : "active",
-				}),
-			);
-		}
-		return left;
+			this.#keepAgent(rows[0]);
+			const left: AgentGroup[] = [];
+			for (const group of this.groups()) {
+				if (group.status !== "active" || !group.members.includes(name))
+					continue;
+				const members = group.members.filter((m) => m !== name);
+				const host = group.host === name ? (members[0] ?? name) : group.host;
+				left.push(
+					await this.#writeGroup(group.name, {
+						members,
+						host,
+						status: members.length < MIN_GROUP_MEMBERS ? "archived" : "active",
+					}),
+				);
+			}
+			return left;
+		});
 	}
 
 	#keepAgent(row: AgentRow | undefined): Agent {
@@ -296,39 +315,44 @@ export class PgAgentStore implements AgentDirectory {
 		members: string[];
 		host: string;
 	}): Promise<AgentGroup> {
-		this.checkNewGroup(group.name, group.members, group.host);
-		checkDisplayName(group.displayName);
-		const rows: GroupRow[] = await this.#sql`
+		return this.#serial(async () => {
+			this.checkNewGroup(group.name, group.members, group.host);
+			checkDisplayName(group.displayName);
+			const rows: GroupRow[] = await this.#sql`
 			INSERT INTO agent_groups (guild_id, name, display_name, channel_id, members, host)
 			VALUES (${this.#guild}, ${group.name}, ${group.displayName.trim()}, ${group.channelId},
 				${group.members.join(",")}, ${group.host})
 			RETURNING *`;
-		return this.#keepGroup(rows[0]);
+			return this.#keepGroup(rows[0]);
+		});
 	}
 
 	async updateGroup(
 		name: string,
 		change: { displayName?: string; members?: string[]; host?: string },
 	): Promise<AgentGroup> {
-		const current = this.#groups.get(name);
-		if (current?.status !== "active")
-			throw new AgentError(`There is no active group "${name}".`);
-		if (change.displayName !== undefined) checkDisplayName(change.displayName);
-		const members = change.members ?? current.members;
-		const host =
-			change.host ??
-			(members.includes(current.host) ? current.host : (members[0] ?? ""));
-		this.#checkMembers(members, host);
-		return this.#writeGroup(name, {
-			displayName: change.displayName?.trim() ?? current.displayName,
-			members,
-			host,
-			status: "active",
+		return this.#serial(async () => {
+			const current = this.#groups.get(name);
+			if (current?.status !== "active")
+				throw new AgentError(`There is no active group "${name}".`);
+			if (change.displayName !== undefined)
+				checkDisplayName(change.displayName);
+			const members = change.members ?? current.members;
+			const host =
+				change.host ??
+				(members.includes(current.host) ? current.host : (members[0] ?? ""));
+			this.#checkMembers(members, host);
+			return this.#writeGroup(name, {
+				displayName: change.displayName?.trim() ?? current.displayName,
+				members,
+				host,
+				status: "active",
+			});
 		});
 	}
 
 	async archiveGroup(name: string): Promise<AgentGroup> {
-		return this.#writeGroup(name, { status: "archived" });
+		return this.#serial(() => this.#writeGroup(name, { status: "archived" }));
 	}
 
 	async #writeGroup(

package/src/core/agents/team-turns.ts

@@ -8,7 +8,7 @@ import type {
 import { AgentError } from "../domain/errors.ts";
 import type { InterimPosts } from "../domain/interim.ts";
 import type { AgentTurnScope } from "../domain/ports.ts";
-import { messages } from "../i18n/index.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";
@@ -35,11 +35,6 @@ import {
 
 export { MAX_CHAIN_MESSAGES, type TeamTurnsOptions };
 
-/** What a failed turn posts: the stopped notice for a stop, the failure notice otherwise. */
-function noticeOf(result: { stopped?: true }): string {
-	return result.stopped ? messages().stoppedNotice : messages().failureNotice;
-}
-
 /**
  * The agent team's turns: owner messages, background turns, group rounds, and messages between
  * agents, each posted under the answering agent's name.
@@ -246,7 +241,7 @@ export class TeamTurns {
 					: undefined;
 			await this.#post(postTo, this.#current(agent), {
 				...(thinking ? { thinking } : {}),
-				chunks: result.ok ? splitReply(result.text) : [noticeOf(result)],
+				chunks: result.ok ? splitReply(result.text) : [failureNotice(result)],
 				...(result.ok && result.files?.length ? { files: result.files } : {}),
 			});
 		} catch (error) {

package/src/core/discord/owner-card-rows.ts

@@ -123,23 +123,27 @@ export function answeredLine(answer: OwnerAnswer): string {
 	return messages().cardAnswered(parts);
 }
 
-/** An approval's controls: run, cancel, and, when the card offers a copy, a copy button that stays usable once it ended. */
+/**
+ * An approval's controls: run, cancel, or the labels its wording gives, and, when the card offers
+ * a copy, a copy button that stays usable once it ended.
+ */
 export function approvalRows(
 	id: string,
 	disabled: boolean,
 	copy: { label: string } | undefined,
+	labels?: { approve: string; decline: string },
 ): Rows {
 	return [
 		new ActionRowBuilder<ButtonBuilder>().addComponents(
 			new ButtonBuilder()
 				.setCustomId(`${CARD_PREFIX}${id}:yes`)
-				.setLabel(messages().cardRunLabel)
+				.setLabel(labels?.approve ?? messages().cardRunLabel)
 				.setEmoji("✅")
 				.setStyle(ButtonStyle.Success)
 				.setDisabled(disabled),
 			new ButtonBuilder()
 				.setCustomId(`${CARD_PREFIX}${id}:no`)
-				.setLabel(messages().cardCancelLabel)
+				.setLabel(labels?.decline ?? messages().cardCancelLabel)
 				.setEmoji("❌")
 				.setStyle(ButtonStyle.Secondary)
 				.setDisabled(disabled),

package/src/core/discord/owner-card-types.ts

@@ -83,6 +83,8 @@ export interface OpenCard {
 	mention?: boolean;
 	/** Who may answer, and what to tell someone else who presses it. */
 	audience: Audience;
+	/** An approval card's footers once approved or declined, where its wording gives them. */
+	outcomes?: { approved: string; declined: string };
 }
 
 /** What `#post` needs to post one card; `T` is what the card resolves with. */
@@ -101,6 +103,8 @@ export interface CardSpec<T> {
 	build?(id: string, footer: string, disabled: boolean): CardPayload;
 	rows?(id: string, disabled: boolean): Rows;
 	footer: string;
+	/** An approval card's footers once approved or declined, where its wording gives them. */
+	outcomes?: { approved: string; declined: string };
 	wait?: {
 		pending: T;
 		late(

package/src/core/discord/owner-cards.ts

@@ -175,8 +175,10 @@ export class OwnerCards implements InteractionModule {
 						sections: [message],
 						...(options?.supersede ? { supersede: options.supersede } : {}),
 						...(copy ? { copy: copy.text } : {}),
-						rows: (id, disabled) => approvalRows(id, disabled, copy),
-						footer: messages().cardApprovalFooter,
+						rows: (id, disabled) =>
+							approvalRows(id, disabled, copy, options?.wording),
+						footer: options?.wording?.footer ?? messages().cardApprovalFooter,
+						...(options?.wording ? { outcomes: options.wording } : {}),
 					},
 				);
 			},
@@ -296,6 +298,7 @@ export class OwnerCards implements InteractionModule {
 				...(card.question ? { question: card.question } : {}),
 				...(card.form ? { form: card.form } : {}),
 				...(card.previews ? { previews: card.previews } : {}),
+				...(card.outcomes ? { outcomes: card.outcomes } : {}),
 			};
 			this.#open.set(id, open);
 			this.#options
@@ -417,7 +420,11 @@ export class OwnerCards implements InteractionModule {
 				return true;
 			}
 			await interaction.update(
-				card.view(approved ? messages().cardApproved : messages().cardDeclined),
+				card.view(
+					approved
+						? (card.outcomes?.approved ?? messages().cardApproved)
+						: (card.outcomes?.declined ?? messages().cardDeclined),
+				),
 			);
 			return true;
 		}

package/src/core/domain/turn-timeout.ts

@@ -0,0 +1,38 @@
+import { AgentRunError } from "./errors.ts";
+
+/** Which limit a turn reached: its budget since the start or the last steer, or its cap. */
+export type TurnLimit = "turn" | "turnMax";
+
+/**
+ * How a timed-out turn ended: at its limit with no card to ask on (`timeout`), cancelled on the
+ * timeout card (`cancelled`), or with the card unanswered in its grace period (`unanswered`).
+ */
+export type TurnTimeoutEnd = "timeout" | "cancelled" | "unanswered";
+
+/** Why a turn hit a time limit, as data: which limit, how long it worked, and what it was doing. */
+export interface TurnTimeout {
+	limit: TurnLimit;
+	/** The limit's length: the budget, or the cap as the owner's Continues raised it. */
+	limitMs: number;
+	/** The turn's work so far, not counting time spent waiting on the owner's other cards. */
+	workedMs: number;
+	/** 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. */
+	tools: [string, number][];
+	/** How long the timeout card waits for an answer. */
+	graceMs: number;
+	end: TurnTimeoutEnd;
+}
+
+/** A turn aborted at a time limit; `timeout` says why, and the message says it in English. */
+export class TurnTimeoutError extends AgentRunError {
+	override name = "TurnTimeoutError";
+	constructor(
+		readonly timeout: TurnTimeout,
+		message: string,
+	) {
+		super(message);
+	}
+}

package/src/core/i18n/en.ts

@@ -7,6 +7,7 @@ import { discordEn } from "./discord.ts";
 import { ownerEn } from "./owner.ts";
 import { schedulesEn } from "./schedules.ts";
 import { timeZonesEn } from "./time-zones.ts";
+import { turnTimeoutEn } from "./turn-timeout.ts";
 import type { CatalogContext } from "./types.ts";
 
 export type Messages = ReturnType<typeof createEn>;
@@ -23,5 +24,6 @@ export function createEn(ctx: CatalogContext) {
 		...dashboardEn(ctx),
 		...channelsEn(ctx),
 		...discordEn(ctx),
+		...turnTimeoutEn(),
 	};
 }

package/src/core/i18n/turn-timeout.ts

@@ -0,0 +1,131 @@
+import type { TurnTimeout } from "../domain/turn-timeout.ts";
+
+/** A duration in whole seconds, as "3 min 12 s", "45 s", or "1 h 5 min". */
+function durationEn(ms: number): string {
+	const s = Math.max(0, Math.round(ms / 1000));
+	const h = Math.floor(s / 3600);
+	const m = Math.floor((s % 3600) / 60);
+	const sec = s % 60;
+	if (h > 0) return m > 0 ? `${h} h ${m} min` : `${h} h`;
+	if (m > 0) return sec > 0 ? `${m} min ${sec} s` : `${m} min`;
+	return `${sec} s`;
+}
+
+function durationZh(ms: number): string {
+	const s = Math.max(0, Math.round(ms / 1000));
+	const h = Math.floor(s / 3600);
+	const m = Math.floor((s % 3600) / 60);
+	const sec = s % 60;
+	if (h > 0) return m > 0 ? `${h} 小時 ${m} 分` : `${h} 小時`;
+	if (m > 0) return sec > 0 ? `${m} 分 ${sec} 秒` : `${m} 分`;
+	return `${sec} 秒`;
+}
+
+/** The tools called so far, as the interim tool line shows them. */
+function toolList(tools: TurnTimeout["tools"], separator: string): string {
+	return tools
+		.map(([name, count]) => (count > 1 ? `${name} ×${count}` : name))
+		.join(separator);
+}
+
+/** The timeout card and the notice a turn posts when it ends at a time limit. */
+export function turnTimeoutEn() {
+	const doing = (t: TurnTimeout) =>
+		t.running.length > 0
+			? t.running
+					.map(({ tool, ms }) => `${tool}, running for ${durationEn(ms)}`)
+					.join("; ")
+			: t.compacting
+				? "compacting the conversation"
+				: "waiting on the model";
+	const limit = (t: TurnTimeout) =>
+		t.limit === "turn"
+			? `its time limit of ${durationEn(t.limitMs)} (since it started or since the last message steered into it)`
+			: `its cap of ${durationEn(t.limitMs)} of work in all`;
+	const tools = (t: TurnTimeout) =>
+		t.tools.length > 0 ? `Tools so far: ${toolList(t.tools, " · ")}.` : "";
+	return {
+		turnTimeoutTitle: "⏱️ This turn is taking long",
+		turnTimeoutQuestion: (t: TurnTimeout, budgetMs: number) =>
+			[
+				`It reached ${limit(t)} and has worked ${durationEn(t.workedMs)}.`,
+				`Now: ${doing(t)}.`,
+				tools(t),
+				`It keeps working while this card is open. Continue gives it another ${durationEn(budgetMs)}; Cancel stops it. With no answer in ${durationEn(t.graceMs)} it stops.`,
+			]
+				.filter(Boolean)
+				.join("\n"),
+		turnTimeoutContinue: "Continue",
+		turnTimeoutCancel: "Cancel",
+		turnTimeoutFooter:
+			"The turn is still working; answer whenever you are ready.",
+		turnTimeoutContinued: "▶️ Continued.",
+		turnTimeoutCancelled: "❌ Cancelled; the turn stops.",
+		turnTimeoutFinished: "✅ The turn finished; nothing to answer.",
+		turnTimeoutUnanswered: (t: TurnTimeout) =>
+			`⏱️ No answer in ${durationEn(t.graceMs)}; the turn was stopped.`,
+		turnTimedOutNotice: (t: TurnTimeout) => {
+			const what =
+				t.running.length > 0
+					? `while ${t.running.map(({ tool, ms }) => `${tool} was running (${durationEn(ms)})`).join(" and ")}`
+					: `while ${doing(t)}`;
+			const head =
+				t.end === "cancelled"
+					? `⏱️ Cancelled by the owner after ${durationEn(t.workedMs)} ${what}.`
+					: t.end === "unanswered"
+						? `⏱️ No answer to the timeout card in ${durationEn(t.graceMs)}, so the turn was stopped after ${durationEn(t.workedMs)} ${what}.`
+						: `⏱️ The turn reached ${limit(t)} and was stopped after ${durationEn(t.workedMs)} ${what}.`;
+			return [head, tools(t)].filter(Boolean).join(" ");
+		},
+	};
+}
+
+export function turnTimeoutZhTW(): ReturnType<typeof turnTimeoutEn> {
+	const doing = (t: TurnTimeout) =>
+		t.running.length > 0
+			? t.running
+					.map(({ tool, ms }) => `${tool}，已執行 ${durationZh(ms)}`)
+					.join("；")
+			: t.compacting
+				? "正在壓縮對話"
+				: "正在等模型回應";
+	const limit = (t: TurnTimeout) =>
+		t.limit === "turn"
+			? `時間上限 ${durationZh(t.limitMs)}（從開始或最後一則插入的訊息算起）`
+			: `總工作時間上限 ${durationZh(t.limitMs)}`;
+	const tools = (t: TurnTimeout) =>
+		t.tools.length > 0 ? `目前用過的工具：${toolList(t.tools, " · ")}。` : "";
+	return {
+		turnTimeoutTitle: "⏱️ 這一輪做得比較久",
+		turnTimeoutQuestion: (t: TurnTimeout, budgetMs: number) =>
+			[
+				`已達到${limit(t)}，已工作 ${durationZh(t.workedMs)}。`,
+				`現在：${doing(t)}。`,
+				tools(t),
+				`這張卡片開著時它會繼續工作。按「繼續」再給它 ${durationZh(budgetMs)}；按「取消」停止。${durationZh(t.graceMs)}內沒有回答就會停止。`,
+			]
+				.filter(Boolean)
+				.join("\n"),
+		turnTimeoutContinue: "繼續",
+		turnTimeoutCancel: "取消",
+		turnTimeoutFooter: "這一輪仍在工作；準備好再回答即可。",
+		turnTimeoutContinued: "▶️ 已繼續。",
+		turnTimeoutCancelled: "❌ 已取消，這一輪會停止。",
+		turnTimeoutFinished: "✅ 這一輪已完成，不需要回答。",
+		turnTimeoutUnanswered: (t: TurnTimeout) =>
+			`⏱️ ${durationZh(t.graceMs)}內沒有回答，這一輪已停止。`,
+		turnTimedOutNotice: (t: TurnTimeout) => {
+			const what =
+				t.running.length > 0
+					? `當時 ${t.running.map(({ tool, ms }) => `${tool} 正在執行（${durationZh(ms)}）`).join("、")}`
+					: `當時${doing(t)}`;
+			const head =
+				t.end === "cancelled"
+					? `⏱️ 擁有者在工作 ${durationZh(t.workedMs)} 後取消了這一輪，${what}。`
+					: t.end === "unanswered"
+						? `⏱️ 逾時卡片在 ${durationZh(t.graceMs)}內沒有回答，這一輪在工作 ${durationZh(t.workedMs)} 後停止，${what}。`
+						: `⏱️ 這一輪達到${limit(t)}，在工作 ${durationZh(t.workedMs)} 後停止，${what}。`;
+			return [head, tools(t)].filter(Boolean).join(" ");
+		},
+	};
+}

package/src/core/i18n/zh-tw.ts

@@ -8,6 +8,7 @@ import type { Messages } from "./en.ts";
 import { ownerZhTW } from "./owner.ts";
 import { schedulesZhTW } from "./schedules.ts";
 import { timeZonesZhTW } from "./time-zones.ts";
+import { turnTimeoutZhTW } from "./turn-timeout.ts";
 import type { CatalogContext } from "./types.ts";
 
 /** The Traditional Chinese catalog. */
@@ -22,5 +23,6 @@ export function createZhTW(ctx: CatalogContext): Messages {
 		...dashboardZhTW(ctx),
 		...channelsZhTW(ctx),
 		...discordZhTW(ctx),
+		...turnTimeoutZhTW(),
 	};
 }

package/src/core/interactions/prompts.ts

@@ -128,6 +128,23 @@ export interface ApprovalOptions {
 	 * withdrawn call whatever the card answers.
 	 */
 	supersede?: AbortSignal;
+	/**
+	 * The card's own words, for a card that asks something other than whether to run an action,
+	 * such as a turn's timeout card; a surface that cannot show them keeps its own.
+	 */
+	wording?: ApprovalWording;
+}
+
+/** A card's words in place of an approval's; see `ApprovalOptions.wording`. */
+export interface ApprovalWording {
+	/** The labels of the controls that answer approved and declined. */
+	approve: string;
+	decline: string;
+	/** The footer while the card is open. */
+	footer: string;
+	/** The footer once it was answered approved, or declined. */
+	approved: string;
+	declined: string;
 }
 
 /** The longest footer a withdrawn card shows, in characters. */