@smithers-orchestrator/db 0.22.0 → 0.24.0

package/src/dialect.js

@@ -0,0 +1,229 @@
+/**
+ * SQL dialect seam for the Smithers persistence layer.
+ *
+ * Smithers' storage was authored against SQLite (bun:sqlite). This module is the
+ * single source of truth for the handful of places where SQLite and PostgreSQL
+ * SQL diverge, so the same hand-written SQL the adapter emits can run unchanged
+ * against either backend:
+ *
+ *   - placeholder style: SQLite `?` vs PostgreSQL `$1, $2, …`
+ *   - DDL types: SQLite's permissive `INTEGER`/`REAL`/`BLOB` vs PostgreSQL's
+ *     stricter `BIGINT`/`DOUBLE PRECISION`/`BYTEA` (millisecond timestamps stored
+ *     in `INTEGER` overflow PostgreSQL's 32-bit `integer`, hence `BIGINT`)
+ *   - autoincrement: `INTEGER PRIMARY KEY AUTOINCREMENT` vs `BIGSERIAL PRIMARY KEY`
+ *   - schema introspection: `PRAGMA table_info` vs `information_schema.columns`
+ *   - transaction start: `BEGIN IMMEDIATE` (SQLite write-lock) vs `BEGIN`
+ *
+ * Identifier quoting (`"x"`), `ON CONFLICT … DO UPDATE SET … = excluded.…`, and
+ * `CREATE TABLE/INDEX IF NOT EXISTS` are already standard across both dialects,
+ * so they need no translation.
+ *
+ * @typedef {"sqlite" | "postgres"} Dialect
+ */
+
+export const SQLITE = /** @type {const} */ ("sqlite");
+export const POSTGRES = /** @type {const} */ ("postgres");
+
+/**
+ * @param {unknown} value
+ * @returns {value is Dialect}
+ */
+export function isDialect(value) {
+    return value === SQLITE || value === POSTGRES;
+}
+
+/**
+ * @param {string} identifier
+ * @returns {string}
+ */
+export function quoteIdentifier(identifier) {
+    return `"${String(identifier).replaceAll(`"`, `""`)}"`;
+}
+
+/**
+ * Rewrite positional `?` placeholders to PostgreSQL's `$1, $2, …`. SQLite keeps
+ * `?`. A `?` inside a string literal, quoted identifier, or comment is left
+ * untouched so only real placeholders are renumbered.
+ *
+ * @param {Dialect} dialect
+ * @param {string} sql
+ * @returns {string}
+ */
+export function translatePlaceholders(dialect, sql) {
+    if (dialect !== POSTGRES) {
+        return sql;
+    }
+    let out = "";
+    let index = 1;
+    let inSingle = false;
+    let inDouble = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = 0; i < sql.length; i++) {
+        const ch = sql[i];
+        const next = sql[i + 1];
+        if (inLineComment) {
+            out += ch;
+            if (ch === "\n") inLineComment = false;
+            continue;
+        }
+        if (inBlockComment) {
+            out += ch;
+            if (ch === "*" && next === "/") {
+                out += next;
+                i++;
+                inBlockComment = false;
+            }
+            continue;
+        }
+        if (inSingle) {
+            out += ch;
+            if (ch === "'") {
+                if (next === "'") {
+                    out += next;
+                    i++;
+                } else {
+                    inSingle = false;
+                }
+            }
+            continue;
+        }
+        if (inDouble) {
+            out += ch;
+            if (ch === `"`) {
+                if (next === `"`) {
+                    out += next;
+                    i++;
+                } else {
+                    inDouble = false;
+                }
+            }
+            continue;
+        }
+        if (ch === "'") {
+            inSingle = true;
+            out += ch;
+            continue;
+        }
+        if (ch === `"`) {
+            inDouble = true;
+            out += ch;
+            continue;
+        }
+        if (ch === "-" && next === "-") {
+            inLineComment = true;
+            out += ch;
+            continue;
+        }
+        if (ch === "/" && next === "*") {
+            inBlockComment = true;
+            out += ch;
+            continue;
+        }
+        if (ch === "?") {
+            out += `$${index++}`;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+
+/**
+ * Map a single SQLite column type keyword (`INTEGER`, `REAL`, `BLOB`, `TEXT`) to
+ * the dialect equivalent. Used by the Zod→DDL generator, which only ever emits
+ * `INTEGER` or `TEXT`.
+ *
+ * @param {Dialect} dialect
+ * @param {string} sqliteType
+ * @returns {string}
+ */
+export function columnType(dialect, sqliteType) {
+    if (dialect !== POSTGRES) {
+        return sqliteType;
+    }
+    switch (sqliteType.toUpperCase()) {
+        case "INTEGER":
+            return "BIGINT";
+        case "REAL":
+            return "DOUBLE PRECISION";
+        case "BLOB":
+            return "BYTEA";
+        default:
+            return sqliteType;
+    }
+}
+
+/**
+ * Translate a complete `CREATE TABLE`/`CREATE INDEX` statement written in SQLite
+ * DDL to the target dialect. Only the controlled, internal Smithers DDL passes
+ * through here (no user-supplied text), so keyword-level regex substitution is
+ * safe. Order matters: the autoincrement primary key is rewritten before the
+ * blanket `INTEGER → BIGINT` so it is not double-translated.
+ *
+ * @param {Dialect} dialect
+ * @param {string} ddl
+ * @returns {string}
+ */
+export function translateDdl(dialect, ddl) {
+    if (dialect !== POSTGRES) {
+        return ddl;
+    }
+    return ddl
+        .replace(/\bINTEGER\s+PRIMARY\s+KEY\s+AUTOINCREMENT\b/gi, "BIGSERIAL PRIMARY KEY")
+        .replace(/\s+AUTOINCREMENT\b/gi, "")
+        .replace(/\bBLOB\b/gi, "BYTEA")
+        .replace(/\bREAL\b/gi, "DOUBLE PRECISION")
+        .replace(/\bINTEGER\b/gi, "BIGINT");
+}
+
+/**
+ * SQL that lists the column names of a table, normalized to rows shaped
+ * `{ name: string }`.
+ *
+ * @param {Dialect} dialect
+ * @param {string} table
+ * @returns {{ sql: string; params: ReadonlyArray<string> }}
+ */
+export function tableColumnsSql(dialect, table) {
+    if (dialect === POSTGRES) {
+        return {
+            sql: "SELECT column_name AS name FROM information_schema.columns WHERE table_name = ? AND table_schema = current_schema()",
+            params: [table],
+        };
+    }
+    return {
+        sql: `PRAGMA table_info(${quoteIdentifier(table)})`,
+        params: [],
+    };
+}
+
+/**
+ * The statement that begins a write transaction. SQLite takes the write lock
+ * eagerly with `BEGIN IMMEDIATE`; PostgreSQL uses a plain `BEGIN`.
+ *
+ * @param {Dialect} dialect
+ * @returns {string}
+ */
+export function beginTransactionSql(dialect) {
+    return dialect === POSTGRES ? "BEGIN" : "BEGIN IMMEDIATE";
+}
+
+/**
+ * A scalar SQL expression extracting a top-level string field from a JSON column
+ * stored as TEXT. SQLite uses `json_extract(col, '$.key')`; PostgreSQL casts to
+ * `json` and uses the `->>` operator. Only simple top-level paths (`$.key`) are
+ * used in Smithers' queries.
+ *
+ * @param {Dialect} dialect
+ * @param {string} columnSql Already-quoted/qualified column expression.
+ * @param {string} jsonPath SQLite-style path, e.g. `$.nodeId`.
+ * @returns {string}
+ */
+export function jsonExtractText(dialect, columnSql, jsonPath) {
+    if (dialect === POSTGRES) {
+        const key = jsonPath.replace(/^\$\./, "").replace(/'/g, "''");
+        return `(${columnSql}::json->>'${key}')`;
+    }
+    return `json_extract(${columnSql}, '${jsonPath.replace(/'/g, "''")}')`;
+}

package/src/ensure.js

@@ -14,5 +14,12 @@ export function ensureSmithersTablesEffect(db) {
  * @param {_BunSQLiteDatabase<Record<string, unknown>>} db
  */
 export function ensureSmithersTables(db) {
+    // Postgres schema initialization is asynchronous and cannot be driven by
+    // runSync. The Postgres/PGlite entry points ensure the schema (awaited)
+    // before the engine starts, so this synchronous SQLite helper is a no-op
+    // for a Postgres connection descriptor.
+    if (db && typeof db === "object" && /** @type {any} */ (db).dialect === "postgres") {
+        return;
+    }
     Effect.runSync(ensureSmithersTablesEffect(db));
 }

package/src/index.d.ts

@@ -958,6 +958,16 @@ declare class SmithersDb {
    */
     listPendingApprovals(runId: string): RunnableEffect<ApprovalRow[], SmithersError$1>;
     /**
+   * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listDecidedApprovals(runId: string): RunnableEffect<ApprovalRow[], SmithersError$1>;
+    /**
+   * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listAllDecidedApprovals(runId: string): RunnableEffect<ApprovalRow[], SmithersError$1>;
+    /**
    * @returns {RunnableEffect<Array<Record<string, unknown>>, SmithersError>}
    */
     listAllPendingApprovals(): RunnableEffect<Array<Record<string, unknown>>, SmithersError$1>;
@@ -1179,6 +1189,16 @@ declare class SmithersDb {
     listPendingApprovalsEffect(runId: string): RunnableEffect<ApprovalRow[], SmithersError$1>;
     /**
    * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listDecidedApprovalsEffect(runId: string): RunnableEffect<ApprovalRow[], SmithersError$1>;
+    /**
+   * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listAllDecidedApprovalsEffect(runId: string): RunnableEffect<ApprovalRow[], SmithersError$1>;
+    /**
+   * @param {string} runId
    * @returns {RunnableEffect<FrameRow | undefined, SmithersError>}
    */
     getLastFrameEffect(runId: string): RunnableEffect<FrameRow | undefined, SmithersError$1>;

package/src/internal-schema/index.js

@@ -20,3 +20,5 @@ export { smithersMemoryMessages } from "./smithersMemoryMessages.js";
 export { smithersVectors } from "./smithersVectors.js";
 export { smithersCron } from "./smithersCron.js";
 export { smithersSchemaMigrations } from "./smithersSchemaMigrations.js";
+export { smithersWorkspaceStates } from "./smithersWorkspaceStates.js";
+export { smithersWorkspaceCheckpoints } from "./smithersWorkspaceCheckpoints.js";

package/src/internal-schema/smithersWorkspaceCheckpoints.js

@@ -0,0 +1,17 @@
+import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const smithersWorkspaceCheckpoints = sqliteTable("_smithers_workspace_checkpoints", {
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    attempt: integer("attempt").notNull(),
+    seq: integer("seq").notNull(),
+    jjCwd: text("jj_cwd").notNull(),
+    jjCommitId: text("jj_commit_id").notNull(),
+    source: text("source").notNull(),
+    tier: integer("tier").notNull(),
+    label: text("label"),
+    toolUseId: text("tool_use_id"),
+    createdAtMs: integer("created_at_ms").notNull(),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.nodeId, t.iteration, t.attempt, t.seq] }),
+}));

package/src/internal-schema/smithersWorkspaceStates.js

@@ -0,0 +1,11 @@
+import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const smithersWorkspaceStates = sqliteTable("_smithers_workspace_states", {
+    runId: text("run_id").notNull(),
+    jjCwd: text("jj_cwd").notNull(),
+    jjCommitId: text("jj_commit_id").notNull(),
+    jjOperationId: text("jj_operation_id").notNull(),
+    jjChangeId: text("jj_change_id"),
+    createdAtMs: integer("created_at_ms").notNull(),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.jjCwd, t.jjCommitId] }),
+}));

