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

package/extensions/watch/index.ts

@@ -4,8 +4,9 @@
  * Registers the `watch` tool and `/watch` command. Watchers read a file or a
  * command's merged output, match each new line against a regular expression,
  * and alert the user; matching lines are reported to the model — and shown as a
- * bytefly notice — at the next turn, or wake a turn immediately when the
- * watcher opted into `wake`. Watchers are session-only and stopped on shutdown.
+ * bytefly notice — at the next turn, or wake a turn as soon as the agent is idle
+ * when the watcher opted into `wake`, including right after a running turn
+ * settles. Watchers are session-only and stopped on shutdown.
  *
  * Load with:  pi --extension ./extensions/watch
  */
@@ -14,8 +15,8 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { isExtensionEnabled } from "../../lib/env.ts";
 import { WATCH_MATCH_CHANNEL, type WatchMatchEvent } from "../../lib/events.ts";
 import { sanitizeLine } from "../../lib/format.ts";
-import { noticeMessage, type NoticeMessage } from "../../lib/notice.ts";
-import { createPendingReporter } from "../../lib/report.ts";
+import { burstText, noticeMessage, type NoticeMessage } from "../../lib/notice.ts";
+import { createPendingReporter, registerPendingChannel } from "../../lib/report.ts";
 import { registerCommands } from "./commands.ts";
 import { clipLabel } from "../../lib/tui/columns.ts";
 import { formatPendingMatch } from "./format.ts";
@@ -32,10 +33,14 @@ const MAX_CONTEXT_MATCHES = 20;
 /** Build the model-facing text for the pending-match notice. */
 export function buildWatchContext(matches: PendingMatch[]): string {
 	const shown = matches.slice(0, MAX_CONTEXT_MATCHES);
-	const lines = shown.map(formatPendingMatch);
 	const more = matches.length - shown.length;
-	const suffix = more > 0 ? `\n… ${more} more match${more === 1 ? "" : "es"}` : "";
-	return `${WATCH_CONTEXT_MARKER}\n${matches.length} watched line${matches.length === 1 ? "" : "s"} matched:\n${lines.join("\n")}${suffix}\nRead more with \`watch matches <id>\`.`;
+	return burstText({
+		marker: WATCH_CONTEXT_MARKER,
+		headline: `${matches.length} watched line${matches.length === 1 ? "" : "s"} matched`,
+		lines: shown.map((match) => formatPendingMatch(match)),
+		...(more > 0 ? { more: `… ${more} more match${more === 1 ? "" : "es"}` } : {}),
+		hint: "Read more with `watch matches <id>`.",
+	});
 }
 
 /** The shared notice for pending matches: model text plus renderer details. */
