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

package/extensions/board/commands.ts

@@ -35,12 +35,24 @@ export function registerCommands(pi: ExtensionAPI, page: BoardPage, deps: { team
 		handler: async (args: string, ctx: ExtensionCommandContext) => {
 			const word = args.trim().toLowerCase();
 			if (word === "status") {
-				ctx.ui.notify(statusLine(page.status(), joined), "info");
+				ctx.ui.notify(statusLine(await page.status(), joined), "info");
 				return;
 			}
 			if (word === "stop") {
-				const status = page.status();
-				// A viewer's page is somebody else's to stop, and saying whose is the answer.
+				const status = await page.status();
+				// A note nobody answers is not a page to leave for the next session to trip over:
+				// it is dropped here, and the line says whose it was.
+				if (status.stale === true) {
+					const dropped = await page.dropStale(ctx);
+					ctx.ui.notify(
+						dropped
+							? `board: dropped ${status.seat}'s note for :${status.port} — it answered nobody`
+							: `board: nothing to stop here — ${status.seat} is answering on :${status.port}`,
+						"info",
+					);
+					return;
+				}
+				// A page another session serves is that session's to stop, and saying whose it is is the answer.
 				if (status.attached === true) {
 					ctx.ui.notify(
 						`board: nothing to stop here — ${status.seat} serves this repository on :${status.port}`,
@@ -64,10 +76,13 @@ export function registerCommands(pi: ExtensionAPI, page: BoardPage, deps: { team
 			// this session's own label when it watches a page somebody else serves.
 			if (started.kind === "failed") return;
 			joined = await team.join(ctx, joinLabel(started.kind === "served"));
+			// The address is on the line because the browser is not the only way in: a machine
+			// with no default browser prints it here, and a tab closed by mistake is one
+			// command from being opened again.
 			ctx.ui.notify(
 				started.kind === "attached"
-					? `board: ${started.seat} is serving this repository on :${started.port} — viewing${teamLine(joined)}`
-					: `board: ${started.seat} serving ${started.where} on :${started.port}${teamLine(joined)}`,
+					? `board: ${started.seat} is serving this repository on :${started.port} — viewing · open ${started.url}${teamLine(joined)}`
+					: `board: ${started.seat} serving ${started.where} on :${started.port} · open ${started.url}${teamLine(joined)}`,
 				"info",
 			);
 		},
@@ -80,6 +95,9 @@ export function statusLine(status: BoardPageStatus, team?: JoinResult): string {
 		const watching = plural(status.watchers ?? 0, "tab");
 		return `board: ${status.seat} serving on :${status.port} · ${watching} watching · ${status.where}${teamLine(team)}`;
 	}
+	if (status.stale === true) {
+		return `board: watching ${status.seat} on :${status.port} — that note answers nobody; /board stop drops it${teamLine(team)}`;
+	}
 	if (status.attached === true) {
 		return `board: watching ${status.seat} on :${status.port} — nothing to stop here${teamLine(team)}`;
 	}

package/extensions/board/format.ts

@@ -12,18 +12,85 @@
  */
 
 import { type Card, cardRef, DEFAULT_PRIORITY, dependsOf, priorityOf } from "../../lib/board/card.ts";
-import type { BoardIndex } from "../../lib/board/links.ts";
+import { type BoardIndex, lanesText, openDependentsOf } from "../../lib/board/links.ts";
+import type { Skip } from "../../lib/board/store.ts";
+import { formatAge } from "../../lib/format.ts";
 import { plural } from "../../lib/board/round-text.ts";
 
 /** One card: the headline, then the state a reader needs in order to act on it. */
-export function formatCard(card: Card, board?: BoardIndex): string {
-	return [`${cardRef(card.id)} ${card.status} · ${card.title}`, ...detailLines(card, board)].join("\n");
+export function formatCard(card: Card, board?: BoardIndex, now?: number): string {
+	return [`${cardRef(card.id)} ${card.status} · ${card.title}`, ...detailLines(card, board, now)].join("\n");
 }
 
-/** A board, in lane order. */
-export function formatCards(cards: readonly Card[]): string {
-	if (cards.length === 0) return "The board is empty.";
-	return cards.map((card) => listLine(card)).join("\n");
+/**
+ * What a listing cannot show, and therefore has to say.
+ *
+ * A footnote is the difference between a listing and the board: an omission nobody
+ * accounted for reads as a smaller board — or as history that was deleted.
+ */
+export interface ListingNotes {
+	/** Finished cards the board holds that a lane-less listing left out. */
+	hiddenDone: number;
+	/** Cards set aside in the archive, which no board read opens. */
+	archived: number;
+	/** Card files this build could not read. */
+	skipped: readonly Skip[];
+}
+
+/**
+ * A board's listing: the cards, then the footnotes a reader cannot see.
+ *
+ * One body, because the footnotes belong to the listing: a card file this build cannot
+ * read, the finished cards a plain listing left out, and the cards an `archive` set aside.
+ */
+export function formatBoard(shown: readonly Card[], notes: ListingNotes): string {
+	const lines =
+		shown.length === 0 ? [notes.hiddenDone === 0 ? "The board is empty." : "No open cards."] : shown.map(listLine);
+	// A finished card is history rather than work, so a listing that names no lane leaves
+	// them out; the count is what keeps the omission from reading as a smaller board.
+	if (notes.hiddenDone > 0) {
+		const them = notes.hiddenDone === 1 ? "it" : "them";
+		lines.push(`${plural(notes.hiddenDone, "done card")} hidden; pass status: "done" to read ${them}.`);
+	}
+	for (const note of [archiveNote(notes.archived), formatSkipped(notes.skipped)]) {
+		if (note !== "") lines.push(note);
+	}
+	return lines.join("\n");
+}
+
+/**
+ * The archive's listing: what is set aside, and the files there this build refused.
+ *
+ * The archive is read on request only, so this has no lane footnote of its own — every
+ * card in the pile is finished, and a `done` lane would be a second way to say it.
+ */
+export function formatArchive(shown: readonly Card[], skipped: readonly Skip[]): string {
+	const lines = shown.length === 0 ? ["The archive is empty."] : shown.map(listLine);
+	const unreadable = formatSkipped(skipped);
+	if (unreadable !== "") lines.push(unreadable);
+	return lines.join("\n");
+}
+
+/**
+ * The one sentence a board listing adds so its archive is not mistaken for deleted history.
+ *
+ * Empty when nothing is set aside, so the ordinary board says nothing new.
+ */
+export function archiveNote(count: number): string {
+	if (count === 0) return "";
+	return `${plural(count, "card")} ${count === 1 ? "is" : "are"} set aside in the archive; pass archived: true to read ${count === 1 ? "it" : "them"}.`;
+}
+
+/**
+ * The files the board could not read, or nothing when it read everything.
+ *
+ * A skipped file is not an absent one: a board written by a newer build would
+ * otherwise read as "nobody has planned anything" while the work sits on disk.
+ */
+export function formatSkipped(skipped: readonly Skip[]): string {
+	if (skipped.length === 0) return "";
+	const files = skipped.map((entry) => `${entry.file} (${entry.why})`).join(", ");
+	return `${plural(skipped.length, "file")} this build cannot read: ${files}`;
 }
 
 /** The dropped id, which is the only thing left of the card. */
@@ -31,22 +98,53 @@ export function formatDropped(id: string): string {
 	return `${cardRef(id)} dropped, with its notes.`;
 }
 
+/**
+ * The ids an archive set aside, and how to read them again.
+ *
+ * A move has to name the way back or it reads like a deletion: the card is out of the
+ * board and its notes, plan, and landed commit are still in its file.
+ */
+export function formatArchived(ids: readonly string[]): string {
+	const theirs = ids.length === 1 ? "its" : "their";
+	return `${plural(ids.length, "card")} archived: ${ids.map(cardRef).join(", ")} — out of the board, ${theirs} notes and plan still readable with archived: true.`;
+}
+
 /** A one-line listing: the id, the lane, the title, and who holds it. */
 function listLine(card: Card): string {
 	const holder = card.owner === undefined ? "unassigned" : card.owner.label;
 	const urgency = priorityOf(card) === DEFAULT_PRIORITY ? "" : ` · ${priorityOf(card)}`;
 	const waits = dependsOf(card).length === 0 ? "" : ` · waits on ${dependsOf(card).map(cardRef).join(", ")}`;
-	return `${cardRef(card.id)} ${card.status} · ${card.title} · ${holder}${urgency}${waits}`;
+	// The two lanes that carry a fact of their own say it here: what a block waits on, and
+	// what closed a finished card. Both are one short phrase, so a listing stays one line.
+	const blocked = card.blockedBy === undefined ? "" : ` · blocked: ${card.blockedBy}`;
+	const landed = card.landed === undefined ? "" : ` · landed ${card.landed.commit}`;
+	return `${cardRef(card.id)} ${card.status} · ${card.title} · ${holder}${urgency}${waits}${blocked}${landed}`;
 }
 
 /** The state lines under a card's headline. */
-function detailLines(card: Card, board?: BoardIndex): string[] {
+function detailLines(card: Card, board?: BoardIndex, now?: number): string[] {
 	const lines: string[] = [];
 	if (card.owner !== undefined) lines.push(`  owner: ${card.owner.label}`);
+	// An offer's age is the fact a reader acts on, which is the one place an age belongs in
+	// this text: the value is whether anybody has had time to answer.
+	if (card.offeredAt !== undefined && now !== undefined) {
+		lines.push(`  offered: ${formatAge(now, card.offeredAt)} ago, and nobody took it`);
+	}
+	if (card.blockedBy !== undefined) lines.push(`  blocked: ${card.blockedBy}`);
+	if (card.landed !== undefined) lines.push(`  landed: ${card.landed.commit}`);
 	if (priorityOf(card) !== DEFAULT_PRIORITY) lines.push(`  priority: ${priorityOf(card)}`);
 	if (card.plan !== undefined) lines.push(`  plan: ${card.plan}`);
 	if (card.paths.length > 0) lines.push(`  paths: ${card.paths.join(", ")}`);
 	if (dependsOf(card).length > 0) lines.push(`  waits on: ${waitingOf(card, board)}`);
+	// The mirror question, for the same board: what leaving this card undone holds up. Only
+	// a card with the board in hand can answer it, which is why a bare card read omits it.
+	if (board !== undefined) {
+		const dependents = openDependentsOf(card.id, board);
+		if (dependents.length > 0) {
+			const which = dependents.length === 1 ? "card" : "cards";
+			lines.push(`  waited on by ${dependents.length} ${which}: ${lanesText(dependents)}`);
+		}
+	}
 	if (card.notes.length > 0) {
 		const last = card.notes.at(-1);
 		if (last) lines.push(`  last note (${last.by}): ${last.text}`);

package/extensions/board/join.ts

@@ -22,7 +22,7 @@ export type { TeamJoin } from "../../lib/session-tool.ts";
 
 /**
  * The label `/board` lands on: the page's seat when this session serves it, and
- * nothing when it watches somebody else's page, so a viewer keeps its own name.
+ * nothing when it opened somebody else's page, so a session keeps its own name.
  */
 export function joinLabel(served: boolean): string | undefined {
 	return served ? DEFAULT_SEAT : undefined;

package/extensions/board/page.ts

@@ -4,9 +4,9 @@
  * `session_shutdown`.
  *
  * Only the lifecycle lives here — the state machine, the port it remembers, the chip
- * that names it, and the three closes. What the page *reads* is `snapshot.ts`, what it
- * *writes* is `writes.ts`, and how a request reaches either is `transport/`; the router
- * knows nothing of the page's markup, and this is still the one place they meet.
+ * that names it, and the three closes. What the page *reads* is `snapshot.ts`, and it
+ * writes nothing: how a request reaches the snapshot is `transport/`, the router knows
+ * nothing of the page's markup, and this is still the one place they meet.
  *
  * All state lives in this closure, not at module scope: Pi loads each extension with an
  * isolated module cache, so a module variable would be one copy per extension.
@@ -27,14 +27,14 @@ import {
 	probePage,
 	readPointer,
 	settlePointer,
-	viewUrlOf,
+	urlOf,
 } from "../../lib/board/page-pointer.ts";
 import { mintToken } from "../../lib/http/index.ts";
+import type { IdleReason } from "../../lib/http/sink.ts";
 import { join } from "node:path";
 import { type BoardConfig, loadBoardConfig } from "./config.ts";
 import { pageActor } from "./seat.ts";
 import { viewOf } from "./snapshot.ts";
-import { writeOf } from "./writes.ts";
 import { type BoardServer, createBoardServer } from "./transport/server.ts";
 import { BOARD_CLIENT_JS } from "./view/client.ts";
 import { type PageView, renderBoardPage } from "./view/page.ts";
@@ -57,11 +57,26 @@ export function randomPort(): number {
  */
 export const IDLE_STOP_MS = 60_000;
 
+/**
+ * How long a page may stand with no tab ever attached.
+ *
+ * `/board` opens a browser, and a browser that does not open (a swallowed failure, a
+ * terminal on a machine with no default browser) would otherwise leave the port bound for
+ * the rest of the session. Two minutes is long enough for a person to finish reading the
+ * transcript and click the link `/board` printed.
+ */
+export const IDLE_FIRST_MS = 120_000;
+
 /** What `/board status` prints. */
 export interface BoardPageStatus {
 	running: boolean;
 	/** True when this session opened somebody else's page instead of serving one. */
 	attached?: boolean;
+	/**
+	 * True when that page no longer answers: the note is there, the process behind it is
+	 * not, and `/board stop` may drop it.
+	 */
+	stale?: boolean;
 	/** The name the page serves as: a seat, not the session that opened it. */
 	seat?: string;
 	port?: number;
@@ -90,6 +105,8 @@ export interface BoardPageDeps {
 	interval?: RepeatTimer;
 	/** Grace after the last tab leaves; defaults to {@link IDLE_STOP_MS}. */
 	idleMs?: number;
+	/** Grace for a page no tab ever attached to; defaults to {@link IDLE_FIRST_MS}. */
+	firstIdleMs?: number;
 	/** Whether a page another session left a note about is answering; a test drives it. */
 	probe?: ProbeFetch;
 	/** How the `board` section answers; a test drives it without a config file. */
@@ -100,12 +117,15 @@ export interface BoardPageDeps {
 export interface BoardPage {
 	start: (ctx: ExtensionContext, view?: PageView) => Promise<PageStart>;
 	stop: (ctx: ExtensionContext) => Promise<boolean>;
-	status: () => BoardPageStatus;
+	/** What `/board status` prints: served here, watched, watched and dead, or absent. */
+	status: () => Promise<BoardPageStatus>;
+	/** Drop the note of a page that has stopped answering. False when it still answers. */
+	dropStale: (ctx: ExtensionContext) => Promise<boolean>;
 	closeAll: () => Promise<void>;
 }
 
 export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {}): BoardPage {
-	let running: { server: BoardServer; store: BoardStore; viewToken: string } | undefined;
+	let running: { server: BoardServer; store: BoardStore; token: string } | undefined;
 	/** The page another session serves, when this session opened that one instead. */
 	let attachedTo: PagePointer | undefined;
 	let sessionPort: number | undefined;
@@ -115,32 +135,60 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 
 	const storeOf = async (ctx: ExtensionContext): Promise<BoardStore> => runtime.store(ctx.cwd);
 
-	const stop = async (ctx: ExtensionContext): Promise<boolean> => {
-		if (!running) return false;
-		const { server, store, viewToken } = running;
+	/**
+	 * Close the page this session serves, and take its note with it.
+	 *
+	 * One close for both callers: `/board stop` has a context and clears the chip, and a
+	 * clean `session_shutdown` has none. The note must leave either way — a note nobody
+	 * answers makes every open tab reconnect forever and costs the next `/board` a probe
+	 * and a takeover before it serves.
+	 */
+	const closeRunning = async (ctx?: ExtensionContext): Promise<boolean> => {
+		if (running === undefined) return false;
+		const { server, store, token } = running;
 		running = undefined;
 		await server.close();
-		// The note is the page's, so it leaves with it: a viewer that reads a note nobody
-		// answers wastes a probe, and the next `/board` would attach to a dead port.
-		await clearPointer(store.dir, viewToken);
-		clearChip(ctx);
+		await clearPointer(store.dir, token);
+		if (ctx !== undefined) clearChip(ctx);
 		return true;
 	};
 
+	const stop = (ctx: ExtensionContext): Promise<boolean> => closeRunning(ctx);
+
 	const start = async (ctx: ExtensionContext, view: PageView = "board"): Promise<PageStart> => {
-		if (running) return describe(running);
-		const store = await storeOf(ctx);
-		await store.ensure();
+		// `/board` is how the page is summoned, and a page whose tab was closed is one
+		// command away from being shown again — the same answer a viewer's `/board` gives.
+		if (running !== undefined) {
+			(deps.open ?? openInBrowser)(view === "board" ? running.server.url : `${running.server.url}&view=team`);
+			return describe(running);
+		}
+		const config = (deps.config ?? loadBoardConfig)(ctx.cwd);
+		const pinned = config.port > 0 ? config.port : undefined;
+		/** One refusal for every way a start can fail, named by what failed. */
+		const failed = (error: unknown): PageStart => {
+			const reason = failureReason(error, pinned);
+			ctx.ui.notify(`board: the page did not start (${reason})`, "error");
+			return { kind: "failed", reason };
+		};
+		// The board's own directory, then the page: both can fail on a path that exists and
+		// cannot be written, and a start that fails must leave no listener behind.
+		let store: BoardStore;
+		try {
+			store = await storeOf(ctx);
+			await store.ensure();
+		} catch (error) {
+			return failed(error);
+		}
 		const open = (url: string) => (deps.open ?? openInBrowser)(view === "board" ? url : `${url}&view=team`);
 		/** Watch the page another session serves: its note is the URL, its seat the name. */
 		const attach = (pointer: PagePointer): PageStart => {
 			attachedTo = pointer;
-			open(viewUrlOf(pointer));
+			open(urlOf(pointer));
 			return {
 				kind: "attached",
 				seat: pointer.seat.label,
 				port: pointer.port,
-				url: viewUrlOf(pointer),
+				url: urlOf(pointer),
 				where: store.where(),
 			};
 		};
@@ -151,24 +199,24 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 		attachedTo = undefined;
 		const actor = () => seat;
 		const now = () => runtime.now();
-		// Read on every start, so an edit to the section applies to the next `/board`.
-		const config = (deps.config ?? loadBoardConfig)(ctx.cwd);
-		const pinned = config.port > 0 ? config.port : undefined;
+		// Read above, so a pinned port names itself in a refusal; the port itself is
+		// remembered for the session so a closed and reopened page lands where it was.
 		const preferred = pinned ?? sessionPort ?? (deps.pickPort ?? randomPort)();
-		// The viewer's credential is minted here rather than by the server, because the note
-		// this session leaves has to carry it: that is what a teammate reads to attach.
-		const viewToken = mintToken();
-		let server: BoardServer;
+		// Minted here rather than by the server: the note this session leaves has to carry it,
+		// and that is what a second session reads to attach instead of serving its own page.
+		const token = mintToken();
+		let server: BoardServer | undefined;
 		try {
 			server = await createBoardServer({
 				// A pinned port is tried alone: falling back would leave the bookmark pointing
 				// at a page that moved, which is the failure the setting exists to prevent.
 				ports: pinned === undefined ? [preferred, 0] : [pinned],
-				viewToken,
+				token,
 				...(deps.interval === undefined ? {} : { interval: deps.interval }),
 				idleMs: deps.idleMs ?? IDLE_STOP_MS,
-				onIdle: () => void stopIdle(ctx),
-				page: async (view, authority) => renderBoardPage({ view, writes: authority === "write" }),
+				firstIdleMs: deps.firstIdleMs ?? IDLE_FIRST_MS,
+				onIdle: (reason) => void stopIdle(ctx, reason),
+				page: async (view) => renderBoardPage({ view }),
 				script: BOARD_CLIENT_JS,
 				view: () =>
 					viewOf({
@@ -178,59 +226,65 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 						now,
 						busDir: () => runtime.busDir(ctx.cwd),
 					}),
-				write: (request) => writeOf({ store, actor, now }, request),
 			});
+			// The note and the seat: written last, on the port the server actually bound, and only if no
+			// other session got there first: the loser of that race attaches to the page that
+			// won rather than serving a second page nobody can find. A note that answers
+			// nobody is taken over, so a page that died between its note and its server does not
+			// hold the name forever, and a note this build cannot read is named rather than
+			// blamed on a session that does not exist.
+			const note: PagePointer = {
+				port: server.port,
+				token,
+				seat: { id: seat.id, label: seat.label },
+				startedAt: runtime.now(),
+			};
+			const outcome = await settlePointer(store.dir, note, deps.probe);
+			if (outcome.kind === "attached") {
+				await server.close();
+				return attach(outcome.pointer);
+			}
+			if (outcome.kind === "written" && outcome.took !== undefined) {
+				const dead = outcome.took;
+				ctx.ui.notify(
+					`board: ${dead.seat.label} on :${dead.port} does not answer — open ${urlOf(dead)} · took its note over`,
+					"info",
+				);
+			}
+			if (outcome.kind !== "written") {
+				await server.close();
+				const path = join(store.dir, PAGE_FILE);
+				const reason =
+					outcome.kind === "stale"
+						? `${path} names ${outcome.pointer.seat.label} on :${outcome.pointer.port}, and nothing answers — remove it to serve this board`
+						: outcome.kind === "busy"
+							? `${path} kept changing hands — run /board again`
+							: `${path} is there and cannot be read — remove it to serve this board`;
+				ctx.ui.notify(`board: the page did not start (${reason})`, "error");
+				return { kind: "failed", reason };
+			}
+			sessionPort = server.port;
+			running = { server, store, token };
+			setChip(ctx, server.port);
+			open(server.url);
+			return describe(running);
 		} catch (error) {
-			const reason = failureReason(error, pinned);
-			ctx.ui.notify(`board: the page did not start (${reason})`, "error");
-			return { kind: "failed", reason };
-		}
-		// The note is written last, on the port the server actually bound, and only if no
-		// other session got there first: the loser of that race becomes a viewer of the
-		// page that won rather than a second page nobody can find. A note that answers
-		// nobody is taken over, so a page that died between its note and its server does not
-		// hold the name forever, and a note this build cannot read is named rather than
-		// blamed on a session that does not exist.
-		const note: PagePointer = {
-			port: server.port,
-			viewToken,
-			seat: { id: seat.id, label: seat.label },
-			startedAt: runtime.now(),
-		};
-		const outcome = await settlePointer(store.dir, note, deps.probe);
-		if (outcome.kind === "attached") {
-			await server.close();
-			return attach(outcome.pointer);
+			// A bind that failed has no server to close; a seat that could not be written does,
+			// and leaving it bound would hold a port no note names — invisible until shutdown.
+			await server?.close();
+			return failed(error);
 		}
-		if (outcome.kind === "written" && outcome.took !== undefined) {
-			const dead = outcome.took;
-			ctx.ui.notify(
-				`board: ${dead.seat.label} on :${dead.port} does not answer — open ${viewUrlOf(dead)} · took its note over`,
-				"info",
-			);
-		}
-		if (outcome.kind !== "written") {
-			await server.close();
-			const path = join(store.dir, PAGE_FILE);
-			const reason =
-				outcome.kind === "stale"
-					? `${path} names ${outcome.pointer.seat.label} on :${outcome.pointer.port}, and nothing answers — remove it to serve this board`
-					: outcome.kind === "busy"
-						? `${path} kept changing hands — run /board again`
-						: `${path} is there and cannot be read — remove it to serve this board`;
-			ctx.ui.notify(`board: the page did not start (${reason})`, "error");
-			return { kind: "failed", reason };
-		}
-		sessionPort = server.port;
-		running = { server, store, viewToken };
-		setChip(ctx, server.port);
-		open(server.url);
-		return describe(running);
 	};
 
-	/** The idle grace closes the page and says so, once. */
-	const stopIdle = async (ctx: ExtensionContext): Promise<void> => {
-		if (await stop(ctx)) ctx.ui.notify("board: stopped — the last page was closed", "info");
+	/** The idle grace closes the page and says which grace it was, once. */
+	const stopIdle = async (ctx: ExtensionContext, reason: IdleReason): Promise<void> => {
+		if (!(await stop(ctx))) return;
+		ctx.ui.notify(
+			reason === "first"
+				? "board: stopped — no tab ever opened; /board starts it again"
+				: "board: stopped — the last page was closed",
+			"info",
+		);
 	};
 
 	const describe = (state: { server: BoardServer; store: BoardStore }): PageStart => ({
@@ -241,9 +295,16 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 		where: state.store.where(),
 	});
 
-	/** What `/board status` answers, wherever the page is: served here, watched, or absent. */
-	const statusOf = (): BoardPageStatus => {
-		if (running) {
+	/**
+	 * What `/board status` answers, wherever the page is: served here, watched, watched and
+	 * dead, or absent.
+	 *
+	 * A watched page is probed, because the note saying it exists is not the same thing as
+	 * it answering: after the lead's session ends, its note stays and the reader would
+	 * otherwise be told about a port nobody holds.
+	 */
+	const statusOf = async (): Promise<BoardPageStatus> => {
+		if (running !== undefined) {
 			return {
 				running: true,
 				seat: seat.label,
@@ -253,27 +314,42 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 				watchers: running.server.watchers(),
 			};
 		}
-		if (attachedTo !== undefined) {
-			return {
-				running: false,
-				attached: true,
-				seat: attachedTo.seat.label,
-				port: attachedTo.port,
-				url: viewUrlOf(attachedTo),
-			};
-		}
-		return { running: false };
+		if (attachedTo === undefined) return { running: false };
+		const answers = await probePage(attachedTo, deps.probe);
+		return {
+			running: false,
+			attached: true,
+			...(answers ? {} : { stale: true }),
+			seat: attachedTo.seat.label,
+			port: attachedTo.port,
+			url: urlOf(attachedTo),
+		};
+	};
+
+	/**
+	 * Drop the note of a page that has stopped answering.
+	 *
+	 * Only a note this session watched, and only while it answers nobody: a page that came
+	 * back between the status line and this call keeps its note, and `clearPointer`'s token
+	 * check makes that true even if a new page wrote one in between.
+	 */
+	const dropStale = async (ctx: ExtensionContext): Promise<boolean> => {
+		const pointer = attachedTo;
+		if (pointer === undefined) return false;
+		if (await probePage(pointer, deps.probe)) return false;
+		const store = await storeOf(ctx);
+		if (!(await clearPointer(store.dir, pointer.token))) return false;
+		attachedTo = undefined;
+		return true;
 	};
 
 	return {
 		start,
 		stop,
 		status: statusOf,
+		dropStale,
 		closeAll: async () => {
-			if (!running) return;
-			const { server } = running;
-			running = undefined;
-			await server.close();
+			await closeRunning();
 		},
 	};
 }

package/extensions/board/result.ts

@@ -58,6 +58,15 @@ export function resultInput(details: BoardDetails): TailResultInput<Card> | unde
  */
 export function collapsedLine(theme: Theme, details: BoardDetails): string {
 	const me = paint(theme, "faint", sanitizeLine(details.me.label));
+	const archived = details.archived;
+	if (archived !== undefined && archived.length > 0) {
+		const first = archived[0];
+		const label =
+			archived.length === 1 && first !== undefined
+				? `${cardRef(first)} archived`
+				: `${plural(archived.length, "card")} archived`;
+		return `${paint(theme, "label", label)} ${SEPARATORS.item} ${me}`;
+	}
 	if (details.dropped)
 		return `${paint(theme, "label", `${cardRef(details.dropped)} dropped`)} ${SEPARATORS.item} ${me}`;
 	const card = details.card;