pi-roundtable 0.26.3 → 0.27.1

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

@@ -5,7 +5,7 @@ import type { ThinkingSetting } from "../models.ts";
 import type { AgentDirectory } from "../services.ts";
 import { zonedStamp } from "../time.ts";
 import type { ChannelMessage } from "./agent-ports.ts";
-import { characterOf } from "./agent-rules.ts";
+import { characterOf, isHelper } from "./agent-rules.ts";
 import { describeThinking } from "./agent-settings.ts";
 import type { Agent } from "./agent-store.ts";
 
@@ -34,10 +34,21 @@ export function channelIdFromRef(channel: string): string {
 
 /** Every agent and group as agent_list shows them, before the category layout. */
 export function teamListText(store: Pick<AgentDirectory, "agents" | "groups">) {
-	const agents = store.agents().map((a) => {
+	const all = store.agents();
+	const line = (a: Agent, indent: string) => {
 		const channel = a.channelId ? `<#${a.channelId}>` : "no channel";
-		return `- ${a.name} "${a.displayName}" — ${channel}, ${a.status}`;
-	});
+		const temp = isHelper(a)
+			? ` (temp, of ${a.parent}, ${a.finishedAt ? "finished" : "working"})`
+			: "";
+		return `${indent}- ${a.name}${temp} "${a.displayName}" — ${channel}, ${a.status}`;
+	};
+	// A temp knight is listed under its parent.
+	const agents = all
+		.filter((a) => !isHelper(a))
+		.flatMap((a) => [
+			line(a, ""),
+			...all.filter((h) => h.parent === a.name).map((h) => line(h, "  ")),
+		]);
 	const groups = store
 		.groups()
 		.map(
@@ -63,6 +74,11 @@ export function agentDetails(
 		`Name: ${agent.name}`,
 		`Display name: ${agent.displayName}`,
 		`Status: ${agent.status}`,
+		...(isHelper(agent)
+			? [
+					`Temp knight of: ${agent.parent} (${agent.finishedAt ? "finished" : "working"})`,
+				]
+			: []),
 		`Channel: ${agent.channelId ? `<#${agent.channelId}>` : "none"}`,
 		...(conversations.length === 0
 			? []

package/src/core/agents/team-turn-types.ts

@@ -22,6 +22,8 @@ import type { ToolTiers } from "../tool-tiers.ts";
 import type { AgentChannels, AgentTurnRunner } from "./agent-ports.ts";
 import type { Agent, PgAgentStore } from "./agent-store.ts";
 import type { RelevanceScorer } from "./group-round.ts";
+import type { HelperWork } from "./helper-work.ts";
+import type { Routes } from "./routes.ts";
 
 /** Agent messages without an owner message in between (spec behavior 13). */
 export const MAX_CHAIN_MESSAGES = 8;
@@ -62,9 +64,14 @@ export interface TeamTurnsOptions {
 	 */
 	surfaces?: Pick<
 		SurfacePort,
-		"sendReply" | "interim" | "roomSurfaces" | "of" | "progress"
+		"sendReply" | "interim" | "roomSurfaces" | "of" | "progress" | "groupRound"
 	>;
 	studio: Pick<AvatarStudio, "url">;
+	/**
+	 * The host's routing table, which says where work no person started lands. Without one the team
+	 * builds the defaults, every place being what the host chose before `routing` existed.
+	 */
+	routes?: Routes;
 	/** Set once the runtime exists, which itself needs the team's tools. */
 	runtime: () => AgentTurnRunner;
 	/** The tools every agent turn runs with. */
@@ -150,4 +157,8 @@ export interface TurnHost {
 	/** Whether the speaker's tier holds every tool of the held actions. */
 	mayApprove(speaker: Speaker, pending: PendingConfirmation): boolean;
 	turnChannel(scope: AgentTurnScope): ChannelKey;
+	/** The routing table. */
+	readonly routes: Routes;
+	/** What keeps a temp knight working; a turn or a message to one brackets itself with it. */
+	readonly helpers: Pick<HelperWork, "begin" | "end">;
 }

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

@@ -15,12 +15,14 @@ import { isQuiet, replyBody } from "../presentation/reply-body.ts";
 import { splitReply } from "../presentation/reply-splitter.ts";
 import { withReplyFiles } from "../reply-files.ts";
 import { endOf, settleTurn } from "../routing/settle-turn.ts";
-import { mayApproveNamed } from "../runtime/extensions/held-calls.ts";
-import { type Speaker, tierAtLeast } from "../speakers.ts";
+import type { Speaker } from "../speakers.ts";
 import { toolTiers } from "../tool-tiers.ts";
 import { AgentMessages } from "./agent-messages.ts";
 import type { Agent } from "./agent-store.ts";
 import { GroupTurns } from "./group-turns.ts";
+import { HelperWork } from "./helper-work.ts";
+import { type Routes, routesOf } from "./routes.ts";
+import { mayApprove } from "./team-approval.ts";
 import {
 	agentOfChannel,
 	channelIdOf,
@@ -28,8 +30,6 @@ import {
 	coordinatorOf,
 	discordIdOf,
 	discordKey,
-	keysOf,
-	roomScope,
 	scopeOf,
 } from "./team-keys.ts";
 import {
@@ -49,6 +49,9 @@ export { MAX_CHAIN_MESSAGES, type TeamTurnsOptions };
  */
 export class TeamTurns {
 	readonly #options: TeamTurnsOptions;
+	readonly routes: Routes;
+	/** What keeps each temp knight working, and so when it is finished. */
+	readonly helpers: HelperWork;
 	/** The chain of each running turn, by session key, read by message_agent. */
 	readonly #chains = new Map<ChannelKey, Chain>();
 	/** The channel each working agent's turn posts in. */
@@ -63,8 +66,19 @@ export class TeamTurns {
 
 	constructor(options: TeamTurnsOptions) {
 		this.#options = options;
+		this.routes = routesOf(options);
+		this.helpers = new HelperWork({
+			store: options.store,
+			queue: options.queue,
+			runtime: options.runtime,
+			roomSurfaces: () => options.surfaces?.roomSurfaces() ?? [],
+			changed: () => options.changed(),
+			logger: options.logger,
+		});
 		const host: TurnHost = {
 			options,
+			routes: this.routes,
+			helpers: this.helpers,
 			chains: this.#chains,
 			turn: (agent, scope, postTo, text, chain, extra) =>
 				this.#turn(agent, scope, postTo, text, chain, extra),
@@ -151,29 +165,8 @@ export class TeamTurns {
 		);
 	}
 
-	/**
-	 * Whether the speaker may approve the held actions by a message, call by call: an owner, as the
-	 * agents' channels are shared, or, for a call whose tool named its approvers, one of those
-	 * principals, or, for any other call, the principal whose turn held them (by their id, for
-	 * actions held before 0.9). Their tier must now hold every call. Nobody else in the channel
-	 * may, so a call that named approvers is not its speaker's to approve unless named. The gate
-	 * checks the named approvers again when the turn begins, whoever asked for the release.
-	 */
 	#mayApprove(speaker: Speaker, pending: PendingConfirmation): boolean {
-		const theirs =
-			pending.principalId !== undefined
-				? speaker.principalId === pending.principalId
-				: speaker.id === pending.speakerId;
-		const tiers = this.#options.toolTiers ?? toolTiers();
-		// Nothing held names an approver to go by: only the owners and the speaker whose turn held it.
-		if (pending.calls.length === 0) return speaker.tier === "owner" || theirs;
-		return pending.calls.every(
-			(call) =>
-				(speaker.tier === "owner" ||
-					(call.approverIds ? mayApproveNamed(speaker, call) : theirs)) &&
-				tiers.allows(speaker.tier, call.tool) &&
-				(!call.minTier || tierAtLeast(speaker.tier, call.minTier)),
-		);
+		return mayApprove(this.#options.toolTiers ?? toolTiers(), speaker, pending);
 	}
 
 	/** The surfaces that host rooms; none for a team without a surface port. */
@@ -207,6 +200,8 @@ export class TeamTurns {
 	): Promise<TurnResult> {
 		const { logger, startTyping, showStop } = this.#options;
 		const stopTyping = startTyping(postTo);
+		// A temp knight is working for as long as a turn of it runs.
+		this.helpers.begin(agent.name);
 		// A group round has several sessions; only an agent's own channel maps to one.
 		const hideStop = scope.group ? undefined : showStop(postTo);
 		this.#chains.set(scope.session, chain);
@@ -250,6 +245,7 @@ export class TeamTurns {
 			this.#posting.delete(scope.session);
 			this.#working.delete(agent.name);
 			this.#active(agent.name, scope.group);
+			this.helpers.end(agent.name);
 		}
 		this.#options.events?.turnEnded({
 			...turn,
@@ -450,11 +446,7 @@ export class TeamTurns {
 		const home =
 			entryChannelId !== undefined
 				? discordKey(entryChannelId)
-				: keysOf(
-						store,
-						coordinator.name,
-						this.#options.surfaces?.roomSurfaces() ?? [],
-					)[0];
+				: this.routes.primary(coordinator.name);
 		if (!home)
 			throw new AgentError(`${coordinator.name} has no room to post in`);
 		await this.#post(home, coordinator, { chunks: splitReply(text) });
@@ -478,6 +470,8 @@ export class TeamTurns {
 	 * One owner message in a group channel: scored, then answered by the chosen members one at
 	 * a time, each seeing every group message since its last turn. Call inside the queue.
 	 */
+	/** Ends the group channel's running round on Stop: the sessions to stop, or undefined when none runs. */
+	readonly stopRound = (channel: ChannelKey) => this.#groups.stopRound(channel);
 	answerGroup(
 		channel: ChannelKey,
 		speaker: Speaker,

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

@@ -9,8 +9,11 @@ import { DiscordAgentTeam } from "../agents/agent-team.ts";
 import { AGENT_TOOLS } from "../agents/agent-tools.ts";
 import { FileAvatarStudio } from "../agents/avatar-studio.ts";
 import { RelevanceScorer } from "../agents/group-round.ts";
-import { discordKey } from "../agents/team-keys.ts";
+import { Routes } from "../agents/routes.ts";
+import { agentOfChannel, discordKey } from "../agents/team-keys.ts";
 import { ownerAttachmentDir } from "../attachments/attachment-dir.ts";
+import type { ResolvedHelpers } from "../config/helpers.ts";
+import type { ResolvedRouting } from "../config/routing.ts";
 import type { AgentSessions } from "../contract/runtime.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
 import { ConfigError } from "../domain/errors.ts";
@@ -116,6 +119,10 @@ export interface AgentServerOptions {
 	avatarNeutral?: string;
 	/** Reports the process's own errors to an agent; without one nothing is reported. */
 	errorReporter?: ErrorReporter;
+	/** The checked `routing` block: where work no person started lands. Without it every place is what it was before `routing`. */
+	routing?: ResolvedRouting;
+	/** The temp knights' limits; `false` leaves `helper_create` and `helper_end` out. Without it the defaults apply. */
+	helpers?: ResolvedHelpers | false;
 }
 
 /** The name of the agent server's plugin, as `serviceStarted` events name it. */
@@ -147,6 +154,9 @@ const AGENT_TIERS: Readonly<Record<string, Tier>> = {
 	agent_get: "member",
 	message_agent: "member",
 	channel_read: "member",
+	// A knight may make temp knights for whoever is talking to it; the limits hold the cost.
+	helper_create: "member",
+	helper_end: "member",
 };
 
 /** The tables the agent server keeps: its agents and groups. */
@@ -186,6 +196,7 @@ export function agentServerPlugin(
 	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;
+	let linkRoutes: (() => void) | undefined;
 	return {
 		name: AGENT_SERVER_PLUGIN,
 		// The agent server's own tables; the host runs them before any setup, in this order. The
@@ -200,6 +211,8 @@ export function agentServerPlugin(
 				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.",
 				);
+			// The surfaces the rules name exist only once every plugin has registered its own.
+			linkRoutes?.();
 		},
 		setup: async (context) => {
 			// Absent on a host without Discord: then the team has no channels or dashboard.
@@ -261,7 +274,21 @@ export function agentServerPlugin(
 					: undefined;
 			const sharedPrompt = shared ? () => shared.text() : undefined;
 			const guestPrompt = guest ? () => guest.text() : undefined;
+			const routes = new Routes({
+				routing: options.routing,
+				store,
+				roomSurfaces: () => surfaces.roomSurfaces(),
+				latest: (agent) => store.conversations.latest(agent),
+				logger,
+			});
+			// The surfaces the rules name are registered by the time every plugin has set up.
+			linkRoutes = () =>
+				routes.validate({
+					names: surfaces.names?.() ?? [],
+					discordChannels: connection !== undefined,
+				});
 			const built: DiscordAgentTeam = new DiscordAgentTeam({
+				routes,
 				guildId: teamId,
 				...(options.entryChannelId !== undefined
 					? { entryChannelId: options.entryChannelId }
@@ -319,6 +346,7 @@ export function agentServerPlugin(
 					: {}),
 				...(skills ? { skills } : {}),
 				modes: () => context.services.find(MODES),
+				...(options.helpers !== undefined ? { helpers: options.helpers } : {}),
 				principals: () => context.services.find(IDENTITY),
 				...(threads ? { threads } : {}),
 				logger,
@@ -349,6 +377,7 @@ export function agentServerPlugin(
 				runtime: running,
 				approvals: confirmations,
 				avatars: studio,
+				routes,
 				workspace: {
 					workDir: options.workDir,
 					...(agentSessions.scratchDir
@@ -373,7 +402,7 @@ export function agentServerPlugin(
 				options.errorReporter?.connect({
 					channelOf: (name) =>
 						store.agent(name)?.status === "active"
-							? built.roomsOf(name)[0]
+							? routes.primary(name)
 							: undefined,
 					post: (channel, text) =>
 						surfaces.sendReply(channel, { chunks: splitReply(text) }),
@@ -411,6 +440,12 @@ export function agentServerPlugin(
 						team: built,
 						runtime: running,
 						surface: context.surfaces,
+						integrationChannel: (origin) => {
+							const agent = agentOfChannel(store, surfaces, origin);
+							return agent
+								? routes.of(agent.name, "integration", origin)
+								: origin;
+						},
 						attachmentDir,
 						...(options.attachmentDownload
 							? { attachmentDownload: options.attachmentDownload }

package/src/core/builtin/modules.ts

@@ -233,20 +233,20 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 				reportsReach = () => {
 					if (!surfaces.of(channel))
 						throw new ConfigError(
-							`config ops.conversation: no chat surface serves ${JSON.stringify(channel)}, so its error reports could never be posted. Name a conversation of a surface a plugin brings, or leave ops out.`,
+							`config ${reporter.configKey}: no chat surface serves ${JSON.stringify(channel)}, so its error reports could never be posted. Name a conversation of a surface a plugin brings, or leave ops out.`,
 						);
 					if (!conversations.owns(channel))
 						throw new ConfigError(
-							`config ops.conversation: no plugin's conversations own ${JSON.stringify(channel)}, so nothing answers its error reports. Name a conversation a plugin's claim owns, or leave ops out.`,
+							`config ${reporter.configKey}: no plugin's conversations own ${JSON.stringify(channel)}, so nothing answers its error reports. Name a conversation a plugin's claim owns, or leave ops out.`,
 						);
 					if (!conversations.takesBackground(channel))
 						throw new ConfigError(
-							`config ops.conversation: the claim that owns ${JSON.stringify(channel)} takes no background turns, so nothing answers its error reports. Name a conversation whose claim takes background turns, or leave ops out.`,
+							`config ${reporter.configKey}: the claim that owns ${JSON.stringify(channel)} takes no background turns, so nothing answers its error reports. Name a conversation whose claim takes background turns, or leave ops out.`,
 						);
 					// A report turn is the system principal's, which a conversation private to its person refuses.
 					if (!conversations.takesSystemReports(channel))
 						throw new ConfigError(
-							`config ops.conversation: the claim that owns ${JSON.stringify(channel)} keeps its conversations private to their people, so it takes no system error reports and each would only be logged. Name a conversation of a surface whose conversations are shared, such as a Discord channel, or report to an agent with ops.agent.`,
+							`config ${reporter.configKey}: the claim that owns ${JSON.stringify(channel)} keeps its conversations private to their people, so it takes no system error reports and each would only be logged. Name a conversation of a surface whose conversations are shared, such as a Discord channel, or report to an agent with ops.agent.`,
 						);
 				};
 			}

package/src/core/config/adapters.ts

@@ -1,5 +1,6 @@
 import type { ChannelContextOptions } from "../contract/channel-context.ts";
 import { ConfigError } from "../domain/errors.ts";
+import { type PeerBotsConfig, peerBotsShape } from "../routing/peer-bots.ts";
 import {
 	bool,
 	guarded,
@@ -51,6 +52,14 @@ export interface DiscordConfig {
 	 * for the agent server and every plugin's claim.
 	 */
 	channelContext?: ChannelContextOptions | false;
+	/**
+	 * The other bots whose mentions and replies the host answers like a guest's, so separate bots
+	 * can talk to each other. Explicit Discord user ids only, each for every server or limited to
+	 * some; there is no wildcard and no "all bots", and left out, no bot is answered. A peer is
+	 * served only as far as `access` serves its identity (`discord:<id>`), and a channel answers at
+	 * most `maxRounds` (default 3) of their messages in a row until a person posts.
+	 */
+	peerBots?: PeerBotsConfig;
 	/**
 	 * The divider the assistant posts in a server channel or thread when its conversation starts
 	 * over (a new conversation by an owner's command), which ends the window channel context reads;
@@ -101,6 +110,7 @@ export interface ResolvedDiscord {
 	agentSpeakers?: "everyone" | "owners";
 	/** As configured: `{}` when left out, so the defaults apply, or `false`. */
 	channelContext: NonNullable<DiscordConfig["channelContext"]>;
+	peerBots?: PeerBotsConfig;
 	freshMarker?: string | false;
 	formatting?: string | false;
 	cardGraceSeconds: number;
@@ -133,6 +143,7 @@ export function resolvedDiscord(
 			? {}
 			: { agentSpeakers: discord.agentSpeakers }),
 		channelContext: discord.channelContext ?? {},
+		...(discord.peerBots === undefined ? {} : { peerBots: discord.peerBots }),
 		...(discord.freshMarker === undefined
 			? {}
 			: { freshMarker: discord.freshMarker }),
@@ -180,6 +191,7 @@ export const discordShape = shape({
 	agentMemory: optional(oneOf<"everyone" | "owners">("everyone", "owners")),
 	agentSpeakers: optional(oneOf<"everyone" | "owners">("everyone", "owners")),
 	channelContext: optional(orOff(channelContextShape)),
+	peerBots: optional(peerBotsShape),
 	freshMarker: optional(orOff(text)),
 	formatting: optional(orOff(text)),
 	cardGraceSeconds: optional(integer(1, 86_400)),

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

@@ -46,6 +46,7 @@ export function checkAgentTeamKeys(
 interface AgentOnlyKeys {
 	agents?: readonly unknown[];
 	skills?: unknown;
+	helpers?: unknown;
 	ops?: { agent?: string; conversation?: string };
 	discord?: {
 		agentMemory?: unknown;
@@ -63,6 +64,7 @@ export function checkAgentServerOff(config: AgentOnlyKeys): void {
 	const used: [string, boolean][] = [
 		["agents", (config.agents?.length ?? 0) > 0],
 		["skills", config.skills !== undefined && config.skills !== false],
+		["helpers", config.helpers !== undefined && config.helpers !== false],
 		["ops.agent", config.ops?.agent !== undefined],
 		["discord.agentMemory", config.discord?.agentMemory !== undefined],
 		["discord.agentSpeakers", config.discord?.agentSpeakers !== undefined],

package/src/core/config/config-schema.ts

@@ -8,8 +8,10 @@ import { discordShape } from "./adapters.ts";
 import { attachmentsShape } from "./attachments.ts";
 import type { Pronouns } from "./config.ts";
 import { conversationsShape } from "./conversations.ts";
+import { helpersField } from "./helpers.ts";
 import { limitsShape } from "./limits.ts";
 import { profilesShape } from "./profiles.ts";
+import { routingShape } from "./routing.ts";
 import {
 	bool,
 	characterInput,
@@ -142,6 +144,8 @@ export const configSchema = shape({
 	skills: optional(skillsField),
 	memory: optional(bool),
 	ops: optional(shape({ agent: optional(text), conversation: optional(text) })),
+	routing: routingShape,
+	helpers: optional(helpersField),
 	drainSeconds: optional(integer(1, 3_600)),
 	...limitsShape,
 	interimText: optional(oneOf<InterimTextMode>("on", "off")),

package/src/core/config/config.ts

@@ -30,9 +30,19 @@ import { checkAgentServerOff, checkAgentTeamKeys } from "./agent-team.ts";
 import type { AttachmentsConfig } from "./attachments.ts";
 import { configSchema } from "./config-schema.ts";
 import type { ConversationsConfig } from "./conversations.ts";
+import {
+	type HelpersConfig,
+	helpersOf,
+	type ResolvedHelpers,
+} from "./helpers.ts";
 import { type LimitsConfig, limitsOf, type ResolvedLimits } from "./limits.ts";
-import { opsOf, type ResolvedOps } from "./ops.ts";
+import { opsOf, opsOfPlace, type ResolvedOps } from "./ops.ts";
 import { type ProfilesConfig, profileRulesOf } from "./profiles.ts";
+import {
+	type ResolvedRouting,
+	type RoutingConfig,
+	routingOf,
+} from "./routing.ts";
 import type { SkillsConfig } from "./skills-config.ts";
 
 export type { DiscordConfig };
@@ -217,8 +227,22 @@ export interface RoundtableConfig extends LimitsConfig {
 	 * `discord`), or to a conversation, by its key `<surface>:<id>`, as a visible message and a
 	 * report turn its claim answers. The host does not start when no chat surface serves the
 	 * conversation or no plugin's claim owns it; the web chat takes no error reports.
+	 * @deprecated An alias of `routing.places.ops` since 0.27, which also accepts an agent whose
+	 * primary place is not Discord; removed in 1.0. Setting both stops the start.
 	 */
 	ops?: { agent: string } | { conversation: string };
+	/**
+	 * Where events no person waits on land: the agents' primary places, where a webhook's report,
+	 * a `message_agent` call and an opening task go, and the named places such as `ops`. Left out,
+	 * every one lands where it did before the key existed.
+	 */
+	routing?: RoutingConfig;
+	/**
+	 * Temp knights: helper knights an agent makes for a task with `helper_create` and clears with
+	 * `helper_end`. Left out, the defaults apply (4 per knight, 12 on the host, finished ones
+	 * archived after 24 hours); `false` leaves the tools out.
+	 */
+	helpers?: false | HelpersConfig;
 	/**
 	 * Seconds a shutdown waits for running turns before stopping them; default 180. Give the
 	 * service manager a stop timeout a minute longer, such as systemd's `TimeoutStopSec`.
@@ -235,6 +259,10 @@ export interface RoundtableConfig extends LimitsConfig {
 	plugins?: RoundtablePlugin[];
 }
 
+/** Logged once when the top-level `ops` is set: it is an alias of the `ops` place. */
+export const OPS_DEPRECATION =
+	"`ops` is an alias of `routing.places.ops` since 0.27 and goes away in 1.0; move it there";
+
 /** 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";
@@ -310,6 +338,12 @@ export interface ResolvedConfig extends ResolvedLimits {
 	skills: false | SkillsConfig;
 	memory: boolean;
 	ops?: ResolvedOps;
+	/** The config key `ops` came from, as error messages name it. */
+	opsKey: "ops" | "routing.places.ops";
+	/** The checked `routing` block; undefined when the configuration has none. */
+	routing?: ResolvedRouting;
+	/** The temp knights' limits, or `false` when the tools are left out. */
+	helpers: ResolvedHelpers | false;
 	drainMs: number;
 	interimText: InterimTextMode;
 	interimPrimaryChars: number;
@@ -353,7 +387,15 @@ export function resolveConfig(input: unknown): ResolvedConfig {
 	checkAgentTeamKeys(config, discord !== undefined);
 	const slug =
 		discord?.rootCommand ?? name.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
-	const ops = opsOf(config.ops, discord !== undefined);
+	const routing = routingOf(config.routing, {
+		withDiscord: discord !== undefined,
+		agentServer:
+			agentServer &&
+			(discord !== undefined || (config.agents?.length ?? 0) > 0),
+		topLevelOps: config.ops !== undefined,
+	});
+	const ops =
+		opsOf(config.ops, discord !== undefined) ?? opsOfPlace(routing?.places.ops);
 	const access = accessOf(config, discord !== undefined);
 	const { primaryOwner } = access;
 	return {
@@ -364,6 +406,7 @@ export function resolveConfig(input: unknown): ResolvedConfig {
 		deprecations: [
 			...access.deprecations,
 			...(config.avatar ? [AVATAR_DEPRECATION] : []),
+			...(config.ops ? [OPS_DEPRECATION] : []),
 		],
 		owner: {
 			id: primaryOwner.id,
@@ -444,6 +487,9 @@ export function resolveConfig(input: unknown): ResolvedConfig {
 			: false,
 		memory: config.memory ?? true,
 		...(ops ? { ops } : {}),
+		opsKey: config.ops ? "ops" : "routing.places.ops",
+		...(routing ? { routing } : {}),
+		helpers: agentServer ? helpersOf(config.helpers) : false,
 		drainMs: (config.drainSeconds ?? DRAIN_LIMIT_MS / 1_000) * 1_000,
 		...limitsOf(config),
 		interimText: config.interimText ?? "on",

package/src/core/config/helpers.ts

@@ -0,0 +1,60 @@
+import { ConfigError } from "../domain/errors.ts";
+import { type Field, integer, optional, orOff, shape } from "./schema.ts";
+
+/**
+ * Temp knights: helper knights an agent makes for a task and clears when they are done. Left out,
+ * the defaults below apply; `false` stops the tools `helper_create` and `helper_end` being offered.
+ */
+export interface HelpersConfig {
+	/** The most active temp knights one knight has at once, 1 to 8; default 4. */
+	perParent?: number;
+	/** The most active temp knights on the whole host, 1 to 50; default 12. */
+	perHost?: number;
+	/**
+	 * Hours a finished temp knight stays before the host archives it, 1 to 720; `false` never does.
+	 * Default 24. An archived one can be restored from the archive page.
+	 */
+	archiveFinishedAfterHours?: number | false;
+}
+
+/** What the team reads: every limit filled in. */
+export interface ResolvedHelpers {
+	perParent: number;
+	perHost: number;
+	archiveFinishedAfterHours: number | false;
+}
+
+const DEFAULT_HELPERS: ResolvedHelpers = Object.freeze({
+	perParent: 4,
+	perHost: 12,
+	archiveFinishedAfterHours: 24,
+});
+
+const afterHours: Field<number | false> = orOff(integer(1, 720));
+
+export const helpersField = orOff(
+	shape({
+		perParent: optional(integer(1, 8)),
+		perHost: optional(integer(1, 50)),
+		archiveFinishedAfterHours: optional(afterHours),
+	}),
+);
+
+/** The checked `helpers` block with the defaults filled in; `false` when it is switched off. */
+export function helpersOf(
+	config: HelpersConfig | false | undefined,
+): ResolvedHelpers | false {
+	if (config === false) return false;
+	const resolved: ResolvedHelpers = {
+		perParent: config?.perParent ?? DEFAULT_HELPERS.perParent,
+		perHost: config?.perHost ?? DEFAULT_HELPERS.perHost,
+		archiveFinishedAfterHours:
+			config?.archiveFinishedAfterHours ??
+			DEFAULT_HELPERS.archiveFinishedAfterHours,
+	};
+	if (resolved.perParent > resolved.perHost)
+		throw new ConfigError(
+			`config helpers.perParent: ${resolved.perParent} is more than helpers.perHost (${resolved.perHost}), which counts all of them. Lower perParent or raise perHost.`,
+		);
+	return resolved;
+}

package/src/core/config/ops.ts

@@ -32,3 +32,11 @@ export function opsOf(
 		);
 	return { conversation: conversation as ChannelKey };
 }
+
+/** The error reports' destination that `routing.places.ops` names: a conversation, or an agent's primary place. */
+export function opsOfPlace(
+	place: ChannelKey | { agent: string } | undefined,
+): ResolvedOps | undefined {
+	if (place === undefined) return undefined;
+	return typeof place === "string" ? { conversation: place } : place;
+}