kanbo-cli 0.3.0 → 0.4.0

package/dist/cli-main.cjs

@@ -357,6 +357,7 @@ const BOARD_ERROR_TEXTS = {
 		text: `No card "${named(details.issueId)}" here.`,
 		next: "kanbo card list"
 	}),
+	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"
@@ -3560,7 +3561,7 @@ new Command();
 * `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.3.0";
+const KANBO_PACKAGE_VERSION = "0.4.0";
 //#endregion
 //#region src/cli/agent-shell.ts
 /**
@@ -3595,22 +3596,26 @@ const AGENT_SHELL_MARKERS = [
 	{
 		variable: "CLAUDECODE",
 		matches: (value) => value === "1",
-		label: "CLAUDECODE=1"
+		label: "CLAUDECODE=1",
+		tool: "claude"
 	},
 	{
 		variable: "GEMINI_CLI",
 		matches: (value) => value === "1",
-		label: "GEMINI_CLI=1"
+		label: "GEMINI_CLI=1",
+		tool: "gemini"
 	},
 	{
 		variable: "CURSOR_AGENT",
 		matches: (value) => value !== "",
-		label: "CURSOR_AGENT"
+		label: "CURSOR_AGENT",
+		tool: "cursor"
 	},
 	{
 		variable: "CODEX_THREAD_ID",
 		matches: (value) => value !== "",
-		label: "CODEX_THREAD_ID"
+		label: "CODEX_THREAD_ID",
+		tool: "codex"
 	}
 ];
 /**
@@ -3627,6 +3632,15 @@ function readAgentShellMarker(env = process.env) {
 	if (kind === "person") return null;
 	return AGENT_SHELL_MARKERS.find((candidate) => candidate.matches(env[candidate.variable]?.trim() ?? ""))?.label ?? null;
 }
+/**
+* The name of the agent tool this shell belongs to (`claude`, `gemini`,
+* `cursor`, `codex`), `agent` when only `KANBO_ACTOR_KIND=agent` says so, or
+* `null` for a person's shell. Same precedence as `readAgentShellMarker`.
+*/
+function readAgentTool(env = process.env) {
+	if (readAgentShellMarker(env) === null) return null;
+	return AGENT_SHELL_MARKERS.find((candidate) => candidate.matches(env[candidate.variable]?.trim() ?? ""))?.tool ?? "agent";
+}
 //#endregion
 //#region src/cli/actor.ts
 /**
@@ -3708,11 +3722,15 @@ const HUMAN_ONLY_MESSAGES = {
 	"run clear-session": describeRunSessionRefRefusal,
 	"run attach-session --replace": describeRunSessionRefRefusal
 };
-/** The actor every board write from this tool is filed under. */
+/**
+* The actor every board write from this tool is filed under: `KANBO_ACTOR_ID`,
+* else the agent tool of an agent's shell (`claude`, `codex`, ...), else the
+* operating system's user.
+*/
 function createCliActor() {
 	return {
 		kind: "external",
-		id: process.env.KANBO_ACTOR_ID?.trim() || safeUsername(),
+		id: process.env.KANBO_ACTOR_ID?.trim() || readAgentTool() || safeUsername(),
 		name: (0, node_os.hostname)()
 	};
 }
@@ -3750,6 +3768,14 @@ function createPlacementActor() {
 		placesForPerson: true
 	};
 }
+/** Who the board page writes as: the person at this machine — `KANBO_ACTOR_ID` in a person's shell, else the OS user; never an agent tool, since the page is read and typed in by a person. */
+function createServeWriter() {
+	return {
+		kind: "external",
+		id: (isAgentShell() ? "" : process.env.KANBO_ACTOR_ID?.trim() ?? "") || safeUsername(),
+		name: (0, node_os.hostname)()
+	};
+}
 /**
 * The person who owns this shell, as the board files a person. Only for a
 * caller that has already asked `isAgentShell` — `requireHumanActor` for a
@@ -11994,12 +12020,33 @@ async function requireParentInWorkspace(store, workspaceId, parentIssueId, issue
 		issueId,
 		parentIssueId
 	});
-	if (!await store.issues.findInWorkspace(workspaceId, parentIssueId)) throw new BoardError("issue_parent_not_found", {
+	const parent = await store.issues.findInWorkspace(workspaceId, parentIssueId);
+	if (!parent) throw new BoardError("issue_parent_not_found", {
 		workspaceId,
 		parentIssueId
 	});
+	if (issueId !== void 0 && await isUnder(store, parent, issueId)) throw new BoardError("issue_parent_cycle", {
+		issueId,
+		parentIssueId
+	});
 	return parentIssueId;
 }
+/**
+* Is the card somewhere under `ancestorId` — its parent, its parent's parent,
+* and so on up? A card put under one of its own sub-cards would make a loop no
+* reader of the board can walk to the top of. The cards already seen end the
+* walk, so a loop the data holds from before cannot hang it.
+*/
+async function isUnder(store, card, ancestorId) {
+	const seen = /* @__PURE__ */ new Set();
+	let id = card.parentIssueId;
+	while (id !== null && !seen.has(id)) {
+		if (id === ancestorId) return true;
+		seen.add(id);
+		id = (await store.issues.findById(id))?.parentIssueId ?? null;
+	}
+	return false;
+}
 /** Is the card's own number already taken by another card in the target workspace? */
 async function numberTakenByAnother(store, workspaceId, card) {
 	const holder = await store.issues.findByNumber(workspaceId, card.number);
@@ -23776,6 +23823,111 @@ async function openWithPostgresJs(url) {
 	};
 }
 //#endregion
+//#region src/cli/project-registry.ts
+/**
+* Which project folders kanbo has opened a board in.
+*
+* Every project keeps its board in its own folder, so nothing else knows which
+* other projects exist. This list, in the user's home, is what lets one board
+* page offer them all. It holds a folder and a time — never a connection
+* string, never board data — and deleting it is safe: it fills again as the
+* projects are used.
+*/
+/** The file's name inside kanbo's per-user folder. */
+const REGISTRY_FILE_NAME = "projects.json";
+/** The file is private to the user, as a binding is. */
+const REGISTRY_FILE_MODE = 384;
+/** The folder holding it is private to the user too. */
+const REGISTRY_DIRECTORY_MODE = 448;
+/**
+* A project noted within this many seconds is not noted again, so an ordinary
+* command does not rewrite the file: a day is fresh enough for "recently used".
+*/
+const RECENTLY_NOTED_SECONDS = 86400;
+const RegisteredProjectSchema = object$1({
+	path: string().min(1),
+	lastSeenAt: number().int().nonnegative()
+});
+const RegistrySchema = object$1({
+	schemaVersion: literal(1),
+	projects: array(RegisteredProjectSchema)
+});
+/** `$KANBO_HOME/projects.json`, else `~/.kanbo/projects.json`. */
+function projectRegistryPath(env = process.env) {
+	const home = env.KANBO_HOME?.trim();
+	return (0, node_path.join)(home || (0, node_path.join)((0, node_os.homedir)(), ".kanbo"), REGISTRY_FILE_NAME);
+}
+/** The projects, most recently seen first; `[]` when the file is missing or does not parse. */
+function readProjectRegistry(path = projectRegistryPath()) {
+	return readEntries(path).sort((a, b) => b.lastSeenAt - a.lastSeenAt);
+}
+/**
+* Note that `projectDir` was just used. Writes only when the folder is new or
+* was last noted more than a day ago, so ordinary commands do not rewrite the file.
+* Drops entries whose `.kanbo/binding.json` is gone.
+*/
+function rememberProject(projectDir, options = {}) {
+	const now = options.now ?? Math.floor(Date.now() / 1e3);
+	const path = options.path ?? projectRegistryPath();
+	const canonical = canonicalPath$1(projectDir);
+	const entries = readEntries(path);
+	const known = entries.find((entry) => entry.path === canonical);
+	if (known && now - known.lastSeenAt <= RECENTLY_NOTED_SECONDS) return;
+	const kept = entries.filter((entry) => entry.path !== canonical && (0, node_fs.existsSync)((0, node_path.join)(entry.path, BINDING_FILE_PATH)));
+	kept.push({
+		path: canonical,
+		lastSeenAt: now
+	});
+	writeEntries(path, kept);
+}
+/**
+* `rememberProject`, for the places that must not fail because of it: a home
+* directory that cannot be written is not a reason for `kanbo card list` to fail.
+* With `KANBO_DEBUG=1` the reason is printed on stderr.
+*/
+function rememberProjectQuietly(projectDir) {
+	const path = projectRegistryPath();
+	try {
+		rememberProject(projectDir, { path });
+	} catch (error) {
+		if (process.env.KANBO_DEBUG === "1") console.error(`kanbo: could not note this project in ${path}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function canonicalPath$1(projectDir) {
+	const absolute = (0, node_path.resolve)(projectDir);
+	try {
+		return (0, node_fs.realpathSync)(absolute);
+	} catch {
+		return absolute;
+	}
+}
+function readEntries(path) {
+	try {
+		const parsed = RegistrySchema.safeParse(JSON.parse((0, node_fs.readFileSync)(path, "utf8")));
+		return parsed.success ? parsed.data.projects : [];
+	} catch {
+		return [];
+	}
+}
+function writeEntries(path, projects) {
+	(0, node_fs.mkdirSync)((0, node_path.dirname)(path), {
+		recursive: true,
+		mode: REGISTRY_DIRECTORY_MODE
+	});
+	const temporaryPath = `${path}.${process.pid}.tmp`;
+	try {
+		(0, node_fs.writeFileSync)(temporaryPath, `${JSON.stringify(RegistrySchema.parse({
+			schemaVersion: 1,
+			projects
+		}), null, 2)}\n`, { mode: REGISTRY_FILE_MODE });
+		(0, node_fs.chmodSync)(temporaryPath, REGISTRY_FILE_MODE);
+		renameWithRetry(temporaryPath, path);
+	} catch (error) {
+		(0, node_fs.rmSync)(temporaryPath, { force: true });
+		throw error;
+	}
+}
+//#endregion
 //#region src/postgres/open-database.ts
 /** `information_schema.tables`, the first of the two views the guard reads. */
 const informationSchemaTables = pgSchema("information_schema").table("tables", {
@@ -24087,15 +24239,17 @@ function withBoardOptions(command) {
 * as a client is talking to it. A failure on the way out closes the board first
 * — a caller that never received a session has nothing to close.
 */
-async function openBoardSession(options, mode) {
-	const cwd = process.cwd();
+async function openBoardSession(options, mode, cwd = process.cwd()) {
 	const target = resolveDbTarget({
 		explicitPath: options.db,
 		explicitUrl: options.databaseUrl,
 		asAgent: options.asAgent,
 		cwd
 	});
-	return 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);
+	const found = findBinding(cwd);
+	if (found) rememberProjectQuietly(found.projectDir);
+	return session;
 }
 async function openFileSession(target, options, mode, cwd) {
 	const board = await openBoardDatabase(target.path);
@@ -24705,7 +24859,7 @@ const KANBO_TOOL_CLI_EQUIVALENTS = {
 	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>]" },
+	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>" },
@@ -24903,6 +25057,81 @@ const cardCommentTool = defineKanboTool({
 	},
 	run: async (transport, input) => await transport.cardComment(input)
 });
+/** The `detail` and `fields` arguments the list tools share. */
+const cardListViewArguments = {
+	detail: _enum(["compact", "full"]).optional().describe("compact (default): id, title, column slug, status line, waiting, parent, run, updatedAt; returned, and the last comment of a waiting or returned card. full: every field, description included."),
+	fields: array(_enum([
+		"number",
+		"title",
+		"description",
+		"column",
+		"columnSlug",
+		"statusLine",
+		"waitingFor",
+		"priority",
+		"labels",
+		"executionMode",
+		"parentIssueId",
+		"attemptCount",
+		"activeRun",
+		"updatedAt"
+	])).optional().describe("Print the id and only these fields of each card, e.g. [\"description\"].")
+};
+function compactKanboCard(card) {
+	return {
+		id: card.id,
+		title: cardDisplayTitle(card),
+		column: card.columnSlug,
+		...card.statusLine ? { statusLine: card.statusLine } : {},
+		...card.waitingFor ? { waitingFor: card.waitingFor } : {},
+		...card.parentIssueId ? { parentId: card.parentIssueId } : {},
+		...card.attemptCount > 0 ? { attempt: card.attemptCount } : {},
+		...card.activeRun ? { activeRun: {
+			agentName: card.activeRun.agentName,
+			startedAt: card.activeRun.startedAt
+		} } : {},
+		updatedAt: card.updatedAt,
+		...card.returned ? { returned: card.returned } : {},
+		...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 = _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. */
@@ -24911,19 +25140,20 @@ const SUBTASK_SENTENCE = "To create a subtask (sub-card) under another card, pas
 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`")}`,
+	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: 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: string().optional().describe("What the card is about, spelled out for whoever picks it up."),
 		column: 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()
+		executionMode: executionModeArgument.optional(),
+		detail: writtenCardDetailArgument
 	},
 	example: {
 		description: "Add slugify(text) with a test",
 		parent: "TST-1"
 	},
-	run: async (transport, input) => await transport.cardCreate(input)
+	run: async (transport, { detail, ...input }) => formatWrittenKanboCard(await transport.cardCreate(input), detail)
 });
 //#endregion
 //#region src/mcp/transport.ts
@@ -25054,9 +25284,14 @@ function projectKanboColumn(column) {
 }
 /** 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: normalizeCommentAuthorKind(comment.authorKind),
+		author,
+		by: named || outside ? comment.authorId ?? author : "kanbo",
 		content: comment.content,
 		createdAt: comment.createdAt
 	};
@@ -25104,67 +25339,6 @@ const cardLinkPrTool = defineKanboTool({
 	},
 	run: async (transport, input) => await transport.cardLinkPullRequest(input)
 });
-/** The `detail` and `fields` arguments the list tools share. */
-const cardListViewArguments = {
-	detail: _enum(["compact", "full"]).optional().describe("compact (default): id, title, column slug, status line, waiting, parent, run, updatedAt; returned, and the last comment of a waiting or returned card. full: every field, description included."),
-	fields: array(_enum([
-		"number",
-		"title",
-		"description",
-		"column",
-		"columnSlug",
-		"statusLine",
-		"waitingFor",
-		"priority",
-		"labels",
-		"executionMode",
-		"parentIssueId",
-		"attemptCount",
-		"activeRun",
-		"updatedAt"
-	])).optional().describe("Print the id and only these fields of each card, e.g. [\"description\"].")
-};
-function compactKanboCard(card) {
-	return {
-		id: card.id,
-		title: cardDisplayTitle(card),
-		column: card.columnSlug,
-		...card.statusLine ? { statusLine: card.statusLine } : {},
-		...card.waitingFor ? { waitingFor: card.waitingFor } : {},
-		...card.parentIssueId ? { parentId: card.parentIssueId } : {},
-		...card.attemptCount > 0 ? { attempt: card.attemptCount } : {},
-		...card.activeRun ? { activeRun: {
-			agentName: card.activeRun.agentName,
-			startedAt: card.activeRun.startedAt
-		} } : {},
-		updatedAt: card.updatedAt,
-		...card.returned ? { returned: card.returned } : {},
-		...card.lastComment ? { lastComment: card.lastComment } : {}
-	};
-}
-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]}`;
-}
 /** The cards on the board a question picks, one page of them. */
 const cardListTool = defineKanboTool({
 	name: "kanbo_card_list",
@@ -25219,10 +25393,11 @@ function readMoment(value) {
 const cardMoveTool = defineKanboTool({
 	name: "kanbo_card_move",
 	title: "Move a card",
-	description: "Move a card to another column the moment its real state changes. Read kanbo_columns first: a card in the wrong column is a lie, and a column with entryRules refuses a card that does not meet them yet, listing what is missing.",
+	description: `Move a card to another column the moment its real state changes. Read kanbo_columns first: a card in the wrong column is a lie, and a column with entryRules refuses a card that does not meet them yet, listing what is missing. ${WRITTEN_CARD_ANSWER_SENTENCE}`,
 	inputSchema: {
 		card: cardArgument,
-		column: string().min(1).describe("The column to move it to, by its slug or name: in_progress, \"In Progress\". Also accepted as `to`.")
+		column: string().min(1).describe("The column to move it to, by its slug or name: in_progress, \"In Progress\". Also accepted as `to`."),
+		detail: writtenCardDetailArgument
 	},
 	aliases: { column: ["to"] },
 	needs: { column: "the column slug, e.g. in_progress" },
@@ -25230,7 +25405,7 @@ const cardMoveTool = defineKanboTool({
 		card: "TST-5",
 		column: "in_progress"
 	},
-	run: async (transport, input) => await transport.cardMove(input)
+	run: async (transport, { detail, ...input }) => formatWrittenKanboCard(await transport.cardMove(input), detail)
 });
 //#endregion
 //#region src/mcp/tools/card-pull-requests.ts
@@ -25245,11 +25420,11 @@ const cardPullRequestsTool = defineKanboTool({
 });
 //#endregion
 //#region src/mcp/tools/card-update.ts
-/** What a card says: its title, what it is about, how urgent it is, how it is labelled. */
+/** What a card says — its title, what it is about, how urgent it is, how it is labelled — and which card it sits under. */
 const cardUpdateTool = defineKanboTool({
 	name: "kanbo_card_update",
 	title: "Update a card",
-	description: "Change what a card says: its title, its description, its priority, its labels or where its work happens.",
+	description: `Change what a card says: its title, its description, its priority, its labels or where its work happens. A card at the wrong level moves with \`parent\`: another card's id, or "none" for the top level. ${WRITTEN_CARD_ANSWER_SENTENCE}`,
 	inputSchema: {
 		card: cardArgument,
 		title: string().min(1).optional().describe("What the card is called."),
@@ -25262,18 +25437,26 @@ const cardUpdateTool = defineKanboTool({
 			"urgent"
 		]).optional(),
 		labels: array(string()).optional().describe("The labels the card carries, replacing the ones it has."),
-		executionMode: executionModeArgument.optional()
+		executionMode: executionModeArgument.optional(),
+		parent: cardArgument.optional().describe("The card to put this one under, by its id or key, e.g. MAN-012; \"none\" makes it a top-level card."),
+		detail: writtenCardDetailArgument
 	},
 	example: {
 		card: "TST-5",
 		title: "Add slugify"
 	},
