pi-roundtable 0.26.0 → 0.26.2

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

@@ -15,6 +15,7 @@ import type {
 } from "../domain/conversation.ts";
 import { AgentRunError } from "../domain/errors.ts";
 import type { TurnRequest } from "../domain/ports.ts";
+import type { IdentityService } from "../identity/identity-port.ts";
 import { silentLogger } from "../log.ts";
 import { StoredSkillRegistry as SkillRegistry } from "../modules/skills/skill-registry.ts";
 import { SkillStore } from "../modules/skills/skill-store.ts";
@@ -37,12 +38,12 @@ import type {
 	CategoryLayout,
 	ChannelMessage,
 } from "./agent-ports.ts";
-import type { AgentSeed } from "./agent-rules.ts";
 import { PgAgentStore as AgentStore } from "./agent-store.ts";
 import {
 	DiscordAgentTeam as AgentTeam,
 	type AgentTeamOptions,
 } from "./agent-team.ts";
+import { seeds } from "./agent-team-seeds.ts";
 import { discordKey } from "./team-keys.ts";
 
 export const ENTRY = "1000";
@@ -261,6 +262,7 @@ export const script: {
 };
 let queue: ChannelQueue;
 let team: AgentTeam;
+let build: () => AgentTeam;
 let skillStore: TestStore<SkillStore>;
 let skills: SkillRegistry;
 export const removedSchedules: number[] = [];
@@ -271,34 +273,6 @@ export const eventLog: string[] = [];
 /** What a plugin adds to every agent's tools: a tool of its own and a group of another server's. */
 const PLUGIN_SELECTION = { tools: ["memory_add"], groups: ["workspace"] };
 
