@sema-agent/server 1.315.0 → 1.316.0

package/dist/plugins/pg-outcome-ledger.d.ts

@@ -1,23 +1,3 @@
-import type { Pool, PoolClient } from "pg";
-import { type TaskOutcome, type RunStatus } from "./tidb-outcome-ledger.js";
-import type { TaskOutcome as CoreTaskOutcome } from "@sema-agent/core";
-export declare const PG_OUTCOME_LEDGER_SCHEMA: string[];
-export declare function ensureSchema(pool: Pool | PoolClient): Promise<void>;
-export declare class PgOutcomeLedger {
-    private readonly pool;
-    constructor(pool: Pool);
-    record(o: TaskOutcome): Promise<string>;
-    recordCore(o: CoreTaskOutcome): Promise<void>;
-    summary(opts?: {
-        taskSignature?: string;
-        includeAborted?: boolean;
-    }): Promise<Array<{
-        taskSignature: string;
-        model: string;
-        n: number;
-        passRate: number;
-        meanCostMicroUsd: number;
-    }>>;
-}
-export type { TaskOutcome, RunStatus };
+export { PgOutcomeLedger, PG_OUTCOME_LEDGER_SCHEMA, ensurePgOutcomeLedgerSchema as ensureSchema, } from "./outcome-ledger-sql.js";
+export type { TaskOutcome, RunStatus } from "./outcome-ledger-sql.js";
 //# sourceMappingURL=pg-outcome-ledger.d.ts.map

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

