@minion-stack/db 0.2.0

package/src/schema/index.ts

@@ -0,0 +1,59 @@
+// Better Auth tables (replaces tenants, users, userTenants, authSessions)
+export {
+  user,
+  session,
+  account,
+  verification,
+  jwks,
+  organization,
+  member,
+  invitation,
+  oauthApplication,
+  oauthAccessToken,
+  oauthConsent,
+} from './auth/index.js';
+export { servers } from './servers.js';
+export { agents } from './agents.js';
+export { skills } from './skills.js';
+export { sessions } from './sessions.js';
+export { chatMessages } from './chat-messages.js';
+export { bugs } from './bugs.js';
+export { connectionEvents } from './connection-events.js';
+export { settings } from './settings.js';
+export { files } from './files.js';
+export { missions } from './missions.js';
+export { tasks } from './tasks.js';
+export { credentialHealthSnapshots } from './credential-health.js';
+export { skillExecutionStats } from './skill-execution-stats.js';
+export { gatewayHeartbeats } from './gateway-heartbeats.js';
+export { activityBins } from './activity-bins.js';
+export { configSnapshots } from './config-snapshots.js';
+export { sessionTasks } from './session-tasks.js';
+export { marketplaceAgents } from './marketplace-agents.js';
+export { marketplaceInstalls } from './marketplace-installs.js';
+export { workshopSaves } from './workshop-saves.js';
+export { deviceIdentities } from './device-identities.js';
+export { flows } from './flows.js';
+export { userServers } from './user-servers.js';
+export { userAgents } from './user-agents.js';
+export { channels } from './channels.js';
+export { channelAssignments } from './channel-assignments.js';
+export { serverProvisionConfigs } from './server-provision-configs.js';
+export { backupConfigs } from './backup-configs.js';
+export { serverBackups } from './server-backups.js';
+export { agentGroups, agentGroupMembers } from './agent-groups.js';
+export { unifiedEvents } from './unified-events.js';
+export { channelIdentities } from './channel-identities.js';
+export { personalAgents } from './personal-agents.js';
+export {
+  builtSkills,
+  builtSkillTools,
+  builtChapters,
+  builtChapterEdges,
+  builtChapterTools,
+  builtAgents,
+  builtAgentSkills,
+  builtTools,
+  agentBuiltSkills,
+} from './builder.js';
+export { userPreferences } from './user-preferences.js';

package/src/schema/marketplace-agents.ts

@@ -0,0 +1,25 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
+
+export const marketplaceAgents = sqliteTable('marketplace_agents', {
+  id: text('id').primaryKey(), // slug e.g. "luna-chen"
+  name: text('name').notNull(),
+  role: text('role').notNull(),
+  category: text('category').notNull(), // engineering | product | data | creative | security
+  tags: text('tags').notNull(), // JSON array string
+  description: text('description').notNull(),
+  catchphrase: text('catchphrase'),
+  version: text('version').notNull(),
+  model: text('model'),
+  avatarSeed: text('avatar_seed').notNull(),
+  githubPath: text('github_path').notNull(),
+  soulMd: text('soul_md'),
+  identityMd: text('identity_md'),
+  userMd: text('user_md'),
+  contextMd: text('context_md'),
+  skillsMd: text('skills_md'),
+  installCount: integer('install_count').default(0),
+  syncedAt: integer('synced_at').notNull(),
+  filesLoadedAt: integer('files_loaded_at'),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});

package/src/schema/marketplace-installs.ts

