pi-roundtable-mcp 0.16.0 → 0.17.1

package/CHANGELOG.md

@@ -5,6 +5,18 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.17.1] - 2026-10-16
+
+- Release in lockstep with pi-roundtable 0.17.1; no package-specific behavior changes. The core peer range stays `>=0.17.0 <0.18.0`.
+
+## [0.17.0] - 2026-10-16
+
+### Changed
+
+- **Breaking for plugins that read `CONNECTORS` while they set up:** `CONNECTORS.list()`, `servers()` and `profileSources()` are empty during `setup` (and `version` is 0), because `mcpConnectors` no longer reads the database or reaches the gateway there. It reads them in its `preflight`, which the host runs after every plugin is set up and before any service starts or any listener opens, and `version` changes when it has. Read the list from a service's `start`, or later (a turn, a command, a request); a host that cached tool sets by `version` before the host started rebuilds them once. `ConnectorRegistry.attach` is synchronous, and a new `load()` does the reading. The runtime's startup tool probe runs before this preflight, so it does not see the connectors' servers: a `requiredTools` entry that only a connector's server provides fails the start; the first real session connects to them instead.
+- `mcpConnectors` and `remoteMcp` no longer query the database, or reach the gateway, during `setup`, so `Roundtable.check()` passes with them and needs neither. `remoteMcp` reads the principal the dispatch token stands for, and adopts the sessions and conversations of earlier versions, in its `preflight` too; a persona and the relay note read the principal when a conversation opens. Because both run before any service starts, no command or turn sees an empty connector list, and a failure there still stops the start before a surface connects. Which error stops the start where: a principal that does not exist, and a token linked to someone else by the configuration or the CLI, are refused by the identity plugin's setup as before; only a token linked to no one, which needs an `IDENTITY` that replaces the built-in plugin, is now refused in `remoteMcp`'s `preflight`, with the same message and without the `setup failed` prefix. A database error while adopting earlier sessions is now raised there too.
+- Release in lockstep with pi-roundtable 0.17.0. The core peer range moves to `>=0.17.0 <0.18.0`.
+
 ## [0.16.0] - 2026-10-16
 
 - Release in lockstep with pi-roundtable 0.16.0; no package-specific behavior changes. The core peer range moves to `>=0.16.0 <0.17.0`.

package/README.md

@@ -110,6 +110,7 @@ It provides the `CONNECTORS` service (`Connectors`):
 | `resolve(serverName)` | Reads one virtual server's URL and tools by name, for servers the host manages itself rather than as connectors |
 | `admin` | `gateways()` and `servers()`: what ContextForge holds, upstream gateways with their state and every virtual server with its tool names, for a host's status view |
 
+The plugin reads the stored connectors, and resolves each one's server in ContextForge, in its `preflight`, which the host runs after every plugin is set up and before any service starts or any listener opens: during `setup` `list()`, `servers()` and `profileSources()` are empty and `version` is 0, and `version` changes once the connectors are loaded. Read them from a service's `start`, or later (a turn, a command, a request); no command or turn arrives before they are loaded. `resolve(serverName)` and `token` work from setup. A host's `Roundtable.check()` runs no preflight, so it needs neither the database nor ContextForge. The runtime's startup tool probe runs before this preflight, so it does not see the connectors' servers: a `requiredTools` entry that only a connector's server provides fails the start; the first real session connects to them instead.
 The plugin does not decide which agent uses which connector.
 The host reads the service, builds its own profiles, and compares `version` with the one it built at.
 A plugin registered after `mcpConnectors` can read the list like this:
@@ -217,7 +218,7 @@ The conversation is recorded as private to that principal.
 Nothing is posted to Discord, since no chat surface serves `mcp:` channels; the outside agent polls for the answer.
 A relayed message that the host's judge reads as approving held actions confirms them, as the person's own reply would.
 Each message begins with a short note that says it was written in an outside agent: for an owner, the note and the persona name the owner, word for word as in 0.8; for anyone else they name no owner, so the agent does not take them for one.
-Which of the two is chosen at the start, by whether the principal then holds the owner role.
+Which of the two is chosen at the start, by whether the principal then holds the owner role: the plugin reads the principal, and adopts the sessions and conversations of earlier versions, in its `preflight`, before any service starts and the listeners open, so a request never arrives before it. A conversation's persona and relay note read it when the conversation opens.
 Starting a remote conversation over archives it, and deleting it also ends the outside agent's session.
 Sessions that stay idle for 14 days are deleted once a day.
 
