kanbo-cli 0.3.0 → 0.4.0

package/dist/lib/{manifest-QPoQl8tn.cjs → manifest-DcIMYvWk.cjs}

@@ -77,22 +77,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"
 	}
 ];
 /**
@@ -110,6 +114,15 @@ function readAgentShellMarker(env = process.env) {
 	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";
+}
+/**
 * Every exit code this tool promises, and what it means — the capabilities
 * manifest's `exitCodes` reads this rather than naming the codes again. `0` and
 * `1` are not declared above: they need no name of their own, success and "I
@@ -305,11 +318,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)()
 	};
 }
@@ -347,6 +364,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
@@ -2836,12 +2861,33 @@ async function requireParentInWorkspace(store, workspaceId, parentIssueId, issue
 		issueId,
 		parentIssueId
 	});
-	if (!await store.issues.findInWorkspace(workspaceId, parentIssueId)) throw new require_migrations_path.BoardError("issue_parent_not_found", {
+	const parent = await store.issues.findInWorkspace(workspaceId, parentIssueId);
+	if (!parent) throw new require_migrations_path.BoardError("issue_parent_not_found", {
 		workspaceId,
 		parentIssueId
 	});
+	if (issueId !== void 0 && await isUnder(store, parent, issueId)) throw new require_migrations_path.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);
@@ -3710,62 +3756,6 @@ function createBoardOps(store) {
 	};
 }
 //#endregion
-//#region src/domain/database-url.ts
-/**
-* A board's connection string, as it may be said out loud.
-*
-* Everything a person needs to recognise which board they are talking to is
-* the host and the database name. The password is the one part that must never
-* reach a terminal, a log, a `--json` result or a tool's answer — and it is not
-* the only part: a connection string carries options in its query, and a
-* `?password=…` there is as much a secret as the one in front of the host.
-*
-* It is a fact about the value rather than about the command line, which is why
-* it lives here: the MCP tools hand back messages they did not write either,
-* and they must not be made to carry the board tool's own runtime to say them
-* safely.
-*/
-/** What a connection string is called when there is nothing safe to print of it. */
-const MASKED_UNREADABLE_URL = "postgres://***";
-/** What is printed in place of a password, and of a query that may hide one. */
-const MASK = "***";
-/**
-* A connection string inside a longer line. Anything but whitespace and the
-* quotes a message may wrap it in belongs to the URL — a password is allowed
-* every character a URL is, so the match has to be greedy to be safe.
-*/
-const DATABASE_URL_PATTERN = /\bpostgres(?:ql)?:\/\/[^\s'"`]+/gi;
-/**
-* The connection string with everything secret taken out of it.
-*
-* A string this cannot take apart is not examined to find out why — it is
-* replaced entirely, because whatever is wrong with it, the secret is still
-* somewhere inside. A missing scheme counts as that: `user:secret@host/db`
-* parses, as a `user:` URL whose whole password is in the path, and printing it
-* back would say the secret out loud.
-*/
-function maskDatabaseUrl(url) {
-	try {
-		const parsed = new URL(url);
-		if (!parsed.host) return MASKED_UNREADABLE_URL;
-		if (parsed.password) parsed.password = MASK;
-		if (parsed.search) parsed.search = MASK;
-		return parsed.toString();
-	} catch {
-		return MASKED_UNREADABLE_URL;
-	}
-}
-/**
-* Every connection string inside a line of text, masked.
-*
-* A message this package did not write — a driver's, a migrator's — may carry
-* the whole connection string in the middle of a sentence, and it reaches the
-* same terminal, or the same agent, as everything else.
-*/
-function maskDatabaseUrls(text) {
-	return text.replace(DATABASE_URL_PATTERN, (url) => maskDatabaseUrl(url));
-}
-//#endregion
 //#region src/cli/setup/fs-retry.ts
 /**
 * A file operation tried again while something else holds the file.
@@ -4045,6 +4035,62 @@ function ignoreBoardFile(projectDir, absoluteDbPath) {
 	(0, node_fs.writeFileSync)(path, kept ? `${kept}\n${missing.join("\n")}\n` : `${missing.join("\n")}\n`);
 }
 //#endregion
+//#region src/domain/database-url.ts
+/**
+* A board's connection string, as it may be said out loud.
+*
+* Everything a person needs to recognise which board they are talking to is
+* the host and the database name. The password is the one part that must never
+* reach a terminal, a log, a `--json` result or a tool's answer — and it is not
+* the only part: a connection string carries options in its query, and a
+* `?password=…` there is as much a secret as the one in front of the host.
+*
+* It is a fact about the value rather than about the command line, which is why
+* it lives here: the MCP tools hand back messages they did not write either,
+* and they must not be made to carry the board tool's own runtime to say them
+* safely.
+*/
+/** What a connection string is called when there is nothing safe to print of it. */
+const MASKED_UNREADABLE_URL = "postgres://***";
+/** What is printed in place of a password, and of a query that may hide one. */
+const MASK = "***";
+/**
+* A connection string inside a longer line. Anything but whitespace and the
+* quotes a message may wrap it in belongs to the URL — a password is allowed
+* every character a URL is, so the match has to be greedy to be safe.
+*/
+const DATABASE_URL_PATTERN = /\bpostgres(?:ql)?:\/\/[^\s'"`]+/gi;
+/**
+* The connection string with everything secret taken out of it.
+*
+* A string this cannot take apart is not examined to find out why — it is
+* replaced entirely, because whatever is wrong with it, the secret is still
+* somewhere inside. A missing scheme counts as that: `user:secret@host/db`
+* parses, as a `user:` URL whose whole password is in the path, and printing it
+* back would say the secret out loud.
+*/
+function maskDatabaseUrl(url) {
+	try {
+		const parsed = new URL(url);
+		if (!parsed.host) return MASKED_UNREADABLE_URL;
+		if (parsed.password) parsed.password = MASK;
+		if (parsed.search) parsed.search = MASK;
+		return parsed.toString();
+	} catch {
+		return MASKED_UNREADABLE_URL;
+	}
+}
+/**
+* Every connection string inside a line of text, masked.
+*
+* A message this package did not write — a driver's, a migrator's — may carry
+* the whole connection string in the middle of a sentence, and it reaches the
+* same terminal, or the same agent, as everything else.
+*/
+function maskDatabaseUrls(text) {
+	return text.replace(DATABASE_URL_PATTERN, (url) => maskDatabaseUrl(url));
+}
+//#endregion
 //#region src/cli/db-target.ts
 /**
 * Which board the command works on.
@@ -4293,6 +4339,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 = zod.z.object({
+	path: zod.z.string().min(1),
+	lastSeenAt: zod.z.number().int().nonnegative()
+});
+const RegistrySchema = zod.z.object({
+	schemaVersion: zod.z.literal(1),
+	projects: zod.z.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/cli/schema-guard.ts
 const SCHEMA_OUTDATED_MESSAGE = "The app's database is older than this kanbo. Let the app it belongs to update it first.";
 /** The same, for a board file this package created and migrates itself. */
@@ -4538,15 +4689,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 require_migrate.openBoardDatabase(target.path);
@@ -5431,9 +5584,14 @@ function pageOf(cards, input) {
 }
 /** 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
 	};
@@ -5504,7 +5662,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"));
@@ -5602,10 +5760,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$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)).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$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()));
 		});
 	});
@@ -5746,9 +5905,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 = {};
@@ -5757,7 +5917,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) {
@@ -6027,6 +6187,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"
@@ -6599,7 +6760,7 @@ function readRequestedRules(options) {
 * `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/setup/paths.ts
 /**
@@ -6995,6 +7156,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",
@@ -8080,7 +8242,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);
@@ -9317,6 +9479,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)
@@ -10064,7 +10227,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,
@@ -10083,7 +10246,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. */
@@ -10516,6 +10679,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}\`.`
@@ -10895,61 +11059,6 @@ const cardCommentTool = defineKanboTool({
 	},
 	run: async (transport, input) => await transport.cardComment(input)
 });