@@ -64,15 +69,16 @@ export default function watch(pi: ExtensionAPI, deps: WatchDeps = {}): void {
 	if (!isExtensionEnabled("watch")) return;
 	const runtime = deps.runtime ?? createWatchRuntime();
 
-	// Opt-in wake: a `wake` watcher matched while the agent is idle. The reporter
-	// reports *all* pending matches, not just the waking one, so a non-wake match
-	// is not silently dropped.
+	// Opt-in wake: a `wake` watcher matched. The reporter reports *all* pending
+	// matches, not just the waking one, so a non-wake match is not silently
+	// dropped, and it retries a burst that arrived mid-turn once the run settles.
 	const reporter = createPendingReporter<PendingMatch>({
 		wake: (notice) => pi.sendMessage(notice, { triggerTurn: true }),
 		pending: () => runtime.pendingMatches(),
 		markReported: (matches) => runtime.markReported(matches),
 		buildNotice: watchNotice,
 		source: "watch",
+		wakeRequested: () => runtime.pendingMatches().some((match) => runtime.get(match.watcherId)?.wake === true),
 		// A wake means the user is away from the terminal, so the alert also leaves
 		// the process. bytefly's notify capability owns delivery; this publishes the
 		// fact and never learns how it is sent. The newest match is the one an alert
@@ -97,41 +103,16 @@ export default function watch(pi: ExtensionAPI, deps: WatchDeps = {}): void {
 	registerTools(pi, runtime);
 	registerCommands(pi, runtime);
 
-	pi.on("session_start", (_event, ctx) => {
-		reporter.sessionStart();
-		runtime.load(ctx);
+	registerPendingChannel(pi, {
+		reporter,
+		runtime,
 		// `shutdown` clears this; a reload or session replacement reuses the
 		// runtime, so re-arm it on every session start.
-		runtime.onMatch = () => reporter.report();
-	});
-
-	// Tree navigation does not change the watcher table; only repaint.
-	pi.on("session_tree", (_event, ctx) => {
-		runtime.setStatus(ctx);
-	});
-
-	pi.on("agent_start", () => {
-		reporter.agentStart();
-	});
-	pi.on("agent_settled", () => {
-		reporter.agentSettled();
-	});
-
-	// Report matches to the model at the start of the next turn.
-	pi.on("before_agent_start", (_event, ctx) => {
-		const reported = reporter.beforeAgentStart();
-		if (!reported) return undefined;
-		runtime.setStatus(ctx);
-		return reported;
-	});
-
-	// Keep stale match notices out of later turns. Only this extension's notices
-	// are pruned; another source's are left for its own handler.
-	pi.on("context", (event) => reporter.filterContext(event.messages));
-
-	// `shutdown` detaches the UI controller, which clears both chips.
-	pi.on("session_shutdown", async () => {
-		runtime.onMatch = undefined;
-		await runtime.shutdown();
+		onSessionStart: () => {
+			runtime.onMatch = () => reporter.report();
+		},
+		onSessionShutdown: () => {
+			runtime.onMatch = undefined;
+		},
 	});
 }

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,23 +192,23 @@ 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
 
-One acknowledgement per wait episode, one answer per turn. A message that
-arrives before the first turn starts is merged into that turn, so it is answered
-inside the answer it is already waiting for — not with a second “working on it”.
+One message, one turn, one answer. A queued message is never merged into
+another prompt; it waits for its own turn. One acknowledgement per wait episode.
 
 | 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 |
-| 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 |
+| 1st message, peer busy | typing, `收到，排队中，轮到就回。` at 4 s, `还在处理前一条，轮到就回。` at 60 s, the answer when the slot frees |
+| 2nd message while a turn runs | its own turn behind the first; the 4 s ack and 60 s busy line; then its own answer |
+| 2nd message already queued | behind the first in FIFO; no merge |
+| 3rd…Nth in a burst | each is its own turn; past eight queued, one line asking to wait |
 
 Two consequences worth knowing: an answer can take up to one long-poll cycle
 (the server holds each `getupdates`; measured ~18 s) before the turn even
@@ -217,17 +218,30 @@ 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.
-- 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.
+- 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 rendered in the peer’s language, one language per prompt. 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. A dialog uses three minutes; the plan review
+  uses ten. 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
@@ -239,21 +253,17 @@ 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
-(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.
+A remote prompt can deliver a local file first. The plan review uses this: the
+plan file is sent before one compact editor prompt with the title, first steps,
+mode status, and three actions. Reply 2 to keep planning or 3 to exit; any other
+text is a refinement. If the upload fails, the plan text is sent instead. The
+plan file stays on disk. 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
-`type: 4` file item. Only the plan review uses it today; images, video, and voice
-are not sent outbound.
+`type: 4` file item. No current flow uses it; images, video, and voice are not
+sent outbound.
 
 ## Configuration
 
@@ -507,7 +517,6 @@ 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. |
 | `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. */
@@ -246,57 +246,61 @@ 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, 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(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;
 				},
-				stop: () => worker?.abort(item.peer) ?? false,
-				status: () => worker?.state(item.peer) ?? { status: "idle", queued: 0 },
-				history: (count) => deps.readHistory(item.peer, count),
+				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.`);
 		}
 	}
 
 	/**
-	 * Send a dialog preface (or plan digest) to the peer owning the in-flight turn.
+	 * Send a prompt to the peer owning the in-flight turn.
 	 *
 	 * 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.
 	 */
-	async function sendPrompt(text: string, signal?: AbortSignal): Promise<boolean> {
+	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);
 	}
-
-	/** Upload and send a local file to the peer owning the in-flight turn. */
 	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) => sendPrompt(text, signal),
+		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 ?? ""),
@@ -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)) {
@@ -620,7 +618,7 @@ export function createBridge(deps: BridgeDeps): Bridge {
 				// not be cancelled by the poll abort that follows.
 				const stopping = abort;
 				abort = undefined;
-				if (interaction.hasPending()) interaction.cancel();
+				if (interaction.hasPending()) await interaction.cancel();
 				stopping?.abort();
 				try {
 					await loopPromise;

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

@@ -30,7 +30,7 @@ import { peerLabel, peerKey } from "./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 "./qrcode.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";
 
@@ -154,7 +154,7 @@ function resetMessage(bridge: Bridge, peer: string): VerbOutcome {
 
 function cancelPromptMessage(bridge: Bridge): VerbOutcome {
 	if (!bridge.status().promptPending) return { message: "No prompt is waiting.", kind: "info" };
-	bridge.channel().cancel();
+	void bridge.channel().cancel();
 	return { message: "Cancelled the waiting prompt.", kind: "info" };
 }
 
@@ -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 () => {