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

package/extensions/wechat/commands.ts

@@ -1,5 +1,5 @@
 /**
- * The `/wechat` command: `login`, `new`, `status`, `logout`, `help`.
+ * The `/wechat` command: `login`, `new`, `status`, `logout`, `allow`, `help`.
  *
  * The command is the operator's single entry point. `/wechat` (or `/wechat
  * status`) opens the control screen, where every action is a key; the verb
@@ -11,13 +11,23 @@
  * declines while a WeChat peer turn is running.
  */
 
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	CONFIG_DIR_NAME,
+	type ExtensionAPI,
+	type ExtensionCommandContext,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { join } from "node:path";
+import { writeConfigValue } from "../../lib/config.ts";
+import { sanitizeLine } from "../../lib/format.ts";
 import { supportsCustomUI } from "../../lib/interaction.ts";
-import type { Bridge } from "./bridge.ts";
+import { isAllowedPeer, type Bridge } from "./bridge.ts";
 import type { WechatClient } from "./client.ts";
 import type { WechatConfig } from "./config.ts";
+import { doctorReport } from "./doctor.ts";
 import { peerLabel, peerKey } from "./format.ts";
-import { defaultSleep, waitForLogin, type LoginOutcome } from "./login.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 { statusLine, statusView, StatusScreenComponent, type StatusAction, type StatusView } from "./status-screen.ts";
@@ -30,6 +40,8 @@ export interface CommandDeps {
 	createLoginClient: (cwd: string) => WechatClient;
 	saveAccount: (account: BotCredentials) => void;
 	primaryAccount: () => BotCredentials | undefined;
+	/** Read a peer's recent messages for `/wechat history`; read-only. */
+	readHistory: (peer: string, count: number) => Promise<string>;
 	logout: () => void;
 	now: () => number;
 }
@@ -49,8 +61,11 @@ export const WECHAT_COMMANDS = [
 	{ verb: "login", description: "Log in by QR; on a scan, store the account and start the bridge" },
 	{ verb: "new", description: "Start a fresh host session (peer conversations are independent)" },
 	{ verb: "status", description: "Open the control screen (a one-line summary outside the TUI)" },
+	{ verb: "doctor", description: "Print a health report: token age, last poll, lock, peers, failures" },
 	{ verb: "stop", description: "Stop one peer's running turn: /wechat stop <peer>" },
 	{ verb: "reset", description: "Start a fresh conversation for one peer: /wechat reset <peer>" },
+	{ verb: "history", description: "Print one peer's recent messages: /wechat history <peer> [n]" },
+	{ verb: "allow", description: "Allow a refused sender in the project config: /wechat allow [peer]" },
 	{ verb: "logout", description: "Clear the stored account and stop the bridge" },
 	{ verb: "help", description: "List these commands" },
 ] as const satisfies readonly WechatCommand[];
@@ -74,10 +89,7 @@ export function isWechatVerb(value: string): value is WechatVerb {
 	return (WECHAT_VERBS as readonly string[]).includes(value);
 }
 
