@vendoai/store 0.1.0

package/dist/schema.js

@@ -0,0 +1,114 @@
+import { pgSchema, text, integer, boolean, jsonb, timestamp, primaryKey, uniqueIndex, index, bigserial } from "drizzle-orm/pg-core";
+export const vendo = pgSchema("vendo");
+export const automations = vendo.table("automations", {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    subject: text("subject").notNull(),
+    name: text("name").notNull(),
+    status: text("status").notNull(),
+    disabledReason: text("disabled_reason"),
+    spec: jsonb("spec").notNull(),
+    currentVersion: integer("current_version").notNull(),
+    triggerKind: text("trigger_kind").notNull(),
+    triggerKey: text("trigger_key"),
+    counters: jsonb("counters").notNull(),
+    createdFromThreadId: text("created_from_thread_id"),
+    createdAt: timestamp("created_at", { withTimezone: true, mode: "string" }).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true, mode: "string" }).notNull(),
+}, (t) => [index("automations_scope_idx").on(t.tenantId, t.subject), index("automations_trigger_idx").on(t.triggerKind, t.triggerKey)]);
+export const automationVersions = vendo.table("automation_versions", {
+    automationId: text("automation_id").notNull(),
+    version: integer("version").notNull(),
+    spec: jsonb("spec").notNull(),
+    dslVersion: integer("dsl_version").notNull(),
+    manifestHash: text("manifest_hash"),
+    grants: jsonb("grants").notNull(),
+    createdBy: text("created_by").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true, mode: "string" }).notNull(),
+}, (t) => [primaryKey({ columns: [t.automationId, t.version] })]);
+export const automationRuns = vendo.table("automation_runs", {
+    id: text("id").primaryKey(), // firingRunId — DB-level double-fire dedup
+    automationId: text("automation_id").notNull(),
+    tenantId: text("tenant_id").notNull(),
+    subject: text("subject").notNull(),
+    version: integer("version").notNull(),
+    manifestHash: text("manifest_hash"),
+    status: text("status").notNull(),
+    outcome: text("outcome"),
+    trigger: jsonb("trigger").notNull(),
+    steps: jsonb("steps").notNull(),
+    pendingApproval: jsonb("pending_approval"),
+    error: text("error"),
+    isTest: boolean("is_test").notNull(),
+    /** ENG-193 §4.6 — cumulative count of parked actions this run created. */
+    parkedCount: integer("parked_count").notNull().default(0),
+    startedAt: timestamp("started_at", { withTimezone: true, mode: "string" }).notNull(),
+    finishedAt: timestamp("finished_at", { withTimezone: true, mode: "string" }),
+}, (t) => [index("runs_automation_idx").on(t.automationId, t.tenantId, t.subject)]);
+/** ENG-193 §4.6 — parked automation drafts: an action a for_each iteration or
+ *  agent step couldn't run unattended, resolved standalone later. Indexed
+ *  columns cover the list filters; the full ParkedAction payload (frozen
+ *  input, guard bindings, tier, hashes, resolution detail) lives in `record`
+ *  jsonb, mirrored the way `saved_vendos.record` already is. */
+export const parkedActions = vendo.table("parked_actions", {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    subject: text("subject").notNull(),
+    automationId: text("automation_id").notNull(),
+    runId: text("run_id").notNull(),
+    resolution: text("resolution"),
+    requestedAt: timestamp("requested_at", { withTimezone: true, mode: "string" }).notNull(),
+    record: jsonb("record").notNull(),
+}, (t) => [index("parked_actions_scope_idx").on(t.tenantId, t.subject, t.automationId, t.runId)]);
+export const decisions = vendo.table("decisions", {
+    tenantId: text("tenant_id").notNull(),
+    subject: text("subject").notNull(),
+    canonicalKey: text("canonical_key").notNull(),
+    decision: jsonb("decision").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true, mode: "string" }).notNull(),
+}, (t) => [primaryKey({ columns: [t.tenantId, t.subject, t.canonicalKey] })]);
+export const threads = vendo.table("threads", {
+    id: text("id").notNull(),
+    tenantId: text("tenant_id").notNull(),
+    subject: text("subject").notNull(),
+    title: text("title"),
+    nextSeq: integer("next_seq").notNull().default(0),
+    createdAt: timestamp("created_at", { withTimezone: true, mode: "string" }).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true, mode: "string" }).notNull(),
+}, (t) => [primaryKey({ columns: [t.tenantId, t.subject, t.id] })]);
+export const threadMessages = vendo.table("thread_messages", {
+    rowId: bigserial("row_id", { mode: "number" }).primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    subject: text("subject").notNull(),
+    threadId: text("thread_id").notNull(),
+    messageId: text("message_id").notNull(),
+    seq: integer("seq").notNull(),
+    message: jsonb("message").notNull(),
+}, (t) => [
+    uniqueIndex("thread_messages_id_uq").on(t.tenantId, t.subject, t.threadId, t.messageId),
+    uniqueIndex("thread_messages_seq_uq").on(t.tenantId, t.subject, t.threadId, t.seq),
+]);
+export const savedVendos = vendo.table("saved_vendos", {
+    id: text("id").notNull(),
+    tenantId: text("tenant_id").notNull(),
+    subject: text("subject").notNull(),
+    record: jsonb("record").notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true, mode: "string" }).notNull(),
+}, (t) => [primaryKey({ columns: [t.tenantId, t.subject, t.id] })]);
+export const connections = vendo.table("connections", {
+    toolkit: text("toolkit").notNull(),
+    tenantId: text("tenant_id").notNull(),
+    subject: text("subject").notNull(),
+    connectedAccountId: text("connected_account_id"),
+    status: text("status").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true, mode: "string" }).notNull(),
+}, (t) => [
+    primaryKey({ columns: [t.tenantId, t.subject, t.toolkit] }),
+    index("connections_account_idx").on(t.connectedAccountId),
+]);
+/** Tiny operational KV (scheduler heartbeat, future flags). NOT for domain data. */
+export const meta = vendo.table("meta", {
+    key: text("key").primaryKey(),
+    value: jsonb("value").notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true, mode: "string" }).notNull(),
+});

