pi-roundtable 0.7.19 → 0.9.0

package/src/core/config/adapters.ts

@@ -0,0 +1,120 @@
+import type { ChannelContextOptions } from "../contract/channel-context.ts";
+import { ConfigError } from "../domain/errors.ts";
+import {
+	bool,
+	integer,
+	number,
+	oneOf,
+	optional,
+	orOff,
+	shape,
+	text,
+} from "./schema.ts";
+
+/** The Discord bot and its guild, as the top-level `discord` or `discord()` from `pi-roundtable/discord` gives them. */
+export interface DiscordConfig {
+	/** The bot token; keep it in `.env`, not in this file. */
+	token: string;
+	/** The agent server's guild id. */
+	guild: string;
+	/** The channel the coordinator lives in. */
+	entryChannel: string;
+	/** The root slash command, without the slash; default the lowercase assistant name. */
+	rootCommand?: string;
+	/**
+	 * Whether the owner's conversations have Discord administration tools; default true. `false`
+	 * leaves the `discord-admin` addon out.
+	 */
+	admin?: boolean;
+	/**
+	 * Text appended as it is to the refusal a non-owner gets from the root command, such as a
+	 * pointer to the commands anyone may use; include the space or punctuation your language
+	 * needs before it. Default none.
+	 */
+	refusalHint?: string;
+	/**
+	 * Whose turns in the agents' channels load memory: `"everyone"` (default) lets each speaker
+	 * read their own, `"owners"` only the owners, so a guest's turn has no memory in its prompt and
+	 * no memory tools, and never makes claude-bridge refuse the owner afterwards.
+	 */
+	agentMemory?: "everyone" | "owners";
+	/**
+	 * What a turn addressed to the assistant in a server channel reads of the messages posted there
+	 * since its last post, mentions or not; on with the defaults when left out. `false` turns it off
+	 * for the agent server and every plugin's claim.
+	 */
+	channelContext?: ChannelContextOptions | false;
+	/**
+	 * The divider the assistant posts in a server channel or thread when its conversation starts
+	 * over (a new conversation by an owner's command), which ends the window channel context reads;
+	 * never in a direct message. Default `─── new conversation ───`; `false` posts none.
+	 */
+	freshMarker?: string | false;
+}
+
+/** What `discord.channelContext` takes besides `false`. */
+const channelContextShape = shape({
+	fetch: optional(integer(1, 100)),
+	keep: optional(integer(1, 100)),
+	similarity: optional(number(0, 1)),
+	messageChars: optional(integer(1, 4000)),
+	botMessageChars: optional(integer(1, 4000)),
+});
+
+/** The Discord settings, at the top level or in a Discord adapter. */
+export const discordShape = shape({
+	token: text,
+	guild: text,
+	entryChannel: text,
+	rootCommand: optional(text),
+	admin: optional(bool),
+	refusalHint: optional(text),
+	agentMemory: optional(oneOf<"everyone" | "owners">("everyone", "owners")),
+	channelContext: optional(orOff(channelContextShape)),
+	freshMarker: optional(orOff(text)),
+});
+
+/** The adapters `adapters` takes, by the name their factory gives them. */
+const ADAPTERS = ["discord"] as const;
+
+/**
+ * The configuration with its adapters in the places the host reads them: a Discord adapter's
+ * settings as the top-level `discord`. Throws a ConfigError naming the adapter by its place.
+ */
+// pi-lens-ignore: no-unknown-returns — the configuration as written is untyped until the schema checks it
+export function liftAdapters(input: unknown): unknown {
+	if (typeof input !== "object" || input === null || !("adapters" in input))
+		return input;
+	const { adapters, ...rest } = input as Record<string, unknown>;
+	if (adapters === undefined) return rest;
+	if (!Array.isArray(adapters))
+		throw new ConfigError(
+			`config adapters: expected a list of adapters, such as [discord({ ... })] with discord from pi-roundtable/discord, got ${JSON.stringify(adapters)}. Fix the value in roundtable.config.ts.`,
+		);
+	const lifted: Record<string, unknown> = { ...rest };
+	adapters.forEach((entry: unknown, index) => {
+		const at = `adapters[${index}]`;
+		const name =
+			typeof entry === "object" && entry !== null
+				? (entry as { adapter?: unknown }).adapter
+				: undefined;
+		if (typeof name !== "string")
+			throw new ConfigError(
+				`config ${at}: expected an adapter, an object its factory makes such as discord({ ... }) from pi-roundtable/discord, got ${JSON.stringify(entry)}. Fix the value in roundtable.config.ts.`,
+			);
+		if (!(ADAPTERS as readonly string[]).includes(name))
+			throw new ConfigError(
+				`config ${at}: unknown adapter ${JSON.stringify(name)}. The adapters are ${ADAPTERS.join(", ")}; a chat network that comes as a plugin, such as pi-roundtable-webchat's webChat(), belongs in plugins.`,
+			);
+		if (lifted.discord !== undefined)
+			throw new ConfigError(
+				`config ${at}: Discord is configured twice, at the top level or by another adapter. Keep one.`,
+			);
+		const { adapter: _adapter, ...settings } = entry as Record<string, unknown>;
+		lifted.discord = shape({ discord: discordShape }).check(
+			settings,
+			at,
+		).discord;
+	});
+	return lifted;
+}