@@ -267,7 +268,7 @@ export function hostRemote(dispatchToken: string, publicUrl: string) {
 The dispatch token is the identity `token:<toolNames.dispatch, or remote-mcp>`, which the plugin declares in its `identities`.
 At every start the host links it to `principal`, or to the primary owner without one, as in 0.8.
 `roundtable principal list` shows it under that principal as `token:remote-mcp  (plugin remote-mcp)`, and `roundtable principal unlink` refuses it: change the option instead.
-The start stops when the principal does not exist, or when the identity is linked to someone else by the configuration or the CLI; the error names what to change.
+The start stops when the principal does not exist, or when the identity is linked to someone else by the configuration or the CLI (the identity plugin refuses either as it sets up), or when `IDENTITY` links the token to no one (the plugin's `preflight`); the error names what to change.
 
 Bound to a member, a remote turn reads and changes the member's memory, and only the tools of their tier are offered; when the host runs the conversations itself, that holds only if its `answer` runs the turn as the `speaker` it receives.
 Give that member a lasting role with `roundtable principal grant <principal> member` (or `admin`).

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable-mcp",
-	"version": "0.16.0",
+	"version": "0.17.1",
 	"description": "MCP connectors through ContextForge and a remote MCP endpoint for pi-roundtable",
 	"type": "module",
 	"license": "MIT",
@@ -40,12 +40,12 @@
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"pi-roundtable": ">=0.16.0 <0.17.0"
+		"pi-roundtable": ">=0.17.0 <0.18.0"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.5.15",
 		"@types/bun": "1.4.2",
-		"pi-roundtable": "0.16.0",
+		"pi-roundtable": "0.17.1",
 		"typescript": "7.0.2"
 	}
 }

package/src/connectors/connector-registry.ts

@@ -106,27 +106,35 @@ export class ConnectorRegistry {
 		},
 	};
 
-	/** The registry over the host's migrated pool, with each connector's server resolved. */
-	static async attach(
+	/** The registry over the host's migrated pool, with no connector read yet; `load()` reads them. */
+	static attach(
 		sql: SQL,
 		options: ConnectorRegistryOptions,
-	): Promise<ConnectorRegistry> {
-		const registry = new ConnectorRegistry(sql, options);
-		const rows: Row[] = await sql`SELECT * FROM owner_connectors ORDER BY name`;
+	): ConnectorRegistry {
+		return new ConnectorRegistry(sql, options);
+	}
+
+	/** Reads the stored connectors and resolves each one's server; one that cannot be reached is logged and left without a server. Changes `version`. */
+	async load(): Promise<void> {
+		const rows: Row[] = await this
+			.#sql`SELECT * FROM owner_connectors ORDER BY name`;
 		for (const row of rows) {
 			const connector = fromRow(row);
 			// One unreachable connector must not keep the host from starting.
 			try {
-				connector.server = await options.resolve(registry.serverName(row.name));
+				connector.server = await this.#options.resolve(
+					this.serverName(row.name),
+				);
 			} catch (error) {
-				options.logger.error(
+				this.#options.logger.error(
 					{ connector: row.name, err: error },
 					"connector could not be read; its profile is off",
 				);
 			}
-			registry.#connectors.set(row.name, connector);
+			this.#connectors.set(row.name, connector);
 		}
-		return registry;
+		// What a host built from the list before this is stale.
+		this.#version += 1;
 	}
 
 	/** The name of the connector's virtual server in ContextForge. */

package/src/connectors/connectors-plugin.ts