package/dist/thread-store.d.ts

@@ -0,0 +1,5 @@
+import type { ThreadStore } from "@vendoai/core";
+import type { VendoDb } from "./db.js";
+export declare function createDrizzleThreadStore(handle: VendoDb, opts?: {
+    now?: () => string;
+}): ThreadStore;

package/dist/thread-store.js

@@ -0,0 +1,209 @@
+/**
+ * DrizzleThreadStore — durable port of the core `ThreadStore` seam
+ * (packages/vendo-core/src/seams/store.ts). Behavioral spec:
+ * InMemoryThreadStore (packages/vendo-runtime/src/embedded/in-memory-store.ts).
+ *
+ * Seq allocation is race-safe: `threads.nextSeq` is reserved with an atomic
+ * `UPDATE ... SET next_seq = next_seq + n RETURNING next_seq` inside a
+ * transaction, never `MAX(seq)+1` (which double-allocates under concurrency —
+ * see the Task 9 plan note). `upsertMessages` reserves seqs ONLY for messages
+ * that are genuinely new; pre-existing message ids are updated in place
+ * (message column only — their seq, and therefore position, never moves).
+ * Existing-vs-new is resolved inside the same transaction as the reservation,
+ * so two concurrent upserts of disjoint message ids always get disjoint seq
+ * ranges without ever touching the `thread_messages_seq_uq` index twice for
+ * the same value (a single INSERT ... ON CONFLICT covering both new and
+ * pre-existing rows would risk exactly that: passing an existing row's own
+ * seq back through the VALUES list can collide with the seq-uniqueness index,
+ * which isn't the ON CONFLICT arbiter and so isn't suppressed — Postgres still
+ * raises 23505 for a violation on a non-arbiter unique index. Splitting the
+ * write into "plain UPDATE for existing ids" + "plain INSERT of freshly
+ * reserved seqs for new ids" avoids that path entirely.)
+ *
+ * Remaining race: two CONCURRENT txns can both run their existing-ids SELECT
+ * before either commits and both classify the SAME message id as "new" —
+ * each reserves its own seq block and both attempt to INSERT that message
+ * id. The new-row INSERT below carries an `ON CONFLICT (tenant_id, subject,
+ * thread_id, message_id) DO UPDATE` naming that exact unique index as its
+ * arbiter, so the loser's insert becomes an UPDATE of the winner's row
+ * (message content only) instead of a 23505 unique-violation. The loser's
+ * reserved seq is simply never used — a benign gap in the sequence, not a
+ * correctness issue (seq only needs to be strictly ordered, not contiguous).
+ */
+import { randomUUID } from "node:crypto";
+import { and, eq, inArray, sql } from "drizzle-orm";
+import { threadMessages, threads } from "./schema.js";
+import { toIso } from "./automation-store.js";
+function rowToThread(row) {
+    const record = {
+        id: row.id,
+        tenantId: row.tenantId,
+        subject: row.subject,
+        createdAt: toIso(row.createdAt),
+        updatedAt: toIso(row.updatedAt),
+    };
+    if (row.title != null)
+        record.title = row.title;
+    return record;
+}
+export function createDrizzleThreadStore(handle, opts = {}) {
+    const db = handle.db;
+    const now = opts.now ?? (() => new Date().toISOString());
+    function withTransaction(fn) {
+        return handle.db.transaction((tx) => fn(tx));
+    }
+    async function selectThreadRow(tx, scope, threadId) {
+        const rows = await tx
+            .select()
+            .from(threads)
+            .where(and(eq(threads.tenantId, scope.tenantId), eq(threads.subject, scope.subject), eq(threads.id, threadId)));
+        return rows[0];
+    }
+    /** Atomically reserves `n` seqs on the thread row and returns the first one
+     *  in the reserved block. Raw SQL (like `claimPendingApproval` in
+     *  automation-store.ts) because drizzle's `.returning()` doesn't type-check
+     *  cleanly against the pglite/node-postgres union `Db` bridge type. */
+    async function reserveSeqs(tx, scope, threadId, n, at) {
+        const result = await tx.execute(sql `
+      UPDATE vendo.threads
+      SET next_seq = next_seq + ${n}, updated_at = ${at}
+      WHERE tenant_id = ${scope.tenantId} AND subject = ${scope.subject} AND id = ${threadId}
+      RETURNING next_seq
+    `);
+        const rows = result.rows;
+        const reserved = rows[0]?.next_seq ?? n;
+        return reserved - n;
+    }
+    return {
+        async create(scope, init = {}) {
+            const id = randomUUID();
+            const createdAt = now();
+            await db.insert(threads).values({
+                id,
+                tenantId: scope.tenantId,
+                subject: scope.subject,
+                title: init.title ?? null,
+                nextSeq: 0,
+                createdAt,
+                updatedAt: createdAt,
+            });
+            const record = {
+                id,
+                tenantId: scope.tenantId,
+                subject: scope.subject,
+                createdAt,
+                updatedAt: createdAt,
+            };
+            if (init.title !== undefined)
+                record.title = init.title;
+            return record;
+        },
+        async get(scope, threadId) {
+            const row = await selectThreadRow(db, scope, threadId);
+            return row ? rowToThread(row) : undefined;
+        },
+        async list(scope) {
+            const rows = await db
+                .select()
+                .from(threads)
+                .where(and(eq(threads.tenantId, scope.tenantId), eq(threads.subject, scope.subject)));
+            return rows.map(rowToThread);
+        },
+        async appendMessages(scope, threadId, messages) {
+            const owned = await selectThreadRow(db, scope, threadId);
+            if (!owned) {
+                throw new Error(`unknown thread "${threadId}" for scope ${scope.tenantId}/${scope.subject}`);
+            }
+            if (messages.length === 0)
+                return;
+            await withTransaction(async (tx) => {
+                const at = now();
+                const startSeq = await reserveSeqs(tx, scope, threadId, messages.length, at);
+                await tx.insert(threadMessages).values(messages.map((m, i) => ({
+                    tenantId: scope.tenantId,
+                    subject: scope.subject,
+                    threadId,
+                    messageId: m.id,
+                    seq: startSeq + i,
+                    message: m,
+                })));
+            });
+        },
+        async getMessages(scope, threadId) {
+            const rows = await db
+                .select()
+                .from(threadMessages)
+                .where(and(eq(threadMessages.tenantId, scope.tenantId), eq(threadMessages.subject, scope.subject), eq(threadMessages.threadId, threadId)))
+                .orderBy(threadMessages.seq);
+            return rows.map((row) => row.message);
+        },
+        async upsertMessages(scope, threadId, messages) {
+            if (messages.length === 0)
+                return;
+            await withTransaction(async (tx) => {
+                const at = now();
+                const existingThread = await selectThreadRow(tx, scope, threadId);
+                if (!existingThread) {
+                    // The client owns thread ids for upsert (ai-SDK resume writes before
+                    // any explicit create() call) — an unrecognized threadId is a
+                    // first-write, not an error. `onConflictDoNothing` guards the (rare)
+                    // race of two concurrent first-writes to the same unknown id.
+                    await tx
+                        .insert(threads)
+                        .values({
+                        id: threadId,
+                        tenantId: scope.tenantId,
+                        subject: scope.subject,
+                        nextSeq: 0,
+                        createdAt: at,
+                        updatedAt: at,
+                    })
+                        .onConflictDoNothing();
+                }
+                const ids = messages.map((m) => m.id);
+                const existingRows = await tx
+                    .select({ messageId: threadMessages.messageId })
+                    .from(threadMessages)
+                    .where(and(eq(threadMessages.tenantId, scope.tenantId), eq(threadMessages.subject, scope.subject), eq(threadMessages.threadId, threadId), inArray(threadMessages.messageId, ids)));
+                const existingIds = new Set(existingRows.map((r) => r.messageId));
+                const existingMessages = messages.filter((m) => existingIds.has(m.id));
+                const newMessages = messages.filter((m) => !existingIds.has(m.id));
+                // Update pre-existing rows in place: message column only, seq (and
+                // therefore position) is never touched.
+                for (const m of existingMessages) {
+                    await tx
+                        .update(threadMessages)
+                        .set({ message: m })
+                        .where(and(eq(threadMessages.tenantId, scope.tenantId), eq(threadMessages.subject, scope.subject), eq(threadMessages.threadId, threadId), eq(threadMessages.messageId, m.id)));
+                }
+                if (newMessages.length > 0) {
+                    const startSeq = await reserveSeqs(tx, scope, threadId, newMessages.length, at);
+                    await tx
+                        .insert(threadMessages)
+                        .values(newMessages.map((m, i) => ({
+                        tenantId: scope.tenantId,
+                        subject: scope.subject,
+                        threadId,
+                        messageId: m.id,
+                        seq: startSeq + i,
+                        message: m,
+                    })))
+                        // Concurrent-same-new-message race: see the module doc. The
+                        // arbiter is the message-id unique index, not the seq one, so
+                        // this can never suppress a genuine seq collision.
+                        .onConflictDoUpdate({
+                        target: [threadMessages.tenantId, threadMessages.subject, threadMessages.threadId, threadMessages.messageId],
+                        set: { message: sql `excluded.message` },
+                    });
+                }
+                else {
+                    // Still bump updatedAt even when nothing new was reserved.
+                    await tx
+                        .update(threads)
+                        .set({ updatedAt: at })
+                        .where(and(eq(threads.tenantId, scope.tenantId), eq(threads.subject, scope.subject), eq(threads.id, threadId)));
+                }
+            });
+        },
+    };
+}

