@gavin-hu/my-pi-agent 0.18.0 → 0.19.0

package/extensions/wechat/bridge.ts

@@ -11,37 +11,35 @@
  * The peer only has the chat window, so the bridge carries the signals the phone
  * needs: typing starts as soon as a message is picked up, a message waiting on
  * another conversation is acknowledged once and told why, a slow turn says so,
- * and a burst that arrives before its turn starts is answered once, in order.
+ * and every queued message is answered in its own turn, in order.
  *
  * The model may message the owner proactively through {@link Bridge.sendToOwner}.
  */
 
-import { WechatError, type WechatClient } from "./client.ts";
-import { createAdmissionQueue, createTurnBudget } from "./admission.ts";
-import { createDeliverer, type MessageTarget } from "./deliver.ts";
-import { createInboundAdmission } from "./inbound.ts";
-import { createPollLoop, defaultPollTimeout } from "./poll.ts";
+import { WechatError, type WechatClient } from "./transport/client.ts";
+import { createAdmissionQueue, createTurnBudget } from "./peer/admission.ts";
+import { createDeliverer, type MessageTarget } from "./transport/deliver.ts";
+import { createInboundAdmission } from "./transport/inbound.ts";
+import { createPollLoop, defaultPollTimeout } from "./transport/poll.ts";
 import { messageOf } from "./errors.ts";
-import { parseInbound, peerKey, peerLabel, peerLanguage, sanitizeInbound, type PeerLanguage } from "./format.ts";
-import { notice } from "./notices.ts";
-import { createPresence } from "./presence.ts";
-import {
-	createWechatInteractionChannel,
-	type PendingPromptInfo,
-	type WechatInteractionChannel,
-} from "./interaction.ts";
+import { parseInbound, peerKey, peerLabel, peerLanguage, sanitizeInbound, type PeerLanguage } from "./text/format.ts";
+import { notice } from "./text/notices.ts";
+import { createPresence } from "./peer/presence.ts";
+import { createPeerChannels, type PeerChannels } from "./dialog/channels.ts";
+import type { PendingPromptInfo, WechatInteractionChannel } from "./dialog/interaction.ts";
 import { defaultSleep, defaultTimer, type ArmTimer } from "./timer.ts";
-import { createPeerWorker, type PeerState, type PeerWorker } from "./peer-worker.ts";
-import type { PeerSession } from "./peer-session.ts";
-import { emptyState, findPeer, recordInbound, rememberMessage, seenMessage } from "./state.ts";
+import { createPeerWorker, type PeerState, type PeerWorker } from "./peer/peer-worker.ts";
+import type { PeerSession } from "./peer/peer-session.ts";
+import { emptyState, findPeer, ownerTarget, recordInbound, rememberMessage, seenMessage } from "./state/state.ts";
 import {
 	expandSnippet,
 	findSlashCommand,
 	parseSlash,
+	slashControls,
 	SLASH_COMMANDS,
 	type SlashCommand,
 	type SlashContext,
-} from "./slash.ts";
+} from "./commands/slash.ts";
 import type { BotCredentials, InboundItem, WechatState, WeixinMessage } from "./types.ts";
 import type { WechatConfig } from "./config.ts";
 
