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

package/extensions/board/join.ts

@@ -1,33 +1,18 @@
 /**
- * Board's side of the team: the one call that puts this session on it.
+ * The board's side of the team: how a join reads on a `/board` line.
  *
  * 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 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).
+ * The join itself is `lib/board/join.ts`'s `joinOnce`, because a claim joins from either
+ * tool; this module holds what is the board's own: what a `/board` line says about it.
  */
 
 import type { JoinResult } from "../../lib/session-tool.ts";
-import { DEFAULT_SEAT } from "./seat.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.
- */
 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.
- */
-export function joinLabel(served: boolean): string | undefined {
-	return served ? DEFAULT_SEAT : undefined;
-}
-
 /**
  * What the join did, as a clause for a `/board` line.
  *

package/extensions/board/lazy-page.ts

@@ -0,0 +1,40 @@
+/**
+ * The board's page, loaded when `/board` first needs it.
+ *
+ * The page module owns the HTTP surface, the snapshots, and the view; none of it
+ * is needed to register the command or the tool. The factory therefore returns a
+ * proxy over `lib/lazy`: every command path loads the real page once, and
+ * `closeAll` on shutdown only closes a page that was already opened, so a
+ * session that never touched the board imports none of it.
+ *
+ * The loader is a seam: a test drives the proxy without a socket.
+ */
+
+import type { BoardSession } from "../../lib/board/session.ts";
+import { lazy } from "../../lib/lazy.ts";
+import type { BoardPage, BoardPageDeps } from "./page.ts";
+
+/** The page module, as the proxy loads it. */
+export type BoardPageModule = typeof import("./page.ts");
+
+/** How the proxy reaches the page module; production uses the dynamic import. */
+export type BoardPageLoader = () => Promise<BoardPageModule>;
+
+export function createLazyBoardPage(
+	session: BoardSession,
+	deps: BoardPageDeps,
+	load: BoardPageLoader = () => import("./page.ts"),
+): BoardPage {
+	const page = lazy(async () => (await load()).createBoardPage(session, deps));
+	return {
+		start: async (ctx, view) => (await page.get()).start(ctx, view),
+		stop: async () => (await page.get()).stop(),
+		status: async () => (await page.get()).status(),
+		dropStale: async (ctx) => (await page.get()).dropStale(ctx),
+		// Shutdown must not start a load: a page that never opened has nothing to close.
+		closeAll: async () => {
+			const opened = page.peek();
+			if (opened !== undefined) await opened.closeAll();
+		},
+	};
+}

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,17 @@ 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 type { Actor } from "../../lib/board/rules.ts";
+import { pageActor } from "../../lib/board/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 +73,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 +88,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 +106,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,36 +120,34 @@ export interface BoardPage {
 	closeAll: () => Promise<void>;
 }
 
