@vendoai/store 0.1.0 → 0.4.0

package/dist/automation-store.js

@@ -1,675 +0,0 @@
-/**
- * DrizzleAutomationStore — Postgres-dialect (PGlite default, DATABASE_URL
- * override) port of `InMemoryAutomationStore` (packages/vendo-runtime/src/
- * automations/store.ts). That class is the BEHAVIORAL SPEC: every method here
- * mirrors its semantics exactly — truncation caps, coarse-status mapping, and
- * the trigger index are reused verbatim via the runtime's exported helpers
- * rather than re-implemented, so the two stores can never silently diverge.
- *
- * Two things can't be ported as plain JS logic because they need the database:
- *  - `claimPendingApproval` — a single capture-then-clear SQL statement (a
- *    plain `UPDATE … RETURNING pending_approval` would return the just-set
- *    NULL, not the value it cleared) using `FOR UPDATE SKIP LOCKED` so exactly
- *    one concurrent caller wins.
- *  - `finalizeRun` — the run write and the automation counters update commit
- *    together in one `db.transaction`.
- *
- * Timestamp round-trip: drizzle's `timestamp(..., { mode: "string" })` gives
- * back Postgres's own text rendering ("2026-07-01 08:00:00+00"), not the ISO
- * string the runtime writes ("2026-07-01T08:00:00.000Z"). Contract tests
- * assert exact ISO equality, so every timestamp column is normalized through
- * `toIso()` at the read boundary. Freshly-created/updated records are
- * returned from the JS values just written (already canonical ISO from the
- * clock) rather than re-read from the DB, so `toIso` only applies where rows
- * come back from a `select`.
- */
-import { randomUUID } from "node:crypto";
-import { and, eq, isNull, sql } from "drizzle-orm";
-import { DuplicateRunError, PARKED_ACTION_TTL_MS, automationSpecSchema, capEnvelope, capParkedInput, capStep, coarseStatus, firingRunId, triggerIndex, } from "@vendoai/runtime";
-import { automationRuns, automations, automationVersions, parkedActions } from "./schema.js";
-/** Postgres text timestamp -> the ISO 8601 string the runtime writes/expects. */
-export function toIso(value) {
-    return new Date(value).toISOString();
-}
-function rowToAutomation(row) {
-    const record = {
-        id: row.id,
-        name: row.name,
-        status: row.status,
-        spec: row.spec,
-        tenantId: row.tenantId,
-        subject: row.subject,
-        currentVersion: row.currentVersion,
-        triggerKind: row.triggerKind,
-        triggerKey: row.triggerKey,
-        counters: row.counters,
-        createdFromThreadId: row.createdFromThreadId,
-        createdAt: toIso(row.createdAt),
-        updatedAt: toIso(row.updatedAt),
-    };
-    if (row.disabledReason != null) {
-        record.disabledReason = row.disabledReason;
-    }
-    return record;
-}
-function rowToVersion(row) {
-    return {
-        automationId: row.automationId,
-        version: row.version,
-        spec: row.spec,
-        dslVersion: row.dslVersion,
-        manifestHash: row.manifestHash,
-        grants: row.grants,
-        createdBy: row.createdBy,
-        createdAt: toIso(row.createdAt),
-    };
-}
-function rowToRun(row) {
-    const run = {
-        id: row.id,
-        automationId: row.automationId,
-        version: row.version,
-        manifestHash: row.manifestHash,
-        tenantId: row.tenantId,
-        subject: row.subject,
-        status: row.status,
-        trigger: row.trigger,
-        steps: row.steps,
-        isTest: row.isTest,
-        parkedCount: row.parkedCount,
-        startedAt: toIso(row.startedAt),
-    };
-    if (row.outcome != null)
-        run.outcome = row.outcome;
-    if (row.pendingApproval != null)
-        run.pendingApproval = row.pendingApproval;
-    if (row.error != null)
-        run.error = row.error;
-    if (row.finishedAt != null)
-        run.finishedAt = toIso(row.finishedAt);
-    return run;
-}
-/** PG unique-violation code; PGlite's thrown shape doesn't always match
- *  node-postgres's (code may be nested under `cause`, or absent — fall back
- *  to matching the driver-agnostic Postgres error text). */
-function isUniqueViolation(err) {
-    const code = err?.code ??
-        err?.cause?.code;
-    if (code === "23505")
-        return true;
-    const message = err instanceof Error ? err.message : String(err);
-    return /duplicate key value violates unique constraint/i.test(message);
-}
-/** Durable port of `InMemoryAutomationStore`; see the module doc for the two
- *  methods that genuinely need database semantics. */
-export class DrizzleAutomationStore {
-    handle;
-    clock;
-    constructor(handle, opts = {}) {
-        this.handle = handle;
-        this.clock = opts.now ?? (() => new Date().toISOString());
-    }
-    now() {
-        return this.clock();
-    }
-    get db() {
-        return this.handle.db;
-    }
-    async withTransaction(fn) {
-        if (this.handle.kind === "pglite") {
-            const handle = this.handle;
-            return handle.db.transaction((tx) => fn(tx));
-        }
-        const handle = this.handle;
-        return handle.db.transaction((tx) => fn(tx));
-    }
-    // ---- frozen core surface -------------------------------------------------
-    async save(scope, automation) {
-        const spec = automationSpecSchema.parse(automation.spec);
-        const { automation: record } = await this.create(scope, {
-            spec,
-            name: automation.name,
-            grants: [],
-        });
-        if (automation.status === "paused")
-            await this.setStatus(scope, record.id, "paused");
-        return (await this.get(scope, record.id));
-    }
-    async get(scope, id) {
-        const rows = await this.db
-            .select()
-            .from(automations)
-            .where(and(eq(automations.id, id), eq(automations.tenantId, scope.tenantId), eq(automations.subject, scope.subject)));
-        return rows[0] ? rowToAutomation(rows[0]) : undefined;
-    }
-    async list(scope) {
-        const rows = await this.db
-            .select()
-            .from(automations)
-            .where(and(eq(automations.tenantId, scope.tenantId), eq(automations.subject, scope.subject)));
-        return rows.map(rowToAutomation);
-    }
-    async recordRun(scope, run) {
-        // Core-shaped upsert: merge onto the engine row when it exists AND the
-        // caller owns it (mirrors InMemoryAutomationStore.recordRun's
-        // `{ ...existing, ...run }` preserve-merge). Run ids are globally unique
-        // (the PK), so an existing id owned by ANOTHER principal can neither be
-        // merged (cross-tenant write) nor re-inserted (PK collision): it's a
-        // no-op, same as the in-memory reference.
-        const existingRows = await this.db.select().from(automationRuns).where(eq(automationRuns.id, run.id));
-        const existing = existingRows[0];
-        if (existing) {
-            if (existing.tenantId !== scope.tenantId || existing.subject !== scope.subject)
-                return;
-            // Preserve-merge: absent optional fields keep their stored values,
-            // matching the in-memory spread.
-            const set = {
-                automationId: run.automationId,
-                status: run.status,
-                startedAt: run.startedAt,
-            };
-            if (run.error !== undefined)
-                set.error = run.error;
-            if (run.finishedAt !== undefined)
-                set.finishedAt = run.finishedAt;
-            await this.db
-                .update(automationRuns)
-                .set(set)
-                .where(and(eq(automationRuns.id, run.id), eq(automationRuns.tenantId, scope.tenantId), eq(automationRuns.subject, scope.subject)));
-            return;
-        }
-        await this.db.insert(automationRuns).values({
-            id: run.id,
-            automationId: run.automationId,
-            tenantId: scope.tenantId,
-            subject: scope.subject,
-            version: 0,
-            manifestHash: null,
-            status: run.status,
-            outcome: null,
-            trigger: {
-                source: "external",
-                eventId: run.id,
-                subject: scope.subject,
-                occurredAt: run.startedAt,
-                payload: undefined,
-            },
-            steps: [],
-            pendingApproval: null,
-            error: run.error ?? null,
-            isTest: false,
-            startedAt: run.startedAt,
-            finishedAt: run.finishedAt ?? null,
-        });
-    }
-    async listRuns(scope, automationId) {
-        const rows = await this.db
-            .select()
-            .from(automationRuns)
-            .where(and(eq(automationRuns.automationId, automationId), eq(automationRuns.tenantId, scope.tenantId), eq(automationRuns.subject, scope.subject)));
-        return rows.map(rowToRun);
-    }
-    // ---- engine surface ------------------------------------------------------
-    async create(scope, input) {
-        const id = `auto-${randomUUID()}`;
-        const now = this.now();
-        const { kind, key } = triggerIndex(input.spec);
-        const counters = {
-            totalRuns: 0,
-            totalFailures: 0,
-            consecutiveFailures: 0,
-            lastRunAt: null,
-            lastStatus: null,
-        };
-        const automation = {
-            id,
-            name: input.name ?? input.spec.name,
-            status: "enabled",
-            spec: input.spec,
-            tenantId: scope.tenantId,
-            subject: scope.subject,
-            currentVersion: 1,
-            triggerKind: kind,
-            triggerKey: key,
-            counters,
-            createdFromThreadId: input.createdFromThreadId ?? null,
-            createdAt: now,
-            updatedAt: now,
-        };
-        const version = {
-            automationId: id,
-            version: 1,
-            spec: input.spec,
-            dslVersion: input.spec.dslVersion,
-            manifestHash: input.manifestHash ?? null,
-            grants: input.grants,
-            createdBy: input.createdBy ?? "compiler",
-            createdAt: now,
-        };
-        // Record + version row commit together: a crash between them must never
-        // leave an automation without its version 1.
-        await this.withTransaction(async (tx) => {
-            await tx.insert(automations).values({
-                id,
-                tenantId: scope.tenantId,
-                subject: scope.subject,
-                name: automation.name,
-                status: "enabled",
-                spec: input.spec,
-                currentVersion: 1,
-                triggerKind: kind,
-                triggerKey: key,
-                counters,
-                createdFromThreadId: automation.createdFromThreadId ?? null,
-                createdAt: now,
-                updatedAt: now,
-            });
-            await tx.insert(automationVersions).values({
-                automationId: id,
-                version: 1,
-                spec: input.spec,
-                dslVersion: input.spec.dslVersion,
-                manifestHash: version.manifestHash,
-                grants: input.grants,
-                createdBy: version.createdBy,
-                createdAt: now,
-            });
-        });
-        return { automation, version };
-    }
-    async update(scope, id, input) {
-        const now = this.now();
-        const { kind, key } = triggerIndex(input.spec);
-        // currentVersion is read and bumped in ONE transaction with the version
-        // insert: a crash between the insert and the pointer bump would otherwise
-        // wedge every later update on the (automation_id, version) PK forever.
-        return this.withTransaction(async (tx) => {
-            // `FOR UPDATE` row-locks this automation for the rest of the
-            // transaction: two concurrent update() calls both reading
-            // currentVersion before either commits would otherwise compute the
-            // SAME nextVersion and race on the (automation_id, version) PK — one
-            // throws a 23505 instead of correctly serializing to versions N+1 and
-            // N+2. The second concurrent caller now blocks here until the first
-            // commits, then reads the POST-update currentVersion. PGlite runs every
-            // `.transaction()` under an internal exclusive lock (one connection),
-            // so this is a no-op there — real concurrent Postgres is what the lock
-            // is for; a true concurrent-PG test isn't runnable in this test
-            // environment (see thread-store.ts's analogous note).
-            const rows = await tx
-                .select()
-                .from(automations)
-                .where(and(eq(automations.id, id), eq(automations.tenantId, scope.tenantId), eq(automations.subject, scope.subject)))
-                .for("update");
-            if (!rows[0])
-                throw new Error(`automation "${id}" not found`);
-            const automation = rowToAutomation(rows[0]);
-            const nextVersion = automation.currentVersion + 1;
-            const version = {
-                automationId: id,
-                version: nextVersion,
-                spec: input.spec,
-                dslVersion: input.spec.dslVersion,
-                manifestHash: input.manifestHash ?? null,
-                grants: input.grants,
-                createdBy: input.createdBy,
-                createdAt: now,
-            };
-            const updated = {
-                ...automation,
-                name: input.spec.name,
-                spec: input.spec,
-                currentVersion: nextVersion,
-                triggerKind: kind,
-                triggerKey: key,
-                updatedAt: now,
-            };
-            await tx.insert(automationVersions).values({
-                automationId: id,
-                version: nextVersion,
-                spec: input.spec,
-                dslVersion: input.spec.dslVersion,
-                manifestHash: version.manifestHash,
-                grants: input.grants,
-                createdBy: input.createdBy,
-                createdAt: now,
-            });
-            await tx
-                .update(automations)
-                .set({
-                name: updated.name,
-                spec: input.spec,
-                currentVersion: nextVersion,
-                triggerKind: kind,
-                triggerKey: key,
-                updatedAt: now,
-            })
-                .where(and(eq(automations.id, id), eq(automations.tenantId, scope.tenantId), eq(automations.subject, scope.subject)));
-            return { automation: updated, version };
-        });
-    }
-    async getVersion(scope, id, version) {
-        const owned = await this.get(scope, id);
-        if (!owned)
-            return undefined;
-        const rows = await this.db
-            .select()
-            .from(automationVersions)
-            .where(and(eq(automationVersions.automationId, id), eq(automationVersions.version, version)));
-        return rows[0] ? rowToVersion(rows[0]) : undefined;
-    }
-    async setStatus(scope, id, status, opts) {
-        await this.mustGet(scope, id);
-        const now = this.now();
-        await this.db
-            .update(automations)
-            .set({
-            status,
-            disabledReason: opts?.disabledReason !== undefined ? opts.disabledReason : null,
-            updatedAt: now,
-        })
-            .where(and(eq(automations.id, id), eq(automations.tenantId, scope.tenantId), eq(automations.subject, scope.subject)));
-    }
-    async delete(scope, id) {
-        const owned = await this.get(scope, id);
-        if (!owned)
-            return;
-        await this.db
-            .delete(automations)
-            .where(and(eq(automations.id, id), eq(automations.tenantId, scope.tenantId), eq(automations.subject, scope.subject)));
-    }
-    async findEnabledByTrigger(scope, lookup) {
-        const rows = await this.db
-            .select()
-            .from(automations)
-            .where(and(eq(automations.tenantId, scope.tenantId), eq(automations.subject, scope.subject), eq(automations.status, "enabled"), eq(automations.triggerKind, lookup.kind), lookup.key === null ? isNull(automations.triggerKey) : eq(automations.triggerKey, lookup.key)));
-        return rows.map(rowToAutomation);
-    }
-    async createRun(scope, input) {
-        const id = firingRunId(input.automation.id, input.envelope.source, input.envelope.eventId);
-        const versionRow = await this.getVersion(scope, input.automation.id, input.version);
-        const now = this.now();
-        const trigger = capEnvelope(input.envelope);
-        const run = {
-            id,
-            automationId: input.automation.id,
-            version: input.version,
-            manifestHash: versionRow?.manifestHash ?? null,
-            tenantId: scope.tenantId,
-            subject: scope.subject,
-            status: "running",
-            trigger,
-            steps: [],
-            isTest: input.isTest,
-            parkedCount: 0,
-            startedAt: now,
-        };
-        try {
-            await this.db.insert(automationRuns).values({
-                id: run.id,
-                automationId: run.automationId,
-                tenantId: run.tenantId,
-                subject: run.subject,
-                version: run.version,
-                manifestHash: run.manifestHash,
-                status: run.status,
-                outcome: null,
-                trigger: run.trigger,
-                steps: run.steps,
-                pendingApproval: null,
-                error: null,
-                isTest: run.isTest,
-                parkedCount: 0,
-                startedAt: now,
-                finishedAt: null,
-            });
-        }
-        catch (err) {
-            if (isUniqueViolation(err))
-                throw new DuplicateRunError(id);
-            throw err;
-        }
-        return run;
-    }
-    async updateRun(scope, id, patch) {
-        const run = await this.mustGetRun(scope, id);
-        const steps = patch.steps ? patch.steps.map(capStep) : run.steps;
-        const status = patch.outcome === "waiting_approval" ? "running" : run.status;
-        const next = { ...run, ...patch, status, steps };
-        await this.db
-            .update(automationRuns)
-            .set({
-            status: next.status,
-            outcome: next.outcome ?? null,
-            steps: next.steps,
-            pendingApproval: next.pendingApproval ?? null,
-            error: next.error ?? null,
-            parkedCount: next.parkedCount,
-        })
-            .where(and(eq(automationRuns.id, id), eq(automationRuns.tenantId, scope.tenantId), eq(automationRuns.subject, scope.subject)));
-        return next;
-    }
-    async finalizeRun(scope, id, input) {
-        const now = this.now();
-        return this.withTransaction(async (tx) => {
-            const runRows = await tx
-                .select()
-                .from(automationRuns)
-                .where(and(eq(automationRuns.id, id), eq(automationRuns.tenantId, scope.tenantId), eq(automationRuns.subject, scope.subject)));
-            const existing = runRows[0];
-            if (!existing)
-                throw new Error(`run "${id}" not found`);
-            const run = rowToRun(existing);
-            const status = coarseStatus(input);
-            // Skipped runs stay compact: no steps array is stored for them.
-            const steps = input.outcome === "skipped" ? [] : (input.steps ?? run.steps).map(capStep);
-            const finalized = {
-                ...run,
-                status,
-                outcome: input.outcome,
-                steps,
-                error: input.error,
-                finishedAt: now,
-                parkedCount: input.parkedCount ?? run.parkedCount,
-            };
-            delete finalized.pendingApproval;
-            await tx
-                .update(automationRuns)
-                .set({
-                status,
-                outcome: input.outcome ?? null,
-                steps,
-                error: input.error ?? null,
-                pendingApproval: null,
-                finishedAt: now,
-                parkedCount: finalized.parkedCount,
-            })
-                .where(eq(automationRuns.id, id));
-            // Counters update commits in the SAME transaction as the run write.
-            const automationRows = await tx
-                .select()
-                .from(automations)
-                .where(and(eq(automations.id, run.automationId), eq(automations.tenantId, scope.tenantId), eq(automations.subject, scope.subject)));
-            const automationRow = automationRows[0];
-            if (automationRow) {
-                const automation = rowToAutomation(automationRow);
-                // Only clean successes and real failures move the streak; refined
-                // outcomes (skipped/cancelled) never count as failures.
-                const failed = status === "failed" && input.outcome === undefined;
-                const succeeded = status === "succeeded" && input.outcome === undefined;
-                const counters = {
-                    totalRuns: automation.counters.totalRuns + 1,
-                    totalFailures: automation.counters.totalFailures + (failed ? 1 : 0),
-                    consecutiveFailures: failed
-                        ? automation.counters.consecutiveFailures + 1
-                        : succeeded
-                            ? 0
-                            : automation.counters.consecutiveFailures,
-                    lastRunAt: now,
-                    lastStatus: input.outcome ?? status,
-                };
-                await tx.update(automations).set({ counters, updatedAt: now }).where(eq(automations.id, automation.id));
-            }
-            return finalized;
-        });
-    }
-    async getRun(scope, id) {
-        const rows = await this.db
-            .select()
-            .from(automationRuns)
-            .where(and(eq(automationRuns.id, id), eq(automationRuns.tenantId, scope.tenantId), eq(automationRuns.subject, scope.subject)));
-        return rows[0] ? rowToRun(rows[0]) : undefined;
-    }
-    /** Capture-then-clear in ONE statement (a plain `RETURNING pending_approval`
-     *  after an `UPDATE … SET pending_approval = NULL` returns the new NULL,
-     *  not the value it cleared) — `FOR UPDATE SKIP LOCKED` makes exactly one
-     *  concurrent caller win. */
-    async claimPendingApproval(scope, runId) {
-        const result = await this.db.execute(sql `
-      WITH claimed AS (
-        SELECT id, pending_approval FROM vendo.automation_runs
-        WHERE id = ${runId} AND tenant_id = ${scope.tenantId} AND subject = ${scope.subject}
-          AND pending_approval IS NOT NULL
-        FOR UPDATE SKIP LOCKED
-      )
-      UPDATE vendo.automation_runs r
-      SET pending_approval = NULL
-      FROM claimed
-      WHERE r.id = claimed.id
-      RETURNING claimed.pending_approval AS claimed_approval
-    `);
-        const rows = result.rows;
-        const row = rows[0];
-        if (!row || row.claimed_approval == null)
-            return undefined;
-        return row.claimed_approval;
-    }
-    async cancelPendingRuns(scope, automationId) {
-        const now = this.now();
-        await this.db
-            .update(automationRuns)
-            .set({
-            status: "failed",
-            outcome: "cancelled",
-            pendingApproval: null,
-            finishedAt: now,
-        })
-            .where(and(eq(automationRuns.automationId, automationId), eq(automationRuns.tenantId, scope.tenantId), eq(automationRuns.subject, scope.subject), eq(automationRuns.outcome, "waiting_approval")));
-    }
-    async listEnabledSchedules() {
-        const rows = await this.db
-            .select()
-            .from(automations)
-            .where(and(eq(automations.status, "enabled"), eq(automations.triggerKind, "schedule")));
-        return rows.map((row) => {
-            const automation = rowToAutomation(row);
-            return {
-                automationId: automation.id,
-                trigger: automation.spec.trigger,
-                principal: { tenantId: automation.tenantId, subject: automation.subject },
-            };
-        });
-    }
-    // -------------------------------------------------------------------------
-    // Parked actions (ENG-193 §4.6) — durable port of the in-memory semantics:
-    // frozen capped input, 7-day TTL swept lazily by list (every surface reads
-    // through list), single-resolution invariant enforced at resolve time.
-    // -------------------------------------------------------------------------
-    async createParkedAction(scope, input) {
-        const id = `parked-${randomUUID()}`;
-        const { input: cappedInput, truncated, bytes } = capParkedInput(input.input);
-        const action = {
-            id,
-            tenantId: scope.tenantId,
-            subject: scope.subject,
-            automationId: input.automationId,
-            runId: input.runId,
-            stepId: input.stepId,
-            tool: input.tool,
-            input: cappedInput,
-            ...(truncated ? { inputTruncated: true, inputBytes: bytes } : {}),
-            ...(input.guardExpr !== undefined ? { guardExpr: input.guardExpr } : {}),
-            ...(input.guardBindings !== undefined ? { guardBindings: input.guardBindings } : {}),
-            reason: input.reason,
-            tier: input.tier,
-            descriptorHash: input.descriptorHash,
-            requestedAt: input.requestedAt,
-        };
-        await this.db.insert(parkedActions).values({
-            id,
-            tenantId: scope.tenantId,
-            subject: scope.subject,
-            automationId: input.automationId,
-            runId: input.runId,
-            resolution: null,
-            requestedAt: input.requestedAt,
-            record: action,
-        });
-        return action;
-    }
-    async listParkedActions(scope, filter) {
-        // Lazy expiry sweep (mirrors InMemoryAutomationStore): stale parked
-        // intent must never surface as approvable — 7-day TTL matching
-        // PendingApproval's. The sweep is a single UPDATE over this scope's
-        // expired-but-unresolved rows.
-        const now = this.now();
-        const cutoff = new Date(Date.parse(now) - PARKED_ACTION_TTL_MS).toISOString();
-        const expiredRows = await this.db
-            .select()
-            .from(parkedActions)
-            .where(and(eq(parkedActions.tenantId, scope.tenantId), eq(parkedActions.subject, scope.subject), isNull(parkedActions.resolution), sql `${parkedActions.requestedAt} <= ${cutoff}`));
-        for (const row of expiredRows) {
-            const expired = { ...row.record, resolution: "expired", resolvedAt: now };
-            await this.db
-                .update(parkedActions)
-                .set({ resolution: "expired", record: expired })
-                .where(and(eq(parkedActions.id, row.id), isNull(parkedActions.resolution)));
-        }
-        const rows = await this.db
-            .select()
-            .from(parkedActions)
-            .where(and(eq(parkedActions.tenantId, scope.tenantId), eq(parkedActions.subject, scope.subject), ...(filter.automationId !== undefined ? [eq(parkedActions.automationId, filter.automationId)] : []), ...(filter.runId !== undefined ? [eq(parkedActions.runId, filter.runId)] : []), ...(filter.unresolvedOnly === true ? [isNull(parkedActions.resolution)] : [])));
-        return rows.map((row) => row.record);
-    }
-    async getParkedAction(scope, id) {
-        const rows = await this.db
-            .select()
-            .from(parkedActions)
-            .where(and(eq(parkedActions.id, id), eq(parkedActions.tenantId, scope.tenantId), eq(parkedActions.subject, scope.subject)));
-        const row = rows[0];
-        return row ? row.record : undefined;
-    }
-    async resolveParkedAction(scope, id, resolution, resolvedAt) {
-        return this.withTransaction(async (tx) => {
-            const rows = await tx
-                .select()
-                .from(parkedActions)
-                .where(and(eq(parkedActions.id, id), eq(parkedActions.tenantId, scope.tenantId), eq(parkedActions.subject, scope.subject)))
-                .for("update");
-            const row = rows[0];
-            if (!row)
-                throw new Error(`parked action "${id}" not found`);
-            const action = row.record;
-            if (action.resolution !== undefined) {
-                throw new Error(`parked action "${id}" is already resolved (${action.resolution})`);
-            }
-            const next = { ...action, resolution, resolvedAt };
-            await tx
-                .update(parkedActions)
-                .set({ resolution, record: next })
-                .where(eq(parkedActions.id, id));
-            return next;
-        });
-    }
-    async mustGet(scope, id) {
-        const automation = await this.get(scope, id);
-        if (!automation)
-            throw new Error(`automation "${id}" not found`);
-        return automation;
-    }
-    async mustGetRun(scope, id) {
-        const run = await this.getRun(scope, id);
-        if (!run)
-            throw new Error(`run "${id}" not found`);
-        return run;
-    }
-}