pi-roundtable 0.27.1 → 0.29.0

package/src/core/config/routing.ts

@@ -31,11 +31,12 @@ export interface AgentRoutes {
 	 */
 	integration?: "origin" | "primary" | (string & {});
 	/**
-	 * The conversation a `message_agent` call reaches when it names none. `"latest"` (default) is
-	 * the one the agent last ran a turn in, never carrying a message from a room out to Discord;
+	 * The conversation a `message_agent` call reaches when it names none. `"origin-surface"`
+	 * (default) is the agent's place on the sender's surface, else its primary place; `"latest"` the
+	 * one the agent last ran a turn in on the sender's surface, else as `"origin-surface"`;
 	 * `"primary"` the agent's primary place; a surface name the agent's place there.
 	 */
-	agentMessage?: "latest" | "primary" | (string & {});
+	agentMessage?: "origin-surface" | "latest" | "primary" | (string & {});
 	/**
 	 * Where an agent's opening task (`agent_create task`) runs. `"origin-surface"` (default) is the
 	 * agent's place on the surface the creation came from, else its primary place; `"primary"`
@@ -86,7 +87,7 @@ const DECLARED_PLACES: readonly string[] = ["ops"];
 export const ROUTE_WORDS = {
 	primary: ["auto"],
 	integration: ["origin", "primary"],
-	agentMessage: ["latest", "primary"],
+	agentMessage: ["origin-surface", "latest", "primary"],
 	opening: ["origin-surface", "primary"],
 } as const;
 

package/src/core/discord/agent-discord.ts

@@ -28,6 +28,7 @@ import { AgentError } from "../domain/errors.ts";
 import type { InterimPosts } from "../domain/interim.ts";
 import { messages } from "../i18n/index.ts";
 import type { Logger } from "../log.ts";
+import { type IntercomTexts, intercomPost } from "./intercom-cards.ts";
 
 const DASHBOARD_NAME = "dashboard";
 
@@ -42,10 +43,13 @@ export class DiscordAgentChannels implements AgentChannels {
 	readonly #webhooks = new Map<string, Promise<Webhook>>();
 	/** The parent channel of each thread the agents live in, and null for a channel that is none. */
 	readonly #parents = new Map<string, string | null>();
+	/** Where the cards' whole texts are kept for their open buttons; without it a card posts as text. */
+	readonly #texts: IntercomTexts | undefined;
 
-	constructor(client: Client, guildId: string) {
+	constructor(client: Client, guildId: string, texts?: IntercomTexts) {
 		this.#client = client;
 		this.#guildId = guildId;
+		this.#texts = texts;
 	}
 
 	/**
@@ -77,6 +81,13 @@ export class DiscordAgentChannels implements AgentChannels {
 			...(route.threadId ? { threadId: route.threadId } : {}),
 		};
 		try {
+			if (post.intercom && this.#texts) {
+				await webhook.send({
+					...as,
+					...intercomPost(post.intercom, this.#texts),
+				});
+				return;
+			}
 			if (post.thinking) await webhook.send({ ...as, content: post.thinking });
 			for (const chunk of post.chunks)
 				await webhook.send({ ...as, content: chunk });

package/src/core/discord/card-copies.ts

@@ -35,6 +35,8 @@ export interface CardCopiesOptions {
 	setInterval?: typeof setInterval;
 	/** Replaceable in tests, with `setInterval`. */
 	clearInterval?: typeof clearInterval;
+	/** What the texts are, as the log names them; default "card copy texts". */
+	what?: string;
 }
 
 /**
@@ -69,7 +71,7 @@ export class CardCopies {
 		} catch (error) {
 			logger.warn(
 				{ path, err: error },
-				"card copy texts not read; copy buttons of earlier cards will say they are gone",
+				`${options.what ?? "card copy texts"} not read; buttons of earlier cards will say they are gone`,
 			);
 		}
 	}
@@ -172,7 +174,10 @@ export class CardCopies {
 			await chmod(temporary, 0o600);
 			await rename(temporary, path);
 		} catch (error) {
-			logger.warn({ path, err: error }, "card copy texts not saved");
+			logger.warn(
+				{ path, err: error },
+				`${this.#options.what ?? "card copy texts"} not saved`,
+			);
 		}
 	}
 }

package/src/core/discord/direct-channel.ts

@@ -36,6 +36,7 @@ export function discordDirectChannel(
 	};
 	return {
 		name: "discord",
+		surface: "discord",
 		label: "a direct message on Discord",
 		knows: async (principalId) => (await userOf(principalId)) !== undefined,
 		reaches: async (principalId) => {

package/src/core/discord/discord-surface.ts

@@ -6,7 +6,6 @@ import {
 	Events,
 	GatewayIntentBits,
 	type Interaction,
-	type Message,
 	MessageFlags,
 	Partials,
 	type REST,
@@ -47,18 +46,17 @@ import { DiscordThreadHost } from "./dispatch-thread-host.ts";
 import { DISCORD_FORMATTING, pickFormatting } from "./formatting.ts";
 import { DEFAULT_FRESH_MARKER, postFreshMarker } from "./fresh-marker.ts";
 import { lateAnswerMessage } from "./inbound-message.ts";
+import type { IntercomTexts } from "./intercom-cards.ts";
 import { listenForMessages, reportChanges } from "./message-changes.ts";
 import type { CardChannel, LateTurn } from "./owner-cards.ts";
 import { DiscordOwnerOps } from "./owner-discord.ts";
-import { stopPanel } from "./stop-button.ts";
+import { showStopPanel } from "./stop-button.ts";
 
 const PREFIX = "discord:";
 /** Discord's error code for a channel that does not exist or cannot be seen. */
 const UNKNOWN_CHANNEL = 10003;
 
 const TYPING_REFRESH_MS = 8_000;
-/** A turn shorter than this shows no stop button, so quick answers do not flicker one. */
-const STOP_PANEL_DELAY_MS = 5_000;
 
 export interface DiscordSurfaceOptions {
 	token: string;
@@ -73,6 +71,8 @@ export interface DiscordSurfaceOptions {
 	freshMarker?: string | false;
 	/** What the model is told about how replies render here; `false` tells it nothing. Default: `DISCORD_FORMATTING`. */
 	formatting?: string | false;
+	/** Where the agents' message cards keep their whole texts for the open button; without it a card posts as text. */
+	intercomTexts?: IntercomTexts;
 	/** Reads the channel context of an addressed message; without it the surface has none. */
 	channelContext?: (
 		message: InboundMessage,
@@ -157,7 +157,11 @@ export class DiscordSurface
 
 	/** The agent server's channels and webhooks. */
 	agentChannels(guildId: string): AgentChannels {
-		return new DiscordAgentChannels(this.#client, guildId);
+		return new DiscordAgentChannels(
+			this.#client,
+			guildId,
+			this.#options.intercomTexts,
+		);
 	}
 
 	/** Threads for background dispatches, in the channel that started each. */
@@ -365,33 +369,12 @@ export class DiscordSurface
 	}
 
 	showStop(channel: ChannelKey): () => void {
-		const { logger } = this.#options;
 		// An outside agent's conversation has no Discord channel to show a button in.
 		if (!channel.startsWith(PREFIX)) return () => undefined;
-		let hidden = false;
-		let panel: Message | undefined;
-		const remove = (message: Message) =>
-			message
-				.delete()
-				.catch((error: unknown) =>
-					logger.warn({ channel, err: error }, "stop panel not removed"),
-				);
-		const timer = setTimeout(() => {
-			this.#sendable(channel)
-				.then((target): Promise<Message> => target.send(stopPanel()))
-				.then((message) => {
-					if (hidden) void remove(message);
-					else panel = message;
-				})
-				.catch((error: unknown) =>
-					logger.warn({ channel, err: error }, "stop panel not shown"),
-				);
-		}, STOP_PANEL_DELAY_MS);
-		return () => {
-			hidden = true;
-			clearTimeout(timer);
-			if (panel) void remove(panel);
-		};
+		return showStopPanel(
+			() => this.#sendable(channel),
+			(error, what) => this.#options.logger.warn({ channel, err: error }, what),
+		);
 	}
 
 	async react(

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

@@ -0,0 +1,121 @@
+import {
+	ActionRowBuilder,
+	AttachmentBuilder,
+	ButtonBuilder,
+	ButtonStyle,
+	type Interaction,
+	MessageFlags,
+} from "discord.js";
+import type { IntercomCard } from "../domain/conversation.ts";
+import { messages } from "../i18n/index.ts";
+import {
+	intercomFolds,
+	intercomHeading,
+	intercomSummary,
+} from "../presentation/intercom.ts";
+import { splitReply } from "../presentation/reply-splitter.ts";
+import type { InteractionModule } from "./interaction-module.ts";
+
+/** The custom id of a card's open button starts with this; the text's id follows. */
+export const INTERCOM_BUTTON_PREFIX = "roundtable:intercom:";
+/** The most messages an opened card's text takes; a longer text comes as one file. */
+const MAX_PARTS = 5;
+
+/** The whole texts of the cards, by the id their open button carries; `CardCopies` keeps them. */
+export interface IntercomTexts {
+	remember(id: string, text: string): void;
+	recall(id: string): string | undefined;
+}
+
+/**
+ * A card's message: one line of small text, its heading and summary, and an open button when the
+ * summary leaves part of the text out and the text was kept under `id`.
+ */
+export function intercomMessage(card: IntercomCard, id: string | undefined) {
+	const line = messages().intercomLine(
+		intercomHeading(card),
+		intercomSummary(card.text),
+	);
+	return {
+		content: `-# ${line}`,
+		allowedMentions: { parse: [] as never[] },
+		...(id === undefined
+			? {}
+			: {
+					components: [
+						new ActionRowBuilder<ButtonBuilder>().addComponents(
+							new ButtonBuilder()
+								.setCustomId(`${INTERCOM_BUTTON_PREFIX}${id}`)
+								.setLabel(messages().intercomExpand)
+								.setStyle(ButtonStyle.Secondary),
+						),
+					],
+					withComponents: true,
+				}),
+	};
+}
+
+/** A card's message, its whole text kept in `texts` for the open button when the summary leaves part out. */
+export function intercomPost(card: IntercomCard, texts: IntercomTexts) {
+	if (!intercomFolds(card)) return intercomMessage(card, undefined);
+	const id = crypto.randomUUID();
+	texts.remember(id, card.text);
+	return intercomMessage(card, id);
+}
+
+/**
+ * What a press of the open button answers, seen only by whoever pressed: the whole text in
+ * messages within Discord's limit, or one file when it would take more than `MAX_PARTS`.
+ */
+export function intercomReplies(text: string) {
+	const flags = MessageFlags.Ephemeral as const;
+	const allowedMentions = { parse: [] as never[] };
+	const parts = splitReply(text);
+	if (parts.length <= MAX_PARTS)
+		return parts.map((content) => ({ content, flags, allowedMentions }));
+	return [
+		{
+			content: messages().cardCopyFile,
+			files: [
+				new AttachmentBuilder(Buffer.from(text, "utf8"), {
+					name: "message.md",
+				}),
+			],
+			flags,
+			allowedMentions,
+		},
+	];
+}
+
+/**
+ * Answers a press of a card's open button with the card's whole text, to whoever pressed; a text
+ * no longer kept is said to be gone.
+ */
+export function intercomButtonModule(
+	texts: Pick<IntercomTexts, "recall">,
+): InteractionModule {
+	return {
+		commands: () => [],
+		handle: async (interaction: Interaction) => {
+			if (
+				!interaction.isButton() ||
+				!interaction.customId.startsWith(INTERCOM_BUTTON_PREFIX)
+			)
+				return false;
+			const text = texts.recall(
+				interaction.customId.slice(INTERCOM_BUTTON_PREFIX.length),
+			);
+			if (!text) {
+				await interaction.reply({
+					content: messages().intercomGone,
+					flags: MessageFlags.Ephemeral,
+				});
+				return true;
+			}
+			const [first, ...rest] = intercomReplies(text);
+			await interaction.reply(first ?? { content: text });
+			for (const part of rest) await interaction.followUp(part);
+			return true;
+		},
+	};
+}

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

@@ -45,6 +45,9 @@ export function askPrompts(args: {
 						? {
 								wait: {
 									pending: "pending",
+									...(wait.graceMs === undefined
+										? {}
+										: { graceMs: wait.graceMs }),
 									late: (value, by) =>
 										wait.late({
 											kind: "question",
@@ -80,6 +83,9 @@ export function askPrompts(args: {
 						? {
 								wait: {
 									pending: "pending",
+									...(wait.graceMs === undefined
+										? {}
+										: { graceMs: wait.graceMs }),
 									late: (value, by) =>
 										wait.late({
 											kind: "questionnaire",
@@ -123,6 +129,9 @@ export function askPrompts(args: {
 						? {
 								wait: {
 									pending: "pending",
+									...(wait.graceMs === undefined
+										? {}
+										: { graceMs: wait.graceMs }),
 									late: (value, by) =>
 										wait.late({
 											kind: "questionnaire",

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

@@ -120,6 +120,8 @@ export interface CardSpec<T> {
 			by: Answerer,
 			prompt: string,
 		): ReturnType<PromptWait["late"]>;
+		/** The turn's own grace period, in ms, in place of the cards' `graceMs`; see `PromptWait.graceMs`. */
+		graceMs?: number;
 	};
 	/** Hears who approved the card, before it resolves approved in its turn. */
 	approved?(by: Answerer, prompt: string): void;

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

@@ -196,10 +196,11 @@ export class OwnerCards implements InteractionModule {
 		cancelled: T,
 		card: CardSpec<T>,
 	): Promise<T> {
-		const { logger, graceMs = CARD_GRACE_MS, resume } = this.#options;
+		const { logger, resume } = this.#options;
 		if (signal?.aborted || card.supersede?.aborted)
 			return Promise.resolve(cancelled);
 		const wait = resume ? card.wait : undefined;
+		const graceMs = wait?.graceMs ?? this.#options.graceMs ?? CARD_GRACE_MS;
 		const id = randomUUID();
 		if (card.copy !== undefined) this.#copies.remember(id, card.copy);
 		const sections = [

package/src/core/discord/stop-button.ts

@@ -3,7 +3,9 @@ import {
 	ButtonBuilder,
 	ButtonStyle,
 	type Interaction,
+	type Message,
 	MessageFlags,
+	type SendableChannels,
 } from "discord.js";
 import type { ConversationPort } from "../contract/channels.ts";
 import { channelKey } from "../contract/surface.ts";
@@ -11,6 +13,8 @@ import { messages } from "../i18n/index.ts";
 import type { CommandGuard, InteractionModule } from "./interaction-module.ts";
 
 export const STOP_BUTTON_ID = "roundtable:stop";
+/** A turn shorter than this shows no stop button, so quick answers do not flicker one. */
+const STOP_PANEL_DELAY_MS = 5_000;
 
 /** The message a long turn shows: a stop button only an owner may press. */
 export function stopPanel() {
@@ -28,6 +32,37 @@ export function stopPanel() {
 	};
 }
 
+/**
+ * Shows the stop panel in the channel `sendable` finds once the turn has run for
+ * `STOP_PANEL_DELAY_MS`; the returned function hides it, or keeps it from showing. A failure is
+ * handed to `warn` with what failed, never thrown.
+ */
+export function showStopPanel(
+	sendable: () => Promise<SendableChannels>,
+	warn: (error: unknown, what: string) => void,
+): () => void {
+	let hidden = false;
+	let panel: Message | undefined;
+	const remove = (message: Message) =>
+		message
+			.delete()
+			.catch((error: unknown) => warn(error, "stop panel not removed"));
+	const timer = setTimeout(() => {
+		sendable()
+			.then((target): Promise<Message> => target.send(stopPanel()))
+			.then((message) => {
+				if (hidden) void remove(message);
+				else panel = message;
+			})
+			.catch((error: unknown) => warn(error, "stop panel not shown"));
+	}, STOP_PANEL_DELAY_MS);
+	return () => {
+		hidden = true;
+		clearTimeout(timer);
+		if (panel) void remove(panel);
+	};
+}
+
 export interface StopButtonOptions {
 	guard: Pick<CommandGuard, "allows">;
 	/** Stops the running turn of the channel the button was pressed in, through its claim. */

package/src/core/domain/conversation.ts

@@ -72,6 +72,19 @@ export interface PostAuthor {
 	agent?: string;
 }
 
+/**
+ * A message between two agents of the team, which a surface that shows cards draws as a small card
+ * that opens to the whole text.
+ */
+export interface IntercomCard {
+	/** `sent`: a request the author sent; `answered`: the answer that came back; `failed`: none came. */
+	kind: "sent" | "answered" | "failed";
+	/** The agent the request went to, which also gives the answer: its stable name and the name it shows. */
+	peer: { name: string; displayName: string };
+	/** The whole text: the request, the answer, or why no answer came. */
+	text: string;
+}
+
 export interface OutboundReply {
 	/** The assistant's thinking for this turn, posted as a quiet line before the card. */
 	thinking?: string;
@@ -88,4 +101,9 @@ export interface OutboundReply {
 	author?: PostAuthor;
 	/** Set only on the reply for a turn that ended in an error. A surface may show it; Discord ignores it. */
 	failed?: true;
+	/**
+	 * Set on a message between agents: a surface that shows cards draws it in place of `chunks`,
+	 * which carry the same as a short line and the text for a surface that shows none.
+	 */
+	intercom?: IntercomCard;
 }

package/src/core/domain/interim.ts

@@ -10,6 +10,13 @@ export interface InterimMessage {
  */
 export interface InterimPosts {
 	post(text: string): Promise<InterimMessage>;
+	/**
+	 * Whether the turn's progress message names the tools it called, on a line of its own; true
+	 * unless false. A surface that shows the tools elsewhere, such as a progress pane, sets false:
+	 * the progress message then carries only the turn's narration, and a run that wrote none posts
+	 * nothing.
+	 */
+	tools?: boolean;
 }
 
 /** Whether a turn posts its intermediate text as it goes; "on" by default. */

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

@@ -23,6 +23,11 @@ export interface TurnTimeout {
 	tools: [string, number][];
 	/** How long the timeout card waits for an answer. */
 	graceMs: number;
+	/**
+	 * The card goes on by itself when no one answers it in `graceMs`, as Continue would: the
+	 * conversation is in yolo mode and the turn is short of the long-running cap.
+	 */
+	autoContinue?: true;
 	end: TurnTimeoutEnd;
 	/** No timeout card could be shown, as in a schedule's turn, so nobody was asked whether to go on. */
 	unasked?: true;

package/src/core/i18n/conversation.ts

@@ -24,10 +24,17 @@ export function conversationEn(ctx: CatalogContext) {
 		delegationTask: (task: string) => `📋 Task:\n${task}`,
 		delegationDone: (report: string) => `✅ Done\n\n${report}`,
 		delegationFailed: (error: string) => `❌ Failed: ${error}`,
-		agentNoReply: (message: string) => `❌ No reply: ${message}`,
 		messageDelivered: (displayName: string, text: string) =>
 			`📨 To **${displayName}**:\n${text}`,
-		answerReturned: (text: string) => `↩️ Reply:\n${text}`,
+		intercomSent: (displayName: string) => `→ To **${displayName}**`,
+		intercomAnswered: (displayName: string) => `← From **${displayName}**`,
+		intercomFailed: (displayName: string) =>
+			`⚠️ No answer from **${displayName}**`,
+		intercomLine: (heading: string, summary: string) =>
+			summary ? `${heading}: ${summary}` : heading,
+		intercomExpand: "Show all",
+		intercomGone:
+			"The full text of this message is no longer kept; it is still in the agents' conversations.",
 		thinkingAuto: "auto",
 		confirmTitle: (asker: string) => `${asker} wants to run this action`,
 		holdGeneric: (tool: string) => `run ${tool}`,
@@ -57,10 +64,15 @@ export function conversationZhTW(
 		delegationTask: (task: string) => `📋 任務：\n${task}`,
 		delegationDone: (report: string) => `✅ 完成\n\n${report}`,
 		delegationFailed: (error: string) => `❌ 失敗：${error}`,
-		agentNoReply: (message: string) => `❌ 沒有回覆：${message}`,
 		messageDelivered: (displayName: string, text: string) =>
 			`📨 給 **${displayName}**：\n${text}`,
-		answerReturned: (text: string) => `↩️ 回覆：\n${text}`,
+		intercomSent: (displayName: string) => `→ 給 **${displayName}**`,
+		intercomAnswered: (displayName: string) => `← 來自 **${displayName}**`,
+		intercomFailed: (displayName: string) => `⚠️ **${displayName}** 沒有回覆`,
+		intercomLine: (heading: string, summary: string) =>
+			summary ? `${heading}：${summary}` : heading,
+		intercomExpand: "展開全文",
+		intercomGone: "這則對講的全文已經不在了；夥伴們的對話裡還找得到。",
 		thinkingAuto: "自動",
 		confirmTitle: (asker: string) => `${asker} 要執行這個動作`,
 		holdGeneric: (tool: string) => `執行 ${tool}`,

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

@@ -51,7 +51,9 @@ export function turnTimeoutEn() {
 				`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.`,
+				t.autoContinue
+					? `It keeps working while this card is open. Continue gives it another ${durationEn(budgetMs)}; Cancel stops it. Yolo mode is on: with no answer in ${durationEn(t.graceMs)} it keeps going by itself.`
+					: `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"),
@@ -64,6 +66,8 @@ export function turnTimeoutEn() {
 		turnTimeoutFinished: "✅ The turn finished; nothing to answer.",
 		turnTimeoutUnanswered: (t: TurnTimeout) =>
 			`⏱️ No answer in ${durationEn(t.graceMs)}; the turn was stopped.`,
+		turnTimeoutAutoContinued: (t: TurnTimeout) =>
+			`⏱️ No answer in ${durationEn(t.graceMs)}; yolo mode is on, so the turn continued automatically.`,
 		turnTimedOutNotice: (t: TurnTimeout) => {
 			const what =
 				t.running.length > 0
@@ -105,7 +109,9 @@ export function turnTimeoutZhTW(): ReturnType<typeof turnTimeoutEn> {
 				`已達到${limit(t)}，已工作 ${durationZh(t.workedMs)}。`,
 				`現在：${doing(t)}。`,
 				tools(t),
-				`這張卡片開著時它會繼續工作。按「繼續」再給它 ${durationZh(budgetMs)}；按「取消」停止。${durationZh(t.graceMs)}內沒有回答就會停止。`,
+				t.autoContinue
+					? `這張卡片開著時它會繼續工作。按「繼續」再給它 ${durationZh(budgetMs)}；按「取消」停止。Yolo 模式已開啟：${durationZh(t.graceMs)}內沒有回答，它會自己繼續。`
+					: `這張卡片開著時它會繼續工作。按「繼續」再給它 ${durationZh(budgetMs)}；按「取消」停止。${durationZh(t.graceMs)}內沒有回答就會停止。`,
 			]
 				.filter(Boolean)
 				.join("\n"),
@@ -117,6 +123,8 @@ export function turnTimeoutZhTW(): ReturnType<typeof turnTimeoutEn> {
 		turnTimeoutFinished: "✅ 這一輪已完成，不需要回答。",
 		turnTimeoutUnanswered: (t: TurnTimeout) =>
 			`⏱️ ${durationZh(t.graceMs)}內沒有回答，這一輪已停止。`,
+		turnTimeoutAutoContinued: (t: TurnTimeout) =>
+			`⏱️ ${durationZh(t.graceMs)}內沒有回答；Yolo 模式已開啟，這一輪已自動繼續。`,
 		turnTimedOutNotice: (t: TurnTimeout) => {
 			const what =
 				t.running.length > 0

package/src/core/interactions/prompts.ts

@@ -202,6 +202,11 @@ export type LateAnswer = { by: string } & (
  */
 export interface PromptWait {
 	late(answer: LateAnswer): string | undefined;
+	/**
+	 * How long this turn waits before `pending`, in ms, in place of the surface's own grace period;
+	 * a yolo turn asks with a shorter one. A surface that keeps no grace period ignores it.
+	 */
+	graceMs?: number;
 }
 
 /**

package/src/core/modes/autonomy.ts

@@ -8,6 +8,16 @@ export interface Autonomy {
 		allow: readonly string[];
 		/** Hold classes or rule names yolo never approves, such as `shell.push` or `tool:repo_push`. */
 		card: readonly string[];
+		/**
+		 * How long an `ask_user` card holds a yolo turn before it goes on with its own best choice, in
+		 * ms; the card stays open. Default `DEFAULT_YOLO_QUESTION_GRACE_MS`, 30 seconds.
+		 */
+		questionGraceMs?: number;
+		/**
+		 * How long the timeout card waits in a yolo conversation before the turn goes on as if
+		 * Continue were pressed, in ms. Default `DEFAULT_YOLO_TIMEOUT_CARD_GRACE_MS`, one minute.
+		 */
+		timeoutCardGraceMs?: number;
 	};
 	/** The most one long-running turn works in all before it asks or stops, in ms. */
 	longRunningMaxMs: number;
@@ -16,8 +26,19 @@ export interface Autonomy {
 /** The longest a long-running turn works without a person: four hours. */
 export const DEFAULT_LONG_RUNNING_MS = 4 * 60 * 60_000;
 
+/** How long a yolo turn waits on its `ask_user` card before it goes on: 30 seconds. */
+export const DEFAULT_YOLO_QUESTION_GRACE_MS = 30_000;
+
+/** How long a yolo turn's timeout card waits before the turn goes on by itself: one minute. */
+export const DEFAULT_YOLO_TIMEOUT_CARD_GRACE_MS = 60_000;
+
 /** Yolo approves nothing beyond its built-in classes, and a long-running turn stops at four hours. */
 export const DEFAULT_AUTONOMY: Autonomy = Object.freeze({
-	yolo: Object.freeze({ allow: [], card: [] }),
+	yolo: Object.freeze({
+		allow: [],
+		card: [],
+		questionGraceMs: DEFAULT_YOLO_QUESTION_GRACE_MS,
+		timeoutCardGraceMs: DEFAULT_YOLO_TIMEOUT_CARD_GRACE_MS,
+	}),
 	longRunningMaxMs: DEFAULT_LONG_RUNNING_MS,
 });