pi-roundtable 0.26.3 → 0.27.1

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

@@ -3,18 +3,14 @@ import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { SQL } from "bun";
-import type { ContextUse } from "../contract/runtime.ts";
 import type { ChatSurface } from "../contract/surface.ts";
 import { NO_ATTACHMENTS } from "../domain/attachment.ts";
 import type {
 	ChannelKey,
 	OutboundReply,
-	PendingConfirmation,
 	PostAuthor,
-	TurnResult,
 } from "../domain/conversation.ts";
-import { AgentRunError } from "../domain/errors.ts";
-import type { TurnRequest } from "../domain/ports.ts";
+import type { RoundProgress } from "../domain/round.ts";
 import type { IdentityService } from "../identity/identity-port.ts";
 import { silentLogger } from "../log.ts";
 import { StoredSkillRegistry as SkillRegistry } from "../modules/skills/skill-registry.ts";
@@ -34,7 +30,6 @@ import type {
 	AgentCategory,
 	AgentChannels,
 	AgentPost,
-	AgentTurnRunner,
 	CategoryLayout,
 	ChannelMessage,
 } from "./agent-ports.ts";
@@ -89,6 +84,24 @@ export class FakeChannels implements AgentChannels {
 		this.put(id, category);
 		return id;
 	}
