pi-roundtable 0.1.0 → 0.2.0

package/src/core/agents/avatar-studio.ts

@@ -3,7 +3,10 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { createCanvas, loadImage } from "canvas";
 import type { ImageDrawer } from "../contract/providers.ts";
+import { ProviderError } from "../errors.ts";
 import type { HttpRoute } from "../http/listeners.ts";
+import type { AvatarStudio } from "../services.ts";
+import { fallbackAvatar } from "./fallback-avatar.ts";
 
 const AVATAR_SIDE = 512;
 const REFERENCE_SIDE = 512;
@@ -18,7 +21,8 @@ export interface AvatarStudioOptions {
 	publicUrl: string;
 	/** The assistant's neutral avatar: the style reference and the picture of an agent without one. */
 	referencePath: string;
-	draw: ImageDrawer;
+	/** Draws the pictures. Without one, the studio only makes each agent a picture from its name. */
+	draw?: ImageDrawer;
 }
 
 /** A centered square crop scaled to at most `side` pixels, as PNG. */
@@ -44,10 +48,11 @@ async function squarePng(bytes: Uint8Array, side: number): Promise<Buffer> {
 }
 
 /**
- * Agent avatars: Codex draws them in the assistant's style, and they are kept and served by content
- * hash, so a new picture has a new URL and Discord shows it at once.
+ * Agent avatars: an image provider draws them in the assistant's style, and without one each agent
+ * gets a picture generated from its display name. They are kept and served by content hash, so a
+ * new picture has a new URL and Discord shows it at once.
  */