@@ -1,105 +1,2 @@
-import { randomUUID } from "node:crypto";
-import { taskSignature, deriveOutcome, } from "./tidb-outcome-ledger.js";
-import { coreOutcomeToLedgerRow } from "./tidb-outcome-ledger.js";
-import { pgSafeJsonStringify } from "./pg-safe-json.js";
-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 ensureSchema(pool) {
-    for (const stmt of PG_OUTCOME_LEDGER_SCHEMA)
-        await pool.query(stmt);
-}
-export class PgOutcomeLedger {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    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.pool.query(`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 ? pgSafeJsonStringify(m.replanTriggers) : null,
-            m.costMicroUsd ?? null,
-            m.turns ?? null,
-            deriveOutcome(m, runStatus),
-            o.llmAssisted ? pgSafeJsonStringify(o.llmAssisted) : null,
-            pgSafeJsonStringify(o.signatureInputs),
-            o.core != null ? pgSafeJsonStringify(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(`task_signature = $${params.length}`);
-        }
-        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
-        const res = await this.pool.query(`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 res.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 { PgOutcomeLedger, PG_OUTCOME_LEDGER_SCHEMA, ensurePgOutcomeLedgerSchema as ensureSchema, } from "./outcome-ledger-sql.js";
 //# sourceMappingURL=pg-outcome-ledger.js.map

package/dist/plugins/pg-resume-anchor-store.d.ts

@@ -1,14 +1,2 @@
-import type { Pool } from "pg";
-export declare class PgResumeAnchorStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    put(sessionId: string, eventId: string, entryId: string, owner: string | null): Promise<void>;
-    resolve(sessionId: string, eventId: string, owner: string | null): Promise<string | undefined>;
-    listBySession(sessionId: string): Promise<Array<{
-        eventId: string;
-        entryId: string;
-        owner: string | null;
-    }>>;
-    deleteBySession(sessionId: string): Promise<number>;
-}
+export { PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
 //# sourceMappingURL=pg-resume-anchor-store.d.ts.map

package/dist/plugins/pg-resume-anchor-store.js

@@ -1,23 +1,2 @@
-export class PgResumeAnchorStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async put(sessionId, eventId, entryId, owner) {
-        await this.pool.query("INSERT INTO resume_anchor (session_id, event_id, entry_id, owner, created_at) VALUES ($1,$2,$3,$4,$5) " +
-            "ON CONFLICT (session_id, event_id) DO UPDATE SET entry_id = EXCLUDED.entry_id, owner = EXCLUDED.owner", [sessionId, eventId, entryId, owner, new Date()]);
-    }
-    async resolve(sessionId, eventId, owner) {
-        const r = await this.pool.query("SELECT entry_id FROM resume_anchor WHERE session_id = $1 AND event_id = $2 AND owner IS NOT DISTINCT FROM $3", [sessionId, eventId, owner]);
-        return r.rows[0] ? String(r.rows[0].entry_id) : undefined;
-    }
-    async listBySession(sessionId) {
-        const r = await this.pool.query("SELECT event_id, entry_id, owner FROM resume_anchor WHERE session_id = $1", [sessionId]);
-        return r.rows.map((row) => ({ eventId: String(row.event_id), entryId: String(row.entry_id), owner: row.owner == null ? null : String(row.owner) }));
-    }
-    async deleteBySession(sessionId) {
-        const r = await this.pool.query("DELETE FROM resume_anchor WHERE session_id = $1", [sessionId]);
-        return r.rowCount ?? 0;
-    }
-}
+export { PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
 //# sourceMappingURL=pg-resume-anchor-store.js.map

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

@@ -1,76 +1,2 @@
-import type { TaskResult, TaskStatus } from "@sema-agent/core";
-import { type UsageRow } from "../usage-analytics.js";
-import type { Pool } from "pg";
-import type { RunRecord, RunEvent, SessionSummary } from "./store-contracts.js";
-export declare class PgRunStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    private tx;
-    createRun(taskId: string, sessionId: string, owner: string | null, instanceId: string, meta?: {
-        jobId?: string | null;
-        source?: string | null;
-        objectivePreview?: string | null;
-    }): Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        activeTaskId: string;
-    }>;
-    requestCancel(taskId: string, owner: string | null): Promise<boolean>;
-    isCancelRequested(taskId: string, owner: string | null): Promise<boolean>;
-    requestPreempt(taskId: string, owner: string | null): Promise<boolean>;
-    isPreemptRequested(taskId: string, owner: string | null): Promise<boolean>;
-    heartbeat(taskId: string, owner: string | null): Promise<void>;
-    appendEvent(taskId: string, seq: number, type: string, data: unknown): Promise<void>;
-    maxSeq(taskId: string): Promise<number>;
-    setTerminal(taskId: string, status: TaskStatus, result: TaskResult | null, error: string | null): Promise<void>;
-    setSuspended(taskId: string): Promise<void>;
-    setNeedsReview(taskId: string): Promise<void>;
-    markResuming(taskId: string): Promise<boolean>;
-    getActiveTaskId(sessionId: string): Promise<string | undefined>;
-    private rowToRun;
-    getRun(taskId: string): Promise<RunRecord | undefined>;
-    listRuns(opts: {
-        status?: string;
-        jobId?: string;
-        source?: string;
-        owner?: string;
-        cursor?: {
-            createdAt: string;
-            taskId: string;
-        };
-        limit: number;
-    }): Promise<RunRecord[]>;
-    listSessions(opts: {
-        owner?: string;
-        cursor?: {
-            lastActivityAt: string;
-            sessionId: string;
-        };
-        limit: number;
-        q?: string;
-    }): Promise<SessionSummary[]>;
-    deleteBySession(sessionId: string, owner: string | null): Promise<{
-        removed: number;
-    } | {
-        active: string;
-    }>;
-    sourceSummary(sinceMs: number): Promise<Array<{
-        source: string | null;
-        status: string;
-        count: number;
-    }>>;
-    usageScan(fromMs: number, toMs: number, opts?: {
-        owner?: string;
-        limit?: number;
-    }): Promise<{
-        rows: UsageRow[];
-        truncated: boolean;
-    }>;
-    retainedFrom(taskId: string): Promise<number>;
-    getEvents(taskId: string, afterSeq: number): Promise<RunEvent[]>;
-    reapStale(olderThanMs: number): Promise<number>;
-    reapSuspended(olderThanMs: number): Promise<number>;
-    failSuspendedWithExpiredCheckpoint(): Promise<number>;
-}
+export { PgRunStore } from "./run-store-sql.js";
 //# sourceMappingURL=pg-run-store.d.ts.map

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