+	/** The threads made under a channel for temp knights, by id; `archived` once closed. */
+	threads = new Map<
+		string,
+		{ parent: string; name: string; archived: boolean }
+	>();
+	async createThread(parentChannelId: string, name: string) {
+		const id = String(this.#next++);
+		this.threads.set(id, { parent: parentChannelId, name, archived: false });
+		return id;
+	}
+	async closeThread(threadId: string) {
+		const thread = this.threads.get(threadId);
+		if (thread) thread.archived = true;
+	}
+	async openThread(threadId: string) {
+		const thread = this.threads.get(threadId);
+		if (thread) thread.archived = false;
+	}
 	async placeIn(channelId: string, category: AgentCategory) {
 		if (this.categoryOf(channelId) === category) return false;
 		this.put(channelId, category);
@@ -140,6 +153,13 @@ class FakeSurfaces {
 	replies: { channel: ChannelKey; reply: OutboundReply }[] = [];
 	/** Interim posts as `channel name/agent: text`, edits included. */
 	interims: string[] = [];
+	/** What each round told the surface, in order. */
+	rounds: { channel: ChannelKey; round: RoundProgress }[] = [];
+	async groupRound(channel: ChannelKey, round: RoundProgress) {
+		// A surface hears of the rounds of its own rooms only; Discord's channels are not any room's.
+		if (this.rooms.includes(channel.slice(0, channel.indexOf(":"))))
+			this.rounds.push({ channel, round });
+	}
 	roomSurfaces() {
 		return this.rooms;
 	}
@@ -175,44 +195,9 @@ class FakeSurfaces {
 	}
 }
 
-/** Answers every turn with a scripted reply; records what each turn received. */
-export class FakeRuntime implements AgentTurnRunner {
-	turns: TurnRequest[] = [];
-	reply: (request: TurnRequest) => string = (r) => `${r.agent?.name} ok`;
-	held = new Map<ChannelKey, PendingConfirmation>();
-	fresh: ChannelKey[] = [];
-	/** Runs inside a turn, like a tool call the model makes. */
-	during?: (request: TurnRequest) => unknown;
-	/** The next turn ends as if the owner pressed stop. */
-	stopNext = false;
-	async runTurn(request: TurnRequest): Promise<TurnResult> {
-		this.turns.push(request);
-		await this.during?.(request);
-		if (this.stopNext) {
-			this.stopNext = false;
-			return {
-				ok: false,
-				error: new AgentRunError("stopped by the owner"),
-				stopped: true,
-			};
-		}
-		return { ok: true, text: this.reply(request) };
-	}
-	async heldActions(session: ChannelKey) {
-		return this.held.get(session);
-	}
-	async startFresh(session: ChannelKey) {
-		this.fresh.push(session);
-	}
-	deleted: ChannelKey[] = [];
-	async deleteConversation(session: ChannelKey) {
-		this.deleted.push(session);
-	}
-	usage = new Map<ChannelKey, ContextUse>();
-	contextUsage(session: ChannelKey) {
-		return this.usage.get(session);
-	}
-}
+export { FakeRuntime } from "./agent-team-fake-runtime.ts";
+
+import { FakeRuntime } from "./agent-team-fake-runtime.ts";
 
 // CI runs the setup below about ten times slower than a laptop, and bun's 5 s hook limit
 // left a timed-out hook running while the next test dropped its tables.
@@ -297,6 +282,8 @@ export function useTeamFixture(
 		local?: boolean;
 		/** The studio the team renders with, called each test; the default fakes pictures. */
 		studio?: () => AgentTeamOptions["studio"];
+		/** The temp knights' limits the team is built with; left out, the defaults. */
+		helpers?: AgentTeamOptions["helpers"];
 	} = {},
 ): void {
 	const { local = false } = options;
@@ -420,6 +407,7 @@ export function useTeamFixture(
 				sharedPrompt: () => script.shared,
 				guestPrompt: () => script.guest,
 				skills,
+				...(options.helpers !== undefined ? { helpers: options.helpers } : {}),
 				logger: silentLogger(),
 			});
 		team = build();

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

@@ -10,22 +10,20 @@ import type { ResolvedSkill } from "../modules/skills/skill-rules.ts";
 import type { AgentChange, AgentTeam } from "../services.ts";
 import type { TurnSelection } from "../sessions.ts";
 import { type Speaker, THE_SPEAKER } from "../speakers.ts";
-import { agentSystemPrompt, placeOf } from "./agent-prompt.ts";
 import type { Agent } from "./agent-store.ts";
 import {
 	type AgentOps,
 	type AvatarMode,
 	agentToolsExtension,
 } from "./agent-tools.ts";
+import type { HelperTeam } from "./helper-ops.ts";
+import { type Routes, routesOf } from "./routes.ts";
 import { TeamEditing } from "./team-editing.ts";
 import {
-	agentRoomKey,
 	channelOwner,
 	coordinatorOf,
 	discordIdOf,
-	discordKey,
 	keysOf,
-	roomSurfaceOf,
 } from "./team-keys.ts";
 import {
 	layoutText,
@@ -34,6 +32,7 @@ import {
 } from "./team-layout.ts";
 import { TeamLifecycle } from "./team-lifecycle.ts";
 import type { AgentTeamOptions, TeamContext } from "./team-options.ts";
+import { teamSystemPrompt } from "./team-prompt.ts";
 import { teamSelection } from "./team-selection.ts";
 import { type TeamStatus, teamStatus } from "./team-status.ts";
 import {
@@ -64,14 +63,15 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 	readonly #editing: TeamEditing;
 
 	constructor(options: AgentTeamOptions) {
-		this.#options = options;
+		// One routing table for the team's turns and its editing.
+		this.#options = { ...options, routes: routesOf(options) };
 		this.#turns = new TeamTurns({
-			...options,
+			...this.#options,
 			selection: (scope) => this.selection(scope),
 			changed: () => this.#changed(),
 		});
 		this.#context = {
-			options,
+			options: this.#options,
 			turns: this.#turns,
 			changed: () => {
 				this.#changed();
@@ -79,6 +79,7 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 			},
 			modelOf: (name) => this.modelOf(name),
 			retitle: (group) => this.#lifecycle.retitle(group),
+			archiveHelpers: (names) => this.#lifecycle.helpers.archive(names),
 		};
 		this.#lifecycle = new TeamLifecycle(this.#context);
 		this.#editing = new TeamEditing(this.#context);
@@ -141,60 +142,7 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 
 	/** The system prompt addition of an agent session, read before each of its runs. */
 	systemPrompt(scope: AgentTurnScope): string {
-		const {
-			store,
-			workDir,
-			sharedPrompt,
-			guestPrompt,
-			owner,
-			shellUser,
-			scratchDir,
-			agentTools,
-			surfaces,
-			channels,
-		} = this.#options;
-		const agent = store.agent(scope.name);
-		if (!agent) throw new AgentError(`no agent ${scope.name}`);
-		const shared =
-			typeof sharedPrompt === "function" ? sharedPrompt() : sharedPrompt;
-		const guest =
-			typeof guestPrompt === "function" ? guestPrompt() : guestPrompt;
-		const group = scope.group ? store.group(scope.group) : undefined;
-		const coordinator = coordinatorOf(store, this.#options);
-		const speaker = this.#turns.speakerOf(scope);
-		const base = agentSystemPrompt({
-			agent,
-			...(speaker ? { speaker } : {}),
-			...(coordinator ? { coordinator } : {}),
-			shared,
-			...(guest ? { guestShared: guest } : {}),
-			workDir,
-			owner,
-			shellUser,
-			...(scratchDir ? { scratchDir } : {}),
-			images: this.#images(),
-			...(agentTools ? { agentTools } : {}),
-			...placeOf(this.#turns.turnChannel(scope), surfaces, !!channels),
-			...(group
-				? {
-						group: {
-							group,
-							members: group.members
-								.map((m) => store.agent(m))
-								.filter((m): m is Agent => m !== undefined),
-						},
-					}
-				: {}),
-		});
-		const added = (this.#options.promptSections?.() ?? []).flatMap(
-			(section) =>
-				section.build({
-					agent: { name: agent.name, displayName: agent.displayName },
-					speaker,
-					scope,
-				}) ?? [],
-		);
-		return [base, ...added.filter((text) => text.trim() !== "")].join("\n\n");
+		return teamSystemPrompt(this.#options, this.#turns, this.#images(), scope);
 	}
 
 	/** The model and thinking setting of an agent's next run: its own, or the assistant's. */
@@ -237,21 +185,12 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 
 	/**
 	 * Another active agent's channel, for schedule_list: its room on the surface `near` is on when
-	 * that surface hosts rooms, otherwise its Discord channel, otherwise its room on the first
-	 * surface that hosts rooms.
+	 * that surface hosts rooms, otherwise its primary place.
 	 */
 	channelOf(name: string, near?: ChannelKey): ChannelKey {
 		try {
-			const agent = this.#options.store.activeAgent(name);
-			const rooms = this.#options.surfaces?.roomSurfaces() ?? [];
-			const surface = near === undefined ? undefined : roomSurfaceOf(near);
-			if (surface !== undefined && rooms.includes(surface))
-				return agentRoomKey(surface, name);
-			if (agent.channelId) return discordKey(agent.channelId);
-			const room = rooms[0];
-			if (room === undefined)
-				throw new AgentError(`${name} has no channel yet`);
-			return agentRoomKey(room, name);
+			this.#options.store.activeAgent(name);
+			return this.#turns.routes.near(name, near);
 		} catch (error) {
 			throw new ScheduleError(
 				error instanceof Error ? error.message : String(error),
@@ -259,6 +198,11 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 		}
 	}
 
+	/** The routing table: where work no person started lands. */
+	get routes(): Routes {
+		return this.#turns.routes;
+	}
+
 	// ── Startup and archive, run by TeamLifecycle ──────────────────────────
 
 	/**
@@ -267,7 +211,10 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 	 * character in the background.
 	 */
 	start(): Promise<void> {
-		return this.#lifecycle.start().then(() => this.#turns.replayMessages());
+		return this.#lifecycle.start().then(() => {
+			this.#turns.routes.warnUnknown();
+			return this.#turns.replayMessages();
+		});
 	}
 
 	/** What the team still writes that a shutdown must wait for. */
@@ -334,6 +281,8 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 		return this.#turns.answerBackground(...args);
 	}
 
+	/** Ends the group channel's running round on Stop: the sessions to stop, or undefined when none runs. */
+	readonly stopRound = (channel: ChannelKey) => this.#turns.stopRound(channel);
 	/** One owner message in a group channel, answered by a round of members; call inside the queue. */
 	answerGroup(
 		channel: ChannelKey,
@@ -460,6 +409,52 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 		return this.#editing.create(caller, input);
 	}
 
+	/** A knight makes a temp knight for one task; see `AgentOps.helperCreate`. */
+	helperCreate(
+		caller: AgentTurnScope,
+		input: Parameters<TeamEditing["createHelper"]>[1],
+	): Promise<string> {
+		return this.#editing.createHelper(caller, input);
+	}
+
+	/** A knight archives its own temp knights; the pages that show the parent are told. */
+	helperEnd(
+		caller: AgentTurnScope,
+		names: readonly string[] | "finished",
+	): Promise<string> {
+		return this.#lifecycle.helpers.end(caller, names);
+	}
+
+	helpersOf(parent: string): Agent[] {
+		return this.#lifecycle.helpers.of(parent);
+	}
+
+	finishedHelpers(parents?: readonly string[]): Agent[] {
+		return this.#lifecycle.helpers.finished(parents);
+	}
+
+	async archiveHelpers(
+		names: readonly string[],
+		by: string,
+	): Promise<string[]> {
+		const archived = await this.#lifecycle.helpers.archive(names);
+		this.#options.logger.info({ by, archived }, "temp knights archived");
+		return archived;
+	}
+
+	restoreHelpers(names: readonly string[]): Promise<string[]> {
+		return this.#lifecycle.helpers.restore(names);
+	}
+
+	/** Archives the temp knights finished for longer than the host keeps them; runs hourly by itself. */
+	sweepFinished(now?: Date): Promise<string[]> {
+		return this.#lifecycle.helpers.sweepFinished(now);
+	}
+
+	onHelpersEnded(listener: Parameters<HelperTeam["onHelpersEnded"]>[0]): void {
+		this.#lifecycle.helpers.onEnded(listener);
+	}
+
 	/** An owner creates an agent outside any agent turn; see `AgentTeam.createAgent`. */
 	createAgent(
 		by: Speaker,

package/src/core/agents/agent-tool-schema.ts

@@ -0,0 +1,84 @@
+import { Type } from "typebox";
+import {
+	CATALOG,
+	type CharacterInput,
+	CLASS_IDS,
+	type PaletteName,
+} from "../../characters/index.ts";
+import { optionalString } from "../runtime/text-tools.ts";
+import { MAX_PROMPT_CHARS } from "./agent-rules.ts";
+
+const PALETTE_NAMES = Object.keys(CATALOG.palettes) as PaletteName[];
+
+// The parts of the agent tools' input that more than one tool takes.
+export const NAME = Type.String({
+	description:
+		"An agent's name (lowercase, from agent_list), not its display name.",
+});
+export const DISPLAY = Type.String({
+	minLength: 1,
+	maxLength: 32,
+	description: "The name shown on its messages; any language.",
+});
+export const PROMPT = Type.String({
+	minLength: 1,
+	maxLength: MAX_PROMPT_CHARS,
+	description:
+		"The agent's role prompt, in English: its job, sources, boundaries, and how it reports. Short and stated positively.",
+});
+const enumOf = (ids: readonly string[], description?: string) =>
+	Type.String({ enum: [...ids], ...(description ? { description } : {}) });
+export const CLASS = enumOf(
+	CLASS_IDS,
+	`The agent's character class, which sets its outfit, hat, and prop. ${CLASS_IDS.map((id) => `${id}: ${CATALOG.classes[id].jobs}`).join("; ")}.`,
+);
+export const COLOR = enumOf(
+	PALETTE_NAMES,
+	"The agent's color palette. Pick one unlike the other agents' (agent_get shows each look).",
+);
+export const PARTS = Type.Object(
+	{
+		outfit: Type.Optional(enumOf(CATALOG.outfits)),
+		hat: Type.Optional(enumOf(CATALOG.hats)),
+		prop: Type.Optional(enumOf(CATALOG.props)),
+		hair: Type.Optional(enumOf(CATALOG.hair)),
+		beard: Type.Optional(enumOf([...CATALOG.beards, "none"])),
+		accessory: Type.Optional(enumOf([...CATALOG.accessories, "none"])),
+		build: Type.Optional(enumOf(["slim", "regular", "stout"])),
+		skin: Type.Optional(Type.Integer({ minimum: 0, maximum: 5 })),
+		hair_color: Type.Optional(
+			Type.String({
+				pattern: "^#[0-9a-fA-F]{6}$",
+				description: "A hex color such as #3b2a1a.",
+			}),
+		),
+	},
+	{ description: "Single parts to change; any left out stay as they are." },
+);
+const PART_FIELDS = {
+	outfit: "outfit",
+	hat: "hat",
+	prop: "prop",
+	hair: "hair",
+	beard: "beard",
+	accessory: "accessory",
+	build: "build",
+	skin: "skin",
+	hair_color: "hairColor",
+} as const;
+
+/** The look a tool call names: class, color as palette, and parts; nothing it leaves out. */
+export function lookOf(input: Record<string, unknown>): CharacterInput {
+	const look: Record<string, unknown> = {};
+	const klass = optionalString(input, "class");
+	const color = optionalString(input, "color");
+	if (klass) look.class = klass;
+	if (color) look.palette = color;
+	const parts = input.parts;
+	if (parts !== null && typeof parts === "object")
+		for (const [key, field] of Object.entries(PART_FIELDS)) {
+			const value = (parts as Record<string, unknown>)[key];
+			if (value !== undefined) look[field] = value;
+		}
+	return look as CharacterInput;
+}

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

@@ -1,11 +1,6 @@
 import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import {
-	CATALOG,
-	type CharacterInput,
-	CLASS_IDS,
-	type PaletteName,
-} from "../../characters/index.ts";
+import type { CharacterInput } from "../../characters/index.ts";
 import { AgentError } from "../domain/errors.ts";
 import type { AgentTurnScope } from "../domain/ports.ts";
 import { assistantName, messages } from "../i18n/index.ts";
@@ -19,13 +14,17 @@ import {
 	textToolsExtension,
 } from "../runtime/text-tools.ts";
 import { timeZone } from "../time.ts";
+import { MAX_GROUP_MEMBERS, MIN_GROUP_MEMBERS } from "./agent-store.ts";
 import {
-	MAX_GROUP_MEMBERS,
-	MAX_PROMPT_CHARS,
-	MIN_GROUP_MEMBERS,
-} from "./agent-store.ts";
-
-const PALETTE_NAMES = Object.keys(CATALOG.palettes) as PaletteName[];
+	CLASS,
+	COLOR,
+	DISPLAY,
+	lookOf,
+	NAME,
+	PARTS,
+	PROMPT,
+} from "./agent-tool-schema.ts";
+import { helperToolDefs } from "./helper-tools.ts";
 
 /** The tool that hands a request to another agent; a group seat has none. */
 export const MESSAGE_AGENT_TOOL = "message_agent";
@@ -33,11 +32,15 @@ export const MESSAGE_AGENT_TOOL = "message_agent";
 /** The tool that changes an agent's look; every host offers it. */
 export const AVATAR_TOOL = "agent_avatar";
 
+/** The tools that make and end temp knights; `helpers: false` leaves them out. */
+export const HELPER_TOOLS = ["helper_create", "helper_end"] as const;
+
 export const AGENT_TOOLS = [
 	"agent_list",
 	"agent_get",
 	"agent_update",
 	"agent_create",
+	...HELPER_TOOLS,
 	AVATAR_TOOL,
 	MESSAGE_AGENT_TOOL,
 	"group_create",
@@ -47,6 +50,20 @@ export const AGENT_TOOLS = [
 	"channel_read",
 ] as const;
 
+/**
+ * The tools a temp knight's turns do not get: making knights, temp knights or groups, archiving,
+ * arranging channels, and scheduling, which would leave work behind with no one to end it.
+ */
+export const WITHHELD_FROM_HELPERS: readonly string[] = [
+	"agent_create",
+	...HELPER_TOOLS,
+	"group_create",
+	"group_update",
+	"archive",
+	"channel_arrange",
+	"schedule_create",
+];
+
 /**
  * @deprecated Agents are composed characters and no longer drawn; use `AgentTeam.dress`.
  * Removed in 1.0.
@@ -83,6 +100,25 @@ export interface AgentOps {
 			longRunning?: boolean;
 		},
 	): Promise<string>;
+	/** Makes a temp knight of the caller for one task; the answer returns to the caller's conversation. */
+	helperCreate(
+		caller: AgentTurnScope,
+		input: {
+			name?: string;
+			displayName: string;
+			prompt: string;
+			task: string;
+			character?: CharacterInput;
+			skills?: string[];
+			model?: string;
+			thinking?: string;
+		},
+	): Promise<string>;
+	/** Archives the caller's own temp knights: the named ones, or every one that is finished. */
+	helperEnd(
+		caller: AgentTurnScope,
+		names: readonly string[] | "finished",
+	): Promise<string>;
 	/** Changes an agent's look; a field left out stays as it is. */
 	avatar(name: string, look: CharacterInput): Promise<string>;
 	/** Queues the message and returns at once. */
@@ -116,50 +152,6 @@ export interface AgentOps {
 	): Promise<string>;
 }
 
-const NAME = Type.String({
-	description:
-		"An agent's name (lowercase, from agent_list), not its display name.",
-});
-const DISPLAY = Type.String({
-	minLength: 1,
-	maxLength: 32,
-	description: "The name shown on its messages; any language.",
-});
-const PROMPT = Type.String({
-	minLength: 1,
-	maxLength: MAX_PROMPT_CHARS,
-	description:
-		"The agent's role prompt, in English: its job, sources, boundaries, and how it reports. Short and stated positively.",
-});
-const enumOf = (ids: readonly string[], description?: string) =>
-	Type.String({ enum: [...ids], ...(description ? { description } : {}) });
-const CLASS = enumOf(
-	CLASS_IDS,
-	`The agent's character class, which sets its outfit, hat, and prop. ${CLASS_IDS.map((id) => `${id}: ${CATALOG.classes[id].jobs}`).join("; ")}.`,
-);
-const COLOR = enumOf(
-	PALETTE_NAMES,
-	"The agent's color palette. Pick one unlike the other agents' (agent_get shows each look).",
-);
-const PARTS = Type.Object(
-	{
-		outfit: Type.Optional(enumOf(CATALOG.outfits)),
-		hat: Type.Optional(enumOf(CATALOG.hats)),
-		prop: Type.Optional(enumOf(CATALOG.props)),
-		hair: Type.Optional(enumOf(CATALOG.hair)),
-		beard: Type.Optional(enumOf([...CATALOG.beards, "none"])),
-		accessory: Type.Optional(enumOf([...CATALOG.accessories, "none"])),
-		build: Type.Optional(enumOf(["slim", "regular", "stout"])),
-		skin: Type.Optional(Type.Integer({ minimum: 0, maximum: 5 })),
-		hair_color: Type.Optional(
-			Type.String({
-				pattern: "^#[0-9a-fA-F]{6}$",
-				description: "A hex color such as #3b2a1a.",
-			}),
-		),
-	},
-	{ description: "Single parts to change; any left out stay as they are." },
-);
 const category = (kind: "Agents" | "Groups") =>
 	Type.String({
 		description: `The category its channel opens under: ${kind} (the default) or ${kind}-<suffix>, such as ${kind}-work; made when missing. Keep to the categories agent_list shows unless a new one fits better.`,
@@ -170,34 +162,6 @@ const MEMBERS = Type.Array(Type.String(), {
 	description: "Agent names in speaking-tie order.",
 });
 
-const PART_FIELDS = {
-	outfit: "outfit",
-	hat: "hat",
-	prop: "prop",
-	hair: "hair",
-	beard: "beard",
-	accessory: "accessory",
-	build: "build",
-	skin: "skin",
-	hair_color: "hairColor",
-} as const;
-
-/** The look a tool call names: class, color as palette, and parts; nothing it leaves out. */
-function lookOf(input: Record<string, unknown>): CharacterInput {
-	const look: Record<string, unknown> = {};
-	const klass = optionalString(input, "class");
-	const color = optionalString(input, "color");
-	if (klass) look.class = klass;
-	if (color) look.palette = color;
-	const parts = input.parts;
-	if (parts !== null && typeof parts === "object")
-		for (const [key, field] of Object.entries(PART_FIELDS)) {
-			const value = (parts as Record<string, unknown>)[key];
-			if (value !== undefined) look[field] = value;
-		}
-	return look as CharacterInput;
-}
-
 type AgentToolDef = TextToolDef<(typeof AGENT_TOOLS)[number]>;
 
 /** What the agent tools offer, by what the host can do. */
@@ -324,6 +288,7 @@ function toolDefs(
 				});
 			},
 		},
+		...helperToolDefs(ops, scope, skillsOn),
 		{
 			name: AVATAR_TOOL,
 			label: "Change look",
@@ -345,7 +310,7 @@ function toolDefs(
 		{
 			name: "group_create",
 			label: "Create group",
-			description: `Create a group chat channel with 2 to 6 agents. The judge picks which members answer each of ${o.name}'s messages there, one after another. The host answers when nobody else fits.`,
+			description: `Create a group chat channel with 2 to 8 agents. The judge picks which members answer each of ${o.name}'s messages there, one after another. The host answers when nobody else fits.`,
 			parameters: Type.Object({
 				name: Type.String({ pattern: "^[a-z0-9-]{1,32}$" }),
 				display_name: DISPLAY,