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

package/extensions/watch/tools.ts

@@ -9,7 +9,7 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { sanitizeLine } from "../../lib/format.ts";
-import { errorResult } from "../../lib/tool-result.ts";
+import { errorResult, textResult } from "../../lib/tool-result.ts";
 import { reuseText, toolDetails } from "../../lib/tui/chrome.ts";
 import { callLine, detailsOrLine, rejectionLine } from "../../lib/tui/tool.ts";
 import { SEPARATORS } from "../../lib/tui/glyphs.ts";
@@ -82,62 +82,45 @@ export function registerTools(pi: ExtensionAPI, runtime: WatchRuntime): void {
 							ctx as ExtensionContext,
 						);
 						const flags = `${call.caseSensitive ? "" : "i"}${watch.wake ? ", wake" : ""}`;
-						return {
-							content: [
-								{
-									type: "text" as const,
-									text: `Watching ${watch.id}: ${sourceLabel(watch)} → /${sanitizeLine(watch.pattern)}/${flags}\nRead with \`watch matches ${watch.id}\` or \`watch logs ${watch.id}\`.`,
-								},
-							],
-							details: { action: "add", watch } satisfies WatchDetails,
-						};
+						return textResult(
+							`Watching ${watch.id}: ${sourceLabel(watch)} → /${sanitizeLine(watch.pattern)}/${flags}\nRead with \`watch matches ${watch.id}\` or \`watch logs ${watch.id}\`.`,
+							{ action: "add", watch } satisfies WatchDetails,
+						);
 					}
 
 					case "list": {
 						const watches = runtime.list();
-						return {
-							content: [{ type: "text" as const, text: formatWatchList(watches) }],
-							details: { action: "list", watches } satisfies WatchDetails,
-						};
+						return textResult(formatWatchList(watches), { action: "list", watches } satisfies WatchDetails);
 					}
 
 					case "status": {
 						const watch = runtime.get(call.id);
 						if (!watch) return errorResult("status", `no watcher "${call.id}".`);
-						return {
-							content: [{ type: "text" as const, text: formatWatchStatus(watch) }],
-							details: { action: "status", watch } satisfies WatchDetails,
-						};
+						return textResult(formatWatchStatus(watch), { action: "status", watch } satisfies WatchDetails);
 					}
 
 					case "matches": {
 						const result = runtime.matches(call.id, call.lines);
 						if (!result) return errorResult("matches", `no watcher "${call.id}".`);
 						const text = formatTail("matches", result.watch, result.lines, 4000);
-						return {
-							content: [{ type: "text" as const, text: text.text }],
-							details: {
-								action: "matches",
-								watch: result.watch,
-								matches: result.lines.join("\n"),
-								truncated: text.truncated,
-							} satisfies WatchDetails,
-						};
+						return textResult(text.text, {
+							action: "matches",
+							watch: result.watch,
+							matches: result.lines.join("\n"),
+							truncated: text.truncated,
+						} satisfies WatchDetails);
 					}
 
 					case "logs": {
 						const result = runtime.logs(call.id, call.lines);
 						if (!result) return errorResult("logs", `no watcher "${call.id}".`);
 						const text = formatTail("output", result.watch, result.lines, 4000);
-						return {
-							content: [{ type: "text" as const, text: text.text }],
-							details: {
-								action: "logs",
-								watch: result.watch,
-								logs: result.lines.join("\n"),
-								truncated: text.truncated,
-							} satisfies WatchDetails,
-						};
+						return textResult(text.text, {
+							action: "logs",
+							watch: result.watch,
+							logs: result.lines.join("\n"),
+							truncated: text.truncated,
+						} satisfies WatchDetails);
 					}
 
 					case "stop": {
@@ -145,34 +128,23 @@ export function registerTools(pi: ExtensionAPI, runtime: WatchRuntime): void {
 						if (!before) return errorResult("stop", `no watcher "${call.id}".`);
 						const stopped = runtime.stop(call.id);
 						const watch = runtime.get(call.id) ?? before;
-						return {
-							content: [
-								{
-									type: "text" as const,
-									text: stopped
-										? `Stopped ${watch.id} (${sourceLabel(watch)}).`
-										: `${watch.id} was not running; nothing to stop.`,
-								},
-							],
-							details: { action: "stop", watch, stopped } satisfies WatchDetails,
-						};
+						return textResult(
+							stopped
+								? `Stopped ${watch.id} (${sourceLabel(watch)}).`
+								: `${watch.id} was not running; nothing to stop.`,
+							{ action: "stop", watch, stopped } satisfies WatchDetails,
+						);
 					}
 
 					case "clear": {
 						const result = runtime.clear(call.id, call.all ?? false);
 						if (result.refused) return errorResult("clear", result.refused);
-						return {
-							content: [
-								{
-									type: "text" as const,
-									text:
-										result.cleared === 0
-											? "Nothing to clear."
-											: `Cleared ${result.cleared} watcher${result.cleared === 1 ? "" : "s"}.`,
-								},
-							],
-							details: { action: "clear", cleared: result.cleared, watches: runtime.list() } satisfies WatchDetails,
-						};
+						return textResult(
+							result.cleared === 0
+								? "Nothing to clear."
+								: `Cleared ${result.cleared} watcher${result.cleared === 1 ? "" : "s"}.`,
+							{ action: "clear", cleared: result.cleared, watches: runtime.list() } satisfies WatchDetails,
+						);
 					}
 				}
 			} catch (error) {

package/extensions/wechat/README.md

@@ -47,8 +47,9 @@ How the `send_wechat` call and its result look in the transcript — the call li
 - **Peer feedback** — a burst that arrives while a turn is still running is
   answered once, a message waiting on another conversation is acknowledged once,
   a slow turn says so, and a turn that ends without text says so instead of going
-  quiet. Notices and `/help` follow the peer's language. The peer can also stop
-  (`/stop`), restart (`/new`), and ask what is happening (`/status`).
+  quiet. Notices and `/help` follow the peer's language: a Chinese message sets it,
+  and a language-neutral reply (`1`, `ok`) does not switch it back. The peer can
+  also stop (`/stop`), restart (`/new`), and ask what is happening (`/status`).
 - **Remote prompts** — the peer session's own UI is bound to that peer, so
   `ask_user_question`, plan approval, and any other dialog raised inside a
   WeChat turn is sent to WeChat and answered there. Terminal turns keep the TUI,
@@ -174,14 +175,14 @@ needs. Per action:
 |---|---|
 | Sends a message | The native typing indicator starts as soon as the message is picked up; the answer is sent when the run settles. |
 | Sends several messages quickly | At most one acknowledgement, then a single answer that covers the burst in order. |
-| Waits behind a long turn | The indicator keeps refreshing, and after four seconds one short `收到，正在处理…` / “Got it — working on it.”; a turn still running at 30 seconds adds one `还在处理这条…` / “Still working on this one”. |
+| Waits behind a long turn | The indicator keeps refreshing, and after four seconds one short `收到，正在排队，轮到就回你。` / “Got it — queued; I’ll answer when it’s my turn.”; a turn still running at 30 seconds adds one `还在处理这条，发送 /stop 可取消。` / “Still working — send /stop to cancel.”, so the way out is named when it is wanted. |
 | Sends while another peer's turn runs | One line after four seconds, then one more at a minute (`前面还有一条正在处理…` / “Your message is queued behind another conversation…”), and the answer when the slot frees. |
 | Sends a photo or a file | The model reads it; an attachment that could not be read (too large, a failed download, no key) is named in the answer. |
 | Sends a voice note or video | One line: voice without a transcript and video are not supported. |
 | Reads a long answer | Streamed as it is produced — one part per paragraph, per two silent seconds, or per 400 characters — and numbered (`[1/3] …`) only when a single part exceeds `maxReplyChars`. |
 | Reads an answer | Plain chat text — Markdown fences, headings, and emphasis markers are flattened, code-block bodies survive. |
-| Is asked a question | A numbered prompt; 确定/是/yes or 不是/否/no answers it, 取消 dismisses. Ignored, it is nudged at 90 seconds and cancelled at three minutes. |
-| Types `/help`, `/new`, `/stop`, or `/status` | The command list, a fresh conversation, a stopped answer, or the current state; `/new` is declined while their run is in flight. |
+| Is asked a question | A numbered prompt; 确定/是/yes or 不是/否/no answers it, 取消 dismisses. Ignored, it is nudged at the halfway point of its window and then cancelled: three minutes for a dialog, ten for a plan review, where the plan has to be read first. |
+| Types `/help`, `/new`, `/stop`, or `/status` | The command list, a fresh conversation, a stopped answer, or the current state — including the dialog a blocked turn is waiting on; `/new` is declined while their run is in flight. A command works while a dialog waits: it is never read as an answer to it. |
 | Types `/history` | The last eight messages of this conversation (or the requested number, up to 20), one line each. |
 | Floods the chat | Past eight queued messages, one line asking to wait rather than an unbounded queue. |
 | Sends the same message twice (a server replay) | Answered once: the WeChat message id is remembered for an hour, across a reconnect or reload. |
@@ -191,9 +192,10 @@ needs. Per action:
 | Gets a turn that could not start | `处理失败，请稍后重试。` / “Something went wrong — please try again.”, and the terminal says why. |
 | Keeps messaging an expired or logged-out bridge | Nothing — the bot goes quiet, and only the terminal chip says why. |
 
-Notices are one line and in the peer's language (Chinese when their message
-contains Chinese). The bridge never sends greetings, read receipts, or progress
-chatter: WeChat notifies per message, so every bubble has to carry information.
+Notices are one line and in the peer's language (Chinese once their messages
+contain Chinese; a bare `1` or `ok` does not switch it back). The bridge never
+sends greetings, read receipts, or progress chatter: WeChat notifies per message,
+so every bubble has to carry information.
 
 ### The reply contract
 
