@sema-agent/server 1.314.0 → 1.316.0

package/dist/plugins/outcome-ledger-sql.js

@@ -0,0 +1,158 @@
+import { randomUUID, createHash } from "node:crypto";
+import { pgSafeJsonStringify } from "./pg-safe-json.js";
+import { mysqlDriver, pgDriver } from "./sql-driver.js";
+export function taskSignature(s) {
+    if (s.tag)
+        return `tag:${s.tag}`;
+    const canon = JSON.stringify({
+        taskType: s.taskType ?? "",
+        toolset: [...(s.toolset ?? [])].sort(),
+        targetLang: s.targetLang ?? "",
+        moduleCount: s.moduleCount ?? 0,
+    });
+    return `h:${createHash("sha256").update(canon).digest("hex").slice(0, 16)}`;
+}
+export function deriveOutcome(m, runStatus = "completed-graded") {
+    if (runStatus === "infra-aborted")
+        return "aborted";
+    const oracleGreen = m.oracleTotal != null && m.oracleTotal > 0 && m.oraclePassed === m.oracleTotal;
+    const buildGreen = (m.assembleExit == null || m.assembleExit === 0) && (m.lintExit == null || m.lintExit === 0);
+    const mergeGreen = m.mergeOk !== false;
+    if (oracleGreen && buildGreen && mergeGreen)
+        return "pass";
+    const anyGreen = oracleGreen || (m.oraclePassed != null && m.oraclePassed > 0) || m.mergeOk === true;
+    return anyGreen ? "partial" : "fail";
+}
+export function coreOutcomeToLedgerRow(o) {
+    const passed = typeof o.oracle?.oraclePassed === "number" ? o.oracle.oraclePassed : o.oracle?.green ? 1 : 0;
+    const total = typeof o.oracle?.oracleTotal === "number" ? o.oracle.oracleTotal : 1;
+    return {
+        taskId: o.runId.slice(0, 64),
+        model: (o.model ?? "unknown").slice(0, 190),
+        signatureInputs: {
+            tag: o.taskSignature.slice(0, 186),
+            ...(o.signatureInputs?.toolset ? { toolset: o.signatureInputs.toolset } : {}),
+            ...(o.signatureInputs?.targetLang ? { targetLang: o.signatureInputs.targetLang } : {}),
+            ...(o.signatureInputs?.moduleCount !== undefined ? { moduleCount: o.signatureInputs.moduleCount } : {}),
+        },
+        mechanical: {
+            oraclePassed: passed,
+            oracleTotal: total,
+            ...(o.costMicroUsd !== undefined ? { costMicroUsd: o.costMicroUsd } : {}),
+            ...(o.turns !== undefined ? { turns: o.turns } : {}),
+        },
+        core: o,
+    };
+}
+export const PG_OUTCOME_LEDGER_SCHEMA = [
+    `CREATE TABLE IF NOT EXISTS outcome_ledger (
+     id             VARCHAR(64)  NOT NULL,
+     task_signature VARCHAR(190) NOT NULL,
+     model          VARCHAR(190) NOT NULL,
+     task_id        VARCHAR(64),
+     run_status     VARCHAR(20)  NOT NULL DEFAULT 'completed-graded',
+     route          VARCHAR(16),
+     worker_count   INTEGER,
+     oracle_passed  INTEGER,
+     oracle_total   INTEGER,
+     assemble_exit  INTEGER,
+     lint_exit      INTEGER,
+     merge_ok       SMALLINT,
+     replan_triggers JSONB,
+     cost_micro_usd BIGINT,
+     turns          INTEGER,
+     outcome        VARCHAR(8),
+     llm_assisted   JSONB,
+     signature_inputs JSONB,
+     -- design/73 §1 bridge: the VERBATIM core TaskOutcome fact (oracleHadRedRun / status / oracle blob) as it
+     -- came off core, kept alongside the derived mechanical columns. NULL when the caller recorded through the
+     -- non-core \`record()\` path (no core fact to bridge).
+     core_outcome   JSONB,
+     created_at     TIMESTAMPTZ(3) NOT NULL,
+     PRIMARY KEY (id)
+   )`,
+    `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_sig_model ON outcome_ledger (task_signature, model, run_status)`,
+    `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_outcome ON outcome_ledger (outcome)`,
+    `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_created ON outcome_ledger (created_at)`,
+];
+export async function ensurePgOutcomeLedgerSchema(pool) {
+    for (const stmt of PG_OUTCOME_LEDGER_SCHEMA)
+        await pool.query(stmt);
+}
+export class SqlOutcomeLedger {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    json(value) {
+        return this.db.dialect === "tidb" ? JSON.stringify(value) : pgSafeJsonStringify(value);
+    }
+    async record(o) {
+        const id = randomUUID().replace(/-/g, "").slice(0, 32);
+        const sig = taskSignature(o.signatureInputs);
+        const m = o.mechanical;
+        const runStatus = o.runStatus ?? "completed-graded";
+        await this.db.query(this.q(`INSERT INTO outcome_ledger
+        (id, task_signature, model, task_id, run_status, route, worker_count, oracle_passed, oracle_total,
+         assemble_exit, lint_exit, merge_ok, replan_triggers, cost_micro_usd, turns, outcome,
+         llm_assisted, signature_inputs, core_outcome, created_at)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`, `INSERT INTO outcome_ledger
+        (id, task_signature, model, task_id, run_status, route, worker_count, oracle_passed, oracle_total,
+         assemble_exit, lint_exit, merge_ok, replan_triggers, cost_micro_usd, turns, outcome,
+         llm_assisted, signature_inputs, core_outcome, created_at)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13::jsonb,$14,$15,$16,$17::jsonb,$18::jsonb,$19::jsonb,$20)`), [
+            id, sig, o.model, o.taskId ?? null, runStatus, m.route ?? null, m.workerCount ?? null,
+            m.oraclePassed ?? null, m.oracleTotal ?? null, m.assembleExit ?? null, m.lintExit ?? null,
+            m.mergeOk == null ? null : m.mergeOk ? 1 : 0,
+            m.replanTriggers ? this.json(m.replanTriggers) : null,
+            m.costMicroUsd ?? null, m.turns ?? null, deriveOutcome(m, runStatus),
+            o.llmAssisted ? this.json(o.llmAssisted) : null,
+            this.json(o.signatureInputs), o.core != null ? this.json(o.core) : null, new Date(),
+        ]);
+        return id;
+    }
+    async recordCore(o) {
+        await this.record(coreOutcomeToLedgerRow(o));
+    }
+    async summary(opts = {}) {
+        const clauses = [];
+        const params = [];
+        if (!opts.includeAborted)
+            clauses.push("run_status = 'completed-graded'");
+        if (opts.taskSignature) {
+            params.push(opts.taskSignature);
+            clauses.push(this.q("task_signature = ?", `task_signature = $${params.length}`));
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        const { rows } = await this.db.query(this.q(`SELECT task_signature, model, COUNT(*) n,
+              AVG(outcome = 'pass') pass_rate, AVG(cost_micro_usd) mean_cost
+         FROM outcome_ledger ${where}
+        GROUP BY task_signature, model
+        ORDER BY task_signature, model`, `SELECT task_signature, model, COUNT(*) n,
+              AVG((outcome = 'pass')::int) pass_rate, AVG(cost_micro_usd) mean_cost
+         FROM outcome_ledger ${where}
+        GROUP BY task_signature, model
+        ORDER BY task_signature, model`), params);
+        return rows.map((r) => ({
+            taskSignature: String(r.task_signature),
+            model: String(r.model),
+            n: Number(r.n),
+            passRate: Number(r.pass_rate),
+            meanCostMicroUsd: Number(r.mean_cost ?? 0),
+        }));
+    }
+}
+export class TiDBOutcomeLedger extends SqlOutcomeLedger {
+    constructor(pool) {
+        super(mysqlDriver(pool));
+    }
+}
+export class PgOutcomeLedger extends SqlOutcomeLedger {
+    constructor(pool) {
+        super(pgDriver(pool));
+    }
+}
+//# sourceMappingURL=outcome-ledger-sql.js.map

package/dist/plugins/pg-approval-store.d.ts

@@ -1,28 +1,2 @@
-import type { Pool, PoolClient } from "pg";
-import { type ApprovalRow, type ApprovalStatus } from "./tidb-approval-store.js";
-export type { ApprovalRow, ApprovalStatus } from "./tidb-approval-store.js";
-export declare const PG_APPROVAL_SCHEMA: string[];
-export declare function ensureSchema(pool: Pool | PoolClient): Promise<void>;
-export declare class PgApprovalStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    createPending(id: string, scope: string | null, ctx: {
-        taskId?: string | null;
-        sessionId?: string | null;
-        owner?: string | null;
-        toolName: string;
-        args: unknown;
-    }): Promise<void>;
-    getStatus(id: string, scope: string | null): Promise<{
-        status: ApprovalStatus;
-        reason: string | null;
-        decidedBy: string | null;
-    } | undefined>;
-    decide(id: string, scope: string | null, decision: "approved" | "denied" | "expired", reason: string | null, decidedBy: string | null): Promise<boolean>;
-    listPending(scope: string | null, owner?: string): Promise<ApprovalRow[]>;
-    get(id: string, scope: string | null): Promise<ApprovalRow | undefined>;
-    getById(id: string): Promise<ApprovalRow | undefined>;
-    listPendingAll(): Promise<ApprovalRow[]>;
-    expireStale(olderThanMs: number): Promise<number>;
-}
+export { PgApprovalStore, PG_APPROVAL_SCHEMA, ensureSchema, type ApprovalRow, type ApprovalStatus, } from "./approval-store-sql.js";
 //# sourceMappingURL=pg-approval-store.d.ts.map

