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

package/extensions/wechat/{interaction.ts → dialog/interaction.ts}

@@ -1,11 +1,13 @@
 /**
  * The WeChat implementation of {@link InteractionChannel}: it forwards a dialog
- * prompt to the peer that owns the current turn and resolves when that peer
- * replies.
+ * prompt to one peer and resolves when that peer replies.
  *
- * It depends only on injected `send`/`sendFile`/`activePeer` accessors and a
- * timer seam, never on the bridge or HTTP client, so it is unit-tested without
- * I/O. The bridge owns the poll loop and hands each inbound message to
+ * One channel serves one peer. That is what lets two peers' turns run at once
+ * without a dialog becoming ambiguous: the channel knows who it is asking, so a
+ * reply can only answer its own peer's prompt. It depends only on injected
+ * `send`/`sendFile`/`active` accessors and a timer seam, never on the bridge or
+ * HTTP client, so it is unit-tested without I/O. The bridge owns the poll loop,
+ * keeps one channel per peer (`channels.ts`), and hands each inbound message to
  * {@link WechatInteractionChannel.handleInbound}.
  *
  * A prompt is bounded: a peer who never answers cannot hold the session open, so
@@ -18,23 +20,25 @@ import {
 	type InteractionAnswer,
 	type InteractionChannel,
 	type InteractionRequest,
-} from "../../lib/interaction.ts";
-import { type PeerLanguage } from "./format.ts";
-import { notice } from "./notices.ts";
+} from "../../../lib/interaction.ts";
+import { type PeerLanguage } from "../text/format.ts";
+import { notice } from "../text/notices.ts";
 import { formatPrompt, parsePromptAnswer } from "./prompt.ts";
-import { defaultTimer, type ArmTimer } from "./timer.ts";
+import { defaultTimer, type ArmTimer } from "../timer.ts";
 
 /** How long a forwarded prompt waits before it is cancelled. */
 export const PROMPT_TIMEOUT_MS = 180_000;
 
 export interface WechatInteractionDeps {
-	/** Send one text message to the owning peer; `force` bypasses the prompt-active gate. */
+	/** The one peer this channel asks. */
+	peer: string;
+	/** Send one text message to the 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. */
+	/** Send a local file to the 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. */
+	/** Whether the peer owns a turn right now, so a prompt has somewhere to land. */
+	active: () => boolean;
+	/** The language the peer writes in, for the timeout notices. */
 	language: () => PeerLanguage;
 	/** Arm a cancellable one-shot timer. Defaults to a real, unref'd `setTimeout`. */
 	armTimer?: ArmTimer;
@@ -48,8 +52,8 @@ export interface WechatInteractionChannel extends InteractionChannel {
 	 * 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;
+	/** Consume an inbound message as a reply to this peer's prompt. */
+	handleInbound(text: string): boolean;
 	/** Whether a prompt is currently waiting for a reply. */
 	hasPending(): boolean;
 	/** The waiting prompt, for the control screen; undefined when none waits. */
@@ -73,7 +77,6 @@ export interface PendingPromptInfo {
 
 interface Pending {
 	request: InteractionRequest;
-	peer: string;
 	startedAt: number;
 	resolve: (answer: InteractionAnswer) => void;
 	signal?: AbortSignal;
@@ -92,11 +95,11 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 	 */
 	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
-	 * never become another peer's answer.
+	 * Free text captured from a `select` "Other" reply: the immediately following
+	 * `input` for this peer returns it. One value, because one channel asks one peer
+	 * — another peer's free text cannot reach this channel at all.
 	 */
-	const other = new Map<string, string>();
+	let other: string | undefined;
 
 	function settle(answer: InteractionAnswer): void {
 		const current = pending;
@@ -110,7 +113,7 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 
 	return {
 		isActive(): boolean {
-			return deps.activePeer() !== undefined;
+			return deps.active();
 		},
 
 		language(): PeerLanguage {
@@ -126,7 +129,7 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 			return current === undefined
 				? undefined
 				: {
-						peer: current.peer,
+						peer: deps.peer,
 						kind: current.request.kind,
 						title: current.request.title,
 						startedAt: current.startedAt,
@@ -164,27 +167,24 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 		},
 
 		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
-			// another round-trip.
-			const asking = deps.activePeer();
-			const stashed = asking === undefined ? undefined : other.get(asking);
-			if (request.kind === "input" && asking !== undefined && stashed !== undefined) {
-				other.delete(asking);
+			// A `select` that resolved to "Other" stashes its text; the immediately
+			// following `input` returns it without another round-trip.
+			const stashed = other;
+			if (request.kind === "input" && stashed !== undefined) {
+				other = undefined;
 				return { kind: "value", value: stashed };
 			}
-			if (request.kind !== "input" && asking !== undefined) other.delete(asking);
+			if (request.kind !== "input") other = undefined;
 
 			if (signal?.aborted || !this.isActive()) return { kind: "cancelled" };
 			if (pending) return { kind: "cancelled" };
 
 			// Register the pending prompt before the send await so a fast reply is
 			// never lost to the round-trip, then send and fail closed.
-			const peer = deps.activePeer() as string;
 			const cancelTimers: Array<() => void> = [];
 			const answer = new Promise<InteractionAnswer>((resolve) => {
 				const onAbort = () => settle({ kind: "cancelled" });
-				pending = { request, peer, startedAt: now(), resolve, signal, onAbort, cancelTimers };
+				pending = { request, startedAt: now(), resolve, signal, onAbort, cancelTimers };
 				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.
@@ -204,9 +204,9 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 			return await answer;
 		},
 
-		handleInbound(peer: string, text: string): boolean {
+		handleInbound(text: string): boolean {
 			const current = pending;
-			if (!current || current.peer !== peer) return false;
+			if (!current) return false;
 			const parsed = parsePromptAnswer(current.request, text);
 			switch (parsed.kind) {
 				case "retry":
@@ -215,7 +215,7 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 					});
 					return true;
 				case "other":
-					other.set(peer, parsed.text);
+					other = parsed.text;
 					settle({ kind: "value", value: INTERACTION_OTHER_LABEL });
 					return true;
 				case "value":
@@ -231,7 +231,7 @@ export function createWechatInteractionChannel(deps: WechatInteractionDeps): Wec
 		},
 
 		reset(): void {
-			other.clear();
+			other = undefined;
 			scopedTimeoutMs = undefined;
 			settle({ kind: "cancelled" });
 		},

package/extensions/wechat/{prompt.ts → dialog/prompt.ts}

@@ -9,8 +9,8 @@
  * the {@link INTERACTION_OTHER_LABEL} option so the caller can collect it once.
  */
 
-import { INTERACTION_OTHER_LABEL, type InteractionRequest } from "../../lib/interaction.ts";
-import { sanitizeInbound, type PeerLanguage } from "./format.ts";
+import { INTERACTION_OTHER_LABEL, type InteractionRequest } from "../../../lib/interaction.ts";
+import { sanitizeInbound, type PeerLanguage } from "../text/format.ts";
 
 /** A parsed reply: a resolved answer, the "other" choice, or a retry. */
 export type PromptParse =

package/extensions/wechat/{remote-ui.ts → dialog/remote-ui.ts}

@@ -24,7 +24,7 @@ import {
 	type InteractionAnswer,
 	type InteractionChannel,
 	type InteractionRequest,
-} from "../../lib/interaction.ts";
+} from "../../../lib/interaction.ts";
 
 function valueOf(answer: InteractionAnswer): string | undefined {
 	return answer.kind === "value" ? answer.value : undefined;

package/extensions/wechat/index.ts

@@ -19,18 +19,18 @@ import { isPidAlive } from "../../lib/spawn.ts";
 import { GLYPHS, STATUS_KEYS } from "../../lib/tui/glyphs.ts";
 import { paint } from "../../lib/tui/tokens.ts";
 import { createBridge, type Bridge, type BridgeState } from "./bridge.ts";
-import { createFetchRunner, WechatClient, type WechatClientOptions } from "./client.ts";
-import { registerCommands, type CommandDeps } from "./commands.ts";
+import { createFetchRunner, WechatClient, type WechatClientOptions } from "./transport/client.ts";
+import { registerCommands, type CommandDeps } from "./commands/commands.ts";
 import { messageOf } from "./errors.ts";
 import { loadWechatConfig } from "./config.ts";
-import { clearCredentials, primaryAccount, saveAccount, wechatDir } from "./credentials.ts";
-import { acquireLock, lockPath, readLock, refreshLock, releaseLock } from "./lock.ts";
-import { openPeerSession, type PeerSession, type PeerSessionOptions } from "./peer-session.ts";
-import { createPeerUIContext } from "./remote-ui.ts";
-import { peerKey } from "./format.ts";
-import { readPeerHistory } from "./history.ts";
-import { SLASH_COMMANDS } from "./slash.ts";
-import { readState, statePath, writeState } from "./state.ts";
+import { clearCredentials, primaryAccount, saveAccount, wechatDir } from "./state/credentials.ts";
+import { acquireLock, lockPath, readLock, refreshLock, releaseLock } from "./state/lock.ts";
+import { openPeerSession, type PeerSession, type PeerSessionOptions } from "./peer/peer-session.ts";
+import { createPeerUIContext } from "./dialog/remote-ui.ts";
+import { peerKey } from "./text/format.ts";
+import { readPeerHistory } from "./commands/history.ts";
+import { SLASH_COMMANDS } from "./commands/slash.ts";
+import { readState, statePath, writeState } from "./state/state.ts";
 import { registerTools } from "./tools.ts";
 
 /**

package/extensions/wechat/{admission.ts → peer/admission.ts}

@@ -8,8 +8,8 @@
  * budget is in memory; a reload starts a fresh hour.
  */
 
-import type { InboundItem } from "./types.ts";
-import { peerKey } from "./format.ts";
+import type { InboundItem } from "../types.ts";
+import { peerKey } from "../text/format.ts";
 
 /** A rolling-hour turn budget per peer. */
 export interface TurnBudget {

package/extensions/wechat/{peer-session.ts → peer/peer-session.ts}

@@ -32,8 +32,8 @@ import {
 	SessionManager,
 } from "@earendil-works/pi-coding-agent";
 import { join } from "node:path";
-import { WECHAT_CHANNEL_PROMPT } from "./channel.ts";
-import { peerKey } from "./format.ts";
+import { WECHAT_CHANNEL_PROMPT } from "../text/channel.ts";
+import { peerKey } from "../text/format.ts";
 
 /** The SDK pieces a peer session needs; injected so tests never load resources. */
 export interface PeerSessionSeams {

package/extensions/wechat/{peer-worker.ts → peer/peer-worker.ts}

@@ -10,13 +10,18 @@
  *
  * Contract:
  *
- * - 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.
+ * - One turn at a time per peer, and by default two peers' turns at once
+ *   (`PEER_CONCURRENCY`), so each answered peer owns its dialog through its own
+ *   interaction channel. A third peer waits for a slot and is told so.
  * - 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.
+ * - A close that abandons the session says `abandoned` once per peer that still
+ *   had work, after its turn stops and before its session goes. The turn's own
+ *   line is suppressed then, and each notice carries its own deadline, so a
+ *   connection that never answers cannot hold the exit.
  * - The session is opened lazily, reset on request, and disposed after an idle
  *   timeout, so a peer who stops writing does not keep a context alive.
  *
@@ -24,10 +29,11 @@
  */
 
 import type { ImageContent } from "@earendil-works/pi-ai";
-import { messageOf } from "./errors.ts";
+import { messageOf } from "../errors.ts";
+import type { NoticeKind } from "../text/notices.ts";
 import type { PeerSession } from "./peer-session.ts";
 import { createReplyPipeline, type ReplyPipeline } from "./reply-pipeline.ts";
-import { defaultTimer, type ArmTimer } from "./timer.ts";
+import { defaultTimer, type ArmTimer } from "../timer.ts";
 
 /** One admitted, media-resolved inbound message. */
 export interface PeerItem {
@@ -45,13 +51,13 @@ export interface PeerItem {
 }
 
 /** What the worker says to the peer when a turn ends without text of its own. */
-export type TurnFallback = "stopped" | "noText" | "failed" | "compacted";
+export type TurnFallback = Extract<NoticeKind, "stopped" | "abandoned" | "noText" | "failed" | "compacted">;
 
 export interface PeerWorkerDeps {
 	/** Open (or resume) one peer's session; the bridge owns the directory layout. */
 	openSession: (peer: string, options: { fresh: boolean }) => Promise<PeerSession>;
-	/** Deliver one turn's text to the peer; false stops the rest of a stream. */
-	send: (item: PeerItem, text: string) => Promise<boolean>;
+	/** Deliver one line to the peer; false stops the rest of a stream. */
+	send: (item: PeerItem, text: string, options?: { signal?: AbortSignal }) => Promise<boolean>;
 	/** The fallback line for a turn that produced no text. */
 	fallback: (item: PeerItem, reason: TurnFallback) => string;
 	/** A turn started / finished for this item, for typing and notices. */
@@ -59,7 +65,7 @@ export interface PeerWorkerDeps {
 	onSettled?: (item: PeerItem) => void;
 	/** A session or turn failure worth showing on the terminal. */
 	notify?: (message: string, kind?: "info" | "warning" | "error") => void;
-	/** Turns running at once across peers. Default 1, so a dialog has one owner. */
+	/** Turns running at once across peers. Defaults to {@link PEER_CONCURRENCY}. */
 	concurrency?: number;
 	/** Dispose an idle session after this long. `0` disables the idle sweep. */
 	idleTimeoutMs?: number;
@@ -86,7 +92,7 @@ export interface PeerSnapshot {
 }
 
 export interface PeerWorker {
-	/** Queue one message; resolves as soon as it is queued or merged. */
+	/** Queue one message; it is never merged into another. */
 	enqueue(item: PeerItem): void;
 	/** Stop the running turn for `peer`; false when nothing was running. */
 	abort(peer: string): boolean;
@@ -95,18 +101,30 @@ export interface PeerWorker {
 	 * Refused while a turn runs, and the queued messages go with it.
 	 */
 	reset(peer: string): boolean;
-	/** The turn running right now, if any (one with the default concurrency). */
-	current(): PeerItem | undefined;
+	/** The turn running for this peer, if any. */
+	running(peer: string): 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. */
-	close(): Promise<void>;
+	close(options?: { abandon?: boolean }): Promise<void>;
 }
 
 const DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 
+/**
+ * Peers whose turns run at once.
+ *
+ * Two, because a phone chat rarely has more than two conversations in flight and
+ * every concurrent turn is a full model run on the user's budget; the rest wait
+ * in a fair queue and are acknowledged, exactly as a second peer waits today.
+ */
+export const PEER_CONCURRENCY = 2;
+
+/** How long a shutdown waits for its one notice per peer before giving up. */
+const ABANDON_NOTICE_MS = 5000;
+
 interface PeerEntry {
 	queue: PeerItem[];
 	running?: PeerItem;
@@ -123,7 +141,7 @@ 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 concurrency = Math.max(1, deps.concurrency ?? PEER_CONCURRENCY);
 	const peers = new Map<string, PeerEntry>();
 	/** Active reply pipelines, so a dialog can flush buffered text first. */
 	const pipelines = new Map<string, ReplyPipeline>();
@@ -132,7 +150,9 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 	/** Peers whose next session must start empty (`/new`). */
 	const fresh = new Set<string>();
 	let running = 0;
-	let currentItem: PeerItem | undefined;
+	/** When each queued item arrived, so the next free slot goes to the oldest wait. */
+	const arrived = new WeakMap<PeerItem, number>();
+	let arrivals = 0;
 	let closed = false;
 
 	function entry(peer: string): PeerEntry {
@@ -280,16 +300,25 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 			unsubscribe();
 			pipelines.delete(item.peer);
 		}
+		// A closing worker has already said, once, that the session ended.
+		if (closed) return;
 		if (reason) await sendPart(deps.fallback(item, reason));
 		if (compacted) await sendPart(deps.fallback(item, "compacted"));
 	}
 
 	/** The next peer with work, so a finished turn can hand its slot on. */
+	/** The next peer with work, oldest queued message first so no peer starves. */
 	function nextRunnable(): [string, PeerEntry] | undefined {
+		let picked: [string, PeerEntry] | undefined;
 		for (const [peer, target] of peers) {
-			if (!target.running && target.queue.length > 0) return [peer, target];
+			if (target.running || target.queue.length === 0) continue;
+			const waiting = target.queue[0];
+			const oldest = picked?.[1].queue[0];
+			if (!picked || (waiting && oldest && (arrived.get(waiting) ?? 0) < (arrived.get(oldest) ?? 0))) {
+				picked = [peer, target];
+			}
 		}
-		return undefined;
+		return picked;
 	}
 
 	/** Start turns until the concurrency limit or the queues are empty. */
@@ -302,7 +331,6 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 			target.running = item;
 			target.startedAt = now();
 			running += 1;
-			currentItem = item;
 			cancelIdleSweep(target);
 			deps.onStart?.(item);
 			void (async () => {
@@ -311,12 +339,13 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 					await runTurn(item, opened);
 				} catch (error) {
 					deps.notify?.(`WeChat session failed for ${item.peer}: ${messageOf(error)}`, "error");
-					await deps.send(item, deps.fallback(item, "failed"));
+					// A closing worker says one line of its own instead: the peer does not need
+					// two reasons, and the second send may well fail on the dying connection.
+					if (!closed) await deps.send(item, deps.fallback(item, "failed"));
 				} finally {
 					target.running = undefined;
 					target.startedAt = undefined;
 					running -= 1;
-					currentItem = undefined;
 					deps.onSettled?.(item);
 					armIdleSweep(target);
 					wake();
@@ -325,11 +354,50 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 		}
 	}
 
+	/** One abandon notice; true when the deadline, not the transport, gave up on it. */
+	async function announce(item: PeerItem): Promise<boolean> {
+		const controller = new AbortController();
+		const cancel = armTimer(ABANDON_NOTICE_MS, () => controller.abort());
+		try {
+			await deps.send(item, deps.fallback(item, "abandoned"), { signal: controller.signal });
+			return controller.signal.aborted;
+		} catch (error) {
+			// A send the deadline cancelled rejects like any aborted request; that is the
+			// deadline's report. Anything else is the transport's own failure.
+			if (controller.signal.aborted) return true;
+			deps.notify?.(`WeChat could not tell ${item.peer} the session ended: ${messageOf(error)}`, "warning");
+			return false;
+		} finally {
+			cancel();
+		}
+	}
+
+	/**
+	 * Tell every peer that still had work that the session ended.
+	 *
+	 * One line per peer, sent after the turns have stopped and before the sessions
+	 * go. Each send carries its own deadline, so a connection that never answers
+	 * cannot hold the exit; a deadline is reported here because the deliverer keeps
+	 * an aborted send quiet — an abort is normally the peer's own `/stop`.
+	 */
+	async function announceAbandoned(items: readonly PeerItem[]): Promise<void> {
+		const gaveUp = await Promise.all(items.map((item) => announce(item)));
+		for (const [index, timedOut] of gaveUp.entries()) {
+			if (!timedOut) continue;
+			deps.notify?.(
+				`WeChat could not tell ${items[index]?.peer ?? ""} the session ended: no reply in ${ABANDON_NOTICE_MS / 1000} s.`,
+				"warning",
+			);
+		}
+	}
+
 	return {
 		enqueue(item: PeerItem): void {
 			if (closed) return;
 			const target = entry(item.peer);
 			// One message, one turn: a queued item is never folded into another.
+			arrivals += 1;
+			arrived.set(item, arrivals);
 			target.queue.push(item);
 			wake();
 		},
@@ -354,8 +422,8 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 			return true;
 		},
 
-		current(): PeerItem | undefined {
-			return currentItem;
+		running(peer: string): PeerItem | undefined {
+			return peers.get(peer)?.running;
 		},
 
 		async flush(peer: string): Promise<void> {
@@ -370,8 +438,17 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 			return [...peers.keys()].map((peer) => ({ peer, state: stateOf(peer) }));
 		},
 
-		async close(): Promise<void> {
+		async close(options?: { abandon?: boolean }): Promise<void> {
 			closed = true;
+			// Captured before the teardown forgets it: a running turn and a queue that
+			// never started are both an answer the peer will not get.
+			const abandoned: PeerItem[] = [];
+			if (options?.abandon) {
+				for (const target of peers.values()) {
+					const item = target.running ?? target.queue[0];
+					if (item) abandoned.push(item);
+				}
+			}
 			pipelines.clear();
 			const runningAborts = [...peers.values()]
 				.filter((target) => target.session)
@@ -383,6 +460,7 @@ export function createPeerWorker(deps: PeerWorkerDeps): PeerWorker {
 			}
 			aborted.clear();
 			fresh.clear();
+			await announceAbandoned(abandoned);
 		},
 	};
 }

package/extensions/wechat/{presence.ts → peer/presence.ts}

@@ -9,12 +9,12 @@
  * notice is bounded to one per wait episode.
  */
 
-import type { BotCredentials } from "./types.ts";
-import type { WechatClient } from "./client.ts";
+import type { BotCredentials } from "../types.ts";
+import type { WechatClient } from "../transport/client.ts";
 import type { PeerState } from "./peer-worker.ts";
-import type { PeerLanguage } from "./format.ts";
-import { notice } from "./notices.ts";
-import { createTimerMap, type ArmTimer } from "./timer.ts";
+import type { PeerLanguage } from "../text/format.ts";
+import { notice } from "../text/notices.ts";
+import { createTimerMap, type ArmTimer } from "../timer.ts";
 
 /** How long a fetched typing ticket is reused. */
 const TYPING_TTL_MS = 5 * 60 * 1000;
@@ -44,7 +44,8 @@ export interface PresenceDeps {
 	/** Send one stock line to the peer (chunked by the bridge). */
 	send: (peer: string, contextToken: string | undefined, text: string) => Promise<unknown>;
 	/** A forwarded dialog is waiting; its own reminder covers the wait. */
-	promptPending: () => boolean;
+	/** Whether that peer is waiting on a dialog, so "still working" would be noise. */
+	promptPending: (peer: string) => boolean;
 }
 
 /** One message a notice refers to. */
@@ -180,7 +181,7 @@ export function createPresence(deps: PresenceDeps): Presence {
 			if (!isRunning(peer)) return;
 			// A turn waiting on an unanswered dialog is not "still working": the
 			// prompt itself nudges, and saying both reads as noise.
-			if (deps.promptPending()) return;
+			if (deps.promptPending(peer)) return;
 			void deps.send(peer, contextToken, notice("stillWorking", deps.languageOf(peer)));
 		});
 	}

package/extensions/wechat/{reply-pipeline.ts → peer/reply-pipeline.ts}

@@ -11,7 +11,7 @@
  * drive it.
  */
 
-import type { ArmTimer } from "./timer.ts";
+import type { ArmTimer } from "../timer.ts";
 
 export interface ReplyPipelineDeps {
 	/** Send one part to the peer. Parts arrive strictly in order. */

package/extensions/wechat/{credentials.ts → state/credentials.ts}

@@ -9,8 +9,8 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_BASE_URL } from "./client.ts";
-import type { BotCredentials, CredentialsFile } from "./types.ts";
+import { DEFAULT_BASE_URL } from "../transport/client.ts";
+import type { BotCredentials, CredentialsFile } from "../types.ts";
 
 /** The bridge's directory under the agent dir. */
 export function wechatDir(): string {

package/extensions/wechat/{state.ts → state/state.ts}

@@ -8,9 +8,10 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import type { PeerState, SeenMessage, WechatState } from "./types.ts";
+import type { BotCredentials, PeerState, SeenMessage, WechatState } from "../types.ts";
+import type { MessageTarget } from "../transport/deliver.ts";
 import { wechatDir } from "./credentials.ts";
-import { peerKey } from "./format.ts";
+import { peerKey } from "../text/format.ts";
 
 /** How long a handled message id is remembered for a replay. */
 export const SEEN_TTL_MS = 60 * 60 * 1000;
@@ -114,6 +115,17 @@ export function findPeer(state: WechatState, peer: string): PeerState | undefine
 	return state.peers[storedKey(state, peer)];
 }
 
+/**
+ * Who a proactive send goes to, and the token that carries it.
+ *
+ * Either id form may be stored: the owner id comes from the login response and the
+ * token from an inbound `from_user_id`, and they need not agree.
+ */
+export function ownerTarget(state: WechatState, account: BotCredentials): MessageTarget {
+	const peer = state.ownerId ?? account.ilinkUserId;
+	return { peer, contextToken: findPeer(state, peer)?.lastContextToken };
+}
+
 /** Whether this message id was already handled for the peer. */
 export function seenMessage(state: WechatState, peer: string, id: number): boolean {
 	const key = peerKey(peer);

package/extensions/wechat/{format.ts → text/format.ts}

@@ -3,9 +3,9 @@
  * and shorten peer ids for display. The peer-facing notices live in `notices.ts`.
  */
 
-import { stripControlChars } from "../../lib/format.ts";
-import { sanitizeFileName } from "./media.ts";
-import type { CDNMedia, MediaRef, MessageItem } from "./types.ts";
+import { stripControlChars } from "../../../lib/format.ts";
+import { sanitizeFileName } from "../transport/media.ts";
+import type { CDNMedia, MediaRef, MessageItem } from "../types.ts";
 
 /**
  * Prepare inbound WeChat text before it becomes a user turn: strip terminal

package/extensions/wechat/{notices.ts → text/notices.ts}

@@ -17,6 +17,7 @@ export type NoticeKind =
 	| "media"
 	| "unsupported"
 	| "stopped"
+	| "abandoned"
 	| "noText"
 	| "compacted"
 	| "budget"
@@ -46,6 +47,10 @@ const NOTICES: Record<NoticeKind, Record<PeerLanguage, string>> = {
 		en: "Voice without a transcript and video aren't supported — please send text or an image.",
 	},
 	stopped: { zh: "已停止。", en: "Stopped." },
+	abandoned: {
+		zh: "会话已停止，这条还没答完。恢复后再发一次即可。",
+		en: "The session stopped before this answer finished — send it again when it's back.",
+	},
 	noText: {
 		zh: "这条处理完了，但没有文字输出。",
 		en: "That turn finished without any text to send.",
@@ -71,6 +76,9 @@ const NOTICES: Record<NoticeKind, Record<PeerLanguage, string>> = {
 	},
 };
 
+/** Every kind the bridge can send, so a check over the catalogue cannot miss one. */
+export const NOTICE_KINDS = Object.keys(NOTICES) as NoticeKind[];
+
 /** Render one notice, with `{n}` replaced when a count applies. */
 export function notice(kind: NoticeKind, lang: PeerLanguage, count?: number): string {
 	const text = NOTICES[kind][lang];