kanbo-cli 0.6.0 → 0.8.0

package/dist/lib/{manifest-DHI1fkoW.mjs → tool-names-CrvHZ-ON.mjs}

@@ -6,7 +6,7 @@ import { z } from "zod";
 import { homedir, hostname, userInfo } from "node:os";
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { sql } from "drizzle-orm";
-import { accessSync, chmodSync, constants, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { accessSync, chmodSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { drizzle } from "drizzle-orm/postgres-js";
 import { migrate } from "drizzle-orm/postgres-js/migrator";
@@ -257,14 +257,9 @@ const describeSprintCloseRefusal = refusal("close a sprint", "close it");
 const describeColumnRulesRefusal = refusal("set what a column asks of a card", "set it");
 /**
 * The same, for changing the board's columns: every agent reads its work from
-* them, and `kanbo ready` from To Do.
+* them, and `kanbo_ready` from To Do.
 */
 const describeColumnChangesRefusal = refusal("change the board's columns", "change them");
-/**
-* The same, for taking back the log a run names: an agent that could clear or
-* swap it could point a card's history at any log it liked.
-*/
-const describeRunSessionRefRefusal = refusal("change or clear the log a run names", "do it");
 /** The commands only a person may run, as typed after `kanbo` — the capabilities manifest reads this rather than naming them again. */
 const HUMAN_ONLY_ACTIONS = [
 	"approve",
@@ -277,8 +272,7 @@ const HUMAN_ONLY_ACTIONS = [
 	"columns move",
 	"columns remove",
 	"columns template",
-	"columns add-standard",
-	"run clear-session"
+	"columns add-standard"
 ];
 const HUMAN_ONLY_MESSAGES = {
 	"approve": describeApprovalRefusal,
@@ -291,9 +285,7 @@ const HUMAN_ONLY_MESSAGES = {
 	"columns move": describeColumnChangesRefusal,
 	"columns remove": describeColumnChangesRefusal,
 	"columns template": describeColumnChangesRefusal,
-	"columns add-standard": describeColumnChangesRefusal,
-	"run clear-session": describeRunSessionRefRefusal,
-	"run attach-session --replace": describeRunSessionRefRefusal
+	"columns add-standard": describeColumnChangesRefusal
 };
 /**
 * The actor every board write from this tool is filed under: `KANBO_ACTOR_ID`,
@@ -312,7 +304,7 @@ function createCliActor() {
 * is none.
 *
 * Approving, returning, closing a sprint, setting a column's entry rules,
-* changing the board's columns and taking back the log a run names are the
+* changing the board's columns are the
 * things only a person may do, and a shell
 * that says it belongs to an agent is not one. `KANBO_ACTOR_KIND=person` overrides
 * the marks — for a person's own terminal that an agent tool marked — so this
@@ -5440,8 +5432,6 @@ function canonicalPath(path) {
 }
 //#endregion
 //#region src/cli/command.ts
-/** The two modes a card can be worked in, as `issues.execution_mode` spells them. */
-const EXECUTION_MODES = ["worktree", "main"];
 /** Add the options that name a board and shape the answer, wherever the command sits in the tree. */
 function withTargetOptions(command) {
 	return command.option("--db <path>", "the board file to open").option("--database-url <url>", "a shared Postgres board to use instead of a board file").option("--json [fields]", "print the result as JSON; name comma-separated fields to print only those").option("--format <format>", "print JSON: json (one line) or pretty (indented)");
@@ -5465,11 +5455,28 @@ async function openBoardSession(options, mode, cwd = process.cwd()) {
 		asAgent: options.asAgent,
 		cwd
 	});
-	const session = target.kind === "postgres" ? await openExternalSession(target, options, cwd) : await openFileSession(target, options, mode, cwd);
+	const session = target.kind === "postgres" ? await openExternalSession(target, options, cwd) : await openFileSession(target, options, mode, cwd).catch((error) => {
+		throw describeEnvironmentOnlyFailure(error, target, options, cwd);
+	});
 	const found = findBinding(cwd);
 	if (found) rememberProjectQuietly(found.projectDir);
 	return session;
 }
+/**
+* A folder with no board of its own that only `KANBO_DB_PATH` points at an
+* app's database: when that database is older than this kanbo, or knows no
+* project for the folder, the folder is told it has no board, not that "the
+* app's database" needs updating — the person never chose that database. A
+* flag or a binding that names the database keeps the app-centred sentence.
+*/
+function describeEnvironmentOnlyFailure(error, target, options, cwd) {
+	if (!(target.owner !== "kanbo" && !options.db?.trim() && !options.databaseUrl?.trim() && !process.env.KANBO_DATABASE_URL?.trim() && findBinding(cwd) === null) || !(error instanceof CliError)) return error;
+	let reason;
+	if (error.exitCode === 3 && error.message === "The app's database is older than this kanbo. Let the app it belongs to update it first.") reason = "is older than this kanbo";
+	else if (error.exitCode === 2 && error.message === "Could not tell which project this is. Pass --workspace <name|id>, or run \"kanbo init\" in the project folder.") reason = "has no project for this folder";
+	else return error;
+	return new CliError(error.exitCode, `This folder has no kanbo board of its own. KANBO_DB_PATH points at another app's database (${target.path}), which ${reason}. To give this folder its own board, run kanbo init here.`);
+}
 async function openFileSession(target, options, mode, cwd) {
 	const board = await openBoardDatabase(target.path);
 	try {
@@ -5547,18 +5554,6 @@ async function runBoardCommand(options, mode, body) {
 		await session.close();
 	}
 }
-/** Where a card's work happens. A caller naming anything else is refused, not corrected. */
-function parseExecutionMode(value) {
-	const mode = EXECUTION_MODES.find((candidate) => candidate === value);
-	if (!mode) throw new CliError(1, `Unknown execution mode "${value}". Use ${EXECUTION_MODES.join(" or ")}.`);
-	return mode;
-}
-/** A count a caller typed, refused rather than quietly rounded when it is not one. */
-function parseCount(value) {
-	const count = Number(value);
-	if (!Number.isInteger(count) || count <= 0) throw new CliError(1, `Expected a positive whole number, got "${value}".`);
-	return count;
-}
 /**
 * A date as the command line takes it: `YYYY-MM-DD`, read as a UTC day, or a
 * unix-seconds number taken as it is. `end` turns a day into its last second,
@@ -5589,7 +5584,7 @@ async function requireCard(session, reference) {
 	if (byId) return byId;
 	const number = readCardNumber(session, trimmed);
 	const byNumber = number === null ? null : await session.store.issues.findByNumber(session.workspace.id, number);
-	if (!byNumber) throw new CliError(2, `No card "${reference}" on this board.\n  Next: kanbo card list`);
+	if (!byNumber) throw new CliError(2, `No card "${reference}" on this board.\n  Next: kanbo board`);
 	return byNumber;
 }
 /**
@@ -5717,7 +5712,7 @@ function isWide(codePoint) {
 }
 //#endregion
 //#region src/cli/view.ts
-/** Every field `kanbo card list|get --json` may ask for, in listing order. */
+/** Every field `--json` may ask of a card, in listing order. */
 const CARD_VIEW_FIELDS = [
 	"id",
 	"number",
@@ -5737,16 +5732,6 @@ const CARD_VIEW_FIELDS = [
 	"returned",
 	"lastComment"
 ];
-/** Every field `kanbo card get --json` may ask for: a card's, and the parts `--include` reads with it. */
-const CARD_DETAIL_VIEW_FIELDS = [
-	...CARD_VIEW_FIELDS,
-	"subCards",
-	"comments",
-	"commentCount",
-	"runs",
-	"history",
-	"pullRequests"
-];
 /** Every field `kanbo sprint list --json` may ask for, in listing order. */
 const SPRINT_VIEW_FIELDS = [
 	"id",
@@ -5758,22 +5743,6 @@ const SPRINT_VIEW_FIELDS = [
 	"openCards",
 	"doneCards"
 ];
-/** Every field `kanbo run start|finish|attach-session --json` may ask for, in listing order. */
-const RUN_VIEW_FIELDS = [
-	"id",
-	"issueId",
-	"agentName",
-	"state",
-	"executionMode",
-	"branch",
-	"worktreePath",
-	"startedAt",
-	"endedAt",
-	"attempt",
-	"chatSessionId",
-	"externalSessionRef",
-	"launchedByKind"
-];
 function projectCard(card, columns, runs) {
 	const view = toIssueView(card);
 	const column = columns.find((candidate) => candidate.id === card.statusId) ?? null;
@@ -5795,14 +5764,6 @@ function projectCard(card, columns, runs) {
 		updatedAt: view.updatedAt
 	};
 }
-/** List cards with what `readCardAttention` says beside them — `returned` and `lastComment` only where there is something. */
-function withCardAttention(cards, attention) {
-	return cards.map((card, index) => ({
-		...card,
-		...attention[index]?.returned ? { returned: true } : {},
-		...attention[index]?.lastComment ? { lastComment: attention[index].lastComment } : {}
-	}));
-}
 /** The run going on right now, trimmed to what a card line needs — not the agent id, the branch or the session behind it. */
 function projectCardActiveRun(run) {
 	return run === null ? null : {
@@ -5839,42 +5800,6 @@ function projectSprint(sprint) {
 		doneCards: sprint.cards.done
 	};
 }
-function projectRun(run) {
-	return {
-		id: run.id,
-		issueId: run.issueId,
-		agentName: run.agentName,
-		state: run.state,
-		executionMode: run.executionMode,
-		branch: run.branch,
-		worktreePath: run.worktreePath,
-		startedAt: run.startedAt,
-		endedAt: run.endedAt,
-		attempt: run.attempt,
-		chatSessionId: run.chatSessionId,
-		externalSessionRef: run.externalSessionRef,
-		launchedByKind: run.launchedByKind
-	};
-}
-/** One card per line: the key, the column it is in, and what it is called (`cardDisplayTitle`). */
-function describeCards(cards) {
-	if (cards.length === 0) return "No cards";
-	const keyWidth = Math.max(...cards.map((card) => card.id.length));
-	const indent = " ".repeat(keyWidth + 2);
-	const column = (card) => sanitizeTerminalText(card.column ?? "—");
-	const columnWidth = Math.max(...cards.map((card) => displayWidth(column(card))));
-	return cards.map((card) => {
-		return [`${card.id.padEnd(keyWidth)}  ${padToWidth(column(card), columnWidth)}  ${sanitizeTerminalText(cardDisplayTitle(card))}`, ...[
-			card.waitingFor === "human" ? `waiting for a person${card.statusLine ? ` — ${sanitizeTerminalText(card.statusLine)}` : ""}` : null,
-			card.returned && !card.lastComment ? "returned" : null,
-			card.lastComment ? `${card.returned ? "returned — " : "last comment, "}${describeCommentAuthor(card.lastComment.author)}: ${sanitizeTerminalText(card.lastComment.text)}` : null
-		].filter((text) => text !== null).map((text) => `${indent}${text}`)].join("\n");
-	}).join("\n");
-}
-/** Who wrote a comment, as a list line says it. */
-function describeCommentAuthor(author) {
-	return author === "user" ? "person" : author;
-}
 /** The whole card, for a person who asked about exactly one. */
 function describeCard(card) {
 	const lines = [`${card.id}  ${sanitizeTerminalText(card.column ?? "—")}  ${card.executionMode}`, sanitizeTerminalText(cardDisplayTitle(card))];
@@ -6081,858 +6006,131 @@ function colorsWanted() {
 	return process.stdout.isTTY === true && process.env.TERM !== "dumb";
 }
 //#endregion
-//#region src/capabilities/markdown.ts
+//#region src/cli/column-changes.ts
 /**
-* The same manifest `buildCapabilitiesManifest` returns, as Markdown a person
-* can read and an agent can paste into its own `CLAUDE.md` or `AGENTS.md`.
+* What `kanbo columns add|rename|move|remove|template` do to a board, once
+* the command or the `kanbo columns` menu knows what the person asked for.
+* Both run these, so a change made from the menu reads exactly like the
+* command it names.
 *
-* Nothing here decides what the board can do — it only lays the manifest's own
-* fields out under headings. `kanbo capabilities` prints this by default, and
-* `kanbo mcp` serves it as `kanbo://capabilities.md` beside the JSON.
+* A refusal of the board's is said as a sentence with the command to type
+* instead, rather than as its code: these are a person's commands.
 */
+const COLUMN_CATEGORIES = [
+	"backlog",
+	"unstarted",
+	"started",
+	"completed",
+	"canceled"
+];
+/** The whole board's columns after a change, and the sentence that says what changed. */
+async function changed(session, message, extra = {}) {
+	const board = await session.ops.listColumns(session.workspace.id);
+	const views = board.map((column) => projectColumn(column, board));
+	return {
+		value: {
+			...Object.fromEntries(Object.entries(extra).map(([key, value]) => [key, typeof value === "number" || Array.isArray(value) ? value : projectColumn(value, board)])),
+			columns: views
+		},
+		text: `${message}\n\n${describeColumns(views)}`
+	};
+}
 /**
-* A table cell, safe from a pipe inside the text breaking the row it sits in —
-* the same escape the package README's own tables use for a command that
-* spells `\|` between two states.
+* A new column, placed in the same write that creates it. A ready-made name
+* (`QA`, `Blocked`) brings its own line and category; any other name is work
+* in progress. With no place given it goes before the board's first completed
+* column (Done), or Canceled, so work still to do stays on the left.
 */
-function cell(text) {
-	return text.replace(/\|/g, "\\|").replace(/\n/g, " ").trim();
-}
-function renderStorages(manifest) {
-	return [
-		"## Storages",
-		"",
-		"| Kind | Label | Description | Schema epoch |",
-		"| --- | --- | --- | --- |",
-		...manifest.storages.map((storage) => `| \`${storage.kind}\` | ${cell(storage.label)} | ${cell(storage.description)} | ${storage.schemaEpoch} |`)
-	];
-}
-function renderTool(tool) {
-	return `| \`${tool.name}\` | \`${cell(tool.cli.kanbo)}\` | ${cell(tool.description)} |`;
-}
-function renderTools(manifest) {
-	return [
-		"## Tools",
-		"",
-		"Full JSON Schema for each tool's input is in the JSON manifest (`kanbo capabilities --json` or `kanbo://capabilities`) — this table is the tools themselves and what to type instead of calling one.",
-		"",
-		"| Tool | `kanbo` | Does |",
-		"| --- | --- | --- |",
-		...manifest.tools.map(renderTool)
-	];
+async function addColumn(session, request, actor) {
+	const workspaceId = session.workspace.id;
+	const name = request.name.trim();
+	if (!normalizeStatusName(name)) throw new CliError(1, "Give the column a name.");
+	if (request.after !== void 0 && request.before !== void 0) throw new CliError(1, "Pass --after or --before, not both.");
+	const existing = await session.ops.findColumn(workspaceId, name);
+	if (existing) throw new CliError(1, `This board already has a column called ${existing.name} (slug ${normalizeStatusName(existing.name)}).`);
+	const anchorName = request.after ?? request.before;
+	const anchor = anchorName === void 0 ? null : await requireNamedColumn(session, anchorName);
+	const spec = findCatalogueColumn(name) ?? ownColumn(name, null);
+	const created = await session.ops.addColumn(workspaceId, {
+		name,
+		description: request.description?.trim() || spec.description,
+		color: spec.color,
+		category: request.category ?? spec.category,
+		position: anchor ? request.after !== void 0 ? { after: anchor.id } : { before: anchor.id } : void 0
+	}, actor);
+	return await changed(session, `Added ${created.name} (slug ${normalizeStatusName(created.name)}).`, { added: created });
 }
-function renderCommand(command) {
-	const options = command.options.map((option) => `\`${option.flags}\`${option.mandatory ? " (required)" : ""}`).join(", ");
-	const humanOnly = command.humanOnly ? " **Person only.**" : "";
-	return `| \`kanbo ${command.path}\` | ${cell(command.description)}${humanOnly} | ${options ? cell(options) : "—"} |`;
+/** Said after a rename: agents' instructions name no column but To Do, and `kanbo_prime` gives them the rest. */
+const RENAME_NOTE = "Agents read column names from kanbo_prime; rename is picked up there.";
+async function renameColumn(session, column, newName, actor) {
+	const before = await requireNamedColumn(session, column);
+	const renamed = await session.ops.renameColumn(session.workspace.id, before.id, newName, actor);
+	return await changed(session, before.name === renamed.name ? `${renamed.name} already has that name.` : `Renamed ${before.name} to ${renamed.name} (slug ${normalizeStatusName(renamed.name)}).\n${RENAME_NOTE}`, { renamed });
 }
-function renderCommands(manifest) {
-	return [
-		"## Commands",
-		"",
-		"| Command | Does | Options |",
-		"| --- | --- | --- |",
-		...manifest.commands.map(renderCommand)
-	];
+/** `--first`, `--last`, `--before <column>` or `--after <column>` — exactly one. */
+function readColumnPosition(options) {
+	const given = [
+		options.first ? "first" : null,
+		options.last ? "last" : null,
+		options.before !== void 0 ? { before: options.before } : null,
+		options.after !== void 0 ? { after: options.after } : null
+	].filter((position) => position !== null);
+	if (given.length !== 1) throw new CliError(1, "Say where the column goes: --first, --last, --before <column> or --after <column> (one of them).");
+	return given[0];
 }
-function renderRules(manifest) {
-	return [
-		"## Rules",
-		"",
-		...manifest.rules.map((rule) => `- ${rule}`)
-	];
+async function moveColumn(session, column, position, actor) {
+	const moving = await requireNamedColumn(session, column);
+	const anchorName = typeof position === "string" ? null : "before" in position ? position.before : position.after;
+	const anchor = anchorName === null ? null : await requireNamedColumn(session, anchorName);
+	const before = await session.ops.listColumns(session.workspace.id);
+	const after = await session.ops.moveColumn(session.workspace.id, moving.id, position, actor);
+	const where = position === "first" ? "to the start" : position === "last" ? "to the end" : `${"before" in position ? "before" : "after"} ${anchor.name}`;
+	return await changed(session, before.map((candidate) => candidate.id).join() === after.map((candidate) => candidate.id).join() ? `${moving.name} is already there.` : `Moved ${moving.name} ${where}.`);
 }
-function renderEntryRules(manifest) {
-	return [
-		"## Column entry rules",
-		"",
-		"What a column may ask of a card before an agent moves it in. Which columns ask for which is per board: `kanbo columns list` or `kanbo_columns`.",
-		"",
-		...manifest.entryRules.map((entry) => `- \`${entry.rule}\` — ${entry.description}`)
-	];
+/** How many cards sit in the column right now. */
+async function countCardsIn(session, column) {
+	return (await session.store.issues.listInBoardOrder(session.workspace.id)).filter((card) => card.statusId === column.id).length;
 }
-function renderCanonicalStrings(manifest) {
-	return [
-		"## Canonical strings",
-		"",
-		"What the board writes for you, on a status line or in a system comment. A value ending in a space or `: ` is a prefix — the rest of the line is whatever the write was about.",
-		"",
-		"| Name | Value |",
-		"| --- | --- |",
-		...Object.entries(manifest.canonicalStrings).map(([name, value]) => `| ${cell(name)} | \`${cell(value)}\` |`)
-	];
+async function removeColumn(session, column, moveCardsTo, actor) {
+	const removing = await requireNamedColumn(session, column);
+	if (moveCardsTo !== null) await requireNamedColumn(session, moveCardsTo);
+	const result = await session.ops.removeColumn(session.workspace.id, removing.id, { moveCardsTo }, actor);
+	for (const card of result.unmetRules ?? []) for (const item of card.unmet) console.error(`kanbo: warning: ${card.issueId} entered "${result.movedTo?.name ?? "—"}" without ${item.rule}: ${item.detail}`);
+	return await changed(session, result.movedTo ? `Removed ${result.removed.name} and moved ${describeCount$1(result.movedCards)} to ${result.movedTo.name}.` : `Removed ${result.removed.name}.`, {
+		removed: result.removed,
+		movedCards: result.movedCards
+	});
 }
-function renderRoles(manifest) {
-	return [
-		"## Roles",
-		"",
-		`- Person: \`${manifest.roles.person}\``,
-		`- Agent: \`${manifest.roles.agent}\``,
-		"",
-		"What the database itself refuses the agent role, on an external board, whichever client sends the write:",
-		"",
-		...manifest.roles.refusals.map((refusal) => `- ${refusal}`)
-	];
+/** The template a person named, or the error that lists the ones there are. */
+function readTemplateId(value) {
+	const id = COLUMN_TEMPLATE_IDS.find((candidate) => candidate === value.trim().toLowerCase());
+	if (!id) throw new CliError(1, `Unknown template "${value}". Use ${COLUMN_TEMPLATE_IDS.join(", ")}.`);
+	return id;
 }
-function renderLimits(manifest) {
-	return [
-		"## Limits",
-		"",
-		...manifest.limits.map((limit) => `- ${limit}`)
-	];
+/**
+* A template's columns on this board. An empty board gets the template as it
+* is; a board with columns only gets the ones it lacks, and only when asked
+* with `--add-missing` — a template never takes a column away.
+*/
+async function applyTemplate(session, id, addMissing, actor) {
+	const workspaceId = session.workspace.id;
+	const label = COLUMN_TEMPLATE_LABELS[id];
+	const present = await session.ops.listColumns(workspaceId);
+	if (present.length > 0 && !addMissing) throw new CliError(1, `This board already has columns. Add the ${label} columns it lacks with: kanbo columns template ${id} --add-missing`);
+	const { added } = present.length === 0 ? await session.ops.applyColumnTemplate(workspaceId, COLUMN_TEMPLATES[id], { mode: "seed" }) : await session.ops.applyColumnTemplate(workspaceId, COLUMN_TEMPLATES[id], {
+		mode: "add-missing",
+		actor
+	});
+	return await changed(session, added.length === 0 ? `This board already has every ${label} column.` : `Added ${added.join(", ")}.`, { added });
 }
-/** The manifest, laid out under one heading per field — stable and diffable, never a snapshot to update by hand. */
-function renderCapabilitiesMarkdown(manifest) {
-	return [
-		"# Kanbo capabilities",
-		"",
-		`\`${manifest.package.name}\` ${manifest.package.version} — capabilities manifest version ${manifest.version}.`,
-		"",
-		...renderStorages(manifest),
-		"",
-		...renderTools(manifest),
-		"",
-		...renderCommands(manifest),
-		"",
-		...renderRules(manifest),
-		"",
-		...renderEntryRules(manifest),
-		"",
-		...renderCanonicalStrings(manifest),
-		"",
-		...renderRoles(manifest),
-		"",
-		...renderLimits(manifest),
-		""
-	].join("\n");
+/** The column a person named, or the error that says the board has none by that name. */
+async function requireNamedColumn(session, nameOrId) {
+	const column = normalizeStatusName(nameOrId) ? await session.ops.findColumn(session.workspace.id, nameOrId) : null;
+	if (!column) throw new CliError(1, `This board has no column "${nameOrId}". See kanbo columns list.`);
+	return column;
 }
-//#endregion
-//#region src/cli/commands/capabilities.ts
-function registerCapabilitiesCommand(program) {
-	program.command("capabilities").description("List what kanbo offers agents: tools, commands, rules and limits (no board needed)").option("--json [fields]", "print it as JSON; name comma-separated fields to print only those").option("--markdown", "print it as Markdown (the default)").action((options) => {
-		if (options.json !== void 0 && options.markdown) throw new CliError(1, "Pass --json or --markdown, not both.");
-		const manifest = buildCapabilitiesManifest();
-		if (options.json !== void 0) {
-			printResult({ value: manifest }, { json: options.json });
-			return;
-		}
-		console.log(renderCapabilitiesMarkdown(manifest));
-	});
-}
-//#endregion
-//#region src/cli/commands/claim.ts
-/**
-* `kanbo claim [card]` — take a card to work on, in one step.
-*
-* The run starts and the card moves out of To Do into the board's first
-* work-in-progress column in one write, so two agents in two terminals never
-* take the same card. Filed as a placement: in a person's own terminal the
-* column's rules warn, in an agent's shell they refuse.
-*/
-function registerClaimCommand(program) {
-	withBoardOptions(program.command("claim").description("Take a card to work on: start your run and move it out of To Do, in one step").argument("[card]", "the card, as MAN-012, MAN-12 or 12 (default: the first ready card)").option("--agent <name>", "your name, e.g. claude (default: the name this shell writes as)").option("--session <ref>", "your session, to find it later: claude:<session id> or codex:<session id> (default: the one Claude Code or Codex names in the environment)")).action(async (reference, options) => {
-		await runBoardCommand(options, "write", async (session) => {
-			const actor = createPlacementActor();
-			const named = reference === void 0 ? void 0 : (await requireCard(session, reference)).id;
-			const claimed = await session.ops.claimCard({
-				workspaceId: session.workspace.id,
-				issueId: named,
-				run: {
-					agentName: options.agent ?? actor.id ?? "agent",
-					externalSessionRef: options.session ?? sessionRefFromEnvironment() ?? void 0,
-					launchedByKind: "external"
-				}
-			}, actor);
-			const [columns, projection, runs] = await Promise.all([
-				session.ops.listColumns(session.workspace.id),
-				session.ops.readBoardProjectionForIssue(claimed.card.id),
-				session.ops.listRuns(claimed.card.id)
-			]);
-			const card = projectCard(claimed.card, columns, projection);
-			for (const item of claimed.card.unmetRules ?? []) console.error(`kanbo: warning: ${card.id} entered "${claimed.column.name}" without ${item.rule}: ${item.detail}`);
-			const run = projectRun({
-				...claimed.run,
-				attempt: runs.find((each) => each.id === claimed.run.id)?.attempt ?? runs.length
-			});
-			return {
-				value: {
-					card,
-					run,
-					column: projectColumn(claimed.column, columns)
-				},
-				text: `Claimed ${card.id}: run ${run.id} started, card moved to ${claimed.column.name}\nWhen you are done: kanbo run finish ${run.id} --state finished`
-			};
-		});
-	});
-}
-//#endregion
-//#region src/mcp/transport.ts
-/** What `kanbo_card_get` may bring along with the card. */
-const KANBO_CARD_INCLUDES = [
-	"comments",
-	"subCards",
-	"runs",
-	"history",
-	"prs"
-];
-/** What a card read brings along when the caller does not say: its latest comments and its sub-cards. */
-const DEFAULT_KANBO_CARD_INCLUDES = ["comments", "subCards"];
-/** How many of its latest comments a card read brings along when the caller does not say. */
-const DEFAULT_KANBO_COMMENT_LIMIT = 10;
-/**
-* The card a tool prints, from the card a transport holds.
-*
-* Both transports project here so the JSON an agent reads is the same whether
-* it came from the server or from the board file — including the column, which
-* neither of them carries on the card itself: the row keeps a foreign key, and
-* an agent moving a card needs the slug.
-*
-* Every field is named rather than spread. A card the board file answers with
-* carries more than this — the agent and session ids behind a run among them —
-* and passing an object through by reference would print whatever it happened
-* to hold, which is both a different shape from the server's answer and host
-* facts the agent was never meant to see.
-*/
-function projectKanboCard(card, columns) {
-	const column = columns.find((candidate) => candidate.id === card.statusId) ?? null;
-	return {
-		id: card.id,
-		number: card.number,
-		title: card.title,
-		description: card.description,
-		column: column?.name ?? null,
-		columnSlug: column?.slug ?? null,
-		statusLine: card.statusLine,
-		waitingFor: card.waitingFor,
-		priority: card.priority,
-		labels: card.labels,
-		executionMode: card.executionMode,
-		parentIssueId: card.parentIssueId,
-		attemptCount: card.attemptCount,
-		activeRun: projectKanboActiveRun(card.activeRun),
-		updatedAt: card.updatedAt,
-		...card.attention?.returned ? { returned: true } : {},
-		...card.attention?.lastComment ? { lastComment: card.attention.lastComment } : {}
-	};
-}
-/** A sub-card, as the card above it lists it: enough to name it and read it next. */
-function projectKanboSubCard(card, columns) {
-	return {
-		id: card.id,
-		title: card.title,
-		columnSlug: columns.find((candidate) => candidate.id === card.statusId)?.slug ?? null
-	};
-}
-/** The run going on right now, as much of it as the agent working the card needs. */
-function projectKanboActiveRun(run) {
-	return run === null ? null : {
-		id: run.id,
-		agentName: run.agentName,
-		state: run.state,
-		executionMode: run.executionMode,
-		branch: run.branch,
-		startedAt: run.startedAt
-	};
-}
-/**
-* One launch of a card, from the run row either transport holds.
-*
-* What the row carries beyond this — the worktree path, the chat session
-* driving it, who launched it — belongs to the host that launched the run, not
-* to the agent that asked for one.
-*/
-function projectKanboRun(run) {
-	return {
-		id: run.id,
-		issueId: run.issueId,
-		agentName: run.agentName,
-		state: run.state,
-		executionMode: run.executionMode,
-		branch: run.branch,
-		startedAt: run.startedAt,
-		endedAt: run.endedAt,
-		externalSessionRef: run.externalSessionRef ?? null
-	};
-}
-/**
-* A pull-request link, from the row either transport holds — without who made
-* it, which is the board's record rather than anything the agent acts on.
-*/
-function projectKanboPullRequest(link) {
-	return {
-		id: link.id,
-		issueId: link.issueId,
-		owner: link.owner,
-		repo: link.repo,
-		number: link.number,
-		url: link.url,
-		createdAt: link.createdAt
-	};
-}
-/** A sprint, from the one `listSprints` answers with on either end — the description and timestamps left behind. */
-function projectKanboSprint(sprint) {
-	return {
-		id: sprint.id,
-		title: sprint.title,
-		status: sprint.status,
-		startDate: sprint.startDate,
-		dueDate: sprint.dueDate,
-		current: sprint.current,
-		openCards: sprint.cards.open,
-		doneCards: sprint.cards.done
-	};
-}
-/** A column of the board, from the row either transport holds; `board` is every column, to name the ones it accepts cards from. */
-function projectKanboColumn(column, board) {
-	const stored = column.entryRules;
-	const allowedIds = typeof column.allowedFrom === "string" ? readFlowRules({
-		allowedFrom: column.allowedFrom,
-		wipLimit: null
-	}).allowedFrom : column.allowedFrom ?? null;
-	return {
-		id: column.id,
-		name: column.name,
-		slug: normalizeStatusName(column.name),
-		description: column.description,
-		order: column.order,
-		entryRules: typeof stored === "object" && stored !== null ? ENTRY_RULES.filter((rule) => stored.includes(rule)) : readEntryRules({ entryRules: stored ?? null }),
-		allowedFrom: allowedIds === null ? null : board.filter((other) => allowedIds.includes(other.id)).map((other) => normalizeStatusName(other.name)),
-		wipLimit: column.wipLimit ?? null
-	};
-}
-/**
-* Does the card answer the query? The filters of `KanboCardQuery`, applied to
-* a card already read — for a transport whose server filters on less than the
-* query names. `statusIds` are the query's columns, already resolved.
-*/
-function matchesKanboCardQuery(card, query, statusIds) {
-	const text = query.text === void 0 ? void 0 : foldCase(query.text);
-	return (statusIds === null || card.statusId !== null && statusIds.has(card.statusId)) && (query.waitingForPerson === void 0 || card.waitingFor === "human" === query.waitingForPerson) && (query.parent === void 0 || card.parentIssueId === query.parent) && (query.hasActiveRun === void 0 || card.activeRun !== null === query.hasActiveRun) && (query.returned === void 0 || (card.attention?.returned ?? false) === query.returned) && (text === void 0 || [
-		card.id,
-		card.title,
-		card.description ?? ""
-	].some((value) => foldCase(value).includes(text))) && (query.updatedSince === void 0 || card.updatedAt >= query.updatedSince) && (query.labels ?? []).every((label) => card.labels.includes(label)) && (query.priority === void 0 || query.priority.includes(card.priority));
-}
-/** A page cut out of cards already picked, in the order they were picked. */
-function pageOf(cards, input) {
-	const offset = input.offset ?? 0;
-	return {
-		cards: cards.slice(offset, input.limit === void 0 ? void 0 : offset + input.limit),
-		total: cards.length,
-		offset
-	};
-}
-/** A comment as a card read lists it, from the row either transport holds. */
-function projectKanboCardComment(comment) {
-	const decision = comment.authorKind === "system.approved" || comment.authorKind === "system.returned";
-	const author = decision ? "user" : normalizeCommentAuthorKind(comment.authorKind);
-	const named = author !== "system" || decision;
-	const outside = author === "system" && isOutsideWriter(comment) && comment.authorKind === "system";
-	return {
-		id: comment.id,
-		author,
-		by: named || outside ? comment.authorId ?? author : "kanbo",
-		content: comment.content,
-		createdAt: comment.createdAt
-	};
-}
-/** A field change as a card read lists it — who by kind only: the id behind it is the host's. */
-function projectKanboFieldChange(change) {
-	return {
-		field: change.field,
-		from: change.fromValue,
-		to: change.toValue,
-		actor: change.actorKind,
-		createdAt: change.createdAt
-	};
-}
-//#endregion
-//#region src/cli/card-extras.ts
-async function readCardExtras(session, card, columns, include, commentLimit) {
-	const wants = new Set(include);
-	const [subCards, comments, runs, history, pullRequests] = await Promise.all([
-		wants.has("subCards") ? session.store.issues.listPage({
-			workspaceId: card.workspaceId,
-			parentIssueId: card.id
-		}) : null,
-		wants.has("comments") ? session.store.comments.listByIssue(card.id) : null,
-		wants.has("runs") ? session.ops.listRuns(card.id) : null,
-		wants.has("history") ? session.store.fieldChanges.listByIssue(card.id) : null,
-		wants.has("prs") ? session.store.pullRequests.listByIssue(card.id) : null
-	]);
-	return {
-		...subCards ? { subCards: subCards.cards.map((row) => {
-			const view = projectCard(row, columns, {
-				issueId: row.id,
-				attemptCount: 0,
-				activeRun: null
-			});
-			return {
-				id: view.id,
-				title: view.title,
-				columnSlug: view.columnSlug
-			};
-		}) } : {},
-		...comments ? {
-			comments: comments.slice(-commentLimit).map(projectKanboCardComment),
-			commentCount: comments.length
-		} : {},
-		...runs ? { runs: runs.map(projectRun) } : {},
-		...history ? { history: history.map(projectKanboFieldChange) } : {},
-		...pullRequests ? { pullRequests: pullRequests.map((link) => ({
-			id: link.id,
-			owner: link.owner,
-			repo: link.repo,
-			number: link.number,
-			url: link.url
-		})) } : {}
-	};
-}
-/** A unix-seconds moment as `YYYY-MM-DD HH:MM` UTC. */
-function formatMoment(seconds) {
-	return (/* @__PURE__ */ new Date(seconds * 1e3)).toISOString().slice(0, 16).replace("T", " ");
-}
-/** The parts under the card, each under a heading; nothing for a part that was not asked for. */
-function describeCardExtras(extras) {
-	const sections = [];
-	if (extras.subCards && extras.subCards.length > 0) sections.push(["Sub-cards:", describeCards(extras.subCards.map((sub) => ({
-		...sub,
-		description: null,
-		column: sub.columnSlug
-	})))].join("\n"));
-	if (extras.comments && extras.comments.length > 0) {
-		const heading = extras.commentCount === extras.comments.length ? "Comments:" : `Comments (last ${extras.comments.length} of ${extras.commentCount}):`;
-		sections.push([heading, ...extras.comments.map((comment) => `${formatMoment(comment.createdAt)}  ${sanitizeTerminalText(comment.by)}${comment.author === "user" ? " (person)" : ""}: ${sanitizeTerminalText(comment.content)}`)].join("\n"));
-	}
-	if (extras.runs && extras.runs.length > 0) sections.push(["Runs:", ...extras.runs.map((run) => `#${run.attempt}  ${run.state}  ${sanitizeTerminalText(run.agentName)}  ${formatMoment(run.startedAt)}  ${run.id}`)].join("\n"));
-	if (extras.history && extras.history.length > 0) sections.push(["History:", ...extras.history.map((change) => `${formatMoment(change.createdAt)}  ${change.actor}  ${change.field}: ${sanitizeTerminalText(change.from ?? "—")} → ${sanitizeTerminalText(change.to ?? "—")}`)].join("\n"));
-	if (extras.pullRequests && extras.pullRequests.length > 0) sections.push(["Pull requests:", ...extras.pullRequests.map((link) => `${link.owner}/${link.repo}#${link.number}  ${link.url}`)].join("\n"));
-	return sections.join("\n\n");
-}
-//#endregion
-//#region src/cli/commands/card.ts
-/**
-* `kanbo card …` — the cards themselves.
-*
-* Every write here is filed under the shell that made it and goes through the
-* board's own operations, so a card an agent moved from a terminal reads on the
-* board exactly like one moved in the app: the same field history, the same
-* status line, the same board version bump for whoever is watching.
-*/
-const PRIORITIES$1 = [
-	"none",
-	"low",
-	"medium",
-	"high",
-	"urgent"
-];
-/**
-* Where `card create` puts a card no `--column` placed. A person's card goes
-* to To Do, as the home screen and the wizard put it: they wrote it down to
-* have it done. An agent's goes where the board's operations put any card with
-* no column — the first one (Backlog on the standard board) — as it did in
-* 0.2: an agent writing down follow-up work should not hand it straight to the
-* next agent that runs `kanbo ready`. A board with no To Do gets the default
-* for a person too.
-*/
-async function readDefaultColumn(session) {
-	if (isAgentShell()) return;
-	return (await session.ops.findColumn(session.workspace.id, READY_COLUMN_SLUG$1))?.name;
-}
-/** How many cards `kanbo card list` prints when the caller names no limit. */
-const DEFAULT_LIST_LIMIT = 50;
-function registerCardCommands(program) {
-	const card = program.command("card").description("Add, change, move and read cards");
-	withBoardOptions(card.command("list").description(`List cards in board order, ${DEFAULT_LIST_LIMIT} at a time; filters combine`).option("--column <columns>", "only cards in these columns, by slug, name or id (comma-separated, or repeat)", collectList, void 0).option("--waiting", "only cards waiting for a person").option("--parent <card>", "only the sub-cards of this card").option("--active", "only cards an agent is working on now").option("--returned", "only cards a person sent back that nobody has picked up again").option("--text <text>", "only cards whose key, title or description contains this, ignoring case in any script (über finds Über)").option("--updated-since <time>", "only cards changed since then: unix seconds, 2026-09-28T10:00:00Z (a zone is required) or 2026-09-28 (UTC midnight)", parseMoment).option("--label <labels>", "only cards carrying every one of these labels (comma-separated, or repeat)", collectList, void 0).option("--priority <priorities>", `only cards of these priorities: ${PRIORITIES$1.join(", ")} (comma-separated)`, parsePriorities).option("--limit <count>", `how many cards to print (${DEFAULT_LIST_LIMIT} when left out)`, parseCount).option("--offset <count>", "how many picked cards to skip first", parseOffset).option("--all", "print every picked card")).action(async (options) => {
-		await runBoardCommand(options, "read", async (session) => {
-			const parent = options.parent ? await requireCard(session, options.parent) : null;
-			const page = await session.ops.queryCards({
-				workspaceId: session.workspace.id,
-				columns: options.column,
-				waitingForPerson: options.waiting ? true : void 0,
-				parentIssueId: parent?.id,
-				hasActiveRun: options.active ? true : void 0,
-				returned: options.returned ? true : void 0,
-				text: options.text,
-				updatedSince: options.updatedSince,
-				labels: options.label,
-				priorities: options.priority,
-				offset: options.offset,
-				limit: options.all ? void 0 : options.limit ?? DEFAULT_LIST_LIMIT
-			}).catch(rethrowUnknownColumn(options.column));
-			const runs = await session.ops.readBoardProjectionForIssues(page.cards.map((row) => row.id));
-			const attention = await session.ops.readCardAttention(page.cards, runs.map((run) => run.activeRun !== null));
-			const cards = withCardAttention(page.cards.map((row, index) => projectCard(row, page.columns, runs[index])), attention);
-			noteMoreCards(page.total, options.offset ?? 0, cards.length);
-			return {
-				value: cards,
-				text: describeCards(cards),
-				fields: CARD_VIEW_FIELDS
-			};
-		});
-	});
-	withBoardOptions(card.command("get").description("Show one card, with its last comments and its sub-cards").argument("<card>", "the card, as MAN-012, MAN-12 or 12").option("--include <parts>", `what to show with the card: ${KANBO_CARD_INCLUDES.join(", ")} (comma-separated; ${DEFAULT_KANBO_CARD_INCLUDES.join(",")} when left out, none for the card alone)`, parseIncludes).option("--comments <count>", `how many of the latest comments to show (10 when left out)`, parseCount)).action(async (reference, options) => {
-		await runBoardCommand(options, "read", async (session) => {
-			const found = await requireCard(session, reference);
-			const [columns, runs] = await Promise.all([session.ops.listColumns(session.workspace.id), session.ops.readBoardProjectionForIssue(found.id)]);
-			const view = projectCard(found, columns, runs);
-			const extras = await readCardExtras(session, found, columns, options.include ?? DEFAULT_KANBO_CARD_INCLUDES, options.comments ?? 10);
-			return {
-				value: {
-					...view,
-					...extras
-				},
-				text: [describeCard(view), describeCardExtras(extras)].filter(Boolean).join("\n\n"),
-				fields: CARD_DETAIL_VIEW_FIELDS
-			};
-		});
-	});
-	withBoardOptions(card.command("create").description("Add a card to the board").option("--title <title>", "what the card is called (its number when left out)").option("--description <text>", "what the card is about").option("--column <column>", "the column to put it in, by slug, name or id (default: To Do for a person, the board's first column for an agent)").option("--parent <card>", "the card this one is part of").option("--execution-mode <mode>", "where the work happens: worktree (its own checkout) or main", parseExecutionMode)).action(async (options) => {
-		await runBoardCommand(options, "write", async (session) => {
-			const parent = options.parent ? await requireCard(session, options.parent) : null;
-			return await presentCard(session, await session.ops.createCard({
-				workspace: session.workspace,
-				title: options.title,
-				description: options.description,
-				statusName: options.column ?? await readDefaultColumn(session),
-				parentIssueId: parent?.id,
-				executionMode: options.executionMode
-			}, createPlacementActor()));
-		});
-	});
-	withBoardOptions(card.command("update").description("Change a card's title, description, priority, labels or parent").argument("<card>", "the card, as MAN-012, MAN-12 or 12").option("--title <title>", "what the card is called").option("--description <text>", "what the card is about").option("--priority <priority>", `one of ${PRIORITIES$1.join(", ")}`, parsePriority).option("--labels <labels>", "comma-separated labels, replacing the ones the card has", parseLabels).option("--execution-mode <mode>", "where the work happens: worktree (its own checkout) or main", parseExecutionMode).option("--parent <card>", "the card to put it under; none puts it on the top level")).action(async (reference, options) => {
-		await runBoardCommand(options, "write", async (session) => {
-			const input = readUpdateInput(options);
-			const existing = await requireCard(session, reference);
-			if (options.parent !== void 0) input.parentIssueId = options.parent === "none" ? null : (await requireCard(session, options.parent)).id;
-			return await presentCard(session, await session.ops.updateCard(existing.id, input, createPlacementActor()));
-		});
-	});
-	withBoardOptions(card.command("move").description("Move a card to another column").argument("<card>", "the card, as MAN-012, MAN-12 or 12").argument("<column>", "the column, by slug, name or id")).action(async (reference, column, options) => {
-		await runBoardCommand(options, "write", async (session) => {
-			const existing = await requireCard(session, reference);
-			return await presentCard(session, await session.ops.moveCard(existing.id, column, createPlacementActor()));
-		});
-	});
-	withBoardOptions(card.command("status-line").description("Say in one line what is happening on a card right now").argument("<card>", "the card, as MAN-012, MAN-12 or 12").option("--text <text>", "one sentence, present tense (required)").addOption(new Option("--content <text>", "the same as --text").hideHelp())).action(async (reference, options) => {
-		const text = readAliasedText("status-line", options, "text", "content");
-		if (text === void 0) throw new CliError(1, "kanbo card status-line needs --text (one sentence). Example: kanbo card status-line TST-5 --text \"Running the tests\"");
-		await runBoardCommand(options, "write", async (session) => {
-			const existing = await requireCard(session, reference);
-			return await presentCard(session, await session.ops.setStatusLine(existing.id, text, createCliActor()));
-		});
-	});
-	withBoardOptions(card.command("comment").description("Leave a comment on a card: a finding, a decision or a question").argument("<card>", "the card, as MAN-012, MAN-12 or 12").option("--content <text>", "what to say (required)").addOption(new Option("--text <text>", "the same as --content").hideHelp())).action(async (reference, options) => {
-		const content = readAliasedText("comment", options, "content", "text");
-		if (content === void 0) throw new CliError(1, "kanbo card comment needs --content (the comment text). Example: kanbo card comment TST-5 --content \"Added slugify with a test\"");
-		await runBoardCommand(options, "write", async (session) => {
-			const existing = await requireCard(session, reference);
-			const comment = await session.ops.addComment({
-				issueId: existing.id,
-				content
-			}, createCliActor());
-			return {
-				value: {
-					id: comment.id,
-					issueId: comment.issueId,
-					content: comment.content,
-					createdAt: comment.createdAt
-				},
-				text: `Commented on ${existing.id}`
-			};
-		});
-	});
-	withBoardOptions(card.command("wait-approval").description("Ask a person to review a card, and stop working on it").argument("<card>", "the card, as MAN-012, MAN-12 or 12").option("--text <text>", "the status line to leave, saying what you need").addOption(new Option("--content <text>", "the same as --text").hideHelp())).action(async (reference, options) => {
-		const text = readAliasedText("wait-approval", options, "text", "content");
-		await runBoardCommand(options, "write", async (session) => {
-			const existing = await requireCard(session, reference);
-			return await presentCard(session, await session.ops.waitApproval(existing.id, { statusLine: text }, createCliActor()));
-		});
-	});
-	registerPullRequestCommands(card);
-}
-/**
-* The text a command was given under its own option or the other one agents
-* reach for (`--text` for a comment, `--content` for a status line): the MCP
-* tools take both names too. Both, saying different things, is refused.
-*/
-function readAliasedText(command, options, canonical, alias) {
-	const own = options[canonical];
-	const other = options[alias];
-	if (own !== void 0 && other !== void 0 && own !== other) throw new CliError(1, `kanbo card ${command} got --${canonical} and --${alias} with different text; pass only --${canonical}.`);
-	return own ?? other;
-}
-/** The fields a pull-request link prints, and the ones `--json` may name. */
-const PULL_REQUEST_FIELDS = [
-	"id",
-	"issueId",
-	"owner",
-	"repo",
-	"number",
-	"url",
-	"createdAt"
-];
-function projectPullRequest(link) {
-	return {
-		id: link.id,
-		issueId: link.issueId,
-		owner: link.owner,
-		repo: link.repo,
-		number: link.number,
-		url: link.url,
-		createdAt: link.createdAt
-	};
-}
-function describePullRequest(link) {
-	return `${link.id}  ${link.owner}/${link.repo}#${link.number}  ${link.url}`;
-}
-/**
-* `kanbo card pr …` — the pull requests a card names (ruling 4-1).
-*
-* Linking is all an agent does: what the pull request is — open, merged, green
-* — reaches the card as comments from whoever watches GitHub, so nothing here
-* writes one.
-*/
-function registerPullRequestCommands(card) {
-	const pr = card.command("pr").description("Link pull requests to a card");
-	withBoardOptions(pr.command("add").description("Link a pull request to a card (linking it twice is fine)").argument("<card>", "the card, as MAN-012, MAN-12 or 12").argument("<url>", "the pull request, as https://github.com/<owner>/<repo>/pull/<n> or <owner>/<repo>#<n>")).action(async (reference, url, options) => {
-		await runBoardCommand(options, "write", async (session) => {
-			const existing = await requireCard(session, reference);
-			const link = projectPullRequest(await session.ops.linkPullRequest(existing.id, url, createCliActor()));
-			return {
-				value: link,
-				text: `Linked ${link.owner}/${link.repo}#${link.number} to ${existing.id} (${link.id})`,
-				fields: PULL_REQUEST_FIELDS
-			};
-		});
-	});
-	withBoardOptions(pr.command("list").description("List the pull requests linked to a card").argument("<card>", "the card, as MAN-012, MAN-12 or 12")).action(async (reference, options) => {
-		await runBoardCommand(options, "read", async (session) => {
-			const existing = await requireCard(session, reference);
-			const links = (await session.ops.listPullRequests(existing.id)).map(projectPullRequest);
-			return {
-				value: links,
-				text: links.length === 0 ? `${existing.id} names no pull requests.` : links.map(describePullRequest).join("\n"),
-				fields: PULL_REQUEST_FIELDS
-			};
-		});
-	});
-	withBoardOptions(pr.command("remove").description("Unlink a pull request from a card").argument("<card>", "the card, as MAN-012, MAN-12 or 12").argument("<linkId>", "the link id, as kanbo card pr list prints it")).action(async (reference, linkId, options) => {
-		await runBoardCommand(options, "write", async (session) => {
-			const existing = await requireCard(session, reference);
-			const link = projectPullRequest(await session.ops.unlinkPullRequest(existing.id, linkId, createCliActor()));
-			return {
-				value: link,
-				text: `Unlinked ${link.owner}/${link.repo}#${link.number} from ${existing.id}`,
-				fields: PULL_REQUEST_FIELDS
-			};
-		});
-	});
-}
-/**
-* The card as both shapes the output contract offers. A card a person placed
-* in a column whose entry rules it does not meet (ruling 6-5) also leaves one
-* warning line per unmet rule on stderr, so the card prints as usual.
-*/
-async function presentCard(session, card) {
-	const [columns, runs] = await Promise.all([session.ops.listColumns(session.workspace.id), session.ops.readBoardProjectionForIssue(card.id)]);
-	const view = projectCard(card, columns, runs);
-	for (const item of card.unmetRules ?? []) console.error(`kanbo: warning: ${view.id} entered "${view.column ?? "—"}" without ${item.rule}: ${item.detail}`);
-	return {
-		value: view,
-		text: describeCard(view),
-		fields: CARD_VIEW_FIELDS
-	};
-}
-/**
-* The fields `card update` was asked to change — all but the parent, a card
-* of the board, looked up there once the card itself is. A command that names
-* none of them is refused rather than obeyed: an empty update still bumps the
-* board version, and every reader would be told the board changed when it did not.
-*/
-function readUpdateInput(options) {
-	const input = {};
-	if (options.title !== void 0) input.title = options.title;
-	if (options.description !== void 0) input.description = options.description;
-	if (options.priority !== void 0) input.priority = options.priority;
-	if (options.labels !== void 0) input.labels = options.labels;
-	if (options.executionMode !== void 0) input.executionMode = options.executionMode;
-	if (Object.keys(input).length === 0 && options.parent === void 0) throw new CliError(1, "Nothing to update. Pass --title, --description, --priority, --labels, --execution-mode or --parent.");
-	return input;
-}
-function parsePriority(value) {
-	const priority = PRIORITIES$1.find((candidate) => candidate === value);
-	if (!priority) throw new CliError(1, `Unknown priority "${value}". Use one of ${PRIORITIES$1.join(", ")}.`);
-	return priority;
-}
-function parseLabels(value) {
-	return value.split(",").map((label) => label.trim()).filter((label) => label.length > 0);
-}
-/** A list option given comma-separated, repeated, or both. */
-function collectList(value, previous) {
-	return [...previous ?? [], ...value.split(",").map((item) => item.trim()).filter((item) => item.length > 0)];
-}
-function parsePriorities(value) {
-	return collectList(value, void 0).map(parsePriority);
-}
-function parseOffset(value) {
-	const count = Number(value);
-	if (!Number.isInteger(count) || count < 0) throw new CliError(1, `Expected a whole number of cards to skip, got "${value}".`);
-	return count;
-}
-function parseMoment(value) {
-	try {
-		return readUnixSeconds(value);
-	} catch (error) {
-		throw new CliError(2, `--updated-since: ${error.message}`);
-	}
-}
-function parseIncludes(value) {
-	if (value.trim() === "none") return [];
-	return collectList(value, void 0).map((part) => {
-		const include = KANBO_CARD_INCLUDES.find((candidate) => candidate.toLowerCase() === part.toLowerCase());
-		if (!include) throw new CliError(1, `Unknown part "${part}". Use ${KANBO_CARD_INCLUDES.join(", ")} or none.`);
-		return include;
-	});
-}
-/** A column the board does not have, said the way the rest of `kanbo card` says it. */
-function rethrowUnknownColumn(named) {
-	return (error) => {
-		if (error instanceof BoardError && error.code === "issue_status_not_found" && named) throw new CliError(1, `This board has no column "${String(error.details?.statusName)}".`);
-		throw error;
-	};
-}
-/** When the page is not every picked card, say so on stderr — where the next page starts, and how to get all of them. */
-function noteMoreCards(total, offset, shown) {
-	const more = total - offset - shown;
-	if (more > 0) console.error(`kanbo: ${more} more of ${total}; next page: --offset ${offset + shown}, or --all for every card`);
-}
-//#endregion
-//#region src/cli/column-changes.ts
-/**
-* What `kanbo columns add|rename|move|remove|template` do to a board, once
-* the command or the `kanbo columns` menu knows what the person asked for.
-* Both run these, so a change made from the menu reads exactly like the
-* command it names.
-*
-* A refusal of the board's is said as a sentence with the command to type
-* instead, rather than as its code: these are a person's commands.
-*/
-const COLUMN_CATEGORIES = [
-	"backlog",
-	"unstarted",
-	"started",
-	"completed",
-	"canceled"
-];
-/** The whole board's columns after a change, and the sentence that says what changed. */
-async function changed(session, message, extra = {}) {
-	const board = await session.ops.listColumns(session.workspace.id);
-	const views = board.map((column) => projectColumn(column, board));
-	return {
-		value: {
-			...Object.fromEntries(Object.entries(extra).map(([key, value]) => [key, typeof value === "number" || Array.isArray(value) ? value : projectColumn(value, board)])),
-			columns: views
-		},
-		text: `${message}\n\n${describeColumns(views)}`
-	};
-}
-/**
-* A new column, placed in the same write that creates it. A ready-made name
-* (`QA`, `Blocked`) brings its own line and category; any other name is work
-* in progress. With no place given it goes before the board's first completed
-* column (Done), or Canceled, so work still to do stays on the left.
-*/
-async function addColumn(session, request, actor) {
-	const workspaceId = session.workspace.id;
-	const name = request.name.trim();
-	if (!normalizeStatusName(name)) throw new CliError(1, "Give the column a name.");
-	if (request.after !== void 0 && request.before !== void 0) throw new CliError(1, "Pass --after or --before, not both.");
-	const existing = await session.ops.findColumn(workspaceId, name);
-	if (existing) throw new CliError(1, `This board already has a column called ${existing.name} (slug ${normalizeStatusName(existing.name)}).`);
-	const anchorName = request.after ?? request.before;
-	const anchor = anchorName === void 0 ? null : await requireNamedColumn(session, anchorName);
-	const spec = findCatalogueColumn(name) ?? ownColumn(name, null);
-	const created = await session.ops.addColumn(workspaceId, {
-		name,
-		description: request.description?.trim() || spec.description,
-		color: spec.color,
-		category: request.category ?? spec.category,
-		position: anchor ? request.after !== void 0 ? { after: anchor.id } : { before: anchor.id } : void 0
-	}, actor);
-	return await changed(session, `Added ${created.name} (slug ${normalizeStatusName(created.name)}).`, { added: created });
-}
-/** Said after a rename: agents' instructions name no column but To Do, and `kanbo prime` gives them the rest. */
-const RENAME_NOTE = "Agents read column names from kanbo prime; rename is picked up there.";
-async function renameColumn(session, column, newName, actor) {
-	const before = await requireNamedColumn(session, column);
-	const renamed = await session.ops.renameColumn(session.workspace.id, before.id, newName, actor);
-	return await changed(session, before.name === renamed.name ? `${renamed.name} already has that name.` : `Renamed ${before.name} to ${renamed.name} (slug ${normalizeStatusName(renamed.name)}).\n${RENAME_NOTE}`, { renamed });
-}
-/** `--first`, `--last`, `--before <column>` or `--after <column>` — exactly one. */
-function readColumnPosition(options) {
-	const given = [
-		options.first ? "first" : null,
-		options.last ? "last" : null,
-		options.before !== void 0 ? { before: options.before } : null,
-		options.after !== void 0 ? { after: options.after } : null
-	].filter((position) => position !== null);
-	if (given.length !== 1) throw new CliError(1, "Say where the column goes: --first, --last, --before <column> or --after <column> (one of them).");
-	return given[0];
-}
-async function moveColumn(session, column, position, actor) {
-	const moving = await requireNamedColumn(session, column);
-	const anchorName = typeof position === "string" ? null : "before" in position ? position.before : position.after;
-	const anchor = anchorName === null ? null : await requireNamedColumn(session, anchorName);
-	const before = await session.ops.listColumns(session.workspace.id);
-	const after = await session.ops.moveColumn(session.workspace.id, moving.id, position, actor);
-	const where = position === "first" ? "to the start" : position === "last" ? "to the end" : `${"before" in position ? "before" : "after"} ${anchor.name}`;
-	return await changed(session, before.map((candidate) => candidate.id).join() === after.map((candidate) => candidate.id).join() ? `${moving.name} is already there.` : `Moved ${moving.name} ${where}.`);
-}
-/** How many cards sit in the column right now. */
-async function countCardsIn(session, column) {
-	return (await session.store.issues.listInBoardOrder(session.workspace.id)).filter((card) => card.statusId === column.id).length;
-}
-async function removeColumn(session, column, moveCardsTo, actor) {
-	const removing = await requireNamedColumn(session, column);
-	if (moveCardsTo !== null) await requireNamedColumn(session, moveCardsTo);
-	const result = await session.ops.removeColumn(session.workspace.id, removing.id, { moveCardsTo }, actor);
-	for (const card of result.unmetRules ?? []) for (const item of card.unmet) console.error(`kanbo: warning: ${card.issueId} entered "${result.movedTo?.name ?? "—"}" without ${item.rule}: ${item.detail}`);
-	return await changed(session, result.movedTo ? `Removed ${result.removed.name} and moved ${describeCount$1(result.movedCards)} to ${result.movedTo.name}.` : `Removed ${result.removed.name}.`, {
-		removed: result.removed,
-		movedCards: result.movedCards
-	});
-}
-/** The template a person named, or the error that lists the ones there are. */
-function readTemplateId(value) {
-	const id = COLUMN_TEMPLATE_IDS.find((candidate) => candidate === value.trim().toLowerCase());
-	if (!id) throw new CliError(1, `Unknown template "${value}". Use ${COLUMN_TEMPLATE_IDS.join(", ")}.`);
-	return id;
-}
-/**
-* A template's columns on this board. An empty board gets the template as it
-* is; a board with columns only gets the ones it lacks, and only when asked
-* with `--add-missing` — a template never takes a column away.
-*/
-async function applyTemplate(session, id, addMissing, actor) {
-	const workspaceId = session.workspace.id;
-	const label = COLUMN_TEMPLATE_LABELS[id];
-	const present = await session.ops.listColumns(workspaceId);
-	if (present.length > 0 && !addMissing) throw new CliError(1, `This board already has columns. Add the ${label} columns it lacks with: kanbo columns template ${id} --add-missing`);
-	const { added } = present.length === 0 ? await session.ops.applyColumnTemplate(workspaceId, COLUMN_TEMPLATES[id], { mode: "seed" }) : await session.ops.applyColumnTemplate(workspaceId, COLUMN_TEMPLATES[id], {
-		mode: "add-missing",
-		actor
-	});
-	return await changed(session, added.length === 0 ? `This board already has every ${label} column.` : `Added ${added.join(", ")}.`, { added });
-}
-/** The column a person named, or the error that says the board has none by that name. */
-async function requireNamedColumn(session, nameOrId) {
-	const column = normalizeStatusName(nameOrId) ? await session.ops.findColumn(session.workspace.id, nameOrId) : null;
-	if (!column) throw new CliError(1, `This board has no column "${nameOrId}". See kanbo columns list.`);
-	return column;
-}
-function describeCount$1(count) {
-	return `${count} ${count === 1 ? "card" : "cards"}`;
+function describeCount$1(count) {
+	return `${count} ${count === 1 ? "card" : "cards"}`;
 }
 //#endregion
 //#region src/cli/humanize.ts
@@ -6943,14 +6141,8 @@ const BOARD_ERROR_TEXTS = {
 		text: "Only a person can approve a card.",
 		next: AS_A_PERSON
 	}),
-	board_card_not_ready: (details) => ({
-		text: details.reason === "run_active" ? `${named(details.issueId)} is taken: it has a run going.` : details.reason === "waiting_for_person" ? `${named(details.issueId)} is waiting for a person.` : `${named(details.issueId)} is not in To Do, so it is not there to take.`,
-		next: "kanbo ready"
-	}),
-	board_card_run_active: (details) => ({
-		text: `${named(details.issueId)} already has a run going: ${named(details.agentName)}'s, run ${named(details.runId)}.`,
-		next: `kanbo run finish ${named(details.runId)} --state stopped`
-	}),
+	board_card_not_ready: (details) => ({ text: details.reason === "run_active" ? `${named(details.issueId)} is taken: it has a run going.` : details.reason === "waiting_for_person" ? `${named(details.issueId)} is waiting for a person.` : `${named(details.issueId)} is not in To Do, so it is not there to take.` }),
+	board_card_run_active: (details) => ({ text: `${named(details.issueId)} already has a run going: ${named(details.agentName)}'s, run ${named(details.runId)}.` }),
 	board_column_name_taken: (details) => ({
 		text: `Another column, ${named(details.takenBy)}, already has that name (same slug). Pick another name.`,
 		next: "kanbo columns list"
@@ -6959,7 +6151,7 @@ const BOARD_ERROR_TEXTS = {
 		text: `${named(details.statusName)} holds ${describeCount(Number(details.cardCount))}. Say where they go.`,
 		next: `kanbo columns remove ${normalizeStatusName(named(details.statusName))} --move-cards-to <column>`
 	}),
-	board_column_ready_protected: (details) => ({ text: details.newName === void 0 ? `${named(details.statusName)} can't be removed: kanbo ready takes work from To Do, and agents would find no cards to take.` : `${named(details.statusName)} can't be renamed to "${named(details.newName)}": kanbo ready takes work from To Do, and agents would find no cards to take. Another spelling of To Do (To-do, TO DO) is fine.` }),
+	board_column_ready_protected: (details) => ({ text: details.newName === void 0 ? `${named(details.statusName)} can't be removed: agents take work from To Do and would find no cards to take.` : `${named(details.statusName)} can't be renamed to "${named(details.newName)}": agents take work from To Do and would find no cards to take. Another spelling of To Do (To-do, TO DO) is fine.` }),
 	board_column_remove_target_invalid: (details) => ({
 		text: `Cards can't move into ${named(details.statusName)}: it is the column being removed.`,
 		next: "kanbo columns list"
@@ -6986,15 +6178,9 @@ const BOARD_ERROR_TEXTS = {
 		next: "kanbo columns list"
 	},
 	board_metrics_range_invalid: (details) => typeof details.from === "number" && typeof details.to === "number" ? { text: `The range starts after it ends: it starts on ${utcDayLabel(details.from)} and ends on ${utcDayLabel(details.to)}.` } : { text: "The range starts after it ends." },
-	board_nothing_ready: () => ({
-		text: "No card in To Do is ready to take: each one is taken or waits for a person, or there is none.",
-		next: "kanbo ready"
-	}),
+	board_nothing_ready: () => ({ text: "No card in To Do is ready to take: each one is taken or waits for a person, or there is none." }),
 	board_pull_request_invalid: (details) => ({ text: `"${named(details.value)}" is not a GitHub pull request. Give its link or owner/repo#number.` }),
-	board_pull_request_not_found: (details) => ({
-		text: `${named(details.issueId)} has no pull request link "${named(details.linkId)}".`,
-		next: `kanbo card pr list ${named(details.issueId)}`
-	}),
+	board_pull_request_not_found: (details) => ({ text: `${named(details.issueId)} has no pull request link "${named(details.linkId)}".` }),
 	board_pull_request_not_yours: (details) => ({ text: `Someone else linked that pull request to ${named(details.issueId)}; only they or a person can unlink it.` }),
 	board_return_no_previous_column: (details) => ({
 		text: `${named(details.issueId)} is already in the first column: there is no column before it to send it back to.`,
@@ -7006,10 +6192,7 @@ const BOARD_ERROR_TEXTS = {
 	}),
 	board_run_already_finished: (details) => ({ text: `Run ${named(details.runId)} has already finished.` }),
 	board_run_not_found: (details) => ({ text: `No run "${named(details.runId)}" on this board.` }),
-	board_run_session_ref_conflict: (details) => ({
-		text: `Run ${named(details.runId)} already names another session log (${describeSessionRef(details.externalSessionRef)}).`,
-		next: `a person can replace it: kanbo run attach-session ${named(details.runId)} <ref> --replace`
-	}),
+	board_run_session_ref_conflict: (details) => ({ text: `Run ${named(details.runId)} already names another session log (${describeSessionRef(details.externalSessionRef)}).` }),
 	board_run_session_ref_invalid: (details) => ({ text: `"${named(details.value)}" is not a session log. Give it as claude:<id> or codex:<id>.` }),
 	board_run_session_ref_requires_user: () => ({
 		text: "Only a person can change or clear the session log a run names.",
@@ -7033,22 +6216,19 @@ const BOARD_ERROR_TEXTS = {
 		next: AS_A_PERSON
 	}),
 	issue_comment_not_found: (details) => ({ text: `No comment "${named(details.commentId)}" on this board.` }),
-	issue_context_ref_invalid_index: (details) => ({
-		text: `${named(details.issueId)} has no context link number ${named(details.index)}.`,
-		next: `kanbo card get ${named(details.issueId)}`
-	}),
+	issue_context_ref_invalid_index: (details) => ({ text: `${named(details.issueId)} has no context link number ${named(details.index)}.` }),
 	issue_milestone_not_found: (details) => ({
 		text: `No sprint "${named(details.milestoneId)}" on this board.`,
 		next: "kanbo sprint list"
 	}),
 	issue_not_found: (details) => ({
 		text: `No card "${named(details.issueId)}" here.`,
-		next: "kanbo card list"
+		next: "kanbo board"
 	}),
 	issue_parent_cycle: () => ({ text: "A card can't be put under one of its own sub-cards." }),
 	issue_parent_not_found: (details) => ({
 		text: `No card "${named(details.parentIssueId)}" here to put this one under.`,
-		next: "kanbo card list"
+		next: "kanbo board"
 	}),
 	issue_parent_self_reference: () => ({ text: "A card can't be put under itself." }),
 	issue_relation_not_found: (details) => ({ text: `No link "${named(details.relationId)}" between cards on this board.` }),
@@ -7661,29 +6841,9 @@ dirname(fileURLToPath(import.meta.url));
 * `package.version`. A build carries it as a literal; running from source
 * (tests, `tsx`) reads the package's own `package.json` instead.
 */
-const KANBO_PACKAGE_VERSION = "0.6.0";
+const KANBO_PACKAGE_VERSION = "0.8.0";
 //#endregion
 //#region src/cli/setup/paths.ts
-/**
-* Where each agent tool keeps the files kanbo writes into, for one project and
-* for the person's whole machine.
-*
-* Resolved on every call rather than at import, so `HOME` and `CODEX_HOME` set
-* by a test (or a person) are the ones obeyed. Each path was checked against
-* the tool's own documentation; `docs/agents.md` lists the pages.
-*/
-/** The tools whose user-level instruction file `kanbo init --global` can write. */
-const GLOBAL_INSTRUCTION_CLIENTS = [
-	"claude",
-	"codex",
-	"gemini"
-];
-/** The tools that can be told about the board's MCP server. */
-const MCP_CLIENTS = [
-	"claude",
-	"codex",
-	"cursor"
-];
 /** Where Codex keeps its global files: `$CODEX_HOME`, else `~/.codex`. */
 function codexHome() {
 	return process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
@@ -7691,7 +6851,9 @@ function codexHome() {
 /**
 * Where Claude Code keeps its user files: `$CLAUDE_CONFIG_DIR`, else
 * `~/.claude`. Its documentation says every `~/.claude` path moves there; it
-* does not say `~/.claude.json` does, so that one is not moved here.
+* does not say `~/.claude.json` does; the MCP file follows the variable
+* all the same, as `claude mcp add --scope user` writes it there
+* (`globalMcpConfigPath`).
 */
 function claudeConfigDir() {
 	return process.env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude");
@@ -7700,7 +6862,7 @@ function claudeConfigDir() {
 function geminiDir() {
 	return join(process.env.GEMINI_CLI_HOME?.trim() || homedir(), ".gemini");
 }
-/** The user-level instruction file of each tool. */
+/** The user-level instruction file of each tool — where an older kanbo wrote its block, which `kanbo connect` takes out. */
 function globalInstructionPath(client) {
 	switch (client) {
 		case "claude": return join(claudeConfigDir(), "CLAUDE.md");
@@ -7710,12 +6872,13 @@ function globalInstructionPath(client) {
 }
 /**
 * The user-level MCP configuration of each tool. Claude Code's is
-* `~/.claude.json`, its own state file: kanbo reads it but never writes it —
+* `.claude.json` in `$CLAUDE_CONFIG_DIR` (else in the home directory), its own
+* state file: resolved on every call, and kanbo reads it but never writes it —
 * `claude mcp add` and `claude mcp remove` do.
 */
 function globalMcpConfigPath(client) {
 	switch (client) {
-		case "claude": return join(homedir(), ".claude.json");
+		case "claude": return join(process.env.CLAUDE_CONFIG_DIR?.trim() || homedir(), ".claude.json");
 		case "codex": return join(codexHome(), "config.toml");
 		case "cursor": return join(homedir(), ".cursor", "mcp.json");
 	}
@@ -7786,8 +6949,9 @@ function isExecutableFile(path) {
 //#region src/cli/setup/agents.ts
 /**
 * The agent tools kanbo can connect a project — or a person — to, and for
-* each one: how to tell it is here, which file it reads its standing
-* instructions from, and where it keeps its MCP servers.
+* each one: how to tell it is here, which file an older kanbo wrote
+* its instruction block into (kept to take that block out again), and where it
+* keeps its MCP servers.
 *
 * `kanbo connect`, `kanbo init`, `kanbo uninstall` and `kanbo doctor` all read
 * this one table, so a file one of them writes is a file the others find.
@@ -7821,8 +6985,7 @@ const AGENTS = {
 		} : {
 			format: "claude-cli",
 			path: globalMcpConfigPath("claude")
-		},
-		mcpScope: "project"
+		}
 	},
 	codex: {
 		id: "codex",
@@ -7832,8 +6995,7 @@ const AGENTS = {
 		mcpTarget: (scope, projectDir) => ({
 			format: "toml",
 			path: scope === "project" ? join(projectDir, ".codex", "config.toml") : globalMcpConfigPath("codex")
-		}),
-		mcpScope: "user"
+		})
 	},
 	cursor: {
 		id: "cursor",
@@ -7844,9 +7006,7 @@ const AGENTS = {
 			format: "json",
 			path: scope === "project" ? join(projectDir, ".cursor", "mcp.json") : globalMcpConfigPath("cursor"),
 			withType: true
-		}),
-		mcpScope: "project",
-		noInstructionFile: "Cursor keeps its rules for every project in its settings, not in a file: paste the kanbo block into Cursor Settings → Rules → User Rules yourself."
+		})
 	},
 	gemini: {
 		id: "gemini",
@@ -7857,13 +7017,16 @@ const AGENTS = {
 			format: "json",
 			path: scope === "project" ? join(projectDir, ".gemini", "settings.json") : join(geminiDir(), "settings.json"),
 			withType: false
-		}),
-		mcpScope: "project"
+		})
 	}
 };
-/** Where the MCP server goes when no scope is named: on Windows always the person's own configuration. */
-function defaultMcpScope(agent, platform = process.platform) {
-	return platform === "win32" ? "user" : AGENTS[agent].mcpScope;
+/**
+* Where the MCP server goes when no scope is named: the person's own
+* configuration, for every agent. One registration serves every project —
+* `kanbo mcp` finds the board from the folder the client starts it in.
+*/
+function defaultMcpScope() {
+	return "user";
 }
 /** The agent's name as typed on the command line, or `null` when it is none of them. */
 function parseAgentId(name) {
@@ -8006,66 +7169,10 @@ const INSTRUCTION_END = "<!-- KANBO_END -->";
 */
 const INSTRUCTION_START_PATTERN = /<!-- KANBO_START\b([^>]*?)\s*-->/g;
 const INSTRUCTION_END_PATTERN = /<!-- KANBO_END\s*-->/g;
-/** The kinds of block that are kanbo's pointer — the one `kanbo connect` writes. */
+/** The kinds of block that are kanbo's pointer — the one kanbo 0.5–0.6 wrote. */
 const POINTER_KINDS = /* @__PURE__ */ new Set(["short", "global"]);
-/** The commands an agent uses, spelled once for the guide and the `kanbo prime` cheat sheet. */
-const COMMAND = {
-	claim: "kanbo claim",
-	move: "kanbo card move <id> <column>",
-	statusLine: "kanbo card status-line <id> --text \"...\"",
-	subtask: "kanbo card create --description \"...\" --parent <id>",
-	comment: "kanbo card comment <id> --content \"...\"",
-	waitApproval: "kanbo card wait-approval <id>",
-	runStart: "kanbo run start <id> --agent <name>",
-	capabilities: "kanbo capabilities"
-};
-/**
-* The whole guide for an agent working a board from the command line — what
-* the project block said in kanbo 0.1–0.2, before it became a pointer.
-*/
-const AGENT_GUIDE_TEXT = [
-	"## Kanbo board",
-	"",
-	"Work on this project is tracked on a kanbo board. Before starting a task run `kanbo prime` — it prints the board's columns and what each one means.",
-	"",
-	...[
-		`- Take a card with \`${COMMAND.claim}\`: it starts your run and moves the card into work in one step, and no other agent gets the same card.`,
-		`- ${MOVE_CARD_RULE} (\`${COMMAND.move}\`)`,
-		`- ${STATUS_LINE_RULE} (\`${COMMAND.statusLine}\`)`,
-		`- ${SUBTASK_RULE} (\`${COMMAND.subtask}\`)`,
-		`- ${COMMENT_RULE} (\`${COMMAND.comment}\`)`,
-		`- ${WAIT_FOR_PERSON_RULE} (\`${COMMAND.waitApproval}\`)`,
-		`- ${PERSON_ONLY_RULE}`,
-		`- ${OWN_SESSION_RULE} (\`${COMMAND.runStart}\`)`,
-		`- Run \`${COMMAND.capabilities}\` for the full list of tools, commands and rules.`
-	]
-].join("\n");
-/**
-* The commands, for an agent with no MCP tools: `kanbo prime` prints this under
-* the board's rules, which say when to use each. Each is written out with its
-* arguments, as a call that works — agents that had only the placeholders read
-* `kanbo capabilities` first, or guessed an option and ran it again
-* (docs/performance.md).
-*/
-const COMMAND_SHEET = [
-	"Commands (a card is named by its id, e.g. TST-5):",
-	"",
-	"- `kanbo ready` — the cards you may take next; cards a person sent back to you come first",
-	"- `kanbo card get TST-5` — one card, with its latest comments",
-	"- `kanbo card list --waiting` (or `--returned`) — cards waiting for a person (or sent back), each with its last comment",
-	"- `kanbo card move TST-5 in_progress` — move a card; the column by its slug above",
-	"- `kanbo card status-line TST-5 --text \"Running the tests\"` — what is happening on the card right now",
-	"- `kanbo card comment TST-5 --content \"Added slugify with a test\"` — a finding, result, decision or question",
-	"- `kanbo card create --description \"...\" --parent TST-5` — a subtask",
-	"- `kanbo card update TST-7 --parent TST-5` — move a card at the wrong level under another (`--parent none`: the top level)",
-	"- `kanbo card wait-approval TST-5 --text \"Ready for review: ...\"` — ask a person, then end your turn",
-	"- `kanbo claim` — take the first ready card: starts your run and moves it into work in one step (`kanbo claim TST-5` for that card); it prints the finish command",
-	"- `kanbo run start TST-5 --agent claude` — record a run on a card you did not claim; it prints the finish command",
-	"- `kanbo run finish <run id> --state finished` — end it: finished, failed or stopped",
-	`- \`${COMMAND.capabilities}\` — everything else, rarely needed`
-].join("\n");
 /** How to take work and who approves it — said by both blocks after their first sentence. */
-const POINTER_TAIL = `Take work with \`${COMMAND.claim}\`. ${PERSON_ONLY_RULE}`;
+const POINTER_TAIL = `Take work with \`kanbo claim\`. ${PERSON_ONLY_RULE}`;
 /** The body of the project block: what `kanbo instructions short` prints. */
 const PROJECT_BODY = [
 	"## Kanbo board",
@@ -8088,9 +7195,9 @@ const GLOBAL_BODY = [
 function wrapInstructionBlock(body, version = 3, kind) {
 	return `<!-- KANBO_START v${version}${kind ? ` k=${kind}` : ""} h=${hashBody(body)} -->\n${body}\n${INSTRUCTION_END}`;
 }
-/** The block `kanbo init --instructions …` writes into a project's own file. */
+/** The project block kanbo 0.5–0.6 wrote into a project's own file. */
 const INSTRUCTION_BLOCK = wrapInstructionBlock(PROJECT_BODY);
-/** The block `kanbo init --global` writes into a person's user-level file. */
+/** The global block kanbo 0.5–0.6 wrote into a person's user-level file. */
 const GLOBAL_INSTRUCTION_BLOCK = wrapInstructionBlock(GLOBAL_BODY);
 /** The same, with what the block's marker said. */
 function inspectBlock(text, current) {
@@ -8113,58 +7220,15 @@ function inspectBlock(text, current) {
 		version: version === void 0 ? null : Number(version),
 		kind
 	});
-	if (fields.trim() === "") return inspection(LEGACY_BLOCK_BODIES.includes(body) ? "legacy" : "edited");
-	if (version !== void 0 && Number(version) > 3) return inspection("newer");
-	if (kind !== null && !POINTER_KINDS.has(kind)) return inspection("chosen");
-	if (version === void 0 || hash === void 0 || hashBody(body) !== hash) return inspection("edited");
-	return inspection(normalized.slice(found.start, found.end) === current ? "current" : "outdated");
-}
-/** What the person is told about a file whose markers do not pair up; `label` names the file. */
-function damagedBlockMessage(label, damage) {
-	return `${label} has ${damage} — fix it by hand, then run again.`;
-}
-/** What the person is told about a block a newer kanbo wrote. */
-function newerBlockMessage(label, version) {
-	return `${label}: the kanbo section was written by a newer kanbo (v${version ?? "?"}) — kept. Update kanbo: npm install -g kanbo-cli@latest`;
-}
-/**
-* The block in that file, once.
-*
-* A file that already carries the markers has its block replaced rather than
-* appended to, so a current block changes nothing at all and an outdated one is
-* brought forward. Everything outside the markers is the person's own writing
-* and is never touched.
-*/
-function planInstructionBlock(path, block) {
-	return planTextFile(path, (existing) => withBlock(existing, block));
-}
-/**
-* The same, minding a block that is not kanbo's to replace: one the person
-* changed is replaced only when they say so at a terminal, and the default
-* answer is no. `--yes` is not that answer — it agrees to kanbo's own changes,
-* not to losing theirs. A block of a text the person chose, one a newer kanbo
-* wrote, and a file whose markers do not pair up are left as they are.
-*/
-async function planInstructionBlockAsking(path, block, options) {
-	const inspection = readInstructionBlockInspection(path, block);
-	const label = options.label ?? path;
-	const keep = (note) => ({
-		change: {
-			path,
-			next: null
-		},
-		note
-	});
-	switch (inspection?.state) {
-		case "damaged": return keep(damagedBlockMessage(label, inspection.damage));
-		case "newer": return keep(newerBlockMessage(label, inspection.version));
-		case "chosen": return keep(`${label}: you chose the ${inspection.kind} text for the kanbo section — kept.`);
-		case "edited": return !options.yes && canPrompt() && await getUi().confirm({
-			message: `You changed the kanbo section in ${label}. Replace it with the current one?`,
-			initialValue: false
-		}) ? { change: planInstructionBlock(path, block) } : keep(`${label}: you changed the kanbo section, so it was left as it is.`);
-		default: return { change: planInstructionBlock(path, block) };
-	}
+	if (fields.trim() === "") return inspection(LEGACY_BLOCK_BODIES.includes(body) ? "legacy" : "edited");
+	if (version !== void 0 && Number(version) > 3) return inspection("newer");
+	if (kind !== null && !POINTER_KINDS.has(kind)) return inspection("chosen");
+	if (version === void 0 || hash === void 0 || hashBody(body) !== hash) return inspection("edited");
+	return inspection(normalized.slice(found.start, found.end) === current ? "current" : "outdated");
+}
+/** What the person is told about a file whose markers do not pair up; `label` names the file. */
+function damagedBlockMessage(label, damage) {
+	return `${label} has ${damage} — fix it by hand, then run again.`;
 }
 /**
 * The file without the block, or no change when it carries none. The file
@@ -8220,13 +7284,6 @@ function readInstructionBlockInspection(path, current) {
 	const text = readTextFile(path)?.text;
 	return text === void 0 ? null : inspectBlock(text, current);
 }
-function withBlock(existing, block) {
-	if (existing === null || !existing.trim()) return `${block}\n`;
-	const bounds = findBlock(existing);
-	if (bounds && "damage" in bounds) return null;
-	if (bounds) return existing.slice(0, bounds.start) + block + existing.slice(bounds.end);
-	return `${existing.replace(/\s*$/, "")}\n\n${block}\n`;
-}
 /**
 * The first block in the text; `null` when there is none; `{ damage }` when
 * the markers do not pair up — every start followed by its end before the
@@ -8355,48 +7412,6 @@ function spawnDetached(command, args) {
 		child.unref();
 	} catch {}
 }
-/**
-* Run a program with this input on its stdin and say whether it exited `0`.
-* Never throws: a program that is not installed, fails or hangs past the
-* timeout is `false`, and the caller tries the next thing. Its output is
-* dropped — nothing it prints reaches kanbo's own stdout.
-*/
-function runWithInput(command, args, input, options) {
-	return new Promise((resolve) => {
-		let settled = false;
-		const settle = (ok) => {
-			if (!settled) {
-				settled = true;
-				clearTimeout(timer);
-				resolve(ok);
-			}
-		};
-		let child;
-		try {
-			child = crossSpawn(command, [...args], {
-				detached: options.detached ?? false,
-				stdio: [
-					"pipe",
-					"ignore",
-					"ignore"
-				],
-				windowsHide: true
-			});
-		} catch {
-			resolve(false);
-			return;
-		}
-		const timer = setTimeout(() => {
-			child.kill();
-			settle(false);
-		}, options.timeoutMs);
-		child.on("error", () => settle(false));
-		child.on("exit", (code) => settle(code === 0));
-		child.stdin?.on("error", () => {});
-		child.stdin?.end(input);
-		if (options.detached) child.unref();
-	});
-}
 //#endregion
 //#region src/cli/setup/mcp-config.ts
 /**
@@ -8527,7 +7542,7 @@ function readJsonMcpEntry(path) {
 	return {
 		command: typeof command === "string" && command.trim() ? command.trim() : null,
 		args: Array.isArray(args) ? args.filter((arg) => typeof arg === "string") : [],
-		otherFields: Object.keys(entry).filter((key) => key !== "command" && key !== "args" && !(key === "type" && entry.type === "stdio"))
+		otherFields: Object.keys(entry).filter((key) => key !== "command" && key !== "args" && !(key === "type" && entry.type === "stdio") && !(key === "env" && isPlainObject$1(entry.env) && Object.keys(entry.env).length === 0))
 	};
 }
 /**
@@ -8560,7 +7575,7 @@ function planCodexMcpServer(path, launch = PORTABLE_MCP_LAUNCH, options = {}) {
 * Is this entry one kanbo wrote, in exactly the shape it writes it? `kanbo mcp`
 * (with `"type": "stdio"` or without), or a Node given by full path running
 * kanbo's own script (`…/kanbo-cli/dist/cli.cjs mcp`) — and nothing else: an
-* entry with an `env`, a `cwd` or any other field, or one that starts kanbo
+* entry with a non-empty `env`, a `cwd` or any other field, or one that starts kanbo
 * some other way (`cmd /c kanbo mcp`, `npx -y kanbo-cli mcp`), is the
 * person's, and kanbo never rewrites or removes it without asking.
 */
@@ -8723,10 +7738,10 @@ function readJsonConfig(path, text) {
 	try {
 		parsed = JSON.parse(text);
 	} catch {
-		throw new CliError(1, `${path} is not valid JSON. Fix or remove it, then run kanbo init again.`);
+		throw new CliError(1, `${path} is not valid JSON. Fix or remove it, then run kanbo connect again.`);
 	}
-	if (!isPlainObject$1(parsed)) throw new CliError(1, `${path} does not hold a JSON object. Fix or remove it, then run kanbo init again.`);
-	if (parsed.mcpServers !== void 0 && !isPlainObject$1(parsed.mcpServers)) throw new CliError(1, `${path} has an "mcpServers" that is not an object. Fix it, then run kanbo init again.`);
+	if (!isPlainObject$1(parsed)) throw new CliError(1, `${path} does not hold a JSON object. Fix or remove it, then run kanbo connect again.`);
+	if (parsed.mcpServers !== void 0 && !isPlainObject$1(parsed.mcpServers)) throw new CliError(1, `${path} has an "mcpServers" that is not an object. Fix it, then run kanbo connect again.`);
 	return parsed;
 }
 /** The file's text as a JSON object, or `null` when it is missing or anything else — for reading and removal, which never refuse. */
@@ -8749,8 +7764,9 @@ function isPlainObject$1(value) {
 * worked out in full before anything is written.
 *
 * `kanbo connect` builds one of these from the agents and scopes it was given,
-* `kanbo init --instructions/--mcp` and `kanbo init --global` build theirs the
-* same way, and all of them show it, ask, and apply it here. Each item is one
+* `kanbo init --connect` builds its the same way, and both show it, ask, and
+* apply it here. kanbo writes only the MCP server into an agent's settings; the
+* `instructions` items take out the section older versions wrote. Each item is one
 * file (or one `claude mcp` command) with what changes in it; an item whose
 * file already says it has `next: null` and is reported `unchanged`.
 */
@@ -8766,8 +7782,10 @@ function ownMcpEntryNote(label, path) {
 	return `${label}: ${path} has your own kanbo entry — left as is.`;
 }
 /**
-* The plan that connects these agents. Asks only one question, and only at a
-* terminal: whether to replace an instruction block the person changed.
+* The plan that connects these agents: their MCP server registered, and the
+* kanbo section older versions wrote into their instruction files taken out.
+* Asks nothing: a section a person changed (or chose, or a newer kanbo wrote)
+* is kept and named in a note, never removed without their say.
 */
 async function planConnect(requests, context) {
 	const plan = {
@@ -8776,29 +7794,36 @@ async function planConnect(requests, context) {
 		notes: []
 	};
 	const planned = /* @__PURE__ */ new Set();
-	for (const { agent, instructions: scope } of requests) {
-		if (scope === null) continue;
-		const path = AGENTS[agent].instructionPath(scope, context.projectDir);
-		if (path === null) {
-			plan.notes.push(AGENTS[agent].noInstructionFile ?? `${AGENTS[agent].label} has no instruction file for this scope.`);
-			continue;
-		}
-		const existing = plan.items.find((item) => item.kind === "instructions" && item.change.path === path);
-		if (existing?.kind === "instructions") {
-			existing.agents.push(agent);
-			continue;
+	for (const { agent, instructions } of requests) {
+		if (instructions === null) continue;
+		for (const scope of instructions === "both" ? ["project", "user"] : [instructions]) {
+			const path = AGENTS[agent].instructionPath(scope, context.projectDir);
+			if (path === null) continue;
+			const existing = plan.items.find((item) => item.kind === "instructions" && item.change.path === path);
+			if (existing?.kind === "instructions") {
+				existing.agents.push(agent);
+				continue;
+			}
+			const label = displayPath(plan, path);
+			const inspection = readInstructionBlockInspection(path, INSTRUCTION_BLOCK);
+			switch (inspection?.state) {
+				case void 0: break;
+				case "damaged":
+					plan.notes.push(damagedBlockMessage(label, inspection.damage));
+					break;
+				case "edited":
+				case "chosen":
+				case "newer":
+					plan.notes.push(`${label}: an old kanbo section is still there; kanbo no longer uses it. Delete it yourself.`);
+					break;
+				default: plan.items.push({
+					kind: "instructions",
+					agents: [agent],
+					scope,
+					change: planInstructionBlockRemoval(path)
+				});
+			}
 		}
-		const asked = await planInstructionBlockAsking(path, scope === "project" ? INSTRUCTION_BLOCK : GLOBAL_INSTRUCTION_BLOCK, {
-			yes: context.yes,
-			label: displayPath(plan, path)
-		});
-		if (asked.note) plan.notes.push(asked.note);
-		plan.items.push({
-			kind: "instructions",
-			agents: [agent],
-			scope,
-			change: asked.change
-		});
 	}
 	for (const { agent, mcp: scope } of requests) {
 		if (scope === null) continue;
@@ -8969,11 +7994,10 @@ function readMcpState(agent, scope, projectDir, platform) {
 	if (!isKanboEntry(entry, scope, platform)) return "own";
 	return isStaleMcpEntry(entry, scope, platform) ? "stale" : "ok";
 }
-/** What the instruction block for one agent in one scope is; `null` when that scope has no file for it. */
-function readInstructionState(agent, scope, projectDir) {
+/** The file that still carries a kanbo section from an older version, in one agent's scope; none when it carries none. */
+function readOldSectionPaths(agent, scope, projectDir) {
 	const path = AGENTS[agent].instructionPath(scope, projectDir);
-	if (path === null) return null;
-	return readInstructionBlockState(path, scope === "project" ? INSTRUCTION_BLOCK : GLOBAL_INSTRUCTION_BLOCK) ?? "missing";
+	return path !== null && readInstructionBlockState(path, INSTRUCTION_BLOCK) !== null ? [path] : [];
 }
 /** The items that change something. */
 function pendingItems(plan) {
@@ -8989,7 +8013,7 @@ function explainItem(item, removal = false) {
 		case "instructions": {
 			const readers = item.agents.map((agent) => AGENTS[agent].label).join(" and ");
 			const one = item.agents.length === 1;
-			return removal ? `the kanbo section ${readers} read${one ? "s" : ""} ${where}` : `the kanbo section: ${readers} read${one ? "s" : ""} it ${where} and run${one ? "s" : ""} kanbo prime before a task`;
+			return removal ? `the kanbo section ${readers} read${one ? "s" : ""} ${where}` : "the old kanbo section: agents now learn the board from the MCP server";
 		}
 		case "mcp": return removal ? `the kanbo MCP server ${AGENTS[item.agent].label} starts ${where}` : `${item.stale ? "rewrites a kanbo MCP entry that no longer starts: " : ""}lets ${AGENTS[item.agent].label} call the board's tools ${where}`;
 		case "claude-cli": return item.argvs.map((argv) => displayCommand(argv)).join(", then ");
@@ -9004,10 +8028,10 @@ function describeConnectPlan(plan, title, removal = false) {
 		"Nothing else is changed."
 	].join("\n");
 }
-/** One line per change the plan makes: `  write  CLAUDE.md (what it is for)`. */
+/** One line per change the plan makes: `  write  .mcp.json (what it is for)`. */
 function describeConnectItems(plan, removal = false) {
 	return pendingItems(plan).map((item) => {
-		const verb = item.kind === "claude-cli" ? "run  " : removal ? "edit " : "write";
+		const verb = item.kind === "claude-cli" ? "run  " : item.kind === "instructions" ? "remove" : removal ? "edit " : "write";
 		return item.kind === "claude-cli" ? `  ${verb}  ${explainItem(item, removal)}` : `  ${verb}  ${displayPath(plan, itemPath(item))} (${explainItem(item, removal)})`;
 	});
 }
@@ -9057,6 +8081,17 @@ function applyConnectPlan(plan) {
 	});
 }
 /**
+* What happened to one item, as a person reads it in the parentheses of an
+* outcome line: an old kanbo section taken out of a file is "removed", not
+* "written" (kanbo writes no section any more); a `claude mcp` command is
+* "ran …". `removal` is `kanbo connect --remove`, where every change is a removal.
+*/
+function describeOutcomeState(outcome, removal = false) {
+	if (outcome.kind === "instructions" && outcome.state === "written") return "old kanbo section removed";
+	if (outcome.state === "ran") return `ran ${outcome.command}`;
+	return outcome.state === "written" && removal ? "removed" : outcome.state;
+}
+/**
 * What the person reads about `claude mcp` commands left to them: each on a
 * line of its own, so each can be pasted into any shell — PowerShell has no `&&`.
 */
@@ -9144,7 +8179,7 @@ function startUpdateCheck(deps = {}) {
 		setTimeout: globalThis.setTimeout,
 		clearTimeout: globalThis.clearTimeout
 	};
-	const current = deps.currentVersion ?? "0.6.0";
+	const current = deps.currentVersion ?? "0.8.0";
 	const controller = new AbortController();
 	let found = null;
 	const timeout = timers.setTimeout(() => controller.abort(), UPDATE_CHECK_TIMEOUT_MS);
@@ -9423,8 +8458,8 @@ async function checkBoard(target, workspaceId, root) {
 /** The Standard columns, as the plan names them. */
 const STANDARD_COLUMN_NAMES = COLUMN_TEMPLATES.standard.map((column) => column.name).join(", ");
 /**
-* A board with no columns gives agents nothing to take: `kanbo prime` lists
-* none and `kanbo ready` has no To Do. Boards from kanbo 0.1–0.2 got their
+* A board with no columns gives agents nothing to take: `kanbo_prime` lists
+* none and `kanbo_ready` has no To Do. Boards from kanbo 0.1–0.2 got their
 * columns only with the first card.
 */
 async function checkColumns(store, workspaceId, open) {
@@ -9432,7 +8467,7 @@ async function checkColumns(store, workspaceId, open) {
 	return [{
 		check: "columns",
 		status: "warn",
-		detail: "This board has no columns: kanbo prime shows agents none, and kanbo ready has no To Do to take cards from.",
+		detail: "This board has no columns: kanbo_prime shows agents none, and kanbo_ready has no To Do to take cards from.",
 		fix: "Run kanbo doctor --fix, or kanbo columns template standard.",
 		repair: {
 			plan: [`  add    the Standard columns to the board: ${STANDARD_COLUMN_NAMES}`],
@@ -9486,9 +8521,11 @@ async function checkPostgresBoard(url, workspaceId) {
 	}
 }
 /**
-* Every instruction block kanbo could have written, compared with the one this
-* build writes. Only files that carry a block are reported: a file without one
-* is not a fault, but having no block anywhere is worth a warning.
+* Every instruction block an older kanbo could have written, in the project's
+* and the person's own agent files. kanbo writes none any more, so a file
+* without one is as it should be, and a file with one is worth a warning: the
+* agent learns the board from the MCP server and the block is dead text. Only
+* files that carry a block are reported.
 */
 async function checkInstructions(root) {
 	const findings = [];
@@ -9504,9 +8541,8 @@ async function checkInstructions(root) {
 	for (const { scope, root: folder, block } of scopes) for (const { path, agents } of instructionPaths(scope, folder)) {
 		const inspection = readInstructionBlockInspection(path, block);
 		if (inspection !== null) {
-			const command = `kanbo connect ${agents[0]} ${scope === "project" ? "--project" : "--global"} --no-mcp`;
-			const finding = blockFinding(path, inspection, scope === "project" ? `cd ${folder} && ${command}` : command);
-			if (inspection.state === "outdated" || inspection.state === "legacy") finding.repair = connectRepair(await planConnect([{
+			const finding = blockFinding(path, inspection, agents[0]);
+			if (inspection.state === "current" || inspection.state === "outdated" || inspection.state === "legacy") finding.repair = connectRepair(await planConnect([{
 				agent: agents[0],
 				instructions: scope,
 				mcp: null
@@ -9517,38 +8553,17 @@ async function checkInstructions(root) {
 			findings.push(finding);
 		}
 	}
-	if (findings.length === 0) findings.push({
-		check: "instructions",
-		status: "warn",
-		detail: "No kanbo instruction block in this project's or your own agent files: agents learn the rules only from the MCP server.",
-		fix: "Run kanbo connect in the project (kanbo connect claude --yes, say), or kanbo connect claude --global."
-	});
 	return findings;
 }
 /**
-* A block kanbo wrote and nobody changed is only out of date: it still sends
-* the agent to `kanbo prime`, so it is a warning, and `--yes` rewrites it. A
-* block the person changed is theirs, and only they can say to replace it; a
-* text they chose, or a block a newer kanbo wrote, is fine as it is. A file
-* whose markers do not pair up is one kanbo will not touch until it is fixed.
+* A block kanbo wrote and nobody changed is only dead text: it is a warning,
+* and `--fix` removes it. A block the person changed or chose, or one a newer
+* kanbo wrote, is theirs to delete. A file whose markers do not pair up is one
+* kanbo will not touch until it is fixed.
 */
-function blockFinding(path, inspection, command) {
+function blockFinding(path, inspection, agent) {
+	const detail = `${path}: an old kanbo section — agents now learn the board from the MCP server.`;
 	switch (inspection.state) {
-		case "current": return {
-			check: "instructions",
-			status: "ok",
-			detail: `${path}: block is current.`
-		};
-		case "chosen": return {
-			check: "instructions",
-			status: "ok",
-			detail: `${path}: you chose the ${inspection.kind} text for the kanbo section; kanbo leaves it alone.`
-		};
-		case "newer": return {
-			check: "instructions",
-			status: "ok",
-			detail: `${path}: written by a newer kanbo (v${inspection.version}) — update kanbo: npm install -g kanbo-cli@latest`
-		};
 		case "damaged": {
 			const message = damagedBlockMessage(path, inspection.damage);
 			return {
@@ -9558,17 +8573,19 @@ function blockFinding(path, inspection, command) {
 				fix: message
 			};
 		}
-		case "edited": return {
+		case "edited":
+		case "chosen":
+		case "newer": return {
 			check: "instructions",
 			status: "warn",
-			detail: `${path}: you edited the kanbo block, so kanbo leaves it alone.`,
-			fix: `Keep it, or run ${command} in a terminal and answer yes to replace it with the current one.`
+			detail,
+			fix: "Delete it yourself."
 		};
 		default: return {
 			check: "instructions",
 			status: "warn",
-			detail: `${path}: block was written by an older kanbo.`,
-			fix: `Run kanbo doctor --fix, or ${command} --yes to rewrite it.`
+			detail,
+			fix: `Run kanbo doctor --fix (or kanbo connect ${agent} --yes) to remove it.`
 		};
 	}
 }
@@ -9594,8 +8611,8 @@ async function checkRegistrations(registrations, platform, projectDir) {
 	if (registrations.length === 0) return [{
 		check: "mcp",
 		status: "warn",
-		detail: "No MCP client has the kanbo server registered.",
-		fix: "Run kanbo connect in the project (kanbo connect claude --yes, say), or kanbo connect claude --global."
+		detail: "No coding agent reaches kanbo: its MCP server is registered nowhere.",
+		fix: "kanbo connect claude --yes (or codex, cursor, gemini)"
 	}];
 	const findings = [];
 	for (const registration of registrations) {
@@ -9668,7 +8685,7 @@ function connectRepair(plan) {
 			switch (outcome.state) {
 				case "manual": return describeManualOutcome(AGENTS[outcome.agents[0]].label, outcome);
 				case "ran": return `ran ${outcome.command}`;
-				default: return `${outcome.state} ${displayPath(plan, outcome.path)}`;
+				default: return outcome.kind === "instructions" && outcome.state === "written" ? `removed the old kanbo section from ${displayPath(plan, outcome.path)}` : `${outcome.state} ${displayPath(plan, outcome.path)}`;
 			}
 		})
 	};
@@ -9682,7 +8699,7 @@ function isAbsoluteOn(platform, path) {
 * alone would register kanbo for the person and leave the project's entry
 * there, so the fix is two commands, each on its own line.
 */
-const CODEX_PROJECT_CMD_FIX = "Codex on Windows can't start a .cmd. Remove the project entry, then register kanbo for your user:\n  kanbo connect codex --project --remove --no-instructions\n  kanbo connect codex";
+const CODEX_PROJECT_CMD_FIX = "Codex on Windows can't start a .cmd. Remove the project entry, then register kanbo for your user:\n  kanbo connect codex --project --remove\n  kanbo connect codex";
 /**
 * A registration that names its program by full path — on Windows, a Node and
 * the kanbo script it runs. Both have to still be there: a Node upgrade or a
@@ -9850,7 +8867,7 @@ async function confirmPlan(input) {
 //#region src/cli/commands/connect.ts
 const AGENT_LIST = `${AGENT_IDS.join(", ")} (or all)`;
 function registerConnectCommand(program) {
-	program.command("connect").alias("setup").argument("[agents...]", `the agents to connect: ${AGENT_LIST}`).description("Connect your coding agents to the board: instructions and MCP server").option("--project", "write into this project's files only").option("--global", "write into your own files, for every project").option("--no-instructions", "leave the agents' instruction files alone").option("--no-mcp", "leave the agents' MCP settings alone").option("--check", "show what is connected; exits 1 when a named agent is not").option("--remove", "disconnect: take kanbo out of their instructions and MCP settings").option("--dry-run", "show what would change, and change nothing").option("--yes", "make the changes without asking").option("--json [fields]", "print the result as JSON; name comma-separated fields to print only those").action(async (names, options) => {
+	program.command("connect").alias("setup").argument("[agents...]", `the agents to connect: ${AGENT_LIST}`).description("Connect your coding agents to the board: its MCP server, for every project (--project: this project only)").option("--project", "write into this project's files only").option("--global", "write into your own files, for every project (the default)").option("--check", "show what is connected; exits 1 when a named agent is not").option("--remove", "disconnect: take kanbo out of their MCP settings and instruction files").option("--dry-run", "show what would change, and change nothing").option("--yes", "make the changes without asking").option("--json [fields]", "print the result as JSON; name comma-separated fields to print only those").action(async (names, options) => {
 		await connect(names, options);
 	});
 }
@@ -9875,7 +8892,7 @@ async function connect(names, options) {
 		await disconnect(agents, scope, projectDir, options);
 		return;
 	}
-	const plan = await planConnect(agents.map((agent) => request(agent, scope, options)), {
+	const plan = await planConnect(agents.map((agent) => request(agent, scope)), {
 		projectDir,
 		yes: options.yes || options.dryRun
 	});
@@ -9898,19 +8915,23 @@ async function connect(names, options) {
 	}
 	printResult(describeOutcomes("connect", agents, applyConnectPlan(plan), plan, false, previewed), outputOptions(options));
 }
-/** What one agent gets: its instructions where the scope says, and its MCP server where the scope — or the agent — says. */
-function request(agent, scope, options) {
+/**
+* What one agent gets: its MCP server where the scope says (the person's own
+* configuration by default), and the old kanbo section taken out of its
+* instruction file in the same scope — in both files when none is named.
+*/
+function request(agent, scope) {
 	return {
 		agent,
-		instructions: options.instructions === false ? null : scope ?? "project",
-		mcp: options.mcp === false ? null : scope ?? defaultMcpScope(agent)
+		instructions: scope ?? "both",
+		mcp: scope ?? defaultMcpScope()
 	};
 }
 async function disconnect(agents, scope, projectDir, options) {
 	const plan = await planDisconnect((scope ? [scope] : ["project", "user"]).flatMap((each) => agents.map((agent) => ({
 		agent,
-		instructions: options.instructions === false ? null : each,
-		mcp: options.mcp === false ? null : each
+		instructions: each,
+		mcp: each
 	}))), {
 		projectDir,
 		yes: options.yes,
@@ -9946,14 +8967,12 @@ async function askAgents$1(projectDir) {
 	});
 }
 /**
-* Show the section the agents get, let the person untick any file, then show
-* what is left and ask once. Unticked files are dropped from the plan.
+* Let the person untick any change, then show what is left and ask once.
+* Unticked changes are dropped from the plan.
 */
 async function chooseAndConfirm(plan) {
 	const ui = getUi();
 	const pending = pendingItems(plan);
-	const section = pending.find((item) => item.kind === "instructions");
-	if (section) console.log(`The kanbo section your agents get:\n\n${section.scope === "project" ? INSTRUCTION_BLOCK : GLOBAL_INSTRUCTION_BLOCK}\n`);
 	const keys = pending.map((_, index) => `${index}`);
 	const kept = new Set(await ui.multiselect({
 		message: "Which of these should kanbo change?",
@@ -9984,10 +9003,7 @@ function describeOutcomes(action, agents, outcomes, plan, dryRun, notesShown = f
 		const who = outcome.agents.map((agent) => AGENTS[agent].label).join(", ");
 		const where = displayPath(plan, outcome.path);
 		if (outcome.state === "manual") lines.push(describeManualOutcome(who, outcome));
-		else {
-			const state = outcome.state === "written" && action === "remove" ? "removed" : outcome.state;
-			lines.push(`${who}: ${where} (${state === "ran" ? `ran ${outcome.command}` : state})`);
-		}
+		else lines.push(`${who}: ${where} (${describeOutcomeState(outcome, action === "remove")})`);
 	}
 	if (!dryRun && !notesShown) lines.push(...plan.notes.map((note) => `Note: ${note}`));
 	if (action === "connect" && !dryRun) lines.push("Check it with kanbo connect --check.");
@@ -10014,73 +9030,61 @@ function describeOutcomes(action, agents, outcomes, plan, dryRun, notesShown = f
 	};
 }
 function runCheck(agents, named, flag, projectDir, options) {
-	const checked = agents.map((agent) => checkAgent(agent, flag, projectDir, options));
+	const checked = agents.map((agent) => checkAgent(agent, flag, projectDir));
 	const rows = checked.map(({ row }) => row);
 	const text = [[
 		"agent",
-		"instructions",
 		"MCP",
 		"scope"
 	], ...rows.map((row) => [
 		row.agent,
-		row.instructions,
 		row.mcp,
 		row.scope
 	])];
 	const widths = text[0].map((_, column) => Math.max(...text.map((line) => line[column].length)));
 	const notes = checked.flatMap(({ notes }) => notes);
+	const oldSections = [...new Set(rows.flatMap((row) => row.oldSections))];
 	printResult({
 		value: rows,
-		text: [...text.map((line) => line.map((cell, column) => cell.padEnd(widths[column])).join("  ").trimEnd()), ...notes.map((note) => `Note: ${note}`)].join("\n")
+		text: [
+			...text.map((line) => line.map((cell, column) => cell.padEnd(widths[column])).join("  ").trimEnd()),
+			...oldSections.map((path) => `old kanbo section in ${path} — kanbo connect removes it`),
+			...notes.map((note) => `Note: ${note}`)
+		].join("\n")
 	}, outputOptions(options));
 	const missing = rows.filter((row) => !row.connected);
 	if (named && missing.length > 0) throw new CliError(1, `Not connected: ${missing.map((row) => row.agent).join(", ")}. Run kanbo connect ${missing.map((row) => row.agent).join(" ")}.`);
 }
 /**
-* Where an agent stands: its kanbo section and its MCP entry, looked for in the
-* scope named — or, when none was, in the project first and then the person's
-* own files. Connected means both are there (or were not asked about) and the
-* MCP entry still starts. An MCP entry of the person's own is theirs: it is
-* reported, left as it is, and counts as connected when it can start.
+* Where an agent stands: its MCP entry, looked for in the scope named — or,
+* when none was, in the project first and then the person's own files.
+* Connected means the entry is there and still starts. An MCP entry of the
+* person's own is theirs: it is reported, left as it is, and counts as
+* connected when it can start. Files that still carry a kanbo section from an
+* older version are listed, for `kanbo connect` to take out.
 */
-function checkAgent(agent, flag, projectDir, options) {
+function checkAgent(agent, flag, projectDir) {
 	const scopes = flag ? [flag] : ["project", "user"];
-	const found = [];
 	const notes = [];
-	let instructions = "skipped";
-	if (options.instructions !== false) {
-		const states = scopes.map((scope) => ({
-			scope,
-			state: readInstructionState(agent, scope, projectDir)
-		}));
-		const present = states.find(({ state }) => state !== null && state !== "missing");
-		instructions = present?.state ?? (states.every(({ state }) => state === null) ? "no file" : "missing");
-		if (present) found.push(present.scope);
-	}
-	let mcp = "skipped";
-	if (options.mcp !== false) {
-		const states = scopes.map((scope) => ({
-			scope,
-			state: readMcpState(agent, scope, projectDir)
-		}));
-		const present = states.find(({ state }) => state === "ok") ?? states.find(({ state }) => state === "own") ?? states.find(({ state }) => state === "stale");
-		mcp = present ? MCP_CELLS[present.state] : "missing";
-		if (present?.state === "own") {
-			const target = AGENTS[agent].mcpTarget(present.scope, projectDir);
-			const startable = canStartMcpEntry(readMcpEntry(target));
-			mcp = startable ? "yours" : "yours, won't start";
-			notes.push(`${ownMcpEntryNote(AGENTS[agent].label, target.path)}${startable ? "" : " It can't start here: its command is not found."}`);
-		}
-		if (present) found.push(present.scope);
+	const states = scopes.map((scope) => ({
+		scope,
+		state: readMcpState(agent, scope, projectDir)
+	}));
+	const present = states.find(({ state }) => state === "ok") ?? states.find(({ state }) => state === "own") ?? states.find(({ state }) => state === "stale");
+	let mcp = present ? MCP_CELLS[present.state] : "missing";
+	if (present?.state === "own") {
+		const target = AGENTS[agent].mcpTarget(present.scope, projectDir);
+		const startable = canStartMcpEntry(readMcpEntry(target));
+		mcp = startable ? "yours" : "yours, won't start";
+		notes.push(`${ownMcpEntryNote(AGENTS[agent].label, target.path)}${startable ? "" : " It can't start here: its command is not found."}`);
 	}
-	const where = [...new Set(found)];
 	return {
 		row: {
 			agent,
-			instructions,
 			mcp,
-			scope: where.length > 0 ? where.join("+") : flag ?? defaultMcpScope(agent),
-			connected: instructions !== "missing" && instructions !== "damaged" && (mcp === "skipped" || mcp === "ok" || mcp === "yours")
+			scope: present ? present.scope : flag ?? defaultMcpScope(),
+			connected: mcp === "ok" || mcp === "yours",
+			oldSections: scopes.flatMap((scope) => readOldSectionPaths(agent, scope, projectDir))
 		},
 		notes
 	};
@@ -10344,31 +9348,10 @@ function assertOwnBoardFile(absolutePath) {
 function notABoardFileMessage(absolutePath) {
 	return `${absolutePath} already holds a database of its own. Name another path with --file, or move that file out of the way.`;
 }
-/** The plan as a person reads it before saying yes. */
-function describeInitPlan(plan) {
-	const lines = ["kanbo init will:"];
-	const columns = plan.columns ? `, with the columns ${plan.columns.map((column) => column.name).join(", ")}` : "";
-	if (plan.boardFile) {
-		const what = plan.boardFile.exists ? "the board file of this project, brought up to date" : `a board file of this project's own${columns}`;
-		lines.push(`  ${plan.boardFile.exists ? "update" : "create"}  ${relativeTo(plan, plan.boardFile.path)} (${what})`);
-	}
-	if (plan.target.kind === "postgres" && plan.migrate) lines.push(`  create  the board's tables in ${maskDatabaseUrl(plan.target.url)}${columns}`);
-	lines.push(`  write   ${BINDING_FILE_PATH} (this project uses board ${plan.workspace.name})`);
-	for (const { kind, change } of plan.fileChanges) if (change.next !== null) lines.push(`  write   ${relativeTo(plan, change.path)} (${kind === "instructions" ? "the kanbo section for agents" : "the kanbo MCP server"})`);
-	for (const item of plan.connect ? pendingItems(plan.connect) : []) lines.push(item.kind === "claude-cli" ? `  run     ${explainItem(item)}` : `  write   ${displayPath(plan, itemPath(item))} (${explainItem(item)})`);
-	if (plan.firstCard) lines.push(`  add     a first card to To Do: ${plan.firstCard}`);
-	for (const note of plan.connect?.notes ?? []) lines.push(`Note: ${note}`);
-	lines.push("Nothing else is changed.");
-	return lines.join("\n");
-}
-function relativeTo(plan, path) {
-	const inside = relative(plan.projectDir, path);
-	return inside.startsWith("..") ? path : inside;
-}
 /**
 * Carry the plan out: the board first — the file, or the shared database's
 * tables — so a migration that fails leaves no binding pointing at nothing;
-* then the binding; then the agent files; then the first card.
+* then the binding; then the agents' settings; then the first card.
 */
 async function applyInitPlan(plan) {
 	let columns = [];
@@ -10382,15 +9365,10 @@ async function applyInitPlan(plan) {
 	if (plan.target.kind === "postgres" && plan.migrate) columns = await migrateSharedBoard(plan.target.url, plan.workspace.id, plan.columns);
 	const bindingPath = writeBinding(plan.projectDir, plan.binding);
 	rememberProjectQuietly(plan.projectDir);
-	const files = plan.fileChanges.map(({ kind, change }) => ({
-		kind,
-		...applyFileChange(change)
-	}));
 	const connect = plan.connect ? applyConnectPlan(plan.connect) : [];
 	const firstCard = plan.firstCard ? await addFirstCard(plan, plan.firstCard) : null;
 	return {
 		bindingPath,
-		files,
 		connect,
 		columns,
 		firstCard
@@ -10451,7 +9429,7 @@ async function withBoardOps(target, body) {
 * `kanbo init --file` a no-op.
 *
 * The chosen columns go into a new board before it is moved into place, for
-* `seed`'s workspace: `kanbo prime` right after `init` then has columns to show.
+* `seed`'s workspace: `kanbo_prime` right after `init` then has columns to show.
 * Returns the names of the columns put there.
 */
 async function createOwnBoardFile(absolutePath, seed) {
@@ -10524,7 +9502,7 @@ async function runInitWizard(context) {
 	const bound = findBinding(context.cwd);
 	say(ui, "kanbo — set up a board for this project");
 	let projectDir;
-	const missing = findMissingBoardFile(context.cwd);
+	const missing = bound ? findMissingBoardFile(context.cwd) : null;
 	if (missing) {
 		projectDir = bound?.projectDir ?? await askProjectDir(ui, context.cwd);
 		await replaceMissingBoard(ui, missing, projectDir, bound, options);
@@ -10536,38 +9514,26 @@ async function runInitWizard(context) {
 		if (namesPostgres(options)) await askBoard(context, projectDir, options, "postgres");
 		else if (!namesBoard(options)) await askBoard(context, projectDir, options);
 	}
-	let pasted = false;
-	if (options.connect === void 0 && options.instructions === void 0 && options.mcp === void 0) {
-		const agents = await askAgents(ui, context.detect(projectDir));
-		const choice = agents.length > 0 ? await askConnect(ui) : "not-now";
-		options.connect = choice === "yes" ? agents : [];
-		if (choice === "paste") {
-			pasted = true;
-			say(ui, `Paste this into your agent's instructions (or run kanbo instructions --copy):\n\n${INSTRUCTION_BLOCK}\n`);
+	const alreadyConnected = [];
+	if (options.connect === void 0) {
+		const detections = context.detect(projectDir);
+		const reaches = (agent) => ["project", "user"].some((scope) => readMcpState(agent, scope, projectDir) !== "missing");
+		const detected = detections.filter((detection) => detection.detected);
+		alreadyConnected.push(...detected.map((detection) => detection.agent).filter(reaches));
+		if (detected.length > 0 && alreadyConnected.length === detected.length) {
+			say(ui, "Your agents already reach kanbo through its MCP server.");
+			options.connect = [];
+		} else {
+			const agents = await askAgents(ui, detections, reaches);
+			options.connect = (agents.length > 0 ? await askConnect(ui) : "not-now") === "yes" ? agents : [];
 		}
 	}
 	const plan = await context.plan(projectDir, options);
-	if (plan.connect && pendingItems(plan.connect).length > 0) await chooseAgentFiles(ui, plan);
-	if (options.firstCard === void 0 && canAddCard(plan)) {
-		const title = (await ui.text({
-			message: "Add a first card? (optional — Enter to skip)",
-			placeholder: "e.g. Add a README"
-		})).trim();
-		if (title) {
-			options.firstCard = title;
-			plan.firstCard = title;
-		}
-	}
-	say(ui, describeInitPlan(plan));
-	if (!await ui.confirm({
-		message: "Write these changes?",
-		initialValue: true
-	})) throw new CliError(1, "Nothing was written.");
 	return {
 		projectDir,
 		options,
 		plan,
-		pasted,
+		alreadyConnected,
 		launchWarning: context.launchWarning
 	};
 }
@@ -10579,9 +9545,14 @@ function say(ui, text) {
 function namesPostgres(options) {
 	return Boolean(options.databaseUrl?.trim() || !options.db?.trim() && options.file === void 0 && process.env.KANBO_DATABASE_URL?.trim());
 }
-/** Does anything besides the wizard already say which board this is? */
+/**
+* Does anything besides the wizard already say which board this is? `--db` or
+* a connection string does. `KANBO_DB_PATH` does not: it names an app's own
+* database for the commands the app starts, and where a new board goes is
+* still the person's question (see `namesNoBoard` in `commands/init.ts`).
+*/
 function namesBoard(options) {
-	return Boolean(options.db?.trim() || options.databaseUrl?.trim() || process.env.KANBO_DB_PATH?.trim() || process.env.KANBO_DATABASE_URL?.trim());
+	return Boolean(options.db?.trim() || options.databaseUrl?.trim() || process.env.KANBO_DATABASE_URL?.trim());
 }
 function describeExistingBoard(bound, cwd) {
 	const { binding } = bound;
@@ -10595,7 +9566,7 @@ function describeExistingBoard(bound, cwd) {
 	return `${bound.projectDir === resolve(cwd) ? "This project" : `The project at ${bound.projectDir}`} already has a board: ${where}${cards}. It stays as it is; this sets up your agents.`;
 }
 /**
-* The board file this project is bound to (or `KANBO_DB_PATH` names) is gone.
+* The board file this project is bound to is gone.
 * The one way on from here is a new, empty board — where the old one was when
 * the project is bound to it — or nothing at all. `--file` already said "a new
 * one"; the columns are asked, and the card key stays the one it was bound to.
@@ -10779,58 +9750,30 @@ async function askCustomColumns(ui) {
 	}
 	return insertOwnColumns(COLUMN_CATALOGUE.filter((column) => picked.has(column.name)), own);
 }
-/** (5) The agents this person uses; the ones found here are ticked already. */
-async function askAgents(ui, detections) {
+/** (5) The agents this person uses; the ones found here that kanbo does not reach yet are ticked already. */
+async function askAgents(ui, detections, reaches) {
 	return await ui.multiselect({
 		message: "Which coding agents do you use here?",
 		options: detections.map(({ agent, detected, evidence }) => ({
 			value: agent,
 			label: detected && evidence[0] ? `${AGENTS[agent].label} (found ${tildify(evidence[0])})` : AGENTS[agent].label
 		})),
-		initialValues: detections.filter((detection) => detection.detected).map((detection) => detection.agent)
+		initialValues: detections.filter((detection) => detection.detected && !reaches(detection.agent)).map((detection) => detection.agent)
 	});
 }
 /** (6) Whether to connect them now. */
 async function askConnect(ui) {
 	return await ui.select({
 		message: "Connect them now?",
-		options: [
-			{
-				value: "yes",
-				label: "Yes — show exactly which files change, then ask"
-			},
-			{
-				value: "not-now",
-				label: "Not now — set up the board only; no other file is touched (later: kanbo connect)"
-			},
-			{
-				value: "paste",
-				label: "I'll paste the instructions myself (prints them; nothing is written)"
-			}
-		]
+		options: [{
+			value: "yes",
+			label: "Yes — register kanbo's MCP server for them, for every project"
+		}, {
+			value: "not-now",
+			label: "Not now — set up the board only (later: kanbo connect)"
+		}]
 	});
 }
-/** (7) The files connecting changes, each explained; an unticked one is left out of the plan. */
-async function chooseAgentFiles(ui, plan) {
-	const connect = plan.connect;
-	const pending = pendingItems(connect);
-	const keys = pending.map((_, index) => `${index}`);
-	const kept = new Set(await ui.multiselect({
-		message: "These files change so your agents know the board. Keep all of them?",
-		options: pending.map((item, index) => ({
-			value: keys[index],
-			label: item.kind === "claude-cli" ? "Claude Code user settings" : displayPath(connect, itemPath(item)),
-			hint: explainItem(item)
-		})),
-		initialValues: keys
-	}));
-	connect.items = connect.items.filter((item) => !pending.includes(item) || kept.has(`${pending.indexOf(item)}`));
-	if (pendingItems(connect).some((item) => item.kind === "instructions")) say(ui, `The kanbo section your agents get:\n\n${INSTRUCTION_BLOCK}\n`);
-}
-/** A shared board whose tables were not created here may have none yet, so there is nowhere to put a card. */
-function canAddCard(plan) {
-	return plan.target.kind !== "postgres" || plan.migrate;
-}
 /** (9) What was done, and what to do next. */
 function printInitOutro(ui, result, applied) {
 	const { plan } = result;
@@ -10854,134 +9797,29 @@ function printInitOutro(ui, result, applied) {
 			continue;
 		}
 		connected.push(...outcome.agents);
-		lines.push(`✔ ${who}: ${where} (${outcome.state === "ran" ? `ran ${outcome.command}` : outcome.state})`);
+		lines.push(`✔ ${who}: ${where} (${describeOutcomeState(outcome)})`);
 	}
-	for (const file of applied.files) lines.push(`✔ ${displayPath(plan, file.path).replaceAll("\\", "/")} (${file.state})`);
 	for (const note of plan.connect?.notes ?? []) lines.push(`Note: ${note}`);
 	if (applied.firstCard) lines.push(`✔ First card: ${applied.firstCard.id} ${applied.firstCard.title}`);
-	const anyAgent = connected.length > 0 || applied.files.length > 0;
-	if (anyAgent && result.launchWarning) lines.push(`! ${result.launchWarning}`);
+	if (connected.length > 0 && result.launchWarning) lines.push(`! ${result.launchWarning}`);
 	lines.push("");
-	const first = result.options.connect?.find((agent) => connected.includes(agent));
+	const first = [...connected, ...result.alreadyConnected][0];
 	if (first) lines.push(`Next: start ${AGENTS[first].label} in this folder and say "take the next card from kanbo".`);
-	else if (result.pasted) lines.push("Next: paste the instructions into your agent, then say \"take the next card from kanbo\".");
-	else if (!anyAgent) lines.push("Next: connect your agent with kanbo connect <agent>, or paste kanbo instructions --copy into it.");
+	else lines.push("Next: connect your agent once: kanbo connect claude (or codex, cursor, gemini).");
 	lines.push("See the board: kanbo board · in your browser: kanbo serve");
 	lines.push("Run kanbo any time to come back here.");
 	say(ui, lines.join("\n"));
 }
 //#endregion
-//#region src/cli/commands/init-global.ts
-/**
-* `kanbo init --global` — this person's own agent tools, told about kanbo once
-* for every project.
-*
-* It binds no board and creates none: the block it writes says "a project with
-* `.kanbo/` is on a board", and a project becomes one with a plain `kanbo init`.
-* The MCP registrations start the same `kanbo mcp` every project registration
-* starts, which resolves the board from the folder the client starts it in —
-* on Windows spelled as this Node and this kanbo's script (`mcp-launch.ts`).
-*
-* It plans what `kanbo connect <agents> --global` plans (`setup/connect-plan.ts`),
-* for the agents its flags name. Every change is worked out first and shown; nothing is written until the
-* person says yes (or said `--yes`), and a file that already says it is
-* reported `unchanged`.
-*/
-/** Written when `--instructions` is not given. Gemini is asked for by name. */
-const DEFAULT_INSTRUCTION_CLIENTS = ["claude", "codex"];
-/** The flags that are about binding a project, which `--global` does not do. */
-const PROJECT_ONLY_FLAGS = [
-	["file", "--file"],
-	["db", "--db"],
-	["databaseUrl", "--database-url"],
-	["workspace", "--workspace"],
-	["board", "--board"],
-	["identifier", "--identifier"],
-	["agentUrl", "--agent-url"]
-];
-async function initGlobal(options) {
-	const format = readFormat(options);
-	const given = PROJECT_ONLY_FLAGS.filter(([key]) => options[key] !== void 0).map(([, flag]) => flag);
-	if (given.length > 0) throw new CliError(1, `--global connects no board; ${given.join(", ")} ${given.length === 1 ? "is" : "are"} for a project. Run kanbo init in the project for that.`);
-	const instructionClients = parseGlobalInstructions(options.instructions);
-	const mcpClients = options.mcp ?? [...MCP_CLIENTS];
-	const plan = await planConnect([...instructionClients.map((agent) => ({
-		agent,
-		instructions: "user",
-		mcp: null
-	})), ...mcpClients.map((agent) => ({
-		agent,
-		instructions: null,
-		mcp: "user"
-	}))], {
-		projectDir: process.cwd(),
-		yes: options.yes
-	});
-	for (const note of plan.notes) console.error(note);
-	if (pendingItems(plan).length > 0) {
-		if (!await confirmPlan({
-			preview: describeConnectPlan(plan, "kanbo init --global will:").replace("Nothing else is changed.", "No board is created. Narrow this with --instructions and --mcp, or use kanbo connect <agents> --global."),
-			question: "Make these changes?",
-			yes: options.yes,
-			machineOutput: Boolean(options.json || format),
-			command: "kanbo init --global"
-		})) throw new CliError(1, "Nothing was changed.");
-	}
-	const outcomes = applyConnectPlan(plan);
-	printResult(describeResult(outcomes.filter((outcome) => outcome.kind === "instructions").map(({ agents, path, state }) => ({
-		client: agents[0],
-		path,
-		state
-	})), outcomes.filter((outcome) => outcome.kind !== "instructions").map(({ agents, path, state, command, reason, removed }) => ({
-		client: agents[0],
-		path,
-		state: state === "ran" ? "written" : state,
-		...command ? { command } : {},
-		...reason ? { reason } : {},
-		...removed ? { removed } : {}
-	}))), options);
-}
-function describeResult(instructions, mcp) {
-	const lines = [];
-	for (const outcome of instructions) lines.push(`Instructions: ${outcome.path} (${outcome.state})`);
-	for (const outcome of mcp) if (outcome.state === "manual") lines.push(`MCP: ${describeManualOutcome(outcome.client, outcome)}`);
-	else lines.push(`MCP: ${outcome.path} (${outcome.state})`);
-	lines.push("A project uses the board once it has run kanbo init. Check everything with kanbo doctor.");
-	return {
-		value: {
-			scope: "global",
-			instructions,
-			mcp
-		},
-		text: lines.join("\n"),
-		fields: [
-			"scope",
-			"instructions",
-			"mcp"
-		]
-	};
-}
-function parseGlobalInstructions(value) {
-	if (value === void 0) return DEFAULT_INSTRUCTION_CLIENTS;
-	const names = value.split(",").map((name) => name.trim()).filter((name) => name.length > 0);
-	if (names.length === 1 && names[0] === "none") return [];
-	return names.map((name) => {
-		const client = GLOBAL_INSTRUCTION_CLIENTS.find((candidate) => candidate === name);
-		if (!client) throw new CliError(1, `Unknown instructions target "${name}" for --global. Use one or more of ${GLOBAL_INSTRUCTION_CLIENTS.join(", ")}, or none.`);
-		return client;
-	});
-}
-//#endregion
 //#region src/cli/commands/init.ts
 /**
-* `kanbo init` — tying a project folder to a board, and telling the agents
-* that work in it what the board expects.
+* `kanbo init` — tying a project folder to a board.
 *
-* Three things come out of it, and each is optional except the first: the
-* binding, so no later command has to be told which workspace this is; a block
-* in the project's agent instructions, so an agent reads the board's rules
-* without being handed them; and a registration of the board's MCP server with
-* whichever tools the person actually uses. Nothing is written to a file the
+* Two things come out of it, and only the first is always there: the binding,
+* so no later command has to be told which workspace this is, and — when the
+* person asks for it with `--connect` or in the wizard — the board's MCP
+* server registered with the agents they use, as `kanbo connect` does. kanbo
+* writes no instruction file into the project. Nothing is written to a file the
 * person did not ask for, and nothing is written twice.
 *
 * Every question comes first. The answers become a plan (`setup/init-plan.ts`)
@@ -11005,15 +9843,10 @@ const AGENT_URL_MISSING_WARNING = "kanbo: agents in this project will reach the
 /** What a person is told when the setup stopped at a question. */
 const INIT_CANCELLED_MESSAGE = "Cancelled — nothing was written.";
 /** What a board set up without its agents ends with. */
-const CONNECT_LATER_TIP = "Agents don't know about this board yet: kanbo connect <agent>, or kanbo instructions --copy and paste it.";
+const CONNECT_LATER_TIP = "Agents can't reach this board yet: kanbo connect <agent>.";
 const CONNECT_VALUES = `${AGENT_IDS.join(", ")}, all or none`;
 function registerInitCommand(program) {
-	program.command("init").description("Set up a board for this project and connect your agents (asks step by step)").option("--db <path>", "the app's database file to find this project in").option("--database-url <url>", "use a shared Postgres board for this project").option("--file [path]", `keep the board in a file in this project (default ${DEFAULT_BOARD_FILE_PATH})`).option("--workspace <nameOrId>", "the project's id on a shared board").option("--json [fields]", "print the result as JSON; name comma-separated fields to print only those").option("--format <format>", "print JSON: json (one line) or pretty (indented)").option("--board <id>", "which board, when the project has more than one").option("--identifier <key>", "the same as --key").option("--key <KEY>", "what card numbers start with, e.g. MYA for MYA-001", parseKey).option("--columns <columns>", `the columns a new board starts with: ${COLUMN_TEMPLATE_IDS.join(", ")}, or a comma-separated list that includes To Do`, parseColumns).option("--connect <agents>", `connect these agents, as kanbo connect does: ${CONNECT_VALUES}`, parseConnect).option("--first-card <title>", "put a first card in To Do").option("--migrate", "create the board's tables in the Postgres database now").option("--agent-url <url>", "a separate connection string for agents (with fewer rights)").option("--instructions <agent>", "where to write the agent instructions: claude, agents or none; with --global, a comma-separated list of claude, codex, gemini, or none").option("--mcp <clients>", `add the board's MCP server to ${MCP_CLIENTS.join(", ")}`, parseMcpClients).option("--global", "set up your agents for every project instead of this one; creates no board").option("--yes", "take the defaults instead of asking").action(async (options) => {
-		if (options.global) {
-			await initGlobal(options);
-			return;
-		}
-		if (options.instructions !== void 0) parseInstructions(options.instructions);
+	program.command("init").description("Set up a board for this project (asks step by step)").option("--db <path>", "the app's database file to find this project in").option("--database-url <url>", "use a shared Postgres board for this project").option("--file [path]", `keep the board in a file in this project (default ${DEFAULT_BOARD_FILE_PATH})`).option("--workspace <nameOrId>", "the project's id on a shared board").option("--json [fields]", "print the result as JSON; name comma-separated fields to print only those").option("--format <format>", "print JSON: json (one line) or pretty (indented)").option("--board <id>", "which board, when the project has more than one").option("--identifier <key>", "the same as --key").option("--key <KEY>", "what card numbers start with, e.g. MYA for MYA-001", parseKey).option("--columns <columns>", `the columns a new board starts with: ${COLUMN_TEMPLATE_IDS.join(", ")}, or a comma-separated list that includes To Do`, parseColumns).option("--connect <agents>", `connect these agents, as kanbo connect does: ${CONNECT_VALUES}`, parseConnect).option("--first-card <title>", "put a first card in To Do").option("--migrate", "create the board's tables in the Postgres database now").option("--agent-url <url>", "a separate connection string for agents (with fewer rights)").option("--yes", "take the defaults instead of asking").action(async (options) => {
 		readFormat(options);
 		const request = normalizeInitOptions(options);
 		if (!request.yes && !request.json && !request.format && canPrompt()) {
@@ -11048,25 +9881,21 @@ async function initWithWizard(options) {
 	printInitOutro(ui, answered, await applyInitPlan(answered.plan));
 }
 /**
-* Agent files — instructions, MCP settings, `claude mcp` — change only on a
-* yes: the wizard's, or `--yes`. Without either (an agent's shell, a script,
-* machine output) the board is still set up and the agent files are left as
-* they are, and the person is told how to connect them, as `kanbo connect` would.
+* Agent settings — the MCP registration, `claude mcp` — change only on a yes:
+* the wizard's, or `--yes`. Without either (an agent's shell, a script,
+* machine output) the board is still set up and the agents are left as they
+* are, and the person is told how to connect them, as `kanbo connect` would.
 */
 function withoutUnconfirmedAgentFiles(plan, options) {
-	const pending = plan.fileChanges.some(({ change }) => change.next !== null) || plan.connect !== null && pendingItems(plan.connect).length > 0;
-	if (options.yes || !pending) return plan;
-	const agents = options.connect?.length ? options.connect : [.../* @__PURE__ */ new Set([...options.instructions === "claude" ? ["claude"] : options.instructions === "agents" ? ["codex"] : [], ...options.mcp ?? []])];
-	console.error(`Not changing agent files without a yes: run kanbo connect ${agents.join(" ") || "<agent>"} --yes`);
+	if (options.yes || plan.connect === null || pendingItems(plan.connect).length === 0) return plan;
+	console.error(`Not connecting agents without a yes: run kanbo connect ${options.connect?.join(" ") || "<agent>"} --yes`);
 	return {
 		...plan,
-		fileChanges: [],
 		connect: null
 	};
 }
-/** The flags as `planInit` takes them: `--key` is `--identifier`, and `--connect` does not mix with the older flags. */
+/** The flags as `planInit` takes them: `--key` is `--identifier`. */
 function normalizeInitOptions(options) {
-	if (options.connect && (options.instructions !== void 0 || options.mcp)) throw new CliError(1, "Use --connect, or the older --instructions and --mcp, not both.");
 	if (options.key === void 0) return options;
 	if (options.identifier !== void 0 && options.identifier.trim().toUpperCase() !== options.key) throw new CliError(1, "--key and --identifier are the same thing; pass one of them.");
 	return {
@@ -11095,7 +9924,6 @@ async function planInit(projectDir, options) {
 		boardFile,
 		columns: newBoard ? options.columns ?? COLUMN_TEMPLATES.standard : null,
 		migrate,
-		fileChanges: [...await planInstructions(projectDir, options), ...await planMcpServers(projectDir, options.mcp ?? [])],
 		connect: options.connect?.length ? await planAgents(projectDir, options.connect, options) : null,
 		firstCard: options.firstCard?.trim() || null
 	};
@@ -11116,12 +9944,12 @@ async function describeKept(target, workspace, options, newBoard) {
 	if (key && key !== workspace.identifier) kept.push(`Kept the existing key (${workspace.identifier}); --key names the key of a new board only`);
 	return kept;
 }
-/** Connect these agents the way `kanbo connect <agents>` does: the kanbo section in the project, the MCP server where each agent reads it. */
+/** Connect these agents the way `kanbo connect <agents>` does: the MCP server in each agent's own settings, and an old kanbo section taken out. */
 async function planAgents(projectDir, agents, options) {
 	return await planConnect(agents.map((agent) => ({
 		agent,
-		instructions: "project",
-		mcp: defaultMcpScope(agent)
+		instructions: "both",
+		mcp: defaultMcpScope()
 	})), {
 		projectDir,
 		yes: options.yes
@@ -11143,13 +9971,20 @@ async function resolveBoard(projectDir, options) {
 	};
 }
 /**
-* Nothing says where a board is: no flag, no environment, no binding at or
-* above this folder. Then a plain `kanbo init` does what `kanbo init --file`
-* does — a person on a machine with nothing else installed gets a board, not a
-* refusal that names a flag.
+* Nothing says where this project's board is: no `--db`, no connection string
+* (typed or exported), no binding at or above this folder. Then a plain
+* `kanbo init` does what `kanbo init --file` does — a person on a machine with
+* nothing else installed gets a board, not a refusal that names a flag.
+*
+* `KANBO_DB_PATH` is not on that list on purpose. It is how an app that embeds
+* kanbo names its own database for the commands it starts, and a new board
+* must not land in it, or fail on it, because the shell `init` runs in happens
+* to carry that variable. Only `kanbo init --db <path>` binds a project to an
+* app's database. A Postgres connection string in the environment is the
+* person's own choice, so it still counts.
 */
 function namesNoBoard$1(projectDir, options) {
-	return !options.db?.trim() && !options.databaseUrl?.trim() && !process.env.KANBO_DB_PATH?.trim() && !process.env.KANBO_DATABASE_URL?.trim() && findBinding(projectDir) === null;
+	return !options.db?.trim() && !options.databaseUrl?.trim() && !process.env.KANBO_DATABASE_URL?.trim() && findBinding(projectDir) === null;
 }
 /** The workspace a host database — or the board file this project is already bound to — says this project is. */
 async function readSessionWorkspace(options) {
@@ -11387,84 +10222,33 @@ async function openHostDatabase(options) {
 function warnAboutOwnerAccess(target, options) {
 	if (target.kind === "postgres" && !options.agentUrl?.trim()) console.error(AGENT_URL_MISSING_WARNING);
 }
-/**
-* The block in the file `--instructions` named. Without the flag nothing is
-* written into a project's instructions: that is `--connect`, the wizard, or
-* `kanbo connect` later.
-*/
-async function planInstructions(projectDir, options) {
-	const target = options.instructions === void 0 ? "none" : parseInstructions(options.instructions);
-	if (target === "none") return [];
-	const plan = await planConnect([{
-		agent: target === "claude" ? "claude" : "codex",
-		instructions: "project",
-		mcp: null
-	}], {
-		projectDir,
-		yes: options.yes
-	});
-	for (const note of plan.notes) console.error(note);
-	return plan.items.flatMap((item) => item.kind === "instructions" ? [{
-		kind: "instructions",
-		change: item.change
-	}] : []);
-}
-/**
-* Tell the tools the person uses about the board's MCP server, in the project's
-* own files — what `kanbo connect <clients> --project --no-instructions` does.
-*
-* Only the ones they named, and only when the tool does not already know: a
-* `kanbo` entry that is already there belongs to them — it may point at
-* a different binary or carry arguments of its own — and is rewritten only
-* when it is kanbo's own and no longer starts.
-*
-* A project file is shared across machines, so it gets the portable form on every system.
-*/
-async function planMcpServers(projectDir, clients) {
-	return (await planConnect(clients.map((agent) => ({
-		agent,
-		instructions: null,
-		mcp: "project"
-	})), { projectDir })).items.flatMap((item) => item.kind === "mcp" ? [{
-		kind: "mcp",
-		change: item.change
-	}] : []);
+/** Has any agent a kanbo MCP registration already, in the project's files or its own settings? Then the tip to connect one is not needed. */
+function someAgentReachesKanbo(projectDir) {
+	return AGENT_IDS.some((agent) => ["project", "user"].some((scope) => readMcpState(agent, scope, projectDir) !== "missing"));
 }
 function describeInit(plan, applied, options) {
 	const { workspace, target } = plan;
-	const outcome = ({ path, state }) => ({
-		path,
-		state
-	});
-	const instructions = applied.files.filter((file) => file.kind === "instructions").map(outcome)[0] ?? null;
-	const mcp = applied.files.filter((file) => file.kind === "mcp").map(outcome);
 	const lines = [`This project uses board ${workspace.name} — ${applied.bindingPath}`];
 	if (target.kind === "postgres") lines.push(`Board: ${maskDatabaseUrl(target.url)}`);
 	else if (target.owner === "kanbo") lines.push(`Board file: ${target.path}`);
 	if (applied.columns.length > 0) lines.push(`Columns: ${applied.columns.join(", ")}`);
 	lines.push(...plan.kept);
-	if (instructions) lines.push(`Instructions: ${instructions.path} (${instructions.state})`);
-	for (const entry of mcp) lines.push(`MCP: ${entry.path} (${entry.state})`);
 	for (const entry of applied.connect) {
 		const who = entry.agents.map((agent) => AGENTS[agent].label).join(", ");
-		lines.push(entry.state === "manual" ? describeManualOutcome(who, entry) : `${who}: ${entry.path} (${entry.state === "ran" ? `ran ${entry.command}` : entry.state})`);
+		lines.push(entry.state === "manual" ? describeManualOutcome(who, entry) : `${who}: ${entry.path} (${describeOutcomeState(entry)})`);
 	}
 	if (applied.firstCard) lines.push(`First card: ${applied.firstCard.id} ${applied.firstCard.title}`);
-	const warning = mcp.length > 0 ? mcpLaunchSpec({ scope: "project" }).warning : void 0;
-	if (warning) lines.push(`Note: ${warning}`);
 	for (const note of plan.connect?.notes ?? []) lines.push(`Note: ${note}`);
-	const connected = instructions !== null || mcp.length > 0 || applied.connect.length > 0;
+	const connected = applied.connect.length > 0;
 	const launchWarning = connected ? readLaunchWarning() : null;
 	if (launchWarning) lines.push(`Note: ${launchWarning}`);
-	if (!connected) lines.push(CONNECT_LATER_TIP);
+	if (!connected && !someAgentReachesKanbo(plan.projectDir)) lines.push(CONNECT_LATER_TIP);
 	return {
 		value: {
 			binding: applied.bindingPath,
 			workspaceId: workspace.id,
 			boardId: options.board ?? null,
 			database: describeTarget(target),
-			instructions,
-			mcp,
 			columns: applied.columns,
 			kept: plan.kept,
 			connect: applied.connect,
@@ -11473,17 +10257,6 @@ function describeInit(plan, applied, options) {
 		text: lines.join("\n")
 	};
 }
-function parseInstructions(value) {
-	if (value !== "claude" && value !== "agents" && value !== "none") throw new CliError(1, `Unknown instructions target "${value}". Use claude, agents or none.`);
-	return value;
-}
-function parseMcpClients(value) {
-	return value.split(",").map((name) => name.trim()).filter((name) => name.length > 0).map((name) => {
-		const client = MCP_CLIENTS.find((candidate) => candidate === name);
-		if (!client) throw new CliError(1, `Unknown MCP client "${name}". Use one or more of ${MCP_CLIENTS.join(", ")}.`);
-		return client;
-	});
-}
 /** `--key`: a letter and two letters or digits, upper-cased. */
 function parseKey(value) {
 	if (!isValidCardKey(value)) throw new CliError(1, `"${value}" can't be a card key: use a letter and two letters or digits, like MYA.`);
@@ -11517,6 +10290,132 @@ function parseConnect(value) {
 	return [...new Set(agents)];
 }
 //#endregion
+//#region src/capabilities/markdown.ts
+/**
+* The same manifest `buildCapabilitiesManifest` returns, as Markdown a person
+* can read and an agent can paste into its own `CLAUDE.md` or `AGENTS.md`.
+*
+* Nothing here decides what the board can do — it only lays the manifest's own
+* fields out under headings. `kanbo mcp` serves it as
+* `kanbo://capabilities.md` beside the JSON.
+*/
+/**
+* A table cell, safe from a pipe inside the text breaking the row it sits in —
+* the same escape the package README's own tables use for a command that
+* spells `\|` between two states.
+*/
+function cell(text) {
+	return text.replace(/\|/g, "\\|").replace(/\n/g, " ").trim();
+}
+function renderStorages(manifest) {
+	return [
+		"## Storages",
+		"",
+		"| Kind | Label | Description | Schema epoch |",
+		"| --- | --- | --- | --- |",
+		...manifest.storages.map((storage) => `| \`${storage.kind}\` | ${cell(storage.label)} | ${cell(storage.description)} | ${storage.schemaEpoch} |`)
+	];
+}
+function renderTool(tool) {
+	return `| \`${tool.name}\` | ${cell(tool.description)} |`;
+}
+function renderTools(manifest) {
+	return [
+		"## Tools",
+		"",
+		"Full JSON Schema for each tool's input is in the JSON manifest (`kanbo://capabilities`) — this table is the tools themselves.",
+		"",
+		"| Tool | Does |",
+		"| --- | --- |",
+		...manifest.tools.map(renderTool)
+	];
+}
+function renderCommand(command) {
+	const options = command.options.map((option) => `\`${option.flags}\`${option.mandatory ? " (required)" : ""}`).join(", ");
+	const humanOnly = command.humanOnly ? " **Person only.**" : "";
+	return `| \`kanbo ${command.path}\` | ${cell(command.description)}${humanOnly} | ${options ? cell(options) : "—"} |`;
+}
+function renderCommands(manifest) {
+	return [
+		"## Commands",
+		"",
+		"| Command | Does | Options |",
+		"| --- | --- | --- |",
+		...manifest.commands.map(renderCommand)
+	];
+}
+function renderRules(manifest) {
+	return [
+		"## Rules",
+		"",
+		...manifest.rules.map((rule) => `- ${rule}`)
+	];
+}
+function renderEntryRules(manifest) {
+	return [
+		"## Column entry rules",
+		"",
+		"What a column may ask of a card before an agent moves it in. Which columns ask for which is per board: `kanbo columns list` or `kanbo_columns`.",
+		"",
+		...manifest.entryRules.map((entry) => `- \`${entry.rule}\` — ${entry.description}`)
+	];
+}
+function renderCanonicalStrings(manifest) {
+	return [
+		"## Canonical strings",
+		"",
+		"What the board writes for you, on a status line or in a system comment. A value ending in a space or `: ` is a prefix — the rest of the line is whatever the write was about.",
+		"",
+		"| Name | Value |",
+		"| --- | --- |",
+		...Object.entries(manifest.canonicalStrings).map(([name, value]) => `| ${cell(name)} | \`${cell(value)}\` |`)
+	];
+}
+function renderRoles(manifest) {
+	return [
+		"## Roles",
+		"",
+		`- Person: \`${manifest.roles.person}\``,
+		`- Agent: \`${manifest.roles.agent}\``,
+		"",
+		"What the database itself refuses the agent role, on an external board, whichever client sends the write:",
+		"",
+		...manifest.roles.refusals.map((refusal) => `- ${refusal}`)
+	];
+}
+function renderLimits(manifest) {
+	return [
+		"## Limits",
+		"",
+		...manifest.limits.map((limit) => `- ${limit}`)
+	];
+}
+/** The manifest, laid out under one heading per field — stable and diffable, never a snapshot to update by hand. */
+function renderCapabilitiesMarkdown(manifest) {
+	return [
+		"# Kanbo capabilities",
+		"",
+		`\`${manifest.package.name}\` ${manifest.package.version} — capabilities manifest version ${manifest.version}.`,
+		"",
+		...renderStorages(manifest),
+		"",
+		...renderTools(manifest),
+		"",
+		...renderCommands(manifest),
+		"",
+		...renderRules(manifest),
+		"",
+		...renderEntryRules(manifest),
+		"",
+		...renderCanonicalStrings(manifest),
+		"",
+		...renderRoles(manifest),
+		"",
+		...renderLimits(manifest),
+		""
+	].join("\n");
+}
+//#endregion
 //#region src/mcp/resources.ts
 /** The URI a client reads the manifest as JSON from. */
 const KANBO_CAPABILITIES_RESOURCE_URI = "kanbo://capabilities";
@@ -11565,7 +10464,7 @@ function tool(name) {
 * What `kanbo mcp` tells a client when it connects — the `instructions` of the
 * MCP initialize result, which a client hands its model before any tool is
 * called. An agent with nothing but this server connected learns from it how
-* to work the board, with no instruction file in the project.
+* to work the board; kanbo writes no instruction file.
 *
 * Static on purpose: it is sent before any board is resolved, so it says
 * nothing about columns — `kanbo_prime` returns those. The rules are the
@@ -11576,7 +10475,7 @@ const KANBO_MCP_INSTRUCTIONS = [
 	"kanbo is a kanban board shared by people and agents; these tools read and change its cards.",
 	"",
 	`- At the start of a session call ${tool("kanbo_prime")} — it returns this board's columns and what each one means.`,
-	`- Take work from ${tool("kanbo_ready")}, and claim the card with ${tool("kanbo_card_claim")} before you start: it starts your run and moves the card into work in one step, so no other agent takes it.`,
+	`- Take work from ${tool("kanbo_ready")}, and claim the card with ${tool("kanbo_card_claim")} before you start: it starts your run and moves the card into work in one step, so no other agent takes it. When you stop, finish the run with ${tool("kanbo_run_finish")}.`,
 	`- ${MOVE_CARD_RULE} (${tool("kanbo_card_move")})`,
 	`- ${STATUS_LINE_RULE} (${tool("kanbo_status_line")})`,
 	`- ${COMMENT_RULE} (${tool("kanbo_card_comment")})`,
@@ -11584,194 +10483,9 @@ const KANBO_MCP_INSTRUCTIONS = [
 	`- A card at the wrong level is moved with ${tool("kanbo_card_update")} and \`parent\` (\`"none"\` for the top level).`,
 	`- ${WAIT_FOR_PERSON_RULE} (${tool("kanbo_wait_approval")})`,
 	`- ${PERSON_ONLY_RULE}`,
+	"- If a tool answers that this folder has no kanbo board, leave the board alone for this session: only a person sets one up.",
 	`- Every tool, rule and canonical string: the resource \`${KANBO_CAPABILITIES_MARKDOWN_RESOURCE_URI}\`.`
 ].join("\n");
-/** Copy the text, trying each program this machine should have in turn. */
-async function copyToClipboard(text, environment = {}) {
-	const env = environment.env ?? process.env;
-	const run = environment.run ?? runWithInput;
-	const stderr = environment.stderr ?? process.stderr;
-	for (const program of chooseClipboardPrograms(text, environment)) if (await run(program.command, program.args, program.input, {
-		timeoutMs: 3e3,
-		detached: program.detached
-	})) return "copied";
-	if ((env.SSH_TTY || env.SSH_CONNECTION) && stderr.isTTY === true) {
-		stderr.write(osc52(text));
-		return "osc52";
-	}
-	return "unavailable";
-}
-/** The programs to try here, in order; empty when there is nothing to try. */
-function chooseClipboardPrograms(text, environment) {
-	const platform = environment.platform ?? process.platform;
-	const env = environment.env ?? process.env;
-	const readFile = environment.readFile ?? readTextOrNull$1;
-	const utf8 = Buffer.from(text, "utf8");
-	if (platform === "darwin") return [{
-		command: "pbcopy",
-		args: [],
-		input: utf8
-	}];
-	if (platform === "win32" || platform === "linux" && /microsoft/i.test(readFile("/proc/version") ?? "")) return [{
-		command: "clip.exe",
-		args: [],
-		input: utf16leWithBom(text)
-	}];
-	const programs = [];
-	if (env.WAYLAND_DISPLAY) programs.push({
-		command: "wl-copy",
-		args: [],
-		input: utf8
-	});
-	if (env.DISPLAY) programs.push({
-		command: "xclip",
-		args: ["-selection", "clipboard"],
-		input: utf8,
-		detached: true
-	}, {
-		command: "xsel",
-		args: ["--clipboard", "--input"],
-		input: utf8
-	});
-	return programs;
-}
-/** The text as `clip.exe` reads it without guessing: UTF-16LE after a byte-order mark. */
-function utf16leWithBom(text) {
-	return Buffer.concat([Buffer.from([255, 254]), Buffer.from(text, "utf16le")]);
-}
-/** The OSC 52 "set the clipboard" escape for this text. */
-function osc52(text) {
-	return `\u001B]52;c;${Buffer.from(text, "utf8").toString("base64")}\u0007`;
-}
-function readTextOrNull$1(path) {
-	try {
-		return readFileSync(path, "utf8");
-	} catch {
-		return null;
-	}
-}
-//#endregion
-//#region src/cli/setup/orchestrator-guide.ts
-/**
-* The instruction file for an orchestrator: an agent that pulls ready cards,
-* splits them when it should, hands subtasks to sub-agents by card key and
-* waits for a person's approval. `kanbo instructions orchestrator` prints it,
-* and `docs/orchestrator.md` shows it word for word — a test holds the two
-* together, so the page never drifts from what the command hands out.
-*/
-const ORCHESTRATOR_GUIDE = [
-	"# Orchestrator",
-	"",
-	"You coordinate work on this project's kanbo board. You do not approve work; a person does.",
-	"",
-	"## Start of every session",
-	"1. Run `kanbo prime` (tool: `kanbo_prime`) and read the column descriptions. On this board the description is the contract, not the name.",
-	"2. Run `kanbo ready` (`kanbo_ready`). If nothing is ready, say so and stop.",
-	"3. Take the first card with `kanbo claim --agent orchestrator` (`kanbo_card_claim`): it starts your run and moves the card out of To Do into the board's first work-in-progress column in one step, so no other agent takes it, and it prints the run id you finish later. If another agent got there first, run `kanbo ready` again.",
-	"",
-	"## While working",
-	"- Write a status line (`kanbo card status-line <card> --text \"…\"`, `kanbo_status_line`) at every step and before and after anything that takes more than a minute. One sentence, present tense.",
-	"- Put decisions, numbers and open questions on the card as comments (`kanbo_card_comment`). Your transcript is not the card.",
-	"",
-	"## Splitting",
-	"Split a card into subtasks only when the person asked for it, or when it has parts that can be done and checked separately — different stages, owners or pull requests. Do not split work you would finish in one go.",
-	"- A subtask is `kanbo card create --parent <card> --column to_do --title \"…\" --description \"…\"` (`kanbo_card_create` with `parent`).",
-	"- Give each subtask a description a sub-agent can act on without asking you: what to change, how to check it, a `- [ ]` checklist when there are several steps.",
-	"",
-	"## Delegating",
-	"- Hand each subtask to a sub-agent by its key only: \"Work APP-014 on the kanbo board.\" The sub-agent reads the card itself.",
-	"- Wait for the sub-agent to finish. Then read the subtask (`kanbo_card_get`): it should be in the board's review column or a finished one (by the descriptions in `kanbo prime`) with a comment saying what changed. If it is not, write why on the parent card and decide: retry, fix it yourself, or ask the person.",
-	"- Link every pull request to the card it belongs to (`kanbo card pr add <card> <url>`, `kanbo_card_link_pr`).",
-	"",
-	"## Handing back",
-	"1. When the card's work is complete, move it to the column this board uses for review (see `kanbo prime`).",
-	"2. Run `kanbo card wait-approval <card> --text \"<what the person should look at>\"` (`kanbo_wait_approval`).",
-	"3. Finish your run: `kanbo run finish <runId> --state finished` (`kanbo_run_finish`).",
-	"4. End your turn. Do not approve, do not move the card out of review, do not start the same card again. The person approves with `kanbo approve` or returns it with a reason.",
-	"",
-	"## When the card comes back",
-	"- Approved: move it to the board's finished column (see `kanbo prime`).",
-	"- Returned: the reason is the newest comment. The card is back in an earlier column; start a new run and address the reason first.",
-	"",
-	"## Never",
-	"- Never run `kanbo approve`, `kanbo return`, `kanbo sprint close`, `kanbo run clear-session`, or anything that changes the columns: `kanbo columns add`, `kanbo columns rename`, `kanbo columns move`, `kanbo columns remove`, `kanbo columns template`, `kanbo columns add-standard`, `kanbo columns rules`, `kanbo columns flow`. They are for a person and will fail in your shell anyway.",
-	"- Never delete or edit the board's database directly."
-].join("\n");
-//#endregion
-//#region src/cli/commands/instructions.ts
-/**
-* `kanbo instructions` — the text to give an agent, without a trip to GitHub.
-*
-* The text goes to stdout and nothing else does, so `kanbo instructions >>
-* AGENTS.md` writes exactly the text. The two lines around it that say what to
-* do with it go to stderr, and only when stderr is a terminal a person reads.
-*/
-/** The versions of the text, as typed after `kanbo instructions`. */
-const INSTRUCTION_KINDS = [
-	"agent",
-	"short",
-	"global",
-	"orchestrator",
-	"mcp",
-	"board"
-];
-/** What `board` says in a folder with no board. */
-const NO_BOARD_FOR_INSTRUCTIONS_MESSAGE = "This folder has no kanbo board, so there are no board rules to print. Run kanbo here to set one up, or ask for a version that needs no board: agent | short | global | orchestrator | mcp.";
-const HEADER = "Paste this into CLAUDE.md or AGENTS.md — or run `kanbo connect <agent>` to have kanbo do it.";
-const FOOTER = "Copy it: kanbo instructions --copy · Other versions: short | global | orchestrator | mcp | board";
-/**
-* The text of each version that needs no board. A function, not a table: the
-* MCP instructions sit on an import cycle back to this command list (through
-* the capabilities manifest), and a table built at load time would hold
-* `undefined` for them.
-*/
-function staticText(kind) {
-	switch (kind) {
-		case "agent": return AGENT_GUIDE_TEXT;
-		case "short": return PROJECT_BODY;
-		case "global": return GLOBAL_BODY;
-		case "orchestrator": return ORCHESTRATOR_GUIDE;
-		case "mcp": return KANBO_MCP_INSTRUCTIONS;
-	}
-}
-function registerInstructionsCommand(program, dependencies = {}) {
-	program.command("instructions").description("Print the instructions to give your agent (to paste yourself)").argument("[kind]", "which version: agent, short, global, orchestrator, mcp or board", "agent").option("--copy", "also put the text on the clipboard").option("--markers", "wrap the text in kanbo's start and end markers, so kanbo connect can update it later").action(async (kind, options) => {
-		const found = parseKind(kind);
-		const body = await readInstructionText(found);
-		const pointer = found === "short" || found === "global";
-		const text = options.markers ? wrapInstructionBlock(body, 3, pointer ? void 0 : found) : body;
-		const hints = process.stderr.isTTY === true;
-		if (hints) process.stderr.write(`${HEADER}\n\n`);
-		console.log(text);
-		if (hints) process.stderr.write(`\n${FOOTER}\n`);
-		if (options.copy) process.stderr.write(`${describeCopy(await copyToClipboard(text, dependencies.clipboard))}\n`);
-	});
-}
-function parseKind(kind) {
-	const found = INSTRUCTION_KINDS.find((candidate) => candidate === kind);
-	if (!found) throw new CliError(1, `Unknown version "${kind}". Use one of: ${INSTRUCTION_KINDS.join(", ")}.`);
-	return found;
-}
-/** The text of one version; `board` reads this folder's board, as `kanbo prime` prints it. */
-async function readInstructionText(kind) {
-	if (kind !== "board") return staticText(kind);
-	const session = await openBoardSession({}, "read").catch((error) => {
-		if (error instanceof BoardNotFoundError) throw new CliError(2, NO_BOARD_FOR_INSTRUCTIONS_MESSAGE);
-		throw error;
-	});
-	try {
-		return `${await session.ops.buildPrimeText(session.workspace.id)}\n\n${COMMAND_SHEET}`;
-	} finally {
-		await session.close();
-	}
-}
-function describeCopy(outcome) {
-	switch (outcome) {
-		case "copied": return "Copied to the clipboard.";
-		case "osc52": return "Sent to your terminal's clipboard (OSC 52).";
-		case "unavailable": return "Couldn't reach a clipboard — select the text above.";
-	}
-}
 //#endregion
 //#region src/mcp/tools/tool.ts
 /** What every tool that takes `card` also takes it as. */
@@ -12032,33 +10746,214 @@ function formatKanboCardPage(page, view, returned) {
 			nextOffset: shownUntil
 		} : {}
 	};
-	const cards = page.cards.map((card) => JSON.stringify(viewCard(card, view)));
-	const opening = `{${returned && returned.cards.length > 0 ? `"returned":[\n${returned.cards.map((card) => JSON.stringify(viewCard(card, view))).join(",\n")}\n],${returned.total > returned.cards.length ? `"returnedTotal":${returned.total},` : ""}` : ""}${JSON.stringify(head).slice(1, -1)}`;
-	return cards.length === 0 ? `${opening},"cards":[]}` : `${opening},"cards":[\n${cards.join(",\n")}\n]}`;
+	const cards = page.cards.map((card) => JSON.stringify(viewCard(card, view)));
+	const opening = `{${returned && returned.cards.length > 0 ? `"returned":[\n${returned.cards.map((card) => JSON.stringify(viewCard(card, view))).join(",\n")}\n],${returned.total > returned.cards.length ? `"returnedTotal":${returned.total},` : ""}` : ""}${JSON.stringify(head).slice(1, -1)}`;
+	return cards.length === 0 ? `${opening},"cards":[]}` : `${opening},"cards":[\n${cards.join(",\n")}\n]}`;
+}
+//#endregion
+//#region src/mcp/tools/card-create.ts
+/** What an agent is told about subtasks, word for word in the tool and in its `parent` field. */
+const SUBTASK_SENTENCE = "To create a subtask (sub-card) under another card, pass `parent` = that card's id (its key, e.g. `MAN-012`).";
+/** A new card, or a sub-card of the one being worked on. */
+const cardCreateTool = defineKanboTool({
+	name: "kanbo_card_create",
+	title: "Create a card",
+	description: `Put a new card on this board. ${SUBTASK_SENTENCE} ${SUBTASK_WHEN_SENTENCE} ${subtaskSplitSentence("pass `parent`")} Answers the card compact, as kanbo_card_list prints it; detail: "full" for every field.`,
+	inputSchema: {
+		title: z.string().optional().describe("What the card is called. Leave it out and the card is titled with its own key; the description then says what the task is."),
+		description: z.string().optional().describe("What the card is about, spelled out for whoever picks it up."),
+		column: z.string().min(1).optional().describe("The column to open it in, by slug or name. The board's first column when absent."),
+		parent: cardArgument.optional().describe(SUBTASK_SENTENCE),
+		executionMode: executionModeArgument.optional(),
+		detail: writtenCardDetailArgument
+	},
+	example: {
+		description: "Add slugify(text) with a test",
+		parent: "TST-1"
+	},
+	run: async (transport, { detail, ...input }) => formatWrittenKanboCard(await transport.cardCreate(input), detail)
+});
+//#endregion
+//#region src/mcp/transport.ts
+/** What `kanbo_card_get` may bring along with the card. */
+const KANBO_CARD_INCLUDES = [
+	"comments",
+	"subCards",
+	"runs",
+	"history",
+	"prs"
+];
+/** What a card read brings along when the caller does not say: its latest comments and its sub-cards. */
+const DEFAULT_KANBO_CARD_INCLUDES = ["comments", "subCards"];
+/** How many of its latest comments a card read brings along when the caller does not say. */
+const DEFAULT_KANBO_COMMENT_LIMIT = 10;
+/**
+* The card a tool prints, from the card a transport holds.
+*
+* Both transports project here so the JSON an agent reads is the same whether
+* it came from the server or from the board file — including the column, which
+* neither of them carries on the card itself: the row keeps a foreign key, and
+* an agent moving a card needs the slug.
+*
+* Every field is named rather than spread. A card the board file answers with
+* carries more than this — the agent and session ids behind a run among them —
+* and passing an object through by reference would print whatever it happened
+* to hold, which is both a different shape from the server's answer and host
+* facts the agent was never meant to see.
+*/
+function projectKanboCard(card, columns) {
+	const column = columns.find((candidate) => candidate.id === card.statusId) ?? null;
+	return {
+		id: card.id,
+		number: card.number,
+		title: card.title,
+		description: card.description,
+		column: column?.name ?? null,
+		columnSlug: column?.slug ?? null,
+		statusLine: card.statusLine,
+		waitingFor: card.waitingFor,
+		priority: card.priority,
+		labels: card.labels,
+		executionMode: card.executionMode,
+		parentIssueId: card.parentIssueId,
+		attemptCount: card.attemptCount,
+		activeRun: projectKanboActiveRun(card.activeRun),
+		updatedAt: card.updatedAt,
+		...card.attention?.returned ? { returned: true } : {},
+		...card.attention?.lastComment ? { lastComment: card.attention.lastComment } : {}
+	};
+}
+/** A sub-card, as the card above it lists it: enough to name it and read it next. */
+function projectKanboSubCard(card, columns) {
+	return {
+		id: card.id,
+		title: card.title,
+		columnSlug: columns.find((candidate) => candidate.id === card.statusId)?.slug ?? null
+	};
+}
+/** The run going on right now, as much of it as the agent working the card needs. */
+function projectKanboActiveRun(run) {
+	return run === null ? null : {
+		id: run.id,
+		agentName: run.agentName,
+		state: run.state,
+		executionMode: run.executionMode,
+		branch: run.branch,
+		startedAt: run.startedAt
+	};
+}
+/**
+* One launch of a card, from the run row either transport holds.
+*
+* What the row carries beyond this — the worktree path, the chat session
+* driving it, who launched it — belongs to the host that launched the run, not
+* to the agent that asked for one.
+*/
+function projectKanboRun(run) {
+	return {
+		id: run.id,
+		issueId: run.issueId,
+		agentName: run.agentName,
+		state: run.state,
+		executionMode: run.executionMode,
+		branch: run.branch,
+		startedAt: run.startedAt,
+		endedAt: run.endedAt,
+		externalSessionRef: run.externalSessionRef ?? null
+	};
+}
+/**
+* A pull-request link, from the row either transport holds — without who made
+* it, which is the board's record rather than anything the agent acts on.
+*/
+function projectKanboPullRequest(link) {
+	return {
+		id: link.id,
+		issueId: link.issueId,
+		owner: link.owner,
+		repo: link.repo,
+		number: link.number,
+		url: link.url,
+		createdAt: link.createdAt
+	};
+}
+/** A sprint, from the one `listSprints` answers with on either end — the description and timestamps left behind. */
+function projectKanboSprint(sprint) {
+	return {
+		id: sprint.id,
+		title: sprint.title,
+		status: sprint.status,
+		startDate: sprint.startDate,
+		dueDate: sprint.dueDate,
+		current: sprint.current,
+		openCards: sprint.cards.open,
+		doneCards: sprint.cards.done
+	};
+}
+/** A column of the board, from the row either transport holds; `board` is every column, to name the ones it accepts cards from. */
+function projectKanboColumn(column, board) {
+	const stored = column.entryRules;
+	const allowedIds = typeof column.allowedFrom === "string" ? readFlowRules({
+		allowedFrom: column.allowedFrom,
+		wipLimit: null
+	}).allowedFrom : column.allowedFrom ?? null;
+	return {
+		id: column.id,
+		name: column.name,
+		slug: normalizeStatusName(column.name),
+		description: column.description,
+		order: column.order,
+		entryRules: typeof stored === "object" && stored !== null ? ENTRY_RULES.filter((rule) => stored.includes(rule)) : readEntryRules({ entryRules: stored ?? null }),
+		allowedFrom: allowedIds === null ? null : board.filter((other) => allowedIds.includes(other.id)).map((other) => normalizeStatusName(other.name)),
+		wipLimit: column.wipLimit ?? null
+	};
+}
+/**
+* Does the card answer the query? The filters of `KanboCardQuery`, applied to
+* a card already read — for a transport whose server filters on less than the
+* query names. `statusIds` are the query's columns, already resolved.
+*/
+function matchesKanboCardQuery(card, query, statusIds) {
+	const text = query.text === void 0 ? void 0 : foldCase(query.text);
+	return (statusIds === null || card.statusId !== null && statusIds.has(card.statusId)) && (query.waitingForPerson === void 0 || card.waitingFor === "human" === query.waitingForPerson) && (query.parent === void 0 || card.parentIssueId === query.parent) && (query.hasActiveRun === void 0 || card.activeRun !== null === query.hasActiveRun) && (query.returned === void 0 || (card.attention?.returned ?? false) === query.returned) && (text === void 0 || [
+		card.id,
+		card.title,
+		card.description ?? ""
+	].some((value) => foldCase(value).includes(text))) && (query.updatedSince === void 0 || card.updatedAt >= query.updatedSince) && (query.labels ?? []).every((label) => card.labels.includes(label)) && (query.priority === void 0 || query.priority.includes(card.priority));
+}
+/** A page cut out of cards already picked, in the order they were picked. */
+function pageOf(cards, input) {
+	const offset = input.offset ?? 0;
+	return {
+		cards: cards.slice(offset, input.limit === void 0 ? void 0 : offset + input.limit),
+		total: cards.length,
+		offset
+	};
+}
+/** A comment as a card read lists it, from the row either transport holds. */
+function projectKanboCardComment(comment) {
+	const decision = comment.authorKind === "system.approved" || comment.authorKind === "system.returned";
+	const author = decision ? "user" : normalizeCommentAuthorKind(comment.authorKind);
+	const named = author !== "system" || decision;
+	const outside = author === "system" && isOutsideWriter(comment) && comment.authorKind === "system";
+	return {
+		id: comment.id,
+		author,
+		by: named || outside ? comment.authorId ?? author : "kanbo",
+		content: comment.content,
+		createdAt: comment.createdAt
+	};
+}
+/** A field change as a card read lists it — who by kind only: the id behind it is the host's. */
+function projectKanboFieldChange(change) {
+	return {
+		field: change.field,
+		from: change.fromValue,
+		to: change.toValue,
+		actor: change.actorKind,
+		createdAt: change.createdAt
+	};
 }
-//#endregion
-//#region src/mcp/tools/card-create.ts
-/** What an agent is told about subtasks, word for word in the tool and in its `parent` field. */
-const SUBTASK_SENTENCE = "To create a subtask (sub-card) under another card, pass `parent` = that card's id (its key, e.g. `MAN-012`).";
-/** A new card, or a sub-card of the one being worked on. */
-const cardCreateTool = defineKanboTool({
-	name: "kanbo_card_create",
-	title: "Create a card",
-	description: `Put a new card on this board. ${SUBTASK_SENTENCE} ${SUBTASK_WHEN_SENTENCE} ${subtaskSplitSentence("pass `parent`")} Answers the card compact, as kanbo_card_list prints it; detail: "full" for every field.`,
-	inputSchema: {
-		title: z.string().optional().describe("What the card is called. Leave it out and the card is titled with its own key; the description then says what the task is."),
-		description: z.string().optional().describe("What the card is about, spelled out for whoever picks it up."),
-		column: z.string().min(1).optional().describe("The column to open it in, by slug or name. The board's first column when absent."),
-		parent: cardArgument.optional().describe(SUBTASK_SENTENCE),
-		executionMode: executionModeArgument.optional(),
-		detail: writtenCardDetailArgument
-	},
-	example: {
-		description: "Add slugify(text) with a test",
-		parent: "TST-1"
-	},
-	run: async (transport, { detail, ...input }) => formatWrittenKanboCard(await transport.cardCreate(input), detail)
-});
 //#endregion
 //#region src/mcp/tools/card-get.ts
 /** One card in full, with what an agent reads next to it. */
@@ -12702,16 +11597,20 @@ async function createDbTransport(input) {
 * The board `kanbo mcp` serves — or, in a folder with none yet, a stand-in
 * that finds it later.
 *
-* A person who registers kanbo in their own agent settings has it started in
-* every folder they open, and most of those have no board. A server that
-* refused to start there would show up in the agent as a broken connection. So
-* it starts anyway: the client connects and reads the instructions, and every
-* tool answers that there is no board here. Each call looks again, so a board
-* a person creates in this folder while the agent is running is picked up on
-* the next call, and held from then on.
-*
-* Any other failure to open the board — a file that is not a board, a database
-* that does not answer — is not "no board" and still stops the server at once.
+* The server is registered once, in the person's own agent settings, so every
+* project they open starts it — and most of those folders cannot give it a
+* board: there is none yet, the database `KANBO_DB_PATH` names is older than
+* this kanbo, or it knows no project for the folder. A server that refused to
+* start there would show up in the agent's client as a broken connection. So
+* it starts anyway: the client connects and reads the instructions, and each
+* tool says why there is no board here. Each call looks again, so a board a
+* person creates in this folder while the agent is running is picked up on the
+* next call, and held from then on.
+*
+* "No board" answers with one fixed message; the two other reasons answer with
+* the error's own message, unchanged. Any other failure to open the board — a
+* file that is not a board, a database that does not answer — still stops the
+* server at once.
 */
 /** What every tool answers in a folder with no board. */
 const NO_BOARD_FOR_AGENT_MESSAGE = DATABASE_NOT_FOUND_AGENT_MESSAGE;
@@ -12755,7 +11654,7 @@ function createDeferredBoard(input) {
 			return opened;
 		}, (error) => {
 			opening = null;
-			throw isNoBoard(error) ? new CliError(2, NO_BOARD_FOR_AGENT_MESSAGE) : error;
+			throw error instanceof BoardNotFoundError ? new CliError(2, NO_BOARD_FOR_AGENT_MESSAGE) : error;
 		});
 		return await opening;
 	};
@@ -12769,9 +11668,13 @@ function createDeferredBoard(input) {
 		}
 	};
 }
-/** The failure that means nothing names a board here — not a board that failed to open. */
+/**
+* The failures that mean this folder has no usable board for now: nothing
+* names one, the host database is older than this kanbo, or no project of it
+* matches the folder. Not a board that failed to open.
+*/
 function isNoBoard(error) {
-	return error instanceof BoardNotFoundError;
+	return error instanceof BoardNotFoundError || error instanceof CliError && (error.exitCode === 3 || error.exitCode === 2);
 }
 /**
 * The same board, with `kanbo_prime` ending in a line about a newer kanbo once
@@ -12906,84 +11809,6 @@ async function migrateOwnFile(target, options) {
 	}, options);
 }
 //#endregion
-//#region src/cli/commands/prime.ts
-/**
-* `kanbo prime` — what the board tells an agent about itself.
-*
-* The first thing an agent should run, and the reason the instruction block
-* `kanbo init` writes says so: the columns of this board with their meaning,
-* and the rules a card travels by. The text belongs to the board, not to this
-* tool, so the command prints what `buildPrimeText` says — and then the
-* commands, because an agent reading this from a shell may have no MCP tools
-* and nothing else to learn them from. The `kanbo_prime` tool leaves them out.
-*/
-function registerPrimeCommand(program) {
-	withBoardOptions(program.command("prime").description("Print the board's columns and rules for an agent to read first")).action(async (options) => {
-		await runBoardCommand(options, "read", async (session) => {
-			const text = `${await session.ops.buildPrimeText(session.workspace.id)}\n\n${COMMAND_SHEET}`;
-			return {
-				value: { text },
-				text
-			};
-		});
-	});
-}
-//#endregion
-//#region src/cli/commands/ready.ts
-/** How many cards `kanbo ready` prints when the caller names no limit. */
-const DEFAULT_READY_LIMIT = 10;
-/** How many returned cards `kanbo ready` prints ahead of the ready ones, at most. */
-const READY_RETURNED_LIMIT = 5;
-/**
-* The ready cards, and ahead of them the cards a person sent back — an agent
-* continues those before it takes anything new. `--json` stays the ready
-* cards alone; `kanbo card list --returned --json` lists the others.
-*/
-async function describeReady(session, cards, returned) {
-	if (returned.cards.length === 0) return describeCards(cards);
-	const runs = await session.ops.readBoardProjectionForIssues(returned.cards.map((card) => card.id));
-	const attention = await session.ops.readCardAttention(returned.cards, runs.map(() => false));
-	const views = withCardAttention(returned.cards.map((card, index) => projectCard(card, returned.columns, runs[index])), attention);
-	const more = returned.total - views.length;
-	return [
-		"Returned to you — continue these first, then hand them back to a person:",
-		describeCards(views),
-		...more > 0 ? [`… and ${more} more: kanbo card list --returned`] : [],
-		"",
-		"Ready:",
-		describeCards(cards)
-	].join("\n");
-}
-/**
-* `kanbo ready` — the cards an agent may pick up right now.
-*
-* What counts as ready is the board's rule, not this tool's: spelled out,
-* nobody working on it, nobody's turn but the agent's. An agent asking for work
-* takes the first line and starts there.
-*/
-function registerReadyCommand(program) {
-	withBoardOptions(program.command("ready").description("Cards ready to start: in To Do, not taken, not waiting for a person").option("--limit <count>", `how many cards to print (${DEFAULT_READY_LIMIT} when left out)`, parseCount).option("--all", "print every ready card")).action(async (options) => {
-		await runBoardCommand(options, "read", async (session) => {
-			const page = await session.ops.queryReady({
-				workspaceId: session.workspace.id,
-				limit: options.all ? void 0 : options.limit ?? DEFAULT_READY_LIMIT
-			});
-			const [runs, returned] = await Promise.all([session.ops.readBoardProjectionForIssues(page.cards.map((card) => card.id)), session.ops.queryCards({
-				workspaceId: session.workspace.id,
-				returned: true,
-				limit: READY_RETURNED_LIMIT
-			})]);
-			const cards = page.cards.map((card, index) => projectCard(card, page.columns, runs[index]));
-			if (page.total > cards.length) console.error(`kanbo: ${page.total - cards.length} more ready; --limit <count> or --all for more`);
-			return {
-				value: cards,
-				text: await describeReady(session, cards, returned),
-				fields: CARD_VIEW_FIELDS
-			};
-		});
-	});
-}
-//#endregion
 //#region src/cli/commands/return.ts
 /**
 * `kanbo return` — a person sending a card back with a reason.
@@ -13090,104 +11915,6 @@ function describeApplied(database) {
 	].join("\n");
 }
 //#endregion
-//#region src/cli/commands/run.ts
-/**
-* `kanbo run …` — saying that a card is being worked on, and how that ended.
-*
-* A run launched from a terminal is recorded exactly like one an app launched:
-* the card gets a line saying who is on it and a comment naming the attempt, so
-* `kanbo ready` stops offering the card to the next agent that asks. Its
-* launch is filed as `external` — no app started this, and a board that
-* claimed otherwise would send someone looking for a session that never existed.
-*/
-function registerRunCommands(program) {
-	const run = program.command("run").description("Record when an agent starts and finishes work on a card");
-	withBoardOptions(run.command("start").description("Say that you started working on a card").argument("<card>", "the card, as MAN-012, MAN-12 or 12").requiredOption("--agent <name>", "your name, e.g. claude").option("--branch <branch>", "the branch the work happens on").option("--execution-mode <mode>", "where the work happens: worktree or main (default: what the card says)", parseExecutionMode).option("--session <ref>", "your session, to find it later: claude:<session id> or codex:<session id> (default: the one Claude Code or Codex names in the environment)")).action(async (reference, options) => {
-		await runBoardCommand(options, "write", async (session) => {
-			const card = await requireCard(session, reference);
-			const started = await session.ops.startRun(card.id, {
-				agentName: options.agent,
-				branch: options.branch,
-				executionMode: options.executionMode,
-				externalSessionRef: options.session ?? sessionRefFromEnvironment() ?? void 0,
-				launchedByKind: "external"
-			}, createCliActor());
-			const view = projectRun({
-				...started,
-				attempt: await attemptFor(session, started)
-			});
-			return {
-				value: view,
-				text: `Run ${view.id} started on ${card.id}\nWhen you are done: kanbo run finish ${view.id} --state finished`,
-				fields: RUN_VIEW_FIELDS
-			};
-		});
-	});
-	withBoardOptions(run.command("attach-session").description("Say which agent session did this work (the first one given stays)").argument("<runId>", "the run id kanbo run start printed").argument("<ref>", "claude:<session id> or codex:<session id>").option("--replace", "replace the session already given (a person only)")).action(async (runId, ref, options, command) => {
-		const actor = options.replace ? requireHumanActor("run attach-session --replace", typedWords(command)) : null;
-		await runBoardCommand(options, "write", async (session) => {
-			const found = await requireRun(session, runId);
-			const attached = actor ? await session.ops.clearRunSessionRef(found.id, actor, { replaceWith: ref }) : await session.ops.recordRunSessionRef(found.id, ref);
-			const view = projectRun({
-				...attached,
-				attempt: await attemptFor(session, attached)
-			});
-			return {
-				value: view,
-				text: `Run ${view.id} carries ${attached.externalSessionRef}`,
-				fields: RUN_VIEW_FIELDS
-			};
-		});
-	});
-	withBoardOptions(run.command("clear-session").description("Remove the session given for this work (a person only)").argument("<runId>", "the run, as `kanbo run start` printed it")).action(async (runId, options, command) => {
-		const actor = requireHumanActor("run clear-session", typedWords(command));
-		await runBoardCommand(options, "write", async (session) => {
-			const found = await requireRun(session, runId);
-			const cleared = await session.ops.clearRunSessionRef(found.id, actor);
-			const view = projectRun({
-				...cleared,
-				attempt: await attemptFor(session, cleared)
-			});
-			return {
-				value: view,
-				text: `Run ${view.id} names no log`,
-				fields: RUN_VIEW_FIELDS
-			};
-		});
-	});
-	withBoardOptions(run.command("finish").description("Say how the work ended").argument("<runId>", "the run, as `kanbo run start` printed it").requiredOption("--state <state>", `one of ${RUN_FINISH_STATES.join(", ")} (completed, succeeded, done: finished; error: failed; cancelled, aborted: stopped)`, parseRunState).option("--error-text <text>", "what went wrong, for a failed run")).action(async (runId, options) => {
-		await runBoardCommand(options, "write", async (session) => {
-			const run = await requireRun(session, runId);
-			const finished = await session.ops.finishRun(run.id, {
-				state: options.state,
-				errorText: options.errorText
-			}, createCliActor());
-			const view = projectRun({
-				...finished,
-				attempt: await attemptFor(session, finished)
-			});
-			return {
-				value: view,
-				text: `Run ${view.id} ${view.state}`,
-				fields: RUN_VIEW_FIELDS
-			};
-		});
-	});
-}
-/**
-* Which attempt a run is. `startRun` and `finishRun` hand back the row
-* itself; the count only exists once every run of the card is lined up.
-*/
-async function attemptFor(session, run) {
-	const runs = await session.ops.listRuns(run.issueId);
-	return runs.find((candidate) => candidate.id === run.id)?.attempt ?? runs.length;
-}
-function parseRunState(value) {
-	const state = readRunFinishState(value);
-	if (!state) throw new CliError(1, `Unknown run state "${value}". Use one of ${RUN_FINISH_STATES.join(", ")}.`);
-	return state;
-}
-//#endregion
 //#region src/serve/actors.ts
 /**
 * Who a request writes as.
@@ -13251,12 +11978,14 @@ const BOARD_PAGE_CSP = [
 	"style-src 'self'",
 	"connect-src 'self'",
 	"img-src 'self' data:",
+	"font-src 'self'",
 	"base-uri 'none'",
 	"form-action 'none'",
 	"frame-ancestors 'none'"
 ].join("; ");
 const SCRIPT_PATH = "/assets/board.js";
 const STYLESHEET_PATH = "/assets/board.css";
+const FONT_PATH = /^\/assets\/fonts\/([a-z0-9-]+\.woff2)$/;
 /** The document itself. No data in it; the `data:` icon keeps the browser from asking for `/favicon.ico`. */
 const BOARD_PAGE_HTML = `<!doctype html>
 <html lang="en">
@@ -13283,19 +12012,23 @@ function resolveBoardPageDirectory() {
 	const candidates = [join(here, "page"), join(here, "..", "..", "dist", "page")];
 	return candidates.find((directory) => existsSync(join(directory, "board.js"))) ?? candidates[1];
 }
-/** The page's two files from `directory`, or `null` when the page has not been built there. */
+/** The page's files from `directory`, or `null` when the page has not been built there. */
 function readBoardPageAssets(directory) {
 	const script = join(directory, "board.js");
 	const stylesheet = join(directory, "board.css");
 	if (!existsSync(script) || !existsSync(stylesheet)) return null;
+	const fontDirectory = join(directory, "fonts");
+	const fonts = /* @__PURE__ */ new Map();
+	if (existsSync(fontDirectory)) for (const name of readdirSync(fontDirectory).filter((file) => FONT_PATH.test(`/assets/fonts/${file}`))) fonts.set(name, readFileSync(join(fontDirectory, name)));
 	return {
 		script: readFileSync(script, "utf8"),
-		stylesheet: readFileSync(stylesheet, "utf8")
+		stylesheet: readFileSync(stylesheet, "utf8"),
+		fonts
 	};
 }
 /** Whether a path is one of the page's own. */
 function isBoardPagePath(pathname) {
-	return pathname === "/" || pathname === SCRIPT_PATH || pathname === STYLESHEET_PATH;
+	return pathname === "/" || pathname === SCRIPT_PATH || pathname === STYLESHEET_PATH || FONT_PATH.test(pathname);
 }
 /**
 * Answer a page path. With no built page, `/` says how to build it rather than
@@ -13314,6 +12047,31 @@ function sendBoardPage(response, pathname, assets) {
 		response.end(body);
 		return;
 	}
+	const fontName = FONT_PATH.exec(pathname)?.[1];
+	if (fontName !== void 0) {
+		const font = assets.fonts.get(fontName);
+		if (!font) {
+			const body = JSON.stringify({
+				code: "not_found",
+				message: "No such font"
+			});
+			response.writeHead(404, {
+				"content-type": "application/json",
+				"content-length": Buffer.byteLength(body)
+			});
+			response.end(body);
+			return;
+		}
+		response.writeHead(200, {
+			"content-type": "font/woff2",
+			"content-length": font.length,
+			"cache-control": "no-cache",
+			"x-content-type-options": "nosniff",
+			"referrer-policy": "no-referrer"
+		});
+		response.end(font);
+		return;
+	}
 	const [contentType, body] = pathname === SCRIPT_PATH ? ["text/javascript; charset=utf-8", assets.script] : pathname === STYLESHEET_PATH ? ["text/css; charset=utf-8", assets.stylesheet] : ["text/html; charset=utf-8", BOARD_PAGE_HTML];
 	response.writeHead(200, {
 		"content-type": contentType,
@@ -13597,65 +12355,172 @@ function withDetails(body, details) {
 		details
 	};
 }
-//#endregion
-//#region src/serve/router.ts
-/** Declare a route; the query and body reach the handler parsed, or the request is a 400. */
-function route(spec) {
-	return {
-		method: spec.method,
-		segments: splitPath(spec.path),
-		write: spec.write ?? false,
-		run: async ({ params, query, body, actors }) => {
-			const parsedQuery = spec.query ? spec.query.safeParse(query) : {
-				success: true,
-				data: query
-			};
-			if (!parsedQuery.success) throw validationError("query", parsedQuery.error);
-			const parsedBody = spec.body ? spec.body.safeParse(body ?? {}) : {
-				success: true,
-				data: void 0
-			};
-			if (!parsedBody.success) throw validationError("body", parsedBody.error);
-			return await spec.handle({
-				params,
-				query: parsedQuery.data,
-				body: parsedBody.data,
-				actors
-			});
-		}
-	};
+//#endregion
+//#region src/serve/router.ts
+/** Declare a route; the query and body reach the handler parsed, or the request is a 400. */
+function route(spec) {
+	return {
+		method: spec.method,
+		segments: splitPath(spec.path),
+		write: spec.write ?? false,
+		run: async ({ params, query, body, actors }) => {
+			const parsedQuery = spec.query ? spec.query.safeParse(query) : {
+				success: true,
+				data: query
+			};
+			if (!parsedQuery.success) throw validationError("query", parsedQuery.error);
+			const parsedBody = spec.body ? spec.body.safeParse(body ?? {}) : {
+				success: true,
+				data: void 0
+			};
+			if (!parsedBody.success) throw validationError("body", parsedBody.error);
+			return await spec.handle({
+				params,
+				query: parsedQuery.data,
+				body: parsedBody.data,
+				actors
+			});
+		}
+	};
+}
+/** The route a request names and its path parameters, or `null` when no route does. */
+function matchRoute(routes, method, path) {
+	const segments = splitPath(path);
+	for (const candidate of routes) {
+		if (candidate.method !== method || candidate.segments.length !== segments.length) continue;
+		const params = {};
+		if (candidate.segments.every((segment, index) => {
+			if (segment.startsWith(":")) {
+				params[segment.slice(1)] = segments[index];
+				return segments[index].length > 0;
+			}
+			return segment === segments[index];
+		})) return {
+			route: candidate,
+			params
+		};
+	}
+	return null;
+}
+/**
+* A path as its segments, decoded, with a trailing slash ignored: `/issues`
+* and `/issues/` are the same list route. A segment that is not valid
+* percent-encoding is kept as it came, and names nothing on the board.
+*/
+function splitPath(path) {
+	return path.split("/").filter(Boolean).map((segment) => {
+		try {
+			return decodeURIComponent(segment);
+		} catch {
+			return segment;
+		}
+	});
+}
+//#endregion
+//#region src/cli/metrics-view.ts
+/** Every field `kanbo stats --json` may name, in the order the value carries them. */
+const BOARD_METRICS_FIELDS = [
+	"range",
+	"now",
+	"milestoneId",
+	"columns",
+	"cycleTime",
+	"leadTime",
+	"throughput",
+	"wip",
+	"aging",
+	"timeInColumn",
+	"cumulativeFlow",
+	"finished",
+	"returns",
+	"attempts",
+	"canceled",
+	"agents",
+	"people"
+];
+const LABEL_WIDTH = 16;
+/** A duration as the command line prints it: minutes under an hour, hours under a day, then days, to one decimal; a dash for none. */
+function formatDuration(seconds) {
+	if (seconds === null) return "—";
+	if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
+	if (seconds < 86400) return `${Number((seconds / 3600).toFixed(1))}h`;
+	return `${Number((seconds / 86400).toFixed(1))}d`;
+}
+function percent(share) {
+	return share === null ? "—" : `${Math.round(share * 100)}%`;
+}
+function decimal(value) {
+	return value === null ? "—" : String(Number(value.toFixed(1)));
+}
+function count(n, noun) {
+	return `${n} ${noun}${n === 1 ? "" : "s"}`;
+}
+function day(seconds) {
+	return (/* @__PURE__ */ new Date(seconds * 1e3)).toISOString().slice(0, 10);
+}
+/** A labelled block: the first item beside the label, the rest under it; a dash when there is nothing. */
+function block(label, items) {
+	const [first = "—", ...rest] = items;
+	return [`${label.padEnd(LABEL_WIDTH)}${first}`, ...rest.map((item) => `${" ".repeat(LABEL_WIDTH)}${item}`)];
+}
+/** Items joined on one line, or none at all. */
+function oneLine(items) {
+	return items.length === 0 ? [] : [items.join(" · ")];
+}
+/**
+* The metrics as a person reads them in a terminal: the range, then one block
+* per figure. The cumulative flow is a series per day and has no one-screen
+* form, so the last line says how to get it.
+*/
+function describeMetrics(metrics, sprint) {
+	const column = (slug) => sanitizeTerminalText(metrics.columns.find((candidate) => candidate.slug === slug)?.name ?? slug);
+	const by = metrics.returns.byActorKind;
+	const lines = [`${day(metrics.range.from)} → ${day(metrics.range.to)}`];
+	if (sprint) lines.push(`${sanitizeTerminalText(sprint.title)}: ${sprint.cards.open + sprint.cards.done} planned · ${sprint.cards.done} done`);
+	if (metrics.range.from > metrics.range.to) return [...lines, "Nothing measured yet: the range starts after now."].join("\n");
+	lines.push(...block("Cycle time", [`p50 ${formatDuration(metrics.cycleTime.p50)} · p85 ${formatDuration(metrics.cycleTime.p85)} (${count(metrics.cycleTime.cards, "card")})`]), ...block("Lead time", [`p50 ${formatDuration(metrics.leadTime.p50)} · p85 ${formatDuration(metrics.leadTime.p85)}`]), ...block("Throughput", oneLine(metrics.throughput.map((week) => `${week.week} ${week.finished}`))), ...block("In progress", oneLine(metrics.wip.map((wip) => `${column(wip.slug)} ${wip.cards}${wip.limit === null ? "" : `/${wip.limit}`}`))), ...block("First pass", [`${percent(metrics.returns.firstPassRate)} · attempts ${decimal(metrics.attempts.perFinishedCard)} per card`]), ...block("Returns", [`${metrics.returns.total} (people ${by.user} · agents ${by.agent} · outside ${by.external}) · ${decimal(metrics.returns.perFinishedCard)} per card`]), ...block("Canceled", [String(metrics.canceled)]), ...block("Aging", metrics.aging.map((card) => `${card.issueId} ${column(card.slug)} ${formatDuration(card.ageSeconds)}${card.overCycleP85 ? " (older than p85)" : ""}`)), ...block("Time in column", oneLine(metrics.timeInColumn.filter((time) => time.seconds > 0).map((time) => `${column(time.slug)} ${formatDuration(time.seconds)}`))), ...block("Agents", metrics.agents.map(describeAgent)), ...block("People", metrics.people.map(describePerson)), "Cumulative flow by day: kanbo stats --json cumulativeFlow");
+	return lines.join("\n");
+}
+function describeAgent(agent) {
+	const { runs } = agent;
+	return `${sanitizeTerminalText(agent.agentName)}: ${count(runs.total, "run")} (${runs.finished} finished · ${runs.failed} failed · ${runs.stopped} stopped · ${runs.running} running) · median ${formatDuration(agent.medianRunSeconds)} · ${count(agent.cardsFinished, "card")} finished · ${percent(agent.returnRate)} returned`;
+}
+function describePerson(person) {
+	return `${sanitizeTerminalText(person.id ?? "unnamed")}: ${person.created} created · ${person.approvals} approved · ${person.returns} returned · ${person.moves} moved`;
 }
-/** The route a request names and its path parameters, or `null` when no route does. */
-function matchRoute(routes, method, path) {
-	const segments = splitPath(path);
-	for (const candidate of routes) {
-		if (candidate.method !== method || candidate.segments.length !== segments.length) continue;
-		const params = {};
-		if (candidate.segments.every((segment, index) => {
-			if (segment.startsWith(":")) {
-				params[segment.slice(1)] = segments[index];
-				return segments[index].length > 0;
-			}
-			return segment === segments[index];
-		})) return {
-			route: candidate,
-			params
-		};
-	}
-	return null;
+const WEEK_SECONDS = 604800;
+/** The Monday that makes the range `DEFAULT_STATS_WEEKS` ISO weeks long, ending with the week of `now`. */
+function defaultStatsFrom(now) {
+	return isoWeekOf(now).start - 11 * WEEK_SECONDS;
 }
 /**
-* A path as its segments, decoded, with a trailing slash ignored: `/issues`
-* and `/issues/` are the same list route. A segment that is not valid
-* percent-encoding is kept as it came, and names nothing on the board.
+* `kanbo stats` — how work flows on this board (spec 2026-11-05, Part 4).
+*
+* Reading only, so it is anybody's, an agent's shell included. A sprint sets
+* the range to its own dates and keeps its cards; `--from` and `--to` still
+* win over either end.
 */
-function splitPath(path) {
-	return path.split("/").filter(Boolean).map((segment) => {
-		try {
-			return decodeURIComponent(segment);
-		} catch {
-			return segment;
-		}
+function registerStatsCommand(program) {
+	withBoardOptions(program.command("stats").description("How work flows on this board: cycle time, throughput, work in progress, returns, agents").option("--from <date>", `first day, YYYY-MM-DD (UTC) or unix seconds (12 weeks back when left out)`, (value) => parseCalendarDay(value, false)).option("--to <date>", "last day, YYYY-MM-DD (UTC, through its end) or unix seconds (now when left out)", (value) => parseCalendarDay(value, true)).option("--sprint <id>", "only the cards of this sprint, over its dates")).action(async (options) => {
+		await runBoardCommand(options, "read", async (session) => {
+			const now = currentUnixSeconds();
+			const sprint = options.sprint === void 0 ? null : (await session.ops.listSprints(session.workspace.id, now)).find((candidate) => candidate.id === options.sprint) ?? null;
+			if (options.sprint !== void 0 && sprint === null) throw new BoardError("issue_milestone_not_found", {
+				milestoneId: options.sprint,
+				workspaceId: session.workspace.id
+			});
+			const metrics = await session.ops.boardMetrics({
+				workspaceIds: [session.workspace.id],
+				from: options.from ?? sprint?.startDate ?? defaultStatsFrom(now),
+				to: options.to ?? sprint?.dueDate ?? now,
+				milestoneId: sprint?.id ?? null
+			}, now);
+			return {
+				value: metrics,
+				text: describeMetrics(metrics, sprint),
+				fields: BOARD_METRICS_FIELDS
+			};
+		});
 	});
 }
 //#endregion
@@ -14000,6 +12865,14 @@ function createActivityResolver(workspace, personWriterId = null) {
 * a server started for one of them must not reach into the rest.
 */
 const OK = { ok: true };
+/** Unix seconds in a query string, where everything arrives as text. */
+const unixSecondsQuery = z.string().regex(/^\d+$/).transform(Number);
+/** `GET /issues/metrics`: the range as `kanbo stats` takes it, `from` and `to` in unix seconds, or a sprint to read over its own dates. */
+const metricsQuery = z.object({
+	from: unixSecondsQuery.optional(),
+	to: unixSecondsQuery.optional(),
+	sprint: z.string().min(1).optional()
+});
 /** How many cards a search answers with when the caller names no limit. */
 const DEFAULT_SEARCH_LIMIT = 20;
 /**
@@ -14295,6 +13168,25 @@ function createIssueRoutes(session, options = {}) {
 				return updated;
 			}
 		}),
+		route({
+			method: "GET",
+			path: "/issues/metrics",
+			query: metricsQuery,
+			handle: async ({ query }) => {
+				const now = currentUnixSeconds();
+				const sprint = query.sprint === void 0 ? null : (await ops.listSprints(workspaceId, now)).find((candidate) => candidate.id === query.sprint) ?? null;
+				if (query.sprint !== void 0 && sprint === null) throw new BoardError("issue_milestone_not_found", {
+					milestoneId: query.sprint,
+					workspaceId
+				});
+				return await ops.boardMetrics({
+					workspaceIds: [workspaceId],
+					from: query.from ?? sprint?.startDate ?? defaultStatsFrom(now),
+					to: query.to ?? sprint?.dueDate ?? now,
+					milestoneId: sprint?.id ?? null
+				}, now);
+			}
+		}),
 		route({
 			method: "GET",
 			path: "/issues/workspace",
@@ -15288,113 +14180,6 @@ function registerSprintCommands(program) {
 	});
 }
 //#endregion
-//#region src/cli/metrics-view.ts
-/** Every field `kanbo stats --json` may name, in the order the value carries them. */
-const BOARD_METRICS_FIELDS = [
-	"range",
-	"now",
-	"milestoneId",
-	"columns",
-	"cycleTime",
-	"leadTime",
-	"throughput",
-	"wip",
-	"aging",
-	"timeInColumn",
-	"cumulativeFlow",
-	"finished",
-	"returns",
-	"attempts",
-	"canceled",
-	"agents",
-	"people"
-];
-const LABEL_WIDTH = 16;
-/** A duration as the command line prints it: minutes under an hour, hours under a day, then days, to one decimal; a dash for none. */
-function formatDuration(seconds) {
-	if (seconds === null) return "—";
-	if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
-	if (seconds < 86400) return `${Number((seconds / 3600).toFixed(1))}h`;
-	return `${Number((seconds / 86400).toFixed(1))}d`;
-}
-function percent(share) {
-	return share === null ? "—" : `${Math.round(share * 100)}%`;
-}
-function decimal(value) {
-	return value === null ? "—" : String(Number(value.toFixed(1)));
-}
-function count(n, noun) {
-	return `${n} ${noun}${n === 1 ? "" : "s"}`;
-}
-function day(seconds) {
-	return (/* @__PURE__ */ new Date(seconds * 1e3)).toISOString().slice(0, 10);
-}
-/** A labelled block: the first item beside the label, the rest under it; a dash when there is nothing. */
-function block(label, items) {
-	const [first = "—", ...rest] = items;
-	return [`${label.padEnd(LABEL_WIDTH)}${first}`, ...rest.map((item) => `${" ".repeat(LABEL_WIDTH)}${item}`)];
-}
-/** Items joined on one line, or none at all. */
-function oneLine(items) {
-	return items.length === 0 ? [] : [items.join(" · ")];
-}
-/**
-* The metrics as a person reads them in a terminal: the range, then one block
-* per figure. The cumulative flow is a series per day and has no one-screen
-* form, so the last line says how to get it.
-*/
-function describeMetrics(metrics, sprint) {
-	const column = (slug) => sanitizeTerminalText(metrics.columns.find((candidate) => candidate.slug === slug)?.name ?? slug);
-	const by = metrics.returns.byActorKind;
-	const lines = [`${day(metrics.range.from)} → ${day(metrics.range.to)}`];
-	if (sprint) lines.push(`${sanitizeTerminalText(sprint.title)}: ${sprint.cards.open + sprint.cards.done} planned · ${sprint.cards.done} done`);
-	if (metrics.range.from > metrics.range.to) return [...lines, "Nothing measured yet: the range starts after now."].join("\n");
-	lines.push(...block("Cycle time", [`p50 ${formatDuration(metrics.cycleTime.p50)} · p85 ${formatDuration(metrics.cycleTime.p85)} (${count(metrics.cycleTime.cards, "card")})`]), ...block("Lead time", [`p50 ${formatDuration(metrics.leadTime.p50)} · p85 ${formatDuration(metrics.leadTime.p85)}`]), ...block("Throughput", oneLine(metrics.throughput.map((week) => `${week.week} ${week.finished}`))), ...block("In progress", oneLine(metrics.wip.map((wip) => `${column(wip.slug)} ${wip.cards}${wip.limit === null ? "" : `/${wip.limit}`}`))), ...block("First pass", [`${percent(metrics.returns.firstPassRate)} · attempts ${decimal(metrics.attempts.perFinishedCard)} per card`]), ...block("Returns", [`${metrics.returns.total} (people ${by.user} · agents ${by.agent} · outside ${by.external}) · ${decimal(metrics.returns.perFinishedCard)} per card`]), ...block("Canceled", [String(metrics.canceled)]), ...block("Aging", metrics.aging.map((card) => `${card.issueId} ${column(card.slug)} ${formatDuration(card.ageSeconds)}${card.overCycleP85 ? " (older than p85)" : ""}`)), ...block("Time in column", oneLine(metrics.timeInColumn.filter((time) => time.seconds > 0).map((time) => `${column(time.slug)} ${formatDuration(time.seconds)}`))), ...block("Agents", metrics.agents.map(describeAgent)), ...block("People", metrics.people.map(describePerson)), "Cumulative flow by day: kanbo stats --json cumulativeFlow");
-	return lines.join("\n");
-}
-function describeAgent(agent) {
-	const { runs } = agent;
-	return `${sanitizeTerminalText(agent.agentName)}: ${count(runs.total, "run")} (${runs.finished} finished · ${runs.failed} failed · ${runs.stopped} stopped · ${runs.running} running) · median ${formatDuration(agent.medianRunSeconds)} · ${count(agent.cardsFinished, "card")} finished · ${percent(agent.returnRate)} returned`;
-}
-function describePerson(person) {
-	return `${sanitizeTerminalText(person.id ?? "unnamed")}: ${person.created} created · ${person.approvals} approved · ${person.returns} returned · ${person.moves} moved`;
-}
-const WEEK_SECONDS = 604800;
-/** The Monday that makes the range `DEFAULT_STATS_WEEKS` ISO weeks long, ending with the week of `now`. */
-function defaultStatsFrom(now) {
-	return isoWeekOf(now).start - 11 * WEEK_SECONDS;
-}
-/**
-* `kanbo stats` — how work flows on this board (spec 2026-11-05, Part 4).
-*
-* Reading only, so it is anybody's, an agent's shell included. A sprint sets
-* the range to its own dates and keeps its cards; `--from` and `--to` still
-* win over either end.
-*/
-function registerStatsCommand(program) {
-	withBoardOptions(program.command("stats").description("How work flows on this board: cycle time, throughput, work in progress, returns, agents").option("--from <date>", `first day, YYYY-MM-DD (UTC) or unix seconds (12 weeks back when left out)`, (value) => parseCalendarDay(value, false)).option("--to <date>", "last day, YYYY-MM-DD (UTC, through its end) or unix seconds (now when left out)", (value) => parseCalendarDay(value, true)).option("--sprint <id>", "only the cards of this sprint, over its dates")).action(async (options) => {
-		await runBoardCommand(options, "read", async (session) => {
-			const now = currentUnixSeconds();
-			const sprint = options.sprint === void 0 ? null : (await session.ops.listSprints(session.workspace.id, now)).find((candidate) => candidate.id === options.sprint) ?? null;
-			if (options.sprint !== void 0 && sprint === null) throw new BoardError("issue_milestone_not_found", {
-				milestoneId: options.sprint,
-				workspaceId: session.workspace.id
-			});
-			const metrics = await session.ops.boardMetrics({
-				workspaceIds: [session.workspace.id],
-				from: options.from ?? sprint?.startDate ?? defaultStatsFrom(now),
-				to: options.to ?? sprint?.dueDate ?? now,
-				milestoneId: sprint?.id ?? null
-			}, now);
-			return {
-				value: metrics,
-				text: describeMetrics(metrics, sprint),
-				fields: BOARD_METRICS_FIELDS
-			};
-		});
-	});
-}
-//#endregion
 //#region src/cli/commands/uninstall.ts
 function registerUninstallCommand(program) {
 	program.command("uninstall").description("Disconnect kanbo from your agents; the board stays unless --purge").option("--project", "only this project's files").option("--global", "only your own files, for every project").option("--purge", "also remove this project's board settings, and its board file after you confirm").option("--yes", "do it without asking (never deletes a board file)").option("--json [fields]", "print what was done as JSON; name comma-separated fields to print only those").action(async (options) => {
@@ -15557,95 +14342,30 @@ function printActions(actions, notes, options) {
 * this one.
 *
 * The order is the order `kanbo --help` lists them in, under the heading of
-* the group each belongs to.
+* the group each belongs to. Agents reach the board through the MCP server
+* (`kanbo mcp`) alone; every other command is a person's.
 */
 function registerKanboCommands(program, context = {}) {
 	program.commandsGroup("Get started:");
 	registerInitCommand(program);
 	registerConnectCommand(program);
-	registerInstructionsCommand(program);
 	registerDoctorCommand(program, context.update ?? null);
 	registerUninstallCommand(program);
 	program.commandsGroup("Your board:");
 	registerBoardCommand(program);
-	registerCardCommands(program);
 	registerColumnsCommands(program);
 	registerApproveCommand(program);
 	registerReturnCommand(program);
-	registerReadyCommand(program);
-	registerPrimeCommand(program);
 	registerSprintCommands(program);
 	registerStatsCommand(program);
 	registerServeCommand(program);
-	program.commandsGroup("For agents and integrations:");
+	program.commandsGroup("For agents:");
 	registerMcpCommand(program);
-	registerClaimCommand(program);
-	registerRunCommands(program);
-	registerCapabilitiesCommand(program);
 	program.commandsGroup("Shared Postgres boards:");
 	registerMigrateCommand(program);
 	registerRolesCommands(program);
 }
 //#endregion
-//#region src/mcp/tool-names.ts
-/**
-* The board's tools, named once.
-*
-* An agent reaches this board through an MCP server, through a command line, or
-* through an HTTP API (`kanbo serve`, or an app that serves the same routes),
-* and the three must agree on what the board can be asked to do. The names live
-* here rather than in the MCP server so that a prompt built for an agent and the
-* tools that agent actually holds cannot drift apart: both read this list.
-*
-* Nothing here executes anything. These are names and the commands that mean
-* the same thing, for a prompt and for documentation.
-*/
-const KANBO_TOOL_NAMES = [
-	"kanbo_prime",
-	"kanbo_ready",
-	"kanbo_card_claim",
-	"kanbo_columns",
-	"kanbo_sprints",
-	"kanbo_card_get",
-	"kanbo_card_list",
-	"kanbo_card_create",
-	"kanbo_card_update",
-	"kanbo_card_move",
-	"kanbo_card_comment",
-	"kanbo_card_link_pr",
-	"kanbo_card_pull_requests",
-	"kanbo_status_line",
-	"kanbo_wait_approval",
-	"kanbo_run_start",
-	"kanbo_run_finish"
-];
-/**
-* What to type instead of calling the tool.
-*
-* An agent without MCP tools is not shut out of the board: every tool has a
-* command that does the same thing, and the card ends up saying the same
-* either way, because both call the same operations.
-*/
-const KANBO_TOOL_CLI_EQUIVALENTS = {
-	kanbo_prime: { kanbo: "kanbo prime" },
-	kanbo_ready: { kanbo: "kanbo ready" },
-	kanbo_card_claim: { kanbo: "kanbo claim [card] [--agent <name>]" },
-	kanbo_columns: { kanbo: "kanbo columns list" },
-	kanbo_sprints: { kanbo: "kanbo sprint list" },
-	kanbo_card_get: { kanbo: "kanbo card get <id>" },
-	kanbo_card_list: { kanbo: "kanbo card list" },
-	kanbo_card_create: { kanbo: "kanbo card create --description <text> [--title <title>] [--parent <id>]" },
-	kanbo_card_update: { kanbo: "kanbo card update <id> [--title <title>] [--description <text>] [--parent <id>]" },
-	kanbo_card_move: { kanbo: "kanbo card move <id> <column>" },
-	kanbo_card_comment: { kanbo: "kanbo card comment <id> --content <text>" },
-	kanbo_card_link_pr: { kanbo: "kanbo card pr add <id> <url>" },
-	kanbo_card_pull_requests: { kanbo: "kanbo card pr list <id>" },
-	kanbo_status_line: { kanbo: "kanbo card status-line <id> --text <text>" },
-	kanbo_wait_approval: { kanbo: "kanbo card wait-approval <id> [--text <text>]" },
-	kanbo_run_start: { kanbo: "kanbo run start <id> --agent <name> [--session <ref>]" },
-	kanbo_run_finish: { kanbo: "kanbo run finish <runId> --state <state>" }
-};
-//#endregion
 //#region src/capabilities/manifest.ts
 /**
 * A machine-readable description of this board, for an agent that has never
@@ -15661,12 +14381,11 @@ const KANBO_TOOL_CLI_EQUIVALENTS = {
 * sources gains something this file was not told about.
 *
 * `buildCapabilitiesManifest` and `renderCapabilitiesMarkdown` are the one
-* source two servings come from: `kanbo capabilities` prints either shape
-* from a terminal, and `kanbo mcp` serves both as resources
+* source two servings come from: `kanbo mcp` serves both as resources
 * (`kanbo://capabilities`, `kanbo://capabilities.md`).
 */
 /** The manifest's own shape version, bumped when a field is added or removed — not the package's version. */
-const CAPABILITIES_MANIFEST_VERSION = "3";
+const CAPABILITIES_MANIFEST_VERSION = "4";
 /** The package name and version this build reports — the same literal `kanbo mcp` and `kanbo --version` already use. */
 const KANBO_PACKAGE = {
 	name: "kanbo",
@@ -15714,14 +14433,13 @@ function buildCanonicalStrings() {
 		approved: APPROVED_COMMENT
 	};
 }
-/** Every board tool, with its schema converted and its CLI equivalent attached. */
+/** Every board tool, with its schema converted. */
 function buildTools() {
 	return KANBO_TOOLS.map((tool) => ({
 		name: tool.name,
 		title: tool.title,
 		description: tool.description,
-		inputSchema: z.toJSONSchema(z.object(tool.inputSchema)),
-		cli: KANBO_TOOL_CLI_EQUIVALENTS[tool.name]
+		inputSchema: z.toJSONSchema(z.object(tool.inputSchema))
 	}));
 }
 /** Every leaf command the `kanbo` binary answers to, walked off its own registration. */
@@ -15755,7 +14473,7 @@ function buildCommands() {
 /** Everything this build of the board can tell an orchestrator about itself. */
 function buildCapabilitiesManifest() {
 	return {
-		version: "3",
+		version: "4",
 		package: KANBO_PACKAGE,
 		storages: [...KANBO_STORAGES],
 		tools: buildTools(),
@@ -15778,8 +14496,8 @@ function buildCapabilitiesManifest() {
 			`The agent role (\`${BOARD_AGENT_ROLE}\`) may not delete a card at all — it holds select, insert and update on \`issues\` and nothing more, even though it may delete freely on every other board table.`,
 			"A column may ask a card to meet entry rules before it enters (`entryRules`). Anyone but a person moving, creating or bulk-moving a card into it early is refused with `board_column_rules_unmet` and one line per unmet rule (CLI exit 1); a person goes through and is told what is missing. Only a person sets the rules — `kanbo columns rules` refuses an agent's shell (exit 4). The database role does not enforce them.",
 			"A column may name the columns it accepts cards from (`allowedFrom`) and the most cards it holds (`wipLimit`). Anyone but a person moving, creating, bulk-moving or claiming a card against them is refused with `board_column_rules_unmet` (`allowed_from`, `wip_limit`); a person goes through and is told. A new board's Done accepts cards from In Review only. Only a person sets them — `kanbo columns flow` refuses an agent's shell (exit 4). The database role does not enforce them.",
-			"A claim (`kanbo claim`, `kanbo_card_claim`, `POST /issues/claim`) takes a ready card from To Do, starts its run and moves it into the board's first `started` column in one write; two claimers never get the same card, and the one that loses is told `board_nothing_ready` or `board_card_not_ready`. A card has one run going at a time: starting a second is refused with `board_card_run_active`, on every path.",
-			"Only a person changes the board's columns: `kanbo columns add`, `rename`, `move`, `remove`, `template` and `add-standard` refuse an agent's shell (exit 4), and the rename, move, remove and add-missing operations refuse any actor but a person (`board_column_structure_requires_user`); no MCP tool changes columns. To Do can be neither removed nor renamed away from its slug `to_do`: `kanbo ready` takes work from it.",
+			"A claim (`kanbo_card_claim`, `POST /issues/claim`) takes a ready card from To Do, starts its run and moves it into the board's first `started` column in one write; two claimers never get the same card, and the one that loses is told `board_nothing_ready` or `board_card_not_ready`. A card has one run going at a time: starting a second is refused with `board_card_run_active`, on every path.",
+			"Only a person changes the board's columns: `kanbo columns add`, `rename`, `move`, `remove`, `template` and `add-standard` refuse an agent's shell (exit 4), and the rename, move, remove and add-missing operations refuse any actor but a person (`board_column_structure_requires_user`); no MCP tool changes columns. To Do can be neither removed nor renamed away from its slug `to_do`: `kanbo_ready` takes work from it.",
 			"No board tool or command deletes a card, agent role or not. Cancelling one is a move to another column. The one exception is `kanbo serve`'s `DELETE /issues/:id`, which it answers only for a request presenting its token, on a server a person started, that has not sent `x-kanbo-actor: agent` (403 `issue_delete_requires_user` otherwise).",
 			"`kanbo migrate` and `kanbo roles apply` refuse a host app's own database file: the app migrates it, and this package never touches it.",
 			"A write to a board older than this build's schema epoch is refused (exit 3) until `kanbo migrate` runs (on a host app's database, until the app migrates it), and so is a read of a board file that lacks a table or a column this build reads; a board whose only difference is its schema stamp stays readable.",
@@ -15788,4 +14506,39 @@ function buildCapabilitiesManifest() {
 	};
 }
 //#endregion
-export { COLUMN_TEMPLATE_IDS as $, projectKanboSprint as A, formatIssueId as At, createBoardOps as B, pageOf as C, formatPlainActivityValue as Ct, projectKanboFieldChange as D, isOutsideWriter as Dt, projectKanboColumn as E, readSystemCommentKind as Et, BINDING_FILE_PATH as F, ENTRY_RULE_DESCRIPTIONS as G, parseExternalSessionRef as H, ignoreBoardFile as I, readChecklist as J, UNMET_ENTRY_RULE_REASONS as K, readBinding as L, renderCapabilitiesMarkdown as M, nextIssueNumber as Mt, maskDatabaseUrl as N, nextIssueOrder as Nt, projectKanboPullRequest as O, normalizeCommentAuthorKind as Ot, maskDatabaseUrls as P, readIssuePrefix as Pt, COLUMN_TEMPLATES as Q, readProjectBinding as R, matchesKanboCardQuery as S, formatActivityIssueReference as St, projectKanboCardComment as T, parseActivityStringArray as Tt, pullRequestFactKeys as U, formatExternalSessionRef as V, ENTRY_RULES as W, serializeEntryRules as X, readEntryRules as Y, COLUMN_CATALOGUE as Z, suggestCardKey as _, currentUnixSeconds as _t, BOARD_ERROR_RESPONSES as a, boardMetricsRuns as at, DEFAULT_KANBO_COMMENT_LIMIT as b, activityToken as bt, registerKanboTools as c, isoWeekOf as ct, KANBO_MCP_INSTRUCTIONS as d, readFlowRules as dt, readChangeSeq as et, KANBO_CAPABILITIES_MARKDOWN_RESOURCE_URI as f, DEFAULT_STATUSES as ft, isValidCardKey as g, BOARD_ACTOR as gt, CARD_KEY_PATTERN as h, previewComment as ht, KANBO_TOOL_NAMES as i, boardMetricsAgentKey as it, projectKanboSubCard as j, nextIssueIdentity as jt, projectKanboRun as k, toIssueView as kt, KANBO_TOOLS as l, utcDayLabel as lt, registerKanboCapabilitiesResources as m, cardDisplayTitle as mt, buildCapabilitiesManifest as n, TRACKED_FIELDS as nt, KANBO_MCP_SERVER_NAME as o, computeBoardMetrics as ot, KANBO_CAPABILITIES_RESOURCE_URI as p, normalizeStatusName as pt, evaluateEntryRules as q, KANBO_TOOL_CLI_EQUIVALENTS as r, diffFieldChanges as rt, createKanboMcpServer as s, nearestRank as st, CAPABILITIES_MANIFEST_VERSION as t, runBoardWrite as tt, buildKanboTools as u, FLOW_RULES as ut, DEFAULT_BOARD_FILE_PATH as v, activityKindOrder as vt, projectKanboCard as w, isEmptyActivityValue as wt, KANBO_CARD_INCLUDES as x, commentAuthorReference as xt, DEFAULT_KANBO_CARD_INCLUDES as y, activityText as yt, writeBinding as z };
+//#region src/mcp/tool-names.ts
+/**
+* The board's tools, named once.
+*
+* An agent reaches this board through an MCP server, or through an HTTP API
+* (`kanbo serve`, or an app that serves the same routes), and both must agree on
+* what the board can be asked to do. The names are read by the MCP server, by
+* the prompts built for an agent and by the HTTP API — there is no command line
+* for an agent. They live here rather than in the MCP server so that a prompt
+* built for an agent and the tools that agent actually holds cannot drift
+* apart: both read this list.
+*
+* Nothing here executes anything. These are names, for a prompt and for
+* documentation.
+*/
+const KANBO_TOOL_NAMES = [
+	"kanbo_prime",
+	"kanbo_ready",
+	"kanbo_card_claim",
+	"kanbo_columns",
+	"kanbo_sprints",
+	"kanbo_card_get",
+	"kanbo_card_list",
+	"kanbo_card_create",
+	"kanbo_card_update",
+	"kanbo_card_move",
+	"kanbo_card_comment",
+	"kanbo_card_link_pr",
+	"kanbo_card_pull_requests",
+	"kanbo_status_line",
+	"kanbo_wait_approval",
+	"kanbo_run_start",
+	"kanbo_run_finish"
+];
+//#endregion
+export { readChangeSeq as $, suggestCardKey as A, nextIssueIdentity as At, formatExternalSessionRef as B, KANBO_MCP_INSTRUCTIONS as C, isEmptyActivityValue as Ct, renderCapabilitiesMarkdown as D, normalizeCommentAuthorKind as Dt, registerKanboCapabilitiesResources as E, isOutsideWriter as Et, ignoreBoardFile as F, UNMET_ENTRY_RULE_REASONS as G, pullRequestFactKeys as H, readBinding as I, readEntryRules as J, evaluateEntryRules as K, readProjectBinding as L, maskDatabaseUrl as M, nextIssueOrder as Mt, maskDatabaseUrls as N, readIssuePrefix as Nt, CARD_KEY_PATTERN as O, toIssueView as Ot, BINDING_FILE_PATH as P, COLUMN_TEMPLATE_IDS as Q, writeBinding as R, projectKanboSubCard as S, formatPlainActivityValue as St, KANBO_CAPABILITIES_RESOURCE_URI as T, readSystemCommentKind as Tt, ENTRY_RULES as U, parseExternalSessionRef as V, ENTRY_RULE_DESCRIPTIONS as W, COLUMN_CATALOGUE as X, serializeEntryRules as Y, COLUMN_TEMPLATES as Z, projectKanboColumn as _, activityKindOrder as _t, KANBO_MCP_SERVER_NAME as a, computeBoardMetrics as at, projectKanboRun as b, commentAuthorReference as bt, KANBO_TOOLS as c, utcDayLabel as ct, DEFAULT_KANBO_COMMENT_LIMIT as d, DEFAULT_STATUSES as dt, runBoardWrite as et, KANBO_CARD_INCLUDES as f, normalizeStatusName as ft, projectKanboCardComment as g, currentUnixSeconds as gt, projectKanboCard as h, BOARD_ACTOR as ht, BOARD_ERROR_RESPONSES as i, boardMetricsRuns as it, DEFAULT_BOARD_FILE_PATH as j, nextIssueNumber as jt, isValidCardKey as k, formatIssueId as kt, buildKanboTools as l, FLOW_RULES as lt, pageOf as m, previewComment as mt, CAPABILITIES_MANIFEST_VERSION as n, diffFieldChanges as nt, createKanboMcpServer as o, nearestRank as ot, matchesKanboCardQuery as p, cardDisplayTitle as pt, readChecklist as q, buildCapabilitiesManifest as r, boardMetricsAgentKey as rt, registerKanboTools as s, isoWeekOf as st, KANBO_TOOL_NAMES as t, TRACKED_FIELDS as tt, DEFAULT_KANBO_CARD_INCLUDES as u, readFlowRules as ut, projectKanboFieldChange as v, activityText as vt, KANBO_CAPABILITIES_MARKDOWN_RESOURCE_URI as w, parseActivityStringArray as wt, projectKanboSprint as x, formatActivityIssueReference as xt, projectKanboPullRequest as y, activityToken as yt, createBoardOps as z };