kanbo-cli 0.2.1 → 0.4.0

package/dist/lib/mcp/index.mjs

@@ -1,5 +1,5 @@
-import { G as normalizeStatusName, _ as projectKanboPullRequest, b as projectKanboSubCard, c as registerKanboTools, d as KANBO_MCP_INSTRUCTIONS, f as KANBO_CAPABILITIES_MARKDOWN_RESOURCE_URI, g as projectKanboColumn, h as projectKanboCard, i as KANBO_TOOL_NAMES, l as KANBO_TOOLS, m as registerKanboCapabilitiesResources, o as KANBO_MCP_SERVER_NAME, p as KANBO_CAPABILITIES_RESOURCE_URI, r as KANBO_TOOL_CLI_EQUIVALENTS, s as createKanboMcpServer, u as buildKanboTools, v as projectKanboRun, y as projectKanboSprint } from "../manifest-DHV2fRdO.mjs";
-import { a as BoardError } from "../migrations-path-Ciwan537.mjs";
+import { A as projectKanboSprint, C as pageOf, D as projectKanboFieldChange, E as projectKanboColumn, O as projectKanboPullRequest, S as matchesKanboCardQuery, T as projectKanboCardComment, b as DEFAULT_KANBO_COMMENT_LIMIT, c as registerKanboTools, d as KANBO_MCP_INSTRUCTIONS, f as KANBO_CAPABILITIES_MARKDOWN_RESOURCE_URI, i as KANBO_TOOL_NAMES, it as normalizeStatusName, j as projectKanboSubCard, k as projectKanboRun, l as KANBO_TOOLS, m as registerKanboCapabilitiesResources, o as KANBO_MCP_SERVER_NAME, p as KANBO_CAPABILITIES_RESOURCE_URI, r as KANBO_TOOL_CLI_EQUIVALENTS, s as createKanboMcpServer, st as previewComment, u as buildKanboTools, w as projectKanboCard, x as KANBO_CARD_INCLUDES, y as DEFAULT_KANBO_CARD_INCLUDES } from "../manifest-Dmo6IlWk.mjs";
+import { a as BoardError } from "../migrations-path-ClaYRNwk.mjs";
 import { z } from "zod";
 //#region src/mcp/http-transport.ts
 const IssueSchema = z.object({
@@ -87,6 +87,32 @@ const SprintSchema = z.object({
 	})
 });
 const PrimeSchema = z.object({ text: z.string() });
+const ACTOR_KINDS = [
+	"user",
+	"agent",
+	"provider-target",
+	"system"
+];
+/** A comment as the server lists it; who wrote it by the stored kind, `system.*` markers included. */
+const CardCommentSchema = z.object({
+	id: z.string(),
+	authorKind: z.string(),
+	authorId: z.string().nullish(),
+	sourceChatSessionId: z.string().nullish(),
+	content: z.string(),
+	createdAt: z.number()
+}).transform((row) => ({
+	...row,
+	authorId: row.authorId ?? null,
+	sourceChatSessionId: row.sourceChatSessionId ?? null
+}));
+const FieldChangeSchema = z.object({
+	field: z.string(),
+	fromValue: z.string().nullable(),
+	toValue: z.string().nullable(),
+	actorKind: z.enum(ACTOR_KINDS),
+	createdAt: z.number()
+});
 function createHttpTransport(input) {
 	const { request } = input;
 	async function readColumns() {
@@ -110,36 +136,135 @@ function createHttpTransport(input) {
 		});
 		return column;
 	}