package/src/internal-schema.js

@@ -268,3 +268,5 @@ export const smithersSchemaMigrations = sqliteTable("_smithers_schema_migrations
         .default(false),
     detailsJson: text("details_json"),
 });
+export { smithersWorkspaceStates } from "./internal-schema/smithersWorkspaceStates.js";
+export { smithersWorkspaceCheckpoints } from "./internal-schema/smithersWorkspaceCheckpoints.js";

package/src/output.js

@@ -1,10 +1,11 @@
-import { and, eq } from "drizzle-orm";
+import { and, eq, getTableName } from "drizzle-orm";
 import { getTableColumns } from "drizzle-orm/utils";
 import { createInsertSchema, createSelectSchema } from "drizzle-zod";
 import { Effect } from "effect";
 import { z } from "zod";
 import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
+import { getJsonColumnKeys, isPostgresDb, pgRowToDrizzle } from "./snapshot.js";
 import { withSqliteWriteRetryEffect } from "./write-retry.js";
 /** @typedef {import("drizzle-orm").AnyColumn} AnyColumn */
 /** @typedef {import("./output/OutputKey.ts").OutputKey} _OutputKey */
@@ -76,9 +77,25 @@ export function buildKeyWhere(table, key) {
  * @returns {Effect.Effect<T | undefined, SmithersError>}
  */
 export function selectOutputRowEffect(db, table, key) {
-    const where = buildKeyWhere(table, key);
+    const cols = getKeyColumns(table);
+    const hasIteration = Boolean(cols.iteration);
+    const jsonKeys = getJsonColumnKeys(table);
     return Effect.tryPromise({
-        try: () => db.select().from(table).where(where).limit(1),
+        try: () => {
+            if (isPostgresDb(db)) {
+                const tableName = getTableName(table).replaceAll(`"`, `""`);
+                const clauses = ["run_id = $1", "node_id = $2"];
+                const values = [key.runId, key.nodeId];
+                if (hasIteration) {
+                    clauses.push("iteration = $3");
+                    values.push(key.iteration ?? 0);
+                }
+                return db.connection
+                    .query({ text: `SELECT * FROM "${tableName}" WHERE ${clauses.join(" AND ")} LIMIT 1`, values })
+                    .then((result) => (result.rows[0] ? [pgRowToDrizzle(result.rows[0], jsonKeys)] : []));
+            }
+            return db.select().from(table).where(buildKeyWhere(table, key)).limit(1);
+        },
         catch: (cause) => toSmithersError(cause, `select output ${table["_"]?.name ?? "output"}`, {
             code: "DB_QUERY_FAILED",
             details: { outputTable: table["_"]?.name ?? "output" },

package/src/schema-migrations.js

@@ -1,5 +1,6 @@
 import { eq } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/bun-sqlite";
+import { POSTGRES, translateDdl } from "./dialect.js";
 import { smithersSchemaMigrations } from "./internal-schema/smithersSchemaMigrations.js";
 
 const MIGRATION_TABLE_SQL = `CREATE TABLE IF NOT EXISTS _smithers_schema_migrations (
@@ -452,6 +453,26 @@ function buildMigrations(context) {
                 return { statementCount: context.createIndexStatements.length + EXTRA_INDEX_STATEMENTS.length };
             },
         },
+        {
+            id: "0015_add_workspace_states",
+            name: "Add workspace snapshot states table",
+            checksum: "packages/db/migrations/0015_add_workspace_states.sql",
+            isApplied: (sqlite) => tableExists(sqlite, "_smithers_workspace_states"),
+            up: (sqlite) => {
+                sqlite.run(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"),
+            up: (sqlite) => {
+                sqlite.run(createTableStatementFor("_smithers_workspace_checkpoints", context.createTableStatements));
+                return { table: "_smithers_workspace_checkpoints" };
+            },
+        },
     ];
 }
 
@@ -479,3 +500,30 @@ export function runSmithersSchemaMigrations(sqlite, context) {
         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
+ * migrations entirely and simply creates every current table and index
+ * idempotently, with DDL translated to PostgreSQL types. Tables are created in
+ * declaration order, which keeps foreign-key references valid (referenced
+ * tables precede their dependents).
+ *
+ * @param {{ query: (config: { text: string }) => Promise<unknown> }} pgConn
+ * @param {{
+ *   createTableStatements: readonly string[];
+ *   createIndexStatements: readonly string[];
+ * }} 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) });
+    }
+}

package/src/snapshot.js

@@ -27,6 +27,29 @@ function getBooleanColumnKeys(table) {
         return [];
     }
 }
+/**
+ * Keys of every json-mode column on the table. zodToTable maps any
+ * array/object/union/complex Zod field to a Drizzle `text(col,{mode:'json'})`
+ * column, which Drizzle's bun:sqlite reader auto-decodes on read. The Postgres
+ * path stores those as TEXT, so we must JSON.parse them to match.
+ * @param {_Table} table
+ * @returns {string[]}
+ */
+export function getJsonColumnKeys(table) {
+    try {
+        const cols = getTableColumns(table);
+        const keys = [];
+        for (const [key, col] of Object.entries(cols)) {
+            const c = /** @type {Record<string, unknown> & { config?: { mode?: string } }} */ (/** @type {unknown} */ (col));
+            if (c?.columnType === "SQLiteTextJson" || c?.config?.mode === "json" || c?.mode === "json" || c?.dataType === "json") {
+                keys.push(key);
+            }
+        }
+        return keys;
+    } catch {
+        return [];
+    }
+}
 /**
  * @param {ReadonlyArray<Record<string, unknown>>} rows
  * @param {readonly string[]} boolKeys
@@ -52,6 +75,45 @@ function coerceBooleanColumns(rows, boolKeys) {
  * @param {string} runId
  * @returns {Effect.Effect<Record<string, unknown> | undefined, SmithersError>}
  */
+/**
+ * @param {unknown} db
+ * @returns {boolean}
+ */
+export function isPostgresDb(db) {
+    return Boolean(db && typeof db === "object" && /** @type {any} */ (db).dialect === "postgres" && /** @type {any} */ (db).connection);
+}
+/**
+ * Map a raw node-postgres row (snake_case columns, JSON stored as TEXT) into the
+ * shape Drizzle's bun:sqlite reader returns (camelCase keys, json-mode columns
+ * decoded), so input/output consumers stay dialect-agnostic. `jsonKeys` is the
+ * set of camelCase json-mode column keys (from getJsonColumnKeys); every TEXT
+ * value for those columns is JSON.parsed to match Drizzle's mode:'json' read.
+ * The literal `payload` column is always decoded so callers that omit `jsonKeys`
+ * (single-value outputs) keep working.
+ * @param {Record<string, unknown>} row
+ * @param {readonly string[]} [jsonKeys]
+ * @returns {Record<string, unknown>}
+ */
+export function pgRowToDrizzle(row, jsonKeys) {
+    /** @type {Record<string, unknown>} */
+    const out = {};
+    const jsonSet = new Set(jsonKeys ?? []);
+    for (const [columnName, value] of Object.entries(row)) {
+        const camel = columnName.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+        if ((camel === "payload" || jsonSet.has(camel)) && typeof value === "string") {
+            try {
+                out[camel] = JSON.parse(value);
+            }
+            catch {
+                out[camel] = value;
+            }
+        }
+        else {
+            out[camel] = value;
+        }
+    }
+    return out;
+}
 export function loadInputEffect(db, inputTable, runId) {
     return Effect.suspend(() => {
         const cols = getTableColumns(inputTable);
@@ -59,6 +121,19 @@ export function loadInputEffect(db, inputTable, runId) {
         if (!runIdCol) {
             return Effect.fail(new SmithersError("DB_MISSING_COLUMNS", "schema.input must include runId column"));
         }
+        if (isPostgresDb(db)) {
+            const tableName = getTableName(inputTable).replaceAll(`"`, `""`);
+            const jsonKeys = getJsonColumnKeys(inputTable);
+            return Effect.tryPromise({
+                try: () => db.connection
+                    .query({ text: `SELECT * FROM "${tableName}" WHERE run_id = $1 LIMIT 1`, values: [runId] })
+                    .then((result) => (result.rows[0] ? pgRowToDrizzle(result.rows[0], jsonKeys) : undefined)),
+                catch: (cause) => toSmithersError(cause, "load input", {
+                    code: "DB_QUERY_FAILED",
+                    details: { runId },
+                }),
+            });
+        }
         return Effect.tryPromise({
             try: () => db.select().from(inputTable).where(eq(runIdCol, runId)).limit(1),
             catch: (cause) => toSmithersError(cause, "load input", {
@@ -104,8 +179,13 @@ export function loadOutputsEffect(db, schema, runId) {
             }).pipe(Effect.option);
             if (Option.isNone(tableNameOpt)) continue;
             const tableName = tableNameOpt.value;
+            const jsonKeys = getJsonColumnKeys(/** @type {_Table} */ (table));
             const rawRows = yield* Effect.tryPromise({
-                try: () => db.select().from(/** @type {_Table} */ (table)).where(eq(runIdCol, runId)),
+                try: () => isPostgresDb(db)
+                    ? db.connection
+                        .query({ text: `SELECT * FROM "${tableName.replaceAll(`"`, `""`)}" WHERE run_id = $1`, values: [runId] })
+                        .then((result) => result.rows.map((r) => pgRowToDrizzle(r, jsonKeys)))
+                    : db.select().from(/** @type {_Table} */ (table)).where(eq(runIdCol, runId)),
                 catch: (cause) => toSmithersError(cause, `load outputs ${tableName}`, { code: "DB_QUERY_FAILED", details: { runId, tableName } }),
             });
             const boolKeys = getBooleanColumnKeys(/** @type {_Table} */ (table));
@@ -125,3 +205,43 @@ export function loadOutputsEffect(db, schema, runId) {
 export function loadOutputs(db, schema, runId) {
     return Effect.runPromise(loadOutputsEffect(db, schema, runId));
 }
+/**
+ * Read every row of a single output table for a run, returning Drizzle-shaped
+ * rows (camelCase keys, boolean columns coerced to JS booleans). Dialect-aware:
+ * Drizzle for bun:sqlite, a raw `$n` query for the Postgres descriptor.
+ * @param {unknown} db
+ * @param {_Table} table
+ * @param {string} [runId]
+ * @returns {Effect.Effect<Array<Record<string, unknown>>, SmithersError>}
+ */
+export function loadRunOutputRowsEffect(db, table, runId) {
+    return Effect.gen(function* () {
+        const cols = getTableColumns(table);
+        const runIdCol = cols.runId;
+        const tableName = getTableName(table);
+        const boolKeys = getBooleanColumnKeys(table);
+        const jsonKeys = getJsonColumnKeys(table);
+        const rawRows = yield* Effect.tryPromise({
+            try: () => {
+                if (isPostgresDb(db)) {
+                    const escaped = tableName.replaceAll(`"`, `""`);
+                    const text = runId && runIdCol
+                        ? `SELECT * FROM "${escaped}" WHERE run_id = $1`
+                        : `SELECT * FROM "${escaped}"`;
+                    const values = runId && runIdCol ? [runId] : [];
+                    return db.connection
+                        .query({ text, values })
+                        .then((result) => result.rows.map((r) => pgRowToDrizzle(r, jsonKeys)));
+                }
+                return runId && runIdCol
+                    ? db.select().from(table).where(eq(runIdCol, runId))
+                    : db.select().from(table);
+            },
+            catch: (cause) => toSmithersError(cause, `load run output ${tableName}`, {
+                code: "DB_QUERY_FAILED",
+                details: { runId, tableName },
+            }),
+        });
+        return coerceBooleanColumns(rawRows, boolKeys);
+    }).pipe(Effect.annotateLogs({ runId: runId ?? "" }), Effect.withLogSpan("db:load-run-output"));
+}