pi-roundtable 0.31.4 → 0.31.6

package/CHANGELOG.md

@@ -5,6 +5,16 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.31.6] - 2026-11-02
+
+### Changed
+
+- Channel context cuts a peer bot's message at the new option `peerMessageChars` (default 4000, an integer from 1 to 4000 in `discord.channelContext`), not at `botMessageChars` (80): a bot `discord.peerBots` lists with an entry that covers the addressed message's channel and server. A host that talks with a peer read only the first 80 characters of what the peer had said to others in the channel, such as a report a person then asked the host about. Every other bot's message is still cut at `botMessageChars`. The sandbox package's `channelContext` option takes `peerMessageChars` with the same bound.
+
+## [0.31.5] - 2026-11-02
+
+- Release in lockstep with pi-roundtable-web 0.31.5 (a temp knight's cards show in the room it was made from; answered thread cards survive trimming; a room's cards in opening order; the waiting chip follows redrawn slots); no core behavior changes.
+
 ## [0.31.4] - 2026-11-02
 
 - Release in lockstep with pi-roundtable-web 0.31.4 (a card asked in a dispatch thread or temp knight's room shows in the room above it, in the animated scene and the chat); no core behavior changes.

package/README.md

@@ -228,6 +228,7 @@ Tune it under `discord.channelContext`, or set `channelContext: false` to turn i
 | `similarity` | `0.8` | How alike two consecutive messages of one author must be to count as one |
 | `messageChars` | `500` | Where a message is cut |
 | `botMessageChars` | `80` | Where another bot's message is cut |
+| `peerMessageChars` | `4000` | Where a peer bot's message is cut (a bot `discord.peerBots` lists for the channel) |
 | `foreignWebhook` | none | `(webhookId) => boolean \| "skip"`: posts through the webhooks it returns true for are read as other people's messages, not the assistant's; `"skip"` drops a webhook's posts as if absent, without ending the window (code only) |
 | `attachments` | `{ images: 0, maxBytes: 10 MiB }` | `images`: how many images of the kept messages are fetched for the turn, at most 4 |
 

package/README.zh-TW.md

@@ -223,6 +223,7 @@ routing: {
 | `similarity` | `0.8` | 同一作者相鄰兩則訊息相似到什麼程度算同一則 |
 | `messageChars` | `500` | 訊息截斷的長度 |
 | `botMessageChars` | `80` | 其他 bot 訊息截斷的長度 |
+| `peerMessageChars` | `4000` | peer bot（`discord.peerBots` 為這個頻道列出的 bot）訊息截斷的長度 |
 | `foreignWebhook` | 無 | `(webhookId) => boolean \| "skip"`：回傳 true 的 webhook 所發的貼文視為別人的訊息，不是騎士自己的；回傳 `"skip"` 則把該 webhook 的貼文當作不存在，不納入也不截斷範圍（只能用程式碼設定） |
 | `attachments` | `{ images: 0, maxBytes: 10 MiB }` | `images`：替這一輪抓取保留訊息中的幾張圖片，最多 4 張 |
 

package/docs/plugins.md

@@ -2741,7 +2741,7 @@ It reads Discord, not the host's history, so it survives restarts:
 - It leaves out the assistant's own posts, the addressed message, empty messages, and every message it handed over before or that addressed it before in that channel, remembered in memory per channel, so a restart can repeat at most what came since the assistant's last post.
 - Other bots and integrations are kept and marked as bots; the host's owners (the primary owner and every other owner's Discord identities) are marked as owners.
 - Consecutive messages of one author at least `similarity` alike (default 0.8, by their longest common run of text) count as one, the later kept.
-- It keeps the newest `keep` (default 15), oldest first. Mentions read as names, and stickers and files as text with their names and links; by default nothing is downloaded or shown to the model as an image (see `attachments` below). A message is cut at `messageChars` (default 500), another bot's at `botMessageChars` (default 80).
+- It keeps the newest `keep` (default 15), oldest first. Mentions read as names, and stickers and files as text with their names and links; by default nothing is downloaded or shown to the model as an image (see `attachments` below). A message is cut at `messageChars` (default 500), another bot's at `botMessageChars` (default 80), and a peer bot's (one `discord.peerBots` lists for the channel, see below) at `peerMessageChars` (default 4000).
 - It never fails the turn over Discord: a Discord error, such as a channel the bot cannot read, is logged and the turn runs without context.
 
 A plugin may mirror an outside chat into a channel through a webhook of its own, created by the bot, so that the application owns it; by default such a post counts as the assistant's own, which ends the window and is left out, and the people mirrored never reach a turn. `foreignWebhook(webhookId)` changes that for the webhooks it returns true for: a post through one is another author's, kept like another bot's (`bot: true`, `authorName` the post's username, `authorId` the webhook's id) and no longer ends the window, which then ends only at the assistant's own posts: its bot user's and every webhook `foreignWebhook` returns false for, such as an agent's voice. It may also return `"skip"` for a webhook that is neither, such as one the plugin posts its own status notices through: a post through it is dropped from the context and does not end the window, as if it were not in the channel, so notices between two mirrored posts neither appear as someone's words nor cut the window, and they are not counted among the messages delivered. Any answer other than `true` and `"skip"` reads as false. A skipped post is still one of the `fetch` messages read, so it uses the budget the window is chosen from. The host sets it as `discord.channelContext.foreignWebhook` and a call overrides it for that call; being a function, it can be set only in code. `authors(message)` is the same decision for any surface and any message, not only a webhook's: it receives the fetched message (`ChannelContextSource`: `id`, `authorId`, `authorName`, `bot`, `own`, `webhookId?`, `external?`, `attachments?`, `at`, `text`) and answers `"keep"` (another author's, which does not end the window; `foreignWebhook` returning `true`), `"skip"` (dropped as if it were not in the channel, without ending the window; `"skip"` of `foreignWebhook`), `"end"` (the assistant's own, which ends the window and is left out; `foreignWebhook` returning `false` for an application webhook) or `undefined`, which leaves the default: the assistant's own posts end the window and everything else is kept. Where it answers, it wins over `foreignWebhook`; it is a function, so it can be set only in code, as a host default (`discord.channelContext.authors`) or per call. Posts through a webhook that `foreignWebhook` returns true for are merged as near repeats only when the poster's name is the same too, since one webhook carries many people; every other message merges by author alone, as before. An edited message reads as Discord now holds it.
@@ -2753,7 +2753,7 @@ Every returned message has `attachments` (`ChannelContextAttachment`: `name`, `c
 `DISCORD.channelContext` resolves undefined in a direct message, on another surface, when nothing new was said, and when the host's `discord.channelContext` is `false`, which turns it off for the agent server and every claim.
 The configuration's values are the host's defaults, and a call's `options` override them for that call.
 Call it once per answered message: what it returns is remembered as handed over.
-A call's `options` are validated like the configuration (`fetch`, `keep`, `messageChars` and `botMessageChars` positive integers, `similarity` from 0 to 1, `foreignWebhook` a function of a webhook id returning `true`, `false` or `"skip"`, `authors` a function of a message returning `"keep"`, `"skip"`, `"end"` or `undefined`, `attachments.images` an integer from 0 to 4, `attachments.maxBytes` an integer from 1 to 25 MiB); an invalid one makes the call reject, a programming error, so `keep: 0` is not "none" (skip the call for that).
+A call's `options` are validated like the configuration (`fetch`, `keep`, `messageChars`, `botMessageChars` and `peerMessageChars` positive integers, `similarity` from 0 to 1, `foreignWebhook` a function of a webhook id returning `true`, `false` or `"skip"`, `authors` a function of a message returning `"keep"`, `"skip"`, `"end"` or `undefined`, `attachments.images` an integer from 0 to 4, `attachments.maxBytes` an integer from 1 to 25 MiB); an invalid one makes the call reject, a programming error, so `keep: 0` is not "none" (skip the call for that).
 It remembers what it handed over and what addressed the assistant, not every message that ran a turn: a post a claim answered some other way, such as a webhook report turn or a steered message, can also come in the context of a later turn if the assistant has not posted since.
 
 What it returns is public channel text, visible to everyone in the channel; it is not private memory, carries no `privateTo`, and goes into the turn's text, so it lives in the conversation's history, not in the system prompt.
@@ -2866,7 +2866,7 @@ discord: {
 An id that is not a Discord id (17 to 20 digits) stops the start with a `ConfigError` that names its place in the list.
 The router, not each claim, applies the list: for a message from a listed bot it sets `InboundMessage.peerBot` and resolves a `speaker` for it through the identity service as for a person, so the host's `access` rules still decide whether that bot is served and at which tier (`discord:<id>` under `access.members` or `access.admins`, or `everyone` and `provisioning: "admitted"`); a bot the rules do not serve gets no turn. A peer is served through its identity and `everyone` only: the Discord roles it holds are not read, so a role rule meant for people never lifts a bot. A webhook is never a peer, and a surface's own `peerBot` is dropped.
 A channel answers at most `maxRounds` of the listed bots' messages in a row, counted when a claim takes the message; a person's message in the channel starts the count over, and the messages after the cap are ignored (logged at info).
-Channel context is unchanged: its window still starts after the assistant's last post and other bots' messages are still cut at `botMessageChars`.
+Channel context's window still starts after the assistant's last post. A listed peer's messages in a channel its entry covers are cut at `peerMessageChars` (default 4000), so the host reads what the peer said to others in full, such as a report it was asked about; every other bot's are still cut at `botMessageChars`.
 
 When a person addresses two bots in one message, both would answer. An entry with `yields: true` makes the host leave such a message to that peer: a person's message (not in a direct conversation) that mentions or replies to the host and also mentions the peer or replies to its message, in a channel the entry covers, starts no turn here (logged at info as `message left to a peer bot`; observers still hear it). The peer answers alone and hands over by mentioning the host, which answers a listed peer as usual. Set it on one host only, and scope the entry with `guilds` or `channels` to where the peer actually answers; two hosts that yield to each other both stay silent. The router reads `InboundMessage.mentionedUserIds` (every user the message mentions) and `InboundMessage.reference.authorId` (who wrote the replied-to message), which the Discord surface sets.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable",
-	"version": "0.31.4",
+	"version": "0.31.6",
 	"description": "A plugin-driven Pi agent server for one owner, reached through Discord or the web",
 	"type": "module",
 	"license": "MIT",

package/src/core/builtin/discord.ts

@@ -24,6 +24,7 @@ import { restOf, restPoster } from "../discord/poster/rest-poster.ts";
 import { stopButtonModule } from "../discord/stop-button.ts";
 import type { InboundMessage } from "../domain/conversation.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
+import { PeerBots, type PeerBotsConfig } from "../routing/peer-bots.ts";
 import { IDENTITY, THREADS } from "../services.ts";
 import type { DispatchThreads } from "../threads/dispatch-threads.ts";
 
@@ -77,6 +78,8 @@ export interface DiscordOptions {
 	refusalHint?: string;
 	/** The host's channel context settings; `false` turns it off. Default: on, with the defaults. */
 	channelContext?: ChannelContextOptions | false;
+	/** The host's peer bots (`discord.peerBots`): channel context cuts their messages at `peerMessageChars`. Default none. */
+	peerBots?: PeerBotsConfig;
 	/** The divider posted in a server channel when its conversation starts over; `false` posts none. Default: a short English divider. */
 	freshMarker?: string | false;
 	/** What the model is told about how replies render in Discord; `false` tells it nothing. Default: Markdown renders, except tables. */
@@ -198,10 +201,19 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 				...(identity ? { identity } : {}),
 				logger,
 			});
+			const peers = options.peerBots
+				? new PeerBots(options.peerBots, "discord", "discord.peerBots")
+				: undefined;
 			const context = new ChannelContextReader({
 				read: (channelId, before, limit) =>
 					connected.messagesBefore(channelId, before, limit),
 				owners: () => owners.ids(),
+				...(peers
+					? {
+							peer: (authorId: string, message: InboundMessage) =>
+								peers.listsBot(authorId, message),
+						}
+					: {}),
 				settings: options.channelContext ?? {},
 				logger,
 			});

package/src/core/config/adapters.ts

@@ -166,6 +166,7 @@ const channelContextShape = shape({
 	similarity: optional(number(0, 1)),
 	messageChars: optional(integer(1, 4000)),
 	botMessageChars: optional(integer(1, 4000)),
+	peerMessageChars: optional(integer(1, 4000)),
 	foreignWebhook: optional(
 		guarded(
 			"a function of a webhook id",

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

@@ -23,6 +23,12 @@ export interface ChannelContextOptions {
 	messageChars?: number;
 	/** Where another bot's message is cut; default 80 characters. */
 	botMessageChars?: number;
+	/**
+	 * Where a message of a peer bot is cut: a bot the host lists in `discord.peerBots` whose entry
+	 * covers the channel, since the host talks with it and reads what it says; default 4000
+	 * characters. Any other bot's message is cut at `botMessageChars`.
+	 */
+	peerMessageChars?: number;
 	/**
 	 * Whether a post through a webhook of the assistant's own application is another author's, not
 	 * the assistant's. `webhookId` is the webhook's id; when this returns true the post is kept as a

package/src/core/define-roundtable.ts

@@ -158,6 +158,7 @@ function discordAssembly(
 				? {}
 				: { refusalHint: discord.refusalHint }),
 			channelContext: discord.channelContext,
+			...(discord.peerBots ? { peerBots: discord.peerBots } : {}),
 			...(discord.freshMarker === undefined
 				? {}
 				: { freshMarker: discord.freshMarker }),

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

@@ -36,6 +36,7 @@ export const CHANNEL_CONTEXT_DEFAULTS: Readonly<
 	similarity: 0.8,
 	messageChars: 500,
 	botMessageChars: 80,
+	peerMessageChars: 4_000,
 	foreignWebhook: () => false,
 	authors: () => undefined,
 	attachments: Object.freeze({ images: 0, maxBytes: 10 * 1024 * 1024 }),
@@ -63,9 +64,22 @@ function resolvedSettings(
 
 /** Throws on a value outside what the configuration accepts: a programming error of the caller. */
 function assertChannelContextSettings(settings: ChannelContextSettings): void {
-	const { fetch, keep, similarity, messageChars, botMessageChars } = settings;
+	const {
+		fetch,
+		keep,
+		similarity,
+		messageChars,
+		botMessageChars,
+		peerMessageChars,
+	} = settings;
 	const { images, maxBytes } = settings.attachments;
-	const positive = { fetch, keep, messageChars, botMessageChars };
+	const positive = {
+		fetch,
+		keep,
+		messageChars,
+		botMessageChars,
+		peerMessageChars,
+	};
 	for (const [name, value] of Object.entries(positive))
 		if (!Number.isInteger(value) || value < 1)
 			throw new RangeError(
@@ -217,12 +231,32 @@ export interface ChannelContextSelection {
 	seen: ReadonlySet<string>;
 	/** The owners' user ids. */
 	owners: readonly string[];
+	/** Whether a bot author is a peer the host talks with here, cut at `peerMessageChars`; without it none is. */
+	peer?: (authorId: string) => boolean;
 	/** What the selection reads of the settings; without `foreignWebhook` every webhook of the application is the assistant's. */
 	settings: Omit<
 		ChannelContextSettings,
-		"foreignWebhook" | "authors" | "attachments"
+		"foreignWebhook" | "authors" | "attachments" | "peerMessageChars"
 	> &
-		Partial<Pick<ChannelContextSettings, "foreignWebhook" | "authors">>;
+		Partial<
+			Pick<
+				ChannelContextSettings,
+				"foreignWebhook" | "authors" | "peerMessageChars"
+			>
+		>;
+}
+
+/** Where a kept message is cut: a person's, a peer bot's, or another bot's limit. */
+function limitOf(
+	message: ContextSourceMessage,
+	{ peer, settings }: ChannelContextSelection,
+): number {
+	if (!message.bot) return settings.messageChars;
+	if (peer?.(message.authorId))
+		return (
+			settings.peerMessageChars ?? CHANNEL_CONTEXT_DEFAULTS.peerMessageChars
+		);
+	return settings.botMessageChars;
 }
 
 /**
@@ -232,8 +266,9 @@ export interface ChannelContextSelection {
  */
 export function selectChannelContext(
 	fetched: readonly ContextSourceMessage[],
-	{ seen, owners, settings }: ChannelContextSelection,
+	selection: ChannelContextSelection,
 ): { messages: ChannelContextMessage[]; window: string[] } {
+	const { seen, owners, settings } = selection;
 	// `authors` says whose a message is; without an answer, a webhook of the application that the
 	// host calls foreign (`foreignWebhook`) speaks for other people, one it calls "skip" speaks for
 	// no one, and the rest is the assistant's when it posted it. A skipped post is not in the channel
@@ -270,10 +305,7 @@ export function selectChannelContext(
 		)
 		.map((message) => ({
 			...message,
-			text: cut(
-				message.text,
-				message.bot ? settings.botMessageChars : settings.messageChars,
-			),
+			text: cut(message.text, limitOf(message, selection)),
 		}));
 	const kept = merged(fresh, settings.similarity, foreign).slice(
 		-settings.keep,
@@ -326,6 +358,8 @@ export interface ChannelContextReaderOptions {
 	): Promise<readonly ContextSourceMessage[] | undefined>;
 	/** The owners' Discord user ids. */
 	owners(): Promise<readonly string[]>;
+	/** Whether a bot is a peer the host lists for the addressed message's channel (`discord.peerBots`); without it no bot is. */
+	peer?: (authorId: string, message: InboundMessage) => boolean;
 	/** The host's settings; `false` turns channel context off for every claim. */
 	settings: ChannelContextOptions | false;
 	logger: Logger;
@@ -371,10 +405,14 @@ export class ChannelContextReader {
 			);
 			if (!fetched) return undefined;
 			const owners = await this.#owners();
+			const peer = this.#options.peer;
 			const { messages, window } = selectChannelContext(fetched, {
 				seen,
 				owners,
 				settings,
+				...(peer
+					? { peer: (authorId: string) => peer(authorId, message) }
+					: {}),
 			});
 			for (const id of window) seen.add(id);
 			this.#trim(seen);

package/src/core/host.ts

@@ -54,6 +54,8 @@ export interface RoundtableOptions {
 	/**
 	 * The other bots on Discord whose mentions and replies are answered like a guest's (what
 	 * `discord.peerBots` sets); without it no bot is. Stops the start for an id that is not a Discord id.
+	 * A host composed by hand passes the same value to `discordPlugin` too, so channel context cuts
+	 * the peers' messages at `peerMessageChars`; `defineRoundtable` does both.
 	 */
 	peerBots?: PeerBotsConfig;
 	/** The model the default judge asks, when no plugin provides a judge. */

package/src/core/routing/peer-bots.ts

@@ -106,6 +106,11 @@ export class PeerBots {
 		return this.#listsHere(message.authorId, message) !== undefined;
 	}
 
+	/** Whether the host lists this bot for the message's channel and server, whoever wrote the message. */
+	listsBot(botId: string, message: InboundMessage): boolean {
+		return this.#listsHere(botId, message) !== undefined;
+	}
+
 	/**
 	 * The peer bot a person's message addressed to the host is left to: one the host lists here with
 	 * `yields` that the message also mentions or replies to; undefined when the host answers it.