package/dist/plugins/pg-approval-store.js

@@ -1,84 +1,2 @@
-import { mapRow } from "./tidb-approval-store.js";
-import { pgProtocolJsonStringify } from "./pg-safe-json.js";
-export const PG_APPROVAL_SCHEMA = [
-    `CREATE TABLE IF NOT EXISTS approval (
-     id          VARCHAR(64)  NOT NULL,
-     task_id     VARCHAR(64),
-     session_id  VARCHAR(64),
-     owner       VARCHAR(190),
-     -- Single-DB fleet scope guard (tenant isolation). NULLABLE on purpose: a NULL-scope row is an untenanted
-     -- run, and every read/decide path matches it with \`scope IS NOT DISTINCT FROM $n\` (the PG twin of TiDB
-     -- \`<=>\`) so NULL matches only NULL and one tenant's scope NEVER matches another's.
-     scope       VARCHAR(190),
-     tool_name   VARCHAR(190) NOT NULL,
-     args        JSONB,
-     status      VARCHAR(16)  NOT NULL,
-     reason      TEXT,
-     decided_by  VARCHAR(190),
-     created_at  TIMESTAMPTZ(3) NOT NULL,
-     decided_at  TIMESTAMPTZ(3),
-     PRIMARY KEY (id)
-   )`,
-    `CREATE INDEX IF NOT EXISTS idx_approval_owner_status ON approval (owner, status)`,
-    `CREATE INDEX IF NOT EXISTS idx_approval_status ON approval (status)`,
-    `CREATE INDEX IF NOT EXISTS idx_approval_scope_status ON approval (scope, status)`,
-];
-export async function ensureSchema(pool) {
-    for (const stmt of PG_APPROVAL_SCHEMA)
-        await pool.query(stmt);
-}
-export class PgApprovalStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async createPending(id, scope, ctx) {
-        await this.pool.query("INSERT INTO approval (id, task_id, session_id, owner, scope, tool_name, args, status, created_at) " +
-            "VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,'pending',$8)", [
-            id,
-            ctx.taskId ?? null,
-            ctx.sessionId ?? null,
-            ctx.owner ?? null,
-            scope,
-            ctx.toolName,
-            ctx.args == null ? null : pgProtocolJsonStringify(ctx.args, "approval args"),
-            new Date(),
-        ]);
-    }
-    async getStatus(id, scope) {
-        const res = await this.pool.query("SELECT status, reason, decided_by FROM approval WHERE id = $1 AND scope IS NOT DISTINCT FROM $2", [id, scope]);
-        const r = res.rows[0];
-        if (!r)
-            return undefined;
-        return { status: r.status, reason: r.reason ?? null, decidedBy: r.decided_by ?? null };
-    }
-    async decide(id, scope, decision, reason, decidedBy) {
-        const res = await this.pool.query("UPDATE approval SET status = $1, reason = $2, decided_by = $3, decided_at = $4 WHERE id = $5 AND scope IS NOT DISTINCT FROM $6 AND status = 'pending'", [decision, reason, decidedBy, new Date(), id, scope]);
-        return (res.rowCount ?? 0) === 1;
-    }
-    async listPending(scope, owner) {
-        const res = owner
-            ? await this.pool.query("SELECT * FROM approval WHERE status = 'pending' AND scope IS NOT DISTINCT FROM $1 AND owner = $2 ORDER BY created_at ASC", [scope, owner])
-            : await this.pool.query("SELECT * FROM approval WHERE status = 'pending' AND scope IS NOT DISTINCT FROM $1 ORDER BY created_at ASC", [scope]);
-        return res.rows.map(mapRow);
-    }
-    async get(id, scope) {
-        const res = await this.pool.query("SELECT * FROM approval WHERE id = $1 AND scope IS NOT DISTINCT FROM $2", [id, scope]);
-        return res.rows[0] ? mapRow(res.rows[0]) : undefined;
-    }
-    async getById(id) {
-        const res = await this.pool.query("SELECT * FROM approval WHERE id = $1", [id]);
-        return res.rows[0] ? mapRow(res.rows[0]) : undefined;
-    }
-    async listPendingAll() {
-        const res = await this.pool.query("SELECT * FROM approval WHERE status = 'pending' ORDER BY created_at ASC");
-        return res.rows.map(mapRow);
-    }
-    async expireStale(olderThanMs) {
-        const cutoff = new Date(Date.now() - olderThanMs);
-        const res = await this.pool.query("UPDATE approval SET status = 'expired', reason = 'timed out before decision', decided_at = $1 " +
-            "WHERE status = 'pending' AND created_at < $2", [new Date(), cutoff]);
-        return res.rowCount ?? 0;
-    }
-}
+export { PgApprovalStore, PG_APPROVAL_SCHEMA, ensureSchema, } from "./approval-store-sql.js";
 //# sourceMappingURL=pg-approval-store.js.map