@@ -204,7 +206,7 @@ inside the answer it is already waiting for — not with a second “working on
 | Situation | What the peer gets |
 |---|---|
 | 1st message, session idle | typing, then the answer (no acknowledgement: there is nothing to wait for) |
-| 1st message, peer busy | typing, `收到，正在处理…` at 4 s, `前面还有一条正在处理…` at 60 s, the answer when the slot frees |
+| 1st message, peer busy | typing, `收到，正在排队，轮到就回你。` at 4 s, `前面还有一条正在处理…` at 60 s, the answer when the slot frees |
 | 2nd message after the acknowledgement, still queued | nothing new; it is merged into the same turn and the one answer covers both in order |
 | 2nd message while a turn runs | no new acknowledgement; it becomes its own turn and answer after the first |
 | 3rd…Nth in a burst | same as the queued case; past eight queued, one line asking to wait |
@@ -217,17 +219,33 @@ starts, and a reply is delivered when the run settles, not token by token.
 
 A dialog raised while a WeChat turn is in flight is forwarded to the sender:
 
-- `select` — a numbered list; reply with a number, the option text, or any other
-  text for the free-form “Other” entry.
+- `select` — a numbered list; reply with a number or the option text. Free text
+  becomes the “Other” answer only when the list carries that entry; the hint says
+  so, so a plan review without it does not pretend free text is a choice.
 - `confirm` — reply 是/否, 确定/不是, or yes/no.
 - `input` / `editor` — reply with the text.
