@smithers-orchestrator/db 0.22.0 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/db",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "SQLite and Drizzle persistence adapter for Smithers workflows",
   "type": "module",
   "sideEffects": false,
@@ -10,6 +10,10 @@
       "import": "./src/index.js",
       "default": "./src/index.js"
     },
+    "./runState": {
+      "import": "./src/runState.js",
+      "default": "./src/runState.js"
+    },
     "./*": {
       "types": "./src/index.d.ts",
       "import": "./src/*.js",
@@ -26,13 +30,16 @@
     "drizzle-zod": "^0.8.3",
     "effect": "^3.21.1",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/errors": "0.22.0",
-    "@smithers-orchestrator/observability": "0.22.0",
-    "@smithers-orchestrator/scheduler": "0.22.0",
-    "@smithers-orchestrator/graph": "0.22.0"
+    "@smithers-orchestrator/errors": "0.24.0",
+    "@smithers-orchestrator/graph": "0.24.0",
+    "@smithers-orchestrator/scheduler": "0.24.0",
+    "@smithers-orchestrator/observability": "0.24.0"
   },
   "devDependencies": {
+    "@electric-sql/pglite": "0.5.1",
+    "@electric-sql/pglite-socket": "0.2.1",
     "@types/bun": "latest",
+    "pg": "^8.13.1",
     "typescript": "~5.9.3"
   },
   "scripts": {

package/src/adapter.js

@@ -11,9 +11,11 @@
 // @smithers-type-exports-end
 
 import { getTableName } from "drizzle-orm";
+import { getTableColumns } from "drizzle-orm/utils";
 import { Effect, Exit, FiberId, Metric } from "effect";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
 import { getSqlMessageStorage } from "./sql-message-storage.js";
+import { POSTGRES, beginTransactionSql } from "./dialect.js";
 import { alertsAcknowledgedTotal, alertsActive, alertsFiredTotal, dbQueryDuration, dbTransactionDuration, dbTransactionRollbacks, } from "@smithers-orchestrator/observability/metrics";
 import { assertOptionalStringMaxLength, assertPositiveFiniteNumber, } from "./input-bounds.js";
 import { FRAME_KEYFRAME_INTERVAL, applyFrameDeltaJson, encodeFrameDelta, normalizeFrameEncoding, serializeFrameDelta, } from "./frame-codec.js";
@@ -24,6 +26,7 @@ import { camelToSnake } from "./utils/camelToSnake.js";
 /** @typedef {import("./adapter/AlertStatus.ts").AlertStatus} AlertStatus */
 /** @typedef {import("./adapter/AttemptRow.ts").AttemptRow} AttemptRow */
 /** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase} BunSQLiteDatabase */
+/** @typedef {import("drizzle-orm").Table} Table */
 /** @typedef {import("./adapter/EventHistoryQuery.ts").EventHistoryQuery} EventHistoryQuery */
 /** @typedef {import("./adapter/HumanRequestRow.ts").HumanRequestRow} HumanRequestRow */
 /** @typedef {import("./output/OutputKey.ts").OutputKey} OutputKey */
@@ -409,6 +412,102 @@ function getSqliteTransactionState(client) {
     }
     return state;
 }