+	async function listCards(filters) {
+		const query = new URLSearchParams({
+			workspaceId: input.workspaceId(),
+			...filters
+		});
+		return z.array(IssueSchema).parse(await request("GET", `/issues/?${query.toString()}`));
+	}
+	/**
+	* The cards a query picks. A server of the `/issues` routes filters on one
+	* column and on a parent, and no more; the rest of the query is applied here,
+	* to the cards it answered with, so the answer is the one the board file gives.
+	*
+	* The server filters on a parent's id only, and an agent may name the parent
+	* the way it names any card — `WOR-001`, `WOR-1`, `1`. The id is asked first;
+	* when no card answers it, the board is read whole to learn which card the
+	* reference names, and a reference that names none is refused as `issue_not_found`.
+	*/
+	async function cardPage(cardQuery) {
+		const columns = await readColumns();
+		const statusIds = cardQuery.columns === void 0 ? null : new Set(cardQuery.columns.map((column) => requireColumn(columns, column).id));
+		const filters = statusIds?.size === 1 ? { statusId: [...statusIds][0] } : {};
+		let parent = cardQuery.parent;
+		let rows = await listCards(parent === void 0 ? filters : {
+			...filters,
+			parentIssueId: parent
+		});
+		if (parent !== void 0 && rows.length === 0) {
+			const board = await listCards({});
+			const named = findCardRow(board, parent);
+			if (!named) throw new BoardError("issue_not_found", { issueId: parent });
+			parent = named.id;
+			rows = board;
+		}
+		const matched = rows.filter((row) => matchesKanboCardQuery(row, {
+			...cardQuery,
+			parent,
+			returned: void 0
+		}, statusIds));
+		const picked = cardQuery.returned === void 0 ? matched : (await withAttention(matched)).filter((row) => matchesKanboCardQuery(row, cardQuery, null));
+		const offset = cardQuery.offset ?? 0;
+		return {
+			cards: (await withAttention(picked.slice(offset, cardQuery.limit === void 0 ? void 0 : offset + cardQuery.limit))).map((row) => projectKanboCard(row, columns)),
+			total: picked.length,
+			offset
+		};
+	}
+	/**
+	* The cards with what a list says beside the ones a person has to look at or
+	* sent back — their comments read one card at a time, since the route lists
+	* none, and only for cards that are waiting, or neither waiting nor running.
+	*/
+	async function withAttention(rows) {
+		return await Promise.all(rows.map(async (row) => {
+			if (row.attention || row.waitingFor !== "human" && row.activeRun !== null) return row;
+			const comments = z.array(CardCommentSchema).parse(await request("GET", `/issues/${encodeURIComponent(row.id)}/comments`));
+			const decision = comments.filter((comment) => comment.authorKind === "system.approved" || comment.authorKind === "system.returned").at(-1);
+			const returned = row.waitingFor !== "human" && decision?.authorKind === "system.returned";
+			const latest = comments.filter((comment) => comment.authorKind !== "system.run").at(-1);
+			const lastComment = (row.waitingFor === "human" || returned) && latest ? previewComment({
+				...latest,
+				authorKind: latest.authorKind
+			}) : null;
+			return {
+				...row,
+				attention: {
+					returned,
+					lastComment
+				}
+			};
+		}));
+	}
+	/** The ready cards, a page of them; the server answers the whole queue. */
+	async function readyPage({ returnedLimit, ...page }) {
+		const query = new URLSearchParams({ workspaceId: input.workspaceId() });
+		const cards = z.array(IssueSchema).parse(await request("GET", `/issues/ready?${query.toString()}`));
+		const columns = await readColumns();
+		const offset = page.offset ?? 0;
+		const ready = {
+			cards: cards.slice(offset, page.limit === void 0 ? void 0 : offset + page.limit).map((row) => projectKanboCard(row, columns)),
+			total: cards.length,
+			offset
+		};
+		return returnedLimit === void 0 ? ready : {
+			...ready,
+			returned: await cardPage({
+				returned: true,
+				limit: returnedLimit
+			})
+		};
+	}
 	return {
 		prime: async () => PrimeSchema.parse(await request("GET", `/issues/prime?workspaceId=${encodeURIComponent(input.workspaceId())}`)),
-		ready: async ({ limit }) => {
-			const query = new URLSearchParams({ workspaceId: input.workspaceId() });
-			if (limit !== void 0) query.set("limit", String(limit));
-			const cards = z.array(IssueSchema).parse(await request("GET", `/issues/ready?${query.toString()}`));
-			const columns = await readColumns();
-			return cards.map((row) => projectKanboCard(row, columns));
-		},
+		ready: async ({ limit }) => (await readyPage({ limit })).cards,
+		readyPage,
 		columns: readColumns,
 		sprints: async () => z.array(SprintSchema).parse(await request("GET", `/issues/sprints?workspaceId=${encodeURIComponent(input.workspaceId())}`)).map(projectKanboSprint),
-		cardGet: async ({ card }) => {
+		cardGet: async ({ card, include = DEFAULT_KANBO_CARD_INCLUDES, commentLimit = 10 }) => {
 			const found = IssueSchema.parse(await request("GET", `/issues/${encodeURIComponent(card)}`));
-			const columns = await readColumns();
+			const wants = new Set(include);
+			const path = `/issues/${encodeURIComponent(found.id)}`;
 			const query = new URLSearchParams({
 				workspaceId: input.workspaceId(),
 				parentIssueId: found.id
 			});
-			const subCards = z.array(IssueSchema).parse(await request("GET", `/issues/?${query.toString()}`));
+			const [columns, subCards, comments, runs, history, pullRequests] = await Promise.all([
+				readColumns(),
+				wants.has("subCards") ? request("GET", `/issues/?${query.toString()}`).then((rows) => z.array(IssueSchema).parse(rows)) : null,
+				wants.has("comments") ? request("GET", `${path}/comments`).then((rows) => z.array(CardCommentSchema).parse(rows)) : null,
+				wants.has("runs") ? request("GET", `${path}/runs`).then((rows) => z.array(RunSchema).parse(rows)) : null,
+				wants.has("history") ? request("GET", `${path}/field-changes`).then((rows) => z.array(FieldChangeSchema).parse(rows)) : null,
+				wants.has("prs") ? request("GET", `${path}/pull-requests`).then((rows) => z.array(PullRequestSchema).parse(rows)) : null
+			]);
 			return {
 				...projectKanboCard(found, columns),
-				subCards: subCards.map((row) => projectKanboSubCard(row, columns))
+				...subCards ? { subCards: subCards.map((row) => projectKanboSubCard(row, columns)) } : {},
+				...comments ? {
+					comments: comments.slice(-commentLimit).map(projectKanboCardComment),
+					commentCount: comments.length
+				} : {},
+				...runs ? { runs: runs.map(projectKanboRun) } : {},
+				...history ? { history: history.map(projectKanboFieldChange) } : {},
+				...pullRequests ? { pullRequests: pullRequests.map(projectKanboPullRequest) } : {}
 			};
 		},
-		cardList: async ({ column, limit }) => {
-			const columns = await readColumns();
-			const query = new URLSearchParams({ workspaceId: input.workspaceId() });
-			if (column) query.set("statusId", requireColumn(columns, column).id);
-			return z.array(IssueSchema).parse(await request("GET", `/issues/?${query.toString()}`)).slice(0, limit ?? Number.POSITIVE_INFINITY).map((row) => projectKanboCard(row, columns));
-		},
+		cardList: async ({ column, limit }) => (await cardPage({
+			columns: column ? [column] : void 0,
+			limit
+		})).cards,
+		cardPage,
 		cardCreate: async ({ title, description, column, parent, executionMode }) => await projectOne(await request("POST", "/issues/", {
 			workspaceId: input.workspaceId(),
 			...title !== void 0 ? { title } : {},
@@ -148,7 +273,10 @@ function createHttpTransport(input) {
 			...parent !== void 0 ? { parentIssueId: parent } : {},
 			...executionMode !== void 0 ? { executionMode } : {}
 		})),
-		cardUpdate: async ({ card, ...patch }) => await projectOne(await request("PATCH", `/issues/${encodeURIComponent(card)}`, patch)),
+		cardUpdate: async ({ card, parent, ...patch }) => await projectOne(await request("PATCH", `/issues/${encodeURIComponent(card)}`, {
+			...patch,
+			...parent !== void 0 ? { parentIssueId: parent } : {}
+		})),
 		cardMove: async ({ card, column }) => await projectOne(await request("PATCH", `/issues/${encodeURIComponent(card)}/status/${encodeURIComponent(column)}`)),
 		cardComment: async ({ card, content }) => CommentSchema.parse(await request("POST", `/issues/${encodeURIComponent(card)}/comments`, { content })),
 		cardLinkPullRequest: async ({ card, url }) => projectKanboPullRequest(PullRequestSchema.parse(await request("POST", `/issues/${encodeURIComponent(card)}/pull-requests`, { url }))),
@@ -167,7 +295,18 @@ function createHttpTransport(input) {
 		})))
 	};
 }
