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

package/extensions/board/transport/server.ts

@@ -1,37 +1,41 @@
 /**
- * The board page's server: one loopback listener, the snapshot pushed to every
- * attached tab, and the idle grace that closes the page when the last one leaves.
+ * The board page's mount: the prefix it holds on the session's one server, the snapshot
+ * pushed to every attached tab, and the idle grace that gives the prefix back when the
+ * last one leaves.
  *
- * `lib/http` owns the socket — binding, the body cap, the SSE head, and the
- * idempotent close — so this module owns only the board's own decisions: when a
- * frame is pushed (only when a card's revision moved), who receives it, and what
- * stops the ticker.
+ * `lib/http` owns the socket and `serve` owns the session's port, so this module owns only
+ * the board's own decisions: where it answers (`BOARD_BASE`), when a frame is pushed (only
+ * when a card's revision moved), who receives it, and what stops the ticker.
  */
 
+import { BOARD_BASE } from "../../../lib/board/page-pointer.ts";
+import type { BoardView } from "../../../lib/board/view.ts";
 import {
 	type EventSink,
+	type HttpMount,
 	LOOPBACK_HOSTS,
-	type LoopbackServer,
+	type MountSource,
+	type MountSpec,
 	mintToken,
-	serveLoopback,
 	tokenMatches,
 } from "../../../lib/http/index.ts";
 import type { IdleReason } from "../../../lib/http/sink.ts";
 import { defaultInterval, type RepeatTimer } from "../../../lib/timer.ts";
-import type { BoardView } from "../../../lib/board/view.ts";
 import type { PageView } from "../view/page.ts";
 import { type BoardRouterContext, handleBoardRequest } from "./router.ts";
 
 /** How often the page is offered a frame; a frame is sent only when the signature moved. */
-export const PUSH_MS = 1_000;
+const PUSH_MS = 1_000;
 
 /** Largest request body the page accepts: a card and a note are small. */
