@sema-agent/server 1.315.0 → 1.317.0

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

@@ -1,288 +1,2 @@
-import { projectUsageStats, USAGE_SCAN_LIMIT } from "../usage-analytics.js";
-import { escapeLike } from "./sql-escape.js";
-import { pgSafeJsonStringify, pgSanitizeText } from "./pg-safe-json.js";
-import { parseJsonLenient as parseJson, toIso as iso } from "./sql-row-helpers.js";
-function isDupKey(err) {
-    return Boolean(err) && err.code === "23505";
-}
-export class PgRunStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async tx(fn) {
-        const c = await this.pool.connect();
-        try {
-            await c.query("BEGIN");
-            const out = await fn(c);
-            await c.query("COMMIT");
-            return out;
-        }
-        catch (err) {
-            try {
-                await c.query("ROLLBACK");
-            }
-            catch {
-            }
-            throw err;
-        }
-        finally {
-            c.release();
-        }
-    }
-    async createRun(taskId, sessionId, owner, instanceId, meta = {}) {
-        const c = await this.pool.connect();
-        try {
-            await c.query("BEGIN");
-            const now = new Date();
-            try {
-                await c.query("INSERT INTO task_active (session_id, task_id, since) VALUES ($1,$2,$3)", [sessionId, taskId, now]);
-            }
-            catch (err) {
-                if (isDupKey(err)) {
-                    await c.query("ROLLBACK");
-                    const active = await c.query("SELECT task_id FROM task_active WHERE session_id = $1", [sessionId]);
-                    return { ok: false, activeTaskId: String(active.rows[0]?.task_id ?? "") };
-                }
-                throw err;
-            }
-            await c.query("INSERT INTO task_run (task_id, session_id, owner, status, instance_id, job_id, source, objective_preview, created_at, updated_at) " +
-                "VALUES ($1,$2,$3,'running',$4,$5,$6,$7,$8,$9)", [taskId, sessionId, owner, instanceId, meta.jobId ?? null, meta.source ?? null, meta.objectivePreview == null ? null : pgSanitizeText(meta.objectivePreview), now, now]);
-            await c.query("COMMIT");
-            return { ok: true };
-        }
-        catch (err) {
-            try {
-                await c.query("ROLLBACK");
-            }
-            catch {
-            }
-            throw err;
-        }
-        finally {
-            c.release();
-        }
-    }
-    async requestCancel(taskId, owner) {
-        const r = await this.pool.query("UPDATE task_run SET cancel_requested = 1 WHERE task_id = $1 AND owner IS NOT DISTINCT FROM $2 AND status = 'running'", [taskId, owner]);
-        return (r.rowCount ?? 0) > 0;
-    }
-    async isCancelRequested(taskId, owner) {
-        const r = await this.pool.query("SELECT cancel_requested FROM task_run WHERE task_id = $1 AND owner IS NOT DISTINCT FROM $2", [taskId, owner]);
-        return Boolean(r.rows[0]?.cancel_requested);
-    }
-    async requestPreempt(taskId, owner) {
-        const r = await this.pool.query("UPDATE task_run SET preempt_requested = 1 WHERE task_id = $1 AND owner IS NOT DISTINCT FROM $2 AND status = 'running'", [taskId, owner]);
-        return (r.rowCount ?? 0) > 0;
-    }
-    async isPreemptRequested(taskId, owner) {
-        const r = await this.pool.query("SELECT preempt_requested FROM task_run WHERE task_id = $1 AND owner IS NOT DISTINCT FROM $2", [taskId, owner]);
-        return Boolean(r.rows[0]?.preempt_requested);
-    }
-    async heartbeat(taskId, owner) {
-        await this.pool.query("UPDATE task_run SET updated_at = $1 WHERE task_id = $2 AND owner IS NOT DISTINCT FROM $3 AND status = 'running'", [new Date(), taskId, owner]);
-    }
-    async appendEvent(taskId, seq, type, data) {
-        await this.pool.query("INSERT INTO task_event (task_id, seq, type, data, ts) VALUES ($1,$2,$3,$4::jsonb,$5)", [
-            taskId,
-            seq,
-            type,
-            data == null ? null : pgSafeJsonStringify(data),
-            new Date(),
-        ]);
-    }
-    async maxSeq(taskId) {
-        const r = await this.pool.query("SELECT MAX(seq) AS m FROM task_event WHERE task_id = $1", [taskId]);
-        const m = r.rows[0]?.m;
-        return m == null ? 0 : Number(m);
-    }
-    async setTerminal(taskId, status, result, error) {
-        const errorCode = result?.errorCode ?? null;
-        await this.tx(async (c) => {
-            await c.query("UPDATE task_run SET status = $1, result = $2::jsonb, error = $3, error_code = $4, updated_at = $5 WHERE task_id = $6 AND status IN ('running','suspended','needs_review')", [
-                status,
-                result == null ? null : pgSafeJsonStringify(result),
-                error == null ? null : pgSanitizeText(error),
-                errorCode == null ? null : pgSanitizeText(errorCode),
-                new Date(),
-                taskId,
-            ]);
-            await c.query("DELETE FROM task_active WHERE task_id = $1", [taskId]);
-        });
-    }
-    async setSuspended(taskId) {
-        await this.pool.query("UPDATE task_run SET status = 'suspended', updated_at = $1 WHERE task_id = $2 AND status IN ('running','suspended')", [new Date(), taskId]);
-    }
-    async setNeedsReview(taskId) {
-        await this.pool.query("UPDATE task_run SET status = 'needs_review', updated_at = $1 WHERE task_id = $2 AND status IN ('running','needs_review')", [new Date(), taskId]);
-    }
-    async markResuming(taskId) {
-        const r = await this.pool.query("UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, updated_at = $1 WHERE task_id = $2 AND status IN ('suspended','needs_review')", [new Date(), taskId]);
-        return (r.rowCount ?? 0) === 1;
-    }
-    async getActiveTaskId(sessionId) {
-        const r = await this.pool.query("SELECT task_id FROM task_active WHERE session_id = $1", [sessionId]);
-        return r.rows[0] ? String(r.rows[0].task_id) : undefined;
-    }
-    rowToRun(r) {
-        return {
-            taskId: String(r.task_id),
-            sessionId: String(r.session_id),
-            owner: r.owner ?? null,
-            status: r.status,
-            result: parseJson(r.result),
-            error: r.error ?? null,
-            errorCode: r.error_code ?? null,
-            jobId: r.job_id ?? null,
-            source: r.source ?? null,
-            instanceId: r.instance_id ?? null,
-            objectivePreview: r.objective_preview ?? null,
-            createdAt: iso(r.created_at),
-            updatedAt: iso(r.updated_at),
-        };
-    }
-    async getRun(taskId) {
-        const r = await this.pool.query("SELECT task_id, session_id, owner, status, result, error, error_code, job_id, source, instance_id, objective_preview, created_at, updated_at FROM task_run WHERE task_id = $1", [taskId]);
-        return r.rows[0] ? this.rowToRun(r.rows[0]) : undefined;
-    }
-    async listRuns(opts) {
-        if (opts.cursor && Number.isNaN(Date.parse(opts.cursor.createdAt)))
-            return [];
-        const where = [];
-        const params = [];
-        const p = (v) => {
-            params.push(v);
-            return `$${params.length}`;
-        };
-        if (opts.status)
-            where.push(`status = ${p(opts.status)}`);
-        if (opts.jobId)
-            where.push(`job_id = ${p(opts.jobId)}`);
-        if (opts.source)
-            where.push(`source = ${p(opts.source)}`);
-        if (opts.owner)
-            where.push(`owner = ${p(opts.owner)}`);
-        if (opts.cursor) {
-            const a = p(new Date(opts.cursor.createdAt));
-            const b = p(new Date(opts.cursor.createdAt));
-            const t = p(opts.cursor.taskId);
-            where.push(`(created_at < ${a} OR (created_at = ${b} AND task_id < ${t}))`);
-        }
-        const sql = "SELECT task_id, session_id, owner, status, result, error, error_code, job_id, source, objective_preview, created_at, updated_at FROM task_run" +
-            (where.length ? " WHERE " + where.join(" AND ") : "") +
-            ` ORDER BY created_at DESC, task_id DESC LIMIT ${p(opts.limit)}`;
-        const r = await this.pool.query(sql, params);
-        return r.rows.map((row) => this.rowToRun(row));
-    }
-    async listSessions(opts) {
-        const params = [];
-        const p = (v) => {
-            params.push(v);
-            return `$${params.length}`;
-        };
-        const innerWhere = opts.owner ? ` WHERE owner = ${p(opts.owner)}` : "";
-        const outer = ["rn = 1"];
-        if (opts.q)
-            outer.push(`EXISTS (SELECT 1 FROM task_run tr WHERE tr.session_id = t.session_id AND LOWER(tr.objective_preview) LIKE LOWER(${p(`%${escapeLike(opts.q)}%`)}) ESCAPE '\\')`);
-        if (opts.cursor) {
-            const a = p(new Date(opts.cursor.lastActivityAt));
-            const b = p(new Date(opts.cursor.lastActivityAt));
-            const sid = p(opts.cursor.sessionId);
-            outer.push(`(last_activity < ${a} OR (last_activity = ${b} AND session_id < ${sid}))`);
-        }
-        const sql = "SELECT session_id, owner, task_id, last_activity, first_activity, run_count, objective_preview, status FROM (" +
-            "SELECT session_id, owner, task_id, objective_preview, status," +
-            " ROW_NUMBER() OVER (PARTITION BY session_id ORDER BY created_at DESC, task_id DESC) AS rn," +
-            " MAX(created_at) OVER (PARTITION BY session_id) AS last_activity," +
-            " MIN(created_at) OVER (PARTITION BY session_id) AS first_activity," +
-            " COUNT(*) OVER (PARTITION BY session_id) AS run_count" +
-            " FROM task_run" + innerWhere + ") t WHERE " + outer.join(" AND ") +
-            ` ORDER BY last_activity DESC, session_id DESC LIMIT ${p(opts.limit)}`;
-        const r = await this.pool.query(sql, params);
-        return r.rows.map((row) => ({
-            sessionId: String(row.session_id),
-            owner: row.owner ?? null,
-            lastActivityAt: iso(row.last_activity),
-            firstActivityAt: iso(row.first_activity),
-            runCount: Number(row.run_count),
-            objectivePreview: row.objective_preview ?? null,
-            lastStatus: String(row.status),
-            lastRunId: row.task_id ?? null,
-            title: null,
-        }));
-    }
-    async deleteBySession(sessionId, owner) {
-        return this.tx(async (c) => {
-            const active = await c.query("SELECT task_id FROM task_active WHERE session_id = $1 FOR UPDATE", [sessionId]);
-            if (active.rows[0])
-                return { active: String(active.rows[0].task_id) };
-            await c.query("DELETE FROM task_event te USING task_run tr WHERE te.task_id = tr.task_id AND tr.session_id = $1 AND tr.owner IS NOT DISTINCT FROM $2", [sessionId, owner]);
-            await c.query("DELETE FROM task_active ta USING task_run tr WHERE ta.task_id = tr.task_id AND tr.session_id = $1 AND tr.owner IS NOT DISTINCT FROM $2", [sessionId, owner]);
-            const res = await c.query("DELETE FROM task_run WHERE session_id = $1 AND owner IS NOT DISTINCT FROM $2", [sessionId, owner]);
-            return { removed: res.rowCount ?? 0 };
-        });
-    }
-    async sourceSummary(sinceMs) {
-        const r = await this.pool.query("SELECT source, status, COUNT(*) AS c FROM task_run WHERE created_at >= $1 GROUP BY source, status", [new Date(sinceMs)]);
-        return r.rows.map((row) => ({ source: row.source ?? null, status: String(row.status), count: Number(row.c) }));
-    }
-    async usageScan(fromMs, toMs, opts) {
-        const limit = Math.min(opts?.limit ?? USAGE_SCAN_LIMIT, USAGE_SCAN_LIMIT);
-        const where = ["created_at >= $1", "created_at < $2"];
-        const params = [new Date(fromMs), new Date(toMs)];
-        if (opts?.owner !== undefined) {
-            where.push("owner = $3");
-            params.push(opts.owner);
-        }
-        const r = await this.pool.query(`SELECT owner, created_at, status, result FROM task_run WHERE ${where.join(" AND ")} ORDER BY created_at LIMIT ${limit + 1}`, params);
-        const truncated = r.rows.length > limit;
-        const page = truncated ? r.rows.slice(0, limit) : r.rows;
-        return {
-            truncated,
-            rows: page.map((row) => ({
-                owner: row.owner ?? null,
-                createdAtMs: new Date(row.created_at).getTime(),
-                status: String(row.status),
-                ...(row.result != null ? { stats: projectUsageStats(row.result) } : {}),
-            })),
-        };
-    }
-    async retainedFrom(taskId) {
-        const r = await this.pool.query("SELECT MIN(seq) AS m FROM task_event WHERE task_id = $1", [taskId]);
-        const m = r.rows[0]?.m;
-        return m == null ? 0 : Number(m);
-    }
-    async getEvents(taskId, afterSeq) {
-        const r = await this.pool.query("SELECT seq, type, data, ts FROM task_event WHERE task_id = $1 AND seq > $2 ORDER BY seq ASC", [taskId, afterSeq]);
-        return r.rows.map((row) => ({ seq: Number(row.seq), type: String(row.type), data: parseJson(row.data), ts: iso(row.ts) }));
-    }
-    async reapStale(olderThanMs) {
-        const cutoff = new Date(Date.now() - olderThanMs);
-        return this.tx(async (c) => {
-            const res = await c.query("UPDATE task_run SET status = 'failed', error = 'run stalled (instance lost?)', updated_at = $1 WHERE status = 'running' AND updated_at < $2", [new Date(), cutoff]);
-            await c.query("DELETE FROM task_active ta USING task_run tr WHERE ta.task_id = tr.task_id AND tr.status NOT IN ('running','suspended','needs_review')");
-            return res.rowCount ?? 0;
-        });
-    }
-    async reapSuspended(olderThanMs) {
-        const cutoff = new Date(Date.now() - olderThanMs);
-        return this.tx(async (c) => {
-            const res = await c.query("UPDATE task_run AS tr SET status = 'failed', error = 'approval expired before decision', error_code = 'approval.expired', updated_at = $1 " +
-                "WHERE tr.status = 'suspended' AND tr.updated_at < $2 " +
-                "AND NOT EXISTS (SELECT 1 FROM checkpoint c WHERE c.session_id = tr.session_id AND c.status = 'pending')", [new Date(), cutoff]);
-            await c.query("DELETE FROM task_active ta USING task_run tr WHERE ta.task_id = tr.task_id AND tr.status NOT IN ('running','suspended','needs_review')");
-            return res.rowCount ?? 0;
-        });
-    }
-    async failSuspendedWithExpiredCheckpoint() {
-        return this.tx(async (c) => {
-            const res = await c.query("UPDATE task_run AS tr SET status = 'failed', error = 'approval expired before decision', error_code = 'approval.expired', updated_at = $1 " +
-                "WHERE tr.status IN ('suspended','needs_review') " +
-                "AND EXISTS (SELECT 1 FROM checkpoint ce WHERE ce.session_id = tr.session_id AND ce.status = 'expired') " +
-                "AND NOT EXISTS (SELECT 1 FROM checkpoint cp WHERE cp.session_id = tr.session_id AND cp.status = 'pending')", [new Date()]);
-            await c.query("DELETE FROM task_active ta USING task_run tr WHERE ta.task_id = tr.task_id AND tr.status NOT IN ('running','suspended','needs_review')");
-            return res.rowCount ?? 0;
-        });
-    }
-}
+export { PgRunStore } from "./run-store-sql.js";
 //# sourceMappingURL=pg-run-store.js.map

