pi-roundtable 0.1.0 → 0.2.1

package/examples/shared-services.ts

@@ -0,0 +1,60 @@
+import { definePlugin, serviceKey } from "pi-roundtable";
+
+/** What the notes plugin offers other plugins: a port, so any object with these methods will do. */
+export interface NoteIndex {
+	add(text: string): void;
+	all(): readonly string[];
+}
+
+/** The key is the service's name. Give its id a prefix of your own; two keys with one id are one service. */
+export const NOTE_INDEX = serviceKey<NoteIndex>("my-notes.index");
+
+/** A plugin lists the services it provides, then provides each from `setup`. */
+export function notes() {
+	const stored: string[] = [];
+	return definePlugin({
+		name: "my-notes",
+		provides: [NOTE_INDEX],
+		setup: ({ services }) => {
+			services.provide(NOTE_INDEX, {
+				add: (text) => void stored.push(text),
+				all: () => stored,
+			});
+			return { services: [{ name: "notes-ready" }] };
+		},
+	});
+}
+
+/** A plugin registered after it reads the service; `find` is undefined when nobody provides it. */
+export function noteReader(
+	onNotes: (notes: readonly string[] | undefined) => void,
+) {
+	return definePlugin({
+		name: "note-reader",
+		setup: ({ services }) => ({
+			services: [
+				{
+					name: "note-reader",
+					start: () => onNotes(services.find(NOTE_INDEX)?.all()),
+				},
+			],
+		}),
+	});
+}
+
+/** A plugin that provides the same key and lists it in `replaces` takes the place of the one before it. */
+export function shoutingNotes() {
+	const stored: string[] = [];
+	return definePlugin({
+		name: "shouting-notes",
+		provides: [NOTE_INDEX],
+		replaces: [NOTE_INDEX],
+		setup: ({ services }) => {
+			services.provide(NOTE_INDEX, {
+				add: (text) => void stored.push(text.toUpperCase()),
+				all: () => stored,
+			});
+			return { services: [{ name: "shouting-notes-ready" }] };
+		},
+	});
+}

package/examples/study-room.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "bun:test";
+import { testPlugin } from "pi-roundtable/testing";
+import { createEchoRuntime } from "./echo-runtime.ts";
+import { FakeSurface } from "./fake-surface.ts";
+import { studyRoom } from "./study-room.ts";
+
+/** The plugin over the fake surface and the echo runtime, with nothing else: no Discord, no Pi, no database. */
+async function studying() {
+	const surface = new FakeSurface();
+	const harness = await testPlugin(studyRoom, {
+		surfaces: [surface],
+		providers: { runtime: createEchoRuntime },
+	});
+	return { surface, harness };
+}
+
+async function until(done: () => boolean): Promise<void> {
+	for (let waited = 0; !done() && waited < 1000; waited += 5)
+		await Bun.sleep(5);
+	expect(done()).toBe(true);
+}
+
+test("a message in a study room runs as a turn of the study kind, with the tutor's persona", async () => {
+	const { surface, harness } = await studying();
+	surface.say("fake:study-algebra", "What is a group?");
+	await until(() => surface.replies.length > 0);
+	expect(surface.replies).toEqual([
+		{
+			channel: "fake:study-algebra",
+			reply: {
+				chunks: [
+					"[You are a patient tutor. Ask one question back before you give the answer.] What is a group?",
+				],
+			},
+		},
+	]);
+	// The plugins' turn events carry the kind and no agent.
+	const started = harness.events.find(({ name }) => name === "turnStarted");
+	expect(started?.turn).toMatchObject({
+		kind: "study",
+		channel: "fake:study-algebra",
+	});
+	expect(started?.turn?.agent).toBeUndefined();
+	await harness.stop();
+});
+
+test("a channel that is not a study room is not the claim's", async () => {
+	const { surface, harness } = await studying();
+	surface.say("fake:lounge", "hello");
+	await Bun.sleep(30);
+	expect(surface.replies).toEqual([]);
+	await harness.stop();
+});
+
+test("starting a room over says it was a study conversation", async () => {
+	const { harness } = await studying();
+	expect(await harness.conversations.startFresh("fake:study-algebra")).toBe(
+		"study",
+	);
+	await harness.stop();
+});
+
+test("the persona is the plugin's and belongs to the study kind only", async () => {
+	const { harness } = await studying();
+	const [persona] = harness.contribution.personas ?? [];
+	expect(persona?.kind).toBe("study");
+	expect(persona?.prompt()).toContain("patient tutor");
+	await harness.stop();
+});

