pi-roundtable 0.26.0 → 0.26.2

package/src/core/agents/team-turn-types.ts

@@ -7,6 +7,7 @@ import type {
 	TurnResult,
 } from "../domain/conversation.ts";
 import type { AgentTurnScope } from "../domain/ports.ts";
+import type { IdentityService } from "../identity/identity-port.ts";
 import type { OwnerIdentity } from "../identity.ts";
 import type { Logger } from "../log.ts";
 import type { EventSink } from "../plugin.ts";
@@ -85,6 +86,12 @@ export interface TeamTurnsOptions {
 	changed(): void;
 	/** Where turns and team changes are reported for the plugins' handlers. */
 	events?: EventSink;
+	/**
+	 * The identity service, read when a kept agent message is replayed: its speaker runs again only
+	 * as a principal that still exists and is enabled, at no more than its tier now. Without one, the
+	 * stored speaker is kept.
+	 */
+	principals?: () => Pick<IdentityService, "speakerFor"> | undefined;
 	/** A thread for each message between agents; without it both go in the sender's channel. */
 	threads?: Pick<DispatchThreads, "open">;
 }
@@ -94,8 +101,29 @@ export interface TurnExtra {
 	attachments?: TurnAttachments;
 	confirmed?: boolean;
 	steerable?: boolean;
+	/** A person's message started it. */
+	byMessage?: boolean;
 	/** The owner started it by writing, or it delivers a report, so it may ask them on cards. */
 	interactive?: boolean;
+	/** No person waits on the answer, so an empty one is no failure. */
+	unattended?: boolean;
+	/** How long the turn may work, in ms, in place of the default; a schedule's own limit. */
+	timeLimitMs?: number;
+}
+
+/** The fields of `extra` that a turn request carries, left out where unset. */
+export function turnFlags(extra: TurnExtra) {
+	return {
+		...(extra.attachments ? { attachments: extra.attachments } : {}),
+		...(extra.confirmed ? { confirmed: true } : {}),
+		...(extra.steerable ? { steerable: true } : {}),
+		...(extra.byMessage ? { byMessage: true } : {}),
+		...(extra.interactive ? { interactive: true } : {}),
+		...(extra.unattended ? { unattended: true } : {}),
+		...(extra.timeLimitMs === undefined
+			? {}
+			: { timeLimitMs: extra.timeLimitMs }),
+	};
 }
 
 /** What the team's message and group collaborators need of the turns that own their state. */

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

@@ -11,7 +11,7 @@ import { AgentError } from "../domain/errors.ts";
 import type { InterimPosts } from "../domain/interim.ts";
 import type { AgentTurnScope } from "../domain/ports.ts";
 import type { TurnProgress } from "../domain/progress.ts";
-import { replyBody } from "../presentation/reply-body.ts";
+import { isQuiet, replyBody } from "../presentation/reply-body.ts";
 import { splitReply } from "../presentation/reply-splitter.ts";
 import { withReplyFiles } from "../reply-files.ts";
 import { endOf, settleTurn } from "../routing/settle-turn.ts";