package/dist/plugins/pg-session-policy-store.d.ts

@@ -1,12 +1,2 @@
-import { type SessionPolicyStore, type SessionPermissionRules, type StoredSessionRules, type SessionRulesRecord, type PutRulesOptions } from "@sema-agent/core";
-import type { Pool } from "pg";
-export declare class PgSessionPolicyStore implements SessionPolicyStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    getRules(sessionId: string, principal?: string): Promise<StoredSessionRules | null>;
-    listBySession(sessionId: string): Promise<SessionRulesRecord[]>;
-    putRules(sessionId: string, principal: string | undefined, rules: SessionPermissionRules, opts?: PutRulesOptions): Promise<StoredSessionRules>;
-    deleteBySession(sessionId: string): Promise<void>;
-    private tx;
-}
+export { PgSessionPolicyStore } from "./session-policy-store-sql.js";
 //# sourceMappingURL=pg-session-policy-store.d.ts.map

package/dist/plugins/pg-session-policy-store.js

@@ -1,91 +1,2 @@
-import { createHash } from "node:crypto";
-import { loosenReasons, SessionPolicyError, normalizeRules, stripRev } from "@sema-agent/core";
-import { pgHasUnstorable } from "./pg-safe-json.js";
-const policyKey = (sessionId, principal) => createHash("sha256").update(JSON.stringify([sessionId, principal ?? null])).digest("hex");
-const parseRules = (v) => (typeof v === "string" ? JSON.parse(v) : v);
-const isDupKey = (e) => e?.code === "23505";
-export class PgSessionPolicyStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async getRules(sessionId, principal) {
-        const r = await this.pool.query("SELECT rules, rev FROM session_policy WHERE policy_key = $1", [policyKey(sessionId, principal)]);
-        if (!r.rows[0])
-            return null;
-        return { ...parseRules(r.rows[0].rules), rev: Number(r.rows[0].rev) };
-    }
-    async listBySession(sessionId) {
-        const r = await this.pool.query("SELECT principal, rules, rev FROM session_policy WHERE session_id = $1", [sessionId]);
-        return r.rows.map((row) => ({
-            principal: row.principal == null ? undefined : String(row.principal),
-            rules: { ...parseRules(row.rules), rev: Number(row.rev) },
-        }));
-    }
-    async putRules(sessionId, principal, rules, opts) {
-        const key = policyKey(sessionId, principal);
-        for (let attempt = 0;; attempt++) {
-            try {
-                return await this.tx(async (c) => {
-                    const r = await c.query("SELECT rules, rev FROM session_policy WHERE policy_key = $1 FOR UPDATE", [key]);
-                    const prior = r.rows[0] ? { rules: parseRules(r.rows[0].rules), rev: Number(r.rows[0].rev) } : undefined;
-                    const priorRev = prior?.rev ?? 0;
-                    if (opts?.expectedRev !== undefined && priorRev !== opts.expectedRev) {
-                        throw new SessionPolicyError("conflict", `session rules rev mismatch (expected ${opts.expectedRev}, have ${priorRev})`);
-                    }
-                    const clean = normalizeRules(stripRev(rules));
-                    if (prior && opts?.operator !== true) {
-                        const loosens = loosenReasons(prior.rules, clean);
-                        if (loosens.length > 0) {
-                            throw new SessionPolicyError("loosen_forbidden", `a non-operator session-rule write may only tighten; refused: ${loosens.join("; ")}`);
-                        }
-                    }
-                    const nextRev = priorRev + 1;
-                    if (pgHasUnstorable(clean)) {
-                        throw new SessionPolicyError("loosen_forbidden", "rules contain unstorable bytes (NUL / lone surrogate) — refused; strip them at the source (authorization rules are never rewritten by the store)");
-                    }
-                    const json = JSON.stringify(clean);
-                    const now = new Date();
-                    if (prior) {
-                        const u = await c.query("UPDATE session_policy SET principal = $1, rules = $2::jsonb, rev = $3, updated_at = $4 WHERE policy_key = $5 AND rev = $6", [principal ?? null, json, nextRev, now, key, priorRev]);
-                        if ((u.rowCount ?? 0) !== 1)
-                            throw new SessionPolicyError("conflict", `session rules rev mismatch (expected ${opts?.expectedRev ?? priorRev}, have ${priorRev})`);
-                    }
-                    else {
-                        await c.query("INSERT INTO session_policy (policy_key, session_id, principal, rules, rev, created_at, updated_at) VALUES ($1,$2,$3,$4::jsonb,$5,$6,$7)", [key, sessionId, principal ?? null, json, nextRev, now, now]);
-                    }
-                    return structuredClone({ ...clean, rev: nextRev });
-                });
-            }
-            catch (e) {
-                if (isDupKey(e) && attempt < 4)
-                    continue;
-                throw e;
-            }
-        }
-    }
-    async deleteBySession(sessionId) {
-        await this.pool.query("DELETE FROM session_policy WHERE session_id = $1", [sessionId]);
-    }
-    async tx(fn) {
-        const c = await this.pool.connect();
-        try {
-            await c.query("BEGIN");
-            const out = await fn(c);
-            await c.query("COMMIT");
-            return out;
-        }
-        catch (err) {
-            try {
-                await c.query("ROLLBACK");
-            }
-            catch {
-            }
-            throw err;
-        }
-        finally {
-            c.release();
-        }
-    }
-}
+export { PgSessionPolicyStore } from "./session-policy-store-sql.js";
 //# sourceMappingURL=pg-session-policy-store.js.map