-export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {}): BoardPage {
-	let running: { server: BoardServer; store: BoardStore; token: string } | undefined;
+export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps): BoardPage {
+	let running: { server: BoardServer; store: BoardStore; token: string; seat: Actor } | 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();
-
 	const storeOf = async (ctx: ExtensionContext): Promise<BoardStore> => runtime.store(ctx.cwd);
 
 	/**
 	 * 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 +156,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 };
 		};
@@ -179,6 +171,11 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 		} catch (error) {
 			return failed(error);
 		}
+		// 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. That name is
+		// the board's lead, so serving the page is what makes a session the lead — a repository
+		// that names one gets a page served under that name, and the gate accepts it.
+		const seat = pageActor(store.config().lead);
 		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 => {
@@ -189,6 +186,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 +197,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, repo: store.name(), root: store.root() }),
 				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 +271,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);
+			running = { server, store, token, seat };
 			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"
@@ -287,11 +290,12 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 		);
 	};
 
-	const describe = (state: { server: BoardServer; store: BoardStore }): PageStart => ({
+	const describe = (state: { server: BoardServer; store: BoardStore; seat: Actor }): PageStart => ({
 		kind: "served",
-		seat: seat.label,
+		seat: state.seat.label,
 		port: state.server.port,
 		url: state.server.url,
+		repo: state.store.name(),
 		where: state.store.where(),
 	});
 
@@ -307,9 +311,10 @@ export function createBoardPage(runtime: BoardSession, deps: BoardPageDeps = {})
 		if (running !== undefined) {
 			return {
 				running: true,
-				seat: seat.label,
+				seat: running.seat.label,
 				port: running.server.port,
 				url: running.server.url,
+				repo: running.store.name(),
 				where: running.store.where(),
 				watchers: running.server.watchers(),
 			};
@@ -353,36 +358,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,19 +8,20 @@
  */
 
 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 { LANE_RULES } from "../../lib/board/lanes.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, TailRowLine } 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";
+import { boardRowLineFor } from "./rows.ts";
+import { TONE_ROLE } from "./tone.ts";
 import type { BoardDetails } from "./types.ts";
 
-/** One section of the expanded block. */
-function section(label: string | undefined, cards: readonly Card[]): TailSection<Card> {
-	return { label, rows: cards, more: 0, rowLine: boardRowLine };
+/** One section of the expanded block, drawn as the session that asked for it. */
+function section(label: string | undefined, cards: readonly Card[], rowLine: TailRowLine<Card>): TailSection<Card> {
+	return { label, rows: cards, more: 0, rowLine };
 }
 
 /**
@@ -33,19 +34,25 @@ function section(label: string | undefined, cards: readonly Card[]): TailSection
  */
 export function resultInput(details: BoardDetails): TailResultInput<Card> | undefined {
 	if (details.action !== "list") return undefined;
-	if (details.card) return { kind: "list", rows: [details.card], more: 0, rowLine: boardRowLine };
+	// Only a read narrowed to this session's own cards marks them, and it marks them with
+	// the rule the filter used: the rows and the filter agree about what "mine" means.
+	const rowLine = boardRowLineFor(details.mine === true ? details.me : undefined);
+	if (details.card) return { kind: "list", rows: [details.card], more: 0, rowLine };
 	const round = details.round;
 	if (!round) {
 		const cards = details.cards ?? [];
-		return cards.length === 0 ? undefined : { kind: "list", rows: cards, more: 0, rowLine: boardRowLine };
+		return cards.length === 0 ? undefined : { kind: "list", rows: cards, more: 0, rowLine };
 	}
 	const sections: TailSection<Card>[] = [];
-	for (const group of round.owners) sections.push(section(group.label, group.cards));
-	if (round.unassigned.length > 0) sections.push(section("Unassigned", round.unassigned));
-	if (round.unplanned.length > 0) sections.push(section("Unplanned", round.unplanned));
-	if (round.blocked.length > 0) sections.push(section("Blocked", round.blocked));
-	if (round.idle.length > 0) sections.push(section("Idle", round.idle));
-	if (round.done.length > 0) sections.push(section("Done", round.done));
+	for (const group of round.owners) sections.push(section(group.label, group.cards, rowLine));
+	if (round.unassigned.length > 0) sections.push(section("Unassigned", round.unassigned, rowLine));
+	if (round.unplanned.length > 0) sections.push(section("Unplanned", round.unplanned, rowLine));
+	// The lead's queue: a contract nobody has signed is a card the flow stops on, so it is
+	// drawn in the order `formatRound` prints it rather than left to the text above.
+	if (round.unapproved.length > 0) sections.push(section("Awaiting approval", round.unapproved, rowLine));
+	if (round.blocked.length > 0) sections.push(section("Blocked", round.blocked, rowLine));
+	if (round.idle.length > 0) sections.push(section("Idle", round.idle, rowLine));
+	if (round.done.length > 0) sections.push(section("Done", round.done, rowLine));
 	return sections.length === 0 ? undefined : { kind: "sections", sections };
 }
 
@@ -78,31 +85,15 @@ export function collapsedLine(theme: Theme, details: BoardDetails): string {
 	return `${paint(theme, "label", plural(count, "card"))} ${SEPARATORS.item} ${plural(owners, "owner")} ${SEPARATORS.item} ${me}`;
 }
 
-/** `#4 doing · Billing webhook accepts orders`, clipped by the caller's row helper. */
+/**
+ * `#4 execute · Billing webhook accepts orders`, clipped by the caller's row helper.
+ *
+ * The lane wears the colour the page gives it — `LANE_RULES`' role, through the tone
+ * bridge — rather than one accent for all five.
+ */
 function cardLine(theme: Theme, card: Card): string {
 	const id = paint(theme, "meta", cardRef(card.id));
-	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);
-	}
+	const lane = paint(theme, TONE_ROLE[LANE_RULES[card.lane].role], card.lane);
+	const title = paint(theme, "label", sanitizeLine(card.title));
+	return `${id} ${lane} ${SEPARATORS.item} ${title}`;
 }

package/extensions/board/rows.ts

@@ -4,45 +4,82 @@
  * Every field comes from a card file, which the model wrote and a person may have
  * edited, so it is sanitized here at the boundary that reaches the terminal, and
  * every row is clipped to the width it was given by the shared row helpers.
