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

package/extensions/wechat/bridge.ts

@@ -2,68 +2,44 @@
  * The WeChat bridge: one connection per account, one session per peer.
  *
  * This is the composition root. The poll loop, outbound delivery, the typing and
- * wait notices, admission (dedupe/cap/budget), and inbound media each live in
- * their own module; the bridge wires them to the live client, account, cursor,
- * and state, and owns the connection lifecycle and the status snapshot. Each
- * admitted message is handed to the sender's own session through the peer
- * worker, so a WeChat turn never runs in the terminal's session.
+ * wait notices, admission (dedupe/cap/budget), inbound media, and the inbound
+ * path itself each live in their own module; the bridge wires them to the live
+ * client, account, cursor, and state, and owns the connection lifecycle and the
+ * status snapshot. Each admitted message is handed to the sender's own session
+ * through the peer worker, so a WeChat turn never runs in the terminal's session.
  *
  * 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 { peerKey, sanitizeInbound, type PeerLanguage } from "./text/format.ts";
+import { notice } from "./text/notices.ts";
+import { createPresence } from "./peer/presence.ts";
+import { createForgetToken, createIntake, createLanguageOf, type Counter } from "./intake.ts";
+
+// The admission predicates, re-exported: they are the bridge's contract, and a caller
+// should not have to know which module inside it answers them.
+export { isAllowedPeer, isInboundMessage } from "./intake.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 {
-	expandSnippet,
-	findSlashCommand,
-	parseSlash,
-	SLASH_COMMANDS,
-	type SlashCommand,
-	type SlashContext,
-} from "./slash.ts";
-import type { BotCredentials, InboundItem, WechatState, WeixinMessage } from "./types.ts";
+import { createPeerWorker, type PeerState, type PeerWorker } from "./peer/peer-worker.ts";
+import type { PeerSession } from "./peer/peer-session.ts";
+import { emptyState, ownerTarget } from "./state/state.ts";
+import { SLASH_COMMANDS, type SlashCommand } from "./commands/slash.ts";
+import type { BotCredentials, WechatState } from "./types.ts";
 import type { WechatConfig } from "./config.ts";
 
-/** Inbound messages held while a turn runs; beyond this the peer is told to wait. */
-const MAX_QUEUE = 8;
-
-/**
- * Whether `peer` may drive the agent: the owner, or an explicit extra. Either id
- * form is accepted (with or without `@im.wechat`), so a label copied from the
- * control screen is not silently refused.
- */
-export function isAllowedPeer(peer: string, owner: string | undefined, allowedPeers: string[]): boolean {
-	const key = peerKey(peer);
-	if (owner !== undefined && peerKey(owner) === key) return true;
-	return allowedPeers.some((allowed) => peerKey(allowed) === key);
-}
-
-/** True when a message is inbound from a human (not the bot's own echo). */
-export function isInboundMessage(message: WeixinMessage): message is WeixinMessage & { from_user_id: string } {
-	return message.message_type !== 2 && typeof message.from_user_id === "string" && message.from_user_id !== "";
-}
-
 /** The bridge's connection state, published to the UI for the status chip. */
 export type BridgeState = "stopped" | "running" | "expired" | "paused";
 
@@ -120,10 +96,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 +136,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. */
@@ -183,7 +159,8 @@ export function createBridge(deps: BridgeDeps): Bridge {
 	let client: WechatClient | undefined;
 	let account: BotCredentials | undefined;
 	let state: WechatState = { cursor: "", peers: {} };
-	let refused = 0;
+	/** Senders refused since the connection opened; the inbound path bumps it. */
+	const refused: Counter = { value: 0 };
 	/** Labels of refused senders, so the operator can allowlist one by name. */
 	const refusedPeers = new Set<string>();
 	/** The language each peer last wrote in, so a media-only message can answer. */
@@ -191,6 +168,9 @@ export function createBridge(deps: BridgeDeps): Bridge {
 	/** Peers already told that the queue is full, until it drains. */
 	const overflow = new Set<string>();
 	const slashCommands = deps.slashCommands ?? SLASH_COMMANDS;
+	/** The peer's language memory: written here when a turn settles, read on every message. */
+	const languageOf = createLanguageOf(languages);
+	const forgetToken = createForgetToken({ state: () => state, saveState: deps.saveState });
 
 	/** One worker per open connection: it owns the queues and the peer sessions. */
 	let worker: PeerWorker | undefined;
@@ -216,17 +196,9 @@ export function createBridge(deps: BridgeDeps): Bridge {
 		notify("WeChat session expired. Run /wechat login to reconnect.", "warning");
 	}
 
-	/** Drop a peer's cached reply token, so the next inbound message replaces it. */
-	function forgetToken(peer: string): void {
-		const entry = findPeer(state, peer);
-		if (!entry?.lastContextToken) return;
-		delete entry.lastContextToken;
-		deps.saveState(state);
-	}
-
 	/** 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. */
@@ -246,81 +218,31 @@ export function createBridge(deps: BridgeDeps): Bridge {
 			lastSendError = undefined;
 		},
 	});