package/examples/study-room.ts

@@ -0,0 +1,52 @@
+import { definePlugin, parseChannelKey } from "pi-roundtable";
+
+/** The kind of a study room's conversations: the string `startFresh` returns, and the persona's kind. */
+const STUDY = "study";
+
+/**
+ * A conversation kind of its own. The persona is the system prompt of every `study` conversation,
+ * the claim owns the channels of the study rooms, and `context.turns` runs each message as a turn
+ * of that kind on whatever runtime the host has, and posts the answer through the channel's
+ * surface.
+ */
+export const studyRoom = definePlugin({
+	name: "study-room",
+	setup: ({ turns }) => ({
+		personas: [
+			{
+				kind: STUDY,
+				prompt: () =>
+					"You are a patient tutor. Ask one question back before you give the answer.",
+			},
+		],
+		channels: [
+			{
+				name: "study-rooms",
+				priority: 10,
+				// The id of a room starts with `study-`, on whichever surface carries it.
+				owns: (channel) => parseChannelKey(channel).id.startsWith("study-"),
+				admit: (message) =>
+					message.authorIsBot
+						? undefined
+						: {
+								kind: "turn",
+								run: async () => {
+									await turns.run({
+										channel: message.channel,
+										kind: STUDY,
+										text: message.text,
+										speaker: {
+											id: message.authorId,
+											name: message.authorName,
+											tier: "member",
+										},
+									});
+								},
+								failure: "a study turn failed",
+							},
+				// What the conversation was, so a host picks the right persona when it starts over.
+				startFresh: async () => STUDY,
+			},
+		],
+	}),
+});

package/examples/support-desk.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from "bun:test";
+import { testPlugin } from "pi-roundtable/testing";
+import { supportDesk } from "./support-desk.ts";
+
+const turn = (target: string) => ({
+	channel: "support:1" as const,
+	target,
+	author: { id: "u1", name: "Sam" },
+	turnId: "t1",
+	text: "check the queue",
+});
+
+test("the plugin contributes its target, with the limits its schedules and tasks obey", async () => {
+	const { conversations, stop } = await testPlugin(supportDesk);
+	const target = conversations.target("support");
+	expect(target?.label("en")).toBe("Support desk");
+	expect(target?.schedules?.perChannel).toBe(3);
+	expect(target?.delegation?.maxRunning).toBe(1);
+	expect(conversations.target("owner")).toBeUndefined();
+	await stop();
+});
+
+test("a turn for its target runs in its channels, and any other target is skipped", async () => {
+	const { conversations, stop } = await testPlugin(supportDesk);
+	expect(await conversations.background(turn("support"))).toEqual({
+		status: "ran",
+	});
+	// Nobody contributes "retired", so the router skips it before any claim is asked.
+	expect(await conversations.background(turn("retired"))).toEqual({
+		status: "skipped",
+		reason: 'no plugin contributes the background target "retired"',
+	});
+	await stop();
+});

package/examples/support-desk.ts