package/dist/plugins/pg-breaker-state.d.ts

@@ -1,20 +1,2 @@
-import type { Pool, PoolClient } from "pg";
-import type { BreakerSnapshot, BreakerState } from "@sema-agent/core";
-export declare const PG_BREAKER_STATE_SCHEMA: string[];
-export declare function ensureSchema(pool: Pool | PoolClient): Promise<void>;
-export declare class PgBreakerState implements BreakerState {
-    private readonly pool;
-    private readonly onWriteFail?;
-    private cache;
-    private timer?;
-    private readonly pending;
-    constructor(pool: Pool, onWriteFail?: ((streak: number) => void) | undefined);
-    private writeFailStreak;
-    get(key: string): BreakerSnapshot | undefined;
-    set(key: string, snap: BreakerSnapshot): void;
-    private writeThrough;
-    refresh(): Promise<void>;
-    startRefresh(intervalMs?: number): this;
-    stop(): void;
-}
+export { PgBreakerState, PG_BREAKER_STATE_SCHEMA, ensureSchema } from "./breaker-state-sql.js";
 //# sourceMappingURL=pg-breaker-state.d.ts.map

package/dist/plugins/pg-breaker-state.js

@@ -1,89 +1,2 @@
-export const PG_BREAKER_STATE_SCHEMA = [
-    `CREATE TABLE IF NOT EXISTS circuit_breaker (
-     breaker_key VARCHAR(190)   NOT NULL,
-     phase       VARCHAR(16)    NOT NULL,
-     failures    INTEGER        NOT NULL DEFAULT 0,
-     opened_at   TIMESTAMPTZ(3),
-     updated_at  TIMESTAMPTZ(3) NOT NULL,
-     PRIMARY KEY (breaker_key)
-   )`,
-];
-export async function ensureSchema(pool) {
-    for (const stmt of PG_BREAKER_STATE_SCHEMA)
-        await pool.query(stmt);
-}
-export class PgBreakerState {
-    pool;
-    onWriteFail;
-    cache = new Map();
-    timer;
-    pending = new Set();
-    constructor(pool, onWriteFail) {
-        this.pool = pool;
-        this.onWriteFail = onWriteFail;
-    }
-    writeFailStreak = 0;
-    get(key) {
-        return this.cache.get(key);
-    }
-    set(key, snap) {
-        this.cache.set(key, snap);
-        this.pending.add(key);
-        void this.writeThrough(key, snap);
-    }
-    async writeThrough(key, snap) {
-        try {
-            await this.pool.query("INSERT INTO circuit_breaker (breaker_key, phase, failures, opened_at, updated_at) VALUES ($1,$2,$3,$4,$5) " +
-                "ON CONFLICT (breaker_key) DO UPDATE SET phase=EXCLUDED.phase, failures=EXCLUDED.failures, opened_at=EXCLUDED.opened_at, updated_at=EXCLUDED.updated_at", [key, snap.phase, snap.failures, snap.openedAt != null ? new Date(snap.openedAt) : null, new Date()]);
-            this.pending.delete(key);
-            if (this.writeFailStreak > 0) {
-                this.writeFailStreak = 0;
-                try {
-                    this.onWriteFail?.(0);
-                }
-                catch { }
-            }
-        }
-        catch {
-            try {
-                this.onWriteFail?.(++this.writeFailStreak);
-            }
-            catch { }
-        }
-    }
-    async refresh() {
-        try {
-            const pendingAtStart = new Set(this.pending);
-            const guarded = (key) => this.pending.has(key) || pendingAtStart.has(key);
-            const res = await this.pool.query("SELECT breaker_key, phase, failures, opened_at FROM circuit_breaker");
-            const seen = new Set();
-            for (const r of res.rows) {
-                const key = String(r.breaker_key);
-                seen.add(key);
-                if (guarded(key))
-                    continue;
-                this.cache.set(key, {
-                    phase: r.phase,
-                    failures: Number(r.failures),
-                    openedAt: r.opened_at != null ? new Date(r.opened_at).getTime() : undefined,
-                });
-            }
-            for (const key of this.cache.keys())
-                if (!seen.has(key) && !guarded(key))
-                    this.cache.delete(key);
-        }
-        catch {
-        }
-    }
-    startRefresh(intervalMs = 5_000) {
-        this.timer ??= setInterval(() => void this.refresh(), intervalMs);
-        this.timer.unref?.();
-        return this;
-    }
-    stop() {
-        if (this.timer)
-            clearInterval(this.timer);
-        this.timer = undefined;
-    }
-}
+export { PgBreakerState, PG_BREAKER_STATE_SCHEMA, ensureSchema } from "./breaker-state-sql.js";
 //# sourceMappingURL=pg-breaker-state.js.map

