pi-roundtable 0.27.1 → 0.28.0

package/src/core/modes/mode-inheritance.ts

@@ -0,0 +1,78 @@
+import type { ChannelKey } from "../sessions.ts";
+import type { ConversationMode } from "./conversation-modes.ts";
+
+/**
+ * What the agent server says of a conversation that follows another's modes, given to
+ * `ConversationModes.trackOrigins`.
+ */
+export interface ModeOrigins {
+	/**
+	 * Whether `channel` still follows `origin`, as a temp knight's conversation follows the one it
+	 * was made from, and the origin's name to show: undefined when it no longer does (its agent is
+	 * gone, or the name is another agent's now), so its own modes count again; `alive: false` when
+	 * the origin conversation is gone, so both modes read off.
+	 */
+	originOf(
+		channel: ChannelKey,
+		origin: ChannelKey,
+	): { name: string; alive: boolean } | undefined;
+}
+
+/** A conversation's stored modes, and the conversation it follows when it follows one. */
+export interface StoredMode {
+	own: ConversationMode;
+	follows?: ChannelKey;
+}
+
+const OFF: ConversationMode = Object.freeze({
+	yolo: false,
+	longRunning: false,
+});
+
+/**
+ * A conversation's modes as they apply now: its own, or, for one that follows another, the
+ * origin's own modes with `inheritedFrom`, both off when the origin is gone. One level only: an
+ * origin's modes are its own, whatever it follows. Without `origins` an origin counts as alive.
+ */
+export function resolveMode(
+	channel: ChannelKey,
+	stored: (channel: ChannelKey) => StoredMode | undefined,
+	origins: ModeOrigins | undefined,
+): ConversationMode {
+	const mine = stored(channel);
+	if (!mine) return OFF;
+	const follows = mine.follows;
+	if (follows === undefined) return mine.own;
+	const origin = origins
+		? origins.originOf(channel, follows)
+		: { name: undefined, alive: true };
+	if (!origin) return mine.own;
+	const from = origin.alive ? (stored(follows)?.own ?? OFF) : OFF;
+	return Object.freeze({
+		yolo: from.yolo,
+		longRunning: from.longRunning,
+		...(from.changedBy === undefined ? {} : { changedBy: from.changedBy }),
+		...(from.changedAt === undefined ? {} : { changedAt: from.changedAt }),
+		inheritedFrom: {
+			channel: follows,
+			...(origin.name === undefined ? {} : { name: origin.name }),
+			...(origin.alive ? {} : { gone: true as const }),
+		},
+	});
+}
+
+/** The conversations that follow `origin` now, from every stored one. */
+export function followersOf(
+	origin: ChannelKey,
+	all: Iterable<[ChannelKey, StoredMode]>,
+	origins: ModeOrigins | undefined,
+): ChannelKey[] {
+	const found: ChannelKey[] = [];
+	for (const [channel, mode] of all)
+		if (
+			mode.follows === origin &&
+			(!origins || origins.originOf(channel, origin) !== undefined)
+		)
+			found.push(channel);
+	return found;
+}

package/src/core/modes/modes-plugin.ts

