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

package/lib/board/view.ts

@@ -13,16 +13,25 @@
  * Pure: the caller supplies the cards, the clock, and the sizes it read.
  */
 
-import { type RosterSession, rosterStateOf } from "../session-roster.ts";
-import { type Card, CARD_STATUSES, type CardStatus, signatureOf } from "./card.ts";
+import { type RosterSession, type RosterState, rosterStateOf } from "../session-roster.ts";
+import {
+	type Card,
+	CARD_STATUSES,
+	type CardStatus,
+	laneSince,
+	priorityOf,
+	type Priority,
+	signatureOf,
+} from "./card.ts";
+import { blockersOf, indexOf, lanesText, openDependentsOf } from "./links.ts";
 import type { Actor } from "./rules.ts";
 import { buildRound, type RoundSummary } from "./round.ts";
 
 /** One session on the repository's bus, as the Team tab lists it. */
 export interface ViewTeammate {
 	label: string;
-	/** `live` while its heartbeat holds, `quiet` once the record has aged out. */
-	state: "live" | "quiet";
+	/** `live` while its heartbeat holds, `quiet` once the record has aged out, `gone` once its process is not running. */
+	state: RosterState;
 	/** When it last proved it was there. */
 	seen: number;
 	/** Messages waiting in its inbox. */
@@ -33,10 +42,47 @@ export interface ViewTeammate {
 	you: boolean;
 }
 
+/**
+ * One card as the page meets it: the stored card, plus the two answers it would
+ * otherwise compute for itself.
+ *
+ * Both are derived from the board, not stored on the card, so a client that did the
+ * same work would be a second copy of a rule — and the copies drift, which is how the
+ * page came to disagree with the tool about what a card waits for.
+ */
+export interface ViewCard extends Card {
+	/** The priority it acts on: a card that never set one is ordinary. */
+	priority: Priority;
+	/**
+	 * The unfinished cards it waits for, as `#2 (doing)`; absent when nothing blocks it.
+	 *
+	 * `undefined` is the whole fact — a waiting card is one with a `waits` — because a
+	 * boolean beside it would be one more thing that can disagree with the string.
+	 */
+	waits?: string;
+	/**
+	 * The unfinished cards waiting on it, as `#9 (todo)`; absent when none do.
+	 *
+	 * The other side of `waits`: what leaving this card undone holds up. Derived here
+	 * rather than in the page's script for the same reason, and filtered to the unfinished
+	 * for the same reason a finished blocker does not count.
+	 */
+	dependents?: string;
+	/**
+	 * When the card entered the lane it is in now, or absent when its history does not say.
+	 *
+	 * A timestamp rather than a phrase: the page already formats ages, and a wording
+	 * decided here would be a second copy of that rule. Absent is the honest answer for a
+	 * card written before the log existed, so the page draws no age rather than guessing
+	 * one from `updatedAt`, which moves on every write.
+	 */
+	since?: number;
+}
+
 /** One lane and the cards in it, in the order the page draws them. */
 export interface ViewLane {
 	status: CardStatus;
-	cards: Card[];
+	cards: ViewCard[];
 }
 
 /** The per-lane tallies the toolbar shows. */
@@ -56,7 +102,7 @@ export interface BoardView {
 	session?: { id?: string; label: string };
 	lanes: ViewLane[];
 	counts: ViewCounts;
-	round: RoundSummary;
+	round: RoundSummary<ViewCard>;
 	/**
 	 * The sessions on this repository's bus, or absent when there is no bus here.
 	 *
@@ -66,6 +112,13 @@ export interface BoardView {
 	teammates?: ViewTeammate[];
 	/** Bytes the store occupies, so a board that is never pruned says so. */
 	bytes: number;
+	/**
+	 * Card files the reader refused, so the footer can say the board is not empty.
+	 *
+	 * Zero is the ordinary answer and draws nothing; a count above it is the one fact
+	 * that separates "no work here" from "this build cannot read your work".
+	 */
+	skipped: number;
 	/** Changes when a card's revision, a teammate's state, or its mail does. */
 	sig: string;
 	/** The store's directory, shortened. */
@@ -86,6 +139,8 @@ export interface ViewInput {
 	cards: readonly Card[];
 	now: number;
 	bytes: number;
+	/** Card files the reader refused; absent reads as none, which is the ordinary board. */
+	skipped?: number;
 	where: string;
 	/** The bus's records, when the page could read them at all. */
 	roster?: readonly RosterSession[];
@@ -93,9 +148,16 @@ export interface ViewInput {
 
 /** Build the page's snapshot. */
 export function buildView(input: ViewInput): BoardView {
+	// One index for the whole snapshot: a card's lane and its blockers are read from the
+	// same board, so a dependency and its dependent cannot be told two different stories.
+	const index = indexOf(input.cards);
+	// One mapped list feeds both halves of the snapshot: the rollup's groups carry the same
+	// card the lane does, so a client reading `round.unassigned` is not handed a card
+	// missing the facts every other card has.
+	const cards = input.cards.map((card) => viewCardOf(card, index));
 	const lanes = CARD_STATUSES.map((status) => ({
 		status,
-		cards: input.cards.filter((card) => card.status === status),
+		cards: cards.filter((card) => card.status === status),
 	}));
 	const reader = input.session ?? input.me;
 	const teammates = input.roster === undefined ? undefined : teammatesOf(input.roster, reader.label, input.now);
@@ -104,16 +166,38 @@ export function buildView(input: ViewInput): BoardView {
 		...(input.session === undefined ? {} : { session: input.session }),
 		lanes,
 		counts: countOf(lanes),
-		round: buildRound(input.cards, input.now),
+		round: buildRound(cards, input.now),
 		...(teammates === undefined ? {} : { teammates }),
 		bytes: input.bytes,
+		skipped: input.skipped ?? 0,
 		// The roster enters the signature at its coarse facts only: a heartbeat every ten
-		// seconds is not news, while a join, a quiet and a letter are.
-		sig: signatureOf(input.cards) + rosterSignature(teammates),
+		// seconds is not news, while a join, a quiet and a letter are. A file that became
+		// readable, or unreadable, is news too: the footer counts it, and a frame that is
+		// not pushed leaves the page saying the board holds less than it does.
+		sig: signatureOf(input.cards) + rosterSignature(teammates) + `|skipped:${input.skipped ?? 0}`,
 		where: input.where,
 	};
 }
 
+/**
+ * One card for the page: what it carries, plus what it acts on.
+ *
+ * The card is copied rather than annotated — the caller's cards are the store's, and a
+ * derived field written onto one would outlive the read that made it.
+ */
+function viewCardOf(card: Card, index: ReadonlyMap<string, Card>): ViewCard {
+	const waits = lanesText(blockersOf(card, index));
+	const dependents = lanesText(openDependentsOf(card.id, index));
+	const since = laneSince(card);
+	return {
+		...card,
+		priority: priorityOf(card),
+		...(waits === "" ? {} : { waits }),
+		...(dependents === "" ? {} : { dependents }),
+		...(since === undefined ? {} : { since }),
+	};
+}
+
 /** The roster as the page shows it, ordered so a repaint never reorders it. */
 function teammatesOf(roster: readonly RosterSession[], meLabel: string, now: number): ViewTeammate[] {
 	return roster

package/lib/format.ts

@@ -53,6 +53,28 @@ export function formatDuration(ms: number): string {
 	return `${hours}h${String(minutes % 60).padStart(2, "0")}m`;
 }
 
+/**
+ * A coarse age, the way a reader says it: `now`, `3m`, `2h`, `5d`.
+ *
+ * One rule for both surfaces that print an age — a card's offer in the transcript, and
+ * the same card on the page — so one fact cannot read `2h ago` in a tool result and `3h`
+ * on the page. Written as concatenation because the page's bundle carries this function's
+ * *source* (`FORMAT_AGE_JS`): a backtick or an interpolation in it would end the string it
+ * is spliced into.
+ */
+export function formatAge(now: number, at: number): string {
+	const seconds = Math.max(0, Math.round((now - at) / 1000));
+	if (seconds < 45) return "now";
+	const minutes = Math.round(seconds / 60);
+	if (minutes < 60) return minutes + "m";
+	const hours = Math.round(minutes / 60);
+	if (hours < 24) return hours + "h";
+	return Math.round(hours / 24) + "d";
+}
+
+/** {@link formatAge} as the page's bundle receives it. */
+export const FORMAT_AGE_JS = String(formatAge);
+
 /** `1 tool`, `3 tools`: a tool count with the right word. */
 export function formatToolCount(count: number): string {
 	const n = Number.isFinite(count) ? Math.max(0, Math.trunc(count)) : 0;

package/lib/http/serve.ts

@@ -218,6 +218,9 @@ export async function serveLoopback(options: LoopbackOptions): Promise<LoopbackS
 		});
 	});
 	const port = await bindFirst(server, host, options.ports);
+	// The socket is bound but no page may ever read it: a server that asked for a first
+	// grace arms it here, so a browser that never came up cannot hold the port all session.
+	sinks.start();
 	const closeServer = createCloser(server);
 	let closed = false;
 	return {

package/lib/http/sink.ts

@@ -22,12 +22,23 @@ export interface EventSink {
 	end(frame?: string): void;
 }
 
+/** Why a server went idle: no stream ever opened, or the last one left. */
+export type IdleReason = "first" | "last";
+
 /** The idle policy a server was given, or none. */
 export interface IdleGrace {
 	/** How long the last stream's departure is held, in ms. */
 	ms: number;
-	/** Called once no stream has been open for `ms`. */
-	onIdle: () => void;
+	/**
+	 * How long a server may stand with no stream ever opened, in ms.
+	 *
+	 * A page opened in a browser that never came up would otherwise hold its port for the
+	 * rest of the session. Omitted, the grace still waits for the first stream, which is
+	 * what a server whose page is opened by hand wants.
+	 */
+	firstMs?: number;
+	/** Called once no stream has been open for the grace that applied. */
+	onIdle: (reason: IdleReason) => void;
 }
 
 /** What the registry needs besides the streams themselves. */
@@ -44,6 +55,8 @@ export interface SinkRegistry {
 	open(response: ServerResponse): EventSink;
 	/** How many streams are open. */
 	size(): number;
+	/** Arm the grace for a server nobody may ever read. Does nothing without `firstMs`. */
+	start(): void;
 	/** End every open stream, because the server is closing. */
 	endAll(): void;
 }
@@ -52,20 +65,24 @@ export function createSinks(deps: SinkDeps = {}): SinkRegistry {
 	const streams = new Set<EventSink>();
 	const timer = deps.timer ?? defaultTimer;
 	let cancelIdle: (() => void) | undefined;
-	/** A grace armed before any page ever attached would close a server nobody opened. */
+	/** A stream has attached at least once, so a departure is one to wait on. */
 	let sawStream = false;
+	/** The server asked for the first grace, so it may go idle without a reader. */
+	let started = false;
 
 	const standDown = (): void => {
 		cancelIdle?.();
 		cancelIdle = undefined;
 	};
 
-	const arm = (): void => {
-		const idle = deps.idle;
-		if (idle === undefined || !sawStream || streams.size > 0 || cancelIdle !== undefined) return;
-		cancelIdle = timer(idle.ms, () => {
+	/** Arm `ms` from now, unless a stream is open or a grace already runs. */
+	const arm = (ms: number, reason: IdleReason): void => {
+		if (deps.idle === undefined || (!started && !sawStream) || streams.size > 0 || cancelIdle !== undefined) return;
+		cancelIdle = timer(ms, () => {
 			cancelIdle = undefined;
-			if (streams.size === 0) deps.idle?.onIdle();
+			// A tab that attached while the grace ran has already stood it down, but a
+			// second look costs nothing and keeps a race from closing a page being read.
+			if (streams.size === 0) deps.idle?.onIdle(reason);
 		});
 	};
 
@@ -74,12 +91,20 @@ export function createSinks(deps: SinkDeps = {}): SinkRegistry {
 			standDown();
 			sawStream = true;
 			const sink = createSink(response, () => {
-				if (streams.delete(sink)) arm();
+				if (!streams.delete(sink)) return;
+				const idle = deps.idle;
+				if (idle !== undefined) arm(idle.ms, "last");
 			});
 			streams.add(sink);
 			return sink;
 		},
 		size: () => streams.size,
+		start() {
+			const idle = deps.idle;
+			if (idle?.firstMs === undefined || started || sawStream) return;
+			started = true;
+			arm(idle.firstMs, "first");
+		},
 		endAll() {
 			standDown();
 			const open = [...streams];

package/lib/plan-entry.ts

@@ -41,6 +41,17 @@ export const PLAN_CONSENT_SHORT =
 	"Enter read-only plan mode? Writes and mutating tools are disabled until you approve a plan.";
 export const PLAN_CONSENT_SHORT_ZH = "进入只读 plan 模式？批准计划前会禁用写入和修改。";
 
+/**
+ * The refusal a command shows when plan mode forbids what it does.
+ *
+ * Plan mode is read-only, so every extension whose command changes something says so the
+ * same way and names the action it is not doing: one sentence in `lib/`, because five
+ * copies is how the guarantee stops reading as one guarantee.
+ */
+export function planModeRefusal(action: string): string {
+	return `Plan mode is read-only. Approve the plan before ${action}.`;
+}
+
 /** What a caller sends on {@link PLAN_ENTER_REQUEST}. */
 export interface PlanEnterRequest {
 	/** The caller's context; `plan` uses it for the footer status. */

package/lib/policy.ts

@@ -15,7 +15,20 @@
  */
 
 import type { ToolAnnotations } from "@earendil-works/pi-coding-agent";
-import { READ_DOC_TOOL } from "./tool-names.ts";
+import { BOARD_READ_ACTION, READ_DOC_TOOL } from "./tool-names.ts";
+
+/**
+ * Whether a call to the `board` tool only reads it.
+ *
+ * The board is one tool over ten actions, so its `readOnlyHint` says "may write" and
+ * cannot answer this. The action can, and it travels in the call's input — and in the
+ * result's `details`, which is all a `tool_execution_end` event carries. Plan mode
+ * asks before the call and the todo nudge after it, so the answer lives here once.
+ */
+export function isBoardRead(call: unknown): boolean {
+	if (typeof call !== "object" || call === null) return false;
+	return (call as { action?: unknown }).action === BOARD_READ_ACTION;
+}
 
 /**
  * Tools that only read the workspace: the built-in structured readers and the

package/lib/session-roster.ts

@@ -9,6 +9,10 @@
  * here once, and `session-bus` imports them, so a layout change cannot land in one
  * copy and not the other.
  *
+ * The rule answers three things, not two: a record whose process is gone is `gone` at
+ * once, rather than aging into `quiet` for ten minutes while the paths it claimed stay
+ * held and the cards it held read `idle`.
+ *
  * A missing directory is an answer, not an error: it means no session has ever
  * joined this repository, and a caller renders that differently from an empty bus.
  *
@@ -18,6 +22,7 @@
 
 import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { isPidAlive, type LivenessFn, startTokenOf, type StartTokenFn } from "./spawn.ts";
 
 /** The bus directory under the agent dir, `session-bus`. */
 export const BUS_DIR_NAME = "session-bus";
@@ -37,6 +42,16 @@ export interface RosterSession {
 	lastSeen: number;
 	/** Messages waiting in its inbox. */
 	mail: number;
+	/**
+	 * The process that owns the record, when the record names one.
+	 *
+	 * Absent is "cannot tell": a record written before this existed, or by a mode that
+	 * is not a local process, is judged by its heartbeat alone rather than being called
+	 * dead on no evidence.
+	 */
+	pid?: number;
+	/** That process's start time, as the bus wrote it, when the record carries it. */
+	startToken?: string;
 	/**
 	 * Whether the session is listening for mail, when its record says.
 	 *
@@ -46,9 +61,56 @@ export interface RosterSession {
 	watching?: { armed: boolean; wake: boolean };
 }
 
-/** Whether a record's heartbeat is fresh enough to call the session live. */
-export function rosterStateOf(session: RosterSession, now: number, ttlMs = SESSION_TTL_MS): "live" | "quiet" {
-	return now - session.lastSeen <= ttlMs ? "live" : "quiet";
+/** What a record's heartbeat and its process say together. */
+export type RosterState = "live" | "quiet" | "gone";
+
+/**
+ * What a record's heartbeat and its process say together.
+ *
+ * The fields the rule reads, rather than the whole roster row: `session-bus` judges its
+ * own records by the same rule without carrying a `mail` count it never shows.
+ */
+export type RosterFacts = Pick<RosterSession, "lastSeen" | "pid" | "startToken">;
+
+/**
+ * The host facts {@link rosterStateOf} reads, injectable so every branch is testable.
+ *
+ * The token spawns a process, so it is asked for only where liveness cannot decide.
+ */
+export interface RosterSeams {
+	alive?: LivenessFn;
+	token?: StartTokenFn;
+}
+
+/**
+ * What one record says about its session: alive, aged out, or attached to nothing.
+ *
+ * Three answers, in the order they are decided:
+ *
+ * - `gone` — the record names a process and that process is not running. A heartbeat
+ *   written ten seconds before a crash is not evidence the process exists, so death
+ *   outranks a fresh one.
+ * - `live` — the heartbeat is fresh. When the pid is alive too, the start token has not
+ *   been asked for yet: a session that wrote ten seconds ago is not the interesting
+ *   case for pid reuse, and `ps` costs a process.
+ * - `quiet` — the heartbeat has aged. If the pid is alive but its start time is not the
+ *   one the record wrote, the process is somebody else's and the session is `gone`
+ *   after all; a platform that cannot answer the start time leaves it at `quiet`.
+ */
+export function rosterStateOf(
+	session: RosterFacts,
+	now: number,
+	ttlMs = SESSION_TTL_MS,
+	seams: RosterSeams = {},
+): RosterState {
+	const alive = seams.alive ?? isPidAlive;
+	if (session.pid !== undefined && !alive(session.pid)) return "gone";
+	if (now - session.lastSeen <= ttlMs) return "live";
+	if (session.pid !== undefined && session.startToken !== undefined) {
+		const current = (seams.token ?? startTokenOf)(session.pid);
+		if (current !== undefined && current !== session.startToken) return "gone";
+	}
+	return "quiet";
 }
 
 /** The fields this reader trusts; anything else in the file is the bus's business. */
@@ -59,6 +121,11 @@ interface SessionPayload {
 	lastSeen: number;
 }
 
+/** A record's pid, read only when it is the shape a pid has. */
+function pidOf(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
 function isSessionPayload(value: unknown): value is SessionPayload {
 	if (typeof value !== "object" || value === null) return false;
 	const { id, label, mode, lastSeen } = value as Record<string, unknown>;
@@ -117,12 +184,16 @@ export async function readRoster(dir: string): Promise<RosterSession[] | undefin
 		if (!isSessionPayload(parsed)) continue;
 		const { id, label, mode, lastSeen } = parsed;
 		const watching = watchingOf((parsed as { watching?: unknown }).watching);
+		const pid = pidOf((parsed as { pid?: unknown }).pid);
+		const rawToken = (parsed as { startToken?: unknown }).startToken;
 		sessions.push({
 			id,
 			label,
 			mode,
 			lastSeen,
 			mail: await mailCount(dir, name.slice(0, -".json".length)),
+			...(pid === undefined ? {} : { pid }),
+			...(typeof rawToken === "string" && rawToken !== "" ? { startToken: rawToken } : {}),
 			...(watching === undefined ? {} : { watching }),
 		});
 	}

package/lib/spawn.ts

@@ -8,11 +8,14 @@
  *
  * IO is split from the decision: {@link spawnOptions} and {@link killPlan} are
  * pure and testable on every platform, while {@link defaultSpawn} and
- * {@link defaultKillTree} execute them. Value-only, like every `lib/` module:
- * no module state, and each caller keeps its own children.
+ * {@link defaultKillTree} execute them. The liveness pair — {@link isPidAlive}
+ * and {@link startTokenOf} — is here too, because asking whether a process is
+ * still the one a record named is the same question as killing it: `job` guards
+ * a reattached pid with it, and so does the session roster. Value-only, like
+ * every `lib/` module: no module state, and each caller keeps its own children.
  */
 
-import { spawn as nodeSpawn, spawnSync } from "node:child_process";
+import { execFileSync, spawn as nodeSpawn, spawnSync } from "node:child_process";
 import type { Readable } from "node:stream";
 
 /**
@@ -124,6 +127,37 @@ export function isPidAlive(pid: number, probe: KillProbe = process.kill): boolea
 	}
 }
 
+/** Whether a pid is still alive. */
+export type LivenessFn = (pid: number) => boolean;
+
+/**
+ * Best-effort OS start-time token for a pid, used to detect pid reuse.
+ *
+ * Returns undefined when the platform cannot provide one (for example Windows, or a
+ * process that is already gone), in which case callers fall back to liveness alone.
+ */
+export type StartTokenFn = (pid: number) => string | undefined;
+
+/**
+ * Default start-time token via `ps`. Undefined where `ps` is unavailable.
+ *
+ * It spawns a process, so a caller asks for it only where liveness alone cannot
+ * decide: a pid that is alive may be a different program than the one a record
+ * named, and nothing cheaper than the start time can tell them apart.
+ */
+export const startTokenOf: StartTokenFn = (pid) => {
+	try {
+		const out = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+			stdio: ["ignore", "pipe", "ignore"],
+			timeout: 2000,
+		});
+		const text = out.toString().trim();
+		return text || undefined;
+	} catch {
+		return undefined;
+	}
+};
+
 /** The host seams {@link applyKillPlan} runs through. */
 export interface KillSeams {
 	/** Signal one pid; throws when the pid is gone or not ours. */

package/lib/stray-fields.ts

@@ -0,0 +1,45 @@
+/**
+ * A field a tool call carries but its action does not act on.
+ *
+ * An action-shaped tool publishes one flat parameter object, so every field is
+ * offered to every action at once; that is harmless only while each action reads
+ * its own. A field that reaches an action which never reads it used to be dropped
+ * in silence — `board add` with `dependsOn` wrote the card without the link and
+ * answered success, and `team offer` with `to` broadcast to every live session
+ * while the caller believed it had named one. The caller could not tell what was
+ * recorded from what was ignored, and nothing in the result said which.
+ *
+ * So the table of what each action reads lives with the tool (`ACTION_FIELDS`),
+ * and this is the sentence a call is refused with: it names every stray field and
+ * the action that does take it, which makes the retry one call away. The table is
+ * keyed in the order the actions are documented, because that order is how the
+ * message lists the verbs that take a field.
+ *
+ * Value-only, as `lib/` must be: the tables are the callers'.
+ */
+
+/** The fields each action reads, keyed in the order the actions are documented. */
+export type ActionFields = Readonly<Record<string, readonly string[]>>;
+
+/**
+ * Why a call carries a field its action does not act on, or nothing when it is clean.
+ *
+ * `undefined` is not a stray: an optional field the caller left out was never passed,
+ * and a schema makes every unset one `undefined`.
+ */
+export function strayField(action: string, args: Record<string, unknown>, fields: ActionFields): string | undefined {
+	const mine = fields[action] ?? [];
+	const stray = Object.entries(args)
+		.filter(([field, value]) => value !== undefined && field !== "action" && !mine.includes(field))
+		.map(([field]) => field);
+	if (stray.length === 0) return undefined;
+	// One stray reads as "takes it"; several need their names, or the sentence stops
+	// saying which field goes where.
+	const named = (field: string): string => {
+		const taking = Object.keys(fields).filter((candidate) => fields[candidate]?.includes(field));
+		if (taking.length === 0) return `${field} belongs to no action`;
+		const verbs = taking.map((one) => `\`${one}\``).join(" and ");
+		return `${verbs} ${taking.length === 1 ? "takes" : "take"} ${stray.length === 1 ? "it" : field}`;
+	};
+	return `${action} does not act on ${stray.join(", ")}: ${stray.map(named).join("; ")}.`;
+}

package/lib/tool-names.ts

@@ -45,6 +45,19 @@ export const SESSION_TOOL = "session";
  */
 export const SUBAGENT_READ_ONLY_PARAM = "readOnly";
 
+/**
+ * The `board` tool: the shared feature list. Plan mode keeps it active because its
+ * `list` action is a read of the repository's cards, so the name is shared while the
+ * write actions stay the board's to refuse.
+ */
+export const BOARD_TOOL = "board";
+
+/**
+ * The one `board` action that reads. Plan mode admits it and refuses the rest, which
+ * is the distinction the tool's `readOnlyHint` cannot carry: the same tool writes.
+ */
+export const BOARD_READ_ACTION = "list";
+
 /**
  * The `read_doc` tool. `file-read` registers it, and the plan, rewind, and
  * subagent reader lists carry the name, so the document reader is one reader

package/lib/tui/glyphs.ts

@@ -30,7 +30,7 @@ export const GLYPHS = {
 	jobsFailure: "✗",
 	stopped: "⊘",
 	browse: "◉",
-	board: "▤",
+	board: "⊞",
 	delegation: "↳",
 	wechat: "✆",
 	gaugeFull: "▰",
@@ -57,10 +57,9 @@ export const GLYPHS = {
 /** Columns between a rail body glyph and its text. */
 export const GLYPH_GAP = 1;
 
-/** Padding used to join (`item`) or group (`group`) UI segments. */
+/** Padding used to join UI segments. */
 export const SEPARATORS = {
 	item: " · ",
-	group: ` ${GLYPHS.divider} `,
 } as const;
 
 /** `ctx.ui.setStatus` keys; one per extension that publishes a chip. */