kanbo-cli 0.1.0

package/dist/lib/sqlite/index.cjs

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_migrations_path = require("../migrations-path-CZxVOgeD.cjs");
+const require_sqlite_schema = require("./schema.cjs");
+const require_migrate = require("../migrate-DnMjTCvu.cjs");
+exports.BOARD_SCHEMA_EPOCH = require_migrations_path.BOARD_SCHEMA_EPOCH;
+exports.assertBoardSchema = require_migrate.assertBoardSchema;
+exports.boardSqliteSchema = require_sqlite_schema.boardSqliteSchema;
+exports.createSqliteBoardStore = require_migrate.createSqliteBoardStore;
+exports.getBoardSqliteMigrationsPath = require_migrate.getBoardSqliteMigrationsPath;
+exports.issueComments = require_sqlite_schema.issueComments;
+exports.issueFieldChanges = require_sqlite_schema.issueFieldChanges;
+exports.issueMilestones = require_sqlite_schema.issueMilestones;
+exports.issueRelations = require_sqlite_schema.issueRelations;
+exports.issueRuns = require_sqlite_schema.issueRuns;
+exports.issueStatuses = require_sqlite_schema.issueStatuses;
+exports.issues = require_sqlite_schema.issues;
+exports.kanbanMeta = require_sqlite_schema.kanbanMeta;
+exports.markBoardFileOwnedByKanbo = require_migrate.markBoardFileOwnedByKanbo;
+exports.migrateBoardFile = require_migrate.migrateBoardFile;
+exports.openBoardDatabase = require_migrate.openBoardDatabase;
+exports.readBoardFileContents = require_migrate.readBoardFileContents;
+exports.readBoardFileOwner = require_migrate.readBoardFileOwner;
+exports.runSqliteTransaction = require_migrate.runSqliteTransaction;

package/dist/lib/sqlite/index.d.cts

