kanbo-cli 0.6.0 → 0.8.0

package/dist/lib/{manifest-BFI4HGPh.cjs → tool-names-BOUJas7m.cjs}

@@ -282,14 +282,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",
@@ -302,8 +297,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,
@@ -316,9 +310,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`,
@@ -337,7 +329,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
@@ -5465,8 +5457,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)");
@@ -5490,11 +5480,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 require_migrate.openBoardDatabase(target.path);
 	try {
@@ -5572,18 +5579,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,
@@ -5614,7 +5609,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;
 }
 /**
@@ -5742,7 +5737,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",
@@ -5762,16 +5757,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",
@@ -5783,22 +5768,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;
@@ -5820,14 +5789,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 : {
@@ -5864,42 +5825,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))];
@@ -6106,858 +6031,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 : require_migrate.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) => require_migrate.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 commander.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 commander.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 commander.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 require_migrations_path.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
@@ -6968,14 +6166,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"
@@ -6984,7 +6176,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"
@@ -7011,15 +6203,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.`,
@@ -7031,10 +6217,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.",
@@ -7058,22 +6241,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.` }),
@@ -7686,29 +6866,9 @@ function readWipLimit(value) {
 * `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() || (0, node_path.join)((0, node_os.homedir)(), ".codex");
@@ -7716,7 +6876,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() || (0, node_path.join)((0, node_os.homedir)(), ".claude");
@@ -7725,7 +6887,7 @@ function claudeConfigDir() {
 function geminiDir() {
 	return (0, node_path.join)(process.env.GEMINI_CLI_HOME?.trim() || (0, node_os.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 (0, node_path.join)(claudeConfigDir(), "CLAUDE.md");
@@ -7735,12 +6897,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 (0, node_path.join)((0, node_os.homedir)(), ".claude.json");
+		case "claude": return (0, node_path.join)(process.env.CLAUDE_CONFIG_DIR?.trim() || (0, node_os.homedir)(), ".claude.json");
 		case "codex": return (0, node_path.join)(codexHome(), "config.toml");
 		case "cursor": return (0, node_path.join)((0, node_os.homedir)(), ".cursor", "mcp.json");
 	}
@@ -7811,8 +6974,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.
@@ -7846,8 +7010,7 @@ const AGENTS = {
 		} : {
 			format: "claude-cli",
 			path: globalMcpConfigPath("claude")
-		},
-		mcpScope: "project"
+		}
 	},
 	codex: {
 		id: "codex",
@@ -7857,8 +7020,7 @@ const AGENTS = {
 		mcpTarget: (scope, projectDir) => ({
 			format: "toml",
 			path: scope === "project" ? (0, node_path.join)(projectDir, ".codex", "config.toml") : globalMcpConfigPath("codex")
-		}),
-		mcpScope: "user"
+		})
 	},
 	cursor: {
 		id: "cursor",
@@ -7869,9 +7031,7 @@ const AGENTS = {
 			format: "json",
 			path: scope === "project" ? (0, node_path.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",
@@ -7882,13 +7042,16 @@ const AGENTS = {
 			format: "json",
 			path: scope === "project" ? (0, node_path.join)(projectDir, ".gemini", "settings.json") : (0, node_path.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) {
@@ -8031,66 +7194,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",
@@ -8113,9 +7220,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) {
@@ -8140,56 +7247,13 @@ function inspectBlock(text, current) {
 	});
 	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 (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
@@ -8245,13 +7309,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
@@ -8380,48 +7437,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 = (0, cross_spawn.default)(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
 /**
@@ -8552,7 +7567,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))
 	};
 }
 /**
@@ -8585,7 +7600,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.
 */
@@ -8748,10 +7763,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. */
@@ -8774,8 +7789,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`.
 */
@@ -8791,8 +7807,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 = {
@@ -8801,29 +7819,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;
@@ -8994,11 +8019,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) {
@@ -9014,7 +8038,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 ");
@@ -9029,10 +8053,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)})`;
 	});
 }
@@ -9082,6 +8106,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 `&&`.
 */
@@ -9169,7 +8204,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);
@@ -9448,8 +8483,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) {
@@ -9457,7 +8492,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}`],
@@ -9511,9 +8546,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 = [];
@@ -9529,9 +8566,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
@@ -9542,38 +8578,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 {
@@ -9583,17 +8598,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.`
 		};
 	}
 }