-export const MAX_BODY_BYTES = 64 * 1_024;
+const MAX_BODY_BYTES = 64 * 1_024;
 
 /** What the page is built from. The lifecycle (`page.ts`) supplies all of it. */
 export interface BoardServerOptions {
-	/** Ports tried in order: the session's remembered port, then an OS-chosen one. */
-	ports: readonly number[];
+	/** Where the prefix comes from: the session's server, or a suite's own. */
+	mount: MountSource;
+	/** The Pi session asking, so the prefix lands on this session's socket. */
+	session: string;
 	/** The page's token; minted here when the caller has none, so the note carries one. */
 	token?: string;
 	page: (view: PageView) => Promise<string>;
@@ -41,8 +45,17 @@ export interface BoardServerOptions {
 	onIdle?: (reason: IdleReason) => void;
 	/** Grace after the last stream leaves; 0 or absent waits for `close()`. */
 	idleMs?: number;
-	/** Grace for a page no tab ever attached to; absent leaves the server open. */
+	/** Grace for a page no tab ever attached to; absent leaves the mount open. */
 	firstIdleMs?: number;
+	/**
+	 * A read that failed while building a frame.
+	 *
+	 * A snapshot can fail for reasons the page does not control — the board directory removed
+	 * or made unreadable under a running page — and a ticker nobody awaits must not turn that
+	 * into an unhandled rejection in the session. The frame is dropped, the next tick tries
+	 * again, and this is the one place the failure is said. Absent, the page stays quiet.
+	 */
+	onError?: (error: unknown) => void;
 	/** The interval seam, so a test drives the ticker instead of waiting. */
 	interval?: RepeatTimer;
 }
@@ -59,10 +72,15 @@ export interface BoardServer {
 	close: () => Promise<void>;
 }
 
-export async function createBoardServer(options: BoardServerOptions): Promise<BoardServer> {
+/** The page, or the reason the session's server has no prefix for it. */
+export type BoardServerResult = { kind: "served"; server: BoardServer } | { kind: "refused"; reason: string };
+
+export async function createBoardServer(options: BoardServerOptions): Promise<BoardServerResult> {
 	const token = options.token ?? mintToken();
 	const clients = new Set<EventSink>();
 	const interval = options.interval ?? defaultInterval;
+	/** A frame that could not be built is not sent; the next tick tries again. */
+	const report = (error: unknown): void => options.onError?.(error);
 	let pushed = "";
 
 	const ctx: BoardRouterContext = {
@@ -84,8 +102,10 @@ export async function createBoardServer(options: BoardServerOptions): Promise<Bo
 		for (const sink of clients) sink.write(frame);
 	};
 
-	const server: LoopbackServer = await serveLoopback({
-		ports: options.ports,
+	/** The prefix this page asks for: the session's server holds it, not this module. */
+	const spec: Omit<MountSpec, "handler"> = {
+		session: options.session,
+		prefix: BOARD_BASE,
 		maxBodyBytes: MAX_BODY_BYTES,
 		...(options.idleMs === undefined || options.onIdle === undefined
 			? {}
@@ -96,6 +116,9 @@ export async function createBoardServer(options: BoardServerOptions): Promise<Bo
 						onIdle: options.onIdle,
 					},
 				}),
+	};
+	const outcome = await options.mount({
+		...spec,
 		async handler(request) {
 			const result = await handleBoardRequest(ctx, request.method, request.url, request.headers);
 			if (!result.stream) return { result };
@@ -105,10 +128,13 @@ export async function createBoardServer(options: BoardServerOptions): Promise<Bo
 					clients.add(sink);
 					// A tab that just attached gets the current frame without waiting for a
 					// card to change — otherwise a quiet board looks like a dead page.
-					void options.view().then((view) => {
-						pushed = view.sig;
-						sink.write(`data: ${JSON.stringify(view)}\n\n`);
-					});
+					void options
+						.view()
+						.then((view) => {
+							pushed = view.sig;
+							sink.write(`data: ${JSON.stringify(view)}\n\n`);
+						})
+						.catch(report);
 					return () => {
 						clients.delete(sink);
 					};
@@ -116,8 +142,10 @@ export async function createBoardServer(options: BoardServerOptions): Promise<Bo
 			};
 		},
 	});
+	if (outcome.kind === "refused") return { kind: "refused", reason: outcome.reason };
+	const mount: HttpMount = outcome.mount;
 
-	const stopTicker = interval(PUSH_MS, () => void push());
+	const stopTicker = interval(PUSH_MS, () => void push().catch(report));
 	let closed = false;
 	const close = async (): Promise<void> => {
 		if (closed) return;
@@ -125,14 +153,17 @@ export async function createBoardServer(options: BoardServerOptions): Promise<Bo
 		stopTicker();
 		for (const sink of clients) sink.end();
 		clients.clear();
-		await server.close();
+		await mount.release();
 	};
 
 	return {
-		port: server.port,
-		url: `http://127.0.0.1:${server.port}/?token=${token}`,
-		watchers: () => clients.size,
-		pushed: () => pushed,
-		close,
+		kind: "served",
+		server: {
+			port: mount.port,
+			url: `${mount.origin}${mount.base}/?token=${token}`,
+			watchers: () => clients.size,
+			pushed: () => pushed,
+			close,
+		},
 	};
 }

package/extensions/board/types.ts

@@ -10,53 +10,47 @@
 import type { Card } from "../../lib/board/card.ts";
 import type { Actor } from "../../lib/board/rules.ts";
 import type { RoundSummary } from "../../lib/board/round.ts";
+import { BOARD_ACTIONS, type BoardAction } from "../../lib/board/actions.ts";
 
 /** The tool's name. One extension registers it, so it stays here. */
 export const BOARD_TOOL = "board";
 
-/** The actions the tool accepts, in the order the description lists them. */
-export const BOARD_ACTIONS = [
-	"list",
-	"add",
-	"claim",
-	"release",
-	"reclaim",
-	"move",
-	"note",
-	"plan",
-	"edit",
-	"archive",
-	"drop",
-] as const;
-
-/** One action. */
-export type BoardAction = (typeof BOARD_ACTIONS)[number];
+// The actions are the board's, not the tool's: plan mode's read-only policy and the todo
+// nudge classify a call by the same table, and nothing under `lib/` may import this
+// file. Re-exported here so the schema, the description, and the suites keep one import
+// for the tool's own vocabulary.
+export { BOARD_ACTIONS, type BoardAction };
 
 /**
- * What each verb does, in one sentence.
+ * What each action does, in one sentence.
  *
  * The tool description is built from this table and the parameter's `action`
- * description points at that sentence, so the verbs are stated once. A new action is
+ * description points at that sentence, so the actions are stated once. A new action is
  * a row here and an entry in {@link BOARD_ACTIONS}; `test` holds the two together.
  */
 export const BOARD_ACTION_DOCS: Record<BoardAction, string> = {
 	list:
-		"shows the board — `status` filters one lane, `mine` only what this session holds, " +
+		"shows the board — `lane` filters one lane, `mine` only what this session holds, " +
 		"`query` matches a title, a holder, a path hint, the plan, or a note's text, `card` reads that one card " +
-		"instead of the board, and `round` adds the lead's rollup of owners, unassigned, unplanned, blocked, and " +
-		"idle, which always covers the whole board — and a listing that names no lane leaves out the `done` cards, " +
+		"instead of the board, which refuses the fields that narrow a listing beside it, and `round` adds the lead's rollup of owners, unassigned, unplanned, awaiting approval, " +
+		"blocked, idle, and done, which always covers the whole board — and a listing that names no lane leaves out the `done` cards, " +
 		"saying how many it left out",
-	add: "creates a `todo` card",
-	claim: "takes one for this session",
-	release: "gives it back",
-	reclaim: "takes it from whoever holds it",
-	move: "changes lane",
+	add: "creates a `backlog` card",
+	claim: "pulls one into `plan` for this session, when `plan` has room",
+	release: "gives it back to `backlog`",
+	reclaim: "takes it from whoever holds it, back to `backlog`",
+	move: "changes lane, through the one transition the board allows from where the card is; a card enters `execute` or `done` only while the plan it recorded is still in the store",
 	note: "appends to its history",
-	plan: "records the plan file being executed",
+	contract:
+		"records the plan file and the three lines a card promises — `goal`, `acceptance`, `scopeOut` — and drops any approval, because the wording changed; `path` is required and must be the plan `plan` action `write` saved in this repository's plan store",
+	approve:
+		"approves the contract: the lead (`board.lead`, `lead` by default, the name the page serves as), who does not hold the card, says the wording is right, which is what `plan` to `execute` requires, and `text` records what the signer saw",
+	review:
+		"records a spot-check of the finished work: the lead, who does not hold the card, in `execute`, which is what `done` requires, and `text` records what the signer saw",
 	edit: "fixes what the card says — title, path hints, priority, and what it waits for",
 	archive:
 		"sets a finished card aside, out of the board and still readable, or every finished card when no `card` is named",
-	drop: "deletes a `todo`, a `done`, or one you hold",
+	drop: "deletes a `backlog` or a `done` card, or one you hold",
 };
 
 /**
@@ -71,34 +65,34 @@ export const BOARD_ACTION_DOCS: Record<BoardAction, string> = {
  * a new field cannot be published without an action that acts on it.
  */
 export const ACTION_FIELDS: Record<BoardAction, readonly string[]> = {
-	list: ["card", "status", "mine", "query", "round", "archived"],
+	list: ["card", "lane", "mine", "query", "round", "archived"],
 	add: ["title", "paths", "priority", "note"],
 	claim: ["card"],
 	release: ["card"],
 	reclaim: ["card"],
-	move: ["card", "status", "blockedBy"],
+	move: ["card", "lane", "blockedBy", "blocker"],
 	note: ["card", "text"],
-	plan: ["card", "path"],
+	contract: ["card", "path", "goal", "acceptance", "scopeOut"],
+	approve: ["card", "text"],
+	review: ["card", "text"],
 	edit: ["card", "title", "paths", "priority", "dependsOn"],
 	archive: ["card"],
 	drop: ["card"],
 };
 
-/**
- * The actions that change the board: everything but a read.
- *
- * One definition, read by the tool (does this call need a teammate?) and by plan
- * mode (may this call run while planning?), so "a read" cannot mean two things.
- */
-export const BOARD_MUTATING_ACTIONS: ReadonlySet<BoardAction> = new Set(
-	BOARD_ACTIONS.filter((action) => action !== "list"),
-);
-
 /** A result the transcript renders and the page's routes mirror. */
 export interface BoardDetails {
 	action: BoardAction;
 	/** The serving session: the id Pi knows, and the label a card records. */
 	me: Actor;
+	/**
+	 * Whether the read was narrowed to this session's own cards.
+	 *
+	 * Kept because the transcript says so: a listing that answers "what am I holding" draws
+	 * those rows in the accent, and a listing that answers "what is on the board" does not
+	 * pretend every row is the reader's.
+	 */
+	mine?: boolean;
 	/** The board a `list` read, in lane order. */
 	cards?: Card[];
 	/** The card an action produced, or the one a refusal left untouched. */

package/extensions/board/view/card.ts

@@ -0,0 +1,229 @@
+/**
+ * One card's face: the title, the facts a reader acts on, and the two marks that say
+ * where they have been.
+ *
+ * It is a fragment of the client bundle like `team.ts` and `dialog.ts`, and it reads the
+ * helpers the renderer publishes — the element builder, the chip, the age, the count's
+ * wording, and the reason rule spliced in from `lib/board/reason.ts` — so no rule about a
+ * card is stated twice.
+ *
+ * Two of the face's facts are longer than it can draw: the hints past its third path, the
+ * reason sentence, and the cards it is holding up. Each is on a hover title for the
+ * pointer, and each is named by the title button's `aria-describedby` for the keyboard,
+ * because `j`/`k` walks cards by focusing that button and never hovers anything.
+ *
+ * Every value arrives as `textContent`, never as markup: a title is model-written and a
+ * note is anything a person typed.
+ */
+
+export const BOARD_CARD_JS = String.raw`(function () {
+  "use strict";
+  var board = window.bfBoard || (window.bfBoard = {});
+  var el = board.el;
+  var chip = board.chip;
+  var ago = board.ago;
+  var plural = board.plural;
+  var reasonFor = board.reasonFor;
+  var reasonTone = board.reasonTone;
+
+  /** Path chips a lane card shows before it counts the rest. */
+  var PATH_CHIPS = 3;
+  /**
+   * The class that draws each tone, in the page kit's own words.
+   *
+   * A tone is a colour and the class is named after it, so the reason line for a missing
+   * contract, an approval nobody gave, and a spot-check nobody did are three kinds drawn in
+   * one tone — instead of three kinds sharing a class named after the first of them.
+   */
+  var TONE_CLASS = {
+    muted: N.cardReasonMuted,
+    dim: N.cardReasonDim,
+    warn: N.cardReasonWarn,
+    accent: N.cardReasonAccent,
+    danger: N.cardReasonDanger,
+    success: N.cardReasonSuccess,
+  };
+
+  /** "3h", "just now" — the age a stamp is drawn with, read against the reader's clock. */
+  function sentence(wording, age) {
+    return wording.replace("{age}", age === "now" ? "just now" : age + " ago");
+  }
+
+  /**
+   * An age the ticker can keep honest: the stamp it was painted from, and the sentence
+   * saying which fact it is, which the ticker fills from the same stamp a second later.
+   *
+   * The wording is the stamp's rather than the ticker's because a card now carries two
+   * ages — when it was written to, and when its last note was filed — and a ticker that
+   * assumed "updated" would relabel one of them within a minute.
+   */
+  function stamp(at, wording) {
+    var node = el("span", "", ago(at));
+    node.setAttribute("data-at", String(at));
+    node.setAttribute("data-at-title", wording);
+    node.title = sentence(wording, ago(at));
+    return node;
+  }
+
+  /** The one line under a card's meta: why it sits where it does. */
+  function reasonOf(card) {
+    // An order is the strongest reason a card is not being worked on, and the one a
+    // reader cannot see from the lane. The sentence is the snapshot's, so this line and
+    // the tool's refusal name one list.
+    if (card.waits !== undefined) return { text: "waits on " + card.waits, kind: "waiting" };
+    return reasonFor(card, ago);
+  }
+
+  /**
+   * A path hint, or the +N chip that points at the rest.
+   *
+   * The hints past the third are the ones a reader needs before opening anything, so they
+   * are not dropped: the chip carries them on its hover one per line, and the list holds
+   * them again as text a screen reader reads, which is the whole of what the chip counts.
+   */
+  function paths(card, limit) {
+    var list = el("ul", N.cardPaths);
+    list.id = "card-paths-" + card.id;
+    var shown = card.paths.slice(0, limit);
+    for (var i = 0; i < shown.length; i++) {
+      var item = el("li", "");
+      var hint = chip(shown[i]);
+      // A path longer than the card elides, and the whole of it is on the hover title: the
+      // card is often the only place its hints are read before opening the record.
+      hint.title = shown[i];
+      item.appendChild(hint);
+      list.appendChild(item);
+    }
+    if (card.paths.length > limit) {
+      var beyond = card.paths.slice(limit);
+      var rest = el("li", "");
+      var more = chip("+" + beyond.length);
+      more.title = beyond.join("\n");
+      // The count is a shape, not a word: what it counts is in the list below it, and a
+      // reader is owed the hints rather than "+3".
+      more.setAttribute("aria-hidden", "true");
+      rest.appendChild(more);
+      list.appendChild(rest);
+      for (var j = 0; j < beyond.length; j++) list.appendChild(el("li", "sr-only", beyond[j]));
+    }
+    return list;
+  }
+
+  /** Whether the reader is dragging a selection, which a click at the end of it would clear. */
+  function textSelected() {
+    var selection = window.getSelection ? window.getSelection() : null;
+    return selection !== null && String(selection) !== "";
+  }
+
+  /** One card in its lane. */
+  function cardNode(card) {
+    var item = el("li", N.card);
+    item.setAttribute("data-card", card.id);
+    item.setAttribute("data-lane", card.lane);
+    item.setAttribute("data-rev", String(card.rev));
+
+    var head = el("p", N.cardHead);
+    head.appendChild(el("span", N.cardId, "#" + card.id));
+    // The title is the page's only focusable thing inside a card, so Enter and the focus
+    // ring have one home; the card around it is the larger target for a pointer. A native
+    // button's Enter and Space arrive as a click that bubbles to the card, so the card is
+    // the one handler and the button needs none.
+    var title = el("button", N.cardTitle, card.title);
+    title.type = "button";
+    head.appendChild(title);
+    item.appendChild(head);
+    item.addEventListener("click", function () {
+      // A drag that ends on a card is a reader selecting a title to copy, not opening it.
+      if (textSelected()) return;
+      board.openCard(card.id);
+    });
+
+    /** The face's clipped text, by id: what the title button describes. */
+    var described = [];
+
+    var meta = el("p", N.cardMeta);
+    meta.appendChild(card.owner ? chip(card.owner.label, "accent") : el("span", "", "unassigned"));
+    // The order inside a lane is the priority, so an urgent card says so: an order
+    // nobody can see reads as an accident. The lane's colour stays the card's own.
+    if (card.priority !== "normal") meta.appendChild(chip(card.priority, "outline"));
+    // The stamp, so the clock can keep the age honest between frames: a board can be
+    // quiet for ten minutes while the page still says "live".
+    meta.appendChild(stamp(card.updatedAt, "updated {age}"));
+    // A card with ten notes and a card with none drew the same face, and the notes are the
+    // card's history: the count says how much is there. The last note's own age earns a place
+    // only when it reads differently from the stamp beside it — a note is itself a write, so
+    // usually the two are one moment and the meta line printed the same bare number twice.
+    if (card.notes.length > 0) {
+      var last = card.notes[card.notes.length - 1];
+      var notes = el("span", N.cardNotes, plural(card.notes.length, "note"));
+      if (ago(last.at) !== ago(card.updatedAt)) {
+        notes.appendChild(document.createTextNode(" \u00b7 "));
+        notes.appendChild(stamp(last.at, "last note {age} by " + last.by));
+      }
+      meta.appendChild(notes);
+    }
+    item.appendChild(meta);
+
+    if (card.paths.length > 0) {
+      item.appendChild(paths(card, PATH_CHIPS));
+      // Only a truncated list is described: the hints a reader can already see are read in
+      // order with the card, and the ones behind the chip have nowhere else to be read.
+      if (card.paths.length > PATH_CHIPS) described.push("card-paths-" + card.id);
+    }
+
+    var reason = reasonOf(card);
+    if (reason) {
+      // The tone is a lookup, not a suffix: a name assembled from a prefix is a name no
+      // test can compare with the stylesheet.
+      var line = el("p", N.cardReason + " " + TONE_CLASS[reasonTone(reason.kind)], reason.text);
+      line.id = "card-reason-" + card.id;
+      // It clamps on the card, so the full sentence is the tooltip.
+      line.title = reason.text;
+      item.appendChild(line);
+      described.push(line.id);
+    }
+
+    // The other side of a link, on the face: what leaving this card undone holds up. It was
+    // dialog-only, so a card three others were waiting on looked like any other card.
+    if (card.dependents !== undefined) {
+      var holds = el("p", N.cardHolds, "holds up " + card.dependents);
+      holds.id = "card-holds-" + card.id;
+      holds.title = "holds up " + card.dependents;
+      item.appendChild(holds);
+      described.push(holds.id);
+    }
+
+    // The reason and the hints are drawn below the title, and a keyboard reader never
+    // hovers: describing the button with them is what makes a clamped line readable from
+    // j/k and from a screen reader alike.
+    if (described.length > 0) title.setAttribute("aria-describedby", described.join(" "));
+
+    return item;
+  }
+
+  board.cardNode = cardNode;
+  board.sentence = sentence;
+
+  /** Set a mark on a card, or drop it, so one that lost it does not keep it. */
+  function marked(node, name, on) {
+    if (on) node.setAttribute(name, "true");
+    else node.removeAttribute(name);
+  }
+
+  /**
+   * Paint the card the reader is on and the cards they have already read.
+   *
+   * j/k walks the drawn cards and wraps, so walking a lane and coming back looked
+   * exactly like arriving for the first time. The two ids are the client's own — never
+   * sent anywhere — and this runs after every frame as well as on a focus and an open,
+   * because a lane is rebuilt whole when its cards move.
+   */
+  board.markCards = function () {
+    var nodes = document.querySelectorAll(".board-card");
+    for (var i = 0; i < nodes.length; i++) {
+      var id = nodes[i].getAttribute("data-card");
+      marked(nodes[i], "data-current", board.current !== undefined && String(board.current) === id);
+      marked(nodes[i], "data-visited", board.visited !== undefined && board.visited[id] === true);
+    }
+  };
+})();`;

package/extensions/board/view/client.ts

@@ -6,36 +6,55 @@
  * Served as one string, because a page that opens six requests before it can paint
  * is a page that looks broken for a moment. Nothing here is typed — no compiler sees
  * a template string — so the split is by job and the class-contract test reads the
- * result: `render.ts` paints, `team.ts` draws the round, `dialog.ts` opens one card,
- * `keys.ts` binds, and `live.ts` owns the tabs and the stream.
+ * result: `render.ts` paints a whole frame, `card.ts` draws one card's face, `team.ts`
+ * draws the round, `dialog.ts` opens one card, `keys.ts` binds, and `live.ts` owns the
+ * tabs and the stream.
  *
- * Load order is a dependency: `team` takes helpers from `render`, and `live` starts
- * last, after every `board.*` handler it wires exists.
+ * Load order is a dependency: `card` and `team` take helpers from `render`, and `live`
+ * starts last, after every `board.*` handler it wires exists.
  */
 
 import { MATCHES_QUERY_JS } from "../../../lib/board/card.ts";
-import { CLIENT_RUNTIME_JS } from "../../../lib/web/index.ts";
-import { PLURAL_JS } from "../../../lib/board/round-text.ts";
+import { REASON_FOR_JS } from "../../../lib/board/reason.ts";
+import { DECISION_RANK_JS, DECISION_TONE_JS, REASON_TONE_JS } from "../../../lib/board/tone.ts";
+import { LANES } from "../../../lib/board/lanes.ts";
+import {
+	CLIENT_BASE_JS,
+	CLIENT_RUNTIME_JS,
+	dialogScript,
+	INLINE_MARKDOWN_JS,
+	keysDialogScript,
+	namesScript,
+	TAB_TITLE_JS,
+	THEME_TOGGLE_JS,
+} from "../../../lib/web/index.ts";
+import { PLURAL_JS, HISTORY_LINE_JS, HISTORY_OWNER_JS } from "../../../lib/board/round-text.ts";
+import { skippedText } from "../../../lib/board/skipped.ts";
 import { FORMAT_AGE_JS } from "../../../lib/format.ts";
-import { namesScript, TAB_TITLE_JS, THEME_TOGGLE_JS, dialogScript, keysDialogScript } from "../../../lib/web/index.ts";
+import { BOARD_CARD_JS } from "./card.ts";
 import { BOARD_CLASS } from "./names.ts";
-import { BOARD_DIALOG_JS } from "./dialog.ts";
+import { BOARD_EMPTY_JS } from "./empty.ts";
+import { dialogJs } from "./dialog.ts";
 import { BOARD_KEYS_JS } from "./keys.ts";
 import { BOARD_LIVE_JS } from "./live.ts";
 import { renderJs } from "./render.ts";
-import { BOARD_TEAM_JS } from "./team.ts";
+import { teamJs } from "./team.ts";
 
 /**
  * The whole client, in load order: paint, round, the card dialog, keys, wiring, start.
  *
- * Four rules cross the boundary as source — the count's wording, the tab title's
- * shape, what a `query` matches, and how an age reads: the browser has no import graph,
- * and a second copy of any of them is exactly what this bundle is not allowed to hold.
+ * Seven rules cross the boundary as source — the count's wording, the tab title's
+ * shape, what a `query` matches, why a card sits where it does, how an age reads, which
+ * owners a round may state once, and how that one line reads: the browser has no import
+ * graph, and a second copy of any of them is exactly what this bundle is not allowed to hold.
  */
-export const BOARD_CLIENT_JS = `${namesScript(BOARD_CLASS)}
-${renderJs({ plural: PLURAL_JS, tabTitle: TAB_TITLE_JS, matches: MATCHES_QUERY_JS, age: FORMAT_AGE_JS, runtime: CLIENT_RUNTIME_JS })}
-${BOARD_TEAM_JS}
-${BOARD_DIALOG_JS}
+export const BOARD_CLIENT_JS = `${CLIENT_BASE_JS}
+${namesScript(BOARD_CLASS)}
+${renderJs({ plural: PLURAL_JS, tabTitle: TAB_TITLE_JS, matches: MATCHES_QUERY_JS, reason: REASON_FOR_JS, age: FORMAT_AGE_JS, lanes: String(LANES.length), skipped: String(skippedText), decisions: DECISION_RANK_JS, decisionTones: DECISION_TONE_JS, reasonTones: REASON_TONE_JS, runtime: CLIENT_RUNTIME_JS })}
+${teamJs({ historyOwner: HISTORY_OWNER_JS, historyLine: HISTORY_LINE_JS })}
+${BOARD_CARD_JS}
+${BOARD_EMPTY_JS}
+${dialogJs({ inlineMarkdown: INLINE_MARKDOWN_JS })}
 ${BOARD_KEYS_JS}
 ${BOARD_LIVE_JS}
 ${THEME_TOGGLE_JS}