-	/** Run a slash action out-of-band and reply to the sender; never starts a turn. */
-	async function runSlashAction(command: SlashCommand, target: MessageTarget, args: string): Promise<void> {
-		if (!command.run) return;
-		const ctx: SlashContext = {
-			args,
-			peer: target.peer,
-			reply: async (text) => {
-				await reply(target, text);
-			},
-			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;
-				},
-				history: (count) => deps.readHistory(target.peer, count),
-			},
-		};
-		try {
-			await command.run(ctx);
-		} catch (error) {
-			notify(`WeChat command /${command.name} failed: ${messageOf(error)}`, "warning");
-			await reply(target, `Command /${command.name} failed.`);
-		}
-	}
-
 	/**
-	 * 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,
 	});
 
-	/** The peer's language: from this text, else the last one they wrote. */
-	function languageOf(peer: string, text?: string): PeerLanguage {
-		// A Chinese message is evidence of Chinese. Its absence is not evidence of
-		// English, or a short reply ("ok", "1") would flip an established conversation
-		// back to English; English is the fallback, so it needs no record of its own.
-		if (text && peerLanguage(text) === "zh") languages.set(peer, "zh");
-		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 +251,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. */
@@ -353,92 +275,27 @@ export function createBridge(deps: BridgeDeps): Bridge {
 	const budget = createTurnBudget(deps.config.maxTurnsPerHour, deps.now);
 	const admission = createAdmissionQueue({ admit: inbound.admit, notify });
 
-	function handleMessage(message: WeixinMessage): void {
-		if (!isInboundMessage(message)) return;
-		const peer = message.from_user_id;
-		const { text: rawText, media, unsupported } = parseInbound(message.item_list);
-		const owner = state.ownerId ?? account?.ilinkUserId;
-		// Admission comes first: a refused sender never reaches the state file, a
-		// pending prompt, or the queue.
-		if (!isAllowedPeer(peer, owner, deps.config.allowedPeers)) {
-			refused += 1;
-			const label = peerLabel(peer);
-			// Name a new sender once, so the operator can allowlist it from the
-			// terminal; the cap keeps a spam run from filling the list.
-			if (refusedPeers.size < 5 && !refusedPeers.has(label)) {
-				refusedPeers.add(label);
-				notify(`WeChat refused a message from ${label}. Add it to allowedPeers to admit.`, "warning");
-			}
-			return;
-		}
-		// A server replay of an already handled message must not answer twice. The
-		// id is persisted, so a reload or reconnect cannot resurrect it.
-		const messageId = message.message_id;
-		if (typeof messageId === "number" && messageId !== 0 && seenMessage(state, peer, messageId)) return;
-
-		let text = rawText;
-		const cap = deps.config.maxInboundChars;
-		if (text.length > cap) {
-			const total = text.length;
-			text = `${text.slice(0, cap)}\n[WeChat message truncated: showing ${cap} of ${total} characters]`;
-			notify(`WeChat message truncated to ${cap} characters.`, "warning");
-		}
-
-		const now = deps.now();
-		recordInbound(state, peer, message.context_token, now);
-		if (typeof messageId === "number" && messageId !== 0) rememberMessage(state, peer, messageId, now);
-		deps.saveState(state);
-
-		const target = { peer, contextToken: message.context_token ?? findPeer(state, peer)?.lastContextToken };
-		// A command is not an answer: while a dialog waits the model is blocked on it,
-		// so /stop and /status must reach their handlers or the peer's only way out is
-		// the prompt timing out. A message with media is never a command, and an
-		// unknown command falls through to the model as ordinary text.
-		const slash = media.length === 0 ? parseSlash(text) : undefined;
-		const command = slash ? findSlashCommand(slashCommands, slash.name) : undefined;
-		if (command && slash) {
-			if (command.ownerOnly && peerKey(peer) !== peerKey(owner ?? "")) {
-				refused += 1;
-				return;
-			}
-			if (command.kind === "snippet") {
-				text = expandSnippet(command, slash.args);
-			} else {
-				void runSlashAction(command, target, slash.args);
-				return;
-			}
-		}
-		// 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;
-		const language = languageOf(peer, text);
-		const item: InboundItem = { ...target, text, media, language };
-		if (!text && media.length === 0) {
-			// Nothing to read. A voice note without a transcript or a video is
-			// answered, so the peer knows it did not reach the agent.
-			if (unsupported > 0) void reply(item, notice("unsupported", language));
-			return;
-		}
-		// A slot is reserved here, before the download, so a burst of media cannot
-		// all pass the check and then enqueue together.
-		if (!budget.allow(peer)) {
-			void reply(item, notice("budget", language));
-			return;
-		}
-		const busy = (worker?.state(peer).queued ?? 0) + admission.pending(peer);
-		if (busy >= MAX_QUEUE) {
-			// Refuse rather than grow without bound; one notice per episode, not per
-			// dropped message.
-			if (!overflow.has(peer)) {
-				overflow.add(peer);
-				void reply(item, notice("overflow", language));
-			}
-			return;
-		}
-		presence.keepTyping(peer, item.contextToken);
-		presence.armAck(item);
-		admission.enqueue(item);
-	}
+	/** The inbound path: admission, commands, and the hand-off to a peer's session. */
+	const intake = createIntake({
+		state: () => state,
+		saveState: deps.saveState,
+		account: () => account,
+		config: deps.config,
+		now: deps.now,
+		notify,
+		worker: () => worker,
+		channels,
+		presence,
+		budget,
+		admission,
+		languageOf,
+		reply: (target, text) => reply(target, text),
+		readHistory: deps.readHistory,
+		refused,
+		refusedPeers,
+		overflow,
+		slashCommands,
+	});
 
 	/** The long-poll loop; it reads the live client, cursor, and state. */
 	const poll = createPollLoop({
@@ -454,7 +311,7 @@ export function createBridge(deps: BridgeDeps): Bridge {
 		notify,
 		onExpired: handleExpired,
 		onMessages: (messages) => {
-			for (const message of messages) handleMessage(message);
+			for (const message of messages) intake.handleMessage(message);
 		},
 		refreshLock: deps.refreshLock,
 		isRunning: () => running,
@@ -475,9 +332,9 @@ export function createBridge(deps: BridgeDeps): Bridge {
 	function resetEphemeral(): void {
 		languages.clear();
 		overflow.clear();
-		refused = 0;
+		refused.value = 0;
 		refusedPeers.clear();
-		interaction.reset();
+		channels.reset();
 		deliverer.reset();
 		presence.reset();
 		budget.reset();
@@ -552,10 +409,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 +459,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 +475,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;
@@ -679,11 +536,11 @@ export function createBridge(deps: BridgeDeps): Bridge {
 				peerCount: Object.keys(state.peers).length,
 				queued: states.reduce((total, entry) => total + entry.state.queued, 0),
 				running: states.some((entry) => entry.state.status === "running"),
-				refused,
+				refused: refused.value,
 				refusedPeers: [...refusedPeers],
 				mediaDropped: inbound.dropped(),
-				promptPending: interaction.hasPending(),
-				prompt: interaction.pendingInfo(),
+				promptPending: channels.hasPending(),
+				prompts: channels.prompts(),
 				startedAt,
 				lastPollAt,
 				lastPollError,
@@ -694,27 +551,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";