-- Reply 取消 (or cancel) to dismiss.
+- Reply 取消 (or cancel) to dismiss; `退出`, `退出 plan 模式`, and
+  `exit plan mode` are recognized as cancel intent. In a plan review a dismissal
+  leaves plan mode without approving.
 - Hints are bilingual (Chinese and English). A reply that cannot be read
   re-sends the prompt with a short “didn’t recognize that” notice instead of
   repeating it silently.
+- A command is not an answer. While a dialog waits the model is blocked on it, so
+  the slash commands are matched first: `/status` names the waiting question and
+  `/stop` stops the turn, where before both were parsed as an attempt to answer
+  and bounced back as “didn’t recognize that”. Any other text is still the answer,
+  so a number, 是/否, or 取消 behaves as above.
 - An unanswered prompt is bounded: a reminder goes out halfway and the question
-  is cancelled after three minutes with a one-line notice, so an ignored dialog
-  cannot freeze the session.
+  is cancelled at the end of its window with a one-line notice, so an ignored
+  dialog cannot freeze the session. The window is three minutes for a dialog and
+  ten for the plan review, which arrives with the plan attached — a request that
+  carries `timeoutMs` asks for the longer one through the channel, and the
+  reminder names 取消 rather than a duration that assumes the short window. A
+  timed-out plan review is treated like a dismissal: plan mode ends without
+  approval, and the plan file remains.
+- A prompt that goes away before it is answered — a pause, a `/stop`, a shutdown —
+  says so (`问题已撤回。` / “That question was withdrawn.”) instead of reusing the
+  timeout line: the peer was not slow, the question left.
 
 Each peer session is created with its own UI context (`bindExtensions` with
 `mode: "rpc"`), so its dialogs go to that peer by construction rather than by