@@ -9619,8 +8636,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) {
@@ -9693,7 +8710,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)}`;
 			}
 		})
 	};
@@ -9707,7 +8724,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
@@ -9875,7 +8892,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);
 	});
 }
@@ -9900,7 +8917,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
 	});
@@ -9923,19 +8940,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,
@@ -9971,14 +8992,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?",
@@ -10009,10 +9028,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.");
@@ -10039,73 +9055,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
 	};
@@ -10369,31 +9373,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 = (0, node_path.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 = [];
@@ -10407,15 +9390,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
@@ -10476,7 +9454,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) {
@@ -10549,7 +9527,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);
@@ -10561,38 +9539,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
 	};
 }
@@ -10604,9 +9570,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;
@@ -10620,7 +9591,7 @@ function describeExistingBoard(bound, cwd) {
 	return `${bound.projectDir === (0, node_path.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.
@@ -10804,58 +9775,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;
@@ -10879,134 +9822,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`)
@@ -11030,15 +9868,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()) {
@@ -11073,25 +9906,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 {
@@ -11120,7 +9949,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
 	};
@@ -11141,12 +9969,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
@@ -11168,13 +9996,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) {
@@ -11412,84 +10247,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,
@@ -11498,17 +10282,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.`);
@@ -11542,6 +10315,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";
@@ -11590,7 +10489,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
@@ -11601,7 +10500,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")})`,
@@ -11609,194 +10508,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 (0, node_fs.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. */
@@ -12024,66 +10738,247 @@ function compactKanboCard(card) {
 		...card.lastComment ? { lastComment: card.lastComment } : {}
 	};
 }
-/** The `detail` argument of the tools that write a card: a list's own word, for the one card a write answers with. */
-const writtenCardDetailArgument = zod.z.enum(["compact", "full"]).optional().describe("compact (default): the card as kanbo_card_list prints it. full: every field, description included.");
-/** What each tool that writes a card says about its answer, in its description. */
-const WRITTEN_CARD_ANSWER_SENTENCE = "Answers the card compact, as kanbo_card_list prints it; detail: \"full\" for every field.";
+/** The `detail` argument of the tools that write a card: a list's own word, for the one card a write answers with. */
+const writtenCardDetailArgument = zod.z.enum(["compact", "full"]).optional().describe("compact (default): the card as kanbo_card_list prints it. full: every field, description included.");
+/** What each tool that writes a card says about its answer, in its description. */
+const WRITTEN_CARD_ANSWER_SENTENCE = "Answers the card compact, as kanbo_card_list prints it; detail: \"full\" for every field.";
+/**
+* The card a write hands back, as the tool answers with it: compact and on one
+* line, as a list prints it. An agent writes its card at every step — a status
+* line, a move, an update — and reads each answer again on every later turn,
+* so a whole card, description included, would cost it again and again.
+* `detail: "full"` answers every field, as `kanbo_card_get` prints the card alone.
+*/
+function formatWrittenKanboCard(card, detail) {
+	return detail === "full" ? JSON.stringify(card, null, 2) : JSON.stringify(compactKanboCard(card));
+}
+function viewCard(card, view) {
+	if (view.fields) return Object.fromEntries([["id", card.id], ...view.fields.map((field) => [field, card[field]])]);
+	return view.detail === "full" ? card : compactKanboCard(card);
+}
+/**
+* The page as the tool's answer: how many cards the question picks, where the
+* next page starts when there is one, and one card per line.
+*/
+function formatKanboCardPage(page, view, returned) {
+	const shownUntil = page.offset + page.cards.length;
+	const more = Math.max(0, page.total - shownUntil);
+	const head = {
+		total: page.total,
+		...page.offset > 0 ? { offset: page.offset } : {},
+		...more > 0 ? {
+			more,
+			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]}`;
+}
+//#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: zod.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: zod.z.string().optional().describe("What the card is about, spelled out for whoever picks it up."),
+		column: zod.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
+	};
+}
 /**
-* The card a write hands back, as the tool answers with it: compact and on one
-* line, as a list prints it. An agent writes its card at every step — a status
-* line, a move, an update — and reads each answer again on every later turn,
-* so a whole card, description included, would cost it again and again.
-* `detail: "full"` answers every field, as `kanbo_card_get` prints the card alone.
+* 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 formatWrittenKanboCard(card, detail) {
-	return detail === "full" ? JSON.stringify(card, null, 2) : JSON.stringify(compactKanboCard(card));
+function matchesKanboCardQuery(card, query, statusIds) {
+	const text = query.text === void 0 ? void 0 : require_migrate.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) => require_migrate.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));
 }
-function viewCard(card, view) {
-	if (view.fields) return Object.fromEntries([["id", card.id], ...view.fields.map((field) => [field, card[field]])]);
-	return view.detail === "full" ? card : compactKanboCard(card);
+/** 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
+	};
 }
-/**
-* The page as the tool's answer: how many cards the question picks, where the
-* next page starts when there is one, and one card per line.
-*/
-function formatKanboCardPage(page, view, returned) {
-	const shownUntil = page.offset + page.cards.length;
-	const more = Math.max(0, page.total - shownUntil);
-	const head = {
-		total: page.total,
-		...page.offset > 0 ? { offset: page.offset } : {},
-		...more > 0 ? {
-			more,
-			nextOffset: shownUntil
-		} : {}
+/** 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
 	};
-	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: zod.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: zod.z.string().optional().describe("What the card is about, spelled out for whoever picks it up."),
-		column: zod.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. */
@@ -12727,16 +11622,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;
@@ -12780,7 +11679,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;
 	};
@@ -12794,9 +11693,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
@@ -12931,84 +11834,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.
@@ -13115,104 +11940,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.
@@ -13276,12 +12003,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">
@@ -13308,19 +12037,23 @@ function resolveBoardPageDirectory() {
 	const candidates = [(0, node_path.join)(here, "page"), (0, node_path.join)(here, "..", "..", "dist", "page")];
 	return candidates.find((directory) => (0, node_fs.existsSync)((0, node_path.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 = (0, node_path.join)(directory, "board.js");
 	const stylesheet = (0, node_path.join)(directory, "board.css");
 	if (!(0, node_fs.existsSync)(script) || !(0, node_fs.existsSync)(stylesheet)) return null;
+	const fontDirectory = (0, node_path.join)(directory, "fonts");
+	const fonts = /* @__PURE__ */ new Map();
+	if ((0, node_fs.existsSync)(fontDirectory)) for (const name of (0, node_fs.readdirSync)(fontDirectory).filter((file) => FONT_PATH.test(`/assets/fonts/${file}`))) fonts.set(name, (0, node_fs.readFileSync)((0, node_path.join)(fontDirectory, name)));
 	return {
 		script: (0, node_fs.readFileSync)(script, "utf8"),
-		stylesheet: (0, node_fs.readFileSync)(stylesheet, "utf8")
+		stylesheet: (0, node_fs.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
@@ -13339,6 +12072,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,
@@ -13650,37 +12408,144 @@ function route(spec) {
 		}
 	};
 }
-/** 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;
+/** 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(" · ")];
 }
 /**
-* 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.
+* 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 splitPath(path) {
-	return path.split("/").filter(Boolean).map((segment) => {
-		try {
-			return decodeURIComponent(segment);
-		} catch {
-			return segment;
-		}
+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 require_migrations_path.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
@@ -14025,6 +12890,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 = zod.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 = zod.z.object({
+	from: unixSecondsQuery.optional(),
+	to: unixSecondsQuery.optional(),
+	sprint: zod.z.string().min(1).optional()
+});
 /** How many cards a search answers with when the caller names no limit. */
 const DEFAULT_SEARCH_LIMIT = 20;
 /**
@@ -14320,6 +13193,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 require_migrations_path.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",
@@ -15313,113 +14205,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 require_migrations_path.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) => {
@@ -15582,95 +14367,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
@@ -15686,12 +14406,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",
@@ -15739,14 +14458,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: zod.z.toJSONSchema(zod.z.object(tool.inputSchema)),
-		cli: KANBO_TOOL_CLI_EQUIVALENTS[tool.name]
+		inputSchema: zod.z.toJSONSchema(zod.z.object(tool.inputSchema))
 	}));
 }
 /** Every leaf command the `kanbo` binary answers to, walked off its own registration. */
@@ -15780,7 +14498,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(),
@@ -15803,8 +14521,8 @@ function buildCapabilitiesManifest() {
 			`The agent role (\`${require_roles_sql.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.",
@@ -15813,6 +14531,41 @@ function buildCapabilitiesManifest() {
 	};
 }
 //#endregion
+//#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
 Object.defineProperty(exports, "BINDING_FILE_PATH", {
 	enumerable: true,
 	get: function() {
@@ -15939,12 +14692,6 @@ Object.defineProperty(exports, "KANBO_TOOLS", {
 		return KANBO_TOOLS;
 	}
 });
-Object.defineProperty(exports, "KANBO_TOOL_CLI_EQUIVALENTS", {
-	enumerable: true,
-	get: function() {
-		return KANBO_TOOL_CLI_EQUIVALENTS;
-	}
-});
 Object.defineProperty(exports, "KANBO_TOOL_NAMES", {
 	enumerable: true,
 	get: function() {