pi-roundtable 0.1.0 → 0.2.0

package/src/core/discord/discord-surface.ts

@@ -8,24 +8,30 @@ import {
 	type Interaction,
 	type Message,
 	MessageFlags,
-	MessageReferenceType,
 	Partials,
 } from "discord.js";
-import type { AttachmentRef } from "../domain/attachment.ts";
+import type { AgentChannels, DashboardBoard } from "../agents/agent-ports.ts";
+import type { ChatSurface } from "../contract/surface.ts";
 import type {
 	ChannelKey,
 	InboundMessage,
 	OutboundReply,
 } from "../domain/conversation.ts";
-import type { ChatSurface, OwnerNotifier } from "../domain/ports.ts";
+import type { OwnerPrompts } from "../domain/owner-prompts.ts";
+import type { OwnerNotifier } from "../domain/ports.ts";
 import { messages } from "../i18n/index.ts";
 import type { Logger } from "../log.ts";
+import type { OwnerOperations } from "../modules/discord-admin/discord-admin.ts";
 import { splitReply } from "../presentation/reply-splitter.ts";
-import type { ComposedInteractions } from "../registry/interactions.ts";
+import type { Speaker } from "../speakers.ts";
 import { DiscordAgentChannels, DiscordDashboard } from "./agent-discord.ts";
 import { discordChannelExecutor } from "./channel-executor.ts";
 import type { ChannelExecutor } from "./channel-operations.ts";
+import type { ComposedCommands } from "./compose-commands.ts";
+import type { ChannelInfo, DiscordConnection } from "./connection.ts";
 import { DiscordThreadHost } from "./dispatch-thread-host.ts";
+import type { ThreadHost } from "./dispatch-threads.ts";
+import { toInbound } from "./inbound-message.ts";
 import type { CardChannel } from "./owner-cards.ts";
 import { DiscordOwnerOps } from "./owner-discord.ts";
 import { stopPanel } from "./stop-button.ts";
@@ -34,9 +40,6 @@ const PREFIX = "discord:";
 /** Discord's error code for a channel that does not exist or cannot be seen. */
 const UNKNOWN_CHANNEL = 10003;
 
-export type ChannelInfo =
-	| { kind: "dm"; name: string }
-	| { kind: "guild"; name: string; guild: string; guildId: string };
 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;
@@ -46,6 +49,8 @@ export interface DiscordSurfaceOptions {
 	ownerId: string;
 	/** How the owner is named in audit-log reasons and refusals. */
 	ownerName: string;
+	/** The owner's cards in a Discord channel; the surface hands them out as its `prompts`. */
+	prompts: (channel: ChannelKey, speaker?: Speaker) => OwnerPrompts | undefined;
 	logger: Logger;
 }
 