@@ -240,15 +258,19 @@ to WeChat. See [Design notes](#design-notes).
 ## Outbound files
 
 A remote prompt can deliver a local file first. `exit_plan_mode` uses this to
-send the plan file itself before the three choices, so WeChat sees the whole plan
+send the plan file itself before the five choices, so WeChat sees the whole plan
 (a long one falls back to chunked text if the upload fails). The peer session's
 UI context carries the bridge channel, so `askHuman` finds it and posts the file
 then the text before the dialogs. Before the choices it also posts a short
 digest — the title, the step count, and the first steps — so the review is
 answerable from the chat even if the file bubble is never opened, and a file or
 digest the bridge cannot deliver is reported on the terminal instead of vanishing.
-The choices also include **Send the full plan**, which posts the plan text and
-asks again, so the whole plan is reachable without the attachment.
+The digest says plan mode is on and that write access is off. The choices also
+include **Send the full plan**, which posts the plan text and asks again, so the
+whole plan is reachable without the attachment, and **Exit plan mode (discard)**,
+which leaves without approving. After a Keep decision the user can say “exit plan
+mode”; the model calls `cancel_plan_mode`, which needs no plan path and records
+no todo or goal.
 The flow mirrors the
 reference client: `getuploadurl` → AES-128-ECB encrypt → `POST` the ciphertext
 (`Content-Type: application/octet-stream`) → read `x-encrypted-param` → send a
@@ -507,7 +529,7 @@ status, which is what the old start/stop guidance used to do.
 | `media.ts` | Media key/encrypt/decrypt, padded size, upload/download URL, MIME sniff, filename sanitize, and save helpers. |
 | `outbound.ts` | Upload and send a local file: hash, encrypt, `getUploadUrl`, upload, `sendFileMessage`. |
 | `login.ts` | QR login state machine. |
-| `qrcode.ts` | QR matrix → Unicode half-block terminal lines. |
+| `qrcode.ts` | QR matrix → Unicode half-block terminal lines; the `qrcode` package is imported on first use, not at registration. |
 | `login-screen.ts` | The `/wechat login` screen (`ctx.ui.custom`), drawn from the `lib/tui/` kit (`titleRule`, `clip`, `isCloseKey`). |
 | `status-screen.ts` | The `/wechat` control screen (`ctx.ui.custom`): live facts, a focusable peer list with stop/reset/history keys, and the pure one-line/body renderers, drawn from the `lib/tui/` kit (`titleRule`, `keyValueRow`, `listRow`, `paint`, `IdCursor`). |
 | `config.ts` | The `wechat` section of `bytefly.json` loading and normalization. |

package/extensions/wechat/bridge.ts

@@ -18,7 +18,7 @@
 
 import { WechatError, type WechatClient } from "./client.ts";
 import { createAdmissionQueue, createTurnBudget } from "./admission.ts";
-import { createDeliverer } from "./deliver.ts";
+import { createDeliverer, type MessageTarget } from "./deliver.ts";
 import { createInboundAdmission } from "./inbound.ts";
 import { createPollLoop, defaultPollTimeout } from "./poll.ts";
 import { messageOf } from "./errors.ts";
@@ -225,8 +225,8 @@ export function createBridge(deps: BridgeDeps): Bridge {
 	}
 
 	/** Send one bubble to a peer and report whether it was delivered. */
-	async function reply(item: { peer: string; contextToken?: string }, text: string): Promise<boolean> {
-		return deliverer.reply(item, text, abort?.signal);
+	async function reply(target: MessageTarget, text: string): Promise<boolean> {
+		return deliverer.reply(target, text, abort?.signal);
 	}
 
 	/** The outbound surface, reading the live client and account at call time. */
@@ -248,30 +248,34 @@ export function createBridge(deps: BridgeDeps): Bridge {
 	});
 
 	/** Run a slash action out-of-band and reply to the sender; never starts a turn. */
-	async function runSlashAction(command: SlashCommand, item: InboundItem, args: string): Promise<void> {
+	async function runSlashAction(command: SlashCommand, target: MessageTarget, args: string): Promise<void> {
 		if (!command.run) return;
 		const ctx: SlashContext = {
 			args,
-			peer: item.peer,
+			peer: target.peer,
 			reply: async (text) => {
-				await reply(item, text);
+				await reply(target, text);
 			},
-			activeTurn: worker?.state(item.peer).status === "running",
-			language: languageOf(item.peer),
+			activeTurn: worker?.state(target.peer).status === "running",
+			language: languageOf(target.peer),
 			session: {
 				newSession: () => {
-					worker?.reset(item.peer);
+					worker?.reset(target.peer);
 				},
-				stop: () => worker?.abort(item.peer) ?? false,
-				status: () => worker?.state(item.peer) ?? { status: "idle", queued: 0 },
-				history: (count) => deps.readHistory(item.peer, count),
+				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(item, `Command /${command.name} failed.`);
+			await reply(target, `Command /${command.name} failed.`);
 		}
 	}
 
@@ -305,11 +309,10 @@ export function createBridge(deps: BridgeDeps): Bridge {
 
 	/** The peer's language: from this text, else the last one they wrote. */
 	function languageOf(peer: string, text?: string): PeerLanguage {
-		if (text) {
-			const language = peerLanguage(text);
-			languages.set(peer, language);
-			return language;
-		}
+		// 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";
 	}
 
@@ -386,26 +389,11 @@ export function createBridge(deps: BridgeDeps): Bridge {
 		if (typeof messageId === "number" && messageId !== 0) rememberMessage(state, peer, messageId, now);
 		deps.saveState(state);
 
-		// 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 = {
-			peer,
-			contextToken: message.context_token ?? findPeer(state, peer)?.lastContextToken,
-			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;
-		}
-		// Intercept a text slash command before it becomes a turn. A message with
-		// media is never a command, so an attachment is never dropped; an unknown
-		// command falls through to the model as ordinary text.
+		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) {
@@ -415,12 +403,22 @@ export function createBridge(deps: BridgeDeps): Bridge {
 			}
 			if (command.kind === "snippet") {
 				text = expandSnippet(command, slash.args);
-				item.text = text;
 			} else {
-				void runSlashAction(command, item, slash.args);
+				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)) {

package/extensions/wechat/client.ts

@@ -9,6 +9,7 @@
  */
 
 import { randomUUID } from "node:crypto";
+import { asNumber } from "../../lib/config.ts";
 import { mediaDownloadUrl } from "./media.ts";
 import type {
 	BotCredentials,
@@ -120,10 +121,6 @@ function parseJson(text: string): Record<string, unknown> {
 	}
 }
 
-function asNumber(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
 function asString(value: unknown): string | undefined {
 	return typeof value === "string" && value !== "" ? value : undefined;
 }

package/extensions/wechat/commands.ts

@@ -292,7 +292,7 @@ async function runLogin(ctx: ExtensionContext, deps: CommandDeps): Promise<void>
 		return;
 	}
 
-	const state: LoginViewState = { status: "wait", lines: qrLines(qr.imgContent), url: qr.imgContent };
+	const state: LoginViewState = { status: "wait", lines: await qrLines(qr.imgContent), url: qr.imgContent };
 	const result = await ctx.ui.custom<LoginOutcome | undefined>((tui, theme, _keybindings, done) => {
 		const controller = new AbortController();
 		void (async () => {

package/extensions/wechat/interaction.ts

@@ -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. */
@@ -79,6 +84,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
@@ -119,9 +129,10 @@ 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
+			// 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.
-			void deps.send(notice("timeout", deps.language()));
+			void deps.send(notice("withdrawn", deps.language()));
 			settle({ kind: "cancelled" });
 		},
 
@@ -133,6 +144,14 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 			return deps.sendFile(path, name, signal);
 		},
 
+		setPromptTimeout(ms: number): () => void {
+			const previous = scopedTimeoutMs;
+			scopedTimeoutMs = ms;
+			return () => {
+				scopedTimeoutMs = previous;
+			};
+		},
+
 		async request(request: InteractionRequest, signal?: AbortSignal): Promise<InteractionAnswer> {
 			// A `select` that resolved to "Other" stashes its text for that peer; the
 			// immediately following `input` from the same peer returns it without
@@ -158,9 +177,10 @@ 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()))));
 				cancelTimers.push(
-					arm(PROMPT_TIMEOUT_MS, () => {
+					arm(bound, () => {
 						void deps.send(notice("timeout", deps.language()));
 						settle({ kind: "cancelled" });
 					}),
@@ -197,6 +217,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: "Got it — queued; I'll answer when it's my turn." },
 	busy: {
 		zh: "前面还有一条正在处理，你的消息排在后面，轮到你就回你。",
 		en: "Your message is queued behind another conversation; I'll answer as soon as it's free.",
 	},
 	stillWorking: {
-		zh: "还在处理这条，稍等一下…",
-		en: "Still working on this one — a moment…",
+		zh: "还在处理这条，发送 /stop 可取消。",
+		en: "Still working — send /stop to cancel.",
 	},
 	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: "Still waiting for your reply — reply “cancel” to skip this.",
 	},
 	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/prompt.ts

@@ -20,9 +20,12 @@ export type PromptParse =
 	| { kind: "cancelled" }
 	| { kind: "retry" };
 
-const SELECT_HINT =
+const SELECT_OTHER_HINT =
 	"回复编号或选项文字；其它内容作为自定义回答；回复「取消」或 cancel 跳过。\n" +
 	"Reply with a number or the option text; anything else becomes your own answer; reply cancel to dismiss.";
+const SELECT_CHOICE_HINT =
+	"回复编号或选项文字；回复「取消」或 cancel 跳过。\n" +
+	"Reply with a number or the option text; 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 =
@@ -32,7 +35,7 @@ const EDITOR_HINT =
 export const RETRY_NOTICE =
 	"没有识别到有效回复，请重新回答。\nSorry, I didn't recognize that reply — please answer again.";
 
-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", "不", "不是", "不行"]);
 
@@ -50,7 +53,8 @@ function promptBody(request: InteractionRequest): 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 : SELECT_CHOICE_HINT]);
 		}
 		case "confirm":
 			return lines([request.title, request.message, CONFIRM_HINT]);
@@ -61,12 +65,23 @@ function promptBody(request: InteractionRequest): string {
 	}
 }
 
+/**
+ * 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" };
 	}