@gavin-hu/my-pi-agent 0.11.1 → 0.11.3

package/extensions/wechat/presence.ts

@@ -0,0 +1,274 @@
+/**
+ * The signals a peer sees while their message waits: the typing indicator, the
+ * one delayed acknowledgement, the "still working" line, and the "queued behind
+ * another conversation" line.
+ *
+ * They are grouped here because they share the same per-peer timer bookkeeping:
+ * every entry is a cancellable timer, every one is cleared when the turn settles,
+ * and a reconnect drops all of them at once. WeChat notifies per bubble, so each
+ * notice is bounded to one per wait episode.
+ */
+
+import type { BotCredentials } from "./types.ts";
+import type { WechatClient } from "./client.ts";
+import type { PeerState } from "./peer-worker.ts";
+import type { PeerLanguage } from "./format.ts";
+import { notice } from "./notices.ts";
+import type { ArmTimer } from "./timer.ts";
+
+/** How long a fetched typing ticket is reused. */
+const TYPING_TTL_MS = 5 * 60 * 1000;
+/** How often the typing indicator is refreshed while a peer waits. */
+const TYPING_KEEPALIVE_MS = 10_000;
+/** Stop refreshing the indicator after this long; a wedged turn must not tick forever. */
+const TYPING_LIMIT_MS = 15 * 60 * 1000;
+/** Wait this long before telling a queued peer they are queued. */
+const ACK_DELAY_MS = 4000;
+/** Suppress a second acknowledgement inside this window. */
+const ACK_REPEAT_MS = 60_000;
+/** Say the running turn is still going after this long without a reply. */
+const TURN_NOTICE_MS = 30_000;
+/** Say `busy` when a message is still queued behind a running turn after this. */
+const BUSY_NOTICE_MS = 60_000;
+
+export interface PresenceDeps {
+	typingIndicator: () => boolean;
+	now: () => number;
+	armTimer: ArmTimer;
+	client: () => WechatClient | undefined;
+	account: () => BotCredentials | undefined;
+	signal: () => AbortSignal | undefined;
+	/** The peer's conversation state, for the wait decisions. */
+	statusOf: (peer: string) => PeerState["status"];
+	languageOf: (peer: string) => PeerLanguage;
+	/** 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;
+}
+
+/** One message a notice refers to. */
+export interface PresenceTarget {
+	peer: string;
+	contextToken?: string;
+}
+
+export interface Presence {
+	/** Start (or restart) the indicator and keep it alive while the peer waits. */
+	keepTyping(peer: string, contextToken: string | undefined): void;
+	/** Turn the indicator off once a turn settles. */
+	typingOff(peer: string): Promise<void>;
+	/** Stop the keep-alive for peers with nothing left to answer. */
+	pruneTyping(): void;
+	/** Stop one peer's keep-alive without touching the indicator. */
+	stopTyping(peer: string): void;
+	/** Tell a queued peer once that their message is waiting. */
+	armAck(target: PresenceTarget): void;
+	cancelAck(peer: string): void;
+	/** Say once that this turn is taking a while. */
+	armSlowNotice(peer: string, contextToken: string | undefined): void;
+	/** Say once why a message is still waiting behind another turn. */
+	armBusyNotice(peer: string, contextToken: string | undefined): void;
+	stopSlowNotice(peer: string): void;
+	stopBusyNotice(peer: string): void;
+	/** Drop every timer and cached ticket (a new connection or a shutdown). */
+	reset(): void;
+}
+
+export function createPresence(deps: PresenceDeps): Presence {
+	const typingCache = new Map<string, { ticket?: string; checkedAt: number }>();
+	/** Per-peer keep-alive cancellers for the typing indicator. */
+	const typing = new Map<string, () => void>();
+	/** Per-peer pending acknowledgement cancellers. */
+	const acks = new Map<string, () => void>();
+	/** When each peer was last acknowledged, so a chatty peer is not spammed. */
+	const ackedAt = new Map<string, number>();
+	/** Peers told that a turn is still running, until that turn ends. */
+	const busyNotified = new Set<string>();
+	/** Per-peer `busy` and `stillWorking` cancellers. */
+	const busyTimers = new Map<string, () => void>();
+	const slowTimers = new Map<string, () => void>();
+
+	const hasWork = (peer: string): boolean => deps.statusOf(peer) !== "idle";
+	const isRunning = (peer: string): boolean => deps.statusOf(peer) === "running";
+
+	/** The typing ticket for a peer, fetched on first use and cached. */
+	async function typingTicket(peer: string, contextToken: string | undefined): Promise<string | undefined> {
+		const cached = typingCache.get(peer);
+		const now = deps.now();
+		if (cached && now - cached.checkedAt < TYPING_TTL_MS) return cached.ticket;
+		const client = deps.client();
+		const account = deps.account();
+		if (!client || !account) return undefined;
+		try {
+			const response = await client.getConfig(account, { ilinkUserId: peer, contextToken }, deps.signal());
+			typingCache.set(peer, { ticket: response?.typingTicket, checkedAt: now });
+			return response?.typingTicket;
+		} catch {
+			typingCache.set(peer, { ticket: undefined, checkedAt: now });
+			return undefined;
+		}
+	}
+
+	async function typingOn(peer: string, contextToken: string | undefined): Promise<void> {
+		const client = deps.client();
+		const account = deps.account();
+		if (!deps.typingIndicator() || !client || !account) return;
+		const ticket = await typingTicket(peer, contextToken);
+		if (!ticket) return;
+		try {
+			await client.sendTyping(account, { ilinkUserId: peer, typingTicket: ticket, typing: true }, deps.signal());
+			// The peer's work may have finished while the ticket round-trip was in
+			// flight; cancel immediately so the indicator cannot get stuck on.
+			if (!hasWork(peer)) {
+				await client.sendTyping(account, { ilinkUserId: peer, typingTicket: ticket, typing: false }, deps.signal());
+			}
+		} catch {
+			// Typing is best-effort.
+		}
+	}
+
+	async function typingOff(peer: string): Promise<void> {
+		const client = deps.client();
+		const account = deps.account();
+		if (!deps.typingIndicator() || !client || !account) return;
+		const ticket = typingCache.get(peer)?.ticket;
+		if (!ticket) return;
+		try {
+			await client.sendTyping(account, { ilinkUserId: peer, typingTicket: ticket, typing: false }, deps.signal());
+		} catch {
+			// Typing is best-effort.
+		}
+	}
+
+	function stopTyping(peer: string): void {
+		const cancel = typing.get(peer);
+		if (!cancel) return;
+		typing.delete(peer);
+		cancel();
+	}
+
+	/**
+	 * Start the typing indicator for a peer and keep it alive while they wait.
+	 * The chat window is the peer's only channel, and WeChat drops the indicator
+	 * after a few seconds, so a long turn needs the refresh to look alive at all.
+	 */
+	function keepTyping(peer: string, contextToken: string | undefined): void {
+		if (!deps.typingIndicator()) return;
+		stopTyping(peer);
+		void typingOn(peer, contextToken);
+		const started = deps.now();
+		const refresh = (): void => {
+			if (!hasWork(peer) || deps.now() - started >= TYPING_LIMIT_MS) {
+				typing.delete(peer);
+				return;
+			}
+			void typingOn(peer, contextToken);
+			typing.set(peer, deps.armTimer(TYPING_KEEPALIVE_MS, refresh));
+		};
+		typing.set(peer, deps.armTimer(TYPING_KEEPALIVE_MS, refresh));
+	}
+
+	function stopSlowNotice(peer: string): void {
+		const cancel = slowTimers.get(peer);
+		if (cancel) cancel();
+		slowTimers.delete(peer);
+	}
+
+	function stopBusyNotice(peer: string): void {
+		const cancel = busyTimers.get(peer);
+		if (cancel) cancel();
+		busyTimers.delete(peer);
+		busyNotified.delete(peer);
+	}
+
+	function armSlowNotice(peer: string, contextToken: string | undefined): void {
+		stopSlowNotice(peer);
+		slowTimers.set(
+			peer,
+			deps.armTimer(TURN_NOTICE_MS, () => {
+				slowTimers.delete(peer);
+				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;
+				void deps.send(peer, contextToken, notice("stillWorking", deps.languageOf(peer)));
+			}),
+		);
+	}
+
+	function armBusyNotice(peer: string, contextToken: string | undefined): void {
+		if (busyNotified.has(peer) || busyTimers.has(peer)) return;
+		busyTimers.set(
+			peer,
+			deps.armTimer(BUSY_NOTICE_MS, () => {
+				busyTimers.delete(peer);
+				if (!hasWork(peer) || busyNotified.has(peer)) return;
+				busyNotified.add(peer);
+				void deps.send(peer, contextToken, notice("busy", deps.languageOf(peer)));
+			}),
+		);
+	}
+
+	function cancelAck(peer: string): void {
+		const cancel = acks.get(peer);
+		if (!cancel) return;
+		acks.delete(peer);
+		cancel();
+	}
+
+	/**
+	 * Tell a queued peer, once, that their message is waiting. A turn that starts
+	 * within {@link ACK_DELAY_MS} cancels this, because the typing indicator says
+	 * 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;
+		if (acks.has(target.peer)) return;
+		const last = ackedAt.get(target.peer);
+		if (last !== undefined && deps.now() - last < ACK_REPEAT_MS) return;
+		acks.set(
+			target.peer,
+			deps.armTimer(ACK_DELAY_MS, () => {
+				acks.delete(target.peer);
+				if (!hasWork(target.peer) || isRunning(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.
+				armBusyNotice(target.peer, target.contextToken);
+			}),
+		);
+	}
+
+	return {
+		keepTyping,
+		typingOff,
+		pruneTyping() {
+			for (const peer of [...typing.keys()]) {
+				if (!hasWork(peer)) stopTyping(peer);
+			}
+		},
+		armAck,
+		cancelAck,
+		armSlowNotice,
+		armBusyNotice,
+		stopSlowNotice,
+		stopBusyNotice,
+		stopTyping,
+		reset() {
+			for (const cancel of typing.values()) cancel();
+			typing.clear();
+			for (const cancel of acks.values()) cancel();
+			acks.clear();
+			for (const cancel of busyTimers.values()) cancel();
+			busyTimers.clear();
+			for (const cancel of slowTimers.values()) cancel();
+			slowTimers.clear();
+			typingCache.clear();
+			ackedAt.clear();
+			busyNotified.clear();
+		},
+	};
+}

package/extensions/wechat/slash.ts

@@ -10,7 +10,8 @@
  * Value-only: no module-level state.
  */
 
-import { notice, type PeerLanguage } from "./format.ts";
+import { type PeerLanguage } from "./format.ts";
+import { notice } from "./notices.ts";
 
 /** The two command kinds. */
 export type SlashKind = "snippet" | "action";

package/extensions/wechat/status-screen.ts

@@ -3,19 +3,20 @@
  *
  * `connectionOf`, `statusView`, `statusLine`, and `statusBody` are pure, so the
  * wording, fields, and width safety are unit-tested; `StatusScreenComponent` is
- * the TUI mounted by `runPanel`. It is the control hub: every operator action
- * (login, new session, logout) is a key here, so the user never has to remember
- * a subcommand. It shows the live connection state and closes with an action so
- * the command can run it after the screen is gone and input focus is free.
+ * the TUI mounted by `runPanel`. It is the control hub: the global keys (login,
+ * new session, logout) close the screen and dispatch, while a focused peer row
+ * can be stopped, reset, or opened in `/wechat history` without leaving the
+ * screen.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
+import { formatDuration, sanitizeLine } from "../../lib/format.ts";
 import { screenHint, type ScreenHint } from "../../lib/tui/chrome.ts";
 import { clip } from "../../lib/tui/columns.ts";
-import { isCloseKey } from "../../lib/tui/cursor.ts";
+import { formatRange, IdCursor, isCloseKey, navIntent } from "../../lib/tui/cursor.ts";
 import { SEPARATORS } from "../../lib/tui/glyphs.ts";
-import { keyValueRow } from "../../lib/tui/rows.ts";
+import { keyValueRow, listRow } from "../../lib/tui/rows.ts";
 import { titleRule } from "../../lib/tui/rules.ts";
 import { paint, type TuiRole } from "../../lib/tui/tokens.ts";
 import type { BridgeStatus } from "./bridge.ts";
@@ -25,8 +26,11 @@ import type { BotCredentials } from "./types.ts";
 /** User-facing connection word; the internal `BridgeState` stays running/stopped. */
 export type StatusConnection = "open" | "expired" | "closed";
 
-/** What the status screen closed with: an action to dispatch, or `close`. */
-export type StatusAction = "close" | "login" | "new" | "logout";
+/**
+ * What the status screen closed with: a global action, a peer history request,
+ * or `close`.
+ */
+export type StatusAction = "close" | "login" | "new" | "logout" | { kind: "history"; peer: string } | { kind: "allow" };
 
 /** The facts the status screen and the one-line summary render. */
 export interface StatusView {
@@ -44,17 +48,23 @@ export interface StatusView {
 	refusedPeers: string[];
 	mediaDropped: number;
 	promptPending: boolean;
+	/** The waiting prompt's peer, title, and start time. */
+	prompt?: { peer: string; title: string; startedAt: number };
+	/** The clock the view was built with, for the prompt age. */
+	now?: number;
 }
 
 /** One peer's line in the control screen. */
 export interface PeerRow {
+	/** The raw peer id, so an action targets the right person; falls back to `label`. */
+	id?: string;
 	label: string;
 	status: "idle" | "queued" | "running";
 	queued: number;
 	runningMs?: number;
 }
 
-/** How many peer rows the screen lists before summarising the rest. */
+/** How many peer rows the screen lists before scrolling. */
 const MAX_PEER_ROWS = 5;
 
 /** The connection word for a bridge status, or `closed` when there is none. */
@@ -63,7 +73,11 @@ export function connectionOf(status: BridgeStatus | undefined): StatusConnection
 }
 
 /** Build the view from the stored account and the live bridge status. */
-export function statusView(account: BotCredentials | undefined, status: BridgeStatus | undefined): StatusView {
+export function statusView(
+	account: BotCredentials | undefined,
+	status: BridgeStatus | undefined,
+	now: number = Date.now(),
+): StatusView {
 	return {
 		bridge: status !== undefined,
 		account: account ? peerLabel(account.ilinkUserId) : undefined,
@@ -72,6 +86,7 @@ export function statusView(account: BotCredentials | undefined, status: BridgeSt
 		peers: status?.peerCount ?? 0,
 		queued: status?.queued ?? 0,
 		peerRows: (status?.peerStates ?? []).map((entry) => ({
+			id: entry.peer,
 			label: peerLabel(entry.peer),
 			status: entry.state.status,
 			queued: entry.state.queued,
@@ -81,6 +96,14 @@ export function statusView(account: BotCredentials | undefined, status: BridgeSt
 		refusedPeers: status?.refusedPeers ?? [],
 		mediaDropped: status?.mediaDropped ?? 0,
 		promptPending: status?.promptPending ?? false,
+		prompt: status?.prompt
+			? {
+					peer: sanitizeLine(peerLabel(status.prompt.peer)),
+					title: sanitizeLine(status.prompt.title),
+					startedAt: status.prompt.startedAt,
+				}
+			: undefined,
+		now,
 	};
 }
 
@@ -140,8 +163,14 @@ function connectionRole(connection: StatusConnection): TuiRole {
 	}
 }
 
+/** The peer focus passed into the body: which row is selected and which slice shows. */
+export interface PeerSelection {
+	selectedId?: string;
+	window?: { start: number; end: number };
+}
+
 /** Rows for the status screen body, each fitted to `width`. */
-export function statusBody(view: StatusView, theme: Theme, width: number): string[] {
+export function statusBody(view: StatusView, theme: Theme, width: number, selection?: PeerSelection): string[] {
 	const target = Math.max(1, width);
 	const lines = [
 		row(theme, target, "Account", view.account ?? "not logged in", view.account ? "label" : "meta"),
@@ -153,8 +182,13 @@ export function statusBody(view: StatusView, theme: Theme, width: number): strin
 		lines.push(row(theme, target, "Queued", String(view.queued), "meta"));
 		if (view.refused > 0) lines.push(row(theme, target, "Refused", refusedValue(view), "meta"));
 		if (view.mediaDropped > 0) lines.push(row(theme, target, "Media", `${view.mediaDropped} dropped`, "meta"));
-		if (view.promptPending) lines.push(row(theme, target, "Prompt", "waiting for a reply", "accent"));
-		lines.push(...peerLines(view.peerRows, theme, target));
+		if (view.prompt) {
+			const age = formatDuration(Math.max(0, (view.now ?? Date.now()) - view.prompt.startedAt));
+			lines.push(row(theme, target, "Prompt", `${view.prompt.peer} · ${view.prompt.title} · ${age}`, "accent"));
+		} else if (view.promptPending) {
+			lines.push(row(theme, target, "Prompt", "waiting for a reply", "accent"));
+		}
+		lines.push(...peerLines(view.peerRows, theme, target, selection));
 	}
 	if (view.connection === "expired") {
 		lines.push("");
@@ -179,47 +213,98 @@ function peerValue(row: PeerRow): string {
 	return "idle";
 }
 
-/** One indented line per peer, capped, so the screen stays compact. */
-function peerLines(rows: PeerRow[], theme: Theme, width: number): string[] {
+/** One selectable line per peer, with a range row when the list is scrolled. */
+function peerLines(rows: PeerRow[], theme: Theme, width: number, selection?: PeerSelection): string[] {
 	if (rows.length === 0) return [];
-	const shown = rows.slice(0, MAX_PEER_ROWS);
-	const lines = [""];
-	for (const [index, entry] of shown.entries()) {
-		const value = peerValue(entry);
+	const start = selection?.window?.start ?? 0;
+	const end = selection?.window?.end ?? Math.min(rows.length, MAX_PEER_ROWS);
+	const shown = rows.slice(start, end);
+	const lines = ["", clip(`  ${paint(theme, "meta", "Conversations")}`, width)];
+	for (const entry of shown) {
+		const selected = selection?.selectedId !== undefined && (entry.id ?? entry.label) === selection.selectedId;
 		const role: TuiRole = entry.status === "running" ? "accent" : entry.status === "queued" ? "warn" : "meta";
-		lines.push(row(theme, width, index === 0 ? "Conversations" : "", value, role));
+		lines.push(
+			listRow(theme, width, {
+				indent: 2,
+				selected,
+				label: entry.label,
+				trailing: peerValue(entry),
+				trailingRole: role,
+			}),
+		);
 	}
-	if (rows.length > shown.length) {
+	if (selection?.window !== undefined) {
+		if (start > 0 || end < rows.length) {
+			lines.push(formatRange(theme, width, { start, end, total: rows.length }));
+		}
+	} else if (rows.length > shown.length) {
 		lines.push(clip(`  ${paint(theme, "meta", `+${rows.length - shown.length} more`)}`, width));
 	}
 	return lines;
 }
 
+/** The peer actions the screen can run without closing. */
+export interface StatusActions {
+	/** Stop the peer's running turn; returns the line to flash. */
+	stop(peer: string): string;
+	/** Start a fresh conversation for the peer; returns the line to flash. */
+	reset(peer: string): string;
+	/** Withdraw the waiting prompt; returns the line to flash. */
+	cancelPrompt(): string;
+}
+
 export interface StatusScreenOptions {
 	theme: Theme;
 	/** Live view, re-read on every render so `r` shows the current state. */
 	view: () => StatusView;
 	/** Called once when the screen closes, with the chosen action. */
 	onClose: (action: StatusAction) => void;
+	/** In-place peer actions; absent makes `s`/`d` explain that they are unavailable. */
+	actions?: StatusActions;
 	/** Repaint after a state change. */
 	requestRender: () => void;
 }
 
 /** The `/wechat` control screen: live connection facts plus every action. */
 export class StatusScreenComponent implements Component {
+	private readonly cursor = new IdCursor();
+	private flash: string | undefined;
+
 	constructor(private readonly options: StatusScreenOptions) {}
 
-	private hints(): ScreenHint[] {
-		return [
-			"Esc close",
+	/**
+	 * The focused peer, or undefined when the list is empty. Not named `focused`:
+	 * the host duck-types focusables with `"focused" in component` and writes a
+	 * boolean there, which would shadow the method.
+	 */
+	private focusedPeer(view: StatusView): PeerRow | undefined {
+		const rows = view.peerRows;
+		if (rows.length === 0) return undefined;
+		return rows[this.cursor.indexOf(rows, (row) => row.id ?? row.label)];
+	}
+
+	private setFlash(message: string | undefined): void {
+		this.flash = message;
+		this.options.requestRender();
+	}
+
+	private hints(view: StatusView): ScreenHint[] {
+		const hints: ScreenHint[] = ["Esc close"];
+		if (view.peerRows.length > 0) {
+			hints.push("j/k move", { text: "s stop", color: "accent" }, { text: "d reset", color: "warning" }, "h history");
+		}
+		hints.push(
 			{ text: "l login", color: "accent" },
 			{ text: "n new", color: "accent" },
 			{ text: "o logout", color: "error" },
 			"r refresh",
-		];
+		);
+		return hints;
 	}
 
 	handleInput(data: string): void {
+		const view = this.options.view();
+		const peer = this.focusedPeer(view);
 		if (isCloseKey(data)) {
 			this.options.onClose("close");
 			return;
@@ -236,21 +321,97 @@ export class StatusScreenComponent implements Component {
 			this.options.onClose("logout");
 			return;
 		}
-		if (data === "r" || data === "R") this.options.requestRender();
+		if (data === "r" || data === "R") {
+			this.setFlash(undefined);
+			return;
+		}
+		if (data === "a" || data === "A") {
+			this.options.onClose({ kind: "allow" });
+			return;
+		}
+		if (data === "c" || data === "C") {
+			if (!view.prompt) {
+				this.setFlash("No prompt waiting.");
+				return;
+			}
+			this.setFlash(this.options.actions?.cancelPrompt() ?? "Prompt cancel is unavailable.");
+			return;
+		}
+		if (data === "s" || data === "S" || data === "d" || data === "D" || data === "h" || data === "H") {
+			if (!peer) {
+				this.setFlash("No peer conversation yet.");
+				return;
+			}
+			const id = peer.id ?? peer.label;
+			if (data === "h" || data === "H") {
+				this.options.onClose({ kind: "history", peer: id });
+				return;
+			}
+			const actions = this.options.actions;
+			if (!actions) {
+				this.setFlash("Peer actions are unavailable here.");
+				return;
+			}
+			this.setFlash(data === "s" || data === "S" ? actions.stop(id) : actions.reset(id));
+			return;
+		}
+		const rows = view.peerRows;
+		const index = this.cursor.indexOf(rows, (row) => row.id ?? row.label);
+		switch (navIntent(data)) {
+			case "up":
+				this.select(index - 1, view);
+				return;
+			case "down":
+				this.select(index + 1, view);
+				return;
+			case "pageUp":
+				this.select(index - this.cursor.visible, view);
+				return;
+			case "pageDown":
+				this.select(index + this.cursor.visible, view);
+				return;
+			case "home":
+				this.select(0, view);
+				return;
+			case "end":
+				this.select(rows.length - 1, view);
+				return;
+		}
 	}
 
-	/** Stateless: every value is read live from `view()` on render. */
+	/** Focus the row at `index` and repaint when it moves. */
+	private select(index: number, view: StatusView): void {
+		const rows = view.peerRows;
+		if (rows.length === 0) return;
+		this.cursor.select(rows, (row) => row.id ?? row.label, index);
+		this.options.requestRender();
+	}
+
+	/** The cursor is plain state and the view is live, so there is nothing to invalidate. */
 	invalidate(): void {}
 
 	render(width: number): string[] {
 		const target = Math.max(1, width);
 		const theme = this.options.theme;
-		return [
+		const view = this.options.view();
+		const rows = view.peerRows;
+		this.cursor.visible = Math.min(MAX_PEER_ROWS, Math.max(1, rows.length));
+		this.cursor.clamp(rows, (row) => row.id ?? row.label);
+		const peer = this.focusedPeer(view);
+		if (rows.length > 0) this.cursor.ensureVisible(this.cursor.indexOf(rows, (row) => row.id ?? row.label));
+		const start = this.cursor.scroll;
+		const end = Math.min(rows.length, start + this.cursor.visible);
+		const selection: PeerSelection | undefined =
+			rows.length === 0
+				? undefined
+				: { selectedId: peer ? (peer.id ?? peer.label) : undefined, window: { start, end } };
+		const lines = [
 			titleRule(theme, target, `wechat${SEPARATORS.item}control`),
 			"",
-			...statusBody(this.options.view(), theme, target),
-			"",
-			screenHint(theme, target, this.hints()),
+			...statusBody(view, theme, target, selection),
 		];
+		if (this.flash) lines.push("", clip(`  ${paint(theme, "meta", this.flash)}`, target));
+		lines.push("", screenHint(theme, target, this.hints(view)));
+		return lines;
 	}
 }

package/extensions/wechat/timer.ts

@@ -1,10 +1,11 @@
 /**
- * The timer seam shared by the bridge and the remote-prompt channel.
+ * The timer seams shared by the bridge, the remote-prompt channel, and login.
  *
- * Both need a cancellable one-shot timer that a test can drive without waiting:
- * the bridge for the delayed acknowledgement and the typing keep-alive, the
- * channel for the prompt timeout. The default is a real `setTimeout`, `unref`'d
- * so a pending timer never holds the process open.
+ * The bridge and the channel need a cancellable one-shot timer that a test can
+ * drive without waiting (the delayed acknowledgement, the typing keep-alive, the
+ * prompt timeout); login needs an abortable sleep between polls. The defaults use
+ * a real `setTimeout`, `unref`'d for the one-shot so a pending timer never holds
+ * the process open.
  */
 
 /** Arm a one-shot timer; the returned function cancels it. */
@@ -16,3 +17,22 @@ export const defaultTimer: ArmTimer = (ms, fn) => {
 	(timer as { unref?: () => void }).unref?.();
 	return () => clearTimeout(timer);
 };
+
+/** An abortable sleep: resolves after `ms`, rejects when `signal` aborts. */
+export function defaultSleep(ms: number, signal?: AbortSignal): Promise<void> {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new Error("aborted"));
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(new Error("aborted"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gavin-hu/my-pi-agent",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "Personal Pi customizations, packaged as a Pi package: worktree isolation and rewind snapshots, question, todo, goal, plan, subagent, job, watch, web-access, file-browse, file-open, document, memory, wechat, and bytefly.",
   "keywords": [
     "pi-package",