pi-roundtable 0.22.4 → 0.23.0

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

@@ -28,16 +28,33 @@ import {
 	RUNTIME,
 	SCHEDULES,
 	SKILLS,
+	THREADS,
 } from "../services.ts";
 import type { SessionTool } from "../sessions.ts";
 import type { Tier } from "../speakers.ts";
 import { DISCORD } from "./discord.ts";
 import { agentOnly } from "./session-tool.ts";
 
+/**
+ * The id of the team on a host without Discord, in place of the Discord guild: the rows the team
+ * keeps are stored under it, as under the guild's id on a host with Discord.
+ */
+export const LOCAL_TEAM_ID = "local";
+
 export interface AgentServerOptions {
-	guildId: string;
-	/** The channel the coordinator lives in. */
-	entryChannelId: string;
+	/**
+	 * The Discord guild the team lives in. Absent on a host without Discord: the team is then
+	 * `LOCAL_TEAM_ID`, it has no channels, and its agents live in the rooms of the surfaces that
+	 * host them.
+	 */
+	guildId?: string;
+	/** The channel the coordinator lives in; set with `guildId`, never with `coordinator`. */
+	entryChannelId?: string;
+	/**
+	 * The coordinator's name on a host without Discord, where no entry channel names it; the first
+	 * seed when absent. Refused with `entryChannelId`.
+	 */
+	coordinator?: string;
 	owner: OwnerIdentity & { id: string };
 	/** The assistant's display name, as the confirmation judge names it. */
 	assistant: string;
@@ -77,10 +94,13 @@ export interface AgentServerOptions {
 	attachmentDownload?: { deadlineMs?: number; idleMs?: number };
 	/** 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. */
-	avatarListener: string;
-	/** The origin the agents' pictures are served from. */
-	avatarUrl: string;
+	/** The listener the avatar pictures are served on; none mounts no route, and a surface serves them through `AGENTS.avatars.serve`. */
+	avatarListener?: string;
+	/**
+	 * The origin the agents' pictures are served from. Without one a picture's URL is
+	 * `/avatars/<hash>.png`, which the surface that serves the pictures resolves against its origin.
+	 */
+	avatarUrl?: string;
 	/** The assistant's neutral avatar: the style reference and the picture of an agent without one. */
 	avatarReference: string;
 	/** The picture used instead when `avatarReference` cannot be read as one; the failure is logged. */
@@ -127,41 +147,62 @@ export interface AgentServerStores {
 /** Attaches the agent server's stores over the host's migrated pool. */
 async function attachStores(
 	sql: SQL,
-	guildId: string,
+	teamId: string,
 ): Promise<AgentServerStores> {
-	return { agents: await PgAgentStore.attach(sql, guildId) };
+	return { agents: await PgAgentStore.attach(sql, teamId) };
 }
 
 /**
  * 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.
+ * it built to the plugins after it. On a host without Discord the team has no channels or
+ * dashboard: its agents live in the rooms of the surfaces that host them, and the host refuses to
+ * start when no surface does.
  */
 export function agentServerPlugin(
 	options: AgentServerOptions,
 	/** Opens the stores; a test hands stand-ins, so the plugin can be set up without a database. */
 	openStores: (
 		context: Pick<PluginContext, "database">,
-		guildId: string,
-	) => Promise<AgentServerStores> = (context, guildId) =>
-		attachStores(context.database(), guildId),
+		teamId: string,
+	) => Promise<AgentServerStores> = (context, teamId) =>
+		attachStores(context.database(), teamId),
 ): RoundtablePlugin {
+	if (options.entryChannelId !== undefined && options.coordinator !== undefined)
+		throw new ConfigError(
+			"the agent server: entryChannelId and coordinator both name the coordinator. Set the entry channel with Discord, the coordinator without it.",
+		);
+	const teamId = options.guildId ?? LOCAL_TEAM_ID;
+	/** Set once the plugin has set up; the preflight reads it after every plugin linked. */
+	let hostsRooms: (() => boolean) | undefined;
 	return {
 		name: AGENT_SERVER_PLUGIN,
 		// 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),
+		migrations: PgAgentStore.migrations(teamId),
 		provides: [AGENTS],
 		requires: [RUNTIME],
+		// A team with no Discord channels is reached through rooms only; without a surface that
+		// hosts them its agents could never be spoken to.
+		preflight: () => {
+			if (hostsRooms && !hostsRooms())
+				throw new ConfigError(
+					"the agents need a surface that hosts their rooms, such as pi-roundtable-web, and none is installed. Without Discord channels there is nowhere to talk to them; add a plugin whose chat surface declares agentRooms: true, or configure discord.",
+				);
+		},
 		setup: async (context) => {
-			const discord = context.services.get(DISCORD);
+			// 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;
+			const connection = discord?.connection;
 			const { logger, providers, surfaces } = context;
+			if (!connection) hostsRooms = () => surfaces.roomSurfaces().length > 0;
 			const studio = new FileAvatarStudio({
 				dir: join(options.dataDir, "avatars"),
-				publicUrl: options.avatarUrl,
+				...(options.avatarUrl ? { publicUrl: options.avatarUrl } : {}),
 				referencePath: options.avatarReference,
 				...(options.avatarNeutral
 					? {
@@ -179,7 +220,7 @@ 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 } = await openStores(context, options.guildId);
+			const { agents: store } = await openStores(context, teamId);
 			const running = context.services.get(RUNTIME);
 			const judge = providers.judge;
 			const confirmations = new ConfirmationJudge({
@@ -189,8 +230,17 @@ export function agentServerPlugin(
 				logger,
 			});
 			const built: DiscordAgentTeam = new DiscordAgentTeam({
-				guildId: options.guildId,
-				entryChannelId: options.entryChannelId,
+				guildId: teamId,
+				...(options.entryChannelId !== undefined
+					? { entryChannelId: options.entryChannelId }
+					: {}),
+				// Without an entry channel the coordinator is the named agent, else the first seed.
+				...(options.entryChannelId === undefined
+					? {
+							coordinator: () =>
+								options.coordinator ?? context.sessions().seeds[0]?.name,
+						}
+					: {}),
 				seeds: () => context.sessions().seeds,
 				promptSections: () => context.sessions().prompt,
 				pluginTools: () => context.sessions().agentTools,
@@ -201,7 +251,9 @@ export function agentServerPlugin(
 				shellUser: options.shellUser,
 				...(options.scratchDir ? { scratchDir: options.scratchDir } : {}),
 				store,
-				channels: connection.agentChannels(options.guildId),
+				...(connection && options.guildId
+					? { channels: connection.agentChannels(options.guildId) }
+					: {}),
 				studio,
 				runtime: () => running,
 				confirmations,
@@ -223,6 +275,7 @@ export function agentServerPlugin(
 				},
 				schedules,
 				queue: context.queue,
+				surfaces,
 				startTyping: (channel) => surfaces.startTyping(channel),
 				showStop: (channel) => surfaces.showStop(channel),
 				workDir: options.workDir,
@@ -231,10 +284,10 @@ export function agentServerPlugin(
 					? { guestPrompt: options.prompts.guest }
 					: {}),
 				...(skills ? { skills } : {}),
-				threads: discord.threads,
+				...(threads ? { threads } : {}),
 				logger,
 			});
-			connection.onChannelDeleted((channelId) => {
+			connection?.onChannelDeleted((channelId) => {
 				if (!built.owns(discordKey(channelId))) return;
 				void context.queue
 					.run(discordKey(channelId), () => built.channelDeleted(channelId))
@@ -263,21 +316,23 @@ export function agentServerPlugin(
 			});
 			const attachmentDir = (channel: ChannelKey) =>
 				ownerAttachmentDir(options.dataDir, channel);
-			const dashboard = new AgentDashboard({
-				status: () => built.status(),
-				board: connection.agentDashboard(options.guildId),
-				lines: () => context.dashboard(),
-				logger,
-			});
-			built.onChange(() => dashboard.changed());
+			// The dashboard is a Discord message; a team without Discord has none.
+			const dashboard =
+				connection && options.guildId
+					? new AgentDashboard({
+							status: () => built.status(),
+							board: connection.agentDashboard(options.guildId),
+							lines: () => context.dashboard(),
+							logger,
+						})
+					: undefined;
+			if (dashboard) built.onChange(() => dashboard.changed());
 			const connectErrorReporter = () =>
 				options.errorReporter?.connect({
-					channelOf: (name) => {
-						const agent = store.agent(name);
-						return agent?.status === "active" && agent.channelId
-							? discordKey(agent.channelId)
-							: undefined;
-					},
+					channelOf: (name) =>
+						store.agent(name)?.status === "active"
+							? built.roomsOf(name)[0]
+							: undefined,
 					post: (channel, text) =>
 						surfaces.sendReply(channel, { chunks: splitReply(text) }),
 					turn: (channel, text) =>
@@ -288,7 +343,9 @@ export function agentServerPlugin(
 				});
 			return {
 				services: [
-					{ name: "dashboard", stop: () => dashboard.stop() },
+					...(dashboard
+						? [{ name: "dashboard", stop: () => dashboard.stop() }]
+						: []),
 					{
 						name: AGENT_TEAM_SERVICE,
 						// The dashboard shows the team, so it starts once the team has; the error
@@ -296,7 +353,7 @@ export function agentServerPlugin(
 						startInBackground: async () => {
 							try {
 								await built.start();
-								dashboard.start();
+								dashboard?.start();
 							} finally {
 								connectErrorReporter();
 							}
@@ -315,10 +372,16 @@ export function agentServerPlugin(
 							? { attachmentDownload: options.attachmentDownload }
 							: {}),
 						logger,
-						channelContext: (message) => discord.channelContext(message),
+						...(discord
+							? { channelContext: (message) => discord.channelContext(message) }
+							: {}),
 					}),
 				],
-				http: [studio.route(options.avatarListener)],
+				// The pictures are public on a listener only where a public address reaches it.
+				http:
+					options.avatarListener && options.avatarUrl
+						? [studio.route(options.avatarListener)]
+						: [],
 				sessionTools: agentSessionTools(built),
 				toolTiers: AGENT_TIERS,
 			};

package/src/core/builtin/discord.ts

@@ -11,7 +11,6 @@ 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 {
 	CommandGuard,
 	CommandRegistrar,
@@ -23,7 +22,8 @@ import { restOf, restPoster } from "../discord/poster/rest-poster.ts";
 import { stopButtonModule } from "../discord/stop-button.ts";
 import type { InboundMessage } from "../domain/conversation.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
-import { IDENTITY } from "../services.ts";
+import { IDENTITY, THREADS } from "../services.ts";
+import type { DispatchThreads } from "../threads/dispatch-threads.ts";
 
 /** The Discord connection and what stands on it, as plugins use it. Provided by the Discord plugin. */
 export interface DiscordServices {
@@ -161,19 +161,8 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 					? {}
 					: { refusalHint: options.refusalHint }),
 			});
-			// A channel whose claim keeps reports in place, such as an open channel, opens no thread.
-			const threads = new DispatchThreads({
-				host: {
-					open: (parentId, name, line) =>
-						connected.threadHost().open(parentId, name, line),
-					post: (threadId, text) => connected.threadHost().post(threadId, text),
-					send: (threadId, text) => connected.threadHost().send(threadId, text),
-					close: (threadId) => connected.threadHost().close(threadId),
-				},
-				ledgerPath: join(options.dataDir, "dispatch-threads.json"),
-				excluded: (channel) => conversations.postsInPlace(channel),
-				logger,
-			});
+			// The host's dispatch threads, which reach Discord's through its surface.
+			const threads = services.get(THREADS);
 			// The cards answer the interactions of held actions, and core posts the stop button, so
 			// core answers both; they come first, as they always have.
 			collection.registrar.add({ module: cards });
@@ -215,8 +204,6 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 					}),
 				],
 				services: [
-					// The sweep reads threads through the connection, so it follows the surface's start.
-					{ name: "threads", start: () => void threads.sweep() },
 					// The copy texts of the last cards are on disk before the host exits.
 					{
 						name: "card-copies",

package/src/core/builtin/modules.ts

@@ -39,6 +39,7 @@ import {
 	IDENTITY,
 	PRECHECKS,
 	SCHEDULES,
+	THREADS,
 } from "../services.ts";
 import type { SessionContext } from "../sessions.ts";
 import { DELEGATE_TOOL } from "../shared/delegate-tool.ts";
@@ -119,11 +120,11 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 			const schedules = services.get(SCHEDULES);
 			// Absent when a plugin list leaves the prechecks plugin out: then none can be attached.
 			const prechecks = services.find(PRECHECKS);
-			// Absent on a host without Discord: then there are no threads.
-			const discord = services.find(DISCORD);
+			// Absent when a plugin list leaves the threads plugin out: then no dispatch opens a thread.
+			const threads = services.find(THREADS);
 			// Another agent's channel, for schedule_list; asked when a tool runs, after the agent server set up.
-			const agentChannelOf = (agent: string) =>
-				services.get(AGENTS).team.channelOf(agent);
+			const agentChannelOf = (agent: string, near: ChannelKey) =>
+				services.get(AGENTS).team.channelOf(agent, near);
 			// 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 (
@@ -166,7 +167,7 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 					}),
 				targets: (name) => conversations.target(name),
 				deliver: (job, outcome) => background.runDelegated(job, outcome),
-				...(discord ? { threads: discord.threads } : {}),
+				...(threads ? { threads } : {}),
 				logger,
 			});
 			services.provide(BACKGROUND_TURNS, background);

package/src/core/builtin/threads.ts

@@ -0,0 +1,37 @@
+import { join } from "node:path";
+import type { RoundtablePlugin } from "../plugin.ts";
+import { THREADS } from "../services.ts";
+import { DispatchThreads } from "../threads/dispatch-threads.ts";
+
+export interface ThreadsOptions {
+	/** Where the ledger of the threads still open is kept, as `dispatch-threads.json`. */
+	dataDir: string;
+}
+
+/**
+ * The dispatch threads of every surface that hosts them. The plugin provides one instance, over
+ * the host's surfaces; the Discord plugin hands the same one out as `DISCORD.threads`. After a
+ * restart it closes the threads the last run left open, once every service has started, so each
+ * surface is up to close its own.
+ */
+export function threadsPlugin(options: ThreadsOptions): RoundtablePlugin {
+	return {
+		name: "threads",
+		provides: [THREADS],
+		setup: ({ conversations, services, surfaces, logger }) => {
+			const threads = new DispatchThreads({
+				surfaces,
+				ledgerPath: join(options.dataDir, "dispatch-threads.json"),
+				// A channel whose claim keeps reports in place, such as an open channel, opens no thread.
+				excluded: (channel) => conversations.postsInPlace(channel),
+				logger,
+			});
+			services.provide(THREADS, threads);
+			return {
+				services: [
+					{ name: "threads", startInBackground: () => threads.sweep() },
+				],
+			};
+		},
+	};
+}

package/src/core/config/agent-team.ts

@@ -0,0 +1,43 @@
+import { ConfigError } from "../domain/errors.ts";
+
+/** The keys of the configuration that shape the agent team. */
+interface AgentTeamKeys {
+	agents?: readonly { name: string; channelId?: string }[];
+	coordinator?: string;
+	skills?: unknown;
+}
+
+/**
+ * Refuses what the agent team needs and a host without Discord lacks, naming the key; and the
+ * coordinator, which only a host without Discord names: with Discord it is the entry channel's agent.
+ */
+export function checkAgentTeamKeys(
+	config: AgentTeamKeys,
+	withDiscord: boolean,
+): void {
+	const seeds = config.agents ?? [];
+	if (config.coordinator !== undefined) {
+		if (withDiscord)
+			throw new ConfigError(
+				"config coordinator: the entry channel's agent is the coordinator with discord. Remove coordinator, or move the agent to discord.entryChannel.",
+			);
+		if (seeds.length === 0)
+			throw new ConfigError(
+				"config coordinator: needs agents, and names one of them. Add the agent to agents, or remove coordinator.",
+			);
+		if (!seeds.some((seed) => seed.name === config.coordinator))
+			throw new ConfigError(
+				`config coordinator: ${JSON.stringify(config.coordinator)} is not one of agents. Name one of ${seeds.map((seed) => seed.name).join(", ")}.`,
+			);
+	}
+	if (withDiscord) return;
+	const placed = seeds.findIndex((seed) => seed.channelId !== undefined);
+	if (placed >= 0)
+		throw new ConfigError(
+			`config agents[${placed}].channelId: a Discord channel, and Discord is not configured. Remove channelId, or configure discord.`,
+		);
+	if (config.skills && seeds.length === 0)
+		throw new ConfigError(
+			"config skills: the skills are the agents', and this host has none: without discord they need agents. Configure agents or discord, or remove skills.",
+		);
+}

package/src/core/config/config.ts

@@ -17,7 +17,6 @@ import {
 import type { PerPrincipalLimits } from "../modules/background/personal-target.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
 import { PRIMARY_CHARS } from "../runtime/interim-text.ts";
-import type { ChannelKey } from "../sessions.ts";
 import type { Tier, TierMembers } from "../speakers.ts";
 import { type AccessConfig, accessOf, accessShape } from "./access.ts";
 import {
@@ -27,9 +26,18 @@ import {
 	type ResolvedDiscord,
 	resolvedDiscord,
 } from "./adapters.ts";
+import { checkAgentTeamKeys } from "./agent-team.ts";
 import { type AttachmentsConfig, attachmentsShape } from "./attachments.ts";
+import {
+	type LimitsConfig,
+	limitsOf,
+	limitsShape,
+	type ResolvedLimits,
+} from "./limits.ts";
+import { opsOf, type ResolvedOps } from "./ops.ts";
 import {
 	bool,
+	characterInput,
 	guarded,
 	integer,
 	list,
@@ -74,7 +82,7 @@ export interface BackgroundConfig {
 }
 
 /** What `roundtable.config.ts` gives `defineRoundtable`. */
-export interface RoundtableConfig {
+export interface RoundtableConfig extends LimitsConfig {
 	/** The assistant's display name; default "Roundtable". */
 	name?: string;
 	/**
@@ -85,9 +93,11 @@ export interface RoundtableConfig {
 	owner?: { id: string; name: string; pronouns?: Pronouns };
 	/**
 	 * The Discord bot, its guild, and the agent server that lives there. Leave it out for a host
-	 * without Discord: no Discord plugins, no agent server or agents, no skills, and no tool that
-	 * messages the owner on Discord; conversations come through the plugins' own surfaces. The same
-	 * settings may come as `adapters: [discord({...})]` instead, never both.
+	 * without Discord: no Discord plugins and no tool that messages the owner on Discord;
+	 * conversations come through the plugins' own surfaces. The agent team (`agents`, `skills`) then
+	 * lives in the rooms of a surface that hosts them, such as pi-roundtable-web, and the host
+	 * refuses to start without one. The same settings may come as `adapters: [discord({...})]`
+	 * instead, never both.
 	 */
 	discord?: DiscordConfig;
 	/**
@@ -133,8 +143,17 @@ export interface RoundtableConfig {
 	toolTiers?: Record<string, Tier>;
 	/** Prompt files, read once at start; `shared` starts every agent's prompt. */
 	prompts?: { shared: string; guest?: string };
-	/** The first team, created once; an agent already stored is never overwritten. Needs `discord`. */
+	/**
+	 * The first team, created once; an agent already stored is never overwritten. Without `discord`
+	 * the team lives in the rooms of a surface that hosts them, so a seed has no `channelId`.
+	 */
 	agents?: AgentSeed[];
+	/**
+	 * Without `discord`, the name of the agent that coordinates the team: the one the owner's
+	 * general requests come to, which cannot be archived. It must be one of `agents`; default the
+	 * first. With `discord` the agent in `discord.entryChannel` is the coordinator, and this key is refused.
+	 */
+	coordinator?: string;
 	/**
 	 * The `public` listener: the public address that reaches it, and the TCP port (default 3000) or
 	 * unix socket the process listens on. `socketMode` is the socket file's permission bits
@@ -149,11 +168,7 @@ export interface RoundtableConfig {
 		socketPath?: string;
 		socketMode?: number;
 	};
-	/**
-	 * A picture of your own for agents without one, and the style reference for drawing them; default
-	 * a plain bot. A PNG, JPEG or GIF of any side within the 64 MP decoded-pixel budget (an ordinary
-	 * camera photo); one that cannot be read as a picture is logged and the plain bot is used.
-	 */
+	/** @deprecated Agents are composed characters since 0.23, so this picture is ignored and a warning is logged at start; removed in 1.0. */
 	avatar?: string;
 	/** The agents' shared working directory; default `<dataDir>/work`. */
 	workDir?: string;
@@ -166,7 +181,7 @@ export interface RoundtableConfig {
 	/**
 	 * Where the skill registry reads built-in skills and keeps linked repositories. `false` leaves
 	 * the `skills` addon out: agents carry no skills, and no skill tools exist. Stored skills stay
-	 * in their tables. Without `discord` there are no agents, so the addon is off.
+	 * in their tables. Without `discord` and `agents` there is no one to carry skills, so the addon is off.
 	 */
 	skills?: false | SkillsConfig;
 	/**
@@ -267,11 +282,13 @@ const schema = shape({
 				name: text,
 				displayName: text,
 				prompt: text,
-				avatarPrompt: text,
+				character: optional(characterInput),
+				avatarPrompt: optional(text),
 				channelId: optional(text),
 			}),
 		),
 	),
+	coordinator: optional(text),
 	http: optional(
 		shape({
 			publicUrl: optional(text),
@@ -288,6 +305,7 @@ const schema = shape({
 	memory: optional(bool),
 	ops: optional(shape({ agent: optional(text), conversation: optional(text) })),
 	drainSeconds: optional(integer(1, 3_600)),
+	...limitsShape,
 	interimText: optional(oneOf<InterimTextMode>("on", "off")),
 	interimPrimaryChars: optional(integer(1, 100_000)),
 	plugins: optional(
@@ -297,8 +315,12 @@ const schema = shape({
 	),
 });
 
+/** Logged once when `avatar` is set: agents are composed characters and no picture is drawn from it. */
+export const AVATAR_DEPRECATION =
+	"agents are composed characters since 0.23; `avatar` is ignored";
+
 /** The configuration with every default filled in. */
-export interface ResolvedConfig {
+export interface ResolvedConfig extends ResolvedLimits {
 	name: string;
 	/**
 	 * The process's short name: the logger's and the scratch dir's, and the root slash command's
@@ -337,6 +359,8 @@ export interface ResolvedConfig {
 	toolTiers: Record<string, Tier>;
 	prompts: { shared?: string; guest?: string };
 	agents: AgentSeed[];
+	/** The coordinator's name; set only without `discord` and with `agents`: the configured one, else the first seed. */
+	coordinator?: string;
 	/** Undefined when no `http` is configured, and the host opens no `public` listener. */
 	http?: {
 		/** Always set with Discord. */
@@ -352,7 +376,7 @@ export interface ResolvedConfig {
 	/** `false` when the skills addon is off. */
 	skills: false | SkillsConfig;
 	memory: boolean;
-	ops?: { agent: string } | { conversation: ChannelKey };
+	ops?: ResolvedOps;
 	drainMs: number;
 	interimText: InterimTextMode;
 	interimPrimaryChars: number;
@@ -368,47 +392,6 @@ function modelOf(value: string, path: string): ModelRef {
 	return parsed;
 }
 
-/** Where the errors go: one of an agent or a conversation; an agent only where the agents live. */
-function opsOf(
-	ops: { agent?: string; conversation?: string } | undefined,
-	withDiscord: boolean,
-): ResolvedConfig["ops"] {
-	if (!ops) return undefined;
-	const { agent, conversation } = ops;
-	if (agent !== undefined && conversation !== undefined)
-		throw new ConfigError(
-			"config ops: name an agent or a conversation, not both. Keep the one the reports go to.",
-		);
-	if (agent !== undefined) {
-		if (!withDiscord)
-			throw new ConfigError(
-				'config ops.agent: the agents live in Discord, which is not configured. Report to a conversation a plugin\'s chat surface serves instead, with ops: { conversation: "<surface>:<id>" }; the web chat takes no error reports.',
-			);
-		return { agent };
-	}
-	if (conversation === undefined)
-		throw new ConfigError(
-			'config ops: name an agent or a conversation, such as ops: { agent: "infra" } or ops: { conversation: "<surface>:<id>" }.',
-		);
-	if (!/^[^:]+:.+$/.test(conversation))
-		throw new ConfigError(
-			`config ops.conversation: expected a conversation key <surface>:<id>, got ${JSON.stringify(conversation)}. Write the surface's prefix, a colon, and the conversation's id.`,
-		);
-	return { conversation: conversation as ChannelKey };
-}
-
-/** Refuses what only the agent server serves on a host without Discord, naming the key. */
-function refuseAgentServerKeys(config: RoundtableConfig): void {
-	if (config.agents && config.agents.length > 0)
-		throw new ConfigError(
-			"config agents: the agents live in Discord, which is not configured. Configure discord, or remove agents.",
-		);
-	if (config.skills)
-		throw new ConfigError(
-			"config skills: the skills are the agents', and the agents live in Discord, which is not configured. Configure discord, or remove skills.",
-		);
-}
-
 /** The configuration checked against its schema, defaults filled; throws a ConfigError naming the key and the fix. */
 export function resolveConfig(input: unknown): ResolvedConfig {
 	const config = schema.check(liftAdapters(input), "") as RoundtableConfig;
@@ -420,7 +403,7 @@ export function resolveConfig(input: unknown): ResolvedConfig {
 		throw new ConfigError(
 			"config http.publicUrl: required with discord, expected the public address that reaches the bot; Discord fetches the agents' avatars from it. Add it to roundtable.config.ts.",
 		);
-	if (!discord) refuseAgentServerKeys(config);
+	checkAgentTeamKeys(config, discord !== undefined);
 	const slug =
 		discord?.rootCommand ?? name.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
 	const ops = opsOf(config.ops, discord !== undefined);
@@ -430,6 +413,10 @@ export function resolveConfig(input: unknown): ResolvedConfig {
 		name,
 		slug,
 		...access,
+		deprecations: [
+			...access.deprecations,
+			...(config.avatar ? [AVATAR_DEPRECATION] : []),
+		],
 		owner: {
 			id: primaryOwner.id,
 			name: primaryOwner.name,
@@ -467,6 +454,9 @@ export function resolveConfig(input: unknown): ResolvedConfig {
 		toolTiers: config.toolTiers ?? {},
 		prompts: config.prompts ?? {},
 		agents: config.agents ?? [],
+		...(!discord && config.agents?.[0]
+			? { coordinator: config.coordinator ?? config.agents[0].name }
+			: {}),
 		...(http
 			? {
 					http: {
@@ -483,11 +473,12 @@ export function resolveConfig(input: unknown): ResolvedConfig {
 		...(config.avatar ? { avatar: config.avatar } : {}),
 		workDir: config.workDir ?? `${config.dataDir}/work`,
 		scratchDir: config.scratchDir ?? join(tmpdir(), `${slug}-scratch`),
-		// Without Discord there are no agents to carry skills, so the addon is off.
-		skills: config.skills ?? (discord ? {} : false),
+		// Without Discord and without agents there is no one to carry skills, so the addon is off.
+		skills: config.skills ?? (discord || config.agents?.length ? {} : false),
 		memory: config.memory ?? true,
 		...(ops ? { ops } : {}),
 		drainMs: (config.drainSeconds ?? DRAIN_LIMIT_MS / 1_000) * 1_000,
+		...limitsOf(config),
 		interimText: config.interimText ?? "on",
 		interimPrimaryChars: config.interimPrimaryChars ?? PRIMARY_CHARS,
 		plugins: config.plugins ?? [],