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

package/extensions/board/join.ts

@@ -2,30 +2,51 @@
  * Board's side of the team: the one call that puts this session on it.
  *
  * The user's surface is `/board` and `team`; the session bus is the transport under
- * them. So the board joins on the user's behalf — when the page opens, and again the
- * first time a card is worked — and never asks anybody to run a bus action.
+ * them. So the board joins on the user's behalf — when the page opens, and the first
+ * time this session claims a card — and never asks anybody to run a bus action.
+ *
+ * The label it asks for is the session's own team name (`BoardSession.who`), so the
+ * card, the bus record, and the roster say one word, and joining never renames the
+ * session: the footer keeps the name the user gave it.
  *
  * The seam exists for the same reason `team`'s dispatch does: a board suite drives a
  * recording join instead of a bus, and the shipped implementation is one in-process
  * request through `lib/session-tool.ts` (a command context cannot call a tool).
  */
 
-import type { JoinResult } from "../../lib/session-tool.ts";
-import { DEFAULT_SEAT } from "./seat.ts";
+import { messageOf } from "../../lib/errors.ts";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { JoinResult, TeamJoin } from "../../lib/session-tool.ts";
+import type { TeamStanding } from "../../lib/board/session.ts";
 
 /**
  * The join itself is `lib/session-tool.ts`'s, because `team` asks for it too; this
- * module only holds what is the board's — the label it lands on, and how the outcome
- * reads on a `/board` line.
+ * module only holds what is the board's — when it asks, and how the outcome reads on a
+ * `/board` line.
  */
 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 opened somebody else's page, so a session keeps its own name.
+ * Put this session on the team, once: the first card it claims.
+ *
+ * Asked only while the standing does not say this session is on the team, so a card
+ * write costs one request for the session rather than one per card. A failure is
+ * recorded and asked again by the next claim; a bus that is not loaded answers with a
+ * sentence, which is a result and not an exception — and a join that did throw still
+ * must not undo the card that was already written, so it is swallowed here.
  */