@@ -28,9 +28,9 @@ import {
 	coordinatorOf,
 	discordIdOf,
 	discordKey,
-	homeScope,
 	keysOf,
 	roomScope,
+	scopeOf,
 } from "./team-keys.ts";
 import {
 	type Chain,
@@ -38,6 +38,7 @@ import {
 	type TeamTurnsOptions,
 	type TurnExtra,
 	type TurnHost,
+	turnFlags,
 } from "./team-turn-types.ts";
 
 export { MAX_CHAIN_MESSAGES, type TeamTurnsOptions };
@@ -95,8 +96,8 @@ export class TeamTurns {
 	}
 
 	/**
-	 * The owner's message in an agent's channel; call inside the channel's queue. `text`
-	 * carries the reference, `replyText` is what they typed.
+	 * The owner's message in an agent's channel; call inside its queue. `text` carries the
+	 * reference, `replyText` is what they typed.
 	 */
 	async answerOwner(
 		channel: ChannelKey,
@@ -106,7 +107,7 @@ export class TeamTurns {
 		attachments: TurnAttachments,
 	): Promise<TurnResult> {
 		const agent = this.#agentOf(channel);
-		const scope = this.#scopeOf(agent, channel);
+		const scope = scopeOf(agent, channel);
 		const pending = await this.#options.runtime().heldActions(scope.session);
 		const confirmed =
 			pending !== undefined &&
@@ -122,29 +123,31 @@ export class TeamTurns {
 				attachments,
 				confirmed,
 				steerable: true,
+				byMessage: true,
 				interactive: true,
 			},
 		);
 	}
 
-	/**
-	 * A turn in an agent's channel that no owner message started; call inside its queue. A report
-	 * turn is interactive: it may ask the owner on cards there.
-	 */
+	/** A turn no owner message started; call inside its queue. A report turn is interactive. */
 	answerBackground(
 		channel: ChannelKey,
 		speaker: Speaker,
 		text: string,
 		interactive = false,
+		timeLimitMs?: number,
 	): Promise<TurnResult> {
 		const agent = this.#agentOf(channel);
 		return this.#turn(
 			agent,
-			this.#scopeOf(agent, channel),
+			scopeOf(agent, channel),
 			channel,
 			text,
 			{ messages: 0, speaker },
-			interactive ? { interactive: true } : {},
+			{
+				...(interactive ? { interactive: true } : { unattended: true }),
+				...(timeLimitMs === undefined ? {} : { timeLimitMs }),
+			},
 		);
 	}
 
@@ -190,13 +193,6 @@ export class TeamTurns {
 		return agent;
 	}
 