@@ -0,0 +1,40 @@
+import { type BackgroundTarget, definePlugin } from "pi-roundtable";
+
+/**
+ * Whose turn a schedule or a delegated task asks for. The target sets what may be scheduled or
+ * delegated for it, so a desk open to many people is held tighter than the owner's own agent.
+ */
+const SUPPORT: BackgroundTarget = {
+	name: "support",
+	label: () => "Support desk",
+	schedules: { perChannel: 3, promptChars: 500, aheadDays: 30 },
+	delegation: { maxRunning: 1 },
+};
+
+/**
+ * A plugin that answers the turns nobody wrote in its channels. The router skips a turn whose
+ * target no plugin contributes, and this claim skips the targets it does not serve, so another
+ * target's schedule never runs here.
+ */
+export const supportDesk = definePlugin({
+	name: "support-desk",
+	setup: () => ({
+		backgroundTargets: [SUPPORT],
+		channels: [
+			{
+				name: "support-desks",
+				priority: 10,
+				owns: (channel) => channel.startsWith("support:"),
+				admit: () => undefined,
+				background: async (turn) =>
+					turn.target === SUPPORT.name
+						? { status: "ran" }
+						: {
+								status: "skipped",
+								reason: `the support desk does not serve "${turn.target}"`,
+							},
+				startFresh: async () => "support",
+			},
+		],
+	}),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable",
-	"version": "0.1.0",
+	"version": "0.2.1",
 	"description": "A plugin-driven Pi agent server for Discord",
 	"type": "module",
 	"license": "MIT",
@@ -9,18 +9,25 @@
 	},
 	"exports": {
 		".": "./src/index.ts",
-		"./testing": "./src/testing.ts"
+		"./testing": "./src/testing.ts",
+		"./kit": "./src/kit/index.ts",
+		"./discord": "./src/discord/index.ts"
 	},
 	"bin": {
-		"roundtable": "./src/cli/roundtable.mjs"
+		"roundtable": "src/cli/roundtable.mjs"
 	},
 	"files": [
 		"src",
+		"!src/**/*.test.ts",
+		"!src/core/testing/file-size.ts",
+		"!src/cli/testing",
 		"templates",
 		"docs",
 		"examples",
+		"!examples/guide.test.ts",
 		"LICENSE",
 		"README.md",
+		"README.zh-TW.md",
 		"CHANGELOG.md"
 	],
 	"repository": {
@@ -43,6 +50,7 @@
 		"canvas": "3.2.3",
 		"discord.js": "14.27.0",
 		"pi-mcp-adapter": "2.37.0",
+		"pi-web-access": "0.35.0",
 		"pino": "10.3.1",
 		"typebox": "1.3.34",
 		"unpdf": "1.8.1"

package/src/cli/checks/database.ts

@@ -1,7 +1,6 @@
-import type { SQL, TransactionSQL } from "bun";
-import type { Migration } from "../../core/db/migrations.ts";
-import { migrate, openPool } from "../../core/db/migrations.ts";
+import { nested, openPool, runMigrations } from "../../core/db/migrations.ts";
 import { MigrationError } from "../../core/errors.ts";
+import type { RoundtablePlugin } from "../../core/plugin.ts";
 import type { Project } from "../project.ts";
 import { fail, ok, type Result, skipped } from "../report.ts";
 
@@ -9,42 +8,28 @@ import { fail, ok, type Result, skipped } from "../report.ts";
 export interface DatabasePort {
 	check(
 		url: string,
-		migrations: readonly Migration[] | undefined,
+		plugins:
+			| readonly Pick<RoundtablePlugin, "name" | "migrations">[]
+			| undefined,
 	): Promise<void>;
 }
 
 class Rollback extends Error {}
 
-/**
- * The transaction as a migration sees the pool: a migration that opens its own transaction
- * with `begin` gets a savepoint of the checking one, which PostgreSQL nests.
- */
-function nested(transaction: TransactionSQL): SQL {
-	return new Proxy(transaction, {
-		get(target, property) {
-			if (property === "begin")
-				return (...args: Parameters<TransactionSQL["savepoint"]>) =>
-					target.savepoint(...args);
-			const value: unknown = Reflect.get(target, property);
-			return typeof value === "function" ? value.bind(target) : value;
-		},
-	});
-}
-
 /**
  * The real port. The migrations run inside a transaction that is always rolled back: DDL in
  * PostgreSQL is transactional, so what the check proves it runs is exactly what the host runs,
  * and the database is left as it was.
  */
 export const postgres: DatabasePort = {
-	async check(url, migrations) {
+	async check(url, plugins) {
 		const pool = openPool(url);
 		try {
 			await pool`select 1`;
-			if (!migrations) return;
+			if (!plugins) return;
 			try {
 				await pool.begin(async (transaction) => {
-					await migrate(nested(transaction), migrations);
+					await runMigrations(nested(transaction), plugins);
 					throw new Rollback();
 				});
 			} catch (error) {
@@ -74,13 +59,9 @@ export async function checkDatabase(
 	const url = await project.text("database", "url");
 	if (!url) return skipped("database.url has no value");
 	const assembled = await project.assembled();
-	const migrations = assembled.ok
-		? assembled.value.defined.plugins.flatMap(
-				(plugin) => plugin.migrations ?? [],
-			)
-		: undefined;
+	const plugins = assembled.ok ? assembled.value.defined.plugins : undefined;
 	try {
-		await port.check(url, migrations);
+		await port.check(url, plugins);
 	} catch (error) {
 		if (error instanceof MigrationError)
 			return fail(
@@ -93,7 +74,7 @@ export async function checkDatabase(
 		);
 	}
 	return ok(
-		migrations
+		plugins
 			? `${where(url)} answers and the migrations run`
 			: `${where(url)} answers; migrations are checked once the configuration is valid`,
 	);

package/src/cli/checks/images.ts

@@ -0,0 +1,19 @@
+import { fillsImages } from "../../core/registry/providers.ts";
+import type { Project } from "../project.ts";
+import { ok, type Result } from "../report.ts";
+
+/** The guide ships in the package, so the path is readable offline. */
+const GUIDE =
+	"node_modules/pi-roundtable/docs/plugins.md#providers-replace-a-part-the-core-runs-on";
+
+/** Whether a plugin fills the `images` slot. Not having one is a choice, not a failure: agents get generated avatars. */
+export async function checkImageProvider(project: Project): Promise<Result> {
+	const assembled = await project.assembled();
+	if (!assembled.ok)
+		return { status: "skipped", reason: "the configuration is not valid yet" };
+	return fillsImages(assembled.value.defined.plugins)
+		? ok("a plugin fills the images slot; agents' avatars are drawn")
+		: ok(
+				`none; agents use avatars generated from their display names. To have them drawn, fill the images slot, as the plugin guide shows: ${GUIDE}`,
+			);
+}

package/src/cli/doctor.ts

@@ -9,6 +9,7 @@ import {
 	Discord,
 } from "./checks/discord.ts";
 import { checkEnvironment } from "./checks/environment.ts";
+import { checkImageProvider } from "./checks/images.ts";
 import { checkModelLogin } from "./checks/model.ts";
 import { checkPublicUrl } from "./checks/public-url.ts";
 import type { Http } from "./http.ts";
@@ -51,6 +52,11 @@ export function buildChecks(
 			run: () => checkConfiguration(project),
 		},
 		{ name: "plugins", offline: true, run: () => checkPlugins(project) },
+		{
+			name: "image provider",
+			offline: true,
+			run: () => checkImageProvider(project),
+		},
 		{
 			name: "PostgreSQL",
 			offline: false,

package/src/cli/main.ts

@@ -8,6 +8,7 @@ runCli(process.argv.slice(2), processEnvironment()).then(
 	},
 	(error: unknown) => {
 		console.error(error instanceof Error ? error.message : String(error));
-		process.exitCode = 1;
+		// A boot that failed has stopped what it started; nothing may keep the process up.
+		process.exit(1);
 	},
 );

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

@@ -1,32 +1,51 @@
 import { attachmentsOf } from "../attachments/turn-attachments.ts";
 import type {
 	Admission,
+	BackgroundTarget,
 	ChannelClaim,
 	InboundMessage,
 } from "../contract/channels.ts";
+import type { AgentRuntime } from "../contract/runtime.ts";
+import type { SurfacePort } from "../contract/surface.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
-import type { AgentRuntime, ChatSurface } from "../domain/ports.ts";
+import { messages } from "../i18n/index.ts";
 import type { OwnerIdentity } from "../identity.ts";
 import type { Logger } from "../log.ts";
 import { withReference } from "../routing/message-text.ts";
 import { outcome } from "../routing/settle-turn.ts";
 import { addressee, attributed, type SpeakerPolicy } from "../speakers.ts";
-import type { AgentTeam } from "./agent-team.ts";
+import type { DiscordAgentTeam } from "./agent-team.ts";
+import { discordIdOf } from "./team-keys.ts";
 
 /**
- * The agent server outranks every other claim, and its guild's other channels stay silent even
- * when party mode or a mention would answer there. It becomes the core's reserved branch once
- * the team moves into the core (pi-roundtable batch 7).
+ * The agent server outranks every other claim on the Discord channels it owns, and its guild's
+ * other channels stay silent even when another plugin's mode or a mention would answer there; a claim of a
+ * plugin must use a higher priority to answer in that guild. It owns no channel of another
+ * surface. It becomes the core's reserved branch once the team moves into the core
+ * (pi-roundtable batch 7).
  */
 export const AGENT_SERVER_PRIORITY = 100;
 
+/**
+ * The host's own background target: the conversations of the owner and of the agent server. The
+ * agent server contributes it, so schedules and delegated tasks made in those conversations carry
+ * its name and limits. Its label is read when a list is shown, never when this module loads,
+ * because the host applies its catalog at startup.
+ */
+export const OWNER_TARGET: BackgroundTarget = {
+	name: "owner",
+	label: () => messages().scheduleModeOwner,
+	schedules: { perChannel: 20, promptChars: 8_000, aheadDays: 366 },
+	delegation: { maxRunning: 3 },
+};
+
 export interface AgentClaimOptions {
 	/** The owner, as forwarded messages name them. */
 	owner: OwnerIdentity;
 	/** Who may talk to the agents, and at which tier. */
 	speakers: SpeakerPolicy;
 	team: Pick<
-		AgentTeam,
+		DiscordAgentTeam,
 		| "guildId"
 		| "owns"
 		| "answerOwner"
@@ -34,8 +53,8 @@ export interface AgentClaimOptions {
 		| "answerBackground"
 		| "startFresh"
 	>;
-	runtime: Pick<AgentRuntime, "steer">;
-	surface: Pick<ChatSurface, "react" | "unreact">;
+	runtime: Pick<AgentRuntime, "steer" | "stop">;
+	surface: Pick<SurfacePort, "react" | "unreact">;
 	/** Where a channel's attachments are saved. */
 	attachmentDir: (channel: ChannelKey) => string;
 	logger: Logger;
@@ -61,7 +80,7 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 			kind: "background",
 			turn: {
 				channel: message.channel,
-				mode: "owner",
+				target: OWNER_TARGET.name,
 				author: { id: message.authorId, name: message.authorName },
 				turnId: `webhook-${message.messageId}`,
 				text: `Webhook "${message.authorName}" posted in your channel:\n${text}`,
@@ -71,7 +90,7 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 				logger.warn(
 					{
 						channel: message.channel,
-						webhook: message.webhookId,
+						webhook: message.integration?.id,
 						outcome: result,
 					},
 					"webhook post not answered",
@@ -82,14 +101,16 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 	return {
 		name: "agent-server",
 		priority: AGENT_SERVER_PRIORITY,
-		owns: (channel, guildId) =>
-			team.owns(channel) !== undefined ||
-			(guildId !== undefined && guildId === team.guildId),
+		// Only Discord keys: another surface's channel is never the agent server's, whatever its id.
+		owns: (channel, space) =>
+			discordIdOf(channel) !== undefined &&
+			(team.owns(channel) !== undefined ||
+				(space !== undefined && space === team.guildId)),
 		admit: (message) => {
 			const owned = team.owns(message.channel);
 			// The agent server's other channels are the owner's notes: nothing there is answered.
 			if (!owned) return undefined;
-			if (owned === "agent" && message.webhookId && !message.ownWebhook)
+			if (owned === "agent" && message.integration && !message.integration.own)
 				return webhookReport(message);
 			if (message.authorIsBot) return undefined;
 			const speaker = speakers.resolve({
@@ -144,8 +165,12 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 			};
 		},
 		background: async (turn) => {
-			if (turn.mode === "party")
-				return { status: "skipped", reason: "party mode is off" };
+			// Fail closed: a turn for any target but the owner's never reaches the owner's tools.
+			if (turn.target !== OWNER_TARGET.name)
+				return {
+					status: "skipped",
+					reason: `the agent server answers only "${OWNER_TARGET.name}" background turns`,
+				};
 			const owned = team.owns(turn.channel);
 			if (owned === "group")
 				return { status: "skipped", reason: "groups have no schedules" };
@@ -162,6 +187,7 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 				),
 			);
 		},
+		stop: (channel) => runtime.stop(channel),
 		startFresh: async (channel) => {
 			await team.startFresh(channel);
 			return "agent";

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

@@ -12,7 +12,7 @@ import {
 	returnedAnswerPost,
 } from "./agent-prompt.ts";
 import type { Agent } from "./agent-store.ts";
-import { channelKey, homeScope } from "./team-keys.ts";
+import { discordKey, homeScope } from "./team-keys.ts";
 import {
 	type Chain,
 	type Exchange,
@@ -47,7 +47,7 @@ export class AgentMessages {
 				chainLimitReason(addressee(chain.speaker, this.#host.options.owner)),
 			);
 		chain.messages += 1;
-		const targetChannel = channelKey(target.channelId);
+		const targetChannel = discordKey(target.channelId);
 		const exchange = this.#openExchange(caller, sender, target, text);
 		void queue
 			.run(targetChannel, async () =>
@@ -121,7 +121,7 @@ export class AgentMessages {
 		exchange: Exchange | undefined,
 	): Promise<void> {
 		const { queue, logger } = this.#host.options;
-		const targetChannel = channelKey(target.channelId ?? "");
+		const targetChannel = discordKey(target.channelId ?? "");
 		await this.#host.post(targetChannel, this.#host.current(sender), {
 			chunks: splitReply(
 				deliveredMessagePost(this.#host.current(target), text),
@@ -143,7 +143,7 @@ export class AgentMessages {
 			await thread.close(messages().agentNoReply(result.error.message));
 		const current = this.#host.options.store.agent(sender.name);
 		if (current?.status !== "active" || !current.channelId) return;
-		const senderChannel = channelKey(current.channelId);
+		const senderChannel = discordKey(current.channelId);
 		// With a thread the answer goes there, leaving the sender's channel its own reply.
 		if (result.ok)
 			await this.#host

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

@@ -1,19 +1,13 @@
-import type {
-	ChannelKey,
-	PendingConfirmation,
-	TurnResult,
-} from "../domain/conversation.ts";
-import type { TurnRequest } from "../domain/ports.ts";
+import type { AgentRuntime, ContextUse } from "../contract/runtime.ts";
 import type { ThinkingSetting } from "../models.ts";
 
-/** The part of the Pi runtime the agent team drives. */
-export interface AgentTurnRunner {
-	runTurn(request: TurnRequest): Promise<TurnResult>;
-	heldActions(session: ChannelKey): Promise<PendingConfirmation | undefined>;
-	startFresh(session: ChannelKey): Promise<void>;
-	/** Undefined until the conversation has run a turn since startup. */
-	contextUsage(session: ChannelKey): ContextUse | undefined;
-}
+export type { ContextUse };
+
+/** The part of the runtime the agent team drives. */
+export type AgentTurnRunner = Pick<
+	AgentRuntime,
+	"runTurn" | "heldActions" | "startFresh" | "contextUsage"
+>;
 
 /** One agent's message in a channel, posted under its name and avatar. */
 export interface AgentPost {
@@ -82,13 +76,6 @@ export interface AgentChannels {
 	): Promise<ChannelMessage[]>;
 }
 
-/** A conversation's context use after its latest turn, as Pi estimates it. */
-export interface ContextUse {
-	/** Null right after a compaction, until the next model response. */
-	tokens: number | null;
-	contextWindow: number;
-}
-
 /** The dashboard channel's one pinned message, made when missing and edited in place. */
 export interface DashboardBoard {
 	show(sections: string[]): Promise<void>;

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

@@ -21,6 +21,8 @@ export function agentSystemPrompt(input: {
 	group?: { group: AgentGroup; members: readonly Agent[] };
 	/** Who the turn is for; without one, or the owner, the prompt speaks to the owner. */
 	speaker?: Speaker;
+	/** Whether agents can redraw avatars; false without an image provider. Default true. */
+	avatars?: boolean;
 }): string {
 	const { agent, coordinator, shared, workDir, owner, shellUser, group } =
 		input;
@@ -32,7 +34,7 @@ export function agentSystemPrompt(input: {
 		(guest && input.guestShared) || shared,
 		`You are "${agent.displayName}" (agent name \`${agent.name}\`), one of ${o.name}'s agents in ${o.his} Discord agent server. Each agent owns one channel and one conversation; you all share ${o.his} tools and ${o.his} memory.`,
 		roleText(agent, coordinator, who),
-		`The team: agent_list shows every agent and group; agent_get and agent_update read and improve any agent's prompt, display name, model, and thinking level, yours included; agent_create adds an agent with its own channel; agent_avatar redraws an avatar; schedule_list with agent reads another agent's schedules. A message marked as coming from another agent is that agent speaking, not ${w.name}; only ${w.name} approves held actions.`,
+		`The team: agent_list shows every agent and group; agent_get and agent_update read and improve any agent's prompt, display name, model, and thinking level, yours included; agent_create adds an agent with its own channel; ${input.avatars === false ? "" : "agent_avatar redraws an avatar; "}schedule_list with agent reads another agent's schedules. A message marked as coming from another agent is that agent speaking, not ${w.name}; only ${w.name} approves held actions.`,
 		`Your shell and file tools run on ${o.his} VPS as the user ${shellUser}, in the shared workspace ${workDir}. Commands that are destructive or change the system, and writes outside the workspace, are held for ${w.his} confirmation: tell ${w.him} exactly what will run and ask ${w.him} to confirm.`,
 	];
 	if (group) {