-function messageOf(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
+import { messageOf } from "./errors.ts";
 /**
  * Whether a peer turn is running anywhere on the bridge.
  *
@@ -100,6 +112,72 @@ function busyWithPeerTurn(ctx: ExtensionContext, deps: CommandDeps, verb: string
 	return true;
 }
 
+/** Print the read-only health report, in the TUI, over RPC, or in a script. */
+async function runDoctor(ctx: ExtensionContext, deps: CommandDeps): Promise<void> {
+	ctx.ui.notify(
+		doctorReport({
+			status: deps.getBridge()?.status(),
+			account: deps.primaryAccount(),
+			config: deps.loadConfig(ctx.cwd),
+			now: deps.now(),
+		}),
+	);
+}
+
+/** Add a refused sender to the project config after the operator confirms. */
+async function runAllow(ctx: ExtensionContext, deps: CommandDeps, peerArg?: string): Promise<void> {
+	if (!ctx.hasUI) {
+		ctx.ui.notify("WeChat allow needs a confirmation dialog, which this mode has no UI for.", "warning");
+		return;
+	}
+	const candidate = peerArg?.trim() || (await chooseRefused(ctx, deps));
+	if (!candidate) return;
+	const config = deps.loadConfig(ctx.cwd);
+	if (isAllowedPeer(candidate, undefined, config.allowedPeers)) {
+		ctx.ui.notify(`${sanitizeLine(peerLabel(candidate))} is already allowed.`);
+		return;
+	}
+	const relative = join(CONFIG_DIR_NAME, "bytefly.json");
+	const label = sanitizeLine(peerLabel(candidate));
+	const confirmed = await ctx.ui.confirm(`Allow ${label}?`, `Add this sender to wechat.allowedPeers in ${relative}?`);
+	if (!confirmed) return;
+	try {
+		writeConfigValue(join(ctx.cwd, relative), "wechat", "allowedPeers", [...config.allowedPeers, candidate]);
+		ctx.ui.notify(`Saved ${label} to ${relative}. Run /reload or restart Pi to apply.`);
+	} catch (error) {
+		ctx.ui.notify(`Could not save the allowlist: ${messageOf(error)}`, "error");
+	}
+}
+
+/** Pick one of the refused senders, or explain that there is nothing to allow. */
+async function chooseRefused(ctx: ExtensionContext, deps: CommandDeps): Promise<string | undefined> {
+	const refused = deps.getBridge()?.status().refusedPeers ?? [];
+	if (refused.length === 0) {
+		ctx.ui.notify("No refused sender to allow.", "warning");
+		return undefined;
+	}
+	return ctx.ui.select("Allow which sender?", refused);
+}
+
+/** Print one peer's recent messages; read-only, and works without a live session. */
+async function runHistory(ctx: ExtensionCommandContext, deps: CommandDeps, args: string): Promise<void> {
+	const [peer = "", countArg] = args.trim().split(/\s+/).filter(Boolean);
+	const bridge = deps.getBridge();
+	if (!peer) {
+		const known = bridge?.status().peerStates.map((entry) => peerLabel(entry.peer)) ?? [];
+		ctx.ui.notify(`Usage: /wechat history <peer> [n]. Known: ${known.join(", ") || "none yet"}.`, "warning");
+		return;
+	}
+	const requested = Number.parseInt(countArg ?? "", 10);
+	const count = Math.min(20, Math.max(1, Number.isFinite(requested) ? requested : 10));
+	try {
+		const text = await deps.readHistory(peer, count);
+		ctx.ui.notify(text || `No history yet for ${peerLabel(peer)}.`);
+	} catch (error) {
+		ctx.ui.notify(`WeChat history failed: ${messageOf(error)}`, "warning");
+	}
+}
+
 /**
  * React to a finished login. A confirmed scan stores the account and starts the
  * bridge immediately, so `/wechat login` is the only command needed to go
@@ -216,9 +294,37 @@ async function runPanel(ctx: ExtensionCommandContext, deps: CommandDeps): Promis
 				theme,
 				view,
 				onClose: done,
+				actions: {
+					stop: (peer) => {
+						const bridge = deps.getBridge();
+						if (!bridge) return "WeChat bridge is not running.";
+						return bridge.stop(peer) ? `Stopping ${peerLabel(peer)}.` : `${peerLabel(peer)} has no running turn.`;
+					},
+					reset: (peer) => {
+						const bridge = deps.getBridge();
+						if (!bridge) return "WeChat bridge is not running.";
+						return bridge.reset(peer)
+							? `Started a fresh conversation for ${peerLabel(peer)}.`
+							: `${peerLabel(peer)} is running; stop it before starting fresh.`;
+					},
+					cancelPrompt: () => {
+						const bridge = deps.getBridge();
+						if (!bridge?.status().promptPending) return "No prompt is waiting.";
+						bridge.channel().cancel();
+						return "Cancelled the waiting prompt.";
+					},
+				},
 				requestRender: () => tui.requestRender(),
 			}),
 	);
+	if (typeof action === "object" && action?.kind === "history") {
+		await runHistory(ctx, deps, action.peer);
+		return;
+	}
+	if (typeof action === "object" && action?.kind === "allow") {
+		await runAllow(ctx, deps);
+		return;
+	}
 	switch (action) {
 		case "login":
 		case "new":
@@ -298,6 +404,12 @@ async function dispatch(
 			return runNew(ctx, deps);
 		case "status":
 			return runPanel(ctx, deps);
+		case "doctor":
+			return runDoctor(ctx, deps);
+		case "history":
+			return runHistory(ctx, deps, peerArg);
+		case "allow":
+			return runAllow(ctx, deps, peerArg || undefined);
 		case "stop":
 			return runPeerAction(ctx, deps, "stop", peerArg);
 		case "reset":
@@ -313,7 +425,7 @@ async function dispatch(
 export function registerCommands(pi: ExtensionAPI, deps: CommandDeps): void {
 	pi.registerCommand("wechat", {
 		description:
-			"WeChat bridge. /wechat opens the control screen (login | new | status | stop | reset | logout | help)",
+			"WeChat bridge. /wechat opens the control screen (login | new | status | doctor | stop | reset | history | allow | logout | help)",
 		getArgumentCompletions: completeSubcommand,
 		handler: async (args, ctx) => {
 			const [sub = "status", ...rest] = args.trim().split(/\s+/).filter(Boolean);

package/extensions/wechat/deliver.ts

@@ -0,0 +1,207 @@
+/**
+ * Every outbound WeChat message goes through here: a reply, a dialog preface, a
+ * file, and the owner-only `send_wechat` tool.
+ *
+ * The path is shared so Markdown flattening, part numbering, session expiry,
+ * body-level rejection, and partial progress are decided once. A failure is
+ * reported once per peer until a send gets through, and the peer's stored reply
+ * token is forgotten so the next inbound message can replace it.
+ */
+
+import type { BotCredentials } from "./types.ts";
+import { isSessionExpired, WechatError, type WechatClient } from "./client.ts";
+import { messageOf } from "./errors.ts";
+import { chunkText, toWechatText } from "./format.ts";
+import { sendLocalFile } from "./outbound.ts";
+
+/** One addressed text destination. */
+export interface MessageTarget {
+	peer: string;
+	contextToken?: string;
+}
+
+/** The outcome of one outbound text delivery attempt. */
+export interface Delivery {
+	ok: boolean;
+	/** Parts the transport accepted before stopping. */
+	sent: number;
+	total: number;
+	/** The server reported an expired token; the caller has been notified. */
+	expired?: boolean;
+	/** Formatting left nothing to send. */
+	empty?: boolean;
+}
+
+/** The owner-send result shape `send_wechat` returns. */
+export interface DeliveryResult {
+	ok: boolean;
+	error?: string;
+}
+
+/** What the deliverer needs from the bridge; all state is read at call time. */
+export interface DeliveryDeps {
+	client: () => WechatClient | undefined;
+	account: () => BotCredentials | undefined;
+	maxReplyChars: () => number;
+	cdnBaseUrl: string;
+	maxMediaBytes: number;
+	notify: (message: string, kind?: "info" | "warning" | "error") => void;
+	onExpired: () => void;
+	/** Drop a peer's cached reply token. */
+	forgetToken: (peer: string) => void;
+	/** The last send failure, for the doctor/status. */
+	onSendError?: (message: string) => void;
+	/** A message got through; clear the last failure. */
+	onSent?: () => void;
+}
+
+/** The bridge's outbound surface. */
+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. */
+	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>;
+	/** Message the owner; returns the tool's result instead of logging. */
+	toOwner(owner: string, contextToken: string | undefined, text: string, signal?: AbortSignal): Promise<DeliveryResult>;
+	/** Forget the one-notice-per-outage state (a new connection). */
+	reset(): void;
+}
+
+export function createDeliverer(deps: DeliveryDeps): Deliverer {
+	/** Peers already reported as unable to receive, until a send gets through. */
+	const failureNotified = new Set<string>();
+
+	/**
+	 * Send `text` in `maxReplyChars` chunks, stopping at the first failed chunk.
+	 * A session expiry is handled here; a transport or rejection error is handed to
+	 * `onFailure` with how much went out, so each caller reports it its own way.
+	 */
+	async function deliverText(
+		to: string,
+		contextToken: string | undefined,
+		text: string,
+		signal: AbortSignal | undefined,
+		onFailure: (error: unknown, progress: { sent: number; total: number }) => void,
+	): Promise<Delivery> {
+		const client = deps.client();
+		const account = deps.account();
+		if (!client || !account) return { ok: false, sent: 0, total: 0 };
+		const chunks = chunkText(toWechatText(text), deps.maxReplyChars()).filter((chunk) => chunk !== "");
+		if (chunks.length === 0) {
+			deps.notify("WeChat message had nothing to send after formatting.", "warning");
+			return { ok: false, sent: 0, total: 0, empty: true };
+		}
+		for (const [index, chunk] of chunks.entries()) {
+			// A split answer says so, so the peer knows more is coming and can tell a
+			// truncated reply from a complete one.
+			const body = chunks.length > 1 ? `[${index + 1}/${chunks.length}] ${chunk}` : chunk;
+			try {
+				const response = await client.sendMessage(account, { to, text: body, contextToken }, signal);
+				if (isSessionExpired(response)) {
+					deps.onExpired();
+					return { ok: false, sent: index, total: chunks.length, expired: true };
+				}
+				// A body-level rejection is not a delivery: report it with the part count
+				// instead of letting the answer vanish.
+				if ((response.ret ?? 0) !== 0 || (response.errcode ?? 0) !== 0) {
+					// Prefer the non-zero value: the body may carry `ret: 0` plus a real
+					// `errcode`, and reporting `ret 0` hides the actual reason.
+					const code = (response.ret ?? 0) !== 0 ? response.ret : (response.errcode ?? 0);
+					// The server's own description is the only way to tell a bad token
+					// from a rate limit, so it is part of the error.
+					const detail = response.errmsg ? `: ${response.errmsg}` : "";
+					onFailure(new WechatError(`Weixin rejected the message (ret ${code}${detail}).`), {
+						sent: index,
+						total: chunks.length,
+					});
+					return { ok: false, sent: index, total: chunks.length };
+				}
+			} catch (error) {
+				onFailure(error, { sent: index, total: chunks.length });
+				return { ok: false, sent: index, total: chunks.length };
+			}
+		}
+		return { ok: true, sent: chunks.length, total: chunks.length };
+	}
+
+	/** Report a failure once per outage, forget the token, and return the outcome. */
+	async function deliverWithNotice(
+		target: MessageTarget,
+		text: string,
+		label: "reply" | "message delivery",
+		signal: AbortSignal | undefined,
+	): Promise<boolean> {
+		let failed = false;
+		const delivery = await deliverText(target.peer, target.contextToken, text, signal, (error, progress) => {
+			failed = true;
+			if (signal?.aborted) return;
+			deps.forgetToken(target.peer);
+			if (failureNotified.has(target.peer)) return;
+			failureNotified.add(target.peer);
+			const partial = progress.total > 1 ? ` after ${progress.sent} of ${progress.total} parts were sent` : "";
+			deps.onSendError?.(messageOf(error));
+			deps.notify(`WeChat ${label} failed${partial}: ${messageOf(error)}`, "warning");
+		});
+		if (!failed && delivery.ok) {
+			failureNotified.delete(target.peer);
+			deps.onSent?.();
+		}
+		return delivery.ok;
+	}
+
+	return {
+		reply(target, text, signal) {
+			return deliverWithNotice(target, text, "reply", signal);
+		},
+
+		prompt(target, text, signal) {
+			return 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,
+			});
+			// `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}`;
+			});
+			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() {
+			failureNotified.clear();
+		},
+	};
+}