package/dist/plugins/pg-checkpoint-store.d.ts

@@ -1,34 +1,2 @@
-import type { Pool } from "pg";
-import { type Checkpoint, type CheckpointStore, type CheckpointSummary, type CheckpointToken, type ResumeOutcome, type ResolveExpectation, type ReopenReason } from "@sema-agent/core";
-import { type PendingCheckpoint } from "./tidb-checkpoint-store.js";
-export declare class PgCheckpointStore implements CheckpointStore {
-    private readonly pool;
-    private readonly logger?;
-    constructor(pool: Pool, logger?: {
-        info?(msg: string, meta?: unknown): void;
-    } | undefined);
-    put(token: CheckpointToken, cp: Checkpoint): Promise<void>;
-    get(token: CheckpointToken): Promise<Checkpoint | null>;
-    resolve(token: CheckpointToken, scope: string, outcome: ResumeOutcome, expect?: ResolveExpectation): Promise<boolean>;
-    reopen(token: CheckpointToken, scope: string, reason: ReopenReason): Promise<boolean>;
-    setPendingSteer(token: CheckpointToken, scope: string, steer: {
-        text: string;
-        trusted: boolean;
-    }): Promise<boolean>;
-    expire(token: CheckpointToken, scope: string): Promise<boolean>;
-    reap(scope: string, cutoff: number): Promise<number>;
-    reapExpired(cutoff: number): Promise<number>;
-    listExpiredApprovalGates(cutoff: number, limit?: number): Promise<Array<{
-        sessionId: string;
-        scope: string;
-    }>>;
-    listPending(scope?: string): Promise<PendingCheckpoint[]>;
-    listByScope(scope: string): Promise<CheckpointSummary[]>;
-    findPendingTokenBySession(sessionId: string, scope?: string): Promise<CheckpointToken | null>;
-    peekPendingScope(sessionId: string): Promise<string | null | undefined>;
-    putCtx(sessionId: string, ctx: unknown): Promise<void>;
-    getCtx<T = unknown>(sessionId: string): Promise<T | null>;
-    reapCtx(cutoff: number): Promise<number>;
-    deleteBySession(sessionId: string, owner: string | null): Promise<number>;
-}
+export { PgCheckpointStore } from "./checkpoint-store-sql.js";
 //# sourceMappingURL=pg-checkpoint-store.d.ts.map