+/**
+ * Resolve a Drizzle output table's on-disk name. The name lives on the
+ * `Symbol(drizzle:Name)` slot, which `getTableName` reads; `table["_"].name` is
+ * `undefined` for these tables, so the raw-SQL Postgres path must not depend on
+ * it. Mirrors how the Drizzle `db.insert(table)` path resolves the name on
+ * SQLite.
+ * @param {unknown} table
+ * @returns {string}
+ */
+function resolveOutputTableName(table) {
+    try {
+        return getTableName(/** @type {Table} */ (table));
+    }
+    catch {
+        return "output";
+    }
+}
+/**
+ * @param {unknown} db
+ * @param {string} tableName
+ * @returns {unknown | null}
+ */
+function findDrizzleTableByName(db, tableName) {
+    const schema = /** @type {{ _?: { fullSchema?: Record<string, unknown> } }} */ (db)?._?.fullSchema;
+    if (!schema) return null;
+    for (const table of Object.values(schema)) {
+        try {
+            if (getTableName(/** @type {Table} */ (table)) === tableName) return table;
+        }
+        catch {
+            // Ignore non-table schema entries.
+        }
+    }
+    return null;
+}
+/**
+ * @param {unknown} table
+ * @returns {string[]}
+ */
+function getPhysicalBooleanColumnNames(table) {
+    try {
+        const cols = getTableColumns(/** @type {Table} */ (table));
+        const names = [];
+        for (const col of Object.values(cols)) {
+            const c = /** @type {Record<string, unknown> & { config?: { mode?: string }; mapFromDriverValue?: unknown; name?: unknown }} */ (/** @type {unknown} */ (col));
+            const mapFn = /** @type {{ toString?: () => string } | undefined} */ (c?.mapFromDriverValue);
+            if (c?.columnType === "SQLiteBoolean" ||
+                c?.config?.mode === "boolean" ||
+                c?.mode === "boolean" ||
+                c?.dataType === "boolean" ||
+                mapFn?.toString?.().includes("Boolean")) {
+                const name = typeof c.name === "string" ? c.name : null;
+                if (name) names.push(name);
+            }
+        }
+        return names;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * @param {Record<string, unknown> | null | undefined} row
+ * @param {readonly string[]} columnNames
+ * @returns {Record<string, unknown> | null | undefined}
+ */
+function coerceRawBooleanColumns(row, columnNames) {
+    if (!row || columnNames.length === 0) return row;
+    const next = { ...row };
+    for (const columnName of columnNames) {
+        const value = next[columnName];
+        if (columnName in next && typeof value !== "boolean") {
+            if (value === 0 || value === 0n || value === "0") next[columnName] = false;
+            else if (value === 1 || value === 1n || value === "1") next[columnName] = true;
+        }
+    }
+    return next;
+}
+/**
+ * @param {unknown} client
+ * @param {string} tableName
+ * @returns {string[]}
+ */
+function getPersistedBooleanColumnNames(client, tableName) {
+    try {
+        const rows = /** @type {{ query: (sql: string) => { all: (...args: unknown[]) => Array<Record<string, unknown>> } }} */ (client)
+            .query(`SELECT column_name FROM _smithers_output_schema_columns WHERE table_name = ? AND kind = 'boolean'`)
+            .all(tableName);
+        return rows
+            .map((row) => row.column_name)
+            .filter((name) => typeof name === "string");
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * @param {unknown} db
  * @returns {{ run: (sql: string) => unknown; query: (sql: string) => { run: (...args: unknown[]) => unknown; get: (...args: unknown[]) => Record<string, unknown> | null | undefined; all: () => Array<Record<string, unknown>> }; exec: (sql: string) => unknown; $client?: unknown }}
@@ -505,6 +604,9 @@ export class SmithersDb {
                 }),
             });
             return yield* self.read(`raw query ${validatedQuery.slice(0, 20)}`, () => {
+                if (self.internalStorage.dialect === POSTGRES) {
+                    return self.internalStorage.queryAllRaw(validatedQuery);
+                }
                 const client = self.db.session.client;
                 const stmt = client.query(validatedQuery);
                 return Promise.resolve(stmt.all());
@@ -648,7 +750,18 @@ export class SmithersDb {
             const transactionState = getSqliteTransactionState(resolveSqliteClientKey(self.db));
             const start = performance.now();
             return yield* Effect.gen(function* () {
-                const client = yield* self.getSqliteTransactionClient();
+                const isPostgres = self.internalStorage.dialect === POSTGRES;
+                const client = isPostgres ? null : yield* self.getSqliteTransactionClient();
+                /**
+                 * Run a transaction-control statement on the active connection,
+                 * dialect-appropriately: synchronous bun:sqlite client.run for
+                 * SQLite, async @effect/sql execute (same connection) for Postgres.
+                 * @param {string} sql
+                 * @returns {Promise<unknown>}
+                 */
+                const runControl = (sql) => isPostgres
+                    ? self.internalStorage.execute(sql)
+                    : Promise.resolve(client.run(sql));
                 /**
      * @param {"operation" | "commit"} phase
      * @param {unknown} error
@@ -660,18 +773,11 @@ export class SmithersDb {
                         phase,
                         error: String(error),
                     }));
-                    yield* Effect.sync(() => {
-                        try {
-                            client.run("ROLLBACK");
-                        }
-                        catch {
-                            // ignore rollback failures
-                        }
-                    });
+                    yield* Effect.promise(() => runControl("ROLLBACK").then(() => undefined, () => undefined));
                 });
-                yield* Effect.try({
-                    try: () => {
-                        client.run("BEGIN IMMEDIATE");
+                yield* Effect.tryPromise({
+                    try: async () => {
+                        await runControl(beginTransactionSql(self.internalStorage.dialect));
                         transactionState.depth += 1;
                         transactionState.ownerThread = currentFiberThread;
                         self.transactionDepth = transactionState.depth;
@@ -688,10 +794,8 @@ export class SmithersDb {
                     yield* rollback("operation", operationExit.cause);
                     return yield* Effect.failCause(operationExit.cause);
                 }
-                const commitExit = yield* Effect.exit(Effect.try({
-                    try: () => {
-                        client.run("COMMIT");
-                    },
+                const commitExit = yield* Effect.exit(Effect.tryPromise({
+                    try: () => runControl("COMMIT"),
                     catch: (cause) => toSmithersError(cause, "commit sqlite transaction", {
                         code: "DB_WRITE_FAILED",
                         details: { writeGroup, phase: "commit" },
@@ -884,9 +988,34 @@ export class SmithersDb {
    */
     claimRunForResume(params) {
         return this.write(`claim stale run ${params.runId}`, () => {
-            const client = this.db.session.client;
             const expectedStatus = params.expectedStatus ?? "running";
             const requireStale = params.requireStale ?? expectedStatus === "running";
+            if (this.internalStorage.dialect === POSTGRES) {
+                // Null-safe heartbeat compare without wrapping the bigint param in a
+                // numeric COALESCE(?, -1): the int4 `-1` literal would force the
+                // ms-timestamp param to int4 and overflow. Compare against the
+                // bigint column directly so Postgres infers bigint.
+                return this.internalStorage
+                    .queryAllRaw(`UPDATE _smithers_runs
+             SET runtime_owner_id = ?, heartbeat_at_ms = ?
+             WHERE run_id = ?
+               AND status = ?
+               AND COALESCE(runtime_owner_id, '') = COALESCE(?, '')
+               AND (heartbeat_at_ms IS NOT DISTINCT FROM ?)
+               AND (? = 0 OR heartbeat_at_ms IS NULL OR heartbeat_at_ms < ?)
+             RETURNING run_id`, [
+                        params.claimOwnerId,
+                        params.claimHeartbeatAtMs,
+                        params.runId,
+                        expectedStatus,
+                        params.expectedRuntimeOwnerId,
+                        params.expectedHeartbeatAtMs,
+                        requireStale ? 1 : 0,
+                        params.staleBeforeMs,
+                    ])
+                    .then((rows) => rows.length > 0);
+            }
+            const client = this.db.session.client;
             client
                 .query(`UPDATE _smithers_runs
            SET runtime_owner_id = ?, heartbeat_at_ms = ?
@@ -924,19 +1053,33 @@ export class SmithersDb {
     updateClaimedRun(params) {
         validateRunPatch(params.patch);
         return this.write(`update claimed run ${params.runId}`, () => {
-            const client = this.db.session.client;
             const patchEntries = Object.entries(params.patch);
             if (patchEntries.length === 0) {
                 return Promise.resolve(true);
             }
             const assignments = patchEntries.map(([key]) => `${camelToSnake(key)} = ?`);
+            const setArgs = patchEntries.map(([, value]) => value);
+            if (this.internalStorage.dialect === POSTGRES) {
+                // Null-safe heartbeat compare (see claimRunForResume): IS NOT
+                // DISTINCT FROM keeps the bigint param from being coerced to int4
+                // by an int4 `-1` sentinel.
+                return this.internalStorage
+                    .queryAllRaw(`UPDATE _smithers_runs
+             SET ${assignments.join(", ")}
+             WHERE run_id = ?
+               AND runtime_owner_id = ?
+               AND (heartbeat_at_ms IS NOT DISTINCT FROM ?)
+             RETURNING run_id`, [...setArgs, params.runId, params.expectedRuntimeOwnerId, params.expectedHeartbeatAtMs])
+                    .then((rows) => rows.length > 0);
+            }
+            const client = this.db.session.client;
             client
                 .query(`UPDATE _smithers_runs
            SET ${assignments.join(", ")}
            WHERE run_id = ?
              AND runtime_owner_id = ?
              AND COALESCE(heartbeat_at_ms, -1) = COALESCE(?, -1)`)
-                .run(...patchEntries.map(([, value]) => value), params.runId, params.expectedRuntimeOwnerId, params.expectedHeartbeatAtMs);
+                .run(...setArgs, params.runId, params.expectedRuntimeOwnerId, params.expectedHeartbeatAtMs);
             return this.internalStorage
                 .queryOne("SELECT changes() AS count")
                 .then((row) => Number(row?.count ?? 0) > 0);
@@ -1005,14 +1148,22 @@ export class SmithersDb {
         const target = cols.iteration
             ? [cols.runId, cols.nodeId, cols.iteration]
             : [cols.runId, cols.nodeId];
-        const tableName = table?.["_"]?.name ?? "output";
-        return this.write(`upsert output ${tableName}`, () => this.db
-            .insert(table)
-            .values(values)
-            .onConflictDoUpdate({
-            target: target,
-            set: values,
-        }));
+        const tableName = resolveOutputTableName(table);
+        const conflictColumns = cols.iteration
+            ? ["runId", "nodeId", "iteration"]
+            : ["runId", "nodeId"];
+        return this.write(`upsert output ${tableName}`, () => {
+            if (this.internalStorage.dialect === POSTGRES) {
+                return this.internalStorage.upsert(tableName, values, conflictColumns);
+            }
+            return this.db
+                .insert(table)
+                .values(values)
+                .onConflictDoUpdate({
+                target: target,
+                set: values,
+            });
+        });
     }
     /**
    * @param {Table} table
@@ -1030,6 +1181,14 @@ export class SmithersDb {
    */
     deleteOutputRow(tableName, key) {
         return this.write(`delete output ${tableName}`, () => {
+            if (this.internalStorage.dialect === POSTGRES) {
+                // PostgreSQL output tables are created from the Zod schema with
+                // snake_case run_id/node_id/iteration columns, so no PRAGMA-based
+                // column discovery is needed.
+                const escapedPg = tableName.replaceAll(`"`, `""`);
+                return this.internalStorage.execute(`DELETE FROM "${escapedPg}"
+             WHERE run_id = ? AND node_id = ? AND iteration = ?`, [key.runId, key.nodeId, key.iteration ?? 0]);
+            }
             const client = this.db.session.client;
             let resolvedTableName = tableName;
             let escapedTableName = resolvedTableName.replaceAll(`"`, `""`);
@@ -1112,10 +1271,20 @@ export class SmithersDb {
     getRawNodeOutput(tableName, runId, nodeId) {
         return runnableEffect(this.read(`get raw node output ${tableName}`, () => {
             const escaped = tableName.replaceAll(`"`, `""`);
+            if (this.internalStorage.dialect === POSTGRES) {
+                const boolColumns = getPhysicalBooleanColumnNames(findDrizzleTableByName(this.db, tableName));
+                return this.internalStorage
+                    .queryOneRaw(`SELECT * FROM "${escaped}" WHERE run_id = ? AND node_id = ? ORDER BY iteration DESC LIMIT 1`, [runId, nodeId])
+                    .then((row) => coerceRawBooleanColumns(row ?? null, boolColumns) ?? null);
+            }
             const client = this.db.session.client;
+            const boolColumns = [
+                ...getPersistedBooleanColumnNames(client, tableName),
+                ...getPhysicalBooleanColumnNames(findDrizzleTableByName(this.db, tableName)),
+            ];
             const stmt = client.query(`SELECT * FROM "${escaped}" WHERE run_id = ? AND node_id = ? ORDER BY iteration DESC LIMIT 1`);
             const row = stmt.get(runId, nodeId);
-            return Promise.resolve(row ?? null);
+            return Promise.resolve(coerceRawBooleanColumns(row ?? null, boolColumns) ?? null);
         }).pipe(Effect.catchAll(() => Effect.succeed(null))));
     }
     /**
@@ -1125,13 +1294,40 @@ export class SmithersDb {
    * @param {number} iteration
    * @returns {RunnableEffect<Record<string, unknown> | null, SmithersError>}
    */
+    /**
+   * Whether a physical table with this exact name exists in the database.
+   * @param {string} tableName
+   * @returns {RunnableEffect<boolean, SmithersError>}
+   */
+    hasPhysicalTable(tableName) {
+        return runnableEffect(this.read(`has physical table ${tableName}`, () => {
+            if (this.internalStorage.dialect === POSTGRES) {
+                return this.internalStorage
+                    .queryOneRaw(`SELECT 1 AS one FROM information_schema.tables WHERE table_name = ? LIMIT 1`, [tableName])
+                    .then((row) => row != null);
+            }
+            const client = this.db.session.client;
+            const stmt = client.query(`SELECT 1 AS one FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1`);
+            return Promise.resolve(stmt.get(tableName) != null);
+        }).pipe(Effect.catchAll(() => Effect.succeed(false))));
+    }
     getRawNodeOutputForIteration(tableName, runId, nodeId, iteration) {
         return runnableEffect(this.read(`get raw node output ${tableName} iteration ${iteration}`, () => {
             const escaped = tableName.replaceAll(`"`, `""`);
+            if (this.internalStorage.dialect === POSTGRES) {
+                const boolColumns = getPhysicalBooleanColumnNames(findDrizzleTableByName(this.db, tableName));
+                return this.internalStorage
+                    .queryOneRaw(`SELECT * FROM "${escaped}" WHERE run_id = ? AND node_id = ? AND iteration = ? LIMIT 1`, [runId, nodeId, iteration])
+                    .then((row) => coerceRawBooleanColumns(row ?? null, boolColumns) ?? null);
+            }
             const client = this.db.session.client;
+            const boolColumns = [
+                ...getPersistedBooleanColumnNames(client, tableName),
+                ...getPhysicalBooleanColumnNames(findDrizzleTableByName(this.db, tableName)),
+            ];
             const stmt = client.query(`SELECT * FROM "${escaped}" WHERE run_id = ? AND node_id = ? AND iteration = ? LIMIT 1`);
             const row = stmt.get(runId, nodeId, iteration);
-            return Promise.resolve(row ?? null);
+            return Promise.resolve(coerceRawBooleanColumns(row ?? null, boolColumns) ?? null);
         }).pipe(Effect.catchAll(() => Effect.succeed(null))));
     }
     /**
@@ -1810,6 +2006,75 @@ export class SmithersDb {
          ORDER BY attempt ASC, seq ASC`, [runId, nodeId, iteration]));
     }
     /**
+   * Record a distinct working-copy state (deduped by jj commit id). Upsert so a
+   * re-snapshot of the same tree refreshes the operation handle.
+   * @param {Record<string, unknown>} row
+   * @returns {RunnableEffect<void, SmithersError>}
+   */
+    upsertWorkspaceState(row) {
+        return this.write(`upsert workspace state ${row.jjCommitId}`, () => this.internalStorage.upsert("_smithers_workspace_states", row, ["runId", "jjCwd", "jjCommitId"]));
+    }
+    /**
+   * @param {string} runId
+   * @returns {RunnableEffect<Array<Record<string, unknown>>, SmithersError>}
+   */
+    listWorkspaceStates(runId) {
+        return this.read(`list workspace states ${runId}`, () => this.internalStorage.queryAll(`SELECT *
+         FROM _smithers_workspace_states
+         WHERE run_id = ?
+         ORDER BY created_at_ms ASC`, [runId]));
+    }
+    /**
+   * Record a snapshot checkpoint event. One row per tool/watch boundary; never
+   * deduped, so a Tier 1 boundary always has a seq to bind a resume to.
+   * @param {Record<string, unknown>} row
+   * @returns {RunnableEffect<void, SmithersError>}
+   */
+    insertWorkspaceCheckpoint(row) {
+        return this.write(`insert workspace checkpoint ${row.nodeId}#${row.seq}`, () => this.internalStorage.insertIgnore("_smithers_workspace_checkpoints", row));
+    }
+    /**
+   * @param {string} runId
+   * @returns {RunnableEffect<Array<Record<string, unknown>>, SmithersError>}
+   */
+    listWorkspaceCheckpoints(runId) {
+        return this.read(`list workspace checkpoints ${runId}`, () => this.internalStorage.queryAll(`SELECT *
+         FROM _smithers_workspace_checkpoints
+         WHERE run_id = ?
+         ORDER BY seq ASC`, [runId]));
+    }
+    /**
+   * Prune old workspace states for a run, keeping the most recent maxKeep by
+   * created_at_ms. The latest rows are always kept. Row-value NOT IN avoids the
+   * string-concat collision a naive key would have; portable to SQLite + Postgres.
+   * @param {string} runId
+   * @param {number} [maxKeep]
+   * @returns {RunnableEffect<void, SmithersError>}
+   */
+    pruneWorkspaceStates(runId, maxKeep = 50) {
+        const keep = Math.max(1, maxKeep);
+        return this.write(`prune workspace states ${runId}`, () => this.internalStorage.deleteWhere("_smithers_workspace_states", `run_id = ? AND (jj_cwd, jj_commit_id) NOT IN (
+           SELECT jj_cwd, jj_commit_id FROM _smithers_workspace_states
+           WHERE run_id = ? ORDER BY created_at_ms DESC LIMIT ?)`, [runId, runId, keep]));
+    }
+    /**
+   * Prune old workspace checkpoints, keeping the most recent maxKeepPerScope per
+   * (node_id, iteration, attempt) via a window function. The latest checkpoint per
+   * scope is always kept, so resume-restore targets survive.
+   * @param {string} runId
+   * @param {number} [maxKeepPerScope]
+   * @returns {RunnableEffect<void, SmithersError>}
+   */
+    pruneWorkspaceCheckpoints(runId, maxKeepPerScope = 100) {
+        const keep = Math.max(1, maxKeepPerScope);
+        return this.write(`prune workspace checkpoints ${runId}`, () => this.internalStorage.deleteWhere("_smithers_workspace_checkpoints", `run_id = ? AND (node_id, iteration, attempt, seq) NOT IN (
+           SELECT node_id, iteration, attempt, seq FROM (
+             SELECT node_id, iteration, attempt, seq,
+                    ROW_NUMBER() OVER (PARTITION BY node_id, iteration, attempt ORDER BY seq DESC) AS rn
+             FROM _smithers_workspace_checkpoints WHERE run_id = ?
+           ) sub WHERE rn <= ?)`, [runId, runId, keep]));
+    }
+    /**
    * @param {Record<string, unknown>} row
    * @returns {RunnableEffect<void, SmithersError>}
    */
@@ -1968,6 +2233,34 @@ export class SmithersDb {
          WHERE run_id = ? AND status = ?`, [runId, "requested"], { booleanColumns: ["autoApproved"] }));
     }
     /**
+   * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listDecidedApprovals(runId) {
+        return this.read(`list decided approvals ${runId}`, () => this.internalStorage.queryAll(`SELECT a.*
+         FROM _smithers_approvals a
+         JOIN _smithers_nodes n
+           ON a.run_id = n.run_id
+          AND a.node_id = n.node_id
+          AND a.iteration = n.iteration
+         WHERE a.run_id = ?
+           AND a.status IN ('approved', 'denied')
+           AND n.state = 'pending'`, [runId], { booleanColumns: ["autoApproved"] }));
+    }
+    /**
+   * Returns all decided approvals for a run (approved or denied), regardless of
+   * node state. Used by why-diagnosis so denied gates (node state = 'failed')
+   * are included in the diagnosis output.
+   * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listAllDecidedApprovals(runId) {
+        return this.read(`list all decided approvals ${runId}`, () => this.internalStorage.queryAll(`SELECT *
+         FROM _smithers_approvals
+         WHERE run_id = ?
+           AND status IN ('approved', 'denied')`, [runId], { booleanColumns: ["autoApproved"] }));
+    }
+    /**
    * @returns {RunnableEffect<Array<Record<string, unknown>>, SmithersError>}
    */
     listAllPendingApprovals() {
@@ -1977,8 +2270,12 @@ export class SmithersDb {
            a.iteration,
            a.status,
            a.requested_at_ms,
+           a.decided_at_ms,
            a.note,
            a.decided_by,
+           a.request_json,
+           a.decision_json,
+           a.auto_approved,
            r.workflow_name,
            r.status AS run_status,
            n.label AS node_label
@@ -1989,7 +2286,7 @@ export class SmithersDb {
           AND a.node_id = n.node_id
           AND a.iteration = n.iteration
          WHERE a.status = ?
-         ORDER BY COALESCE(a.requested_at_ms, 0) ASC, a.run_id, a.node_id, a.iteration`, ["requested"]));
+         ORDER BY COALESCE(a.requested_at_ms, 0) ASC, a.run_id, a.node_id, a.iteration`, ["requested"], { booleanColumns: ["autoApproved"] }));
     }
     /**
    * @param {string} workflowName
@@ -2401,6 +2698,20 @@ export class SmithersDb {
     }
     /**
    * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listDecidedApprovalsEffect(runId) {
+        return this.listDecidedApprovals(runId);
+    }
+    /**
+   * @param {string} runId
+   * @returns {RunnableEffect<ApprovalRow[], SmithersError>}
+   */
+    listAllDecidedApprovalsEffect(runId) {
+        return this.listAllDecidedApprovals(runId);
+    }
+    /**
+   * @param {string} runId
    * @returns {RunnableEffect<FrameRow | undefined, SmithersError>}
    */
     getLastFrameEffect(runId) {