-	/** The agent's own conversation in the channel: its Discord channel's, or its room's. */
-	#scopeOf(agent: Agent, channel: ChannelKey): AgentTurnScope {
-		return discordIdOf(channel) === undefined
-			? roomScope(agent, channel)
-			: homeScope(agent);
-	}
-
 	/**
 	 * Runs one agent turn and posts its reply, or a failure notice, in `postTo` under the
 	 * agent's name. Never rejects.
@@ -216,6 +212,9 @@ export class TeamTurns {
 		this.#chains.set(scope.session, chain);
 		this.#posting.set(scope.session, postTo);
 		this.#working.set(agent.name, postTo);
+		// A message to the agent lands where it last ran a turn; a group round is none.
+		if (!scope.group)
+			this.#options.store.conversations.keep(agent.name, postTo, logger);
 		this.#active(agent.name, scope.group);
 		const turn = {
 			agent: agent.name,
@@ -236,10 +235,7 @@ export class TeamTurns {
 							channel: postTo,
 							selection: this.#options.selection(scope),
 							text,
-							...(extra.attachments ? { attachments: extra.attachments } : {}),
-							...(extra.confirmed ? { confirmed: true } : {}),
-							...(extra.steerable ? { steerable: true } : {}),
-							...(extra.interactive ? { interactive: true } : {}),
+							...turnFlags(extra),
 							agent: scope,
 							speaker: chain.speaker,
 							...(interim ? { interim } : {}),
@@ -266,7 +262,12 @@ export class TeamTurns {
 					"agent turn failed",
 				);
 			}
-			await this.#post(postTo, this.#current(agent), replyBody(result));
+			if (isQuiet(result))
+				logger.info(
+					{ agent: agent.name, channel: postTo },
+					"unattended turn had nothing to say; nothing posted",
+				);
+			else await this.#post(postTo, this.#current(agent), replyBody(result));
 		} catch (error) {
 			logger.error({ agent: agent.name, err: error }, "agent reply not posted");
 		} finally {
@@ -459,8 +460,18 @@ export class TeamTurns {
 		await this.#post(home, coordinator, { chunks: splitReply(text) });
 	}
 
-	message(caller: AgentTurnScope, to: string, text: string): string {
-		return this.#messages.message(caller, to, text);
+	message(...args: Parameters<AgentMessages["message"]>): string {
+		return this.#messages.message(...args);
+	}
+
+	/** Delivers the agent messages the last run kept while it stopped; never rejects. */
+	replayMessages(): Promise<void> {
+		return this.#messages.replay();
+	}
+
+	/** What the team still writes that a shutdown must wait for. */
+	busy(): string[] {
+		return this.#messages.busy();
 	}
 
 	/**

package/src/core/assets/prompts/shared-guest.md

@@ -1,9 +1,7 @@
-You are an agent in a Discord server. The person you are talking with is a guest of that server, named in the last section of this prompt. You are not speaking for the server's owner, and the owner's private facts stay theirs.
+You are an agent in an agent server. The person you are talking with is a guest of that server, named in the last section of this prompt. You are not speaking for the server's owner, and the owner's private facts stay theirs.
 
 Reply in the language they write in. Be warm, direct, and brief.
 
-Write in Discord's Markdown: bold, italics, headings, bullet and numbered lists, block quotes, inline code, fenced code blocks, and `-#` small text all render. Discord shows Markdown tables as raw pipes, so list figures as bullets instead.
-
 Your context holds only their own core facts and upcoming events. When a request touches their projects, people, tools, or past, search memory first. When they ask you to remember or forget something, use the memory tools; what you store is theirs alone.
 
 When you need their decision to continue, ask with ask_user instead of ending your turn with a question; they answer on buttons in the channel and your turn goes on.

package/src/core/assets/prompts/shared.md

@@ -1,9 +1,7 @@
-You are an agent in a Discord server, working for the server's owner. You talk with them in channels and threads.
+You are an agent working for the owner of this agent server. You talk with them in channels, rooms and threads.
 
 Reply in the language they write in. Be warm, direct, and brief.
 
-Write in Discord's Markdown: bold, italics, headings, bullet and numbered lists, block quotes, inline code, fenced code blocks, and `-#` small text all render. Discord shows Markdown tables as raw pipes, so list figures as bullets instead.
-
 Your context holds only their core facts and upcoming events. When a request touches their projects, people, tools, or past, search memory first. When they ask you to remember or forget something, use the memory tools.
 
 When you need their decision to continue, ask with ask_user instead of ending your turn with a question; they answer on buttons in the channel and your turn goes on.

package/src/core/builtin/agent-server.ts

@@ -26,6 +26,8 @@ import type { AgentSessionsSlot } from "../runtime/runtime-plugin.ts";
 import {
 	AGENTS,
 	BACKGROUND_TURNS,
+	IDENTITY,
+	MODES,
 	PROMPTS,
 	RUNTIME,
 	SCHEDULES,
@@ -316,6 +318,8 @@ export function agentServerPlugin(
 					? { guestPrompt: guestPrompt ?? options.prompts.guest }
 					: {}),
 				...(skills ? { skills } : {}),
+				modes: () => context.services.find(MODES),
+				principals: () => context.services.find(IDENTITY),
 				...(threads ? { threads } : {}),
 				logger,
 			});
@@ -387,6 +391,7 @@ export function agentServerPlugin(
 					{
 						name: AGENT_TEAM_SERVICE,
 						stop: () => built.stop(),
+						busy: () => built.busy(),
 						// The dashboard shows the team, so it starts once the team has; the error
 						// reporter connects whether or not the team did, since it reports the failure.
 						startInBackground: async () => {

package/src/core/builtin/modules.ts

@@ -125,6 +125,9 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 			// Another agent's channel, for schedule_list; asked when a tool runs, after the agent server set up.
 			const agentChannelOf = (agent: string, near: ChannelKey) =>
 				services.get(AGENTS).team.channelOf(agent, near);
+			// All of an agent's conversations, for its own schedules; asked when a tool runs.
+			const ownConversations = (agent: string) =>
+				services.get(AGENTS).team.roomsOf(agent);
 			// A conversation no chat surface carries keeps its runs in the creator's direct messages, where
 			// a claim must take them; anyone's elsewhere would run in a conversation that is not theirs.
 			const channelFor = async (
@@ -303,6 +306,9 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 								session.homeChannel,
 								session.agent ? agentChannelOf : undefined,
 								session.speaker,
+								session.agent
+									? () => ownConversations(session.agent?.name ?? "")
+									: undefined,
 							),
 						),
 					),

package/src/core/config/config.ts

@@ -271,7 +271,10 @@ export interface ResolvedConfig extends ResolvedLimits {
 	/** Absent `retention`: used files live as long as their conversation. */
 	attachments: AttachmentsConfig;
 	/** Days to keep each conversation kind after its last activity; a kind not listed is kept. */
