@sema-agent/server 1.313.0 → 1.315.0

package/dist/memory-scope.d.ts

@@ -0,0 +1,18 @@
+import { FileMemoryEngineBackend } from "@sema-agent/core";
+import type { ServiceConfig } from "./config-types.js";
+export declare function memoryScopeFor(config: ServiceConfig, principal?: string, projectId?: string): string | undefined;
+export declare function memoryEngineRemoteLanePosture(config: ServiceConfig): {
+    lane: string;
+    posture: "dark" | "forced";
+} | undefined;
+export declare function memoryEngineBackendFor(config: ServiceConfig, fallbackRoot?: string): {
+    backend: FileMemoryEngineBackend;
+    root: string;
+} | undefined;
+export declare function memorySpecForRequest(scope: string | undefined, memoryWrite: boolean | undefined, defaultScopes?: string[]): {
+    scope: string;
+    scopes?: string[];
+    writeScope?: string | null;
+    scopeContract?: "v2";
+} | undefined;
+//# sourceMappingURL=memory-scope.d.ts.map

package/dist/memory-scope.js

@@ -0,0 +1,38 @@
+import { join } from "node:path";
+import { FileMemoryEngineBackend, resolveMemoryEngineRoot, deriveControlPlaneDir, formatUserScope, formatProjScope } from "@sema-agent/core";
+export function memoryScopeFor(config, principal, projectId) {
+    if (config.requirePrincipal === true) {
+        if (config.memoryEngineBackend === "pg" || config.memoryEngineBackend === "tidb") {
+            if (!principal)
+                return undefined;
+            return projectId ? formatProjScope(principal, projectId) : formatUserScope(principal);
+        }
+        return undefined;
+    }
+    return config.memoryScope;
+}
+export function memoryEngineRemoteLanePosture(config) {
+    const lane = config.remoteExec?.provider;
+    if (lane === undefined || lane === "host")
+        return undefined;
+    return { lane, posture: config.memoryEngineRemoteLaneAllowed === true ? "forced" : "dark" };
+}
+export function memoryEngineBackendFor(config, fallbackRoot) {
+    if (config.requirePrincipal === true || !config.memoryEngineEnabled)
+        return undefined;
+    if (memoryEngineRemoteLanePosture(config)?.posture === "dark")
+        return undefined;
+    const root = resolveMemoryEngineRoot(config.memoryEngineDir ?? fallbackRoot);
+    const dir = join(root, "memory");
+    return { backend: new FileMemoryEngineBackend(dir, { controlDir: deriveControlPlaneDir(root, dir) }), root };
+}
+export function memorySpecForRequest(scope, memoryWrite, defaultScopes) {
+    if (!scope)
+        return undefined;
+    const isV2 = (k) => k.startsWith("user:") || k.startsWith("org:") || k.startsWith("proj:") || k.startsWith("userproj:");
+    const extras = (defaultScopes ?? []).filter((s, i, arr) => typeof s === "string" && s.length > 0 && s !== scope && arr.indexOf(s) === i);
+    const layered = extras.length > 0 ? { scopes: [scope, ...extras], writeScope: scope } : {};
+    const v2 = isV2(scope) || extras.some(isV2) ? { scopeContract: "v2" } : {};
+    return memoryWrite === false ? { scope, ...layered, writeScope: null, ...v2 } : { scope, ...layered, ...v2 };
+}
+//# sourceMappingURL=memory-scope.js.map

package/dist/observability/cost-taxonomy.d.ts

@@ -0,0 +1,34 @@
+export interface InfraCostRates {
+    toolCallMicroUsd: number;
+    sandboxSecMicroUsd: number;
+    egressGbMicroUsd: number;
+}
+export interface InfraUsage {
+    toolCalls: number;
+    sandboxWalltimeMs: number;
+    egressBytes: number;
+}
+export interface InfraCostBreakdown {
+    toolCallMicroUsd: number;
+    sandboxWalltimeMicroUsd: number;
+    egressMicroUsd: number;
+    totalMicroUsd: number;
+}
+export interface LlmCostBreakdown {
+    llmRootMicroUsd: number;
+    nestedSubagentMicroUsd: number;
+    memoryConsolidationMicroUsd: number;
+    compactionMicroUsd: number;
+}
+export interface SupervisorCostBreakdown {
+    llm: LlmCostBreakdown | null;
+    infra: InfraCostBreakdown;
+    totalMicroUsd: number;
+}
+export declare function infraCost(usage: InfraUsage, rates: InfraCostRates): InfraCostBreakdown;
+export declare function composeSupervisorCost(llm: LlmCostBreakdown | null, llmTotalMicroUsd: number, infra: InfraCostBreakdown): SupervisorCostBreakdown;
+export declare function hasInfraPricing(r: InfraCostRates): boolean;
+export declare function infraUsageFromEvents(events: ReadonlyArray<{
+    type?: string;
+}>, runDurationMs: number): InfraUsage;
+//# sourceMappingURL=cost-taxonomy.d.ts.map

