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

package/extensions/wechat/deliver.ts

@@ -59,7 +59,7 @@ export interface DeliveryDeps {
 export interface Deliverer {
 	/** Send a reply to a peer; false when the transport rejected it. */
 	reply(target: MessageTarget, text: string, signal?: AbortSignal): Promise<boolean>;
-	/** Send a dialog preface (or plan digest) to a peer. */
+	/** Send a prompt to a peer. */
 	prompt(target: MessageTarget, text: string, signal?: AbortSignal): Promise<boolean>;
 	/** Upload and send a local file to a peer. */
 	file(target: MessageTarget, filePath: string, fileName: string, signal?: AbortSignal): Promise<boolean>;
@@ -72,6 +72,22 @@ export interface Deliverer {
 export function createDeliverer(deps: DeliveryDeps): Deliverer {
 	/** Peers already reported as unable to receive, until a send gets through. */
 	const failureNotified = new Set<string>();
+	/** Per-peer FIFO: a reply, prompt, or file cannot start before the previous one. */
+	const queues = new Map<string, Promise<void>>();
+
+	function serialize<T>(peer: string, work: () => Promise<T>): Promise<T> {
+		const previous = queues.get(peer) ?? Promise.resolve();
+		const run = previous.then(work, work);
+		const settled = run.then(
+			() => undefined,
+			() => undefined,
+		);
+		queues.set(peer, settled);
+		void settled.finally(() => {
+			if (queues.get(peer) === settled) queues.delete(peer);
+		});
+		return run;
+	}
 
 	/**
 	 * Send `text` in `maxReplyChars` chunks, stopping at the first failed chunk.
@@ -149,51 +165,55 @@ export function createDeliverer(deps: DeliveryDeps): Deliverer {
 
 	return {
 		reply(target, text, signal) {
-			return deliverWithNotice(target, text, "reply", signal);
+			return serialize(target.peer, () => deliverWithNotice(target, text, "reply", signal));
 		},
 
 		prompt(target, text, signal) {
-			return deliverWithNotice(target, text, "message delivery", signal);
+			return serialize(target.peer, () => deliverWithNotice(target, text, "message delivery", signal));
 		},
 
-		async file(target, filePath, fileName, signal) {
-			const client = deps.client();
-			const account = deps.account();
-			if (!client || !account) return false;
-			const sent = await sendLocalFile({
-				client,
-				account,
-				cdnBaseUrl: deps.cdnBaseUrl,
-				maxBytes: deps.maxMediaBytes,
-				to: target.peer,
-				contextToken: target.contextToken,
-				filePath,
-				fileName,
-				signal,
+		file(target, filePath, fileName, signal) {
+			return serialize(target.peer, async () => {
+				const client = deps.client();
+				const account = deps.account();
+				if (!client || !account) return false;
+				const sent = await sendLocalFile({
+					client,
+					account,
+					cdnBaseUrl: deps.cdnBaseUrl,
+					maxBytes: deps.maxMediaBytes,
+					to: target.peer,
+					contextToken: target.contextToken,
+					filePath,
+					fileName,
+					signal,
+				});
+				// `sendLocalFile` reports only success, and the caller may fall back to text;
+				// without this line the operator would never know the attachment was dropped.
+				if (!sent && !signal?.aborted) {
+					deps.onSendError?.(`file delivery failed: ${fileName}`);
+					deps.notify(`WeChat file delivery failed for ${fileName}.`, "warning");
+				}
+				if (sent) deps.onSent?.();
+				return sent;
 			});
-			// `sendLocalFile` reports only success, and the caller may fall back to text;
-			// without this line the operator would never know the attachment was dropped.
-			if (!sent && !signal?.aborted) {
-				deps.onSendError?.(`file delivery failed: ${fileName}`);
-				deps.notify(`WeChat file delivery failed for ${fileName}.`, "warning");
-			}
-			if (sent) deps.onSent?.();
-			return sent;
 		},
 
-		async toOwner(owner, contextToken, text, signal) {
-			let failure: string | undefined;
-			const delivery = await deliverText(owner, contextToken, text, signal, (error, progress) => {
-				deps.forgetToken(owner);
-				const partial = progress.total > 1 ? ` after ${progress.sent} of ${progress.total} parts were sent` : "";
-				deps.onSendError?.(messageOf(error));
-				failure = `${messageOf(error)}${partial}`;
+		toOwner(owner, contextToken, text, signal) {
+			return serialize(owner, async () => {
+				let failure: string | undefined;
+				const delivery = await deliverText(owner, contextToken, text, signal, (error, progress) => {
+					deps.forgetToken(owner);
+					const partial = progress.total > 1 ? ` after ${progress.sent} of ${progress.total} parts were sent` : "";
+					deps.onSendError?.(messageOf(error));
+					failure = `${messageOf(error)}${partial}`;
+				});
+				if (delivery.expired) return { ok: false, error: "WeChat session expired." };
+				if (delivery.empty) return { ok: false, error: "Nothing to send after formatting." };
+				if (!delivery.ok) return { ok: false, error: failure ?? "WeChat send failed." };
+				deps.onSent?.();
+				return { ok: true };
 			});
-			if (delivery.expired) return { ok: false, error: "WeChat session expired." };
-			if (delivery.empty) return { ok: false, error: "Nothing to send after formatting." };
-			if (!delivery.ok) return { ok: false, error: failure ?? "WeChat send failed." };
-			deps.onSent?.();
-			return { ok: true };
 		},
 
 		reset() {

package/extensions/wechat/interaction.ts

@@ -28,10 +28,10 @@ import { defaultTimer, type ArmTimer } from "./timer.ts";
 export const PROMPT_TIMEOUT_MS = 180_000;
 
 export interface WechatInteractionDeps {
-	/** Send one text message to the owning peer; resolves false when it fails. */
-	send: (text: string, signal?: AbortSignal) => Promise<boolean>;
-	/** Send a local file to the owning peer; resolves false when it fails. */
-	sendFile: (path: string, name: string, signal?: AbortSignal) => Promise<boolean>;
+	/** Send one text message to the owning peer; `force` bypasses the prompt-active gate. */
+	send: (text: string, signal?: AbortSignal, options?: { force?: boolean }) => Promise<boolean>;
+	/** Send a local file to the owning peer; `force` bypasses the prompt-active gate. */
+	sendFile: (path: string, name: string, signal?: AbortSignal, options?: { force?: boolean }) => Promise<boolean>;
 	/** The peer that owns the in-flight turn, or undefined when there is none. */
 	activePeer: () => string | undefined;
 	/** The language the owning peer writes in, for the timeout notices. */
@@ -43,6 +43,11 @@ export interface WechatInteractionDeps {
 }
 
 export interface WechatInteractionChannel extends InteractionChannel {
+	/**
+	 * Widen the bound for the prompts asked inside the scope, and restore the
+	 * previous one when it ends: the optional channel member, made concrete here.
+	 */
+	setPromptTimeout(ms: number): () => void;
 	/** Consume an inbound message as a reply; true when it was one. */
 	handleInbound(peer: string, text: string): boolean;
 	/** Whether a prompt is currently waiting for a reply. */
@@ -50,7 +55,9 @@ export interface WechatInteractionChannel extends InteractionChannel {
 	/** The waiting prompt, for the control screen; undefined when none waits. */
 	pendingInfo(): PendingPromptInfo | undefined;
 	/** Withdraw the waiting prompt: tell the peer and resolve it cancelled. */
-	cancel(): void;
+	cancel(): Promise<void>;
+	/** The language prompts are rendered in. */
+	language(): PeerLanguage;
 	/** Drop any pending prompt (turn settled or the bridge stopped). */
 	reset(): void;
 }
@@ -79,6 +86,11 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 	const arm = deps.armTimer ?? defaultTimer;
 	const now = deps.now ?? Date.now;
 	let pending: Pending | undefined;
+	/**
+	 * The bound for the prompts asked inside the current `setPromptTimeout` scope,
+	 * set by a caller whose dialog needs reading time before it can be answered.
+	 */
+	let scopedTimeoutMs: number | undefined;
 	/**
 	 * Free text captured from a `select` "Other" reply, per peer: the immediately
 	 * following `input` for that peer returns it. Keyed so one peer's free text can
@@ -101,6 +113,10 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 			return deps.activePeer() !== undefined;
 		},
 
+		language(): PeerLanguage {
+			return deps.language();
+		},
+
 		hasPending(): boolean {
 			return pending !== undefined;
 		},
@@ -117,20 +133,34 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 					};
 		},
 
-		cancel(): void {
-			if (!pending) return;
-			// The peer saw the prompt; one line says it was withdrawn. `reset` is the
-			// silent cleanup path and deliberately does not send this.
-			void deps.send(notice("timeout", deps.language()));
-			settle({ kind: "cancelled" });
+		async cancel(): Promise<void> {
+			const current = pending;
+			if (!current) return;
+			// The peer saw the prompt; one line says it was withdrawn, which is not the
+			// same as expiry — they were not slow, the question went away. `reset` is the
+			// silent cleanup path and deliberately does not send this. Settle after the
+			// notice is on the wire, so a caller awaiting the answer knows it was sent.
+			try {
+				await deps.send(notice("withdrawn", deps.language()), undefined, { force: true });
+			} finally {
+				if (pending === current) settle({ kind: "cancelled" });
+			}
 		},
 
 		async post(text: string, signal?: AbortSignal): Promise<void> {
-			await deps.send(text, signal);
+			await deps.send(text, signal, { force: true });
 		},
 
 		async postFile(path: string, name: string, signal?: AbortSignal): Promise<boolean> {
-			return deps.sendFile(path, name, signal);
+			return deps.sendFile(path, name, signal, { force: true });
+		},
+
+		setPromptTimeout(ms: number): () => void {
+			const previous = scopedTimeoutMs;
+			scopedTimeoutMs = ms;
+			return () => {
+				scopedTimeoutMs = previous;
+			};
 		},
 
 		async request(request: InteractionRequest, signal?: AbortSignal): Promise<InteractionAnswer> {
@@ -158,15 +188,18 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 				signal?.addEventListener("abort", onAbort, { once: true });
 				// An ignored question must not freeze the session: nudge once, then
 				// cancel so the model gets a clean answer instead of a hang.
-				cancelTimers.push(arm(PROMPT_TIMEOUT_MS / 2, () => void deps.send(notice("promptWaiting", deps.language()))));
+				const bound = scopedTimeoutMs ?? PROMPT_TIMEOUT_MS;
+				cancelTimers.push(
+					arm(bound / 2, () => void deps.send(notice("promptWaiting", deps.language()), undefined, { force: true })),
+				);
 				cancelTimers.push(
-					arm(PROMPT_TIMEOUT_MS, () => {
-						void deps.send(notice("timeout", deps.language()));
+					arm(bound, () => {
+						void deps.send(notice("timeout", deps.language()), undefined, { force: true });
 						settle({ kind: "cancelled" });
 					}),
 				);
 			});
-			const sent = await deps.send(formatPrompt(request), signal);
+			const sent = await deps.send(formatPrompt(request, { language: deps.language() }), signal);
 			if (!sent) settle({ kind: "cancelled" });
 			return await answer;
 		},
@@ -177,7 +210,9 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 			const parsed = parsePromptAnswer(current.request, text);
 			switch (parsed.kind) {
 				case "retry":
-					void deps.send(formatPrompt(current.request, { retry: true }));
+					void deps.send(formatPrompt(current.request, { retry: true, language: deps.language() }), undefined, {
+						force: true,
+					});
 					return true;
 				case "other":
 					other.set(peer, parsed.text);
@@ -197,6 +232,7 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 
 		reset(): void {
 			other.clear();
+			scopedTimeoutMs = undefined;
 			settle({ kind: "cancelled" });
 		},
 	};

package/extensions/wechat/login-screen.ts

@@ -8,7 +8,7 @@
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { type Component, visibleWidth } from "@earendil-works/pi-tui";
-import { screenHint } from "../../lib/tui/chrome.ts";
+import { screenFooter, screenHint } from "../../lib/tui/chrome.ts";
 import { clip } from "../../lib/tui/columns.ts";
 import { isCloseKey } from "../../lib/tui/cursor.ts";
 import { titleRule } from "../../lib/tui/rules.ts";
@@ -87,8 +87,7 @@ export class LoginScreenComponent implements Component {
 			titleRule(theme, target, "wechat · login"),
 			"",
 			...loginBody(this.options.state(), target),
-			"",
-			screenHint(theme, target, ["Esc cancel"]),
+			...screenFooter(theme, target, screenHint(theme, target, ["Esc cancel"])),
 		];
 	}
 }

package/extensions/wechat/notices.ts

@@ -22,18 +22,19 @@ export type NoticeKind =
 	| "budget"
 	| "promptWaiting"
 	| "timeout"
+	| "withdrawn"
 	| "failed"
 	| "newBusy";
 
 const NOTICES: Record<NoticeKind, Record<PeerLanguage, string>> = {
-	ack: { zh: "收到，正在处理…", en: "Got it — working on it." },
+	ack: { zh: "收到，排队中，轮到就回。", en: "Queued — I'll answer next." },
 	busy: {
-		zh: "前面还有一条正在处理，你的消息排在后面，轮到你就回你。",
-		en: "Your message is queued behind another conversation; I'll answer as soon as it's free.",
+		zh: "还在处理前一条，轮到就回。",
+		en: "Still on the previous message; yours is next.",
 	},
 	stillWorking: {
-		zh: "还在处理这条，稍等一下…",
-		en: "Still working on this one — a moment…",
+		zh: "还在处理，/stop 可取消。",
+		en: "Still working — /stop cancels.",
 	},
 	overflow: { zh: "消息有点多，稍后再发。", en: "Too many messages queued — please wait a moment." },
 	media: {
@@ -58,10 +59,11 @@ const NOTICES: Record<NoticeKind, Record<PeerLanguage, string>> = {
 		en: "You've reached this hour's message limit — please try again later.",
 	},
 	promptWaiting: {
-		zh: "还在等你的回复，约 1 分钟后超时。",
-		en: "Still waiting for your reply — this expires in about a minute.",
+		zh: "等你回复；回复「取消」跳过。",
+		en: "Waiting for your reply — reply cancel to skip.",
 	},
 	timeout: { zh: "问题超时，已取消。", en: "That question timed out." },
+	withdrawn: { zh: "问题已撤回。", en: "That question was withdrawn." },
 	failed: { zh: "处理失败，请稍后重试。", en: "Something went wrong — please try again." },
 	newBusy: {
 		zh: "正在处理当前消息，稍后再发送 /new。",

package/extensions/wechat/peer-worker.ts

@@ -12,8 +12,8 @@
  *
  * - One turn at a time per peer, and by default one turn at a time overall
  *   (`concurrency`), so a forwarded dialog always has a single owning peer.
- * - A message that arrives while its peer is already waiting behind a turn is
- *   merged into the waiting one, so a burst is answered once, in order.
+ * - Every message is its own turn, in arrival order. A message that arrives
+ *   while a turn runs waits for its own turn and answer; nothing is merged.
  * - A turn's answer is the text it produced. A requested `/stop` says `stopped`
  *   and drops the partial answer, a finished turn with no text says `noText`,
  *   and a thrown turn says `failed` — never silence.
@@ -26,7 +26,7 @@
 import type { ImageContent } from "@earendil-works/pi-ai";
 import { messageOf } from "./errors.ts";
 import type { PeerSession } from "./peer-session.ts";
-import { createReplyPipeline } from "./reply-pipeline.ts";
+import { createReplyPipeline, type ReplyPipeline } from "./reply-pipeline.ts";
 import { defaultTimer, type ArmTimer } from "./timer.ts";
 
 /** One admitted, media-resolved inbound message. */
@@ -97,6 +97,8 @@ export interface PeerWorker {
 	reset(peer: string): boolean;
 	/** The turn running right now, if any (one with the default concurrency). */
 	current(): PeerItem | undefined;
+	/** Flush buffered assistant text for a running peer before a prompt/file. */
+	flush(peer: string): Promise<void>;
 	state(peer: string): PeerState;
 	snapshot(): PeerSnapshot[];
 	/** Drop every session; queued messages are dropped with them. */
@@ -107,8 +109,6 @@ const DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 
 interface PeerEntry {
 	queue: PeerItem[];
-	/** Messages merged into the waiting item, so `queued` counts real messages. */
-	merged: number;
 	running?: PeerItem;
 	/** Monotonic start time of the running turn, for `runningMs`. */
 	startedAt?: number;
@@ -119,26 +119,14 @@ interface PeerEntry {
 	disposeTimer?: () => void;
 }
 
-/** Merge a waiting item with a newer one from the same peer. */
-function mergeItems(first: PeerItem, next: PeerItem): PeerItem {
-	const images = [...(first.images ?? []), ...(next.images ?? [])];
-	return {
-		peer: first.peer,
-		text: first.text && next.text ? `${first.text}\n${next.text}` : first.text || next.text,
-		images: images.length > 0 ? images : undefined,
-		// The first item's prefix still describes an attachment the model never saw.
-		prefix: first.prefix,
-		language: next.language,
-		contextToken: next.contextToken ?? first.contextToken,
-	};
-}
-
 export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 	const now = deps.now ?? Date.now;
 	const armTimer = deps.armTimer ?? defaultTimer;
 	const idleTimeoutMs = deps.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
 	const concurrency = Math.max(1, deps.concurrency ?? 1);
 	const peers = new Map<string, PeerEntry>();
+	/** Active reply pipelines, so a dialog can flush buffered text first. */
+	const pipelines = new Map<string, ReplyPipeline>();
 	/** Peers whose running turn the peer asked to stop, so it reads as stopped. */
 	const aborted = new Set<string>();
 	/** Peers whose next session must start empty (`/new`). */
@@ -150,7 +138,7 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 	function entry(peer: string): PeerEntry {
 		const existing = peers.get(peer);
 		if (existing) return existing;
-		const created: PeerEntry = { queue: [], merged: 0 };
+		const created: PeerEntry = { queue: [] };
 		peers.set(peer, created);
 		return created;
 	}
@@ -168,12 +156,12 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 		if (target.running) {
 			return {
 				status: "running",
-				queued: target.queue.length + target.merged,
+				queued: target.queue.length,
 				runningMs: target.startedAt === undefined ? 0 : now() - target.startedAt,
 				...sessionAge,
 			};
 		}
-		const queued = target.queue.length + target.merged;
+		const queued = target.queue.length;
 		return { status: queued > 0 ? "queued" : "idle", queued, ...sessionAge };
 	}
 
@@ -251,6 +239,7 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 			partChars: deps.partChars,
 			quietMs: deps.quietMs,
 		});
+		pipelines.set(item.peer, pipeline);
 		/** The session compacted this turn, so the peer is told its older detail is fuzzy. */
 		let compacted = false;
 		const unsubscribe = session.subscribe((event) => {
@@ -289,6 +278,7 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 			}
 		} finally {
 			unsubscribe();
+			pipelines.delete(item.peer);
 		}
 		if (reason) await sendPart(deps.fallback(item, reason));
 		if (compacted) await sendPart(deps.fallback(item, "compacted"));
@@ -309,7 +299,6 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 			if (!next) return;
 			const [peer, target] = next;
 			const item = target.queue.shift() as PeerItem;
-			target.merged = 0;
 			target.running = item;
 			target.startedAt = now();
 			running += 1;
@@ -340,16 +329,8 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 		enqueue(item: PeerItem): void {
 			if (closed) return;
 			const target = entry(item.peer);
-			const tail = target.queue.at(-1);
-			// A non-empty queue means this peer's turn has not started yet, so the
-			// burst is answered once, in send order. The merged count keeps `queued`
-			// honest so the bridge can cap a flood and the panel can report it.
-			if (tail) {
-				target.queue[target.queue.length - 1] = mergeItems(tail, item);
-				target.merged += 1;
-			} else {
-				target.queue.push(item);
-			}
+			// One message, one turn: a queued item is never folded into another.
+			target.queue.push(item);
 			wake();
 		},
 
@@ -368,7 +349,6 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 			releaseSession(peer);
 			if (target) {
 				target.queue = [];
-				target.merged = 0;
 				cancelIdleSweep(target);
 			}
 			return true;
@@ -378,6 +358,10 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 			return currentItem;
 		},
 
+		async flush(peer: string): Promise<void> {
+			await pipelines.get(peer)?.flush();
+		},
+
 		state(peer: string): PeerState {
 			return stateOf(peer);
 		},
@@ -388,6 +372,7 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 
 		async close(): Promise<void> {
 			closed = true;
+			pipelines.clear();
 			const runningAborts = [...peers.values()]
 				.filter((target) => target.session)
 				.map((target) => target.session?.session.abort());

package/extensions/wechat/presence.ts

@@ -204,14 +204,13 @@ export function createPresence(deps: PresenceDeps): Presence {
 	 * the same thing without spending a bubble.
 	 */
 	function armAck(target: PresenceTarget): void {
-		// A turn for this peer is already running: its own progress notice covers
-		// this message, so a second acknowledgement would be noise.
-		if (isRunning(target.peer)) return;
+		// A message can be queued behind a running turn; it still gets one
+		// acknowledgement after the delay, but not one per message.
 		if (acks.has(target.peer)) return;
 		const last = ackedAt.get(target.peer);
 		if (last !== undefined && deps.now() - last < ACK_REPEAT_MS) return;
 		acks.arm(target.peer, ACK_DELAY_MS, () => {
-			if (!hasWork(target.peer) || isRunning(target.peer)) return;
+			if (!hasWork(target.peer)) return;
 			ackedAt.set(target.peer, deps.now());
 			void deps.send(target.peer, target.contextToken, notice("ack", deps.languageOf(target.peer)));
 			// Still waiting after a minute behind another turn: say why.

package/extensions/wechat/prompt.ts

@@ -2,15 +2,15 @@
  * Pure rendering and parsing of remote dialog prompts (no I/O).
  *
  * A prompt is rendered to a WeChat message by {@link formatPrompt}; the reply is
- * interpreted by {@link parsePromptAnswer}. Hints are bilingual (Chinese and
- * English) so either reader can answer, and {@link formatPrompt} can prepend a
- * short notice when a reply was not understood. The parser is deliberately total:
+ * interpreted by {@link parsePromptAnswer}. Hints are rendered in the peer's
+ * language, and {@link formatPrompt} can prepend a short notice when a reply was
+ * not understood. The parser is deliberately total:
  * anything it cannot resolve reports `retry`, and free text on a `select` becomes
  * the {@link INTERACTION_OTHER_LABEL} option so the caller can collect it once.
  */
 
 import { INTERACTION_OTHER_LABEL, type InteractionRequest } from "../../lib/interaction.ts";
-import { sanitizeInbound } from "./format.ts";
+import { sanitizeInbound, type PeerLanguage } from "./format.ts";
 
 /** A parsed reply: a resolved answer, the "other" choice, or a retry. */
 export type PromptParse =
@@ -20,19 +20,32 @@ export type PromptParse =
 	| { kind: "cancelled" }
 	| { kind: "retry" };
 
-const SELECT_HINT =
-	"回复编号或选项文字；其它内容作为自定义回答；回复「取消」或 cancel 跳过。\n" +
-	"Reply with a number or the option text; anything else becomes your own answer; reply cancel to dismiss.";
-const CONFIRM_HINT = "回复「是」或「否」。\nReply yes or no.";
-const INPUT_HINT = "直接回复内容；回复「取消」或 cancel 跳过。\nReply with the text; reply cancel to skip.";
-const EDITOR_HINT =
-	"把内容作为一条消息发回；回复「取消」或 cancel 取消。\nSend the text as one message; reply cancel to cancel.";
+const SELECT_OTHER_HINT: Record<PeerLanguage, string> = {
+	zh: "回复编号或选项文字；其它内容作为自定义回答；回复「取消」跳过。",
+	en: "Reply with a number or the option text; anything else is your own answer; reply cancel to dismiss.",
+};
+const SELECT_CHOICE_HINT: Record<PeerLanguage, string> = {
+	zh: "回复编号或选项文字；回复「取消」跳过。",
+	en: "Reply with a number or the option text; reply cancel to dismiss.",
+};
+const CONFIRM_HINT: Record<PeerLanguage, string> = {
+	zh: "回复「是」或「否」。",
+	en: "Reply yes or no.",
+};
+const INPUT_HINT: Record<PeerLanguage, string> = {
+	zh: "直接回复内容；回复「取消」跳过。",
+	en: "Reply with the text; reply cancel to skip.",
+};
+const EDITOR_HINT: Record<PeerLanguage, string> = {
+	zh: "把内容作为一条消息发回；回复「取消」取消。",
+	en: "Send the text as one message; reply cancel to cancel.",
+};
 
 /** Sent ahead of a re-prompt when a reply could not be interpreted. */
-export const RETRY_NOTICE =
-	"没有识别到有效回复，请重新回答。\nSorry, I didn't recognize that reply — please answer again.";
+export const RETRY_NOTICE = "Sorry, I didn't recognize that reply — please answer again.";
+const RETRY_ZH = "没有识别到有效回复，请重新回答。";
 
-const CANCEL_WORDS = new Set(["取消", "cancel", "quit", "exit"]);
+const CANCEL_WORDS = new Set(["取消", "退出", "cancel", "quit", "exit"]);
 const YES_WORDS = new Set(["是", "y", "yes", "1", "确认", "确定", "行", "ok", "好", "对"]);
 const NO_WORDS = new Set(["否", "n", "no", "0", "不", "不是", "不行"]);
 
@@ -41,32 +54,49 @@ function lines(parts: Array<string | undefined>): string {
 }
 
 /** Render a dialog prompt as a WeChat message body, optionally after a retry. */
-export function formatPrompt(request: InteractionRequest, options: { retry?: boolean } = {}): string {
-	const body = promptBody(request);
-	return options.retry ? `${RETRY_NOTICE}\n\n${body}` : body;
+export function formatPrompt(
+	request: InteractionRequest,
+	options: { retry?: boolean; language?: PeerLanguage } = {},
+): string {
+	const language = options.language ?? "en";
+	const body = promptBody(request, language);
+	const retry = language === "zh" ? RETRY_ZH : RETRY_NOTICE;
+	return options.retry ? `${retry}\n\n${body}` : body;
 }
 
-function promptBody(request: InteractionRequest): string {
+function promptBody(request: InteractionRequest, language: PeerLanguage): string {
 	switch (request.kind) {
 		case "select": {
 			const options = (request.options ?? []).map((label, index) => `${index + 1}. ${label}`);
-			return lines([request.title, ...options, SELECT_HINT]);
+			const hasOther = (request.options ?? []).includes(INTERACTION_OTHER_LABEL);
+			return lines([request.title, ...options, hasOther ? SELECT_OTHER_HINT[language] : SELECT_CHOICE_HINT[language]]);
 		}
 		case "confirm":
-			return lines([request.title, request.message, CONFIRM_HINT]);
+			return lines([request.title, request.message, CONFIRM_HINT[language]]);
 		case "input":
-			return lines([request.title, request.placeholder, INPUT_HINT]);
+			return lines([request.title, request.placeholder, INPUT_HINT[language]]);
 		case "editor":
-			return lines([request.title, request.prefill, EDITOR_HINT]);
+			return lines([request.title, request.prefill, EDITOR_HINT[language]]);
 	}
 }
 
+/**
+ * Cancel intent, including the phrases a phone user naturally types.
+ * Exact words keep the old meaning; the two patterns cover “退出 plan 模式” and
+ * “exit plan mode” without treating a sentence such as “exit code” as a cancel.
+ */
+function isCancelIntent(text: string, lower: string): boolean {
+	if (CANCEL_WORDS.has(lower)) return true;
+	if (/^(退出|离开)\s*(计划|plan)/i.test(text)) return true;
+	return /^(exit|leave)\s+(the\s+)?plan\b/i.test(text);
+}
+
 /** Interpret a WeChat reply to `request`. */
 export function parsePromptAnswer(request: InteractionRequest, raw: string): PromptParse {
 	const text = sanitizeInbound(raw);
 	const lower = text.toLowerCase();
 
-	if (lower !== "" && CANCEL_WORDS.has(lower)) {
+	if (isCancelIntent(text, lower)) {
 		return request.kind === "confirm" ? { kind: "confirmed", confirmed: false } : { kind: "cancelled" };
 	}