@@ -0,0 +1,175 @@
+import { _ as issueStatuses, c as IssueStatus, d as issueComments, f as issueFieldChanges, g as issueRuns, h as issueRelations, i as IssueMilestone, l as KanbanMeta, n as IssueComment, o as IssueRelation, p as issueMilestones, r as IssueFieldChange, s as IssueRun, t as Issue, u as boardSqliteSchema, v as issues, y as kanbanMeta } from "../schema-fsHqNAip.cjs";
+import { a as BoardStore } from "../board-store-BHHo_ZlR.cjs";
+import { t as BOARD_SCHEMA_EPOCH } from "../schema-epoch-ZyumVL_A.cjs";
+import { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+import { Database } from "better-sqlite3";
+//#region src/sqlite/transaction.d.ts
+/**
+ * The database handle itself — what the host hands the board — and not an open
+ * transaction on it: the helper reaches for the driver connection, which a
+ * drizzle `SQLiteTransaction` does not carry.
+ *
+ * The schema parameter is `Record<string, unknown>` rather than any particular
+ * schema, which is what lets one type stand for all three of the files a board
+ * can live in (ruling 5-3): a handle drizzle was given a host app's whole schema
+ * satisfies it, and so does one given only the board's own nine tables. The
+ * board never reaches for `database.query`, so the relational builder those
+ * generics shape is not something this package gives up by asking for less —
+ * `src/sqlite/database-type.test.ts` is the probe that says both handles still
+ * arrive here.
+ */
+type SqliteDatabase = BetterSQLite3Database<Record<string, unknown>>;
+/**
+ * How the outer `begin` takes its write lock. `deferred` — the SQLite default —
+ * waits for the first write; `immediate` takes the lock up front, so two
+ * processes racing for the same file fail fast instead of half-way through.
+ * A nested scope is a savepoint and takes no lock of its own, so the mode only
+ * reaches the outer statement.
+ */
+type SqliteTransactionMode = 'deferred' | 'immediate';
+/**
+ * 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.
+ */
+declare function runSqliteTransaction<T>(database: SqliteDatabase, fn: () => Promise<T>, options?: {
+  mode?: SqliteTransactionMode;
+}): Promise<T>;
+//#endregion
+//#region src/sqlite/board-store.sqlite.d.ts
+/**
+ * `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.
+ */
+declare function createSqliteBoardStore(options: {
+  database: () => SqliteDatabase;
+}): BoardStore;
+//#endregion
+//#region src/sqlite/migrate.d.ts
+/**
+ * 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.
+ */
+declare function getBoardSqliteMigrationsPath(): string;
+/**
+ * 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).
+ */
+declare function migrateBoardFile(database: SqliteDatabase): void;
+//#endregion
+//#region src/sqlite/open-database.d.ts
+/** One open board file: the drizzle handle, the driver beneath it, and the way to let go. */
+interface BoardDatabase {
+  database: SqliteDatabase;
+  connection: Database;
+  close: () => void;
+}
+/**
+ * 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.
+ */
+declare function openBoardDatabase(path: string): Promise<BoardDatabase>;
+/**
+ * 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.
+ */
+declare function assertBoardSchema(database: SqliteDatabase): void;
+/**
+ * Who created this board file's tables from nothing: this package
+ * (`kanbo init --file`), or a host app whose own database the board lives in.
+ */
+type BoardFileOwner = 'kanbo' | 'host';
+/**
+ * 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.
+ */
+declare function readBoardFileOwner(database: SqliteDatabase): BoardFileOwner;
+/**
+ * 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.
+ */
+declare function markBoardFileOwnedByKanbo(database: SqliteDatabase): void;
+/** What a file already holds, before a board is opened on it or written into it. */
+interface BoardFileContents {
+  /** No tables at all — a path nothing has been created in yet, or a zero-byte file. */
+  empty: boolean;
+  /** Whose board the tables are, by the `file_owner` marker (ruling 5-4). Says nothing about an empty file. */
+  owner: BoardFileOwner;
+}
+/**
+ * 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.
+ */
+declare function readBoardFileContents(path: string): BoardFileContents;
+//#endregion
+export { BOARD_SCHEMA_EPOCH, type BoardDatabase, type BoardFileContents, type BoardFileOwner, type Issue, type IssueComment, type IssueFieldChange, type IssueMilestone, type IssueRelation, type IssueRun, type IssueStatus, type KanbanMeta, type SqliteDatabase, type SqliteTransactionMode, assertBoardSchema, boardSqliteSchema, createSqliteBoardStore, getBoardSqliteMigrationsPath, issueComments, issueFieldChanges, issueMilestones, issueRelations, issueRuns, issueStatuses, issues, kanbanMeta, markBoardFileOwnedByKanbo, migrateBoardFile, openBoardDatabase, readBoardFileContents, readBoardFileOwner, runSqliteTransaction };
+//# sourceMappingURL=index.d.cts.map

package/dist/lib/sqlite/index.d.mts

@@ -0,0 +1,175 @@
+import { _ as issueStatuses, c as IssueStatus, d as issueComments, f as issueFieldChanges, g as issueRuns, h as issueRelations, i as IssueMilestone, l as KanbanMeta, n as IssueComment, o as IssueRelation, p as issueMilestones, r as IssueFieldChange, s as IssueRun, t as Issue, u as boardSqliteSchema, v as issues, y as kanbanMeta } from "../schema-fsHqNAip.mjs";
+import { a as BoardStore } from "../board-store-B16YarvX.mjs";
+import { t as BOARD_SCHEMA_EPOCH } from "../schema-epoch-ZyumVL_A.mjs";
+import { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+import { Database } from "better-sqlite3";
+//#region src/sqlite/transaction.d.ts
+/**
+ * The database handle itself — what the host hands the board — and not an open
+ * transaction on it: the helper reaches for the driver connection, which a
+ * drizzle `SQLiteTransaction` does not carry.
+ *
+ * The schema parameter is `Record<string, unknown>` rather than any particular
+ * schema, which is what lets one type stand for all three of the files a board
+ * can live in (ruling 5-3): a handle drizzle was given a host app's whole schema
+ * satisfies it, and so does one given only the board's own nine tables. The
+ * board never reaches for `database.query`, so the relational builder those
+ * generics shape is not something this package gives up by asking for less —
+ * `src/sqlite/database-type.test.ts` is the probe that says both handles still
+ * arrive here.
+ */
+type SqliteDatabase = BetterSQLite3Database<Record<string, unknown>>;
+/**
+ * How the outer `begin` takes its write lock. `deferred` — the SQLite default —
+ * waits for the first write; `immediate` takes the lock up front, so two
+ * processes racing for the same file fail fast instead of half-way through.
+ * A nested scope is a savepoint and takes no lock of its own, so the mode only
+ * reaches the outer statement.
+ */
+type SqliteTransactionMode = 'deferred' | 'immediate';
+/**
+ * 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.
+ */
+declare function runSqliteTransaction<T>(database: SqliteDatabase, fn: () => Promise<T>, options?: {
+  mode?: SqliteTransactionMode;
+}): Promise<T>;
+//#endregion
+//#region src/sqlite/board-store.sqlite.d.ts
+/**
+ * `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.
+ */
+declare function createSqliteBoardStore(options: {
+  database: () => SqliteDatabase;
+}): BoardStore;
+//#endregion
+//#region src/sqlite/migrate.d.ts
+/**
+ * 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.
+ */
+declare function getBoardSqliteMigrationsPath(): string;
+/**
+ * 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).
+ */
+declare function migrateBoardFile(database: SqliteDatabase): void;
+//#endregion
+//#region src/sqlite/open-database.d.ts
+/** One open board file: the drizzle handle, the driver beneath it, and the way to let go. */
+interface BoardDatabase {
+  database: SqliteDatabase;
+  connection: Database;
+  close: () => void;
+}
+/**
+ * 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.
+ */
+declare function openBoardDatabase(path: string): Promise<BoardDatabase>;
+/**
+ * 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.
+ */
+declare function assertBoardSchema(database: SqliteDatabase): void;
+/**
+ * Who created this board file's tables from nothing: this package
+ * (`kanbo init --file`), or a host app whose own database the board lives in.
+ */
+type BoardFileOwner = 'kanbo' | 'host';
+/**
+ * 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.
+ */
+declare function readBoardFileOwner(database: SqliteDatabase): BoardFileOwner;
+/**
+ * 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.
+ */
+declare function markBoardFileOwnedByKanbo(database: SqliteDatabase): void;
+/** What a file already holds, before a board is opened on it or written into it. */
+interface BoardFileContents {
+  /** No tables at all — a path nothing has been created in yet, or a zero-byte file. */
+  empty: boolean;
+  /** Whose board the tables are, by the `file_owner` marker (ruling 5-4). Says nothing about an empty file. */
+  owner: BoardFileOwner;
+}
+/**
+ * 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.
+ */
+declare function readBoardFileContents(path: string): BoardFileContents;
+//#endregion
+export { BOARD_SCHEMA_EPOCH, type BoardDatabase, type BoardFileContents, type BoardFileOwner, type Issue, type IssueComment, type IssueFieldChange, type IssueMilestone, type IssueRelation, type IssueRun, type IssueStatus, type KanbanMeta, type SqliteDatabase, type SqliteTransactionMode, assertBoardSchema, boardSqliteSchema, createSqliteBoardStore, getBoardSqliteMigrationsPath, issueComments, issueFieldChanges, issueMilestones, issueRelations, issueRuns, issueStatuses, issues, kanbanMeta, markBoardFileOwnedByKanbo, migrateBoardFile, openBoardDatabase, readBoardFileContents, readBoardFileOwner, runSqliteTransaction };
+//# sourceMappingURL=index.d.mts.map

package/dist/lib/sqlite/index.mjs

@@ -0,0 +1,4 @@
+import { r as BOARD_SCHEMA_EPOCH } from "../migrations-path-Ciwan537.mjs";
+import { boardSqliteSchema, issueComments, issueFieldChanges, issueMilestones, issueRelations, issueRuns, issueStatuses, issues, kanbanMeta } from "./schema.mjs";
+import { a as openBoardDatabase, c as createSqliteBoardStore, i as markBoardFileOwnedByKanbo, l as runSqliteTransaction, n as migrateBoardFile, o as readBoardFileContents, r as assertBoardSchema, s as readBoardFileOwner, t as getBoardSqliteMigrationsPath } from "../migrate-BhYi9cXw.mjs";
+export { BOARD_SCHEMA_EPOCH, assertBoardSchema, boardSqliteSchema, createSqliteBoardStore, getBoardSqliteMigrationsPath, issueComments, issueFieldChanges, issueMilestones, issueRelations, issueRuns, issueStatuses, issues, kanbanMeta, markBoardFileOwnedByKanbo, migrateBoardFile, openBoardDatabase, readBoardFileContents, readBoardFileOwner, runSqliteTransaction };

package/dist/lib/sqlite/schema.cjs

@@ -0,0 +1,266 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let drizzle_orm = require("drizzle-orm");
+let drizzle_orm_sqlite_core = require("drizzle-orm/sqlite-core");
+//#region src/sqlite/schema.ts
+/**
+* The board, as a SQLite file holds it.
+*
+* These nine tables are the board itself, and this package owns them: the same
+* logical schema as `src/postgres/schema.ts`, written for the dialect a file
+* speaks. They live in three different places at runtime — a host app's own
+* database, a board file of a project's own, and neither of those when the
+* board is a Postgres database — and none of those homes owns the shape. A host
+* app re-exports these very objects from its own schema, so its tables and
+* these are the same tables rather than two declarations that have to be kept
+* in step.
+*
+* **Every reference out of the board is a plain text column** (ruling 5-1).
+* `workspace_id`, `delegate_agent_id`, `delegate_provider_target_id` and
+* `source_chat_session_id` name rows in a host app's tables, and a board file of
+* a project's own has no such tables to point at — so they are soft references
+* into whichever app is looking, exactly as they are on Postgres. What an
+* `ON DELETE` would do is done in the open by the app that deletes the row: it
+* empties a removed workspace's board, and clears the delegation off the cards
+* that named a removed agent or provider target. The foreign keys that stay are the
+* ones that point *inside* the board, and they still cascade.
+*/
+const textPk = () => (0, drizzle_orm_sqlite_core.text)("id").primaryKey();
+const timestamps = () => ({
+	createdAt: (0, drizzle_orm_sqlite_core.int)("created_at").notNull().default(drizzle_orm.sql`(unixepoch())`),
+	updatedAt: (0, drizzle_orm_sqlite_core.int)("updated_at").notNull().default(drizzle_orm.sql`(unixepoch())`)
+});
+const createdAt = () => ({ createdAt: (0, drizzle_orm_sqlite_core.int)("created_at").notNull().default(drizzle_orm.sql`(unixepoch())`) });
+const issueStatuses = (0, drizzle_orm_sqlite_core.sqliteTable)("issue_statuses", {
+	id: textPk(),
+	workspaceId: (0, drizzle_orm_sqlite_core.text)("workspace_id").notNull(),
+	name: (0, drizzle_orm_sqlite_core.text)("name").notNull(),
+	description: (0, drizzle_orm_sqlite_core.text)("description"),
+	color: (0, drizzle_orm_sqlite_core.text)("color"),
+	category: (0, drizzle_orm_sqlite_core.text)("category", { enum: [
+		"triage",
+		"backlog",
+		"unstarted",
+		"started",
+		"completed",
+		"canceled"
+	] }).notNull().default("unstarted"),
+	order: (0, drizzle_orm_sqlite_core.int)("order").notNull().default(0),
+	/**
+	* What a card must satisfy before an agent may put it in this column — a JSON
+	* array of `ENTRY_RULES` (ruling 6-1); `null` asks for nothing. Read it
+	* through `readEntryRules`, never by hand.
+	*/
+	entryRules: (0, drizzle_orm_sqlite_core.text)("entry_rules"),
+	...createdAt()
+}, (table) => ({
+	byWorkspace: (0, drizzle_orm_sqlite_core.index)("issue_statuses_workspace_id_idx").on(table.workspaceId),
+	byWorkspaceName: (0, drizzle_orm_sqlite_core.uniqueIndex)("issue_statuses_workspace_name_unique").on(table.workspaceId, table.name)
+}));
+const issueMilestones = (0, drizzle_orm_sqlite_core.sqliteTable)("issue_milestones", {
+	id: textPk(),
+	workspaceId: (0, drizzle_orm_sqlite_core.text)("workspace_id").notNull(),
+	title: (0, drizzle_orm_sqlite_core.text)("title").notNull(),
+	description: (0, drizzle_orm_sqlite_core.text)("description"),
+	/** When the milestone, read as a sprint, begins (unix seconds); null for a plain milestone. */
+	startDate: (0, drizzle_orm_sqlite_core.int)("start_date"),
+	dueDate: (0, drizzle_orm_sqlite_core.int)("due_date"),
+	status: (0, drizzle_orm_sqlite_core.text)("status", { enum: ["open", "closed"] }).notNull().default("open"),
+	...timestamps()
+}, (table) => ({ byWorkspace: (0, drizzle_orm_sqlite_core.index)("issue_milestones_workspace_id_idx").on(table.workspaceId) }));
+const issues = (0, drizzle_orm_sqlite_core.sqliteTable)("issues", {
+	id: textPk(),
+	workspaceId: (0, drizzle_orm_sqlite_core.text)("workspace_id").notNull(),
+	number: (0, drizzle_orm_sqlite_core.int)("number").notNull(),
+	statusId: (0, drizzle_orm_sqlite_core.text)("status_id").references(() => issueStatuses.id, { onDelete: "set null" }),
+	milestoneId: (0, drizzle_orm_sqlite_core.text)("milestone_id").references(() => issueMilestones.id, { onDelete: "set null" }),
+	parentIssueId: (0, drizzle_orm_sqlite_core.text)("parent_issue_id").references(() => issues.id, { onDelete: "set null" }),
+	title: (0, drizzle_orm_sqlite_core.text)("title").notNull(),
+	description: (0, drizzle_orm_sqlite_core.text)("description"),
+	priority: (0, drizzle_orm_sqlite_core.text)("priority", { enum: [
+		"none",
+		"low",
+		"medium",
+		"high",
+		"urgent"
+	] }).notNull().default("none"),
+	labels: (0, drizzle_orm_sqlite_core.text)("labels").notNull().default("[]"),
+	assigneeKind: (0, drizzle_orm_sqlite_core.text)("assignee_kind"),
+	assigneeId: (0, drizzle_orm_sqlite_core.text)("assignee_id"),
+	dueDate: (0, drizzle_orm_sqlite_core.int)("due_date"),
+	createdByKind: (0, drizzle_orm_sqlite_core.text)("created_by_kind", { enum: [
+		"user",
+		"agent",
+		"system",
+		"provider-target"
+	] }).notNull().default("user"),
+	createdById: (0, drizzle_orm_sqlite_core.text)("created_by_id").notNull().default("__self__"),
+	sourceChatSessionId: (0, drizzle_orm_sqlite_core.text)("source_chat_session_id"),
+	delegateAgentId: (0, drizzle_orm_sqlite_core.text)("delegate_agent_id"),
+	delegateProviderTargetId: (0, drizzle_orm_sqlite_core.text)("delegate_provider_target_id"),
+	contextRefs: (0, drizzle_orm_sqlite_core.text)("context_refs").notNull().default("[]"),
+	statusLine: (0, drizzle_orm_sqlite_core.text)("status_line"),
+	waitingFor: (0, drizzle_orm_sqlite_core.text)("waiting_for", { enum: ["human"] }),
+	executionMode: (0, drizzle_orm_sqlite_core.text)("execution_mode", { enum: ["worktree", "main"] }).notNull().default("worktree"),
+	order: (0, drizzle_orm_sqlite_core.int)("order").notNull().default(0),
+	...timestamps()
+}, (table) => ({
+	byWorkspace: (0, drizzle_orm_sqlite_core.index)("issues_workspace_id_idx").on(table.workspaceId),
+	byWorkspaceNumber: (0, drizzle_orm_sqlite_core.uniqueIndex)("issues_workspace_number_unique").on(table.workspaceId, table.number),
+	byStatus: (0, drizzle_orm_sqlite_core.index)("issues_status_id_idx").on(table.statusId),
+	byMilestone: (0, drizzle_orm_sqlite_core.index)("issues_milestone_id_idx").on(table.milestoneId),
+	byParent: (0, drizzle_orm_sqlite_core.index)("issues_parent_issue_id_idx").on(table.parentIssueId),
+	byDelegateAgent: (0, drizzle_orm_sqlite_core.index)("issues_delegate_agent_id_idx").on(table.delegateAgentId),
+	byDelegateProviderTarget: (0, drizzle_orm_sqlite_core.index)("issues_delegate_provider_target_id_idx").on(table.delegateProviderTargetId)
+}));
+const issueComments = (0, drizzle_orm_sqlite_core.sqliteTable)("issue_comments", {
+	id: textPk(),
+	issueId: (0, drizzle_orm_sqlite_core.text)("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+	content: (0, drizzle_orm_sqlite_core.text)("content").notNull(),
+	authorKind: (0, drizzle_orm_sqlite_core.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: (0, drizzle_orm_sqlite_core.text)("author_id"),
+	sourceChatSessionId: (0, drizzle_orm_sqlite_core.text)("source_chat_session_id"),
+	agentActivityId: (0, drizzle_orm_sqlite_core.text)("agent_activity_id"),
+	dedupeKey: (0, drizzle_orm_sqlite_core.text)("dedupe_key"),
+	...createdAt()
+}, (table) => ({
+	byIssue: (0, drizzle_orm_sqlite_core.index)("issue_comments_issue_id_idx").on(table.issueId),
+	byIssueDedupeKey: (0, drizzle_orm_sqlite_core.uniqueIndex)("issue_comments_issue_dedupe_idx").on(table.issueId, table.dedupeKey)
+}));
+const issueRuns = (0, drizzle_orm_sqlite_core.sqliteTable)("issue_runs", {
+	id: textPk(),
+	issueId: (0, drizzle_orm_sqlite_core.text)("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+	launchedByKind: (0, drizzle_orm_sqlite_core.text)("launched_by_kind", { enum: [
+		"user",
+		"agent",
+		"external"
+	] }).notNull().default("user"),
+	launchedById: (0, drizzle_orm_sqlite_core.text)("launched_by_id"),
+	agentId: (0, drizzle_orm_sqlite_core.text)("agent_id"),
+	agentName: (0, drizzle_orm_sqlite_core.text)("agent_name").notNull(),
+	host: (0, drizzle_orm_sqlite_core.text)("host"),
+	executionMode: (0, drizzle_orm_sqlite_core.text)("execution_mode", { enum: ["worktree", "main"] }).notNull().default("worktree"),
+	branch: (0, drizzle_orm_sqlite_core.text)("branch"),
+	worktreePath: (0, drizzle_orm_sqlite_core.text)("worktree_path"),
+	state: (0, drizzle_orm_sqlite_core.text)("state", { enum: [
+		"running",
+		"finished",
+		"failed",
+		"stopped"
+	] }).notNull().default("running"),
+	chatSessionId: (0, drizzle_orm_sqlite_core.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: (0, drizzle_orm_sqlite_core.text)("external_session_ref"),
+	startedAt: (0, drizzle_orm_sqlite_core.int)("started_at").notNull().default(drizzle_orm.sql`(unixepoch())`),
+	endedAt: (0, drizzle_orm_sqlite_core.int)("ended_at")
+}, (table) => ({
+	byIssue: (0, drizzle_orm_sqlite_core.index)("issue_runs_issue_id_idx").on(table.issueId),
+	byIssueState: (0, drizzle_orm_sqlite_core.index)("issue_runs_issue_state_idx").on(table.issueId, table.state),
+	byChatSession: (0, drizzle_orm_sqlite_core.index)("issue_runs_chat_session_idx").on(table.chatSessionId)
+}));
+const issueRelations = (0, drizzle_orm_sqlite_core.sqliteTable)("issue_relations", {
+	id: textPk(),
+	sourceIssueId: (0, drizzle_orm_sqlite_core.text)("source_issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+	targetIssueId: (0, drizzle_orm_sqlite_core.text)("target_issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+	type: (0, drizzle_orm_sqlite_core.text)("type", { enum: [
+		"blocks",
+		"duplicates",
+		"relates_to"
+	] }).notNull(),
+	...createdAt()
+}, (table) => ({
+	bySource: (0, drizzle_orm_sqlite_core.index)("issue_relations_source_issue_id_idx").on(table.sourceIssueId),
+	byTarget: (0, drizzle_orm_sqlite_core.index)("issue_relations_target_issue_id_idx").on(table.targetIssueId),
+	byPairType: (0, drizzle_orm_sqlite_core.uniqueIndex)("issue_relations_pair_type_unique").on(table.sourceIssueId, table.targetIssueId, table.type)
+}));
+const issueFieldChanges = (0, drizzle_orm_sqlite_core.sqliteTable)("issue_field_changes", {
+	id: textPk(),
+	issueId: (0, drizzle_orm_sqlite_core.text)("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+	field: (0, drizzle_orm_sqlite_core.text)("field").notNull(),
+	fromValue: (0, drizzle_orm_sqlite_core.text)("from_value"),
+	toValue: (0, drizzle_orm_sqlite_core.text)("to_value"),
+	actorKind: (0, drizzle_orm_sqlite_core.text)("actor_kind", { enum: [
+		"user",
+		"agent",
+		"provider-target",
+		"system"
+	] }).notNull().default("user"),
+	actorId: (0, drizzle_orm_sqlite_core.text)("actor_id"),
+	sourceChatSessionId: (0, drizzle_orm_sqlite_core.text)("source_chat_session_id"),
+	...createdAt()
+}, (table) => ({ byIssue: (0, drizzle_orm_sqlite_core.index)("issue_field_changes_issue_id_idx").on(table.issueId) }));
+/**
+* A pull request someone said belongs to a card.
+*
+* The link is the board's; what the pull request *is* — open, merged, green —
+* is GitHub's, and the board keeps none of it. Whoever watches GitHub reads the
+* links here and writes what it saw as comments on the card, so this row is a
+* name (`owner/repo#number`, and the URL it came from) and who gave it. One
+* card names one pull request once; the same pull request may belong to several
+* cards, which is why `(owner, repo, number)` is indexed on its own.
+*/
+const issuePullRequests = (0, drizzle_orm_sqlite_core.sqliteTable)("issue_pull_requests", {
+	id: textPk(),
+	issueId: (0, drizzle_orm_sqlite_core.text)("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+	owner: (0, drizzle_orm_sqlite_core.text)("owner").notNull(),
+	repo: (0, drizzle_orm_sqlite_core.text)("repo").notNull(),
+	number: (0, drizzle_orm_sqlite_core.int)("number").notNull(),
+	url: (0, drizzle_orm_sqlite_core.text)("url").notNull(),
+	createdByKind: (0, drizzle_orm_sqlite_core.text)("created_by_kind", { enum: [
+		"user",
+		"agent",
+		"provider-target",
+		"system"
+	] }).notNull(),
+	createdById: (0, drizzle_orm_sqlite_core.text)("created_by_id"),
+	...createdAt()
+}, (table) => ({
+	byIssuePullRequest: (0, drizzle_orm_sqlite_core.uniqueIndex)("issue_pull_requests_issue_pr_unique").on(table.issueId, table.owner, table.repo, table.number),
+	byPullRequest: (0, drizzle_orm_sqlite_core.index)("issue_pull_requests_pr_idx").on(table.owner, table.repo, table.number)
+}));
+/**
+* Monotonic counters the board keeps for its readers: `board` is bumped by the
+* board operations layer once per write transaction that changed something, so a
+* poller can tell a changed board from an unchanged one, and `schema_epoch`
+* records the board schema generation the file was written with.
+*/
+const kanbanMeta = (0, drizzle_orm_sqlite_core.sqliteTable)("kanban_meta", {
+	key: (0, drizzle_orm_sqlite_core.text)("key").primaryKey(),
+	revision: (0, drizzle_orm_sqlite_core.int)("revision").notNull().default(0),
+	updatedAt: (0, drizzle_orm_sqlite_core.int)("updated_at").notNull().default(drizzle_orm.sql`(unixepoch())`)
+});
+/** Every table of the board, in the order a reader of the schema wants them. */
+const boardSqliteSchema = {
+	issueStatuses,
+	issueMilestones,
+	issues,
+	issueComments,
+	issueRuns,
+	issueRelations,
+	issueFieldChanges,
+	issuePullRequests,
+	kanbanMeta
+};
+//#endregion
+exports.boardSqliteSchema = boardSqliteSchema;
+exports.issueComments = issueComments;
+exports.issueFieldChanges = issueFieldChanges;
+exports.issueMilestones = issueMilestones;
+exports.issuePullRequests = issuePullRequests;
+exports.issueRelations = issueRelations;
+exports.issueRuns = issueRuns;
+exports.issueStatuses = issueStatuses;
+exports.issues = issues;
+exports.kanbanMeta = kanbanMeta;
+
+//# sourceMappingURL=schema.cjs.map