@@ -85,18 +85,22 @@ function checkOptions({ contextForge }: McpConnectorsOptions): string {
 export function mcpConnectors(options: McpConnectorsOptions): RoundtablePlugin {
 	const url = checkOptions(options);
 	const text = connectorMessages(options.messages);
+	let load: (() => Promise<void>) | undefined;
 	return definePlugin({
 		name: "mcp-connectors",
 		requires: [DISCORD],
 		provides: [CONNECTORS],
 		migrations: [ConnectorRegistry.migration],
-		setup: async ({ database, services, logger }) => {
+		// The stored connectors are read, and their servers resolved, before any service starts, so
+		// Discord takes no command or turn that sees an empty list; `Roundtable.check()` never runs it.
+		preflight: () => load?.(),
+		setup: ({ database, services, logger }) => {
 			const { jwtSecret, user } = options.contextForge;
 			const token = contextForgeToken(jwtSecret, user, TOKEN_TTL_SECONDS);
 			const admin = new ContextForgeAdmin(url, token, fetch, text);
 			const resolve = (name: string) =>
 				resolveVirtualServer(url, token, name, fetch, text);
-			const registry = await ConnectorRegistry.attach(database(), {
+			const registry = ConnectorRegistry.attach(database(), {
 				admin,
 				resolve,
 				logger,
@@ -120,6 +124,8 @@ export function mcpConnectors(options: McpConnectorsOptions): RoundtablePlugin {
 					servers: () => admin.servers(),
 				},
 			});
+			// Nothing is added but what preflight reads.
+			load = () => registry.load();
 			return {};
 		},
 	});

package/src/remote-mcp/remote-mcp-plugin.ts

@@ -138,6 +138,7 @@ export function remoteMcp(options: RemoteMcpOptions): RoundtablePlugin {
 	const text = remoteMcpMessages(options.messages);
 	const toolNames = toolNamesOf(options);
 	const identity = tokenIdentity(options);
+	let adopt: (() => Promise<void>) | undefined;
 	return definePlugin({
 		name: "remote-mcp",
 		requires: [DISCORD, IDENTITY, CONVERSATIONS],
@@ -154,40 +155,47 @@ export function remoteMcp(options: RemoteMcpOptions): RoundtablePlugin {
 			ChannelGrantStore.migration,
 			...RemoteSessionStore.migrations(),
 		],
+		// Who the token stands for is read, and the sessions of earlier versions adopted, before any
+		// service starts, so a failure stops the start before Discord connects; `Roundtable.check()`
+		// never runs it.
+		preflight: () => adopt?.(),
 		setup: async (context) => {
 			const { services, logger, conversations, database } = context;
 			const discord = services.get(DISCORD);
 			const identities = services.get(IDENTITY);
-			const bound = await boundPrincipal(identities, identity);
+			// Who the token stands for is read from the stored principals in preflight.
+			let found: Bound | undefined;
+			const bound = (): Bound => {
+				if (!found)
+					throw new PluginError(
+						"remote-mcp: the dispatch token's principal is read in preflight, before the listeners open; a request before that has no one to act for.",
+					);
+				return found;
+			};
 			const conversation = conversationOf(options, context);
 			const grants = await ChannelGrantStore.attach(database());
 			const sessions = await RemoteSessionStore.attach(database());
-			// 0.8's sessions were the owner's, and their conversations, recorded shared, become theirs.
 			const registry = services.get(CONVERSATIONS);
-			const [primary] = await identities.owners();
-			if (primary)
-				await sessions.adopt(primary.id, async (id) => {
-					await registry.adopt(`mcp:${id}`, primary.id);
-				});
-			// Every start adopts each session's conversation for its principal again, so one a failed
-			// hand-over left no one's becomes theirs; adopt never changes one already someone's.
-			for (const { id, principalId } of await sessions.owned())
-				await registry.adopt(`mcp:${id}`, principalId);
 			const gateway = new McpGateway({
 				dispatchToken: options.dispatchToken,
 				agent: new RemoteAgent({
 					sessions: {
-						create: () => sessions.create(bound.id),
-						touch: (id) => sessions.touch(id, bound.id),
+						create: () => sessions.create(bound().id),
+						touch: (id) => sessions.touch(id, bound().id),
 					},
 					answer: async (channel, relayed) =>
 						conversation.answer(
 							channel,
 							relayed,
-							await identities.speakerFor(bound.id),
+							await identities.speakerFor(bound().id),
 						),
 					logger,
-					messages: { ...text, relayNote: relayNoteOf(options, bound) },
+					messages: {
+						...text,
+						get relayNote() {
+							return relayNoteOf(options, bound());
+						},
+					},
 				}),
 				grants,
 				executor: () => discord.connection.channelExecutor(),
@@ -205,6 +213,20 @@ export function remoteMcp(options: RemoteMcpOptions): RoundtablePlugin {
 				mcpGrantCommands(discord.guard, grants, options.publicUrl, text),
 			);
 			services.provide(REMOTE_MCP, remoteMcpService(grants, text));
+			// Read before any service starts, by `preflight` above.
+			adopt = async () => {
+				found = await boundPrincipal(identities, identity);
+				// 0.8's sessions were the owner's, and their conversations, recorded shared, become theirs.
+				const [primary] = await identities.owners();
+				if (primary)
+					await sessions.adopt(primary.id, async (id) => {
+						await registry.adopt(`mcp:${id}`, primary.id);
+					});
+				// Every start adopts each session's conversation for its principal again, so one a failed
+				// hand-over left no one's becomes theirs; adopt never changes one already someone's.
+				for (const { id, principalId } of await sessions.owned())
+					await registry.adopt(`mcp:${id}`, principalId);
+			};
 			return {
 				services: [
 					{
@@ -262,14 +284,20 @@ function conversationOf(
 
 /**
  * The persona of the default conversations, the owner's or one that names no owner, as the token
- * stands for at the start; a host that runs its own brings its own.
+ * stands for at the start (read when a conversation opens); a host that runs its own brings its own.
  */
 function personaOf(
 	options: RemoteMcpOptions,
-	bound: Bound,
+	bound: () => Bound,
 ): Pick<Contribution, "personas"> {
 	if (options.answer) return {};
-	const prompt =
-		options.persona ?? (bound.owner ? DEFAULT_PERSONA : MEMBER_PERSONA);
-	return { personas: [{ kind: REMOTE_KIND, prompt: () => prompt }] };
+	return {
+		personas: [
+			{
+				kind: REMOTE_KIND,
+				prompt: () =>
+					options.persona ?? (bound().owner ? DEFAULT_PERSONA : MEMBER_PERSONA),
+			},
+		],
+	};
 }