@@ -55,7 +60,10 @@ export interface DiscordSurfaceOptions {
  * server's channels answer the owner without a mention; elsewhere the assistant still answers only
  * DMs and messages that mention it.
  */
-export class DiscordSurface implements ChatSurface, OwnerNotifier {
+export class DiscordSurface
+	implements ChatSurface, OwnerNotifier, DiscordConnection
+{
+	readonly surface = "discord";
 	readonly #options: DiscordSurfaceOptions;
 	readonly #client = new Client({
 		intents: [
@@ -68,15 +76,15 @@ export class DiscordSurface implements ChatSurface, OwnerNotifier {
 		allowedMentions: { parse: [] },
 	});
 
-	#interactions: ComposedInteractions = { commands: [], modules: [] };
+	#interactions: ComposedCommands = { commands: [], modules: [] };
 
 	constructor(options: DiscordSurfaceOptions) {
 		this.#options = options;
 	}
 
 	/** Slash commands and the modules that answer them; the commands are registered globally at startup. */
-	useInteractions(interactions: ComposedInteractions): void {
-		this.#interactions = interactions;
+	setCommands(composed: ComposedCommands): void {
+		this.#interactions = composed;
 	}
 
 	/** Channel operations for outside agents; undefined until the connection is ready. */
@@ -87,7 +95,7 @@ export class DiscordSurface implements ChatSurface, OwnerNotifier {
 	}
 
 	/** Discord reading and management for the owner's agent; calls fail until the connection is ready. */
-	ownerDiscord(): DiscordOwnerOps {
+	ownerOperations(): OwnerOperations {
 		return new DiscordOwnerOps(
 			this.#client,
 			this.#options.ownerId,
@@ -96,17 +104,17 @@ export class DiscordSurface implements ChatSurface, OwnerNotifier {
 	}
 
 	/** The agent server's channels and webhooks. */
-	agentChannels(guildId: string): DiscordAgentChannels {
+	agentChannels(guildId: string): AgentChannels {
 		return new DiscordAgentChannels(this.#client, guildId);
 	}
 
 	/** Threads for background dispatches, in the channel that started each. */
-	threadHost(): DiscordThreadHost {
+	threadHost(): ThreadHost {
 		return new DiscordThreadHost(this.#client);
 	}
 
 	/** The agent server's `#dashboard` and its pinned status message. */
-	agentDashboard(guildId: string): DiscordDashboard {
+	agentDashboard(guildId: string): DashboardBoard {
 		return new DiscordDashboard(this.#client, guildId, this.#options.logger);
 	}
 
@@ -145,10 +153,18 @@ export class DiscordSurface implements ChatSurface, OwnerNotifier {
 		this.#client.on(Events.ChannelDelete, (channel) => handler(channel.id));
 	}
 
+	/** The owner's approval and question cards in a Discord channel. */
+	prompts(channel: ChannelKey, speaker?: Speaker): OwnerPrompts | undefined {
+		return this.#options.prompts(channel, speaker);
+	}
+
 	async start(onMessage: (message: InboundMessage) => void): Promise<void> {
 		const { logger, token } = this.#options;
 		this.#client.on(Events.MessageCreate, (message) => {
-			this.#toInbound(message)
+			toInbound(message, {
+				botId: this.#client.user?.id,
+				applicationId: this.#client.application?.id,
+			})
 				.then((inbound) => {
 					if (inbound) onMessage(inbound);
 				})
@@ -317,73 +333,6 @@ export class DiscordSurface implements ChatSurface, OwnerNotifier {
 		await this.#client.destroy();
 	}
 
-	async #toInbound(message: Message): Promise<InboundMessage | undefined> {
-		const botId = this.#client.user?.id;
-		if (!botId || message.author.id === botId) return undefined;
-		const mention = new RegExp(`<@!?${botId}>`, "g");
-		const reference = message.reference;
-		// A forward also has a reference, to a message elsewhere; its copy is the snapshot.
-		const forward =
-			reference?.type === MessageReferenceType.Forward
-				? message.messageSnapshots.first()
-				: undefined;
-		const referenced =
-			reference?.messageId && !forward
-				? await message.fetchReference().catch(() => undefined)
-				: undefined;
-		return {
-			channel: `${PREFIX}${message.channelId}`,
-			messageId: message.id,
-			authorId: message.author.id,
-			authorName:
-				message.member?.displayName ??
-				message.author.globalName ??
-				message.author.username,
-			authorIsBot: message.author.bot,
-			...(message.member
-				? { authorRoleIds: [...message.member.roles.cache.keys()] }
-				: {}),
-			...(message.webhookId
-				? {
-						webhookId: message.webhookId,
-						// Webhooks the assistant created carry its application on every message they post.
-						ownWebhook:
-							message.applicationId !== null &&
-							message.applicationId === (this.#client.application?.id ?? botId),
-					}
-				: {}),
-			isDirect: message.channel.isDMBased(),
-			...(message.guildId ? { guildId: message.guildId } : {}),
-			mentionsBot: message.mentions.users.has(botId),
-			repliesToBot: referenced?.author.id === botId,
-			text: message.content.replace(mention, "").trim(),
-			attachments: [
-				...attachmentRefs(message),
-				...(forward ? attachmentRefs(forward) : []),
-			],
-			...(forward && reference?.channelId
-				? {
-						forwarded: {
-							text: forward.content ?? "",
-							channelMention: `<#${reference.channelId}>`,
-							url: `https://discord.com/channels/${reference.guildId ?? "@me"}/${reference.channelId}/${reference.messageId ?? ""}`,
-						},
-					}
-				: {}),
-			...(referenced
-				? {
-						reference: {
-							text: referenced.content.replace(mention, "").trim(),
-							attachments: attachmentRefs(referenced),
-							...(referenced.webhookId
-								? { webhookName: referenced.author.username }
-								: {}),
-						},
-					}
-				: {}),
-		};
-	}
-
 	async #dispatch(interaction: Interaction): Promise<void> {
 		const { logger } = this.#options;
 		try {
@@ -418,14 +367,3 @@ export class DiscordSurface implements ChatSurface, OwnerNotifier {
 		return target;
 	}
 }
-
-function attachmentRefs(
-	message: Pick<Message, "attachments">,
-): AttachmentRef[] {
-	return [...message.attachments.values()].map((attachment) => ({
-		url: attachment.url,
-		name: attachment.name,
-		...(attachment.contentType ? { contentType: attachment.contentType } : {}),
-		size: attachment.size,
-	}));
-}

package/src/core/discord/dispatch-threads.ts

@@ -12,7 +12,7 @@ import type { Logger } from "../log.ts";
 
 const PREFIX = "discord:";
 /** Discord's limit on a thread name. */
-export const THREAD_NAME_LIMIT = 100;
+const THREAD_NAME_LIMIT = 100;
 
 /** The chat side of dispatch threads; the Discord surface implements it. */
 export interface ThreadHost {
@@ -48,7 +48,7 @@ export interface DispatchThreadsOptions {
 	host: ThreadHost;
 	/** Threads still open, so a start after a crash can archive them. */
 	ledgerPath: string;
-	/** Channels that keep posting in place, such as party channels. */
+	/** Channels whose claims keep reports in place rather than opening threads. */
 	excluded?: (channel: ChannelKey) => boolean;
 	logger: Logger;
 }

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

@@ -0,0 +1,99 @@
+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";
+
+/** Who the bot is on Discord, as far as the client knows it. */
+export interface BotIdentity {
+	/** The bot user's id; undefined until the client is ready. */
+	botId: string | undefined;
+	/** The application's id, which the webhooks the assistant created carry. */
+	applicationId: string | undefined;
+}
+
+function attachmentRefs(
+	message: Pick<Message, "attachments">,
+): AttachmentRef[] {
+	return [...message.attachments.values()].map((attachment) => ({
+		url: attachment.url,
+		name: attachment.name,
+		...(attachment.contentType ? { contentType: attachment.contentType } : {}),
+		size: attachment.size,
+	}));
+}
+
+/**
+ * The facts of one Discord message, as the neutral `InboundMessage`; undefined for the bot's own
+ * messages and before the client is ready. A forward reports the channel it came from as a
+ * channel key, and a webhook's post as an integration.
+ */
+export async function toInbound(
+	message: Message,
+	{ botId, applicationId }: BotIdentity,
+): Promise<InboundMessage | undefined> {
+	if (!botId || message.author.id === botId) return undefined;
+	const mention = new RegExp(`<@!?${botId}>`, "g");
+	const reference = message.reference;
+	// A forward also has a reference, to a message elsewhere; its copy is the snapshot.
+	const forward =
+		reference?.type === MessageReferenceType.Forward
+			? message.messageSnapshots.first()
+			: undefined;
+	const referenced =
+		reference?.messageId && !forward
+			? await message.fetchReference().catch(() => undefined)
+			: undefined;
+	return {
+		channel: channelKey("discord", message.channelId),
+		messageId: message.id,
+		authorId: message.author.id,
+		authorName:
+			message.member?.displayName ??
+			message.author.globalName ??
+			message.author.username,
+		authorIsBot: message.author.bot,
+		...(message.member
+			? { authorRoleIds: [...message.member.roles.cache.keys()] }
+			: {}),
+		...(message.webhookId
+			? {
+					integration: {
+						id: message.webhookId,
+						// Webhooks the assistant created carry its application on every message they post.
+						own:
+							message.applicationId !== null &&
+							message.applicationId === (applicationId ?? botId),
+					},
+				}
+			: {}),
+		isDirect: message.channel.isDMBased(),
+		...(message.guildId ? { space: message.guildId } : {}),
+		mentionsBot: message.mentions.users.has(botId),
+		repliesToBot: referenced?.author.id === botId,
+		text: message.content.replace(mention, "").trim(),
+		attachments: [
+			...attachmentRefs(message),
+			...(forward ? attachmentRefs(forward) : []),
+		],
+		...(forward && reference?.channelId
+			? {
+					forwarded: {
+						text: forward.content ?? "",
+						source: channelKey("discord", reference.channelId),
+						url: `https://discord.com/channels/${reference.guildId ?? "@me"}/${reference.channelId}/${reference.messageId ?? ""}`,
+					},
+				}
+			: {}),
+		...(referenced
+			? {
+					reference: {
+						text: referenced.content.replace(mention, "").trim(),
+						attachments: attachmentRefs(referenced),
+						...(referenced.webhookId
+							? { webhookName: referenced.author.username }
+							: {}),
+					},
+				}
+			: {}),
+	};
+}

package/src/core/discord/interaction-module.ts

@@ -1 +1,57 @@
-export type { InteractionModule } from "../contract/discord.ts";
+import type {
+	APIApplicationCommandSubcommandGroupOption,
+	APIApplicationCommandSubcommandOption,
+	Interaction,
+	InteractionContextType,
+	RESTPostAPIChatInputApplicationCommandsJSONBody,
+} from "discord.js";
+
+/** A group of slash commands and the components they post, handled together. */
+export interface InteractionModule {
+	/** Top-level commands of its own; never the configured root command. */
+	commands(): RESTPostAPIChatInputApplicationCommandsJSONBody[];
+	/** Resolves true when this module handled the interaction. */
+	handle(interaction: Interaction): Promise<boolean>;
+}
+
+/** A subcommand or subcommand group under the root command. */
+export type RootOption =
+	| APIApplicationCommandSubcommandOption
+	| APIApplicationCommandSubcommandGroupOption;
+
+/** A plugin's interactions: its module, and the subcommands it adds under the root command. */
+export interface InteractionContribution {
+	module: InteractionModule;
+	rootOptions?: readonly RootOption[];
+}
+
+/** The one root command every plugin's subcommands go under, such as `/roundtable`. */
+export interface CommandRoot {
+	name: string;
+	description: string;
+	contexts: readonly InteractionContextType[];
+}
+
+/**
+ * Takes the slash commands and components of the plugins. Plugins add theirs while they set up;
+ * the Discord plugin composes them in its preflight, so a clash fails before any service starts.
+ */
+export interface CommandRegistrar {
+	/** Throws PluginError once the Discord plugin's preflight has composed the commands. */
+	add(contribution: InteractionContribution): void;
+}
+
+/** Who may use the owner's commands, and how a failing command answers. */
+export interface CommandGuard {
+	/** The name of the root command the guard serves, without the slash. */
+	readonly root: string;
+	/**
+	 * Text appended as it is to the refusal a non-owner gets, such as a pointer to the commands
+	 * anyone may use; include the space or punctuation your language needs before it.
+	 */
+	readonly refusalHint?: string;
+	/** Whether the actor is the owner: an interaction, or anything with `user.id`, such as a test's. */
+	isOwner(actor: { user: { id: string } }): boolean;
+	/** Runs a handler; a failure becomes a panel instead of a hanging interaction. */
+	run(interaction: Interaction, run: () => Promise<void>): Promise<void>;
+}

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

@@ -12,6 +12,7 @@ import {
 	TextInputBuilder,
 	TextInputStyle,
 } from "discord.js";
+import { parseChannelKey } from "../contract/surface.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
 import type {
 	Approval,
@@ -56,7 +57,7 @@ export interface CardMessage {
 /** Where a channel's cards are posted. */
 export interface CardChannel {
 	send(payload: CardPayload): Promise<CardMessage>;
-	/** A thread, where the owner is mentioned so he hears of the card; a channel never mentions him. */
+	/** A thread, where the owner is mentioned so they hear of the card; a channel never mentions them. */
 	thread?: boolean;
 }
 
@@ -118,10 +119,9 @@ export class OwnerCards implements InteractionModule {
 		return [];
 	}
 
-	/** The channel's cards; undefined for a conversation outside Discord. */
+	/** The channel's cards; the chat surface port sends only Discord keys here. */
 	prompts(channel: ChannelKey, speaker?: Speaker): OwnerPrompts | undefined {
-		if (!channel.startsWith("discord:")) return undefined;
-		const channelId = channel.slice("discord:".length);
+		const channelId = parseChannelKey(channel).id;
 		return {
 			confirm: (title, message, signal, minTier = "owner") =>
 				this.#post<Approval>(channelId, signal, "expired", "cancelled", {

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

@@ -6,10 +6,14 @@ import {
 	MessageFlags,
 	SlashCommandSubcommandGroupBuilder,
 } from "discord.js";
-import type { CommandRoot, RootOption } from "../contract/discord.ts";
 import { messages } from "../i18n/index.ts";
 import type { Logger } from "../log.ts";
-import type { InteractionModule } from "./interaction-module.ts";
+import type {
+	CommandGuard,
+	CommandRoot,
+	InteractionModule,
+	RootOption,
+} from "./interaction-module.ts";
 import { ephemeralPanel, OwnerFacingError, ownerPanel } from "./owner-panel.ts";
 
 /** The owner's single control command, such as `/roundtable`, every feature adds its subcommands to. */
@@ -29,24 +33,31 @@ export const groupOption = (
 ): RootOption => build(new SlashCommandSubcommandGroupBuilder()).toJSON();
 
 /**
- * Only the owner may use the root command, checked by user ID; every answer is visible only to him,
+ * Only the owner may use the root command, checked by user ID; every answer is visible only to them,
  * and a failure becomes a panel instead of a hanging interaction.
  */
 // pi-lens-ignore: large-class — two methods: the owner check and the failure panel
-export class OwnerGuard {
+export class OwnerGuard implements CommandGuard {
 	readonly #ownerId: string;
 	readonly #logger: Logger;
 	/** The name of the root command the guard serves, without the slash. */
 	readonly root: string;
+	readonly refusalHint: string | undefined;
 
-	constructor(ownerId: string, logger: Logger, root: string) {
+	constructor(
+		ownerId: string,
+		logger: Logger,
+		root: string,
+		refusalHint?: string,
+	) {
 		this.#ownerId = ownerId;
 		this.#logger = logger;
 		this.root = root;
+		this.refusalHint = refusalHint;
 	}
 
-	isOwner(interaction: Interaction): boolean {
-		return interaction.user.id === this.#ownerId;
+	isOwner(actor: { user: { id: string } }): boolean {
+		return actor.user.id === this.#ownerId;
 	}
 
 	/** Runs a handler; failures become a panel instead of a hanging interaction. */
@@ -69,6 +80,28 @@ export class OwnerGuard {
 	}
 }
 
+/** What `commandGuard` needs. */
+export interface CommandGuardOptions {
+	/** The one user who may use the owner's commands. */
+	ownerId: string;
+	/** The name of the root command the guard serves, without the slash. */
+	root: string;
+	/** Where a failing command is logged. */
+	logger: Logger;
+	/** Text appended as it is to the refusal a non-owner gets. */
+	refusalHint?: string;
+}
+
+/** A guard for the owner's commands, such as the one a test hands a module; the Discord plugin makes its own. */
+export function commandGuard(options: CommandGuardOptions): CommandGuard {
+	return new OwnerGuard(
+		options.ownerId,
+		options.logger,
+		options.root,
+		options.refusalHint,
+	);
+}
+
 /** One feature's part of the root command. */
 export interface OwnerCommandHandlers {
 	/** Whether a root subcommand, in its group or null at the top level, is this feature's. */
@@ -82,15 +115,15 @@ export interface OwnerCommandHandlers {
 	component?(interaction: Interaction): Promise<boolean>;
 }
 
-const refusal = () =>
+const refusal = (hint: string | undefined) =>
 	ephemeralPanel({
 		title: messages().ownerRefusalTitle,
-		sections: [messages().ownerRefusalBody],
+		sections: [`${messages().ownerRefusalBody}${hint ?? ""}`],
 	});
 
 /** Answers a feature's root subcommands and components, for the owner only. */
 export function ownerCommandModule(
-	guard: OwnerGuard,
+	guard: CommandGuard,
 	handlers: OwnerCommandHandlers,
 ): InteractionModule {
 	const owned = (
@@ -114,7 +147,7 @@ export function ownerCommandModule(
 			if (!interaction.isChatInputCommand() || !owned(interaction))
 				return false;
 			if (!guard.isOwner(interaction)) {
-				await interaction.reply(refusal());
+				await interaction.reply(refusal(guard.refusalHint));
 				return true;
 			}
 			if (await handlers.open?.(interaction)) return true;

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

@@ -5,7 +5,7 @@ import {
 	PermissionFlagsBits,
 } from "discord.js";
 import { messages } from "../i18n/index.ts";
-import type { OwnerDiscord } from "../modules/discord-admin/discord-admin.ts";
+import type { OwnerOperations } from "../modules/discord-admin/discord-admin.ts";
 import {
 	discordChannelExecutor,
 	fetchOwnerChannel,
@@ -29,7 +29,7 @@ export { outranksMember, outranksRole } from "./owner-discord-access.ts";
  * Discord operations for the owner's agent over the bot's connection. Every call is bounded
  * by what both the owner and the bot may do where it acts, read fresh from Discord.
  */
-export class DiscordOwnerOps implements OwnerDiscord {
+export class DiscordOwnerOps implements OwnerOperations {
 	readonly #client: Client;
 	readonly #ownerId: string;
 	/** The audit-log reason of an action taken without one of its own. */

package/src/core/discord/schedule-commands.ts

@@ -3,18 +3,15 @@ import type {
 	ChatInputCommandInteraction,
 	SlashCommandSubcommandGroupBuilder,
 } from "discord.js";
-import type { InteractionContribution } from "../contract/discord.ts";
 import { messages } from "../i18n/index.ts";
 import { describeRecurrence } from "../modules/schedules/recurrence.ts";
+import type { Schedule } from "../modules/schedules/schedule-store.ts";
+import type { ScheduleStore } from "../services.ts";
 import type {
-	Schedule,
-	ScheduleStore,
-} from "../modules/schedules/schedule-store.ts";
-import {
-	groupOption,
-	type OwnerGuard,
-	ownerCommandModule,
-} from "./owner-command.ts";
+	CommandGuard,
+	InteractionContribution,
+} from "./interaction-module.ts";
+import { groupOption, ownerCommandModule } from "./owner-command.ts";
 import {
 	OwnerFacingError,
 	ownerPanel,
@@ -52,7 +49,10 @@ function channelMention(schedule: Schedule): string {
 
 const unix = (at: Date) => Math.floor(at.getTime() / 1000);
 
-function section(schedule: Schedule): string {
+/** How a schedule's target reads in a list; the target's name when no plugin contributes it. */
+export type TargetLabel = (target: string) => string;
+
+function section(schedule: Schedule, label: TargetLabel): string {
 	const prompt =
 		schedule.prompt.length > PROMPT_PREVIEW
 			? `${schedule.prompt.slice(0, PROMPT_PREVIEW)}…`
@@ -64,14 +64,12 @@ function section(schedule: Schedule): string {
 				plain(schedule.lastStatus ?? "?"),
 			)
 		: "";
-	const mode =
-		schedule.mode === "owner" ? text.scheduleModeOwner : text.scheduleModeParty;
 	return [
 		text.scheduleHead(
 			schedule.id,
 			plain(schedule.title),
 			channelMention(schedule),
-			mode,
+			plain(label(schedule.target)),
 		),
 		text.scheduleNextRun(
 			describeRecurrence(schedule.recurrence),
@@ -85,9 +83,11 @@ function section(schedule: Schedule): string {
 /** `/<root> schedule`: the owner's view over every channel's schedules. */
 export class ScheduleCommands {
 	readonly #store: ScheduleStore;
+	readonly #label: TargetLabel;
 
-	constructor(store: ScheduleStore) {
+	constructor(store: ScheduleStore, label: TargetLabel) {
 		this.#store = store;
+		this.#label = label;
 	}
 
 	async autocomplete(interaction: AutocompleteInteraction): Promise<void> {
@@ -110,7 +110,9 @@ export class ScheduleCommands {
 		const all = await this.#store.all();
 		await replyWithPanels(interaction, {
 			title: messages().scheduleTitle,
-			sections: all.length ? all.map(section) : [messages().scheduleNone],
+			sections: all.length
+				? all.map((s) => section(s, this.#label))
+				: [messages().scheduleNone],
 			footer: messages().scheduleFooter,
 		});
 	}
@@ -126,7 +128,7 @@ export class ScheduleCommands {
 		await interaction.editReply(
 			ownerPanel({
 				title: messages().scheduleCancelled,
-				sections: [section(removed)],
+				sections: [section(removed, this.#label)],
 			}),
 		);
 	}
@@ -134,10 +136,11 @@ export class ScheduleCommands {
 
 /** `/<root> schedule list|cancel`. */
 export function scheduleCommands(
-	guard: OwnerGuard,
+	guard: CommandGuard,
 	store: ScheduleStore,
+	label: TargetLabel,
 ): InteractionContribution {
-	const commands = new ScheduleCommands(store);
+	const commands = new ScheduleCommands(store, label);
 	return {
 		module: ownerCommandModule(guard, {
 			owns: (group) => group === "schedule",