@tangen/db 0.0.0-stage → 0.1.55

package/src/schema/ai-chats.ts

@@ -0,0 +1,36 @@
+/**
+ * File Name: ai-chats.ts
+ * Purpose: Drizzle schema for the `ai_chats` table — Gen AI conversation
+ *          threads. A member can keep several threads per content object
+ *          (workspace + env + type + id), listed by recency in the panel.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: messages is a capped jsonb array; threads per scope are
+ *          capped and member-private (see routes/ai/chats.ts).
+ */
+import { pgTable, text, timestamp, jsonb, index } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+/**
+ * Gen AI conversation threads — several rows per content object per member.
+ */
+export const aiChats = pgTable(
+  'ai_chats',
+  {
+    id: text('id').primaryKey(),
+    workspaceId: text('workspace_id').notNull(),
+    objectType: text('object_type').notNull(),
+    objectId: text('object_id').notNull(),
+    /** Conversations are private — every query is member-scoped. */
+    memberId: text('member_id').notNull(),
+    /** Thread label shown in the picker; derived from the first user message. */
+    title: text('title'),
+    messages: jsonb('messages').notNull().default(sql`'[]'`),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => ({
+    aiChatsScopeIdx: index('ai_chats_scope_idx').on(t.workspaceId, t.objectType, t.objectId, t.memberId),
+  }),
+)

package/src/schema/ai-settings.ts

@@ -0,0 +1,24 @@
+/**
+ * File Name: ai-settings.ts
+ * Purpose: Drizzle schema for the `ai_settings` table — one row per workspace
+ *          holding the admin-editable Content AI configuration (chosen provider
+ *          and model, title-generation toggle, and content guidelines).
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: Workspace-scoped by design (guidelines are brand-level and
+ *                     shared across environments). Provider API keys never live
+ *                     here — they are environment/process configuration.
+ */
+import { pgTable, text, timestamp, jsonb } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+/**
+ * Admin-editable Content AI settings, one row per workspace.
+ */
+export const aiSettings = pgTable('ai_settings', {
+  workspaceId: text('workspace_id').primaryKey(),
+  data: jsonb('data').notNull().default(sql`'{}'`),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+})

package/src/schema/api-keys.ts

@@ -0,0 +1,37 @@
+/**
+ * File Name: api-keys.ts
+ * Purpose: Drizzle schema for the `api_keys` table, which stores hashed API credentials
+ *          used by external clients to authenticate against the Tangen REST/GraphQL APIs.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: Keys are stored as SHA-256 hashes (keyHash); only the prefix is
+ *                     stored in plaintext for display. An index on keyHash enables fast
+ *                     lookup during request authentication.
+ */
+import { pgTable, text, timestamp, jsonb, index } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+/**
+ * Stores hashed API keys scoped to a workspace and environment, with permission
+ * grants, optional expiry, and revocation tracking.
+ */
+export const apiKeys = pgTable('api_keys', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  label: text('label').notNull(),
+  keyPrefix: text('key_prefix').notNull(),
+  keyHash: text('key_hash').notNull(),
+  permissions: jsonb('permissions').notNull().default(sql`'{}'`),
+  expiresAt: timestamp('expires_at', { withTimezone: true }),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  createdBy: text('created_by'),
+  /** The identity this key is a credential of (K8); null for a key that acts as itself. */
+  identityId: text('identity_id'),
+  lastUsedAt: timestamp('last_used_at', { withTimezone: true }),
+  revokedAt: timestamp('revoked_at', { withTimezone: true }),
+}, (t) => ({
+  keyHashIdx: index('api_keys_key_hash_idx').on(t.keyHash),
+  identityIdx: index('api_keys_identity_idx').on(t.identityId),
+}))

package/src/schema/audit-log.ts

