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

package/extensions/wechat/{client.ts → transport/client.ts}

@@ -9,7 +9,7 @@
  */
 
 import { randomUUID } from "node:crypto";
-import { asNumber } from "../../lib/config.ts";
+import { asNumber } from "../../../lib/config.ts";
 import { mediaDownloadUrl } from "./media.ts";
 import type {
 	BotCredentials,
@@ -21,7 +21,7 @@ import type {
 	SendTypingResponse,
 	UpdatesResponse,
 	WeixinMessage,
-} from "./types.ts";
+} from "../types.ts";
 
 /** Fixed public API base used for QR login. */
 export const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
@@ -324,6 +324,30 @@ export class WechatClient {
 		};
 	}
 
+	/** `POST /ilink/bot/sendmessage` — send one image. */
+	async sendImageMessage(
+		account: BotCredentials,
+		args: { to: string; media: CDNMedia; midSize: number; aeskey: string; contextToken?: string },
+		signal?: AbortSignal,
+	): Promise<SendResponse> {
+		const url = `${account.baseUrl}/ilink/bot/sendmessage`;
+		const msg: Record<string, unknown> = {
+			from_user_id: "",
+			to_user_id: args.to,
+			client_id: randomUUID(),
+			message_type: 2,
+			message_state: 2,
+			item_list: [{ type: 2, image_item: { media: args.media, mid_size: args.midSize, aeskey: args.aeskey } }],
+		};
+		if (args.contextToken) msg.context_token = args.contextToken;
+		const data = await this.post(url, this.authHeaders(account), { msg, base_info: this.baseInfo() }, signal);
+		return {
+			ret: asNumber(data.ret),
+			errcode: asNumber(data.errcode),
+			errmsg: asString(data.errmsg),
+		};
+	}
+
 	/** `POST /ilink/bot/getconfig` — the per-user typing ticket. */
 	async getConfig(
 		account: BotCredentials,

package/extensions/wechat/{deliver.ts → transport/deliver.ts}

@@ -8,11 +8,12 @@
  * token is forgotten so the next inbound message can replace it.
  */
 
-import type { BotCredentials } from "./types.ts";
+import type { BotCredentials } from "../types.ts";
 import { isSessionExpired, rejectionOf, WechatError, type WechatClient } from "./client.ts";
-import { messageOf } from "./errors.ts";
-import { chunkText, toWechatText } from "./format.ts";
-import { sendLocalFile } from "./outbound.ts";
+import { messageOf } from "../errors.ts";
+import { chunkText, toWechatText } from "../text/format.ts";
+import { basename } from "node:path";
+import { sendLocalFile, sendLocalImage } from "./outbound.ts";
 
 /** One addressed text destination. */
 export interface MessageTarget {
@@ -59,10 +60,12 @@ 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>;
+	/** Upload and send a local image to a peer, as a picture. */
+	image(target: MessageTarget, filePath: 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). */
@@ -72,6 +75,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.
@@ -147,53 +166,98 @@ export function createDeliverer(deps: DeliveryDeps): Deliverer {
 		return delivery.ok;
 	}
 
+	/**
+	 * Send one attachment, reporting a failure the model cannot see otherwise.
+	 *
+	 * The sender reports only success, and a caller may fall back to text; without
+	 * this report the operator would never know the attachment was dropped.
+	 */
+	function media(
+		target: MessageTarget,
+		label: "file" | "image",
+		name: string,
+		send: (client: WechatClient, account: BotCredentials, signal?: AbortSignal) => Promise<boolean>,
+		signal?: AbortSignal,
+	): Promise<boolean> {
+		return serialize(target.peer, async () => {
+			const client = deps.client();
+			const account = deps.account();
+			if (!client || !account) return false;
+			const sent = await send(client, account, signal);
+			if (!sent && !signal?.aborted) {
+				deps.onSendError?.(`${label} delivery failed: ${name}`);
+				deps.notify(`WeChat ${label} delivery failed for ${name}.`, "warning");
+			}
+			if (sent) deps.onSent?.();
+			return sent;
+		});
+	}
+
 	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,
+		file(target, filePath, fileName, signal) {
+			return media(
+				target,
+				"file",
 				fileName,
+				(client, account, abortSignal) =>
+					sendLocalFile({
+						client,
+						account,
+						cdnBaseUrl: deps.cdnBaseUrl,
+						maxBytes: deps.maxMediaBytes,
+						to: target.peer,
+						contextToken: target.contextToken,
+						filePath,
+						fileName,
+						signal: abortSignal,
+					}),
 				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}`;
+		image(target, filePath, signal) {
+			return media(
+				target,
+				"image",
+				basename(filePath),
+				(client, account, abortSignal) =>
+					sendLocalImage({
+						client,
+						account,
+						cdnBaseUrl: deps.cdnBaseUrl,
+						maxBytes: deps.maxMediaBytes,
+						to: target.peer,
+						contextToken: target.contextToken,
+						filePath,
+						signal: abortSignal,
+					}),
+				signal,
+			);
+		},
+
+		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/{inbound.ts → transport/inbound.ts}

@@ -8,12 +8,12 @@
  */
 
 import type { ImageContent } from "@earendil-works/pi-ai";
-import type { BotCredentials, InboundItem } from "./types.ts";
+import type { BotCredentials, InboundItem } from "../types.ts";
 import type { WechatClient } from "./client.ts";
-import type { PeerItem } from "./peer-worker.ts";
-import { messageOf } from "./errors.ts";
+import type { PeerItem } from "../peer/peer-worker.ts";
+import { messageOf } from "../errors.ts";
 import { decodeMediaKey, decryptEcb, saveMedia, sniffImageMime } from "./media.ts";
-import { notice } from "./notices.ts";
+import { notice } from "../text/notices.ts";
 
 /** What the inbound side needs from the bridge; every value is read at call time. */
 export interface InboundDeps {
@@ -84,7 +84,7 @@ export function createInboundAdmission(deps: InboundDeps): InboundAdmission {
 					images.push({
 						type: "image",
 						data: Buffer.from(plain).toString("base64"),
-						mimeType: sniffImageMime(plain),
+						mimeType: sniffImageMime(plain) ?? "image/jpeg",
 					});
 				}
 			} catch (error) {

package/extensions/wechat/{media.ts → transport/media.ts}

@@ -10,8 +10,8 @@
 import { createCipheriv, createDecipheriv } from "node:crypto";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { stripControlChars } from "../../lib/format.ts";
-import type { CDNMedia } from "./types.ts";
+import { stripControlChars } from "../../../lib/format.ts";
+import type { CDNMedia } from "../types.ts";
 
 /** Decode a Weixin media AES key from 32 hex chars or base64 to 16 bytes. */
 export function decodeMediaKey(value: string): Buffer {
@@ -38,8 +38,14 @@ export function aesEcbPaddedSize(plaintextSize: number): number {
 	return Math.ceil((plaintextSize + 1) / 16) * 16;
 }
 
-/** Sniff a common image MIME from magic bytes; defaults to `image/jpeg`. */
-export function sniffImageMime(bytes: Uint8Array): string {
+/**
+ * The MIME a common image's magic bytes name, or `undefined` when they name none.
+ *
+ * `undefined` is what an outbound image send refuses on; the inbound attach path
+ * decides its own fallback, because a peer's photo is worth passing on even when
+ * the header is unfamiliar.
+ */
+export function sniffImageMime(bytes: Uint8Array): string | undefined {
 	if (bytes.length >= 8 && bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) {
 		return "image/png";
 	}
@@ -60,7 +66,7 @@ export function sniffImageMime(bytes: Uint8Array): string {
 	) {
 		return "image/webp";
 	}
-	return "image/jpeg";
+	return undefined;
 }
 
 /** Strip control characters and path separators, cap length, and never empty. */

package/extensions/wechat/transport/outbound.ts

@@ -0,0 +1,142 @@
+/**
+ * Outbound media: encrypt one local file and deliver it as a Weixin attachment.
+ *
+ * The flow mirrors the reference client: read the plaintext, compute its size and
+ * MD5, generate a 16-byte AES key and a file key, request the CDN upload target,
+ * upload the AES-128-ECB ciphertext, then send the item whose media reference
+ * carries the returned download parameter. The upload is one body; the item is a
+ * `type: 4` file or a `type: 2` image, and an image must sniff as one.
+ *
+ * Everything is injected, so it is tested with a fake client and a temp file.
+ */
+
+import { createHash, randomBytes } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { rejectionOf, type WechatClient } from "./client.ts";
+import { aesEcbPaddedSize, encryptEcb, sanitizeFileName, sniffImageMime, uploadUrlOf } from "./media.ts";
+import type { BotCredentials, CDNMedia } from "../types.ts";
+
+/** `UploadMediaType.FILE` from the protocol. */
+export const UPLOAD_MEDIA_TYPE_FILE = 3;
+
+/** `UploadMediaType.IMAGE` from the protocol. */
+export const UPLOAD_MEDIA_TYPE_IMAGE = 1;
+
+export interface SendLocalFileArgs {
+	client: WechatClient;
+	account: BotCredentials;
+	cdnBaseUrl: string;
+	/** Files larger than this are refused. */
+	maxBytes: number;
+	to: string;
+	contextToken?: string;
+	filePath: string;
+	/** Display name; defaults to the file's base name, sanitized. */
+	fileName?: string;
+	signal?: AbortSignal;
+	/** Random bytes for the AES key and file key; defaults to `crypto.randomBytes`. */
+	random?: (size: number) => Buffer;
+}
+
+/** One encrypted upload, with what both item shapes need to describe it. */
+interface Uploaded {
+	plain: Buffer;
+	/** Plaintext size in bytes, the `len` of a file item. */
+	rawsize: number;
+	/** Padded ciphertext size, the `mid_size` of an image item. */
+	filesize: number;
+	media: CDNMedia;
+	/** The AES key as 32 hex characters, which an image item names itself. */
+	aeskey: string;
+}
+
+/** Encrypt and upload one local file's bytes; `undefined` when it is empty or too big. */
+async function uploadLocal(args: SendLocalFileArgs, mediaType: number, plain: Buffer): Promise<Uploaded | undefined> {
+	if (plain.length === 0 || plain.length > args.maxBytes) return undefined;
+
+	const random = args.random ?? randomBytes;
+	const aesKey = random(16);
+	const filekey = random(16).toString("hex");
+	const rawsize = plain.length;
+	const rawfilemd5 = createHash("md5").update(plain).digest("hex");
+	const filesize = aesEcbPaddedSize(rawsize);
+	const aeskey = aesKey.toString("hex");
+
+	const upload = await args.client.getUploadUrl(
+		args.account,
+		{ filekey, mediaType, toUserId: args.to, rawsize, rawfilemd5, filesize, aeskey },
+		args.signal,
+	);
+
+	const downloadParam = await args.client.uploadCdn(
+		uploadUrlOf(upload, args.cdnBaseUrl, filekey),
+		encryptEcb(plain, aesKey),
+		args.signal,
+	);
+
+	// The reference encodes the hex key string as base64 (not the raw 16 bytes);
+	// the download decoder accepts either.
+	const media: CDNMedia = {
+		encrypt_query_param: downloadParam,
+		aes_key: Buffer.from(aeskey).toString("base64"),
+		encrypt_type: 1,
+	};
+	return { plain, rawsize, filesize, media, aeskey };
+}
+
+/**
+ * Upload and send a local file. Returns true when the message was accepted.
+ * Any failure (unreadable file, size cap, upload rejection) returns false rather
+ * than throwing, so the caller can fall back.
+ */
+export async function sendLocalFile(args: SendLocalFileArgs): Promise<boolean> {
+	try {
+		const uploaded = await uploadLocal(args, UPLOAD_MEDIA_TYPE_FILE, readFileSync(args.filePath));
+		if (!uploaded) return false;
+		const response = await args.client.sendFileMessage(
+			args.account,
+			{
+				to: args.to,
+				fileName: sanitizeFileName(args.fileName ?? basename(args.filePath)),
+				len: String(uploaded.rawsize),
+				media: uploaded.media,
+				contextToken: args.contextToken,
+			},
+			args.signal,
+		);
+		return rejectionOf(response) === undefined;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Upload and send a local image as a picture, not a document.
+ *
+ * A file whose bytes sniff as no image is refused before the upload, so this path
+ * cannot become a general file sender. Everything else matches
+ * {@link sendLocalFile}: false on any failure, for the caller to fall back on.
+ */
+export async function sendLocalImage(args: SendLocalFileArgs): Promise<boolean> {
+	try {
+		const plain = readFileSync(args.filePath);
+		if (sniffImageMime(plain) === undefined) return false;
+		const uploaded = await uploadLocal(args, UPLOAD_MEDIA_TYPE_IMAGE, plain);
+		if (!uploaded) return false;
+		const response = await args.client.sendImageMessage(
+			args.account,
+			{
+				to: args.to,
+				media: uploaded.media,
+				midSize: uploaded.filesize,
+				aeskey: uploaded.aeskey,
+				contextToken: args.contextToken,
+			},
+			args.signal,
+		);
+		return rejectionOf(response) === undefined;
+	} catch {
+		return false;
+	}
+}

package/extensions/wechat/{poll.ts → transport/poll.ts}

@@ -8,10 +8,10 @@
  * stops the loop.
  */
 
-import type { BotCredentials, WeixinMessage } from "./types.ts";
+import type { BotCredentials, WeixinMessage } from "../types.ts";
 import { isSessionExpired, rejectionOf, type WechatClient } from "./client.ts";
-import { messageOf } from "./errors.ts";
-import { defaultTimer } from "./timer.ts";
+import { messageOf } from "../errors.ts";
+import { defaultTimer } from "../timer.ts";
 
 const BACKOFF_MS = 2000;
 /** Poll watchdog when the server has not told us its long-poll hold yet. */

package/extensions/wechat/types.ts

@@ -6,7 +6,7 @@
  * the persisted credentials, cursor, and peer state.
  */
 
-import type { PeerLanguage } from "./format.ts";
+import type { PeerLanguage } from "./text/format.ts";
 
 /** One content item inside a message (`type` 1 = text). */
 export interface MessageItem {
@@ -68,6 +68,15 @@ export interface WeixinMessage {
 	message_id?: number;
 	from_user_id?: string;
 	to_user_id?: string;
+	/**
+	 * A group message's room, declared by the protocol as "when applicable".
+	 *
+	 * Nothing routes on it: the bridge keys a conversation by sender. The poll
+	 * probe prints it so a probe can tell whether rooms are delivered at all.
+	 */
+	group_id?: string;
+	/** The conversation the message belongs to, when the protocol supplies one. */
+	session_id?: string;
 	message_type?: number;
 	message_state?: number;
 	item_list?: MessageItem[];

package/extensions/wechat/{login-screen.ts → view/login-screen.ts}

@@ -8,10 +8,10 @@
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { type Component, visibleWidth } from "@earendil-works/pi-tui";
-import { screenFooter, screenHint } from "../../lib/tui/chrome.ts";
-import { clip } from "../../lib/tui/columns.ts";
-import { isCloseKey } from "../../lib/tui/cursor.ts";
-import { titleRule } from "../../lib/tui/rules.ts";
+import { screenFooter, screenHint } from "../../../lib/tui/chrome.ts";
+import { clip } from "../../../lib/tui/columns.ts";
+import { isCloseKey } from "../../../lib/tui/cursor.ts";
+import { titleRule } from "../../../lib/tui/rules.ts";
 
 export interface LoginViewState {
 	/** Raw `get_qrcode_status` value, or `wait` before the first poll. */

package/extensions/wechat/{status-screen.ts → view/status-screen.ts}

@@ -11,17 +11,17 @@
 
 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 { screenFooter, screenHint, type ScreenHint } from "../../lib/tui/chrome.ts";
-import { clip } from "../../lib/tui/columns.ts";
-import { formatRange, IdCursor, isCloseKey, navIntent } from "../../lib/tui/cursor.ts";
-import { SEPARATORS } from "../../lib/tui/glyphs.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";
-import { peerLabel } from "./format.ts";
-import type { BotCredentials } from "./types.ts";
+import { formatDuration, sanitizeLine } from "../../../lib/format.ts";
+import { screenFooter, screenHint, type ScreenHint } from "../../../lib/tui/chrome.ts";
+import { clip } from "../../../lib/tui/columns.ts";
+import { formatRange, IdCursor, isCloseKey, navIntent } from "../../../lib/tui/cursor.ts";
+import { SEPARATORS } from "../../../lib/tui/glyphs.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";
+import { peerLabel } from "../text/format.ts";
+import type { BotCredentials } from "../types.ts";
 
 /** User-facing connection word; the internal `BridgeState` stays running/stopped. */
 export type StatusConnection = "open" | "expired" | "paused" | "closed";
@@ -48,8 +48,8 @@ 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 };
+	/** Every waiting prompt, one per peer that was asked something. */
+	prompts: Array<{ peer: string; title: string; startedAt: number }>;
 	/** The clock the view was built with, for the prompt age. */
 	now?: number;
 }
@@ -96,13 +96,11 @@ export function statusView(
 		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,
+		prompts: (status?.prompts ?? []).map((prompt) => ({
+			peer: sanitizeLine(peerLabel(prompt.peer)),
+			title: sanitizeLine(prompt.title),
+			startedAt: prompt.startedAt,
+		})),
 		now,
 	};
 }
@@ -186,9 +184,12 @@ export function statusBody(view: StatusView, theme: Theme, width: number, select
 		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.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"));
+		if (view.prompts.length > 0) {
+			// One line per peer: with two turns running, two prompts can wait at once.
+			for (const prompt of view.prompts) {
+				const age = formatDuration(Math.max(0, (view.now ?? Date.now()) - prompt.startedAt));
+				lines.push(row(theme, target, "Prompt", `${prompt.peer} · ${prompt.title} · ${age}`, "accent"));
+			}
 		} else if (view.promptPending) {
 			lines.push(row(theme, target, "Prompt", "waiting for a reply", "accent"));
 		}
@@ -257,7 +258,8 @@ export interface StatusActions {
 	/** 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;
+	/** Withdraw the focused peer's waiting prompt. */
+	cancelPrompt(peer: string): string;
 	/** Pause or resume polling; async because it settles the poll loop first. */
 	togglePause(): string | Promise<string>;
 }
@@ -360,11 +362,14 @@ export class StatusScreenComponent implements Component {
 			return;
 		}
 		if (data === "c" || data === "C") {
-			if (!view.prompt) {
+			// Cancel the focused peer's own prompt: with two turns running, the other
+			// peer's question is not this operator's to withdraw.
+			const waiting = peer ? view.prompts.find((entry) => entry.peer === peer.label) : undefined;
+			if (!peer || !waiting) {
 				this.setFlash("No prompt waiting.");
 				return;
 			}
-			this.setFlash(this.options.actions?.cancelPrompt() ?? "Prompt cancel is unavailable.");
+			this.setFlash(this.options.actions?.cancelPrompt(peer.id ?? peer.label) ?? "Prompt cancel is unavailable.");
 			return;
 		}
 		if (data === "s" || data === "S" || data === "d" || data === "D" || data === "h" || data === "H") {

package/extensions/worktree/git.ts

@@ -355,6 +355,11 @@ export async function inspectWork(pi: ExtensionAPI, dir: string, base?: string):
 }
 
 export interface ManagedWorktree {
+	/**
+	 * Canonical path, resolved through symlinks by `listManagedWorktrees`. Every
+	 * caller takes that as given: re-resolving it here would repeat a sync ancestor
+	 * walk the listing already paid for, once per worktree per status read.
+	 */
 	path: string;
 	branch?: string;
 	head?: string;

package/extensions/worktree/guard.ts

@@ -15,6 +15,7 @@
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { isInside, isInsideReal, realPathOfNearest } from "../../lib/path.ts";
+import { WORKSPACE_READERS } from "../../lib/policy.ts";
 import { isShellEscapable } from "../../lib/shell.ts";
 import type { WorktreeConfig } from "./config.ts";
 
@@ -33,14 +34,11 @@ export function resolveUnder(root: string, path: string | undefined): string {
 // File tools (check 1)
 // ---------------------------------------------------------------------------
 
+/** The file tools and the one argument that carries their path. */
 const PATH_FIELD: Record<string, string> = {
-	read: "path",
-	read_doc: "path",
+	...Object.fromEntries(WORKSPACE_READERS.map((name): [string, string] => [name, "path"])),
 	write: "path",
 	edit: "path",
-	grep: "path",
-	find: "path",
-	ls: "path",
 };
 
 const WRITE_TOOLS = new Set(["write", "edit"]);