package/dist/observability/cost-taxonomy.js

@@ -0,0 +1,26 @@
+const nonNeg = (n) => (Number.isFinite(n) && n > 0 ? n : 0);
+export function infraCost(usage, rates) {
+    const toolCallMicroUsd = nonNeg(usage.toolCalls) * nonNeg(rates.toolCallMicroUsd);
+    const sandboxWalltimeMicroUsd = (nonNeg(usage.sandboxWalltimeMs) / 1000) * nonNeg(rates.sandboxSecMicroUsd);
+    const egressMicroUsd = (nonNeg(usage.egressBytes) / 1_000_000_000) * nonNeg(rates.egressGbMicroUsd);
+    return {
+        toolCallMicroUsd,
+        sandboxWalltimeMicroUsd,
+        egressMicroUsd,
+        totalMicroUsd: toolCallMicroUsd + sandboxWalltimeMicroUsd + egressMicroUsd,
+    };
+}
+export function composeSupervisorCost(llm, llmTotalMicroUsd, infra) {
+    return { llm, infra, totalMicroUsd: nonNeg(llmTotalMicroUsd) + infra.totalMicroUsd };
+}
+export function hasInfraPricing(r) {
+    return r.toolCallMicroUsd > 0 || r.sandboxSecMicroUsd > 0 || r.egressGbMicroUsd > 0;
+}
+export function infraUsageFromEvents(events, runDurationMs) {
+    return {
+        toolCalls: events.reduce((n, e) => (e.type === "tool_start" ? n + 1 : n), 0),
+        sandboxWalltimeMs: nonNeg(runDurationMs),
+        egressBytes: 0,
+    };
+}
+//# sourceMappingURL=cost-taxonomy.js.map

package/dist/observability/prompt-manifest.d.ts

@@ -0,0 +1,75 @@
+export interface PromptManifestRecord {
+    constitution: string;
+    blocks: Array<{
+        id: string;
+        chars: number;
+        hash: string;
+    }>;
+    sections?: Array<{
+        id: string;
+        slot: string;
+        carrier: string;
+        cadence: string;
+        cacheClass: string;
+        chars: number;
+        hash: string;
+        contentHash?: string;
+    }>;
+    tools?: Array<{
+        wireName: string;
+        aliases: string[];
+        contractId: string;
+        implementationRevision: string;
+        cardId: string;
+        shapeDigest: string;
+        wireSchemaDigest: string;
+    }>;
+    totalChars: number;
+}
+export declare function promptManifestRecordOf(e: {
+    constitution: string;
+    blocks: Array<{
+        id: string;
+        chars: number;
+        hash: string;
+    }>;
+    sections?: Array<{
+        id: string;
+        slot: string;
+        carrier: string;
+        cadence: string;
+        cacheClass: string;
+        chars: number;
+        hash: string;
+        contentHash?: string;
+    }>;
+    tools?: Array<{
+        wireName: string;
+        aliases: string[];
+        contractId: string;
+        implementationRevision: string;
+        cardId: string;
+        shapeDigest: string;
+        wireSchemaDigest: string;
+    }>;
+    totalChars: number;
+}): PromptManifestRecord;
+export declare function configAssembledRecordOf(e: {
+    catalogVersion?: unknown;
+    fields?: unknown;
+    overrideReasons?: unknown;
+    ts?: unknown;
+}): Record<string, unknown> | undefined;
+export declare class PromptManifestTracker {
+    private readonly byTask;
+    private readonly configByTask;
+    private readonly active;
+    private leaseCounter;
+    register(taskId: string): number;
+    record(taskId: string, m: PromptManifestRecord): void;
+    recordConfig(taskId: string, rec: Record<string, unknown>): void;
+    drainConfig(taskId: string): Array<Record<string, unknown>> | undefined;
+    drain(taskId: string): PromptManifestRecord[] | undefined;
+    clear(taskId: string, lease: number): void;
+}
+//# sourceMappingURL=prompt-manifest.d.ts.map