package/extensions/wechat/doctor.ts

@@ -0,0 +1,121 @@
+/**
+ * The plain-text health report behind `/wechat doctor`.
+ *
+ * It answers the operator's first question — why is the bot quiet or slow? — from
+ * facts the bridge already has: the connection, the token's age, the last poll,
+ * the poller lock, per-peer sessions, and the last send/poll failure. Pure, so
+ * the wording and the age math are unit-tested without a bridge.
+ */
+
+import { formatDuration } from "../../lib/format.ts";
+import type { BridgeStatus } from "./bridge.ts";
+import type { WechatConfig } from "./config.ts";
+import type { BotCredentials } from "./types.ts";
+import { peerLabel } from "./format.ts";
+
+export interface DoctorInput {
+	/** Undefined when the bridge has never been built in this runtime. */
+	status?: BridgeStatus;
+	account?: BotCredentials;
+	config: WechatConfig;
+	now: number;
+}
+
+const LABEL = 11;
+
+/** One `Label      value` line. */
+function row(label: string, value: string): string {
+	return `${label.padEnd(LABEL)}${value}`;
+}
+
+/** `3.2s` since `at`, or a placeholder. */
+function age(now: number, at: number | undefined): string {
+	return at === undefined ? "unknown" : `${formatDuration(Math.max(0, now - at))} ago`;
+}
+
+function connection(status: BridgeStatus | undefined, account: BotCredentials | undefined, now: number): string {
+	if (!status?.open) {
+		return status?.expired ? "expired · run /wechat login" : "closed";
+	}
+	const owner = status.owner ? peerLabel(status.owner) : "unclaimed";
+	const token = account ? `${formatDuration(Math.max(0, now - account.createdAt))} old` : "unknown age";
+	return `open · owner ${owner} · token ${token}`;
+}
+
+function poll(status: BridgeStatus | undefined, now: number): string {
+	if (!status) return "not started";
+	const last =
+		status.lastPollAt === undefined
+			? "no poll yet"
+			: `last ${formatDuration(Math.max(0, now - status.lastPollAt))} ago`;
+	const hold = status.pollHoldMs === undefined ? "server hold" : `hold ${formatDuration(status.pollHoldMs)}`;
+	const error = status.lastPollError ? ` · error: ${status.lastPollError}` : "";
+	return `${last} · ${hold}${error}`;
+}
+
+function lockLine(status: BridgeStatus | undefined, now: number): string {
+	const lock = status?.lock;
+	if (!lock) return status?.open ? "not held" : "not running";
+	return `pid ${lock.pid} · ${age(now, lock.at)}`;
+}
+
+function peers(status: BridgeStatus | undefined): string[] {
+	if (!status || status.peerStates.length === 0) return [row("Peers", "none")];
+	const running = status.peerStates.filter((entry) => entry.state.status === "running").length;
+	const lines = [row("Peers", `${status.peerStates.length} · ${running} running · ${status.queued} queued`)];
+	for (const entry of status.peerStates) {
+		const state = entry.state;
+		const what =
+			state.status === "running"
+				? `running ${formatDuration(state.runningMs ?? 0)}`
+				: state.status === "queued"
+					? `queued ${state.queued}`
+					: "idle";
+		const session = state.sessionAgeMs === undefined ? "" : ` · session ${formatDuration(state.sessionAgeMs)}`;
+		lines.push(row(`  ${peerLabel(entry.peer)}`, `${what}${session}`));
+	}
+	return lines;
+}
+
+function recent(status: BridgeStatus | undefined): string {
+	const errors = [
+		status?.lastSendError ? `send: ${status.lastSendError}` : undefined,
+		status?.lastPollError ? `poll: ${status.lastPollError}` : undefined,
+	].filter((entry): entry is string => entry !== undefined);
+	return row("Recent", errors.length > 0 ? errors.join(" · ") : "no recent failure");
+}
+
+function media(status: BridgeStatus | undefined): string {
+	const dropped = status?.mediaDropped ?? 0;
+	const refused = status?.refused ?? 0;
+	const names = status?.refusedPeers.join(", ");
+	return row(
+		"Media",
+		`${dropped} dropped · ${refused} refused${names ? ` (${names})` : ""} · ${status?.promptPending ? "prompt waiting" : "no prompt"}`,
+	);
+}
+
+function configLine(config: WechatConfig): string {
+	const overrides = Object.keys(config.peers).length;
+	const limits = config.maxTurnsPerHour > 0 ? `${config.maxTurnsPerHour} turns/h` : "no turn cap";
+	return row(
+		"Config",
+		`typing ${config.typingIndicator ? "on" : "off"} · prompts ${config.remotePrompts ? "on" : "off"} · ` +
+			`${config.allowedPeers.length} allowed · ${overrides} peer override(s) · ${limits}`,
+	);
+}
+
+/** The doctor report, one line per fact. */
+export function doctorReport(input: DoctorInput): string {
+	const { status, account, config, now } = input;
+	return [
+		"wechat — health",
+		row("Connection", connection(status, account, now)),
+		row("Poll", poll(status, now)),
+		row("Lock", lockLine(status, now)),
+		...peers(status),
+		recent(status),
+		media(status),
+		configLine(config),
+	].join("\n");
+}