-export class AvatarStudio {
+export class FileAvatarStudio implements AvatarStudio {
 	readonly #options: AvatarStudioOptions;
 	#defaultHash: string | undefined;
 
@@ -63,6 +68,11 @@ export class AvatarStudio {
 		);
 	}
 
+	/** Whether an image provider is configured; without one, only `fallback` makes pictures. */
+	get canDraw(): boolean {
+		return this.#options.draw !== undefined;
+	}
+
 	/** The public URL of a picture, or of the default when there is none. */
 	url(hash: string | undefined): string {
 		const chosen = hash ?? this.#defaultHash;
@@ -76,11 +86,12 @@ export class AvatarStudio {
 	 * so agents stay easy to tell apart.
 	 */
 	async draw(avatarPrompt: string): Promise<string> {
+		const draw = this.#drawer();
 		const reference = await squarePng(
 			readFileSync(this.#options.referencePath),
 			REFERENCE_SIDE,
 		);
-		const bytes = await this.#options.draw(
+		const bytes = await draw(
 			`Draw a square Discord avatar of the person in the reference image, redrawn as an anime character: keep their face, short dark hair, and features recognizable as the same person, but in vivid anime cel-shading with a big, exaggerated expression and a dramatic pose that shows the role. Dress them and paint the background exactly in the colours the description names; ignore the reference's green jacket and teal background. Head-and-shoulders framing that still reads at 40 px. No text, no border. The role: ${avatarPrompt}`,
 			[{ data: reference.toString("base64"), mimeType: "image/png" }],
 		);
@@ -89,16 +100,31 @@ export class AvatarStudio {
 
 	/** Edits a stored picture by an instruction; returns the new picture's hash. */
 	async edit(hash: string | undefined, instruction: string): Promise<string> {
+		const draw = this.#drawer();
 		const current = readFileSync(
 			this.#path(hash ?? this.#defaultHashOrThrow()),
 		);
-		const bytes = await this.#options.draw(
+		const bytes = await draw(
 			`Edit this Discord avatar: ${instruction}. Keep everything else, the style, and the square head-and-shoulders framing the same. No text, no border.`,
 			[{ data: current.toString("base64"), mimeType: "image/png" }],
 		);
 		return this.#store(bytes);
 	}
 
+	/**
+	 * A picture made from an agent's display name, its name, and the assistant's icon, for a host without an
+	 * image provider; the same name always gives the same picture. Returns its hash.
+	 */
+	async fallback(displayName: string, name: string): Promise<string> {
+		return this.#store(
+			await fallbackAvatar(
+				displayName,
+				readFileSync(this.#options.referencePath),
+				name,
+			),
+		);
+	}
+
 	/** Avatar pictures, public on the listener that cloudflared forwards the public hostname to. */
 	route(listener: string): HttpRoute {
 		return {
@@ -127,6 +153,14 @@ export class AvatarStudio {
 		});
 	}
 
+	#drawer(): ImageDrawer {
+		if (!this.#options.draw)
+			throw new ProviderError(
+				"no image provider is configured, so avatars cannot be drawn",
+			);
+		return this.#options.draw;
+	}
+
 	#defaultHashOrThrow(): string {
 		if (!this.#defaultHash)
 			throw new Error("the avatar studio was not initialized");

package/src/core/agents/fallback-avatar.ts

@@ -0,0 +1,85 @@
+import { createHash } from "node:crypto";
+import { createCanvas, loadImage } from "canvas";
+
+const SIDE = 512;
+/** The icon sits in a disc, with a badge overlapping its lower right. */
+const ICON_RADIUS = 176;
+const ICON_CENTER = { x: 256, y: 232 };
+const BADGE = { x: 396, y: 396, radius: 64 };
+
+const hsl = (h: number, s: number, l: number): string =>
+	`hsl(${Math.round(h) % 360},${s}%,${l}%)`;
+
+const layer = (body: string): Buffer =>
+	Buffer.from(
+		`<svg xmlns="http://www.w3.org/2000/svg" width="${SIDE}" height="${SIDE}" viewBox="0 0 ${SIDE} ${SIDE}">${body}</svg>`,
+	);
+
+/**
+ * A stable picture for an agent nobody drew: the assistant's icon on a colour taken from the
+ * display name, with a badge holding the initial of the agent's name. The name is lowercase Latin
+ * letters, digits, and dashes, so the badge is always drawn from a font every server has, whatever
+ * script the display name is written in. The same display name, name, and icon always give the
+ * same bytes.
+ */
+export async function fallbackAvatar(
+	displayName: string,
+	icon: Uint8Array,
+	name: string,
+): Promise<Buffer> {
+	const shown = displayName.normalize("NFC").trim();
+	const digest = createHash("sha256").update(shown).digest();
+	const byte = (i: number) => digest[i] ?? 0;
+	const hue = ((byte(0) << 8) | byte(1)) % 360;
+	const dark = hsl(hue, 58, 26);
+
+	const bubbles = [0, 1, 2]
+		.map((i) => {
+			const cx = (byte(2 + i * 3) / 255) * SIDE;
+			const cy = (byte(3 + i * 3) / 255) * SIDE;
+			const r = 90 + (byte(4 + i * 3) / 255) * 130;
+			return `<circle cx="${cx.toFixed(1)}" cy="${cy.toFixed(1)}" r="${r.toFixed(1)}" fill="#fff" fill-opacity="0.09"/>`;
+		})
+		.join("");
+	const back = layer(
+		`<defs><linearGradient id="g" x1="0" y1="0" x2="0.35" y2="1"><stop offset="0" stop-color="${hsl(hue, 62, 55)}"/><stop offset="1" stop-color="${hsl(hue + 32, 60, 33)}"/></linearGradient></defs>` +
+			`<rect width="${SIDE}" height="${SIDE}" fill="url(#g)"/>${bubbles}` +
+			`<circle cx="${ICON_CENTER.x}" cy="${ICON_CENTER.y}" r="${ICON_RADIUS + 8}" fill="#fff" fill-opacity="0.35"/>` +
+			`<circle cx="${ICON_CENTER.x}" cy="${ICON_CENTER.y}" r="${ICON_RADIUS}" fill="#fff" fill-opacity="0.55"/>`,
+	);
+
+	const initial = (name.match(/[a-z0-9]/)?.[0] ?? "?").toUpperCase();
+	const mark = `<text x="${BADGE.x}" y="${BADGE.y + 28}" font-family="DejaVu Sans, Helvetica, Arial, sans-serif" font-size="80" font-weight="bold" text-anchor="middle" fill="${dark}">${initial}</text>`;
+	const front = layer(
+		`<circle cx="${BADGE.x}" cy="${BADGE.y}" r="${BADGE.radius + 8}" fill="${hsl(hue + 32, 60, 33)}"/>` +
+			`<circle cx="${BADGE.x}" cy="${BADGE.y}" r="${BADGE.radius}" fill="#fff"/>${mark}`,
+	);
+
+	const canvas = createCanvas(SIDE, SIDE);
+	const ctx = canvas.getContext("2d");
+	ctx.drawImage(await loadImage(back), 0, 0);
+	const face = await loadImage(Buffer.from(icon));
+	const crop = Math.min(face.width, face.height);
+	ctx.save();
+	ctx.beginPath();
+	ctx.arc(ICON_CENTER.x, ICON_CENTER.y, ICON_RADIUS, 0, Math.PI * 2);
+	ctx.clip();
+	ctx.drawImage(
+		face,
+		(face.width - crop) / 2,
+		(face.height - crop) / 2,
+		crop,
+		crop,
+		ICON_CENTER.x - ICON_RADIUS,
+		ICON_CENTER.y - ICON_RADIUS,
+		ICON_RADIUS * 2,
+		ICON_RADIUS * 2,
+	);
+	// Tint the icon's own backdrop with the name's colour so the disc belongs to the picture.
+	ctx.globalCompositeOperation = "multiply";
+	ctx.fillStyle = hsl(hue, 45, 93);
+	ctx.fillRect(0, 0, SIDE, SIDE);
+	ctx.restore();
+	ctx.drawImage(await loadImage(front), 0, 0);
+	return canvas.toBuffer("image/png");
+}

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

@@ -6,10 +6,14 @@ import { openingTaskText } from "./agent-prompt.ts";
 import { modelSetting, thinkingSetting } from "./agent-settings.ts";
 import type { Agent } from "./agent-store.ts";
 import type { AvatarMode } from "./agent-tools.ts";
-import { channelKey } from "./team-keys.ts";
+import { discordKey } from "./team-keys.ts";
 import { groupTopic, teamCategory } from "./team-layout.ts";
 import type { TeamContext } from "./team-options.ts";
 
+/** Said when an avatar is to be redrawn on a host without an image provider. */
+const NO_IMAGE_PROVIDER =
+	"No image provider is configured, so avatars cannot be redrawn; the current picture stays. A plugin fills the images slot to draw them.";
+
 /** Creating and changing agents, their avatars, and groups. */
 export class TeamEditing {
 	readonly #ctx: TeamContext;
@@ -74,37 +78,62 @@ export class TeamEditing {
 			name: string;
 			displayName: string;
 			prompt: string;
-			avatarPrompt: string;
+			/** Required when an image provider is configured, ignored otherwise. */
+			avatarPrompt?: string;
 			task: string;
 			category?: string;
 			skills?: string[];
 		},
 	): Promise<string> {
+		const { store, studio, channels, queue, skills, logger } =
+			this.#ctx.options;
+		if (input.skills && input.skills.length > 0 && !skills)
+			throw new AgentError(
+				"Skills are off on this host, so an agent cannot carry any. Create it without skills.",
+			);
 		const speaker = this.#ctx.turns.speakerOf(caller);
 		if (!speaker)
 			throw new AgentError(
 				"agent_create can only be used during an agent turn.",
 			);
-		const { store, channels, queue, skills, logger } = this.#ctx.options;
-		const { category, skills: carried = [], ...fields } = input;
+		const drawing = studio.canDraw !== false;
+		const {
+			category,
+			skills: carried = [],
+			avatarPrompt = "",
+			...fields
+		} = input;
+		if (drawing && avatarPrompt.trim() === "")
+			throw new AgentError("Give avatar_prompt: the avatar is drawn from it.");
 		const parent = teamCategory(category, "Agents");
 		store.checkNewName(input.name);
-		skills.checkRegistered(carried);
+		skills?.checkRegistered(carried);
 		const channelId = await channels.createChannel(
 			input.name,
 			input.displayName,
 			parent,
 		);
-		const agent = await store.createAgent({ ...fields, channelId });
-		if (carried.length > 0) await skills.attach(agent.name, carried, []);
+		const agent = await store.createAgent({
+			...fields,
+			avatarPrompt: drawing ? avatarPrompt : "",
+			channelId,
+		});
+		if (skills && carried.length > 0)
+			await skills.attach(agent.name, carried, []);
 		logger.info({ agent: agent.name, by: caller.name }, "agent created");
 		this.#ctx.changed();
-		const avatar = await this.#redraw(agent.name, "redraw").then(
-			() => "its avatar is drawn",
+		const avatar = await (drawing
+			? this.#redraw(agent.name, "redraw")
+			: this.#generate(agent)
+		).then(
+			() =>
+				drawing
+					? "its avatar is drawn"
+					: "its avatar is generated from its display name",
 			(error: unknown) =>
 				`its avatar could not be drawn (${error instanceof Error ? error.message : String(error)}), so it uses ${assistantName()}'s for now`,
 		);
-		const home = channelKey(channelId);
+		const home = discordKey(channelId);
 		const creator = store.agent(caller.name);
 		void queue
 			.run(home, () =>
@@ -138,9 +167,19 @@ export class TeamEditing {
 		return this.#redraw(name, mode, text);
 	}
 
+	/** Gives an agent the picture made from its display name; a host without an image provider has no other. */
+	async #generate(agent: Agent): Promise<Agent> {
+		const { store, studio } = this.#ctx.options;
+		if (!studio.fallback)
+			throw new AgentError("The avatar studio has no generated avatars.");
+		const avatarHash = await studio.fallback(agent.displayName, agent.name);
+		return store.updateAgent(agent.name, { avatarHash });
+	}
+
 	async #redraw(name: string, mode: AvatarMode, text?: string): Promise<Agent> {
 		const { store, studio, logger } = this.#ctx.options;
 		const agent = store.activeAgent(name);
+		if (studio.canDraw === false) throw new AgentError(NO_IMAGE_PROVIDER);
 		if (mode !== "redraw" && !text?.trim())
 			throw new AgentError(
 				mode === "edit"

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

@@ -1,12 +1,24 @@
+import { channelKey, parseChannelKey } from "../contract/surface.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
 import type { AgentTurnScope } from "../domain/ports.ts";
-import type { Agent, AgentGroup, AgentStore } from "./agent-store.ts";
+import type { AgentDirectory } from "../services.ts";
+import type { Agent, AgentGroup } from "./agent-store.ts";
 
-export const channelKey = (channelId: string): ChannelKey =>
-	`discord:${channelId}`;
+/** The surface of the channels the agent server runs on. */
+const DISCORD_SURFACE = "discord";
 
-export const channelIdOf = (channel: ChannelKey) =>
-	channel.slice("discord:".length);
+/** The key of a Discord channel. */
+export const discordKey = (channelId: string): ChannelKey =>
+	channelKey(DISCORD_SURFACE, channelId);
+
+/** The Discord channel id of a key, or undefined when the key belongs to another surface. */
+export function discordIdOf(channel: ChannelKey): string | undefined {
+	const { surface, id } = parseChannelKey(channel);
+	return surface === DISCORD_SURFACE ? id : undefined;
+}
+
+/** The id part of a key the caller already knows is a Discord one, because the agent server owns it. */
+export const channelIdOf = (channel: ChannelKey) => parseChannelKey(channel).id;
 
 /** An agent's conversation inside a group, apart from its own. */
 export const groupSessionKey = (group: AgentGroup, agent: string): ChannelKey =>
@@ -14,7 +26,7 @@ export const groupSessionKey = (group: AgentGroup, agent: string): ChannelKey =>
 
 /** An agent's own conversation. */
 export function homeScope(agent: Agent): AgentTurnScope {
-	const home = channelKey(agent.channelId ?? "");
+	const home = discordKey(agent.channelId ?? "");
 	return { name: agent.name, session: home, home };
 }
 
@@ -23,17 +35,18 @@ export function groupScope(agent: Agent, group: AgentGroup): AgentTurnScope {
 	return {
 		name: agent.name,
 		session: groupSessionKey(group, agent.name),
-		home: channelKey(agent.channelId ?? ""),
+		home: discordKey(agent.channelId ?? ""),
 		group: group.name,
 	};
 }
 
 /** The agent or group that owns a channel of the agent server. */
 export function channelOwner(
-	store: Pick<AgentStore, "agentByChannel" | "groupByChannel">,
+	store: Pick<AgentDirectory, "agentByChannel" | "groupByChannel">,
 	channel: ChannelKey,
 ): "agent" | "group" | undefined {
-	const id = channelIdOf(channel);
+	const id = discordIdOf(channel);
+	if (id === undefined) return undefined;
 	if (store.agentByChannel(id)) return "agent";
 	if (store.groupByChannel(id)) return "group";
 	return undefined;

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

@@ -1,10 +1,11 @@
 import { AgentError } from "../domain/errors.ts";
 import { messages } from "../i18n/index.ts";
+import type { AgentDirectory } from "../services.ts";
 import type { CategoryLayout } from "./agent-ports.ts";
-import type { AgentGroup, AgentStore } from "./agent-store.ts";
+import type { AgentGroup } from "./agent-store.ts";
 
 type TeamStore = Pick<
-	AgentStore,
+	AgentDirectory,
 	"agent" | "group" | "agentByChannel" | "groupByChannel"
 >;
 
@@ -38,7 +39,7 @@ export function teamCategory(
 /** A group channel's topic: who is in it and who hosts. */
 export function groupTopic(
 	group: AgentGroup,
-	store: Pick<AgentStore, "agent">,
+	store: Pick<AgentDirectory, "agent">,
 ): string {
 	const shown = (name: string) => store.agent(name)?.displayName ?? name;
 	return messages().groupTopic(

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

@@ -4,7 +4,7 @@ import type { AgentTurnScope } from "../domain/ports.ts";
 import type { AgentGroup } from "./agent-store.ts";
 import {
 	channelIdOf,
-	channelKey,
+	discordKey,
 	groupSessionKey,
 	homeScope,
 } from "./team-keys.ts";
@@ -66,6 +66,7 @@ export class TeamLifecycle {
 
 	async #drawMissingAvatars(): Promise<void> {
 		const { store, studio, logger } = this.#ctx.options;
+		if (studio.canDraw === false) return this.#generateMissingAvatars();
 		for (const agent of store.agents()) {
 			if (agent.status !== "active" || agent.avatarHash) continue;
 			try {
@@ -78,6 +79,31 @@ export class TeamLifecycle {
 		}
 	}
 
+	/**
+	 * Without an image provider, gives each active agent that has no picture the one made from
+	 * its display name, and says so once instead of once per agent on every boot.
+	 */
+	async #generateMissingAvatars(): Promise<void> {
+		const { store, studio, logger } = this.#ctx.options;
+		if (!studio.fallback) return;
+		let generated = 0;
+		for (const agent of store.agents()) {
+			if (agent.status !== "active" || agent.avatarHash) continue;
+			try {
+				const avatarHash = await studio.fallback(agent.displayName, agent.name);
+				await store.updateAgent(agent.name, { avatarHash });
+				generated++;
+			} catch (error) {
+				logger.warn({ agent: agent.name, err: error }, "avatar not generated");
+			}
+		}
+		if (generated > 0)
+			logger.info(
+				{ generated },
+				"no image provider is configured; agents without a picture got one generated from their display name",
+			);
+	}
+
 	/** Starts an agent's or every group member's conversation over; call inside the channel's queue. */
 	async startFresh(channel: ChannelKey): Promise<void> {
 		const { store } = this.#ctx.options;
@@ -149,7 +175,7 @@ export class TeamLifecycle {
 		const agent = store.agentByChannel(channelId);
 		if (agent) {
 			const left = await store.archiveAgent(agent.name);
-			const home = channelKey(channelId);
+			const home = discordKey(channelId);
 			for (const schedule of await schedules.forChannel(home))
 				await schedules.remove(schedule.id, home);
 			await runtime.startFresh(home);

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

@@ -1,11 +1,10 @@
 import type { ChannelKey } from "../domain/conversation.ts";
 import type { ThinkingSetting } from "../models.ts";
-import type { SkillRegistry } from "../modules/skills/skill-registry.ts";
 import type { PromptSection } from "../plugin.ts";
+import type { AvatarStudio, SkillRegistry } from "../services.ts";
 import type { ToolSelection } from "../sessions.ts";
 import type { AgentChannels, AgentModels } from "./agent-ports.ts";
 import type { AgentGroup, AgentSeed } from "./agent-store.ts";
-import type { AvatarStudio } from "./avatar-studio.ts";
 import type { TeamTurns, TeamTurnsOptions } from "./team-turns.ts";
 
 export interface AgentTeamOptions
@@ -19,7 +18,12 @@ export interface AgentTeamOptions
 	/** The tools plugins defined for agents, read before each agent turn. */
 	pluginTools?: () => readonly string[];
 	channels: AgentChannels;
-	studio: Pick<AvatarStudio, "url" | "draw" | "edit">;
+	/**
+	 * `canDraw: false` marks a host without an image provider: agents are offered no drawing and
+	 * get `fallback` pictures. A studio that leaves `canDraw` out draws.
+	 */
+	studio: Pick<AvatarStudio, "url" | "draw" | "edit"> &
+		Partial<Pick<AvatarStudio, "canDraw" | "fallback">>;
 	/** The tools and groups the plugins give every agent, read before each agent turn. */
 	pluginSelection: () => ToolSelection;
 	models: AgentModels;
@@ -35,8 +39,8 @@ export interface AgentTeamOptions
 	sharedPrompt: string;
 	/** The shared prompt for speakers other than the owner, when `sharedPrompt` speaks to the owner. */
 	guestPrompt?: string;
-	/** The skill registry: what each agent carries and the skill tools. */
-	skills: SkillRegistry;
+	/** The skill registry: what each agent carries. Absent when the skills addon is off. */
+	skills?: SkillRegistry;
 }
 
 /** What the team's collaborators share: its options, its turns, and its change signal. */

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

@@ -1,6 +1,6 @@
 import type { ThinkingSetting } from "../models.ts";
 import type { ContextUse } from "./agent-ports.ts";
-import { channelIdOf, channelKey } from "./team-keys.ts";
+import { channelIdOf, discordKey } from "./team-keys.ts";
 import type { TeamContext } from "./team-options.ts";
 
 /** An active agent as the dashboard shows it. */
@@ -44,10 +44,10 @@ export async function teamStatus(ctx: TeamContext): Promise<TeamStatus> {
 	const agents: AgentStatus[] = [];
 	for (const agent of store.agents()) {
 		if (agent.status !== "active") continue;
-		const home = agent.channelId ? channelKey(agent.channelId) : undefined;
+		const home = agent.channelId ? discordKey(agent.channelId) : undefined;
 		const workingIn = turns.workingIn(agent.name);
 		const queued = home ? queue.size(home) : 0;
-		const context = home ? runtime.contextUsage(home) : undefined;
+		const context = home ? runtime.contextUsage?.(home) : undefined;
 		const lastActive = turns.lastActive(agent.name);
 		agents.push({
 			name: agent.name,
@@ -72,7 +72,7 @@ export async function teamStatus(ctx: TeamContext): Promise<TeamStatus> {
 				channelId: group.channelId,
 				members: group.members.map((m) => store.agent(m)?.displayName ?? m),
 				host: store.agent(group.host)?.displayName ?? group.host,
-				busy: queue.size(channelKey(group.channelId)),
+				busy: queue.size(discordKey(group.channelId)),
 				...(lastActive ? { lastActive } : {}),
 			};
 		});

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

@@ -1,10 +1,11 @@
 import { AgentError } from "../domain/errors.ts";
 import { assistantName } from "../i18n/index.ts";
 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 { describeThinking } from "./agent-settings.ts";
-import type { Agent, AgentStore } from "./agent-store.ts";
+import type { Agent } from "./agent-store.ts";
 
 /** One message as channel_read shows it: id, local time, author, text, attachments. */
 export function messageLine(message: ChannelMessage): string {
@@ -26,7 +27,7 @@ export function channelIdFromRef(channel: string): string {
 }
 
 /** Every agent and group as agent_list shows them, before the category layout. */
-export function teamListText(store: Pick<AgentStore, "agents" | "groups">) {
+export function teamListText(store: Pick<AgentDirectory, "agents" | "groups">) {
 	const agents = store.agents().map((a) => {
 		const channel = a.channelId ? `<#${a.channelId}>` : "no channel";
 		return `- ${a.name} "${a.displayName}" — ${channel}, ${a.status}`;
@@ -40,11 +41,12 @@ export function teamListText(store: Pick<AgentStore, "agents" | "groups">) {
 	return `Agents:\n${agents.join("\n") || "none"}\n\nGroups:\n${groups.join("\n") || "none"}`;
 }
 
-/** One agent as agent_get shows it; unset settings name the assistant's. */
+/** One agent as agent_get shows it; unset settings name the assistant's, and no skills line while the skills addon is off. */
 export function agentDetails(
 	agent: Agent,
 	defaults: { model: string; thinking: ThinkingSetting },
-	skills: string,
+	skills: string | undefined,
+	avatars = true,
 ): string {
 	return [
 		`Name: ${agent.name}`,
@@ -53,8 +55,8 @@ export function agentDetails(
 		`Channel: ${agent.channelId ? `<#${agent.channelId}>` : "none"}`,
 		`Model: ${agent.model ?? `${assistantName()}'s (${defaults.model})`}`,
 		`Thinking: ${agent.thinking ?? `${assistantName()}'s (${describeThinking(defaults.thinking)})`}`,
-		`Skills: ${skills}`,
-		`Avatar prompt: ${agent.avatarPrompt}`,
+		...(skills === undefined ? [] : [`Skills: ${skills}`]),
+		...(avatars ? [`Avatar prompt: ${agent.avatarPrompt}`] : []),
 		`Prompt:\n${agent.prompt}`,
 	].join("\n");
 }

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

@@ -13,12 +13,12 @@ import type { AgentTurnScope } from "../domain/ports.ts";
 import type { OwnerIdentity } from "../identity.ts";
 import type { Logger } from "../log.ts";
 import type { EventSink } from "../plugin.ts";
+import type { AvatarStudio } from "../services.ts";
 import type { TurnSelection } from "../sessions.ts";
 import type { Speaker } from "../speakers.ts";
 import type { ToolTiers } from "../tool-tiers.ts";
 import type { AgentChannels, AgentTurnRunner } from "./agent-ports.ts";
-import type { Agent, AgentStore } from "./agent-store.ts";
-import type { AvatarStudio } from "./avatar-studio.ts";
+import type { Agent, PgAgentStore } from "./agent-store.ts";
 import type { RelevanceScorer } from "./group-round.ts";
 
 /** Agent messages without an owner message in between (spec behavior 13). */
@@ -43,7 +43,7 @@ export interface TeamTurnsOptions {
 	entryChannelId: string;
 	/** Who the agents work for, as their prompts and group history name them. */
 	owner: OwnerIdentity;
-	store: AgentStore;
+	store: PgAgentStore;
 	channels: Pick<AgentChannels, "post">;
 	studio: Pick<AvatarStudio, "url">;
 	/** Set once the runtime exists, which itself needs the team's tools. */
@@ -76,7 +76,7 @@ export interface TurnExtra {
 	attachments?: TurnAttachments;
 	confirmed?: boolean;
 	steerable?: boolean;
-	/** The owner started it by writing, or it delivers a report, so it may ask him on cards. */
+	/** The owner started it by writing, or it delivers a report, so it may ask them on cards. */
 	interactive?: boolean;
 }
 

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

@@ -17,8 +17,8 @@ import type { Agent } from "./agent-store.ts";
 import { GroupTurns } from "./group-turns.ts";
 import {
 	channelIdOf,
-	channelKey,
 	channelOwner,
+	discordKey,
 	homeScope,
 } from "./team-keys.ts";
 import {
@@ -83,7 +83,7 @@ export class TeamTurns {
 
 	/**
 	 * The owner's message in an agent's channel; call inside the channel's queue. `text`
-	 * carries the reference, `replyText` is what he typed.
+	 * carries the reference, `replyText` is what they typed.
 	 */
 	async answerOwner(
 		channel: ChannelKey,
@@ -168,6 +168,7 @@ export class TeamTurns {
 		this.#active(agent.name, scope.group);
 		const turn = {
 			agent: agent.name,
+			kind: "agent",
 			channel: postTo,
 			speaker: chain.speaker,
 			...(scope.group ? { group: scope.group } : {}),
@@ -267,7 +268,7 @@ export class TeamTurns {
 
 	/**
 	 * Posts text under the caller's name in the channel of its turn: the group's in a group
-	 * round, otherwise its own, as a change report is (repos-and-skills spec behavior 10).
+	 * round, otherwise its own, as a change report is.
 	 */
 	async postAs(caller: AgentTurnScope, text: string): Promise<void> {
 		const agent = this.#options.store.activeAgent(caller.name);
@@ -281,7 +282,7 @@ export class TeamTurns {
 		const group = scope.group
 			? this.#options.store.group(scope.group)
 			: undefined;
-		return group ? channelKey(group.channelId) : scope.home;
+		return group ? discordKey(group.channelId) : scope.home;
 	}
 
 	/** The assistant's own notice, such as a new release, posted in the coordinator's channel under its name. */
@@ -290,7 +291,7 @@ export class TeamTurns {
 		const coordinator = store.agentByChannel(entryChannelId);
 		if (!coordinator)
 			throw new AgentError("no active agent in the entry channel");
-		await this.#post(channelKey(entryChannelId), coordinator, {
+		await this.#post(discordKey(entryChannelId), coordinator, {
 			chunks: splitReply(text),
 		});
 	}