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

package/extensions/plan/web-plan.ts

@@ -0,0 +1,150 @@
+/**
+ * The review page's plan renderer: the DOM a frame draws, thrown away and rebuilt.
+ *
+ * The seventh capability out of the review client's template literal, and the one with the
+ * most to read: it builds every block, its comment rail, and the cards under it, then puts
+ * the reader back where they were. Reads arrive through getters and mutations leave through
+ * callbacks, so the client keeps every variable it owns — `activeIndex`, the quote a click
+ * is waiting for, the observer — and this function holds only the shape of one frame.
+ *
+ * Two rules it owns, both about a repaint not stealing the reader's place:
+ *
+ * - focus is restored only when it was inside the plan to begin with, so a frame the stream
+ *   caused cannot pull the keyboard out of the page the reviewer is working in;
+ * - the active block's class is put back in place rather than by scrolling, so the arrow
+ *   keys resume where they were instead of jumping to the top.
+ */
+
+import type { ClientNode } from "../../lib/web/client-runtime.ts";
+import type { ComposerDeps } from "./web-composer.ts";
+import { blockElements, type IslandBlock, setActive } from "./web-blocks.ts";
+import type { SectionWatcher } from "./web-outline.ts";
+
+/** What `el` has to answer for a frame. Spliced beside it; declared for the checker. */
+type Build = (tag: string, className?: string, text?: string | null) => ClientNode;
+declare const el: Build;
+
+/** The quote a click on a block's control is waiting for: the reader's selection. */
+export interface PendingQuote {
+	wrap: ClientNode;
+	quote: string;
+}
+
+/** What a repaint reads, and the callbacks it changes the client's state through. */
+export interface PlanRenderDeps {
+	planEl: ClientNode | null;
+	outlineList: ClientNode | null;
+	/** The element that had focus before this frame, or null when nothing did. */
+	focused: ClientNode | null;
+	blocks(): readonly IslandBlock[];
+	annotations(): readonly { anchor: number }[];
+	activeIndex(): number;
+	setActiveIndex(index: number): void;
+	pendingQuote(): PendingQuote | null;
+	clearPendingQuote(): void;
+	/** The composer lifecycle, for the close a repaint begins with. */
+	composer(): ComposerDeps;
+	/** The block's content, from the Markdown half. */
+	renderBlock(wrap: ClientNode, block: IslandBlock): void;
+	/** The cards under one block, and the loose ones that lost their anchor. */
+	renderComments(scope: ClientNode, line: number): void;
+	renderCommentCards(scope: ClientNode, list: readonly unknown[]): void;
+	/** The text a reader selected inside a block, used as the next comment's quote. */
+	selectionIn(wrap: ClientNode): string;
+	open(wrap: ClientNode, block: IslandBlock, quote: string): void;
+	/** The facts and the header chip, repainted after the blocks. */
+	facts(): void;
+	updateState(): void;
+}
+
+/**
+ * Draw the plan, and put the reader back. Returns the section watcher it installed.
+ *
+ * The client's own zero-argument entry is `renderAll()`: it builds the frame's deps and
+ * hands them here, which is how the fragments keep calling a name that takes nothing.
+ */
+export function renderPlanFrame(
+	deps: PlanRenderDeps,
+	closePlan: () => void,
+	observe: (
+		planEl: ClientNode | null,
+		list: ClientNode | null,
+		previous: SectionWatcher | null,
+	) => SectionWatcher | null,
+	previousObserver: SectionWatcher | null,
+): SectionWatcher | null {
+	const { planEl } = deps;
+	if (!planEl) return previousObserver;
+	// Focus is only put back when it was inside this document to begin with.
+	const keepFocus = !!(deps.focused && deps.focused !== planEl && planEl.contains(deps.focused));
+	closePlan();
+	const scrollTop = planEl.scrollTop;
+	planEl.replaceChildren();
+	const anchored: Record<number, boolean> = {};
+	for (const block of deps.blocks()) {
+		if (block.kind === "blank") continue;
+		anchored[block.start] = true;
+		const wrap = el("div", "bf-block");
+		wrap.setAttribute("data-line", String(block.start));
+		wrap.setAttribute("data-kind", String(block.kind));
+		if (block.kind === "heading") wrap.id = "s-" + block.start;
+		deps.renderBlock(wrap, block);
+		const mine = deps.annotations().filter((annotation) => annotation.anchor === block.start);
+		if (mine.length > 0) wrap.classList.add("bf-block--commented");
+		const rail = el("div", "bf-block__rail");
+		const add = el("button", "bf-block__add");
+		add.type = "button";
+		add.textContent = "+";
+		add.setAttribute("aria-label", "Comment on this block");
+		add.addEventListener("click", function () {
+			// Read at click time, not at render time: a selection made after this frame is
+			// the quote the reader means.
+			const waiting = deps.pendingQuote();
+			const quoted = waiting && waiting.wrap === wrap ? waiting.quote : deps.selectionIn(wrap);
+			deps.clearPendingQuote();
+			deps.open(wrap, block, quoted);
+		});
+		rail.appendChild(add);
+		if (mine.length > 0) {
+			const badge = el("span", "bf-block__count");
+			badge.textContent = String(mine.length);
+			badge.title = mine.length === 1 ? "1 review comment" : mine.length + " review comments";
+			rail.appendChild(badge);
+		}
+		wrap.appendChild(rail);
+		wrap.addEventListener("focusin", function () {
+			const next = setActive(planEl, blockElements(planEl).indexOf(wrap));
+			if (next !== null) deps.setActiveIndex(next);
+		});
+		planEl.appendChild(wrap);
+		deps.renderComments(planEl, block.start);
+	}
+	const orphans = deps.annotations().filter((annotation) => !anchored[annotation.anchor]);
+	if (orphans.length > 0) {
+		const box = el("div", "bf-comments bf-comments--orphans");
+		const note = el("p");
+		note.textContent = "Comments not attached to a current block";
+		box.appendChild(note);
+		deps.renderCommentCards(box, orphans);
+		planEl.appendChild(box);
+	}
+	planEl.scrollTop = scrollTop;
+	// The DOM was rebuilt, so the active block's class is gone; restore it in place rather
+	// than scrolling, so the keyboard resumes where the reviewer was.
+	const activeIndex = deps.activeIndex();
+	const active = activeIndex >= 0 ? blockElements(planEl)[activeIndex] : null;
+	if (active) active.classList.add("bf-block--active");
+	// The focused element went with the old DOM, so put the tab stop back on the block's
+	// comment control: that is where adding, editing, or deleting left it.
+	if (keepFocus && active) {
+		const stop = active.querySelector(".bf-block__add");
+		if (stop) stop.focus();
+	}
+	deps.facts();
+	const observer = observe(planEl, deps.outlineList, previousObserver);
+	deps.updateState();
+	return observer;
+}
+
+/** The block renderer as source, for the client bundle. */
+export const WEB_PLAN_JS = String(renderPlanFrame);

