pi-roundtable 0.26.3 → 0.27.0

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

@@ -17,7 +17,9 @@ import { characterOf, overBase } from "./agent-rules.ts";
 import { modelSetting, thinkingSetting } from "./agent-settings.ts";
 import type { Agent } from "./agent-store.ts";
 import type { AvatarMode } from "./agent-tools.ts";
-import { agentRoomKey, discordKey, keysOf, seatsOf } from "./team-keys.ts";
+import { createHelper } from "./helper-create.ts";
+import { routesOf } from "./routes.ts";
+import { agentRoomKey, keysOf, seatsOf } from "./team-keys.ts";
 import { groupTopic, teamCategory } from "./team-layout.ts";
 import type { TeamContext } from "./team-options.ts";
 
@@ -121,6 +123,39 @@ export class TeamEditing {
 		return made.text;
 	}
 
+	#helperChain: Promise<void> = Promise.resolve();
+
+	/** Closes the thread of a temp knight whose row was never written, logging a failure. */
+	async #closeOrphan(threadId?: string): Promise<void> {
+		const { channels, logger } = this.#ctx.options;
+		await channels
+			?.closeThread?.(threadId ?? "")
+			.catch((err: unknown) =>
+				logger.warn({ err }, "orphan thread not closed"),
+			);
+	}
+
+	/** The agent tool: a knight makes a temp knight for one task; see `createHelper`. */
+	createHelper(
+		caller: AgentTurnScope,
+		input: Parameters<typeof createHelper>[3],
+	): Promise<string> {
+		// One at a time: parallel calls cannot overshoot a cap or pick one name.
+		const run = this.#helperChain.then(() =>
+			createHelper(
+				this.#ctx,
+				(who, fields, settings) => this.#create(who, fields, settings),
+				caller,
+				input,
+			),
+		);
+		this.#helperChain = run.then(
+			() => undefined,
+			() => undefined,
+		);
+		return run;
+	}
+
 	/**
 	 * An owner creates an agent from outside any agent turn (the web app's form; any other tier is
 	 * refused, since the opening task runs as `speaker`): the same checks,
@@ -185,6 +220,10 @@ export class TeamEditing {
 			creator: Agent | undefined;
 			/** The surface whose room runs the opening task. */
 			openIn?: string | undefined;