+/**
+* The card a reference names among cards already read, the way the board file
+* resolves one: its id, its number, or its key without the padding (`WOR-1`).
+*/
+function findCardRow(rows, reference) {
+	const trimmed = reference.trim();
+	const byId = rows.find((row) => row.id === trimmed);
+	if (byId) return byId;
+	const key = /^(?:(.+)-)?(\d+)$/.exec(trimmed);
+	if (!key) return;
+	const [, prefix, digits] = key;
+	return rows.find((row) => row.number === Number(digits) && (prefix === void 0 || row.id.slice(0, row.id.lastIndexOf("-")).toUpperCase() === prefix.toUpperCase()));
+}
 //#endregion
-export { KANBO_CAPABILITIES_MARKDOWN_RESOURCE_URI, KANBO_CAPABILITIES_RESOURCE_URI, KANBO_MCP_INSTRUCTIONS, KANBO_MCP_SERVER_NAME, KANBO_TOOLS, KANBO_TOOL_CLI_EQUIVALENTS, KANBO_TOOL_NAMES, buildKanboTools, createHttpTransport, createKanboMcpServer, registerKanboCapabilitiesResources, registerKanboTools };
-
-//# sourceMappingURL=index.mjs.map
+export { DEFAULT_KANBO_CARD_INCLUDES, DEFAULT_KANBO_COMMENT_LIMIT, KANBO_CAPABILITIES_MARKDOWN_RESOURCE_URI, KANBO_CAPABILITIES_RESOURCE_URI, KANBO_CARD_INCLUDES, KANBO_MCP_INSTRUCTIONS, KANBO_MCP_SERVER_NAME, KANBO_TOOLS, KANBO_TOOL_CLI_EQUIVALENTS, KANBO_TOOL_NAMES, buildKanboTools, createHttpTransport, createKanboMcpServer, matchesKanboCardQuery, pageOf, registerKanboCapabilitiesResources, registerKanboTools };

