kanbo-cli 0.1.0

package/dist/lib/roles.sql-CvyCGt38.mjs

@@ -0,0 +1,920 @@
+import { a as BoardError, i as BOARD_TABLES_ADDED_WITHIN_EPOCH, n as resolveBoardMigrationsPath, t as hasMigrationJournal } from "./migrations-path-Ciwan537.mjs";
+import { and, asc, desc, eq, getTableColumns, inArray, isNotNull, or, sql } from "drizzle-orm";
+import { bigint, bigserial, getTableConfig, index, integer, pgSchema, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/postgres/schema.ts
+/**
+* The board, as a Postgres database holds it.
+*
+* This is the same logical schema as `src/sqlite/schema.ts` — same column
+* names, same nullability, same enum members, same index names — written for a
+* second dialect rather than a second design. The store reads and writes both
+* through one `BoardStore` interface, so anything that drifts here shows up as
+* a card that reads differently depending on where its board lives.
+*
+* Two deliberate differences from the SQLite file:
+*
+* - **Unix seconds are `bigint`, read as `number`.** SQLite stores them in an
+*   `integer` wide enough for them; Postgres's `integer` is 32-bit, and
+*   `mode: 'number'` keeps the value a JavaScript number so the store hands
+*   `ops` and `domain` exactly what the SQLite store hands them.
+* - **`seq` on `issue_runs`, `issue_comments`, `issue_field_changes` and
+*   `issue_pull_requests`.**
+*   SQLite orders those four by `rowid` — insertion order, which two rows
+*   written in the same second still separate. Postgres has no `rowid`, and its
+*   heap order is free to change (a row written last can land in the slot a
+*   deleted one freed), so the board carries its own order: a `bigserial` those
+*   queries order by, and the only columns here that have no SQLite
+*   counterpart.
+*
+* What used to be a third difference is one no longer: `workspace_id`,
+* `delegate_agent_id`, `delegate_provider_target_id` and
+* `source_chat_session_id` are plain text here *and* in the file (ruling 5-1),
+* because a database holding only the board was never the only home without a
+* `workspaces` table to point at.
+*
+* `labels` and `context_refs` stay `text` holding JSON rather than becoming
+* `jsonb`: they are encoded and decoded above the store, and a second
+* representation would be a second thing to keep in step for nothing.
+*/
+/** `unixepoch()` in the dialect that has no such function. */
+const unixNow = sql`(extract(epoch from now())::bigint)`;
+const textPk = () => text("id").primaryKey();
+const createdAt = () => ({ createdAt: bigint("created_at", { mode: "number" }).notNull().default(unixNow) });
+const timestamps = () => ({
+	...createdAt(),
+	updatedAt: bigint("updated_at", { mode: "number" }).notNull().default(unixNow)
+});
+const issueStatuses = pgTable("issue_statuses", {
+	id: textPk(),
+	workspaceId: text("workspace_id").notNull(),
+	name: text("name").notNull(),
+	description: text("description"),
+	color: text("color"),
+	category: text("category", { enum: [
+		"triage",
+		"backlog",
+		"unstarted",
+		"started",
+		"completed",
+		"canceled"
+	] }).notNull().default("unstarted"),
+	order: integer("order").notNull().default(0),
+	/** A JSON array of `ENTRY_RULES`, or `null` for none — see the SQLite schema. */
+	entryRules: text("entry_rules"),
+	...createdAt()
+}, (table) => [index("issue_statuses_workspace_id_idx").on(table.workspaceId), uniqueIndex("issue_statuses_workspace_name_unique").on(table.workspaceId, table.name)]);
+const issueMilestones = pgTable("issue_milestones", {
+	id: textPk(),
+	workspaceId: text("workspace_id").notNull(),
+	title: text("title").notNull(),
+	description: text("description"),
+	/** When the milestone, read as a sprint, begins (unix seconds); null for a plain milestone. */
+	startDate: bigint("start_date", { mode: "number" }),
+	dueDate: bigint("due_date", { mode: "number" }),
+	status: text("status", { enum: ["open", "closed"] }).notNull().default("open"),
+	...timestamps()
+}, (table) => [index("issue_milestones_workspace_id_idx").on(table.workspaceId)]);
+const issues = pgTable("issues", {
+	id: textPk(),
+	workspaceId: text("workspace_id").notNull(),
+	number: integer("number").notNull(),
+	statusId: text("status_id").references(() => issueStatuses.id, { onDelete: "set null" }),
+	milestoneId: text("milestone_id").references(() => issueMilestones.id, { onDelete: "set null" }),
+	parentIssueId: text("parent_issue_id").references(() => issues.id, { onDelete: "set null" }),
+	title: text("title").notNull(),
+	description: text("description"),
+	priority: text("priority", { enum: [
+		"none",
+		"low",
+		"medium",
+		"high",
+		"urgent"
+	] }).notNull().default("none"),
+	labels: text("labels").notNull().default("[]"),
+	assigneeKind: text("assignee_kind"),
+	assigneeId: text("assignee_id"),
+	dueDate: bigint("due_date", { mode: "number" }),
+	createdByKind: text("created_by_kind", { enum: [
+		"user",
+		"agent",
+		"system",
+		"provider-target"
+	] }).notNull().default("user"),
+	createdById: text("created_by_id").notNull().default("__self__"),
+	sourceChatSessionId: text("source_chat_session_id"),
+	delegateAgentId: text("delegate_agent_id"),
+	delegateProviderTargetId: text("delegate_provider_target_id"),
+	contextRefs: text("context_refs").notNull().default("[]"),
+	statusLine: text("status_line"),
+	waitingFor: text("waiting_for", { enum: ["human"] }),
+	executionMode: text("execution_mode", { enum: ["worktree", "main"] }).notNull().default("worktree"),
+	order: integer("order").notNull().default(0),
+	...timestamps()
+}, (table) => [
+	index("issues_workspace_id_idx").on(table.workspaceId),
+	uniqueIndex("issues_workspace_number_unique").on(table.workspaceId, table.number),
+	index("issues_status_id_idx").on(table.statusId),
+	index("issues_milestone_id_idx").on(table.milestoneId),
+	index("issues_parent_issue_id_idx").on(table.parentIssueId),
+	index("issues_delegate_agent_id_idx").on(table.delegateAgentId),
+	index("issues_delegate_provider_target_id_idx").on(table.delegateProviderTargetId)
+]);
+const issueComments = pgTable("issue_comments", {
+	id: textPk(),
+	issueId: text("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+	content: text("content").notNull(),
+	authorKind: text("author_kind", { enum: [
+		"user",
+		"agent",
+		"provider-target",
+		"system",
+		"system.delegated",
+		"system.undelegated",
+		"system.run",
+		"system.approved",
+		"system.returned",
+		"system.pr"
+	] }).notNull().default("user"),
+	authorId: text("author_id"),
+	sourceChatSessionId: text("source_chat_session_id"),
+	agentActivityId: text("agent_activity_id"),
+	dedupeKey: text("dedupe_key"),
+	...createdAt(),
+	/** Insertion order, standing in for the `rowid` the SQLite board orders comments by. */
+	seq: bigserial("seq", { mode: "number" }).notNull()
+}, (table) => [index("issue_comments_issue_id_idx").on(table.issueId), uniqueIndex("issue_comments_issue_dedupe_idx").on(table.issueId, table.dedupeKey)]);
+const issueRuns = pgTable("issue_runs", {
+	id: textPk(),
+	issueId: text("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+	launchedByKind: text("launched_by_kind", { enum: [
+		"user",
+		"agent",
+		"external"
+	] }).notNull().default("user"),
+	launchedById: text("launched_by_id"),
+	agentId: text("agent_id"),
+	agentName: text("agent_name").notNull(),
+	host: text("host"),
+	executionMode: text("execution_mode", { enum: ["worktree", "main"] }).notNull().default("worktree"),
+	branch: text("branch"),
+	worktreePath: text("worktree_path"),
+	state: text("state", { enum: [
+		"running",
+		"finished",
+		"failed",
+		"stopped"
+	] }).notNull().default("running"),
+	chatSessionId: text("chat_session_id"),
+	/** Where an external agent's own log of this run lives — `claude:<id>` or `codex:<id>` (ruling 7-1), `null` when it never said. */
+	externalSessionRef: text("external_session_ref"),
+	startedAt: bigint("started_at", { mode: "number" }).notNull().default(unixNow),
+	endedAt: bigint("ended_at", { mode: "number" }),
+	/** Insertion order, standing in for the `rowid` the SQLite board orders runs by. */
+	seq: bigserial("seq", { mode: "number" }).notNull()
+}, (table) => [
+	index("issue_runs_issue_id_idx").on(table.issueId),
+	index("issue_runs_issue_state_idx").on(table.issueId, table.state),
+	index("issue_runs_chat_session_idx").on(table.chatSessionId)
+]);
+const issueRelations = pgTable("issue_relations", {
+	id: textPk(),
+	sourceIssueId: text("source_issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+	targetIssueId: text("target_issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+	type: text("type", { enum: [
+		"blocks",
+		"duplicates",
+		"relates_to"
+	] }).notNull(),
+	...createdAt()
+}, (table) => [
+	index("issue_relations_source_issue_id_idx").on(table.sourceIssueId),
+	index("issue_relations_target_issue_id_idx").on(table.targetIssueId),
+	uniqueIndex("issue_relations_pair_type_unique").on(table.sourceIssueId, table.targetIssueId, table.type)
+]);
+const issueFieldChanges = pgTable("issue_field_changes", {
+	id: textPk(),
+	issueId: text("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+	field: text("field").notNull(),
+	fromValue: text("from_value"),
+	toValue: text("to_value"),
+	actorKind: text("actor_kind", { enum: [
+		"user",
+		"agent",
+		"provider-target",
+		"system"
+	] }).notNull().default("user"),
+	actorId: text("actor_id"),
+	sourceChatSessionId: text("source_chat_session_id"),
+	...createdAt(),
+	/** Insertion order, standing in for the `rowid` the SQLite board orders changes by. */
+	seq: bigserial("seq", { mode: "number" }).notNull()
+}, (table) => [index("issue_field_changes_issue_id_idx").on(table.issueId)]);
+/** A pull request someone said belongs to a card — see the SQLite twin for what the row is and is not. */
+const issuePullRequests = pgTable("issue_pull_requests", {
+	id: textPk(),
+	issueId: text("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+	owner: text("owner").notNull(),
+	repo: text("repo").notNull(),
+	number: integer("number").notNull(),
+	url: text("url").notNull(),
+	createdByKind: text("created_by_kind", { enum: [
+		"user",
+		"agent",
+		"provider-target",
+		"system"
+	] }).notNull(),
+	createdById: text("created_by_id"),
+	...createdAt(),
+	/** Insertion order, standing in for the `rowid` the SQLite board orders a card's links by. */
+	seq: bigserial("seq", { mode: "number" }).notNull()
+}, (table) => [uniqueIndex("issue_pull_requests_issue_pr_unique").on(table.issueId, table.owner, table.repo, table.number), index("issue_pull_requests_pr_idx").on(table.owner, table.repo, table.number)]);
+/**
+* The counters the board keeps for its readers, exactly as the SQLite file
+* keeps them: `board` is bumped once per write transaction that changed
+* something, and `schema_epoch` records the generation the board was created
+* with.
+*/
+const kanbanMeta = pgTable("kanban_meta", {
+	key: text("key").primaryKey(),
+	revision: integer("revision").notNull().default(0),
+	updatedAt: bigint("updated_at", { mode: "number" }).notNull().default(unixNow)
+});
+/** Every table of the board, in the order a reader of the schema wants them. */
+const boardPostgresSchema = {
+	issueStatuses,
+	issueMilestones,
+	issues,
+	issueComments,
+	issueRuns,
+	issueRelations,
+	issueFieldChanges,
+	issuePullRequests,
+	kanbanMeta
+};
+/** The table names a Postgres board must carry, for the guard that refuses a database without them. */
+const BOARD_POSTGRES_TABLES = [
+	"issue_statuses",
+	"issue_milestones",
+	"issues",
+	"issue_comments",
+	"issue_runs",
+	"issue_relations",
+	"issue_field_changes",
+	"issue_pull_requests",
+	"kanban_meta"
+];
+//#endregion
+//#region src/postgres/board-store.postgres.ts
+/**
+* The run without `seq`.
+*
+* `seq` is this dialect's answer to SQLite's `rowid` — the board's own record of
+* which of two runs started in the same second was written first. It is a fact
+* about the storage rather than about the run, so it is taken off here instead
+* of leaking into a type shared with a board that has no such column.
+*/
+function toIssueRun({ seq: _seq, ...run }) {
+	return run;
+}
+/** The comment without `seq`, for the same reason a run is handed over without it. */
+function toIssueComment({ seq: _seq, ...comment }) {
+	return comment;
+}
+/** The field change without `seq`, for the same reason. */
+function toIssueFieldChange({ seq: _seq, ...change }) {
+	return change;
+}
+/** The pull-request link without `seq`, for the same reason. */
+function toIssuePullRequest({ seq: _seq, ...link }) {
+	return link;
+}
+/** A link with its card's workspace, without `seq`. */
+function toLinkedPullRequest({ seq: _seq, ...link }) {
+	return link;
+}
+/**
+* The run facts of every card in scope, in one statement.
+*
+* The same shape as the SQLite store's: `count(*)` counts the card's runs on
+* every one of its rows and `row_number()` ranks them — a `running` run first,
+* then the newest start, then the row written last — so reading only rank 1
+* leaves one row per card. Two differences from the file, both dialect: the
+* tie-break reads `seq` where SQLite reads `rowid`, and both window counters are
+* cast to `int` because Postgres counts in `bigint`, which a driver is free to
+* hand back as a string.
+*/
+async function selectRunProjection(database, scope) {
+	if ("issueIds" in scope && scope.issueIds.length === 0) return [];
+	const cards = "workspaceId" in scope ? inArray(issueRuns.issueId, database.select({ id: issues.id }).from(issues).where(eq(issues.workspaceId, scope.workspaceId))) : inArray(issueRuns.issueId, scope.issueIds);
+	const ranked = database.select({
+		issueId: issueRuns.issueId,
+		attemptCount: sql`cast(count(*) over (partition by ${issueRuns.issueId}) as int)`.as("attempt_count"),
+		id: issueRuns.id,
+		agentId: issueRuns.agentId,
+		agentName: issueRuns.agentName,
+		state: issueRuns.state,
+		branch: issueRuns.branch,
+		executionMode: issueRuns.executionMode,
+		chatSessionId: issueRuns.chatSessionId,
+		startedAt: issueRuns.startedAt,
+		cardRank: sql`cast(row_number() over (partition by ${issueRuns.issueId} order by (${issueRuns.state} = 'running') desc, ${issueRuns.startedAt} desc, ${issueRuns.seq} desc) as int)`.as("card_rank")
+	}).from(issueRuns).where(cards).as("ranked");
+	return (await database.select({
+		issueId: ranked.issueId,
+		attemptCount: ranked.attemptCount,
+		id: ranked.id,
+		agentId: ranked.agentId,
+		agentName: ranked.agentName,
+		state: ranked.state,
+		branch: ranked.branch,
+		executionMode: ranked.executionMode,
+		chatSessionId: ranked.chatSessionId,
+		startedAt: ranked.startedAt
+	}).from(ranked).where(eq(ranked.cardRank, 1))).map((row) => ({
+		issueId: row.issueId,
+		attemptCount: row.attemptCount,
+		activeRun: row.state === "running" ? {
+			id: row.id,
+			agentId: row.agentId,
+			agentName: row.agentName,
+			state: row.state,
+			branch: row.branch,
+			executionMode: row.executionMode,
+			chatSessionId: row.chatSessionId,
+			startedAt: row.startedAt
+		} : null
+	}));
+}
+/**
+* The board's statements against one Postgres handle — a connection, or a
+* transaction on one.
+*
+* `transaction` builds a second store over the transactional handle drizzle
+* hands it, which is the one structural difference from the SQLite store: there
+* a single connection *is* the transaction, so the store hands back itself.
+*/
+function createStoreOver(database) {
+	return {
+		statuses: {
+			listByWorkspace: async (workspaceId) => await database.select().from(issueStatuses).where(eq(issueStatuses.workspaceId, workspaceId)).orderBy(issueStatuses.order),
+			listAllInBoardOrder: async () => await database.select().from(issueStatuses).orderBy(issueStatuses.workspaceId, issueStatuses.order),
+			listAll: async () => await database.select().from(issueStatuses),
+			findById: async (statusId) => {
+				const [row] = await database.select().from(issueStatuses).where(eq(issueStatuses.id, statusId)).limit(1);
+				return row ?? null;
+			},
+			findInWorkspace: async (workspaceId, statusId) => {
+				const [row] = await database.select().from(issueStatuses).where(and(eq(issueStatuses.workspaceId, workspaceId), eq(issueStatuses.id, statusId))).limit(1);
+				return row ?? null;
+			},
+			countByWorkspace: async (workspaceId) => {
+				const [row] = await database.select({ count: sql`cast(count(*) as int)` }).from(issueStatuses).where(eq(issueStatuses.workspaceId, workspaceId));
+				return row?.count ?? 0;
+			},
+			create: async (values) => {
+				const [row] = await database.insert(issueStatuses).values(values).returning();
+				return row;
+			},
+			update: async (statusId, patch) => {
+				await database.update(issueStatuses).set(patch).where(eq(issueStatuses.id, statusId));
+			},
+			delete: async (statusId) => {
+				await database.delete(issueStatuses).where(eq(issueStatuses.id, statusId));
+			}
+		},
+		milestones: {
+			listNewestFirst: async (workspaceId) => await database.select().from(issueMilestones).where(workspaceId ? eq(issueMilestones.workspaceId, workspaceId) : void 0).orderBy(desc(issueMilestones.createdAt)),
+			listByWorkspace: async (workspaceId) => await database.select().from(issueMilestones).where(eq(issueMilestones.workspaceId, workspaceId)),
+			listAll: async () => await database.select().from(issueMilestones),
+			findById: async (milestoneId) => {
+				const [row] = await database.select().from(issueMilestones).where(eq(issueMilestones.id, milestoneId)).limit(1);
+				return row ?? null;
+			},
+			findInWorkspace: async (workspaceId, milestoneId) => {
+				const [row] = await database.select().from(issueMilestones).where(and(eq(issueMilestones.id, milestoneId), eq(issueMilestones.workspaceId, workspaceId))).limit(1);
+				return row ?? null;
+			},
+			create: async (values) => {
+				const [row] = await database.insert(issueMilestones).values(values).returning();
+				return row;
+			},
+			update: async (milestoneId, patch) => {
+				await database.update(issueMilestones).set(patch).where(eq(issueMilestones.id, milestoneId));
+			},
+			delete: async (milestoneId) => {
+				await database.delete(issueMilestones).where(eq(issueMilestones.id, milestoneId));
+			}
+		},
+		issues: {
+			listInBoardOrder: async (workspaceId) => await database.select().from(issues).where(workspaceId ? eq(issues.workspaceId, workspaceId) : void 0).orderBy(issues.order, desc(issues.createdAt)),
+			listNewestFirst: async () => await database.select().from(issues).orderBy(desc(issues.createdAt)),
+			listAll: async () => await database.select().from(issues),
+			listByWorkspace: async (workspaceId) => await database.select().from(issues).where(eq(issues.workspaceId, workspaceId)),
+			listByIds: async (issueIds) => await database.select().from(issues).where(inArray(issues.id, issueIds)),
+			findById: async (issueId) => {
+				const [row] = await database.select().from(issues).where(eq(issues.id, issueId)).limit(1);
+				return row ?? null;
+			},
+			findInWorkspace: async (workspaceId, issueId) => {
+				const [row] = await database.select().from(issues).where(and(eq(issues.id, issueId), eq(issues.workspaceId, workspaceId))).limit(1);
+				return row ?? null;
+			},
+			findByNumber: async (workspaceId, number) => {
+				const [row] = await database.select().from(issues).where(and(eq(issues.workspaceId, workspaceId), eq(issues.number, number))).limit(1);
+				return row ?? null;
+			},
+			maxNumber: async (workspaceId) => {
+				const [row] = await database.select({ maxNumber: sql`cast(coalesce(max(${issues.number}), 0) as int)` }).from(issues).where(eq(issues.workspaceId, workspaceId));
+				return row?.maxNumber ?? 0;
+			},
+			maxOrder: async (workspaceId) => {
+				const [row] = await database.select({ maxOrder: sql`cast(coalesce(max(${issues.order}), 0) as int)` }).from(issues).where(eq(issues.workspaceId, workspaceId));
+				return row?.maxOrder ?? 0;
+			},
+			/**
+			* The one insert the board expects to be refused sometimes.
+			*
+			* Two writers can pick the same card number, and the unique index turns
+			* the loser's insert into an error that the numbering answers by reading
+			* the board again. Postgres refuses to read anything from a transaction a
+			* statement has failed in, so this insert runs inside a savepoint of its
+			* own: when it is refused, the savepoint rolls back and the caller's
+			* transaction is still there to be read. A board in a file needs nothing
+			* of the sort — SQLite leaves a transaction usable after a failed
+			* statement — which is why this lives in the store and not in `ops`.
+			*/
+			create: async (values) => {
+				const [row] = await database.transaction(async (tx) => await tx.insert(issues).values(values).returning());
+				return row;
+			},
+			update: async (issueId, patch) => {
+				await database.update(issues).set(patch).where(eq(issues.id, issueId));
+			},
+			updateMany: async (issueIds, patch) => {
+				if (issueIds.length === 0) return 0;
+				return (await database.update(issues).set(patch).where(inArray(issues.id, issueIds)).returning({ id: issues.id })).length;
+			},
+			clearMilestoneReferences: async (milestoneId, updatedAt) => {
+				await database.update(issues).set({
+					milestoneId: null,
+					updatedAt
+				}).where(eq(issues.milestoneId, milestoneId));
+			},
+			clearParentReferences: async (parentIssueId, updatedAt) => {
+				await database.update(issues).set({
+					parentIssueId: null,
+					updatedAt
+				}).where(eq(issues.parentIssueId, parentIssueId));
+			},
+			clearDelegateReferences: async (delegate, updatedAt) => {
+				return (await database.update(issues).set({
+					delegateAgentId: null,
+					delegateProviderTargetId: null,
+					updatedAt
+				}).where("agentId" in delegate ? eq(issues.delegateAgentId, delegate.agentId) : eq(issues.delegateProviderTargetId, delegate.providerTargetId)).returning({ id: issues.id })).length;
+			},
+			delete: async (issueId) => {
+				await database.delete(issues).where(eq(issues.id, issueId));
+			}
+		},
+		comments: {
+			listByIssue: async (issueId) => (await database.select().from(issueComments).where(eq(issueComments.issueId, issueId)).orderBy(asc(issueComments.createdAt), asc(issueComments.seq))).map(toIssueComment),
+			findById: async (commentId) => {
+				const [row] = await database.select().from(issueComments).where(eq(issueComments.id, commentId)).limit(1);
+				return row ? toIssueComment(row) : null;
+			},
+			findByDedupeKey: async (issueId, dedupeKey) => {
+				const [row] = await database.select().from(issueComments).where(and(eq(issueComments.issueId, issueId), eq(issueComments.dedupeKey, dedupeKey))).limit(1);
+				return row ? toIssueComment(row) : null;
+			},
+			listByDedupeKeyPrefix: async (issueId, prefix) => (await database.select().from(issueComments).where(and(eq(issueComments.issueId, issueId), sql`starts_with(${issueComments.dedupeKey}, ${prefix})`)).orderBy(asc(issueComments.createdAt), asc(issueComments.seq))).map(toIssueComment),
+			create: async (values) => {
+				const [row] = await database.insert(issueComments).values(values).returning();
+				return toIssueComment(row);
+			},
+			createOnce: async (values) => {
+				const [inserted] = await database.insert(issueComments).values(values).onConflictDoNothing().returning();
+				if (inserted) return toIssueComment(inserted);
+				const [existing] = await database.select().from(issueComments).where(and(eq(issueComments.issueId, values.issueId), eq(issueComments.dedupeKey, values.dedupeKey))).limit(1);
+				if (!existing) throw new Error(`issue comment for ${values.issueId} was refused, and no comment carries dedupe key ${values.dedupeKey}`);
+				return toIssueComment(existing);
+			},
+			delete: async (commentId) => {
+				await database.delete(issueComments).where(eq(issueComments.id, commentId));
+			}
+		},
+		runs: {
+			listByIssue: async (issueId) => (await database.select().from(issueRuns).where(eq(issueRuns.issueId, issueId)).orderBy(asc(issueRuns.startedAt), asc(issueRuns.seq))).map(toIssueRun),
+			listRunning: async (issueId) => (await database.select().from(issueRuns).where(and(eq(issueRuns.issueId, issueId), eq(issueRuns.state, "running"))).orderBy(asc(issueRuns.startedAt), asc(issueRuns.seq))).map(toIssueRun),
+			listRunningWithSession: async () => (await database.select().from(issueRuns).where(and(eq(issueRuns.state, "running"), isNotNull(issueRuns.chatSessionId))).orderBy(asc(issueRuns.startedAt), asc(issueRuns.seq))).map(toIssueRun),
+			findById: async (runId) => {
+				const [row] = await database.select().from(issueRuns).where(eq(issueRuns.id, runId)).limit(1);
+				return row ? toIssueRun(row) : null;
+			},
+			findByChatSessionId: async (chatSessionId) => {
+				const [row] = await database.select().from(issueRuns).where(eq(issueRuns.chatSessionId, chatSessionId)).orderBy(desc(issueRuns.startedAt), desc(issueRuns.seq)).limit(1);
+				return row ? toIssueRun(row) : null;
+			},
+			countByIssue: async (issueId) => {
+				const [row] = await database.select({ count: sql`cast(count(*) as int)` }).from(issueRuns).where(eq(issueRuns.issueId, issueId));
+				return row?.count ?? 0;
+			},
+			create: async (values) => {
+				const [row] = await database.insert(issueRuns).values(values).returning();
+				return toIssueRun(row);
+			},
+			update: async (runId, patch) => {
+				await database.update(issueRuns).set(patch).where(eq(issueRuns.id, runId));
+			},
+			project: async (scope) => await selectRunProjection(database, scope)
+		},
+		relations: {
+			listByIssue: async (issueId) => await database.select().from(issueRelations).where(or(eq(issueRelations.sourceIssueId, issueId), eq(issueRelations.targetIssueId, issueId))),
+			findById: async (relationId) => {
+				const [row] = await database.select().from(issueRelations).where(eq(issueRelations.id, relationId)).limit(1);
+				return row ?? null;
+			},
+			findMatching: async (edge) => {
+				const [row] = await database.select().from(issueRelations).where(and(eq(issueRelations.type, edge.type), edge.type === "relates_to" ? or(and(eq(issueRelations.sourceIssueId, edge.sourceIssueId), eq(issueRelations.targetIssueId, edge.targetIssueId)), and(eq(issueRelations.sourceIssueId, edge.targetIssueId), eq(issueRelations.targetIssueId, edge.sourceIssueId))) : and(eq(issueRelations.sourceIssueId, edge.sourceIssueId), eq(issueRelations.targetIssueId, edge.targetIssueId)))).limit(1);
+				return row ?? null;
+			},
+			create: async (values) => {
+				const [row] = await database.insert(issueRelations).values(values).returning();
+				return row;
+			},
+			delete: async (relationId) => {
+				await database.delete(issueRelations).where(eq(issueRelations.id, relationId));
+			},
+			deleteByIssue: async (issueId) => {
+				await database.delete(issueRelations).where(or(eq(issueRelations.sourceIssueId, issueId), eq(issueRelations.targetIssueId, issueId)));
+			}
+		},
+		contextRefs: { replace: async (issueId, contextRefs, updatedAt) => {
+			await database.update(issues).set({
+				contextRefs,
+				updatedAt
+			}).where(eq(issues.id, issueId));
+		} },
+		fieldChanges: {
+			listByIssue: async (issueId) => (await database.select().from(issueFieldChanges).where(eq(issueFieldChanges.issueId, issueId)).orderBy(asc(issueFieldChanges.createdAt), asc(issueFieldChanges.seq))).map(toIssueFieldChange),
+			listByIssueField: async (issueId, field) => (await database.select().from(issueFieldChanges).where(and(eq(issueFieldChanges.issueId, issueId), eq(issueFieldChanges.field, field))).orderBy(asc(issueFieldChanges.createdAt), asc(issueFieldChanges.seq))).map(toIssueFieldChange),
+			create: async (values) => {
+				await database.insert(issueFieldChanges).values(values);
+			}
+		},
+		pullRequests: {
+			listByIssue: async (issueId) => (await database.select().from(issuePullRequests).where(eq(issuePullRequests.issueId, issueId)).orderBy(asc(issuePullRequests.createdAt), asc(issuePullRequests.seq))).map(toIssuePullRequest),
+			listLinked: async () => (await database.select({
+				...getTableColumns(issuePullRequests),
+				workspaceId: issues.workspaceId
+			}).from(issuePullRequests).innerJoin(issues, eq(issues.id, issuePullRequests.issueId)).orderBy(asc(issuePullRequests.createdAt), asc(issuePullRequests.seq))).map(toLinkedPullRequest),
+			link: async (values) => {
+				const [inserted] = await database.insert(issuePullRequests).values(values).onConflictDoNothing().returning();
+				if (inserted) return toIssuePullRequest(inserted);
+				const [existing] = await database.select().from(issuePullRequests).where(and(eq(issuePullRequests.issueId, values.issueId), eq(issuePullRequests.owner, values.owner), eq(issuePullRequests.repo, values.repo), eq(issuePullRequests.number, values.number))).limit(1);
+				if (!existing) throw new Error(`pull request link for ${values.issueId} was refused, and the card names no ${values.owner}/${values.repo}#${values.number}`);
+				return toIssuePullRequest(existing);
+			},
+			unlink: async (issueId, linkId) => {
+				const [removed] = await database.delete(issuePullRequests).where(and(eq(issuePullRequests.id, linkId), eq(issuePullRequests.issueId, issueId))).returning();
+				return removed ? toIssuePullRequest(removed) : null;
+			}
+		},
+		meta: {
+			read: async (key) => {
+				const [row] = await database.select().from(kanbanMeta).where(eq(kanbanMeta.key, key)).limit(1);
+				return row ?? null;
+			},
+			bumpRevision: async (key, updatedAt) => {
+				await database.insert(kanbanMeta).values({
+					key,
+					revision: 1,
+					updatedAt
+				}).onConflictDoUpdate({
+					target: kanbanMeta.key,
+					set: {
+						revision: sql`${kanbanMeta.revision} + 1`,
+						updatedAt
+					}
+				});
+			}
+		},
+		/**
+		* Run `fn` inside one Postgres transaction, on the handle this store is
+		* bound to. A transaction opened on a transactional handle is a savepoint —
+		* drizzle writes that for us — so a nested write rolls back on its own
+		* without taking the outer one with it.
+		*
+		* `mode` reaches nothing here. `immediate` is SQLite's way of taking the
+		* file's write lock up front, and Postgres has no counterpart worth writing:
+		* it locks rows as they are written, and the two races the board actually
+		* has — two writers numbering a card, two writers bumping the change
+		* counter — are settled by the unique index on `(workspace_id, number)` and
+		* by the `on conflict do update` on `kanban_meta`. Nothing here takes a lock
+		* the statement itself would not.
+		*/
+		transaction: async (fn, _options) => {
+			return await database.transaction(async (tx) => await fn(createStoreOver(tx)));
+		}
+	};
+}
+/**
+* `BoardStore` backed by Postgres — the board in a database several machines
+* share, rather than in a file one machine holds.
+*
+* It is written against `pg-core` and nothing below it, so the same store serves
+* a real connection onto an external database and the embedded
+* Postgres the tests run on. Every method answers what the SQLite store
+* answers, down to the order of two rows written in the same second — `seq` on
+* `issue_runs`, `issue_comments`, `issue_field_changes` and
+* `issue_pull_requests` is what stands in for `rowid` there.
+*/
+function createPostgresBoardStore(options) {
+	return createStoreOver(options.database);
+}
+//#endregion
+//#region src/postgres/migrations-path.ts
+/** The folder's name, wherever it has been put. */
+const MIGRATIONS_DIRECTORY = "drizzle-postgres";
+/**
+* The board's Postgres migrations for the file that is running right now — the
+* ones `kanbo migrate` applies to an external database. The two
+* layouts this has to survive are `src/migrations-path.ts`'s subject.
+*/
+function getBoardMigrationsPath() {
+	const here = dirname(fileURLToPath(import.meta.url));
+	return resolveBoardMigrationsPath(here, MIGRATIONS_DIRECTORY, hasMigrationJournal);
+}
+//#endregion
+//#region src/postgres/open-database.ts
+/** `information_schema.tables`, the first of the two views the guard reads. */
+const informationSchemaTables = pgSchema("information_schema").table("tables", {
+	tableSchema: text("table_schema").notNull(),
+	tableName: text("table_name").notNull()
+});
+/** And `information_schema.columns`, for a board whose tables are all there but older inside. */
+const informationSchemaColumns = pgSchema("information_schema").table("columns", {
+	tableSchema: text("table_schema").notNull(),
+	tableName: text("table_name").notNull(),
+	columnName: text("column_name").notNull()
+});
+/**
+* Every column this build expects to find, read off the schema itself rather
+* than listed again here — a column added to the schema and forgotten in a
+* migration is exactly the drift this is looking for.
+*/
+function expectedColumns() {
+	return Object.values(boardPostgresSchema).flatMap((table) => {
+		const config = getTableConfig(table);
+		return config.columns.map((column) => ({
+			table: config.name,
+			column: column.name
+		}));
+	});
+}
+/**
+* Refuse a Postgres board this build cannot speak for, before any statement
+* runs against it.
+*
+* An external database has no app of its own to migrate it — `kanbo migrate`
+* is the only thing that ever creates the board here — so this guard answers
+* three different mistakes with one code: a connection string pointing at a
+* database that has no board in it at all, one pointing at a board whose tables
+* are all there but which a later migration has since added to, and
+* one pointing at a board written by another generation of this package.
+*
+* The middle case is the one a stamp alone cannot catch, and it comes in two
+* shapes: a table a later migration added (`issue_pull_requests`, reported as
+* `missingAddedTables` so a host does not read it as "no board here"), and a
+* column one added. `BOARD_SCHEMA_EPOCH` says which *logical* board a database
+* holds, and a migration that only adds a column this dialect needs for itself — `seq`, the insertion order Postgres
+* has no `rowid` for — does not change that. Such a board would pass a stamp
+* check and then fail on the first listing, statement by statement, so the
+* columns are asked for by name instead.
+*/
+async function assertBoardSchema(database) {
+	const present = new Set((await database.select({ name: informationSchemaTables.tableName }).from(informationSchemaTables).where(eq(informationSchemaTables.tableSchema, sql`current_schema()`))).map((row) => row.name));
+	const added = new Set(BOARD_TABLES_ADDED_WITHIN_EPOCH);
+	const missing = BOARD_POSTGRES_TABLES.filter((table) => !added.has(table) && !present.has(table));
+	if (missing.length > 0) throw new BoardError("board_schema_outdated", { missingTables: missing });
+	const missingAddedTables = BOARD_TABLES_ADDED_WITHIN_EPOCH.filter((table) => !present.has(table));
+	if (missingAddedTables.length > 0) throw new BoardError("board_schema_outdated", { missingAddedTables });
+	const columns = new Set((await database.select({
+		table: informationSchemaColumns.tableName,
+		column: informationSchemaColumns.columnName
+	}).from(informationSchemaColumns).where(eq(informationSchemaColumns.tableSchema, sql`current_schema()`))).map((row) => `${row.table}.${row.column}`));
+	const missingColumns = expectedColumns().filter(({ table, column }) => !columns.has(`${table}.${column}`)).map(({ table, column }) => `${table}.${column}`);
+	if (missingColumns.length > 0) throw new BoardError("board_schema_outdated", { missingColumns });
+	const [row] = await database.select({ revision: kanbanMeta.revision }).from(kanbanMeta).where(eq(kanbanMeta.key, "schema_epoch"));
+	if (row?.revision !== 1) throw new BoardError("board_schema_outdated", {
+		expected: 1,
+		found: row?.revision ?? null
+	});
+}
+//#endregion
+//#region src/postgres/roles.sql.ts
+/** The role a person connects as: the board, whole. */
+const BOARD_PERSON_ROLE = "kanban_person";
+/** The role an agent connects as: the board, minus the two decisions that are a person's. */
+const BOARD_AGENT_ROLE = "kanban_agent";
+/**
+* What the database says when the agent role tries to take a card back from a
+* person. The board's clients turn it into `board_approval_requires_user`;
+* it is written here because by then the only thing left of the refusal is this
+* sentence.
+*/
+const AGENT_WAITING_REFUSAL = "kanbo: only a person may take a card out of waiting";
+/** What the database says when the agent role tries to write a person's decision into the history. */
+const AGENT_APPROVAL_COMMENT_REFUSAL = "kanbo: only a person may approve or return a card";
+/**
+* `insufficient_privilege` — the SQLSTATE every refusal above is raised with,
+* and the one thing about them that survives a driver. A caller that maps the
+* refusal to an answer of its own matches this rather than the sentence.
+*/
+const BOARD_REFUSAL_ERRCODE = "42501";
+/**
+* The sequences behind the four `seq` columns — the board's stand-in for the
+* `rowid` a file orders by. An insert into one of those tables draws from its
+* sequence, so a role without `usage` on it cannot write the row at all.
+*/
+const BOARD_SEQUENCES = [
+	"issue_runs_seq_seq",
+	"issue_comments_seq_seq",
+	"issue_field_changes_seq_seq",
+	"issue_pull_requests_seq_seq"
+];
+/** The cards themselves — the one table the agent role may not delete from. */
+const ISSUES_TABLE = "issues";
+/** Everything else, which both roles hold outright. */
+const AGENT_DELETABLE_TABLES = BOARD_POSTGRES_TABLES.filter((table) => table !== ISSUES_TABLE);
+/** Every board table, as the SQL spells a list of them. */
+function quoted(tables) {
+	return tables.map((table) => `"${table}"`).join(", ");
+}
+/**
+* The two roles an external board is worked through, and the two rules the
+* database itself keeps.
+*
+* A board in a file is protected by whoever can open the file. A board in a
+* shared database is not: several people and several agents connect to it at
+* once, from machines nobody else knows about, so the rule that approving is
+* a person's job has to live somewhere they all pass through. That is here —
+* below every client, in triggers that read `current_user`, so an agent holding
+* a connection string still cannot do a person's two things:
+*
+* - take a card out of `waiting_for = 'human'`, which is how a person accepts
+*   or returns the work, and
+* - write a `system.approved` or `system.returned` comment, which is how that
+*   decision is recorded — nor delete one, nor rewrite one, because a rule
+*   about who may write a row is worth nothing if the other side may erase or
+*   re-word it afterwards.
+*
+* The third rule is a grant rather than a trigger: the agent role may not
+* delete a card at all. A trigger cannot answer this one, because a cascading
+* delete is carried out as the owner of the table it reaches — `current_user`
+* inside the comment guard is the owner, not the agent, so deleting the card
+* would quietly take the decision on it with it. Nothing is lost by refusing:
+* the board's own tools offer no way to delete a card (cancelling one is a move
+* to another column), and a card that could be deleted and written again is a
+* way around waiting for a person.
+*
+* The guards read `current_user`, which is the role the session *logged in as*:
+* a login merely granted membership in `kanban_agent` is still itself, and the
+* rules below do not fire for it. The header of the SQL says so to whoever
+* applies it.
+*
+* Everything else about the board is the agent's to do. Both roles are created
+* with `login` and **no password**: an administrator sets one with
+* `alter role kanban_agent with password '…'` before a connection string is
+* handed out, and no password is ever written by this package.
+*
+* Applying this twice is a no-op — `kanbo roles apply` is meant to be run
+* again whenever the board moves or the rules change.
+*/
+const BOARD_ROLE_SQL = `-- Two roles for one board: a person's and an agent's.
+-- Apply as the owner of the board tables (or a superuser):
+--   psql "$KANBO_DATABASE_URL" -f roles.sql
+-- Neither role is given a password here. Set one before handing out a
+-- connection string:
+--   alter role ${BOARD_AGENT_ROLE} with password '…';
+-- The agent role is granted no delete on "issues": see the comment on that
+-- grant below.
+-- Connect AS the role. The guards below read current_user, and a login that was
+-- merely granted membership ("create role bot login; grant ${BOARD_AGENT_ROLE} to bot;")
+-- keeps current_user = 'bot' — the guards then never fire and the board looks
+-- configured while nothing is enforced. Either hand out ${BOARD_AGENT_ROLE}'s own
+-- connection string, or have the session run "set role ${BOARD_AGENT_ROLE}" before it
+-- touches the board.
+do $$
+begin
+  if not exists (select 1 from pg_catalog.pg_roles where rolname = '${BOARD_PERSON_ROLE}') then
+    create role "${BOARD_PERSON_ROLE}" login;
+  end if;
+  if not exists (select 1 from pg_catalog.pg_roles where rolname = '${BOARD_AGENT_ROLE}') then
+    create role "${BOARD_AGENT_ROLE}" login;
+  end if;
+end
+$$;
+
+grant usage on schema public to "${BOARD_PERSON_ROLE}", "${BOARD_AGENT_ROLE}";
+
+grant select, insert, update, delete on ${quoted(BOARD_POSTGRES_TABLES)}
+  to "${BOARD_PERSON_ROLE}";
+
+-- The agent holds everything but the deletion of a card. A card carries its
+-- history by cascade, and a cascading delete runs as the table's owner, so a
+-- trigger on the comments cannot tell an agent's deletion from anyone's: the
+-- only place to say it is here. The board's own tools never delete a card —
+-- cancelling one is a move to another column — and a card that could be deleted
+-- and written again is a way around waiting for a person.
+grant select, insert, update, delete on ${quoted(AGENT_DELETABLE_TABLES)}
+  to "${BOARD_AGENT_ROLE}";
+
+grant select, insert, update on "${ISSUES_TABLE}" to "${BOARD_AGENT_ROLE}";
+revoke delete on "${ISSUES_TABLE}" from "${BOARD_AGENT_ROLE}";
+
+grant usage, select on sequence ${quoted(BOARD_SEQUENCES)}
+  to "${BOARD_PERSON_ROLE}", "${BOARD_AGENT_ROLE}";
+
+-- A person accepts or returns the work; an agent asks and waits.
+create or replace function kanban_guard_waiting_for() returns trigger
+language plpgsql as $$
+begin
+  if current_user = '${BOARD_AGENT_ROLE}'
+    and old.waiting_for = 'human'
+    and new.waiting_for is distinct from old.waiting_for then
+    raise exception '${AGENT_WAITING_REFUSAL}' using errcode = '${BOARD_REFUSAL_ERRCODE}';
+  end if;
+  return new;
+end;
+$$;
+
+drop trigger if exists kanban_guard_waiting_for on "issues";
+create trigger kanban_guard_waiting_for
+  before update on "issues"
+  for each row execute function kanban_guard_waiting_for();
+
+-- And the same decision, said in the card's history.
+create or replace function kanban_guard_approval_comments() returns trigger
+language plpgsql as $$
+begin
+  if current_user = '${BOARD_AGENT_ROLE}'
+    and new.author_kind in ('system.approved', 'system.returned') then
+    raise exception '${AGENT_APPROVAL_COMMENT_REFUSAL}' using errcode = '${BOARD_REFUSAL_ERRCODE}';
+  end if;
+  return new;
+end;
+$$;
+
+drop trigger if exists kanban_guard_approval_comments on "issue_comments";
+create trigger kanban_guard_approval_comments
+  before insert on "issue_comments"
+  for each row execute function kanban_guard_approval_comments();
+
+-- And the same decision cannot be erased either: a rule about who may write a
+-- row is worth nothing if the other side may delete it afterwards.
+create or replace function kanban_guard_approval_comment_deletes() returns trigger
+language plpgsql as $$
+begin
+  if current_user = '${BOARD_AGENT_ROLE}'
+    and old.author_kind in ('system.approved', 'system.returned') then
+    raise exception '${AGENT_APPROVAL_COMMENT_REFUSAL}' using errcode = '${BOARD_REFUSAL_ERRCODE}';
+  end if;
+  return old;
+end;
+$$;
+
+drop trigger if exists kanban_guard_approval_comment_deletes on "issue_comments";
+create trigger kanban_guard_approval_comment_deletes
+  before delete on "issue_comments"
+  for each row execute function kanban_guard_approval_comment_deletes();
+
+-- Nor rewritten. A decision that can be re-worded, re-dated or turned into
+-- something else is not a decision, and an update is how each of those is
+-- spelled: "set content", "set created_at", "set author_kind = 'agent'". The
+-- row is guarded coming and going — what it already is, and what it is being
+-- made into — so the agent can neither take a person's decision away nor turn
+-- its own comment into one.
+create or replace function kanban_guard_approval_comment_updates() returns trigger
+language plpgsql as $$
+begin
+  if current_user = '${BOARD_AGENT_ROLE}'
+    and (old.author_kind in ('system.approved', 'system.returned')
+      or new.author_kind in ('system.approved', 'system.returned')) then
+    raise exception '${AGENT_APPROVAL_COMMENT_REFUSAL}' using errcode = '${BOARD_REFUSAL_ERRCODE}';
+  end if;
+  return new;
+end;
+$$;
+
+drop trigger if exists kanban_guard_approval_comment_updates on "issue_comments";
+create trigger kanban_guard_approval_comment_updates
+  before update on "issue_comments"
+  for each row execute function kanban_guard_approval_comment_updates();
+`;
+//#endregion
+export { issueStatuses as _, BOARD_REFUSAL_ERRCODE as a, getBoardMigrationsPath as c, boardPostgresSchema as d, issueComments as f, issueRuns as g, issueRelations as h, BOARD_PERSON_ROLE as i, createPostgresBoardStore as l, issueMilestones as m, AGENT_WAITING_REFUSAL as n, BOARD_ROLE_SQL as o, issueFieldChanges as p, BOARD_AGENT_ROLE as r, assertBoardSchema as s, AGENT_APPROVAL_COMMENT_REFUSAL as t, BOARD_POSTGRES_TABLES as u, issues as v, kanbanMeta as y };
+
+//# sourceMappingURL=roles.sql-CvyCGt38.mjs.map