@@ -13,7 +13,7 @@ export const MODES_PLUGIN = "modes";
 export function modesPlugin(): RoundtablePlugin {
 	return {
 		name: MODES_PLUGIN,
-		migrations: [PgConversationModes.migration],
+		migrations: [...PgConversationModes.migrations],
 		provides: [MODES],
 		setup: ({ database, logger, services }) => {
 			const modes = PgConversationModes.attach(database(), logger);

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

@@ -41,6 +41,8 @@ export interface SkillRegistry {
 	): Promise<SkillDocument>;
 	/** Makes a skill from a whole SKILL.md, as `skill_create` does; it is attached to no one. Throws AgentError for a taken or refused name or text. */
 	createDocument(text: string, by: string): Promise<SkillDocument>;
+	/** Deletes an agent-written skill and detaches it from every agent and group, as `skill_delete` does; returns what it was detached from. Throws AgentError for any other skill. */
+	delete(name: string): Promise<string>;
 	/** The saved versions of an agent-written skill, newest first; none for any other skill. */
 	documentHistory(name: string): Promise<SkillVersion[]>;
 	/** Adds and removes an agent's registered skills together, or changes nothing; returns what it carries after. */

package/src/core/presentation/intercom.ts

@@ -0,0 +1,44 @@
+import type { IntercomCard } from "../domain/conversation.ts";
+import { messages } from "../i18n/index.ts";
+
+/** The most characters of a card's summary line. */
+export const INTERCOM_SUMMARY_CHARS = 120;
+
+/**
+ * The first line of the text that has words in it, without a Markdown heading's marks, cut to
+ * `max` characters with an ellipsis and never through a surrogate pair.
+ */
+export function intercomSummary(
+	text: string,
+	max = INTERCOM_SUMMARY_CHARS,
+): string {
+	const line =
+		text
+			.split("\n")
+			.map((one) => one.trim())
+			.find((one) => one !== "") ?? "";
+	const plain = line.replace(/^#{1,6}\s+/, "");
+	if (plain.length <= max) return plain;
+	const last = plain.charCodeAt(max - 2);
+	const cut = last >= 0xd800 && last <= 0xdbff ? max - 2 : max - 1;
+	return `${plain.slice(0, cut)}…`;
+}
+
+/** Whether the summary leaves part of the text out, so the card offers to open to the rest. */
+export function intercomFolds(card: IntercomCard): boolean {
+	return intercomSummary(card.text) !== card.text.trim();
+}
+
+/** The card's heading: whom the request went to, or whom the answer came from. */
+export function intercomHeading(card: IntercomCard): string {
+	const text = messages();
+	const name = card.peer.displayName;
+	if (card.kind === "sent") return text.intercomSent(name);
+	if (card.kind === "answered") return text.intercomAnswered(name);
+	return text.intercomFailed(name);
+}
+
+/** The card as plain text, for a surface that shows no cards: its heading, then the whole text. */
+export function intercomPlain(card: IntercomCard): string {
+	return `${intercomHeading(card)}\n${card.text}`;
+}

package/src/core/runtime/ask-questions.ts

@@ -12,6 +12,7 @@ import {
 	lateAnswerText,
 	lateQuestionnaireText,
 	questionnaireText,
+	restartingText,
 	sequentialText,
 } from "./extensions/ask-user-text.ts";
 
@@ -19,7 +20,11 @@ import {
  * Asks a questionnaire on `prompts` and returns the tool's result text. A set the core refuses
  * posts no card. One question without previews, and a surface without `questionnaire` or with
  * room for fewer questions, go through `ask`: one question exactly as before 0.20, several one
- * at a time, stopping at the first that does not come back answered.
+ * at a time, stopping at the first that does not come back answered. While the host stops
+ * (`stopping`), no card is posted, and one left waiting is reported lost: open cards do not
+ * survive the restart. With `yoloGraceMs`, the turn's conversation is in yolo mode: each card
+ * holds the turn that long at most, and one left unanswered tells it to go on with its own best
+ * choice instead of ending its turn; the restart still wins over that.
  */
 export async function askQuestions(
 	prompts: Prompts,
@@ -27,9 +32,16 @@ export async function askQuestions(
 	questionnaire: Questionnaire,
 	owner: OwnerIdentity,
 	signal: AbortSignal | undefined,
+	stopping?: () => boolean,
+	yoloGraceMs?: number,
 ): Promise<string> {
+	const yolo = yoloGraceMs !== undefined;
+	const grace = yolo ? { graceMs: yoloGraceMs } : {};
 	const refused = validateQuestionnaire(questionnaire);
 	if (refused !== undefined) return refused;
+	if (stopping?.()) return restartingText(owner, false);
+	const lost = (answer: unknown) =>
+		answer === "pending" && stopping?.() === true;
 	const title = messages().askTitle(asker);
 	const n = questionnaire.questions.length;
 	const support = prompts.asks;
@@ -47,6 +59,7 @@ export async function askQuestions(
 			shapeFor(questionnaire, support),
 			signal,
 			{
+				...grace,
 				late: (late) =>
 					late.kind === "questionnaire"
 						? n === 1
@@ -59,33 +72,37 @@ export async function askQuestions(
 						: undefined,
 			},
 		);
+		if (lost(answer)) return restartingText(owner, true);
 		if (n === 1)
 			return answerText(
 				answer === "pending" || answer === "declined" || answer === undefined
 					? answer
 					: (answer.answers[0] ?? { choices: [] }),
 				owner,
+				yolo,
 			);
-		return questionnaireText(answer, questionnaire, owner);
+		return questionnaireText(answer, questionnaire, owner, yolo);
 	}
 	const shaped = shapeFor(questionnaire, SINGLE_QUESTION);
 	const answers: OwnerAnswer[] = [];
 	for (const [i, question] of shaped.questions.entries()) {
 		const text = questionnaire.questions[i]?.question ?? question.question;
 		const answer = await prompts.ask(title, question, signal, {
+			...grace,
 			late: (late) =>
 				late.kind === "question"
 					? lateAnswerText(text, late.answer, late.by)
 					: undefined,
 		});
-		if (n === 1) return answerText(answer, owner);
+		if (lost(answer)) return restartingText(owner, true);
+		if (n === 1) return answerText(answer, owner, yolo);
 		if (answer === "pending" || answer === "declined" || answer === undefined)
 			return sequentialText(
 				questionnaire,
 				answers,
 				answer ?? "unanswered",
 				owner,
-				answerText(answer, owner),
+				answerText(answer, owner, yolo),
 			);
 		answers.push(answer);
 	}

package/src/core/runtime/extensions/ask-user-text.ts

@@ -9,14 +9,37 @@ import type {
 /** The longest a question's name is when it has no header, in characters. */
 const NAME_CHARS = 120;
 
-/** The tool's result: what the owner chose and wrote. */
+/**
+ * When a question truly blocks a yolo turn: the one case it may end waiting for the answer. Shared
+ * by the unanswered result and the yolo note, so the two never say it differently.
+ */
+function trulyBlocks(o: ReturnType<typeof ownerWords>): string {
+	return `Only a question that truly blocks may end your turn: one with no safe choice without the answer, such as an irreversible or outward-facing step whose direction only ${o.he} can pick. Then first finish every part of the work the answer does not affect, and end your turn saying what you are waiting for.`;
+}
+
+/**
+ * The note a yolo turn's system prompt carries: work on without waiting for the owner, and end the
+ * turn with a question only when it truly blocks.
+ */
+export function yoloAskNote(owner: OwnerIdentity): string {
+	const o = ownerWords(owner);
+	return `Yolo mode is on in this conversation: keep working without waiting for ${o.name}, and do not end your turn with a question. When an ask_user card goes unanswered, go on with your recommended option, or your best judgment where you offered none, and say in your reply what you assumed; ${o.his} later answer comes in a new turn to correct course. ${trulyBlocks(o)}`;
+}
+
+/**
+ * The tool's result: what the owner chose and wrote. `yolo`: the turn's conversation is in yolo
+ * mode, so a question not answered in its short wait does not end the turn.
+ */
 export function answerText(
 	answer: OwnerAnswer | "pending" | "declined" | undefined,
 	owner: OwnerIdentity,
+	yolo = false,
 ): string {
 	const o = ownerWords(owner);
 	if (answer === "declined")
 		return `${o.name} cancelled the question on its card without answering. Do not ask the same question again. Continue without the answer, or, if you cannot go on without it, end your turn saying so.`;
+	if (answer === "pending" && yolo)
+		return `${o.name} has not answered yet, and yolo mode is on in this conversation, so keep working: do not end your turn and do not ask again. Go on with your recommended option, or your best judgment where you offered none, and say in your reply what you assumed. The card stays open; if ${o.he} answers later, a new turn brings you the answer and you correct course from there. ${trulyBlocks(o)}`;
 	if (answer === "pending")
 		return `${o.name} has not answered yet. The card stays open, so do not ask again and do not wait for it. End your turn now: say briefly that you are waiting for ${o.his} answer on the card. When ${o.he} answers, a new turn brings you the answer and you continue from there.`;
 	if (!answer)
@@ -30,6 +53,15 @@ export function answerText(
 	return lines.length > 0 ? lines.join("\n") : `${o.name} chose nothing.`;
 }
 
+/**
+ * The tool's result while the server restarts: open cards live in its memory and are gone after
+ * the restart, so a new card is not posted (`opened` false) and one still waiting will be lost.
+ */
+export function restartingText(owner: OwnerIdentity, opened: boolean): string {
+	const o = ownerWords(owner);
+	return `${opened ? `${o.name} has not answered yet, and the server is restarting: the card closes with it, so ${o.his} answer cannot reach you through it.` : `The server is restarting, so no card was posted: a card would not survive the restart.`} Do not call ask_user again in this turn. Write the question as your final answer instead; it is posted to this channel for ${o.him} to read, and ${o.his} answer comes in a new turn.`;
+}
+
 /** The turn a late answer starts: the question it answers and what was chosen and written. */
 export function lateAnswerText(
 	question: string,
@@ -72,14 +104,15 @@ function listOf(
 	];
 }
 
-/** The tool's result for a questionnaire: each question's answer, and the note. */
+/** The tool's result for a questionnaire: each question's answer, and the note; `yolo` as for `answerText`. */
 export function questionnaireText(
 	answer: QuestionnaireAnswer | "pending" | "declined" | undefined,
 	questionnaire: Questionnaire,
 	owner: OwnerIdentity,
+	yolo = false,
 ): string {
 	if (answer === "pending" || answer === "declined" || !answer)
-		return answerText(answer, owner);
+		return answerText(answer, owner, yolo);
 	return [
 		`${owner.name} answered your questions on the card:`,
 		...listOf(questionnaire, answer),

package/src/core/runtime/extensions/ask-user.ts

@@ -3,24 +3,42 @@ import { type Static, Type } from "typebox";
 import { type OwnerIdentity, ownerWords } from "../../identity.ts";
 import type { OwnerQuestion } from "../../interactions/prompts.ts";
 import { QUESTIONNAIRE_LIMITS as L } from "../../interactions/questionnaire.ts";
+import { DEFAULT_YOLO_QUESTION_GRACE_MS } from "../../modes/autonomy.ts";
 import { toolText } from "../../shared/tool-result.ts";
 import { askQuestions } from "../ask-questions.ts";
 import type { PromptSlot } from "../prompt-slot.ts";
 import { foldAskArguments } from "./ask-user-arguments.ts";
+import { yoloAskNote } from "./ask-user-text.ts";
 
 export { answerText, lateAnswerText } from "./ask-user-text.ts";
 
 export const ASK_USER_TOOL = "ask_user";
 
-/** Registers ask_user, which asks the owner on a card in the turn's channel and waits. */
+/**
+ * Registers ask_user, which asks the owner on a card in the turn's channel and waits. In a turn
+ * whose conversation is in yolo mode (`slot.yolo`), a card holds the turn `yoloGraceMs` at most and
+ * an unanswered one does not end it, and the system prompt carries the yolo note.
+ */
 export function askUserExtension(
 	slot: PromptSlot,
 	owner: OwnerIdentity,
 	/** Whom the running turn is for, when not the owner; the answer's words name them. */
 	addressee?: () => OwnerIdentity,
+	/** Whether the host is shutting down: no card is posted then, as none survives the restart. */
+	stopping?: () => boolean,
+	/** How long a card holds a yolo turn, in ms; default `DEFAULT_YOLO_QUESTION_GRACE_MS`. */
+	yoloGraceMs: number = DEFAULT_YOLO_QUESTION_GRACE_MS,
 ): ExtensionFactory {
 	const o = ownerWords(owner);
 	return (pi) => {
+		pi.on("before_agent_start", (event) => {
+			if (!slot.yolo) return;
+			const note = yoloAskNote(addressee?.() ?? owner);
+			const appended = event.systemPromptOptions.appendSystemPrompt;
+			event.systemPromptOptions.appendSystemPrompt = appended
+				? `${appended}\n\n${note}`
+				: note;
+		});
 		const parameters = Type.Object(
 			{
 				questions: Type.Array(
@@ -113,6 +131,8 @@ export function askUserExtension(
 						},
 						addressee?.() ?? owner,
 						signal,
+						stopping,
+						slot.yolo ? yoloGraceMs : undefined,
 					),
 				);
 			},

package/src/core/runtime/interim-text.ts

@@ -86,8 +86,9 @@ export interface InterimPosterOptions {
 /**
  * Posts a turn's intermediate text as it goes. A tool-calling assistant message whose text is
  * primary is posted as ordinary messages; shorter text joins the run's progress message with
- * the tools called, edited in place. A primary post or a card starts a new run. Posts go out
- * in order, and a failed one is logged, never thrown.
+ * the tools called, edited in place, or without them where the posts say `tools: false`. A
+ * primary post or a card starts a new run. Posts go out in order, and a failed one is logged,
+ * never thrown.
  */
 export class InterimPoster {
 	readonly #posts: InterimPosts;
@@ -163,9 +164,11 @@ export class InterimPoster {
 	}
 
 	#render(run: Run): void {
-		if (run.lines.length === 0 && run.tools.size === 0) return;
+		// A surface that shows the tools elsewhere gets no tool line.
+		const tools = this.#posts.tools === false ? new Map() : run.tools;
+		if (run.lines.length === 0 && tools.size === 0) return;
 		run.lastAt = now();
-		const text = progressText(run.lines, run.tools);
+		const text = progressText(run.lines, tools);
 		this.#enqueue(async () => {
 			if (text === run.shown) return;
 			if (run.message) await run.message.edit(text);

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

@@ -266,6 +266,7 @@ export class PiAgentRuntime implements AgentRuntime {
 				: undefined,
 			request.agent?.name ?? assistantName(),
 			interim ? () => interim.flush() : undefined,
+			() => this.#options.modes?.peek(request.channel).yolo === true,
 		);
 		// A model that ignores the abort must not hold the turn: its session is disposed of instead.
 		const guard = new AbortGuard(session, {
@@ -421,8 +422,7 @@ export class PiAgentRuntime implements AgentRuntime {
 		const timer = setTimeout(abort, task.timeoutMs);
 		try {
 			const registered = new Set(session.getAllTools().map((t) => t.name));
-			// A worker that loaded the reader's memory may report it: the call that started it, and the
-			// calls that one runs within, then record their results as the reader's.
+			// A worker that loaded the reader's memory: its starting call and the calls within it report as the reader's.
 			if (memoryReader(conversation, turn.speaker) && loadsMemory(registered)) {
 				parent.draws.drawn(runningCalls());
 				this.#memoryTurns.get(scope.turn)?.();

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

@@ -18,6 +18,7 @@ import { turnBudget } from "./turn-budget.ts";
 export class PromptSlot {
 	#prompts: Prompts | undefined;
 	#beforeCard: (() => Promise<void>) | undefined;
+	#yolo: (() => boolean) | undefined;
 	#asker = assistantName();
 	#open = 0;
 	#openSince = 0;
@@ -26,15 +27,18 @@ export class PromptSlot {
 
 	/**
 	 * Binds the turn's prompts; `asker` names who asks, the assistant or an agent. `beforeCard`
-	 * runs before each card opens, such as posting the text the turn wrote before it.
+	 * runs before each card opens, such as posting the text the turn wrote before it. `yolo` says
+	 * whether the turn's conversation is in yolo mode now, read each time a card asks.
 	 */
 	bind(
 		prompts: Prompts | undefined,
 		asker: string,
 		beforeCard?: () => Promise<void>,
+		yolo?: () => boolean,
 	): void {
 		this.#prompts = prompts;
 		this.#beforeCard = beforeCard;
+		this.#yolo = yolo;
 		this.#asker = asker;
 		this.#open = 0;
 		this.#waited = 0;
@@ -56,12 +60,18 @@ export class PromptSlot {
 	unbind(): void {
 		this.#prompts = undefined;
 		this.#beforeCard = undefined;
+		this.#yolo = undefined;
 	}
 
 	get asker(): string {
 		return this.#asker;
 	}
 
+	/** Whether the bound turn's conversation is in yolo mode now; false with none bound. */
+	get yolo(): boolean {
+		return this.#yolo?.() === true;
+	}
+
 	/** The turn's prompts, each open card counted as waiting; undefined when none is bound. */
 	get prompts(): Prompts | undefined {
 		const prompts = this.#prompts;

package/src/core/runtime/session-factory.ts

@@ -425,12 +425,17 @@ export class SessionFactory {
 					confirmationGate: confirmationGateExtension(gate, slot, (signal) =>
 						toolTurn(context, signal),
 					),
-					askUser: askUserExtension(slot, addressee, () =>
-						turnAddressee(
-							this.#deps.speaker(turnKey),
-							state,
-							this.#options.owner,
-						),
+					askUser: askUserExtension(
+						slot,
+						addressee,
+						() =>
+							turnAddressee(
+								this.#deps.speaker(turnKey),
+								state,
+								this.#options.owner,
+							),
+						this.#options.stopping,
+						this.#options.autonomy?.yolo.questionGraceMs,
 					),
 					selfCompactGuard: selfCompactGuardExtension(),
 					// Each request carries no one's memory but the running turn's reader's.

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

@@ -5,6 +5,7 @@ import type {
 } from "../domain/turn-timeout.ts";
 import { messages } from "../i18n/index.ts";
 import type { Approval } from "../interactions/prompts.ts";
+import { DEFAULT_YOLO_TIMEOUT_CARD_GRACE_MS } from "../modes/autonomy.ts";
 import type { ChannelKey } from "../sessions.ts";
 import type { PromptSlot } from "./prompt-slot.ts";
 import type { PiAgentRuntimeOptions } from "./runtime-types.ts";
@@ -129,6 +130,14 @@ export interface TurnBudgetSeams {
 	 * fires at it, as the turn's cap, so a long time limit cannot overshoot the long-running cap.
 	 */
 	ceilingMs?: number;
+	/**
+	 * Whether the turn's conversation is in yolo mode, asked when a limit fires: its timeout card
+	 * then waits `yoloCardMs` and, unanswered, extends the turn as Continue would, up to
+	 * `ceilingMs` of work. Past that, or without `ceilingMs`, the card is the usual one.
+	 */
+	yolo?: () => boolean;
+	/** How long a yolo turn's timeout card waits, in ms; default `DEFAULT_YOLO_TIMEOUT_CARD_GRACE_MS`. */
+	yoloCardMs?: number;
 }
 
 /**
@@ -139,6 +148,8 @@ export interface TurnBudgetSeams {
  * 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.
  * When `seams.keepGoing` says so, the limit is extended server-side first and neither happens.
+ * In a yolo conversation (`seams.yolo`) short of `seams.ceilingMs`, the card waits
+ * `seams.yoloCardMs` instead, and no answer extends the turn as Continue would, up to the ceiling.
  */
 export function runtimeTurnBudget(
 	options: Pick<
@@ -160,15 +171,24 @@ export function runtimeTurnBudget(
 		limit: TurnLimit,
 		limitMs: number,
 		end: TurnTimeoutEnd,
+		auto = false,
 	): TurnTimeout => ({
 		limit,
 		limitMs,
 		workedMs: budget.workedMs(),
 		...seams.activity.now(clock.now()),
-		graceMs,
+		graceMs: auto
+			? (seams.yoloCardMs ?? DEFAULT_YOLO_TIMEOUT_CARD_GRACE_MS)
+			: graceMs,
 		end,
+		...(auto ? { autoContinue: true as const } : {}),
 		...(slot.cards ? {} : { unasked: true as const }),
 	});
+	/** Whether an unanswered card goes on by itself: a yolo conversation short of the ceiling. */
+	const autoContinues = () =>
+		seams.ceilingMs !== undefined &&
+		budget.workedMs() < seams.ceilingMs &&
+		seams.yolo?.() === true;
 	const stop = (timeout: TurnTimeout) => {
 		logger.warn(
 			{
@@ -202,13 +222,15 @@ export function runtimeTurnBudget(
 			const prompts = slot.cards;
 			if (!prompts) return stop(reason(limit, limitMs, "timeout"));
 			const m = messages();
-			const asked = reason(limit, limitMs, "timeout");
+			const auto = autoContinues();
+			const asked = reason(limit, limitMs, "timeout", auto);
 			logger.info(
 				{
 					channel,
 					limit,
 					workedMs: asked.workedMs,
 					running: asked.running,
+					...(auto ? { yolo: true } : {}),
 				},
 				"turn reached its time limit; asking the owner",
 			);
@@ -223,10 +245,19 @@ export function runtimeTurnBudget(
 			};
 			const cancelGrace = clock.schedule(() => {
 				if (!settle()) return;
+				if (auto) {
+					controller.abort(m.turnTimeoutAutoContinued(asked));
+					budget.extend(limit === "turnMax", seams.ceilingMs);
+					logger.info(
+						{ channel, limit, workedMs: budget.workedMs() },
+						"yolo mode continued the turn; the timeout card went unanswered",
+					);
+					return;
+				}
 				const timeout = reason(limit, limitMs, "unanswered");
 				controller.abort(m.turnTimeoutUnanswered(timeout));
 				stop(timeout);
-			}, graceMs);
+			}, asked.graceMs);
 			closeCard = (footer) => {
 				if (settle()) controller.abort(footer);
 			};

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

@@ -35,7 +35,9 @@ export function timeoutMessage(timeout: TurnTimeout): string {
 /**
  * The time limit of a turn of the built-in runtime; see `runtimeTurnBudget`. `abort` aborts the
  * turn. In a long-running conversation (`options.modes`) a limit extends the turn instead of
- * asking or aborting, until the turn has worked `options.autonomy.longRunningMaxMs`. A
+ * asking or aborting, until the turn has worked `options.autonomy.longRunningMaxMs`; in a yolo
+ * conversation the card waits `autonomy.yolo.timeoutCardGraceMs` and, unanswered, goes on up to
+ * that same cap. A
  * `timeLimitMs` replaces the turn's limit and its cap, both held under that same ceiling.
  */
 export function turnLimits(
@@ -46,7 +48,7 @@ export function turnLimits(
 	abort: () => void,
 	timeLimitMs?: number,
 ): TurnLimits {
-	const { longRunningMaxMs } = options.autonomy ?? DEFAULT_AUTONOMY;
+	const { longRunningMaxMs, yolo } = options.autonomy ?? DEFAULT_AUTONOMY;
 	const limited =
 		timeLimitMs === undefined
 			? options
@@ -68,7 +70,15 @@ export function turnLimits(
 			timedOut = timeout;
 			abort();
 		},
-		{ activity, keepGoing, ceilingMs: longRunningMaxMs },
+		{
+			activity,
+			keepGoing,
+			ceilingMs: longRunningMaxMs,
+			yolo: () => options.modes?.peek(channel).yolo === true,
+			...(yolo.timeoutCardGraceMs === undefined
+				? {}
+				: { yoloCardMs: yolo.timeoutCardGraceMs }),
+		},
 	);
 	return {
 		budget,

package/src/index.ts

@@ -153,6 +153,7 @@ export type {
 } from "./core/domain/client.ts";
 export type {
 	HeldCall,
+	IntercomCard,
 	OutboundReply,
 	PendingConfirmation,
 	PostAuthor,