@smithers-orchestrator/db 0.24.0 → 0.25.0

package/src/schema-migrations.js

@@ -1,5 +1,6 @@
 import { eq } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/bun-sqlite";
+import { Effect } from "effect";
 import { POSTGRES, translateDdl } from "./dialect.js";
 import { smithersSchemaMigrations } from "./internal-schema/smithersSchemaMigrations.js";
 
@@ -151,6 +152,21 @@ function tableExists(sqlite, table) {
         .get(table));
 }
 
+/**
+ * Extract the target table name from a `CREATE INDEX ... ON <table> (...)`
+ * statement so the "current indexes" migration can skip an index whose table a
+ * later migration has not created yet (e.g. a store upgrading from a ledger that
+ * predates `_smithers_docs`). Returns null when no table can be parsed, in which
+ * case the statement runs unguarded.
+ *
+ * @param {string} statement
+ * @returns {string | null}
+ */
+function indexTargetTable(statement) {
+    const match = /\bON\s+"?([A-Za-z0-9_]+)"?/i.exec(statement);
+    return match ? match[1] : null;
+}
+
 /**
  * @param {import("bun:sqlite").Database} sqlite
  * @param {string} table
@@ -166,6 +182,35 @@ function tableColumnNames(sqlite, table) {
         .filter((name) => typeof name === "string"));
 }
 
+/**
+ * @param {{ query: (config: { text: string; values?: readonly unknown[] }) => Promise<{ rows?: readonly Record<string, unknown>[] }> }} pgConn
+ * @param {string} table
+ */
+async function tableExistsPostgres(pgConn, table) {
+    const result = await pgConn.query({
+        text: "SELECT 1 AS ok FROM information_schema.tables WHERE table_schema = current_schema() AND table_name = $1 LIMIT 1",
+        values: [table],
+    });
+    return Boolean(result.rows?.[0]);
+}
+
+/**
+ * @param {{ query: (config: { text: string; values?: readonly unknown[] }) => Promise<{ rows?: readonly Record<string, unknown>[] }> }} pgConn
+ * @param {string} table
+ */
+async function tableColumnNamesPostgres(pgConn, table) {
+    if (!(await tableExistsPostgres(pgConn, table))) {
+        return new Set();
+    }
+    const result = await pgConn.query({
+        text: "SELECT column_name AS name FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = $1",
+        values: [table],
+    });
+    return new Set((result.rows ?? [])
+        .map((row) => row.name)
+        .filter((name) => typeof name === "string"));
+}
+
 /**
  * @param {import("bun:sqlite").Database} sqlite
  * @param {string} table
@@ -222,6 +267,15 @@ function createTableStatementFor(table, createTableStatements) {
     return statement;
 }
 
+/**
+ * @param {readonly string[]} createTableStatements
+ */
+function currentTableNames(createTableStatements) {
+    return createTableStatements
+        .map((statement) => statement.match(/CREATE TABLE IF NOT EXISTS\s+("?[_a-zA-Z0-9]+"?)\s*\(/i)?.[1]?.replace(/^"|"$/g, ""))
+        .filter((name) => typeof name === "string" && name.length > 0);
+}
+
 /**
  * @param {import("bun:sqlite").Database} sqlite
  * @param {string} table
@@ -237,6 +291,21 @@ function addColumnIfMissing(sqlite, table, column, definition) {
     return true;
 }
 
+/**
+ * @param {{ query: (config: { text: string; values?: readonly unknown[] }) => Promise<unknown> }} pgConn
+ * @param {string} table
+ * @param {string} column
+ * @param {string} definition
+ */
+async function addColumnIfMissingPostgres(pgConn, table, column, definition) {
+    const columns = await tableColumnNamesPostgres(pgConn, table);
+    if (columns.has(column)) {
+        return false;
+    }
+    await pgConn.query({ text: `ALTER TABLE ${quoteIdentifier(table)} ADD COLUMN ${translateDdl(POSTGRES, definition)}` });
+    return true;
+}
+
 /**
  * @param {import("bun:sqlite").Database} sqlite
  * @param {{ table: string; columns: readonly string[]; defaults?: Record<string, string>; }} config
@@ -327,6 +396,16 @@ function loadAppliedMigrationIds(sqlite) {
         .map((row) => row.id));
 }
 
+/**
+ * @param {{ query: (config: { text: string; values?: readonly unknown[] }) => Promise<{ rows?: readonly Record<string, unknown>[] }> }} pgConn
+ */
+async function loadAppliedMigrationIdsPostgres(pgConn) {
+    const result = await pgConn.query({ text: "SELECT id FROM _smithers_schema_migrations" });
+    return new Set((result.rows ?? [])
+        .map((row) => row.id)
+        .filter((id) => typeof id === "string"));
+}
+
 /**
  * @param {import("bun:sqlite").Database} sqlite
  * @param {{ id: string; name: string; checksum?: string; destructive?: boolean; }} migration
@@ -347,6 +426,28 @@ function recordMigration(sqlite, migration, details) {
         .run();
 }
 
+/**
+ * @param {{ query: (config: { text: string; values?: readonly unknown[] }) => Promise<unknown> }} pgConn
+ * @param {{ id: string; name: string; checksum?: string; destructive?: boolean; }} migration
+ * @param {unknown} details
+ */
+async function recordMigrationPostgres(pgConn, migration, details) {
+    await pgConn.query({
+        text: `INSERT INTO _smithers_schema_migrations
+          (id, name, applied_at_ms, checksum, destructive, details_json)
+          VALUES ($1, $2, $3, $4, $5, $6)
+          ON CONFLICT (id) DO NOTHING`,
+        values: [
+            migration.id,
+            migration.name,
+            Date.now(),
+            migration.checksum ?? null,
+            migration.destructive ? 1 : 0,
+            details === undefined ? null : JSON.stringify(details),
+        ],
+    });
+}
+
 /**
  * @param {{ id: string; destructive?: boolean; }} migration
  * @param {any} details
@@ -362,6 +463,39 @@ function logDestructiveMigration(migration, details) {
     console.warn(`[smithers-db] migration ${migration.id} dropped ${droppedCount} orphan run-owned rows`, details.tables);
 }
 
+/**
+ * Run one SQLite schema migration inside an Effect span while preserving the
+ * existing synchronous migration API.
+ *
+ * @param {{
+ *   id: string;
+ *   name: string;
+ *   checksum?: string;
+ *   destructive?: boolean;
+ *   isApplied: (sqlite: import("bun:sqlite").Database) => boolean;
+ *   up: (sqlite: import("bun:sqlite").Database) => unknown;
+ * }} migration
+ * @param {() => unknown} run
+ */
+function runSqliteMigrationSpan(migration, run) {
+    const start = Date.now();
+    return Effect.runSync(Effect.sync(() => {
+        const details = run();
+        const durationMs = Date.now() - start;
+        Effect.runSync(Effect.logDebug("db.schema_migration.applied").pipe(Effect.annotateLogs({
+            dbDialect: "sqlite",
+            migrationId: migration.id,
+            migrationName: migration.name,
+            durationMs,
+        })));
+        return details;
+    }).pipe(Effect.annotateLogs({
+        dbDialect: "sqlite",
+        migrationId: migration.id,
+        migrationName: migration.name,
+    }), Effect.withLogSpan("db:schema-migration")));
+}
+
 /**
  * @param {{
  *   createTableStatements: readonly string[];
@@ -377,6 +511,10 @@ function buildMigrations(context) {
             const columns = tableColumnNames(sqlite, config.table);
             return config.columns.every(([column]) => columns.has(column));
         },
+        isAppliedPostgres: async (pgConn) => {
+            const columns = await tableColumnNamesPostgres(pgConn, config.table);
+            return config.columns.every(([column]) => columns.has(column));
+        },
         up: (sqlite) => {
             const addedColumns = [];
             for (const [column, definition] of config.columns) {
@@ -386,6 +524,15 @@ function buildMigrations(context) {
             }
             return { table: config.table, addedColumns };
         },
+        upPostgres: async (pgConn) => {
+            const addedColumns = [];
+            for (const [column, definition] of config.columns) {
+                if (await addColumnIfMissingPostgres(pgConn, config.table, column, definition)) {
+                    addedColumns.push(column);
+                }
+            }
+            return { table: config.table, addedColumns };
+        },
     }));
     return [
         {
@@ -393,12 +540,27 @@ function buildMigrations(context) {
             name: "Create current Smithers tables",
             checksum: checksumForStatements(context.createTableStatements),
             isApplied: () => false,
+            isAppliedPostgres: async (pgConn) => {
+                const names = currentTableNames(context.createTableStatements);
+                for (const name of names) {
+                    if (!(await tableExistsPostgres(pgConn, name))) {
+                        return false;
+                    }
+                }
+                return true;
+            },
             up: (sqlite) => {
                 for (const statement of context.createTableStatements) {
                     sqlite.run(statement);
                 }
                 return { statementCount: context.createTableStatements.length };
             },
+            upPostgres: async (pgConn) => {
+                for (const statement of context.createTableStatements) {
+                    await pgConn.query({ text: translateDdl(POSTGRES, statement) });
+                }
+                return { statementCount: context.createTableStatements.length };
+            },
         },
         ...columnMigrations,
         {
@@ -406,10 +568,15 @@ function buildMigrations(context) {
             name: "Add node diff cache table",
             checksum: "packages/db/migrations/0011_add_node_diffs.sql",
             isApplied: (sqlite) => tableExists(sqlite, "_smithers_node_diffs"),
+            isAppliedPostgres: (pgConn) => tableExistsPostgres(pgConn, "_smithers_node_diffs"),
             up: (sqlite) => {
                 sqlite.run(createTableStatementFor("_smithers_node_diffs", context.createTableStatements));
                 return { table: "_smithers_node_diffs" };
             },
+            upPostgres: async (pgConn) => {
+                await pgConn.query({ text: translateDdl(POSTGRES, createTableStatementFor("_smithers_node_diffs", context.createTableStatements)) });
+                return { table: "_smithers_node_diffs" };
+            },
         },
         {
             id: "0012_add_time_travel_audit",
@@ -417,6 +584,8 @@ function buildMigrations(context) {
             checksum: "packages/db/migrations/0012_add_time_travel_audit.sql",
             isApplied: (sqlite) => tableExists(sqlite, "_smithers_time_travel_audit") &&
                 tableColumnNames(sqlite, "_smithers_time_travel_audit").has("duration_ms"),
+            isAppliedPostgres: async (pgConn) => (await tableExistsPostgres(pgConn, "_smithers_time_travel_audit")) &&
+                (await tableColumnNamesPostgres(pgConn, "_smithers_time_travel_audit")).has("duration_ms"),
             up: (sqlite) => {
                 if (!tableExists(sqlite, "_smithers_time_travel_audit")) {
                     sqlite.run(createTableStatementFor("_smithers_time_travel_audit", context.createTableStatements));
@@ -425,6 +594,14 @@ function buildMigrations(context) {
                 addColumnIfMissing(sqlite, "_smithers_time_travel_audit", "duration_ms", "duration_ms INTEGER");
                 return { table: "_smithers_time_travel_audit", addedColumns: ["duration_ms"] };
             },
+            upPostgres: async (pgConn) => {
+                if (!(await tableExistsPostgres(pgConn, "_smithers_time_travel_audit"))) {
+                    await pgConn.query({ text: translateDdl(POSTGRES, createTableStatementFor("_smithers_time_travel_audit", context.createTableStatements)) });
+                    return { table: "_smithers_time_travel_audit", created: true };
+                }
+                const added = await addColumnIfMissingPostgres(pgConn, "_smithers_time_travel_audit", "duration_ms", "duration_ms INTEGER");
+                return { table: "_smithers_time_travel_audit", addedColumns: added ? ["duration_ms"] : [] };
+            },
         },
         {
             id: "0013_run_owned_foreign_keys",
@@ -432,6 +609,7 @@ function buildMigrations(context) {
             checksum: checksumForStatements(RUN_OWNED_FOREIGN_KEY_TABLES.map((config) => config.table)),
             destructive: true,
             isApplied: (sqlite) => RUN_OWNED_FOREIGN_KEY_TABLES.every((config) => tableHasRunForeignKey(sqlite, config.table)),
+            isAppliedPostgres: () => true,
             up: (sqlite) => {
                 const tables = RUN_OWNED_FOREIGN_KEY_TABLES.map((config) => rebuildRunOwnedForeignKeyTable(sqlite, config, context.createTableStatements));
                 const violations = sqlite.query("PRAGMA foreign_key_check").all();
@@ -440,17 +618,44 @@ function buildMigrations(context) {
                 }
                 return { tables };
             },
+            upPostgres: async () => ({ skipped: "sqlite_only" }),
         },
         {
             id: "0014_current_indexes",
             name: "Create current Smithers indexes",
             checksum: checksumForStatements([...context.createIndexStatements, ...EXTRA_INDEX_STATEMENTS]),
             isApplied: () => false,
+            isAppliedPostgres: () => false,
             up: (sqlite) => {
+                let applied = 0;
+                let skipped = 0;
                 for (const statement of [...context.createIndexStatements, ...EXTRA_INDEX_STATEMENTS]) {
+                    const target = indexTargetTable(statement);
+                    // Skip indexes whose table a later migration creates; running
+                    // them here would throw "no such table" on a store whose
+                    // ledger predates that table (e.g. `_smithers_docs`).
+                    if (target && !tableExists(sqlite, target)) {
+                        skipped += 1;
+                        continue;
+                    }
                     sqlite.run(statement);
+                    applied += 1;
+                }
+                return { statementCount: applied, skipped };
+            },
+            upPostgres: async (pgConn) => {
+                let applied = 0;
+                let skipped = 0;
+                for (const statement of [...context.createIndexStatements, ...EXTRA_INDEX_STATEMENTS]) {
+                    const target = indexTargetTable(statement);
+                    if (target && !(await tableExistsPostgres(pgConn, target))) {
+                        skipped += 1;
+                        continue;
+                    }
+                    await pgConn.query({ text: translateDdl(POSTGRES, statement) });
+                    applied += 1;
                 }
-                return { statementCount: context.createIndexStatements.length + EXTRA_INDEX_STATEMENTS.length };
+                return { statementCount: applied, skipped };
             },
         },
         {
@@ -458,20 +663,68 @@ function buildMigrations(context) {
             name: "Add workspace snapshot states table",
             checksum: "packages/db/migrations/0015_add_workspace_states.sql",
             isApplied: (sqlite) => tableExists(sqlite, "_smithers_workspace_states"),
+            isAppliedPostgres: (pgConn) => tableExistsPostgres(pgConn, "_smithers_workspace_states"),
             up: (sqlite) => {
                 sqlite.run(createTableStatementFor("_smithers_workspace_states", context.createTableStatements));
                 return { table: "_smithers_workspace_states" };
             },
+            upPostgres: async (pgConn) => {
+                await pgConn.query({ text: translateDdl(POSTGRES, createTableStatementFor("_smithers_workspace_states", context.createTableStatements)) });
+                return { table: "_smithers_workspace_states" };
+            },
         },
         {
             id: "0016_add_workspace_checkpoints",
             name: "Add workspace snapshot checkpoints table",
             checksum: "packages/db/migrations/0016_add_workspace_checkpoints.sql",
             isApplied: (sqlite) => tableExists(sqlite, "_smithers_workspace_checkpoints"),
+            isAppliedPostgres: (pgConn) => tableExistsPostgres(pgConn, "_smithers_workspace_checkpoints"),
             up: (sqlite) => {
                 sqlite.run(createTableStatementFor("_smithers_workspace_checkpoints", context.createTableStatements));
                 return { table: "_smithers_workspace_checkpoints" };
             },
+            upPostgres: async (pgConn) => {
+                await pgConn.query({ text: translateDdl(POSTGRES, createTableStatementFor("_smithers_workspace_checkpoints", context.createTableStatements)) });
+                return { table: "_smithers_workspace_checkpoints" };
+            },
+        },
+        {
+            id: "0017_add_scorer_context_columns",
+            name: "Add scorer context correlation columns",
+            checksum: "packages/db/migrations/0017_add_scorer_context_columns.sql",
+            isApplied: (sqlite) => {
+                const columns = tableColumnNames(sqlite, "_smithers_scorers");
+                return columns.has("ground_truth_json") && columns.has("context_json");
+            },
+            up: (sqlite) => {
+                const addedColumns = [];
+                if (addColumnIfMissing(sqlite, "_smithers_scorers", "ground_truth_json", "ground_truth_json TEXT")) {
+                    addedColumns.push("ground_truth_json");
+                }
+                if (addColumnIfMissing(sqlite, "_smithers_scorers", "context_json", "context_json TEXT")) {
+                    addedColumns.push("context_json");
+                }
+                return { table: "_smithers_scorers", addedColumns };
+            },
+        },
+        {
+            id: "0018_add_docs",
+            name: "Add docs (tickets/plans/specs/proposals) table",
+            checksum: "packages/db/migrations/0018_add_docs.sql",
+            isApplied: (sqlite) => tableExists(sqlite, "_smithers_docs"),
+            isAppliedPostgres: (pgConn) => tableExistsPostgres(pgConn, "_smithers_docs"),
+            up: (sqlite) => {
+                sqlite.run(createTableStatementFor("_smithers_docs", context.createTableStatements));
+                sqlite.run(`CREATE INDEX IF NOT EXISTS _smithers_docs_kind_live_idx
+    ON _smithers_docs (kind, deleted_at_ms, updated_at_ms)`);
+                return { table: "_smithers_docs" };
+            },
+            upPostgres: async (pgConn) => {
+                await pgConn.query({ text: translateDdl(POSTGRES, createTableStatementFor("_smithers_docs", context.createTableStatements)) });
+                await pgConn.query({ text: translateDdl(POSTGRES, `CREATE INDEX IF NOT EXISTS _smithers_docs_kind_live_idx
+    ON _smithers_docs (kind, deleted_at_ms, updated_at_ms)`) });
+                return { table: "_smithers_docs" };
+            },
         },
     ];
 }
@@ -491,16 +744,103 @@ export function runSmithersSchemaMigrations(sqlite, context) {
         if (applied.has(migration.id) || hasMigrationRecord(sqlite, migration.id)) {
             continue;
         }
-        const alreadyApplied = migration.isApplied(sqlite);
-        const details = alreadyApplied
-            ? { skipped: "schema_already_matches" }
-            : migration.up(sqlite);
+        const details = runSqliteMigrationSpan(migration, () => {
+            const alreadyApplied = migration.isApplied(sqlite);
+            return alreadyApplied
+                ? { skipped: "schema_already_matches" }
+                : migration.up(sqlite);
+        });
         logDestructiveMigration(migration, details);
         recordMigration(sqlite, migration, details);
         applied.add(migration.id);
     }
 }
 
+/**
+ * Run one Postgres schema migration inside an Effect span so OTLP-backed
+ * runtimes can attribute long DDL steps and log-only runtimes still get a
+ * structured event.
+ *
+ * @param {{
+ *   id: string;
+ *   name: string;
+ *   checksum?: string;
+ *   destructive?: boolean;
+ *   isAppliedPostgres?: (pgConn: any) => Promise<boolean> | boolean;
+ *   upPostgres?: (pgConn: any) => Promise<unknown>;
+ * }} migration
+ * @param {() => Promise<unknown>} run
+ */
+async function runPostgresMigrationSpan(migration, run) {
+    const start = Date.now();
+    return Effect.runPromise(Effect.tryPromise({
+        try: async () => {
+            const details = await run();
+            const durationMs = Date.now() - start;
+            await Effect.runPromise(Effect.logDebug("db.schema_migration.applied").pipe(Effect.annotateLogs({
+                dbDialect: "postgres",
+                migrationId: migration.id,
+                migrationName: migration.name,
+                durationMs,
+            })));
+            return details;
+        },
+        catch: (cause) => cause,
+    }).pipe(Effect.annotateLogs({
+        dbDialect: "postgres",
+        migrationId: migration.id,
+        migrationName: migration.name,
+    }), Effect.withLogSpan("db:schema-migration")));
+}
+
+/**
+ * Versioned PostgreSQL schema migration runner. It shares the SQLite migration
+ * ledger ids so the current server schema head is available on both dialects.
+ * A fresh Postgres database applies the current DDL in 0001 and records the
+ * historical SQLite-only/additive steps as already satisfied.
+ *
+ * @param {{ query: (config: { text: string; values?: readonly unknown[] }) => Promise<{ rows?: readonly Record<string, unknown>[] } | unknown> }} pgConn
+ * @param {{
+ *   createTableStatements: readonly string[];
+ *   createIndexStatements: readonly string[];
+ * }} context
+ * @returns {Promise<void>}
+ */
+export async function runSmithersSchemaMigrationsPostgres(pgConn, context) {
+    await pgConn.query({ text: translateDdl(POSTGRES, MIGRATION_TABLE_SQL) });
+    const applied = await loadAppliedMigrationIdsPostgres(pgConn);
+    for (const migration of buildMigrations(context)) {
+        if (applied.has(migration.id)) {
+            continue;
+        }
+        const details = await runPostgresMigrationSpan(migration, async () => {
+            await pgConn.query({ text: "BEGIN" });
+            try {
+                const alreadyApplied = migration.isAppliedPostgres
+                    ? await migration.isAppliedPostgres(pgConn)
+                    : false;
+                const nextDetails = alreadyApplied
+                    ? { skipped: "schema_already_matches" }
+                    : await migration.upPostgres?.(pgConn);
+                await recordMigrationPostgres(pgConn, migration, nextDetails);
+                await pgConn.query({ text: "COMMIT" });
+                return nextDetails;
+            }
+            catch (error) {
+                try {
+                    await pgConn.query({ text: "ROLLBACK" });
+                }
+                catch {
+                    // Preserve the original migration failure.
+                }
+                throw error;
+            }
+        });
+        logDestructiveMigration(migration, details);
+        applied.add(migration.id);
+    }
+}
+
 /**
  * PostgreSQL schema initialization. A fresh PostgreSQL database starts at the
  * current schema, so it skips the SQLite-only legacy column/foreign-key
@@ -517,13 +857,5 @@ export function runSmithersSchemaMigrations(sqlite, context) {
  * @returns {Promise<void>}
  */
 export async function runSmithersSchemaInitPostgres(pgConn, context) {
-    const statements = [
-        MIGRATION_TABLE_SQL,
-        ...context.createTableStatements,
-        ...context.createIndexStatements,
-        ...EXTRA_INDEX_STATEMENTS,
-    ];
-    for (const statement of statements) {
-        await pgConn.query({ text: translateDdl(POSTGRES, statement) });
-    }
+    await runSmithersSchemaMigrationsPostgres(pgConn, context);
 }

package/src/sha256Hex.js

@@ -0,0 +1,14 @@
+import { createHash } from "node:crypto";
+
+/**
+ * Lowercase hex `sha256` of a UTF-8 string. The gateway's
+ * `createTicket`/`updateTicket` handlers and the file-watcher seam both hash doc
+ * `content` through this ONE helper so a `content_hash` written by an RPC and
+ * one computed from a `.md` file are byte-for-byte comparable (the watcher's
+ * last-write-wins compare key).
+ * @param {string} content
+ * @returns {string}
+ */
+export function sha256Hex(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}

package/src/sql-message-storage.js

@@ -321,6 +321,8 @@ const CREATE_TABLE_STATEMENTS = [
     meta_json TEXT,
     input_json TEXT,
     output_json TEXT,
+    ground_truth_json TEXT,
+    context_json TEXT,
     latency_ms REAL,
     scored_at_ms INTEGER NOT NULL,
     duration_ms REAL
@@ -352,6 +354,15 @@ const CREATE_TABLE_STATEMENTS = [
     node_id TEXT,
     created_at_ms INTEGER NOT NULL
   )`,
+    `CREATE TABLE IF NOT EXISTS _smithers_docs (
+    path TEXT PRIMARY KEY,
+    kind TEXT NOT NULL DEFAULT 'ticket',
+    content TEXT NOT NULL,
+    content_hash TEXT NOT NULL,
+    status TEXT,
+    updated_at_ms INTEGER NOT NULL,
+    deleted_at_ms INTEGER
+  )`,
 ];
 const CREATE_INDEX_STATEMENTS = [
     `CREATE INDEX IF NOT EXISTS _smithers_runs_status_heartbeat_idx
@@ -360,6 +371,8 @@ const CREATE_INDEX_STATEMENTS = [
     ON _smithers_signals (run_id, signal_name, correlation_id, received_at_ms)`,
     `CREATE INDEX IF NOT EXISTS _smithers_time_travel_audit_lookup_idx
     ON _smithers_time_travel_audit (run_id, caller, timestamp_ms)`,
+    `CREATE INDEX IF NOT EXISTS _smithers_docs_kind_live_idx
+    ON _smithers_docs (kind, deleted_at_ms, updated_at_ms)`,
 ];
 /**
  * @param {string} identifier

package/src/zodToCreateTableSQL.js

@@ -1,21 +1,28 @@
 import { unwrapZodType } from "./unwrapZodType.js";
 import { columnType, SQLITE } from "./dialect.js";
 import { camelToSnake } from "./utils/camelToSnake.js";
+import { assertNoReservedColumns } from "./assertNoReservedColumns.js";
 /**
  * Determines the Zod base type name from a (possibly unwrapped) Zod type.
  */
 function getZodBaseTypeName(zodType) {
     return zodType._zod?.def?.type ?? "unknown";
 }
+function isIntegerNumberType(zodType, baseTypeName) {
+    if (baseTypeName === "int")
+        return true;
+    const def = zodType._zod?.def;
+    return def?.format === "safeint" ||
+        def?.checks?.some((check) => check?._zod?.def?.check === "number_format");
+}
 function sqliteTypeFor(zodFieldSchema) {
     const baseType = unwrapZodType(zodFieldSchema);
     const baseTypeName = getZodBaseTypeName(baseType);
-    if (baseTypeName === "number" ||
-        baseTypeName === "int" ||
-        baseTypeName === "float" ||
-        baseTypeName === "boolean") {
+    if (baseTypeName === "boolean" || isIntegerNumberType(baseType, baseTypeName)) {
         return "INTEGER";
     }
+    if (baseTypeName === "number" || baseTypeName === "float")
+        return "REAL";
     return "TEXT";
 }
 function sqliteKindFor(zodFieldSchema) {
@@ -55,6 +62,7 @@ export function zodSchemaColumns(schema) {
  * (`sqlite`) is byte-identical to the historical output.
  */
 export function zodToCreateTableSQL(tableName, schema, opts) {
+    assertNoReservedColumns(schema, tableName, opts);
     const dialect = opts?.dialect ?? SQLITE;
     const integer = columnType(dialect, "INTEGER");
     const colDefs = opts?.isInput

package/src/zodToTable.js

@@ -1,4 +1,6 @@
-import { sqliteTable, text, integer, primaryKey, } from "drizzle-orm/sqlite-core";
+import { sqliteTable, text, integer, real, primaryKey, } from "drizzle-orm/sqlite-core";
+import { assertZodV4 } from "@smithers-orchestrator/errors/assertZodV4";
+import { assertNoReservedColumns } from "./assertNoReservedColumns.js";
 import { unwrapZodType } from "./unwrapZodType.js";
 import { camelToSnake } from "./utils/camelToSnake.js";
 /**
@@ -7,12 +9,19 @@ import { camelToSnake } from "./utils/camelToSnake.js";
 function getZodBaseTypeName(zodType) {
     return zodType._zod?.def?.type ?? "unknown";
 }
+function isIntegerNumberType(zodType, baseTypeName) {
+    if (baseTypeName === "int")
+        return true;
+    const def = zodType._zod?.def;
+    return def?.format === "safeint" ||
+        def?.checks?.some((check) => check?._zod?.def?.check === "number_format");
+}
 /**
  * Generates a Drizzle sqliteTable from a Zod object schema.
  *
  * Each Zod field is mapped to a SQLite column:
  * - z.string() / z.enum() -> text column
- * - z.number() -> integer column
+ * - z.number() -> real column
  * - z.boolean() -> integer column with boolean mode
  * - z.array() / z.object() / complex -> text column with json mode
  *
@@ -20,6 +29,11 @@ function getZodBaseTypeName(zodType) {
  * runId, nodeId, iteration with a composite primary key.
  */
 export function zodToTable(tableName, schema, opts) {
+    // A Zod v3 schema has no `_zod`, so getZodBaseTypeName below would silently
+    // resolve every field to "unknown" and degrade every column to JSON text.
+    // Reject it up front with an actionable error instead.
+    assertZodV4(schema, tableName);
+    assertNoReservedColumns(schema, tableName, opts);
     const columns = opts?.isInput
         ? { runId: text("run_id").primaryKey() }
         : {
@@ -32,11 +46,12 @@ export function zodToTable(tableName, schema, opts) {
         const colName = camelToSnake(key);
         const baseType = unwrapZodType(zodType);
         const baseTypeName = getZodBaseTypeName(baseType);
-        if (baseTypeName === "number" ||
-            baseTypeName === "int" ||
-            baseTypeName === "float") {
+        if (isIntegerNumberType(baseType, baseTypeName)) {
             columns[key] = integer(colName);
         }
+        else if (baseTypeName === "number" || baseTypeName === "float") {
+            columns[key] = real(colName);
+        }
         else if (baseTypeName === "boolean") {
             columns[key] = integer(colName, { mode: "boolean" });
         }