+ *
+ * The colours come from `lib/board/tone.ts` — the table the page reads too — through
+ * `TONE_ROLE`, so a lane's word in the transcript is the lane's colour on the page. Each
+ * word is painted on its own, which means the separator between two words is painted as
+ * well: a bare ` · ` would fall back to the terminal's default foreground between two
+ * coloured words.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { type Card, cardRef, DEFAULT_PRIORITY, priorityOf } from "../../lib/board/card.ts";
+import { type Card, cardRef, DEFAULT_PRIORITY, holds, priorityOf } from "../../lib/board/card.ts";
+import { LANE_RULES } from "../../lib/board/lanes.ts";
+import type { Actor } from "../../lib/board/rules.ts";
+import { type BoardTone, REASON_TONE } from "../../lib/board/tone.ts";
 import { sanitizeLine } from "../../lib/format.ts";
+import { clip, splitRow } from "../../lib/tui/columns.ts";
 import { SEPARATORS } from "../../lib/tui/glyphs.ts";
-import { listRow } from "../../lib/tui/rows.ts";
+import { paint } from "../../lib/tui/tokens.ts";
 import type { TailRowLine } from "../../lib/tui/tool.ts";
+import { TONE_ROLE } from "./tone.ts";
 
-/** Who holds a card, as the row's trailing text. */
-function holderOf(card: Card): string {
-	if (card.owner === undefined) return "unassigned";
-	return sanitizeLine(card.owner.label);
+/** One fact the row states about a card, and the tone it wears. */
+interface Fact {
+	text: string;
+	tone: BoardTone;
 }
 
 /**
- * The lane, and — for work in flight — whether it was planned first, and — when it is
- * not the ordinary one — how urgent it is.
+ * Who holds a card, the lane it sits in, and — for work in flight — whether it was planned
+ * first, with the priority when it is not the ordinary one.
  *
  * A row carries the lane because a flat listing has no section heading to say it, and
- * "planned" because a `doing` card nobody planned is the one a lead looks at. The
- * priority rides along for the same reason: inside a lane the order is the priority,
- * and an order nobody can see reads as an accident.
+ * "planned" because a card nobody planned is the one a lead looks at. The priority rides
+ * along for the same reason: inside a lane the order is the priority, and an order nobody
+ * can see reads as an accident.
  */
-function stateOf(card: Card): string[] {
-	const urgency = priorityOf(card) === DEFAULT_PRIORITY ? [] : [priorityOf(card)];
-	if (card.status === "todo" || card.status === "done") return [...urgency, card.status];
-	return [...urgency, card.status, card.plan === undefined ? "unplanned" : "planned"];
+function factsOf(card: Card): Fact[] {
+	const facts: Fact[] = [
+		{
+			text: card.owner === undefined ? "unassigned" : sanitizeLine(card.owner.label),
+			tone: "muted",
+		},
+	];
+	const priority = priorityOf(card);
+	if (priority !== DEFAULT_PRIORITY) facts.push({ text: priority, tone: "muted" });
+	facts.push({ text: card.lane, tone: LANE_RULES[card.lane].role });
+	// The pool has no plan to speak of and a finished card is history, so only a lane
+	// somebody is working in says whether the work was planned first. An unplanned card
+	// wears the tone the page's reason line gives the same fact.
+	const rule = LANE_RULES[card.lane];
+	if (!rule.ownerless && !rule.terminal) {
+		facts.push(
+			card.planPath === undefined
+				? { text: "unplanned", tone: REASON_TONE.contract }
+				: { text: "planned", tone: "muted" },
+		);
+	}
+	return facts;
 }
 
-/** One card: the id and title, with its state trailing. */
-export 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)}`,
-		labelRole: options.self === true ? "accent" : "label",
-		trailing: [holderOf(card), ...stateOf(card)].join(SEPARATORS.item),
-	});
+/** One card: the id and title, with its facts trailing. */
+function cardRowText(card: Card, width: number, theme: Theme, self: boolean): string {
+	const head = paint(theme, self ? "accent" : "label", `${cardRef(card.id)} ${sanitizeLine(card.title)}`);
+	const gap = paint(theme, "meta", SEPARATORS.item);
+	const trailing = factsOf(card)
+		.map((fact) => paint(theme, TONE_ROLE[fact.tone], fact.text))
+		.join(gap);
+	return splitRow(head, clip(trailing, width), width);
 }
 
-/** The row renderer every board section uses. */
-export const boardRowLine: TailRowLine<Card> = (card, width, theme) => cardRowLine(card, width, theme);
+/**
+ * The row renderer every board section uses, for the session reading it.
+ *
+ * `me` matters: a `list` narrowed to this session's own cards should look like it, so the
+ * holder's rows wear the accent the page gives the card the reader is looking at. Passing
+ * no actor draws every row the same, which is what a card produced by an action gets.
+ */
+export function boardRowLineFor(me?: Actor): TailRowLine<Card> {
+	return (card, width, theme) => cardRowText(card, width, theme, me !== undefined && holds(card, me));
+}