package/extensions/wechat/errors.ts

@@ -0,0 +1,11 @@
+/**
+ * The one place an unknown thrown value becomes a user-facing line.
+ *
+ * Every terminal notice and tool error in the extension reports the same way, so
+ * an `Error` yields its message and anything else is stringified.
+ */
+
+/** A user-facing message for an unknown thrown value. */
+export function messageOf(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}

package/extensions/wechat/format.ts

@@ -1,6 +1,6 @@
 /**
  * Pure text helpers for the bridge: sanitize inbound text, chunk long replies,
- * shorten peer ids for display, and render the short peer-facing notices.
+ * and shorten peer ids for display. The peer-facing notices live in `notices.ts`.
  */
 
 import { stripControlChars } from "../../lib/format.ts";
@@ -82,27 +82,6 @@ export function chunkText(text: string, max: number): string[] {
 /** The language a peer is answered in. */
 export type PeerLanguage = "zh" | "en";
 
-/**
- * The notices the bridge sends on its own, outside a reply. Every one is a
- * single short line in the peer's language: WeChat pings per message, so a
- * notice has to earn its bubble.
- */
-export type NoticeKind =
-	| "ack"
-	| "busy"
-	| "stillWorking"
-	| "overflow"
-	| "media"
-	| "unsupported"
-	| "stopped"
-	| "noText"
-	| "compacted"
-	| "budget"
-	| "promptWaiting"
-	| "timeout"
-	| "failed"
-	| "newBusy";
-
 const CJK = /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/;
 
 /** The language to answer `text` in: Chinese when it contains CJK characters. */
@@ -110,56 +89,6 @@ export function peerLanguage(text: string): PeerLanguage {
 	return CJK.test(text) ? "zh" : "en";
 }
 
-const NOTICES: Record<NoticeKind, Record<PeerLanguage, string>> = {
-	ack: { zh: "收到，正在处理…", en: "Got it — working on it." },
-	busy: {
-		zh: "前面还有一条正在处理，你的消息排在后面，轮到你就回你。",
-		en: "Your message is queued behind another conversation; I'll answer as soon as it's free.",
-	},
-	stillWorking: {
-		zh: "还在处理这条，稍等一下…",
-		en: "Still working on this one — a moment…",
-	},
-	overflow: { zh: "消息有点多，稍后再发。", en: "Too many messages queued — please wait a moment." },
-	media: {
-		zh: "有 {n} 个附件没能读取，可以重发或直接说明。",
-		en: "Couldn't open {n} attachment(s) — please resend or describe it.",
-	},
-	unsupported: {
-		zh: "语音（无转写）和视频暂不支持，请发文字或图片。",
-		en: "Voice without a transcript and video aren't supported — please send text or an image.",
-	},
-	stopped: { zh: "已停止。", en: "Stopped." },
-	noText: {
-		zh: "这条处理完了，但没有文字输出。",
-		en: "That turn finished without any text to send.",
-	},
-	compacted: {
-		zh: "对话较长，上下文已压缩；更早的细节可能记不全。",
-		en: "The conversation was compacted to stay within context; earlier details may be fuzzy.",
-	},
-	budget: {
-		zh: "这一小时的消息有点多，稍后再试。",
-		en: "You've reached this hour's message limit — please try again later.",
-	},
-	promptWaiting: {
-		zh: "还在等你的回复，约 1 分钟后超时。",
-		en: "Still waiting for your reply — this expires in about a minute.",
-	},
-	timeout: { zh: "问题超时，已取消。", en: "That question timed out." },
-	failed: { zh: "处理失败，请稍后重试。", en: "Something went wrong — please try again." },
-	newBusy: {
-		zh: "正在处理当前消息，稍后再发送 /new。",
-		en: "Still working on your last message — send /new again after it finishes.",
-	},
-};
-
-/** 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];
-	return count === undefined ? text : text.replace("{n}", String(count));
-}
-
 /** Drop the `@im.wechat` suffix from a peer id for a compact label. */
 export function peerLabel(peer: string): string {
 	return peer.replace(/@im\.wechat$/i, "");