package/dist/lib/{migrate-DnMjTCvu.cjs → migrate-Dca5WdYd.cjs}

@@ -1,4 +1,4 @@
-const require_migrations_path = require("./migrations-path-CZxVOgeD.cjs");
+const require_migrations_path = require("./migrations-path-DBCE17dT.cjs");
 const require_sqlite_schema = require("./sqlite/schema.cjs");
 let drizzle_orm = require("drizzle-orm");
 let drizzle_orm_sqlite_core = require("drizzle-orm/sqlite-core");
@@ -6,6 +6,17 @@ let node_module = require("node:module");
 let node_path = require("node:path");
 let node_url = require("node:url");
 let drizzle_orm_better_sqlite3_migrator = require("drizzle-orm/better-sqlite3/migrator");
+//#region src/domain/fold-case.ts
+/**
+* Text as a search compares it: every letter lowercased by Unicode's rules, not
+* only A–Z — `Über` and `über` are one word. What Postgres `ilike` does on
+* either side of a board search; SQLite's own `like` folds ASCII alone, so a
+* board file compares through this function instead (`kanbo_fold`).
+*/
+function foldCase(text) {
+	return text.toLowerCase();
+}
+//#endregion
 //#region src/sqlite/transaction.ts
 /**
 * The better-sqlite3 handle Drizzle keeps beside the query builder. `drizzle()`
@@ -162,6 +173,82 @@ function selectRunProjection(database, scope) {
 	}));
 }
 /**
+* One page of the cards a query picks, and how many it picks in all, in one
+* statement: `count(*) over ()` is taken over every picked row before `limit`
+* and `offset` cut the page out of them. Only a page past the last card — no
+* row to carry the count — asks a second time.
+*/
+function selectCardPage(database, query) {
+	if (query.statusIds?.length === 0 || query.priorities?.length === 0) return {
+		cards: [],
+		total: 0
+	};
+	if (query.text !== void 0) registerFoldFunction(database);
+	const where = (0, drizzle_orm.and)(...cardQueryPredicates(query));
+	const rows = database.select({
+		...(0, drizzle_orm.getTableColumns)(require_sqlite_schema.issues),
+		pickedTotal: drizzle_orm.sql`count(*) over ()`
+	}).from(require_sqlite_schema.issues).where(where).orderBy(require_sqlite_schema.issues.order, (0, drizzle_orm.desc)(require_sqlite_schema.issues.createdAt), require_sqlite_schema.issues.id).limit(query.limit ?? Number.MAX_SAFE_INTEGER).offset(query.offset ?? 0).all();
+	if (rows.length === 0) return {
+		cards: [],
+		total: (query.offset ?? 0) > 0 ? database.select({ count: drizzle_orm.sql`count(*)` }).from(require_sqlite_schema.issues).where(where).get()?.count ?? 0 : 0
+	};
+	return {
+		cards: rows.map(({ pickedTotal: _total, ...card }) => card),
+		total: rows[0].pickedTotal
+	};
+}
+/** The connections `kanbo_fold` is registered on already. */
+const foldingConnections = /* @__PURE__ */ new WeakSet();
+/**
+* Teach the connection `kanbo_fold(text)`, the search's `foldCase`, once.
+*
+* SQLite's `like` and `lower()` fold A–Z and nothing else, so `über` would not
+* find `Über` on a board file while Postgres `ilike` and the HTTP transport find
+* it. The function is registered on the connection the statement runs on —
+* the host may have opened it, not this package — and stays one statement.
+*/
+function registerFoldFunction(database) {
+	const connection = readSqliteConnection(database);
+	if (foldingConnections.has(connection)) return;
+	connection.function("kanbo_fold", { deterministic: true }, (value) => typeof value === "string" ? foldCase(value) : value);
+	foldingConnections.add(connection);
+}
+function cardQueryPredicates(query) {
+	const running = drizzle_orm.sql`${require_sqlite_schema.issues.id} in (select ${require_sqlite_schema.issueRuns.issueId} from ${require_sqlite_schema.issueRuns} where ${require_sqlite_schema.issueRuns.state} = 'running')`;
+	const text = foldCase(query.text ?? "");
+	return [
+		(0, drizzle_orm.eq)(require_sqlite_schema.issues.workspaceId, query.workspaceId),
+		query.statusIds === void 0 ? void 0 : (0, drizzle_orm.inArray)(require_sqlite_schema.issues.statusId, [...query.statusIds]),
+		query.waitingForPerson === void 0 ? void 0 : query.waitingForPerson ? (0, drizzle_orm.eq)(require_sqlite_schema.issues.waitingFor, "human") : (0, drizzle_orm.isNull)(require_sqlite_schema.issues.waitingFor),
+		query.parentIssueId === void 0 ? void 0 : (0, drizzle_orm.eq)(require_sqlite_schema.issues.parentIssueId, query.parentIssueId),
+		query.hasActiveRun === void 0 ? void 0 : query.hasActiveRun ? running : drizzle_orm.sql`not ${running}`,
+		query.returned === void 0 ? void 0 : query.returned ? returnedCard(running) : drizzle_orm.sql`not ${returnedCard(running)}`,
+		query.text === void 0 ? void 0 : drizzle_orm.sql`(instr(kanbo_fold(${require_sqlite_schema.issues.id}), ${text}) > 0 or instr(kanbo_fold(${require_sqlite_schema.issues.title}), ${text}) > 0 or instr(kanbo_fold(coalesce(${require_sqlite_schema.issues.description}, '')), ${text}) > 0)`,
+		query.updatedSince === void 0 ? void 0 : (0, drizzle_orm.gte)(require_sqlite_schema.issues.updatedAt, query.updatedSince),
+		...(query.labels ?? []).map((label) => drizzle_orm.sql`exists (select 1 from json_each(${require_sqlite_schema.issues.labels}) where value = ${label})`),
+		query.priorities === void 0 ? void 0 : (0, drizzle_orm.inArray)(require_sqlite_schema.issues.priority, [...query.priorities])
+	];
+}
+/**
+* A card a person sent back that nobody picked up again (`BoardCardQuery.returned`):
+* not waiting, not running, and its last decision a return — no approval or
+* return written after it, `rowid` breaking a tie inside one second the way
+* `readApproval`'s comment order does.
+*/
+function returnedCard(running) {
+	return drizzle_orm.sql`(${require_sqlite_schema.issues.waitingFor} is null and not ${running} and exists (
+    select 1 from ${require_sqlite_schema.issueComments} as decision
+    where decision.issue_id = ${require_sqlite_schema.issues.id} and decision.author_kind = 'system.returned'
+      and not exists (
+        select 1 from ${require_sqlite_schema.issueComments} as later
+        where later.issue_id = decision.issue_id
+          and later.author_kind in ('system.approved', 'system.returned')
+          and (later.created_at > decision.created_at or (later.created_at = decision.created_at and later.rowid > decision.rowid))
+      )
+  ))`;
+}
+/**
 * Bind the store's statements to one SQLite handle. `resolveDatabase` is called
 * per statement rather than captured, so the store follows a host that swaps its
 * database out (a server that resets its infrastructure between tests, say).
@@ -173,6 +260,7 @@ function createSqliteBoardStoreCore(resolveDatabase) {
 			listAllInBoardOrder: () => resolveDatabase().select().from(require_sqlite_schema.issueStatuses).orderBy(require_sqlite_schema.issueStatuses.workspaceId, require_sqlite_schema.issueStatuses.order).all(),
 			listAll: () => resolveDatabase().select().from(require_sqlite_schema.issueStatuses).all(),
 			findById: (statusId) => resolveDatabase().select().from(require_sqlite_schema.issueStatuses).where((0, drizzle_orm.eq)(require_sqlite_schema.issueStatuses.id, statusId)).get() ?? null,
+			lockById: (statusId) => resolveDatabase().select().from(require_sqlite_schema.issueStatuses).where((0, drizzle_orm.eq)(require_sqlite_schema.issueStatuses.id, statusId)).get() ?? null,
 			findInWorkspace: (workspaceId, statusId) => resolveDatabase().select().from(require_sqlite_schema.issueStatuses).where(drizzle_orm.sql`${require_sqlite_schema.issueStatuses.workspaceId} = ${workspaceId} AND ${require_sqlite_schema.issueStatuses.id} = ${statusId}`).get() ?? null,
 			countByWorkspace: (workspaceId) => {
 				return resolveDatabase().select({ count: drizzle_orm.sql`count(*)` }).from(require_sqlite_schema.issueStatuses).where((0, drizzle_orm.eq)(require_sqlite_schema.issueStatuses.workspaceId, workspaceId)).get()?.count ?? 0;
@@ -205,11 +293,17 @@ function createSqliteBoardStoreCore(resolveDatabase) {
 		issues: {
 			listInBoardOrder: (workspaceId) => {
 				const predicates = [workspaceId ? (0, drizzle_orm.eq)(require_sqlite_schema.issues.workspaceId, workspaceId) : void 0].filter((predicate) => predicate !== void 0);
-				return resolveDatabase().select().from(require_sqlite_schema.issues).where(predicates.length > 0 ? (0, drizzle_orm.and)(...predicates) : void 0).orderBy(require_sqlite_schema.issues.order, (0, drizzle_orm.desc)(require_sqlite_schema.issues.createdAt)).all();
+				return resolveDatabase().select().from(require_sqlite_schema.issues).where(predicates.length > 0 ? (0, drizzle_orm.and)(...predicates) : void 0).orderBy(require_sqlite_schema.issues.order, (0, drizzle_orm.desc)(require_sqlite_schema.issues.createdAt), require_sqlite_schema.issues.id).all();
 			},
 			listNewestFirst: () => resolveDatabase().select().from(require_sqlite_schema.issues).orderBy((0, drizzle_orm.desc)(require_sqlite_schema.issues.createdAt)).all(),
 			listAll: () => resolveDatabase().select().from(require_sqlite_schema.issues).all(),
 			listByWorkspace: (workspaceId) => resolveDatabase().select().from(require_sqlite_schema.issues).where((0, drizzle_orm.eq)(require_sqlite_schema.issues.workspaceId, workspaceId)).all(),
+			listPage: (query) => selectCardPage(resolveDatabase(), query),
+			countByMilestone: (workspaceId) => resolveDatabase().select({
+				milestoneId: drizzle_orm.sql`${require_sqlite_schema.issues.milestoneId}`,
+				statusId: require_sqlite_schema.issues.statusId,
+				count: drizzle_orm.sql`count(*)`
+			}).from(require_sqlite_schema.issues).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issues.workspaceId, workspaceId), (0, drizzle_orm.isNotNull)(require_sqlite_schema.issues.milestoneId))).groupBy(require_sqlite_schema.issues.milestoneId, require_sqlite_schema.issues.statusId).all(),
 			listByIds: (issueIds) => resolveDatabase().select().from(require_sqlite_schema.issues).where((0, drizzle_orm.inArray)(require_sqlite_schema.issues.id, issueIds)).all(),
 			findById: (issueId) => resolveDatabase().select().from(require_sqlite_schema.issues).where((0, drizzle_orm.eq)(require_sqlite_schema.issues.id, issueId)).get() ?? null,
 			findInWorkspace: (workspaceId, issueId) => resolveDatabase().select().from(require_sqlite_schema.issues).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issues.id, issueId), (0, drizzle_orm.eq)(require_sqlite_schema.issues.workspaceId, workspaceId))).get() ?? null,
@@ -248,6 +342,15 @@ function createSqliteBoardStoreCore(resolveDatabase) {
 		},
 		comments: {
 			listByIssue: (issueId) => resolveDatabase().select().from(require_sqlite_schema.issueComments).where((0, drizzle_orm.eq)(require_sqlite_schema.issueComments.issueId, issueId)).orderBy((0, drizzle_orm.asc)(require_sqlite_schema.issueComments.createdAt), COMMENT_INSERTION_ORDER).all(),
+			listLatestByIssues: (issueIds, authorKinds) => {
+				if (issueIds.length === 0 || authorKinds?.length === 0) return [];
+				const database = resolveDatabase();
+				const ranked = database.select({
+					id: require_sqlite_schema.issueComments.id,
+					commentRank: drizzle_orm.sql`row_number() over (partition by ${require_sqlite_schema.issueComments.issueId} order by ${require_sqlite_schema.issueComments.createdAt} desc, ${require_sqlite_schema.issueComments}.rowid desc)`.as("comment_rank")
+				}).from(require_sqlite_schema.issueComments).where((0, drizzle_orm.and)((0, drizzle_orm.inArray)(require_sqlite_schema.issueComments.issueId, [...issueIds]), authorKinds === void 0 ? void 0 : (0, drizzle_orm.inArray)(require_sqlite_schema.issueComments.authorKind, [...authorKinds]))).as("ranked");
+				return database.select((0, drizzle_orm.getTableColumns)(require_sqlite_schema.issueComments)).from(require_sqlite_schema.issueComments).innerJoin(ranked, (0, drizzle_orm.eq)(ranked.id, require_sqlite_schema.issueComments.id)).where((0, drizzle_orm.eq)(ranked.commentRank, 1)).all();
+			},
 			findById: (commentId) => resolveDatabase().select().from(require_sqlite_schema.issueComments).where((0, drizzle_orm.eq)(require_sqlite_schema.issueComments.id, commentId)).get() ?? null,
 			findByDedupeKey: (issueId, dedupeKey) => resolveDatabase().select().from(require_sqlite_schema.issueComments).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issueComments.issueId, issueId), (0, drizzle_orm.eq)(require_sqlite_schema.issueComments.dedupeKey, dedupeKey))).get() ?? null,
 			listByDedupeKeyPrefix: (issueId, prefix) => resolveDatabase().select().from(require_sqlite_schema.issueComments).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issueComments.issueId, issueId), drizzle_orm.sql`substr(${require_sqlite_schema.issueComments.dedupeKey}, 1, ${prefix.length}) = ${prefix}`)).orderBy((0, drizzle_orm.asc)(require_sqlite_schema.issueComments.createdAt), COMMENT_INSERTION_ORDER).all(),
@@ -354,6 +457,7 @@ function createSqliteBoardStore(options) {
 			listAllInBoardOrder: async () => core.statuses.listAllInBoardOrder(),
 			listAll: async () => core.statuses.listAll(),
 			findById: async (statusId) => core.statuses.findById(statusId),
+			lockById: async (statusId) => core.statuses.lockById(statusId),
 			findInWorkspace: async (workspaceId, statusId) => core.statuses.findInWorkspace(workspaceId, statusId),
 			countByWorkspace: async (workspaceId) => core.statuses.countByWorkspace(workspaceId),
 			create: async (values) => core.statuses.create(values),
@@ -375,6 +479,8 @@ function createSqliteBoardStore(options) {
 			listNewestFirst: async () => core.issues.listNewestFirst(),
 			listAll: async () => core.issues.listAll(),
 			listByWorkspace: async (workspaceId) => core.issues.listByWorkspace(workspaceId),
+			listPage: async (query) => core.issues.listPage(query),
+			countByMilestone: async (workspaceId) => core.issues.countByMilestone(workspaceId),
 			listByIds: async (issueIds) => core.issues.listByIds(issueIds),
 			findById: async (issueId) => core.issues.findById(issueId),
 			findInWorkspace: async (workspaceId, issueId) => core.issues.findInWorkspace(workspaceId, issueId),
@@ -391,6 +497,7 @@ function createSqliteBoardStore(options) {
 		},
 		comments: {
 			listByIssue: async (issueId) => core.comments.listByIssue(issueId),
+			listLatestByIssues: async (issueIds, authorKinds) => core.comments.listLatestByIssues(issueIds, authorKinds),
 			findById: async (commentId) => core.comments.findById(commentId),
 			findByDedupeKey: async (issueId, dedupeKey) => core.comments.findByDedupeKey(issueId, dedupeKey),
 			listByDedupeKeyPrefix: async (issueId, prefix) => core.comments.listByDedupeKeyPrefix(issueId, prefix),
@@ -448,25 +555,35 @@ function createSqliteBoardStore(options) {
 	};
 	return store;
 }
+/** The logger a board handle is opened with: the counter while one is on, otherwise none. */
+function boardQueryLogger() {}
 //#endregion
 //#region src/sqlite/open-database.ts
 const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
 /** The tables a board file must already carry for this package to read it. */
 const REQUIRED_BOARD_TABLES = ["issue_runs", "kanban_meta"];
