pi-roundtable 0.7.19 → 0.9.0

package/src/core/agents/agent-claim.ts

@@ -1,4 +1,8 @@
 import { attachmentsOf } from "../attachments/turn-attachments.ts";
+import {
+	type ChannelContext,
+	withChannelContext,
+} from "../contract/channel-context.ts";
 import type {
 	Admission,
 	BackgroundTarget,
@@ -8,12 +12,13 @@ import type {
 import type { AgentRuntime } from "../contract/runtime.ts";
 import type { SurfacePort } from "../contract/surface.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
-import { messages } from "../i18n/index.ts";
 import type { OwnerIdentity } from "../identity.ts";
 import type { Logger } from "../log.ts";
+import { PERSONAL_TARGET } from "../modules/background/personal-target.ts";
 import { withReference } from "../routing/message-text.ts";
 import { outcome } from "../routing/settle-turn.ts";
-import { addressee, attributed, type SpeakerPolicy } from "../speakers.ts";
+import { systemTurn } from "../routing/system-turns.ts";
+import { addressee, attributed } from "../speakers.ts";
 import type { DiscordAgentTeam } from "./agent-team.ts";
 import { discordIdOf } from "./team-keys.ts";
 
@@ -27,23 +32,15 @@ import { discordIdOf } from "./team-keys.ts";
 export const AGENT_SERVER_PRIORITY = 100;
 
 /**
- * The host's own background target: the conversations of the owner and of the agent server. The
- * agent server contributes it, so schedules and delegated tasks made in those conversations carry
- * its name and limits. Its label is read when a list is shown, never when this module loads,
- * because the host applies its catalog at startup.
+ * The host's own background target, which the agent server answers.
+ * @deprecated Use `PERSONAL_TARGET`, the same target, which the core contributes on every host;
+ * this name goes away in 1.0.
  */
-export const OWNER_TARGET: BackgroundTarget = {
-	name: "owner",
-	label: () => messages().scheduleModeOwner,
-	schedules: { perChannel: 20, promptChars: 8_000, aheadDays: 366 },
-	delegation: { maxRunning: 3 },
-};
+export const OWNER_TARGET: BackgroundTarget = PERSONAL_TARGET;
 
 export interface AgentClaimOptions {
 	/** The owner, as forwarded messages name them. */
 	owner: OwnerIdentity;
-	/** Who may talk to the agents, and at which tier. */
-	speakers: SpeakerPolicy;
 	team: Pick<
 		DiscordAgentTeam,
 		| "guildId"
@@ -60,6 +57,13 @@ export interface AgentClaimOptions {
 	logger: Logger;
 	/** Replaceable in tests. */
 	fetchImpl?: typeof fetch;
+	/**
+	 * What was said in an agent's channel since its last post, `DISCORD.channelContext`; without it
+	 * the turns carry none. A group's round carries what was said since its last turn already.
+	 */
+	channelContext?: (
+		message: InboundMessage,
+	) => Promise<ChannelContext | undefined>;
 }
 
 /**
@@ -68,24 +72,39 @@ export interface AgentClaimOptions {
  * failure notice, is a labelled report turn for the agent.
  */
 export function agentClaim(options: AgentClaimOptions): ChannelClaim {
-	const { speakers, team, runtime, surface, attachmentDir, logger, fetchImpl } =
-		options;
+	const { team, runtime, surface, attachmentDir, logger, fetchImpl } = options;
 	const attachments = (message: InboundMessage) =>
 		attachmentsOf(message, attachmentDir(message.channel), logger, fetchImpl);
+	/** The channel context of a message in an agent's channel; none, logged, when it cannot be read. */
+	const around = async (
+		message: InboundMessage,
+	): Promise<ChannelContext | undefined> => {
+		try {
+			return await options.channelContext?.(message);
+		} catch (error) {
+			logger.warn(
+				{ channel: message.channel, err: error },
+				"channel context not read; the turn runs without it",
+			);
+			return undefined;
+		}
+	};
 
 	const webhookReport = (message: InboundMessage): Admission | undefined => {
 		const text = message.text.trim();
 		if (!text) return undefined;
 		return {
 			kind: "background",
-			turn: {
+			// The host's own turn, at the owner tier as in 0.8; what the webhook posted is untrusted input.
+			turn: systemTurn({
 				channel: message.channel,
-				target: OWNER_TARGET.name,
+				target: PERSONAL_TARGET.name,
 				author: { id: message.authorId, name: message.authorName },
+				tier: "owner",
 				turnId: `webhook-${message.messageId}`,
 				text: `Webhook "${message.authorName}" posted in your channel:\n${text}`,
 				report: true,
-			},
+			}),
 			unanswered: (result) =>
 				logger.warn(
 					{
@@ -112,13 +131,9 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 			if (!owned) return undefined;
 			if (owned === "agent" && message.integration && !message.integration.own)
 				return webhookReport(message);
-			if (message.authorIsBot) return undefined;
-			const speaker = speakers.resolve({
-				id: message.authorId,
-				name: message.authorName,
-				...(message.authorRoleIds ? { roleIds: message.authorRoleIds } : {}),
-			});
-			if (!speaker) return undefined;
+			// Who may talk to the agents, and at which tier, the router resolved through the identity service.
+			const { speaker } = message;
+			if (message.authorIsBot || !speaker) return undefined;
 			const { channel, messageId } = message;
 			const forwarder = addressee(speaker, options.owner);
 			return {
@@ -147,7 +162,10 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 						await team.answerOwner(
 							channel,
 							speaker,
-							attributed(speaker, text),
+							attributed(
+								speaker,
+								withChannelContext(text, await around(message)),
+							),
 							message.text,
 							saved,
 						);
@@ -166,22 +184,26 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 		},
 		background: async (turn) => {
 			// Fail closed: a turn for any target but the owner's never reaches the owner's tools.
-			if (turn.target !== OWNER_TARGET.name)
+			if (turn.target !== PERSONAL_TARGET.name)
 				return {
 					status: "skipped",
-					reason: `the agent server answers only "${OWNER_TARGET.name}" background turns`,
+					reason: `the agent server answers only "${PERSONAL_TARGET.name}" background turns`,
 				};
 			const owned = team.owns(turn.channel);
 			if (owned === "group")
 				return { status: "skipped", reason: "groups have no schedules" };
+			// Who the turn runs as, checked by the router: its author's principal, at a tier they hold.
+			const { speaker } = turn;
+			if (!speaker)
+				return {
+					status: "skipped",
+					reason:
+						"a background turn reaches the agent server through the router, which says whom it runs as",
+				};
 			return outcome(
 				await team.answerBackground(
 					turn.channel,
-					{
-						id: turn.author.id,
-						name: turn.author.name,
-						tier: turn.tier ?? "owner",
-					},
+					speaker,
 					turn.text,
 					turn.report === true,
 				),

package/src/core/agents/agent-team-fixture.ts

@@ -25,6 +25,7 @@ import {
 } from "../testing/database.ts";
 import { useTestLocale } from "../testing/locale.ts";
 import { OWNER_SPEAKER, TEST_OWNER } from "../testing/owner.ts";
+import { toolTiers } from "../tool-tiers.ts";
 import type {
 	AgentCategory,
 	AgentChannels,
@@ -176,6 +177,10 @@ export interface TeamFixture {
 	skills: SkillRegistry;
 }
 
+/** The tool tiers the team reads; `deploy` is an admin's tool, so an admin may approve it. */
+const FIXTURE_TIERS = toolTiers();
+FIXTURE_TIERS.declare("test", { deploy: "admin" });
+
 /** The fixture of the running test; set by `useTeamFixture` before each test. */
 export const fx = {} as TeamFixture;
 
@@ -297,6 +302,7 @@ export function useTeamFixture(): void {
 		eventLog.length = 0;
 		team = new AgentTeam({
 			owner: TEST_OWNER,
+			toolTiers: FIXTURE_TIERS,
 			shellUser: "mcops",
 			guildId: "1",
 			entryChannelId: ENTRY,

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

@@ -143,8 +143,17 @@ export class TeamTurns {
 		);
 	}
 
-	/** Whether the speaker's tier holds every tool of the held actions. */
+	/**
+	 * Whether the speaker may approve the held actions by a message: an owner, as the agents'
+	 * channels are shared, or the principal whose turn held them (by their id, for actions held
+	 * before 0.9), when their tier now holds every tool. Nobody else in the channel may.
+	 */
 	#mayApprove(speaker: Speaker, pending: PendingConfirmation): boolean {
+		const theirs =
+			pending.principalId !== undefined
+				? speaker.principalId === pending.principalId
+				: speaker.id === pending.speakerId;
+		if (speaker.tier !== "owner" && !theirs) return false;
 		const tiers = this.#options.toolTiers ?? toolTiers();
 		return pending.calls.every(
 			(call) =>

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

@@ -2,7 +2,7 @@ import { chmodSync, lstatSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
 import type { SQL } from "bun";
-import { agentClaim, OWNER_TARGET } from "../agents/agent-claim.ts";
+import { agentClaim } from "../agents/agent-claim.ts";
 import { AgentDashboard } from "../agents/agent-dashboard.ts";
 import { PgAgentStore } from "../agents/agent-store.ts";
 import { DiscordAgentTeam } from "../agents/agent-team.ts";
@@ -11,28 +11,26 @@ import { FileAvatarStudio } from "../agents/avatar-studio.ts";
 import { RelevanceScorer } from "../agents/group-round.ts";
 import { discordKey } from "../agents/team-keys.ts";
 import { ownerAttachmentDir } from "../attachments/attachment-dir.ts";
-import type { AgentRuntime, AgentSessions } from "../contract/runtime.ts";
+import type { AgentSessions } from "../contract/runtime.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
 import { ConfigError } from "../domain/errors.ts";
-import type { InterimTextMode } from "../domain/interim.ts";
 import type { OwnerIdentity } from "../identity.ts";
 import { ConfirmationJudge } from "../judging/confirmation-judge.ts";
-import { AGENT_BRIEF, EffortJudge } from "../judging/effort-judge.ts";
-import {
-	AUTO_THINKING,
-	formatModelRef,
-	type ModelRef,
-	type ThinkingLevel,
-} from "../models.ts";
+import { AUTO_THINKING, formatModelRef, type ModelRef } from "../models.ts";
 import type { ErrorReporter } from "../ops/error-reporter.ts";
 import type { PluginContext, RoundtablePlugin } from "../plugin.ts";
 import { splitReply } from "../presentation/reply-splitter.ts";
 import { agentPromptExtension } from "../runtime/extensions/agent-prompt.ts";
-import { PendingConfirmationStore } from "../runtime/pending-confirmation-store.ts";
-import { PiAgentRuntime } from "../runtime/pi-agent-runtime.ts";
-import { AGENTS, BACKGROUND_TURNS, SCHEDULES, SKILLS } from "../services.ts";
+import type { AgentSessionsSlot } from "../runtime/runtime-plugin.ts";
+import {
+	AGENTS,
+	BACKGROUND_TURNS,
+	RUNTIME,
+	SCHEDULES,
+	SKILLS,
+} from "../services.ts";
 import type { SessionTool } from "../sessions.ts";
-import type { Speaker, SpeakerPolicy, Tier } from "../speakers.ts";
+import type { Tier } from "../speakers.ts";
 import { DISCORD } from "./discord.ts";
 import { agentOnly } from "./session-tool.ts";
 
@@ -43,17 +41,15 @@ export interface AgentServerOptions {
 	owner: OwnerIdentity & { id: string };
 	/** The assistant's display name, as the confirmation judge names it. */
 	assistant: string;
-	/** Who may talk to the agents, and at which tier. */
-	speakers: SpeakerPolicy;
-	/** Shared with the rest of the host, so logins refresh in one place. */
+	/** Shared with the rest of the host, so logins refresh in one place; lists the models an agent may run. */
 	modelRuntime: ModelRuntime;
-	agentDir: string;
 	dataDir: string;
-	/** The model of agents and of the assistant, and the thinking level a judge falls back to. */
+	/** The model of agents and of the assistant. */
 	model: ModelRef;
-	thinking: ThinkingLevel;
-	/** How sure the judges must be before their answer is used. */
+	/** How sure the confirmation judge must be before its answer is used. */
 	judgeThreshold: number;
+	/** Where the agent server hands the runtime plugin its per-agent settings. */
+	agents?: AgentSessionsSlot;
 	/** The shell's shared working directory. */
 	workDir: string;
 	/**
@@ -63,6 +59,11 @@ export interface AgentServerOptions {
 	scratchDir?: string;
 	/** The host account the agents' shell and file tools run as. */
 	shellUser: string;
+	/**
+	 * Whose turns in the agents' channels load memory: `"everyone"` (the default) or `"owners"`;
+	 * see `AgentSessions.memory`.
+	 */
+	memory?: "everyone" | "owners";
 	/** The prompt every agent starts with, and the one for speakers other than the owner. */
 	prompts: { shared: string; guest?: string };
 	/** The listener the avatar pictures are served on. */
@@ -73,10 +74,6 @@ export interface AgentServerOptions {
 	avatarReference: string;
 	/** Reports the process's own errors to an agent; without one nothing is reported. */
 	errorReporter?: ErrorReporter;
-	/** Whether turns post the text they write before their final answer as they go; default "on". */
-	interimText?: InterimTextMode;
-	/** An intermediate text this long or longer is posted as an ordinary message; default 400. */
-	interimPrimaryChars?: number;
 }
 
 /** The name of the agent server's plugin, as `serviceStarted` events name it. */
@@ -109,11 +106,9 @@ const AGENT_TIERS: Readonly<Record<string, Tier>> = {
 	channel_read: "member",
 };
 
-/** The tables the agent server keeps: its agents and groups, and the held actions. */
+/** The tables the agent server keeps: its agents and groups. */
 export interface AgentServerStores {
 	agents: PgAgentStore;
-	/** Held actions, kept across a restart. */
-	confirmations: PendingConfirmationStore;
 }
 
 /** Attaches the agent server's stores over the host's migrated pool. */
@@ -121,16 +116,14 @@ async function attachStores(
 	sql: SQL,
 	guildId: string,
 ): Promise<AgentServerStores> {
-	return {
-		agents: await PgAgentStore.attach(sql, guildId),
-		confirmations: await PendingConfirmationStore.attach(sql),
-	};
+	return { agents: await PgAgentStore.attach(sql, guildId) };
 }
 
 /**
- * The agent server: the team with its channels and dashboard, and the runtime that runs every
- * agent turn. The skills the agents carry come from the skills addon when it is on. It claims the agent channels, starts the team in the
- * background, and hands what it built to the plugins after it.
+ * The agent server: the team with its channels and dashboard, run on the runtime plugin's runtime,
+ * which it hands its per-agent settings. The skills the agents carry come from the skills addon
+ * when it is on. It claims the agent channels, starts the team in the background, and hands what
+ * it built to the plugins after it.
  */
 export function agentServerPlugin(
 	options: AgentServerOptions,
@@ -141,18 +134,13 @@ export function agentServerPlugin(
 	) => Promise<AgentServerStores> = (context, guildId) =>
 		attachStores(context.database(), guildId),
 ): RoundtablePlugin {
-	let runtime: AgentRuntime | undefined;
 	return {
 		name: AGENT_SERVER_PLUGIN,
-		// The agent server's own tables; the host runs them before any setup, in this order.
-		migrations: [
-			PendingConfirmationStore.migration,
-			...PgAgentStore.migrations(options.guildId),
-		],
+		// The agent server's own tables; the host runs them before any setup, in this order. The
+		// held actions' table is the runtime plugin's.
+		migrations: PgAgentStore.migrations(options.guildId),
 		provides: [AGENTS],
-		preflight: async () => {
-			await runtime?.preflight?.();
-		},
+		requires: [RUNTIME],
 		setup: async (context) => {
 			const discord = context.services.get(DISCORD);
 			const schedules = context.services.get(SCHEDULES);
@@ -168,10 +156,8 @@ export function agentServerPlugin(
 			await studio.init();
 			// Absent when the skills addon is off: the agents then carry none.
 			const skills = context.services.find(SKILLS);
-			const { agents: store, confirmations: heldActions } = await openStores(
-				context,
-				options.guildId,
-			);
+			const { agents: store } = await openStores(context, options.guildId);
+			const running = context.services.get(RUNTIME);
 			const judge = providers.judge;
 			const confirmations = new ConfirmationJudge({
 				judge,
@@ -194,11 +180,7 @@ export function agentServerPlugin(
 				store,
 				channels: connection.agentChannels(options.guildId),
 				studio,
-				// The runtime is built next, with this team's tools.
-				runtime: () => {
-					if (!runtime) throw new Error("the runtime is built with the team");
-					return runtime;
-				},
+				runtime: () => running,
 				confirmations,
 				scorer: new RelevanceScorer(judge, logger, options.owner),
 				models: {
@@ -246,51 +228,9 @@ export function agentServerPlugin(
 				modelOf: (name) => built.modelOf(name),
 				skills: (name) => built.skillsOf(name),
 				turnChannel: (scope) => built.turnChannel(scope),
+				...(options.memory ? { memory: options.memory } : {}),
 			};
-			const prompts = (channel: ChannelKey, speaker?: Speaker) =>
-				context.surfaces.prompts(channel, speaker);
-			// A plugin that fills the runtime slot replaces the whole conversation runtime; without
-			// one the agent server runs Pi, built from the options below.
-			const running: AgentRuntime = providers.filled.has("runtime")
-				? providers.runtime({
-						logger,
-						env: context.env,
-						owner: { id: options.owner.id, name: options.owner.name },
-						sessions: context.sessions,
-						toolTiers: context.toolTiers,
-						prompts,
-						agents: agentSessions,
-						confirmations: heldActions,
-						judge,
-					})
-				: new PiAgentRuntime({
-						owner: options.owner,
-						sessions: context.sessions,
-						agentDir: options.agentDir,
-						modelRuntime: options.modelRuntime,
-						dataDir: options.dataDir,
-						model: options.model,
-						thinking: options.thinking,
-						effort: new EffortJudge({
-							judge,
-							brief: AGENT_BRIEF,
-							fallback: options.thinking,
-							threshold: options.judgeThreshold,
-							logger,
-						}),
-						confirmations: heldActions,
-						toolTiers: context.toolTiers,
-						agents: agentSessions,
-						prompts,
-						logger,
-						...(options.interimText
-							? { interimText: options.interimText }
-							: {}),
-						...(options.interimPrimaryChars
-							? { interimPrimaryChars: options.interimPrimaryChars }
-							: {}),
-					});
-			runtime = running;
+			options.agents?.bind(agentSessions);
 			context.services.provide(AGENTS, {
 				team: built,
 				directory: store,
@@ -325,7 +265,6 @@ export function agentServerPlugin(
 				});
 			return {
 				services: [
-					{ name: "runtime", stop: () => running.dispose?.() },
 					{ name: "dashboard", stop: () => dashboard.stop() },
 					{
 						name: AGENT_TEAM_SERVICE,
@@ -341,17 +280,15 @@ export function agentServerPlugin(
 						},
 					},
 				],
-				// The schedules and delegated tasks of the owner's and the agents' conversations are its own.
-				backgroundTargets: [OWNER_TARGET],
 				channels: [
 					agentClaim({
 						owner: options.owner,
-						speakers: options.speakers,
 						team: built,
 						runtime: running,
 						surface: context.surfaces,
 						attachmentDir,
 						logger,
+						channelContext: (message) => discord.channelContext(message),
 					}),
 				],
 				http: [studio.route(options.avatarListener)],

package/src/core/builtin/discord-admin.ts

@@ -8,7 +8,10 @@ import { DISCORD } from "./discord.ts";
 import { fixed } from "./session-tool.ts";
 
 export interface DiscordAdminOptions {
-	/** Whose Discord permissions the tools check, and who they serve. */
+	/**
+	 * Whose Discord permissions the tools check, and who they serve: the primary owner, by their
+	 * Discord user id, whichever owner's turn calls them.
+	 */
 	owner: OwnerIdentity & { id: string };
 }
 

package/src/core/builtin/discord.ts

@@ -1,7 +1,14 @@
 import { join } from "node:path";
+import type {
+	ChannelContext,
+	ChannelContextOptions,
+} from "../contract/channel-context.ts";
 import { type ServiceKey, serviceKey } from "../contract/services.ts";
+import { ChannelContextReader } from "../discord/channel-context.ts";
 import { CommandCollection } from "../discord/command-collection.ts";
 import type { DiscordConnection } from "../discord/connection.ts";
+import { discordDirectChannel } from "../discord/direct-channel.ts";
+import { DiscordOwners } from "../discord/discord-owners.ts";
 import { DiscordSurface } from "../discord/discord-surface.ts";
 import { DispatchThreads } from "../discord/dispatch-threads.ts";
 import type {
@@ -9,20 +16,33 @@ import type {
 	CommandRegistrar,
 } from "../discord/interaction-module.ts";
 import { OwnerCards } from "../discord/owner-cards.ts";
-import { OwnerGuard, ownerRootCommand } from "../discord/owner-command.ts";
+import { commandGuard, ownerRootCommand } from "../discord/owner-command.ts";
 import { stopButtonModule } from "../discord/stop-button.ts";
+import type { InboundMessage } from "../domain/conversation.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
-import type { SpeakerPolicy } from "../speakers.ts";
+import { IDENTITY } from "../services.ts";
 
 /** The Discord connection and what stands on it, as plugins use it. Provided by the Discord plugin. */
 export interface DiscordServices {
 	connection: DiscordConnection;
 	/** Adds a plugin's slash commands and components; during setup only. */
 	commands: CommandRegistrar;
-	/** Who may use the owner's commands. */
+	/** Who may use the owner's commands: every owner, by their Discord identity. */
 	guard: CommandGuard;
 	/** The threads that carry background reports. */
 	threads: DispatchThreads;
+	/**
+	 * What was said in a server channel since the assistant last posted there, before `message`:
+	 * for a claim that answers it, to append to its turn's text with `withChannelContext`. Call it
+	 * once per answered message, inside the turn's `run`: the messages it returns, and `message`,
+	 * are remembered per channel and not returned again. Undefined in a direct message, on another
+	 * surface, when the host's `discord.channelContext` is `false`, when nothing new was said, and
+	 * when Discord cannot be read (logged). Never rejects. `options` override the host's for this call.
+	 */
+	channelContext(
+		message: InboundMessage,
+		options?: ChannelContextOptions,
+	): Promise<ChannelContext | undefined>;
 }
 
 /** The Discord connection, provided by the Discord plugin. */
@@ -31,16 +51,22 @@ export const DISCORD: ServiceKey<DiscordServices> =
 
 export interface DiscordOptions {
 	token: string;
+	/**
+	 * The primary owner's Discord user id: an owner always, and the one the admin tools act as.
+	 * Every other owner the identity service knows uses the owner's commands and cards too.
+	 */
 	ownerId: string;
-	/** How the owner is named in audit-log reasons and refusals. */
+	/** How the primary owner is named in audit-log reasons and refusals. */
 	ownerName: string;
-	/** Who may answer a card besides the owner. */
-	speakers: SpeakerPolicy;
 	dataDir: string;
 	/** The name of the root slash command, without the slash. */
 	rootCommand: string;
 	/** Text appended as it is to the refusal a non-owner gets, such as a pointer to the commands anyone may use. */
 	refusalHint?: string;
+	/** The host's channel context settings; `false` turns it off. Default: on, with the defaults. */
+	channelContext?: ChannelContextOptions | false;
+	/** The divider posted in a server channel when its conversation starts over; `false` posts none. Default: a short English divider. */
+	freshMarker?: string | false;
 }
 
 /**
@@ -62,10 +88,12 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 			);
 		},
 		setup: async ({ conversations, services, logger }) => {
+			const identity = services.find(IDENTITY);
 			// The surface exists by the time a turn posts a card.
 			const cards: OwnerCards = new OwnerCards({
 				ownerId: options.ownerId,
-				speakers: options.speakers,
+				// Who may answer a card besides the primary owner, by the identity service.
+				...(identity ? { identity } : {}),
 				channel: (channelId) => connected.cardChannel(channelId),
 				logger,
 			});
@@ -73,16 +101,23 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 				token: options.token,
 				ownerId: options.ownerId,
 				ownerName: options.ownerName,
-				prompts: (channel, speaker) => cards.prompts(channel, speaker),
+				prompts: (channel, scope) => cards.prompts(channel, scope),
 				logger,
+				...(options.freshMarker === undefined
+					? {}
+					: { freshMarker: options.freshMarker }),
 			});
 			surface = connected;
-			const guard = new OwnerGuard(
-				options.ownerId,
+			// Every owner may use the owner's commands, by the identity service; the primary owner always.
+			const guard = commandGuard({
+				ownerId: options.ownerId,
+				...(identity ? { identity } : {}),
+				root: options.rootCommand,
 				logger,
-				options.rootCommand,
-				options.refusalHint,
-			);
+				...(options.refusalHint === undefined
+					? {}
+					: { refusalHint: options.refusalHint }),
+			});
 			// A channel whose claim keeps reports in place, such as an open channel, opens no thread.
 			const threads = new DispatchThreads({
 				host: {
@@ -101,15 +136,38 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 			collection.registrar.add({
 				module: stopButtonModule({ guard, conversations }),
 			});
+			// Marks the owners in channel context: the primary owner, and every other owner's Discord identities.
+			const owners = new DiscordOwners({
+				ownerId: options.ownerId,
+				...(identity ? { identity } : {}),
+				logger,
+			});
+			const context = new ChannelContextReader({
+				read: (channelId, before, limit) =>
+					connected.messagesBefore(channelId, before, limit),
+				owners: () => owners.ids(),
+				settings: options.channelContext ?? {},
+				logger,
+			});
 			services.provide(DISCORD, {
 				connection: connected,
 				commands: collection.registrar,
 				guard,
 				threads,
+				channelContext: (message, given) => context.of(message, given),
 			});
 			return {
 				// The host starts the surface first; it registers the composed commands as it connects.
 				surfaces: [connected],
+				// A person's Discord direct messages, through a Discord identity of theirs.
+				directChannels: [
+					discordDirectChannel({
+						directChannel: (userId) => connected.directChannel(userId),
+						sendDirect: (userId, text) => connected.sendDirect(userId, text),
+						...(identity ? { identity } : {}),
+						ownerId: options.ownerId,
+					}),
+				],
 				services: [
 					// The sweep reads threads through the connection, so it follows the surface's start.
 					{ name: "threads", start: () => void threads.sweep() },