package/dist/plugins/pg-tool-result-store.d.ts

@@ -1,16 +1,2 @@
-import type { ToolResultStore, ToolResultSlice } from "@sema-agent/core";
-import type { Pool, PoolClient } from "pg";
-export declare const PG_TOOL_RESULT_SCHEMA: string[];
-export declare function ensureSchema(pool: Pool | PoolClient): Promise<void>;
-export declare class PgToolResultStore implements ToolResultStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    put(ref: string, content: string): Promise<void>;
-    get(ref: string, opts?: {
-        offset?: number;
-        limit?: number;
-    }): Promise<ToolResultSlice | undefined>;
-    reapOlderThan(cutoffMs: number): Promise<number>;
-    deleteBySession(sessionId: string): Promise<number>;
-}
+export { PgToolResultStore, PG_TOOL_RESULT_SCHEMA, ensureSchema } from "./tool-result-store-sql.js";
 //# sourceMappingURL=pg-tool-result-store.d.ts.map

package/dist/plugins/pg-tool-result-store.js

@@ -1,53 +1,2 @@
-import { escapeLike } from "./sql-escape.js";
-import { pgSanitizeText } from "./pg-safe-json.js";
-export const PG_TOOL_RESULT_SCHEMA = [
-    `CREATE TABLE IF NOT EXISTS tool_result (
-     ref        VARCHAR(190) NOT NULL,
-     content    TEXT         NOT NULL,
-     created_at TIMESTAMPTZ(3) NOT NULL,
-     PRIMARY KEY (ref)
-   )`,
-    `CREATE INDEX IF NOT EXISTS idx_tool_result_created ON tool_result (created_at)`,
-];
-export async function ensureSchema(pool) {
-    for (const stmt of PG_TOOL_RESULT_SCHEMA)
-        await pool.query(stmt);
-}
-export class PgToolResultStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async put(ref, content) {
-        const safe = pgSanitizeText(Buffer.from(content, "utf8").toString("utf8"));
-        await this.pool.query("INSERT INTO tool_result (ref, content, created_at) VALUES ($1,$2,$3) ON CONFLICT (ref) DO NOTHING", [ref, safe, new Date()]);
-    }
-    async get(ref, opts = {}) {
-        const offset = Math.max(0, Math.floor(opts.offset ?? 0));
-        const hasLimit = opts.limit !== undefined && Number.isFinite(opts.limit);
-        const limit = hasLimit ? Math.max(0, Math.floor(opts.limit)) : 0;
-        const sql = hasLimit
-            ? "SELECT SUBSTRING(content FROM $1::int FOR $2::int) AS slice, CHAR_LENGTH(content) AS total FROM tool_result WHERE ref = $3"
-            : "SELECT SUBSTRING(content FROM $1::int) AS slice, CHAR_LENGTH(content) AS total FROM tool_result WHERE ref = $2";
-        const params = hasLimit ? [offset + 1, limit, ref] : [offset + 1, ref];
-        const res = await this.pool.query(sql, params);
-        if (res.rows.length === 0)
-            return undefined;
-        return { content: String(res.rows[0].slice ?? ""), offset, totalChars: Number(res.rows[0].total) };
-    }
-    async reapOlderThan(cutoffMs) {
-        try {
-            const res = await this.pool.query("DELETE FROM tool_result WHERE created_at < $1", [new Date(cutoffMs)]);
-            return res.rowCount ?? 0;
-        }
-        catch {
-            return 0;
-        }
-    }
-    async deleteBySession(sessionId) {
-        const prefix = `${escapeLike(`tr_${sessionId}_`)}%`;
-        const res = await this.pool.query("DELETE FROM tool_result WHERE ref LIKE $1 ESCAPE '\\'", [prefix]);
-        return res.rowCount ?? 0;
-    }
-}
+export { PgToolResultStore, PG_TOOL_RESULT_SCHEMA, ensureSchema } from "./tool-result-store-sql.js";
 //# sourceMappingURL=pg-tool-result-store.js.map

