pi-roundtable 0.7.19 → 0.9.0

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

@@ -0,0 +1,460 @@
+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 { 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";
+
+/** What the person on a surface's network has seen, as the contract reads it. */
+export type SurfaceObservation =
+	| { kind: "reply"; text: string; files: readonly string[] }
+	| { kind: "typing"; on: boolean }
+	| { kind: "stop"; on: boolean }
+	| { kind: "progress"; event: TurnProgress }
+	| { kind: "prompt"; id: string; title: string }
+	| { kind: "prompt_closed"; id: string };
+
+/**
+ * A surface under the contract, and one person on its network the contract acts as. The
+ * contract starts the surface, then calls `join`; it stops the surface after `close`.
+ */
+export interface SurfaceContractSubject {
+	surface: ChatSurface;
+	/** A channel of the surface the person takes part in. */
+	channel: ChannelKey;
+	/** The person joins `channel`, once the surface has started. */
+	join?(): Promise<void>;
+	/** The person writes `text` in `channel`; the surface delivers it to the host. */
+	write(text: string): Promise<void>;
+	/** Everything the person has seen so far, oldest first. */
+	observations(): readonly SurfaceObservation[];
+	/** 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` 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, 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?: 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;
+	error: unknown;
+}
+
+interface Running {
+	subject: SurfaceContractSubject;
+	delivered: InboundMessage[];
+}
+
+interface Check {
+	name: string;
+	/** Whether the check applies to this subject; a check that does not is skipped. */
+	applies?(subject: SurfaceContractSubject): boolean;
+	run(running: Running): Promise<void>;
+}
+
+class ContractBroken extends Error {
+	override name = "ContractBroken";
+}
+
+function expectThat(condition: boolean, message: string): void {
+	if (!condition) throw new ContractBroken(message);
+}
+
+async function until(
+	done: () => boolean,
+	what: string,
+	ms = 2000,
+): Promise<void> {
+	const deadline = Date.now() + ms;
+	while (!done()) {
+		if (Date.now() > deadline)
+			throw new ContractBroken(`timed out waiting until ${what}`);
+		await Bun.sleep(5);
+	}
+}
+
+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",
+		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> {
+	await until(
+		() => seen(running, "prompt").length > before,
+		"the person sees the approval",
+	);
+	const prompt = seen(running, "prompt").at(-1);
+	if (prompt?.kind !== "prompt") throw new ContractBroken("no prompt seen");
+	return prompt.id;
+}
+
+/** 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, scopeOf(running.subject));
+	if (!prompts || !answer)
+		throw new ContractBroken("the surface shows no prompts");
+	const before = seen(running, "prompt").length;
+	const result = prompts.confirm(
+		"Approve?",
+		"Send the report.",
+		undefined,
+		speakerOf(running.subject).tier,
+	);
+	await answer(await nextPrompt(running, before), approved);
+	return result;
+}
+
+const CHECKS: readonly Check[] = [
+	{
+		name: "names a surface prefix without a colon, and owns the subject's channel",
+		run: async ({ subject }) => {
+			const { surface } = subject.surface;
+			expectThat(
+				surface !== "" && !surface.includes(":"),
+				`"${surface}" is not a surface name`,
+			);
+			expectThat(
+				parseChannelKey(subject.channel).surface === surface,
+				`${subject.channel} is not a channel of ${surface}`,
+			);
+		},
+	},
+	{
+		name: "delivers what the person writes, in their channel",
+		run: async (running) => {
+			await running.subject.write("hello from the contract");
+			await until(
+				() => running.delivered.length > 0,
+				"the surface delivers the message",
+			);
+			const [message] = running.delivered;
+			expectThat(
+				message?.channel === running.subject.channel,
+				`delivered to ${message?.channel}, not ${running.subject.channel}`,
+			);
+			expectThat(
+				message?.text === "hello from the contract",
+				`delivered the text ${JSON.stringify(message?.text)}`,
+			);
+			expectThat(
+				Boolean(message?.messageId) && Boolean(message?.authorId),
+				"a delivered message names its id and its author",
+			);
+			expectThat(message?.authorIsBot === false, "the person is not a bot");
+		},
+	},
+	{
+		name: "shows the person every chunk of a reply",
+		run: async (running) => {
+			const { surface, channel } = running.subject;
+			await surface.sendReply(channel, { chunks: ["first part", "second"] });
+			await until(
+				() => seen(running, "reply").length > 0,
+				"the person sees the reply",
+			);
+			const reply = seen(running, "reply")[0];
+			expectThat(
+				reply?.kind === "reply" &&
+					reply.text.includes("first part") &&
+					reply.text.includes("second"),
+				"the reply shows both chunks",
+			);
+		},
+	},
+	{
+		name: "delivers a reply's files when it supports them",
+		applies: (subject) => subject.surface.supportsFiles === true,
+		run: async (running) => {
+			const { surface, channel } = running.subject;
+			await surface.sendReply(channel, {
+				chunks: ["see the file"],
+				files: [{ name: "notes.txt", data: new TextEncoder().encode("hi") }],
+			});
+			await until(
+				() =>
+					seen(running, "reply").some(
+						(o) => o.kind === "reply" && o.files.includes("notes.txt"),
+					),
+				"the person receives the file",
+			);
+		},
+	},
+	{
+		name: "a typing indicator ends when its handle is called, and calling it again is harmless",
+		applies: (subject) => subject.surface.startTyping !== undefined,
+		run: async (running) => {
+			const { surface, channel } = running.subject;
+			const stop = surface.startTyping?.(channel);
+			stop?.();
+			stop?.();
+			await until(
+				() => seen(running, "typing").some((o) => o.kind === "typing" && !o.on),
+				"the person sees typing end",
+			);
+		},
+	},
+	{
+		name: "a stop control ends when its handle is called, and calling it again is harmless",
+		applies: (subject) => subject.surface.showStop !== undefined,
+		run: async (running) => {
+			const { surface, channel } = running.subject;
+			const hide = surface.showStop?.(channel);
+			hide?.();
+			hide?.();
+			await until(
+				() => seen(running, "stop").some((o) => o.kind === "stop" && !o.on),
+				"the person sees the stop control go",
+			);
+		},
+	},
+	{
+		name: "shows a running turn's progress",
+		applies: (subject) => subject.surface.progress !== undefined,
+		run: async (running) => {
+			const { surface, channel } = running.subject;
+			await surface.progress?.(channel, { type: "text", delta: "Look" });
+			await surface.progress?.(channel, {
+				type: "tool_start",
+				id: "t1",
+				tool: "search",
+			});
+			await until(
+				() => seen(running, "progress").length >= 2,
+				"the person sees the progress",
+			);
+		},
+	},
+	{
+		name: "an approval resolves as the person answers it, and closes",
+		applies: (subject) =>
+			subject.surface.prompts !== undefined && subject.answer !== undefined,
+		run: async (running) => {
+			const approved = await approval(running, true);
+			expectThat(approved === "approved", `approving answered ${approved}`);
+			const declined = await approval(running, false);
+			expectThat(declined === "declined", `declining answered ${declined}`);
+			await until(
+				() => seen(running, "prompt_closed").length >= 2,
+				"both approvals close",
+			);
+		},
+	},
+	{
+		name: "a stopped turn's approval resolves cancelled and closes",
+		applies: (subject) =>
+			subject.surface.prompts !== undefined && subject.answer !== undefined,
+		run: async (running) => {
+			const { surface, channel } = 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;
+			const result = prompts.confirm(
+				"Approve?",
+				"Send it.",
+				stop.signal,
+				speakerOf(running.subject).tier,
+			);
+			const id = await nextPrompt(running, before);
+			stop.abort();
+			const answer: Approval = await result;
+			expectThat(answer === "cancelled", `a stopped turn answered ${answer}`);
+			await until(
+				() =>
+					seen(running, "prompt_closed").some(
+						(o) => o.kind === "prompt_closed" && o.id === id,
+					),
+				"the stopped approval closes",
+			);
+		},
+	},
+	{
+		name: "another person cannot answer the person's approval",
+		applies: (subject) =>
+			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 } = 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;
+			const answer = await Promise.race([
+				prompts.confirm("Approve?", "Delete the notes.", undefined, "owner"),
+				Bun.sleep(1000).then(() => "still open" as const),
+			]);
+			expectThat(
+				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",
+			);
+		},
+	},
+];
+
+/**
+ * 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>,
+): Promise<"passed" | "skipped"> {
+	const subject = await make();
+	const running: Running = { subject, delivered: [] };
+	try {
+		if (check.applies && !check.applies(subject)) return "skipped";
+		await subject.surface.start((message) => running.delivered.push(message));
+		await subject.join?.();
+		await check.run(running);
+		return "passed";
+	} finally {
+		await subject.close?.();
+		await subject.surface.stop?.();
+	}
+}
+
+/**
+ * Runs the chat surface contract on fresh subjects from `make`, one per check, and returns the
+ * checks the surface broke. `describeSurfaceContract` registers the same checks as tests.
+ */
+export async function checkSurfaceContract(
+	make: () => Promise<SurfaceContractSubject>,
+): Promise<SurfaceContractFailure[]> {
+	const failures: SurfaceContractFailure[] = [];
+	for (const check of CHECKS) {
+		try {
+			await runCheck(check, make);
+		} catch (error) {
+			failures.push({ name: check.name, error });
+		}
+	}
+	return failures;
+}
+
+/**
+ * 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, 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(
+	name: string,
+	make: () => Promise<SurfaceContractSubject>,
+): void {
+	describe(`${name} keeps the chat surface contract`, () => {
+		for (const check of CHECKS)
+			test(check.name, async () => {
+				await runCheck(check, make);
+			});
+	});
+}

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. */
@@ -43,8 +48,13 @@ export interface TestHostOptions {
 	 * having none, whatever login the machine holds.
 	 */
 	apiKeys?: Readonly<Record<string, string>>;
-	/** What the stand-in Discord hands out. */
-	discord?: Partial<Pick<DiscordConnection, "agentChannels" | "ownerChannel">>;
+	/**
+	 * What the stand-in Discord hands out. `false` boots a host without Discord: no `discord`,
+	 * `http`, or `agents` in the configuration, so no Discord plugin and no agent server.
+	 */
+	discord?:
+		| false
+		| Partial<Pick<DiscordConnection, "agentChannels" | "ownerChannel">>;
 }
 
 export interface TestHost {
@@ -68,10 +78,28 @@ export interface TestHost {
 	stop(): Promise<void>;
 }
 
-function defaultConfig(): RoundtableConfig {
+/** 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 {
+			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",
@@ -110,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",
@@ -125,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: {
@@ -138,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] };
 		},
 	};
 }
@@ -156,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(
 		{},
 		{
@@ -176,6 +221,7 @@ const CORE_EXTENSIONS = {
 	confirmationGate: noop,
 	askUser: noop,
 	selfCompactGuard: noop,
+	privateMemory: noop,
 	activeTools: noop,
 };
 
@@ -197,14 +243,33 @@ export async function testHost(
 			return { services: [{ name: "probe" }] };
 		},
 	};
-	const base: RoundtableConfig = { ...defaultConfig(), ...options.config };
+	const withDiscord = options.discord !== false;
+	const given = options.discord === false ? undefined : options.discord;
+	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.discord;
-	const guard = new OwnerGuard(resolved.owner.id, silentLogger(), rootCommand);
+	const rootCommand = resolved.slug;
+	// 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: [
-			standInDiscord(commands, guard, options.discord),
+			...(withDiscord
+				? [standInDiscord(commands, guard, given, discordOwnerOf(resolved).id)]
+				: []),
 			{
 				name: "test-runtime",
 				providers: { runtime: () => runtime },
@@ -227,9 +292,10 @@ export async function testHost(
 	await roundtable.run();
 	if (!captured) throw new Error("the probe was not set up");
 	const context = captured;
-	const ownerChannel = await (
-		options.discord?.ownerChannel ?? (async () => "discord:owner-dm" as const)
-	)();
+	// Without Discord the owner's session is a conversation of a plugin's surface.
+	const ownerChannel = withDiscord
+		? await (given?.ownerChannel ?? (async () => "discord:owner-dm" as const))()
+		: ("test:owner" as const);
 	/** A group seat's turns run in the group's channel; an agent's in its own. */
 	const turnChannelOf = (scope?: AgentTurnScope) =>
 		scope?.group ? scope.session : scope?.home;
@@ -243,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");