-//#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`")}`,
-	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()
-	},
-	example: {
-		description: "Add slugify(text) with a test",
-		parent: "TST-1"
-	},
-	run: async (transport, input) => await transport.cardCreate(input)
-});
-//#endregion
-//#region src/mcp/tools/card-get.ts
-/** One card in full, with what an agent reads next to it. */
-const cardGetTool = defineKanboTool({
-	name: "kanbo_card_get",
-	title: "Read a card",
-	description: `Read one card in full — description, column, status line, whose turn it is, parent (\`parentIssueId\`) — with its last 10 comments and its subtasks (\`subCards\`), in one call. Its runs, field history and pull requests too: include: ["comments","subCards","runs","history","prs"].`,
-	inputSchema: {
-		card: cardArgument,
-		include: zod.z.array(zod.z.enum(KANBO_CARD_INCLUDES)).optional().describe("What to read with the card; [\"comments\",\"subCards\"] when absent, [] for the card alone."),
-		commentLimit: zod.z.number().int().positive().optional().describe(`How many of the latest comments to include; 10 when absent.`)
-	},
-	example: { card: "TST-5" },
-	run: async (transport, input) => await transport.cardGet(input)
-});
-//#endregion
-//#region src/mcp/tools/card-link-pr.ts
-/** A pull request the card's work went into, named on the card so its facts reach it. */
-const cardLinkPrTool = defineKanboTool({
-	name: "kanbo_card_link_pr",
-	title: "Link a pull request to a card",
-	description: "Opened a pull request for this card? Link it here. Its state and CI results then reach the card as comments, without you writing them. Linking the same pull request again changes nothing.",
-	inputSchema: {
-		card: cardArgument,
-		url: zod.z.string().min(1).describe("The pull request, as https://github.com/<owner>/<repo>/pull/<number> or <owner>/<repo>#<number>.")
-	},
-	needs: { url: "the pull request" },
-	example: {
-		card: "TST-5",
-		url: "https://github.com/owner/repo/pull/12"
-	},
-	run: async (transport, input) => await transport.cardLinkPullRequest(input)
-});
 /** The `detail` and `fields` arguments the list tools share. */
 const cardListViewArguments = {
 	detail: zod.z.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."),
@@ -10988,6 +11097,20 @@ 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 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);
@@ -11011,6 +11134,62 @@ function formatKanboCardPage(page, view, returned) {
 	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. */
+const cardGetTool = defineKanboTool({
+	name: "kanbo_card_get",
+	title: "Read a card",
+	description: `Read one card in full — description, column, status line, whose turn it is, parent (\`parentIssueId\`) — with its last 10 comments and its subtasks (\`subCards\`), in one call. Its runs, field history and pull requests too: include: ["comments","subCards","runs","history","prs"].`,
+	inputSchema: {
+		card: cardArgument,
+		include: zod.z.array(zod.z.enum(KANBO_CARD_INCLUDES)).optional().describe("What to read with the card; [\"comments\",\"subCards\"] when absent, [] for the card alone."),
+		commentLimit: zod.z.number().int().positive().optional().describe(`How many of the latest comments to include; 10 when absent.`)
+	},
+	example: { card: "TST-5" },
+	run: async (transport, input) => await transport.cardGet(input)
+});
+//#endregion
+//#region src/mcp/tools/card-link-pr.ts
+/** A pull request the card's work went into, named on the card so its facts reach it. */
+const cardLinkPrTool = defineKanboTool({
+	name: "kanbo_card_link_pr",
+	title: "Link a pull request to a card",
+	description: "Opened a pull request for this card? Link it here. Its state and CI results then reach the card as comments, without you writing them. Linking the same pull request again changes nothing.",
+	inputSchema: {
+		card: cardArgument,
+		url: zod.z.string().min(1).describe("The pull request, as https://github.com/<owner>/<repo>/pull/<number> or <owner>/<repo>#<number>.")
+	},
+	needs: { url: "the pull request" },
+	example: {
+		card: "TST-5",
+		url: "https://github.com/owner/repo/pull/12"
+	},
+	run: async (transport, input) => await transport.cardLinkPullRequest(input)
+});
 /** The cards on the board a question picks, one page of them. */
 const cardListTool = defineKanboTool({
 	name: "kanbo_card_list",
@@ -11065,10 +11244,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: zod.z.string().min(1).describe("The column to move it to, by its slug or name: in_progress, \"In Progress\". Also accepted as `to`.")
+		column: zod.z.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" },
@@ -11076,7 +11256,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
@@ -11091,11 +11271,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: zod.z.string().min(1).optional().describe("What the card is called."),
@@ -11108,18 +11288,26 @@ const cardUpdateTool = defineKanboTool({
 			"urgent"
 		]).optional(),
 		labels: zod.z.array(zod.z.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
@@ -11256,10 +11444,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: zod.z.string().min(1).describe("One sentence, present tense, about what is happening on the card right now. Also accepted as `content`.")
+			text: zod.z.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" },
@@ -11267,22 +11456,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: zod.z.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: zod.z.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
@@ -11483,10 +11673,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();
@@ -11640,13 +11834,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) => {
@@ -11655,6 +11876,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 _modelcontextprotocol_sdk_server_stdio_js.StdioServerTransport());
 		} catch (error) {
@@ -12299,6 +12521,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"
@@ -12680,10 +12906,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)
 	};
 }
 /**
@@ -12691,23 +12927,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,
@@ -12743,13 +12990,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
 	};
 }
@@ -12770,10 +13017,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 require_migrations_path.BoardError("issue_workspace_not_found", { workspaceId: named });
@@ -13058,6 +13310,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",
@@ -13211,7 +13472,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({
@@ -13224,7 +13485,7 @@ function createIssueRoutes(session) {
 				return toCommentView(await ops.addComment({
 					issueId: params.id,
 					content: body.content
-				}, actors.writer));
+				}, actors.person), personWriterId);
 			}
 		}),
 		route({
@@ -13353,7 +13614,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);
@@ -13399,6 +13660,11 @@ const SAFE_METHODS = /* @__PURE__ */ new Set([
 	"HEAD",
 	"OPTIONS"
 ]);
+/** What the board page tells the server about itself. */
+const PRESENCE_BODY = zod.z.object({
+	tabId: zod.z.string().min(1).max(64).regex(/^[A-Za-z0-9-]+$/),
+	state: zod.z.enum(["open", "closed"])
+});
 function createRequestHandler(routes, options, boundPort) {
 	const token = options.token || null;
 	const corsOrigins = new Set(options.corsOrigins ?? []);
@@ -13459,17 +13725,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
@@ -13495,6 +13785,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";
 }
@@ -13638,6 +13943,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) => {
@@ -13645,7 +14090,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);
@@ -13657,26 +14102,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,
@@ -13684,10 +14149,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,
@@ -13701,25 +14168,40 @@ 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();
+				}
 			}
 		}
 	};
 }
-/** Settles on the first Ctrl-C (SIGINT) or SIGTERM, and stops listening for both. */
-function waitForInterrupt() {
+/** 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;
+}
+/**
+* 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) {
@@ -14043,7 +14525,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>" },