package/extensions/plan/web-router.ts

@@ -122,7 +122,6 @@ export async function handleReviewRequest(
 	if (!parsed) return jsonError(400, "Malformed request URL.");
 	const { pathname, search } = parsed;
 
-	if (pathname === "/favicon.ico") return { status: 204, headers: { "Cache-Control": "no-store" } };
 	if (pathname === THEME_JS_PATH) return { status: 200, headers: scriptHeaders(), body: THEME_JS };
 	if (pathname === "/client.js") return { status: 200, headers: scriptHeaders(), body: REVIEW_CLIENT_JS };
 

package/extensions/plan/web-settle.ts

@@ -0,0 +1,194 @@
+/**
+ * The review page's settlement: the four ways a review ends, and the one POST they share.
+ *
+ * The eighth capability out of the review client's template literal. Every write has the
+ * same shape — POST the annotations, read the answer, report it in the status line — and
+ * what differs is whether the review settles: the owner's save and approve finish it, a
+ * reviewer's post does not (the server keeps the review open so she can keep editing), and
+ * cancel is the owner's own decision and carries no body at all.
+ *
+ * The page owns its flags, its buttons, and its stream; this module owns the rules about
+ * them, so it reads through getters and reports changes through the callbacks it is given.
+ */
+
+/** What a settlement reads of the page, and the changes it reports. */
+export interface SettleDeps {
+	/** The path a write goes to, without its query string. */
+	token(): string;
+	role(): string;
+	/** The comments this writer may write: her own when she is a reviewer, all when owner. */
+	mine(): readonly unknown[];
+	annotations(): readonly unknown[];
+	/** Whether the review has already ended, by any of the three routes. */
+	settled(): boolean;
+	setStatus(text: string, kind?: string): void;
+	/** The three buttons a conflict disables, and the fourth a close does. */
+	buttons(): {
+		approve: { disabled: boolean } | null;
+		save: { disabled: boolean } | null;
+		post: { disabled: boolean } | null;
+	};
+	/** The draft this tab's work lives in: cleared once the server has it. */
+	clearDraft(): void;
+	/** The page is no longer dirty: the server has everything this tab wrote. */
+	markClean(): void;
+	/** The server bound this reviewer's name to her link: adopt it. */
+	adoptName(name: string): void;
+	/** Put a reload button beside the controls: the page cannot recover on its own. */
+	offerReload(): void;
+	/** Record how the review ended, stop following it, and stop offering to change it. */
+	markSettled(kind: "saved" | "approved" | "closed"): void;
+	settleStream(): void;
+	lockActions(): void;
+	/** Repaint the header chip and the facts. */
+	updateState(): void;
+	/** Refuse to leave a half-written comment, saying why. */
+	confirmNoDraft(): boolean;
+	post(url: string, body: unknown): Promise<{ ok: boolean; status: number; body: unknown }>;
+	/** A body-less POST, for the close that carries nothing. */
+	send(url: string): Promise<unknown>;
+	/** What a body-less conflict says, when the server gave no sentence of its own. */
+	planMoved: string;
+}
+
+/** What a settlement reports back: the flag it set, and whether the page is finished. */
+export interface SettleResult {
+	outcome: "ok" | "conflict" | "failed";
+	reason?: string;
+}
+
+/**
+ * POST the annotations, and read the answer on both branches.
+ *
+ * A 409 disables the three write buttons and offers a reload, because the page's island is
+ * out of date and no retry from here can fix that; anything else surfaces the server's own
+ * sentence, which is why the body is parsed on both branches rather than only on success.
+ */
+export function submitAnnotations(
+	deps: SettleDeps,
+	url: string,
+	okText: string,
+	failText: string,
+	onOk: (() => void) | null,
+): Promise<SettleResult> {
+	const payload = deps.role() === "reviewer" ? deps.mine() : deps.annotations();
+	return deps
+		.post(url + "?token=" + encodeURIComponent(deps.token()), { annotations: payload })
+		.then((result) => {
+			if (result.ok) {
+				deps.markClean();
+				deps.clearDraft();
+				deps.setStatus(okText, "saved");
+				if (onOk) onOk();
+				deps.updateState();
+				// The server binds a reviewer's name to her link on the first post, so a
+				// second tab of the same link posts under the same name.
+				const body = result.body as { author?: unknown } | null;
+				if (deps.role() === "reviewer" && body && typeof body.author === "string" && body.author) {
+					deps.adoptName(body.author);
+				}
+				return { outcome: "ok" as const };
+			}
+			if (result.status === 409) {
+				const buttons = deps.buttons();
+				if (buttons.approve) buttons.approve.disabled = true;
+				if (buttons.save) buttons.save.disabled = true;
+				if (buttons.post) buttons.post.disabled = true;
+				deps.offerReload();
+				const body = result.body as { error?: unknown } | null;
+				const reason = body && typeof body.error === "string" ? body.error : deps.planMoved;
+				deps.setStatus(reason, "error");
+				return { outcome: "conflict" as const, reason };
+			}
+			const body = result.body as { error?: unknown } | null;
+			throw new Error(body && typeof body.error === "string" ? body.error : "server returned " + result.status);
+		})
+		.catch((error: { message?: string }) => {
+			const reason = failText + (error && error.message ? error.message : "");
+			deps.setStatus(reason, "error");
+			return { outcome: "failed" as const, reason };
+		});
+}
+
+/** Save the annotations and finish the review: the owner's way to close an approved plan. */
+export function saveReview(deps: SettleDeps): Promise<SettleResult> | null {
+	if (deps.settled()) return null;
+	if (deps.confirmNoDraft()) return null;
+	deps.setStatus("Saving\u2026");
+	return submitAnnotations(
+		deps,
+		"/api/feedback",
+		"Saved \u2014 return to Pi to continue.",
+		"Could not save: ",
+		function () {
+			deps.markSettled("saved");
+			deps.settleStream();
+			deps.lockActions();
+		},
+	);
+}
+
+/**
+ * Post a reviewer's comments and keep the review open.
+ *
+ * A reviewer's write never settles the page: the server keeps the review open so she can
+ * keep editing her own comments, and closing the stream here would strand her.
+ */
+export function postReviewComments(deps: SettleDeps): Promise<SettleResult> | null {
+	if (deps.settled()) return null;
+	if (deps.confirmNoDraft()) return null;
+	deps.setStatus("Posting\u2026");
+	return submitAnnotations(
+		deps,
+		"/api/comment",
+		"Comments posted \u2014 the owner sees them now.",
+		"Could not post: ",
+		null,
+	);
+}
+
+/** Approve the plan, which finishes the review. */
+export function approveReview(deps: SettleDeps): Promise<SettleResult> | null {
+	if (deps.settled()) return null;
+	deps.setStatus("Approving\u2026");
+	return submitAnnotations(
+		deps,
+		"/api/approve",
+		"Approved \u2014 return to Pi to continue.",
+		"Could not approve: ",
+		function () {
+			deps.markSettled("approved");
+			deps.settleStream();
+			deps.lockActions();
+		},
+	);
+}
+
+/**
+ * Close the review without saving: only the owner may, and the page says so while it asks.
+ *
+ * The close carries no body, so it is the one write that does not go through
+ * `submitAnnotations`; its answer is a status line either way, because a tab that closed the
+ * review has nothing left to do with a failure.
+ */
+export function cancelReview(deps: SettleDeps): Promise<void> | null {
+	if (deps.role() !== "owner" || deps.settled()) return null;
+	if (deps.confirmNoDraft()) return null;
+	deps.markSettled("closed");
+	deps.settleStream();
+	deps.lockActions();
+	deps.setStatus("Closing\u2026");
+	deps.updateState();
+	return deps
+		.send("/api/cancel?token=" + encodeURIComponent(deps.token()))
+		.catch(function () {})
+		.then(function () {
+			deps.setStatus("Closed \u2014 return to Pi.");
+			deps.updateState();
+		});
+}
+
+/** The settlement rules as source, for the client bundle. */
+export const WEB_SETTLE_JS = [submitAnnotations, saveReview, postReviewComments, approveReview, cancelReview]
+	.map(String)
+	.join("\n\n");

package/extensions/rewind/commands/review.ts

@@ -12,6 +12,7 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { messageOf } from "../../../lib/errors.ts";
 import { sanitizeLine } from "../../../lib/format.ts";
+import { planModeRefusal } from "../../../lib/plan-entry.ts";
 import { isPlanModeEnabled } from "../../../lib/plan-state.ts";
 import { withRailsSuppressed } from "../../../lib/rails.ts";
 import {
@@ -75,7 +76,7 @@ async function loadReview(runtime: RewindRuntime, ctx: ExtensionCommandContext):
 		return {
 			ok: false,
 			kind: "warning",
-			message: "Plan mode is read-only. Approve the plan before reviewing and reverting its changes.",
+			message: planModeRefusal("reviewing and reverting its changes"),
 		};
 	}
 

package/extensions/session-bus/rows.ts

@@ -15,6 +15,7 @@ import { listRow, statusRow } from "../../lib/tui/rows.ts";
 import type { TailRowLine } from "../../lib/tui/tool.ts";
 import { paint } from "../../lib/tui/tokens.ts";
 import { idSuffix } from "./format.ts";
+import type { RosterState } from "../../lib/session-roster.ts";
 import type { BusMessage, ClaimRecord, SessionRecord, SessionStatus } from "./types.ts";
 
 /** Claim paths the focus block lists before it points at the pane. */
@@ -27,7 +28,7 @@ export function count(n: number, noun: string): string {
 
 /** One session on the board, with the claims it holds. */
 export interface SessionRow {
-	session: SessionRecord & { unread: number };
+	session: SessionRecord & { unread: number; state: RosterState };
 	/** Whether this row is the session reading the board. */
 	self: boolean;
 	claims: ClaimRecord[];
@@ -69,7 +70,7 @@ export function sessionRowLine(
 	options: { selected?: boolean; marker?: boolean } = {},
 ): string {
 	const label = `${sanitizeLine(row.session.label)}${row.self ? " · you" : ""}`;
-	const counts = [`${row.session.unread} unread`];
+	const counts = [row.session.state === "gone" ? "gone" : `${row.session.unread} unread`];
 	if (row.claims.length > 0) counts.push(count(row.claims.length, "claim"));
 	return listRow(theme, width, {
 		selected: options.selected === true,
@@ -147,7 +148,9 @@ export function summaryCells(
 ): string[] {
 	const unread = rows.reduce((total, row) => total + row.session.unread, 0);
 	const claims = rows.reduce((total, row) => total + row.claims.length, 0);
+	const gone = rows.filter((row) => row.session.state === "gone").length;
 	const cells = [paint(theme, "meta", count(rows.length, "session"))];
+	if (gone > 0) cells.push(paint(theme, "bad", `${gone} gone`));
 	if (unread > 0) cells.push(paint(theme, "label", `${unread} unread`));
 	cells.push(paint(theme, "meta", count(claims, "claim")));
 	if (watching) cells.push(paint(theme, "ok", watching.wake ? "watch wake" : "watch on"));
@@ -165,7 +168,8 @@ export function sessionDetailBlock(row: SessionRow, now: number): string[] {
 	}
 	lines.push(
 		`mode: ${sanitizeLine(row.session.mode)}${SEPARATORS.item}id: ${idSuffix(row.session.id)}` +
-			`${SEPARATORS.item}last seen: ${formatDuration(Math.max(0, now - row.session.lastSeen))} ago`,
+			`${SEPARATORS.item}last seen: ${formatDuration(Math.max(0, now - row.session.lastSeen))} ago` +
+			`${row.session.state === "gone" ? `${SEPARATORS.item}process gone` : ""}`,
 	);
 	return lines;
 }

package/extensions/session-bus/runtime.ts

@@ -40,7 +40,14 @@ import {
 import { createMailWatch, type WatchingState } from "./mail-watch.ts";
 import { createBusStore, releaseClaimed, type BusStore } from "./store.ts";
 import type { BusMessage, ClaimConflict, SessionRecord, SessionStatus } from "./types.ts";
-import { BUS_DIR_NAME, SESSION_TTL_MS } from "../../lib/session-roster.ts";
+import {
+	BUS_DIR_NAME,
+	type RosterSeams,
+	type RosterState,
+	rosterStateOf,
+	SESSION_TTL_MS,
+} from "../../lib/session-roster.ts";
+import { isPidAlive, type LivenessFn, startTokenOf, type StartTokenFn } from "../../lib/spawn.ts";
 
 export interface SessionBusOptions {
 	now?: () => number;
@@ -48,6 +55,10 @@ export interface SessionBusOptions {
 	dir?: string;
 	/** Test seam: the process id this runtime registers as, so two can share one session id. */
 	pid?: number;
+	/** Test seam: whether a pid is running, so a suite never depends on the host's pids. */
+	alive?: LivenessFn;
+	/** Test seam: the start-time seam the record is stamped with. */
+	startTokenFn?: StartTokenFn;
 	/** Test seam: skip git and use this repository identity. */
 	repo?: { root: string; key: string };
 	/** Heartbeat interval; 0 disables it (tests). */
@@ -107,11 +118,6 @@ function messageId(now: number): string {
 	return `${now}-${randomBytes(4).toString("hex")}`;
 }
 
-/** Whether a record's heartbeat is fresh: the rule the bus prunes and displays by. */
-function isLive(session: SessionRecord, at: number, ttlMs: number): boolean {
-	return at - session.lastSeen <= ttlMs;
-}
-
 /** A label with this session's short id appended, inside the label budget. */
 function suffixLabel(label: string, id: string): string {
 	const suffix = `-${shortId(id)}`;
@@ -124,6 +130,26 @@ export function createSessionBus(pi: ExtensionAPI, options: SessionBusOptions =
 	const watchMs = options.watchMs ?? DEFAULT_WATCH_MS;
 	const interval = options.interval ?? defaultInterval;
 	const pid = options.pid ?? process.pid;
+	const seams: RosterSeams = { alive: options.alive ?? isPidAlive, token: options.startTokenFn ?? startTokenOf };
+	// Asked once, here: a reused pid is settled from the record afterwards, so no
+	// heartbeat tick spawns `ps`.
+	const processToken = (seams.token ?? startTokenOf)(pid);
+
+	/**
+	 * What one record says about its session.
+	 *
+	 * The rule is the roster's, not a copy: the bus writes these records and the page
+	 * reads them, and a second copy of the heartbeat rule is how a dead session keeps its
+	 * label and its claims while the screen already says it is gone.
+	 */
+	function stateOf(session: SessionRecord, at = now()): RosterState {
+		return rosterStateOf(session, at, sessionTtlMs, seams);
+	}
+
+	/** Whether a record is a session that can still answer. */
+	function isLive(session: SessionRecord, at = now()): boolean {
+		return stateOf(session, at) === "live";
+	}
 	const sessionTtlMs = options.sessionTtlMs ?? SESSION_TTL_MS;
 	const messageTtlMs = options.messageTtlMs ?? DEFAULT_MESSAGE_TTL_MS;
 
@@ -161,6 +187,9 @@ export function createSessionBus(pi: ExtensionAPI, options: SessionBusOptions =
 				mode,
 				startedAt: now(),
 				lastSeen: now(),
+				// Asked once, here: a reused pid is settled from the record, not by this session
+				// polling `ps` for its own heartbeat.
+				...(processToken === undefined ? {} : { startToken: processToken }),
 			};
 		})();
 		try {
@@ -202,14 +231,16 @@ export function createSessionBus(pi: ExtensionAPI, options: SessionBusOptions =
 	}
 
 	/** The labels other live sessions hold: a crashed session's label is not taken. */
-	async function takenLabels(bus: BusStore, mine: string): Promise<Set<string>> {
+	async function takenLabels(bus: BusStore, mine: string): Promise<Map<string, SessionRecord>> {
 		const at = now();
 		const sessions = await bus.sessions();
-		return new Set(
-			sessions
-				.filter((session) => session.id !== mine && isLive(session, at, sessionTtlMs))
-				.map((session) => session.label.toLowerCase()),
-		);
+		const taken = new Map<string, SessionRecord>();
+		// The record, not just the string: a refusal names the session that holds the label,
+		// which a set of lowercase labels could not do.
+		for (const session of sessions) {
+			if (session.id !== mine && isLive(session, at)) taken.set(session.label.toLowerCase(), session);
+		}
+		return taken;
 	}
 
 	/**
@@ -231,15 +262,25 @@ export function createSessionBus(pi: ExtensionAPI, options: SessionBusOptions =
 		await store.writeSession(me);
 	}
 
-	/** The live session ids a prune must keep: this session is active by definition. */
-	async function liveIds(): Promise<Set<string>> {
+	/**
+	 * What a prune must keep, and what it must let go.
+	 *
+	 * `live` is who can still answer, and this session is active by definition. `gone` is
+	 * who cannot: their rows survive on the heartbeat's clock, but the paths they held are
+	 * nobody's, which is the half a lead waits for.
+	 */
+	async function pruneSets(): Promise<{ live: Set<string>; gone: Set<string> }> {
 		if (!store) throw new Error("session bus is not started.");
 		const at = now();
-		const active = new Set(
-			(await store.sessions()).filter((session) => isLive(session, at, sessionTtlMs)).map((session) => session.id),
-		);
-		if (record) active.add(record.id);
-		return active;
+		const live = new Set<string>();
+		const gone = new Set<string>();
+		for (const session of await store.sessions()) {
+			const state = stateOf(session, at);
+			if (state === "live") live.add(session.id);
+			else if (state === "gone") gone.add(session.id);
+		}
+		if (record) live.add(record.id);
+		return { live, gone };
 	}
 
 	async function prepare(): Promise<void> {
@@ -249,12 +290,14 @@ export function createSessionBus(pi: ExtensionAPI, options: SessionBusOptions =
 		// session that finally calls a tool does not delete its own record.
 		record.lastSeen = now();
 		await store.writeSession(record);
-		const sessions = await store.sessions();
-		const active = new Set(
-			sessions.filter((session) => isLive(session, now(), sessionTtlMs)).map((session) => session.id),
-		);
-		if (record) active.add(record.id);
-		await store.prune({ now: now(), activeIds: active, sessionTtlMs, messageTtlMs });
+		const sets = await pruneSets();
+		await store.prune({
+			now: now(),
+			activeIds: sets.live,
+			goneIds: sets.gone,
+			sessionTtlMs,
+			messageTtlMs,
+		});
 	}
 
 	async function currentRecord(): Promise<SessionRecord> {
@@ -277,17 +320,28 @@ export function createSessionBus(pi: ExtensionAPI, options: SessionBusOptions =
 		return store;
 	}
 
-	async function withUnread(rows: readonly SessionRecord[]): Promise<Array<SessionRecord & { unread: number }>> {
-		return Promise.all(rows.map(async (session) => ({ ...session, unread: (await store?.unread(session.id)) ?? 0 })));
+	async function withUnread(
+		rows: readonly SessionRecord[],
+	): Promise<Array<SessionRecord & { unread: number; state: RosterState }>> {
+		const at = now();
+		return Promise.all(
+			rows.map(async (session) => ({
+				...session,
+				unread: (await store?.unread(session.id)) ?? 0,
+				state: stateOf(session, at),
+			})),
+		);
 	}
 
 	/**
 	 * The bus as it stands, this session's own record included.
 	 *
-	 * `liveOnly` drops a session whose heartbeat went stale, and a claim held by
-	 * one, without writing or deleting anything, so a board can read it every
-	 * second. The prune itself stays with `prepare()` on the next tool or command
-	 * call, which is therefore what the screen's next action sees.
+	 * `liveOnly` drops a session whose heartbeat went stale, and the claims of one whose
+	 * process is gone, without writing or deleting anything, so a board can read it every
+	 * second. A gone session stays listed — a lead needs a face for the paths it still
+	 * holds — but its claims are nobody's, so they are not drawn. The prune itself stays
+	 * with `prepare()` on the next tool or command call, which is therefore what the
+	 * screen's next action sees.
 	 */
 	async function readStatus(
 		me: { id: string; label: string; onBus: boolean },
@@ -296,10 +350,10 @@ export function createSessionBus(pi: ExtensionAPI, options: SessionBusOptions =
 		if (!store) throw new Error("session bus is not started.");
 		const records = await store.sessions();
 		const sessions = liveOnly
-			? records.filter((session) => session.id === record?.id || isLive(session, now(), sessionTtlMs))
+			? records.filter((session) => session.id === record?.id || stateOf(session) !== "quiet")
 			: records;
-		const live = new Set(sessions.map((session) => session.id));
-		const claims = (await store.claims()).filter((claim) => !liveOnly || live.has(claim.owner));
+		const ours = new Set(sessions.filter((session) => stateOf(session) !== "gone").map((session) => session.id));
+		const claims = (await store.claims()).filter((claim) => !liveOnly || ours.has(claim.owner));
 		return {
 			me: { id: me.id, label: me.label },
 			onBus: me.onBus,
@@ -312,9 +366,10 @@ export function createSessionBus(pi: ExtensionAPI, options: SessionBusOptions =
 	async function rename(label: string): Promise<string> {
 		if (!store || !record) throw new Error("session bus is not started.");
 		const candidate = normalizeLabel(label, record.label);
-		if ((await takenLabels(store, record.id)).has(candidate.toLowerCase())) {
-			throw new Error(`the label "${candidate}" is already in use.`);
-		}
+		// The bus's own answer to "who has it": the session record, named by its id, because
+		// the label it holds is the one the caller just asked for.
+		const holder = (await takenLabels(store, record.id)).get(candidate.toLowerCase());
+		if (holder) throw new Error(`the label "${candidate}" is already in use by session ${holder.id}.`);
 		record.label = candidate;
 		record.lastSeen = now();
 		await store.writeSession(record);
@@ -382,7 +437,14 @@ export function createSessionBus(pi: ExtensionAPI, options: SessionBusOptions =
 			// A reader does not join: an unjoined session prunes and reads, and is not
 			// listed by the act of looking. Only an addressable action joins.
 			if (!joined) {
-				await store.prune({ now: now(), activeIds: await liveIds(), sessionTtlMs, messageTtlMs });
+				const sets = await pruneSets();
+				await store.prune({
+					now: now(),
+					activeIds: sets.live,
+					goneIds: sets.gone,
+					sessionTtlMs,
+					messageTtlMs,
+				});
 				return readStatus({ id: record.id, label: record.label, onBus: false }, false);
 			}
 			const me = await currentRecord();