pi-roundtable 0.8.0 → 0.9.0

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

@@ -1,4 +1,8 @@
 import { attachmentsOf } from "../attachments/turn-attachments.ts";
+import {
+	type ChannelContext,
+	withChannelContext,
+} from "../contract/channel-context.ts";
 import type {
 	Admission,
 	BackgroundTarget,
@@ -8,12 +12,13 @@ import type {
 import type { AgentRuntime } from "../contract/runtime.ts";
 import type { SurfacePort } from "../contract/surface.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
-import { messages } from "../i18n/index.ts";
 import type { OwnerIdentity } from "../identity.ts";
 import type { Logger } from "../log.ts";
+import { PERSONAL_TARGET } from "../modules/background/personal-target.ts";
 import { withReference } from "../routing/message-text.ts";
 import { outcome } from "../routing/settle-turn.ts";
-import { addressee, attributed, type SpeakerPolicy } from "../speakers.ts";
+import { systemTurn } from "../routing/system-turns.ts";
+import { addressee, attributed } from "../speakers.ts";
 import type { DiscordAgentTeam } from "./agent-team.ts";
 import { discordIdOf } from "./team-keys.ts";
 
@@ -27,23 +32,15 @@ import { discordIdOf } from "./team-keys.ts";
 export const AGENT_SERVER_PRIORITY = 100;
 
 /**
- * The host's own background target: the conversations of the owner and of the agent server. The
- * agent server contributes it, so schedules and delegated tasks made in those conversations carry
- * its name and limits. Its label is read when a list is shown, never when this module loads,
- * because the host applies its catalog at startup.
+ * The host's own background target, which the agent server answers.
+ * @deprecated Use `PERSONAL_TARGET`, the same target, which the core contributes on every host;
+ * this name goes away in 1.0.
  */
-export const OWNER_TARGET: BackgroundTarget = {
-	name: "owner",
-	label: () => messages().scheduleModeOwner,
-	schedules: { perChannel: 20, promptChars: 8_000, aheadDays: 366 },
-	delegation: { maxRunning: 3 },
-};
+export const OWNER_TARGET: BackgroundTarget = PERSONAL_TARGET;
 
 export interface AgentClaimOptions {
 	/** The owner, as forwarded messages name them. */
 	owner: OwnerIdentity;
-	/** Who may talk to the agents, and at which tier. */
-	speakers: SpeakerPolicy;
 	team: Pick<
 		DiscordAgentTeam,
 		| "guildId"
@@ -60,6 +57,13 @@ export interface AgentClaimOptions {
 	logger: Logger;
 	/** Replaceable in tests. */
 	fetchImpl?: typeof fetch;
+	/**
+	 * What was said in an agent's channel since its last post, `DISCORD.channelContext`; without it
+	 * the turns carry none. A group's round carries what was said since its last turn already.
+	 */
+	channelContext?: (
+		message: InboundMessage,
+	) => Promise<ChannelContext | undefined>;
 }
 
 /**
@@ -68,24 +72,39 @@ export interface AgentClaimOptions {
  * failure notice, is a labelled report turn for the agent.
  */
 export function agentClaim(options: AgentClaimOptions): ChannelClaim {
-	const { speakers, team, runtime, surface, attachmentDir, logger, fetchImpl } =
-		options;
+	const { team, runtime, surface, attachmentDir, logger, fetchImpl } = options;
 	const attachments = (message: InboundMessage) =>
 		attachmentsOf(message, attachmentDir(message.channel), logger, fetchImpl);
+	/** The channel context of a message in an agent's channel; none, logged, when it cannot be read. */
+	const around = async (
+		message: InboundMessage,
+	): Promise<ChannelContext | undefined> => {
+		try {
+			return await options.channelContext?.(message);
+		} catch (error) {
+			logger.warn(
+				{ channel: message.channel, err: error },
+				"channel context not read; the turn runs without it",
+			);
+			return undefined;
+		}
+	};
 
 	const webhookReport = (message: InboundMessage): Admission | undefined => {
 		const text = message.text.trim();
 		if (!text) return undefined;
 		return {
 			kind: "background",
-			turn: {
+			// The host's own turn, at the owner tier as in 0.8; what the webhook posted is untrusted input.
+			turn: systemTurn({
 				channel: message.channel,
-				target: OWNER_TARGET.name,
+				target: PERSONAL_TARGET.name,
 				author: { id: message.authorId, name: message.authorName },
+				tier: "owner",
 				turnId: `webhook-${message.messageId}`,
 				text: `Webhook "${message.authorName}" posted in your channel:\n${text}`,
 				report: true,
-			},
+			}),
 			unanswered: (result) =>
 				logger.warn(
 					{
@@ -112,13 +131,9 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 			if (!owned) return undefined;
 			if (owned === "agent" && message.integration && !message.integration.own)
 				return webhookReport(message);
-			if (message.authorIsBot) return undefined;
-			const speaker = speakers.resolve({
-				id: message.authorId,
-				name: message.authorName,
-				...(message.authorRoleIds ? { roleIds: message.authorRoleIds } : {}),
-			});
-			if (!speaker) return undefined;
+			// Who may talk to the agents, and at which tier, the router resolved through the identity service.
+			const { speaker } = message;
+			if (message.authorIsBot || !speaker) return undefined;
 			const { channel, messageId } = message;
 			const forwarder = addressee(speaker, options.owner);
 			return {
@@ -147,7 +162,10 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 						await team.answerOwner(
 							channel,
 							speaker,
-							attributed(speaker, text),
+							attributed(
+								speaker,
+								withChannelContext(text, await around(message)),
+							),
 							message.text,
 							saved,
 						);
@@ -166,22 +184,26 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 		},
 		background: async (turn) => {
 			// Fail closed: a turn for any target but the owner's never reaches the owner's tools.
-			if (turn.target !== OWNER_TARGET.name)
+			if (turn.target !== PERSONAL_TARGET.name)
 				return {
 					status: "skipped",
-					reason: `the agent server answers only "${OWNER_TARGET.name}" background turns`,
+					reason: `the agent server answers only "${PERSONAL_TARGET.name}" background turns`,
 				};
 			const owned = team.owns(turn.channel);
 			if (owned === "group")
 				return { status: "skipped", reason: "groups have no schedules" };
+			// Who the turn runs as, checked by the router: its author's principal, at a tier they hold.
+			const { speaker } = turn;
+			if (!speaker)
+				return {
+					status: "skipped",
+					reason:
+						"a background turn reaches the agent server through the router, which says whom it runs as",
+				};
 			return outcome(
 				await team.answerBackground(
 					turn.channel,
-					{
-						id: turn.author.id,
-						name: turn.author.name,
-						tier: turn.tier ?? "owner",
-					},
+					speaker,
 					turn.text,
 					turn.report === true,
 				),

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

@@ -144,12 +144,16 @@ export class TeamTurns {
 	}
 
 	/**
-	 * Whether the speaker may approve the held actions: the owner, or the speaker whose turn held
-	 * them, when their tier now holds every tool. Nobody else in the channel may.
+	 * Whether the speaker may approve the held actions by a message: an owner, as the agents'
+	 * channels are shared, or the principal whose turn held them (by their id, for actions held
+	 * before 0.9), when their tier now holds every tool. Nobody else in the channel may.
 	 */
 	#mayApprove(speaker: Speaker, pending: PendingConfirmation): boolean {
-		if (speaker.tier !== "owner" && speaker.id !== pending.speakerId)
-			return false;
+		const theirs =
+			pending.principalId !== undefined
+				? speaker.principalId === pending.principalId
+				: speaker.id === pending.speakerId;
+		if (speaker.tier !== "owner" && !theirs) return false;
 		const tiers = this.#options.toolTiers ?? toolTiers();
 		return pending.calls.every(
 			(call) =>

package/src/core/builtin/agent-server.ts

@@ -2,7 +2,7 @@ import { chmodSync, lstatSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
 import type { SQL } from "bun";
-import { agentClaim, OWNER_TARGET } from "../agents/agent-claim.ts";
+import { agentClaim } from "../agents/agent-claim.ts";
 import { AgentDashboard } from "../agents/agent-dashboard.ts";
 import { PgAgentStore } from "../agents/agent-store.ts";
 import { DiscordAgentTeam } from "../agents/agent-team.ts";
@@ -30,7 +30,7 @@ import {
 	SKILLS,
 } from "../services.ts";
 import type { SessionTool } from "../sessions.ts";
-import type { SpeakerPolicy, Tier } from "../speakers.ts";
+import type { Tier } from "../speakers.ts";
 import { DISCORD } from "./discord.ts";
 import { agentOnly } from "./session-tool.ts";
 
@@ -41,8 +41,6 @@ export interface AgentServerOptions {
 	owner: OwnerIdentity & { id: string };
 	/** The assistant's display name, as the confirmation judge names it. */
 	assistant: string;
-	/** Who may talk to the agents, and at which tier. */
-	speakers: SpeakerPolicy;
 	/** Shared with the rest of the host, so logins refresh in one place; lists the models an agent may run. */
 	modelRuntime: ModelRuntime;
 	dataDir: string;
@@ -61,6 +59,11 @@ export interface AgentServerOptions {
 	scratchDir?: string;
 	/** The host account the agents' shell and file tools run as. */
 	shellUser: string;
+	/**
+	 * Whose turns in the agents' channels load memory: `"everyone"` (the default) or `"owners"`;
+	 * see `AgentSessions.memory`.
+	 */
+	memory?: "everyone" | "owners";
 	/** The prompt every agent starts with, and the one for speakers other than the owner. */
 	prompts: { shared: string; guest?: string };
 	/** The listener the avatar pictures are served on. */
@@ -225,6 +228,7 @@ export function agentServerPlugin(
 				modelOf: (name) => built.modelOf(name),
 				skills: (name) => built.skillsOf(name),
 				turnChannel: (scope) => built.turnChannel(scope),
+				...(options.memory ? { memory: options.memory } : {}),
 			};
 			options.agents?.bind(agentSessions);
 			context.services.provide(AGENTS, {
@@ -276,17 +280,15 @@ export function agentServerPlugin(
 						},
 					},
 				],
-				// The schedules and delegated tasks of the owner's and the agents' conversations are its own.
-				backgroundTargets: [OWNER_TARGET],
 				channels: [
 					agentClaim({
 						owner: options.owner,
-						speakers: options.speakers,
 						team: built,
 						runtime: running,
 						surface: context.surfaces,
 						attachmentDir,
 						logger,
+						channelContext: (message) => discord.channelContext(message),
 					}),
 				],
 				http: [studio.route(options.avatarListener)],

package/src/core/builtin/discord-admin.ts

@@ -8,7 +8,10 @@ import { DISCORD } from "./discord.ts";
 import { fixed } from "./session-tool.ts";
 
 export interface DiscordAdminOptions {
-	/** Whose Discord permissions the tools check, and who they serve. */
+	/**
+	 * Whose Discord permissions the tools check, and who they serve: the primary owner, by their
+	 * Discord user id, whichever owner's turn calls them.
+	 */
 	owner: OwnerIdentity & { id: string };
 }
 

package/src/core/builtin/discord.ts

@@ -1,7 +1,14 @@
 import { join } from "node:path";
+import type {
+	ChannelContext,
+	ChannelContextOptions,
+} from "../contract/channel-context.ts";
 import { type ServiceKey, serviceKey } from "../contract/services.ts";
+import { ChannelContextReader } from "../discord/channel-context.ts";
 import { CommandCollection } from "../discord/command-collection.ts";
 import type { DiscordConnection } from "../discord/connection.ts";
+import { discordDirectChannel } from "../discord/direct-channel.ts";
+import { DiscordOwners } from "../discord/discord-owners.ts";
 import { DiscordSurface } from "../discord/discord-surface.ts";
 import { DispatchThreads } from "../discord/dispatch-threads.ts";
 import type {
@@ -9,20 +16,33 @@ import type {
 	CommandRegistrar,
 } from "../discord/interaction-module.ts";
 import { OwnerCards } from "../discord/owner-cards.ts";
-import { OwnerGuard, ownerRootCommand } from "../discord/owner-command.ts";
+import { commandGuard, ownerRootCommand } from "../discord/owner-command.ts";
 import { stopButtonModule } from "../discord/stop-button.ts";
+import type { InboundMessage } from "../domain/conversation.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
-import type { SpeakerPolicy } from "../speakers.ts";
+import { IDENTITY } from "../services.ts";
 
 /** The Discord connection and what stands on it, as plugins use it. Provided by the Discord plugin. */
 export interface DiscordServices {
 	connection: DiscordConnection;
 	/** Adds a plugin's slash commands and components; during setup only. */
 	commands: CommandRegistrar;
-	/** Who may use the owner's commands. */
+	/** Who may use the owner's commands: every owner, by their Discord identity. */
 	guard: CommandGuard;
 	/** The threads that carry background reports. */
 	threads: DispatchThreads;
+	/**
+	 * What was said in a server channel since the assistant last posted there, before `message`:
+	 * for a claim that answers it, to append to its turn's text with `withChannelContext`. Call it
+	 * once per answered message, inside the turn's `run`: the messages it returns, and `message`,
+	 * are remembered per channel and not returned again. Undefined in a direct message, on another
+	 * surface, when the host's `discord.channelContext` is `false`, when nothing new was said, and
+	 * when Discord cannot be read (logged). Never rejects. `options` override the host's for this call.
+	 */
+	channelContext(
+		message: InboundMessage,
+		options?: ChannelContextOptions,
+	): Promise<ChannelContext | undefined>;
 }
 
 /** The Discord connection, provided by the Discord plugin. */
@@ -31,16 +51,22 @@ export const DISCORD: ServiceKey<DiscordServices> =
 
 export interface DiscordOptions {
 	token: string;
+	/**
+	 * The primary owner's Discord user id: an owner always, and the one the admin tools act as.
+	 * Every other owner the identity service knows uses the owner's commands and cards too.
+	 */
 	ownerId: string;
-	/** How the owner is named in audit-log reasons and refusals. */
+	/** How the primary owner is named in audit-log reasons and refusals. */
 	ownerName: string;
-	/** Who may answer a card besides the owner. */
-	speakers: SpeakerPolicy;
 	dataDir: string;
 	/** The name of the root slash command, without the slash. */
 	rootCommand: string;
 	/** Text appended as it is to the refusal a non-owner gets, such as a pointer to the commands anyone may use. */
 	refusalHint?: string;
+	/** The host's channel context settings; `false` turns it off. Default: on, with the defaults. */
+	channelContext?: ChannelContextOptions | false;
+	/** The divider posted in a server channel when its conversation starts over; `false` posts none. Default: a short English divider. */
+	freshMarker?: string | false;
 }
 
 /**
@@ -62,10 +88,12 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 			);
 		},
 		setup: async ({ conversations, services, logger }) => {
+			const identity = services.find(IDENTITY);
 			// The surface exists by the time a turn posts a card.
 			const cards: OwnerCards = new OwnerCards({
 				ownerId: options.ownerId,
-				speakers: options.speakers,
+				// Who may answer a card besides the primary owner, by the identity service.
+				...(identity ? { identity } : {}),
 				channel: (channelId) => connected.cardChannel(channelId),
 				logger,
 			});
@@ -73,16 +101,23 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 				token: options.token,
 				ownerId: options.ownerId,
 				ownerName: options.ownerName,
-				prompts: (channel, speaker) => cards.prompts(channel, speaker),
+				prompts: (channel, scope) => cards.prompts(channel, scope),
 				logger,
+				...(options.freshMarker === undefined
+					? {}
+					: { freshMarker: options.freshMarker }),
 			});
 			surface = connected;
-			const guard = new OwnerGuard(
-				options.ownerId,
+			// Every owner may use the owner's commands, by the identity service; the primary owner always.
+			const guard = commandGuard({
+				ownerId: options.ownerId,
+				...(identity ? { identity } : {}),
+				root: options.rootCommand,
 				logger,
-				options.rootCommand,
-				options.refusalHint,
-			);
+				...(options.refusalHint === undefined
+					? {}
+					: { refusalHint: options.refusalHint }),
+			});
 			// A channel whose claim keeps reports in place, such as an open channel, opens no thread.
 			const threads = new DispatchThreads({
 				host: {
@@ -101,15 +136,38 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 			collection.registrar.add({
 				module: stopButtonModule({ guard, conversations }),
 			});
+			// Marks the owners in channel context: the primary owner, and every other owner's Discord identities.
+			const owners = new DiscordOwners({
+				ownerId: options.ownerId,
+				...(identity ? { identity } : {}),
+				logger,
+			});
+			const context = new ChannelContextReader({
+				read: (channelId, before, limit) =>
+					connected.messagesBefore(channelId, before, limit),
+				owners: () => owners.ids(),
+				settings: options.channelContext ?? {},
+				logger,
+			});
 			services.provide(DISCORD, {
 				connection: connected,
 				commands: collection.registrar,
 				guard,
 				threads,
+				channelContext: (message, given) => context.of(message, given),
 			});
 			return {
 				// The host starts the surface first; it registers the composed commands as it connects.
 				surfaces: [connected],
+				// A person's Discord direct messages, through a Discord identity of theirs.
+				directChannels: [
+					discordDirectChannel({
+						directChannel: (userId) => connected.directChannel(userId),
+						sendDirect: (userId, text) => connected.sendDirect(userId, text),
+						...(identity ? { identity } : {}),
+						ownerId: options.ownerId,
+					}),
+				],
 				services: [
 					// The sweep reads threads through the connection, so it follows the surface's start.
 					{ name: "threads", start: () => void threads.sweep() },