@smithers-orchestrator/db 0.21.0 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/db",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "SQLite and Drizzle persistence adapter for Smithers workflows",
   "type": "module",
   "sideEffects": false,
@@ -26,13 +26,16 @@
     "drizzle-zod": "^0.8.3",
     "effect": "^3.21.1",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/errors": "0.21.0",
-    "@smithers-orchestrator/graph": "0.21.0",
-    "@smithers-orchestrator/scheduler": "0.21.0",
-    "@smithers-orchestrator/observability": "0.21.0"
+    "@smithers-orchestrator/errors": "0.23.0",
+    "@smithers-orchestrator/observability": "0.23.0",
+    "@smithers-orchestrator/graph": "0.23.0",
+    "@smithers-orchestrator/scheduler": "0.23.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

@@ -10,10 +10,11 @@
 /** @typedef {import("./adapter/StaleRunRecord.ts").StaleRunRecord} StaleRunRecord */
 // @smithers-type-exports-end
 
-import { getTableName, sql } from "drizzle-orm";
+import { getTableName } from "drizzle-orm";
 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";
@@ -409,6 +410,23 @@ 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
  * @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 +523,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 +669,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 +692,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 +713,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 +907,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 +972,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 +1067,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 +1100,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(`"`, `""`);
@@ -1111,9 +1189,16 @@ export class SmithersDb {
    */
     getRawNodeOutput(tableName, runId, nodeId) {
         return runnableEffect(this.read(`get raw node output ${tableName}`, () => {
-            const query = sql.raw(`SELECT * FROM "${tableName}" WHERE run_id = '${runId}' AND node_id = '${nodeId}' ORDER BY iteration DESC LIMIT 1`);
-            const res = this.db.get(query);
-            return Promise.resolve(res ?? null);
+            const escaped = tableName.replaceAll(`"`, `""`);
+            if (this.internalStorage.dialect === POSTGRES) {
+                return this.internalStorage
+                    .queryOneRaw(`SELECT * FROM "${escaped}" WHERE run_id = ? AND node_id = ? ORDER BY iteration DESC LIMIT 1`, [runId, nodeId])
+                    .then((row) => row ?? null);
+            }
+            const client = this.db.session.client;
+            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);
         }).pipe(Effect.catchAll(() => Effect.succeed(null))));
     }
     /**
@@ -1126,6 +1211,11 @@ export class SmithersDb {
     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) {
+                return this.internalStorage
+                    .queryOneRaw(`SELECT * FROM "${escaped}" WHERE run_id = ? AND node_id = ? AND iteration = ? LIMIT 1`, [runId, nodeId, iteration])
+                    .then((row) => row ?? null);
+            }
             const client = this.db.session.client;
             const stmt = client.query(`SELECT * FROM "${escaped}" WHERE run_id = ? AND node_id = ? AND iteration = ? LIMIT 1`);
             const row = stmt.get(runId, nodeId, iteration);
@@ -1808,6 +1898,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>}
    */

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/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/loadInputEffect.js

