@zq-silk/yui 0.5.2 → 0.6.0

package/dist/storage/persistenceWorker.js

@@ -0,0 +1,194 @@
+/**
+ * Persistence Worker Thread (task-21, work-item-5).
+ *
+ * The worker owns the {@link SqliteTaskStore} connection: one writer connection
+ * (single-writer, `BEGIN IMMEDIATE`) plus a small read pool (separate WAL
+ * connections that never take the write lock, §3.2). The main thread never
+ * touches the db; it sends commands over a `MessageChannel` port and receives
+ * results.
+ *
+ * The port handshake, dispatch, cancellation observation, and error
+ * serialization are provided by the shared `core/boundedRpc` worker host
+ * (`runRpcWorker`); this module supplies the storage dialect:
+ *
+ *   - `call` ......... a `TaskStore` method. Reads use the read pool; writes
+ *                      run on the writer inside a transaction and are made
+ *                      idempotent via the durable outbox (§5.4): a retried
+ *                      write after a crash returns `already-applied`.
+ *   - `transaction` .. an ordered command batch inside one
+ *                      `BEGIN IMMEDIATE … COMMIT` on the writer (§3.2),
+ *                      yielding between commands so a `cancel` can roll back an
+ *                      open transaction (§3.1). Committed batches are not undone.
+ *   - `observer` ..... a controller observer method hosted by the worker (the
+ *                      `FileSchedulerStoreAdapter` folds run here, off the main
+ *                      event loop).
+ *   - `expectedRevision` enforces the global revision CAS in the same txn
+ *                      (§5.3); a mismatch fails with `StorageConflictError`.
+ *
+ * `synchronous=FULL` is never weakened; the worker opens the store with the same
+ * pragmas as the in-process path (WAL, FULL, busy_timeout).
+ */
+import { runRpcWorker } from "../core/boundedRpc.js";
+import { SqliteTaskStore } from "./sqliteStore.js";
+import { StorageRecordError } from "./taskStore.js";
+// -- method invocation -------------------------------------------------------
+function invokeMethod(target, method, args) {
+    const fn = target[method];
+    if (typeof fn !== "function") {
+        throw new StorageRecordError(`Unknown store method: ${method}`);
+    }
+    return fn.apply(target, args);
+}
+/**
+ * Sentinel returned by a handler when the durable outbox already records the
+ * request's effect (§5.4). The host's `result` builder maps it to an
+ * `already-applied` response. Store results are plain JSON data, so a Symbol
+ * sentinel can never collide with a real result.
+ */
+const ALREADY_APPLIED = Symbol("already-applied");
+const state = {
+    writer: undefined,
+    readers: [],
+    readIndex: 0,
+    observer: undefined,
+    cancelled: new Set()
+};
+function nextReader() {
+    const reader = state.readers[state.readIndex % state.readers.length];
+    state.readIndex += 1;
+    return reader;
+}
+// -- request handlers --------------------------------------------------------
+async function handleInit(request) {
+    const writer = new SqliteTaskStore(request.home);
+    const poolSize = request.readPoolSize ?? 4;
+    const readers = [];
+    for (let index = 0; index < poolSize; index += 1) {
+        readers.push(new SqliteTaskStore(request.home));
+    }
+    state.writer = writer;
+    state.readers = readers;
+    if (request.observerModule !== undefined) {
+        const module = (await import(request.observerModule));
+        const Adapter = module.FileSchedulerStoreAdapter;
+        if (Adapter === undefined) {
+            throw new Error(`Observer module ${request.observerModule} does not export FileSchedulerStoreAdapter.`);
+        }
+        const host = new Adapter(writer);
+        state.observer = {
+            invoke(method, args) {
+                return invokeMethod(host, method, args);
+            }
+        };
+    }
+}
+async function handleCall(request) {
+    const { requestId, method, args, readOnly } = request;
+    if (readOnly) {
+        return invokeMethod(nextReader(), method, args);
+    }
+    // Write. With a requestId, make it idempotent via the durable outbox
+    // (§5.4): skip if already committed, otherwise record the effect in the
+    // same transaction. The worker is single-threaded, so the check and the
+    // write are race-free; the UNIQUE constraint is the backstop.
+    const writer = state.writer;
+    if (writer === undefined)
+        throw new Error("Worker not initialized.");
+    if (writer.hasOutboxEntry(requestId)) {
+        return ALREADY_APPLIED;
+    }
+    return writer.transaction((store) => invokeMethod(store, method, args), { requestId });
+}
+async function handleTransaction(request) {
+    const { requestId, commands, expectedRevision } = request;
+    const writer = state.writer;
+    if (writer === undefined) {
+        throw new Error("Worker not initialized.");
+    }
+    // Idempotent replay: a batch that committed before a crash is not re-run.
+    if (writer.hasOutboxEntry(requestId)) {
+        return ALREADY_APPLIED;
+    }
+    const shouldCancel = () => state.cancelled.has(requestId);
+    try {
+        return await writer.transactionAsyncBatch(commands, {
+            requestId,
+            ...(expectedRevision === undefined ? {} : { expectedRevision }),
+            shouldCancel
+        });
+    }
+    finally {
+        state.cancelled.delete(requestId);
+    }
+}
+async function handleObserver(request) {
+    if (state.observer === undefined) {
+        throw new Error("Worker has no observer host (observerModule not provided at init).");
+    }
+    return state.observer.invoke(request.method, request.args);
+}
+// -- worker host --------------------------------------------------------------
+runRpcWorker({
+    serial: true,
+    kindOf: (request) => {
+        switch (request.kind) {
+            case "init":
+                return "init";
+            case "cancel":
+                return "cancel";
+            case "shutdown":
+                return "shutdown";
+            case "call":
+            case "transaction":
+            case "observer":
+                return "request";
+        }
+    },
+    requestIdOf: (request) => {
+        switch (request.kind) {
+            case "call":
+            case "transaction":
+            case "observer":
+            case "cancel":
+                return request.requestId;
+            case "init":
+            case "shutdown":
+                return undefined;
+        }
+    },
+    init: (request) => handleInit(request),
+    handle: (request) => {
+        switch (request.kind) {
+            case "call":
+                return handleCall(request);
+            case "transaction":
+                return handleTransaction(request);
+            case "observer":
+                return handleObserver(request);
+            case "init":
+            case "cancel":
+            case "shutdown":
+                throw new Error(`Unexpected request kind for handle: ${request.kind}`);
+        }
+    },
+    cancel: (requestId) => {
+        state.cancelled.add(requestId);
+    },
+    shutdown: async () => {
+        for (const reader of state.readers) {
+            try {
+                reader.close();
+            }
+            catch { /* already closed */ }
+        }
+        try {
+            state.writer?.close();
+        }
+        catch { /* already closed */ }
+    },
+    ready: () => ({ kind: "ready" }),
+    result: (requestId, value) => (value === ALREADY_APPLIED
+        ? { kind: "already-applied", requestId }
+        : { kind: "result", requestId, result: value }),
+    error: (requestId, error) => ({ kind: "error", requestId, error })
+});