package/dist/observability/prompt-manifest.js

@@ -0,0 +1,82 @@
+export function promptManifestRecordOf(e) {
+    return {
+        constitution: String(e.constitution),
+        blocks: (Array.isArray(e.blocks) ? e.blocks : []).map((b) => ({ id: String(b.id), chars: b.chars, hash: String(b.hash) })),
+        ...(Array.isArray(e.sections)
+            ? { sections: e.sections.map((s) => ({ id: String(s.id), slot: String(s.slot), carrier: String(s.carrier), cadence: String(s.cadence), cacheClass: String(s.cacheClass), chars: s.chars, hash: String(s.hash), ...(typeof s.contentHash === "string" ? { contentHash: s.contentHash } : {}) })) }
+            : {}),
+        ...(Array.isArray(e.tools)
+            ? { tools: e.tools.map((t) => ({ wireName: String(t.wireName), aliases: (Array.isArray(t.aliases) ? t.aliases : []).map(String), contractId: String(t.contractId), implementationRevision: String(t.implementationRevision), cardId: String(t.cardId), shapeDigest: String(t.shapeDigest), wireSchemaDigest: String(t.wireSchemaDigest) })) }
+            : {}),
+        totalChars: e.totalChars,
+    };
+}
+export function configAssembledRecordOf(e) {
+    const rec = {
+        catalogVersion: e.catalogVersion,
+        fields: e.fields,
+        ...(e.overrideReasons !== undefined ? { overrideReasons: e.overrideReasons } : {}),
+        ts: e.ts,
+    };
+    try {
+        if (JSON.stringify(rec).length > 32_768)
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    return rec;
+}
+export class PromptManifestTracker {
+    byTask = new Map();
+    configByTask = new Map();
+    active = new Map();
+    leaseCounter = 0;
+    register(taskId) {
+        if (!taskId)
+            return 0;
+        const lease = ++this.leaseCounter;
+        this.active.set(taskId, lease);
+        return lease;
+    }
+    record(taskId, m) {
+        if (!taskId || !this.active.has(taskId))
+            return;
+        const q = this.byTask.get(taskId);
+        if (q)
+            q.push(m);
+        else
+            this.byTask.set(taskId, [m]);
+    }
+    recordConfig(taskId, rec) {
+        if (!taskId || !this.active.has(taskId))
+            return;
+        const q = this.configByTask.get(taskId);
+        if (q)
+            q.push(rec);
+        else
+            this.configByTask.set(taskId, [rec]);
+    }
+    drainConfig(taskId) {
+        const q = this.configByTask.get(taskId);
+        if (!q || q.length === 0)
+            return undefined;
+        this.configByTask.delete(taskId);
+        return q;
+    }
+    drain(taskId) {
+        const q = this.byTask.get(taskId);
+        if (!q || q.length === 0)
+            return undefined;
+        this.byTask.delete(taskId);
+        return q;
+    }
+    clear(taskId, lease) {
+        if (this.active.get(taskId) !== lease)
+            return;
+        this.byTask.delete(taskId);
+        this.active.delete(taskId);
+        this.configByTask.delete(taskId);
+    }
+}
+//# sourceMappingURL=prompt-manifest.js.map

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

@@ -0,0 +1,67 @@
+import type { Pool as MySqlPool } from "mysql2/promise";
+import type { Pool as PgPool } from "pg";
+import { type Checkpoint, type CheckpointStore, type CheckpointSummary, type CheckpointToken, type ResumeOutcome, type ResolveExpectation, type ReopenReason, type RiskDescriptor } from "@sema-agent/core";
+import { type SqlDriver } from "./sql-driver.js";
+export declare const TERMINAL_BACKSTOP_MS: number;
+export declare const TERMINAL_GRACE_MS = 3600000;
+export declare function tokenFingerprint(token: string): string;
+export interface PendingCheckpoint {
+    sessionId: string;
+    scope: string;
+    toolName: string | null;
+    toolCallId: string | null;
+    boundCallId: string | null;
+    boundInputHash: string | null;
+    taskId: string | null;
+    input: unknown;
+    createdAt: number;
+    deadline: number | null;
+    riskDescriptor: RiskDescriptor | null;
+}
+export declare function boundedToolInput(args: unknown): unknown;
+export declare class SqlCheckpointStore implements CheckpointStore {
+    protected readonly db: SqlDriver;
+    protected readonly logger?: {
+        info?(msg: string, meta?: unknown): void;
+    } | undefined;
+    constructor(db: SqlDriver, logger?: {
+        info?(msg: string, meta?: unknown): void;
+    } | undefined);
+    private q;
+    private json;
+    private isDupKey;
+    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 declare class TiDBCheckpointStore extends SqlCheckpointStore {
+    constructor(pool: MySqlPool, logger?: {
+        info?(msg: string, meta?: unknown): void;
+    });
+}
+export declare class PgCheckpointStore extends SqlCheckpointStore {
+    constructor(pool: PgPool, logger?: {
+        info?(msg: string, meta?: unknown): void;
+    });
+}
+//# sourceMappingURL=checkpoint-store-sql.d.ts.map

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

@@ -0,0 +1,224 @@
+import { createHash } from "node:crypto";
+import { CheckpointError, validatePendingSteer, checkpointVersionOf, winnerFromOutcome, summarizeCheckpoint, MAX_SUPPORTED_CHECKPOINT_VERSION, } from "@sema-agent/core";
+import { redactDeep } from "../trace/redact.js";
+import { pgProtocolJsonStringify } from "./pg-safe-json.js";
+import { parseJsonStrict as parseJson } from "./sql-row-helpers.js";
+import { mysqlDriver, pgDriver } from "./sql-driver.js";
+const MAX_TOOL_INPUT_CHARS = 8192;
+export const TERMINAL_BACKSTOP_MS = Math.max(60_000, Number(process.env.APPROVAL_TERMINAL_BACKSTOP_MS) || 30 * 86_400_000);
+export const TERMINAL_GRACE_MS = 3_600_000;
+export function tokenFingerprint(token) {
+    return "sha256:" + createHash("sha256").update(token).digest("hex").slice(0, 12);
+}
+export 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;
+}
+const DUP_ENTRY = 1062;
+const PG_UNIQUE_VIOLATION = "23505";
+export class SqlCheckpointStore {
+    db;
+    logger;
+    constructor(db, logger) {
+        this.db = db;
+        this.logger = logger;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    json(value, label) {
+        return this.db.dialect === "tidb" ? JSON.stringify(value) : pgProtocolJsonStringify(value, label);
+    }
+    isDupKey(e) {
+        return this.db.dialect === "tidb"
+            ? e?.errno === DUP_ENTRY
+            : e?.code === PG_UNIQUE_VIOLATION;
+    }
+    async put(token, cp) {
+        const pa = cp.pendingAction;
+        const version = checkpointVersionOf(cp);
+        const toolInput = boundedToolInput(pa?.args);
+        try {
+            await this.db.query(this.q("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 (?,?,?,?,'pending',?,?,?,?,?,?,?,?,?,?)", "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 : this.json(toolInput, "approval tool_input"),
+                this.json(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 ? this.json(g.riskDescriptor, "risk descriptor") : null))(cp.gate),
+            ]);
+        }
+        catch (e) {
+            if (this.isDupKey(e)) {
+                throw new CheckpointError("checkpoint.already_exists", `checkpoint token already exists`);
+            }
+            throw e;
+        }
+    }
+    async get(token) {
+        const { rows } = await this.db.query(this.q("SELECT version, status, checkpoint, outcome, reopen_reason, rev, pending_steer FROM checkpoint WHERE token = ?", "SELECT version, status, checkpoint, outcome, reopen_reason, rev, pending_steer FROM checkpoint WHERE token = $1"), [token]);
+        const r = 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 = [this.json(outcome, "checkpoint outcome"), Date.now(), token, scope];
+        if (expect)
+            params.push(expect.rev);
+        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'resolved', outcome = ?, decided_at = ?, rev = rev + 1, reopen_reason = NULL WHERE token = ? AND scope = ? AND status = 'pending'" +
+            (expect ? " AND rev = ?" : ""), "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.affected === 1;
+    }
+    async reopen(token, scope, reason) {
+        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'pending', reopen_reason = ?, rev = rev + 1 WHERE token = ? AND scope = ? AND status = 'resolved'", "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.affected === 1;
+    }
+    async setPendingSteer(token, scope, steer) {
+        const clean = validatePendingSteer(steer);
+        const res = await this.db.query(this.q("UPDATE checkpoint SET pending_steer = ? WHERE token = ? AND scope = ? AND status = 'pending'", "UPDATE checkpoint SET pending_steer = $1 WHERE token = $2 AND scope = $3 AND status = 'pending'"), [this.json(clean, "pending steer"), token, scope]);
+        return res.affected > 0;
+    }
+    async expire(token, scope) {
+        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'expired', decided_at = ? WHERE token = ? AND scope = ? AND status = 'pending'", "UPDATE checkpoint SET status = 'expired', decided_at = $1 WHERE token = $2 AND scope = $3 AND status = 'pending'"), [Date.now(), token, scope]);
+        return res.affected === 1;
+    }
+    async reap(scope, cutoff) {
+        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'expired', decided_at = ? WHERE scope = ? AND status = 'pending' AND deadline IS NOT NULL AND deadline <= ?", "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.affected;
+    }
+    async reapExpired(cutoff) {
+        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'expired', decided_at = ? " +
+            "WHERE status = 'pending' AND ((deadline IS NOT NULL AND deadline <= ? 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 <= ?))", "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.affected;
+    }
+    async listExpiredApprovalGates(cutoff, limit = 100) {
+        const { rows } = await this.db.query(this.q("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 <= ? ORDER BY deadline ASC LIMIT ?", "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 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 { rows } = scope
+            ? await this.db.query(`${base}${this.q(" AND c.scope=?", " AND c.scope=$1")} ORDER BY c.created_at ASC`, [scope])
+            : await this.db.query(`${base} ORDER BY c.created_at ASC`);
+        const out = 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 { rows } = await this.db.query(this.q("SELECT checkpoint, status FROM checkpoint WHERE status = 'pending' AND scope = ? ORDER BY created_at ASC LIMIT 500", "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 rows) {
+            const cp = parseJson(r.checkpoint);
+            if (!cp)
+                continue;
+            cp.status = r.status;
+            out.push(summarizeCheckpoint(cp));
+        }
+        return out;
+    }
+    async findPendingTokenBySession(sessionId, scope) {
+        const { rows } = scope
+            ? await this.db.query(this.q("SELECT token FROM checkpoint WHERE session_id=? AND scope=? AND status='pending' LIMIT 1", "SELECT token FROM checkpoint WHERE session_id=$1 AND scope=$2 AND status='pending' LIMIT 1"), [sessionId, scope])
+            : await this.db.query(this.q("SELECT token FROM checkpoint WHERE session_id=? AND status='pending' LIMIT 1", "SELECT token FROM checkpoint WHERE session_id=$1 AND status='pending' LIMIT 1"), [sessionId]);
+        return rows[0] ? String(rows[0].token) : null;
+    }
+    async peekPendingScope(sessionId) {
+        const { rows } = await this.db.query(this.q("SELECT scope FROM checkpoint WHERE session_id=? AND status='pending' LIMIT 1", "SELECT scope FROM checkpoint WHERE session_id=$1 AND status='pending' LIMIT 1"), [sessionId]);
+        if (!rows[0])
+            return undefined;
+        return rows[0].scope ?? null;
+    }
+    async putCtx(sessionId, ctx) {
+        await this.db.query(this.q("INSERT INTO checkpoint_ctx (session_id, ctx, updated_at) VALUES (?,?,?) " +
+            "ON DUPLICATE KEY UPDATE ctx = VALUES(ctx), updated_at = VALUES(updated_at)", "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, this.json(ctx, "checkpoint ctx"), Date.now()]);
+    }
+    async getCtx(sessionId) {
+        const { rows } = await this.db.query(this.q("SELECT ctx FROM checkpoint_ctx WHERE session_id=?", "SELECT ctx FROM checkpoint_ctx WHERE session_id=$1"), [sessionId]);
+        return rows[0] ? parseJson(rows[0].ctx) : null;
+    }
+    async reapCtx(cutoff) {
+        const res = await this.db.query(this.q("DELETE FROM checkpoint_ctx WHERE updated_at < ? " +
+            "AND session_id NOT IN (SELECT session_id FROM checkpoint WHERE status='pending') " +
+            "AND session_id NOT IN (SELECT session_id FROM task_active)", "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.affected;
+    }
+    async deleteBySession(sessionId, owner) {
+        const ownerGuard = this.q("EXISTS (SELECT 1 FROM session_meta sm WHERE sm.session_id = ? AND sm.owner <=> ?)", "EXISTS (SELECT 1 FROM session_meta sm WHERE sm.session_id = $1 AND sm.owner IS NOT DISTINCT FROM $2)");
+        const params = this.db.dialect === "tidb" ? [sessionId, sessionId, owner] : [sessionId, owner];
+        const res = await this.db.query(this.q(`DELETE FROM checkpoint WHERE session_id = ? AND ${ownerGuard}`, `DELETE FROM checkpoint WHERE session_id = $1 AND ${ownerGuard}`), params);
+        await this.db.query(this.q(`DELETE FROM checkpoint_ctx WHERE session_id = ? AND ${ownerGuard}`, `DELETE FROM checkpoint_ctx WHERE session_id = $1 AND ${ownerGuard}`), params);
+        return res.affected;
+    }
+}
+export class TiDBCheckpointStore extends SqlCheckpointStore {
+    constructor(pool, logger) {
+        super(mysqlDriver(pool), logger);
+    }
+}
+export class PgCheckpointStore extends SqlCheckpointStore {
+    constructor(pool, logger) {
+        super(pgDriver(pool), logger);
+    }
+}
+//# sourceMappingURL=checkpoint-store-sql.js.map

package/dist/plugins/image-bake-store-sql.d.ts

@@ -0,0 +1,53 @@
+import type { Pool as MySqlPool } from "mysql2/promise";
+import type { Pool as PgPool, PoolClient } from "pg";
+import { type SqlDriver } from "./sql-driver.js";
+import { type BakeStatus, type BakeState, type BakeRecord, type BakeEvent, type CreateBakeInput, type BakeTerminal } from "./store-contracts.js";
+export declare const PG_IMAGE_BAKE_SCHEMA: string[];
+export declare function ensurePgImageBakeSchema(pool: PgPool | PoolClient, poolName?: string): Promise<void>;
+export declare class SqlImageBake {
+    protected readonly db: SqlDriver;
+    protected readonly poolName: string;
+    constructor(db: SqlDriver, poolName?: string);
+    private q;
+    private insertParams;
+    createBake(input: CreateBakeInput): Promise<{
+        created: boolean;
+        bake: BakeRecord;
+    }>;
+    createBakeIfIdle(input: CreateBakeInput): Promise<{
+        created: boolean;
+        bake: BakeRecord | null;
+    }>;
+    getBake(bakeId: string): Promise<BakeRecord | null>;
+    getBakeByIdem(idemKey: string): Promise<BakeRecord | null>;
+    findActiveByArgv(argv: string[]): Promise<BakeRecord | null>;
+    findActiveAny(): Promise<BakeRecord | null>;
+    findNextQueuedId(): Promise<string | null>;
+    claimBake(bakeId: string, runnerId: string, leaseMs: number): Promise<BakeRecord | null>;
+    appendEvent(bakeId: string, kind: string, data: unknown, opts?: {
+        lineOrd?: number | null;
+        level?: string | null;
+    }): Promise<number | null>;
+    private lineOrdExists;
+    maxSeq(bakeId: string): Promise<number>;
+    retainedFrom(bakeId: string): Promise<number>;
+    getEvents(bakeId: string, afterSeq: number): Promise<BakeEvent[]>;
+    setStatus(bakeId: string, status: BakeStatus): Promise<void>;
+    setState(bakeId: string, state: BakeState): Promise<void>;
+    setTerminal(bakeId: string, t: BakeTerminal): Promise<number>;
+    private terminalParamsTidb;
+    private terminalParamsPg;
+    setIndexId(bakeId: string, indexId: string): Promise<boolean>;
+    heartbeatLease(bakeId: string, runnerId: string, leaseMs: number): Promise<boolean>;
+    requestCancel(bakeId: string): Promise<boolean>;
+    isCancelRequested(bakeId: string): Promise<boolean>;
+    reapStaleBakes(olderThanMs: number): Promise<number>;
+    private tx;
+}
+export declare class TiDBImageBake extends SqlImageBake {
+    constructor(pool: MySqlPool, poolName?: string);
+}
+export declare class PgImageBake extends SqlImageBake {
+    constructor(pool: PgPool, poolName?: string);
+}
+//# sourceMappingURL=image-bake-store-sql.d.ts.map