package/dist/vendo-registry.d.ts

@@ -0,0 +1,5 @@
+import type { SavedVendoStore } from "@vendoai/core";
+import type { VendoDb } from "./db.js";
+export declare function createDrizzleSavedVendoStore(handle: VendoDb, opts?: {
+    now?: () => string;
+}): SavedVendoStore;

package/dist/vendo-registry.js

@@ -0,0 +1,52 @@
+/**
+ * DrizzleSavedVendoStore — durable port of the core `SavedVendoStore`
+ * seam (packages/vendo-core/src/seams/store.ts). Behavioral spec:
+ * InMemorySavedVendoStore (packages/vendo-runtime/src/embedded/in-memory-store.ts).
+ *
+ * The whole `SavedVendo` record (uiTree, query, originatingPrompt, etc.)
+ * lives verbatim in the `record` jsonb column; `updatedAt` is denormalized
+ * onto its own column purely so `list()` can order by it without unpacking
+ * jsonb per row.
+ */
+import { randomUUID } from "node:crypto";
+import { and, desc, eq } from "drizzle-orm";
+import { savedVendos } from "./schema.js";
+export function createDrizzleSavedVendoStore(handle, opts = {}) {
+    const db = handle.db;
+    const now = opts.now ?? (() => new Date().toISOString());
+    return {
+        async save(scope, vendo) {
+            const id = randomUUID();
+            const createdAt = now();
+            const record = { ...vendo, id, createdAt, updatedAt: createdAt };
+            await db.insert(savedVendos).values({
+                id,
+                tenantId: scope.tenantId,
+                subject: scope.subject,
+                record,
+                updatedAt: createdAt,
+            });
+            return record;
+        },
+        async get(scope, id) {
+            const rows = await db
+                .select()
+                .from(savedVendos)
+                .where(and(eq(savedVendos.tenantId, scope.tenantId), eq(savedVendos.subject, scope.subject), eq(savedVendos.id, id)));
+            return rows[0] ? rows[0].record : undefined;
+        },
+        async list(scope) {
+            const rows = await db
+                .select()
+                .from(savedVendos)
+                .where(and(eq(savedVendos.tenantId, scope.tenantId), eq(savedVendos.subject, scope.subject)))
+                .orderBy(desc(savedVendos.updatedAt));
+            return rows.map((row) => row.record);
+        },
+        async delete(scope, id) {
+            await db
+                .delete(savedVendos)
+                .where(and(eq(savedVendos.tenantId, scope.tenantId), eq(savedVendos.subject, scope.subject), eq(savedVendos.id, id)));
+        },
+    };
+}

