pi-roundtable 0.8.0 → 0.9.1

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");

package/src/core/testing/tool-set.ts

@@ -1,3 +1,5 @@
+import type { ChannelKey } from "../domain/conversation.ts";
+import type { RoundtablePlugin } from "../plugin.ts";
 import { ASK_USER_TOOL } from "../runtime/extensions/ask-user.ts";
 import { COMPACT_TOOL } from "../runtime/extensions/self-compact-guard.ts";
 import { AGENTS } from "../services.ts";
@@ -16,6 +18,36 @@ export const seat: AgentTurnScope = {
 	group: "war-room",
 };
 
+/**
+ * The conversations the recorded sessions live in, served as a host serves them: the owner's
+ * direct messages by an app's claim, such as one that answers the owner there, and the agent's
+ * channel by the agent server; both answer background turns, so their sessions schedule and
+ * delegate. Give it to the test host the tool set is captured on.
+ */
+export function servedConversations(
+	ownerChannel: ChannelKey,
+): RoundtablePlugin {
+	const served = new Set<ChannelKey>([ownerChannel, scout.home, seat.home]);
+	return {
+		name: "served-conversations",
+		setup: () => ({
+			channels: [
+				{
+					name: "served-conversations",
+					priority: 0,
+					owns: (channel) => served.has(channel),
+					admit: () => undefined,
+					background: async () => ({
+						status: "skipped",
+						reason: "the tool set's host runs no background turns",
+					}),
+					startFresh: async () => "owner",
+				},
+			],
+		}),
+	};
+}
+
 /** Tools the core's own extensions and pi-web-access register, which no fake session here loads. */
 const NAMED_ELSEWHERE = [
 	ASK_USER_TOOL,

package/src/core/tool-set.snapshot.json

@@ -37,7 +37,7 @@
 				"memory_add",
 				"memory_remove",
 				"memory_search",
-				"notify_owner",
+				"notify",
 				"schedule_cancel",
 				"schedule_create",
 				"schedule_list",
@@ -92,7 +92,7 @@
 				"memory_remove",
 				"memory_search",
 				"message_agent",
-				"notify_owner",
+				"notify",
 				"schedule_cancel",
 				"schedule_create",
 				"schedule_list",
@@ -179,7 +179,7 @@
 				"memory_add",
 				"memory_remove",
 				"memory_search",
-				"notify_owner",
+				"notify",
 				"schedule_cancel",
 				"schedule_create",
 				"schedule_list",
@@ -272,7 +272,7 @@
 		"memory_remove": "member",
 		"memory_search": "member",
 		"message_agent": "member",
-		"notify_owner": "owner",
+		"notify": "owner",
 		"read": "owner",
 		"read_attachment": "member",
 		"schedule_cancel": "admin",

package/src/core/tool-tiers.ts

@@ -1,4 +1,5 @@
 import { PluginError } from "./errors.ts";
+import type { Logger } from "./log.ts";
 import { ASK_USER_TOOL } from "./runtime/extensions/ask-user.ts";
 import { COMPACT_TOOL } from "./runtime/extensions/self-compact-guard.ts";
 import { type Tier, tierAtLeast } from "./speakers.ts";
@@ -27,6 +28,40 @@ export const CORE_TOOL_TIERS: Readonly<Record<string, Tier>> = set("member", [
 	"read_attachment",
 ]);
 
+/**
+ * Tools renamed since 0.8, by their old name: until 1.0 the old name still names the tool in a
+ * selection, a task's `exclude`, a plugin's `requiredTools`, and the operator's and plugins'
+ * `toolTiers`, where the new name's own setting wins.
+ */
+export const RENAMED_TOOLS: Readonly<Record<string, string>> = {
+	notify_owner: "notify",
+};
+
+const warnedAliases = new WeakMap<Logger, Set<string>>();
+
+/** Each logger warns once for an old name used in tiers or selections. */
+function warnAliases(tools: readonly string[], logger: Logger): void {
+	const warned = warnedAliases.get(logger) ?? new Set<string>();
+	warnedAliases.set(logger, warned);
+	for (const tool of tools) {
+		const renamed = RENAMED_TOOLS[tool];
+		if (!renamed || warned.has(tool)) continue;
+		warned.add(tool);
+		logger.warn(
+			`deprecated: ${tool} is now ${renamed}; update selections and toolTiers before 1.0`,
+		);
+	}
+}
+
+/** The tools named, each by its current name and once, in order. */
+export function currentToolNames(
+	tools: readonly string[],
+	logger?: Logger,
+): string[] {
+	if (logger) warnAliases(tools, logger);
+	return [...new Set(tools.map((tool) => RENAMED_TOOLS[tool] ?? tool))];
+}
+
 /**
  * What each tool needs: the operator's setting first, then the tier its plugin declared, then
  * the core's default, and the owner for a tool nobody named. Plugins declare theirs when the
@@ -38,7 +73,15 @@ export class ToolTierTable implements ToolTiers {
 	readonly #core = new Map(Object.entries(CORE_TOOL_TIERS));
 
 	constructor(operator: Readonly<Record<string, Tier>> = {}) {
-		this.#operator = new Map(Object.entries(operator));
+		const entries = Object.entries(operator);
+		// An old name first, so the new name's own setting overrides it.
+		this.#operator = new Map([
+			...entries.flatMap(([tool, tier]) => {
+				const renamed = RENAMED_TOOLS[tool];
+				return renamed ? [[renamed, tier] as const] : [];
+			}),
+			...entries,
+		]);
 	}
 
 	/**
@@ -46,7 +89,16 @@ export class ToolTierTable implements ToolTiers {
 	 * plugin declaring its own tool again, as when the host retries its start, replaces it.
 	 */
 	declare(plugin: string, tiers: Readonly<Record<string, Tier>>): void {
-		for (const [tool, tier] of Object.entries(tiers)) {
+		const entries = Object.entries(tiers);
+		// An old name is the new name's, declared first so the new name's own tier wins.
+		const named = [
+			...entries.flatMap(([tool, tier]) => {
+				const renamed = RENAMED_TOOLS[tool];
+				return renamed ? [[renamed, tier] as const] : [];
+			}),
+			...entries.filter(([tool]) => !RENAMED_TOOLS[tool]),
+		];
+		for (const [tool, tier] of named) {
 			const other = this.#declared.get(tool);
 			if (other && other.plugin !== plugin)
 				throw new PluginError(
@@ -73,11 +125,13 @@ export class ToolTierTable implements ToolTiers {
 /** The core's tiers with the operator's on top; plugins add theirs through `declare`. */
 export function toolTiers(
 	operator: Readonly<Record<string, Tier>> = {},
+	logger?: Logger,
 ): ToolTierTable {
+	if (logger) warnAliases(Object.keys(operator), logger);
 	return new ToolTierTable(operator);
 }
 
-/** The tools a tier may use, in order; a turn nobody spoke in has the owner's tier. */
+/** The tools a tier may use, in order; a turn's tier is its speaker's, and a turn without one is refused. */
 export function toolsForTier(
 	tools: readonly string[],
 	tier: Tier,

package/src/discord/index.ts

@@ -4,12 +4,19 @@
 export type { DiscordServices } from "../core/builtin/discord.ts";
 export { DISCORD } from "../core/builtin/discord.ts";
 export type { DiscordAdapterConfig } from "../core/config/config.ts";
+export type {
+	ChannelContext,
+	ChannelContextMessage,
+	ChannelContextOptions,
+} from "../core/contract/channel-context.ts";
+export { withChannelContext } from "../core/contract/channel-context.ts";
 export type { AgentPanelMessage } from "../core/discord/agent-commands.ts";
 export type {
 	AgentPanel,
 	AgentPanelOptions,
 } from "../core/discord/agent-panel.ts";
 export { agentPanel } from "../core/discord/agent-panel.ts";
+export { CHANNEL_CONTEXT_DEFAULTS } from "../core/discord/channel-context.ts";
 export type { ManagedChannel } from "../core/discord/channel-executor.ts";
 export {
 	fetchManagedChannel,
@@ -35,6 +42,7 @@ export type {
 	DiscordConnection,
 } from "../core/discord/connection.ts";
 export { discord } from "../core/discord/discord-adapter.ts";
+export type { DiscordActor } from "../core/discord/discord-owners.ts";
 export type {
 	CommandGuard,
 	CommandRegistrar,