@tangen/db 0.0.0-stage → 0.1.55

package/src/schema/knowledge.ts

@@ -0,0 +1,85 @@
+/**
+ * File Name: knowledge.ts
+ * Purpose: The Knowledge (RAG) tables, declared where every other system
+ *          table is declared. `knowledge_meta` pins the vector space of one
+ *          workspace x environment (provider, model, dimensions);
+ *          `knowledge_chunks` holds the embedded chunks; `knowledge_qa` the
+ *          curated question/answer pairs; `knowledge_queries` the retrieval
+ *          log the Insights screen reads.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: drizzle-orm/pg-core. Migration 0041 creates these; the
+ *          canonical DDL text lives in ../knowledge-schema.ts and the test
+ *          proves the migration carries it verbatim. `embedding` is
+ *          pgvector's `vector` type; its dimensions are NOT part of the
+ *          declaration because they come from the configured embedding model
+ *          - `pinKnowledgeVectorSpace` types the column when the space is
+ *          pinned. `@tangen/knowledge` itself declares and creates nothing.
+ */
+import { pgTable, text, integer, real, boolean, bigserial, jsonb, timestamp, primaryKey, index, customType } from 'drizzle-orm/pg-core'
+
+/** pgvector's `vector` column type; dimensions are applied by the vector-space pin, not the declaration. */
+export const vector = customType<{ data: number[]; driverData: string }>({
+  dataType() { return 'vector' },
+  toDriver(value: number[]) { return `[${value.join(',')}]` },
+})
+
+export const knowledgeMeta = pgTable('knowledge_meta', {
+  workspaceId: text('workspace_id').notNull(),
+  provider: text('provider').notNull(),
+  model: text('model').notNull(),
+  dimensions: integer('dimensions').notNull(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (t) => ({
+  pk: primaryKey({ columns: [t.workspaceId] }),
+}))
+
+export const knowledgeChunks = pgTable('knowledge_chunks', {
+  id: bigserial('id', { mode: 'number' }).primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  sourceKind: text('source_kind').notNull(),
+  sourceId: text('source_id').notNull(),
+  sourceGroup: text('source_group').notNull().default(''),
+  field: text('field').notNull().default(''),
+  locale: text('locale').notNull().default(''),
+  audience: text('audience').notNull().default('public'),
+  chunkIndex: integer('chunk_index').notNull().default(0),
+  content: text('content').notNull(),
+  contentHash: text('content_hash').notNull(),
+  metadata: jsonb('metadata'),
+  embedding: vector('embedding').notNull(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (t) => ({
+  scopeIdx: index('knowledge_chunks_scope_idx').on(t.workspaceId, t.sourceKind, t.sourceId),
+}))
+
+export const knowledgeQa = pgTable('knowledge_qa', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  question: text('question').notNull(),
+  answer: text('answer').notNull(),
+  audience: text('audience').notNull().default('public'),
+  enabled: boolean('enabled').notNull().default(true),
+  updatedBy: text('updated_by'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (t) => ({
+  scopeIdx: index('knowledge_qa_scope_idx').on(t.workspaceId),
+}))
+
+export const knowledgeQueries = pgTable('knowledge_queries', {
+  id: bigserial('id', { mode: 'number' }).primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  query: text('query').notNull(),
+  source: text('source').notNull(),
+  audience: text('audience').notNull().default('public'),
+  locale: text('locale').notNull().default(''),
+  topScore: real('top_score'),
+  hitCount: integer('hit_count').notNull().default(0),
+  answered: boolean('answered').notNull().default(false),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+}, (t) => ({
+  scopeIdx: index('knowledge_queries_scope_idx').on(t.workspaceId, t.createdAt),
+}))

package/src/schema/media.ts

@@ -0,0 +1,52 @@
+/**
+ * File Name: media.ts
+ * Purpose: Drizzle schema for the `media_folders` and `media_assets` tables, which
+ *          together model a hierarchical media library for uploaded files and images.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: mediaFolders supports nesting via self-referential parentId.
+ *                     mediaAssets references mediaFolders for folder placement.
+ *                     storagePath is the provider-specific path (S3 key, local path, etc.).
+ */
+import { pgTable, text, timestamp, integer, bigint, jsonb, index } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+/**
+ * Stores hierarchical folder nodes for organising media assets; parentId is nullable
+ * to represent root-level folders.
+ */
+export const mediaFolders = pgTable('media_folders', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  name: text('name').notNull(),
+  parentId: text('parent_id'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+})
+
+/**
+ * Stores uploaded media file records including MIME type, dimensions, alt text, tags,
+ * storage path, and an optional thumbnail path for image previews.
+ */
+export const mediaAssets = pgTable('media_assets', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  folderId: text('folder_id').references(() => mediaFolders.id),
+  filename: text('filename').notNull(),
+  originalName: text('original_name').notNull(),
+  mimeType: text('mime_type').notNull(),
+  sizeBytes: bigint('size_bytes', { mode: 'number' }).notNull(),
+  width: integer('width'),
+  height: integer('height'),
+  altText: text('alt_text'),
+  tags: text('tags').array().notNull().default(sql`'{}'`),
+  metadata: jsonb('metadata').notNull().default(sql`'{}'`),
+  storagePath: text('storage_path').notNull(),
+  thumbnailPath: text('thumbnail_path'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  createdBy: text('created_by'),
+}, (t) => ({
+  workspaceIdx: index('media_assets_workspace_idx').on(t.workspaceId),
+  folderIdx: index('media_assets_folder_idx').on(t.folderId),
+}))

package/src/schema/member-grants.ts

@@ -0,0 +1,34 @@
+/**
+ * File Name: member-grants.ts
+ * Purpose: Drizzle schema for `member_grants` - per-member ADDITIVE permission
+ *          grants layered on top of a member's role (extra admin capabilities
+ *          and extra extension-page access). One row per member; a row in this
+ *          database is a grant in THIS deployment (environments are removed, so
+ *          the database boundary is the environment boundary).
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: Grants only ever ADD - they never remove a role right
+ *          (see tasks/plan-per-user-grants.md). `capabilities` and `extensions`
+ *          are string arrays (Capability[] / ExtensionId[]). `expires_at` is an
+ *          optional time-box; an expired grant is ignored at read time.
+ */
+import { pgTable, text, timestamp, jsonb, primaryKey } from 'drizzle-orm/pg-core'
+
+export const memberGrants = pgTable('member_grants', {
+  workspaceId: text('workspace_id').notNull(),
+  memberId: text('member_id').notNull(),
+  /** Extra admin-area capabilities (Capability[]). */
+  capabilities: jsonb('capabilities').notNull().default([]),
+  /** Extra extension-page ids this member may open (ExtensionId[]). */
+  extensions: jsonb('extensions').notNull().default([]),
+  /** Member id of whoever granted it, for provenance. */
+  grantedBy: text('granted_by'),
+  reason: text('reason'),
+  /** Optional expiry; a past value means the grant no longer applies. */
+  expiresAt: timestamp('expires_at', { withTimezone: true }),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (t) => ({
+  pk: primaryKey({ columns: [t.workspaceId, t.memberId] }),
+}))

package/src/schema/members.ts

@@ -0,0 +1,49 @@
+/**
+ * File Name: members.ts
+ * Purpose: Drizzle schema for the `members` and `refresh_tokens` tables, which store
+ *          workspace admin accounts and their session refresh tokens respectively.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: Members are the human operators of the CMS admin UI, distinct
+ *                     from end-users stored in auth_users. passwordHash uses argon2id
+ *                     (see seed/skeleton.ts). refresh_tokens supports revocation via
+ *                     revokedAt; expired/revoked tokens should be pruned periodically.
+ */
+import { pgTable, text, timestamp, unique, index } from 'drizzle-orm/pg-core'
+
+/**
+ * Stores workspace admin member accounts with email/password credentials and role;
+ * email must be unique within a workspace.
+ */
+export const members = pgTable('members', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  email: text('email').notNull(),
+  name: text('name'),
+  /** Job title shown on the profile / member list (self-editable). */
+  designation: text('designation'),
+  /** Avatar image URL (self-editable). Members are workspace-scoped, so a plain
+   *  URL avoids the env-scoped media coupling. */
+  avatar: text('avatar'),
+  passwordHash: text('password_hash').notNull(),
+  role: text('role').notNull().default('editor'),
+  /** 'active' | 'suspended' — suspended members cannot log in or refresh. */
+  status: text('status').notNull().default('active'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  lastLoginAt: timestamp('last_login_at', { withTimezone: true }),
+}, (t) => ({
+  uniqWorkspaceEmail: unique().on(t.workspaceId, t.email),
+}))
+
+export const refreshTokens = pgTable('refresh_tokens', {
+  id: text('id').primaryKey(),
+  memberId: text('member_id').notNull().references(() => members.id),
+  tokenHash: text('token_hash').notNull(),
+  expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  revokedAt: timestamp('revoked_at', { withTimezone: true }),
+}, (t) => ({
+  memberIdx: index('refresh_tokens_member_idx').on(t.memberId),
+}))

package/src/schema/migration-runs.ts

@@ -0,0 +1,46 @@
+/**
+ * File Name: migration-runs.ts
+ * Purpose: Durable state for Porter data-movement runs (promote, export,
+ *   import, remote transfer). The row IS the worker's state: claimable,
+ *   heartbeat while alive, per-outcome counters, cancellable, and a pointer
+ *   to the parts-based JSONL results ledger in storage - so a crash or
+ *   redeploy loses nothing and "resume" is just reading the row back.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: drizzle-orm/pg-core. Results live OUTSIDE the row
+ *   (storage adapter, one JSONL file per flush part) - a 100k-item report
+ *   does not belong in a jsonb column.
+ */
+import { pgTable, text, timestamp, integer, boolean, jsonb, index } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+export const migrationRuns = pgTable('migration_runs', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  /** promote | export | import | remote_send | remote_receive */
+  kind: text('kind').notNull(),
+  /** Envs are nullable per kind: export has no target, import no source. */
+  /** pending | running | completed | failed | cancelled */
+  status: text('status').notNull().default('pending'),
+  /** What the run covers: type/objectIds/labels/bundle info - kind-specific. */
+  scope: jsonb('scope').notNull().default(sql`'{}'`),
+  /** Per-outcome counters: { created, overwritten, unchanged, replaced, failed, skipped }. */
+  counts: jsonb('counts').notNull().default(sql`'{}'`),
+  totalItems: integer('total_items').notNull().default(0),
+  processedItems: integer('processed_items').notNull().default(0),
+  /** Number of JSONL result parts written to storage (porter/runs/<id>/results-N.jsonl). */
+  resultsParts: integer('results_parts').notNull().default(0),
+  error: text('error'),
+  /** Durable cancel flag - workers poll it between chunks. */
+  cancelRequested: boolean('cancel_requested').notNull().default(false),
+  createdBy: text('created_by'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  startedAt: timestamp('started_at', { withTimezone: true }),
+  finishedAt: timestamp('finished_at', { withTimezone: true }),
+  heartbeatAt: timestamp('heartbeat_at', { withTimezone: true }),
+}, (t) => ({
+  workspaceIdx: index('migration_runs_workspace_idx').on(t.workspaceId, t.createdAt),
+  statusIdx: index('migration_runs_status_idx').on(t.status),
+}))

package/src/schema/object-types.ts

@@ -0,0 +1,41 @@
+/**
+ * File Name: object-types.ts
+ * Purpose: Defines the `object_types` table, which stores content-type definitions
+ *   (schema blueprints) registered in each environment of a workspace.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: drizzle-orm/pg-core; one registry per database: a type name is unique in the deployment.
+ */
+import { pgTable, text, timestamp, boolean, integer, jsonb, unique } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+/**
+ * Stores the schema definition for a single content type within an environment.
+ * Each row describes one content type (e.g. "post", "author") including its field
+ * schema version, singleton flag, and admin UI configuration.
+ */
+export const objectTypes = pgTable('object_types', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  label: text('label').notNull(),
+  /** Explicit plural word (nullable — inflection derives one from `name` when absent). */
+  plural: text('plural'),
+  singleton: boolean('singleton').notNull().default(false),
+  disabled: boolean('disabled').notNull().default(false),
+  /** Type-level localization opt-in — title (and any localized fields) get a
+   *  <type>_i18n side table; drives whether the admin offers translation. */
+  localized: boolean('localized').notNull().default(false),
+  /** The extension that declares this type, or NULL when the site's own code
+   *  does. A row with a value here is never dropped by a push: an extension
+   *  that stops declaring it leaves an orphan the tooling reports instead. */
+  providedBy: text('provided_by'),
+  previousNames: text('previous_names').array().notNull().default(sql`'{}'`),
+  adminConfig: jsonb('admin_config').notNull().default(sql`'{}'`),
+  schemaVersion: integer('schema_version').notNull().default(1),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (t) => ({
+  uniqEnvName: unique().on(t.name),
+}))

package/src/schema/objects.ts

@@ -0,0 +1,38 @@
+/**
+ * File Name: objects.ts
+ * Purpose: Defines the `_revisions` table, which stores immutable point-in-time
+ *   snapshots of content objects used for version history and auditing.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: drizzle-orm/pg-core; authoritative live content lives in
+ *   per-type tables provisioned by `tangen push` — this table only holds snapshots.
+ */
+import { pgTable, text, timestamp, jsonb, integer, index, uniqueIndex } from 'drizzle-orm/pg-core'
+
+// Immutable point-in-time snapshots used for version history.
+// Authoritative live content lives in per-type tables created by `tangen push`.
+/**
+ * Stores a versioned, immutable JSONB snapshot of a content object at a specific
+ * point in time, enabling full version history and rollback for any object type.
+ */
+export const revisions = pgTable('_revisions', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  typeId: text('type_id').notNull(),
+  typeName: text('type_name').notNull(),
+  objectId: text('object_id').notNull(),
+  version: integer('version').notNull().default(1),
+  versionType: text('version_type'),
+  snapshot: jsonb('snapshot').notNull(),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  createdBy: text('created_by'),
+  /** The locale this revision captured (K5); null for the base row. */
+  locale: text('locale'),
+}, (t) => ({
+  idxObject: index('revisions_object').on(t.workspaceId, t.objectId, t.createdAt),
+  // The invariant the allocator relies on: one version number per object, ever.
+  // Scope matches the allocation scope (workspace + object, not env).
+  uniqObjectVersion: uniqueIndex('_revisions_object_version_uniq').on(t.workspaceId, t.objectId, t.version),
+}))

package/src/schema/paused-jobs.ts

@@ -0,0 +1,25 @@
+/**
+ * File Name: paused-jobs.ts
+ * Purpose: Admin pause/resume for CODE-defined scheduled jobs — a row here means
+ *   the job (workspace-level, all envs) is paused; the scheduler skips it. Presence
+ *   = paused, absence = running. Lets operators stop a job from the admin without a
+ *   code deploy.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ */
+import { pgTable, text, timestamp, primaryKey } from 'drizzle-orm/pg-core'
+
+export const pausedJobs = pgTable('paused_jobs', {
+  workspaceId: text('workspace_id').notNull(),
+  /** The defineScheduledJob id (from app/jobs). */
+  jobId: text('job_id').notNull(),
+  /** Env slug the pause applies to; '*' = all envs (legacy rows migrate here). */
+  pausedAt: timestamp('paused_at', { withTimezone: true }).notNull().defaultNow(),
+  /** Member who paused it (audit; nullable - null for the circuit breaker). */
+  pausedBy: text('paused_by'),
+  /** Why (circuit breaker writes this; manual pauses leave it null). */
+  reason: text('reason'),
+}, (t) => ({
+  pk: primaryKey({ columns: [t.workspaceId, t.jobId] }),
+}))

package/src/schema/playground.ts

@@ -0,0 +1,43 @@
+/**
+ * File Name: playground.ts
+ * Purpose: PG-3 — API Playground persistence: collections (folders of saved
+ *          REST/GraphQL requests, private by default, shareable within the
+ *          playground's own RBAC circle) and per-member variable sets
+ *          ({{name}} interpolation; values never leave this table).
+ *
+ * Author: Raghunath J
+ * License: MIT
+ */
+import { pgTable, text, timestamp, jsonb, index, unique } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+/**
+ * A collection: an ordered jsonb list of saved requests. Requests never store
+ * key ids or variable values — keys are picked and variables resolved at run
+ * time. `visibility`: 'private' (creator only) | 'shared' (every member who
+ * clears the playground RBAC gate).
+ */
+export const playgroundCollections = pgTable('playground_collections', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  name: text('name').notNull(),
+  /** [{ id, name, request: { kind, method?, path?, query?, headers?, body?, graphql? } }] */
+  requests: jsonb('requests').notNull().default(sql`'[]'`),
+  visibility: text('visibility').notNull().default('private'),
+  createdBy: text('created_by').notNull(),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (t) => ({
+  playgroundCollectionsScopeIdx: index('playground_collections_scope_idx').on(t.workspaceId),
+}))
+
+/** One variable set per member per workspace+env: { name: { value, secret? } }. */
+export const playgroundVariables = pgTable('playground_variables', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  memberId: text('member_id').notNull(),
+  vars: jsonb('vars').notNull().default(sql`'{}'`),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (t) => ({
+  playgroundVariablesOwner: unique('playground_variables_owner').on(t.workspaceId, t.memberId),
+}))

package/src/schema/porter-transfer.ts

@@ -0,0 +1,47 @@
+/**
+ * File Name: porter-transfer.ts
+ * Purpose: Arc R gatekeeper storage. Transfer CODES are the human front
+ *   door (single-use, short TTL, hashed at rest - the receiving admin
+ *   reads one out to the sender); transfer TOKENS are what a redeemed code
+ *   becomes (scoped to porter ingest endpoints and ONE run, never admin
+ *   access). Both are directional: they grant write-IN only.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ */
+import { pgTable, text, timestamp, jsonb, index } from 'drizzle-orm/pg-core'
+
+export const porterTransferCodes = pgTable('porter_transfer_codes', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  /** The RECEIVING environment the code grants write-in to. */
+  /** sha256 of the normalized code - the plaintext exists only in the
+   *  generating response and the receiver's screen. */
+  codeHash: text('code_hash').notNull(),
+  expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+  redeemedAt: timestamp('redeemed_at', { withTimezone: true }),
+  revokedAt: timestamp('revoked_at', { withTimezone: true }),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  createdBy: text('created_by'),
+}, (t) => ({
+  hashIdx: index('porter_codes_hash_idx').on(t.codeHash),
+  workspaceIdx: index('porter_codes_workspace_idx').on(t.workspaceId),
+}))
+
+export const porterTransferTokens = pgTable('porter_transfer_tokens', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  tokenHash: text('token_hash').notNull(),
+  /** The code this token was redeemed from (audit trail). */
+  codeId: text('code_id').notNull(),
+  /** The ONE receiver-side run this token is allowed to feed (set when the
+   *  transfer starts; a token never feeds two runs). */
+  runId: text('run_id'),
+  expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+  revokedAt: timestamp('revoked_at', { withTimezone: true }),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  /** Sender-declared audit info ({url, label} - informational only). */
+  senderInfo: jsonb('sender_info').notNull().default({}),
+}, (t) => ({
+  hashIdx: index('porter_tokens_hash_idx').on(t.tokenHash),
+}))

package/src/schema/realtime.ts

@@ -0,0 +1,45 @@
+/**
+ * File Name: realtime.ts
+ * Purpose: The realtime_events table - the bounded replay window for the
+ *          Postgres fan-out, and the row a NOTIFY receiver reads back.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: Realtime R2 (tasks/plan-realtime.md section 4.4).
+ *          One bigserial mints the order for every API process; `id` is
+ *          the `<epoch>-<seq>` cursor a client resumes with; `data` holds
+ *          ids, slugs and changed-field names, never a document. Pruned by
+ *          the queue worker like rate_limit_counters; migration 0028 and
+ *          the ensure-system-schema guard create it.
+ */
+import { pgTable, text, jsonb, bigint, bigserial, index, uniqueIndex, primaryKey } from 'drizzle-orm/pg-core'
+
+export const realtimeEvents = pgTable('realtime_events', {
+  seq: bigserial('seq', { mode: 'number' }).primaryKey(),
+  channel: text('channel').notNull(),
+  id: text('id').notNull(),
+  t: bigint('t', { mode: 'number' }).notNull(),
+  type: text('type').notNull(),
+  data: jsonb('data').notNull().default({}),
+}, (t) => [
+  index('realtime_events_channel_seq_idx').on(t.channel, t.seq),
+  uniqueIndex('realtime_events_channel_id_idx').on(t.channel, t.id),
+])
+
+/**
+ * The realtime_presence table (R3): one row per joined session per scope
+ * channel, the session record as JSON and its expiry for the sweep.
+ * Ephemeral by construction - pruned by the queue worker, never read by
+ * the activity log; migration 0029 and the ensure-system-schema guard
+ * create it.
+ */
+export const realtimePresence = pgTable('realtime_presence', {
+  channel: text('channel').notNull(),
+  sessionId: text('session_id').notNull(),
+  data: jsonb('data').notNull().default({}),
+  expiresAt: bigint('expires_at', { mode: 'number' }).notNull(),
+}, (t) => [
+  primaryKey({ columns: [t.channel, t.sessionId] }),
+  index('realtime_presence_expires_idx').on(t.expiresAt),
+])

package/src/schema/releases.ts

@@ -0,0 +1,95 @@
+/**
+ * File Name: releases.ts
+ * Purpose: Releases v1 (closure plan Phase 5B): a reviewed, immutable
+ *          promotion from one environment to the next. `releases` carries
+ *          the state machine (draft -> in_review -> approved -> applying ->
+ *          applied | failed) with who did what and when, the approved
+ *          payload's checksum and the failure record; `release_items` is
+ *          one row per object with the review snapshot, the frozen payload
+ *          approval wrote, and the per-item apply outcome;
+ *          `release_history` is the operator's ledger of every transition
+ *          and attempt; `promotion_log` stays the per-object trail.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: Migration 0049 added the lifecycle columns, the
+ *          status check, the item identity (one per object per release)
+ *          and the history table, and turned legacy `pending` into `draft`.
+ */
+import { pgTable, text, timestamp, jsonb, integer, index, uniqueIndex } from 'drizzle-orm/pg-core'
+import { workspaces } from './workspaces'
+
+export const releases = pgTable('releases', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  workspaceId: text('workspace_id').notNull().references(() => workspaces.id, { onDelete: 'cascade' }),
+  /** draft | in_review | approved | applying | applied | failed */
+  status: text('status').notNull().default('draft'),
+  createdBy: text('created_by'),
+  appliedBy: text('applied_by'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  appliedAt: timestamp('applied_at', { withTimezone: true }),
+  submittedAt: timestamp('submitted_at', { withTimezone: true }),
+  submittedBy: text('submitted_by'),
+  approvedAt: timestamp('approved_at', { withTimezone: true }),
+  approvedBy: text('approved_by'),
+  /** sha256 over the frozen payloads in apply order; the apply refuses when it no longer matches. */
+  approvedChecksum: text('approved_checksum'),
+  scheduledAt: timestamp('scheduled_at', { withTimezone: true }),
+  scheduledBy: text('scheduled_by'),
+  applyingStartedAt: timestamp('applying_started_at', { withTimezone: true }),
+  failedAt: timestamp('failed_at', { withTimezone: true }),
+  /** { stage, itemId?, error, errorId? } of the last failure. */
+  failure: jsonb('failure'),
+  attempts: integer('attempts').notNull().default(0),
+}, (t) => ({
+  workspaceIdx: index('releases_workspace_idx').on(t.workspaceId),
+}))
+
+export const releaseItems = pgTable('release_items', {
+  id: text('id').primaryKey(),
+  releaseId: text('release_id').notNull().references(() => releases.id, { onDelete: 'cascade' }),
+  objectId: text('object_id').notNull(),
+  typeName: text('type_name').notNull(),
+  /** The main row at selection time: what review and diff show. */
+  fieldSnapshot: jsonb('field_snapshot').notNull(),
+  comparisonState: text('comparison_state'),
+  resolvedValues: jsonb('resolved_values'),
+  /** Written at APPROVE: the complete source (row, i18n rows, tags, extension data) the apply uses. */
+  frozenPayload: jsonb('frozen_payload'),
+  /** The target's fingerprint at APPROVE; a different one at apply is a conflict. */
+  targetFingerprint: text('target_fingerprint'),
+  /** Deterministic apply order within the release. */
+  position: integer('position'),
+  /** created | overwritten | unchanged | skipped | failed, per attempt. */
+  applyOutcome: text('apply_outcome'),
+  appliedAt: timestamp('applied_at', { withTimezone: true }),
+  applyError: text('apply_error'),
+}, (t) => ({
+  releaseIdx: index('release_items_release_idx').on(t.releaseId),
+  objectIdx: index('release_items_object_idx').on(t.objectId),
+  identity: uniqueIndex('release_items_identity_unique').on(t.releaseId, t.typeName, t.objectId),
+}))
+
+export const releaseHistory = pgTable('release_history', {
+  id: text('id').primaryKey(),
+  releaseId: text('release_id').notNull(),
+  workspaceId: text('workspace_id').notNull(),
+  attempt: integer('attempt').notNull().default(0),
+  /** submit | withdraw | approve | schedule | unschedule | apply | retry | preflight-failed | apply-failed | applied */
+  action: text('action').notNull(),
+  fromStatus: text('from_status'),
+  toStatus: text('to_status').notNull(),
+  actor: text('actor'),
+  checksum: text('checksum'),
+  counts: jsonb('counts'),
+  errorId: text('error_id'),
+  errorSummary: text('error_summary'),
+  reason: text('reason'),
+  startedAt: timestamp('started_at', { withTimezone: true }).notNull().defaultNow(),
+  finishedAt: timestamp('finished_at', { withTimezone: true }),
+}, (t) => ({
+  releaseIdx: index('release_history_release_idx').on(t.releaseId, t.startedAt),
+}))
+

package/src/schema/roles.ts

@@ -0,0 +1,27 @@
+/**
+ * File Name: roles.ts
+ * Purpose: Drizzle schema for the `roles` table — workspace-defined custom
+ *          member roles. members.role references a role's slug (or a built-in
+ *          role name); permissions holds a MemberPermissions bundle.
+ *
+ * Author: Raghunath J
+ * License: MIT
+ *
+ * Dependencies/Notes: slug is the stable identifier (unique per workspace) —
+ *          field-level access lists and env-role overrides reference slugs,
+ *          never DB ids, so code-first configs survive environment moves.
+ */
+import { pgTable, text, timestamp, jsonb, unique } from 'drizzle-orm/pg-core'
+
+export const roles = pgTable('roles', {
+  id: text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull(),
+  slug: text('slug').notNull(),
+  name: text('name').notNull(),
+  description: text('description'),
+  permissions: jsonb('permissions').notNull().default({}),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (t) => ({
+  uniqWorkspaceSlug: unique().on(t.workspaceId, t.slug),
+}))