@@ -0,0 +1,54 @@
+/**
+ * File Name: audit-log.ts
+ * Purpose: Drizzle schema for the `audit_log` table, which records an immutable
+ *          chronological trail of significant events across the workspace.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: A GIN index
+ *                     on payload->>'object_id' should be applied via gin-indexes.sql.
+ */
+import { pgTable, text, timestamp, jsonb, index, boolean } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+/**
+ * Append-only log of workspace events (content changes, schema pushes, member actions, etc.)
+ * indexed by workspace and creation time for chronological queries.
+ */
+export const auditLog = pgTable('audit_log', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  eventType: text('event_type').notNull(),
+  eventId: text('event_id').notNull(),             // cuid2 of the event itself
+  actorId: text('actor_id'),
+  actorType: text('actor_type'),                   // 'member' | 'api_key' (the bus envelope's word)
+  payload: jsonb('payload').notNull(),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  // ── The kernel's event record (K5): the row the domain operations write in their transaction ──
+  /** 'member' | 'api_key' | 'system' | 'site_user' */
+  actorKind: text('actor_kind'),
+  initiatorId: text('initiator_id'),
+  initiatorKind: text('initiator_kind'),
+  /** request | job | flow | scheduler | release | porter | cli | agent */
+  executionKind: text('execution_kind'),
+  executionId: text('execution_id'),
+  correlationId: text('correlation_id'),
+  causationId: text('causation_id'),
+  /** 'object' | 'media' | 'global' | ... */
+  resourceKind: text('resource_kind'),
+  resourceType: text('resource_type'),
+  resourceId: text('resource_id'),
+  locale: text('locale'),
+  /** The transport: admin | rest | sdk | graphql | mcp | extension | scheduler | ... */
+  source: text('source'),
+  /** True when a domain operation wrote this row inside its transaction (false: the bus subscriber's best-effort copy). */
+  recordedInTransaction: boolean('recorded_in_transaction').notNull().default(false),
+}, (t) => ({
+  idxWorkspace: index('audit_log_workspace').on(t.workspaceId, t.createdAt),
+  idxResource: index('audit_log_resource').on(t.workspaceId, t.resourceId, t.createdAt),
+  idxCorrelation: index('audit_log_correlation').on(t.correlationId),
+  // Expression index on payload->>'object_id' — expressed as raw SQL because Drizzle's
+  // IndexBuilderOn.on() expects column refs; a drizzle-kit migration is the canonical
+  // way to add this index in production.
+}))

package/src/schema/connections.ts

@@ -0,0 +1,35 @@
+/**
+ * File Name: connections.ts
+ * Purpose: The `connections` table (Extension Kernel K6.1): an operator's
+ *          credentials for a connector, per workspace, sealed at rest. The
+ *          API reads and writes it through services/connections.ts only.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ */
+import { pgTable, text, jsonb, timestamp, index } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+export const connections = pgTable(
+  'connections',
+  {
+    id: text('id').primaryKey(),
+    workspaceId: text('workspace_id').notNull(),
+    /** `ext:<extension>/<connector>`. */
+    connectorId: text('connector_id').notNull(),
+    label: text('label').notNull(),
+    /** `oauth2` | `apiKey` | `basic`. */
+    kind: text('kind').notNull(),
+    /** The sealed envelope (`v1.<iv>.<tag>.<data>`), never plaintext. */
+    secret: text('secret').notNull(),
+    meta: jsonb('meta').notNull().default(sql`'{}'::jsonb`),
+    /** `active` | `revoked` | `unreadable`. */
+    status: text('status').notNull().default('active'),
+    health: jsonb('health'),
+    createdBy: text('created_by'),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+    lastCheckedAt: timestamp('last_checked_at', { withTimezone: true }),
+  },
+  (t) => ({ workspaceConnector: index('connections_workspace_connector_idx').on(t.workspaceId, t.connectorId) }),
+)

package/src/schema/custom-table-owners.ts