package/dist/plugins/pg-workflow-journal-store.d.ts

@@ -1,21 +1,2 @@
-import type { Pool } from "pg";
-import { type WorkflowJournalEntry, type WorkflowJournalStore } from "@sema-agent/core";
-export declare class PgWorkflowJournalStore implements WorkflowJournalStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    append(runId: string, scope: string, entry: WorkflowJournalEntry): Promise<void>;
-    load(runId: string, scope: string): Promise<WorkflowJournalEntry[]>;
-    locator(runId: string, _scope: string): string;
-    loadPage(runId: string, scope: string, opts: {
-        offset: number;
-        limit: number;
-        maxResultBytes: number;
-    }): Promise<Array<{
-        callKey: string;
-        resultJson: string | null;
-        resultBytes: number;
-    }>>;
-    deleteByRun(runId: string): Promise<number>;
-    reapExpired(now: number, maxAgeMs: number): Promise<number>;
-}
+export { PgWorkflowJournalStore } from "./workflow-journal-store-sql.js";
 //# sourceMappingURL=pg-workflow-journal-store.d.ts.map

package/dist/plugins/pg-workflow-journal-store.js

@@ -1,35 +1,2 @@
-import { callKeyOrdinal } from "@sema-agent/core";
-import { oversizeJournalResult } from "./workflow-journal-limits.js";
-export class PgWorkflowJournalStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async append(runId, scope, entry) {
-        const serialized = JSON.stringify(entry.result);
-        if (oversizeJournalResult(serialized))
-            return;
-        await this.pool.query("INSERT INTO workflow_journal (run_id, ordinal, scope, call_key, result, created_at) VALUES ($1,$2,$3,$4,$5,$6) " +
-            "ON CONFLICT (run_id, ordinal) DO UPDATE SET call_key = EXCLUDED.call_key, result = EXCLUDED.result", [runId, callKeyOrdinal(entry.callKey), scope, entry.callKey, serialized, Date.now()]);
-    }
-    async load(runId, scope) {
-        const r = await this.pool.query("SELECT call_key, result FROM workflow_journal WHERE run_id = $1 AND scope = $2 ORDER BY ordinal ASC", [runId, scope]);
-        return r.rows.map((row) => ({ callKey: String(row.call_key), result: JSON.parse(String(row.result)) }));
-    }
-    locator(runId, _scope) {
-        return `/v1/workflows/${runId}/journal`;
-    }
-    async loadPage(runId, scope, opts) {
-        const r = await this.pool.query("SELECT call_key, CASE WHEN OCTET_LENGTH(result) > $3 THEN NULL ELSE result END AS result_json, OCTET_LENGTH(result) AS result_bytes FROM workflow_journal WHERE run_id = $1 AND scope = $2 ORDER BY ordinal ASC LIMIT $4 OFFSET $5", [runId, scope, opts.maxResultBytes, opts.limit, opts.offset]);
-        return r.rows.map((row) => ({ callKey: String(row.call_key), resultJson: row.result_json === null ? null : String(row.result_json), resultBytes: Number(row.result_bytes) }));
-    }
-    async deleteByRun(runId) {
-        const r = await this.pool.query("DELETE FROM workflow_journal WHERE run_id = $1", [runId]);
-        return r.rowCount ?? 0;
-    }
-    async reapExpired(now, maxAgeMs) {
-        const r = await this.pool.query("DELETE FROM workflow_journal WHERE created_at < $1", [now - maxAgeMs]);
-        return r.rowCount ?? 0;
-    }
-}
+export { PgWorkflowJournalStore } from "./workflow-journal-store-sql.js";
 //# sourceMappingURL=pg-workflow-journal-store.js.map

