pi-roundtable 0.1.0 → 0.2.0

package/src/core/runtime/session-factory.ts

@@ -19,8 +19,8 @@ import {
 	type ToolSelection,
 	type TransientTask,
 } from "../sessions.ts";
+import { activeToolsExtension } from "../shared/active-tools.ts";
 import { packageDir } from "../shared/package-dir.ts";
-import { profileToolsExtension } from "../shared/profile-tools.ts";
 import { readAttachmentExtension } from "../shared/read-attachment-tool.ts";
 import { addressee, type Speaker, THE_SPEAKER } from "../speakers.ts";
 import {
@@ -83,6 +83,19 @@ export class SessionFactory {
 		return this.#linked;
 	}
 
+	/**
+	 * The system prompt of a non-agent conversation of the kind: a plugin's persona, else for
+	 * "owner" none. A kind nobody wrote a persona for is refused, never given the owner's.
+	 */
+	personaOf(kind: string): string {
+		const contributed = this.link().persona(kind);
+		if (contributed !== undefined) return contributed;
+		if (kind === "owner") return "";
+		throw new ConfigError(
+			`no persona is registered for the conversation kind "${kind}". A plugin adds one with \`personas: [{ kind: "${kind}", prompt() { ... } }]\`, or its claim must start conversations of a kind that has one.`,
+		);
+	}
+
 	get plan(): SessionPlan {
 		return this.link().plan;
 	}
@@ -196,8 +209,11 @@ export class SessionFactory {
 		slot: PromptSlot,
 		attachmentDir: string,
 		agent: AgentTurnScope | undefined,
+		kind: string,
 	): Promise<ChannelSession> {
-		const { agentDir, model, thinking, persona, logger } = this.#options;
+		const { agentDir, model, thinking, logger } = this.#options;
+		// An agent's prompt is set before each run; the other kinds are refused here, before a session is built.
+		const persona = agent ? undefined : this.personaOf(kind);
 		const skills = this.skillsOf(agent);
 		const state = {
 			tools: [] as readonly string[],
@@ -218,7 +234,7 @@ export class SessionFactory {
 			this.plan.compaction?.engine,
 		);
 		const context: SessionContext = {
-			kind: agent ? "agent" : "owner",
+			kind: agent ? "agent" : kind,
 			homeChannel: channel,
 			turnChannel: agent && agents ? agents.turnChannel(agent) : channel,
 			compaction: {
@@ -253,10 +269,10 @@ export class SessionFactory {
 					() => addressee(this.#deps.speaker(channel), this.#options.owner),
 				),
 				selfCompactGuard: selfCompactGuardExtension(),
-				profileTools: profileToolsExtension(() => state.tools),
+				activeTools: activeToolsExtension(() => state.tools),
 			}),
 			// An agent's prompt is set before each run by the agent-prompt extension.
-			appendSystemPrompt: agent ? [] : [persona],
+			appendSystemPrompt: persona === undefined ? [] : [persona],
 		});
 		await resourceLoader.reload();
 

package/src/core/runtime/text-tools.ts

@@ -14,15 +14,13 @@ export interface TextToolDef<Name extends string = string> {
 	run(input: ToolInput, signal?: AbortSignal): Promise<string> | string;
 }
 
-type ErrorClass = abstract new (...args: never[]) => Error;
-
 /**
  * Registers text tools. A thrown `refusal` becomes an error result the model reads; any other
  * error fails the call.
  */
 export function textToolsExtension(
 	defs: readonly TextToolDef[],
-	refusal: ErrorClass,
+	refusal: abstract new (...args: never[]) => Error,
 ): ExtensionFactory {
 	return (pi) => {
 		for (const def of defs) {

package/src/core/services.ts

@@ -1,107 +1,255 @@
-import type { AgentStore } from "./agents/agent-store.ts";
-import type { AgentTeam } from "./agents/agent-team.ts";
-import type { AvatarStudio } from "./agents/avatar-studio.ts";
-import type { DiscordSurface } from "./discord/discord-surface.ts";
-import type { DispatchThreads } from "./discord/dispatch-threads.ts";
-import type { OwnerCards } from "./discord/owner-cards.ts";
-import type { OwnerGuard } from "./discord/owner-command.ts";
-import { PluginError } from "./errors.ts";
-import type { ConfirmationJudge } from "./judging/confirmation-judge.ts";
-import type { BackgroundTurns } from "./modules/background/background-turns.ts";
-import type { Delegator } from "./modules/delegation/delegator.ts";
-import type { OwnerMemoryStore } from "./modules/memory/owner-memory-store.ts";
-import type { ScheduleStore } from "./modules/schedules/schedule-store.ts";
-import type { SkillRegistry } from "./modules/skills/skill-registry.ts";
-import type { SkillStore } from "./modules/skills/skill-store.ts";
-import type { PendingConfirmationStore } from "./runtime/pending-confirmation-store.ts";
-import type { PiAgentRuntime } from "./runtime/pi-agent-runtime.ts";
+import type { Agent, AgentGroup } from "./agents/agent-rules.ts";
+import type { AvatarMode } from "./agents/agent-tools.ts";
+import type { TeamStatus } from "./agents/team-status.ts";
+import type { ScheduledOutcome } from "./contract/channels.ts";
+import type { AgentRuntime } from "./contract/runtime.ts";
+import { type ServiceKey, serviceKey } from "./contract/services.ts";
+import type { PendingConfirmation } from "./domain/conversation.ts";
+import type { HttpRoute } from "./http/listeners.ts";
+import type { ThinkingSetting } from "./models.ts";
+import type {
+	DelegationJob,
+	DelegationOutcome,
+} from "./modules/delegation/delegator.ts";
+import type {
+	Memory,
+	MemoryKind,
+	PromptMemory,
+} from "./modules/memory/owner-memory-store.ts";
+import type {
+	NewSchedule,
+	Schedule,
+	ScheduleChange,
+} from "./modules/schedules/schedule-store.ts";
+import type {
+	SkillCatalogEntry,
+	SkillSet,
+} from "./modules/skills/skill-rules.ts";
+import type { AgentTurnScope, ChannelKey } from "./sessions.ts";
 
-/** The stores every process has, attached to the host's one pool. */
-export interface CoreStores {
-	/** The owner's memory. */
-	memory: OwnerMemoryStore;
-	schedules: ScheduleStore;
-	/** Held actions, kept across a restart. */
-	confirmations: PendingConfirmationStore;
-	/** The agent server's agents and groups. */
-	agents: AgentStore;
-	skills: SkillStore;
-}
+// The services the built-in plugins provide, and the ports they keep to. Each port is an
+// interface, so an object with the same methods satisfies it without being one of the built-in
+// classes; a plugin replaces a built-in by providing its own under the same key.
 
-/** The Discord connection and what stands on it. */
-export interface CoreDiscord {
-	surface: DiscordSurface;
-	/** The owner's cards, which also answer the interactions of held actions. */
-	cards: OwnerCards;
-	guard: OwnerGuard;
-	studio: AvatarStudio;
-	/** The threads that carry background reports. */
-	threads: DispatchThreads;
-}
+/** The agent server: its team, its directory, the runtime that runs every agent turn. Provided by the agent-server plugin. */
+export const AGENTS: ServiceKey<AgentServer> =
+	serviceKey<AgentServer>("roundtable.agents");
+/** Scheduled turns, stored. Provided by the `schedule-store` plugin. */
+export const SCHEDULES: ServiceKey<ScheduleStore> = serviceKey<ScheduleStore>(
+	"roundtable.schedules",
+);
+/** Turns nobody wrote: a due schedule's, a delegated task's report, a logged error's. Provided by the modules plugin. */
+export const BACKGROUND_TURNS: ServiceKey<BackgroundTurns> =
+	serviceKey<BackgroundTurns>("roundtable.background-turns");
+/** Tasks run in the background, each reporting back in its channel. Provided by the modules plugin. */
+export const DELEGATION: ServiceKey<Delegator> = serviceKey<Delegator>(
+	"roundtable.delegation",
+);
+/**
+ * The remembered facts of each speaker. Provided by the `memory` plugin, an addon: read it with
+ * `find` when your plugin works without memory, and with `get` when it cannot.
+ */
+export const MEMORY: ServiceKey<MemoryStore> = serviceKey<MemoryStore>(
+	"roundtable.memory",
+	{
+		absent:
+			"The memory addon is switched off (config memory: false). Switch it on, or provide the service from a plugin of your own.",
+	},
+);
+/**
+ * The skills agents carry. Provided by the `skills` plugin, an addon: read it with `find` when
+ * your plugin works without skills, and with `get` when it cannot.
+ */
+export const SKILLS: ServiceKey<SkillRegistry> = serviceKey<SkillRegistry>(
+	"roundtable.skills",
+	{
+		absent:
+			"The skills addon is switched off (config skills: false). Switch it on, or provide the service from a plugin of your own.",
+	},
+);
 
-/** What the agent server builds. */
-export interface CoreAgents {
+/** What the agent server builds, for the plugins set up after it. */
+export interface AgentServer {
 	team: AgentTeam;
-	runtime: PiAgentRuntime;
-	skills: SkillRegistry;
-	/** Decides whether the owner's reply approves a held action. */
-	confirmations: ConfirmationJudge;
+	/** Read-only lookups of agents and groups; edits go through the team. */
+	directory: AgentDirectory;
+	/** The runtime every agent-server turn runs on: the `runtime` provider's, or Pi's when no plugin fills the slot. */
+	runtime: AgentRuntime;
+	/** Decides whether the owner's reply approves the actions the assistant held for them. */
+	approvals: {
+		approves(pending: PendingConfirmation, reply: string): Promise<boolean>;
+	};
+	/** Agents' pictures. */
+	avatars: AvatarStudio;
 }
 
-/** What the built-in plugins build for the plugins registered after them. */
-export interface CoreServices {
-	stores: CoreStores;
-	discord: CoreDiscord;
-	/** Turns nobody wrote: a due schedule's, a delegated task's report, a logged error's. */
-	background: BackgroundTurns;
-	delegator: Delegator;
-	/** The agent server: its team, the runtime that runs every turn, and the skill registry. */
-	agents: CoreAgents;
+/** Agent pictures: drawn by an image provider, or made from the agent's name, kept and served by content hash. */
+export interface AvatarStudio {
+	/** Whether an image provider is configured; without one, only `fallback` makes pictures. */
+	readonly canDraw: boolean;
+	/** The public URL of a picture, or of the default when there is none. */
+	url(hash: string | undefined): string;
+	/** Draws a new picture from an avatar prompt; returns its hash. */
+	draw(avatarPrompt: string): Promise<string>;
+	/** Edits a stored picture by an instruction; returns the new picture's hash. */
+	edit(hash: string | undefined, instruction: string): Promise<string>;
+	/** A picture made from an agent's display name and name, for a host without an image provider; returns its hash. */
+	fallback(displayName: string, name: string): Promise<string>;
+	/** The pictures, public on the named listener. */
+	route(listener: string): HttpRoute;
+	/** Serves `/avatars/<hash>.png`; undefined for any other path. */
+	serve(pathname: string): Response | undefined;
 }
 
-/** Reads the core's services; reading one before its built-in plugin has set up throws a PluginError. */
-export type CoreAccess = {
-	readonly [K in keyof CoreServices]: CoreServices[K];
-};
+/** The read half of the agent store: every inbound message asks, and only this process changes them. */
+export interface AgentDirectory {
+	agents(): Agent[];
+	agent(name: string): Agent | undefined;
+	/** The agent, or throws AgentError when it is unknown or archived. */
+	activeAgent(name: string): Agent;
+	agentByChannel(channelId: string): Agent | undefined;
+	groups(): AgentGroup[];
+	group(name: string): AgentGroup | undefined;
+	groupByChannel(channelId: string): AgentGroup | undefined;
+}
 
-/** Holds what the built-in plugins provide, for the plugins set up after them. */
-export class CoreRegistry implements CoreAccess {
-	readonly #values = new Map<keyof CoreServices, unknown>();
+/** What an agent's settings may change, as `update` takes it. */
+export interface AgentChange {
+	displayName?: string;
+	prompt?: string;
+	model?: string;
+	thinking?: string;
+}
 
-	/** Stores a service; a built-in plugin calls this once in its setup. */
-	provide<K extends keyof CoreServices>(key: K, value: CoreServices[K]): void {
-		if (this.#values.has(key))
-			throw new PluginError(
-				`core service ${key} is provided twice. Register only one plugin that provides it.`,
-			);
-		this.#values.set(key, value);
-	}
+/** The agent team as plugins use it: who is in it, what model they run, and their channels. */
+export interface AgentTeam {
+	readonly guildId: string;
+	/** Called when a turn starts or ends and when an agent or group changes. */
+	onChange(listener: () => void): void;
+	/** Every active agent and group, with what each is doing now. */
+	status(): Promise<TeamStatus>;
+	/** The agent or group that owns a channel of the agent server. */
+	owns(channel: ChannelKey): "agent" | "group" | undefined;
+	/** The model and thinking setting of an agent's next run: its own, or the assistant's. */
+	modelOf(name: string): { model: string; thinking: ThinkingSetting };
+	/** The assistant's model and thinking setting, which agents without their own follow. */
+	defaultModel(): { model: string; thinking: ThinkingSetting };
+	/** Models an agent can be set to: every one the host runs, `current` first when given. */
+	usableModels(current?: string): Promise<string[]>;
+	/** An active agent's channel; throws ScheduleError for an unknown agent, as the schedule tools catch it. */
+	channelOf(name: string): ChannelKey;
+	/** The channel the scope's turns run in: the group's in a group round, otherwise its own. */
+	turnChannel(scope: AgentTurnScope): ChannelKey;
+	/** Posts text under the caller's name in the channel of its turn. */
+	postAs(caller: AgentTurnScope, text: string): Promise<void>;
+	/** The assistant's own notice, posted in the coordinator's channel under its name. */
+	announce(text: string): Promise<void>;
+	/** Changes an agent's display name, prompt, model, or thinking level; a model must be one the host runs. */
+	update(name: string, change: AgentChange): Promise<string>;
+	/** Draws and stores a new picture for an agent. */
+	redrawAvatar(name: string, mode: AvatarMode, text?: string): Promise<Agent>;
+}
 
-	#need<K extends keyof CoreServices>(key: K): CoreServices[K] {
-		if (!this.#values.has(key))
-			throw new PluginError(
-				`core service ${key} is not provided yet. Register the built-in plugin that provides it before the plugin that reads it.`,
-			);
-		return this.#values.get(key) as CoreServices[K];
-	}
+/** Scheduled turns, stored. A one-time schedule is deleted once it fires. */
+export interface ScheduleStore {
+	create(schedule: NewSchedule): Promise<Schedule>;
+	get(id: number): Promise<Schedule | undefined>;
+	forChannel(channel: ChannelKey): Promise<Schedule[]>;
+	all(): Promise<Schedule[]>;
+	/** Applies a change to one of the channel's schedules; undefined when it has no such schedule. */
+	update(
+		channel: ChannelKey,
+		id: number,
+		change: ScheduleChange,
+	): Promise<Schedule | undefined>;
+	/** Deletes a schedule, only from the given channel when one is given. */
+	remove(id: number, channel?: ChannelKey): Promise<Schedule | undefined>;
+	due(now: Date): Promise<Schedule[]>;
+	/** Takes a due schedule before it runs: moves it to its next run, or deletes it when there is none; false when another claim won. */
+	claim(
+		schedule: Schedule,
+		next: Date | undefined,
+		now: Date,
+	): Promise<boolean>;
+	/** Records how a run ended. */
+	recordStatus(id: number, status: string): Promise<void>;
+}
 
-	get stores(): CoreStores {
-		return this.#need("stores");
-	}
+/** Turns nobody wrote, each answered in its channel by the claim that owns it. */
+export interface BackgroundTurns {
+	/** A due schedule's turn, run as its creator's. */
+	runScheduled(schedule: Schedule, firedAt: Date): Promise<ScheduledOutcome>;
+	/** A delegated task's report, answered in its channel under the same rules as a schedule. */
+	runDelegated(job: DelegationJob, result: DelegationOutcome): Promise<void>;
+	/** The process's own logged error, reported to an agent in its channel as a report turn. */
+	runErrorReport(channel: ChannelKey, text: string): Promise<ScheduledOutcome>;
+}
 
-	get discord(): CoreDiscord {
-		return this.#need("discord");
-	}
+/** What a delegated task is asked with: its job, before the delegator numbers and times it. */
+export type DelegationRequest = Omit<
+	DelegationJob,
+	"id" | "startedAt" | "thread"
+>;
 
-	get background(): BackgroundTurns {
-		return this.#need("background");
-	}
+/** Tasks run in the background, each handing its result back to its channel. Jobs live in memory. */
+export interface Delegator {
+	/** Starts a job and returns at once; throws DelegationError on bad input or a full channel. */
+	start(request: DelegationRequest): DelegationJob;
+	/** The channel of each job still running, one entry per job. */
+	runningChannels(): ChannelKey[];
+	/** Resolves once every started job has reported. */
+	idle(): Promise<void>;
+}
 
-	get delegator(): Delegator {
-		return this.#need("delegator");
-	}
+/** Remembered facts, each speaker's own; every agent shares the memory of whoever is speaking. */
+export interface MemoryStore {
+	/** One speaker's memory; it never reads or changes another's. */
+	forSpeaker(speakerId: string): SpeakerMemory;
+}
+
+/** One speaker's remembered facts. */
+export interface SpeakerMemory {
+	list(): Promise<Memory[]>;
+	/** What every turn carries: all core facts, and events that have not passed yet. */
+	forPrompt(today: string): Promise<PromptMemory>;
+	add(fact: string, kind?: MemoryKind, eventDate?: string): Promise<Memory>;
+	/** Memories containing any query term, most terms matched first, then newest first. */
+	search(query: string, limit?: number): Promise<Memory[]>;
+	/** Replaces one memory's text, kind, and date; undefined when the id is unknown. */
+	update(
+		id: number,
+		change: { fact: string; kind: MemoryKind; eventDate?: string },
+	): Promise<Memory | undefined>;
+	/** Deletes one memory; false when the id is unknown. */
+	removeById(id: number): Promise<boolean>;
+	/** Deletes every memory containing the text; returns the removed facts. */
+	remove(text: string): Promise<string[]>;
+}
 
-	get agents(): CoreAgents {
-		return this.#need("agents");
-	}
+/** The skills agents carry: built in, linked from repositories, or written by an agent. */
+export interface SkillRegistry {
+	/** The built-in skills plus the named registered ones, resolved to their files. */
+	resolve(names: readonly string[]): SkillSet;
+	/** What an agent carries, built-in skills included. */
+	carried(agent: string): SkillSet;
+	/** The registered skills an agent carries, as the dashboard lists them. */
+	carriedNames(agent: string): string[];
+	/** An agent's skills as `agent_get` shows them. */
+	describeCarried(agent: string): string;
+	/** Every skill, built-in ones first. */
+	catalog(): SkillCatalogEntry[];
+	/** Every skill, or those of a group or matching a query, as the `skill_list` tool shows them. */
+	list(filter?: { group?: string; query?: string }): string;
+	/** The skills linked from a managed repository. */
+	linkedFrom(repo: string): string[];
+	/** Throws AgentError when a name is not registered; built-in names are carried already. */
+	checkRegistered(names: readonly string[]): void;
+	/** Links the skill at a repository path, or every child folder with a SKILL.md. */
+	link(repo: string, path: string): Promise<string>;
+	/** Adds and removes an agent's registered skills together, or changes nothing; returns what it carries after. */
+	attach(
+		agent: string,
+		add: readonly string[],
+		remove: readonly string[],
+	): Promise<string[]>;
 }

package/src/core/sessions.ts

@@ -43,7 +43,8 @@ export interface TransientTask {
 
 /** What one Pi session is for, as a session tool's factory sees it. */
 export interface SessionContext {
-	kind: "owner" | "agent";
+	/** "agent" for an agent's session; otherwise the kind of conversation, which the claim that owns the channel names. */
+	kind: string;
 	/** Where the session's schedules and delegated reports belong: the agent's own channel, or the owner's. */
 	homeChannel: ChannelKey;
 	/** Where the session's turns run: a group's channel for an agent's seat in it, else the home channel. */
@@ -94,7 +95,7 @@ const CORE_EXTENSIONS = [
 	"confirmation-gate",
 	"ask-user",
 	"self-compact-guard",
-	"profile-tools",
+	"active-tools",
 ] as const;
 
 /** Session tools grouped by phase, each group in registration order. */

package/src/core/shared/{profile-tools.ts → active-tools.ts}

@@ -1,11 +1,11 @@
 import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
 
 /**
- * Pins each run's active tools to the current profile. Inline factories load after path
+ * Pins each run's active tools to the turn's selection. Inline factories load after path
  * extensions, so this handler runs last and undoes additions such as pi-web-access
  * re-adding web_enable or claude-bridge's AskClaude.
  */
-export function profileToolsExtension(
+export function activeToolsExtension(
 	currentTools: () => readonly string[],
 ): ExtensionFactory {
 	return (pi) => {

package/src/core/shared/delegate-tool.ts

@@ -1,9 +1,10 @@
 import { Type } from "typebox";
+import { freeze } from "../freeze.ts";
 
-/** Hands web research to the cheaper worker model; the same for the owner agent and party roles. */
+/** Hands web research to the cheaper worker model; shared by conversation sessions. */
 export const DELEGATE_TOOL = "delegate_task" as const;
 
-export const DELEGATE_TOOL_SPEC = {
+export const DELEGATE_TOOL_SPEC = freeze({
 	name: DELEGATE_TOOL,
 	label: "Delegate task",
 	description:
@@ -12,4 +13,4 @@ export const DELEGATE_TOOL_SPEC = {
 		title: Type.String({ description: "A short name for the task." }),
 		task: Type.String({ description: "The self-contained task." }),
 	}),
-};
+});

package/src/core/shared/schedule-tools.ts

@@ -1,24 +1,23 @@
 import { type TSchema, Type } from "typebox";
-import { messages } from "../i18n/index.ts";
-import { timeZone } from "../time.ts";
+import { catalogFor, type Locale } from "../i18n/index.ts";
 
 /**
- * Schedule tools, the same for the owner agent and party roles. Each acts on the schedules of
+ * Schedule tools, shared by conversation sessions. Each acts on the schedules of
  * the channel it runs in; the host decides the channel and speaker, never the model.
  */
-export const SCHEDULE_TOOLS = [
+export const SCHEDULE_TOOLS = Object.freeze([
 	"schedule_create",
 	"schedule_list",
 	"schedule_update",
 	"schedule_cancel",
-] as const;
+] as const);
 export type ScheduleToolName = (typeof SCHEDULE_TOOLS)[number];
 
 export function isScheduleTool(value: string): value is ScheduleToolName {
 	return (SCHEDULE_TOOLS as readonly string[]).includes(value);
 }
 
-const timing = () => ({
+const timing = (zone: string) => ({
 	in_minutes: Type.Optional(
 		Type.Integer({
 			minimum: 1,
@@ -28,12 +27,12 @@ const timing = () => ({
 	),
 	at: Type.Optional(
 		Type.String({
-			description: `Run once at this ${messages().zoneTime(timeZone())}, "YYYY-MM-DD HH:MM". Give one of in_minutes, at, or time.`,
+			description: `Run once at this ${zone}, "YYYY-MM-DD HH:MM". Give one of in_minutes, at, or time.`,
 		}),
 	),
 	time: Type.Optional(
 		Type.String({
-			description: `Repeat at this ${messages().zoneTime(timeZone())} of day, "HH:MM".`,
+			description: `Repeat at this ${zone} of day, "HH:MM".`,
 		}),
 	),
 	every_days: Type.Optional(
@@ -70,24 +69,34 @@ export interface ScheduleToolSpec {
 	parameters: TSchema;
 }
 
-export function scheduleToolSpecs(): readonly ScheduleToolSpec[] {
+/** The wording of the tools' descriptions: a locale's catalog, and the zone the times are in. */
+export interface ScheduleToolWording {
+	locale: Locale;
+	/** An IANA time zone, such as `Asia/Taipei`. */
+	timeZone: string;
+}
+
+export function scheduleToolSpecs(
+	wording: ScheduleToolWording,
+): readonly ScheduleToolSpec[] {
+	const zone = catalogFor(wording.locale).zoneTime(wording.timeZone);
 	return [
 		{
 			name: "schedule_create",
 			label: "Create schedule",
-			description: `Schedule a task for yourself in this channel: at the set ${messages().zoneTime(timeZone())} you are woken with the prompt and your answer is posted here. Use it for reminders, follow-ups, and recurring checks someone asks for. Write the prompt as a complete instruction to your future self, including who it is for and what to report; it runs without the current conversation in view.`,
+			description: `Schedule a task for yourself in this channel: at the set ${zone} you are woken with the prompt and your answer is posted here. Use it for reminders, follow-ups, and recurring checks someone asks for. Write the prompt as a complete instruction to your future self, including who it is for and what to report; it runs without the current conversation in view.`,
 			parameters: Type.Object({
 				title: Type.String({ description: "A short name for the schedule." }),
 				prompt: Type.String({
 					description: "What to do when it runs, self-contained.",
 				}),
-				...timing(),
+				...timing(zone),
 			}),
 		},
 		{
 			name: "schedule_list",
 			label: "List schedules",
-			description: `List this channel's schedules with their next run, and the current ${messages().zoneTime(timeZone())}. Give id to read one schedule's full prompt.`,
+			description: `List this channel's schedules with their next run, and the current ${zone}. Give id to read one schedule's full prompt.`,
 			parameters: Type.Object({
 				id: Type.Optional(Type.Integer({ description: "Schedule id." })),
 			}),
@@ -103,7 +112,7 @@ export function scheduleToolSpecs(): readonly ScheduleToolSpec[] {
 				prompt: Type.Optional(
 					Type.String({ description: "The whole new prompt." }),
 				),
-				...timing(),
+				...timing(zone),
 			}),
 		},
 		{

package/src/core/shared/session-messages.ts

@@ -1,5 +1,5 @@
 /** An assistant message of a Pi session, as far as its final answer needs it. */
-interface AssistantLike {
+export interface AssistantLike {
 	role: "assistant";
 	content: unknown;
 	stopReason?: string;

package/src/core/speakers.ts

@@ -1,8 +1,8 @@
-import { ConfigError } from "./domain/errors.ts";
+import { freeze } from "./freeze.ts";
 import type { OwnerIdentity } from "./identity.ts";
 
 /** How much a speaker may do: `owner` above `admin` above `member`. */
-export const TIERS = ["member", "admin", "owner"] as const;
+export const TIERS = Object.freeze(["member", "admin", "owner"] as const);
 export type Tier = (typeof TIERS)[number];
 
 /** Whether `tier` is `least` or above. */
@@ -42,14 +42,16 @@ export function addressee(
  * the description is fixed when the session opens, so it names no one, and the prompt says who
  * the speaker is.
  */
-export const THE_SPEAKER: OwnerIdentity = {
+export const THE_SPEAKER: Readonly<Omit<OwnerIdentity, "pronouns">> & {
+	readonly pronouns: Readonly<OwnerIdentity["pronouns"]>;
+} = freeze({
 	name: "the speaker",
 	pronouns: {
 		subject: "the speaker",
 		object: "the speaker",
 		possessive: "the speaker's",
 	},
-};
+});
 
 /** The turn's text under the speaker's name, so a conversation several speakers share says who wrote what. */
 export function attributed(speaker: Speaker, text: string): string {
@@ -107,37 +109,3 @@ export function speakerPolicy(map: SpeakerMap): SpeakerPolicy {
 		},
 	};
 }
-
-/**
- * Reads a tier's members from text: comma-separated `user:<id>`, `role:<id>`, or `@everyone`;
- * a bare id is a user. `allowEveryone` is false for tiers that cannot be everyone.
- */
-export function parseTierMembers(
-	text: string | undefined,
-	name: string,
-	allowEveryone: boolean,
-): TierMembers | undefined {
-	const items = (text ?? "")
-		.split(",")
-		.map((item) => item.trim())
-		.filter((item) => item !== "");
-	if (items.length === 0) return undefined;
-	const users: string[] = [];
-	const roles: string[] = [];
-	let everyone = false;
-	for (const item of items) {
-		if (item === "@everyone") {
-			if (!allowEveryone)
-				throw new ConfigError(`${name} cannot include @everyone`);
-			everyone = true;
-			continue;
-		}
-		const [kind, id] = item.includes(":") ? item.split(":", 2) : ["user", item];
-		if ((kind !== "user" && kind !== "role") || !/^\d{17,20}$/.test(id ?? ""))
-			throw new ConfigError(
-				`${name} must list user:<id>, role:<id>, or @everyone, got ${item}`,
-			);
-		(kind === "role" ? roles : users).push(id as string);
-	}
-	return { users, roles, everyone };
-}