+			/** Makes the agent a temp knight of this knight: its place is a thread of the parent's channel, and it settles on the parent's model. */
+			parent?: Agent | undefined;
+			/** The conversation a temp knight is made from. */
+			origin?: string | undefined;
 		},
 		input: {
 			name: string;
@@ -216,14 +255,21 @@ export class TeamEditing {
 			...fields
 		} = input;
 		const modes = longRunning ? this.#longRunning(who.speaker) : undefined;
-		const parent = teamCategory(category, "Agents");
+		const categoryName = teamCategory(category, "Agents");
 		store.checkNewName(input.name);
 		skills?.checkRegistered(carried);
 		// A model or thinking level the host cannot run fails the create, before anything is made.
-		const model = await modelSetting(settings.model, () =>
-			this.#ctx.options.models.usable(),
-		);
-		const thinking = thinkingSetting(settings.thinking);
+		// A temp knight runs the parent's, as it stands, unless told otherwise.
+		const model =
+			settings.model === undefined && who.parent
+				? who.parent.model
+				: await modelSetting(settings.model, () =>
+						this.#ctx.options.models.usable(),
+					);
+		const thinking =
+			settings.thinking === undefined && who.parent
+				? who.parent.thinking
+				: thinkingSetting(settings.thinking);
 		// The picture comes before the row and the channel: a render failure fails the create.
 		const taken = store
 			.agents()
@@ -233,25 +279,43 @@ export class TeamEditing {
 		const suggested = suggestCharacter(input, taken);
 		const character = this.#resolve(wanted ?? {}, suggested);
 		const avatarHash = await studio.render(character);
-		// Without Discord channels the agent lives in its rooms, which exist as soon as it does.
-		const channelId = await channels?.createChannel(
-			input.name,
-			input.displayName,
-			parent,
-		);
-		let agent = await store.createAgent({
-			...fields,
-			character,
-			avatarHash,
-			...(channelId ? { channelId } : {}),
-		});
-		if (model || thinking)
-			agent = await store.updateAgent(agent.name, {
-				...(model ? { model } : {}),
-				...(thinking ? { thinking } : {}),
+		// Without Discord channels the agent lives in its rooms, which exist as soon as it does. A
+		// temp knight lives in a thread of its parent's channel, or in rooms alone without one.
+		const channelId = who.parent
+			? who.parent.channelId && channels?.createThread
+				? await channels.createThread(who.parent.channelId, input.displayName)
+				: undefined
+			: await channels?.createChannel(
+					input.name,
+					input.displayName,
+					categoryName,
+				);
+		let agent: Agent;
+		try {
+			agent = await store.createAgent({
+				...fields,
+				character,
+				avatarHash,
+				...(channelId ? { channelId } : {}),
+				...(who.parent ? { parent: who.parent.name } : {}),
+				...(who.parent && who.origin ? { origin: who.origin } : {}),
 			});
-		if (skills && carried.length > 0)
-			await skills.attach(agent.name, carried, []);
+		} catch (error) {
+			await this.#closeOrphan(channelId);
+			throw error;
+		}
+		try {
+			if (model || thinking)
+				agent = await store.updateAgent(agent.name, {
+					...(model ? { model } : {}),
+					...(thinking ? { thinking } : {}),
+				});
+			if (skills && carried.length > 0)
+				await skills.attach(agent.name, carried, []);
+		} catch (error) {
+			if (who.parent) await this.#ctx.archiveHelpers([agent.name]);
+			throw error;
+		}
 		logger.info(
 			{ agent: agent.name, by: who.by, class: character.class },
 			"agent created",
@@ -269,14 +333,15 @@ export class TeamEditing {
 				agent,
 				text: `Created "${agent.displayName}" (${agent.name})${where}; ${avatar}.`,
 			};
-		// 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 home =
-			who.openIn !== undefined && rooms.includes(who.openIn)
-				? agentRoomKey(who.openIn, agent.name)
-				: channelId
-					? discordKey(channelId)
-					: keysOf(store, agent.name, rooms)[0];
+		// The opening task runs where the routing table puts it: by default the agent's place on the
+		// surface that asked, else its primary place.
+		const home = routesOf(this.#ctx.options).of(
+			agent.name,
+			"opening",
+			who.openIn === undefined
+				? undefined
+				: agentRoomKey(who.openIn, agent.name),
+		);
 		if (!home) {
 			logger.warn(
 				{ agent: agent.name },

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

@@ -0,0 +1,216 @@
+import { helpersOf } from "../config/helpers.ts";
+import { AgentError } from "../domain/errors.ts";
+import type { AgentTurnScope } from "../domain/ports.ts";
+import { isHelper } from "./agent-rules.ts";
+import type { Agent } from "./agent-store.ts";
+import type { HelpersEnded } from "./helper-ops.ts";
+import type { TeamContext } from "./team-options.ts";
+
+/** How often the host looks for finished temp knights past their keep. */
+const SWEEP_EVERY_MS = 3_600_000;
+
+/**
+ * The team's temp knights after they are made: which a knight has, which are finished, and their
+ * archive, restore, and sweep. Archiving one closes its Discord thread, since a temp knight's
+ * place is a thread of its parent's channel; an archived one keeps its history.
+ */
+export class TeamHelpers {
+	readonly #ctx: TeamContext;
+	/** Archives one agent as the team archives any: schedules, groups, conversations. */
+	readonly #archiveAgent: (agent: Agent) => Promise<void>;
+	readonly #ended: ((event: HelpersEnded) => void)[] = [];
+	#sweeper: ReturnType<typeof setInterval> | undefined;
+
+	constructor(ctx: TeamContext, archiveAgent: (agent: Agent) => Promise<void>) {
+		this.#ctx = ctx;
+		this.#archiveAgent = archiveAgent;
+	}
+
+	onEnded(listener: (event: HelpersEnded) => void): void {
+		this.#ended.push(listener);
+	}
+
+	/** The active temp knights a knight made. */
+	of(parent: string): Agent[] {
+		return this.#ctx.options.store.helpersOf(parent, "active");
+	}
+
+	/** The active temp knights that are finished, of the named parents or of every knight. */
+	finished(parents?: readonly string[]): Agent[] {
+		return this.#ctx.options.store
+			.agents()
+			.filter(
+				(agent) =>
+					isHelper(agent) &&
+					agent.status === "active" &&
+					agent.finishedAt !== undefined &&
+					(parents === undefined || parents.includes(agent.parent as string)),
+			);
+	}
+
+	/**
+	 * The agent tool: a knight archives its own temp knights, the named ones or every finished one.
+	 * Whoever shows the parent's room is told, to offer the undo.
+	 */
+	async end(
+		caller: AgentTurnScope,
+		names: readonly string[] | "finished",
+	): Promise<string> {
+		const mine = this.of(caller.name);
+		const wanted =
+			names === "finished"
+				? mine.filter((agent) => agent.finishedAt !== undefined)
+				: names.map((name) => {
+						const own = mine.find((agent) => agent.name === name);
+						if (!own)
+							throw new AgentError(
+								`"${name}" is not one of your temp knights; yours: ${mine.map((agent) => agent.name).join(", ") || "none"}.`,
+							);
+						return own;
+					});
+		if (wanted.length === 0)
+			return "None of your temp knights is finished yet, so none was archived.";
+		const archived = await this.archive(wanted.map((agent) => agent.name));
+		for (const listener of this.#ended)
+			listener({ parent: caller.name, names: archived });
+		return `Archived ${archived.length} temp knight${archived.length === 1 ? "" : "s"}: ${archived.join(", ")}. Their history stays readable, and the owner can restore them.`;
+	}
+
+	/**
+	 * Archives temp knights: each stops answering, keeps its history, and its Discord thread is
+	 * closed. Names that are no active temp knight are passed over. Says which were archived.
+	 */
+	async archive(names: readonly string[]): Promise<string[]> {
+		const { store } = this.#ctx.options;
+		const archived: string[] = [];
+		for (const name of new Set(names)) {
+			const agent = store.agent(name);
+			if (!agent || !isHelper(agent) || agent.status !== "active") continue;
+			await this.archiveOne(agent);
+			archived.push(name);
+		}
+		return archived;
+	}
+
+	/** Archives a temp knight and closes its thread, when it has one; a thread that will not close is logged. */
+	async archiveOne(agent: Agent): Promise<void> {
+		const { channels, logger } = this.#ctx.options;
+		await this.#archiveAgent(agent);
+		if (!agent.channelId || !channels?.closeThread) return;
+		try {
+			await channels.closeThread(agent.channelId);
+		} catch (error) {
+			logger.warn(
+				{ agent: agent.name, err: error },
+				"temp knight's thread not closed; it stays silent where it is",
+			);
+		}
+	}
+
+	/**
+	 * Returns archived temp knights to the active ones, each with its thread open again; a name that
+	 * is no archived temp knight of an active parent is passed over, so an undo after another
+	 * change restores only what is still there. Says which were restored.
+	 */
+	async restore(names: readonly string[]): Promise<string[]> {
+		const { store } = this.#ctx.options;
+		const restored: string[] = [];
+		for (const name of new Set(names)) {
+			const agent = store.agent(name);
+			if (!agent || !isHelper(agent) || agent.status !== "archived") continue;
+			if (store.agent(agent.parent as string)?.status !== "active") continue;
+			await this.restoreOne(agent);
+			restored.push(name);
+		}
+		return restored;
+	}
+
+	/**
+	 * Restores one archived temp knight: its thread opens again, or a new one is made when the old
+	 * is gone. It comes back finished, with nothing running.
+	 */
+	async restoreOne(agent: Agent): Promise<void> {
+		const { store, channels, logger } = this.#ctx.options;
+		const parent = store.agent(agent.parent as string);
+		if (parent?.status !== "active")
+			throw new AgentError(
+				`"${agent.name}" belongs to "${agent.parent}", which is archived; restore it first.`,
+			);
+		let { channelId } = agent;
+		if (channels?.createThread && parent.channelId) {
+			if (
+				channelId &&
+				channels.openThread &&
+				(await channels.exists(channelId))
+			)
+				await channels.openThread(channelId);
+			else
+				channelId = await channels.createThread(
+					parent.channelId,
+					agent.displayName,
+				);
+		}
+		await store.restoreAgent(agent.name, channelId);
+		logger.info(
+			{ name: agent.name, parent: parent.name },
+			"temp knight restored",
+		);
+		this.#ctx.changed();
+	}
+
+	/**
+	 * Stamps every temp knight still marked working as finished. Nothing runs when the team starts,
+	 * so one marked working was cut off by a stop or a crash and would hold its cap slot for good;
+	 * a replayed message makes it work again.
+	 */
+	async reconcile(): Promise<string[]> {
+		const { store } = this.#ctx.options;
+		const stale = store
+			.agents()
+			.filter(
+				(agent) =>
+					isHelper(agent) &&
+					agent.status === "active" &&
+					agent.finishedAt === undefined,
+			);
+		const stamped: string[] = [];
+		for (const agent of stale)
+			if (await store.setFinished(agent.name, true)) stamped.push(agent.name);
+		return stamped;
+	}
+
+	/** Archives the temp knights that have been finished for longer than the host keeps them. */
+	async sweepFinished(now: Date = new Date()): Promise<string[]> {
+		const limits = helpersOf(this.#ctx.options.helpers);
+		if (!limits || limits.archiveFinishedAfterHours === false) return [];
+		const cutoff = now.getTime() - limits.archiveFinishedAfterHours * 3_600_000;
+		const stale = this.finished()
+			.filter((agent) => (agent.finishedAt as Date).getTime() <= cutoff)
+			.map((agent) => agent.name);
+		if (stale.length === 0) return [];
+		const archived = await this.archive(stale);
+		this.#ctx.options.logger.info(
+			{ archived },
+			"finished temp knights archived",
+		);
+		return archived;
+	}
+
+	/** Sweeps once now and then every hour, until `stop`. */
+	startSweeper(): void {
+		const limits = helpersOf(this.#ctx.options.helpers);
+		if (!limits || limits.archiveFinishedAfterHours === false) return;
+		const run = () =>
+			this.sweepFinished().catch((error: unknown) =>
+				this.#ctx.options.logger.warn({ err: error }, "temp knights not swept"),
+			);
+		void run();
+		this.#sweeper = setInterval(run, SWEEP_EVERY_MS);
+		this.#sweeper.unref();
+	}
+
+	stop(): void {
+		if (this.#sweeper) clearInterval(this.#sweeper);
+		this.#sweeper = undefined;
+	}
+}

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

@@ -8,9 +8,10 @@ import { AgentError } from "../domain/errors.ts";
 import type { AgentTurnScope } from "../domain/ports.ts";
 import { messages } from "../i18n/index.ts";
 import type { AgentChannels } from "./agent-ports.ts";
-import { overBase } from "./agent-rules.ts";
+import { isHelper, overBase } from "./agent-rules.ts";
 import type { Agent, AgentGroup } from "./agent-store.ts";
 import { refreshAvatars } from "./avatar-refresh.ts";
+import { TeamHelpers } from "./team-helpers.ts";
 import {
 	agentOfChannel,
 	coordinatorOf,
@@ -30,14 +31,18 @@ import type { TeamContext } from "./team-options.ts";
 export class TeamLifecycle {
 	readonly #ctx: TeamContext;
 	readonly #stopped = new AbortController();
+	/** The temp knights: their archive, restore and sweep, which archiving a parent calls. */
+	readonly helpers: TeamHelpers;
 
 	constructor(ctx: TeamContext) {
 		this.#ctx = ctx;
+		this.helpers = new TeamHelpers(ctx, (agent) => this.#archiveAgent(agent));
 	}
 
 	/** Ends the background avatar refresh: nothing is rendered, written or logged after it. */
 	stop(): void {
 		this.#stopped.abort();
+		this.helpers.stop();
 	}
 
 	// ── Startup ────────────────────────────────────────────────────────────
@@ -55,6 +60,8 @@ export class TeamLifecycle {
 		if (added.length > 0) logger.info({ added }, "seed agents added");
 		if (channels) await this.#startChannels(channels);
 		this.#ctx.changed();
+		await this.helpers.reconcile();
+		this.helpers.startSweeper();
 		void this.#dressMissing().then(async (dressed) => {
 			if (this.#stopped.signal.aborted) return;
 			if (dressed) this.#ctx.changed();
@@ -81,6 +88,8 @@ export class TeamLifecycle {
 		const { store, logger } = this.#ctx.options;
 		for (const agent of store.agents()) {
 			if (agent.status !== "active") continue;
+			// A temp knight of a parent without a channel lives in rooms only.
+			if (!agent.channelId && isHelper(agent)) continue;
 			if (!agent.channelId) {
 				const id = await channels.createChannel(
 					agent.name,
@@ -216,6 +225,11 @@ export class TeamLifecycle {
 		if (agent && name === caller?.name)
 			throw new AgentError("You cannot archive yourself; ask another agent.");
 		const { channelId } = target;
+		// A temp knight's place is a thread of its parent's channel, closed rather than moved.
+		if (agent && isHelper(agent)) {
+			await this.helpers.archiveOne(agent);
+			return `Archived "${target.displayName}"; its history stays readable, and it no longer answers.`;
+		}
 		if (agent) await this.#archiveAgent(agent);
 		else if (group) await this.#archiveGroup(group);
 		if (!channelId || !channels)
@@ -253,6 +267,10 @@ export class TeamLifecycle {
 			);
 		if (target.status === "active")
 			throw new AgentError(`"${name}" is not archived.`);
+		if (agent && isHelper(agent)) {
+			await this.helpers.restoreOne(agent);
+			return `Restored "${target.displayName}"; it answers again.`;
+		}
 		if (group) store.checkRestorableGroup(name);
 		// The store checks again when it restores. A member archived, or a second restore of the
 		// same name, between the two checks leaves the channel moved or made with no owner; it
@@ -304,6 +322,10 @@ export class TeamLifecycle {
 				`"${name}" is active; archive it before deleting it.`,
 			);
 		await cleanup?.();
+		// A parent's archived temp knights go with it; none is left naming a parent that is gone.
+		if (agent)
+			for (const helper of store.helpersOf(name))
+				await this.remove(helper.name);
 		// What a name keeps in the runtime would be picked up by the next agent or group made under it.
 		const runtime = this.#ctx.options.runtime();
 		const rooms = this.#rooms();
@@ -326,6 +348,9 @@ export class TeamLifecycle {
 		const { store, schedules, logger } = this.#ctx.options;
 		const runtime = this.#ctx.options.runtime();
 		const rooms = this.#rooms();
+		// A parent's temp knights are archived first: they have no place of their own once it is gone.
+		for (const helper of store.helpersOf(agent.name, "active"))
+			await this.helpers.archiveOne(helper);
 		const left = await store.archiveAgent(agent.name);
 		// The agent's Discord channel and each of its rooms are conversations of their own.
 		for (const key of keysOf(store, agent.name, rooms)) {

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

@@ -1,3 +1,4 @@
+import type { ResolvedHelpers } from "../config/helpers.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
 import type { ThinkingSetting } from "../models.ts";
 import type { ConversationModes } from "../modes/conversation-modes.ts";
@@ -64,6 +65,11 @@ export interface AgentTeamOptions
 	skills?: SkillRegistry;
 	/** The conversation modes, read when an agent is created with long-running on; none, none is set. */
 	modes?: () => ConversationModes | undefined;
+	/**
+	 * The temp knights' limits; `false` leaves `helper_create` and `helper_end` out. Without it the
+	 * defaults apply.
+	 */
+	helpers?: ResolvedHelpers | false;
 }
 
 /** What the team's collaborators share: its options, its turns, and its change signal. */
@@ -76,4 +82,6 @@ export interface TeamContext {
 	modelOf(name: string): { model: string; thinking: ThinkingSetting };
 	/** Writes a group's members and host into its channel topic, without waiting on Discord. */
 	retitle(group: AgentGroup): void;
+	/** Archives temp knights, closing their threads; says which were archived. */
+	archiveHelpers(names: readonly string[]): Promise<string[]>;
 }

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

@@ -0,0 +1,75 @@
+import { AgentError } from "../domain/errors.ts";
+import type { AgentTurnScope } from "../domain/ports.ts";
+import { agentSystemPrompt, placeOf } from "./agent-prompt.ts";
+import type { Agent } from "./agent-store.ts";
+import { coordinatorOf } from "./team-keys.ts";
+import type { AgentTeamOptions } from "./team-options.ts";
+import type { TeamTurns } from "./team-turns.ts";
+
+/**
+ * The system prompt addition of an agent session, read before each of its runs: the base every
+ * agent turn starts with, then what the plugins' prompt sections add. `images` is whether the
+ * agent can generate pictures.
+ */
+export function teamSystemPrompt(
+	options: AgentTeamOptions,
+	turns: Pick<TeamTurns, "speakerOf" | "turnChannel">,
+	images: boolean,
+	scope: AgentTurnScope,
+): string {
+	const {
+		store,
+		workDir,
+		sharedPrompt,
+		guestPrompt,
+		owner,
+		shellUser,
+		scratchDir,
+		agentTools,
+		surfaces,
+		channels,
+	} = 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, options);
+	const speaker = turns.speakerOf(scope);
+	const base = agentSystemPrompt({
+		agent,
+		...(speaker ? { speaker } : {}),
+		...(coordinator ? { coordinator } : {}),
+		shared,
+		...(guest ? { guestShared: guest } : {}),
+		workDir,
+		owner,
+		shellUser,
+		...(scratchDir ? { scratchDir } : {}),
+		images,
+		...(agent.parent ? { parent: store.agent(agent.parent) } : {}),
+		helpers: options.helpers !== false,
+		...(agentTools ? { agentTools } : {}),
+		...placeOf(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 = (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");
+}

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

@@ -1,31 +1,49 @@
 import type { AgentTurnScope } from "../domain/ports.ts";
 import { SHELL_TOOLS } from "../modules/host-shell/shell-policy.ts";
 import type { TurnSelection } from "../sessions.ts";
-import { AGENT_TOOLS, MESSAGE_AGENT_TOOL } from "./agent-tools.ts";
+import { isHelper } from "./agent-rules.ts";
+import {
+	AGENT_TOOLS,
+	HELPER_TOOLS,
+	MESSAGE_AGENT_TOOL,
+	WITHHELD_FROM_HELPERS,
+} from "./agent-tools.ts";
 import type { AgentTeamOptions } from "./team-options.ts";
 
 /** The tools every agent turn runs with: the plugins', plus the shell and agent tools. */
 export function teamSelection(
 	options: Pick<
 		AgentTeamOptions,
-		"pluginSelection" | "pluginTools" | "agentTools"
-	>,
+		"pluginSelection" | "pluginTools" | "agentTools" | "helpers"
+	> & { store?: Pick<AgentTeamOptions["store"], "agent"> },
 	scope?: AgentTurnScope,
 ): TurnSelection {
 	const plugged = options.pluginSelection();
+	// A temp knight cannot make knights, groups or schedules, nor archive anything: the tools are
+	// not offered to its turns, which stops a chain of them multiplying.
+	const helper =
+		scope !== undefined && isHelper(options.store?.agent(scope.name));
+	const kept = (tool: string): boolean =>
+		!(helper && WITHHELD_FROM_HELPERS.includes(tool)) &&
+		!(
+			(options.helpers === false || scope?.group) &&
+			(HELPER_TOOLS as readonly string[]).includes(tool)
+		);
 	return {
 		id: "agent",
 		tools: [
-			...new Set([
-				...plugged.tools,
-				// A chat-only host's agents carry no shell and no file tools.
-				...(options.agentTools === "chat-only" ? [] : SHELL_TOOLS),
-				// Group members hand off by mentioning each other, so a group seat has no message_agent.
-				...AGENT_TOOLS.filter(
-					(tool) => !(scope?.group && tool === MESSAGE_AGENT_TOOL),
-				),
-				...(options.pluginTools?.() ?? []),
-			]),
+			...new Set(
+				[
+					...plugged.tools,
+					// A chat-only host's agents carry no shell and no file tools.
+					...(options.agentTools === "chat-only" ? [] : SHELL_TOOLS),
+					// Group members hand off by mentioning each other, so a group seat has no message_agent.
+					...AGENT_TOOLS.filter(
+						(tool) => !(scope?.group && tool === MESSAGE_AGENT_TOOL),
+					),
+					...(options.pluginTools?.() ?? []),
+				].filter(kept),
+			),
 		],
 		groups: plugged.groups,
 	};

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

@@ -19,6 +19,10 @@ export interface AgentStatus {
 	lastActive?: Date;
 	/** Its schedules, across its Discord channel and its rooms. */
 	schedules: number;
+	/** The knight that made it, for a temp knight. */
+	parent?: string;
+	/** A temp knight with nothing running, queued or waiting for the owner. */
+	finished?: true;
 }
 
 /** An active group as the dashboard shows it. */
@@ -74,6 +78,8 @@ export async function teamStatus(ctx: TeamContext): Promise<TeamStatus> {
 			...(context ? { context } : {}),
 			...(lastActive ? { lastActive } : {}),
 			schedules: scheduled,
+			...(agent.parent ? { parent: agent.parent } : {}),
+			...(agent.parent && agent.finishedAt ? { finished: true as const } : {}),
 		});
 	}
 	const groups: GroupStatus[] = store.groups().flatMap((group) => {