package/dist/storage/sqliteSchema.js

@@ -0,0 +1,444 @@
+/**
+ * SQLite WAL control-plane schema and migration runner (task-21, work-item-3).
+ *
+ * This is the normalized, `task_id`-partitioned schema that replaces the single
+ * aggregate `state.json` document. It implements the logical schema from
+ * `docs/sqlite-control-plane-design.md` §4 (31 tables) plus the cross-task
+ * coordination tables the design references in §5:
+ *
+ *   - `global_sequences` (§5.3): global record ID high-water marks.
+ *   - `outbox` (§5.4): durable outbox with `UNIQUE(request_id)` for exactly-once.
+ *   - `config`: the `YuiConfig` singleton (the design keeps `home_meta` for
+ *     identity/revision/versions; config is a separate singleton).
+ *
+ * Record payloads are stored two ways, per §4: typed columns for fields that are
+ * queried/filtered/used-for-CAS, and a `payload` JSON column holding the full
+ * versioned record (including its family `schemaVersion`). The record axis of
+ * the three-axis versioning is therefore unchanged.
+ *
+ * The migration runner is idempotent: it records applied versions in
+ * `schema_migrations` and uses `CREATE TABLE IF NOT EXISTS`, so re-running on an
+ * already-current database is a no-op and a crash mid-migration is rolled back
+ * by SQLite (DDL is transactional) and re-applied on the next open.
+ */
+import { createHash } from "node:crypto";
+/** The SQLite layout version (state.json layout 6 -> SQLite layout 7, per §8.1). */
+export const SQLITE_LAYOUT_VERSION = 7;
+/** The aggregate version of the normalized SQLite schema. */
+export const SQLITE_AGGREGATE_VERSION = 1;
+/** The current schema migration version. */
+export const SQLITE_SCHEMA_VERSION = 1;
+/** Telemetry retention bounds (§4.4). Open question 3 in §11; defaults from the design. */
+export const TELEMETRY_KEEP_PER_GENERATION = 200;
+export const TELEMETRY_RUN_CAP = 50_000;
+/**
+ * Version 1 migration: creates every table and index.
+ *
+ * `synchronous`/`foreign_keys`/`busy_timeout` are per-connection PRAGMAs set by
+ * the store; `journal_mode=WAL` is a persistent database property set on open.
+ * The migration itself only contains schema objects.
+ */
+const MIGRATION_1_SQL = `
+-- Global catalog and coordination (§4.1) -------------------------------------
+
+CREATE TABLE IF NOT EXISTS home_meta (
+  id                INTEGER PRIMARY KEY CHECK (id = 1),
+  home_identity     TEXT NOT NULL,
+  revision          INTEGER NOT NULL,
+  layout_version    INTEGER NOT NULL,
+  aggregate_version INTEGER NOT NULL,
+  created_at        TEXT NOT NULL,
+  updated_at        TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS config (
+  id         INTEGER PRIMARY KEY CHECK (id = 1),
+  payload    TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS configured_agents (
+  id         TEXT PRIMARY KEY,
+  payload    TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS agent_profiles (
+  id         TEXT PRIMARY KEY,
+  payload    TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS projects (
+  id         TEXT PRIMARY KEY,
+  name       TEXT NOT NULL,
+  path       TEXT NOT NULL,
+  payload    TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS global_roles (
+  name       TEXT PRIMARY KEY,
+  payload    TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS global_role_session_sets (
+  name       TEXT PRIMARY KEY,
+  payload    TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (name) REFERENCES global_roles(name)
+);
+
+-- Global record ID high-water marks (§5.3).
+CREATE TABLE IF NOT EXISTS global_sequences (
+  name       TEXT PRIMARY KEY,
+  high_water INTEGER NOT NULL
+);
+
+-- Task catalog: the global active index and lifecycle lookup.
+CREATE TABLE IF NOT EXISTS tasks_catalog (
+  task_id     TEXT PRIMARY KEY,
+  status      TEXT NOT NULL,
+  lifecycle   TEXT NOT NULL,
+  is_active   INTEGER NOT NULL CHECK (is_active IN (0,1)),
+  created_at  TEXT NOT NULL,
+  updated_at  TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_tasks_active ON tasks_catalog(is_active) WHERE is_active = 1;
+
+-- Session/Workspace ownership is global (workspaces outlive task activity).
+CREATE TABLE IF NOT EXISTS managed_workspaces (
+  owner_kind  TEXT NOT NULL CHECK (owner_kind IN
+                ('task','work-item','review-round','integration-attempt','execution-lane')),
+  owner_id    TEXT NOT NULL,
+  task_id     TEXT,
+  path        TEXT NOT NULL,
+  payload     TEXT NOT NULL,
+  status      TEXT NOT NULL,
+  created_at  TEXT NOT NULL,
+  updated_at  TEXT NOT NULL,
+  PRIMARY KEY (owner_kind, owner_id)
+);
+CREATE INDEX IF NOT EXISTS idx_workspaces_task ON managed_workspaces(task_id);
+
+-- Per-task record ID high-water marks (replaces StoredTask.idHighWaterMarks).
+CREATE TABLE IF NOT EXISTS id_sequences (
+  task_id    TEXT NOT NULL,
+  kind       TEXT NOT NULL,
+  high_water INTEGER NOT NULL,
+  PRIMARY KEY (task_id, kind)
+);
+
+-- Cross-task coordination: Project locks and the Integration queue.
+CREATE TABLE IF NOT EXISTS coordination_locks (
+  lock_key     TEXT PRIMARY KEY,
+  holder_task  TEXT NOT NULL,
+  holder_ref   TEXT NOT NULL,
+  acquired_at  TEXT NOT NULL,
+  expires_at   TEXT
+);
+
+CREATE TABLE IF NOT EXISTS integration_queue (
+  queue_id     TEXT PRIMARY KEY,
+  task_id      TEXT NOT NULL,
+  project_id   TEXT NOT NULL,
+  change_set   TEXT NOT NULL,
+  status       TEXT NOT NULL,
+  payload      TEXT NOT NULL,
+  created_at   TEXT NOT NULL,
+  updated_at   TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_integration_queue_status ON integration_queue(status, created_at);
+
+-- Durable outbox (§5.4): UNIQUE(request_id) makes cross-task effects exactly-once.
+CREATE TABLE IF NOT EXISTS outbox (
+  outbox_id  INTEGER PRIMARY KEY,
+  request_id TEXT NOT NULL UNIQUE,
+  command    TEXT NOT NULL,
+  state      TEXT NOT NULL DEFAULT 'pending',
+  created_at TEXT NOT NULL,
+  applied_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_outbox_state ON outbox(state, created_at);
+
+-- Mailboxes (§4.2): per-target ordering and exactly-once signals. -------------
+
+CREATE TABLE IF NOT EXISTS mailboxes (
+  mailbox_id    INTEGER PRIMARY KEY,
+  target_kind   TEXT NOT NULL CHECK (target_kind IN
+                  ('task','role','role-runtime','global-role-runtime','operator')),
+  task_id       TEXT,
+  role_name     TEXT,
+  -- The stable mailboxTargetKey string carries the real uniqueness: the column
+  -- UNIQUE below cannot, because NULL task_id/role_name (the 'operator' and
+  -- 'global-role-runtime' targets) are distinct under SQL NULL semantics.
+  target_key    TEXT NOT NULL,
+  next_sequence INTEGER NOT NULL,
+  processing    TEXT,
+  pending       TEXT,
+  UNIQUE (target_kind, task_id, role_name)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_mailboxes_target_key
+  ON mailboxes(target_key);
+
+-- Signals are the durable append log; (mailbox, sequence) is the exactly-once key.
+CREATE TABLE IF NOT EXISTS mailbox_signals (
+  mailbox_id   INTEGER NOT NULL,
+  sequence     INTEGER NOT NULL,
+  reason       TEXT NOT NULL,
+  ref_type     TEXT,
+  ref_task_id  TEXT,
+  ref_id       TEXT,
+  occurred_at  TEXT NOT NULL,
+  request_id   TEXT NOT NULL,
+  PRIMARY KEY (mailbox_id, sequence),
+  FOREIGN KEY (mailbox_id) REFERENCES mailboxes(mailbox_id)
+);
+CREATE INDEX IF NOT EXISTS idx_mailbox_signals_request ON mailbox_signals(request_id);
+
+-- Task-partitioned tables (§4.3). Every task-local read constrains task_id. ----
+
+CREATE TABLE IF NOT EXISTS task_records (
+  task_id     TEXT PRIMARY KEY,
+  payload     TEXT NOT NULL,
+  brief       TEXT,
+  updated_at  TEXT NOT NULL,
+  FOREIGN KEY (task_id) REFERENCES tasks_catalog(task_id)
+);
+
+CREATE TABLE IF NOT EXISTS task_roles (
+  task_id     TEXT NOT NULL,
+  role_name   TEXT NOT NULL,
+  payload     TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (task_id, role_name)
+);
+
+CREATE TABLE IF NOT EXISTS role_session_sets (
+  task_id     TEXT NOT NULL,
+  role_name   TEXT NOT NULL,
+  payload     TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (task_id, role_name)
+);
+
+CREATE TABLE IF NOT EXISTS work_items (
+  task_id      TEXT NOT NULL,
+  work_item_id TEXT NOT NULL,
+  status       TEXT NOT NULL,
+  payload      TEXT NOT NULL,
+  updated_at   TEXT NOT NULL,
+  PRIMARY KEY (task_id, work_item_id)
+);
+CREATE INDEX IF NOT EXISTS idx_work_items_status ON work_items(task_id, status);
+
+CREATE TABLE IF NOT EXISTS work_item_candidates (
+  task_id      TEXT NOT NULL,
+  candidate_id TEXT NOT NULL,
+  work_item_id TEXT NOT NULL,
+  payload      TEXT NOT NULL,
+  created_at   TEXT NOT NULL,
+  PRIMARY KEY (task_id, candidate_id)
+);
+
+CREATE TABLE IF NOT EXISTS agent_runs (
+  task_id    TEXT NOT NULL,
+  run_id     TEXT NOT NULL,
+  role_name  TEXT NOT NULL,
+  status     TEXT NOT NULL,
+  payload    TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (task_id, run_id)
+);
+CREATE INDEX IF NOT EXISTS idx_agent_runs_role_status ON agent_runs(task_id, role_name, status);
+
+-- Active-run pointers (getActiveAgentRun / execution-lane runs).
+CREATE TABLE IF NOT EXISTS active_runs (
+  task_id    TEXT NOT NULL,
+  pointer    TEXT NOT NULL,
+  run_id     TEXT NOT NULL,
+  payload    TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (task_id, pointer)
+);
+
+CREATE TABLE IF NOT EXISTS review_rounds (
+  task_id         TEXT NOT NULL,
+  review_round_id TEXT NOT NULL,
+  status          TEXT NOT NULL,
+  payload         TEXT NOT NULL,
+  updated_at      TEXT NOT NULL,
+  PRIMARY KEY (task_id, review_round_id)
+);
+
+CREATE TABLE IF NOT EXISTS change_sets (
+  task_id       TEXT NOT NULL,
+  change_set_id TEXT NOT NULL,
+  project_id    TEXT NOT NULL,
+  head_sha      TEXT NOT NULL,
+  payload       TEXT NOT NULL,
+  created_at    TEXT NOT NULL,
+  PRIMARY KEY (task_id, change_set_id)
+);
+CREATE INDEX IF NOT EXISTS idx_change_sets_project ON change_sets(task_id, project_id);
+
+CREATE TABLE IF NOT EXISTS integration_attempts (
+  task_id        TEXT NOT NULL,
+  integration_id TEXT NOT NULL,
+  status         TEXT NOT NULL,
+  payload        TEXT NOT NULL,
+  updated_at     TEXT NOT NULL,
+  PRIMARY KEY (task_id, integration_id)
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+  task_id    TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  seq        INTEGER NOT NULL,
+  payload    TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (task_id, message_id)
+);
+CREATE INDEX IF NOT EXISTS idx_messages_seq ON messages(task_id, seq);
+
+CREATE TABLE IF NOT EXISTS input_requests (
+  task_id       TEXT NOT NULL,
+  input_id      TEXT NOT NULL,
+  status        TEXT NOT NULL,
+  blocks        TEXT,
+  payload       TEXT NOT NULL,
+  created_at    TEXT NOT NULL,
+  updated_at    TEXT NOT NULL,
+  PRIMARY KEY (task_id, input_id)
+);
+CREATE INDEX IF NOT EXISTS idx_input_open ON input_requests(task_id, status) WHERE status <> 'resolved';
+
+CREATE TABLE IF NOT EXISTS decisions (
+  task_id     TEXT NOT NULL,
+  decision_id TEXT NOT NULL,
+  payload     TEXT NOT NULL,
+  created_at  TEXT NOT NULL,
+  PRIMARY KEY (task_id, decision_id)
+);
+
+CREATE TABLE IF NOT EXISTS milestones (
+  task_id      TEXT NOT NULL,
+  milestone_id TEXT NOT NULL,
+  payload      TEXT NOT NULL,
+  created_at   TEXT NOT NULL,
+  PRIMARY KEY (task_id, milestone_id)
+);
+
+-- Terminal/semantic events: retained individually, never pruned.
+CREATE TABLE IF NOT EXISTS events (
+  task_id     TEXT NOT NULL,
+  event_id    TEXT NOT NULL,
+  type        TEXT NOT NULL,
+  occurred_at TEXT NOT NULL,
+  payload     TEXT NOT NULL,
+  PRIMARY KEY (task_id, event_id)
+);
+CREATE INDEX IF NOT EXISTS idx_events_type_time ON events(task_id, type, occurred_at);
+
+-- Per-task scheduler projections (leaderFailure, operatorNotification).
+CREATE TABLE IF NOT EXISTS task_projections (
+  task_id    TEXT NOT NULL,
+  kind       TEXT NOT NULL CHECK (kind IN ('leader-failure','operator-notification')),
+  payload    TEXT,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (task_id, kind)
+);
+
+-- Telemetry (§4.4): bounded, latest-per-key. WITHOUT ROWID, PK is the key.
+CREATE TABLE IF NOT EXISTS telemetry (
+  task_id     TEXT NOT NULL,
+  role_name   TEXT NOT NULL,
+  run_id      TEXT NOT NULL,
+  generation  TEXT NOT NULL,
+  progress_id TEXT NOT NULL,
+  sequence    INTEGER,
+  payload     TEXT NOT NULL,
+  received_at TEXT NOT NULL,
+  PRIMARY KEY (task_id, role_name, run_id, generation, progress_id)
+) WITHOUT ROWID;
+CREATE INDEX IF NOT EXISTS idx_telemetry_run ON telemetry(task_id, run_id);
+`;
+const MIGRATIONS = [
+    { version: 1, axis: "layout", sql: MIGRATION_1_SQL }
+];
+function checksum(sql) {
+    return createHash("sha256").update(sql).digest("hex");
+}
+/**
+ * Apply pending migrations idempotently inside transactions.
+ *
+ * Each migration runs in its own transaction: the DDL and the
+ * `schema_migrations` bookkeeping commit atomically, so a crash mid-migration
+ * rolls back and the next open re-applies cleanly. Re-running on a current
+ * database performs no work (every version is already recorded).
+ */
+export function migrateSqliteSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version     INTEGER PRIMARY KEY,
+      axis        TEXT NOT NULL CHECK (axis IN ('layout','aggregate','record')),
+      record_kind TEXT,
+      applied_at  TEXT NOT NULL,
+      checksum    TEXT NOT NULL
+    )
+  `);
+    const applied = new Set(db.prepare("SELECT version FROM schema_migrations").all().map((row) => row.version));
+    const newlyApplied = [];
+    for (const migration of MIGRATIONS) {
+        if (applied.has(migration.version))
+            continue;
+        const apply = db.transaction(() => {
+            db.exec(migration.sql);
+            db.prepare(`INSERT INTO schema_migrations (version, axis, record_kind, applied_at, checksum)
+         VALUES (?, ?, ?, ?, ?)`).run(migration.version, migration.axis, migration.recordKind ?? null, new Date().toISOString(), checksum(migration.sql));
+        });
+        apply();
+        newlyApplied.push(migration.version);
+    }
+    const version = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
+    return { applied: newlyApplied, version };
+}
+/** The names of every table the schema creates (for tests/introspection). */
+export const SQLITE_SCHEMA_TABLES = [
+    "schema_migrations",
+    "home_meta",
+    "config",
+    "configured_agents",
+    "agent_profiles",
+    "projects",
+    "global_roles",
+    "global_role_session_sets",
+    "global_sequences",
+    "tasks_catalog",
+    "managed_workspaces",
+    "id_sequences",
+    "coordination_locks",
+    "integration_queue",
+    "outbox",
+    "mailboxes",
+    "mailbox_signals",
+    "task_records",
+    "task_roles",
+    "role_session_sets",
+    "work_items",
+    "work_item_candidates",
+    "agent_runs",
+    "active_runs",
+    "review_rounds",
+    "change_sets",
+    "integration_attempts",
+    "messages",
+    "input_requests",
+    "decisions",
+    "milestones",
+    "events",
+    "task_projections",
+    "telemetry"
+];