package/migrations/0000_living_kate_bishop.sql

@@ -0,0 +1,110 @@
+CREATE SCHEMA IF NOT EXISTS "vendo";
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "vendo"."automation_runs" (
+	"id" text PRIMARY KEY NOT NULL,
+	"automation_id" text NOT NULL,
+	"tenant_id" text NOT NULL,
+	"subject" text NOT NULL,
+	"version" integer NOT NULL,
+	"manifest_hash" text,
+	"status" text NOT NULL,
+	"outcome" text,
+	"trigger" jsonb NOT NULL,
+	"steps" jsonb NOT NULL,
+	"pending_approval" jsonb,
+	"error" text,
+	"is_test" boolean NOT NULL,
+	"started_at" timestamp with time zone NOT NULL,
+	"finished_at" timestamp with time zone
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "vendo"."automation_versions" (
+	"automation_id" text NOT NULL,
+	"version" integer NOT NULL,
+	"spec" jsonb NOT NULL,
+	"dsl_version" integer NOT NULL,
+	"manifest_hash" text,
+	"grants" jsonb NOT NULL,
+	"created_by" text NOT NULL,
+	"created_at" timestamp with time zone NOT NULL,
+	CONSTRAINT "automation_versions_automation_id_version_pk" PRIMARY KEY("automation_id","version")
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "vendo"."automations" (
+	"id" text PRIMARY KEY NOT NULL,
+	"tenant_id" text NOT NULL,
+	"subject" text NOT NULL,
+	"name" text NOT NULL,
+	"status" text NOT NULL,
+	"disabled_reason" text,
+	"spec" jsonb NOT NULL,
+	"current_version" integer NOT NULL,
+	"trigger_kind" text NOT NULL,
+	"trigger_key" text,
+	"counters" jsonb NOT NULL,
+	"created_from_thread_id" text,
+	"created_at" timestamp with time zone NOT NULL,
+	"updated_at" timestamp with time zone NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "vendo"."connections" (
+	"toolkit" text NOT NULL,
+	"tenant_id" text NOT NULL,
+	"subject" text NOT NULL,
+	"connected_account_id" text,
+	"status" text NOT NULL,
+	"created_at" timestamp with time zone NOT NULL,
+	CONSTRAINT "connections_tenant_id_subject_toolkit_pk" PRIMARY KEY("tenant_id","subject","toolkit")
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "vendo"."decisions" (
+	"tenant_id" text NOT NULL,
+	"subject" text NOT NULL,
+	"canonical_key" text NOT NULL,
+	"decision" jsonb NOT NULL,
+	"created_at" timestamp with time zone NOT NULL,
+	CONSTRAINT "decisions_tenant_id_subject_canonical_key_pk" PRIMARY KEY("tenant_id","subject","canonical_key")
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "vendo"."meta" (
+	"key" text PRIMARY KEY NOT NULL,
+	"value" jsonb NOT NULL,
+	"updated_at" timestamp with time zone NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "vendo"."saved_vendos" (
+	"id" text NOT NULL,
+	"tenant_id" text NOT NULL,
+	"subject" text NOT NULL,
+	"record" jsonb NOT NULL,
+	"updated_at" timestamp with time zone NOT NULL,
+	CONSTRAINT "saved_vendos_tenant_id_subject_id_pk" PRIMARY KEY("tenant_id","subject","id")
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "vendo"."thread_messages" (
+	"row_id" bigserial PRIMARY KEY NOT NULL,
+	"tenant_id" text NOT NULL,
+	"subject" text NOT NULL,
+	"thread_id" text NOT NULL,
+	"message_id" text NOT NULL,
+	"seq" integer NOT NULL,
+	"message" jsonb NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "vendo"."threads" (
+	"id" text NOT NULL,
+	"tenant_id" text NOT NULL,
+	"subject" text NOT NULL,
+	"title" text,
+	"next_seq" integer DEFAULT 0 NOT NULL,
+	"created_at" timestamp with time zone NOT NULL,
+	"updated_at" timestamp with time zone NOT NULL,
+	CONSTRAINT "threads_tenant_id_subject_id_pk" PRIMARY KEY("tenant_id","subject","id")
+);
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "runs_automation_idx" ON "vendo"."automation_runs" USING btree ("automation_id","tenant_id","subject");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "automations_scope_idx" ON "vendo"."automations" USING btree ("tenant_id","subject");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "automations_trigger_idx" ON "vendo"."automations" USING btree ("trigger_kind","trigger_key");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "connections_account_idx" ON "vendo"."connections" USING btree ("connected_account_id");--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS "thread_messages_id_uq" ON "vendo"."thread_messages" USING btree ("tenant_id","subject","thread_id","message_id");--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS "thread_messages_seq_uq" ON "vendo"."thread_messages" USING btree ("tenant_id","subject","thread_id","seq");

package/migrations/0001_brainy_tinkerer.sql

@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS "vendo"."parked_actions" (
+	"id" text PRIMARY KEY NOT NULL,
+	"tenant_id" text NOT NULL,
+	"subject" text NOT NULL,
+	"automation_id" text NOT NULL,
+	"run_id" text NOT NULL,
+	"resolution" text,
+	"requested_at" timestamp with time zone NOT NULL,
+	"record" jsonb NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "vendo"."automation_runs" ADD COLUMN "parked_count" integer DEFAULT 0 NOT NULL;--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "parked_actions_scope_idx" ON "vendo"."parked_actions" USING btree ("tenant_id","subject","automation_id","run_id");