-/** The team a fresh database starts with: a coordinator in the entry channel, then two specialists. */
-function seeds(entryChannelId: string | undefined): AgentSeed[] {
-	return [
-		{
-			name: "coordinator",
-			displayName: "Coordinator",
-			...(entryChannelId ? { channelId: entryChannelId } : {}),
-			prompt:
-				"You are the chief of staff of the owner's agent team. You hand work that belongs to a specialist to that agent with message_agent, one owner per task, and propose a new agent when a lasting responsibility has no owner.",
-			character: { class: "navigator", palette: "amber" },
-		},
-		{
-			name: "doctor",
-			displayName: "Doctor",
-			prompt:
-				"You keep the owner's agents healthy: read an agent's prompt with agent_get, find the instruction that caused a misbehavior, and fix it with agent_update.",
-			character: { class: "healer", palette: "rose" },
-		},
-		{
-			name: "infra",
-			displayName: "Infra",
-			prompt:
-				"You manage the owner's servers. Check before you change: read state first, state what you will change and why, then act.",
-			character: { class: "engineer", palette: "purpure" },
-		},
-	];
-}
-
 /**
  * Waits until every queued channel task has settled and every active agent has its avatar,
  * which startup draws in the background; a fixed sleep was too short on a slow runner.
@@ -337,6 +311,8 @@ export function useTeamFixture(
 			"agent_groups",
 			"agent_group_messages",
 			"agent_group_cursors",
+			"agent_outbox",
+			"agent_latest_conversation",
 			"prompt_history",
 			"skills",
 			"skill_versions",
@@ -381,68 +357,72 @@ export function useTeamFixture(
 		script.guest = "";
 		queue = channelQueue();
 		removedSchedules.length = 0;
+		identity.current = undefined;
 		stops.length = 0;
 		eventLog.length = 0;
-		team = new AgentTeam({
-			owner: TEST_OWNER,
-			toolTiers: FIXTURE_TIERS,
-			shellUser: "mcops",
-			guildId: local ? "local" : "1",
-			...(local
-				? { coordinator: "coordinator" }
-				: { entryChannelId: ENTRY, channels }),
-			seeds: () => seeds(local ? undefined : ENTRY),
-			store,
-			surfaces,
-			studio: options.studio?.() ?? {
-				url: (hash) => `https://x/avatars/${hash ?? "default"}.png`,
-				render: async (spec) =>
-					new Bun.CryptoHasher("sha256")
-						.update(JSON.stringify(spec))
-						.digest("hex"),
-				draw: async () => "a".repeat(64),
-				edit: async () => "b".repeat(64),
-			},
-			runtime: () => runtime,
-			pluginSelection: () => PLUGIN_SELECTION,
-			confirmations: { approves: async (_p, reply) => reply.includes("yes") },
-			scorer: { score: async () => script.scores },
-			events: {
-				turnStarted: (turn) => eventLog.push(`turnStarted ${turn.agent}`),
-				turnEnded: (turn) =>
-					eventLog.push(`turnEnded ${turn.agent} ${turn.result}`),
-				changed: () => eventLog.push("changed"),
-			},
-			promptSections: () => script.prompt,
-			pluginTools: () => script.tools,
-			models: {
-				defaults: {
-					model: "claude-bridge/claude-opus-5-5",
-					thinking: "medium",
+		build = () =>
+			new AgentTeam({
+				owner: TEST_OWNER,
+				toolTiers: FIXTURE_TIERS,
+				principals: () => identity.current,
+				shellUser: "mcops",
+				guildId: local ? "local" : "1",
+				...(local
+					? { coordinator: "coordinator" }
+					: { entryChannelId: ENTRY, channels }),
+				seeds: () => seeds(local ? undefined : ENTRY),
+				store,
+				surfaces,
+				studio: options.studio?.() ?? {
+					url: (hash) => `https://x/avatars/${hash ?? "default"}.png`,
+					render: async (spec) =>
+						new Bun.CryptoHasher("sha256")
+							.update(JSON.stringify(spec))
+							.digest("hex"),
+					draw: async () => "a".repeat(64),
+					edit: async () => "b".repeat(64),
 				},
-				usable: async () => USABLE,
-			},
-			schedules: {
-				forChannel: async (channel) =>
-					channel === discordKey("2000")
-						? [{ id: 7 }]
-						: channel === "app:agent.doctor"
-							? [{ id: 8 }]
-							: [],
-				remove: async (id) => removedSchedules.push(id),
-			},
-			queue,
-			startTyping: () => () => undefined,
-			showStop: (channel) => {
-				stops.push(`show ${channel}`);
-				return () => stops.push(`hide ${channel}`);
-			},
-			workDir: "/tmp/agents/work",
-			sharedPrompt: () => script.shared,
-			guestPrompt: () => script.guest,
-			skills,
-			logger: silentLogger(),
-		});
+				runtime: () => runtime,
+				pluginSelection: () => PLUGIN_SELECTION,
+				confirmations: { approves: async (_p, reply) => reply.includes("yes") },
+				scorer: { score: async () => script.scores },
+				events: {
+					turnStarted: (turn) => eventLog.push(`turnStarted ${turn.agent}`),
+					turnEnded: (turn) =>
+						eventLog.push(`turnEnded ${turn.agent} ${turn.result}`),
+					changed: () => eventLog.push("changed"),
+				},
+				promptSections: () => script.prompt,
+				pluginTools: () => script.tools,
+				models: {
+					defaults: {
+						model: "claude-bridge/claude-opus-5-5",
+						thinking: "medium",
+					},
+					usable: async () => USABLE,
+				},
+				schedules: {
+					forChannel: async (channel) =>
+						channel === discordKey("2000")
+							? [{ id: 7 }]
+							: channel === "app:agent.doctor"
+								? [{ id: 8 }]
+								: [],
+					remove: async (id) => removedSchedules.push(id),
+				},
+				queue,
+				startTyping: () => () => undefined,
+				showStop: (channel) => {
+					stops.push(`show ${channel}`);
+					return () => stops.push(`hide ${channel}`);
+				},
+				workDir: "/tmp/agents/work",
+				sharedPrompt: () => script.shared,
+				guestPrompt: () => script.guest,
+				skills,
+				logger: silentLogger(),
+			});
+		team = build();
 		await team.start();
 		Object.assign(fx, {
 			store,
@@ -458,6 +438,19 @@ export function useTeamFixture(
 	}, HOOK_TIMEOUT_MS);
 }
 
+/** Starts the team again over the same database, as a restarted host: a new queue, runtime and team. */
+/** The identity service the team's replay asks; none until a test sets one. */
+export const identity: { current?: Pick<IdentityService, "speakerFor"> } = {};
+
+export async function restart(): Promise<void> {
+	queue = channelQueue();
+	runtime = new FakeRuntime();
+	team = build();
+	await team.start();
+	Object.assign(fx, { queue, runtime, team });
+	await settle();
+}
+
 export const opsGroup = () => {
 	const group = store.group("ops");
 	if (!group) throw new Error("no ops group");

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

@@ -0,0 +1,29 @@
+import type { AgentSeed } from "./agent-rules.ts";
+
+/** The team a fresh database starts with: a coordinator in the entry channel, then two specialists. */
+export function seeds(entryChannelId: string | undefined): AgentSeed[] {
+	return [
+		{
+			name: "coordinator",
+			displayName: "Coordinator",
+			...(entryChannelId ? { channelId: entryChannelId } : {}),
+			prompt:
+				"You are the chief of staff of the owner's agent team. You hand work that belongs to a specialist to that agent with message_agent, one owner per task, and propose a new agent when a lasting responsibility has no owner.",
+			character: { class: "navigator", palette: "amber" },
+		},
+		{
+			name: "doctor",
+			displayName: "Doctor",
+			prompt:
+				"You keep the owner's agents healthy: read an agent's prompt with agent_get, find the instruction that caused a misbehavior, and fix it with agent_update.",
+			character: { class: "healer", palette: "rose" },
+		},
+		{
+			name: "infra",
+			displayName: "Infra",
+			prompt:
+				"You manage the owner's servers. Check before you change: read state first, state what you will change and why, then act.",
+			character: { class: "engineer", palette: "purpure" },
+		},
+	];
+}

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

@@ -10,7 +10,7 @@ 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 } from "./agent-prompt.ts";
+import { agentSystemPrompt, placeOf } from "./agent-prompt.ts";
 import type { Agent } from "./agent-store.ts";
 import {
 	type AgentOps,
@@ -150,6 +150,8 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 			shellUser,
 			scratchDir,
 			agentTools,
+			surfaces,
+			channels,
 		} = this.#options;
 		const agent = store.agent(scope.name);
 		if (!agent) throw new AgentError(`no agent ${scope.name}`);
