kanbo-cli 0.1.0

package/dist/lib/migrate-DnMjTCvu.cjs

@@ -0,0 +1,709 @@
+const require_migrations_path = require("./migrations-path-CZxVOgeD.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");
+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/sqlite/transaction.ts
+/**
+* The better-sqlite3 handle Drizzle keeps beside the query builder. `drizzle()`
+* attaches it as `$client` (`drizzle-orm/better-sqlite3/driver.js`), but the
+* handle is declared as a `BetterSQLite3Database`, a class that does not
+* declare `$client` — which is why the assertion below restates the shape by
+* hand. Its `inTransaction` is the only honest answer to "is a
+* transaction already open", including one this module did not open.
+*/
+function readSqliteConnection(database) {
+	return database.$client;
+}
+/**
+* One fixed name for every nested scope, the way better-sqlite3 names its own
+* (`lib/methods/transaction.js`). `release` and `rollback to` address the
+* innermost savepoint carrying the name, and these scopes are opened and closed
+* in stack order, so each call reaches its own — a counter in the name would
+* only repeat what SQLite already tracks, and would collide the moment two
+* scopes nested through different code paths.
+*/
+const SAVEPOINT_NAME = "kanbo_tx";
+function readTransactionScope(connection, mode) {
+	if (!connection.inTransaction) return {
+		begin: mode === "immediate" ? "begin immediate" : "begin",
+		commit: "commit",
+		undo: "rollback",
+		releaseAfterUndo: null
+	};
+	return {
+		begin: `savepoint ${SAVEPOINT_NAME}`,
+		commit: `release ${SAVEPOINT_NAME}`,
+		undo: `rollback to ${SAVEPOINT_NAME}`,
+		releaseAfterUndo: `release ${SAVEPOINT_NAME}`
+	};
+}
+/**
+* Run `fn` inside one SQLite transaction that is allowed to await.
+*
+* `database.transaction(...)` cannot serve here: it commits the moment its
+* callback returns, and an async callback returns a pending promise, so the
+* transaction would close before the work inside it ran. The statements are
+* issued by hand instead, and the driver's own `inTransaction` flag picks which
+* — the same branch better-sqlite3 takes. With nothing open: `begin`, then
+* `commit`, or `rollback` when `fn` throws. With a transaction already open —
+* another call to this helper, or one a module opened through
+* `database.transaction` — a `savepoint` … `release` pair, undone by
+* `rollback to` followed by its own `release`. A second `begin` would throw,
+* which is why the flag decides and not a private counter. When SQLite has
+* already aborted the transaction itself the undo is skipped: it would throw
+* over the caller's error.
+*
+* **The callback must be the only database-touching async chain in flight —
+* no `Promise.all` sibling, no lock hand-off, no fire-and-forget promise
+* started before it — and inside it, only await operations that resolve
+* without I/O: store methods, synchronous database writes.** Even a resolved
+* promise yields to the microtask queue first, so a sibling chain already
+* queued in the same macrotask still runs inside this open transaction; a
+* chain started in a separate macrotask is unaffected. Awaiting anything that
+* truly suspends — a timer, the filesystem, the network — hands the
+* connection to whatever runs next, and its writes land in this transaction
+* too.
+*/
+async function runSqliteTransaction(database, fn, options) {
+	const connection = readSqliteConnection(database);
+	const scope = readTransactionScope(connection, options?.mode ?? "deferred");
+	database.run(drizzle_orm.sql.raw(scope.begin));
+	try {
+		const result = await fn();
+		database.run(drizzle_orm.sql.raw(scope.commit));
+		return result;
+	} catch (error) {
+		if (connection.inTransaction) {
+			database.run(drizzle_orm.sql.raw(scope.undo));
+			if (scope.releaseAfterUndo) database.run(drizzle_orm.sql.raw(scope.releaseAfterUndo));
+		}
+		throw error;
+	}
+}
+//#endregion
+//#region src/sqlite/board-store.sqlite.ts
+/**
+* The order two runs of one card are in when they started in the same second.
+*
+* `started_at` counts whole seconds and a run id is a random UUID, so the column
+* pair the attempt number is built on cannot separate two launches a second
+* apart — the row the board wrote second has to be the second attempt. SQLite
+* hands that out already: `rowid` rises with every insert. A store on another
+* engine answers the same question with whatever its own insert order is.
+*/
+const RUN_INSERTION_ORDER = drizzle_orm.sql`${require_sqlite_schema.issueRuns}.rowid asc`;
+/**
+* The same tie-break for the two tables that record what happened to a card.
+*
+* `created_at` counts whole seconds here too, and a person approving a card and
+* an agent commenting on it inside the same second must come back in the order
+* the board wrote them: `readApproval` takes the *last* comment to decide
+* whether the card was approved or returned.
+*/
+const COMMENT_INSERTION_ORDER = drizzle_orm.sql`${require_sqlite_schema.issueComments}.rowid asc`;
+const FIELD_CHANGE_INSERTION_ORDER = drizzle_orm.sql`${require_sqlite_schema.issueFieldChanges}.rowid asc`;
+/** And for a card's pull-request links, which list in the order they were made. */
+const PULL_REQUEST_INSERTION_ORDER = drizzle_orm.sql`${require_sqlite_schema.issuePullRequests}.rowid asc`;
+/**
+* The run facts of every card in scope, in one statement.
+*
+* The window functions do the grouping the caller would otherwise do with a
+* second query per card: `count(*)` counts the card's runs on every one of its
+* rows, and `row_number()` ranks them so that a `running` run wins, then the
+* newest start, then the row written last — the tie-break two runs started in
+* the same second need. Reading only rank 1 therefore leaves one row per card, carrying
+* the run the board should show — and `state` on that row says whether it is
+* still going, which is what turns it into an `activeRun` or into `null`.
+*/
+function selectRunProjection(database, scope) {
+	if ("issueIds" in scope && scope.issueIds.length === 0) return [];
+	const cards = "workspaceId" in scope ? drizzle_orm.sql`select ${require_sqlite_schema.issues.id} from ${require_sqlite_schema.issues} where ${require_sqlite_schema.issues.workspaceId} = ${scope.workspaceId}` : drizzle_orm.sql`values ${drizzle_orm.sql.join(scope.issueIds.map((issueId) => drizzle_orm.sql`(${issueId})`), drizzle_orm.sql`, `)}`;
+	return database.all(drizzle_orm.sql`
+    select
+      ranked.issue_id as issueId,
+      ranked.attempt_count as attemptCount,
+      ranked.id as id,
+      ranked.agent_id as agentId,
+      ranked.agent_name as agentName,
+      ranked.state as state,
+      ranked.branch as branch,
+      ranked.execution_mode as executionMode,
+      ranked.chat_session_id as chatSessionId,
+      ranked.started_at as startedAt
+    from (
+      select
+        run.*,
+        count(*) over (partition by run.issue_id) as attempt_count,
+        row_number() over (
+          partition by run.issue_id
+          order by (run.state = 'running') desc, run.started_at desc, run.rowid desc
+        ) as card_rank
+      from ${require_sqlite_schema.issueRuns} as run
+      where run.issue_id in (${cards})
+    ) as ranked
+    where ranked.card_rank = 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
+	}));
+}
+/**
+* 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).
+*/
+function createSqliteBoardStoreCore(resolveDatabase) {
+	return {
+		statuses: {
+			listByWorkspace: (workspaceId) => resolveDatabase().select().from(require_sqlite_schema.issueStatuses).where((0, drizzle_orm.eq)(require_sqlite_schema.issueStatuses.workspaceId, workspaceId)).orderBy(require_sqlite_schema.issueStatuses.order).all(),
+			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,
+			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;
+			},
+			create: (values) => resolveDatabase().insert(require_sqlite_schema.issueStatuses).values(values).returning().get(),
+			update: (statusId, patch) => {
+				resolveDatabase().update(require_sqlite_schema.issueStatuses).set(patch).where((0, drizzle_orm.eq)(require_sqlite_schema.issueStatuses.id, statusId)).run();
+			},
+			delete: (statusId) => {
+				resolveDatabase().delete(require_sqlite_schema.issueStatuses).where((0, drizzle_orm.eq)(require_sqlite_schema.issueStatuses.id, statusId)).run();
+			}
+		},
+		milestones: {
+			listNewestFirst: (workspaceId) => {
+				const predicates = [workspaceId ? (0, drizzle_orm.eq)(require_sqlite_schema.issueMilestones.workspaceId, workspaceId) : void 0].filter((predicate) => predicate !== void 0);
+				return resolveDatabase().select().from(require_sqlite_schema.issueMilestones).where(predicates.length > 0 ? (0, drizzle_orm.and)(...predicates) : void 0).orderBy((0, drizzle_orm.desc)(require_sqlite_schema.issueMilestones.createdAt)).all();
+			},
+			listByWorkspace: (workspaceId) => resolveDatabase().select().from(require_sqlite_schema.issueMilestones).where((0, drizzle_orm.eq)(require_sqlite_schema.issueMilestones.workspaceId, workspaceId)).all(),
+			listAll: () => resolveDatabase().select().from(require_sqlite_schema.issueMilestones).all(),
+			findById: (milestoneId) => resolveDatabase().select().from(require_sqlite_schema.issueMilestones).where((0, drizzle_orm.eq)(require_sqlite_schema.issueMilestones.id, milestoneId)).get() ?? null,
+			findInWorkspace: (workspaceId, milestoneId) => resolveDatabase().select().from(require_sqlite_schema.issueMilestones).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issueMilestones.id, milestoneId), (0, drizzle_orm.eq)(require_sqlite_schema.issueMilestones.workspaceId, workspaceId))).get() ?? null,
+			create: (values) => resolveDatabase().insert(require_sqlite_schema.issueMilestones).values(values).returning().get(),
+			update: (milestoneId, patch) => {
+				resolveDatabase().update(require_sqlite_schema.issueMilestones).set(patch).where((0, drizzle_orm.eq)(require_sqlite_schema.issueMilestones.id, milestoneId)).run();
+			},
+			delete: (milestoneId) => {
+				resolveDatabase().delete(require_sqlite_schema.issueMilestones).where((0, drizzle_orm.eq)(require_sqlite_schema.issueMilestones.id, milestoneId)).run();
+			}
+		},
+		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();
+			},
+			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(),
+			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,
+			findByNumber: (workspaceId, number) => resolveDatabase().select().from(require_sqlite_schema.issues).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issues.workspaceId, workspaceId), (0, drizzle_orm.eq)(require_sqlite_schema.issues.number, number))).get() ?? null,
+			maxNumber: (workspaceId) => {
+				return resolveDatabase().select({ maxNum: drizzle_orm.sql`coalesce(max(${require_sqlite_schema.issues.number}), 0)` }).from(require_sqlite_schema.issues).where((0, drizzle_orm.eq)(require_sqlite_schema.issues.workspaceId, workspaceId)).get()?.maxNum ?? 0;
+			},
+			maxOrder: (workspaceId) => {
+				return resolveDatabase().select({ maxOrder: drizzle_orm.sql`coalesce(max(${require_sqlite_schema.issues.order}), 0)` }).from(require_sqlite_schema.issues).where((0, drizzle_orm.eq)(require_sqlite_schema.issues.workspaceId, workspaceId)).get()?.maxOrder ?? 0;
+			},
+			create: (values) => resolveDatabase().insert(require_sqlite_schema.issues).values(values).returning().get(),
+			update: (issueId, patch) => {
+				resolveDatabase().update(require_sqlite_schema.issues).set(patch).where((0, drizzle_orm.eq)(require_sqlite_schema.issues.id, issueId)).run();
+			},
+			updateMany: (issueIds, patch) => resolveDatabase().update(require_sqlite_schema.issues).set(patch).where(drizzle_orm.sql`${require_sqlite_schema.issues.id} IN (${drizzle_orm.sql.join(issueIds.map((issueId) => drizzle_orm.sql`${issueId}`), drizzle_orm.sql`, `)})`).run().changes,
+			clearMilestoneReferences: (milestoneId, updatedAt) => {
+				resolveDatabase().update(require_sqlite_schema.issues).set({
+					milestoneId: null,
+					updatedAt
+				}).where((0, drizzle_orm.eq)(require_sqlite_schema.issues.milestoneId, milestoneId)).run();
+			},
+			clearParentReferences: (parentIssueId, updatedAt) => {
+				resolveDatabase().update(require_sqlite_schema.issues).set({
+					parentIssueId: null,
+					updatedAt
+				}).where((0, drizzle_orm.eq)(require_sqlite_schema.issues.parentIssueId, parentIssueId)).run();
+			},
+			clearDelegateReferences: (delegate, updatedAt) => resolveDatabase().update(require_sqlite_schema.issues).set({
+				delegateAgentId: null,
+				delegateProviderTargetId: null,
+				updatedAt
+			}).where("agentId" in delegate ? (0, drizzle_orm.eq)(require_sqlite_schema.issues.delegateAgentId, delegate.agentId) : (0, drizzle_orm.eq)(require_sqlite_schema.issues.delegateProviderTargetId, delegate.providerTargetId)).run().changes,
+			delete: (issueId) => {
+				resolveDatabase().delete(require_sqlite_schema.issues).where((0, drizzle_orm.eq)(require_sqlite_schema.issues.id, issueId)).run();
+			}
+		},
+		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(),
+			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(),
+			create: (values) => resolveDatabase().insert(require_sqlite_schema.issueComments).values(values).returning().get(),
+			createOnce: (values) => {
+				const database = resolveDatabase();
+				const inserted = database.insert(require_sqlite_schema.issueComments).values(values).onConflictDoNothing().returning().get();
+				if (inserted) return inserted;
+				const existing = database.select().from(require_sqlite_schema.issueComments).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issueComments.issueId, values.issueId), (0, drizzle_orm.eq)(require_sqlite_schema.issueComments.dedupeKey, values.dedupeKey))).get();
+				if (!existing) throw new Error(`issue comment for ${values.issueId} was refused, and no comment carries dedupe key ${values.dedupeKey}`);
+				return existing;
+			},
+			delete: (commentId) => {
+				resolveDatabase().delete(require_sqlite_schema.issueComments).where((0, drizzle_orm.eq)(require_sqlite_schema.issueComments.id, commentId)).run();
+			}
+		},
+		runs: {
+			listByIssue: (issueId) => resolveDatabase().select().from(require_sqlite_schema.issueRuns).where((0, drizzle_orm.eq)(require_sqlite_schema.issueRuns.issueId, issueId)).orderBy((0, drizzle_orm.asc)(require_sqlite_schema.issueRuns.startedAt), RUN_INSERTION_ORDER).all(),
+			listRunning: (issueId) => resolveDatabase().select().from(require_sqlite_schema.issueRuns).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issueRuns.issueId, issueId), (0, drizzle_orm.eq)(require_sqlite_schema.issueRuns.state, "running"))).orderBy((0, drizzle_orm.asc)(require_sqlite_schema.issueRuns.startedAt), RUN_INSERTION_ORDER).all(),
+			listRunningWithSession: () => resolveDatabase().select().from(require_sqlite_schema.issueRuns).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issueRuns.state, "running"), (0, drizzle_orm.isNotNull)(require_sqlite_schema.issueRuns.chatSessionId))).orderBy((0, drizzle_orm.asc)(require_sqlite_schema.issueRuns.startedAt), RUN_INSERTION_ORDER).all(),
+			findById: (runId) => resolveDatabase().select().from(require_sqlite_schema.issueRuns).where((0, drizzle_orm.eq)(require_sqlite_schema.issueRuns.id, runId)).get() ?? null,
+			findByChatSessionId: (chatSessionId) => resolveDatabase().select().from(require_sqlite_schema.issueRuns).where((0, drizzle_orm.eq)(require_sqlite_schema.issueRuns.chatSessionId, chatSessionId)).orderBy((0, drizzle_orm.desc)(require_sqlite_schema.issueRuns.startedAt), drizzle_orm.sql`${require_sqlite_schema.issueRuns}.rowid desc`).get() ?? null,
+			countByIssue: (issueId) => {
+				return resolveDatabase().select({ count: drizzle_orm.sql`count(*)` }).from(require_sqlite_schema.issueRuns).where((0, drizzle_orm.eq)(require_sqlite_schema.issueRuns.issueId, issueId)).get()?.count ?? 0;
+			},
+			create: (values) => resolveDatabase().insert(require_sqlite_schema.issueRuns).values(values).returning().get(),
+			update: (runId, patch) => {
+				resolveDatabase().update(require_sqlite_schema.issueRuns).set(patch).where((0, drizzle_orm.eq)(require_sqlite_schema.issueRuns.id, runId)).run();
+			},
+			project: (scope) => selectRunProjection(resolveDatabase(), scope)
+		},
+		relations: {
+			listByIssue: (issueId) => resolveDatabase().select().from(require_sqlite_schema.issueRelations).where((0, drizzle_orm.or)((0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.sourceIssueId, issueId), (0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.targetIssueId, issueId))).all(),
+			findById: (relationId) => resolveDatabase().select().from(require_sqlite_schema.issueRelations).where((0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.id, relationId)).get() ?? null,
+			findMatching: (edge) => resolveDatabase().select().from(require_sqlite_schema.issueRelations).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.type, edge.type), edge.type === "relates_to" ? (0, drizzle_orm.or)((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.sourceIssueId, edge.sourceIssueId), (0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.targetIssueId, edge.targetIssueId)), (0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.sourceIssueId, edge.targetIssueId), (0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.targetIssueId, edge.sourceIssueId))) : (0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.sourceIssueId, edge.sourceIssueId), (0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.targetIssueId, edge.targetIssueId)))).get() ?? null,
+			create: (values) => resolveDatabase().insert(require_sqlite_schema.issueRelations).values(values).returning().get(),
+			delete: (relationId) => {
+				resolveDatabase().delete(require_sqlite_schema.issueRelations).where((0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.id, relationId)).run();
+			},
+			deleteByIssue: (issueId) => {
+				resolveDatabase().delete(require_sqlite_schema.issueRelations).where((0, drizzle_orm.or)((0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.sourceIssueId, issueId), (0, drizzle_orm.eq)(require_sqlite_schema.issueRelations.targetIssueId, issueId))).run();
+			}
+		},
+		contextRefs: { replace: (issueId, contextRefs, updatedAt) => {
+			resolveDatabase().update(require_sqlite_schema.issues).set({
+				contextRefs,
+				updatedAt
+			}).where((0, drizzle_orm.eq)(require_sqlite_schema.issues.id, issueId)).run();
+		} },
+		fieldChanges: {
+			listByIssue: (issueId) => resolveDatabase().select().from(require_sqlite_schema.issueFieldChanges).where((0, drizzle_orm.eq)(require_sqlite_schema.issueFieldChanges.issueId, issueId)).orderBy((0, drizzle_orm.asc)(require_sqlite_schema.issueFieldChanges.createdAt), FIELD_CHANGE_INSERTION_ORDER).all(),
+			listByIssueField: (issueId, field) => resolveDatabase().select().from(require_sqlite_schema.issueFieldChanges).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issueFieldChanges.issueId, issueId), (0, drizzle_orm.eq)(require_sqlite_schema.issueFieldChanges.field, field))).orderBy((0, drizzle_orm.asc)(require_sqlite_schema.issueFieldChanges.createdAt), FIELD_CHANGE_INSERTION_ORDER).all(),
+			create: (values) => {
+				resolveDatabase().insert(require_sqlite_schema.issueFieldChanges).values(values).run();
+			}
+		},
+		pullRequests: {
+			listByIssue: (issueId) => resolveDatabase().select().from(require_sqlite_schema.issuePullRequests).where((0, drizzle_orm.eq)(require_sqlite_schema.issuePullRequests.issueId, issueId)).orderBy((0, drizzle_orm.asc)(require_sqlite_schema.issuePullRequests.createdAt), PULL_REQUEST_INSERTION_ORDER).all(),
+			listLinked: () => resolveDatabase().select({
+				...(0, drizzle_orm.getTableColumns)(require_sqlite_schema.issuePullRequests),
+				workspaceId: require_sqlite_schema.issues.workspaceId
+			}).from(require_sqlite_schema.issuePullRequests).innerJoin(require_sqlite_schema.issues, (0, drizzle_orm.eq)(require_sqlite_schema.issues.id, require_sqlite_schema.issuePullRequests.issueId)).orderBy((0, drizzle_orm.asc)(require_sqlite_schema.issuePullRequests.createdAt), PULL_REQUEST_INSERTION_ORDER).all(),
+			link: (values) => {
+				const database = resolveDatabase();
+				const inserted = database.insert(require_sqlite_schema.issuePullRequests).values(values).onConflictDoNothing().returning().get();
+				if (inserted) return inserted;
+				const existing = database.select().from(require_sqlite_schema.issuePullRequests).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issuePullRequests.issueId, values.issueId), (0, drizzle_orm.eq)(require_sqlite_schema.issuePullRequests.owner, values.owner), (0, drizzle_orm.eq)(require_sqlite_schema.issuePullRequests.repo, values.repo), (0, drizzle_orm.eq)(require_sqlite_schema.issuePullRequests.number, values.number))).get();
+				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 existing;
+			},
+			unlink: (issueId, linkId) => resolveDatabase().delete(require_sqlite_schema.issuePullRequests).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_sqlite_schema.issuePullRequests.id, linkId), (0, drizzle_orm.eq)(require_sqlite_schema.issuePullRequests.issueId, issueId))).returning().get() ?? null
+		},
+		meta: {
+			read: (key) => resolveDatabase().select().from(require_sqlite_schema.kanbanMeta).where((0, drizzle_orm.eq)(require_sqlite_schema.kanbanMeta.key, key)).get() ?? null,
+			bumpRevision: (key, updatedAt) => {
+				resolveDatabase().insert(require_sqlite_schema.kanbanMeta).values({
+					key,
+					revision: 1,
+					updatedAt
+				}).onConflictDoUpdate({
+					target: require_sqlite_schema.kanbanMeta.key,
+					set: {
+						revision: drizzle_orm.sql`${require_sqlite_schema.kanbanMeta.revision} + 1`,
+						updatedAt
+					}
+				}).run();
+			}
+		}
+	};
+}
+/**
+* `BoardStore` backed by SQLite: every method resolves immediately, because the
+* core underneath it is synchronous.
+*
+* `database` is a function rather than a handle so the store follows whatever
+* the host currently has open — a server passes its single connection
+* accessor, a standalone reader passes its own.
+*/
+function createSqliteBoardStore(options) {
+	const core = createSqliteBoardStoreCore(options.database);
+	const store = {
+		statuses: {
+			listByWorkspace: async (workspaceId) => core.statuses.listByWorkspace(workspaceId),
+			listAllInBoardOrder: async () => core.statuses.listAllInBoardOrder(),
+			listAll: async () => core.statuses.listAll(),
+			findById: async (statusId) => core.statuses.findById(statusId),
+			findInWorkspace: async (workspaceId, statusId) => core.statuses.findInWorkspace(workspaceId, statusId),
+			countByWorkspace: async (workspaceId) => core.statuses.countByWorkspace(workspaceId),
+			create: async (values) => core.statuses.create(values),
+			update: async (statusId, patch) => core.statuses.update(statusId, patch),
+			delete: async (statusId) => core.statuses.delete(statusId)
+		},
+		milestones: {
+			listNewestFirst: async (workspaceId) => core.milestones.listNewestFirst(workspaceId),
+			listByWorkspace: async (workspaceId) => core.milestones.listByWorkspace(workspaceId),
+			listAll: async () => core.milestones.listAll(),
+			findById: async (milestoneId) => core.milestones.findById(milestoneId),
+			findInWorkspace: async (workspaceId, milestoneId) => core.milestones.findInWorkspace(workspaceId, milestoneId),
+			create: async (values) => core.milestones.create(values),
+			update: async (milestoneId, patch) => core.milestones.update(milestoneId, patch),
+			delete: async (milestoneId) => core.milestones.delete(milestoneId)
+		},
+		issues: {
+			listInBoardOrder: async (workspaceId) => core.issues.listInBoardOrder(workspaceId),
+			listNewestFirst: async () => core.issues.listNewestFirst(),
+			listAll: async () => core.issues.listAll(),
+			listByWorkspace: async (workspaceId) => core.issues.listByWorkspace(workspaceId),
+			listByIds: async (issueIds) => core.issues.listByIds(issueIds),
+			findById: async (issueId) => core.issues.findById(issueId),
+			findInWorkspace: async (workspaceId, issueId) => core.issues.findInWorkspace(workspaceId, issueId),
+			findByNumber: async (workspaceId, number) => core.issues.findByNumber(workspaceId, number),
+			maxNumber: async (workspaceId) => core.issues.maxNumber(workspaceId),
+			maxOrder: async (workspaceId) => core.issues.maxOrder(workspaceId),
+			create: async (values) => core.issues.create(values),
+			update: async (issueId, patch) => core.issues.update(issueId, patch),
+			updateMany: async (issueIds, patch) => core.issues.updateMany(issueIds, patch),
+			clearMilestoneReferences: async (milestoneId, updatedAt) => core.issues.clearMilestoneReferences(milestoneId, updatedAt),
+			clearParentReferences: async (parentIssueId, updatedAt) => core.issues.clearParentReferences(parentIssueId, updatedAt),
+			clearDelegateReferences: async (delegate, updatedAt) => core.issues.clearDelegateReferences(delegate, updatedAt),
+			delete: async (issueId) => core.issues.delete(issueId)
+		},
+		comments: {
+			listByIssue: async (issueId) => core.comments.listByIssue(issueId),
+			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),
+			create: async (values) => core.comments.create(values),
+			createOnce: async (values) => core.comments.createOnce(values),
+			delete: async (commentId) => core.comments.delete(commentId)
+		},
+		runs: {
+			listByIssue: async (issueId) => core.runs.listByIssue(issueId),
+			listRunning: async (issueId) => core.runs.listRunning(issueId),
+			listRunningWithSession: async () => core.runs.listRunningWithSession(),
+			findById: async (runId) => core.runs.findById(runId),
+			findByChatSessionId: async (chatSessionId) => core.runs.findByChatSessionId(chatSessionId),
+			countByIssue: async (issueId) => core.runs.countByIssue(issueId),
+			create: async (values) => core.runs.create(values),
+			update: async (runId, patch) => core.runs.update(runId, patch),
+			project: async (scope) => core.runs.project(scope)
+		},
+		relations: {
+			listByIssue: async (issueId) => core.relations.listByIssue(issueId),
+			findById: async (relationId) => core.relations.findById(relationId),
+			findMatching: async (edge) => core.relations.findMatching(edge),
+			create: async (values) => core.relations.create(values),
+			delete: async (relationId) => core.relations.delete(relationId),
+			deleteByIssue: async (issueId) => core.relations.deleteByIssue(issueId)
+		},
+		contextRefs: { replace: async (issueId, contextRefs, updatedAt) => core.contextRefs.replace(issueId, contextRefs, updatedAt) },
+		fieldChanges: {
+			listByIssue: async (issueId) => core.fieldChanges.listByIssue(issueId),
+			listByIssueField: async (issueId, field) => core.fieldChanges.listByIssueField(issueId, field),
+			create: async (values) => core.fieldChanges.create(values)
+		},
+		pullRequests: {
+			listByIssue: async (issueId) => core.pullRequests.listByIssue(issueId),
+			listLinked: async () => core.pullRequests.listLinked(),
+			link: async (values) => core.pullRequests.link(values),
+			unlink: async (issueId, linkId) => core.pullRequests.unlink(issueId, linkId)
+		},
+		meta: {
+			read: async (key) => core.meta.read(key),
+			bumpRevision: async (key, updatedAt) => core.meta.bumpRevision(key, updatedAt)
+		},
+		/**
+		* Run `fn` inside one SQLite transaction, through the driver-level helper in
+		* `./transaction.ts`.
+		*
+		* The caller rule lives there in full; in short: `fn` must be the only
+		* database-touching async chain in flight, and inside it only await
+		* operations that resolve without I/O — store methods, synchronous database
+		* writes.
+		*/
+		transaction: async (fn, transactionOptions) => {
+			return await runSqliteTransaction(options.database(), () => fn(store), transactionOptions);
+		}
+	};
+	return store;
+}
+//#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.
+*/
+function loadBetterSqlite3() {
+	try {
+		return require$1("better-sqlite3");
+	} catch (error) {
+		throw new Error(BETTER_SQLITE3_MISSING_MESSAGE, { cause: error });
+	}
+}
+/**
+* Drizzle's own better-sqlite3 driver, and why it is not imported at the top of
+* this file like every other import in the package.
+*
+* `drizzle-orm/better-sqlite3` imports the native module eagerly — it has an
+* overload where `drizzle()` constructs the connection itself — so a static
+* import of it makes `better-sqlite3` required by everything that can reach
+* 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
+* 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.
+*
+* The module is remembered after the first load, so a command that opens two
+* board files pays for it once.
+*/
+let sqliteDriver = null;
+async function loadSqliteDriver() {
+	sqliteDriver ??= await import("drizzle-orm/better-sqlite3");
+	return sqliteDriver;
+}
+/**
+* Open a board file with the runtime pragmas a long-running server sets on its
+* own database, so a board read from a terminal behaves the same as one read
+* from inside an app. Migrations are not applied here: the file's owner applies
+* them (`kanbo init --file`, `kanbo migrate`, or the app the database belongs to).
+*
+* Asynchronous because the driver beneath it is loaded on demand — see
+* `loadSqliteDriver`. The native module is asked for first, so an install
+* without it hears the sentence above rather than a module-resolution stack
+* from inside drizzle.
+*/
+async function openBoardDatabase(path) {
+	const Database = loadBetterSqlite3();
+	const { drizzle } = await loadSqliteDriver();
+	const connection = new Database(path);
+	connection.pragma("foreign_keys = ON");
+	connection.pragma("journal_mode = WAL");
+	connection.pragma("busy_timeout = 5000");
+	connection.pragma("synchronous = NORMAL");
+	return {
+		database: drizzle(connection, { schema: require_sqlite_schema.boardSqliteSchema }),
+		connection,
+		close: () => connection.close()
+	};
+}
+/**
+* Every column this build expects to find, read off the schema itself — the
+* same idea as the Postgres guard's, so a column a later migration added
+* (`issue_milestones.start_date`) is looked for without being listed again.
+*/
+function expectedColumns() {
+	return Object.values(require_sqlite_schema.boardSqliteSchema).flatMap((table) => {
+		const config = (0, drizzle_orm_sqlite_core.getTableConfig)(table);
+		return config.columns.map((column) => `${config.name}.${column.name}`);
+	});
+}
+/**
+* Refuse a board file this build cannot speak for, before any statement runs
+* against it: one with no board in it (`missingTables`), one whose board a
+* later migration has since added a table to (`missingAddedTables`) or a
+* column to (`missingColumns`), and one stamped with another epoch. An app
+* that migrates its own database on start need not call this; it is the guard a
+* standalone reader puts in front of a file it did not create.
+*/
+function assertBoardSchema(database) {
+	const present = new Set(database.all(drizzle_orm.sql`select name from sqlite_master where type = 'table'`).map((row) => row.name));
+	const missing = REQUIRED_BOARD_TABLES.filter((table) => !present.has(table));
+	if (missing.length > 0) throw new require_migrations_path.BoardError("board_schema_outdated", { missingTables: missing });
+	const missingAddedTables = require_migrations_path.BOARD_TABLES_ADDED_WITHIN_EPOCH.filter((table) => !present.has(table));
+	if (missingAddedTables.length > 0) throw new require_migrations_path.BoardError("board_schema_outdated", { missingAddedTables });
+	const columns = new Set(database.all(drizzle_orm.sql`
+      select m.name as tableName, p.name as columnName
+      from sqlite_master m join pragma_table_info(m.name) p
+      where m.type = 'table'`).map((row) => `${row.tableName}.${row.columnName}`));
+	const missingColumns = expectedColumns().filter((column) => !columns.has(column));
+	if (missingColumns.length > 0) throw new require_migrations_path.BoardError("board_schema_outdated", { missingColumns });
+	const row = database.get(drizzle_orm.sql`select revision from kanban_meta where key = 'schema_epoch'`);
+	if (row?.revision !== 1) throw new require_migrations_path.BoardError("board_schema_outdated", {
+		expected: 1,
+		found: row?.revision ?? null
+	});
+}
+/**
+* Which of the two ever wrote this file's board, going by the `kanban_meta`
+* marker `kanbo init --file` leaves behind (ruling 5-4).
+*
+* Absent reads as a host database — every file this package has never
+* touched, and a file this build cannot make sense of at all: `assertBoardSchema` is what says a board is missing or too old,
+* not this, so a table or a row that is not there yet is read as "not this
+* package's file" rather than an error of its own.
+*/
+function readBoardFileOwner(database) {
+	try {
+		return database.get(drizzle_orm.sql`select key from kanban_meta where key = 'file_owner'`) ? "kanbo" : "host";
+	} catch {
+		return "host";
+	}
+}
+/**
+* Leave the marker that tells every later reader this file is this package's
+* own, not a host app's. `kanbo init --file` calls this once, right after
+* migrating; `insert or ignore` is what makes calling it again on the same
+* file a no-op rather than a conflict.
+*/
+function markBoardFileOwnedByKanbo(database) {
+	database.run(drizzle_orm.sql`insert or ignore into kanban_meta (key, revision) values ('file_owner', 1)`);
+}
+/**
+* Look at a file on a connection of its own and hand it back closed, so a
+* caller can decide what to do with it before opening it for real.
+*
+* Two callers, two different decisions off the same two facts: the command line
+* asks whose file it is to know whether a host app's `workspaces` row may be
+* looked up in it, and a host app asks before it writes a board into it, because
+* a file with tables that are not this package's is somebody else's database
+* and migrating it would contaminate it (ruling 5-8).
+*
+* A path that is not a SQLite database at all — a README, a half-downloaded
+* file, a directory — throws, and that is deliberately not the same answer as
+* "a database with somebody else's tables in it": one is a mistake about which
+* path to use and the other is a mistake about which file is a board. No pragma
+* is set and nothing is written, so a file that turns out not to be ours is
+* left exactly as it was found, journal mode included.
+*/
+function readBoardFileContents(path) {
+	const connection = new (loadBetterSqlite3())(path, { fileMustExist: true });
+	try {
+		if (connection.prepare("select count(*) as count from sqlite_master where type = 'table'").get().count === 0) return {
+			empty: true,
+			owner: "host"
+		};
+		return {
+			empty: false,
+			owner: readMarkedOwner(connection)
+		};
+	} finally {
+		connection.close();
+	}
+}
+/** The marker, read straight off the driver: the same question `readBoardFileOwner` asks a drizzle handle. */
+function readMarkedOwner(connection) {
+	try {
+		return connection.prepare("select key from kanban_meta where key = 'file_owner'").get() ? "kanbo" : "host";
+	} catch {
+		return "host";
+	}
+}
+//#endregion
+//#region src/sqlite/migrate.ts
+/** The folder's name, wherever it has been put. */
+const MIGRATIONS_DIRECTORY = "drizzle-sqlite";
+/**
+* The board's SQLite migrations for the file that is running right now — the
+* ones that build a board *file of this package's own*. The two layouts this
+* has to survive are `src/migrations-path.ts`'s subject.
+*/
+function getBoardSqliteMigrationsPath() {
+	const here = (0, node_path.dirname)((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+	return require_migrations_path.resolveBoardMigrationsPath(here, MIGRATIONS_DIRECTORY, require_migrations_path.hasMigrationJournal);
+}
+/**
+* Create or update a board file this package owns.
+*
+* A host app's own database is not this: there the board is nine tables among
+* the app's own, and the app's migration runner migrates the whole file — which
+* may take two passes, because a migration that rebuilds a table has to drop
+* it with foreign keys off. Nothing here rebuilds anything — `drizzle-sqlite/` starts at the
+* board as it is now and will only ever be appended to — so drizzle's own
+* migrator is the whole of what this needs, and a file that has been migrated
+* before is a no-op by `__drizzle_migrations`.
+*
+* What the file holds afterwards is the board and nothing else: no
+* `workspaces`, no `agents`, no `provider_targets`. Every reference out of the
+* board is a plain text column for exactly that reason (ruling 5-1).
+*/
+function migrateBoardFile(database) {
+	(0, drizzle_orm_better_sqlite3_migrator.migrate)(database, { migrationsFolder: getBoardSqliteMigrationsPath() });
+}
+//#endregion
+Object.defineProperty(exports, "assertBoardSchema", {
+	enumerable: true,
+	get: function() {
+		return assertBoardSchema;
+	}
+});
+Object.defineProperty(exports, "createSqliteBoardStore", {
+	enumerable: true,
+	get: function() {
+		return createSqliteBoardStore;
+	}
+});
+Object.defineProperty(exports, "getBoardSqliteMigrationsPath", {
+	enumerable: true,
+	get: function() {
+		return getBoardSqliteMigrationsPath;
+	}
+});
+Object.defineProperty(exports, "markBoardFileOwnedByKanbo", {
+	enumerable: true,
+	get: function() {
+		return markBoardFileOwnedByKanbo;
+	}
+});
+Object.defineProperty(exports, "migrateBoardFile", {
+	enumerable: true,
+	get: function() {
+		return migrateBoardFile;
+	}
+});
+Object.defineProperty(exports, "openBoardDatabase", {
+	enumerable: true,
+	get: function() {
+		return openBoardDatabase;
+	}
+});
+Object.defineProperty(exports, "readBoardFileContents", {
+	enumerable: true,
+	get: function() {
+		return readBoardFileContents;
+	}
+});
+Object.defineProperty(exports, "readBoardFileOwner", {
+	enumerable: true,
+	get: function() {
+		return readBoardFileOwner;
+	}
+});
+Object.defineProperty(exports, "runSqliteTransaction", {
+	enumerable: true,
+	get: function() {
+		return runSqliteTransaction;
+	}
+});
+
+//# sourceMappingURL=migrate-DnMjTCvu.cjs.map