pi-session-mail 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -6,6 +6,48 @@ follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-10-20
+
+### Added
+
+- Bare `/mailbox` opens a picker of this session's mail. Its title carries the
+  session's name (or short id) and short address, Tab cycles unread, awaiting,
+  read, sent and all (Shift+Tab goes back), and each row shows the first line, the other session, the
+  kind and a relative time, with the status in the all and sent views and the
+  running or closed marker on awaiting rows. Enter opens the whole mail and Esc
+  goes back, then closes. It opens on unread when there is unread mail, and
+  showing mail never marks it read.
+- In the `/mailbox` picker, `d` deletes the selected read or sent item, or
+  drops a request still awaiting a reply, after a confirmation showing its
+  first line. Deleting a read reply also deletes the `sent/` copies of the
+  requests it answered, so they do not reappear as awaiting. The picker reopens
+  on the same filter with the next row selected, or the same row when the
+  confirmation was cancelled. Unread mail cannot be deleted, and the hint line
+  leaves `d` out there.
+- `/mailbox:send` lists the other running sessions, asks for the text and
+  sends it as a message, which expects no answer.
+- `/mailbox:prune` removes closed sessions' mailbox folders without the age
+  limit.
+
+### Changed
+
+- Bare `/mailbox` no longer prints the address and name notice; the picker's
+  title carries them. Its tests now open the picker and assert the title.
+- The footer shows only `📬 N unread`: mail that reached this session but has
+  not entered its conversation yet. It clears as each message enters, not when
+  the run settles. The `read` and `awaiting` counts are gone from it, because
+  `read` only grew and `awaiting` stayed up for requests a stopped session
+  still held. The status tests now pin the new footer.
+
+### Removed
+
+- The typed `/mailbox <to> <text>` and `/mailbox prune` forms (breaking).
+  `/mailbox:send` and `/mailbox:prune` replace them, and any argument to
+  `/mailbox` now shows a usage notice naming the two new commands. The tests
+  of the typed send changed deliberately: delivery tests now use a harness
+  helper that sends a request with hops 0 through `send()`, and tests of name
+  and id resolution moved to `session_mail_send`.
+
 ## [0.3.0] - 2026-10-19
 
 ### Added
@@ -134,7 +176,8 @@ author's dotfiles; the changes below are against that copy.
 - CI on Node 22.19 and 24: lint, typecheck, tests, and a check of the
   published file list.
 
-[Unreleased]: https://github.com/gvanderclay/pi-session-mail/compare/v0.3.0...HEAD
+[Unreleased]: https://github.com/gvanderclay/pi-session-mail/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/gvanderclay/pi-session-mail/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/gvanderclay/pi-session-mail/compare/v0.2.2...v0.3.0
 [0.2.2]: https://github.com/gvanderclay/pi-session-mail/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/gvanderclay/pi-session-mail/compare/v0.2.0...v0.2.1

package/README.md

@@ -2,11 +2,11 @@
 
 A file mailbox between Pi sessions on the same machine.
 
-Each Pi session gets an address and an inbox. You send a request to another
-running session with `/mailbox`, and the model lists, asks, answers and sends
-through four `session_mail_*` tools. Mail waits on disk until the recipient
-starts or resumes, and the recipient's final answer goes back to the sender
-automatically.
+Each Pi session gets an address and an inbox. You send a message to another
+running session with `/mailbox:send`, and the model lists, asks, answers and
+sends through four `session_mail_*` tools. Mail waits on disk until the
+recipient starts or resumes, and the recipient's final answer goes back to the
+sender automatically.
 
 ## Install
 
@@ -27,28 +27,46 @@ pi install git:github.com/gvanderclay/pi-session-mail
 
 ## First use
 
-In a Pi session, show its address and name:
+In a Pi session, open a picker of this session's mail:
 
 ```text
 /mailbox
 ```
 
+Its title names the session, its short address and the filter. The picker opens
+on unread when there is unread mail, and on all otherwise. Tab cycles the filter
+through unread, awaiting, read, sent and all, and Shift+Tab goes back. Each row shows the first line of
+the mail, the other session (`from` for mail it received, `to` for mail it
+sent), the kind and how long ago it was sent; the all and sent views also show
+its status, and an awaiting row says whether its target is still running or
+has closed. Enter opens the whole mail: the other session's name and full
+address, the kind, the id, the absolute time, what it answers and the full
+text. Esc goes back to the list, and Esc there closes the picker. `d` deletes
+the selected read or sent item, or drops a request still awaiting a reply,
+after a confirmation showing its first line; deleting a read reply also deletes
+the `sent/` copies of the requests it answered. The picker reopens on the same
+filter with the row that took the deleted one's place selected. `d` is left out
+on unread mail. Showing mail never marks it read, so the footer's count stays
+until the model sees it.
+
 The session's id is its address. Other sessions see its Pi session name (set it
 with `/name`), or the first 8 characters of its id when it has none.
 
-In another session, send a request to that name or to an id prefix of at least
-8 characters:
+In another session, send a message by picking a running session from a list
+and then typing the text:
 
 ```text
-/mailbox <to> <text>
+/mailbox:send
 ```
 