@@ -172,6 +174,7 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 			...(scratchDir ? { scratchDir } : {}),
 			images: this.#images(),
 			...(agentTools ? { agentTools } : {}),
+			...placeOf(this.#turns.turnChannel(scope), surfaces, !!channels),
 			...(group
 				? {
 						group: {
@@ -264,7 +267,12 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 	 * character in the background.
 	 */
 	start(): Promise<void> {
-		return this.#lifecycle.start();
+		return this.#lifecycle.start().then(() => this.#turns.replayMessages());
+	}
+
+	/** What the team still writes that a shutdown must wait for. */
+	busy(): string[] {
+		return this.#turns.busy();
 	}
 
 	/** Ends the background work the team started. */
@@ -299,10 +307,7 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 
 	// ── Turns, run by TeamTurns ────────────────────────────────────────────
 
-	/**
-	 * The owner's message in an agent's channel; call inside the channel's queue. `text`
-	 * carries the reference, `replyText` is what they typed.
-	 */
+	/** The owner's message in an agent's channel; call inside its queue. `text` has the reference, `replyText` what they typed. */
 	answerOwner(
 		channel: ChannelKey,
 		speaker: Speaker,
@@ -321,15 +326,12 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 
 	/**
 	 * A schedule's or a report's turn in an agent's channel; call inside its queue. A report's
-	 * turn is interactive: it may ask the owner on cards.
+	 * turn is interactive: it may ask the owner on cards. `timeLimitMs` is a schedule's own limit.
 	 */
 	answerBackground(
-		channel: ChannelKey,
-		speaker: Speaker,
-		text: string,
-		interactive = false,
+		...args: Parameters<TeamTurns["answerBackground"]>
 	): Promise<TurnResult> {
-		return this.#turns.answerBackground(channel, speaker, text, interactive);
+		return this.#turns.answerBackground(...args);
 	}
 
 	/** One owner message in a group channel, answered by a round of members; call inside the queue. */
@@ -366,8 +368,8 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 		return this.#turns.announce(text);
 	}
 
-	message(caller: AgentTurnScope, to: string, text: string): string {
-		return this.#turns.message(caller, to, text);
+	message(...args: Parameters<TeamTurns["message"]>): string {
+		return this.#turns.message(...args);
 	}
 
 	async read(
@@ -430,6 +432,7 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 			agent,
 			models.defaults,
 			skills?.describeCarried(agent.name),
+			store.conversations.mark(agent.name, this.roomsOf(name)),
 		);
 	}
 

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

@@ -79,12 +79,23 @@ export interface AgentOps {
 			task: string;
 			category?: string;
 			skills?: string[];
+			/** Turn long-running mode on for its conversations; an owner's turn only. */
+			longRunning?: boolean;
 		},
 	): 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. */
-	message(caller: AgentTurnScope, to: string, text: string): string;
+	/**
+	 * Hands a request to another agent, in the conversation it used most recently, or in the
+	 * `conversation` named: "discord", "web" (or a room surface's name), or one of its conversation keys.
+	 */
+	message(
+		caller: AgentTurnScope,
+		to: string,
+		text: string,
+		conversation?: string,
+	): string;
 	createGroup(input: {
 		name: string;
 		displayName: string;
@@ -112,7 +123,7 @@ const NAME = Type.String({
 const DISPLAY = Type.String({
 	minLength: 1,
 	maxLength: 32,
-	description: "The name shown on its Discord messages; any language.",
+	description: "The name shown on its messages; any language.",
 });
 const PROMPT = Type.String({
 	minLength: 1,
@@ -263,7 +274,7 @@ function toolDefs(
 			name: "agent_create",
 			label: "Create agent",
 			description:
-				"Create a new agent with its own channel and a character picture; its look follows its role unless class and color are given. It starts at once on the opening task in its channel. Its name is permanent.",
+				"Create a new agent with its own channel and a character picture; its look follows its role unless class and color are given. It starts at once on the opening task in its channel, which is stopped after 10 minutes unless long_running is set. Its name is permanent.",
 			parameters: Type.Object({
 				name: Type.String({
 					pattern: "^[a-z0-9-]{1,32}$",
@@ -280,6 +291,11 @@ function toolDefs(
 					description: "Its opening task, self-contained.",
 				}),
 				category: Type.Optional(category("Agents")),
+				long_running: Type.Optional(
+					Type.Boolean({
+						description: `Turn on long-running mode for its conversations: its turns, such as the opening task, go on past the usual 10-minute limit by themselves, up to the host's cap (four hours by default). Set it for an agent whose tasks run long, such as research or large changes.`,
+					}),
+				),
 				...(skillsOn
 					? {
 							skills: Type.Optional(
@@ -295,6 +311,7 @@ function toolDefs(
 				const category = optionalString(i, "category");
 				const skills = stringList(i, "skills");
 				const look = lookOf(i);
+				const longRunning = i.long_running === true;
 				return ops.create(scope, {
 					name: requiredString(i, "name"),
 					displayName: requiredString(i, "display_name"),
@@ -303,6 +320,7 @@ function toolDefs(
 					task: requiredString(i, "task"),
 					...(category ? { category } : {}),
 					...(skills && skills.length > 0 ? { skills } : {}),
+					...(longRunning ? { longRunning } : {}),
 				});
 			},
 		},
@@ -442,13 +460,24 @@ function toolDefs(
 			name: MESSAGE_AGENT_TOOL,
 			label: "Message agent",
 			description:
-				"Send a self-contained request to another agent. It returns at once; the agent works in its own channel and its answer comes back to you as a new turn. Its channel shows the exchange, and so does a thread in your channel.",
+				'Send a self-contained request to another agent. It returns at once; the agent works in its own conversation and its answer comes back to you as a new turn, in the conversation you are writing from. An agent has one conversation on each surface (Discord, the web app); by default the request lands in the one it used most recently, so work it started in the web app is answered there. Give conversation to choose another: "discord", "web", or one of the conversation keys agent_get lists for it. The exchange shows in its conversation, and a thread in yours.',
 			parameters: Type.Object({
 				to: NAME,
 				text: Type.String({ minLength: 1, maxLength: 4000 }),
+				conversation: Type.Optional(
+					Type.String({
+						description:
+							'Which of the agent\'s conversations to deliver into: "discord", "web" (or the name of another surface that hosts rooms), or a key from agent_get. Leave it out to reach the one it used most recently.',
+					}),
+				),
 			}),
 			run: (i) =>
-				ops.message(scope, requiredString(i, "to"), requiredString(i, "text")),
+				ops.message(
+					scope,
+					requiredString(i, "to"),
+					requiredString(i, "text"),
+					optionalString(i, "conversation"),
+				),
 		});
 	return defs;
 }

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

@@ -118,7 +118,7 @@ export class GroupTurns {
 			if (backlog.lastId !== undefined)
 				await store.advanceCursor(log, name, backlog.lastId);
 			// Attachments and a confirmation belong to a member's first turn of the round only.
-			const extra: TurnExtra = { interactive: true };
+			const extra: TurnExtra = { interactive: true, byMessage: true };
 			if (first) {
 				extra.attachments = attachments;
 				if (approvals.get(name)) extra.confirmed = true;

package/src/core/agents/message-target.ts

@@ -0,0 +1,79 @@
+import type { ChannelKey } from "../domain/conversation.ts";
+import { AgentError } from "../domain/errors.ts";
+import type { AgentDirectory } from "../services.ts";
+import type { Agent } from "./agent-store.ts";
+import {
+	agentRoomKey,
+	discordIdOf,
+	discordKey,
+	keysOf,
+	roomSurfaceOf,
+} from "./team-keys.ts";
+
+/** What the choice of a message's conversation reads. */
+export interface MessageTargetContext {
+	store: Pick<AgentDirectory, "agent" | "group">;
+	/** The surfaces that host agent rooms. */
+	roomSurfaces: readonly string[];
+	/** The conversation the target last ran a turn in, if it ran one since the host started. */
+	latest: ChannelKey | undefined;
+	/** The conversation the sender writes from. */
+	from: ChannelKey;
+}
+
+/** The word for the web app's conversation, accepted when exactly one surface hosts rooms. */
+const WEB = "web";
+
+/**
+ * The conversation of `target` that a message is delivered into. With `ask` (a surface name such
+ * as "discord", "web", or the surface of a room, or one of the target's conversation keys) that
+ * one; otherwise the conversation the target used most recently, except that a message from a room
+ * never follows it out to Discord, and, when it has run none yet, the sender's own surface, so a message between rooms stays among the rooms.
+ */
+export function messageTarget(
+	ctx: MessageTargetContext,
+	target: Agent,
+	ask: string | undefined,
+): ChannelKey {
+	const keys = keysOf(ctx.store, target.name, ctx.roomSurfaces);
+	const has = keys.length > 0 ? keys.join(", ") : "none";
+	if (ask === undefined || ask.trim() === "") {
+		const via = roomSurfaceOf(ctx.from);
+		// From a room, never out to Discord: its content may be for the owners alone.
+		const outward =
+			via !== undefined &&
+			ctx.latest !== undefined &&
+			discordIdOf(ctx.latest) !== undefined;
+		if (ctx.latest !== undefined && keys.includes(ctx.latest) && !outward)
+			return ctx.latest;
+		if (via === undefined) {
+			if (!target.channelId)
+				throw new AgentError(`${target.name} has no channel yet.`);
+			return discordKey(target.channelId);
+		}
+		return agentRoomKey(via, target.name);
+	}
+	const wanted = ask.trim();
+	const exact = keys.find((key) => key === wanted);
+	if (exact !== undefined) return exact;
+	if (wanted === "discord") {
+		if (!target.channelId)
+			throw new AgentError(
+				`${target.name} has no Discord channel; its conversations: ${has}.`,
+			);
+		return discordKey(target.channelId);
+	}
+	const surface = ctx.roomSurfaces.includes(wanted)
+		? wanted
+		: wanted === WEB && ctx.roomSurfaces.length === 1
+			? ctx.roomSurfaces[0]
+			: undefined;
+	if (surface !== undefined) return agentRoomKey(surface, target.name);
+	throw new AgentError(
+		`${target.name} has no conversation "${wanted}"; its conversations: ${has}. Give "discord", "web" (or the surface's name), or one of those keys.`,
+	);
+}
+
+/** How a conversation reads to the model that sent a message there: its surface and key. */
+export const conversationLabel = (key: ChannelKey): string =>
+	`${key.slice(0, key.indexOf(":"))} conversation (${key})`;

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

@@ -8,6 +8,8 @@ import {
 import { parseChannelKey } from "../contract/surface.ts";
 import { AgentError } from "../domain/errors.ts";
 import type { AgentTurnScope } from "../domain/ports.ts";
+import { SYSTEM_PRINCIPAL } from "../identity/principal-store.ts";
+import type { ConversationModes } from "../modes/conversation-modes.ts";
 import type { AgentChange } from "../services.ts";
 import { addressee, type Speaker } from "../speakers.ts";
 import { openingTaskText } from "./agent-prompt.ts";
@@ -95,6 +97,8 @@ export class TeamEditing {
 			task: string;
 			category?: string;
 			skills?: string[];
+			/** Turn long-running mode on for its conversations; the speaker must be an owner. */
+			longRunning?: boolean;
 		},
 	): Promise<string> {
 		this.#refuseSkillsOff(input.skills);
@@ -149,6 +153,23 @@ export class TeamEditing {
 		return made.agent;
 	}
 
+	/**
+	 * The modes to turn long-running on in, once the speaker may: an owner other than the host's
+	 * own turns, as for any change of a conversation's modes. Refused before anything is made.
+	 */
+	#longRunning(speaker: Speaker): ConversationModes {
+		const modes = this.#ctx.options.modes?.();
+		if (!modes)
+			throw new AgentError(
+				"This host has no conversation modes, so long_running cannot be set. Create the agent without it.",
+			);
+		if (speaker.tier !== "owner" || speaker.principalId === SYSTEM_PRINCIPAL)
+			throw new AgentError(
+				"Only an owner's turn may create an agent with long_running on. Create it without, and ask the owner to turn it on.",
+			);
+		return modes;
+	}
+
 	/** An agent cannot carry skills on a host with skills switched off. */
 	#refuseSkillsOff(carried: string[] | undefined): void {
 		if (carried && carried.length > 0 && !this.#ctx.options.skills)
@@ -175,6 +196,7 @@ export class TeamEditing {
 			task?: string;
 			category?: string;
 			skills?: string[];
+			longRunning?: boolean;
 		},
 		settings: {
 			model?: string | undefined;
@@ -190,8 +212,10 @@ export class TeamEditing {
 			character: wanted,
 			avatarPrompt: _ignored,
 			task,
+			longRunning,
 			...fields
 		} = input;
+		const modes = longRunning ? this.#longRunning(who.speaker) : undefined;
 		const parent = teamCategory(category, "Agents");
 		store.checkNewName(input.name);
 		skills?.checkRegistered(carried);
@@ -233,7 +257,12 @@ export class TeamEditing {
 			"agent created",
 		);
 		this.#ctx.changed();
-		const avatar = `its picture is the ${character.class} look`;
+		const rooms = surfaces?.roomSurfaces() ?? [];
+		// Before the opening task starts, so its turn already runs under the mode.
+		if (modes)
+			for (const key of keysOf(store, agent.name, rooms))
+				await modes.set(key, { longRunning: true }, who.speaker);
+		const avatar = `its picture is the ${character.class} look${modes ? "; long-running mode is on" : ""}`;
 		const where = channelId ? ` in <#${channelId}>` : "";
 		if (!task)
 			return {
@@ -242,7 +271,6 @@ export class TeamEditing {
 			};
 		// The opening task runs in the room of the surface that asked, else where the agent is first
 		// reached: its channel, else its first room.
-		const rooms = surfaces?.roomSurfaces() ?? [];
 		const home =
 			who.openIn !== undefined && rooms.includes(who.openIn)
 				? agentRoomKey(who.openIn, agent.name)

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

@@ -147,6 +147,13 @@ export function roomScope(agent: Agent, room: ChannelKey): AgentTurnScope {
 	return { name: agent.name, session: room, home: room };
 }
 
+/** The agent's own conversation in the channel: its Discord channel's, or its room's. */
+export function scopeOf(agent: Agent, channel: ChannelKey): AgentTurnScope {
+	return discordIdOf(channel) === undefined
+		? roomScope(agent, channel)
+		: homeScope(agent);
+}
+
 /**
  * An agent's conversation inside a group: in a Discord group channel, or without a room, as
  * before; in a room, the room's seat, whose home is the agent's own room on that surface.

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

@@ -1,5 +1,6 @@
 import type { ChannelKey } from "../domain/conversation.ts";
 import type { ThinkingSetting } from "../models.ts";
+import type { ConversationModes } from "../modes/conversation-modes.ts";
 import type { AgentTools, PromptSection } from "../plugin.ts";
 import type { AvatarStudio, SkillRegistry } from "../services.ts";
 import type { ToolSelection } from "../sessions.ts";
@@ -61,6 +62,8 @@ export interface AgentTeamOptions
 	guestPrompt?: string | (() => string);
 	/** The skill registry: what each agent carries. Absent when the skills addon is off. */
 	skills?: SkillRegistry;
+	/** The conversation modes, read when an agent is created with long-running on; none, none is set. */
+	modes?: () => ConversationModes | undefined;
 }
 
 /** What the team's collaborators share: its options, its turns, and its change signal. */

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

@@ -57,12 +57,16 @@ export function agentDetails(
 	agent: Agent,
 	defaults: { model: string; thinking: ThinkingSetting },
 	skills: string | undefined,
+	conversations: readonly string[] = [],
 ): string {
 	return [
 		`Name: ${agent.name}`,
 		`Display name: ${agent.displayName}`,
 		`Status: ${agent.status}`,
 		`Channel: ${agent.channelId ? `<#${agent.channelId}>` : "none"}`,
+		...(conversations.length === 0
+			? []
+			: [`Conversations: ${conversations.join(", ")}`]),
 		`Model: ${agent.model ?? `${assistantName()}'s (${defaults.model})`}`,
 		`Thinking: ${agent.thinking ?? `${assistantName()}'s (${describeThinking(defaults.thinking)})`}`,
 		...(skills === undefined ? [] : [`Skills: ${skills}`]),