pi-roundtable 0.8.0 → 0.9.0

package/src/core/testing/modules.ts

@@ -1,13 +1,16 @@
 import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
 import type { SQL } from "bun";
-import { OWNER_TARGET } from "../agents/agent-claim.ts";
 import { DISCORD, type DiscordServices } from "../builtin/discord.ts";
 import { discordAdminPlugin } from "../builtin/discord-admin.ts";
 import { type ModulesOptions, modulesPlugin } from "../builtin/modules.ts";
 import { skillsPlugin } from "../builtin/skills.ts";
 import { memoryPlugin } from "../builtin/stores.ts";
+import type { ConversationRegistry } from "../conversations/conversation-registry.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
+import type { IdentityService } from "../identity/identity-service.ts";
+import type { Principal } from "../identity/principal-store.ts";
 import { silentLogger } from "../log.ts";
+import { PERSONAL_TARGET } from "../modules/background/personal-target.ts";
 import type { SkillStore } from "../modules/skills/skill-store.ts";
 import {
 	type Contribution,
@@ -15,10 +18,22 @@ import {
 	pluginContext,
 	type RoundtablePlugin,
 } from "../plugin.ts";
+import {
+	type DirectChannelProvider,
+	directChannelsPort,
+} from "../presence/direct-channels.ts";
 import { ServiceRegistry } from "../registry/services.ts";
 import { surfacePort } from "../routing/surface-port.ts";
 import type { AgentServer, MemoryStore, ScheduleStore } from "../services.ts";
-import { AGENTS, MEMORY, SCHEDULES } from "../services.ts";
+import {
+	AGENTS,
+	CONVERSATIONS,
+	IDENTITY,
+	MEMORY,
+	SCHEDULES,
+} from "../services.ts";
+import type { Tier } from "../speakers.ts";
+import { toolTiers } from "../tool-tiers.ts";
 
 /** What the modules' tools did, for a test to read. */
 export interface ModuleRecord {
@@ -26,14 +41,28 @@ export interface ModuleRecord {
 	threadOrigins: (ChannelKey | undefined)[];
 	/** The channel each delegated report came back to. */
 	reportChannels: ChannelKey[];
-	/** How often a conversation without a chat channel fell back to the owner's messages. */
+	/** How often anything asked the connection for the primary owner's messages, which the modules no longer read. */
 	ownerChannelAsked: number;
+	/** Whose direct channel was asked for, in order. */
+	directAsked: string[];
+	/** The notices sent through a direct channel, by principal. */
+	notified: { principalId: string; text: string }[];
 	/** What was posted on the surface, by channel. */
 	posted: { channel: ChannelKey; text: string }[];
 }
 
 export const OWNER_CHANNEL: ChannelKey = "discord:owner-dm";
 
+/** The primary owner the modules serve: principal "1". */
+export const MODULES_OWNER = {
+	id: "1",
+	name: "Owner",
+	pronouns: { subject: "they", object: "them", possessive: "their" },
+};
+
+/** The direct messages the stand-in Discord provider reaches by default: the owner's, principal "1". */
+const DIRECT: Readonly<Record<string, ChannelKey>> = { "1": OWNER_CHANNEL };
+
 /** The modules plugin set up over stand-in stores and surface; returns its contribution and the record. */
 export async function setUpModules(
 	options: {
@@ -46,7 +75,29 @@ export async function setUpModules(
 		owns?: (channel: ChannelKey) => boolean;
 		/** Whether the claim owning a channel takes background turns; by default every owned channel's does. */
 		takesBackground?: (channel: ChannelKey) => boolean;
+		/** Whether the claim owning a channel takes the host's own turns; by default every owned channel's does. */
+		takesSystemReports?: (channel: ChannelKey) => boolean;
 		errorReporter?: ModulesOptions["errorReporter"];
+		/** The schedules the tools keep; by default a stub that answers nothing. */
+		schedules?: ScheduleStore;
+		/** The conversations the host records, which say whose a conversation is; by default none is recorded. */
+		conversations?: Pick<ConversationRegistry, "get">;
+		/**
+		 * Each principal's direct messages on the stand-in Discord provider, the host's only direct
+		 * channel; by default the owner's are `OWNER_CHANNEL`, and without Discord there is none.
+		 */
+		direct?: Readonly<Record<string, ChannelKey>>;
+		/**
+		 * Whether the stand-in provider reaches the network, read at each `reaches`, which throws
+		 * while it does not; `knows` answers from its records either way. Default always.
+		 */
+		online?: () => boolean;
+		/** The host's owners, as `IDENTITY` lists them; by default there is no identity service. */
+		owners?: readonly Principal[];
+		/** The operator's tool tiers; by default none, so notify stays the owners'. */
+		toolTiers?: Readonly<Record<string, Tier>>;
+		/** The modules' options besides the test's own. */
+		modules?: Partial<ModulesOptions>;
 	} = {},
 ): Promise<{
 	plugin: RoundtablePlugin;
@@ -58,14 +109,31 @@ export async function setUpModules(
 		threadOrigins: [],
 		reportChannels: [],
 		ownerChannelAsked: 0,
+		directAsked: [],
+		notified: [],
 		posted: [],
 	};
+	const direct =
+		options.direct ?? (options.discord === false ? undefined : DIRECT);
+	const providers: DirectChannelProvider[] = direct
+		? [
+				{
+					name: "discord",
+					label: "a direct message on Discord",
+					knows: async (principalId) => direct[principalId] !== undefined,
+					reaches: async (principalId) => {
+						record.directAsked.push(principalId);
+						if (options.online?.() === false)
+							throw new Error("Discord is unreachable");
+						return direct[principalId];
+					},
+					deliver: async (principalId, text) =>
+						void record.notified.push({ principalId, text }),
+				},
+			]
+		: [];
 	const plugin = modulesPlugin({
-		owner: {
-			id: "1",
-			name: "Owner",
-			pronouns: { subject: "they", object: "them", possessive: "their" },
-		},
+		owner: MODULES_OWNER,
 		assistant: "Assistant",
 		// SAFETY: a worker of the test's own replaces the one that would read the runtime.
 		modelRuntime: {} as ModelRuntime,
@@ -77,11 +145,26 @@ export async function setUpModules(
 			worker: { run: async () => "found it" },
 		},
 		...(options.errorReporter ? { errorReporter: options.errorReporter } : {}),
+		...options.modules,
 	});
 	const services = new ServiceRegistry([plugin]);
 	// SAFETY: the tools under test read no store; each stub is asked for nothing else.
 	services.preset(MEMORY, {} as MemoryStore);
-	services.preset(SCHEDULES, {} as ScheduleStore);
+	services.preset(SCHEDULES, options.schedules ?? ({} as ScheduleStore));
+	if (options.conversations)
+		// SAFETY: the schedule tools only read a conversation's record.
+		services.preset(
+			CONVERSATIONS,
+			options.conversations as unknown as ConversationRegistry,
+		);
+	if (options.owners) {
+		const owners = options.owners;
+		// SAFETY: the modules ask the identity service for the owners and a principal by id only.
+		services.preset(IDENTITY, {
+			owners: async () => owners,
+			principal: async (id: string) => owners.find((owner) => owner.id === id),
+		} as unknown as IdentityService);
+	}
 	if (options.agentChannelOf)
 		// SAFETY: the schedule tools ask the agent team for a channel and nothing else.
 		services.preset(AGENTS, {
@@ -108,30 +191,34 @@ export async function setUpModules(
 		} as unknown as DiscordServices);
 	const owns =
 		options.owns ?? ((channel: ChannelKey) => channel.startsWith("discord:"));
-	// SAFETY: setup and the preflight read only the logger, the conversations' background, targets and owners, the surfaces, and the services.
+	// Only Discord's channels have a surface; any other conversation has none to report in.
+	const surfaces = surfacePort(() => [
+		{
+			surface: "discord",
+			start: async () => undefined,
+			sendReply: async (channel, reply) =>
+				void record.posted.push({ channel, text: reply.chunks.join("") }),
+		},
+	]);
+	// SAFETY: setup and the preflight read only the logger, the conversations' background, targets and owners, the surfaces, the direct channels, and the services.
 	const context = {
 		logger: silentLogger(),
 		conversations: {
 			target: (name: string) =>
-				options.ownerTarget !== false && name === OWNER_TARGET.name
-					? OWNER_TARGET
+				options.ownerTarget !== false && name === PERSONAL_TARGET.name
+					? PERSONAL_TARGET
 					: undefined,
 			owns,
 			takesBackground: options.takesBackground ?? owns,
+			takesSystemReports: options.takesSystemReports ?? owns,
 			background: async (turn: { channel: ChannelKey }) => {
 				record.reportChannels.push(turn.channel);
 				return { status: "ran" };
 			},
 		},
-		// Only Discord's channels have a surface; any other conversation has none to report in.
-		surfaces: surfacePort(() => [
-			{
-				surface: "discord",
-				start: async () => undefined,
-				sendReply: async (channel, reply) =>
-					void record.posted.push({ channel, text: reply.chunks.join("") }),
-			},
-		]),
+		surfaces,
+		directChannels: directChannelsPort(() => providers, surfaces),
+		toolTiers: toolTiers(options.toolTiers),
 	} as unknown as Omit<PluginContext, "services">;
 	const contribution = await services.setUp(plugin, () =>
 		plugin.setup(pluginContext(plugin, context, services.forPlugin(plugin))),

package/src/core/testing/owner.ts

@@ -1,3 +1,4 @@
+import type { Principal } from "../identity/principal-store.ts";
 import type { OwnerIdentity } from "../identity.ts";
 import type { Speaker } from "../speakers.ts";
 
@@ -7,9 +8,25 @@ export const TEST_OWNER: OwnerIdentity = {
 	pronouns: { subject: "he", object: "him", possessive: "his" },
 };
 
+/** The owner as a principal of the tests, its id the owner speaker's, as for an owner carried over from 0.8. */
+export const OWNER_PRINCIPAL: Principal = {
+	id: "1",
+	displayName: TEST_OWNER.name,
+	pronouns: "he",
+	disabled: false,
+};
+
+/** A member as a principal of the tests. */
+export const MEMBER_PRINCIPAL: Principal = {
+	id: "2",
+	displayName: "Bo",
+	disabled: false,
+};
+
 /** The owner as a speaker of the tests. */
 export const OWNER_SPEAKER: Speaker = {
 	id: "1",
 	name: TEST_OWNER.name,
 	tier: "owner",
+	principalId: OWNER_PRINCIPAL.id,
 };

package/src/core/testing/surface-contract.ts

@@ -2,8 +2,12 @@ import { describe, test } from "bun:test";
 import type { InboundMessage } from "../contract/channels.ts";
 import type { ChatSurface } from "../contract/surface.ts";
 import { parseChannelKey } from "../contract/surface.ts";
-import type { Approval } from "../domain/owner-prompts.ts";
 import type { TurnProgress } from "../domain/progress.ts";
+import {
+	type Approval,
+	type PromptScope,
+	promptScope,
+} from "../interactions/prompts.ts";
 import type { ChannelKey } from "../sessions.ts";
 import type { Speaker } from "../speakers.ts";
 
@@ -33,23 +37,34 @@ export interface SurfaceContractSubject {
 	/** The person answers an open approval; without it the prompt checks are skipped. */
 	answer?(prompt: string, approved: boolean): Promise<void>;
 	/**
-	 * The person as the speaker of the turns that ask them, given to `surface.prompts`; default an
-	 * owner-tier speaker. Every approval the contract asks for needs exactly the speaker's tier, so
-	 * it is theirs to answer.
+	 * The person as the speaker of the turns that ask them, given to `surface.prompts` as the
+	 * scope `promptScope(speaker, visibility)`; default an owner-tier speaker. Every approval the
+	 * contract asks for needs exactly the speaker's tier, so it is theirs to answer; one above a
+	 * speaker below the owner tier checks that a private conversation escalates to no one.
 	 */
 	speaker?: Speaker;
 	/**
-	 * Someone else on the surface's network, not the owner, who knows the id of the person's open
-	 * prompt and answers it; without it the responder-scope check is skipped.
+	 * Someone else on the surface's network, another principal and not an owner, who knows the
+	 * id of the person's open prompt and answers it; without it the responder-scope check is
+	 * skipped.
 	 */
-	stranger?: {
-		/** They join the surface, once it has started. */
-		join?(): Promise<void>;
-		answer(prompt: string, approved: boolean): Promise<void>;
-	};
+	stranger?: SurfaceContractAnswerer;
+	/**
+	 * An owner on the surface's network, another principal than the person, who knows the id of
+	 * the person's open prompt in their private conversation and answers it; without it that
+	 * check is skipped.
+	 */
+	owner?: SurfaceContractAnswerer;
 	close?(): Promise<void>;
 }
 
+/** Someone on the network other than the person, who answers a prompt by its id. */
+export interface SurfaceContractAnswerer {
+	/** They join the surface, once it has started. */
+	join?(): Promise<void>;
+	answer(prompt: string, approved: boolean): Promise<void>;
+}
+
 /** One way the subject broke the contract. */
 export interface SurfaceContractFailure {
 	name: string;
@@ -93,7 +108,18 @@ const seen = (running: Running, kind: SurfaceObservation["kind"]) =>
 	running.subject.observations().filter((o) => o.kind === kind);
 
 const speakerOf = (subject: SurfaceContractSubject): Speaker =>
-	subject.speaker ?? { id: "contract-speaker", name: "Ada", tier: "owner" };
+	subject.speaker ?? {
+		id: "contract-speaker",
+		name: "Ada",
+		tier: "owner",
+		principalId: "contract-speaker",
+	};
+
+/** The person's prompt scope in a conversation of this visibility. */
+const scopeOf = (
+	subject: SurfaceContractSubject,
+	visibility: "private" | "shared" = "shared",
+): PromptScope => promptScope(speakerOf(subject), visibility);
 
 /** The newest prompt the person has seen, once one more than `before` is open. */
 async function nextPrompt(running: Running, before: number): Promise<string> {
@@ -109,7 +135,7 @@ async function nextPrompt(running: Running, before: number): Promise<string> {
 /** Asks for one approval and answers it as the person does. */
 async function approval(running: Running, approved: boolean) {
 	const { surface, channel, answer } = running.subject;
-	const prompts = surface.prompts?.(channel, speakerOf(running.subject));
+	const prompts = surface.prompts?.(channel, scopeOf(running.subject));
 	if (!prompts || !answer)
 		throw new ContractBroken("the surface shows no prompts");
 	const before = seen(running, "prompt").length;
@@ -264,7 +290,7 @@ const CHECKS: readonly Check[] = [
 			subject.surface.prompts !== undefined && subject.answer !== undefined,
 		run: async (running) => {
 			const { surface, channel } = running.subject;
-			const prompts = surface.prompts?.(channel, speakerOf(running.subject));
+			const prompts = surface.prompts?.(channel, scopeOf(running.subject));
 			if (!prompts) throw new ContractBroken("the surface shows no prompts");
 			const stop = new AbortController();
 			const before = seen(running, "prompt").length;
@@ -293,39 +319,89 @@ const CHECKS: readonly Check[] = [
 			subject.surface.prompts !== undefined &&
 			subject.answer !== undefined &&
 			subject.stranger !== undefined,
+		run: (running) =>
+			answeredOnlyByThem(running, running.subject.stranger, "shared"),
+	},
+	{
+		name: "another principal cannot answer for the person in their private conversation, even an owner",
+		applies: (subject) =>
+			subject.surface.prompts !== undefined &&
+			subject.answer !== undefined &&
+			subject.owner !== undefined,
+		run: (running) =>
+			answeredOnlyByThem(running, running.subject.owner, "private"),
+	},
+	{
+		name: "a private conversation's approval above the person's tier goes to no one: it expires at once",
+		applies: (subject) =>
+			subject.surface.prompts !== undefined &&
+			speakerOf(subject).tier !== "owner",
 		run: async (running) => {
-			const { surface, channel, answer, stranger } = running.subject;
-			const prompts = surface.prompts?.(channel, speakerOf(running.subject));
-			if (!prompts || !answer || !stranger)
-				throw new ContractBroken("the surface shows no prompts");
-			await stranger.join?.();
+			const { surface, channel } = running.subject;
+			const prompts = surface.prompts?.(
+				channel,
+				scopeOf(running.subject, "private"),
+			);
+			if (!prompts) throw new ContractBroken("the surface shows no prompts");
 			const before = seen(running, "prompt").length;
-			let settled: Approval | undefined;
-			const result = prompts
-				.confirm(
-					"Approve?",
-					"Send the report.",
-					undefined,
-					speakerOf(running.subject).tier,
-				)
-				.then((value) => {
-					settled = value;
-					return value;
-				});
-			const id = await nextPrompt(running, before);
-			await stranger.answer(id, true);
-			await Bun.sleep(50);
+			const answer = await Promise.race([
+				prompts.confirm("Approve?", "Delete the notes.", undefined, "owner"),
+				Bun.sleep(1000).then(() => "still open" as const),
+			]);
 			expectThat(
-				settled === undefined,
-				`another person's answer settled the approval as ${settled}`,
+				answer === "expired",
+				`an approval no one may answer came back ${answer}`,
+			);
+			expectThat(
+				seen(running, "prompt").length === before,
+				"an approval no one may answer was shown",
 			);
-			await answer(id, false);
-			const own = await result;
-			expectThat(own === "declined", `the person's answer came back ${own}`);
 		},
 	},
 ];
 
+/**
+ * Opens the person's approval in a conversation of `visibility`, has `other` answer it by its id,
+ * and checks that only the person's own answer settles it.
+ */
+async function answeredOnlyByThem(
+	running: Running,
+	other: SurfaceContractAnswerer | undefined,
+	visibility: "private" | "shared",
+): Promise<void> {
+	const { surface, channel, answer } = running.subject;
+	const prompts = surface.prompts?.(
+		channel,
+		scopeOf(running.subject, visibility),
+	);
+	if (!prompts || !answer || !other)
+		throw new ContractBroken("the surface shows no prompts");
+	await other.join?.();
+	const before = seen(running, "prompt").length;
+	let settled: Approval | undefined;
+	const result = prompts
+		.confirm(
+			"Approve?",
+			"Send the report.",
+			undefined,
+			speakerOf(running.subject).tier,
+		)
+		.then((value) => {
+			settled = value;
+			return value;
+		});
+	const id = await nextPrompt(running, before);
+	await other.answer(id, true);
+	await Bun.sleep(50);
+	expectThat(
+		settled === undefined,
+		`another principal's answer settled the approval as ${settled}`,
+	);
+	await answer(id, false);
+	const own = await result;
+	expectThat(own === "declined", `the person's answer came back ${own}`);
+}
+
 async function runCheck(
 	check: Check,
 	make: () => Promise<SurfaceContractSubject>,
@@ -366,8 +442,9 @@ export async function checkSurfaceContract(
  * Registers the chat surface contract as one test per check, under `name`: the surface names a
  * prefix and owns its channel, delivers what its person writes, shows every chunk of a reply, and,
  * where it offers them, delivers files, ends typing and stop controls idempotently, shows
- * progress, resolves approvals as the person answers or as a stopped turn cancels them, and
- * ignores another person's answer to the person's approval. Each
+ * progress, resolves approvals as the person answers or as a stopped turn cancels them, ignores
+ * another person's answer to the person's approval, and, in a private conversation, an owner's
+ * too, and lets an approval above the person's tier there expire at once, shown to no one. Each
  * check gets a fresh subject from `make`; a check for an optional part the surface lacks passes.
  */
 export function describeSurfaceContract(

package/src/core/testing/test-host.ts

@@ -11,27 +11,32 @@ import { type RoundtableConfig, resolveConfig } from "../config/config.ts";
 import type { ConversationPort } from "../contract/channels.ts";
 import type { AgentRuntime } from "../contract/runtime.ts";
 import type { ChatSurface } from "../contract/surface.ts";
-import { defineRoundtable } from "../define-roundtable.ts";
+import { defineRoundtable, discordOwnerOf } from "../define-roundtable.ts";
 import { CommandCollection } from "../discord/command-collection.ts";
 import type { ComposedCommands } from "../discord/compose-commands.ts";
 import type { DiscordConnection } from "../discord/connection.ts";
+import { discordDirectChannel } from "../discord/direct-channel.ts";
 import type {
 	CommandGuard,
 	InteractionContribution,
 } from "../discord/interaction-module.ts";
-import { OwnerGuard, ownerRootCommand } from "../discord/owner-command.ts";
+import { commandGuard, ownerRootCommand } from "../discord/owner-command.ts";
 import { Roundtable } from "../host.ts";
 import { silentLogger } from "../log.ts";
 import type { PluginContext, RoundtablePlugin } from "../plugin.ts";
 import { CompactionTiers } from "../runtime/compaction-tiers.ts";
+import { privateCompaction } from "../runtime/extensions/private-memory.ts";
 import { sessionExtensions } from "../runtime/runtime-types.ts";
+import { IDENTITY } from "../services.ts";
 import type { AgentTurnScope, SessionContext } from "../sessions.ts";
+import { THE_SPEAKER } from "../speakers.ts";
 import { testDatabaseUrl } from "./database.ts";
 
 export interface TestHostOptions {
 	/**
-	 * Over a test configuration: an owner, a guild, a temporary `dataDir`, and the test database
-	 * (`ROUNDTABLE_TEST_DATABASE_URL`).
+	 * Over a test configuration: the owner Ada in `access`, a guild, a temporary `dataDir`, and
+	 * the test database (`ROUNDTABLE_TEST_DATABASE_URL`). Giving the 0.8 `owner` or `speakers`
+	 * replaces the default `access`.
 	 */
 	config?: Partial<RoundtableConfig>;
 	/** The app's plugins, after the built-in ones, as `defineRoundtable` places them. */
@@ -73,17 +78,28 @@ export interface TestHost {
 	stop(): Promise<void>;
 }
 
+/** The test host's owner, Ada, as `access` writes her: her principal is her Discord user id. */
+const TEST_ACCESS: NonNullable<RoundtableConfig["access"]> = {
+	owners: [
+		{
+			name: "Ada",
+			principal: "100000000000000001",
+			identities: ["discord:100000000000000001"],
+		},
+	],
+};
+
 function defaultConfig(withDiscord: boolean): RoundtableConfig {
 	const dataDir = mkdtempSync(join(tmpdir(), "roundtable-test-host-"));
 	if (!withDiscord)
 		return {
-			owner: { id: "100000000000000001", name: "Ada" },
+			access: TEST_ACCESS,
 			database: { url: testDatabaseUrl },
 			dataDir,
 			model: "anthropic/claude-sonnet-5-5",
 		};
 	return {
-		owner: { id: "100000000000000001", name: "Ada" },
+		access: TEST_ACCESS,
 		discord: {
 			token: "token",
 			guild: "900000000000000001",
@@ -122,10 +138,14 @@ function quietRuntime(): AgentRuntime {
 }
 
 /** A Discord that connects to nothing, recording the commands added to it, standing in for the built-in plugin that does. */
-function standInDiscord(
+export function standInDiscord(
 	commands: CommandCollection,
 	guard: CommandGuard,
 	given: TestHostOptions["discord"],
+	/** The primary owner's Discord user id, whose direct messages are the owner channel. */
+	ownerId: string,
+	/** What `DISCORD.channelContext` answers; by default no context, as on a host with it off. */
+	channelContext: DiscordServices["channelContext"] = async () => undefined,
 ): RoundtablePlugin {
 	const surface: ChatSurface = {
 		surface: "discord",
@@ -137,6 +157,18 @@ function standInDiscord(
 		provides: [DISCORD],
 		replaces: [DISCORD],
 		setup: ({ services }) => {
+			const identity = services.find(IDENTITY);
+			const ownerChannel =
+				(given ? given.ownerChannel : undefined) ??
+				(async () => "discord:owner-dm" as const);
+			// Each person's direct messages, as the Discord plugin's provider reaches them; the owner's is the owner channel.
+			const direct = discordDirectChannel({
+				directChannel: async (userId) =>
+					userId === ownerId ? ownerChannel() : `discord:dm-${userId}`,
+				sendDirect: async () => undefined,
+				...(identity ? { identity } : {}),
+				ownerId,
+			});
 			// SAFETY: the plugins after it read only these members while they set up; the rest is read when a tool runs, which a test host does not do.
 			services.provide(DISCORD, {
 				connection: {
@@ -150,8 +182,9 @@ function standInDiscord(
 				commands: commands.registrar,
 				guard,
 				threads: { open: async () => undefined, sweep: async () => undefined },
+				channelContext,
 			} as unknown as DiscordServices);
-			return { surfaces: [surface] };
+			return { surfaces: [surface], directChannels: [direct] };
 		},
 	};
 }
@@ -168,8 +201,8 @@ function ignored(): Ignored {
 /** The tools a factory registers, by name; every other registration (handlers, commands, events) is accepted and ignored. */
 async function registeredBy(factory: ExtensionFactory): Promise<string[]> {
 	const names: string[] = [];
-	// SAFETY: a session factory only registers tools, handlers and commands; the fake records the tool names and ignores the rest.
 	const registerTool = (tool: { name: string }) => names.push(tool.name);
+	// SAFETY: a session factory only registers tools, handlers and commands; the fake records the tool names and ignores the rest.
 	const api = new Proxy(
 		{},
 		{
@@ -188,6 +221,7 @@ const CORE_EXTENSIONS = {
 	confirmationGate: noop,
 	askUser: noop,
 	selfCompactGuard: noop,
+	privateMemory: noop,
 	activeTools: noop,
 };
 
@@ -211,17 +245,31 @@ export async function testHost(
 	};
 	const withDiscord = options.discord !== false;
 	const given = options.discord === false ? undefined : options.discord;
-	const base: RoundtableConfig = {
-		...defaultConfig(withDiscord),
-		...options.config,
-	};
+	const defaults = defaultConfig(withDiscord);
+	// A test that writes the 0.8 owner or speakers gets them in place of the default access.
+	if (options.config?.owner || options.config?.speakers) delete defaults.access;
+	const base: RoundtableConfig = { ...defaults, ...options.config };
 	const resolved = resolveConfig(base);
 	const rootCommand = resolved.slug;
-	const guard = new OwnerGuard(resolved.owner.id, silentLogger(), rootCommand);
+	// Like the Discord plugin's, the guard asks the host's identity service, once the host is up.
+	const identity = () => captured?.services.find(IDENTITY);
+	const guard = commandGuard({
+		ownerId: discordOwnerOf(resolved).id,
+		identity: {
+			resolve: async (facts, scope) => identity()?.resolve(facts, scope),
+			owners: async () => (await identity()?.owners()) ?? [],
+			identities: async (principalId) =>
+				(await identity()?.identities(principalId)) ?? [],
+		},
+		root: rootCommand,
+		logger: silentLogger(),
+	});
 	const config: RoundtableConfig = {
 		...base,
 		plugins: [
-			...(withDiscord ? [standInDiscord(commands, guard, given)] : []),
+			...(withDiscord
+				? [standInDiscord(commands, guard, given, discordOwnerOf(resolved).id)]
+				: []),
 			{
 				name: "test-runtime",
 				providers: { runtime: () => runtime },
@@ -261,9 +309,24 @@ export async function testHost(
 			kind: scope ? "agent" : "owner",
 			homeChannel: scope?.home ?? ownerChannel,
 			turnChannel: turnChannelOf(scope) ?? ownerChannel,
+			// Shared, as the runtime makes it, so its compactor summarizes no one's private memory.
 			compaction: {
-				wrap: (compactor) => tiers.wrapCompactor(compactor, () => undefined),
+				wrap: (compactor) =>
+					tiers.wrapCompactor(
+						compactor,
+						() => undefined,
+						(event) =>
+							privateCompaction(
+								event.preparation,
+								event.branchEntries.flatMap((entry) =>
+									entry.type === "message" ? [entry.message] : [],
+								),
+							),
+					),
 			},
+			conversation: { visibility: "shared" },
+			addressee: THE_SPEAKER,
+			memory: "speaker",
 			speaker: () => undefined,
 			runTask: async () => {
 				throw new Error("a test host session cannot run tasks");