@@ -0,0 +1,32 @@
+/**
+ * File Name: custom-table-owners.ts
+ * Purpose: Who declared each custom table, so ownership survives the extension
+ *   that asked for it.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: Keyed by table name alone, because a physical table is
+ *   instance-global: a second workspace enabling the same extension finds the
+ *   table that is already there rather than creating another. Row data stays
+ *   workspace-scoped; `workspaceId` here records only
+ *   which push first claimed the table, for diagnostics.
+ *
+ *   No row means UNCLAIMED, not unowned. Every custom table older than this
+ *   registry has no row, and an extension declaring such a name is refused
+ *   rather than handed a table full of somebody else's data.
+ */
+import { pgTable, text, timestamp } from 'drizzle-orm/pg-core'
+
+export const customTableOwners = pgTable('custom_table_owners', {
+  tableName: text('table_name').primaryKey(),
+  /** 'site' | 'extension' */
+  ownerKind: text('owner_kind').notNull(),
+  /** The extension id, when ownerKind is 'extension'. */
+  ownerId: text('owner_id'),
+  /** The manifest version the table was last claimed at. */
+  ownerVersion: text('owner_version'),
+  workspaceId: text('workspace_id'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+})

package/src/schema/delivery-artifacts.ts

@@ -0,0 +1,33 @@
+/**
+ * File Name: delivery-artifacts.ts
+ * Purpose: The delivery_artifacts table - where published Studio artifacts
+ *          (page and stylesheet builds, route pointers) live.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: Platform-owned on purpose: the public delivery route
+ *          reads this table whether or not Studio is installed, which is the
+ *          guarantee that a published page never goes down with the
+ *          extension. Artifacts used to live in extension_data, the shared
+ *          extension KV table, and were the wrong shape for it - immutable,
+ *          never deleted, unbounded. One row per (workspace, env, path).
+ *          Build rows (tangen/builds/<version>/...) are content-addressed
+ *          and immutable; pointer rows (tangen/routes/<route>.json) are the
+ *          one mutable thing and are upserted on publish. `body` is text:
+ *          every artifact is CSS or JSON, and the content type is recorded
+ *          beside it so a bucket or a CDN can serve it as-is. Migration
+ *          0030 and the ensure-system-schema guard create it.
+ */
+import { pgTable, text, timestamp, primaryKey } from 'drizzle-orm/pg-core'
+
+export const deliveryArtifacts = pgTable('delivery_artifacts', {
+  workspaceId: text('workspace_id').notNull(),
+  path: text('path').notNull(),
+  body: text('body').notNull(),
+  contentType: text('content_type').notNull().default('application/octet-stream'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (t) => [
+  primaryKey({ columns: [t.workspaceId, t.path], name: 'delivery_artifacts_pk' }),
+])

package/src/schema/entity-tags.ts

@@ -0,0 +1,33 @@
+/**
+ * File Name: entity-tags.ts
+ * Purpose: System tags — a single polymorphic table holding free-form tags for ANY
+ *   entity (content records, form submissions, members, media). One queryable place
+ *   so admin users, extensions, the API, and MCP can all tag + filter uniformly,
+ *   without a per-entity column/migration. Env-scoped (instances are env-scoped).
+ *   `entity_type` is namespaced: 'content:<typeName>' | 'submission' | 'member' |
+ *   'media'. `source` records who added it ('user' | 'system' | 'ext:<id>' | ...).
+ *
+ * Author: Raghunath J
+ * License: MIT
+ */
+import { pgTable, text, timestamp, primaryKey, index } from 'drizzle-orm/pg-core'
+
+export const entityTags = pgTable('entity_tags', {
+  workspaceId: text('workspace_id').notNull(),
+  /** 'content:<typeName>' | 'submission' | 'member' | 'media' */
+  entityType: text('entity_type').notNull(),
+  entityId: text('entity_id').notNull(),
+  /** Normalized tag (trim + collapsed whitespace). */
+  tag: text('tag').notNull(),
+  /** Who added it: 'user' | 'system' | 'ext:<id>' | 'mcp' | 'api'. */
+  source: text('source').notNull().default('user'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  /** Member id / key id / null (audit). */
+  createdBy: text('created_by'),
+}, (t) => ({
+  pk: primaryKey({ columns: [t.workspaceId, t.entityType, t.entityId, t.tag] }),
+  // filter a type by tag + distinct-tag autocomplete
+  filterIdx: index('entity_tags_filter_idx').on(t.workspaceId, t.entityType, t.tag),
+  // list one entity's tags / batch-list for a list view
+  entityIdx: index('entity_tags_entity_idx').on(t.workspaceId, t.entityType, t.entityId),
+}))

package/src/schema/extension-data.ts

@@ -0,0 +1,38 @@
+/**
+ * File Name: extension-data.ts
+ * Purpose: Drizzle schema for the `extension_data` table, which stores arbitrary
+ *          per-object data owned by installed extensions, separate from core content.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: One row per (extensionId, objectId, workspaceId) tuple.
+ *                     publishedData mirrors data at publish time, allowing extensions
+ *                     to distinguish draft vs published state.
+ */
+import { pgTable, text, timestamp, jsonb, uniqueIndex } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+/**
+ * Stores extension-owned key-value data attached to a content object, with separate
+ * draft and published data blobs and a unique constraint per extension-object pair.
+ */
+export const extensionData = pgTable(
+  'extension_data',
+  {
+    id: text('id').primaryKey(),
+    extensionId: text('extension_id').notNull(),
+    objectId: text('object_id').notNull(),
+    workspaceId: text('workspace_id').notNull(),
+    data: jsonb('data').notNull().default(sql`'{}'`),
+    publishedData: jsonb('published_data'),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => ({
+    uniqueExtensionObject: uniqueIndex('extension_data_ext_object_unique').on(
+      t.extensionId,
+      t.objectId,
+      t.workspaceId,
+      ),
+  }),
+)

package/src/schema/extension-migrations.ts

@@ -0,0 +1,42 @@
+/**
+ * File Name: extension-migrations.ts
+ * Purpose: The extension migration ledger (closure plan Phase 4, Unit 5):
+ *          one row per migration an extension applied in one workspace x
+ *          environment, with the checksum of the SQL that ran and the
+ *          extension version that carried it. INSTALL and UPGRADE read it
+ *          to compute what is pending; the gate reads it to refuse an
+ *          extension whose schema is not there; doctor reads it to explain.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: Migration 0046 creates it. A `failed` row is the
+ *          diagnosable trace of a migration whose transaction rolled back;
+ *          the next run retries it. A row whose checksum no longer matches
+ *          the declared SQL, or whose migration the extension no longer
+ *          declares, refuses every further migration of that extension in
+ *          that scope: history is not rewritten.
+ */
+import { pgTable, text, timestamp, uniqueIndex } from 'drizzle-orm/pg-core'
+
+export const extensionMigrations = pgTable(
+  'extension_migrations',
+  {
+    id: text('id').primaryKey(),
+    workspaceId: text('workspace_id').notNull(),
+    extensionId: text('extension_id').notNull(),
+    /** The migration's declared id, e.g. `0001_create_reviews`. */
+    migrationId: text('migration_id').notNull(),
+    /** The extension version that carried the migration when it ran. */
+    extensionVersion: text('extension_version'),
+    /** sha256 over the migration id and its SQL. */
+    checksum: text('checksum').notNull(),
+    /** `applied` | `failed` */
+    status: text('status').notNull().default('applied'),
+    error: text('error'),
+    appliedAt: timestamp('applied_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => ({
+    scopeUnique: uniqueIndex('extension_migrations_scope_unique').on(t.workspaceId, t.extensionId, t.migrationId),
+  }),
+)

package/src/schema/fields.ts

@@ -0,0 +1,37 @@
+/**
+ * File Name: fields.ts
+ * Purpose: Drizzle schema for the `fields` table, which stores the field-level
+ *          schema definitions for each content type (objectType) within an environment.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: References object_types. previousNames tracks rename history
+ *                     to support non-destructive field renames in migrations.
+ *                     config is a JSON blob whose shape depends on fieldType.
+ */
+import { pgTable, text, timestamp, boolean, integer, jsonb, unique } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+import { objectTypes } from './object-types'
+
+/**
+ * Defines individual field schemas belonging to a content object type, including
+ * field type, display config, ordering, required flag, and rename history.
+ */
+export const fields = pgTable('fields', {
+  id: text('id').primaryKey(),
+  typeId: text('type_id').notNull().references(() => objectTypes.id),
+  name: text('name').notNull(),
+  label: text('label').notNull(),
+  fieldType: text('field_type').notNull(),
+  config: jsonb('config').notNull().default(sql`'{}'`),
+  previousNames: text('previous_names').array().notNull().default(sql`'{}'`),
+  position: integer('position').notNull().default(0),
+  required: boolean('required').notNull().default(false),
+  /** Soft-disable: hidden from every runtime surface; column + data preserved. */
+  disabled: boolean('disabled').notNull().default(false),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (t) => ({
+  uniqTypeField: unique().on(t.typeId, t.name),
+}))

package/src/schema/globals.ts

@@ -0,0 +1,35 @@
+/**
+ * File Name: globals.ts
+ * Purpose: Drizzle schema for the `globals` table, which stores workspace-level
+ *          singleton data entries (Options / Globals) defined in tangen.config.ts.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: Keyed by (workspaceId, name) with a unique index,
+ *                     making each named global a single JSON document per environment.
+ */
+import { pgTable, text, timestamp, jsonb, uniqueIndex } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+/**
+ * Workspace-level key-value store (Globals / Options).
+ * Developers define named global entries in tangen.config.ts; this table
+ * stores the actual data. Keyed by (workspace_id, name).
+ */
+export const globals = pgTable(
+  'globals',
+  {
+    id: text('id').primaryKey(),
+    name: text('name').notNull(),
+    workspaceId: text('workspace_id').notNull(),
+    data: jsonb('data').notNull().default(sql`'{}'`),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => ({
+    uniqueGlobal: uniqueIndex('globals_workspace_name_unique').on(
+      t.workspaceId,
+      t.name,
+    ),
+  }),
+)

package/src/schema/identities.ts

@@ -0,0 +1,27 @@
+/**
+ * File Name: identities.ts
+ * Purpose: The `identities` table (framework kernel K8): service and agent
+ *          identities that hold authority and own API keys as credentials.
+ *          Migration 0055.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ */
+import { pgTable, text, timestamp, jsonb, index } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+export const identities = pgTable('identities', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  kind: text('kind').notNull(),                       // 'service' | 'agent'
+  name: text('name').notNull(),
+  description: text('description'),
+  status: text('status').notNull().default('active'), // 'active' | 'suspended'
+  permissions: jsonb('permissions').notNull().default(sql`'{}'`),
+  capabilities: jsonb('capabilities').notNull().default(sql`'[]'`),
+  ownerId: text('owner_id'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (t) => ({
+  workspaceIdx: index('identities_workspace_idx').on(t.workspaceId),
+}))

package/src/schema/index.ts

@@ -0,0 +1,51 @@
+/**
+ * File Name: index.ts
+ * Purpose: Barrel file that re-exports all Drizzle table definitions for the system schema,
+ *          making every table available through a single import path.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: This file is the schema entry point referenced by drizzle.config.ts.
+ *                     Content tables (generated by tangen push) are exported separately
+ *                     from src/generated/content-tables.ts.
+ */
+export * from './workspaces'
+export * from './object-types'
+export * from './fields'
+export * from './objects'  // exports `revisions` (_revisions table)
+export * from './members'
+export * from './member-grants'
+export * from './api-keys'
+export * from './identities'
+export * from './media'
+export * from './webhooks'
+export * from './webhook-deliveries'
+export * from './audit-log'
+export * from './saved-views'
+export * from './roles'
+export * from './jobs'
+export * from './workspace-domains'
+export * from './releases'
+export * from './workspace-installed-apps'
+export * from './connections'
+export * from './extension-migrations'
+export * from './extension-data'
+export * from './ai-settings'
+export * from './ai-chats'
+export * from './globals'
+export * from './realtime'
+export * from './delivery-artifacts'
+export * from './workspace-activity'
+export * from './search-query-log'
+export * from './search-synonyms'
+export * from './search-recommendations'
+export * from './playground'
+export * from './paused-jobs'
+export * from './entity-tags'
+export * from './migration-runs'
+export * from './porter-transfer'
+export * from './schema-pushes'
+export * from './custom-table-owners'
+export * from './search-documents'
+export * from './knowledge'

package/src/schema/jobs.ts

@@ -0,0 +1,104 @@
+/**
+ * File Name: jobs.ts
+ * Purpose: Drizzle schema for the jobs-v2 tables — the durable Postgres
+ *          queue (job_queue), execution history (job_runs), redis-less
+ *          scheduler state, admin-managed cron entries, and the Postgres
+ *          cache fallback store.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: Queue polling uses raw SKIP LOCKED SQL (task-queue
+ *          service); these definitions serve typed reads/writes and admin
+ *          routes. Migration: drizzle/0011_jobs_v2.sql.
+ */
+import { pgTable, text, timestamp, jsonb, integer, boolean, bigserial, index } from 'drizzle-orm/pg-core'
+
+export const jobQueue = pgTable('job_queue', {
+  id: bigserial('id', { mode: 'number' }).primaryKey(),
+  taskId: text('task_id').notNull(),
+  workspaceId: text('workspace_id').notNull(),
+  payload: jsonb('payload'),
+  /**
+   * Collapses redundant PENDING work: at most one queued row per key, enforced
+   * by a partial unique index (drizzle/0037). NULL means "never deduplicate",
+   * which is every task except search indexing. See task-queue.pgEnqueue.
+   */
+  dedupeKey: text('dedupe_key'),
+  /** Who enqueued and whose authority the run uses (kernel K6): { initiator, runAs, correlationId, causationId, locale }. */
+  execution: jsonb('execution'),
+  status: text('status').notNull().default('queued'),
+  attempts: integer('attempts').notNull().default(0),
+  maxAttempts: integer('max_attempts').notNull().default(3),
+  runAt: timestamp('run_at', { withTimezone: true }).notNull().defaultNow(),
+  lockedAt: timestamp('locked_at', { withTimezone: true }),
+  lockedBy: text('locked_by'),
+  lastError: text('last_error'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  finishedAt: timestamp('finished_at', { withTimezone: true }),
+})
+
+export const jobRuns = pgTable('job_runs', {
+  id: bigserial('id', { mode: 'number' }).primaryKey(),
+  kind: text('kind').notNull(),
+  name: text('name').notNull(),
+  workspaceId: text('workspace_id').notNull(),
+  status: text('status').notNull(),
+  startedAt: timestamp('started_at', { withTimezone: true }).notNull().defaultNow(),
+  finishedAt: timestamp('finished_at', { withTimezone: true }),
+  durationMs: integer('duration_ms'),
+  error: text('error'),
+  meta: jsonb('meta'),
+  // ── The run's identity (kernel K6) ──
+  actorKind: text('actor_kind'),
+  actorId: text('actor_id'),
+  initiatorKind: text('initiator_kind'),
+  initiatorId: text('initiator_id'),
+  executionId: text('execution_id'),
+  correlationId: text('correlation_id'),
+  attempt: integer('attempt'),
+}, (t) => ({
+  /** Retention: the purge scans by workspace and age (migration 0044). */
+  retentionIdx: index('job_runs_retention_idx').on(t.workspaceId, t.startedAt),
+  correlationIdx: index('job_runs_correlation').on(t.correlationId),
+}))
+
+export const schedulerState = pgTable('scheduler_state', {
+  workspaceId: text('workspace_id').notNull(),
+  jobId: text('job_id').notNull(),
+  lastRun: timestamp('last_run', { withTimezone: true }).notNull(),
+})
+
+export const cronJobs = pgTable('cron_jobs', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  name: text('name').notNull(),
+  schedule: text('schedule').notNull(),
+  /** IANA zone the cron fields evaluate in; NULL = server-local time. */
+  timezone: text('timezone'),
+  action: jsonb('action').notNull(),
+  enabled: boolean('enabled').notNull().default(true),
+  createdBy: text('created_by'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+})
+
+export const cacheEntries = pgTable('cache_entries', {
+  key: text('key').primaryKey(),
+  value: text('value').notNull(),
+  tags: text('tags').array().notNull().default([]),
+  storedAt: timestamp('stored_at', { withTimezone: true }).notNull().defaultNow(),
+  expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+})
+
+/**
+ * Fixed-window rate-limit counters for deployments without Redis (Gateway
+ * M5, plan section 28). One row per counter key; a hit past `reset_at`
+ * starts a new window. Pruned by the queue worker like cache_entries.
+ */
+export const rateLimitCounters = pgTable('rate_limit_counters', {
+  key: text('key').primaryKey(),
+  count: integer('count').notNull().default(0),
+  resetAt: timestamp('reset_at', { withTimezone: true }).notNull(),
+})
+