pi-roundtable 0.27.1 → 0.29.0

package/src/core/agents/routes.ts

@@ -37,7 +37,7 @@ export interface RoutingTable {
 	 * has none when the agent has no place at all.
 	 */
 	of(agent: string, kind: "integration", origin: ChannelKey): ChannelKey;
-	of(agent: string, kind: "agentMessage", origin?: ChannelKey): ChannelKey;
+	of(agent: string, kind: "agentMessage", origin: ChannelKey): ChannelKey;
 	of(
 		agent: string,
 		kind: RouteKind,
@@ -154,7 +154,7 @@ export class Routes implements RoutingTable {
 	 * when an `agentMessage` finds no place; undefined when an `opening` finds none.
 	 */
 	of(name: string, kind: "integration", origin: ChannelKey): ChannelKey;
-	of(name: string, kind: "agentMessage", origin?: ChannelKey): ChannelKey;
+	of(name: string, kind: "agentMessage", origin: ChannelKey): ChannelKey;
 	of(
 		name: string,
 		kind: RouteKind,
@@ -201,39 +201,57 @@ export class Routes implements RoutingTable {
 	}
 
 	/**
-	 * The conversation a message to the agent lands in when the sender names none: with `latest`
-	 * the one it last ran a turn in, except that a message from a room never follows it out to
-	 * Discord, since the room's text may be for the owners alone; with none yet, the sender's own
-	 * surface when it hosts rooms, so a message between rooms stays among them; otherwise its
-	 * primary place.
+	 * The conversation a message to the agent lands in when the sender names none. By default
+	 * (`"origin-surface"`) its place on the sender's own surface: its Discord channel for a message
+	 * from Discord, its room for one from a room. `"latest"` is the conversation it last ran a turn
+	 * in, but only on the sender's surface. A message never crosses surfaces by recency: when the
+	 * agent has no place on the sender's surface, or no sender is known, it lands in the agent's
+	 * primary place, and a crossing is logged with both surfaces.
 	 */
 	#agentMessage(name: string, from: ChannelKey | undefined): ChannelKey {
-		const { store, roomSurfaces, latest } = this.#options;
-		const to = this.rules(name).agentMessage ?? "latest";
-		if (to !== "latest") {
+		const { latest } = this.#options;
+		const to = this.rules(name).agentMessage ?? "origin-surface";
+		if (to !== "latest" && to !== "origin-surface") {
 			const key =
 				to === "primary" ? this.primary(name) : this.placeOn(name, to);
 			if (key) return key;
 			this.#warn(
 				`message:${name}`,
 				{ agent: name, to },
-				"the agent has no place for messages to it; the conversation it last ran a turn in is used",
+				"the agent has no place for messages to it; its place on the sender's surface is used",
 			);
 		}
-		const via = from === undefined ? undefined : roomSurfaceOf(from);
-		const last = latest?.(name);
-		const keys = keysOf(store, name, roomSurfaces());
-		const outward =
-			via !== undefined &&
-			last !== undefined &&
-			roomSurfaceOf(last) === undefined;
-		if (last !== undefined && keys.includes(last) && !outward) return last;
-		if (via === undefined) {
-			const primary = this.primary(name);
-			if (!primary) throw new AgentError(`${name} has no channel yet.`);
-			return primary;
+		const surface =
+			from === undefined ? undefined : parseChannelKey(from).surface;
+		if (to === "latest" && surface !== undefined) {
+			const last = latest?.(name);
+			const keys = keysOf(
+				this.#options.store,
+				name,
+				this.#options.roomSurfaces(),
+			);
+			if (
+				last !== undefined &&
+				keys.includes(last) &&
+				parseChannelKey(last).surface === surface
+			)
+				return last;
 		}
-		return agentRoomKey(via, name);
+		const own = surface === undefined ? undefined : this.placeOn(name, surface);
+		if (own) return own;
+		const primary = this.primary(name);
+		if (!primary) throw new AgentError(`${name} has no channel yet.`);
+		if (surface !== undefined)
+			this.#warn(
+				`message-cross:${name}:${surface}`,
+				{
+					agent: name,
+					from: surface,
+					to: parseChannelKey(primary).surface,
+				},
+				"the agent has no place on the sender's surface; the message lands in its primary place",
+			);
+		return primary;
 	}
 
 	/**

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

@@ -220,9 +220,9 @@ export class TeamEditing {
 			creator: Agent | undefined;
 			/** The surface whose room runs the opening task. */
 			openIn?: string | undefined;
-			/** Makes the agent a temp knight of this knight: its place is a thread of the parent's channel, and it settles on the parent's model. */
+			/** Makes the agent a temp knight of this knight, which settles on the parent's model. */
 			parent?: Agent | undefined;
-			/** The conversation a temp knight is made from. */
+			/** The conversation a temp knight is made from: made on Discord, it lives in a thread of the parent's channel, made elsewhere in its rooms alone. */
 			origin?: string | undefined;
 		},
 		input: {
@@ -279,10 +279,10 @@ export class TeamEditing {
 		const suggested = suggestCharacter(input, taken);
 		const character = this.#resolve(wanted ?? {}, suggested);
 		const avatarHash = await studio.render(character);
-		// Without Discord channels the agent lives in its rooms, which exist as soon as it does. A
-		// temp knight lives in a thread of its parent's channel, or in rooms alone without one.
+		// Without Discord channels the agent lives in its rooms, which exist as soon as it does.
+		const onDiscord = who.origin?.startsWith("discord:") !== false;
 		const channelId = who.parent
-			? who.parent.channelId && channels?.createThread
+			? onDiscord && who.parent.channelId && channels?.createThread
 				? await channels.createThread(who.parent.channelId, input.displayName)
 				: undefined
 			: await channels?.createChannel(

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

@@ -1,7 +1,8 @@
 import { helpersOf } from "../config/helpers.ts";
 import { AgentError } from "../domain/errors.ts";
 import type { AgentTurnScope } from "../domain/ports.ts";
-import { isHelper } from "./agent-rules.ts";
+import { surfaceOf } from "../presence/delivery-router.ts";
+import { answersTo, helperSurface, isHelper } from "./agent-rules.ts";
 import type { Agent } from "./agent-store.ts";
 import type { HelpersEnded } from "./helper-ops.ts";
 import type { TeamContext } from "./team-options.ts";
@@ -11,8 +12,9 @@ const SWEEP_EVERY_MS = 3_600_000;
 
 /**
  * The team's temp knights after they are made: which a knight has, which are finished, and their
- * archive, restore, and sweep. Archiving one closes its Discord thread, since a temp knight's
- * place is a thread of its parent's channel; an archived one keeps its history.
+ * archive, restore, and sweep. A temp knight made on Discord lives in a thread of its parent's
+ * channel; one made in the web app gets that thread only once someone reaches for it on Discord.
+ * Archiving one closes its thread, when it has one; an archived one keeps its history.
  */
 export class TeamHelpers {
 	readonly #ctx: TeamContext;
@@ -20,6 +22,8 @@ export class TeamHelpers {
 	readonly #archiveAgent: (agent: Agent) => Promise<void>;
 	readonly #ended: ((event: HelpersEnded) => void)[] = [];
 	#sweeper: ReturnType<typeof setInterval> | undefined;
+	/** The threads being made for web-born temp knights, by name, so two reaches make one. */
+	readonly #placing = new Map<string, Promise<void>>();
 
 	constructor(ctx: TeamContext, archiveAgent: (agent: Agent) => Promise<void>) {
 		this.#ctx = ctx;
@@ -125,9 +129,74 @@ export class TeamHelpers {
 		return restored;
 	}
 
+	/**
+	 * A `message_agent` call that names "discord", or names nothing from a Discord conversation, gives
+	 * a web-born temp knight its thread first.
+	 */
+	async reach(
+		caller: AgentTurnScope,
+		to: string,
+		conversation?: string,
+	): Promise<void> {
+		const { store } = this.#ctx.options;
+		const { turns } = this.#ctx;
+		const target = store.agent(to);
+		const speaker = turns.speakerOf(caller);
+		const from = turns.turnChannel(caller);
+		// Unnamed, a message stays on the sender's surface, so one sent from Discord goes there too.
+		const wanted = conversation?.trim() || surfaceOf(from);
+		if (wanted !== "discord" || !target || !speaker) return;
+		if (answersTo(target, caller.name, from, speaker))
+			await this.placeOnDiscord(to);
+	}
+
+	/**
+	 * Gives an active temp knight made in the web app its thread under the parent's channel, the
+	 * first time someone reaches for it on Discord. One made on Discord, or before the origin was
+	 * kept, already has its place, and a host without Discord threads makes none; never rejects.
+	 */
+	placeOnDiscord(name: string): Promise<void> {
+		const pending = this.#placing.get(name);
+		if (pending) return pending;
+		const placing = this.#placeOnDiscord(name).finally(() =>
+			this.#placing.delete(name),
+		);
+		this.#placing.set(name, placing);
+		return placing;
+	}
+
+	async #placeOnDiscord(name: string): Promise<void> {
+		const { store, channels, logger } = this.#ctx.options;
+		const agent = store.agent(name);
+		const surface = helperSurface(agent);
+		if (agent?.status !== "active" || agent.channelId) return;
+		if (surface === undefined || surface === "discord") return;
+		const parent = store.agent(agent.parent as string);
+		if (!parent?.channelId || !channels?.createThread) return;
+		try {
+			const channelId = await channels.createThread(
+				parent.channelId,
+				agent.displayName,
+			);
+			await store.updateAgent(name, { channelId });
+		} catch (error) {
+			logger.warn(
+				{ agent: name, err: error },
+				"temp knight's thread not made; it stays in its rooms",
+			);
+			return;
+		}
+		logger.info(
+			{ agent: name, parent: parent.name },
+			"temp knight's thread made",
+		);
+		this.#ctx.changed();
+	}
+
 	/**
 	 * Restores one archived temp knight: its thread opens again, or a new one is made when the old
-	 * is gone. It comes back finished, with nothing running.
+	 * is gone. One made in the web app never gets a new thread: its old one reopens, if it had one
+	 * that is still there. It comes back finished, with nothing running.
 	 */
 	async restoreOne(agent: Agent): Promise<void> {
 		const { store, channels, logger } = this.#ctx.options;
@@ -137,6 +206,8 @@ export class TeamHelpers {
 				`"${agent.name}" belongs to "${agent.parent}", which is archived; restore it first.`,
 			);
 		let { channelId } = agent;
+		const surface = helperSurface(agent);
+		const bornOnDiscord = surface === undefined || surface === "discord";
 		if (channels?.createThread && parent.channelId) {
 			if (
 				channelId &&
@@ -144,7 +215,7 @@ export class TeamHelpers {
 				(await channels.exists(channelId))
 			)
 				await channels.openThread(channelId);
-			else
+			else if (bornOnDiscord)
 				channelId = await channels.createThread(
 					parent.channelId,
 					agent.displayName,

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

@@ -87,6 +87,20 @@ export const roomSurfaceOf = (room: ChannelKey): string | undefined => {
 	return surface === DISCORD_SURFACE ? undefined : surface;
 };
 
+/**
+ * The channel a group seat runs in outside a running turn: the group's room on the surface of the
+ * seat's home for a room seat, so it never falls out to the group's Discord channel; otherwise the
+ * group's Discord channel, or the seat's home.
+ */
+export function groupSeatChannel(
+	group: Pick<AgentGroup, "name" | "channelId">,
+	scope: Pick<AgentTurnScope, "home">,
+): ChannelKey {
+	const surface = roomSurfaceOf(scope.home);
+	if (surface !== undefined) return groupRoomKey(surface, group.name);
+	return group.channelId ? discordKey(group.channelId) : scope.home;
+}
+
 /**
  * An agent's conversation inside a group, apart from its own. In a Discord group channel, or
  * without a room, it is keyed by the channel; in a room of another surface, by the surface and the

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,
@@ -30,6 +31,7 @@ import {
 	coordinatorOf,
 	discordIdOf,
 	discordKey,
+	groupSeatChannel,
 	scopeOf,
 } from "./team-keys.ts";
 import {
@@ -321,8 +323,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 +367,7 @@ export class TeamTurns {
 			files?: ReplyFile[];
 			threadId?: string;
 			failed?: true;
+			intercom?: IntercomCard;
 		},
 	): Promise<void> {
 		const { store, channels, studio, surfaces, logger } = this.#options;
@@ -378,7 +383,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 +395,7 @@ export class TeamTurns {
 					...(files?.length ? { files } : {}),
 					author: this.#author(as),
 					...(failed ? { failed } : {}),
+					...(intercom ? { intercom } : {}),
 				},
 			);
 		}
@@ -424,10 +430,7 @@ export class TeamTurns {
 			: undefined;
 		if (!group) return scope.home;
 		// A seat of a room's group runs in that room; its running turn knows which.
-		return (
-			this.#posting.get(scope.session) ??
-			(group.channelId ? discordKey(group.channelId) : scope.home)
-		);
+		return this.#posting.get(scope.session) ?? groupSeatChannel(group, scope);
 	}
 
 	/**

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/builtin/modules.ts

@@ -31,6 +31,7 @@ import { Scheduler } from "../modules/schedules/scheduler.ts";
 import { schedulesExtension } from "../modules/schedules/schedules.ts";
 import type { ErrorReporter } from "../ops/error-reporter.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
+import { runChannelFor } from "../presence/delivery-router.ts";
 import { splitReply } from "../presentation/reply-splitter.ts";
 import {
 	AGENTS,
@@ -130,23 +131,22 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 				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 (
+			// The delivery router picks those messages with the conversation as the origin.
+			const channelFor = (
 				channel: ChannelKey,
 				principalId: string,
 				refused: (message: string) => Error,
-			) => {
-				if (surfaces.of(channel)) return channel;
-				const reached = await directChannels.reach(principalId);
-				if (!reached)
-					throw refused(
-						"this conversation has no chat surface to post a run in, and you have no direct channel on this host to post it in instead",
-					);
-				if (!conversations.takesBackground(reached.channel))
-					throw refused(
-						`this conversation has no chat surface to post a run in, and nothing here takes background turns in your ${reached.provider.name} direct messages, where it would go instead`,
-					);
-				return reached.channel;
-			};
+			) =>
+				runChannelFor(
+					{
+						surfaces,
+						directChannels,
+						takesBackground: (key) => conversations.takesBackground(key),
+					},
+					channel,
+					principalId,
+					refused,
+				);
 			const scheduleChannelFor = (channel: ChannelKey, principalId: string) =>
 				channelFor(channel, principalId, (m) => new ScheduleError(m));
 			const delegateChannelFor = (channel: ChannelKey, principalId: string) =>
@@ -198,7 +198,7 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 					// Only whether a direct channel knows them, without the network; the conversation there,
 					// and whether a claim takes its turns, are checked when a tool runs.
 					try {
-						if (!(await directChannels.known(own))) return;
+						if (!(await directChannels.known(home, own))) return;
 					} catch (error) {
 						logger.warn(
 							{ channel: home, err: error },

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;
+}