package/src/core/config/config.ts

@@ -4,6 +4,7 @@ import type { AgentSeed } from "../agents/agent-rules.ts";
 import { ConfigError } from "../domain/errors.ts";
 import type { InterimTextMode } from "../domain/interim.ts";
 import { isLocale, type Locale } from "../i18n/index.ts";
+import type { AccessRules } from "../identity/access-policy.ts";
 import type { OwnerIdentity } from "../identity.ts";
 import {
 	type ModelRef,
@@ -11,9 +12,13 @@ import {
 	THINKING_LEVELS,
 	type ThinkingLevel,
 } from "../models.ts";
+import type { PerPrincipalLimits } from "../modules/background/personal-target.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
 import { PRIMARY_CHARS } from "../runtime/interim-text.ts";
+import type { ChannelKey } from "../sessions.ts";
 import type { Tier, TierMembers } from "../speakers.ts";
+import { type AccessConfig, accessOf, accessShape } from "./access.ts";
+import { type DiscordConfig, discordShape, liftAdapters } from "./adapters.ts";
 import {
 	bool,
 	guarded,
@@ -28,6 +33,8 @@ import {
 	text,
 } from "./schema.ts";
 
+export type { DiscordConfig };
+
 /** How prompts refer back to the owner. */
 export type Pronouns = "he" | "she" | "they";
 
@@ -41,33 +48,46 @@ export interface TierConfig {
 	everyone?: boolean;
 }
 
+/** A chat network the host talks through, as its adapter's factory makes it; `adapter` names the network. */
+export interface AdapterConfig {
+	readonly adapter: string;
+}
+
+/** What `discord()` from `pi-roundtable/discord` makes: the Discord settings under the adapter's name. */
+export interface DiscordAdapterConfig extends AdapterConfig {
+	readonly adapter: "discord";
+	readonly discord: DiscordConfig;
+}
+
+/** The configuration's `background`: each person's share of the host's background work. */
+export interface BackgroundConfig {
+	perPrincipal?: PerPrincipalLimits;
+}
+
 /** What `roundtable.config.ts` gives `defineRoundtable`. */
 export interface RoundtableConfig {
 	/** The assistant's display name; default "Roundtable". */
 	name?: string;
-	/** The one owner: the only person who can change everything. */
-	owner: { id: string; name: string; pronouns?: Pronouns };
-	discord: {
-		/** The bot token; keep it in `.env`, not in this file. */
-		token: string;
-		/** The agent server's guild id. */
-		guild: string;
-		/** The channel the coordinator lives in. */
-		entryChannel: string;
-		/** The root slash command, without the slash; default the lowercase assistant name. */
-		rootCommand?: string;
-		/**
-		 * Whether the owner's conversations have Discord administration tools; default true. `false`
-		 * leaves the `discord-admin` addon out.
-		 */
-		admin?: boolean;
-		/**
-		 * Text appended as it is to the refusal a non-owner gets from the root command, such as a
-		 * pointer to the commands anyone may use; include the space or punctuation your language
-		 * needs before it. Default none.
-		 */
-		refusalHint?: string;
-	};
+	/**
+	 * The one owner, as 0.8 wrote it: their id, which is both their principal and their Discord
+	 * user id, their name, and pronouns. Deprecated, going away in 0.10: write `access` instead,
+	 * never both; `roundtable upgrade` rewrites it.
+	 */
+	owner?: { id: string; name: string; pronouns?: Pronouns };
+	/**
+	 * The Discord bot, its guild, and the agent server that lives there. Leave it out for a host
+	 * without Discord: no Discord plugins, no agent server or agents, no skills, and no tool that
+	 * messages the owner on Discord; conversations come through the plugins' own surfaces. The same
+	 * settings may come as `adapters: [discord({...})]` instead, never both.
+	 */
+	discord?: DiscordConfig;
+	/**
+	 * The chat networks the host talks through, each made by its adapter's factory, such as
+	 * `discord()` from `pi-roundtable/discord`. A Discord adapter is the same as the top-level
+	 * `discord`; a chat network that comes as a plugin, such as pi-roundtable-webchat, stays in
+	 * `plugins`.
+	 */
+	adapters?: readonly AdapterConfig[];
 	database: { url: string };
 	/** Where the process keeps its files, such as pictures, attachments, and skills. */
 	dataDir: string;
@@ -84,20 +104,33 @@ export interface RoundtableConfig {
 	locale?: Locale;
 	/** The IANA time zone schedules and stamps use; default "UTC". */
 	timeZone?: string;
-	/** Who may talk to the agents besides the owner, and what each tier may use. */
+	/** Who may talk to the agents besides the owner, by Discord user and role ids, as 0.8 wrote it. Deprecated with `owner`: write `access` instead. */
 	speakers?: { admins?: TierConfig; members?: TierConfig };
+	/**
+	 * Who the host serves: the owners, the first the primary one, and the admins and members by
+	 * identity (`<provider>:<subject>`), role (`<surface>:role:<name>`), or everyone. Required
+	 * unless the deprecated `owner` is given, and never with it.
+	 */
+	access?: AccessConfig;
+	/**
+	 * Each person's limits across all their conversations: `perPrincipal.schedules` they may keep and
+	 * `perPrincipal.delegations` running at once. Unset, only each conversation's, as in 0.8.
+	 */
+	background?: BackgroundConfig;
 	toolTiers?: Record<string, Tier>;
 	/** Prompt files, read once at start; `shared` starts every agent's prompt. */
 	prompts?: { shared: string; guest?: string };
-	/** The first team, created once; an agent already stored is never overwritten. */
+	/** The first team, created once; an agent already stored is never overwritten. Needs `discord`. */
 	agents?: AgentSeed[];
 	/**
-	 * Where the agents' avatars are served: the public address that reaches it, and the TCP port
-	 * (default 3000) or unix socket the process listens on. `socketMode` is the socket file's
-	 * permission bits (default `0o660`); widen it only for a proxy that runs as another user.
+	 * The `public` listener: the public address that reaches it, and the TCP port (default 3000) or
+	 * unix socket the process listens on. `socketMode` is the socket file's permission bits
+	 * (default `0o660`); widen it only for a proxy that runs as another user. With `discord` it is
+	 * required, with `publicUrl`, the address the agents' avatars are served from; without
+	 * `discord` leave it out when no plugin serves HTTP, and the host opens no listener.
 	 */
-	http: {
-		publicUrl: string;
+	http?: {
+		publicUrl?: string;
 		port?: number;
 		hostname?: string;
 		socketPath?: string;
@@ -109,13 +142,14 @@ export interface RoundtableConfig {
 	workDir?: string;
 	/**
 	 * The agents' scratch dir: their shell runs with TMPDIR pointing to it, and writes and removals
-	 * inside it run without a hold. Default `<os temp dir>/<discord.rootCommand>-scratch`.
+	 * inside it run without a hold. Default `<os temp dir>/<slug>-scratch`, where the slug is
+	 * `discord.rootCommand`, or the lowercase assistant name without Discord.
 	 */
 	scratchDir?: string;
 	/**
 	 * Where the skill registry reads built-in skills and keeps linked repositories. `false` leaves
 	 * the `skills` addon out: agents carry no skills, and no skill tools exist. Stored skills stay
-	 * in their tables.
+	 * in their tables. Without `discord` there are no agents, so the addon is off.
 	 */
 	skills?: false | { builtinDir?: string; reposDir?: string };
 	/**
@@ -123,8 +157,13 @@ export interface RoundtableConfig {
 	 * `memory` addon out: no memory tools, no memory prompt block, and the table stays as it is.
 	 */
 	memory?: boolean;
-	/** The agent that investigates the process's own errors, by name. */
-	ops?: { agent: string };
+	/**
+	 * Where the process's own errors are reported: to an agent, by name, in its channel (needs
+	 * `discord`), or to a conversation, by its key `<surface>:<id>`, as a visible message and a
+	 * report turn its claim answers. The host does not start when no chat surface serves the
+	 * conversation or no plugin's claim owns it; the web chat takes no error reports.
+	 */
+	ops?: { agent: string } | { conversation: string };
 	/**
 	 * Whether a turn posts the text it writes before its final answer as it goes: long or
 	 * structured text as ordinary messages, short narration and the tools called in one small
@@ -150,19 +189,14 @@ const isPlugin = (value: unknown): value is RoundtablePlugin =>
 
 const schema = shape({
 	name: optional(text),
-	owner: shape({
-		id: text,
-		name: text,
-		pronouns: optional(oneOf<Pronouns>("he", "she", "they")),
-	}),
-	discord: shape({
-		token: text,
-		guild: text,
-		entryChannel: text,
-		rootCommand: optional(text),
-		admin: optional(bool),
-		refusalHint: optional(text),
-	}),
+	owner: optional(
+		shape({
+			id: text,
+			name: text,
+			pronouns: optional(oneOf<Pronouns>("he", "she", "they")),
+		}),
+	),
+	discord: optional(discordShape),
 	database: shape({ url: text }),
 	dataDir: text,
 	agentDir: optional(text),
@@ -186,6 +220,17 @@ const schema = shape({
 	speakers: optional(
 		shape({ admins: optional(tierMembers), members: optional(tierMembers) }),
 	),
+	access: optional(accessShape),
+	background: optional(
+		shape({
+			perPrincipal: optional(
+				shape({
+					schedules: optional(integer(1, 10_000)),
+					delegations: optional(integer(1, 1_000)),
+				}),
+			),
+		}),
+	),
 	toolTiers: optional(record(oneOf<Tier>("owner", "admin", "member"))),
 	prompts: optional(shape({ shared: text, guest: optional(text) })),
 	agents: optional(
@@ -199,13 +244,15 @@ const schema = shape({
 			}),
 		),
 	),
-	http: shape({
-		publicUrl: text,
-		port: optional(integer(1, 65535)),
-		hostname: optional(text),
-		socketPath: optional(text),
-		socketMode: optional(integer(0, 0o777)),
-	}),
+	http: optional(
+		shape({
+			publicUrl: optional(text),
+			port: optional(integer(1, 65535)),
+			hostname: optional(text),
+			socketPath: optional(text),
+			socketMode: optional(integer(0, 0o777)),
+		}),
+	),
 	avatar: optional(text),
 	workDir: optional(text),
 	scratchDir: optional(text),
@@ -213,7 +260,7 @@ const schema = shape({
 		orOff(shape({ builtinDir: optional(text), reposDir: optional(text) })),
 	),
 	memory: optional(bool),
-	ops: optional(shape({ agent: text })),
+	ops: optional(shape({ agent: optional(text), conversation: optional(text) })),
 	interimText: optional(oneOf<InterimTextMode>("on", "off")),
 	interimPrimaryChars: optional(integer(1, 100_000)),
 	plugins: optional(
@@ -223,23 +270,37 @@ const schema = shape({
 	),
 });
 
-const PRONOUNS: Record<Pronouns, OwnerIdentity["pronouns"]> = {
-	he: { subject: "he", object: "him", possessive: "his" },
-	she: { subject: "she", object: "her", possessive: "her" },
-	they: { subject: "they", object: "them", possessive: "their" },
-};
-
 /** The configuration with every default filled in. */
 export interface ResolvedConfig {
 	name: string;
+	/**
+	 * The process's short name: the logger's and the scratch dir's, and the root slash command's
+	 * with Discord. `discord.rootCommand` when Discord is on, else the lowercase assistant name.
+	 */
+	slug: string;
+	/**
+	 * The primary owner, `access.owners[0]` (or the 0.8 `owner`): their principal id, name, and
+	 * pronouns, and the Discord user id the Discord parts act for until 0.10.
+	 */
+	primaryOwner: OwnerIdentity & { id: string; discordId?: string };
+	/** The primary owner as 0.8 knew them, `id` their principal id. Deprecated: read `primaryOwner`. */
 	owner: OwnerIdentity & { id: string };
-	discord: {
+	/** Who the host serves, the 0.8 `owner` and `speakers` converted when they are what the configuration gives. */
+	access: AccessRules;
+	/** What the configuration wrote in a deprecated form, which the host logs once. */
+	deprecations: string[];
+	/** Undefined on a host without Discord. */
+	discord?: {
 		token: string;
 		guild: string;
 		entryChannel: string;
 		rootCommand: string;
 		admin: boolean;
 		refusalHint?: string;
+		agentMemory?: "everyone" | "owners";
+		/** As configured: `{}` when left out, so the defaults apply, or `false`. */
+		channelContext: NonNullable<DiscordConfig["channelContext"]>;
+		freshMarker?: string | false;
 	};
 	databaseUrl: string;
 	dataDir: string;
@@ -250,12 +311,17 @@ export interface ResolvedConfig {
 	delegation: { model: ModelRef; thinking: ThinkingLevel };
 	locale: Locale;
 	timeZone: string;
+	/** The 0.8 `speakers`; empty when the configuration writes `access`. Deprecated: read `access`. */
 	speakers: { admins?: TierMembers; members?: TierMembers };
+	/** Each person's limits across their conversations; a limit left out is unset. */
+	background: { perPrincipal: PerPrincipalLimits };
 	toolTiers: Record<string, Tier>;
 	prompts: { shared?: string; guest?: string };
 	agents: AgentSeed[];
-	http: {
-		publicUrl: string;
+	/** Undefined when no `http` is configured, and the host opens no `public` listener. */
+	http?: {
+		/** Always set with Discord. */
+		publicUrl?: string;
 		port: number;
 		hostname?: string;
 		socketPath?: string;
@@ -267,7 +333,7 @@ export interface ResolvedConfig {
 	/** `false` when the skills addon is off. */
 	skills: false | { builtinDir?: string; reposDir?: string };
 	memory: boolean;
-	ops?: { agent: string };
+	ops?: { agent: string } | { conversation: ChannelKey };
 	interimText: InterimTextMode;
 	interimPrimaryChars: number;
 	plugins: RoundtablePlugin[];
@@ -282,32 +348,94 @@ function modelOf(value: string, path: string): ModelRef {
 	return parsed;
 }
 
+/** Where the errors go: one of an agent or a conversation; an agent only where the agents live. */
+function opsOf(
+	ops: { agent?: string; conversation?: string } | undefined,
+	withDiscord: boolean,
+): ResolvedConfig["ops"] {
+	if (!ops) return undefined;
+	const { agent, conversation } = ops;
+	if (agent !== undefined && conversation !== undefined)
+		throw new ConfigError(
+			"config ops: name an agent or a conversation, not both. Keep the one the reports go to.",
+		);
+	if (agent !== undefined) {
+		if (!withDiscord)
+			throw new ConfigError(
+				'config ops.agent: the agents live in Discord, which is not configured. Report to a conversation a plugin\'s chat surface serves instead, with ops: { conversation: "<surface>:<id>" }; the web chat takes no error reports.',
+			);
+		return { agent };
+	}
+	if (conversation === undefined)
+		throw new ConfigError(
+			'config ops: name an agent or a conversation, such as ops: { agent: "infra" } or ops: { conversation: "<surface>:<id>" }.',
+		);
+	if (!/^[^:]+:.+$/.test(conversation))
+		throw new ConfigError(
+			`config ops.conversation: expected a conversation key <surface>:<id>, got ${JSON.stringify(conversation)}. Write the surface's prefix, a colon, and the conversation's id.`,
+		);
+	return { conversation: conversation as ChannelKey };
+}
+
+/** Refuses what only the agent server serves on a host without Discord, naming the key. */
+function refuseAgentServerKeys(config: RoundtableConfig): void {
+	if (config.agents && config.agents.length > 0)
+		throw new ConfigError(
+			"config agents: the agents live in Discord, which is not configured. Configure discord, or remove agents.",
+		);
+	if (config.skills)
+		throw new ConfigError(
+			"config skills: the skills are the agents', and the agents live in Discord, which is not configured. Configure discord, or remove skills.",
+		);
+}
+
 /** The configuration checked against its schema, defaults filled; throws a ConfigError naming the key and the fix. */
 export function resolveConfig(input: unknown): ResolvedConfig {
-	const config = schema.check(input, "") as RoundtableConfig;
+	const config = schema.check(liftAdapters(input), "") as RoundtableConfig;
 	const name = config.name ?? "Roundtable";
 	const model = modelOf(config.model, "model");
 	const thinking = config.thinking ?? "medium";
-	const rootCommand =
-		config.discord.rootCommand ??
-		name.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+	const { discord, http } = config;
+	if (discord && !http?.publicUrl)
+		throw new ConfigError(
+			"config http.publicUrl: required with discord, expected the public address that reaches the bot; Discord fetches the agents' avatars from it. Add it to roundtable.config.ts.",
+		);
+	if (!discord) refuseAgentServerKeys(config);
+	const slug =
+		discord?.rootCommand ?? name.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+	const ops = opsOf(config.ops, discord !== undefined);
+	const access = accessOf(config, discord !== undefined);
+	const { primaryOwner } = access;
 	return {
 		name,
+		slug,
+		...access,
 		owner: {
-			id: config.owner.id,
-			name: config.owner.name,
-			pronouns: PRONOUNS[config.owner.pronouns ?? "they"],
-		},
-		discord: {
-			token: config.discord.token,
-			guild: config.discord.guild,
-			entryChannel: config.discord.entryChannel,
-			rootCommand,
-			admin: config.discord.admin ?? true,
-			...(config.discord.refusalHint === undefined
-				? {}
-				: { refusalHint: config.discord.refusalHint }),
+			id: primaryOwner.id,
+			name: primaryOwner.name,
+			pronouns: primaryOwner.pronouns,
 		},
+		...(discord
+			? {
+					discord: {
+						token: discord.token,
+						guild: discord.guild,
+						entryChannel: discord.entryChannel,
+						rootCommand: slug,
+						admin: discord.admin ?? true,
+						...(discord.refusalHint === undefined
+							? {}
+							: { refusalHint: discord.refusalHint }),
+						...(discord.agentMemory === undefined
+							? {}
+							: { agentMemory: discord.agentMemory }),
+						channelContext: discord.channelContext ?? {},
+						...(discord.freshMarker === undefined
+							? {}
+							: { freshMarker: discord.freshMarker }),
+					},
+				}
+			: {}),
 		databaseUrl: config.database.url,
 		dataDir: config.dataDir,
 		agentDir: config.agentDir ?? `${config.dataDir}/pi`,
@@ -331,24 +459,30 @@ export function resolveConfig(input: unknown): ResolvedConfig {
 			...(config.speakers?.admins ? { admins: config.speakers.admins } : {}),
 			...(config.speakers?.members ? { members: config.speakers.members } : {}),
 		},
+		background: { perPrincipal: { ...config.background?.perPrincipal } },
 		toolTiers: config.toolTiers ?? {},
 		prompts: config.prompts ?? {},
 		agents: config.agents ?? [],
-		http: {
-			publicUrl: config.http.publicUrl,
-			port: config.http.port ?? 3000,
-			...(config.http.hostname ? { hostname: config.http.hostname } : {}),
-			...(config.http.socketPath ? { socketPath: config.http.socketPath } : {}),
-			...(config.http.socketMode === undefined
-				? {}
-				: { socketMode: config.http.socketMode }),
-		},
+		...(http
+			? {
+					http: {
+						...(http.publicUrl ? { publicUrl: http.publicUrl } : {}),
+						port: http.port ?? 3000,
+						...(http.hostname ? { hostname: http.hostname } : {}),
+						...(http.socketPath ? { socketPath: http.socketPath } : {}),
+						...(http.socketMode === undefined
+							? {}
+							: { socketMode: http.socketMode }),
+					},
+				}
+			: {}),
 		...(config.avatar ? { avatar: config.avatar } : {}),
 		workDir: config.workDir ?? `${config.dataDir}/work`,
-		scratchDir: config.scratchDir ?? join(tmpdir(), `${rootCommand}-scratch`),
-		skills: config.skills ?? {},
+		scratchDir: config.scratchDir ?? join(tmpdir(), `${slug}-scratch`),
+		// Without Discord there are no agents to carry skills, so the addon is off.
+		skills: config.skills ?? (discord ? {} : false),
 		memory: config.memory ?? true,
-		...(config.ops ? { ops: config.ops } : {}),
+		...(ops ? { ops } : {}),
 		interimText: config.interimText ?? "on",
 		interimPrimaryChars: config.interimPrimaryChars ?? PRIMARY_CHARS,
 		plugins: config.plugins ?? [],

package/src/core/contract/channel-context.ts

@@ -0,0 +1,53 @@
+// What a surface tells a turn about the channel around the message it answers. Discord fills it
+// (`DISCORD.channelContext`); the types and the way a turn carries it are any surface's.
+
+/** How much of a channel a turn reads as its channel context; every member has a default. */
+export interface ChannelContextOptions {
+	/** How many messages before the addressed one are fetched; default 50, at most 100 (Discord's page). */
+	fetch?: number;
+	/** How many of the window's messages are kept, the newest; default 15. */
+	keep?: number;
+	/**
+	 * How alike (0 to 1) two consecutive messages of one author must be to count as one, the later
+	 * kept, such as a message and its corrected repost; default 0.8.
+	 */
+	similarity?: number;
+	/** Where a message's text is cut; default 500 characters. */
+	messageChars?: number;
+	/** Where another bot's message is cut; default 80 characters. */
+	botMessageChars?: number;
+}
+
+/** One channel message a turn reads around the message that addressed the assistant. */
+export interface ChannelContextMessage {
+	id: string;
+	authorId: string;
+	/** How the author appears in the channel. */
+	authorName: string;
+	/** Another bot, or an integration such as a webhook that is not the assistant's. */
+	bot: boolean;
+	/** One of the host's owners. */
+	owner: boolean;
+	/** The text, with mentions by name and stickers and files as text, cut where the options say. */
+	text: string;
+	at: Date;
+}
+
+/**
+ * What was said in a server channel since the assistant last posted there, before the message that
+ * addressed it: public channel text, not anyone's private memory, and not from the turn's speaker.
+ */
+export interface ChannelContext {
+	/** Oldest first; never empty. */
+	readonly messages: readonly ChannelContextMessage[];
+	/** The delimited block `withChannelContext` appends to a turn's text. */
+	readonly text: string;
+}
+
+/** The turn's text, then its channel context when there is one, as `withReference` adds a replied-to message. */
+export function withChannelContext(
+	text: string,
+	context: ChannelContext | undefined,
+): string {
+	return context ? `${text}\n\n${context.text}` : text;
+}