@@ -0,0 +1,25 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+import { marketplaceAgents } from './marketplace-agents.js';
+
+export const marketplaceInstalls = sqliteTable(
+  'marketplace_installs',
+  {
+    id: text('id').primaryKey(),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    agentId: text('agent_id')
+      .notNull()
+      .references(() => marketplaceAgents.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    installedAt: integer('installed_at').notNull(),
+  },
+  (t) => [
+    index('idx_marketplace_installs_tenant').on(t.tenantId),
+    index('idx_marketplace_installs_agent').on(t.agentId),
+  ],
+);

package/src/schema/missions.ts

@@ -0,0 +1,33 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+import { sessions } from './sessions.js';
+
+export const missions = sqliteTable(
+  'missions',
+  {
+    id: text('id').primaryKey(),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    sessionId: text('session_id')
+      .notNull()
+      .references(() => sessions.id, { onDelete: 'cascade' }),
+    title: text('title').notNull(),
+    description: text('description'),
+    status: text('status', { enum: ['active', 'completed', 'cancelled'] })
+      .notNull()
+      .default('active'),
+    metadata: text('metadata'),
+    createdAt: integer('created_at').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+  },
+  (t) => [
+    index('idx_missions_tenant').on(t.tenantId),
+    index('idx_missions_session').on(t.sessionId),
+    index('idx_missions_server').on(t.serverId),
+  ],
+);

package/src/schema/personal-agents.ts

@@ -0,0 +1,41 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { user } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const personalAgents = sqliteTable(
+  'personal_agents',
+  {
+    id: text('id').primaryKey(),
+    userId: text('user_id')
+      .notNull()
+      .unique()
+      .references(() => user.id, { onDelete: 'cascade' }),
+    agentId: text('agent_id').notNull(),
+    serverId: text('server_id').references(() => servers.id, { onDelete: 'set null' }),
+    displayName: text('display_name').notNull(),
+    conversationName: text('conversation_name'),
+    avatarUrl: text('avatar_url'),
+    personalityPreset: text('personality_preset', {
+      enum: ['professional', 'casual', 'creative', 'technical'],
+    }),
+    personalityText: text('personality_text'),
+    personalityConfigured: integer('personality_configured', { mode: 'boolean' })
+      .notNull()
+      .default(false),
+    provisioningStatus: text('provisioning_status', {
+      enum: ['pending', 'provisioning', 'active', 'error'],
+    })
+      .notNull()
+      .default('pending'),
+    provisioningError: text('provisioning_error'),
+    lastRetryAt: integer('last_retry_at'),
+    retryCount: integer('retry_count').notNull().default(0),
+    createdAt: integer('created_at').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+  },
+  (t) => [
+    index('idx_personal_agents_user').on(t.userId),
+    index('idx_personal_agents_agent').on(t.agentId),
+    index('idx_personal_agents_status').on(t.provisioningStatus),
+  ],
+);

package/src/schema/reliability-events.ts

@@ -0,0 +1,32 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const reliabilityEvents = sqliteTable(
+  'reliability_events',
+  {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    agentId: text('agent_id'),
+    category: text('category', {
+      enum: ['cron', 'browser', 'timezone', 'general', 'auth', 'skill', 'agent', 'gateway'],
+    }).notNull(),
+    severity: text('severity', { enum: ['critical', 'high', 'medium', 'low', 'ok'] }).notNull(),
+    event: text('event').notNull(),
+    message: text('message').notNull(),
+    metadata: text('metadata'),
+    occurredAt: integer('occurred_at').notNull(),
+    createdAt: integer('created_at').notNull(),
+  },
+  (t) => [
+    index('idx_rel_events_server_cat_time').on(t.serverId, t.category, t.occurredAt),
+    index('idx_rel_events_server_time').on(t.serverId, t.occurredAt),
+    index('idx_rel_events_server_sev_time').on(t.serverId, t.severity, t.occurredAt),
+    index('idx_rel_events_tenant').on(t.tenantId),
+  ],
+);

package/src/schema/server-backups.ts

@@ -0,0 +1,27 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const serverBackups = sqliteTable(
+  'server_backups',
+  {
+    id: text('id').primaryKey(),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    snapshotPath: text('snapshot_path').notNull(),
+    timestamp: integer('timestamp').notNull(),
+    sizeBytes: integer('size_bytes'),
+    status: text('status', { enum: ['running', 'complete', 'failed'] })
+      .notNull()
+      .default('running'),
+    createdAt: integer('created_at').notNull(),
+  },
+  (t) => [
+    index('idx_server_backups_server').on(t.serverId),
+    index('idx_server_backups_tenant').on(t.tenantId),
+  ],
+);

package/src/schema/server-provision-configs.ts

@@ -0,0 +1,57 @@
+import { sqliteTable, text, integer, index, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const serverProvisionConfigs = sqliteTable(
+  'server_provision_configs',
+  {
+    id: text('id').primaryKey(),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+
+    // SSH connection
+    sshHost: text('ssh_host'),
+    sshUser: text('ssh_user').default('root'),
+    sshPort: integer('ssh_port').default(22),
+
+    // Credentials (encrypted)
+    apiKey: text('api_key'),
+    apiKeyIv: text('api_key_iv'),
+
+    // Agent config
+    agentName: text('agent_name'),
+    sandboxMode: text('sandbox_mode', { enum: ['non-main', 'always', 'never'] }).default(
+      'non-main',
+    ),
+    dmPolicy: text('dm_policy', { enum: ['pairing', 'solo', 'disabled'] }).default('pairing'),
+
+    // Install config
+    installMethod: text('install_method', { enum: ['package', 'source'] }).default('package'),
+    pkgManager: text('pkg_manager', { enum: ['npm', 'bun'] }).default('npm'),
+
+    // Gateway config
+    gatewayPort: integer('gateway_port').default(18789),
+    gatewayBind: text('gateway_bind', { enum: ['loopback', 'all'] }).default('loopback'),
+
+    // Channel toggles
+    enableWhatsapp: integer('enable_whatsapp').default(0),
+    enableTelegram: integer('enable_telegram').default(0),
+    enableDiscord: integer('enable_discord').default(0),
+
+    // Provision state
+    phaseStatuses: text('phase_statuses').default('{}'),
+    lastProvisionAt: integer('last_provision_at'),
+
+    // Timestamps
+    createdAt: integer('created_at').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+  },
+  (t) => [
+    uniqueIndex('provision_configs_uniq_server').on(t.serverId),
+    index('idx_provision_configs_tenant').on(t.tenantId),
+  ],
+);

package/src/schema/servers.ts

@@ -0,0 +1,26 @@
+import { sqliteTable, text, integer, index, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+
+export const servers = sqliteTable(
+  'servers',
+  {
+    id: text('id').primaryKey(),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    name: text('name').notNull(),
+    url: text('url').notNull(),
+    token: text('token').notNull().default(''),
+    tokenIv: text('token_iv').notNull().default(''),
+    authMode: text('auth_mode', { enum: ['token', 'none'] })
+      .notNull()
+      .default('token'),
+    lastConnectedAt: integer('last_connected_at'),
+    createdAt: integer('created_at').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+  },
+  (t) => [
+    index('idx_servers_tenant').on(t.tenantId),
+    uniqueIndex('servers_uniq_url').on(t.tenantId, t.url),
+  ],
+);

package/src/schema/session-tasks.ts

@@ -0,0 +1,30 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const sessionTasks = sqliteTable(
+  'session_tasks',
+  {
+    id: text('id').primaryKey(),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    sessionKey: text('session_key').notNull(),
+    title: text('title').notNull(),
+    description: text('description'),
+    status: text('status', { enum: ['backlog', 'todo', 'in_progress', 'done'] })
+      .notNull()
+      .default('backlog'),
+    sortOrder: integer('sort_order').notNull().default(0),
+    metadata: text('metadata'),
+    createdAt: integer('created_at').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+  },
+  (t) => [
+    index('idx_session_tasks_tenant').on(t.tenantId),
+    index('idx_session_tasks_server_session').on(t.serverId, t.sessionKey),
+  ],
+);

package/src/schema/sessions.ts

@@ -0,0 +1,31 @@
+import { sqliteTable, text, integer, index, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const sessions = sqliteTable(
+  'sessions',
+  {
+    id: text('id').primaryKey(),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    agentId: text('agent_id').notNull(),
+    sessionKey: text('session_key').notNull(),
+    status: text('status', { enum: ['running', 'thinking', 'idle', 'aborted', 'completed'] })
+      .notNull()
+      .default('idle'),
+    metadata: text('metadata'),
+    startedAt: integer('started_at'),
+    endedAt: integer('ended_at'),
+    createdAt: integer('created_at').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+  },
+  (t) => [
+    index('idx_sessions_tenant').on(t.tenantId),
+    index('idx_sessions_server').on(t.serverId),
+    uniqueIndex('sessions_uniq_key').on(t.tenantId, t.serverId, t.sessionKey),
+  ],
+);

package/src/schema/settings.ts

@@ -0,0 +1,23 @@
+import { sqliteTable, text, integer, index, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const settings = sqliteTable(
+  'settings',
+  {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    section: text('section').notNull(),
+    value: text('value').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+  },
+  (t) => [
+    uniqueIndex('uq_settings_server_section').on(t.serverId, t.section),
+    index('idx_settings_tenant').on(t.tenantId),
+  ],
+);

package/src/schema/skill-execution-stats.ts

@@ -0,0 +1,28 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const skillExecutionStats = sqliteTable(
+  'skill_execution_stats',
+  {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    agentId: text('agent_id'),
+    skillName: text('skill_name').notNull(),
+    sessionKey: text('session_key'),
+    status: text('status', { enum: ['ok', 'auth_error', 'timeout', 'error'] }).notNull(),
+    durationMs: integer('duration_ms'),
+    errorMessage: text('error_message'),
+    occurredAt: integer('occurred_at').notNull(),
+    createdAt: integer('created_at').notNull(),
+  },
+  (t) => [
+    index('idx_skill_stats_server_skill_time').on(t.serverId, t.skillName, t.occurredAt),
+    index('idx_skill_stats_tenant').on(t.tenantId),
+  ],
+);

package/src/schema/skills.ts

@@ -0,0 +1,28 @@
+import { sqliteTable, text, integer, index, primaryKey } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const skills = sqliteTable(
+  'skills',
+  {
+    skillKey: text('skill_key').notNull(),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    name: text('name').notNull(),
+    description: text('description'),
+    emoji: text('emoji'),
+    bundled: integer('bundled', { mode: 'boolean' }).notNull().default(false),
+    disabled: integer('disabled', { mode: 'boolean' }).notNull().default(false),
+    eligible: integer('eligible', { mode: 'boolean' }).notNull().default(false),
+    rawJson: text('raw_json').notNull(),
+    lastSeenAt: integer('last_seen_at').notNull(),
+  },
+  (t) => [
+    primaryKey({ columns: [t.skillKey, t.serverId] }),
+    index('idx_skills_tenant').on(t.tenantId),
+  ],
+);

package/src/schema/tasks.ts

@@ -0,0 +1,26 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { missions } from './missions.js';
+
+export const tasks = sqliteTable(
+  'tasks',
+  {
+    id: text('id').primaryKey(),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    missionId: text('mission_id')
+      .notNull()
+      .references(() => missions.id, { onDelete: 'cascade' }),
+    title: text('title').notNull(),
+    description: text('description'),
+    status: text('status', { enum: ['backlog', 'todo', 'in_progress', 'done'] })
+      .notNull()
+      .default('backlog'),
+    sortOrder: integer('sort_order').notNull().default(0),
+    metadata: text('metadata'),
+    createdAt: integer('created_at').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+  },
+  (t) => [index('idx_tasks_tenant').on(t.tenantId), index('idx_tasks_mission').on(t.missionId)],
+);

package/src/schema/unified-events.ts

@@ -0,0 +1,33 @@
+import { sqliteTable, text, integer, index, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { organization } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const unifiedEvents = sqliteTable(
+  'unified_events',
+  {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    tenantId: text('tenant_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    localEventId: integer('local_event_id').notNull(),
+    category: text('category').notNull(),
+    severity: text('severity', { enum: ['critical', 'high', 'medium', 'low', 'info'] }).notNull(),
+    event: text('event').notNull(),
+    message: text('message').notNull(),
+    agentId: text('agent_id'),
+    correlationId: text('correlation_id'),
+    metadata: text('metadata'),
+    occurredAt: integer('occurred_at').notNull(),
+    createdAt: integer('created_at').notNull(),
+  },
+  (t) => [
+    index('idx_unified_events_tenant').on(t.tenantId),
+    index('idx_unified_events_server_cat_time').on(t.serverId, t.category, t.occurredAt),
+    index('idx_unified_events_server_time').on(t.serverId, t.occurredAt),
+    index('idx_unified_events_correlation').on(t.correlationId),
+    uniqueIndex('idx_unified_events_dedup').on(t.tenantId, t.serverId, t.localEventId),
+  ],
+);

package/src/schema/user-agents.ts

@@ -0,0 +1,21 @@
+import { sqliteTable, text, integer, primaryKey, index } from 'drizzle-orm/sqlite-core';
+import { user } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const userAgents = sqliteTable(
+  'user_agents',
+  {
+    userId: text('user_id')
+      .notNull()
+      .references(() => user.id, { onDelete: 'cascade' }),
+    agentId: text('agent_id').notNull(),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    createdAt: integer('created_at').notNull(),
+  },
+  (t) => [
+    primaryKey({ columns: [t.userId, t.agentId, t.serverId] }),
+    index('idx_user_agents_server').on(t.serverId),
+  ],
+);

package/src/schema/user-preferences.ts

@@ -0,0 +1,19 @@
+import { sqliteTable, text, integer, uniqueIndex, index } from 'drizzle-orm/sqlite-core';
+import { user } from './auth/index.js';
+
+export const userPreferences = sqliteTable(
+  'user_preferences',
+  {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    userId: text('user_id')
+      .notNull()
+      .references(() => user.id, { onDelete: 'cascade' }),
+    section: text('section').notNull(),
+    value: text('value').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+  },
+  (t) => [
+    uniqueIndex('uq_user_prefs_user_section').on(t.userId, t.section),
+    index('idx_user_prefs_user').on(t.userId),
+  ],
+);

package/src/schema/user-servers.ts

@@ -0,0 +1,20 @@
+import { sqliteTable, text, integer, primaryKey, index } from 'drizzle-orm/sqlite-core';
+import { user } from './auth/index.js';
+import { servers } from './servers.js';
+
+export const userServers = sqliteTable(
+  'user_servers',
+  {
+    userId: text('user_id')
+      .notNull()
+      .references(() => user.id, { onDelete: 'cascade' }),
+    serverId: text('server_id')
+      .notNull()
+      .references(() => servers.id, { onDelete: 'cascade' }),
+    createdAt: integer('created_at').notNull(),
+  },
+  (t) => [
+    primaryKey({ columns: [t.userId, t.serverId] }),
+    index('idx_user_servers_server').on(t.serverId),
+  ],
+);

package/src/schema/workshop-saves.ts

@@ -0,0 +1,12 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
+
+export const workshopSaves = sqliteTable('workshop_saves', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  state: text('state').notNull(), // JSON string of WorkshopState
+  thumbnail: text('thumbnail'), // base64 PNG data-URI, nullable
+  userId: text('user_id'), // owner — null for pre-migration rows (treated as shared)
+  tenantId: text('tenant_id'), // tenant scope — null for pre-migration rows
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});

package/src/utils.ts

@@ -0,0 +1,11 @@
+import { init } from '@paralleldrive/cuid2';
+
+const createId = init({ length: 24 });
+
+export function newId(): string {
+  return createId();
+}
+
+export function nowMs(): number {
+  return Date.now();
+}