-export function joinLabel(served: boolean): string | undefined {
-	return served ? DEFAULT_SEAT : undefined;
+export async function joinOnClaim(
+	standing: TeamStanding,
+	team: TeamJoin,
+	ctx: ExtensionContext,
+	label: string,
+): Promise<void> {
+	if (standing.last()?.ok === true) return;
+	try {
+		standing.record(await team.join(ctx, { label }));
+	} catch (error) {
+		standing.record({ ok: false, error: messageOf(error) });
+	}
 }
 
 /**

package/extensions/board/page.ts

@@ -1,12 +1,13 @@
 /**
- * The page's lifecycle: one server per session, started by `/board` and closed by
+ * The page's lifecycle: one mount per session, started by `/board` and given back by
  * `/board stop`, by the idle grace once the last tab has been gone for a minute, or by
  * `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`, 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.
+ * Only the lifecycle lives here — the state machine, the prefix it holds, the note that
+ * names it, and the three closes. The session's port belongs to `serve`, so nothing here
+ * picks one. 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.
@@ -15,11 +16,10 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { BoardStore } from "../../lib/board/store.ts";
 import { openInBrowser } from "../../lib/browser.ts";
-import { GLYPHS, STATUS_KEYS } from "../../lib/tui/glyphs.ts";
-import { paint } from "../../lib/tui/tokens.ts";
 import type { RepeatTimer } from "../../lib/timer.ts";
 import type { BoardSession } from "../../lib/board/session.ts";
 import {
+	BOARD_BASE,
 	clearPointer,
 	PAGE_FILE,
 	type PagePointer,
@@ -29,25 +29,16 @@ import {
 	settlePointer,
 	urlOf,
 } from "../../lib/board/page-pointer.ts";
-import { mintToken } from "../../lib/http/index.ts";
+import { mintToken, type MountSource } from "../../lib/http/index.ts";
+import { messageOf } from "../../lib/errors.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 { type BoardServer, createBoardServer } from "./transport/server.ts";
 import { BOARD_CLIENT_JS } from "./view/client.ts";
 import { type PageView, renderBoardPage } from "./view/page.ts";
 
-/**
- * A free port in the range the other loopback pages use, so a session's pages cluster.
- * Only the unpinned page draws one: `board.port` in `bytefly.json` states the port a
- * bookmarked URL keeps.
- */
-export function randomPort(): number {
-	return 4780 + Math.floor(Math.random() * 1000);
-}
-
 /**
  * How long the page waits for a tab after the last one leaves.
  *
@@ -81,6 +72,8 @@ export interface BoardPageStatus {
 	seat?: string;
 	port?: number;
 	url?: string;
+	/** The repository's name, so `status` says which board the page is. */
+	repo?: string;
 	where?: string;
 	/** How many tabs are attached, while this session serves the page. */
 	watchers?: number;
@@ -94,14 +87,17 @@ export interface BoardPageStatus {
  * page* is a third answer a `running: false` could not express.
  */
 export type PageStart =
-	| { kind: "served"; seat: string; port: number; url: string; where: string }
-	| { kind: "attached"; seat: string; port: number; url: string; where: string }
+	| { kind: "served"; seat: string; port: number; url: string; repo: string; where: string }
+	| { kind: "attached"; seat: string; port: number; url: string; repo: string; where: string }
 	| { kind: "failed"; reason: string };
 
 /** Test seams and the one place a caller may redirect the browser. */
 export interface BoardPageDeps {
 	open?: (url: string) => void;
-	pickPort?: () => number;
+	/** Where the prefix comes from: the session's server, or a suite's own. */
+	mount: MountSource;
+	/** The Pi session this page serves as, so the prefix lands on its socket. */
+	session: () => string;
 	interval?: RepeatTimer;
 	/** Grace after the last tab leaves; defaults to {@link IDLE_STOP_MS}. */
 	idleMs?: number;
@@ -109,14 +105,13 @@ export interface BoardPageDeps {
 	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. */
-	config?: (cwd: string) => BoardConfig;
 }
 
 /** The page as `/board` and `session_shutdown` drive it. */
 export interface BoardPage {
 	start: (ctx: ExtensionContext, view?: PageView) => Promise<PageStart>;
-	stop: (ctx: ExtensionContext) => Promise<boolean>;
+	/** Give the prefix back; the session's server closes with its last mount. */
+	stop: () => Promise<boolean>;
 	/** 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. */
@@ -124,11 +119,10 @@ export interface BoardPage {
 	closeAll: () => Promise<void>;
 }
 
-export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {}): BoardPage {
+export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps): BoardPage {
 	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;
 	// The page is a seat, not a session: one name and one id for its whole life, so a card
 	// a browser claimed is still the seat's after the session that served it ends.
 	const seat = pageActor();
@@ -138,22 +132,25 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 	/**
 	 * 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
+	 * One close for both callers: `/board stop` has a context and clears the status line, 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> => {
+	const closeRunning = async (): Promise<boolean> => {
 		if (running === undefined) return false;
 		const { server, store, token } = running;
 		running = undefined;
 		await server.close();
 		await clearPointer(store.dir, token);
-		if (ctx !== undefined) clearChip(ctx);
+		// A page that closed is no seat: the session's next card is written as itself. This is
+		// the one place all three closes pass — `/board stop`, the idle grace, and shutdown — so
+		// a page nobody is looking at cannot leave the session serving in name only.
+		runtime.serve(undefined);
 		return true;
 	};
 
-	const stop = (ctx: ExtensionContext): Promise<boolean> => closeRunning(ctx);
+	const stop = (): Promise<boolean> => closeRunning();
 
 	const start = async (ctx: ExtensionContext, view: PageView = "board"): Promise<PageStart> => {
 		// `/board` is how the page is summoned, and a page whose tab was closed is one
@@ -162,11 +159,9 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 			(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);
+			const reason = error instanceof Error ? error.message : String(error);
 			ctx.ui.notify(`board: the page did not start (${reason})`, "error");
 			return { kind: "failed", reason };
 		};
@@ -189,6 +184,7 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 				seat: pointer.seat.label,
 				port: pointer.port,
 				url: urlOf(pointer),
+				repo: store.name(),
 				where: store.where(),
 			};
 		};
@@ -199,34 +195,44 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 		attachedTo = undefined;
 		const actor = () => seat;
 		const now = () => runtime.now();
-		// 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)();
 		// 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;
+		/** Whether this page has already said it cannot read the board. */
+		let blind = false;
+		// A frame the page cannot build is a dropped frame, not a crash: the ticker asks again
+		// in a second. Said once, because a failure that persists would otherwise become one
+		// notice per tick — and unsaid, a page that stopped following the board looks frozen.
+		const warnBlind = (error: unknown): void => {
+			if (blind) return;
+			blind = true;
+			ctx.ui.notify(`board: the page cannot read the board (${messageOf(error)}) — it will keep trying`, "warning");
+		};
 		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],
+			const started = await createBoardServer({
+				mount: deps.mount,
+				session: deps.session(),
 				token,
 				...(deps.interval === undefined ? {} : { interval: deps.interval }),
+				onError: warnBlind,
 				idleMs: deps.idleMs ?? IDLE_STOP_MS,
 				firstIdleMs: deps.firstIdleMs ?? IDLE_FIRST_MS,
 				onIdle: (reason) => void stopIdle(ctx, reason),
-				page: async (view) => renderBoardPage({ view }),
+				page: async (view) => renderBoardPage({ view, base: BOARD_BASE }),
 				script: BOARD_CLIENT_JS,
 				view: () =>
 					viewOf({
 						store,
 						actor,
-						session: () => runtime.who(ctx, ctx.cwd),
 						now,
 						busDir: () => runtime.busDir(ctx.cwd),
 					}),
 			});
+			if (started.kind === "refused") {
+				ctx.ui.notify(`board: the page did not start (${started.reason})`, "error");
+				return { kind: "failed", reason: started.reason };
+			}
+			const server = started.server;
 			// 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
@@ -263,22 +269,17 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 				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) {
-			// 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);
 		}
 	};
 
 	/** 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;
+		if (!(await stop())) return;
 		ctx.ui.notify(
 			reason === "first"
 				? "board: stopped — no tab ever opened; /board starts it again"
@@ -292,6 +293,7 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 		seat: seat.label,
 		port: state.server.port,
 		url: state.server.url,
+		repo: state.store.name(),
 		where: state.store.where(),
 	});
 
@@ -310,6 +312,7 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 				seat: seat.label,
 				port: running.server.port,
 				url: running.server.url,
+				repo: running.store.name(),
 				where: running.store.where(),
 				watchers: running.server.watchers(),
 			};
@@ -353,36 +356,3 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 		},
 	};
 }
-
-/**
- * Why a start failed, naming the setting when the pinned port was the reason: a
- * bind error's own text says the address, not the key that chose it.
- */
-function failureReason(error: unknown, pinned: number | undefined): string {
-	// The bind path rejects with the `listen` error, so `code` is there to read.
-	const code = (error as NodeJS.ErrnoException | undefined)?.code;
-	if (pinned !== undefined && code === "EADDRINUSE") {
-		return `port ${pinned} is in use — change "port" in the bytefly.json board section, or stop what answers on it`;
-	}
-	return error instanceof Error ? error.message : String(error);
-}
-
-/** The chip naming the port, cleared with an empty text. */
-function setChip(ctx: ExtensionContext, port: number): void {
-	try {
-		ctx.ui.setStatus(
-			STATUS_KEYS.board,
-			`${paint(ctx.ui.theme, "ok", GLYPHS.board)} ${paint(ctx.ui.theme, "accent", String(port))}`,
-		);
-	} catch {
-		// A host without a status line is not a reason to keep the page from starting.
-	}
-}
-
-function clearChip(ctx: ExtensionContext): void {
-	try {
-		ctx.ui.setStatus(STATUS_KEYS.board, undefined);
-	} catch {
-		// Same as above: nothing to clear.
-	}
-}

package/extensions/board/result.ts

@@ -8,11 +8,10 @@
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import type { Component } from "@earendil-works/pi-tui";
 import { type Card, cardRef } from "../../lib/board/card.ts";
 import { sanitizeLine } from "../../lib/format.ts";
 import { SEPARATORS } from "../../lib/tui/glyphs.ts";
-import { TailResult, type TailResultInput, type TailSection } from "../../lib/tui/tool.ts";
+import type { TailResultInput, TailSection } from "../../lib/tui/tool.ts";
 import { plural } from "../../lib/board/round-text.ts";
 import { paint } from "../../lib/tui/tokens.ts";
 import { boardRowLine } from "./rows.ts";
@@ -84,25 +83,3 @@ function cardLine(theme: Theme, card: Card): string {
 	const lane = paint(theme, "accent", card.status);
 	return `${id} ${lane} ${SEPARATORS.item} ${paint(theme, "label", sanitizeLine(card.title))}`;
 }
-
-/** The expanded block, as a component the transcript can reuse across renders. */
-export class BoardResult implements Component {
-	private readonly view: TailResult<Card>;
-
-	constructor(input: TailResultInput<Card>, theme: Theme) {
-		this.view = new TailResult(input, theme);
-	}
-
-	/** Update in place so the transcript reuses this component. */
-	setInput(input: TailResultInput<Card>, theme: Theme): void {
-		this.view.setInput(input, theme);
-	}
-
-	invalidate(): void {
-		this.view.invalidate();
-	}
-
-	render(width: number): string[] {
-		return this.view.render(width);
-	}
-}

package/extensions/board/rows.ts

@@ -35,7 +35,7 @@ function stateOf(card: Card): string[] {
 }
 
 /** One card: the id and title, with its state trailing. */
-export function cardRowLine(card: Card, width: number, theme: Theme, options: { self?: boolean } = {}): string {
+function cardRowLine(card: Card, width: number, theme: Theme, options: { self?: boolean } = {}): string {
 	return listRow(theme, width, {
 		marker: false,
 		label: `${cardRef(card.id)} ${sanitizeLine(card.title)}`,

package/extensions/board/schema.ts

@@ -8,7 +8,7 @@
  */
 
 import { Type } from "typebox";
-import { CARD_STATUSES, PRIORITIES } from "../../lib/board/card.ts";
+import { CARD_STATUSES, MAX_NOTE, PRIORITIES } from "../../lib/board/card.ts";
 import { BOARD_ACTIONS } from "./types.ts";
 
 export const BoardParams = Type.Object({
@@ -49,8 +49,14 @@ export const BoardParams = Type.Object({
 				"`add` and `edit`: repository-relative hints (directories or files) where the work happens. Not claims.",
 		}),
 	),
-	note: Type.Optional(Type.String({ description: "`add`: a first note, e.g. why the card exists." })),
-	text: Type.Optional(Type.String({ description: "`note`: the note to append." })),
+	note: Type.Optional(
+		Type.String({
+			description: `\`add\`: a first note, e.g. why the card exists; one line, at most ${MAX_NOTE} characters.`,
+		}),
+	),
+	text: Type.Optional(
+		Type.String({ description: `\`note\`: the note to append; one line, at most ${MAX_NOTE} characters.` }),
+	),
 	path: Type.Optional(Type.String({ description: "`plan`: the plan file this card is executing." })),
 	priority: Type.Optional(
 		Type.Union(

package/extensions/board/snapshot.ts

@@ -18,8 +18,6 @@ export interface SnapshotContext {
 	store: BoardStore;
 	/** The actor every request is made and reported as: the page's seat. */
 	actor: () => Actor;
-	/** The session serving the page, which is who is reading, not who it writes as. */
-	session?: () => Actor;
 	now: () => number;
 	/** Where this repository's bus files its records. */
 	busDir: () => Promise<string>;
@@ -28,14 +26,17 @@ export interface SnapshotContext {
 /** The snapshot the page renders, and the body of `/api/board`. */
 export async function viewOf(context: SnapshotContext): Promise<BoardView> {
 	const roster = await readRoster(await context.busDir());
-	const session = context.session?.();
+	// One read of the pile answers both: a frame that asked `list` and `skipped` separately
+	// would parse every card twice, once a second, for as long as a tab is open.
+	const { cards, skipped } = await context.store.scan();
 	return buildView({
 		me: context.actor(),
-		...(session === undefined ? {} : { session }),
-		cards: await context.store.list(),
+		cards,
 		now: context.now(),
 		bytes: await context.store.bytes(),
-		skipped: (await context.store.skipped()).length,
+		skipped: skipped.length,
+		repo: context.store.name(),
+		root: context.store.root(),
 		where: context.store.where(),
 		...(roster === undefined ? {} : { roster }),
 	});

package/extensions/board/tools.ts

@@ -14,7 +14,7 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { Static } from "typebox";
-import { cardRef, matchesQuery, normalizeCardId } from "../../lib/board/card.ts";
+import { type Card, cardRef, matchesQuery, normalizeCardId } from "../../lib/board/card.ts";
 import { indexOf } from "../../lib/board/links.ts";
 import { type CardOp, holds } from "../../lib/board/rules.ts";
 import { buildRound } from "../../lib/board/round.ts";
@@ -25,7 +25,7 @@ import { strayField } from "../../lib/stray-fields.ts";
 import { createExecRunner } from "../../lib/git/runner.ts";
 import { failedResult, textResult } from "../../lib/tool-result.ts";
 import { reuseText, toolDetails } from "../../lib/tui/chrome.ts";
-import { callLine, detailsOrLine } from "../../lib/tui/tool.ts";
+import { callLine, detailsOrLine, isTailResult, TailResult } from "../../lib/tui/tool.ts";
 import { formatRound } from "../../lib/board/round-text.ts";
 import {
 	archiveNote,
@@ -37,7 +37,8 @@ import {
 	formatSkipped,
 } from "./format.ts";
 import { createTeamJoin, type TeamJoin } from "../../lib/session-tool.ts";
-import { BoardResult, collapsedLine, resultInput } from "./result.ts";
+import { joinOnClaim } from "./join.ts";
+import { collapsedLine, resultInput } from "./result.ts";
 import { createInput } from "./input.ts";
 import type { BoardSession } from "../../lib/board/session.ts";
 import { BoardParams } from "./schema.ts";
@@ -45,7 +46,6 @@ import {
 	ACTION_FIELDS,
 	BOARD_ACTION_DOCS,
 	BOARD_ACTIONS,
-	BOARD_MUTATING_ACTIONS,
 	BOARD_TOOL,
 	type BoardAction,
 	type BoardDetails,
@@ -96,6 +96,17 @@ function refusal(action: BoardAction, me: BoardDetails["me"], message: string, c
 	});
 }
 
+/**
+ * Whether a result this tool built is a refusal.
+ *
+ * `refusal` marks one with `isError`, and the success shape (`ToolResult`) has no such
+ * field, so this is the one probe that tells the two apart — read here rather than
+ * widening the shared envelope with a flag that would then be optional everywhere.
+ */
+function refused(result: unknown): boolean {
+	return typeof result === "object" && result !== null && (result as { isError?: unknown }).isError === true;
+}
+
 /**
  * The commit at `cwd`'s `HEAD`, shortened, or nothing when there is none.
  *
@@ -149,13 +160,6 @@ export function registerTools(pi: ExtensionAPI, runtime: BoardSession, deps: { t
 				// have enlisted this session as a teammate on its way to the refusal.
 				const stray = strayField(action, args, ACTION_FIELDS);
 				if (stray !== undefined) return refusal(action, me, stray);
-				// Working a card makes this session a teammate, once: the board is the user's
-				// surface for the team, so nobody has to know the bus exists. A failed join is
-				// not a failed card write — the board works with no bus at all — and it is not
-				// marked, so the next write asks again.
-				if (BOARD_MUTATING_ACTIONS.has(action) && !runtime.joined()) {
-					if ((await team.join(ctx)).ok) runtime.markJoined();
-				}
 				const store = await runtime.store(ctx.cwd);
 				const now = runtime.now();
 				switch (action) {
@@ -163,8 +167,16 @@ export function registerTools(pi: ExtensionAPI, runtime: BoardSession, deps: { t
 						return await read(store, action, me, args, now);
 					case "add":
 						return await add(store, me, args, now);
-					case "claim":
-						return await mutate(store, action, me, now, args, { kind: "claim" });
+					case "claim": {
+						const claimed = await mutate(store, action, me, now, args, { kind: "claim" });
+						// Taking a card is what makes this session a teammate. It is the one action here
+						// worth being addressed about, and the board is the user's surface for the team, so
+						// nobody has to know the bus exists. A refused claim wrote nothing and enlists
+						// nobody; a refused join is not a failed claim, so the card stands and the next
+						// claim asks again.
+						if (!refused(claimed)) await joinOnClaim(runtime.team, team, ctx, me.label);
+						return claimed;
+					}
 					case "release":
 						return await mutate(store, action, me, now, args, { kind: "release" });
 					case "reclaim":
@@ -239,8 +251,8 @@ export function registerTools(pi: ExtensionAPI, runtime: BoardSession, deps: { t
 				text.setText(collapsedLine(theme, outcome.details));
 				return text;
 			}
-			const view =
-				context?.lastComponent instanceof BoardResult ? context.lastComponent : new BoardResult(input, theme);
+			const previous = context?.lastComponent;
+			const view = isTailResult<Card>(previous) ? previous : new TailResult<Card>(input, theme);
 			view.setInput(input, theme);
 			return view;
 		},

package/extensions/board/transport/router.ts

@@ -23,6 +23,7 @@ import {
 	type ServeResponse,
 } from "../../../lib/http/index.ts";
 import type { BoardView } from "../../../lib/board/view.ts";
+import { PING_PATH, SNAPSHOT_PATH } from "../../../lib/board/page-pointer.ts";
 import { THEME_JS, THEME_JS_PATH } from "../../../lib/web/index.ts";
 import type { PageView } from "../view/page.ts";
 
@@ -45,13 +46,10 @@ export interface BoardRouterContext {
 	page: (view: PageView) => Promise<string>;
 	/** The client script. */
 	script: string;
-	/** The snapshot the page renders, and the body of `/api/board`. */
+	/** The snapshot the page renders, and the body of the snapshot route. */
 	view: () => Promise<BoardView>;
 }
 
-/** The cheap liveness route: a probe reads this, and never the snapshot. */
-export const PING_PATH = "/api/ping";
-
 /**
  * Handle one request. `method`, `rawUrl`, and `headers` are the raw HTTP values.
  */
@@ -77,7 +75,7 @@ export async function handleBoardRequest(
 	// must not pay for the snapshot, which is a store read and a roster read on the same
 	// event loop the probe is racing.
 	if (pathname === PING_PATH) return jsonResponse(200, { ok: true });
-	if (pathname === "/api/board") return jsonResponse(200, await ctx.view());
+	if (pathname === SNAPSHOT_PATH) return jsonResponse(200, await ctx.view());
 	if (pathname === "/" || pathname === "/index.html") {
 		return { status: 200, headers: pageHeaders(), body: await ctx.page(viewOf(search.get("view"))) };
 	}