package/dist/plugins/pg-checkpoint-store.js

@@ -1,190 +1,2 @@
-import { CheckpointError, validatePendingSteer, checkpointVersionOf, winnerFromOutcome, summarizeCheckpoint, MAX_SUPPORTED_CHECKPOINT_VERSION } from "@sema-agent/core";
-import { redactDeep } from "../trace/redact.js";
-import { tokenFingerprint } from "./tidb-checkpoint-store.js";
-import { pgProtocolJsonStringify } from "./pg-safe-json.js";
-import { parseJsonStrict as parseJson } from "./sql-row-helpers.js";
-const MAX_TOOL_INPUT_CHARS = 8192;
-const TERMINAL_BACKSTOP_MS = Math.max(60_000, Number(process.env.APPROVAL_TERMINAL_BACKSTOP_MS) || 30 * 86_400_000);
-const TERMINAL_GRACE_MS = 3_600_000;
-const PG_UNIQUE_VIOLATION = "23505";
-function boundedToolInput(args) {
-    if (args === undefined)
-        return null;
-    const redacted = redactDeep(args);
-    const json = JSON.stringify(redacted);
-    if (json === undefined)
-        return null;
-    if (json.length > MAX_TOOL_INPUT_CHARS)
-        return { truncated: true, bytes: json.length };
-    return redacted;
-}
-export class PgCheckpointStore {
-    pool;
-    logger;
-    constructor(pool, logger) {
-        this.pool = pool;
-        this.logger = logger;
-    }
-    async put(token, cp) {
-        const pa = cp.pendingAction;
-        const version = checkpointVersionOf(cp);
-        const toolInput = boundedToolInput(pa?.args);
-        try {
-            await this.pool.query("INSERT INTO checkpoint (token, scope, session_id, version, status, tool_name, tool_call_id, tool_input, checkpoint, deadline, created_at, terminal_at, gate_kind, bound_input_hash, risk_descriptor) " +
-                "VALUES ($1,$2,$3,$4,'pending',$5,$6,$7::jsonb,$8::jsonb,$9,$10,$11,$12,$13,$14)", [
-                token,
-                cp.scope,
-                cp.sessionId,
-                version,
-                pa?.toolName ?? null,
-                pa?.toolCallId ?? null,
-                toolInput === null ? null : pgProtocolJsonStringify(toolInput, "approval tool_input"),
-                pgProtocolJsonStringify(cp, "checkpoint"),
-                cp.deadline ?? null,
-                cp.createdAt,
-                Math.max(cp.createdAt + TERMINAL_BACKSTOP_MS, (cp.deadline ?? 0) + TERMINAL_GRACE_MS),
-                cp.gate?.kind ?? null,
-                pa?.boundInputHash ?? null,
-                ((g) => (g?.riskDescriptor ? pgProtocolJsonStringify(g.riskDescriptor, "risk descriptor") : null))(cp.gate),
-            ]);
-        }
-        catch (e) {
-            if (e?.code === PG_UNIQUE_VIOLATION) {
-                throw new CheckpointError("checkpoint.already_exists", `checkpoint token already exists`);
-            }
-            throw e;
-        }
-    }
-    async get(token) {
-        const res = await this.pool.query("SELECT version, status, checkpoint, outcome, reopen_reason, rev, pending_steer FROM checkpoint WHERE token = $1", [token]);
-        const r = res.rows[0];
-        if (!r)
-            return null;
-        const version = Number(r.version);
-        if (version > MAX_SUPPORTED_CHECKPOINT_VERSION) {
-            throw new Error(`checkpoint format version ${version} is newer than this build supports (max ${MAX_SUPPORTED_CHECKPOINT_VERSION}) — upgrade the service to resume it`);
-        }
-        const cp = parseJson(r.checkpoint);
-        cp.status = r.status;
-        const outcomeRaw = parseJson(r.outcome);
-        if (outcomeRaw)
-            cp.resolvedOutcome = winnerFromOutcome(outcomeRaw);
-        cp.reopenReason = r.reopen_reason ?? undefined;
-        cp.rev = r.rev == null ? 0 : Number(r.rev);
-        const steerRaw = parseJson(r.pending_steer);
-        if (steerRaw && cp.state)
-            cp.state.pendingSteer = steerRaw;
-        this.logger?.info?.("checkpoint_get", {
-            tokenFp: tokenFingerprint(token),
-            status: cp.status,
-            version,
-            hasWorkspaceHandle: !!cp.state?.workspaceHandle,
-            snapshotId: cp.state?.workspaceHandle?.snapshotId,
-        });
-        return cp;
-    }
-    async resolve(token, scope, outcome, expect) {
-        const params = [pgProtocolJsonStringify(outcome, "checkpoint outcome"), Date.now(), token, scope];
-        if (expect)
-            params.push(expect.rev);
-        const res = await this.pool.query("UPDATE checkpoint SET status = 'resolved', outcome = $1::jsonb, decided_at = $2, rev = rev + 1, reopen_reason = NULL WHERE token = $3 AND scope = $4 AND status = 'pending'" +
-            (expect ? " AND rev = $5" : ""), params);
-        return (res.rowCount ?? 0) === 1;
-    }
-    async reopen(token, scope, reason) {
-        const res = await this.pool.query("UPDATE checkpoint SET status = 'pending', reopen_reason = $1, rev = rev + 1 WHERE token = $2 AND scope = $3 AND status = 'resolved'", [reason, token, scope]);
-        return (res.rowCount ?? 0) === 1;
-    }
-    async setPendingSteer(token, scope, steer) {
-        const clean = validatePendingSteer(steer);
-        const res = await this.pool.query("UPDATE checkpoint SET pending_steer = $1 WHERE token = $2 AND scope = $3 AND status = 'pending'", [pgProtocolJsonStringify(clean, "pending steer"), token, scope]);
-        return (res.rowCount ?? 0) > 0;
-    }
-    async expire(token, scope) {
-        const res = await this.pool.query("UPDATE checkpoint SET status = 'expired', decided_at = $1 WHERE token = $2 AND scope = $3 AND status = 'pending'", [Date.now(), token, scope]);
-        return (res.rowCount ?? 0) === 1;
-    }
-    async reap(scope, cutoff) {
-        const res = await this.pool.query("UPDATE checkpoint SET status = 'expired', decided_at = $1 WHERE scope = $2 AND status = 'pending' AND deadline IS NOT NULL AND deadline <= $3", [Date.now(), scope, cutoff]);
-        return res.rowCount ?? 0;
-    }
-    async reapExpired(cutoff) {
-        const res = await this.pool.query("UPDATE checkpoint SET status = 'expired', decided_at = $1 " +
-            "WHERE status = 'pending' AND ((deadline IS NOT NULL AND deadline <= $2 AND (gate_kind IS NULL OR gate_kind NOT IN ('human','irreversible_ask') OR COALESCE(tool_name,'') = 'AskUserQuestion')) OR (terminal_at IS NOT NULL AND terminal_at <= $3))", [Date.now(), cutoff, cutoff]);
-        return res.rowCount ?? 0;
-    }
-    async listExpiredApprovalGates(cutoff, limit = 100) {
-        const res = await this.pool.query("SELECT session_id, scope FROM checkpoint WHERE status = 'pending' AND gate_kind IN ('human','irreversible_ask') " +
-            "AND COALESCE(tool_name,'') <> 'AskUserQuestion' AND deadline IS NOT NULL AND deadline <= $1 ORDER BY deadline ASC LIMIT $2", [cutoff, limit]);
-        return res.rows.map((r) => ({ sessionId: String(r.session_id), scope: String(r.scope) }));
-    }
-    async listPending(scope) {
-        const base = "SELECT c.session_id, c.scope, c.tool_name, c.tool_call_id, c.tool_input, c.bound_input_hash, c.risk_descriptor, c.created_at, c.deadline, ta.task_id " +
-            "FROM checkpoint c LEFT JOIN task_active ta ON ta.session_id = c.session_id WHERE c.status='pending'";
-        const res = scope
-            ? await this.pool.query(`${base} AND c.scope=$1 ORDER BY c.created_at ASC`, [scope])
-            : await this.pool.query(`${base} ORDER BY c.created_at ASC`);
-        const out = res.rows.map((r) => {
-            const toolCallId = r.tool_call_id ?? null;
-            return {
-                sessionId: String(r.session_id),
-                scope: String(r.scope),
-                toolName: r.tool_name ?? null,
-                toolCallId,
-                boundCallId: toolCallId,
-                boundInputHash: r.bound_input_hash ?? null,
-                taskId: r.task_id ?? null,
-                input: r.tool_input ?? null,
-                createdAt: Number(r.created_at),
-                deadline: r.deadline == null ? null : Number(r.deadline),
-                riskDescriptor: parseJson(r.risk_descriptor),
-            };
-        });
-        return out.sort((a, b) => (b.riskDescriptor?.severity ?? 0) - (a.riskDescriptor?.severity ?? 0) || a.createdAt - b.createdAt);
-    }
-    async listByScope(scope) {
-        const res = await this.pool.query("SELECT checkpoint, status FROM checkpoint WHERE status = 'pending' AND scope = $1 ORDER BY created_at ASC LIMIT 500", [scope]);
-        const out = [];
-        for (const r of res.rows) {
-            const cp = parseJson(r.checkpoint);
-            if (!cp)
-                continue;
-            cp.status = r.status;
-            out.push(summarizeCheckpoint(cp));
-        }
-        return out;
-    }
-    async findPendingTokenBySession(sessionId, scope) {
-        const res = scope
-            ? await this.pool.query("SELECT token FROM checkpoint WHERE session_id=$1 AND scope=$2 AND status='pending' LIMIT 1", [sessionId, scope])
-            : await this.pool.query("SELECT token FROM checkpoint WHERE session_id=$1 AND status='pending' LIMIT 1", [sessionId]);
-        return res.rows[0] ? String(res.rows[0].token) : null;
-    }
-    async peekPendingScope(sessionId) {
-        const res = await this.pool.query("SELECT scope FROM checkpoint WHERE session_id=$1 AND status='pending' LIMIT 1", [sessionId]);
-        if (!res.rows[0])
-            return undefined;
-        return res.rows[0].scope ?? null;
-    }
-    async putCtx(sessionId, ctx) {
-        await this.pool.query("INSERT INTO checkpoint_ctx (session_id, ctx, updated_at) VALUES ($1,$2::jsonb,$3) " +
-            "ON CONFLICT (session_id) DO UPDATE SET ctx = EXCLUDED.ctx, updated_at = EXCLUDED.updated_at", [sessionId, pgProtocolJsonStringify(ctx, "checkpoint ctx"), Date.now()]);
-    }
-    async getCtx(sessionId) {
-        const res = await this.pool.query("SELECT ctx FROM checkpoint_ctx WHERE session_id=$1", [sessionId]);
-        return res.rows[0] ? parseJson(res.rows[0].ctx) : null;
-    }
-    async reapCtx(cutoff) {
-        const res = await this.pool.query("DELETE FROM checkpoint_ctx WHERE updated_at < $1 " +
-            "AND session_id NOT IN (SELECT session_id FROM checkpoint WHERE status='pending') " +
-            "AND session_id NOT IN (SELECT session_id FROM task_active)", [cutoff]);
-        return res.rowCount ?? 0;
-    }
-    async deleteBySession(sessionId, owner) {
-        const ownerGuard = "EXISTS (SELECT 1 FROM session_meta sm WHERE sm.session_id = $1 AND sm.owner IS NOT DISTINCT FROM $2)";
-        const res = await this.pool.query(`DELETE FROM checkpoint WHERE session_id = $1 AND ${ownerGuard}`, [sessionId, owner]);
-        await this.pool.query(`DELETE FROM checkpoint_ctx WHERE session_id = $1 AND ${ownerGuard}`, [sessionId, owner]);
-        return res.rowCount ?? 0;
-    }
-}
+export { PgCheckpointStore } from "./checkpoint-store-sql.js";
 //# sourceMappingURL=pg-checkpoint-store.js.map