package/dist/plugins/pg-workflow-run-store.d.ts

@@ -1,56 +1,2 @@
-import type { Pool } from "pg";
-import { summarizeWorkflowRun, type WorkflowRunStore } from "@sema-agent/core";
-import { type WorkflowCompletionInbox, type WorkflowCompletionInboxEntry } from "../orchestration/workflow-completion-inbox.js";
-import type { WorkflowNotifyJournalStore, WorkflowNotifyJournalEntry } from "../orchestration/workflow-notify-journal.js";
-import { type InboxWarn } from "./tidb-workflow-run-store.js";
-type WorkflowRun = Parameters<WorkflowRunStore["put"]>[1];
-export declare class PgWorkflowRunStore implements WorkflowRunStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    put(id: string, run: WorkflowRun): Promise<void>;
-    get(id: string): Promise<WorkflowRun | null>;
-    update(id: string, scope: string, run: WorkflowRun, expect?: {
-        rev: number;
-    }): Promise<boolean>;
-    listByScope(scope: string, opts?: {
-        status?: WorkflowRun["status"];
-        limit?: number;
-        session?: string;
-    }): Promise<ReturnType<typeof summarizeWorkflowRun>[]>;
-    reapAllScopes(now: number, opts: {
-        maxAgeMs?: number;
-        keep?: number;
-    }): Promise<number>;
-    reap(scope: string, now: number, opts?: {
-        maxAgeMs?: number;
-        keep?: number;
-    }): Promise<number>;
-}
-export declare class PgWorkflowCompletionInbox implements WorkflowCompletionInbox {
-    private readonly pool;
-    private readonly onWarn?;
-    constructor(pool: Pool, onWarn?: InboxWarn | undefined);
-    private sweepFences;
-    enqueue(entry: WorkflowCompletionInboxEntry): Promise<void>;
-    pending(sessionId: string): Promise<WorkflowCompletionInboxEntry[]>;
-    ack(sessionId: string, runId: string): Promise<void>;
-    purge(sessionId: string, purgedOwner?: string | null): Promise<void>;
-    markTerminalServed(sessionId: string, runId: string): Promise<void>;
-}
-export declare class PgWorkflowNotifyJournalStore implements WorkflowNotifyJournalStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    record(input: {
-        runId: string;
-        scope: string;
-        sourceTaskId?: string;
-        principal?: string;
-        createdAt: number;
-    }): Promise<void>;
-    ack(runId: string, ackedAt: number): Promise<void>;
-    listPending(): Promise<WorkflowNotifyJournalEntry[]>;
-    reapAcked(before: number): Promise<number>;
-    get(runId: string): Promise<WorkflowNotifyJournalEntry | null>;
-}
-export {};
+export { PgWorkflowRunStore, PgWorkflowCompletionInbox, PgWorkflowNotifyJournalStore } from "./workflow-run-store-sql.js";
 //# sourceMappingURL=pg-workflow-run-store.d.ts.map