pi-roundtable 0.27.1 → 0.28.0

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

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

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

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

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

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

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

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

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

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

package/src/core/domain/conversation.ts

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

package/src/core/domain/interim.ts

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

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

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

package/src/core/i18n/conversation.ts

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

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

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

package/src/core/interactions/prompts.ts

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

package/src/core/modes/autonomy.ts

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

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

@@ -5,6 +5,12 @@ import { SYSTEM_PRINCIPAL } from "../identity/principal-store.ts";
 import type { Logger } from "../log.ts";
 import type { ChannelKey } from "../sessions.ts";
 import type { Speaker } from "../speakers.ts";
+import {
+	followersOf,
+	type ModeOrigins,
+	resolveMode,
+	type StoredMode,
+} from "./mode-inheritance.ts";
 
 /** What a conversation is set to run unattended: both off until an owner switches them on. */
 export interface ConversationMode {
@@ -15,6 +21,12 @@ export interface ConversationMode {
 	/** The principal who last changed it; absent for a conversation never changed. */
 	changedBy?: string;
 	changedAt?: Date;
+	/**
+	 * Present when the modes follow another conversation's, live: a temp knight's follow the
+	 * conversation it was made from. `name` is that conversation's, as the agent server tells it;
+	 * `gone` says it no longer exists, so both modes are off. `set` refuses such a conversation.
+	 */
+	inheritedFrom?: { channel: ChannelKey; name?: string; gone?: true };
 }
 
 /** Which modes a change sets; a mode left out stays as it is. */
@@ -53,7 +65,33 @@ export interface ConversationModes {
 		change: ModeChange,
 		by: Speaker,
 	): Promise<ConversationMode>;
-	/** Called after each change. Returns the function that stops it. A throwing listener is logged. */
+	/**
+	 * Makes each of `channels` follow `origin`'s modes live, in place of its own: `peek` returns the
+	 * origin's, with `inheritedFrom`, and `set` is refused for it. Stored, so it survives a restart.
+	 * Throws `PluginError` unless `by` is an owner other than the system principal, as `set` does.
+	 */
+	follow(
+		channels: readonly ChannelKey[],
+		origin: ChannelKey,
+		by: Speaker,
+	): Promise<void>;
+	/**
+	 * Drops a conversation's modes and what it follows, as for a conversation that is gone or made
+	 * anew. It only turns modes off, so it needs no speaker.
+	 */
+	forget(channel: ChannelKey): Promise<void>;
+	/**
+	 * How a following conversation's origin is named and whether it still exists; the agent server
+	 * gives it. `originOf` is undefined when `channel` no longer follows `origin`, so its own modes
+	 * count again; `alive: false` when the origin is gone, so both modes read off.
+	 */
+	trackOrigins(origins: {
+		originOf(
+			channel: ChannelKey,
+			origin: ChannelKey,
+		): { name: string; alive: boolean } | undefined;
+	}): void;
+	/** Called after each change, also for each conversation that follows the changed one. Returns the function that stops it. A throwing listener is logged. */
 	onChange(
 		listener: (channel: ChannelKey, mode: ConversationMode) => void,
 	): () => void;
@@ -68,27 +106,35 @@ interface Row {
 	long_running: boolean;
 	changed_by: string | null;
 	changed_at: Date;
+	follows: string | null;
 }
 
-const OFF: ConversationMode = Object.freeze({
-	yolo: false,
-	longRunning: false,
-});
-
-function modeOf(row: Row): ConversationMode {
-	return Object.freeze({
-		yolo: row.yolo,
-		longRunning: row.long_running,
-		...(row.changed_by === null ? {} : { changedBy: row.changed_by }),
-		changedAt: row.changed_at,
-	});
+function storedOf(row: Row): StoredMode {
+	return {
+		own: Object.freeze({
+			yolo: row.yolo,
+			longRunning: row.long_running,
+			...(row.changed_by === null ? {} : { changedBy: row.changed_by }),
+			changedAt: row.changed_at,
+		}),
+		...(row.follows === null ? {} : { follows: row.follows as ChannelKey }),
+	};
+}
+
+/** Refuses a change of modes by anyone but an owner, and by the host's own turns. */
+function checkOwner(by: Speaker): void {
+	if (by.tier !== "owner" || by.principalId === SYSTEM_PRINCIPAL)
+		throw new PluginError(
+			"only an owner sets a conversation's modes, and not the host's own turns",
+		);
 }
 
 /** The conversation modes in the `conversation_modes` table, cached in memory after one load. */
 export class PgConversationModes implements ConversationModes {
 	readonly #sql: SQL;
 	readonly #logger: Logger;
-	readonly #modes = new Map<ChannelKey, ConversationMode>();
+	readonly #modes = new Map<ChannelKey, StoredMode>();
+	#origins: ModeOrigins | undefined;
 	readonly #changed = new Set<
 		(channel: ChannelKey, mode: ConversationMode) => void
 	>();
@@ -99,7 +145,7 @@ export class PgConversationModes implements ConversationModes {
 		this.#logger = logger;
 	}
 
-	/** The modes' table; the host runs this before the modes attach. */
+	/** The modes' table; the host runs this, then `followsMigration`, before the modes attach. */
 	static readonly migration: Migration = {
 		name: "conversation-modes",
 		up: async (sql) => {
@@ -114,6 +160,20 @@ export class PgConversationModes implements ConversationModes {
 		},
 	};
 
+	/** The conversation whose modes a row follows, such as a temp knight's origin. */
+	static readonly followsMigration: Migration = {
+		name: "conversation-modes-follows",
+		up: async (sql) => {
+			await sql`ALTER TABLE conversation_modes ADD COLUMN IF NOT EXISTS follows text`;
+		},
+	};
+
+	/** Every migration of the modes' table, in order. */
+	static readonly migrations: readonly Migration[] = [
+		PgConversationModes.migration,
+		PgConversationModes.followsMigration,
+	];
+
 	/**
 	 * The modes over the host's migrated pool, with none loaded: `Roundtable.check()` opens no
 	 * connection, so the rows are read by `load`, from the plugin's service start.
@@ -128,11 +188,15 @@ export class PgConversationModes implements ConversationModes {
 		// A mode `set` wrote while the rows were read is newer than its row here.
 		for (const row of rows)
 			if (!this.#modes.has(row.channel as ChannelKey))
-				this.#modes.set(row.channel as ChannelKey, modeOf(row));
+				this.#modes.set(row.channel as ChannelKey, storedOf(row));
 	}
 
 	peek(channel: ChannelKey): ConversationMode {
-		return this.#modes.get(channel) ?? OFF;
+		return resolveMode(channel, (key) => this.#modes.get(key), this.#origins);
+	}
+
+	trackOrigins(origins: ModeOrigins): void {
+		this.#origins = origins;
 	}
 
 	async set(
@@ -140,9 +204,11 @@ export class PgConversationModes implements ConversationModes {
 		change: ModeChange,
 		by: Speaker,
 	): Promise<ConversationMode> {
-		if (by.tier !== "owner" || by.principalId === SYSTEM_PRINCIPAL)
+		checkOwner(by);
+		const inherited = this.peek(channel).inheritedFrom;
+		if (inherited)
 			throw new PluginError(
-				"only an owner sets a conversation's modes, and not the host's own turns",
+				`this conversation follows the modes of ${inherited.name ?? inherited.channel}; change them there`,
 			);
 		const yolo = change.yolo ?? null;
 		const longRunning = change.longRunning ?? null;
@@ -155,13 +221,14 @@ export class PgConversationModes implements ConversationModes {
 				yolo = COALESCE(${yolo}::boolean, conversation_modes.yolo),
 				long_running = COALESCE(${longRunning}::boolean, conversation_modes.long_running),
 				changed_by = ${by.principalId},
-				changed_at = now()
+				changed_at = now(),
+				follows = NULL
 			RETURNING *`;
 		const [row] = rows;
 		if (!row)
 			throw new Error(`conversation modes of ${channel} were not stored`);
-		const mode = modeOf(row);
-		this.#modes.set(channel, mode);
+		this.#modes.set(channel, storedOf(row));
+		const mode = this.peek(channel);
 		this.#logger.info(
 			{
 				channel,
@@ -171,10 +238,44 @@ export class PgConversationModes implements ConversationModes {
 			},
 			"conversation modes changed",
 		);
-		this.#tell(this.#changed, "change", (listener) => listener(channel, mode));
+		this.#announce(channel);
 		return mode;
 	}
 
+	async follow(
+		channels: readonly ChannelKey[],
+		origin: ChannelKey,
+		by: Speaker,
+	): Promise<void> {
+		checkOwner(by);
+		for (const channel of channels) {
+			// Its own modes go off: they count again only once it no longer follows.
+			const rows: Row[] = await this.#sql`
+				INSERT INTO conversation_modes (channel, yolo, long_running, changed_by, changed_at, follows)
+				VALUES (${channel}, false, false, ${by.principalId}, now(), ${origin})
+				ON CONFLICT (channel) DO UPDATE SET
+					yolo = false, long_running = false, changed_by = ${by.principalId},
+					changed_at = now(), follows = ${origin}
+				RETURNING *`;
+			const [row] = rows;
+			if (!row)
+				throw new Error(`conversation modes of ${channel} were not stored`);
+			this.#modes.set(channel, storedOf(row));
+			this.#logger.info(
+				{ channel, origin, by: by.principalId },
+				"conversation modes follow another conversation",
+			);
+			this.#announce(channel);
+		}
+	}
+
+	async forget(channel: ChannelKey): Promise<void> {
+		await this.#sql`DELETE FROM conversation_modes WHERE channel = ${channel}`;
+		if (!this.#modes.delete(channel)) return;
+		this.#logger.info({ channel }, "conversation modes forgotten");
+		this.#announce(channel);
+	}
+
 	onChange(
 		listener: (channel: ChannelKey, mode: ConversationMode) => void,
 	): () => void {
@@ -200,6 +301,17 @@ export class PgConversationModes implements ConversationModes {
 		return () => void this.#approved.delete(listener);
 	}
 
+	/** Tells the listeners of `channel`'s modes, and of each conversation that follows it. */
+	#announce(channel: ChannelKey): void {
+		for (const key of [
+			channel,
+			...followersOf(channel, this.#modes, this.#origins),
+		]) {
+			const mode = this.peek(key);
+			this.#tell(this.#changed, "change", (listener) => listener(key, mode));
+		}
+	}
+
 	/** Runs each listener; one that throws is logged and the rest still hear it. */
 	#tell<L>(listeners: Set<L>, what: string, call: (listener: L) => void): void {
 		for (const listener of [...listeners]) {