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

package/extensions/subagent/{background-tui.ts → view/agents-board.ts}

@@ -14,15 +14,15 @@
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { sanitizeLine, stripControlChars } from "../../lib/format.ts";
-import type { ScreenHint, ViewportRowsSource } from "../../lib/tui/chrome.ts";
-import { DockListScreen, type DetailContents } from "../../lib/tui/dock-screen.ts";
-import { GLYPHS, SEPARATORS } from "../../lib/tui/glyphs.ts";
-import { keyValueRow, statusRow } from "../../lib/tui/rows.ts";
-import { paint, type TuiRole } from "../../lib/tui/tokens.ts";
-import type { BackgroundRun, BackgroundStatus } from "./background.ts";
-import { canCollect } from "./background.ts";
-import { formatBackgroundDuration, formatUsageStats } from "./format.ts";
+import { sanitizeLine, stripControlChars } from "../../../lib/format.ts";
+import type { ScreenHint, ViewportRowsSource } from "../../../lib/tui/chrome.ts";
+import { DockListScreen, type DetailContents } from "../../../lib/tui/dock-screen.ts";
+import { GLYPHS, SEPARATORS } from "../../../lib/tui/glyphs.ts";
+import { keyValueRow, statusRow } from "../../../lib/tui/rows.ts";
+import { paint, type TuiRole } from "../../../lib/tui/tokens.ts";
+import type { BackgroundRun, BackgroundStatus } from "../background.ts";
+import { canCollect } from "../background.ts";
+import { formatBackgroundDuration, formatUsageStats } from "../format.ts";
 
 /** One status's glyph, role, and readable label. */
 function statusView(status: BackgroundStatus): { glyph: string; role: TuiRole; label: string } {
@@ -164,7 +164,7 @@ export class AgentsBoardComponent extends DockListScreen<BackgroundRun> {
 		const focused = this.focusedRow;
 		const hints: ScreenHint[] = ["Esc close", { text: "Enter detail", color: "accent" }];
 		if (focused && canCollect(focused)) hints.push({ text: "c collect", color: "accent" });
-		if (focused?.status === "running") hints.push({ text: "x cancel", color: "warning" });
+		if (focused?.status === "running") hints.push({ text: "x cancel", color: "warn" });
 		hints.push("↑/↓ select");
 		return hints;
 	}
@@ -172,7 +172,7 @@ export class AgentsBoardComponent extends DockListScreen<BackgroundRun> {
 	protected detailHints(run: BackgroundRun | undefined): ScreenHint[] {
 		const hints: ScreenHint[] = ["Esc back"];
 		if (run && canCollect(run)) hints.push({ text: "c collect", color: "accent" });
-		if (run?.status === "running") hints.push({ text: "x cancel", color: "warning" });
+		if (run?.status === "running") hints.push({ text: "x cancel", color: "warn" });
 		hints.push("j/k scroll");
 		return hints;
 	}

package/extensions/team/commands.ts

@@ -5,7 +5,7 @@
  * open a browser to see what needs a decision, so the command prints the rollup the
  * tool returns, the work a dead owner left behind, and one line saying who is live. It
  * reads the cards and the bus's records and writes nothing: acting on the round is
- * `team`'s tool (`assign`, `reclaim`) or `board`'s.
+ * `team`'s tool (`assign`, `offer`, `reclaim`, `claim`) or `board`'s.
  */
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
@@ -13,8 +13,9 @@ import { type Card, cardRef } from "../../lib/board/card.ts";
 import { buildRound } from "../../lib/board/round.ts";
 import { formatRound, plural } from "../../lib/board/round-text.ts";
 import type { BoardSession } from "../../lib/board/session.ts";
-import { createTeamJoin, type JoinResult, type TeamJoin } from "../../lib/session-tool.ts";
+import { createTeamJoin, type JoinResult, type TeamJoin, type TeamJoinInput } from "../../lib/session-tool.ts";
 import { readRoster, type RosterSession, rosterStateOf } from "../../lib/session-roster.ts";
+import { sessionNameOf } from "../../lib/session-label.ts";
 import { formatJoined, formatNotJoined } from "./format.ts";
 
 /** The command's name, which is also the word a user types. */
@@ -40,7 +41,13 @@ export function registerCommands(pi: ExtensionAPI, session: BoardSession, deps:
 			const [word = "", ...rest] = args.trim().split(/\s+/).filter(Boolean);
 			if (word === "join") {
 				const label = rest.join(" ").trim();
-				const joined = await team.join(ctx, label === "" ? undefined : label);
+				// A typed label is the one naming action: it is also Pi's session name, which is what
+				// `/team join` is for. With no label, a session Pi already names keeps that name and
+				// the bus derives it; one with no name of its own draws a preset teammate name
+				// instead of landing on the repository's basename, and the drawn name renames nothing
+				// because it is the team's, not the user's.
+				const input: TeamJoinInput = label === "" ? await unnamedJoin(session, ctx) : { label, name: true };
+				const joined = await team.join(ctx, input);
 				ctx.ui.notify(joinedLine(joined), joined.ok ? "info" : "warning");
 				return;
 			}
@@ -61,6 +68,18 @@ export function registerCommands(pi: ExtensionAPI, session: BoardSession, deps:
 	});
 }
 
+/**
+ * What a bare `/team join` asks for: nothing, when Pi already names the session and the
+ * bus can derive that, and otherwise the name the board draws for it.
+ *
+ * A drawn name is the team's, not the user's, so `name` is never set here: only a typed
+ * label is meant to rename the footer.
+ */
+async function unnamedJoin(session: BoardSession, ctx: ExtensionCommandContext): Promise<TeamJoinInput> {
+	if ((sessionNameOf(ctx) ?? "").trim() !== "") return {};
+	return { label: (await session.who(ctx, ctx.cwd)).label };
+}
+
 /** `/team join`'s line: who this session is on the team, or why it is on none. */
 export function joinedLine(result: JoinResult): string {
 	return result.ok ? formatJoined(result.label, result.watching) : formatNotJoined(result.error);
@@ -74,7 +93,7 @@ export function joinedLine(result: JoinResult): string {
  */
 export function roundText(cards: readonly Card[], now: number, roster?: readonly RosterSession[]): string {
 	if (cards.length === 0) return "team: nothing to report — the board is empty";
-	const round = formatRound(cards, buildRound(cards, now)).split("\n");
+	const round = formatRound(cards, buildRound(cards, now), roster).split("\n");
 	const shown = round.slice(0, MAX_ROUND_LINES);
 	if (round.length > MAX_ROUND_LINES) shown.push(`… ${plural(round.length - MAX_ROUND_LINES, "line")} more`);
 	for (const line of goneLines(cards, roster, now)) shown.push(line);
@@ -99,7 +118,7 @@ function goneLines(cards: readonly Card[], roster: readonly RosterSession[] | un
 	if (gone.size === 0) return [];
 	const byOwner = new Map<string, string[]>();
 	for (const card of cards) {
-		if (card.owner === undefined || card.status === "done") continue;
+		if (card.owner === undefined || card.lane === "done") continue;
 		const label = gone.get(card.owner.label.toLowerCase());
 		if (label === undefined) continue;
 		byOwner.set(label, [...(byOwner.get(label) ?? []), cardRef(card.id)]);

package/extensions/team/dispatch.ts

@@ -14,6 +14,7 @@
 import type { ExtensionToolContext } from "@earendil-works/pi-coding-agent";
 import type { Card } from "../../lib/board/card.ts";
 import { cardRef, type CardOwner } from "../../lib/board/card.ts";
+import type { Actor } from "../../lib/board/rules.ts";
 import { listPeers, MAX_MESSAGE_TEXT, type Peer, send as sendTo } from "../../lib/session-tool.ts";
 
 /** How a handoff reaches a peer, and what the bus can say about the peers there are. */
@@ -42,9 +43,9 @@ export function handoffText(card: Card, to: string, note?: string): string {
 	const lines = [
 		`Handoff: ${cardRef(card.id)} "${card.title}" is yours, ${to}.`,
 		card.paths.length > 0 ? `Paths: ${card.paths.join(", ")}` : undefined,
-		card.plan === undefined ? undefined : `Plan: ${card.plan}`,
+		card.planPath === undefined ? undefined : `Plan: ${card.planPath}`,
 		note === undefined ? undefined : `Note: ${note}`,
-		`It is already assigned to you — record the plan with board action "plan" if it has none, then note each phase and move it to done or blocked.`,
+		`It is already assigned to you — write its contract with board action "contract" if it has none, then note each phase and move it to execute, blocked, or done.`,
 	].filter((line): line is string => line !== undefined);
 	return withinLimit(lines.join("\n"));
 }
@@ -60,9 +61,9 @@ export function offerText(card: Card, note?: string): string {
 	const lines = [
 		`Offer: ${cardRef(card.id)} "${card.title}" is unclaimed.`,
 		card.paths.length > 0 ? `Paths: ${card.paths.join(", ")}` : undefined,
-		card.plan === undefined ? undefined : `Plan: ${card.plan}`,
+		card.planPath === undefined ? undefined : `Plan: ${card.planPath}`,
 		note === undefined ? undefined : `Note: ${note}`,
-		`First to claim it takes it: run board action "claim" with card "${card.id}", then note each phase and move it to done or blocked.`,
+		`First to claim it takes it: run board action "claim" with card "${card.id}", then write its contract and move it on from plan.`,
 	].filter((line): line is string => line !== undefined);
 	return withinLimit(lines.join("\n"));
 }
@@ -123,6 +124,19 @@ export function notListening(peers: readonly Peer[] | undefined, labels: readonl
 	});
 }
 
+/**
+ * The actor a handoff names: the peer the bus lists, else the label that was asked for.
+ *
+ * `team assign` checks the card against this before it sends anything and records the same
+ * actor afterwards, so the check and the write cannot disagree about who `to` is. That is
+ * what makes an id the holder: a card records the id the bus gave it, `holds` compares ids
+ * first, and only the resolved actor carries one.
+ */
+export function actorFor(peers: readonly Peer[] | undefined, to: string): Actor {
+	const peer = peerFor(peers, to);
+	return peer === undefined ? { label: to.trim() } : { id: peer.id, label: peer.label };
+}
+
 /**
  * The peer a handoff names, as the card records it when the bus cannot say who that
  * is: the label a message file was written for, else the one that was asked for.

package/extensions/team/format.ts

@@ -113,7 +113,22 @@ export function formatRacedAssignment(card: Card, to: string, reason: string): s
 	);
 }
 
-/** A card taken back to To do. */
+/** A card taken back to the pool. */
 export function formatReclaimed(card: Card, previous: string): string {
-	return `${cardRef(card.id)} reclaimed from ${previous} and back in To do; its notes are kept.\n  ${card.title}`;
+	return `${cardRef(card.id)} reclaimed from ${previous} and back in Backlog; its notes are kept.\n  ${card.title}`;
+}
+
+/**
+ * A card the lead took itself.
+ *
+ * The next step is the board's, so it is named: a claim is the one round action that
+ * leaves a card in `plan` waiting on its owner, and a line that stopped at "yours" would
+ * leave the lead holding a card nobody said what to do with.
+ */
+export function formatClaimed(card: Card): string {
+	return (
+		`${cardRef(card.id)} is yours, in plan.\n` +
+		`  ${card.title}\n` +
+		`  next: design it in plan mode, \`plan\` action \`write\`, then \`board\` action \`contract\``
+	);
 }

package/extensions/team/index.ts

@@ -1,18 +1,19 @@
 /**
  * team — the lead's round over the shared board.
  *
- * `board` owns the cards and never touches the session bus; `team` owns the two
- * actions that need it. `assign` hands a card to a session that is already running
- * and sends it a handoff — dispatch cannot start a peer's turn, and the page and the
- * docs say so — and `reclaim` takes a card back when its owner is gone or has gone quiet.
+ * `board` owns the cards; `team` owns the leads round over them. `assign` hands a card to
+ * a session that is already running and sends it a handoff — dispatch cannot start a
+ * peer's turn, and the page and the docs say so — `offer` broadcasts one to whoever is
+ * free, `reclaim` takes one back when its owner is gone or has gone quiet, and `claim`
+ * takes one for the lead itself. The card's life after that is `board`'s.
  * Its one
  * command, `/team`, prints the round the board's Team tab draws, without a browser.
  *
- * Either extension works without the other: `board` is the work list any session
- * uses, and `team` is the lead's. The factory only registers; the store is opened on
- * first use.
+ * Either extension works without the other: `board` is the work list, and `team` is
+ * the lead's half of it; both are opt-in, so a session names the ones it runs. The
+ * factory only registers; the store is opened on first use.
  *
- * Load with:  pi --extension ./extensions/team --extension ./extensions/session-bus
+ * Load with:  PI_ENABLED_EXTENSIONS=board,team pi --extension ./extensions/team --extension ./extensions/session-bus
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";

package/extensions/team/schema.ts

@@ -1,9 +1,9 @@
 /**
- * The `team` tool's parameters: two actions over one card.
+ * The `team` tool's parameters: four actions over one card.
  *
- * `assign` names the peer a handoff goes to, and `reclaim` takes a card back. Both
- * take the card the way `board` does — `4` or `#4` — because a lead reads ids off
- * the same board.
+ * `assign` names the peer a handoff goes to, and `reclaim` takes a card back; `claim`
+ * takes one for the lead. All of them take the card the way `board` does — `4` or `#4` —
+ * because a lead reads ids off the same board.
  */
 
 import { Type } from "typebox";
@@ -16,7 +16,8 @@ export const TeamParams = Type.Object({
 			description:
 				"`assign` hands a card to a running session and sends it a handoff; `offer` broadcasts an unclaimed card to " +
 				"every other live session and writes nothing, so the first to claim it takes it; `reclaim` takes a card back " +
-				"to To do. A lead's three actions — use `board` to create, claim, move, note, and finish the cards themselves.",
+				"to Backlog; `claim` takes one for the lead itself, which then plans and records it with `board`. They are " +
+				"the round's four verbs: `board` creates, plans, moves, and finishes the cards, and the page is a view.",
 		},
 	),
 	card: Type.String({ description: 'The card to act on, e.g. "4" or "#4".' }),

package/extensions/team/tools.ts

@@ -1,32 +1,45 @@
 /**
  * The `team` tool: the lead's round over the same cards `board` owns.
  *
- * Two actions, because those are the two that need the bus. `assign` sends the
- * handoff **first** and sets the owner **second**: a card assigned without a message
- * is a card nobody knows about, while a message for a card that then changed is one
- * the peer can still claim. Either failure is reported with the card as it actually
- * is, so the lead's next call starts from the truth.
+ * Four actions, because they are the four a lead takes at the round: hand a card out,
+ * offer it, take one back, and take one itself. `assign` sends the handoff **first** and
+ * sets the owner **second**: a card assigned without a message is a card nobody knows
+ * about, while a message for a card that then changed is one the peer can still claim.
+ * Either failure is reported with the card as it actually is, so the lead's next call
+ * starts from the truth.
  *
- * `reclaim` needs no message — it is the compensation for a dispatch that did not
- * land — and it belongs here rather than in `board` because it only makes sense in
- * the lead's context.
+ * `claim` is the lead's own work, and it is the same store operation `board`'s claim
+ * makes, so the lane rules, the WIP limit, and the offer record cleared are the store's —
+ * not a second answer the round would keep in step by hand. Everything after the claim
+ * (plan, contract, move, finish) is `board`'s, because that is the card's life and not
+ * the round's.
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Static } from "typebox";
 import { type Card, cardRef, normalizeCardId } from "../../lib/board/card.ts";
 import { indexOf } from "../../lib/board/links.ts";
-import { type Actor, applyOp } from "../../lib/board/rules.ts";
+import { type Actor, mayOp } from "../../lib/board/rules.ts";
 import type { BoardSession } from "../../lib/board/session.ts";
 import type { BoardStore } from "../../lib/board/store.ts";
 import { messageOf } from "../../lib/errors.ts";
+import type { TeamJoin } from "../../lib/session-tool.ts";
 import { failedResult, type ToolFailure, textResult } from "../../lib/tool-result.ts";
 import { reuseText, toolDetails } from "../../lib/tui/chrome.ts";
 import { callLine, detailsOrLine } from "../../lib/tui/tool.ts";
 import { plural } from "../../lib/board/round-text.ts";
 import { strayField } from "../../lib/stray-fields.ts";
-import { type Dispatch, handoffText, notListening, offerText, ownerFor, peerFor, sessionDispatch } from "./dispatch.ts";
 import {
+	actorFor,
+	type Dispatch,
+	handoffText,
+	notListening,
+	offerText,
+	ownerFor,
+	sessionDispatch,
+} from "./dispatch.ts";
+import {
+	formatClaimed,
 	formatHandoff,
 	formatHandoffFailure,
 	formatOffer,
@@ -64,10 +77,19 @@ function callSubject(action: TeamAction, args: Record<string, unknown>): string
 export interface TeamToolsDeps {
 	/** Test seam: the handoff transport. */
 	dispatch?: (ctx: Parameters<typeof sessionDispatch>[0]) => Dispatch;
+	/** Test seam: the join a claim makes, so a suite records it instead of asking a bus. */
+	team?: TeamJoin;
 }
 
 export function registerTools(pi: ExtensionAPI, session: BoardSession, deps: TeamToolsDeps = {}): void {
 	const dispatchFor = deps.dispatch ?? sessionDispatch;
+	/** The join, built on the first claim: a round that never takes a card pays nothing. */
+	let joinBuilder: Promise<TeamJoin> | undefined;
+	const teamFor = (): Promise<TeamJoin> => {
+		if (deps.team !== undefined) return Promise.resolve(deps.team);
+		joinBuilder ??= import("../../lib/session-tool.ts").then(({ createTeamJoin }) => createTeamJoin(pi));
+		return joinBuilder;
+	};
 
 	pi.registerTool({
 		name: TEAM_TOOL,
@@ -75,13 +97,16 @@ export function registerTools(pi: ExtensionAPI, session: BoardSession, deps: Tea
 		description:
 			"Run a round of work over the shared board: `assign` hands a card to a running session and sends it a handoff " +
 			"(`to` is a teammate's label or id, as `/team` lists them); `offer` broadcasts an unclaimed card to every other " +
-			"live session and writes nothing, so the first to claim it takes it; `reclaim` takes a card back to To do and " +
-			"sends nothing, so it needs no team. Use `board` for everything else. Nothing here starts a peer's turn: a " +
-			"message waits in its inbox, and a peer that is listening reports it at its next turn.",
-		promptSnippet: "Run a round over the board: assign a card to a running session, offer one, or reclaim one.",
+			"live session and writes nothing, so the first to claim it takes it; `reclaim` takes a card back to Backlog and " +
+			"sends nothing, so it needs no team; `claim` takes one for yourself, and the card's plan, contract, moves, and " +
+			"finish are `board`'s. Nothing here starts a peer's turn: a message waits in its inbox, and a peer that is " +
+			"listening reports it at its next turn.",
+		promptSnippet:
+			"Run a round over the board: assign a card to a running session, offer one, reclaim one, or claim one.",
 		promptGuidelines: [
 			"Open the board with `/board` or work a card first, so this session and its peers are on the team.",
-			"Offer a card nobody has taken; assign one you mean a particular peer to hold.",
+			"Offer a card nobody has taken; assign one you mean a particular peer to hold; claim one you will take " +
+				"yourself, then plan and record it with `board`.",
 			"When a result says `Not listening`, say so: the message waits for that peer's next turn.",
 			"Reclaim a card whose owner is gone or has gone quiet rather than editing someone else's work. A " +
 				"`gone:` owner's process is not running, so what it held is anyone's to reclaim.",
@@ -102,12 +127,13 @@ export function registerTools(pi: ExtensionAPI, session: BoardSession, deps: Tea
 			if (stray !== undefined) return refusal(action, stray);
 			const id = normalizeCardId(args.card);
 			if (id === undefined) return refusal(action, `"${String(args.card)}" is not a card id.`);
-			const me = session.who(ctx, ctx.cwd);
+			const me = await session.who(ctx, ctx.cwd);
 			try {
 				const store = await session.store(ctx.cwd);
 				const now = session.now();
 				if (action === "reclaim") return await reclaimCard(store, me, id, now);
 				if (action === "offer") return await offerCard(store, me, id, args.note, now, dispatchFor(ctx));
+				if (action === "claim") return await claimCard(store, session, teamFor, ctx, me, id, now);
 				const to = typeof args.to === "string" ? args.to.trim() : "";
 				if (to === "") return refusal("assign", 'assign needs a peer: pass `to`, e.g. "billing-core".');
 				return await assignCard(store, me, id, to, args.note, now, dispatchFor(ctx));
@@ -134,8 +160,9 @@ export function registerTools(pi: ExtensionAPI, session: BoardSession, deps: Tea
 /**
  * `assign`: check the preconditions, send the handoff, then set the owner.
  *
- * The preconditions are checked with the same `applyOp` the store will use, so an
- * assignment the rules would refuse never sends a message at all.
+ * The preconditions are checked with `mayOp`, the same decision the store's `applyOp` will
+ * make — and with the store's own limits, so a configured WIP cap is the one the precheck
+ * sees — so an assignment the rules would refuse never sends a message at all.
  */
 async function assignCard(
 	store: BoardStore,
@@ -148,11 +175,21 @@ async function assignCard(
 ): Promise<ReturnType<typeof textResult<TeamDetails>> | ToolFailure<TeamDetails>> {
 	const card = await store.read(id);
 	if (!card) return refusal("assign", `${cardRef(id)} does not exist.`);
-	const owner: Actor = { label: to };
-	// The board, not just the card: a card that waits on unfinished work is refused here,
-	// so a handoff for it is never sent.
-	const dry = applyOp(card, { kind: "assign", to: owner }, me, now, indexOf(await store.list()));
-	if (!dry.ok) return refusal("assign", dry.error, card);
+	// A handoff to yourself is not a claim: it writes a message into your own inbox and
+	// records you as the owner without the claim's next step. `claim` is that act.
+	if (namesSelf(me, to))
+		return refusal("assign", `${cardRef(id)} cannot be handed to yourself: \`claim\` takes one.`, card);
+	// Who `to` names, asked before the check and once: a card records the id the bus gave its
+	// holder, and `holds` compares ids first, so an id the caller typed has to be resolved to
+	// the peer it names rather than compared as a label. The same actor is what the write
+	// records, so the check and the write cannot disagree about who `to` is.
+	const peers = await dispatch.peers().catch(() => undefined);
+	const target = actorFor(peers, to);
+	// The board, not just the card: a card that waits on unfinished work, or a `plan` lane
+	// with no room, is refused here, so a handoff for it is never sent. `mayOp` is the
+	// store's own check without the write, and the board's settings are the store's, not a default.
+	const refused = mayOp(card, { kind: "assign", to: target }, me, indexOf(await store.list()), store.config());
+	if (refused !== undefined) return refusal("assign", refused, card);
 
 	let delivered: string[];
 	try {
@@ -161,14 +198,12 @@ async function assignCard(
 		return refusal("assign", formatHandoffFailure(card, to, messageOf(error)), card);
 	}
 
-	// Ask the bus which session answers to the label: an owner recorded with its id
-	// survives the peer renaming itself, which a label alone does not — and the same read
-	// says whether that peer will be woken by the message it just got.
-	const peers = await dispatch.peers().catch(() => undefined);
-	const peer = peerFor(peers, to);
+	// The owner a handoff records: the resolved peer, whose id survives the peer renaming
+	// itself, or the label a message file was written for when the bus could not say who that
+	// is. The same read also says whether that peer will be woken by the message it just got.
 	const applied = await store.mutate(
 		id,
-		{ kind: "assign", to: peer === undefined ? ownerFor(to, delivered) : { id: peer.id, label: peer.label } },
+		{ kind: "assign", to: target.id === undefined ? ownerFor(to, delivered) : target },
 		me,
 		now,
 	);
@@ -184,15 +219,6 @@ async function assignCard(
 	});
 }
 
-/**
- * The actor an offer's preconditions are judged as: nobody in particular.
- *
- * `claim` is what the offer asks a peer to do, so the dry run is a claim by someone who
- * holds nothing — the rules' own refusals decide whether a card may be offered at all,
- * without a second copy of the sentences.
- */
-const OFFER_CLAIMANT: Actor = { label: "*" };
-
 /**
  * `offer`: check the claim's preconditions, broadcast the card, then record the offer.
  *
@@ -212,10 +238,11 @@ async function offerCard(
 ): Promise<ReturnType<typeof textResult<TeamDetails>> | ToolFailure<TeamDetails>> {
 	const card = await store.read(id);
 	if (!card) return refusal("offer", `${cardRef(id)} does not exist.`);
-	// The board, not just the card: a card that waits on unfinished work, or one somebody
-	// holds, is refused here, so a broadcast for it is never sent.
-	const dry = applyOp(card, { kind: "claim" }, OFFER_CLAIMANT, now, indexOf(await store.list()));
-	if (!dry.ok) return refusal("offer", dry.error, card);
+	// The board, not just the card: a card that waits on unfinished work, one somebody
+	// holds, or a `plan` lane with no room is refused here, so a broadcast for it is never
+	// sent. This is the offer's own rule, asked without the write.
+	const refused = mayOp(card, { kind: "offer" }, me, indexOf(await store.list()), store.config());
+	if (refused !== undefined) return refusal("offer", refused, card);
 
 	let delivered: string[];
 	try {
@@ -237,7 +264,41 @@ async function offerCard(
 	});
 }
 
-/** `reclaim`: the owner clears and the card returns to To do, notes and all. */
+/** Whether `to` names this session: its id, or its label ignoring case. */
+function namesSelf(me: Actor, to: string): boolean {
+	const target = to.trim();
+	return (me.id !== undefined && target === me.id) || target.toLowerCase() === me.label.toLowerCase();
+}
+
+/**
+ * `claim`: the lead takes a card itself, through the store operation `board`'s claim makes.
+ *
+ * The lane rules, the WIP limit, the waiting refusal, and the offer record cleared are the
+ * store's, so the two doors cannot answer them differently. The join is the claim's one
+ * side effect outside the card: taking work is what makes this session a teammate, and it
+ * is the same ask-once call `board` makes.
+ */
+async function claimCard(
+	store: BoardStore,
+	session: BoardSession,
+	teamFor: () => Promise<TeamJoin>,
+	ctx: ExtensionContext,
+	me: Actor,
+	id: string,
+	now: number,
+): Promise<ReturnType<typeof textResult<TeamDetails>> | ToolFailure<TeamDetails>> {
+	const before = await store.read(id);
+	if (!before) return refusal("claim", `${cardRef(id)} does not exist.`);
+	const result = await store.mutate(id, { kind: "claim" }, me, now);
+	if (!result.ok) return refusal("claim", result.error, result.card ?? before);
+	// Both loaded here, not at registration: a round that never takes a card pays nothing
+	// for the bus, and the registration graph stays the size it was.
+	const { joinOnce } = await import("../../lib/board/join.ts");
+	await joinOnce(session.team, await teamFor(), ctx, me.label);
+	return textResult(formatClaimed(result.card), { action: "claim", card: result.card });
+}
+
+/** `reclaim`: the owner clears and the card returns to the pool, notes and all. */
 async function reclaimCard(
 	store: BoardStore,
 	me: Actor,
@@ -257,11 +318,12 @@ async function reclaimCard(
 function summaryOf(details: TeamDetails): string {
 	const card = details.card;
 	if (!card) return details.action === "reclaim" ? "reclaimed" : "handed off";
+	if (details.action === "claim") return `${cardRef(card.id)} claimed`;
 	if (details.action === "offer") {
 		const count = details.delivered?.length ?? 0;
 		return `${cardRef(card.id)} offered to ${plural(count, "session")}`;
 	}
 	const who = details.assigned?.label ?? card.owner?.label;
 	const target = details.action === "assign" && who !== undefined ? ` → ${who}` : "";
-	return `${cardRef(card.id)} ${card.status}${target}`;
+	return `${cardRef(card.id)} ${card.lane}${target}`;
 }

package/extensions/team/types.ts

@@ -13,8 +13,8 @@ import type { CardOwner } from "../../lib/board/card.ts";
 /** The tool's name. `board` owns the cards; `team` owns the round. */
 export const TEAM_TOOL = "team";
 
-/** The three actions: the lead's whole surface — hand out, offer, take back. */
-export const TEAM_ACTIONS = ["assign", "offer", "reclaim"] as const;
+/** The four actions: the lead's round — hand out, offer, take back, and take one itself. */
+export const TEAM_ACTIONS = ["assign", "offer", "reclaim", "claim"] as const;
 
 /** One action. */
 export type TeamAction = (typeof TEAM_ACTIONS)[number];
@@ -57,6 +57,7 @@ export const ACTION_FIELDS: Record<TeamAction, readonly string[]> = {
 	assign: ["card", "to", "note"],
 	offer: ["card", "note"],
 	reclaim: ["card"],
+	claim: ["card"],
 };
 
 /** Whether a value is one of the actions, so an unknown one is a refusal and not a crash. */

package/extensions/todo/commands.ts

@@ -3,10 +3,8 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { withRailsSuppressed } from "../../lib/rails.ts";
 import { formatTodoList, progressSummary } from "./format.ts";
 import type { TodoRuntime } from "./runtime.ts";
-import { TodoListComponent } from "./tui.ts";
 
 export function registerCommands(pi: ExtensionAPI, runtime: TodoRuntime): void {
 	pi.registerCommand("todos", {
@@ -17,6 +15,10 @@ export function registerCommands(pi: ExtensionAPI, runtime: TodoRuntime): void {
 				ctx.ui.notify(todos.length === 0 ? "No todos." : `${progressSummary(todos)}\n${formatTodoList(todos)}`, "info");
 				return;
 			}
+			// The screen and its rails wrapper are the TUI's: the listing above and
+			// registration load neither.
+			const { withRailsSuppressed } = await import("../../lib/rails.ts");
+			const { TodoListComponent } = await import("./view/todo-screen.ts");
 			let unsubscribe: (() => void) | undefined;
 			try {
 				await withRailsSuppressed(pi, () =>

package/extensions/todo/format.ts

@@ -5,11 +5,22 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { GLYPH_GAP, GLYPHS } from "../../lib/tui/glyphs.ts";
+import { listRow } from "../../lib/tui/rows.ts";
 import { overflowHint } from "../../lib/tui/tool.ts";
 import { paint, type TuiRole } from "../../lib/tui/tokens.ts";
 import { completedCount, currentTodo } from "./state.ts";
 import type { Todo, TodoStatus } from "./types.ts";
 
+/** One indented item line, clipped to `width`. */
+export function todoRow(todo: Todo, theme: Theme, width: number): string {
+	return listRow(theme, width, {
+		glyph: todoGlyphChar(todo),
+		glyphRole: todoGlyphRole(todo),
+		label: todoLabelText(todo),
+		labelRole: todoLabelRole(todo),
+	});
+}
+
 /** Sort order so the widget and transcript surface current work before finished rows. */
 const STATUS_ORDER: Record<TodoStatus, number> = { in_progress: 0, pending: 1, completed: 2 };
 

package/extensions/todo/render.ts

@@ -0,0 +1,57 @@
+/**
+ * The `TodoResult` transcript block: the indented glyph rail over the todo list.
+ *
+ * `render` runs on every frame Pi draws, for every block in the transcript, so
+ * the rail is memoized on the width (`RenderCache`) and rebuilt only when
+ * `setInput` hands over a new list or `invalidate` says the theme moved.
+ *
+ * This module is on the registration path — the `todo` tool's `renderResult`
+ * needs the class — while the `/todos` screen beside it is not.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { RenderCache } from "../../lib/tui/render-cache.ts";
+import { todoRailLines, type TodoRailInput } from "./format.ts";
+
+/**
+ * Transcript result block: the indented glyph rail, wrapping at the render width.
+ *
+ * `render` runs on every frame Pi draws, for every block in the transcript, so the
+ * rail is memoized on the width (`RenderCache`) and rebuilt only when
+ * `setInput` hands over a new list or `invalidate` says the theme moved. The
+ * caller must go through `setInput`: mutating a list in place would leave the
+ * block showing what it drew last.
+ */
+export class TodoResult implements Component {
+	private input: TodoRailInput;
+	private theme: Theme;
+	private readonly cache = new RenderCache();
+
+	constructor(input: TodoRailInput, theme: Theme) {
+		this.input = input;
+		this.theme = theme;
+	}
+
+	/** Update in place so the transcript can reuse this component across renders. */
+	setInput(input: TodoRailInput, theme: Theme): void {
+		this.input = input;
+		this.theme = theme;
+		this.cache.invalidate();
+	}
+
+	invalidate(): void {
+		this.cache.invalidate();
+	}
+
+	render(width: number): string[] {
+		const w = Math.max(1, width);
+		return this.cache.lines(w, undefined, () => this.build(w));
+	}
+
+	private build(w: number): string[] {
+		// The leading blank line separates the rail from the call header, matching
+		// the built-ins' header/output gap.
+		return ["", ...todoRailLines(this.input, this.theme, w)];
+	}
+}