pi-roundtable 0.27.0 → 0.28.0

package/src/core/agents/helper-create.ts

@@ -2,12 +2,11 @@ import type { CharacterInput } from "../../characters/index.ts";
 import { helpersOf } from "../config/helpers.ts";
 import { AgentError } from "../domain/errors.ts";
 import type { AgentTurnScope } from "../domain/ports.ts";
-import { SYSTEM_PRINCIPAL } from "../identity/principal-store.ts";
 import type { Speaker } from "../speakers.ts";
 import { toolTiers } from "../tool-tiers.ts";
 import { isHelper } from "./agent-rules.ts";
 import type { Agent } from "./agent-store.ts";
-import { keysOf } from "./team-keys.ts";
+import { followOrigin } from "./helper-modes.ts";
 import type { TeamContext } from "./team-options.ts";
 
 /** The team's way of making an agent, which `createHelper` uses to make a temp knight. */
@@ -98,10 +97,10 @@ export async function createHelper(
 	);
 	const helper = made.agent;
 	try {
-		await inheritLongRunning(ctx, caller, speaker, helper);
+		await followOrigin(ctx, caller, speaker, helper);
 		ctx.turns.message(caller, helper.name, task);
 	} catch (error) {
-		// The long-running mode or the task could not be handed over (a chain at its cap): the temp
+		// The modes or the task could not be handed over (a chain at its cap): the temp
 		// knight is not left idle, and its thread is closed.
 		await ctx.archiveHelpers([helper.name]);
 		throw error;
@@ -158,23 +157,3 @@ async function makeRoom(
 	await ctx.archiveHelpers([oldest.name]);
 	return ` To make room, "${oldest.displayName}" (${oldest.name}), your oldest finished temp knight, was archived.`;
 }
-
-/**
- * Turns long-running on for the temp knight's conversations when the conversation that asked for
- * it has it on, so it works as long as its parent may. This adds no permission: an owner turned
- * it on there. Only a turn of an owner can carry that over, as for any change of modes.
- */
-async function inheritLongRunning(
-	ctx: TeamContext,
-	caller: AgentTurnScope,
-	speaker: Speaker,
-	helper: Agent,
-): Promise<void> {
-	const { store, surfaces } = ctx.options;
-	const modes = ctx.options.modes?.();
-	if (!modes?.peek(ctx.turns.turnChannel(caller)).longRunning) return;
-	if (speaker.tier !== "owner" || speaker.principalId === SYSTEM_PRINCIPAL)
-		return;
-	for (const key of keysOf(store, helper.name, surfaces?.roomSurfaces() ?? []))
-		await modes.set(key, { longRunning: true }, speaker);
-}

package/src/core/agents/helper-modes.ts

@@ -0,0 +1,64 @@
+import type { AgentTurnScope } from "../domain/ports.ts";
+import { SYSTEM_PRINCIPAL } from "../identity/principal-store.ts";
+import type { ModeOrigins } from "../modes/mode-inheritance.ts";
+import type { AgentDirectory } from "../services.ts";
+import type { Speaker } from "../speakers.ts";
+import { isHelper } from "./agent-rules.ts";
+import type { Agent } from "./agent-store.ts";
+import { agentOfChannel, groupOfChannel, keysOf } from "./team-keys.ts";
+import type { TeamContext } from "./team-options.ts";
+
+/**
+ * Makes the temp knight's conversations follow the modes of the conversation that asked for it,
+ * live, so turning yolo or long-running on or off there applies to it at once. This adds no
+ * permission: an owner turns the modes on there. Only a turn of an owner can carry them over, as
+ * for any change of modes; any other turn's temp knight starts with its own, both off, whatever
+ * an earlier agent of the same name followed.
+ */
+export async function followOrigin(
+	ctx: TeamContext,
+	caller: AgentTurnScope,
+	speaker: Speaker,
+	helper: Agent,
+): Promise<void> {
+	const { store, surfaces } = ctx.options;
+	const modes = ctx.options.modes?.();
+	if (!modes) return;
+	const keys = keysOf(store, helper.name, surfaces?.roomSurfaces() ?? []);
+	if (speaker.tier !== "owner" || speaker.principalId === SYSTEM_PRINCIPAL) {
+		for (const key of keys) await modes.forget(key);
+		return;
+	}
+	await modes.follow(keys, ctx.turns.turnChannel(caller), speaker);
+}
+
+/**
+ * What the agent server says of a conversation that follows another's modes: it still does while
+ * it is a temp knight's conversation made from that origin, named after the temp knight's parent;
+ * the origin is gone once the agent or group whose conversation it is (else the parent) is
+ * archived or deleted.
+ */
+export function modeOrigins(
+	store: Pick<
+		AgentDirectory,
+		"agent" | "agentByChannel" | "group" | "groupByChannel"
+	>,
+	hosts: { roomSurfaces(): readonly string[] },
+): ModeOrigins {
+	return {
+		originOf: (channel, origin) => {
+			const helper = agentOfChannel(store, hosts, channel);
+			if (!helper || !isHelper(helper) || helper.origin !== origin)
+				return undefined;
+			const parent = store.agent(helper.parent as string);
+			const owner =
+				agentOfChannel(store, hosts, origin) ??
+				groupOfChannel(store, hosts, origin) ??
+				parent;
+			return {
+				name: parent?.displayName ?? (helper.parent as string),
+				alive: owner?.status === "active",
+			};
+		},
+	};
+}

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

@@ -3,6 +3,7 @@ import type { SurfacePort } from "../contract/surface.ts";
 import type { TurnAttachments } from "../domain/attachment.ts";
 import type {
 	ChannelKey,
+	IntercomCard,
 	PendingConfirmation,
 	TurnResult,
 } from "../domain/conversation.ts";
@@ -14,10 +15,6 @@ import type { EventSink } from "../plugin.ts";
 import type { AvatarStudio } from "../services.ts";
 import type { TurnSelection } from "../sessions.ts";
 import type { Speaker } from "../speakers.ts";
-import type {
-	DispatchThread,
-	DispatchThreads,
-} from "../threads/dispatch-threads.ts";
 import type { ToolTiers } from "../tool-tiers.ts";
 import type { AgentChannels, AgentTurnRunner } from "./agent-ports.ts";
 import type { Agent, PgAgentStore } from "./agent-store.ts";
@@ -36,12 +33,6 @@ export interface Chain {
 	speaker: Speaker;
 }
 
-/** A message's thread in the sender's turn channel, which holds the request and the answer. */
-export interface Exchange {
-	parent: ChannelKey;
-	thread: DispatchThread;
-}
-
 export interface TeamTurnsOptions {
 	/** The agent server's entry channel, where the coordinator lives; absent on a host without Discord. */
 	entryChannelId?: string;
@@ -99,8 +90,6 @@ export interface TeamTurnsOptions {
 	 * 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">;
 }
 
 /** How a turn runs, beyond its text. */
@@ -150,7 +139,12 @@ export interface TurnHost {
 	post(
 		channel: ChannelKey,
 		as: Agent,
-		body: { thinking?: string; chunks: string[]; threadId?: string },
+		body: {
+			thinking?: string;
+			chunks: string[];
+			threadId?: string;
+			intercom?: IntercomCard;
+		},
 	): Promise<void>;
 	/** The agent's latest row. */
 	current(agent: Agent): Agent;

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

@@ -2,6 +2,7 @@ import { channelKey, parseChannelKey } from "../contract/surface.ts";
 import type { TurnAttachments } from "../domain/attachment.ts";
 import type {
 	ChannelKey,
+	IntercomCard,
 	PendingConfirmation,
 	PostAuthor,
 	ReplyFile,
@@ -321,8 +322,10 @@ export class TeamTurns {
 		const { store, channels, studio, surfaces } = this.#options;
 		if (discordIdOf(channel) === undefined) {
 			// A room's interim posts are its surface's, under the agent as author.
-			if (!surfaces?.interim(channel, this.#author(agent))) return undefined;
+			const first = surfaces?.interim(channel, this.#author(agent));
+			if (!surfaces || !first) return undefined;
 			return {
+				...(first.tools === false ? { tools: false } : {}),
 				post: async (text) => {
 					if (!channelOwner(store, channel, this.#rooms(channel)))
 						throw new AgentError(`${channel} is archived`);
@@ -363,6 +366,7 @@ export class TeamTurns {
 			files?: ReplyFile[];
 			threadId?: string;
 			failed?: true;
+			intercom?: IntercomCard;
 		},
 	): Promise<void> {
 		const { store, channels, studio, surfaces, logger } = this.#options;
@@ -378,7 +382,7 @@ export class TeamTurns {
 		if (discordIdOf(channel) === undefined) {
 			if (!surfaces)
 				throw new AgentError(`no surface serves the room ${channel}`);
-			const { thinking, chunks, files, threadId } = rest;
+			const { thinking, chunks, files, threadId, intercom } = rest;
 			// A thread of the room's surface is a channel of that surface, and speaks there.
 			return surfaces.sendReply(
 				threadId === undefined
@@ -390,6 +394,7 @@ export class TeamTurns {
 					...(files?.length ? { files } : {}),
 					author: this.#author(as),
 					...(failed ? { failed } : {}),
+					...(intercom ? { intercom } : {}),
 				},
 			);
 		}

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

@@ -9,6 +9,7 @@ import { DiscordAgentTeam } from "../agents/agent-team.ts";
 import { AGENT_TOOLS } from "../agents/agent-tools.ts";
 import { FileAvatarStudio } from "../agents/avatar-studio.ts";
 import { RelevanceScorer } from "../agents/group-round.ts";
+import { modeOrigins } from "../agents/helper-modes.ts";
 import { Routes } from "../agents/routes.ts";
 import { agentOfChannel, discordKey } from "../agents/team-keys.ts";
 import { ownerAttachmentDir } from "../attachments/attachment-dir.ts";
@@ -35,7 +36,6 @@ import {
 	RUNTIME,
 	SCHEDULES,
 	SKILLS,
-	THREADS,
 } from "../services.ts";
 import type { SessionTool } from "../sessions.ts";
 import type { Tier } from "../speakers.ts";
@@ -217,8 +217,6 @@ export function agentServerPlugin(
 		setup: async (context) => {
 			// Absent on a host without Discord: then the team has no channels or dashboard.
 			const discord = context.services.find(DISCORD);
-			// Dispatch threads on any surface that hosts them, Discord's or a room surface's.
-			const threads = context.services.find(THREADS);
 			const schedules = context.services.get(SCHEDULES);
 			const connection = discord?.connection;
 			const { logger, providers, surfaces } = context;
@@ -245,6 +243,8 @@ export function agentServerPlugin(
 			// Absent when the skills addon is off: the agents then carry none.
 			const skills = context.services.find(SKILLS);
 			const { agents: store } = await openStores(context, teamId);
+			// A temp knight's conversations follow the modes of the one that made it.
+			context.services.find(MODES)?.trackOrigins(modeOrigins(store, surfaces));
 			const running = context.services.get(RUNTIME);
 			const judge = providers.judge;
 			const confirmations = new ConfirmationJudge({
@@ -348,7 +348,6 @@ export function agentServerPlugin(
 				modes: () => context.services.find(MODES),
 				...(options.helpers !== undefined ? { helpers: options.helpers } : {}),
 				principals: () => context.services.find(IDENTITY),
-				...(threads ? { threads } : {}),
 				logger,
 			});
 			connection?.onChannelDeleted((channelId) => {

package/src/core/builtin/discord.ts

@@ -5,6 +5,7 @@ import type {
 	ChannelContextOptions,
 } from "../contract/channel-context.ts";
 import { type ServiceKey, serviceKey } from "../contract/services.ts";
+import { CardCopies } from "../discord/card-copies.ts";
 import { ChannelContextReader } from "../discord/channel-context.ts";
 import { CommandCollection } from "../discord/command-collection.ts";
 import type { DiscordConnection } from "../discord/connection.ts";
@@ -15,6 +16,7 @@ import type {
 	CommandGuard,
 	CommandRegistrar,
 } from "../discord/interaction-module.ts";
+import { intercomButtonModule } from "../discord/intercom-cards.ts";
 import { OwnerCards } from "../discord/owner-cards.ts";
 import { commandGuard, ownerRootCommand } from "../discord/owner-command.ts";
 import type { DiscordPoster } from "../discord/poster/poster.ts";
@@ -88,11 +90,15 @@ export interface DiscordOptions {
 	 * How the texts behind approval cards' copy buttons are kept: the newest `keep` (default 100)
 	 * for `keepDays` (default 30), in `card-copies.json` under `dataDir`, so the buttons work after
 	 * a restart. `false` keeps them in memory only, with the same limits: they are gone when the
-	 * process restarts and the button then says so.
+	 * process restarts and the button then says so. The whole texts behind the agents' message
+	 * cards follow the same choice and `keepDays`, the newest 300, in `intercom-texts.json`.
 	 */
 	cardCopies?: { keepDays?: number; keep?: number } | false;
 }
 
+/** How many agent message cards keep their whole text for the open button, the newest. */
+const INTERCOM_KEEP = 300;
+
 /**
  * The Discord connection and what stands on it: the owner's cards, the command guard, and the
  * threads that carry background reports. It contributes the Discord surface, collects the
@@ -114,11 +120,24 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 		setup: async ({ conversations, services, logger }) => {
 			const identity = services.find(IDENTITY);
 			// A host that keeps no copy texts on disk drops what an earlier run left.
-			if (options.cardCopies === false) {
-				const file = join(options.dataDir, "card-copies.json");
-				rmSync(file, { force: true });
-				rmSync(`${file}.tmp`, { force: true });
-			}
+			if (options.cardCopies === false)
+				for (const name of ["card-copies.json", "intercom-texts.json"]) {
+					const file = join(options.dataDir, name);
+					rmSync(file, { force: true });
+					rmSync(`${file}.tmp`, { force: true });
+				}
+			// The whole texts behind the agents' message cards, kept as the copy texts are.
+			const intercomTexts = new CardCopies({
+				...(options.cardCopies === false
+					? {}
+					: { path: join(options.dataDir, "intercom-texts.json") }),
+				keep: INTERCOM_KEEP,
+				...(options.cardCopies
+					? { keepDays: options.cardCopies.keepDays }
+					: {}),
+				logger,
+				what: "agent message texts",
+			});
 			// The surface exists by the time a turn posts a card.
 			const cards: OwnerCards = new OwnerCards({
 				ownerId: options.ownerId,
@@ -142,6 +161,7 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 				ownerId: options.ownerId,
 				ownerName: options.ownerName,
 				prompts: (channel, scope) => cards.prompts(channel, scope),
+				intercomTexts,
 				// Built below, once the surface can read messages; called only after setup.
 				channelContext: (message, given) => context.of(message, given),
 				logger,
@@ -171,6 +191,7 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 			collection.registrar.add({
 				module: stopButtonModule({ guard, conversations }),
 			});
+			collection.registrar.add({ module: intercomButtonModule(intercomTexts) });
 			// Marks the owners in channel context: the primary owner, and every other owner's Discord identities.
 			const owners = new DiscordOwners({
 				ownerId: options.ownerId,
@@ -210,8 +231,14 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 					// The copy texts of the last cards are on disk before the host exits.
 					{
 						name: "card-copies",
-						start: () => cards.startCopies(),
-						stop: () => cards.stopCopies(),
+						start: () => {
+							cards.startCopies();
+							intercomTexts.start();
+						},
+						stop: async () => {
+							await cards.stopCopies();
+							await intercomTexts.stop();
+						},
 					},
 				],
 			};

package/src/core/config/adapters.ts

@@ -84,7 +84,8 @@ export interface DiscordConfig {
 	 * for `keepDays` (default 30), in `card-copies.json` under the data directory, so the buttons
 	 * work after a restart. `false` keeps them in memory only, with the same limits: they are gone
 	 * when the process restarts, and the button then says so. Discarding a conversation does not
-	 * remove them; they age out.
+	 * remove them; they age out. The whole texts behind the agents' message cards follow the same
+	 * choice and `keepDays`, the newest 300, in `intercom-texts.json`.
 	 */
 	cardCopies?: { keepDays?: number; keep?: number } | false;
 	/**

package/src/core/config/limits.ts

@@ -1,5 +1,10 @@
 import { ConfigError } from "../domain/errors.ts";
-import { type Autonomy, DEFAULT_LONG_RUNNING_MS } from "../modes/autonomy.ts";
+import {
+	type Autonomy,
+	DEFAULT_LONG_RUNNING_MS,
+	DEFAULT_YOLO_QUESTION_GRACE_MS,
+	DEFAULT_YOLO_TIMEOUT_CARD_GRACE_MS,
+} from "../modes/autonomy.ts";
 import { integer, list, optional, shape, text } from "./schema.ts";
 
 /** The configuration's `turnLimits` and `autonomy`: how long a turn works, and what runs without a person. */
@@ -27,6 +32,16 @@ export interface LimitsConfig {
 			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
+			 * (the card stays open, and a later answer starts a new turn); 5 to 600, default 30.
+			 */
+			questionGraceSeconds?: number;
+			/**
+			 * How long the timeout card waits in a yolo conversation before the turn goes on as if
+			 * Continue were pressed, up to `longRunning.maxSeconds` of work; 10 to 3600, default 60.
+			 */
+			timeoutCardSeconds?: number;
 		};
 		/** Long-running mode: a turn that reaches its time limit goes on by itself, up to this. */
 		longRunning?: {
@@ -48,7 +63,12 @@ export const limitsShape = {
 	autonomy: optional(
 		shape({
 			yolo: optional(
-				shape({ allow: optional(list(text)), card: optional(list(text)) }),
+				shape({
+					allow: optional(list(text)),
+					card: optional(list(text)),
+					questionGraceSeconds: optional(integer(5, 600)),
+					timeoutCardSeconds: optional(integer(10, 3_600)),
+				}),
 			),
 			longRunning: optional(
 				shape({ maxSeconds: optional(integer(600, 604_800)) }),
@@ -83,6 +103,14 @@ export function limitsOf(config: LimitsConfig): ResolvedLimits {
 			yolo: {
 				allow: autonomy?.yolo?.allow ?? [],
 				card: autonomy?.yolo?.card ?? [],
+				questionGraceMs: secondsOr(
+					autonomy?.yolo?.questionGraceSeconds,
+					DEFAULT_YOLO_QUESTION_GRACE_MS,
+				),
+				timeoutCardGraceMs: secondsOr(
+					autonomy?.yolo?.timeoutCardSeconds,
+					DEFAULT_YOLO_TIMEOUT_CARD_GRACE_MS,
+				),
 			},
 			longRunningMaxMs:
 				longRunning === undefined
@@ -91,3 +119,8 @@ export function limitsOf(config: LimitsConfig): ResolvedLimits {
 		},
 	};
 }
+
+/** Seconds as ms, or the default in ms when unset. */
+function secondsOr(seconds: number | undefined, defaultMs: number): number {
+	return seconds === undefined ? defaultMs : seconds * 1_000;
+}

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/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. */
@@ -297,8 +301,8 @@ export class DiscordSurface
 
 	/**
 	 * Discord draws attachments below a message's text, so the card goes out as its own message
-	 * first and produced files last, each on its own. Replies may mention people but never everyone or a role.
-	 */
+	 * first and produced files last, each on its own. Replies may mention people but never everyone or a role. A card
+	 * Discord refuses (a channel without Attach Files) is logged, and the text still goes out. */
 	async sendReply(channel: ChannelKey, reply: OutboundReply): Promise<void> {
 		const target = await this.#sendable(channel);
 		const allowedMentions = { parse: ["users" as const] };
@@ -306,12 +310,14 @@ export class DiscordSurface
 			await target.send({ content: reply.thinking, allowedMentions });
 		}
 		if (reply.card) {
-			await target.send({
-				files: [
-					new AttachmentBuilder(Buffer.from(reply.card), {
-						name: "card.png",
-					}),
-				],
+			const card = new AttachmentBuilder(Buffer.from(reply.card), {
+				name: "card.png",
+			});
+			await target.send({ files: [card] }).catch((err: unknown) => {
+				this.#options.logger.warn(
+					{ channel, err },
+					"reply card not posted; sending the text alone",
+				);
 			});
 		}
 		for (const chunk of reply.chunks) {
@@ -363,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(