@@ -120,10 +118,10 @@ export interface BridgeStatus {
 	/** Labels of the senders refused since the bridge opened, newest last, capped. */
 	refusedPeers: string[];
 	mediaDropped: number;
-	/** Whether a remote dialog prompt is waiting for an answer. */
+	/** Whether any peer's dialogs prompt is waiting for an answer. */
 	promptPending: boolean;
-	/** The waiting prompt's peer, kind, title, and age. */
-	prompt?: PendingPromptInfo;
+	/** Every waiting prompt, one per peer, with its kind, title, and age. */
+	prompts: PendingPromptInfo[];
 	/** When this connection opened. */
 	startedAt?: number;
 	/** When the last poll settled, successful or not. */
@@ -160,10 +158,10 @@ export interface Bridge {
 	/** What one peer's conversation is doing, for `/status`. */
 	peerState(peer: string): PeerState;
 	status(): BridgeStatus;
-	/** The remote interaction channel the peer sessions route their dialogs through. */
-	channel(): WechatInteractionChannel;
-	/** Message the owner proactively. Owner-only and text-only by design. */
-	sendToOwner(text: string): Promise<SendResult>;
+	/** One peer's interaction channel: the channel its session routes its dialogs through. */
+	channel(peer: string): WechatInteractionChannel;
+	/** Message the owner proactively: one text, or one image, never a chosen recipient. */
+	sendToOwner(text: string | undefined, image?: string): Promise<SendResult>;
 }
 
 /** Create the bridge over an injected environment. */
@@ -225,8 +223,8 @@ export function createBridge(deps: BridgeDeps): Bridge {
 	}
 
 	/** Send one bubble to a peer and report whether it was delivered. */
-	async function reply(target: MessageTarget, text: string): Promise<boolean> {
-		return deliverer.reply(target, text, abort?.signal);
+	async function reply(target: MessageTarget, text: string, signal?: AbortSignal): Promise<boolean> {
+		return deliverer.reply(target, text, signal ?? abort?.signal);
 	}
 
 	/** The outbound surface, reading the live client and account at call time. */
@@ -257,18 +255,15 @@ export function createBridge(deps: BridgeDeps): Bridge {
 			},
 			activeTurn: worker?.state(target.peer).status === "running",
 			language: languageOf(target.peer),
-			session: {
-				newSession: () => {
-					worker?.reset(target.peer);
-				},
-				stop: () => worker?.abort(target.peer) ?? false,
-				status: () => {
-					const current = worker?.state(target.peer) ?? { status: "idle" as const, queued: 0 };
-					const waiting = interaction.pendingInfo();
-					return waiting?.peer === target.peer ? { ...current, prompt: waiting.title } : current;
+			session: slashControls(target.peer, {
+				state: (peer) => worker?.state(peer) ?? { status: "idle", queued: 0 },
+				prompt: (peer) => channels.pendingFor(peer)?.title,
+				reset: (peer) => {
+					worker?.reset(peer);
 				},
-				history: (count) => deps.readHistory(target.peer, count),
-			},
+				stop: (peer) => worker?.abort(peer) ?? false,
+				history: (peer, count) => deps.readHistory(peer, count),
+			}),
 		};
 		try {
 			await command.run(ctx);
@@ -279,31 +274,27 @@ export function createBridge(deps: BridgeDeps): Bridge {
 	}
 
 	/**
-	 * Send a prompt to the peer owning the in-flight turn.
+	 * Every peer's dialogs, one channel each.
 	 *
-	 * A failure is reported on the terminal once per peer by the deliverer; a silent
-	 * failure would leave the peer with only the choices, as if nothing preceded
-	 * them.
+	 * A prompt is sent through the peer's channel to the turn it belongs to, so a
+	 * reply can only answer its own peer's question even when two turns run at once.
+	 * A failure is reported once per peer by the deliverer; a silent failure would
+	 * leave the peer with only the choices, as if nothing preceded them.
 	 */
-	async function sendPrompt(text: string, signal?: AbortSignal, options?: { force?: boolean }): Promise<boolean> {
-		const current = worker?.current();
-		if (!current) return false;
-		// The model may have produced text before this prompt; put it on the wire first.
-		await worker?.flush(current.peer);
-		if (!options?.force && !interaction.hasPending()) return false;
-		return deliverer.prompt(current, text, signal ?? abort?.signal);
-	}
-	async function sendFileToPeer(filePath: string, fileName: string, signal?: AbortSignal): Promise<boolean> {
-		const current = worker?.current();
-		if (!current) return false;
-		await worker?.flush(current.peer);
-		return deliverer.file(current, filePath, fileName, signal ?? abort?.signal);
-	}
-	const interaction = createWechatInteractionChannel({
-		send: (text, signal, options) => sendPrompt(text, signal, options),
-		sendFile: (path, name, signal) => sendFileToPeer(path, name, signal),
-		activePeer: () => worker?.current()?.peer,
-		language: () => languageOf(worker?.current()?.peer ?? ""),
+	const channels: PeerChannels = createPeerChannels({
+		flush: async (peer) => {
+			await worker?.flush(peer);
+		},
+		send: (peer, text, signal) => {
+			const item = worker?.running(peer);
+			return item ? deliverer.prompt(item, text, signal ?? abort?.signal) : Promise.resolve(false);
+		},
+		sendFile: (peer, filePath, fileName, signal) => {
+			const item = worker?.running(peer);
+			return item ? deliverer.file(item, filePath, fileName, signal ?? abort?.signal) : Promise.resolve(false);
+		},
+		active: (peer) => worker?.state(peer).status === "running",
+		language: (peer) => languageOf(peer),
 		armTimer: deps.armTimer,
 	});
 
@@ -316,11 +307,6 @@ export function createBridge(deps: BridgeDeps): Bridge {
 		return languages.get(peer) ?? "en";
 	}
 
-	/** The peer's conversation state, for the wait decisions in presence. */
-	function peerStatus(peer: string): PeerState["status"] {
-		return worker?.state(peer).status ?? "idle";
-	}
-
 	/** Typing, acknowledgement, and the slow/busy lines; one timer registry each. */
 	const presence = createPresence({
 		typingIndicator: () => deps.config.typingIndicator,
@@ -329,10 +315,10 @@ export function createBridge(deps: BridgeDeps): Bridge {
 		client: () => client,
 		account: () => account,
 		signal: () => abort?.signal,
-		statusOf: peerStatus,
+		statusOf: (peer) => worker?.state(peer).status ?? "idle",
 		languageOf,
 		send: (peer, contextToken, text) => reply({ peer, contextToken }, text),
-		promptPending: () => interaction.hasPending(),
+		promptPending: (peer) => channels.hasPending(peer),
 	});
 
 	/** Inbound media resolution and the hand-off to a peer session. */
@@ -410,7 +396,7 @@ export function createBridge(deps: BridgeDeps): Bridge {
 		}
 		// A reply to a pending prompt is consumed here, before queueing, so it never
 		// starts a turn of its own. A duplicate answer was stopped by the id check.
-		if (interaction.handleInbound(peer, text)) return;
+		if (channels.handleInbound(peer, text)) return;
 		const language = languageOf(peer, text);
 		const item: InboundItem = { ...target, text, media, language };
 		if (!text && media.length === 0) {
@@ -477,7 +463,7 @@ export function createBridge(deps: BridgeDeps): Bridge {
 		overflow.clear();
 		refused = 0;
 		refusedPeers.clear();
-		interaction.reset();
+		channels.reset();
 		deliverer.reset();
 		presence.reset();
 		budget.reset();
@@ -552,10 +538,10 @@ export function createBridge(deps: BridgeDeps): Bridge {
 			// a login (or a reconnect after an expiry) starts from a clean slate while
 			// each peer's history stays on disk.
 			worker = createPeerWorker({
-				openSession: (peer, options) => deps.openSession(peer, { fresh: options.fresh, channel: interaction }),
+				openSession: (peer, options) => deps.openSession(peer, { fresh: options.fresh, channel: channels.for(peer) }),
 				// Each part is delivered as its own bubble; the worker puts the
 				// attachment line on the first one. A false result stops the stream.
-				send: (item, text) => reply(item, text),
+				send: (item, text, options) => reply(item, text, options?.signal),
 				fallback: (item, reason) => notice(reason, item.language),
 				onStart: (item) => {
 					presence.cancelAck(item.peer);
@@ -602,7 +588,7 @@ export function createBridge(deps: BridgeDeps): Bridge {
 				// worker, so close it unconditionally rather than leaking the sessions.
 				const closing = worker;
 				worker = undefined;
-				await closing?.close();
+				await closing?.close({ abandon: true });
 				resetEphemeral();
 				publishState();
 				releaseSafe();
@@ -618,7 +604,7 @@ export function createBridge(deps: BridgeDeps): Bridge {
 				// not be cancelled by the poll abort that follows.
 				const stopping = abort;
 				abort = undefined;
-				if (interaction.hasPending()) await interaction.cancel();
+				await channels.cancelAll();
 				stopping?.abort();
 				try {
 					await loopPromise;
@@ -682,8 +668,8 @@ export function createBridge(deps: BridgeDeps): Bridge {
 				refused,
 				refusedPeers: [...refusedPeers],
 				mediaDropped: inbound.dropped(),
-				promptPending: interaction.hasPending(),
-				prompt: interaction.pendingInfo(),
+				promptPending: channels.hasPending(),
+				prompts: channels.prompts(),
 				startedAt,
 				lastPollAt,
 				lastPollError,
@@ -694,27 +680,25 @@ export function createBridge(deps: BridgeDeps): Bridge {
 			};
 		},
 
-		channel(): WechatInteractionChannel {
-			return interaction;
+		channel(peer: string): WechatInteractionChannel {
+			return channels.for(peer);
 		},
 
-		async sendToOwner(text: string): Promise<SendResult> {
+		async sendToOwner(text: string | undefined, image?: string): Promise<SendResult> {
 			if (!running || !client || !account) return { ok: false, error: "WeChat bridge is not started." };
-			const owner = state.ownerId ?? account.ilinkUserId;
-			const current = worker?.current();
-			if (current && peerKey(current.peer) === peerKey(owner)) {
-				// The bridge answers this turn itself, so a tool send would land twice.
-				return {
-					ok: false,
-					error: "The bridge replies to this turn automatically; do not repeat it.",
-				};
+			const target = ownerTarget(state, account);
+			if (text !== undefined && worker?.state(target.peer).status === "running") {
+				// The bridge answers this turn itself, so a text send would land twice.
+				return { ok: false, error: "The bridge replies to this turn automatically; do not repeat it." };
+			}
+			if (image !== undefined) {
+				// An image cannot duplicate the streamed answer, so a running turn is fine.
+				const sent = await deliverer.image(target, image, abort?.signal);
+				return sent ? { ok: true } : { ok: false, error: "The image could not be sent; see the terminal notice." };
 			}
-			const trimmed = sanitizeInbound(text);
+			const trimmed = sanitizeInbound(text ?? "");
 			if (!trimmed) return { ok: false, error: "Nothing to send." };
-			// Either id form may be stored: the owner id comes from the login response
-			// and the token from an inbound `from_user_id`, and they need not agree.
-			const contextToken = findPeer(state, owner)?.lastContextToken;
-			return deliverer.toOwner(owner, contextToken, trimmed, abort?.signal);
+			return deliverer.toOwner(target.peer, target.contextToken, trimmed, abort?.signal);
 		},
 	};
 }

package/extensions/wechat/{commands.ts → commands/commands.ts}

@@ -18,21 +18,27 @@ import {
 	type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { join } from "node:path";
-import { writeConfigValue } from "../../lib/config.ts";
-import { sanitizeLine } from "../../lib/format.ts";
-import { supportsCustomUI } from "../../lib/interaction.ts";
-import { isAllowedPeer, type Bridge } from "./bridge.ts";
-import type { WechatClient } from "./client.ts";
-import type { WechatConfig } from "./config.ts";
+import { writeConfigValue } from "../../../lib/config.ts";
+import { sanitizeLine } from "../../../lib/format.ts";
+import { supportsCustomUI } from "../../../lib/interaction.ts";
+import { isAllowedPeer, type Bridge } from "../bridge.ts";
+import type { WechatClient } from "../transport/client.ts";
+import type { WechatConfig } from "../config.ts";
 import { doctorReport } from "./doctor.ts";
-import { messageOf } from "./errors.ts";
-import { peerLabel, peerKey } from "./format.ts";
+import { messageOf } from "../errors.ts";
+import { peerLabel, peerKey } from "../text/format.ts";
 import { waitForLogin, type LoginOutcome } from "./login.ts";
-import { defaultSleep } from "./timer.ts";
-import { LoginScreenComponent, type LoginViewState } from "./login-screen.ts";
-import { qrLines } from "../../lib/qr.ts";
-import { statusLine, statusView, StatusScreenComponent, type StatusAction, type StatusView } from "./status-screen.ts";
-import type { BotCredentials } from "./types.ts";
+import { defaultSleep } from "../timer.ts";
+import { LoginScreenComponent, type LoginViewState } from "../view/login-screen.ts";
+import { qrLines } from "../../../lib/qr.ts";
+import {
+	statusLine,
+	statusView,
+	StatusScreenComponent,
+	type StatusAction,
+	type StatusView,
+} from "../view/status-screen.ts";
+import type { BotCredentials } from "../types.ts";
 
 export interface CommandDeps {
 	getBridge: () => Bridge | undefined;
@@ -152,9 +158,11 @@ function resetMessage(bridge: Bridge, peer: string): VerbOutcome {
 		: { message: `${label} is running; stop it before starting a new conversation.`, kind: "info" };
 }
 
-function cancelPromptMessage(bridge: Bridge): VerbOutcome {
-	if (!bridge.status().promptPending) return { message: "No prompt is waiting.", kind: "info" };
-	void bridge.channel().cancel();
+function cancelPromptMessage(bridge: Bridge, peer: string): VerbOutcome {
+	if (!bridge.status().prompts.some((prompt) => prompt.peer === peer)) {
+		return { message: "No prompt is waiting.", kind: "info" };
+	}
+	void bridge.channel(peer).cancel();
 	return { message: "Cancelled the waiting prompt.", kind: "info" };
 }
 
@@ -364,9 +372,9 @@ async function runPanel(ctx: ExtensionCommandContext, deps: CommandDeps): Promis
 						const bridge = deps.getBridge();
 						return bridge ? resetMessage(bridge, peer).message : "WeChat bridge is not running.";
 					},
-					cancelPrompt: () => {
+					cancelPrompt: (focused) => {
 						const bridge = deps.getBridge();
-						return bridge ? cancelPromptMessage(bridge).message : "No prompt is waiting.";
+						return bridge ? cancelPromptMessage(bridge, focused).message : "No prompt is waiting.";
 					},
 					togglePause: async () => {
 						const bridge = deps.getBridge();

package/extensions/wechat/{doctor.ts → commands/doctor.ts}

@@ -7,11 +7,11 @@
  * the wording and the age math are unit-tested without a bridge.
  */
 
-import { formatDuration } from "../../lib/format.ts";
-import type { BridgeStatus } from "./bridge.ts";
-import type { WechatConfig } from "./config.ts";
-import type { BotCredentials } from "./types.ts";
-import { peerLabel } from "./format.ts";
+import { formatDuration } from "../../../lib/format.ts";
+import type { BridgeStatus } from "../bridge.ts";
+import type { WechatConfig } from "../config.ts";
+import type { BotCredentials } from "../types.ts";
+import { peerLabel } from "../text/format.ts";
 
 export interface DoctorInput {
 	/** Undefined when the bridge has never been built in this runtime. */

package/extensions/wechat/{history.ts → commands/history.ts}

@@ -8,7 +8,7 @@
  */
 
 import { SessionManager, type SessionEntry, type SessionMessageEntry } from "@earendil-works/pi-coding-agent";
-import { peerSessionDir } from "./peer-session.ts";
+import { peerSessionDir } from "../peer/peer-session.ts";
 
 /** Longest text one history line carries before it is elided. */
 export const HISTORY_LINE_CHARS = 160;

package/extensions/wechat/{login.ts → commands/login.ts}

@@ -6,9 +6,9 @@
  * without a real timer, and the caller owns displaying the QR.
  */
 
-import { DEFAULT_BASE_URL, type WechatClient } from "./client.ts";
-import { messageOf } from "./errors.ts";
-import type { BotCredentials, QrResponse, QrStatus } from "./types.ts";
+import { DEFAULT_BASE_URL, type WechatClient } from "../transport/client.ts";
+import { messageOf } from "../errors.ts";
+import type { BotCredentials, QrResponse, QrStatus } from "../types.ts";
 
 /** Categorical meaning of a `get_qrcode_status` value. */
 export type StatusKind = "pending" | "confirmed" | "expired" | "verify" | "blocked" | "binded";

package/extensions/wechat/{slash.ts → commands/slash.ts}

@@ -10,8 +10,8 @@
  * Value-only: no module-level state.
  */
 
-import { type PeerLanguage } from "./format.ts";
-import { notice } from "./notices.ts";
+import { type PeerLanguage } from "../text/format.ts";
+import { notice } from "../text/notices.ts";
 
 /** The two command kinds. */
 export type SlashKind = "snippet" | "action";
@@ -37,6 +37,42 @@ export interface SlashSessionControls {
 	history?: (count: number) => Promise<string>;
 }
 
+/** What a builder needs to bind the session controls to one sender. */
+export interface SlashControlsDeps {
+	/** What that peer's conversation is doing. */
+	state: (peer: string) => SlashPeerState;
+	/** The title of a dialog waiting on that peer, if one waits. */
+	prompt: (peer: string) => string | undefined;
+	/** Drop the peer's conversation, so the next message starts empty. */
+	reset: (peer: string) => void;
+	/** Stop the peer's running turn; false when nothing was running. */
+	stop: (peer: string) => boolean;
+	/** The last `count` messages of the peer's own conversation. */
+	history: (peer: string, count: number) => Promise<string>;
+}
+
+/**
+ * The controls one action runs against, for the peer that typed the command.
+ *
+ * The registry owns what a command may do; the bridge owns the queue and the
+ * channels, so it supplies them here and keeps no per-peer session shape of its
+ * own.
+ */
+export function slashControls(peer: string, deps: SlashControlsDeps): SlashSessionControls {
+	return {
+		newSession: () => {
+			deps.reset(peer);
+		},
+		stop: () => deps.stop(peer),
+		status: () => {
+			const waiting = deps.prompt(peer);
+			const state = deps.state(peer);
+			return waiting === undefined ? state : { ...state, prompt: waiting };
+		},
+		history: (count) => deps.history(peer, count),
+	};
+}
+
 /** The environment an action handler runs in. */
 export interface SlashContext {
 	/** Text after the command name, trimmed. */

package/extensions/wechat/dialog/channels.ts

@@ -0,0 +1,136 @@
+/**
+ * One interaction channel per peer.
+ *
+ * Two peers' turns can run at once ({@link PEER_CONCURRENCY}), and a forwarded
+ * dialog is only unambiguous if the channel that asks knows which peer it is
+ * asking — so each peer owns a channel, and a reply can only answer its own
+ * peer's prompt. This registry builds them lazily, routes an inbound message to
+ * that peer's channel, and aggregates what waits so the control screen and
+ * `/wechat status` can name each waiting peer.
+ *
+ * It also owns the dialogs' outbound path — the flush of buffered text, the
+ * prompt gate, and the deliverer call — because that path is per peer and belongs
+ * with the channel that uses it rather than with the bridge that wires it.
+ *
+ * Value-only: the map lives in the closure.
+ */
+
+import type { PendingPromptInfo, WechatInteractionChannel } from "./interaction.ts";
+import { createWechatInteractionChannel } from "./interaction.ts";
+import type { PeerLanguage } from "../text/format.ts";
+import type { ArmTimer } from "../timer.ts";
+
+/** What the registry needs from the bridge; the turn's item carries the token. */
+export interface PeerChannelDeps {
+	/** Put buffered assistant text on the wire before a prompt or a file. */
+	flush: (peer: string) => Promise<void>;
+	/** Send one dialog message to a peer as that peer's next bubble. */
+	send: (peer: string, text: string, signal?: AbortSignal) => Promise<boolean>;
+	/** Send one local file to a peer. */
+	sendFile: (peer: string, path: string, name: string, signal?: AbortSignal) => Promise<boolean>;
+	/** Whether the peer owns a running turn, so a prompt has somewhere to land. */
+	active: (peer: string) => boolean;
+	/** The language the peer writes in, for the prompt and the timeout notices. */
+	language: (peer: string) => PeerLanguage;
+	/** Arm a cancellable one-shot timer. Defaults to a real, unref'd one. */
+	armTimer?: ArmTimer;
+	/** Clock for a prompt's start time; defaults to `Date.now`. */
+	now?: () => number;
+}
+
+export interface PeerChannels {
+	/** This peer's channel, created on first use. */
+	for(peer: string): WechatInteractionChannel;
+	/** Route an inbound message to the peer's pending prompt; true when it answered one. */
+	handleInbound(peer: string, text: string): boolean;
+	/** The prompt one peer is waiting on, if any. */
+	pendingFor(peer: string): PendingPromptInfo | undefined;
+	/** Every waiting prompt, oldest channel first. */
+	prompts(): PendingPromptInfo[];
+	/** Whether that peer — or with no argument, any peer — has a prompt waiting. */
+	hasPending(peer?: string): boolean;
+	/** Withdraw every waiting prompt, telling each peer. */
+	cancelAll(): Promise<void>;
+	/** Drop every channel and its waiting prompt, silently. */
+	reset(): void;
+}
+
+export function createPeerChannels(deps: PeerChannelDeps): PeerChannels {
+	const channels = new Map<string, WechatInteractionChannel>();
+
+	function build(peer: string): WechatInteractionChannel {
+		let channel: WechatInteractionChannel | undefined;
+		/**
+		 * Dialog text is only sent while its prompt is registered; the timeout,
+		 * waiting, and withdrawal lines force their way through. Reading the channel
+		 * this closure builds keeps one owner for "is a prompt waiting".
+		 */
+		const allowed = (options?: { force?: boolean }): boolean =>
+			options?.force === true || (channel?.hasPending() ?? false);
+
+		channel = createWechatInteractionChannel({
+			peer,
+			send: async (text, signal, options) => {
+				if (!allowed(options)) return false;
+				await deps.flush(peer);
+				return deps.send(peer, text, signal);
+			},
+			sendFile: async (path, name, signal, options) => {
+				if (!allowed(options)) return false;
+				await deps.flush(peer);
+				return deps.sendFile(peer, path, name, signal);
+			},
+			active: () => deps.active(peer),
+			language: () => deps.language(peer),
+			armTimer: deps.armTimer,
+			now: deps.now,
+		});
+		return channel;
+	}
+
+	return {
+		for(peer: string): WechatInteractionChannel {
+			const existing = channels.get(peer);
+			if (existing) return existing;
+			const created = build(peer);
+			channels.set(peer, created);
+			return created;
+		},
+
+		handleInbound(peer: string, text: string): boolean {
+			// Only a channel that exists can be waiting, so an inbound message never
+			// creates one for a peer that has not been asked anything.
+			return channels.get(peer)?.handleInbound(text) ?? false;
+		},
+
+		pendingFor(peer: string): PendingPromptInfo | undefined {
+			return channels.get(peer)?.pendingInfo();
+		},
+
+		prompts(): PendingPromptInfo[] {
+			const waiting: PendingPromptInfo[] = [];
+			for (const channel of channels.values()) {
+				const info = channel.pendingInfo();
+				if (info) waiting.push(info);
+			}
+			return waiting;
+		},
+
+		hasPending(peer?: string): boolean {
+			if (peer !== undefined) return channels.get(peer)?.hasPending() ?? false;
+			for (const channel of channels.values()) if (channel.hasPending()) return true;
+			return false;
+		},
+
+		async cancelAll(): Promise<void> {
+			for (const channel of channels.values()) {
+				if (channel.hasPending()) await channel.cancel();
+			}
+		},
+
+		reset(): void {
+			for (const channel of channels.values()) channel.reset();
+			channels.clear();
+		},
+	};
+}