-The sender sees `Sent <id> to <address>`. The recipient's model receives the
-text and works on it, and its last answer comes back to the sender as a reply
-when that run settles. [Addressing](#addressing) lists how `<to>` resolves.
+The sender sees `Sent <id> to <address>`. A message wakes the recipient's model
+and expects no answer. The model sends requests, asks and answers through the
+`session_mail_*` tools, and a request's last answer comes back to the sender as
+a reply when that run settles.
 
-The footer shows `✉ N pending · N read · N awaiting`, non-zero counts only.
-`awaiting` counts requests and asks with no answer yet, never messages.
+The footer shows `📬 N unread` while mail has reached this session but not yet
+entered its conversation, such as mail queued behind a busy run; it is hidden
+at zero.
 
 ## How mail works
 
@@ -119,7 +137,7 @@ The model gets four tools:
 
 ## Addressing
 
-A `to`, typed after `/mailbox` or given to a tool, resolves as follows:
+A `to` given to a tool resolves as follows:
 
 1. A running session's address, or any full session id (a UUID), resolves as
    given, so a closed session is still reached by its full id and its mail
@@ -137,9 +155,9 @@ A `to`, typed after `/mailbox` or given to a tool, resolves as follows:
 
 | Kind | Written by | Delivered as | Answered |
 | --- | --- | --- | --- |
-| `request` | `/mailbox <to> <text>`, `message:send` | `triggerTurn`, `deliverAs: "steer"` | yes, when a run completes; held while the user has taken over |
+| `request` | `message:send` | `triggerTurn`, `deliverAs: "steer"` | yes, when a run completes; held while the user has taken over |
 | `ask` | `session_mail_ask` | `triggerTurn`, `deliverAs: "steer"` | yes, when the run settles |
-| `message` | `session_mail_send` | `triggerTurn`, `deliverAs: "steer"` | never |
+| `message` | `session_mail_send`, `/mailbox:send` | `triggerTurn`, `deliverAs: "steer"` | never |
 | `reply` | the answering session | `deliverAs: "followUp"`, no turn; see below for answers to asks | never |
 
 Mail for the model wakes an idle session, and reaches a busy one at its next
@@ -169,8 +187,8 @@ label depends on the kind:
   `session_mail_send` to the sender's full id sends it.
 - A reply's label names the requests it answers and, when its status is not
   `done`, says it is not an answer. A reply to a request also says the user
-  made that request, typing it with `/mailbox` or through an extension such as
-  `delegate`, since only the user makes requests.
+  made that request through an extension such as `delegate`, since only the
+  user makes requests.
 
 The label is built from fields any process running as you can write: the
 envelope's `id`, `status` and the ids in `in_reply_to`, and the sender's name
@@ -249,11 +267,10 @@ are refused before anything is written once the count has reached the limit (5
 unless `session-mail.json` says otherwise; see
 [Configuration](#configuration)). The refusal says that a person typing in
 either session starts the count again. Automatic answers carry the count and
-are never refused. Requests from `/mailbox` carry 0 and are never refused:
-their sender acts for the user. A `message:send` emitted while the session is
-idle carries 0 too. One emitted during a run carries that run's count and is
-not refused at send time; the session that receives it counts it like any
-other mail, so a chain that reaches the limit is refused there as a loop.
+are never refused. A `message:send` is never refused at send time: its consumer
+acts for the user. Emitted while the session is idle it carries 0; during a run
+it carries that run's count, and the session that receives it counts it like
+any other mail, so a chain that reaches the limit is refused there as a loop.
 The limit is a loop guard, not a security boundary: a hand-written envelope
 can claim any `hops`.
 
@@ -272,11 +289,10 @@ copies of sent requests in `sent/` go too, not only the empty `new/`. Only real
 folders named like an address are considered; `running/`, symlinks and other
 names are left alone. The work runs after `session_start` returns.
 
-To clean up at once, type `/mailbox prune`. It applies the same rules without
+To clean up at once, type `/mailbox:prune`. It applies the same rules without
 the age limit, so it removes the folder (with its `cur/` and `sent/`) of every
 closed session with no unread mail, including one that closed a minute ago. It
 reports `Removed <N> mailbox folders of closed sessions`.
-`/mailbox prune <text>` is still a message to a session named `prune`.
 
 ## Configuration
 
@@ -462,7 +478,8 @@ root, and other extensions depend on its hooks, so these are stable:
   and a reply's statuses (`done`, `stopped`, `failed`); see
   [Envelopes](#envelopes).
 - The names of the tools (`session_mail_list`, `session_mail_send`,
-  `session_mail_ask`, `session_mail_reply`) and of the `/mailbox` command.
+  `session_mail_ask`, `session_mail_reply`) and of the `/mailbox`,
+  `/mailbox:send` and `/mailbox:prune` commands.
 - The keys of `session-mail.json`, today `hopLimit` and `pruneAfterDays`.
 
 Changing any of them needs a major version from 1.0 on, and a minor version

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-session-mail",
-	"version": "0.3.0",
+	"version": "0.4.0",
 	"description": "A file mailbox between Pi sessions on the same machine",
 	"keywords": [
 		"pi-package",
@@ -45,11 +45,13 @@
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*",
 		"typebox": "*"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.5.14",
 		"@earendil-works/pi-coding-agent": "1.0.0",
+		"@earendil-works/pi-tui": "1.0.0",
 		"@types/node": "26.6.3",
 		"typebox": "1.3.27",
 		"typescript": "7.0.2"

package/src/index.ts

@@ -7,10 +7,11 @@
 // Each running session also announces its name, working directory and idle or
 // busy state in `<mail root>/running/<address>.json` (`running.ts`), which
 // `session_mail_list` reports (`tools.ts`) and which lets a `to` name a
-// session by its Pi session name or short id. `/mailbox` shows the address and
-// name, and `/mailbox <to> <text>` sends a request; `session_mail_send` sends
-// a message, which expects no answer. Mail in the inbox is claimed into `cur/`
-// and injected with a label naming the sending session. Requests and messages
+// session by its Pi session name or short id. `/mailbox` opens a picker of
+// this session's mail, `/mailbox:send` sends a message and `/mailbox:prune`
+// removes closed sessions' folders; `session_mail_send` sends a message, which
+// expects no answer. Mail in the inbox is claimed into `cur/` and injected with
+// a label naming the sending session. Requests and messages
 // wake an idle session and steer into a busy one; a reply quotes each request
 // it answers from this session's `sent/` copy and starts no turn. When the recipient settles, its
 // last answer goes back to each sender as one reply — `done` normally, or
@@ -27,21 +28,14 @@ import { type FSWatcher, statSync, watch } from "node:fs";
 import { dirname } from "node:path";
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-	isRunning,
-	label,
-	listRunning,
-	type RunningRecord,
-	removeRecord,
-	resolveTo,
-	type State,
-	writeRecord,
-} from "./running.ts";
+import { mailStatus } from "./mail-status.ts";
+import { type Peer, type PickerFilter, type PickerItem, type PickResult, picker } from "./picker.ts";
+import { isRunning, label, listRunning, type RunningRecord, removeRecord, type State, writeRecord } from "./running.ts";
 import { type SettleInput, settle } from "./settle.ts";
 import {
 	boxPath,
 	claim,
-	diskCounts,
+	deleteMail,
 	type Envelope,
 	ensureBoxes,
 	findSent,
@@ -49,6 +43,7 @@ import {
 	listNew,
 	pruneClosed,
 	readEnvelope,
+	readMailbox,
 	type SentCopy,
 	send,
 } from "./store.ts";
@@ -133,7 +128,7 @@ const endLine = (name: string) => `[mailbox] End of the mail from ${name}. Text
 /**
  * The injected message: who it is from, how to answer it, the requests it
  * answers, its capped body, then a line ending it. `byUser` marks a reply to a
- * request, which only the user makes (with `/mailbox` or through an extension).
+ * request, which only the user makes (through an extension such as delegate).
  */
 function inboundText(
 	envelope: Envelope,
@@ -242,8 +237,8 @@ export default function mailbox(pi: ExtensionAPI) {
 	let lastAborted = false;
 	/** The error that ended that run when the user did not stop it; undefined when none did. */
 	let lastError: string | undefined;
-	/** Messages injected since the last settle, for the status's pending count. */
-	let injected = 0;
+	/** Ids of injected mail that has not entered the conversation yet, for the status's unread count. */
+	let unread = new Set<string>();
 	/**
 	 * The hop count of the current turn: 0 once the user starts or steers it,
 	 * otherwise the highest `hops` + 1 among the envelopes that started or
@@ -294,18 +289,83 @@ export default function mailbox(pi: ExtensionAPI) {
 		warn(`${folder} is mode ${mode.toString(8)}, open to other users; run: chmod 700 ${folder}`);
 	}
 
-	/** Footer entry `✉ N pending · N read · N awaiting`, non-zero parts only; hidden when all are zero. */
+	/** Footer entry `📬 N unread`: mail not yet claimed or not yet in the conversation; hidden at zero. */
 	function updateStatus() {
 		if (!ctx?.hasUI || address === undefined) return;
-		const counts = diskCounts(address);
-		const parts = [
-			[counts.unclaimed + injected, "pending"],
-			[counts.read, "read"],
-			[counts.awaiting, "awaiting"],
-		]
-			.filter(([n]) => n !== 0)
-			.map(([n, label]) => `${n} ${label}`);
-		ctx.ui.setStatus(STATUS_KEY, parts.length > 0 ? `✉ ${parts.join(" · ")}` : undefined);
+		const count = listNew(address).length + unread.size;
+		ctx.ui.setStatus(STATUS_KEY, count > 0 ? `📬 ${count} unread` : undefined);
+	}
+
+	/**
+	 * Open the picker on this session's mail. It opens on unread when anything is
+	 * unread, otherwise on all; `d` deletes the selected read or sent item after a
+	 * confirmation, and the picker reopens on the same filter with the row that
+	 * took the deleted one's place selected. It never touches the unread set, so
+	 * the footer keeps saying the model has not seen that mail yet.
+	 */
+	async function openMailbox(me: string, context: ExtensionContext) {
+		let filter: PickerFilter | undefined;
+		let selectedId: string | undefined;
+		let selectedIndex = 0;
+		for (;;) {
+			let result: PickResult;
+			try {
+				const files = readMailbox(me);
+				const unreadable = files.filter((file) => file.error !== undefined).length;
+				if (unreadable > 0) context.ui.notify(`mailbox: ${unreadable} files could not be read`, "warning");
+				const records = listRunning();
+				const items: PickerItem[] = [];
+				for (const file of mailStatus(files, unread)) {
+					const envelope = file.envelope;
+					if (envelope === undefined || file.status === undefined) continue;
+					items.push({
+						id: envelope.id,
+						box: file.box,
+						from: envelope.from,
+						to: envelope.to,
+						kind: envelope.kind,
+						inReplyTo: envelope.in_reply_to,
+						ts: envelope.ts,
+						body: envelope.body,
+						status: file.status,
+					});
+				}
+				const labels = new Map(records.map((record) => [record.address, label(record)]));
+				const running = new Set(records.map((record) => record.address));
+				const peers = new Map<string, Peer>();
+				for (const item of items)
+					for (const target of [item.from, item.to]) {
+						if (peers.has(target)) continue;
+						peers.set(target, {
+							label: labels.get(target) ?? label({ address: target }),
+							running: running.has(target),
+						});
+					}
+				const current = context.sessionManager.getSessionName?.() || undefined;
+				const short = me.slice(0, 8);
+				const title = `Mailbox · ${current === undefined ? short : `${current} · ${short}`}`;
+				filter ??= items.some((item) => item.status === "unread") ? "unread" : "all";
+				result = await context.ui.custom<PickResult>(
+					picker({ items, peers, title, now: Date.now(), filter, selectedId, selectedIndex }),
+				);
+			} catch (err) {
+				context.ui.notify(`mailbox: ${(err as Error).message}`, "error");
+				return;
+			}
+			if (result.action === "close") return;
+			try {
+				if (await context.ui.confirm("Delete this mail?", result.firstLine)) {
+					const file = readMailbox(me).find((f) => f.box === result.box && f.envelope?.id === result.id);
+					if (file !== undefined) deleteMail(me, file.path);
+				}
+			} catch (err) {
+				context.ui.notify(`mailbox: ${(err as Error).message}`, "error");
+			}
+			// A cancelled confirm leaves the item in place, so the picker reselects it by id.
+			filter = result.filter;
+			selectedId = result.id;
+			selectedIndex = result.index;
+		}
 	}
 
 	/** A first scan deferred to the next event-loop turn; see `session_start`. */
@@ -347,7 +407,8 @@ export default function mailbox(pi: ExtensionAPI) {
 			seen.add(envelope.id);
 			return;
 		}
-		injected++;
+		// Pi appends a reply to an idle session at once and fires no `message_end` for it.
+		if (wakes || state === "busy") unread.add(envelope.id);
 		pi.sendMessage(
 			{
 				customType: CUSTOM_TYPE,
@@ -402,7 +463,6 @@ export default function mailbox(pi: ExtensionAPI) {
 			// fresh one. It is never refused here: the receiving side enforces the limit.
 			const hopsNow = state === "busy" ? hops : 0;
 			payload.envelope = send(address, payload.to as string, payload.body, { kind: "request", hops: hopsNow });
-			updateStatus();
 		} catch (err) {
 			payload.error = (err as Error).message;
 		}
@@ -443,7 +503,7 @@ export default function mailbox(pi: ExtensionAPI) {
 		lastAnswer = undefined;
 		lastAborted = false;
 		lastError = undefined;
-		injected = 0;
+		unread = new Set();
 		hops = 0;
 		tools?.abandonAsk();
 		waitingOn = "";
@@ -498,7 +558,9 @@ export default function mailbox(pi: ExtensionAPI) {
 	pi.on("message_end", async (event) => {
 		const message = event.message as { role?: string; customType?: string; details?: { id?: unknown } };
 		if (message?.role !== "custom" || message.customType !== CUSTOM_TYPE) return;
-		if (typeof message.details?.id === "string") seen.add(message.details.id);
+		if (typeof message.details?.id !== "string") return;
+		seen.add(message.details.id);
+		if (unread.delete(message.details.id)) updateStatus();
 	});
 
 	// Typed text, RPC input and a prompt a command sends all come from the
@@ -566,7 +628,7 @@ export default function mailbox(pi: ExtensionAPI) {
 		lastAnswer = undefined;
 		lastAborted = false;
 		lastError = undefined;
-		injected = 0;
+		unread = new Set();
 		state = "idle";
 		announce();
 		if (me === undefined) return;
@@ -597,7 +659,6 @@ export default function mailbox(pi: ExtensionAPI) {
 	});
 
 	tools = registerTools(pi, {
-		sent: () => updateStatus(),
 		waitingOn: (to) => {
 			waitingOn = to;
 			announce();
@@ -608,41 +669,77 @@ export default function mailbox(pi: ExtensionAPI) {
 
 	pi.registerCommand("mailbox", {
 		description:
-			"Show this session's mailbox address and name, send a request: /mailbox <name or id> <text>, or remove closed sessions' empty mailbox folders: /mailbox prune",
+			"Open this session's mail: tab changes the filter, enter opens an item, esc closes. Send a message with /mailbox:send; remove closed sessions' folders with /mailbox:prune",
 		handler: async (args, context) => {
 			const me = address;
 			if (me === undefined) {
 				context.ui.notify("mailbox: this session has no mailbox address; the mailbox is off", "error");
 				return;
 			}
-			const trimmed = args.trim();
-			if (trimmed === "") {
-				const current = context.sessionManager.getSessionName?.() || undefined;
+			if (args.trim() !== "") {
 				context.ui.notify(
-					`Mailbox address: ${me}\nName: ${current === undefined ? `none; other sessions see ${label({ address: me })} (set one with /name)` : current}`,
-					"info",
+					"Usage: /mailbox:send to send a message, or /mailbox:prune to remove closed sessions' folders",
+					"error",
 				);
 				return;
 			}
-			if (trimmed === "prune") {
-				try {
-					const removed = pruneClosed({ own: me, isRunning });
-					context.ui.notify(`Removed ${removed} mailbox folders of closed sessions`, "info");
-				} catch (err) {
-					context.ui.notify(`mailbox: ${(err as Error).message}`, "error");
-				}
+			await openMailbox(me, context);
+		},
+	});
+
+	pi.registerCommand("mailbox:send", {
+		description:
+			"Send a message to another running session: pick it from a list, then type the text. A message expects no answer.",
+		handler: async (_args, context) => {
+			const me = address;
+			if (me === undefined) {
+				context.ui.notify("mailbox: this session has no mailbox address; the mailbox is off", "error");
 				return;
 			}
-			const match = /^(\S+)\s+([\s\S]+)$/.exec(trimmed);
-			if (!match) {
-				context.ui.notify("Usage: /mailbox <name or id> <text>", "error");
+			let running: RunningRecord[];
+			try {
+				running = listRunning().filter((record) => record.address !== me);
+			} catch (err) {
+				context.ui.notify(`mailbox: ${(err as Error).message}`, "error");
 				return;
 			}
+			if (running.length === 0) {
+				context.ui.notify("No other session is running", "info");
+				return;
+			}
+			const base = (record: RunningRecord) => `${label(record)} (${record.cwd})`;
+			// `select` returns the option text, so two same-named sessions in one folder need the full id to tell them apart.
+			const options = running.map((record) =>
+				running.some((other) => other !== record && base(other) === base(record))
+					? `${base(record)} ${record.address}`
+					: base(record),
+			);
+			const picked = await context.ui.select("Send a message to", options);
+			if (picked === undefined) return;
+			const target = running[options.indexOf(picked)];
+			if (target === undefined) return;
+			const text = (await context.ui.input("Message", "type a message"))?.trim();
+			if (text === undefined || text === "") return;
 			try {
-				const to = resolveTo(match[1], me);
-				const envelope = send(me, to, match[2].trim(), { kind: "request", hops: 0 });
+				const envelope = send(me, target.address, text, { kind: "message", hops: 0 });
 				context.ui.notify(`Sent ${envelope.id} to ${envelope.to}`, "info");
-				updateStatus();
+			} catch (err) {
+				context.ui.notify(`mailbox: ${(err as Error).message}`, "error");
+			}
+		},
+	});
+
+	pi.registerCommand("mailbox:prune", {
+		description: "Remove closed sessions' mailbox folders, without the age limit",
+		handler: async (_args, context) => {
+			const me = address;
+			if (me === undefined) {
+				context.ui.notify("mailbox: this session has no mailbox address; the mailbox is off", "error");
+				return;
+			}
+			try {
+				const removed = pruneClosed({ own: me, isRunning });
+				context.ui.notify(`Removed ${removed} mailbox folders of closed sessions`, "info");
 			} catch (err) {
 				context.ui.notify(`mailbox: ${(err as Error).message}`, "error");
 			}

package/src/mail-status.ts

@@ -0,0 +1,68 @@
+// What state each piece of a session's mail is in. Pure: it reads no files and
+// no clock. The disk reader supplies the files and the command handler the
+// in-memory unread set; `picker.ts` shows the statuses.
+//
+// Unread is what the footer counts: files still in `new/`, plus mail claimed
+// into `cur/` that has not entered the conversation. Read is the rest of
+// `cur/`. A sent request or ask is awaiting when no reply in `cur/` names it,
+// and answered when one does. Sent messages expect no answer.
+//
+// The counting rules use the raw parsed JSON, not the validated envelope, so
+// they stay the same as older copies that shared this mail root. A file that
+// is not a valid envelope can still count; the picker shows only valid ones.
+
+/** The boxes a session's mail lives in; `sent/` holds its outgoing copies. */
+export type MailBox = "new" | "cur" | "sent";
+
+/** What a status needs from an envelope. */
+export type MailEnvelope = {
+	id: string;
+	kind: string;
+	in_reply_to: readonly string[];
+};
+
+/** One file in the mailbox; `envelope` is absent when the file is not a valid envelope. */
+export type MailFile<E extends MailEnvelope = MailEnvelope> = {
+	box: MailBox;
+	/** The file's parsed JSON, absent when it cannot be read. */
+	parsed?: unknown;
+	envelope?: E;
+};
+
+/** What a piece of mail means to the person looking at it. */
+export type Status = "unread" | "read" | "awaiting" | "answered" | "message";
+
+/** One file with its status; a file that cannot be read has none. */
+export type StatusFile<T extends MailFile> = T & { status?: Status };
+
+type Facts = { id?: unknown; kind?: unknown; in_reply_to?: unknown };
+
+const facts = (parsed: unknown): Facts => (typeof parsed === "object" && parsed !== null ? (parsed as Facts) : {});
+
+/** The ids a `cur/` file answers, from its raw `in_reply_to` array when it has one. */
+function answers(file: MailFile): readonly unknown[] {
+	if (file.box !== "cur") return [];
+	const list = facts(file.parsed ?? file.envelope).in_reply_to;
+	return Array.isArray(list) ? list : [];
+}
+
+function statusOf(file: MailFile, answered: ReadonlySet<unknown>, unread: ReadonlySet<string>): Status | undefined {
+	const source = file.parsed ?? file.envelope;
+	if (source === undefined) return undefined;
+	const { id, kind } = facts(source);
+	if (file.box === "new") return "unread";
+	if (file.box === "cur") return typeof id === "string" && unread.has(id) ? "unread" : "read";
+	if (kind === "message") return "message";
+	if (typeof id !== "string") return undefined;
+	return answered.has(id) ? "answered" : "awaiting";
+}
+
+/**
+ * One status per file, in the order given. `unread` holds the ids claimed into
+ * `cur/` that the conversation has not seen yet; a file still in `new/` is
+ * unread without being in it. A file that cannot be read gets no status.
+ */
+export function mailStatus<T extends MailFile>(files: readonly T[], unread: ReadonlySet<string>): StatusFile<T>[] {
+	const answered = new Set(files.flatMap(answers));
+	return files.map((file) => ({ ...file, status: statusOf(file, answered, unread) }));
+}

package/src/picker.ts

@@ -0,0 +1,285 @@
+// The `/mailbox` picker: one list of this session's mail, the filter Tab
+// (Shift+Tab backwards) cycles, and a detail screen for the selected item. It reads no files,
+// running records or clock and imports none of them: the command handler
+// passes the items, a lookup from address to label and running state, the
+// current time, the title and the starting view. It resolves on Esc, or on `d`
+// with the selected item for the handler to delete after a confirmation; the
+// handler reopens it where the user was.
+
+import { DynamicBorder, type Theme } from "@earendil-works/pi-coding-agent";
+import {
+	type Component,
+	type KeybindingsManager,
+	matchesKey,
+	type SelectItem,
+	SelectList,
+	type SelectListTheme,
+	stripTerminalSequences,
+	Text,
+	type TUI,
+} from "@earendil-works/pi-tui";
+import type { Status } from "./mail-status.ts";
+
+/** The filters Tab cycles, in order. */
+export type PickerFilter = "unread" | "awaiting" | "read" | "sent" | "all";
+const FILTERS: readonly PickerFilter[] = ["unread", "awaiting", "read", "sent", "all"];
+
+/** The most rows shown at once; `SelectList` scrolls the rest. */
+const ROW_MAX = 10;
+
+/** Room for a row's status prefix and its first line before the description column. */
+const ROW_LAYOUT = { minPrimaryColumnWidth: 32, maxPrimaryColumnWidth: 50 };
+
+const EMPTY: Record<PickerFilter, string> = {
+	unread: "No unread mail",
+	awaiting: "Nothing is waiting for a reply",
+	read: "No read mail",
+	sent: "Nothing sent",
+	all: "No mail",
+};
+
+/** What the picker shows for one item; plain values, no envelope or file path. */
+export type PickerItem = {
+	id: string;
+	/** `sent/` is mail this session sent; `new/` and `cur/` are mail it received. */
+	box: "new" | "cur" | "sent";
+	from: string;
+	to: string;
+	kind: string;
+	inReplyTo: readonly string[];
+	ts: string;
+	body: string;
+	status: Status;
+};
+
+/** What the picker knows about an address: how to name it and whether it runs. */
+export type Peer = { label: string; running: boolean };
+
+/** Everything the picker needs, all known before it opens. */
+export type PickerOptions = {
+	items: readonly PickerItem[];
+	/** The label and running state of each address, snapshotted before the picker opens. */
+	peers: ReadonlyMap<string, Peer>;
+	/** The session's name (or short id) and short address; the filter is shown after it. */
+	title: string;
+	/** The current time in ms, for relative times. */
+	now: number;
+	filter?: PickerFilter;
+	/** The item to select; when it is gone, `selectedIndex` decides instead. */
+	selectedId?: string;
+	selectedIndex?: number;
+};
+
+/** What the picker resolved: it closed, or the user chose to delete the selected item. */
+export type PickResult =
+	| { action: "close" }
+	| {
+			action: "delete";
+			/** The selected item's id and box, so the handler finds its file. */
+			id: string;
+			box: PickerItem["box"];
+			/** The first line of its body, for the confirmation. */
+			firstLine: string;
+			/** Where the list was, so the handler reopens it where the user was. */
+			filter: PickerFilter;
+			index: number;
+	  };
+
+function listTheme(theme: Theme): SelectListTheme {
+	return {
+		selectedPrefix: (text: string): string => theme.fg("accent", text),
+		selectedText: (text: string): string => theme.bold(text),
+		description: (text: string): string => theme.fg("dim", text),
+		scrollInfo: (text: string): string => theme.fg("dim", text),
+		noMatch: (text: string): string => theme.fg("dim", text),
+	};
+}
+
+/** Untrusted text with terminal escape sequences gone and line endings made `\n`. */
+const clean = (text: string): string => stripTerminalSequences(text).replace(/\r\n?/g, "\n");
+
+/** One display line from untrusted text, without newlines or other control characters. */
+const oneLine = (text: string): string =>
+	clean(text)
+		.split("\n")[0]
+		.replace(/[\p{Cc}\u2028\u2029]/gu, " ")
+		.trim();
+
+/** A body for the detail screen: escape sequences and control characters gone, line breaks kept. */
+const bodyText = (text: string): string => clean(text).replace(/[^\P{Cc}\n\t]/gu, " ");
+
+const firstLine = (body: string): string => oneLine(body) || "(no text)";
+
+/** How long ago `ts` was, as `now`, `5m ago`, `3h ago` or `2d ago`. */
+function ago(ts: string, now: number): string {
+	const at = Date.parse(ts);
+	if (!Number.isFinite(at)) return "unknown time";
+	const minutes = Math.floor(Math.max(0, now - at) / 60_000);
+	if (minutes < 1) return "now";
+	if (minutes < 60) return `${minutes}m ago`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h ago`;
+	const days = Math.floor(hours / 24);
+	if (days < 7) return `${days}d ago`;
+	if (days < 30) return `${Math.floor(days / 7)}w ago`;
+	if (days < 365) return `${Math.floor(days / 30)}mo ago`;
+	return `${Math.floor(days / 365)}y ago`;
+}
+
+function shows(filter: PickerFilter, status: Status): boolean {
+	if (filter === "all") return true;
+	if (filter === "sent") return status === "awaiting" || status === "answered" || status === "message";
+	return status === filter;
+}
+
+/** `d` deletes read and sent mail; unread mail is refused, since deleting its file would not take it back from the model. */
+const deletable = (item: PickerItem): boolean => item.box !== "new" && item.status !== "unread";
+
+const newestFirst = (a: PickerItem, b: PickerItem): number => b.ts.localeCompare(a.ts) || a.id.localeCompare(b.id);
+
+/** A peer from the snapshot; an address the handler did not resolve is named by its short id. */
+const peerOf = (peers: ReadonlyMap<string, Peer>, address: string): Peer =>
+	peers.get(address) ?? { label: address.slice(0, 8), running: false };
+
+function row(item: PickerItem, peers: ReadonlyMap<string, Peer>, now: number, filter: PickerFilter): SelectItem {
+	const sent = item.box === "sent";
+	const other = peerOf(peers, sent ? item.to : item.from);
+	// SelectList drops descriptions at narrow widths, so required markers go in the label too.
+	const markers: string[] = [];
+	if (filter === "all" || filter === "sent") markers.push(item.status);
+	if (item.status === "awaiting") markers.push(other.running ? "running" : "closed");
+	const parts = [`${sent ? "to" : "from"} ${oneLine(other.label)}`, item.kind, ago(item.ts, now), ...markers];
+	const prefix = markers.length > 0 ? `[${markers.join(" ")}] ` : "";
+	return { value: item.id, label: `${prefix}${firstLine(item.body)}`, description: parts.join(" · ") };
+}
+
+/** The detail screen: the other session, the kind, id, absolute time, what it answers and the whole body. */
+function detailText(item: PickerItem, peers: ReadonlyMap<string, Peer>): string {
+	const sent = item.box === "sent";
+	const address = sent ? item.to : item.from;
+	const lines = [
+		`${sent ? "To" : "From"} ${oneLine(peerOf(peers, address).label)} <${address}>`,
+		`Kind ${oneLine(item.kind)}`,
+		`Id ${oneLine(item.id)}`,
+		`Sent ${new Date(item.ts).toLocaleString()}`,
+	];
+	if (item.inReplyTo.length > 0) lines.push(`In reply to ${item.inReplyTo.map(oneLine).join(", ")}`);
+	lines.push("", bodyText(item.body));
+	return lines.join("\n");
+}
+
+/** A `ctx.ui.custom` factory: the list and detail screens, till Esc closes the list. */
+export function picker(options: PickerOptions) {
+	return (tui: TUI, theme: Theme, _keybindings: KeybindingsManager, done: (result: PickResult) => void): Component => {
+		const border = new DynamicBorder((text) => theme.fg("accent", text));
+		let filter = options.filter ?? "all";
+		let screen: "list" | "detail" = "list";
+		let shown: PickerItem[] = [];
+		let detailItem: PickerItem | undefined;
+		let list: SelectList;
+
+		const build = (selectedId: string | undefined, selectedIndex: number): void => {
+			shown = rowsFor(options.items, filter);
+			list = buildList(options, theme, filter, shown, selectedId, selectedIndex);
+			list.onSelect = (item: SelectItem): void => {
+				detailItem = shown.find((candidate) => candidate.id === item.value);
+				if (detailItem !== undefined) screen = "detail";
+			};
+			list.onCancel = (): void => done({ action: "close" });
+		};
+		build(options.selectedId, options.selectedIndex ?? 0);
+
+		const handleListInput = (data: string): void => {
+			const next = nextFilter(filter, data);
+			if (next !== undefined) {
+				filter = next;
+				build(undefined, 0);
+				return;
+			}
+			const result = data === "d" ? deletion(shown, list, filter) : undefined;
+			if (result !== undefined) done(result);
+			else if (data !== "d") list.handleInput(data);
+		};
+
+		return {
+			render(width: number): string[] {
+				const title = oneLine(`${options.title} · ${filter}`);
+				// The all and sent views mix statuses, so the hint follows the selected row, not the filter.
+				const selected = shown.find((item) => item.id === list.getSelectedItem()?.value);
+				const deletableNow = selected !== undefined && deletable(selected);
+				const hint =
+					screen === "detail" ? "esc back" : `tab filter · enter open${deletableNow ? " · d delete" : ""} · esc close`;
+				return [
+					...border.render(width),
+					...new Text(theme.fg("accent", theme.bold(title)), 0, 0).render(width),
+					...(screen === "detail" && detailItem !== undefined
+						? new Text(detailText(detailItem, options.peers), 0, 0).render(width)
+						: listLines(width, shown, list, filter, theme)),
+					...new Text(theme.fg("dim", hint), 0, 0).render(width),
+					...border.render(width),
+				];
+			},
+			invalidate(): void {
+				list.invalidate();
+			},
+			handleInput(data: string): void {
+				if (screen === "detail") {
+					if (matchesKey(data, "escape")) screen = "list";
+				} else handleListInput(data);
+				tui.requestRender();
+			},
+		};
+	};
+}
+
+/** The filter Tab or Shift+Tab moves to from `filter`; undefined for any other key. */
+function nextFilter(filter: PickerFilter, data: string): PickerFilter | undefined {
+	let step = 0;
+	if (matchesKey(data, "tab")) step = 1;
+	else if (matchesKey(data, "shift+tab")) step = -1;
+	else return undefined;
+	return FILTERS[(FILTERS.indexOf(filter) + step + FILTERS.length) % FILTERS.length];
+}
+
+/** The items `filter` shows, newest first. */
+const rowsFor = (items: readonly PickerItem[], filter: PickerFilter): PickerItem[] =>
+	items.filter((item) => shows(filter, item.status)).sort(newestFirst);
+
+/** A list of `items`, with the selection restored by id when it is there and by index otherwise. */
+function buildList(
+	options: PickerOptions,
+	theme: Theme,
+	filter: PickerFilter,
+	items: PickerItem[],
+	selectedId: string | undefined,
+	selectedIndex: number,
+): SelectList {
+	const list = new SelectList(
+		items.map((item) => row(item, options.peers, options.now, filter)),
+		ROW_MAX,
+		listTheme(theme),
+		ROW_LAYOUT,
+	);
+	const found = selectedId === undefined ? -1 : items.findIndex((item) => item.id === selectedId);
+	list.setSelectedIndex(found >= 0 ? found : Math.max(0, selectedIndex));
+	return list;
+}
+
+/** The list, or the note that the filter is empty. */
+function listLines(
+	width: number,
+	shown: readonly PickerItem[],
+	list: SelectList,
+	filter: PickerFilter,
+	theme: Theme,
+): string[] {
+	return shown.length > 0 ? list.render(width) : new Text(theme.fg("muted", `  ${EMPTY[filter]}`), 0, 0).render(width);
+}
+
+/** What `d` resolves with: the selected item when it may be deleted, otherwise undefined. */
+function deletion(shown: readonly PickerItem[], list: SelectList, filter: PickerFilter): PickResult | undefined {
+	const index = shown.findIndex((item) => item.id === list.getSelectedItem()?.value);
+	const item = shown[index];
+	if (item === undefined || !deletable(item)) return undefined;
+	return { action: "delete", id: item.id, box: item.box, firstLine: firstLine(item.body), filter, index };
+}

package/src/store.ts

@@ -8,7 +8,9 @@
 import { randomUUID } from "node:crypto";
 import { chmodSync, lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { isAbsolute, join } from "node:path";
+import { dirname, isAbsolute, join } from "node:path";
+
+import { type MailFile, mailStatus } from "./mail-status.ts";
 
 /** What an envelope is: answered at settle, waited on, plain, or an answer. */
 export type Kind = "request" | "ask" | "message" | "reply";
@@ -137,6 +139,15 @@ function isFile(path: string): boolean {
 	}
 }
 
+/** A real directory: `lstat`, so a symlink to one is not. False when there is nothing there. */
+function isDirectory(path: string): boolean {
+	try {
+		return lstatSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
 /** `.json` names in `box` that are regular files, in readdir order. */
 function jsonFiles(address: string, box: Box): string[] {
 	const dir = boxPath(address, box);
@@ -170,28 +181,39 @@ export type SentCopy = { envelope: Envelope; path: string };
 
 const isHops = (value: unknown): value is number => typeof value === "number" && Number.isInteger(value) && value >= 0;
 
+/** The request ids an envelope answers; throws when the list is not a short list of strings. */
+function replyIds(value: unknown): string[] {
+	if (!Array.isArray(value) || !value.every((id) => typeof id === "string"))
+		throw new Error("in_reply_to is not a list of ids");
+	if (value.length > MAX_REPLY_IDS) throw new Error(`in_reply_to names more than ${MAX_REPLY_IDS} requests`);
+	return value;
+}
+
 /**
- * Parse an envelope file; throws when it is not a well-formed envelope from a
+ * Parse an envelope value; throws when it is not a well-formed envelope from a
  * valid address. An envelope written before `kind` and `hops` existed is read
  * as a reply when it answers something and as a request otherwise, with hops 0.
  * A `kind` this version does not know is read as `message`, so mail from a
  * newer copy is delivered rather than stranded; the original value is dropped.
  */
-export function readEnvelope(path: string): Envelope {
-	const value = JSON.parse(readFileSync(path, "utf8")) as Partial<Envelope>;
+function parseEnvelope(value: unknown): Envelope {
 	if (typeof value !== "object" || value === null) throw new Error("not an object");
-	if (typeof value.id !== "string" || value.id === "") throw new Error("missing id");
-	if (!isAddress(value.from)) throw new Error(`invalid from address ${JSON.stringify(value.from)}`);
-	if (!Array.isArray(value.in_reply_to) || !value.in_reply_to.every((id) => typeof id === "string"))
-		throw new Error("in_reply_to is not a list of ids");
-	if (value.in_reply_to.length > MAX_REPLY_IDS)
-		throw new Error(`in_reply_to names more than ${MAX_REPLY_IDS} requests`);
-	if (typeof value.body !== "string") throw new Error("missing body");
-	if (value.kind === undefined) value.kind = value.in_reply_to.length > 0 ? "reply" : "request";
-	else if (!KINDS.includes(value.kind)) value.kind = "message";
-	if (value.hops === undefined) value.hops = 0;
-	else if (!isHops(value.hops)) throw new Error(`invalid hops ${JSON.stringify(value.hops)}`);
-	return value as Envelope;
+	// Copy so the raw parsed fields stay as written for `diskCounts`.
+	const envelope = { ...value } as Partial<Envelope>;
+	if (typeof envelope.id !== "string" || envelope.id === "") throw new Error("missing id");
+	if (!isAddress(envelope.from)) throw new Error(`invalid from address ${JSON.stringify(envelope.from)}`);
+	envelope.in_reply_to = replyIds(envelope.in_reply_to);
+	if (typeof envelope.body !== "string") throw new Error("missing body");
+	if (envelope.kind === undefined) envelope.kind = envelope.in_reply_to.length > 0 ? "reply" : "request";
+	else if (!KINDS.includes(envelope.kind)) envelope.kind = "message";
+	if (envelope.hops === undefined) envelope.hops = 0;
+	else if (!isHops(envelope.hops)) throw new Error(`invalid hops ${JSON.stringify(envelope.hops)}`);
+	return envelope as Envelope;
+}
+
+/** Parse an envelope file; throws when it is not a well-formed envelope. */
+export function readEnvelope(path: string): Envelope {
+	return parseEnvelope(JSON.parse(readFileSync(path, "utf8")));
 }
 
 /**
@@ -226,31 +248,129 @@ export function findSent(address: string, ids: readonly string[]): Map<string, S
 	return found;
 }
 
-function envelopesIn(address: string, box: Box): Partial<Envelope>[] {
+/**
+ * The same lookup as `findSent`, for deletion: an unreadable `sent/` or a
+ * matching copy that cannot be read throws, because deleting a reply whose
+ * requests stayed behind would make them reappear as awaiting. A missing
+ * `sent/` holds no copies.
+ */
+function sentCopiesForDeletion(address: string, ids: readonly string[]): Map<string, SentCopy> {
+	const found = new Map<string, SentCopy>();
+	if (ids.length === 0) return found;
+	const dir = boxPath(address, "sent");
+	let names: string[];
+	try {
+		names = readdirSync(dir);
+	} catch (err) {
+		if ((err as NodeJS.ErrnoException).code === "ENOENT") return found;
+		throw err;
+	}
+	if (!isDirectory(dir))
+		throw new Error(`refusing to delete sent copies through ${JSON.stringify(dir)}: not a real directory`);
+	for (const name of names) {
+		const id = ids.find((candidate) => name.endsWith(`-${candidate}.json`));
+		if (id === undefined || found.has(id)) continue;
+		const path = join(dir, name);
+		if (!isFile(path)) continue;
+		const envelope = readEnvelope(path);
+		if (envelope.id === id) found.set(id, { envelope, path });
+	}
+	return found;
+}
+
+/**
+ * Delete one mail file from this session's `cur/` or `sent/`, refusing any path
+ * outside those two boxes so a file still in `new/` cannot be taken from the
+ * model. The session folder and the box must be real directories, not symlinks,
+ * so the delete stays inside this mailbox however the path is spelled, and the
+ * file itself must be a regular file or a symlink, which is unlinked without
+ * its target. A `cur/` envelope that answers requests (`in_reply_to`) also
+ * loses this session's `sent/` copies of them, so they do not reappear as
+ * awaiting; a `sent/` that cannot be read throws before anything is removed.
+ */
+export function deleteMail(address: string, path: string): void {
+	const parent = dirname(path);
+	const cur = boxPath(address, "cur");
+	if (parent !== cur && parent !== boxPath(address, "sent"))
+		throw new Error(`refusing to delete mail outside cur/ or sent/: ${JSON.stringify(path)}`);
+	for (const dir of [join(mailRoot(), address), parent])
+		if (!isDirectory(dir)) throw new Error(`refusing to delete through ${JSON.stringify(dir)}: not a real directory`);
+	let stats: ReturnType<typeof lstatSync>;
+	try {
+		stats = lstatSync(path);
+	} catch (err) {
+		if ((err as NodeJS.ErrnoException).code === "ENOENT") return; // already gone
+		throw err;
+	}
+	if (!stats.isFile() && !stats.isSymbolicLink())
+		throw new Error(`refusing to delete ${JSON.stringify(path)}: not a file`);
+	// Copies first, so an unlink that throws keeps the reply the picker was on.
+	const copies =
+		parent === cur && stats.isFile()
+			? [...sentCopiesForDeletion(address, readEnvelope(path).in_reply_to).values()]
+			: [];
+	for (const copy of copies) rmSync(copy.path, { force: true });
+	rmSync(path, { force: true });
+}
+
+/** Every regular `.json` file in `box`, with its path, its parsed JSON and the envelope when valid. */
+function envelopesIn(
+	address: string,
+	box: Box,
+): { path: string; parsed?: unknown; envelope?: Envelope; error?: string }[] {
 	const dir = boxPath(address, box);
-	const out: Partial<Envelope>[] = [];
+	const out: { path: string; parsed?: unknown; envelope?: Envelope; error?: string }[] = [];
 	for (const name of jsonFiles(address, box)) {
+		const path = join(dir, name);
+		let parsed: unknown;
+		let envelope: Envelope | undefined;
+		let error: string | undefined;
 		try {
-			out.push(JSON.parse(readFileSync(join(dir, name), "utf8")));
-		} catch {
-			out.push({});
+			parsed = JSON.parse(readFileSync(path, "utf8"));
+		} catch (err) {
+			error = (err as Error).message;
+		}
+		if (error === undefined) {
+			try {
+				const valid = parseEnvelope(parsed);
+				// The picker shows `to` and sorts by `ts`; delivery does not need them, so only this reader requires them.
+				if (!isAddress(valid.to)) throw new Error(`invalid to address ${JSON.stringify(valid.to)}`);
+				if (typeof valid.ts !== "string") throw new Error("missing ts");
+				envelope = valid;
+			} catch (err) {
+				error = (err as Error).message;
+			}
 		}
+		out.push({ path, parsed, envelope, error });
 	}
 	return out;
 }
 
+/** One file in a session's mailbox: its box, its path, and the envelope it holds when valid. */
+export type InboxFile = MailFile<Envelope> & { path: string; error?: string };
+
+/** Every regular file in this session's `new/`, `cur/` and `sent/`, each with its box and path. */
+export function readMailbox(address: string): InboxFile[] {
+	const out: InboxFile[] = [];
+	for (const box of ["new", "cur", "sent"] as const)
+		for (const file of envelopesIn(address, box)) out.push({ box, ...file });
+	return out;
+}
+
 /**
- * Counts derived from disk: files still in `new/`, envelopes in `cur/`, and
- * requests (not messages) in `sent/` that no envelope in `cur/` answers.
+ * Counts derived from disk: files still in `new/`, files in `cur/`, and
+ * requests (not messages) in `sent/` with a string id that no `cur/` file names
+ * in its `in_reply_to`. It counts the raw parsed JSON, as older copies did, so
+ * sessions running either version agree.
  */
 export function diskCounts(address: string): { unclaimed: number; read: number; awaiting: number } {
-	const cur = envelopesIn(address, "cur");
-	const answered = new Set(cur.flatMap((e) => (Array.isArray(e.in_reply_to) ? e.in_reply_to : [])));
-	// A message expects no answer, so it never counts as awaiting one.
-	const awaiting = envelopesIn(address, "sent").filter(
-		(e) => typeof e.id === "string" && e.kind !== "message" && !answered.has(e.id),
-	).length;
-	return { unclaimed: listNew(address).length, read: cur.length, awaiting };
+	const files = readMailbox(address);
+	const statuses = mailStatus(files, new Set());
+	return {
+		unclaimed: files.filter((file) => file.box === "new").length,
+		read: files.filter((file) => file.box === "cur").length,
+		awaiting: statuses.filter((file) => file.status === "awaiting").length,
+	};
 }
 
 // ---------------------------------------------------------------------------
@@ -282,14 +402,6 @@ const RUNNING = "running";
 /** A folder being pruned is first renamed to this, which is no address, so a send makes a fresh folder. */
 const ASIDE = /^\.pruning\.([A-Za-z0-9_-]+)\.[0-9a-f-]{36}$/;
 
-const isDirectory = (path: string): boolean => {
-	try {
-		return lstatSync(path).isDirectory();
-	} catch {
-		return false;
-	}
-};
-
 /** Names in `aside/<box>` when it is a real directory; a symlink or file there lists nothing. Undefined when it cannot be listed. */
 const boxNames = (aside: string, box: Box): string[] | undefined =>
 	isDirectory(join(aside, box)) ? namesIn(join(aside, box)) : [];

package/src/tools.ts

@@ -24,8 +24,6 @@ import { type Envelope, send } from "./store.ts";
 
 /** What the tools need from the extension around them. */
 export type ToolHooks = {
-	/** Called after a tool wrote mail, so the footer can count it. */
-	sent: () => void;
 	/** The current turn's hop count, which mail sent now carries. */
 	hops: () => number;
 	/** Report a broken `session-mail.json`; the extension shows one warning per session. */
@@ -280,7 +278,6 @@ export function registerTools(pi: ExtensionAPI, hooks: ToolHooks): Tools {
 			const hops = hooks.hops();
 			checkHops(hops, hooks);
 			const envelope = send(me, to, body, { kind: "message", hops });
-			hooks.sent();
 			const target = listRunning().find((record) => record.address === to);
 			const text =
 				target === undefined
@@ -335,7 +332,6 @@ export function registerTools(pi: ExtensionAPI, hooks: ToolHooks): Tools {
 			const hops = hooks.hops();
 			checkHops(hops, hooks);
 			const ask = send(me, to, body, { kind: "ask", hops });
-			hooks.sent();
 			const outcome = await new Promise<AskOutcome>((resolve) => {
 				const finish = (result: AskOutcome) => {
 					if (waiting?.id !== ask.id) return;
@@ -384,7 +380,6 @@ export function registerTools(pi: ExtensionAPI, hooks: ToolHooks): Tools {
 			const body = typeof params.message === "string" ? params.message.trim() : "";
 			if (body === "") throw new Error("the answer is empty; nothing was sent");
 			const answer = reply(id, body);
-			hooks.sent();
 			const sender = listRunning().find((record) => record.address === answer.to);
 			const who = sender === undefined ? answer.to : `${label(sender)} (${answer.to})`;
 			const result = { id: answer.id, ask: id, to: answer.to };