-	run: async (transport, { card, ...patch }) => {
-		if (Object.keys(patch).length === 0) throw new Error("Nothing to update. Pass title, description, priority, labels or executionMode.");
-		return await transport.cardUpdate({
+	prepare: (input) => {
+		const { parent, ...rest } = input;
+		return parent === null ? rest : input;
+	},
+	run: async (transport, { card, detail, parent, ...patch }) => {
+		if (Object.keys(patch).length === 0 && parent === void 0) throw new Error("Nothing to update. Pass title, description, priority, labels, executionMode or parent.");
+		const placement = parent === void 0 ? {} : { parent: parent === "none" ? null : parent };
+		return formatWrittenKanboCard(await transport.cardUpdate({
 			card,
-			...patch
-		});
+			...patch,
+			...placement
+		}), detail);
 	}
 });
 //#endregion
@@ -25410,10 +25593,11 @@ const KANBO_TOOLS = [
 	defineKanboTool({
 		name: "kanbo_status_line",
 		title: "Set the status line",
-		description: "Say what the card is doing right now: `card` and `text` (one sentence). Write one at every step, including before and after anything long-running.",
+		description: "Say what the card is doing right now: `card` and `text` (one sentence). Write one at every step, including before and after anything long-running. " + WRITTEN_CARD_ANSWER_SENTENCE,
 		inputSchema: {
 			card: cardArgument,
-			text: string().min(1).describe("One sentence, present tense, about what is happening on the card right now. Also accepted as `content`.")
+			text: string().min(1).describe("One sentence, present tense, about what is happening on the card right now. Also accepted as `content`."),
+			detail: writtenCardDetailArgument
 		},
 		aliases: { text: ["content"] },
 		needs: { text: "the status line, one sentence" },
@@ -25421,22 +25605,23 @@ const KANBO_TOOLS = [
 			card: "TST-5",
 			text: "Running the tests"
 		},
-		run: async (transport, input) => await transport.statusLine(input)
+		run: async (transport, { detail, ...input }) => formatWrittenKanboCard(await transport.statusLine(input), detail)
 	}),
 	defineKanboTool({
 		name: "kanbo_wait_approval",
 		title: "Hand the card to a person",
-		description: "Mark the card as waiting for a person and end your turn: `card`, and `text` for the status line the person reads. A person approves or returns it; you will be told the answer.",
+		description: `Mark the card as waiting for a person and end your turn: \`card\`, and \`text\` for the status line the person reads. A person approves or returns it; you will be told the answer. ${WRITTEN_CARD_ANSWER_SENTENCE}`,
 		inputSchema: {
 			card: cardArgument,
-			text: string().min(1).optional().describe("The status line to leave, saying what the person is being asked to look at. Also accepted as `content`.")
+			text: string().min(1).optional().describe("The status line to leave, saying what the person is being asked to look at. Also accepted as `content`."),
+			detail: writtenCardDetailArgument
 		},
 		aliases: { text: ["content"] },
 		example: {
 			card: "TST-5",
 			text: "Ready for review: slugify added with a test"
 		},
-		run: async (transport, input) => await transport.waitApproval(input)
+		run: async (transport, { detail, ...input }) => formatWrittenKanboCard(await transport.waitApproval(input), detail)
 	}),
 	runStartTool,
 	runFinishTool
@@ -25981,7 +26166,7 @@ function describeCardExtras(extras) {
 	})))].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)}  ${comment.author}: ${sanitizeTerminalText(comment.content)}`)].join("\n"));
+		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"));
@@ -26079,10 +26264,11 @@ function registerCardCommands(program) {
 			}, createPlacementActor()));
 		});
 	});
-	withBoardOptions(card.command("update").description("Change a card's title, description, priority or labels").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.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)).action(async (reference, options) => {
+	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.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()));
 		});
 	});
@@ -26223,9 +26409,10 @@ async function presentCard(session, card) {
 	};
 }
 /**
-* The fields `card update` was asked to change. 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.
+* 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 = {};
@@ -26234,7 +26421,7 @@ function readUpdateInput(options) {
 	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) throw new CliError(1, "Nothing to update. Pass --title, --description, --priority, --labels or --execution-mode.");
+	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) {
@@ -42838,6 +43025,7 @@ const COMMAND_SHEET = [
 	"- `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 run start TST-5 --agent claude` — record a run you started yourself; it prints the finish command",
 	"- `kanbo run finish <run id> --state finished` — end it: finished, failed or stopped",
@@ -43965,7 +44153,7 @@ function startUpdateCheck(deps = {}) {
 		setTimeout: globalThis.setTimeout,
 		clearTimeout: globalThis.clearTimeout
 	};
-	const current = deps.currentVersion ?? "0.3.0";
+	const current = deps.currentVersion ?? "0.4.0";
 	const controller = new AbortController();
 	let found = null;
 	const timeout = timers.setTimeout(() => controller.abort(), UPDATE_CHECK_TIMEOUT_MS);
@@ -45287,6 +45475,7 @@ 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)
@@ -46034,7 +46223,7 @@ async function planAgents(projectDir, agents, options) {
 }
 /** The board this project is bound to, and the workspace on it. */
 async function resolveBoard(projectDir, options) {
-	if (options.file !== void 0 || namesNoBoard(projectDir, options)) return await resolveOwnFile(projectDir, options);
+	if (options.file !== void 0 || namesNoBoard$1(projectDir, options)) return await resolveOwnFile(projectDir, options);
 	const target = resolveInitTarget(projectDir, options);
 	if (target.kind === "postgres") return {
 		target,
@@ -46053,7 +46242,7 @@ async function resolveBoard(projectDir, options) {
 * does — a person on a machine with nothing else installed gets a board, not a
 * refusal that names a flag.
 */
-function namesNoBoard(projectDir, options) {
+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;
 }
 /** The workspace a host database — or the board file this project is already bound to — says this project is. */
@@ -46486,6 +46675,7 @@ const KANBO_MCP_INSTRUCTIONS = [
 	`- ${STATUS_LINE_RULE} (${tool("kanbo_status_line")})`,
 	`- ${COMMENT_RULE} (${tool("kanbo_card_comment")})`,
 	`- ${SUBTASK_RULE} (${tool("kanbo_card_create")} with \`parent\`)`,
+	`- 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}`,
 	`- Every tool, rule and canonical string: the resource \`${KANBO_CAPABILITIES_MARKDOWN_RESOURCE_URI}\`.`
@@ -48193,10 +48383,14 @@ async function createDbTransport(input) {
 				executionMode
 			}, actor));
 		},