-/** What a caller is told when the native module a board file needs is not installed. */
-const BETTER_SQLITE3_MISSING_MESSAGE = "Install better-sqlite3 to use a board file";
 /**
-* `better-sqlite3` is an optional peer dependency (ruling 5): a Postgres-only
-* or capabilities-only install carries no native module, and importing
-* `kanbo/sqlite` for a type or for `runSqliteTransaction` should not
-* demand one either. So the require happens here, the one place a board file
-* is actually opened, rather than at the top of this module.
+* What a caller is told when the native module a board file needs does not
+* load: which Node, system and processor it was tried on — a prebuilt module
+* exists for most, not all — what the loader said, and how to get it back.
+*/
+function betterSqlite3MissingMessage(cause) {
+	const said = cause instanceof Error ? cause.message.split("\n")[0] : String(cause);
+	return `Could not load better-sqlite3, which kanbo opens board files with, on Node ${process.version} (${process.platform}-${process.arch}): ${said}. Reinstall kanbo with npm install -g kanbo-cli, which brings it along; a program that uses kanbo as a library installs better-sqlite3 itself.`;
+}
+/**
+* `better-sqlite3` is an optional dependency (ruling 5): an install where it
+* could not be built carries no native module, and a Postgres-only or
+* capabilities-only use — or importing `kanbo/sqlite` for a type or for
+* `runSqliteTransaction` — should not demand one. So the require happens here,
+* the one place a board file is actually opened, rather than at the top of
+* this module.
 */
 function loadBetterSqlite3() {
 	try {
 		return require$1("better-sqlite3");
 	} catch (error) {
-		throw new Error(BETTER_SQLITE3_MISSING_MESSAGE, { cause: error });
+		throw new Error(betterSqlite3MissingMessage(error), { cause: error });
 	}
 }
 /**
@@ -479,7 +596,7 @@ function loadBetterSqlite3() {
 * this module, `kanbo capabilities` and `kanbo/mcp` included, and the
 * friendly message above becomes unreachable. A dynamic import keeps the whole
 * chain behind the one call that actually opens a file, which is what makes the
-* optional peer honest. `createRequire` would be the smaller change and is the
+* optional dependency honest. `createRequire` would be the smaller change and is the
 * wrong one: it would load drizzle's CJS copy beside the ESM one this package
 * already holds, and it would resolve from `node_modules`, which the packaged
 * `dist/cli.cjs` deliberately does not have beside it.
@@ -512,7 +629,10 @@ async function openBoardDatabase(path) {
 	connection.pragma("busy_timeout = 5000");
 	connection.pragma("synchronous = NORMAL");
 	return {
-		database: drizzle(connection, { schema: require_sqlite_schema.boardSqliteSchema }),
+		database: drizzle(connection, {
+			schema: require_sqlite_schema.boardSqliteSchema,
+			logger: void 0
+		}),
 		connection,
 		close: () => connection.close()
 	};
@@ -657,12 +777,24 @@ Object.defineProperty(exports, "assertBoardSchema", {
 		return assertBoardSchema;
 	}
 });
+Object.defineProperty(exports, "boardQueryLogger", {
+	enumerable: true,
+	get: function() {
+		return boardQueryLogger;
+	}
+});
 Object.defineProperty(exports, "createSqliteBoardStore", {
 	enumerable: true,
 	get: function() {
 		return createSqliteBoardStore;
 	}
 });
+Object.defineProperty(exports, "foldCase", {
+	enumerable: true,
+	get: function() {
+		return foldCase;
+	}
+});
 Object.defineProperty(exports, "getBoardSqliteMigrationsPath", {
 	enumerable: true,
 	get: function() {
@@ -705,5 +837,3 @@ Object.defineProperty(exports, "runSqliteTransaction", {
 		return runSqliteTransaction;
 	}
 });
-
-//# sourceMappingURL=migrate-DnMjTCvu.cjs.map