@@ -13,16 +13,18 @@ import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
  * @returns {Effect.Effect<Record<string, unknown> | undefined, SmithersError>}
  */
 export function loadInput(db, inputTable, runId) {
-    const cols = getTableColumns(inputTable);
-    const runIdCol = cols.runId;
-    if (!runIdCol) {
-        throw new SmithersError("DB_MISSING_COLUMNS", "schema.input must include runId column");
-    }
-    return Effect.tryPromise({
-        try: () => db.select().from(inputTable).where(eq(runIdCol, runId)).limit(1),
-        catch: (cause) => toSmithersError(cause, "load input", {
-            code: "DB_QUERY_FAILED",
-            details: { runId },
-        }),
-    }).pipe(Effect.map((rows) => rows[0]), Effect.annotateLogs({ runId }), Effect.withLogSpan("db:load-input"));
+    return Effect.suspend(() => {
+        const cols = getTableColumns(inputTable);
+        const runIdCol = cols.runId;
+        if (!runIdCol) {
+            return Effect.fail(new SmithersError("DB_MISSING_COLUMNS", "schema.input must include runId column"));
+        }
+        return Effect.tryPromise({
+            try: () => db.select().from(inputTable).where(eq(runIdCol, runId)).limit(1),
+            catch: (cause) => toSmithersError(cause, "load input", {
+                code: "DB_QUERY_FAILED",
+                details: { runId },
+            }),
+        }).pipe(Effect.map((rows) => rows[0]));
+    }).pipe(Effect.annotateLogs({ runId }), Effect.withLogSpan("db:load-input"));
 }

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,19 +75,73 @@ function coerceBooleanColumns(rows, boolKeys) {
  * @param {string} runId
  * @returns {Effect.Effect<Record<string, unknown> | undefined, SmithersError>}
  */
-export function loadInputEffect(db, inputTable, runId) {
-    const cols = getTableColumns(inputTable);
-    const runIdCol = cols.runId;
-    if (!runIdCol) {
-        throw new SmithersError("DB_MISSING_COLUMNS", "schema.input must include runId column");
+/**
+ * @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 Effect.tryPromise({
-        try: () => db.select().from(inputTable).where(eq(runIdCol, runId)).limit(1),
-        catch: (cause) => toSmithersError(cause, "load input", {
-            code: "DB_QUERY_FAILED",
-            details: { runId },
-        }),
-    }).pipe(Effect.map((rows) => rows[0]), Effect.annotateLogs({ runId }), Effect.withLogSpan("db:load-input"));
+    return out;
+}
+export function loadInputEffect(db, inputTable, runId) {
+    return Effect.suspend(() => {
+        const cols = getTableColumns(inputTable);
+        const runIdCol = cols.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", {
+                code: "DB_QUERY_FAILED",
+                details: { runId },
+            }),
+        }).pipe(Effect.map((rows) => rows[0]));
+    }).pipe(Effect.annotateLogs({ runId }), Effect.withLogSpan("db:load-input"));
 }
 /**
  * @param {BunSQLiteDatabase<Record<string, unknown>>} db
@@ -102,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));
@@ -123,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"));
+}

package/src/sql-message-storage.js

@@ -3,8 +3,17 @@ import * as SqlClient from "@effect/sql/SqlClient";
 import { SqlError } from "@effect/sql/SqlError";
 import * as Statement from "@effect/sql/Statement";
 import { Database } from "bun:sqlite";
-import { Context, Effect, Layer, ManagedRuntime, Scope } from "effect";
-import { runSmithersSchemaMigrations } from "./schema-migrations.js";
+import { Context, Effect, Layer, ManagedRuntime, Scope, Stream } from "effect";
+import {
+    POSTGRES,
+    SQLITE,
+    jsonExtractText,
+    translatePlaceholders,
+} from "./dialect.js";
+import {
+    runSmithersSchemaMigrations,
+    runSmithersSchemaInitPostgres,
+} from "./schema-migrations.js";
 import { camelToSnake } from "./utils/camelToSnake.js";
 /** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase} BunSQLiteDatabase */
 /** @typedef {import("./SqlMessageStorageEventHistoryQuery.ts").SqlMessageStorageEventHistoryQuery} SqlMessageStorageEventHistoryQuery */
@@ -205,6 +214,30 @@ const CREATE_TABLE_STATEMENTS = [
     status TEXT NOT NULL,
     error_json TEXT,
     PRIMARY KEY (run_id, node_id, iteration, attempt, seq)
+  )`,
+    `CREATE TABLE IF NOT EXISTS _smithers_workspace_states (
+    run_id TEXT NOT NULL,
+    jj_cwd TEXT NOT NULL,
+    jj_commit_id TEXT NOT NULL,
+    jj_operation_id TEXT NOT NULL,
+    jj_change_id TEXT,
+    created_at_ms INTEGER NOT NULL,
+    PRIMARY KEY (run_id, jj_cwd, jj_commit_id)
+  )`,
+    `CREATE TABLE IF NOT EXISTS _smithers_workspace_checkpoints (
+    run_id TEXT NOT NULL,
+    node_id TEXT NOT NULL,
+    iteration INTEGER NOT NULL DEFAULT 0,
+    attempt INTEGER NOT NULL,
+    seq INTEGER NOT NULL,
+    jj_cwd TEXT NOT NULL,
+    jj_commit_id TEXT NOT NULL,
+    source TEXT NOT NULL,
+    tier INTEGER NOT NULL,
+    label TEXT,
+    tool_use_id TEXT,
+    created_at_ms INTEGER NOT NULL,
+    PRIMARY KEY (run_id, node_id, iteration, attempt, seq)
   )`,
     `CREATE TABLE IF NOT EXISTS _smithers_events (
     run_id TEXT NOT NULL,
@@ -393,14 +426,17 @@ function applyBooleanColumns(row, booleanColumns) {
  * @param {Record<string, unknown>} row
  * @param {{ orIgnore?: boolean; conflictColumns?: readonly string[]; updateColumns?: readonly string[]; }} [options]
  */
-function buildInsertSql(table, row, options) {
+function buildInsertSql(table, row, options, dialect = SQLITE) {
     const entries = Object.entries(row).filter(([, value]) => value !== undefined);
     const columns = entries.map(([key]) => camelToSnake(key));
     const params = entries.map(([, value]) => encodeParam(value));
     const tableSql = quoteIdentifier(table);
     const columnSql = columns.map(quoteIdentifier).join(", ");
     const placeholderSql = columns.map(() => "?").join(", ");
-    let statement = `INSERT${options?.orIgnore ? " OR IGNORE" : ""} INTO ${tableSql} (${columnSql}) ` +
+    // SQLite spells the ignore-on-conflict shorthand `INSERT OR IGNORE`;
+    // PostgreSQL has no such prefix and instead appends `ON CONFLICT DO NOTHING`.
+    const orIgnorePrefix = options?.orIgnore && dialect !== POSTGRES ? " OR IGNORE" : "";
+    let statement = `INSERT${orIgnorePrefix} INTO ${tableSql} (${columnSql}) ` +
         `VALUES (${placeholderSql})`;
     if (options?.conflictColumns && options.conflictColumns.length > 0) {
         const conflictSql = options.conflictColumns.map(camelToSnake).map(quoteIdentifier).join(", ");
@@ -417,6 +453,9 @@ function buildInsertSql(table, row, options) {
             statement += ` ON CONFLICT (${conflictSql}) DO UPDATE SET ${updateSql}`;
         }
     }
+    else if (options?.orIgnore && dialect === POSTGRES) {
+        statement += ` ON CONFLICT DO NOTHING`;
+    }
     return { statement, params };
 }
 /**
@@ -494,7 +533,7 @@ function createConnection(sqlite) {
             }
         }),
         executeUnprepared: (statement, params, transformRows) => execute(statement, params, transformRows),
-        executeStream: () => Effect.dieMessage("executeStream not implemented"),
+        executeStream: (statement, params, transformRows) => Stream.fromIterableEffect(execute(statement, params, transformRows)),
     };
 }
 /**
@@ -524,18 +563,118 @@ function makeSqlClientEffect(sqlite) {
 function makeSqlClientLayer(sqlite) {
     return Layer.scoped(SqlClient.SqlClient, makeSqlClientEffect(sqlite));
 }
+/**
+ * @param {SqliteParam} value
+ * @returns {unknown}
+ */
+function toPostgresParam(value) {
+    // node-postgres maps Buffer → bytea; a bare Uint8Array does not round-trip.
+    if (value instanceof Uint8Array || Buffer.isBuffer(value)) {
+        return Buffer.isBuffer(value) ? value : Buffer.from(value);
+    }
+    // Smithers mirrors SQLite's storage model on Postgres: JSON lives in TEXT
+    // columns. SQLite/Drizzle stringify objects automatically; node-postgres does
+    // not, so do it here to keep a single encoding contract across dialects.
+    if (value !== null && typeof value === "object" && !(value instanceof Date)) {
+        return JSON.stringify(value);
+    }
+    return value;
+}
+/**
+ * A `@effect/sql` connection backed by a single node-postgres connection (any
+ * object exposing `query({ text, values, rowMode })` — a `pg.Client`, or a
+ * PGlite socket connection). Smithers writes SQL with `?` placeholders; this
+ * connection rewrites them to PostgreSQL's `$n` on the way out, mirroring the
+ * SQLite connection so the rest of the adapter is dialect-agnostic.
+ * @param {{ query: (config: { text: string; values?: ReadonlyArray<unknown>; rowMode?: "array" }) => Promise<{ rows?: ReadonlyArray<any> }> }} pgConn
+ * @returns {Connection}
+ */
+function createPostgresConnection(pgConn) {
+    const run = (statement, params, transformRows) => Effect.tryPromise({
+        try: async () => {
+            const text = translatePlaceholders(POSTGRES, statement);
+            const result = await pgConn.query({ text, values: params.map(toPostgresParam) });
+            const rows = result.rows ?? [];
+            return transformRows ? transformRows(rows) : rows;
+        },
+        catch: (cause) => new SqlError({ cause, message: "Failed to execute Postgres statement" }),
+    });
+    return {
+        execute: (statement, params, transformRows) => run(statement, params, transformRows),
+        executeRaw: (statement, params) => run(statement, params, undefined),
+        executeValues: (statement, params) => Effect.tryPromise({
+            try: async () => {
+                const text = translatePlaceholders(POSTGRES, statement);
+                const result = await pgConn.query({
+                    text,
+                    values: params.map(toPostgresParam),
+                    rowMode: "array",
+                });
+                return result.rows ?? [];
+            },
+            catch: (cause) => new SqlError({ cause, message: "Failed to execute Postgres values statement" }),
+        }),
+        executeUnprepared: (statement, params, transformRows) => run(statement, params, transformRows),
+        executeStream: (statement, params, transformRows) => Stream.fromIterableEffect(run(statement, params, transformRows)),
+    };
+}
+/**
+ * @param {object} pgConn
+ * @returns {Effect.Effect<SqlClient.SqlClient, never>}
+ */
+function makePostgresSqlClientEffect(pgConn) {
+    // The compiler is only exercised by the `sql``` tagged template, which this
+    // storage never uses — every query is a pre-built string run through the raw
+    // connection, where the `?`→`$n` rewrite happens. So the SQLite compiler is
+    // an inert placeholder here.
+    const compiler = Statement.makeCompilerSqlite(camelToSnake);
+    const connection = createPostgresConnection(pgConn);
+    return Effect.gen(function* () {
+        const semaphore = yield* Effect.makeSemaphore(1);
+        const acquirer = semaphore.withPermits(1)(Effect.succeed(connection));
+        const transactionAcquirer = Effect.uninterruptibleMask((restore) => Effect.as(Effect.zipRight(restore(semaphore.take(1)), Effect.tap(Effect.scope, (scope) => Scope.addFinalizer(scope, semaphore.release(1)))), connection));
+        const reactivity = yield* Reactivity.make;
+        return yield* SqlClient.make({
+            acquirer,
+            compiler,
+            transactionAcquirer,
+            spanAttributes: [[ATTR_DB_SYSTEM_NAME, "postgresql"]],
+            transformRows: transformRowKeys,
+        }).pipe(Effect.provideService(Reactivity.Reactivity, reactivity));
+    });
+}
+/**
+ * @param {object} pgConn
+ */
+function makePostgresSqlClientLayer(pgConn) {
+    return Layer.scoped(SqlClient.SqlClient, makePostgresSqlClientEffect(pgConn));
+}
 export class SqlMessageStorage {
     sqlite;
+    /** @type {import("./dialect.js").Dialect} */
+    dialect;
+    /** @type {object | null} */
+    pgConn;
     // TODO(Phase 8): Keep this per-DB runtime until the unified runtime can
     // inject a scoped SqlClient without rebuilding the per-connection semaphore.
     runtime;
     tableColumnsCache = new Map();
     /**
-   * @param {BunSQLiteDatabase<any> | Database} db
+   * @param {BunSQLiteDatabase<any> | Database | { dialect: "postgres"; connection: object }} db
    */
     constructor(db) {
-        this.sqlite = resolveSqliteDatabase(db);
-        this.runtime = ManagedRuntime.make(makeSqlClientLayer(this.sqlite));
+        if (db && typeof db === "object" && /** @type {any} */ (db).dialect === POSTGRES) {
+            this.dialect = POSTGRES;
+            this.pgConn = /** @type {any} */ (db).connection;
+            this.sqlite = null;
+            this.runtime = ManagedRuntime.make(makePostgresSqlClientLayer(this.pgConn));
+        }
+        else {
+            this.dialect = SQLITE;
+            this.sqlite = resolveSqliteDatabase(db);
+            this.pgConn = null;
+            this.runtime = ManagedRuntime.make(makeSqlClientLayer(this.sqlite));
+        }
     }
     /**
    * @param {string} table
@@ -546,6 +685,13 @@ export class SqlMessageStorage {
         if (cached) {
             return cached;
         }
+        if (this.dialect === POSTGRES) {
+            // A fresh PostgreSQL schema has no historical column drift to defend
+            // against, and PRAGMA is unavailable. Returning null tells
+            // filterKnownColumns to skip filtering, so a genuinely missing column
+            // surfaces as a loud insert error rather than a silently dropped field.
+            return null;
+        }
         const rows = this.sqlite
             .query(`PRAGMA table_info(${quoteIdentifier(table)})`)
             .all();
@@ -562,7 +708,7 @@ export class SqlMessageStorage {
    */
     filterKnownColumns(table, row) {
         const knownColumns = this.getTableColumns(table);
-        return Object.fromEntries(Object.entries(row).filter(([key, value]) => value !== undefined && knownColumns.has(key)));
+        return Object.fromEntries(Object.entries(row).filter(([key, value]) => value !== undefined && (knownColumns === null || knownColumns.has(key))));
     }
     /**
    * @template A, E
@@ -584,6 +730,16 @@ export class SqlMessageStorage {
    * @returns {Effect.Effect<void, never>}
    */
     ensureSchemaEffect() {
+        if (this.dialect === POSTGRES) {
+            const pgConn = this.pgConn;
+            return Effect.tryPromise({
+                try: () => runSmithersSchemaInitPostgres(pgConn, {
+                    createTableStatements: CREATE_TABLE_STATEMENTS,
+                    createIndexStatements: CREATE_INDEX_STATEMENTS,
+                }),
+                catch: (cause) => new SqlError({ cause, message: "Failed to initialize Postgres schema" }),
+            });
+        }
         const sqlite = this.sqlite;
         return Effect.sync(() => {
             runSmithersSchemaMigrations(sqlite, {
@@ -622,6 +778,28 @@ export class SqlMessageStorage {
         return rows[0];
     }
     /**
+   * Like {@link queryAll} but returns rows with their on-disk column names (no
+   * snake→camel transform). Used for "raw" output-table reads where callers
+   * expect the storage column names verbatim.
+   * @template T
+   * @param {string} statement
+   * @param {ReadonlyArray<SqliteParam>} [params]
+   * @returns {Promise<Array<T>>}
+   */
+    queryAllRaw(statement, params = []) {
+        return this.withConnection((connection) => connection.execute(statement, params.map(encodeParam), undefined));
+    }
+    /**
+   * @template T
+   * @param {string} statement
+   * @param {ReadonlyArray<SqliteParam>} [params]
+   * @returns {Promise<T | undefined>}
+   */
+    async queryOneRaw(statement, params = []) {
+        const rows = await this.queryAllRaw(statement, params);
+        return rows[0];
+    }
+    /**
    * @param {string} statement
    * @param {ReadonlyArray<SqliteParam>} [params]
    * @returns {Promise<void>}
@@ -636,7 +814,7 @@ export class SqlMessageStorage {
    */
     insertIgnore(table, row) {
         const filteredRow = this.filterKnownColumns(table, row);
-        const { statement, params } = buildInsertSql(table, filteredRow, { orIgnore: true });
+        const { statement, params } = buildInsertSql(table, filteredRow, { orIgnore: true }, this.dialect);
         return this.execute(statement, params);
     }
     /**
@@ -651,7 +829,7 @@ export class SqlMessageStorage {
         const { statement, params } = buildInsertSql(table, filteredRow, {
             conflictColumns,
             updateColumns,
-        });
+        }, this.dialect);
         return this.execute(statement, params);
     }
     /**
@@ -694,7 +872,7 @@ export class SqlMessageStorage {
             params.push(...query.types);
         }
         if (query.nodeId) {
-            clauses.push("json_extract(payload_json, '$.nodeId') = ?");
+            clauses.push(`${jsonExtractText(this.dialect, "payload_json", "$.nodeId")} = ?`);
             params.push(query.nodeId);
         }
         return {

package/src/zodToCreateTableSQL.js

@@ -1,4 +1,5 @@
 import { unwrapZodType } from "./unwrapZodType.js";
+import { columnType, SQLITE } from "./dialect.js";
 import { camelToSnake } from "./utils/camelToSnake.js";
 /**
  * Determines the Zod base type name from a (possibly unwrapped) Zod type.
@@ -34,18 +35,22 @@ export function zodSchemaColumns(schema) {
 }
 /**
  * Generates a CREATE TABLE IF NOT EXISTS SQL statement from a Zod schema.
- * Used for runtime table creation without Drizzle migrations.
+ * Used for runtime table creation without Drizzle migrations. Pass
+ * `opts.dialect` to emit PostgreSQL-compatible column types; the default
+ * (`sqlite`) is byte-identical to the historical output.
  */
 export function zodToCreateTableSQL(tableName, schema, opts) {
+    const dialect = opts?.dialect ?? SQLITE;
+    const integer = columnType(dialect, "INTEGER");
     const colDefs = opts?.isInput
         ? [`run_id TEXT NOT NULL PRIMARY KEY`]
         : [
             `run_id TEXT NOT NULL`,
             `node_id TEXT NOT NULL`,
-            `iteration INTEGER NOT NULL DEFAULT 0`,
+            `iteration ${integer} NOT NULL DEFAULT 0`,
         ];
     for (const { name, sqliteType } of zodSchemaColumns(schema)) {
-        colDefs.push(`"${name}" ${sqliteType}`);
+        colDefs.push(`"${name}" ${columnType(dialect, sqliteType)}`);
     }
     if (!opts?.isInput) {
         colDefs.push(`PRIMARY KEY (run_id, node_id, iteration)`);