-	conversations: { keepDays: Readonly<Record<string, number>> };
+	conversations: {
+		keepDays: Readonly<Record<string, number>>;
+		keep?: ConversationsConfig["keep"];
+	};
 	agentDir: string;
 	model: ModelRef;
 	thinking: ThinkingLevel;
@@ -373,7 +376,12 @@ export function resolveConfig(input: unknown): ResolvedConfig {
 		attachments: config.attachments?.retention
 			? { retention: config.attachments.retention }
 			: {},
-		conversations: { keepDays: { ...config.conversations?.keepDays } },
+		conversations: {
+			keepDays: { ...config.conversations?.keepDays },
+			...(config.conversations?.keep
+				? { keep: config.conversations.keep }
+				: {}),
+		},
 		agentDir: config.agentDir ?? `${config.dataDir}/pi`,
 		model,
 		thinking,

package/src/core/config/conversations.ts

@@ -1,4 +1,5 @@
-import { integer, optional, record, shape } from "./schema.ts";
+import type { ConversationRecord } from "../conversations/conversation-registry.ts";
+import { guarded, integer, optional, record, shape } from "./schema.ts";
 
 /** The configuration's `conversations`: what the host does with the conversations it has recorded. */
 export interface ConversationsConfig {
@@ -10,6 +11,15 @@ export interface ConversationsConfig {
 	 * which is what a host without this key does.
 	 */
 	keepDays?: Readonly<Record<string, number>>;
+	/**
+	 * Asked for each conversation the sweep would delete, after its kind's `keepDays` ran out:
+	 * answer `true` to keep it for now, such as a support conversation whose ticket is still open.
+	 * It is asked again at the next sweep, so a conversation kept today is deleted once the host
+	 * stops wanting it. A function that throws or rejects keeps the conversation for this sweep and
+	 * is logged. Without it
+	 * every conversation past its days is deleted.
+	 */
+	keep?: (conversation: ConversationRecord) => boolean | Promise<boolean>;
 }
 
 /** The longest keep the configuration accepts, in days: a hundred years. */
@@ -17,5 +27,14 @@ const MAX_DAYS = 36_500;
 
 /** The `conversations` key's shape. */
 export const conversationsShape = optional(
-	shape({ keepDays: optional(record(integer(1, MAX_DAYS))) }),
+	shape({
+		keepDays: optional(record(integer(1, MAX_DAYS))),
+		keep: optional(
+			guarded(
+				"a function from a conversation record to true to keep it",
+				(value): value is NonNullable<ConversationsConfig["keep"]> =>
+					typeof value === "function",
+			),
+		),
+	}),
 );

package/src/core/contract/channels.ts

@@ -153,6 +153,11 @@ export interface BackgroundTurn {
 	text: string;
 	/** It delivers a report the owner is waiting for, so it may ask them on cards. */
 	report?: boolean;
+	/**
+	 * How long the turn may work, in ms, in place of the runtime's default time limit: a
+	 * schedule's own. The runtime holds it under the long-running cap. Absent = the default.
+	 */
+	timeLimitMs?: number;
 	/**
 	 * Who the turn runs as, set by the router alone once it checked the author: their principal
 	 * exists and is not disabled, and the tier is capped at theirs. A claim runs the turn as this

package/src/core/contract/surface.ts

@@ -79,6 +79,11 @@ export interface SurfaceThreads {
 export interface ChatSurface {
 	/** The key prefix of this surface's channels, such as "discord"; unique per host. */
 	readonly surface: string;
+	/**
+	 * What people call this surface, such as "Discord" or "the web app"; the agent prompt names it
+	 * as the place a conversation is in. Absent = the key prefix.
+	 */
+	readonly label?: string;
 	/** Explicit opt-in to delivering OutboundReply.files; absent or false refuses turn attachments. */
 	readonly supportsFiles?: boolean;
 	/**

package/src/core/conversations/conversation-retention.ts

@@ -1,7 +1,10 @@
 import type { ConversationPort } from "../contract/channels.ts";
 import type { Logger } from "../log.ts";
 import type { Service } from "../plugin.ts";
-import type { ConversationRegistry } from "./conversation-registry.ts";
+import type {
+	ConversationRecord,
+	ConversationRegistry,
+} from "./conversation-registry.ts";
 
 const DAY_MS = 24 * 60 * 60_000;
 
@@ -12,6 +15,8 @@ export interface ConversationRetentionOptions {
 	conversations: Pick<ConversationPort, "deleteConversation">;
 	/** Days to keep each kind after its last activity; a kind not listed is kept. */
 	keepDays: Readonly<Record<string, number>>;
+	/** True keeps a conversation past its days for this sweep; a throw keeps it too and is logged. */
+	keep?: (record: ConversationRecord) => boolean | Promise<boolean>;
 	now: () => Date;
 	logger: Logger;
 }
@@ -21,8 +26,10 @@ export interface ConversationSweep {
 	deleted: number;
 	/** A turn was running or waiting: tried again at the next sweep. */
 	busy: number;
-	/** Its claim could not delete it: logged, and tried again at the next sweep. */
+	/** Its claim could not delete it, or `keep` threw: logged, and tried again at the next sweep. */
 	failed: number;
+	/** `keep` wanted it: asked again at the next sweep. */
+	kept: number;
 }
 
 /**
@@ -33,8 +40,13 @@ export interface ConversationSweep {
 export async function sweepConversations(
 	options: ConversationRetentionOptions,
 ): Promise<ConversationSweep> {
-	const { registry, conversations, keepDays, now, logger } = options;
-	const result: ConversationSweep = { deleted: 0, busy: 0, failed: 0 };
+	const { registry, conversations, keepDays, keep, now, logger } = options;
+	const result: ConversationSweep = {
+		deleted: 0,
+		busy: 0,
+		failed: 0,
+		kept: 0,
+	};
 	const at = now().getTime();
 	for (const record of await registry.list()) {
 		const days = keepDays[record.kind];
@@ -44,6 +56,10 @@ export async function sweepConversations(
 		)
 			continue;
 		try {
+			if (keep && (await keep(record))) {
+				result.kept += 1;
+				continue;
+			}
 			const outcome = await conversations.deleteConversation(record.key);
 			if (outcome === "busy") {
 				result.busy += 1;
@@ -55,7 +71,7 @@ export async function sweepConversations(
 			result.failed += 1;
 			logger.warn(
 				{ channel: record.key, kind: record.kind, err: error },
-				"conversation past its keepDays not deleted",
+				"conversation past its keepDays not deleted (keep or its claim failed)",
 			);
 		}
 	}
@@ -77,7 +93,7 @@ export function conversationRetentionService(
 	const sweep = async (): Promise<void> => {
 		try {
 			const result = await sweepConversations(options);
-			if (result.deleted + result.busy + result.failed > 0)
+			if (result.deleted + result.busy + result.failed + result.kept > 0)
 				options.logger.info(result, "conversations past their keepDays swept");
 		} catch (error) {
 			options.logger.warn(

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

@@ -2,7 +2,10 @@ import type { SQL } from "bun";
 import type { RoundtablePlugin } from "../plugin.ts";
 import { CONVERSATIONS } from "../services.ts";
 import type { ConversationRegistry } from "./conversation-registry.ts";
-import { conversationRetentionService } from "./conversation-retention.ts";
+import {
+	type ConversationRetentionOptions,
+	conversationRetentionService,
+} from "./conversation-retention.ts";
 import { PgConversationRegistry } from "./conversation-store.ts";
 
 /** The name of the conversation registry's plugin, as the migration ledger names it. */
@@ -19,6 +22,8 @@ export function conversationsPlugin(
 		PgConversationRegistry.attach(sql),
 	/** Days to keep each conversation kind after its last activity (`conversations.keepDays`); none = keep them all. */
 	keepDays: Readonly<Record<string, number>> = {},
+	/** Asked before a conversation past its days is deleted (`conversations.keep`); true keeps it. */
+	keep?: ConversationRetentionOptions["keep"],
 ): RoundtablePlugin {
 	return {
 		name: CONVERSATIONS_PLUGIN,
@@ -35,6 +40,7 @@ export function conversationsPlugin(
 						registry,
 						conversations,
 						keepDays,
+						...(keep ? { keep } : {}),
 						now: () => env.now(),
 						logger,
 					}),

package/src/core/define-roundtable.ts

@@ -372,7 +372,11 @@ export async function defineRoundtable(
 			}),
 			...(assembly?.admin ?? []),
 			...(agentTeam?.skills ?? []),
-			conversationsPlugin(undefined, config.conversations.keepDays),
+			conversationsPlugin(
+				undefined,
+				config.conversations.keepDays,
+				config.conversations.keep,
+			),
 			modesPlugin(),
 			runtimePlugin({
 				owner,

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

@@ -14,6 +14,7 @@ import { parseChannelKey } from "../contract/surface.ts";
 import { MAX_TURN_IMAGES } from "../domain/attachment.ts";
 import type { Logger } from "../log.ts";
 import { contextImages, type SkippedImage } from "./context-images.ts";
+import { embedText } from "./embed-text.ts";
 import type { BotIdentity } from "./inbound-message.ts";
 
 /** The most bytes one image may be: the core's limit for any attachment. */
@@ -122,7 +123,8 @@ export function contextSourceOf(
 		if (!user) return mention;
 		return `@${members?.get(id)?.displayName ?? user.globalName ?? user.username}`;
 	});
-	const parts = text.trim() ? [text.trim()] : [];
+	const embeds = embedText(message.embeds);
+	const parts = [text.trim(), embeds].filter(Boolean);
 	for (const sticker of message.stickers.values())
 		parts.push(`[sticker: ${sticker.name}]`);
 	for (const file of message.attachments.values())

package/src/core/discord/embed-text.ts

@@ -0,0 +1,45 @@
+import type { Embed } from "discord.js";
+
+/** The most characters the embeds of one message add to its text; the rest is cut and marked. */
+export const EMBED_TEXT_CHARS = 4_000;
+
+/** What of an embed is read: its words and link, never its pictures, colors, or timestamp. */
+type EmbedFacts = Pick<
+	Embed,
+	"title" | "description" | "url" | "fields" | "footer" | "author"
+>;
+
+const CUT = "…";
+
+function embedLines(embed: EmbedFacts): string[] {
+	const lines: string[] = [];
+	const head = [embed.author?.name, embed.title].filter(Boolean).join(" — ");
+	if (head) lines.push(head);
+	if (embed.description) lines.push(embed.description);
+	for (const field of embed.fields) lines.push(`${field.name}: ${field.value}`);
+	if (embed.footer?.text) lines.push(embed.footer.text);
+	if (embed.url) lines.push(embed.url);
+	return lines;
+}
+
+/**
+ * The words of a message's embeds as plain text, one block per embed (title, description, each
+ * field as `name: value`, footer, link), so a post that is only an embed, such as an alert a
+ * webhook posts, reads as text. Discord renders a Slack-compatible webhook's attachments as
+ * embeds, so those are covered too. Text only, nothing is wrapped in markup; at most
+ * `EMBED_TEXT_CHARS` characters; empty for a message without embeds.
+ */
+export function embedText(embeds: readonly EmbedFacts[]): string {
+	const text = embeds
+		.map((embed) => embedLines(embed).join("\n").replace(/\r\n?/g, "\n").trim())
+		.filter(Boolean)
+		.join("\n\n");
+	return text.length > EMBED_TEXT_CHARS
+		? `${text.slice(0, EMBED_TEXT_CHARS - CUT.length)}${CUT}`
+		: text;
+}
+
+/** A message's own text and its embeds' text, apart by a blank line; either may be empty. */
+export function withEmbeds(content: string, embeds: readonly EmbedFacts[]) {
+	return [content.trim(), embedText(embeds)].filter(Boolean).join("\n\n");
+}

package/src/core/discord/inbound-message.ts

@@ -2,6 +2,7 @@ import { type Message, MessageReferenceType } from "discord.js";
 import type { InboundMessage } from "../contract/channels.ts";
 import { channelKey } from "../contract/surface.ts";
 import type { AttachmentRef } from "../domain/attachment.ts";
+import { withEmbeds } from "./embed-text.ts";
 import type { LateTurn } from "./owner-cards.ts";
 
 /** Who the bot is on Discord, as far as the client knows it. */
@@ -25,7 +26,9 @@ function attachmentRefs(
 
 function referenceOf(referenced: Message, mention: RegExp) {
 	return {
-		text: referenced.content.replace(mention, "").trim(),
+		text: withEmbeds(referenced.content, referenced.embeds)
+			.replace(mention, "")
+			.trim(),
 		attachments: attachmentRefs(referenced),
 		...(referenced.webhookId
 			? { webhookName: referenced.author.username }
@@ -97,7 +100,9 @@ export async function toInbound(
 		...(message.guildId ? { space: message.guildId } : {}),
 		mentionsBot: message.mentions.users.has(botId),
 		repliesToBot: referenced?.author.id === botId,
-		text: message.content.replace(mention, "").trim(),
+		text: withEmbeds(message.content, message.embeds)
+			.replace(mention, "")
+			.trim(),
 		attachments: [
 			...attachmentRefs(message),
 			...(forward ? attachmentRefs(forward) : []),

package/src/core/domain/ports.ts

@@ -60,12 +60,29 @@ export interface TurnRequest {
 	kind?: string;
 	/** The owner's own chat turn, which their next messages may steer. */
 	steerable?: boolean;
+	/**
+	 * A person's message started the turn, so the speaker is present: only such a turn spends a late
+	 * approval's release. Set by message ingest alone, never by a schedule, agent message, report or error turn.
+	 */
+	byMessage?: boolean;
 	/**
 	 * The owner started the turn by writing in its channel, or it delivers a dispatch's report,
 	 * so it may ask them there on cards: approvals of held actions and ask_user questions. A
 	 * schedule's turn is not.
 	 */
 	interactive?: boolean;
+	/**
+	 * No person waits on the turn's answer: a schedule's turn, an agent's message, an agent's
+	 * opening task. A turn like that may end with nothing to say, which is an empty answer
+	 * instead of a failure; the reply is then not posted. Absent = someone waits, and an empty
+	 * final answer fails.
+	 */
+	unattended?: boolean;
+	/**
+	 * How long the turn may work, in ms, in place of the runtime's default time limit; a schedule's
+	 * own limit. The runtime never lets it pass the long-running cap. Absent = the default.
+	 */
+	timeLimitMs?: number;
 	/**
 	 * Where the turn posts the text it writes before its final answer, as it goes; the caller
 	 * hands the channel its reply goes to. Absent = only the final reply is posted.

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

@@ -24,6 +24,8 @@ export interface TurnTimeout {
 	/** How long the timeout card waits for an answer. */
 	graceMs: number;
 	end: TurnTimeoutEnd;
+	/** No timeout card could be shown, as in a schedule's turn, so nobody was asked whether to go on. */
+	unasked?: true;
 }
 
 /** A turn aborted at a time limit; `timeout` says why, and the message says it in English. */

package/src/core/holds.ts

@@ -47,6 +47,14 @@ export interface HoldContext {
  *
  * `classes` are the hold classes of the call, for a rule that describes it in a turn (see
  * `HoldRule.holdClasses`); a rule that leaves them out leaves its call unclassed.
+ *
+ * `onDeclined` is called once when the call's approval card is declined, whether the turn was
+ * still waiting on it or the owner declined after the turn stopped waiting, so a plugin can close
+ * what it opened for the call, such as its own notice that asks for the approval. It is not
+ * called when the call is withdrawn through `supersede` (the plugin did that itself), approved,
+ * left unanswered or expired, or dropped by a message that does not confirm it: only a declined
+ * card calls it, in the process that holds the card (a restart loses it with the card). It
+ * must not throw; whatever it throws or rejects with is ignored, and the call is refused either way.
  */
 export type HoldDescription =
 	| string
@@ -56,6 +64,7 @@ export type HoldDescription =
 			supersede?: AbortSignal;
 			approval?: "speaker";
 			classes?: readonly string[];
+			onDeclined?: () => void | Promise<void>;
 	  };
 
 /**