llm-cli-gateway 2.13.2 → 2.14.0-rc.1

package/dist/job-store.d.ts

@@ -214,18 +214,56 @@ export declare class MemoryJobStore implements JobStore {
     evictExpired(): number;
     close(): void;
 }
-export declare class PostgresJobStore implements JobStore {
-    constructor(_dsn: string, _logger?: Logger);
-    recordStart(): void;
-    recordOutput(): void;
-    recordComplete(): void;
-    getById(): JobRecord | null;
-    findByRequestKey(): JobRecord | null;
+export declare class PostgresJobStore implements JobStore, ValidationRunStore {
+    private logger;
+    private worker;
+    private tmpDir;
+    private nextRequestId;
+    private closed;
+    constructor(dsn: string, logger?: Logger, options?: {
+        retentionMs?: number;
+        dedupWindowMs?: number;
+    });
+    private syncCall;
+    recordStart(input: {
+        id: string;
+        correlationId: string;
+        requestKey: string;
+        cli: string;
+        args: string[];
+        outputFormat?: string;
+        startedAt: string;
+        pid: number | null;
+        ownerPrincipal?: string | null;
+        transport?: JobTransport;
+        payloadJson?: string | null;
+    }): void;
+    recordOutput(id: string, stdout: string, stderr: string, outputTruncated: boolean): void;
+    recordComplete(input: {
+        id: string;
+        status: Exclude<JobStoreStatus, "running">;
+        exitCode: number | null;
+        stdout: string;
+        stderr: string;
+        outputTruncated: boolean;
+        error: string | null;
+        finishedAt: string;
+        httpStatus?: number | null;
+    }): void;
+    getById(id: string): JobRecord | null;
+    findByRequestKey(requestKey: string): JobRecord | null;
     markOrphanedOnStartup(): {
         count: number;
         orphaned: Array<OrphanedJobSnapshot>;
     };
     evictExpired(): number;
+    recordValidationRun(run: ValidationRunRecord): void;
+    getValidationRun(validationId: string): ValidationRunRecord | null;
+    setValidationJudgeLink(validationId: string, judgeLink: ValidationRunLink): void;
+    setValidationRunStatus(validationId: string, status: ValidationRunRecord["status"]): void;
+    getValidationRunIdByJobId(jobId: string): string | null;
+    recordValidationReceipt(receipt: ValidationReceiptRecord): void;
+    getValidationReceipt(validationId: string): ValidationReceiptRecord | null;
     close(): void;
 }
 export declare function createJobStore(config: PersistenceConfig, logger?: Logger): JobStore | null;

package/dist/job-store.js

@@ -1,7 +1,9 @@
-import { chmodSync } from "fs";
+import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync } from "fs";
 import os from "os";
 import path from "path";
 import { createHash } from "crypto";
