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

package/extensions/wechat/README.md

@@ -199,17 +199,16 @@ 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
@@ -227,9 +226,9 @@ A dialog raised while a WeChat turn is in flight is forwarded to the sender:
 - 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.
+- 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
@@ -237,12 +236,9 @@ A dialog raised while a WeChat turn is in flight is forwarded to the sender:
   so a number, 是/否, or 取消 behaves as above.
 - An unanswered prompt is bounded: a reminder goes out halfway and the question
   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.
+  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.
@@ -257,25 +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 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 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.
+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
 
@@ -529,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; 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

@@ -246,7 +246,6 @@ 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;
@@ -280,27 +279,28 @@ export function createBridge(deps: BridgeDeps): Bridge {
 	}
 
 	/**
-	 * 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 ?? ""),
@@ -618,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/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" };
 }
 

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. */
@@ -55,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;
 }
@@ -111,6 +113,10 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 			return deps.activePeer() !== undefined;
 		},
 
+		language(): PeerLanguage {
+			return deps.language();
+		},
+
 		hasPending(): boolean {
 			return pending !== undefined;
 		},
@@ -127,21 +133,26 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 					};
 		},
 
-		cancel(): void {
-			if (!pending) return;
+		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.
-			void deps.send(notice("withdrawn", deps.language()));
-			settle({ kind: "cancelled" });
+			// 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 {
@@ -178,15 +189,17 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 				// An ignored question must not freeze the session: nudge once, then
 				// cancel so the model gets a clean answer instead of a hang.
 				const bound = scopedTimeoutMs ?? PROMPT_TIMEOUT_MS;
-				cancelTimers.push(arm(bound / 2, () => void deps.send(notice("promptWaiting", deps.language()))));
+				cancelTimers.push(
+					arm(bound / 2, () => void deps.send(notice("promptWaiting", deps.language()), undefined, { force: true })),
+				);
 				cancelTimers.push(
 					arm(bound, () => {
-						void deps.send(notice("timeout", deps.language()));
+						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;
 		},
@@ -197,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);

package/extensions/wechat/notices.ts

@@ -27,14 +27,14 @@ export type NoticeKind =
 	| "newBusy";
 
 const NOTICES: Record<NoticeKind, Record<PeerLanguage, string>> = {
-	ack: { zh: "收到，正在排队，轮到就回你。", en: "Got it — queued; I'll answer when it's my turn." },
+	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: "还在处理这条，发送 /stop 可取消。",
-		en: "Still working — send /stop to cancel.",
+		zh: "还在处理，/stop 可取消。",
+		en: "Still working — /stop cancels.",
 	},
 	overflow: { zh: "消息有点多，稍后再发。", en: "Too many messages queued — please wait a moment." },
 	media: {
@@ -59,8 +59,8 @@ const NOTICES: Record<NoticeKind, Record<PeerLanguage, string>> = {
 		en: "You've reached this hour's message limit — please try again later.",
 	},
 	promptWaiting: {
-		zh: "还在等你的回复，回复「取消」可跳过。",
-		en: "Still waiting for your reply — reply “cancel” to skip this.",
+		zh: "等你回复；回复「取消」跳过。",
+		en: "Waiting for your reply — reply cancel to skip.",
 	},
 	timeout: { zh: "问题超时，已取消。", en: "That question timed out." },
 	withdrawn: { zh: "问题已撤回。", en: "That question was withdrawn." },

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.