pi-roundtable-web 0.26.0 → 0.26.1

package/src/app/routes.ts

@@ -19,11 +19,13 @@ import type {
 	CharacterRefusal,
 	MessagesView,
 	ModelsView,
+	RoomOneView,
 	RoomsView,
 	SchedulesView,
 	ScheduleView,
 	SessionView,
 	SkillView,
+	ThreadsDismissed,
 	WorkspaceConflict,
 	WorkspaceNew,
 	WorkspaceRefusalBody,
@@ -48,7 +50,7 @@ import type { LayoutStore } from "./layout.ts";
 import { LayoutRoutes } from "./layout-routes.ts";
 import { PromptApi, type PromptApiOptions } from "./prompt-routes.ts";
 import { PAGE_LIMIT, type RoomLog } from "./room-log.ts";
-import type { Rooms } from "./rooms.ts";
+import type { ResolvedRoom, Rooms } from "./rooms.ts";
 import { SkillDocApi } from "./skill-doc-routes.ts";
 import type { AppSurface } from "./surface.ts";
 import { TeamApi } from "./team-routes.ts";
@@ -75,7 +77,10 @@ export interface AppApiOptions {
 	/** The rooms whose push the owners muted. */
 	mutes: Pick<PushMutes, "set" | "setMany">;
 	/** The dispatch threads, which go with the room they hang under. */
-	threads: Pick<WebThreads, "under" | "removeUnder">;
+	threads: Pick<
+		WebThreads,
+		"under" | "removeUnder" | "dismiss" | "dismissFinished"
+	>;
 	/** The owners' shared arrangement of the room list: pins and folders. */
 	layout: LayoutStore;
 	conversations: Pick<ConversationPort, "startFresh">;
@@ -496,6 +501,16 @@ export class AppApi {
 		}
 		const room = await rooms.resolve(key);
 		if (!room) throw notFound();
+		if (!action && method === "GET") {
+			// A thread dismissed from the list still opens by its address; the page asks for its view.
+			const view = await rooms.threadView(room.key);
+			if (!view) throw notFound();
+			return json({ room: view } satisfies RoomOneView);
+		}
+		if (action === "dismiss" && method === "POST" && parts.length === 4)
+			return this.#dismiss(room, admission);
+		if (action === "dismiss-threads" && method === "POST" && parts.length === 4)
+			return this.#dismissFinished(room, admission);
 		if (action === "messages" && method === "GET" && parts.length === 4) {
 			const params = new URL(request.url).searchParams;
 			const before = params.get("before");
@@ -573,6 +588,33 @@ export class AppApi {
 		throw new HttpError(404, "There is no such API.");
 	}
 
+	/** Takes one finished thread off the room list for every owner; an open one is refused. */
+	async #dismiss(
+		room: ResolvedRoom,
+		admission: Authenticated,
+	): Promise<Response> {
+		if (room.kind !== "thread") throw notFound();
+		await this.#owner(admission);
+		const outcome = await this.#options.threads.dismiss(room.name);
+		if (outcome === "missing") throw notFound();
+		if (outcome === "open")
+			throw new HttpError(409, "The thread is still open.");
+		this.#options.changed();
+		return json({ dismissed: 1 } satisfies ThreadsDismissed);
+	}
+
+	/** Takes every finished thread of a room off the room list; the open ones stay. */
+	async #dismissFinished(
+		room: ResolvedRoom,
+		admission: Authenticated,
+	): Promise<Response> {
+		if (room.kind === "thread") throw notFound();
+		await this.#owner(admission);
+		const dismissed = await this.#options.threads.dismissFinished(room.key);
+		if (dismissed) this.#options.changed();
+		return json({ dismissed } satisfies ThreadsDismissed);
+	}
+
 	async #file(id: string, admission: Authenticated): Promise<Response> {
 		if (!isFileId(id)) throw notFound();
 		const { files, host } = this.#options;

package/src/app/socket.ts

@@ -559,7 +559,9 @@ export class SocketRoute {
 			this.#refuse(connection, code, frame.id);
 		// The agent rooms are the owners', and they take only turns.
 		if (who.tier !== "owner") return refuse("forbidden");
-		if (frame.mode === "note") return refuse("bad_frame");
+		// A note is for the other people who read the rooms; where nobody else does, it is no frame.
+		const note = frame.mode === "note";
+		if (note && !(await rooms.notesOn())) return refuse("bad_frame");
 		const room = await rooms.resolve(frame.room);
 		if (!room) return refuse("unknown_room");
 		if (room.readOnly) return refuse("read_only");
@@ -567,18 +569,22 @@ export class SocketRoute {
 		if (text.length > MAX_MESSAGE_CHARS) return refuse("too_long");
 		const ids = frame.uploads ?? [];
 		if (text === "" && ids.length === 0) return refuse("empty");
-		// Without the actor the credential vouched for, the router cannot tell whose message it is.
-		if (!who.actor) return refuse("forbidden");
+		// Without the actor the credential vouched for, the router cannot tell whose message it is;
+		// a note goes to no router.
+		if (!note && !who.actor) return refuse("forbidden");
 		const files = uploads.claim(ids, who.principalId);
 		if (!files) return refuse("unknown_upload");
 		if (!surface.started) return refuse("not_accepted");
 		try {
-			await this.say(room.key, who, text, files, connection, (message) =>
-				sockets.deliver(
-					{ type: "accepted", id: frame.id, room: room.key, message },
-					{ connection },
-				),
-			);
+			if (note)
+				await this.#note(connection, who, room.key, frame.id, text, files);
+			else
+				await this.say(room.key, who, text, files, connection, (message) =>
+					sockets.deliver(
+						{ type: "accepted", id: frame.id, room: room.key, message },
+						{ connection },
+					),
+				);
 		} catch (error) {
 			logger.warn(
 				{ room: room.key, err: error },
@@ -588,6 +594,36 @@ export class SocketRoute {
 		}
 	}
 
+	/**
+	 * Keeps an owner's internal note in a room: stored and shown to the other readers, and given to
+	 * no one else. It does not reach the host, so the agent runs no turn, the note is not in its
+	 * conversation, and nothing about the room reads as asked.
+	 */
+	async #note(
+		connection: AppSocket,
+		who: Answerer,
+		room: ChannelKey,
+		id: string,
+		text: string,
+		files: readonly RoomFile[],
+	): Promise<void> {
+		const { surface, uploads, sockets } = this.#options;
+		const message = await surface.publish(
+			{
+				room,
+				kind: "owner",
+				principalId: who.principalId,
+				author: who.name,
+				text,
+				files: [...files],
+				note: true,
+			},
+			connection,
+		);
+		uploads.use(files.map((file) => file.id));
+		sockets.deliver({ type: "accepted", id, room, message }, { connection });
+	}
+
 	/**
 	 * Takes a message of the owner into a room: stores it, shows it to the other sockets, and
 	 * hands it to the host as the owner's. `files` are uploads the sender claimed, which move to

package/src/app/threads.ts

@@ -60,6 +60,15 @@ export class WebThreads {
 		},
 	};
 
+	/** The mark of a finished thread the owners took off the room list; the thread itself stays. */
+	static readonly dismissedMigration: Migration = {
+		name: "web-threads-dismissed",
+		up: async (sql) => {
+			await sql`
+				ALTER TABLE web_threads ADD COLUMN IF NOT EXISTS dismissed_at timestamptz`;
+		},
+	};
+
 	/** Starts a thread under `parent`. */
 	async open(parent: string, title: string): Promise<WebThread> {
 		const id = `thread.${crypto.randomUUID()}`;
@@ -76,6 +85,26 @@ export class WebThreads {
 		await this.#sql`UPDATE web_threads SET open = false WHERE id = ${id}`;
 	}
 
+	/**
+	 * Takes a finished thread off the room list. It stays readable by its address, and asking again
+	 * changes nothing. An open thread is refused: `open` says so, `missing` that there is none.
+	 */
+	async dismiss(id: string): Promise<"dismissed" | "open" | "missing"> {
+		const rows: unknown[] = await this.#sql`
+			UPDATE web_threads SET dismissed_at = COALESCE(dismissed_at, now())
+			WHERE id = ${id} AND NOT open RETURNING 1`;
+		if (rows.length) return "dismissed";
+		return (await this.get(id)) ? "open" : "missing";
+	}
+
+	/** Dismisses every finished thread under `parent` that is still listed; returns how many. */
+	async dismissFinished(parent: string): Promise<number> {
+		const rows: unknown[] = await this.#sql`
+			UPDATE web_threads SET dismissed_at = now()
+			WHERE parent = ${parent} AND NOT open AND dismissed_at IS NULL RETURNING 1`;
+		return rows.length;
+	}
+
 	async get(id: string): Promise<WebThread | undefined> {
 		const [row]: Row[] = await this
 			.#sql`SELECT * FROM web_threads WHERE id = ${id}`;
@@ -98,14 +127,14 @@ export class WebThreads {
 
 	/**
 	 * The threads the room list shows, newest first: every open one, and the `closedLimit` newest
-	 * closed ones, which stay readable but are not kept in view for ever.
+	 * closed ones that were not dismissed. The rest stay readable but are not kept in view.
 	 */
 	async list(closedLimit = CLOSED_LISTED): Promise<WebThread[]> {
 		const rows: Row[] = await this.#sql`
 			SELECT * FROM (
 				SELECT * FROM web_threads WHERE open
 				UNION ALL
-				(SELECT * FROM web_threads WHERE NOT open
+				(SELECT * FROM web_threads WHERE NOT open AND dismissed_at IS NULL
 					ORDER BY created_at DESC, id LIMIT ${closedLimit})
 			) shown ORDER BY created_at DESC, id`;
 		return rows.map(threadOf);

package/src/auth/authenticator.ts

@@ -78,7 +78,7 @@ export interface AuthenticatorOptions {
 	listener: { id: string; address: Readonly<ListenerAddress> | undefined };
 	/** The sign-in flow and the session store, for `oidc`. */
 	oidc?: {
-		login: Pick<OidcLogin, "open" | "credential">;
+		login: Pick<OidcLogin, "open" | "credential" | "verified">;
 		sessions: Pick<WebSessions, "alive">;
 	};
 	/** Where the password is read from; default `process.env`. */
@@ -205,6 +205,8 @@ export function createAuthenticator(
 			)
 				return denied("foreign origin");
 			const { session } = checked as Admitted;
+			if (session)
+				options.oidc?.login.verified(session, identified.visitor.principal.id);
 			return {
 				visitor: identified.visitor,
 				...(checked.actor ? { actor: checked.actor } : {}),
@@ -222,9 +224,13 @@ export function createAuthenticator(
 				}
 			}
 			const identified = await identify(held.actor);
-			return "refusal" in identified
-				? denied(String(identified.refusal))
-				: { visitor: identified.visitor };
+			if ("refusal" in identified) return denied(String(identified.refusal));
+			if (held.session)
+				options.oidc?.login.verified(
+					held.session,
+					identified.visitor.principal.id,
+				);
+			return { visitor: identified.visitor };
 		},
 	};
 }

package/src/auth/login-page.ts

@@ -1,9 +1,10 @@
 import { type ConsolePresentation, message } from "../features.ts";
 import { escapeHtml } from "../http.ts";
+import { iconLinks } from "../page-presentation.ts";
 
-/** The login page's CSP: no script at all, one inline style, and the form posts only to this origin. */
+/** The login page's CSP: no script at all, one inline style, its own icon, and the form posts only to this origin. */
 export const LOGIN_CSP =
-	"default-src 'none'; style-src 'unsafe-inline'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'";
+	"default-src 'none'; style-src 'unsafe-inline'; img-src 'self'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'";
 
 /** The login page, as one server-rendered document with no script; `note` is a line above the field. */
 export function loginPage(
@@ -19,6 +20,7 @@ export function loginPage(
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta name="robots" content="noindex">
+${iconLinks(mount, false)}
 <title>${escapeHtml(title)}</title>
 <style>
 body{font:16px/1.5 system-ui,sans-serif;margin:0;min-height:100vh;display:grid;place-items:center;background:#f6f6f4;color:#1c1c1a}

package/src/auth/oidc-pages.ts

@@ -1,5 +1,6 @@
 import { type ConsolePresentation, message } from "../features.ts";
 import { escapeHtml } from "../http.ts";
+import { iconLinks } from "../page-presentation.ts";
 import { LOGIN_CSP } from "./login-page.ts";
 
 /** What a page of the sign-in flow tells, and the link it offers. */
@@ -30,6 +31,7 @@ export function oidcPage(
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta name="robots" content="noindex">
+${iconLinks(mount, false)}
 <title>${escapeHtml(title)}</title>
 <style>
 body{font:16px/1.5 system-ui,sans-serif;margin:0;min-height:100vh;display:grid;place-items:center;background:#f6f6f4;color:#1c1c1a}

package/src/auth/oidc.ts

@@ -27,6 +27,10 @@ const MAX_NAME_CHARS = 100;
 const MAX_SUBJECT_CHARS = 256;
 /** The most characters of one stored claim, as JSON. */
 const MAX_CLAIM_CHARS = 2000;
+/** How seldom a live session is reported again to `onSessionVerified`. */
+const VERIFIED_EVERY_MS = 300_000;
+/** The most sessions whose last report is remembered before the lapsed ones are dropped. */
+const VERIFIED_PRUNE_AT = 1024;
 /** Answers to a silent request that mean "the person must be asked", not "something is wrong". */
 const INTERACTION_NEEDED = new Set([
 	"login_required",
@@ -133,6 +137,8 @@ export interface OidcLoginOptions {
 	onSignIn?(info: SignedIn): void | Promise<void>;
 	/** A session ended (logout), so the sockets on it can close. */
 	onEnded?(sessionId: string): void;
+	/** A request or an open socket proved a live session of this person: the host's `onSessionVerified`. */
+	onSessionVerified?(principalId: string): void | Promise<void>;
 	logger: Logger;
 	/** The provider's signing keys; the published ones by default. */
 	keys?: JWTVerifyGetKey;
@@ -210,6 +216,8 @@ export class OidcLogin {
 	readonly #outCookie = "__Secure-rt_out";
 	/** States already used, until they would have lapsed. */
 	readonly #spent = new Map<string, number>();
+	/** When each session was last reported to `onSessionVerified`, by session id. */
+	readonly #verified = new Map<string, number>();
 
 	constructor(options: OidcLoginOptions) {
 		this.#options = options;
@@ -576,6 +584,33 @@ export class OidcLogin {
 		return { admitted: true, actor: facts, session: session.id };
 	};
 
+	/**
+	 * Reports that a request or an open socket proved this session live, so the host may count the
+	 * person as present. At most once per session every few minutes; never waits for the hook and
+	 * never throws: a hook that fails is logged.
+	 */
+	verified(session: string, principalId: string): void {
+		const hook = this.#options.onSessionVerified;
+		if (!hook) return;
+		const now = this.#now();
+		const last = this.#verified.get(session);
+		if (last !== undefined && now - last < VERIFIED_EVERY_MS) return;
+		if (this.#verified.size >= VERIFIED_PRUNE_AT)
+			for (const [id, at] of this.#verified)
+				if (now - at >= VERIFIED_EVERY_MS) this.#verified.delete(id);
+		this.#verified.set(session, now);
+		const failed = (cause: unknown) =>
+			this.#options.logger.warn(
+				{ err: cause },
+				"web-console: the session-verified hook failed",
+			);
+		try {
+			Promise.resolve(hook(principalId)).catch(failed);
+		} catch (cause) {
+			failed(cause);
+		}
+	}
+
 	async #logout(request: Request): Promise<Response> {
 		const { mount, origin, settings, metadata } = this.#options;
 		if (request.headers.get("origin") !== origin)
@@ -589,7 +624,10 @@ export class OidcLogin {
 		);
 		if (token) {
 			const id = await this.#options.sessions.end(token).catch(() => undefined);
-			if (id) this.#options.onEnded?.(id);
+			if (id) {
+				this.#verified.delete(id);
+				this.#options.onEnded?.(id);
+			}
 		}
 		const base = `${mount}/`;
 		let to = `${mount}/auth/signed-out`;

package/src/authz.ts

@@ -50,7 +50,8 @@ export const ROUTES: readonly Rule[] = [
 	row("*", "api/notes", "V"),
 	row("*", "api/notes/:id", "V"),
 	row("*", "api/principals", "V"),
-	// The agent rooms are the owners'. The route says 404, not 403, to anyone else.
+	// The agent rooms are the owners'. The route says 404, not 403, to anyone else. Their threads are under
+	// it too: a thread's view and `…/dismiss`, and `…/dismiss-threads` of its parent.
 	row("*", "api/rooms", "O", true),
 	row("*", "api/rooms/**", "O", true),
 	row("*", "api/folders/**", "O"),

package/src/console-server.ts

@@ -12,8 +12,12 @@ import type { ConsoleApi } from "./console-api.ts";
 import { type ConsolePresentation, message } from "./features.ts";
 import type { Gate } from "./gate.ts";
 import { json } from "./http.ts";
-import { presentPage } from "./page-presentation.ts";
-import { servePwa } from "./pwa.ts";
+import {
+	defaultDescription,
+	type PageMeta,
+	presentPage,
+} from "./page-presentation.ts";
+import { hasMarkSvg, isPublicStatic, servePwa } from "./pwa.ts";
 import type { Visitor } from "./visitors.ts";
 import { viewerOf } from "./web-app.ts";
 
@@ -76,6 +80,10 @@ export interface ConsoleServerOptions {
 	/** Where the install icons come from; default the ones this package ships. */
 	iconsDir?: string;
 	look?: "modern" | "camelot";
+	/** The console's own origin, for the absolute `og:image` of a link preview. */
+	origin?: string;
+	/** What the page says about itself in a search result and a link preview; default derived from the title. */
+	description?: string;
 }
 
 /**
@@ -89,6 +97,7 @@ export interface ConsoleServerOptions {
 export class ConsoleServer {
 	readonly #options: ConsoleServerOptions;
 	readonly #base: string;
+	readonly #meta: PageMeta | undefined;
 	readonly #streams = new Set<ReadableStreamDefaultController<Uint8Array>>();
 	#pending: ReturnType<typeof setTimeout> | undefined;
 	#ping: ReturnType<typeof setInterval> | undefined;
@@ -96,6 +105,16 @@ export class ConsoleServer {
 	constructor(options: ConsoleServerOptions) {
 		this.#options = options;
 		this.#base = `${options.mount}/`;
+		const title = options.title ?? "Roundtable";
+		this.#meta = options.origin
+			? {
+					title,
+					description: options.description ?? defaultDescription(title),
+					origin: options.origin,
+					mount: options.mount,
+					svg: hasMarkSvg(options.iconsDir),
+				}
+			: undefined;
 		options.subscribe(() => this.#changed());
 	}
 
@@ -157,6 +176,11 @@ export class ConsoleServer {
 		if (path !== this.#options.mount && !path.startsWith(this.#base))
 			return new Response("Not found", { status: 404 });
 		const rest = path.slice(this.#base.length);
+		// Static and the same for everyone: a sign-in page and a link preview show the icon without a session.
+		if (READ_METHODS.has(request.method) && isPublicStatic(rest)) {
+			const shown = servePwa(rest, this.#pwa());
+			if (shown) return shown;
+		}
 		const open = await this.#options.authenticator.open?.(request, rest);
 		if (open) return open;
 		const admission = await this.#options.authenticator.authenticate(request);
@@ -183,10 +207,7 @@ export class ConsoleServer {
 			);
 		if (!READ_METHODS.has(request.method))
 			return new Response("Method not allowed", { status: 405 });
-		const installable = servePwa(rest, {
-			...this.#options,
-			title: this.#options.title ?? "Roundtable",
-		});
+		const installable = servePwa(rest, this.#pwa());
 		if (installable) return installable;
 		const asset = this.#options.assets.get(rest);
 		if (asset && rest !== "index.html" && rest !== "sw.js")
@@ -205,6 +226,7 @@ export class ConsoleServer {
 						this.#options.pathRouting ? this.#options.mount : undefined,
 						this.#options.presentation,
 						this.#options.look,
+						this.#meta,
 					),
 					{
 						headers: {
@@ -223,6 +245,10 @@ export class ConsoleServer {
 		return new Response("Not found", { status: 404 });
 	}
 
+	#pwa(): Parameters<typeof servePwa>[1] {
+		return { ...this.#options, title: this.#options.title ?? "Roundtable" };
+	}
+
 	async #gated(visitor: Visitor): Promise<boolean> {
 		const { gate } = this.#options;
 		if (!gate) return false;

package/src/host/cards.ts

@@ -49,11 +49,20 @@ export class HostCardLog {
 		},
 	};
 
+	/** The mark of a card the host keeps past its kind's retention (`HostCard.keep`). */
+	static readonly keepMigration: Migration = {
+		name: "web-host-cards-keep",
+		up: async (sql) => {
+			await sql`
+				ALTER TABLE web_host_cards ADD COLUMN IF NOT EXISTS keep boolean NOT NULL DEFAULT false`;
+		},
+	};
+
 	async create(room: string, card: HostCard): Promise<StoredHostCard> {
 		const id = crypto.randomUUID();
 		const [row]: Row[] = await this.#sql`
-			INSERT INTO web_host_cards (id, room, card, state)
-			VALUES (${id}, ${room}, ${JSON.stringify(card)}::jsonb, ${card.state ?? null})
+			INSERT INTO web_host_cards (id, room, card, state, keep)
+			VALUES (${id}, ${room}, ${JSON.stringify(card)}::jsonb, ${card.state ?? null}, ${card.keep === true})
 			RETURNING *`;
 		if (!row) throw new Error("the card log stored nothing");
 		return cardOf(row);
@@ -67,7 +76,7 @@ export class HostCardLog {
 	): Promise<StoredHostCard | undefined> {
 		const [row]: Row[] = await this.#sql`
 			UPDATE web_host_cards
-			SET card = ${JSON.stringify(card)}::jsonb, state = ${card.state ?? null}, updated_at = now()
+			SET card = ${JSON.stringify(card)}::jsonb, state = ${card.state ?? null}, keep = ${card.keep === true}, updated_at = now()
 			WHERE id = ${id} AND room = ${room} RETURNING *`;
 		return row && cardOf(row);
 	}
@@ -85,11 +94,15 @@ export class HostCardLog {
 		return rows.map(cardOf);
 	}
 
-	/** Deletes the cards of the rooms whose key starts with `prefix` that are older than `before`; how many. */
+	/**
+	 * Deletes the cards of the rooms whose key starts with `prefix` that are older than `before`,
+	 * except those the host marked `keep`; how many.
+	 */
 	async sweepKind(prefix: string, before: Date): Promise<number> {
 		const rows: unknown[] = await this.#sql`
 			DELETE FROM web_host_cards
-			WHERE starts_with(room, ${prefix}) AND created_at < ${before} RETURNING 1`;
+			WHERE starts_with(room, ${prefix}) AND created_at < ${before}
+			AND NOT keep RETURNING 1`;
 		return rows.length;
 	}
 

package/src/host/context.ts

@@ -54,22 +54,46 @@ function sourceOf(message: RoomMessage): Source {
 	};
 }
 
+/** What `WebApp.rooms.context` takes. */
+export interface HostRoomContextOptions {
+	/** The most messages to return, newest kept; default 15, at most 100. */
+	limit?: number;
+	/** The most characters of one message before it is cut with `…`; default 500. */
+	messageChars?: number;
+}
+
+/** The two ways a host room's recent messages are read. */
+export interface HostRoomContext {
+	/** For a turn the room's message addressed: marks what it returns as handed over. */
+	read(
+		message: InboundMessage,
+		options?: ChannelContextOptions,
+	): Promise<ChannelContext | undefined>;
+	/** For a host with no addressing message: the same block, and nothing is marked handed over. */
+	peek(
+		room: string,
+		options?: HostRoomContextOptions,
+	): Promise<ChannelContext | undefined>;
+}
+
 /**
- * The app surface's `channelContext` for a host room: what was said in it since the assistant
+ * The app surface's channel context of a host room: what was said in it since the assistant
  * last posted, before the message that addressed it, as the core's block of channel messages. An
  * outsider's words read as `external`, a notice line is not in the channel as far as the context
  * goes, and a message already handed to the conversation is not handed again. Anything but a host
- * room has none: an agent room is one person's.
+ * room has none: an agent room is one person's. `peek` reads the same block for the end of the
+ * room and leaves the handed-over marks alone, so a retry gets the same.
  */
-export function hostChannelContext(
+export function hostRoomContext(
 	ctx: Pick<HostContext, "registry" | "log">,
-): (
-	message: InboundMessage,
-	options?: ChannelContextOptions,
-) => Promise<ChannelContext | undefined> {
+): HostRoomContext {
 	const seen = new Map<string, Set<string>>();
-	return async (message, options = {}) => {
-		const room = message.channel;
+	const build = async (
+		room: string,
+		addressed: number | undefined,
+		options: ChannelContextOptions,
+		consume: boolean,
+	): Promise<ChannelContext | undefined> => {
 		if (!ctx.registry.isHostRoom(room)) return undefined;
 		const fetch = positive("fetch", options.fetch ?? DEFAULT_FETCH, PAGE_LIMIT);
 		const keep = positive("keep", options.keep ?? DEFAULT_KEEP, 100);
@@ -78,12 +102,7 @@ export function hostChannelContext(
 			options.messageChars ?? DEFAULT_CHARS,
 			20_000,
 		);
-		const addressed = /^app-(\d+)$/.exec(message.messageId)?.[1];
-		const page = await ctx.log.page(
-			room,
-			addressed === undefined ? undefined : Number(addressed),
-			fetch,
-		);
+		const page = await ctx.log.page(room, addressed, fetch);
 		const sources = page.messages.map((one) => ({
 			source: sourceOf(one),
 			notice: authorKindOf(one) === "notice",
@@ -99,24 +118,26 @@ export function hostChannelContext(
 		const lastEnd = considered.findLastIndex(
 			(entry) => verdict(entry) === "end",
 		);
-		const known = seen.get(room) ?? new Set<string>();
+		const known = consume ? (seen.get(room) ?? new Set<string>()) : undefined;
 		const fresh = considered
 			.slice(lastEnd + 1)
 			.filter(
 				(entry) =>
 					verdict(entry) === "keep" &&
-					!known.has(entry.source.id) &&
+					!known?.has(entry.source.id) &&
 					entry.source.text !== "",
 			)
 			.slice(-keep);
-		// What was in the window is not handed over again, kept or not.
-		for (const entry of considered.slice(lastEnd + 1))
-			known.add(entry.source.id);
-		seen.delete(room);
-		seen.set(room, new Set([...known].slice(-SEEN_PER_ROOM)));
-		if (seen.size > SEEN_ROOMS) {
-			const oldest = seen.keys().next().value;
-			if (oldest !== undefined) seen.delete(oldest);
+		if (known) {
+			// What was in the window is not handed over again, kept or not.
+			for (const entry of considered.slice(lastEnd + 1))
+				known.add(entry.source.id);
+			seen.delete(room);
+			seen.set(room, new Set([...known].slice(-SEEN_PER_ROOM)));
+			if (seen.size > SEEN_ROOMS) {
+				const oldest = seen.keys().next().value;
+				if (oldest !== undefined) seen.delete(oldest);
+			}
 		}
 		if (fresh.length === 0) return undefined;
 		const messages: ChannelContextMessage[] = fresh.map(({ source }) => ({
@@ -138,4 +159,30 @@ export function hostChannelContext(
 		}));
 		return { messages, text: formatChannelContext(messages) };
 	};
+	return {
+		read(message, options = {}) {
+			const addressed = /^app-(\d+)$/.exec(message.messageId)?.[1];
+			return build(
+				message.channel,
+				addressed === undefined ? undefined : Number(addressed),
+				options,
+				true,
+			);
+		},
+		peek(room, options = {}) {
+			const limit = options.limit ?? DEFAULT_KEEP;
+			return build(
+				room,
+				undefined,
+				{
+					keep: limit,
+					fetch: Math.min(PAGE_LIMIT, Math.max(DEFAULT_FETCH, limit * 3)),
+					...(options.messageChars === undefined
+						? {}
+						: { messageChars: options.messageChars }),
+				},
+				false,
+			);
+		},
+	};
 }