+import { Worker } from "worker_threads";
+import { fileURLToPath } from "url";
 import { openDatabase } from "./sqlite-driver.js";
 import { noopLogger } from "./logger.js";
 export function resolveJobStoreDbPath() {
@@ -550,34 +552,153 @@ export class MemoryJobStore {
     }
 }
 export class PostgresJobStore {
-    constructor(_dsn, _logger = noopLogger) {
-        throw new Error("PostgresJobStore is not yet implemented. Use backend = 'sqlite' (single-instance) or " +
-            "backend = 'memory' (ephemeral) until the Postgres backend ships.");
+    logger;
+    worker;
+    tmpDir;
+    nextRequestId = 0;
+    closed = false;
+    constructor(dsn, logger = noopLogger, options = {}) {
+        this.logger = logger;
+        if (!dsn) {
+            throw new Error("PostgresJobStore requires a non-empty DSN");
+        }
+        this.tmpDir = mkdtempSync(path.join(os.tmpdir(), "llm-gateway-pg-job-store-"));
+        this.worker = new Worker(resolvePostgresWorkerUrl(), {
+            execArgv: [],
+            workerData: {
+                dsn,
+                retentionMs: options.retentionMs ?? resolveJobRetentionMs(),
+                dedupWindowMs: options.dedupWindowMs ?? resolveDedupWindowMs(),
+                farFutureIso: FAR_FUTURE_ISO,
+                connectionTimeoutMillis: 5000,
+            },
+        });
+        try {
+            this.syncCall("init");
+        }
+        catch (err) {
+            this.closed = true;
+            void this.worker.terminate();
+            rmSync(this.tmpDir, { recursive: true, force: true });
+            throw err;
+        }
     }
-    recordStart() {
-        throw new Error("not implemented");
+    syncCall(method, ...args) {
+        if (this.closed && method !== "close") {
+            throw new Error("PostgresJobStore is closed");
+        }
+        const shared = new SharedArrayBuffer(4);
+        const state = new Int32Array(shared);
+        const resultPath = path.join(this.tmpDir, `result-${process.pid}-${++this.nextRequestId}.json`);
+        this.worker.postMessage({ method, args, resultPath, shared });
+        const wait = Atomics.wait(state, 0, 0, method === "init" ? 10_000 : 30_000);
+        if (wait !== "ok" && wait !== "not-equal") {
+            throw new Error(`PostgresJobStore ${method} wait failed: ${wait}`);
+        }
+        if (Atomics.load(state, 0) === 2) {
+            throw new Error(`PostgresJobStore ${method} worker could not write its result`);
+        }
+        let payload;
+        try {
+            payload = JSON.parse(readFileSync(resultPath, "utf8"));
+        }
+        finally {
+            rmSync(resultPath, { force: true });
+        }
+        if (!payload.ok) {
+            const err = new Error(payload.error.message);
+            if (payload.error.stack)
+                err.stack = payload.error.stack;
+            throw err;
+        }
+        return payload.value;
     }
-    recordOutput() {
-        throw new Error("not implemented");
+    recordStart(input) {
+        this.syncCall("recordStart", input);
     }
-    recordComplete() {
-        throw new Error("not implemented");
+    recordOutput(id, stdout, stderr, outputTruncated) {
+        this.syncCall("recordOutput", id, stdout, stderr, outputTruncated);
     }
-    getById() {
-        throw new Error("not implemented");
+    recordComplete(input) {
+        this.syncCall("recordComplete", input);
     }
-    findByRequestKey() {
-        throw new Error("not implemented");
+    getById(id) {
+        const row = this.syncCall("getById", id);
+        return row ? rowToRecord(row) : null;
+    }
+    findByRequestKey(requestKey) {
+        const row = this.syncCall("findByRequestKey", requestKey);
+        return row ? rowToRecord(row) : null;
     }
     markOrphanedOnStartup() {
-        throw new Error("not implemented");
+        const result = this.syncCall("markOrphanedOnStartup");
+        return {
+            count: result.count,
+            orphaned: result.orphaned.map(row => ({
+                id: row.id,
+                correlationId: row.correlation_id,
+                startedAt: row.started_at,
+                stdout: row.stdout ?? "",
+                stderr: row.stderr ?? "",
+                exitCode: row.exit_code,
+                transport: row.transport ?? "process",
+                httpStatus: row.http_status ?? null,
+            })),
+        };
     }
     evictExpired() {
-        throw new Error("not implemented");
+        return this.syncCall("evictExpired");
+    }
+    recordValidationRun(run) {
+        this.syncCall("recordValidationRun", run);
+    }
+    getValidationRun(validationId) {
+        const row = this.syncCall("getValidationRun", validationId);
+        return row ? rowToValidationRunRecord(row) : null;
+    }
+    setValidationJudgeLink(validationId, judgeLink) {
+        this.syncCall("setValidationJudgeLink", validationId, judgeLink);
+    }
+    setValidationRunStatus(validationId, status) {
+        this.syncCall("setValidationRunStatus", validationId, status);
+    }
+    getValidationRunIdByJobId(jobId) {
+        return this.syncCall("getValidationRunIdByJobId", jobId);
+    }
+    recordValidationReceipt(receipt) {
+        this.syncCall("recordValidationReceipt", receipt);
+    }
+    getValidationReceipt(validationId) {
+        const row = this.syncCall("getValidationReceipt", validationId);
+        return row ? rowToValidationReceiptRecord(row) : null;
     }
     close() {
+        if (this.closed)
+            return;
+        try {
+            this.syncCall("close");
+        }
+        catch (err) {
+            this.logger.error("PostgresJobStore close failed", err);
+        }
+        finally {
+            this.closed = true;
+            void this.worker.terminate();
+            rmSync(this.tmpDir, { recursive: true, force: true });
+        }
     }
 }
+function resolvePostgresWorkerUrl() {
+    const sibling = new URL("./postgres-job-store-worker.js", import.meta.url);
+    if (existsSync(fileURLToPath(sibling)))
+        return sibling;
+    if (import.meta.url.endsWith("/src/job-store.ts")) {
+        const built = new URL("../dist/postgres-job-store-worker.js", import.meta.url);
+        if (existsSync(fileURLToPath(built)))
+            return built;
+    }
+    throw new Error("PostgresJobStore worker module is missing. Run `npm run build` before using backend = 'postgres'.");
+}
 export function createJobStore(config, logger = noopLogger) {
     const opts = {
         retentionMs: config.retentionDays * 24 * 60 * 60 * 1000,
@@ -589,7 +710,7 @@ export function createJobStore(config, logger = noopLogger) {
         case "memory":
             return new MemoryJobStore(opts);
         case "postgres":
-            return new PostgresJobStore(config.dsn ?? "", logger);
+            return new PostgresJobStore(config.dsn ?? "", logger, opts);
         case "sqlite":
         default:
             if (!config.path) {

package/dist/model-registry.d.ts

@@ -17,6 +17,7 @@ export interface CliInfo {
     aliases?: Record<string, string>;
     modelMetadata?: Record<string, ModelMetadata>;
     warnings?: string[];
+    defaultAgent?: string;
 }
 export type CliInfoMap = Record<CliType, CliInfo>;
 export declare function getCliInfo(forceRefresh?: boolean): CliInfoMap;

package/dist/model-registry.js

@@ -139,6 +139,7 @@ function cloneInfo(source) {
         aliases: source.aliases ? { ...source.aliases } : undefined,
         modelMetadata: source.modelMetadata ? { ...source.modelMetadata } : {},
         warnings: source.warnings ? [...source.warnings] : [],
+        defaultAgent: source.defaultAgent,
     };
     Object.keys(cloned.models).forEach(model => {
         cloned.modelMetadata[model] = cloned.modelMetadata[model] ?? {
@@ -373,6 +374,7 @@ function applyGeminiOverrides(info) {
 }
 function applyGrokOverrides(info) {
     const envDefault = process.env.GROK_DEFAULT_MODEL;
+    applyGrokConfig(info);
     addEnvModels(info, "GROK_MODELS");
     addEnvAliases(info, "grok", "GROK_MODEL_ALIASES");
     addGlobalEnvAliases(info, "grok");
@@ -381,8 +383,48 @@ function applyGrokOverrides(info) {
     }
     info.modelOrder = buildOrder(info, info.defaultModel);
 }
+function applyGrokConfig(info) {
+    const configPath = process.env.GROK_CONFIG_PATH || path.join(homedir(), ".grok", "config.toml");
+    if (!existsSync(configPath)) {
+        return;
+    }
+    try {
+        const parsed = parseToml(readFileSync(configPath, "utf-8"));
+        const models = readRecordProperty(parsed, "models");
+        Object.entries(models).forEach(([key, value]) => {
+            if (typeof value !== "string") {
+                return;
+            }
+            if (key === "default") {
+                setDefaultModel(info, value, `${configPath} [models].default`, "config");
+                return;
+            }
+            addModel(info, value, `Custom Grok model from config.toml [models].${key}`, {
+                source: "config",
+                sourceDetail: `${configPath} [models].${key}`,
+                confidence: "medium",
+            });
+        });
+        const ui = readRecordProperty(parsed, "ui");
+        const forkModel = readStringProperty(ui, "fork_secondary_model");
+        if (forkModel) {
+            addModel(info, forkModel, "Configured Grok fork/secondary model", {
+                source: "config",
+                sourceDetail: `${configPath} [ui].fork_secondary_model`,
+                confidence: "medium",
+            });
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        addWarning(info, `Could not parse Grok config ${configPath}: ${message}`);
+    }
+}
 function applyMistralOverrides(info) {
     const vibeConfig = readVibeConfig(info);
+    if (vibeConfig.defaultAgent) {
+        info.defaultAgent = vibeConfig.defaultAgent;
+    }
     addVibeModelEntries(info, parseVibeModels(process.env.VIBE_MODELS, "VIBE_MODELS"), "env");
     addVibeModelEntries(info, vibeConfig.models, "config");
     addEnvModels(info, "MISTRAL_MODELS");
@@ -426,6 +468,10 @@ function readVibeConfig(info) {
         if (activeModel) {
             result.activeModel = activeModel.trim();
         }
+        const defaultAgent = readStringProperty(parsed, "default_agent");
+        if (defaultAgent) {
+            result.defaultAgent = defaultAgent.trim();
+        }
         result.models = parseVibeModelArray(readRecordOrArrayProperty(parsed, "models"), configPath);
     }
     catch (error) {

package/dist/oauth.js

@@ -273,7 +273,7 @@ export class OAuthServer {
         return {
             resource: joinBaseAndPath(baseUrl, this.opts.protectedPath),
             authorization_servers: [baseUrl],
-            scopes_supported: ["mcp", "workspace:admin"],
+            scopes_supported: ["mcp", "workspace:admin", "cli:admin"],
             bearer_methods_supported: ["header"],
         };
     }
@@ -291,7 +291,7 @@ export class OAuthServer {
             code_challenge_methods_supported: this.opts.config.allowPlainPkce
                 ? ["S256", "plain"]
                 : ["S256"],
-            scopes_supported: ["mcp", "workspace:admin"],
+            scopes_supported: ["mcp", "workspace:admin", "cli:admin"],
         };
     }
     registrationAllowedByPolicy(req, params) {

package/dist/postgres-job-store-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/postgres-job-store-worker.js

@@ -0,0 +1,327 @@
+import { writeFileSync } from "node:fs";
+import { parentPort, workerData } from "node:worker_threads";
+let pool = null;
+function signal(shared, status) {
+    const view = new Int32Array(shared);
+    Atomics.store(view, 0, status);
+    Atomics.notify(view, 0, 1);
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function fail(error) {
+    return {
+        ok: false,
+        error: {
+            message: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        },
+    };
+}
+function getPool() {
+    if (!pool)
+        throw new Error("PostgresJobStore worker pool is not initialized");
+    return pool;
+}
+async function withClient(fn) {
+    const client = await getPool().connect();
+    try {
+        return await fn(client);
+    }
+    finally {
+        client.release();
+    }
+}
+async function init() {
+    let pg;
+    try {
+        pg = await import("pg");
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") {
+            throw new Error("Postgres persistence requires optional peer dependency 'pg'. Install it alongside llm-cli-gateway to use backend = 'postgres'.", { cause: error });
+        }
+        throw error;
+    }
+    pool = new pg.Pool({
+        connectionString: workerData.dsn,
+        connectionTimeoutMillis: workerData.connectionTimeoutMillis,
+    });
+    await getPool().query("SELECT 1");
+    await getPool().query(`
+    CREATE TABLE IF NOT EXISTS jobs (
+      id TEXT PRIMARY KEY,
+      correlation_id TEXT NOT NULL,
+      request_key TEXT NOT NULL,
+      cli TEXT NOT NULL,
+      args_json TEXT NOT NULL,
+      output_format TEXT,
+      status TEXT NOT NULL,
+      exit_code INTEGER,
+      stdout TEXT,
+      stderr TEXT,
+      output_truncated BOOLEAN NOT NULL DEFAULT FALSE,
+      error TEXT,
+      started_at TEXT NOT NULL,
+      finished_at TEXT,
+      pid INTEGER,
+      expires_at TEXT NOT NULL,
+      owner_principal TEXT,
+      transport TEXT NOT NULL DEFAULT 'process',
+      http_status INTEGER,
+      payload_json TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_jobs_request_key ON jobs(request_key);
+    CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status);
+    CREATE INDEX IF NOT EXISTS idx_jobs_expires_at ON jobs(expires_at);
+    CREATE INDEX IF NOT EXISTS idx_jobs_request_key_finished ON jobs(request_key, finished_at);
+
+    CREATE TABLE IF NOT EXISTS validation_runs (
+      validation_id TEXT PRIMARY KEY,
+      owner_principal TEXT NOT NULL,
+      intent TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      request_json TEXT NOT NULL,
+      provider_links TEXT NOT NULL,
+      judge_link TEXT,
+      status TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_validation_runs_owner ON validation_runs(owner_principal);
+
+    CREATE TABLE IF NOT EXISTS validation_run_jobs (
+      job_id TEXT PRIMARY KEY,
+      validation_id TEXT NOT NULL,
+      role TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_validation_run_jobs_run ON validation_run_jobs(validation_id);
+
+    CREATE TABLE IF NOT EXISTS validation_receipts (
+      validation_id TEXT PRIMARY KEY,
+      owner_principal TEXT NOT NULL,
+      minted_at TEXT NOT NULL,
+      schema_version TEXT NOT NULL,
+      report_json TEXT NOT NULL,
+      canonical_sha256 TEXT NOT NULL,
+      prev_sha256 TEXT,
+      seq INTEGER,
+      signature TEXT,
+      models TEXT NOT NULL,
+      has_material_disagreement BOOLEAN NOT NULL,
+      confidence TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_validation_receipts_owner ON validation_receipts(owner_principal);
+  `);
+    await getPool().query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS owner_principal TEXT");
+    await getPool().query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS transport TEXT NOT NULL DEFAULT 'process'");
+    await getPool().query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS http_status INTEGER");
+    await getPool().query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS payload_json TEXT");
+}
+async function op(method, args) {
+    switch (method) {
+        case "init":
+            await init();
+            return null;
+        case "recordStart": {
+            const input = args[0];
+            await getPool().query(`INSERT INTO jobs (id, correlation_id, request_key, cli, args_json, output_format,
+                           status, exit_code, stdout, stderr, output_truncated, error,
+                           started_at, finished_at, pid, expires_at, owner_principal,
+                           transport, http_status, payload_json)
+         VALUES ($1, $2, $3, $4, $5, $6, 'running', NULL, '', '', FALSE, NULL,
+                 $7, NULL, $8, $9, $10, $11, NULL, $12)`, [
+                input.id,
+                input.correlationId,
+                input.requestKey,
+                input.cli,
+                JSON.stringify(input.args),
+                input.outputFormat ?? null,
+                input.startedAt,
+                input.pid,
+                workerData.farFutureIso,
+                input.ownerPrincipal ?? null,
+                input.transport ?? "process",
+                input.payloadJson ?? null,
+            ]);
+            return null;
+        }
+        case "recordOutput":
+            await getPool().query("UPDATE jobs SET stdout = $2, stderr = $3, output_truncated = $4 WHERE id = $1", args);
+            return null;
+        case "recordComplete": {
+            const input = args[0];
+            const expiresAt = new Date(Date.parse(input.finishedAt) + workerData.retentionMs).toISOString();
+            await getPool().query(`UPDATE jobs
+         SET status = $2, exit_code = $3, stdout = $4, stderr = $5,
+             output_truncated = $6, error = $7, finished_at = $8,
+             expires_at = $9, http_status = $10
+         WHERE id = $1`, [
+                input.id,
+                input.status,
+                input.exitCode,
+                input.stdout,
+                input.stderr,
+                input.outputTruncated,
+                input.error,
+                input.finishedAt,
+                expiresAt,
+                input.httpStatus ?? null,
+            ]);
+            return null;
+        }
+        case "getById": {
+            const result = await getPool().query("SELECT * FROM jobs WHERE id = $1", [args[0]]);
+            return result.rows[0] ?? null;
+        }
+        case "findByRequestKey": {
+            const cutoff = new Date(Date.now() - workerData.dedupWindowMs).toISOString();
+            const result = await getPool().query(`SELECT * FROM jobs
+         WHERE request_key = $1
+           AND started_at >= $2
+           AND status IN ('running', 'completed')
+         ORDER BY started_at DESC
+         LIMIT 1`, [args[0], cutoff]);
+            return result.rows[0] ?? null;
+        }
+        case "markOrphanedOnStartup":
+            return await withClient(async (client) => {
+                const now = new Date().toISOString();
+                const expiresAt = new Date(Date.now() + workerData.retentionMs).toISOString();
+                await client.query("BEGIN");
+                try {
+                    const rows = await client.query("SELECT id, correlation_id, started_at, stdout, stderr, exit_code, transport, http_status FROM jobs WHERE status = 'running'");
+                    const update = await client.query(`UPDATE jobs
+             SET status = 'orphaned',
+                 error = COALESCE(error, 'Gateway restarted while job was running'),
+                 finished_at = COALESCE(finished_at, $1),
+                 expires_at = $2
+             WHERE status = 'running'`, [now, expiresAt]);
+                    await client.query("COMMIT");
+                    return { count: update.rowCount ?? 0, orphaned: rows.rows };
+                }
+                catch (error) {
+                    await client.query("ROLLBACK");
+                    throw error;
+                }
+            });
+        case "evictExpired": {
+            const result = await getPool().query("DELETE FROM jobs WHERE expires_at < $1", [
+                new Date().toISOString(),
+            ]);
+            return result.rowCount ?? 0;
+        }
+        case "recordValidationRun": {
+            const run = args[0];
+            await withClient(async (client) => {
+                await client.query("BEGIN");
+                try {
+                    await client.query(`INSERT INTO validation_runs
+               (validation_id, owner_principal, intent, created_at, request_json,
+                provider_links, judge_link, status)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+             ON CONFLICT (validation_id) DO NOTHING`, [
+                        run.validationId,
+                        run.ownerPrincipal,
+                        run.intent,
+                        run.createdAt,
+                        run.requestJson,
+                        JSON.stringify(run.providerLinks),
+                        run.judgeLink ? JSON.stringify(run.judgeLink) : null,
+                        run.status,
+                    ]);
+                    for (const link of run.providerLinks) {
+                        await client.query(`INSERT INTO validation_run_jobs (job_id, validation_id, role)
+               VALUES ($1, $2, 'provider')
+               ON CONFLICT (job_id) DO NOTHING`, [link.jobId, run.validationId]);
+                    }
+                    await client.query("COMMIT");
+                }
+                catch (error) {
+                    await client.query("ROLLBACK");
+                    throw error;
+                }
+            });
+            return null;
+        }
+        case "getValidationRun": {
+            const result = await getPool().query("SELECT * FROM validation_runs WHERE validation_id = $1", [args[0]]);
+            return result.rows[0] ?? null;
+        }
+        case "setValidationJudgeLink": {
+            const [validationId, judgeLink] = args;
+            await withClient(async (client) => {
+                await client.query("BEGIN");
+                try {
+                    await client.query("UPDATE validation_runs SET judge_link = $2 WHERE validation_id = $1", [validationId, JSON.stringify(judgeLink)]);
+                    await client.query(`INSERT INTO validation_run_jobs (job_id, validation_id, role)
+             VALUES ($1, $2, 'judge')
+             ON CONFLICT (job_id) DO NOTHING`, [judgeLink.jobId, validationId]);
+                    await client.query("COMMIT");
+                }
+                catch (error) {
+                    await client.query("ROLLBACK");
+                    throw error;
+                }
+            });
+            return null;
+        }
+        case "setValidationRunStatus":
+            await getPool().query("UPDATE validation_runs SET status = $2 WHERE validation_id = $1", args);
+            return null;
+        case "getValidationRunIdByJobId": {
+            const result = await getPool().query("SELECT validation_id FROM validation_run_jobs WHERE job_id = $1", [args[0]]);
+            return result.rows[0] ? result.rows[0].validation_id : null;
+        }
+        case "recordValidationReceipt": {
+            const receipt = args[0];
+            await getPool().query(`INSERT INTO validation_receipts
+           (validation_id, owner_principal, minted_at, schema_version, report_json,
+            canonical_sha256, prev_sha256, seq, signature, models,
+            has_material_disagreement, confidence)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+         ON CONFLICT (validation_id) DO NOTHING`, [
+                receipt.validationId,
+                receipt.ownerPrincipal,
+                receipt.mintedAt,
+                receipt.schemaVersion,
+                receipt.reportJson,
+                receipt.canonicalSha256,
+                receipt.prevSha256,
+                receipt.seq,
+                receipt.signature,
+                JSON.stringify(receipt.models),
+                receipt.hasMaterialDisagreement,
+                receipt.confidence,
+            ]);
+            return null;
+        }
+        case "getValidationReceipt": {
+            const result = await getPool().query("SELECT * FROM validation_receipts WHERE validation_id = $1", [args[0]]);
+            return result.rows[0] ?? null;
+        }
+        case "close":
+            if (pool)
+                await pool.end();
+            pool = null;
+            return null;
+        default:
+            throw new Error(`Unknown PostgresJobStore worker method: ${method}`);
+    }
+}
+parentPort?.on("message", async (message) => {
+    const { method, args, resultPath, shared } = message;
+    let payload;
+    try {
+        payload = ok(await op(method, args));
+    }
+    catch (error) {
+        payload = fail(error);
+    }
+    try {
+        writeFileSync(resultPath, JSON.stringify(payload));
+        signal(shared, 1);
+    }
+    catch {
+        signal(shared, 2);
+    }
+});