-		cardUpdate: async ({ card, ...patch }) => {
+		cardUpdate: async ({ card, parent, ...patch }) => {
 			await session.assertWritable();
 			const existing = await resolveCard(card);
-			return await project(await ops.updateCard(existing.id, patch, actor));
+			const placement = parent === void 0 ? {} : { parentIssueId: parent === null ? null : (await resolveCard(parent)).id };
+			return await project(await ops.updateCard(existing.id, {
+				...patch,
+				...placement
+			}, actor));
 		},
 		cardMove: async ({ card, column }) => {
 			await session.assertWritable();
@@ -48350,13 +48544,40 @@ function withUpdateNote(board, peek) {
 }
 //#endregion
 //#region src/cli/commands/mcp.ts
+/**
+* The actor of a `kanbo mcp` session, which is always an agent's: `KANBO_ACTOR_ID`,
+* else the agent tool, else `agent` until the client says its name (see
+* `nameActorAfterClient`).
+*/
+function createMcpActor() {
+	const tool = readAgentTool();
+	const namedByShell = Boolean(process.env.KANBO_ACTOR_ID?.trim() || tool && tool !== "agent");
+	const actor = createCliActor();
+	if (!namedByShell) actor.id = "agent";
+	return {
+		actor,
+		namedByShell
+	};
+}
+/**
+* Files the session's writes under the client's own name (`Test Client` ->
+* `test-client`) once it has initialized. `actor` is the object the board
+* holds, so later writes see the new id.
+*/
+function nameActorAfterClient(server, actor) {
+	server.server.oninitialized = () => {
+		const id = (server.server.getClientVersion()?.name)?.trim().toLowerCase().replace(/\s+/g, "-").slice(0, 40);
+		if (id) actor.id = id;
+	};
+}
 function registerMcpCommand(program) {
 	program.command("mcp").description("Run the board's MCP server for an agent (it starts this itself)").option("--db <path>", "the board file to open").option("--database-url <url>", "a shared Postgres board to use instead of a board file").option("--workspace <nameOrId>", "the project, when this folder is not bound to one").action(async (options) => {
+		const { actor, namedByShell } = createMcpActor();
 		const board = await openMcpBoard({
 			dbPath: options.db,
 			databaseUrl: options.databaseUrl,
 			workspaceId: options.workspace,
-			actor: createCliActor()
+			actor
 		});
 		let closing;
 		const close = () => closing ??= board.close().catch((error) => {
@@ -48365,6 +48586,7 @@ function registerMcpCommand(program) {
 		const check = isUpdateCheckDisabled() ? null : startUpdateCheck();
 		const server = createKanboMcpServer(check ? withUpdateNote(board, check.peek) : board, { includeRunTools: true });
 		server.server.onclose = () => void close();
+		if (!namedByShell) nameActorAfterClient(server, actor);
 		try {
 			await server.connect(new StdioServerTransport());
 		} catch (error) {
@@ -49009,6 +49231,10 @@ const BOARD_ERROR_RESPONSES = {
 		status: 404,
 		message: "Issue not found"
 	},
+	issue_parent_cycle: {
+		status: 400,
+		message: "Issue cannot be put under one of its own sub-issues"
+	},
 	issue_parent_not_found: {
 		status: 404,
 		message: "Parent issue not found"
@@ -49390,10 +49616,20 @@ function toStatusView(status) {
 		entryRules: readEntryRules(status)
 	};
 }
-function toCommentView(comment) {
+function toCommentView(comment, personWriterId = null) {
+	if (comment.authorKind === "system.approved" || comment.authorKind === "system.returned") return {
+		...comment,
+		author: {
+			kind: "user",
+			id: comment.authorId ?? "__self__",
+			displayName: "You",
+			avatarUrl: null,
+			label: null
+		}
+	};
 	return {
 		...comment,
-		author: resolveActor(commentAuthorReference(comment))
+		author: resolveActor(commentAuthorReference(comment), personWriterId)
 	};
 }
 /**
@@ -49401,23 +49637,34 @@ function toCommentView(comment) {
 *
 * For the kinds that need nobody else's tables: an outside writer is shown
 * under the name it gave, the board writing for itself is `kanbo`, and a person
-* is `You`. An agent and a provider target are rows of whatever app launched
+* is `You`. So is an outside writer that is the person who started this
+* server (`personWriterId`): their own writes carry the name their shell files
+* them under. An agent and a provider target are rows of whatever app launched
 * them, which this server cannot read, so they are shown by the id the board
 * holds for them.
 */
-function resolveActor(actor) {
+function resolveActor(actor, personWriterId) {
 	if (actor.kind === "system") {
 		const provenance = {
 			authorId: actor.id,
 			sourceChatSessionId: actor.sourceChatSessionId
 		};
-		if (isOutsideWriter(provenance)) return {
-			kind: "system",
-			id: provenance.authorId,
-			displayName: provenance.authorId,
-			avatarUrl: null,
-			label: "External"
-		};
+		if (isOutsideWriter(provenance)) {
+			if (personWriterId !== null && provenance.authorId === personWriterId) return {
+				kind: "user",
+				id: provenance.authorId,
+				displayName: "You",
+				avatarUrl: null,
+				label: null
+			};
+			return {
+				kind: "system",
+				id: provenance.authorId,
+				displayName: provenance.authorId,
+				avatarUrl: null,
+				label: "External"
+			};
+		}
 		return {
 			kind: "system",
 			id: null,
@@ -49453,13 +49700,13 @@ function resolveActor(actor) {
 * serves, named by its identity; actors as `resolveActor` reads them; and an
 * agent assignee by its id.
 */
-function createActivityResolver(workspace) {
+function createActivityResolver(workspace, personWriterId = null) {
 	return {
 		workspaceById: /* @__PURE__ */ new Map([[workspace.id, {
 			id: workspace.id,
 			name: workspace.name
 		}]]),
-		resolveActor: async (actor) => resolveActor(actor),
+		resolveActor: async (actor) => resolveActor(actor, personWriterId),
 		resolveAgentName: async (agentId) => agentId
 	};
 }
@@ -49480,10 +49727,15 @@ function createActivityResolver(workspace) {
 const OK = { ok: true };
 /** How many cards a search answers with when the caller names no limit. */
 const DEFAULT_SEARCH_LIMIT = 20;
-function createIssueRoutes(session) {
+/**
+* `personWriterId` is the id the person who started the server is filed under;
+* their writes read as `You`, everyone else's by name.
+*/
+function createIssueRoutes(session, options = {}) {
+	const personWriterId = options.personWriterId ?? null;
 	const { ops, store, workspace } = session;
 	const workspaceId = workspace.id;
-	const activityResolver = createActivityResolver(workspace);
+	const activityResolver = createActivityResolver(workspace, personWriterId);
 	/** The served workspace, when that is the one the caller named — or named none. */
 	function requireWorkspace(named) {
 		if (named !== void 0 && named !== workspaceId) throw new BoardError("issue_workspace_not_found", { workspaceId: named });
@@ -49768,6 +50020,15 @@ function createIssueRoutes(session) {
 				return updated;
 			}
 		}),
+		route({
+			method: "GET",
+			path: "/issues/workspace",
+			handle: async () => ({
+				id: workspace.id,
+				identifier: workspace.identifier,
+				name: workspace.name
+			})
+		}),
 		route({
 			method: "GET",
 			path: "/issues/:id",
@@ -49921,7 +50182,7 @@ function createIssueRoutes(session) {
 			path: "/issues/:id/comments",
 			handle: async ({ params }) => {
 				await requireCard(params.id);
-				return (await ops.listComments(params.id)).map(toCommentView);
+				return (await ops.listComments(params.id)).map((comment) => toCommentView(comment, personWriterId));
 			}
 		}),
 		route({
@@ -49934,7 +50195,7 @@ function createIssueRoutes(session) {
 				return toCommentView(await ops.addComment({
 					issueId: params.id,
 					content: body.content
-				}, actors.writer));
+				}, actors.person), personWriterId);
 			}
 		}),
 		route({
@@ -50063,7 +50324,7 @@ function assertServeBinding(host, token) {
 }
 async function startKanboServer(options) {
 	assertServeBinding(options.host, options.token);
-	const routes = createIssueRoutes(options.session);
+	const routes = createIssueRoutes(options.session, { personWriterId: options.actors.writer.id });
 	const listenHost = stripBrackets(options.host);
 	let boundPort = 0;
 	const handle = createRequestHandler(routes, options, () => boundPort);
@@ -50109,6 +50370,11 @@ const SAFE_METHODS = /* @__PURE__ */ new Set([
 	"HEAD",
 	"OPTIONS"
 ]);
+/** What the board page tells the server about itself. */
+const PRESENCE_BODY = object$1({
+	tabId: string().min(1).max(64).regex(/^[A-Za-z0-9-]+$/),
+	state: _enum(["open", "closed"])
+});
 function createRequestHandler(routes, options, boundPort) {
 	const token = options.token || null;
 	const corsOrigins = new Set(options.corsOrigins ?? []);
@@ -50169,17 +50435,41 @@ function createRequestHandler(routes, options, boundPort) {
 				throw new ServeError(401, "unauthorized", "A valid bearer token is required");
 			}
 			if (!SAFE_METHODS.has(request.method ?? "GET") && !isJsonContentType(request.headers["content-type"])) throw new ServeError(415, "unsupported_media_type", "Send the request as content-type: application/json");
-			const matched = matchRoute(routes, request.method ?? "GET", url.pathname);
-			if (!matched) throw new ServeError(404, "not_found", "Not Found");
+			if (url.pathname === "/page/presence" && request.method === "POST") {
+				if (!options.presence) {
+					response.writeHead(204).end();
+					return;
+				}
+				const parsed = PRESENCE_BODY.safeParse(await readJsonBody(request));
+				if (!parsed.success) throw validationError("body", parsed.error);
+				if (parsed.data.state === "open") options.presence.seen(parsed.data.tabId);
+				else options.presence.closed(parsed.data.tabId);
+				sendJson(response, 200, { ok: true });
+				return;
+			}
+			const projectPath = readProjectPath(url.pathname);
+			if (url.pathname === "/projects" && request.method === "GET" && options.projects) {
+				sendJson(response, 200, options.projects.list());
+				return;
+			}
+			const matched = projectPath ? null : matchRoute(routes, request.method ?? "GET", url.pathname);
+			if (!projectPath && !matched) throw new ServeError(404, "not_found", "Not Found");
+			if (projectPath && !options.projects) throw new ServeError(404, "not_found", "Not Found");
 			const body = await readJsonBody(request);
 			const actors = resolveRequestActors(options.actors, {
 				actorHeader: request.headers[ACTOR_HEADER],
 				authenticated: token !== null
 			});
 			const result = queue.then(async () => {
-				if (matched.route.write) await options.session.assertWritable();
-				return await matched.route.run({
-					params: matched.params,
+				const target = projectPath && options.projects ? await options.projects.resolve(projectPath.projectId) : {
+					session: options.session,
+					routes
+				};
+				const found = matched ?? matchRoute(target.routes, request.method ?? "GET", projectPath?.rest ?? url.pathname);
+				if (!found) throw new ServeError(404, "not_found", "Not Found");
+				if (found.route.write) await target.session.assertWritable();
+				return await found.route.run({
+					params: found.params,
 					query: readQuery(url.searchParams),
 					body,
 					actors
@@ -50205,6 +50495,21 @@ function createRequestHandler(routes, options, boundPort) {
 		}
 	};
 }
+/** `/projects/<id>/issues/...` as the project's id and the `/issues/...` path under it; `null` for any other path. */
+function readProjectPath(pathname) {
+	const segments = pathname.split("/").filter(Boolean);
+	if (segments[0] !== "projects" || segments.length < 3 || segments[2] !== "issues") return null;
+	let projectId;
+	try {
+		projectId = decodeURIComponent(segments[1]);
+	} catch {
+		return null;
+	}
+	return {
+		projectId,
+		rest: `/${segments.slice(2).join("/")}`
+	};
+}
 function isJsonContentType(value) {
 	return value?.split(";")[0].trim().toLowerCase() === "application/json";
 }
@@ -50348,6 +50653,146 @@ function readTextOrNull(path) {
 	}
 }
 //#endregion
+//#region src/serve/page-presence.ts
+function createPagePresence(options) {
+	const closedGraceMs = options.closedGraceMs ?? 5e3;
+	const staleMs = options.staleMs ?? 12e4;
+	const tickMs = options.tickMs ?? 1e4;
+	const now = options.now ?? Date.now;
+	const tabs = /* @__PURE__ */ new Map();
+	let finished = false;
+	let graceTimer = null;
+	let lastTick = now();
+	function stop() {
+		finished = true;
+		clearInterval(ticker);
+		if (graceTimer) {
+			clearTimeout(graceTimer);
+			graceTimer = null;
+		}
+	}
+	function idle() {
+		if (finished) return;
+		stop();
+		options.onIdle();
+	}
+	const ticker = setInterval(() => {
+		const current = now();
+		const asleep = current - lastTick > 3 * tickMs;
+		lastTick = current;
+		if (asleep) {
+			for (const id of tabs.keys()) tabs.set(id, current);
+			return;
+		}
+		if (tabs.size === 0) return;
+		for (const [id, lastSeen] of tabs) if (current - lastSeen > staleMs) tabs.delete(id);
+		if (tabs.size === 0) idle();
+	}, tickMs);
+	ticker.unref();
+	return {
+		seen: (tabId) => {
+			if (!finished) tabs.set(tabId, now());
+		},
+		closed: (tabId) => {
+			if (finished || !tabs.delete(tabId) || tabs.size > 0) return;
+			if (graceTimer) clearTimeout(graceTimer);
+			graceTimer = setTimeout(() => {
+				graceTimer = null;
+				if (tabs.size === 0) idle();
+			}, closedGraceMs);
+			graceTimer.unref();
+		},
+		stop
+	};
+}
+//#endregion
+//#region src/serve/projects.ts
+function createServeProjects(input) {
+	const routesOptions = { personWriterId: input.personWriterId ?? null };
+	const opened = /* @__PURE__ */ new Map();
+	let defaultOpened = null;
+	/** Every project that can be offered right now, default first, with the folder each lives in. */
+	function entries() {
+		const defaultDir = input.defaultProject?.dir ?? null;
+		const dirs = [...defaultDir === null ? [] : [defaultDir], ...input.readRegistry().map((project) => project.path).filter((path) => path !== defaultDir)];
+		const found = [];
+		for (const dir of dirs) {
+			const binding = input.readBinding(dir);
+			if (binding === null && dir !== defaultDir) continue;
+			found.push({
+				view: viewOf(dir, binding, dir === defaultDir),
+				dir
+			});
+		}
+		return found;
+	}
+	return {
+		list: () => entries().map((entry) => entry.view),
+		resolve: async (projectId) => {
+			const entry = entries().find((candidate) => candidate.view.id === projectId);
+			if (!entry) throw new ServeError(404, "project_not_found", "No project with that id is on this computer's list");
+			if (entry.view.isDefault && input.defaultProject) {
+				defaultOpened ??= {
+					session: input.defaultProject.session,
+					routes: createIssueRoutes(input.defaultProject.session, routesOptions)
+				};
+				return defaultOpened;
+			}
+			const cached = opened.get(projectId);
+			if (cached) return cached;
+			let session;
+			try {
+				session = await input.openSession(entry.dir);
+			} catch (error) {
+				throw new ServeError(503, "project_unavailable", describeFailure(error).message);
+			}
+			const project = {
+				session,
+				routes: createIssueRoutes(session, routesOptions)
+			};
+			opened.set(projectId, project);
+			return project;
+		},
+		close: async () => {
+			const sessions = [...opened.values()].map((project) => project.session);
+			opened.clear();
+			await Promise.allSettled(sessions.map(async (session) => await session.close()));
+		}
+	};
+}
+function projectId(dir) {
+	return (0, node_crypto.createHash)("sha256").update(dir).digest("hex").slice(0, 12);
+}
+function viewOf(dir, binding, isDefault) {
+	return {
+		id: projectId(dir),
+		name: dir.split(/[\\/]/).filter(Boolean).pop() ?? dir,
+		folder: tildify(dir),
+		storage: storageOf(dir, binding),
+		isDefault
+	};
+}
+/** Where the board lives. The connection string is read here to name its host, and goes no further. */
+function storageOf(dir, binding) {
+	if (binding?.databaseUrl) return {
+		kind: "postgres",
+		where: hostOf(maskDatabaseUrl(binding.databaseUrl))
+	};
+	return {
+		kind: "file",
+		path: tildify((0, node_path.resolve)(dir, binding?.dbPath ?? ".kanbo/board.db"))
+	};
+}
+/** The host of an already masked connection string; a string that is not one names no host. */
+function hostOf(maskedUrl) {
+	try {
+		const { host } = new URL(maskedUrl);
+		return host && !host.includes("*") ? host : "a Postgres database";
+	} catch {
+		return "a Postgres database";
+	}
+}
+//#endregion
 //#region src/cli/commands/serve.ts
 function registerServeCommand(program) {
 	program.command("serve").description("Open the board in your browser").option("--port <port>", "port to listen on", String(DEFAULT_SERVE_PORT)).option("--host <host>", "address to listen on; anything but this computer needs a token", DEFAULT_SERVE_HOST).option("--db <path>", "the board file to open").option("--database-url <url>", "a shared Postgres board to use instead of a board file").option("--workspace <nameOrId>", "the project, when this folder is not bound to one").option("--token <token>", "a password every request must carry (or set KANBO_SERVE_TOKEN); made up for you when left out").option("--cors-origin <origin>", "let pages from this web address call the board; repeat for more", collect, []).option("--no-open", "print the board page link without opening it in the browser").action(async (options) => {
@@ -50355,7 +50800,7 @@ function registerServeCommand(program) {
 			status: (line) => console.error(line),
 			page: (line) => console.log(line)
 		});
-		await waitForInterrupt();
+		if (await waitForStop(running.idle) === "idle") console.error("kanbo serve: the last board tab was closed — stopped.");
 		try {
 			await running.close();
 			process.exit(0);
@@ -50367,26 +50812,46 @@ function registerServeCommand(program) {
 }
 /**
 * Open the board and serve it — everything `kanbo serve` does but wait. The
-* command waits for Ctrl-C and ends the process; the home menu waits for
-* Ctrl-C and comes back to its menu.
+* command waits for Ctrl-C (or the last board tab closing) and ends the
+* process; the home menu waits the same and comes back to its menu.
 */
 async function startServe(options, output) {
 	const port = parsePort(options.port);
 	const access = resolveServeAccess(options.host, options.token?.trim() || process.env.KANBO_SERVE_TOKEN?.trim() || null);
+	const here = findBinding(process.cwd());
+	const mostRecent = here === null && namesNoBoard(options) ? readProjectRegistry()[0] : void 0;
+	const defaultDir = here?.projectDir ?? mostRecent?.path ?? null;
 	const session = await openBoardSession({
 		db: options.db,
 		databaseUrl: options.databaseUrl,
 		workspace: options.workspace
-	}, "read");
+	}, "read", mostRecent?.path);
 	const agentShell = isAgentShell();
 	const actors = {
-		writer: createCliActor(),
+		writer: createServeWriter(),
 		person: agentShell ? null : createPersonActor()
 	};
+	const projects = createServeProjects({
+		defaultProject: defaultDir === null ? null : {
+			dir: defaultDir,
+			session
+		},
+		readRegistry: () => readProjectRegistry(),
+		readBinding: (dir) => readProjectBinding(dir),
+		openSession: async (dir) => await openBoardSession({}, "read", dir),
+		personWriterId: actors.writer.id
+	});
+	const opensBrowser = !agentShell && process.stdout.isTTY === true && options.open;
+	let presence;
+	const idle = new Promise((resolve) => {
+		presence = opensBrowser ? createPagePresence({ onIdle: resolve }) : void 0;
+	});
 	let server;
 	try {
 		server = await startKanboServer({
 			session,
+			projects,
+			presence,
 			actors,
 			host: options.host,
 			port,
@@ -50394,10 +50859,12 @@ async function startServe(options, output) {
 			corsOrigins: options.corsOrigin
 		});
 	} catch (error) {
+		presence?.stop();
 		await session.close();
 		throw error;
 	}
-	output.status(`kanbo serve: ${server.url} — workspace ${session.workspace.id}, bearer token required${access.generated ? " (generated for this run)" : ""}`);
+	const projectCount = projects.list().length;
+	output.status(`kanbo serve: ${server.url} — workspace ${session.workspace.id}, ${projectCount} ${projectCount === 1 ? "project" : "projects"}, bearer token required${access.generated ? " (generated for this run)" : ""}`);
 	output.status(`kanbo serve: ${describePersonRights(actors)}`);
 	presentServePage({
 		url: server.url,
@@ -50411,15 +50878,25 @@ async function startServe(options, output) {
 	});
 	return {
 		link: access.generated ? `${server.url}/#token=${access.token}` : `${server.url}/`,
+		idle,
 		close: async () => {
+			presence?.stop();
 			try {
 				await server.close();
 			} finally {
-				await session.close();
+				try {
+					await projects.close();
+				} finally {
+					await session.close();
+				}
 			}
 		}
 	};
 }
+/** Whether neither a flag nor the environment says which board to open. */
+function namesNoBoard(options) {
+	return !options.db && !options.databaseUrl && !options.workspace && !process.env.KANBO_DB_PATH && !process.env.KANBO_DATABASE_URL && !process.env.KANBO_WORKSPACE_ID;
+}
 /** What `kanbo serve` with no options is told — the home menu serves the board this way. */
 const DEFAULT_SERVE_OPTIONS = {
 	port: String(DEFAULT_SERVE_PORT),
@@ -50427,16 +50904,21 @@ const DEFAULT_SERVE_OPTIONS = {
 	corsOrigin: [],
 	open: true
 };
-/** Settles on the first Ctrl-C (SIGINT) or SIGTERM, and stops listening for both. */
-function waitForInterrupt() {
+/**
+* Settles on the first Ctrl-C (SIGINT) or SIGTERM, or when `idle` settles, and
+* stops listening for both signals whichever it was.
+*/
+function waitForStop(idle) {
 	return new Promise((resolve) => {
-		const stop = () => {
-			process.off("SIGINT", stop);
-			process.off("SIGTERM", stop);
-			resolve();
+		const finish = (why) => {
+			process.off("SIGINT", onSignal);
+			process.off("SIGTERM", onSignal);
+			resolve(why);
 		};
-		process.on("SIGINT", stop);
-		process.on("SIGTERM", stop);
+		const onSignal = () => finish("interrupt");
+		process.on("SIGINT", onSignal);
+		process.on("SIGTERM", onSignal);
+		idle.then(() => finish("idle"));
 	});
 }
 function collect(value, previous) {
@@ -50720,7 +51202,7 @@ const SERVE_FROM_MENU = {
 		status: (line) => console.error(line),
 		page: () => {}
 	}),
-	waitForStop: waitForInterrupt
+	waitForStop: (running) => waitForStop(running.idle)
 };
 /** The `--check` instruction cells that mean a kanbo section is there and readable. */
 const INSTRUCTION_BLOCK_PRESENT = /* @__PURE__ */ new Set([
@@ -50882,7 +51364,7 @@ async function serveUntilStopped(context) {
 	const running = await start();
 	try {
 		say(context.ui, `Board open at ${running.link} — press Ctrl-C to stop and return to the menu`);
-		await waitForStop();
+		await waitForStop(running);
 	} finally {
 		await running.close();
 	}