@minion-stack/db 0.3.1 → 0.6.0

package/src/pg/schema/builder.ts

@@ -0,0 +1,205 @@
+import { pgTable, uuid, text, integer, real, timestamp, index } from 'drizzle-orm/pg-core';
+import { gateway } from './gateway.js';
+
+/**
+ * Visual builder (Workshop) tables. Mirrors Turso `built_*` / `agent_built_skills`.
+ * FK remap on migration:
+ *   server_id  → gateway_id (gateway.id, matched via gateway.legacy_server_id)
+ *   tenant_id  → organizations.id (plain uuid, soft ref — enforced via RLS)
+ *   created_by → kept as text (loose audit field, may be a legacy user id)
+ *   created_at / updated_at / published_at (integer epoch) → timestamptz
+ */
+
+// ── Built Skills ──────────────────────────────────────────────────────
+export const builtSkills = pgTable(
+  'built_skills',
+  {
+    id: text('id').primaryKey(),
+    name: text('name').notNull(),
+    description: text('description').default(''),
+    emoji: text('emoji').default('📖'),
+    status: text('status', { enum: ['draft', 'published'] })
+      .notNull()
+      .default('draft'),
+    maxCycles: integer('max_cycles').notNull().default(3),
+    gatewayId: uuid('gateway_id').references(() => gateway.id, { onDelete: 'cascade' }),
+    tenantId: uuid('tenant_id'),
+    createdBy: text('created_by'),
+    publishedAt: timestamp('published_at', { withTimezone: true }),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    index('idx_built_skills_gateway').on(t.gatewayId),
+    index('idx_built_skills_tenant').on(t.tenantId),
+  ],
+);
+
+// ── Skill Tool Pool (junction: skill → gateway tool IDs) ─────────────
+export const builtSkillTools = pgTable(
+  'built_skill_tools',
+  {
+    id: text('id').primaryKey(),
+    skillId: text('skill_id')
+      .notNull()
+      .references(() => builtSkills.id, { onDelete: 'cascade' }),
+    toolId: text('tool_id').notNull(),
+  },
+  (t) => [index('idx_built_skill_tools_skill').on(t.skillId)],
+);
+
+// ── Chapters (subprocess nodes in the DAG) ───────────────────────────
+export const builtChapters = pgTable(
+  'built_chapters',
+  {
+    id: text('id').primaryKey(),
+    skillId: text('skill_id')
+      .notNull()
+      .references(() => builtSkills.id, { onDelete: 'cascade' }),
+    type: text('type', { enum: ['chapter', 'condition'] })
+      .notNull()
+      .default('chapter'),
+    name: text('name').notNull(),
+    description: text('description').default(''),
+    guide: text('guide').default(''),
+    context: text('context').default(''),
+    outputDef: text('output_def').default(''),
+    conditionText: text('condition_text').default(''),
+    positionX: real('position_x').notNull().default(0),
+    positionY: real('position_y').notNull().default(0),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [index('idx_built_chapters_skill').on(t.skillId)],
+);
+
+// ── Chapter Edges (DAG connections between chapters) ─────────────────
+export const builtChapterEdges = pgTable(
+  'built_chapter_edges',
+  {
+    id: text('id').primaryKey(),
+    skillId: text('skill_id')
+      .notNull()
+      .references(() => builtSkills.id, { onDelete: 'cascade' }),
+    sourceChapterId: text('source_chapter_id')
+      .notNull()
+      .references(() => builtChapters.id, { onDelete: 'cascade' }),
+    targetChapterId: text('target_chapter_id')
+      .notNull()
+      .references(() => builtChapters.id, { onDelete: 'cascade' }),
+    label: text('label'),
+  },
+  (t) => [index('idx_built_chapter_edges_skill').on(t.skillId)],
+);
+
+// ── Chapter Tools (junction: chapter → subset of skill's tool pool) ──
+export const builtChapterTools = pgTable(
+  'built_chapter_tools',
+  {
+    id: text('id').primaryKey(),
+    chapterId: text('chapter_id')
+      .notNull()
+      .references(() => builtChapters.id, { onDelete: 'cascade' }),
+    toolId: text('tool_id').notNull(),
+  },
+  (t) => [index('idx_built_chapter_tools_chapter').on(t.chapterId)],
+);
+
+// ── Built Agents ─────────────────────────────────────────────────────
+export const builtAgents = pgTable(
+  'built_agents',
+  {
+    id: text('id').primaryKey(),
+    name: text('name').notNull(),
+    emoji: text('emoji').default('🤖'),
+    description: text('description').default(''),
+    model: text('model'),
+    systemPrompt: text('system_prompt').default(''),
+    temperature: real('temperature').default(0.7),
+    maxTokens: integer('max_tokens').default(4096),
+    retryPolicy: text('retry_policy').default('{}'),
+    fallbackAgentId: text('fallback_agent_id'),
+    status: text('status', { enum: ['draft', 'published'] })
+      .notNull()
+      .default('draft'),
+    gatewayId: uuid('gateway_id').references(() => gateway.id, { onDelete: 'cascade' }),
+    tenantId: uuid('tenant_id'),
+    createdBy: text('created_by'),
+    publishedAt: timestamp('published_at', { withTimezone: true }),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    index('idx_built_agents_gateway').on(t.gatewayId),
+    index('idx_built_agents_tenant').on(t.tenantId),
+  ],
+);
+
+// ── Agent Skill Slots (junction: agent → skill with order) ───────────
+export const builtAgentSkills = pgTable(
+  'built_agent_skills',
+  {
+    id: text('id').primaryKey(),
+    agentId: text('agent_id')
+      .notNull()
+      .references(() => builtAgents.id, { onDelete: 'cascade' }),
+    skillId: text('skill_id')
+      .notNull()
+      .references(() => builtSkills.id, { onDelete: 'cascade' }),
+    position: integer('position').notNull().default(0),
+    configOverrides: text('config_overrides').default('{}'),
+  },
+  (t) => [index('idx_built_agent_skills_agent').on(t.agentId)],
+);
+
+// ── Agent Built Skills (junction: gateway agent → built skill) ────────
+export const agentBuiltSkills = pgTable(
+  'agent_built_skills',
+  {
+    id: text('id').primaryKey(),
+    gatewayAgentId: text('gateway_agent_id').notNull(),
+    gatewayId: uuid('gateway_id')
+      .notNull()
+      .references(() => gateway.id, { onDelete: 'cascade' }),
+    tenantId: uuid('tenant_id').notNull(),
+    skillId: text('skill_id')
+      .notNull()
+      .references(() => builtSkills.id, { onDelete: 'cascade' }),
+    position: integer('position').notNull().default(0),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    index('idx_agent_built_skills_gateway_agent').on(t.gatewayAgentId),
+    index('idx_agent_built_skills_tenant').on(t.tenantId),
+  ],
+);
+
+// ── Built Tools (admin-only playground) ──────────────────────────────
+export const builtTools = pgTable(
+  'built_tools',
+  {
+    id: text('id').primaryKey(),
+    name: text('name').notNull(),
+    description: text('description').default(''),
+    scriptCode: text('script_code').default(''),
+    scriptLang: text('script_lang', { enum: ['javascript', 'python', 'bash'] })
+      .notNull()
+      .default('javascript'),
+    envVars: text('env_vars').default('{}'),
+    validationRules: text('validation_rules').default('{}'),
+    executionConfig: text('execution_config').default('{}'),
+    status: text('status', { enum: ['draft', 'published'] })
+      .notNull()
+      .default('draft'),
+    gatewayId: uuid('gateway_id').references(() => gateway.id, { onDelete: 'cascade' }),
+    tenantId: uuid('tenant_id'),
+    createdBy: text('created_by'),
+    publishedAt: timestamp('published_at', { withTimezone: true }),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    index('idx_built_tools_gateway').on(t.gatewayId),
+    index('idx_built_tools_tenant').on(t.tenantId),
+  ],
+);

package/src/pg/schema/channels.ts

@@ -0,0 +1,77 @@
+import { pgTable, uuid, text, timestamp, index, uniqueIndex } from 'drizzle-orm/pg-core';
+import { gateway } from './gateway.js';
+import { profiles } from './profiles.js';
+
+/**
+ * Channel connections + assignments + identity mappings.
+ * Mirrors Turso `channels` / `channel_assignments` / `channel_identities`.
+ * FK remap: server_id → gateway_id (gateway.id via legacy_server_id),
+ * tenant_id → organizations.id (plain uuid soft-ref, RLS-enforced),
+ * user_id → profiles.id (matched via profiles.legacy_user_id).
+ */
+
+export const channels = pgTable(
+  'channels',
+  {
+    id: text('id').primaryKey(),
+    tenantId: uuid('tenant_id').notNull(),
+    gatewayId: uuid('gateway_id')
+      .notNull()
+      .references(() => gateway.id, { onDelete: 'cascade' }),
+    type: text('type', { enum: ['discord', 'whatsapp', 'telegram'] }).notNull(),
+    label: text('label').notNull(),
+    credentials: text('credentials').notNull().default(''),
+    credentialsIv: text('credentials_iv').notNull().default(''),
+    credentialsMeta: text('credentials_meta').notNull().default('{}'),
+    status: text('status', { enum: ['active', 'inactive', 'pairing'] })
+      .notNull()
+      .default('inactive'),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    index('idx_channels_tenant_gateway').on(t.tenantId, t.gatewayId),
+    uniqueIndex('channels_uniq_type_label').on(t.tenantId, t.gatewayId, t.type, t.label),
+  ],
+);
+
+export const channelAssignments = pgTable(
+  'channel_assignments',
+  {
+    id: text('id').primaryKey(),
+    tenantId: uuid('tenant_id').notNull(),
+    channelId: text('channel_id')
+      .notNull()
+      .references(() => channels.id, { onDelete: 'cascade' }),
+    targetType: text('target_type', { enum: ['user', 'session'] }).notNull(),
+    targetId: text('target_id').notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    index('idx_channel_assign_channel').on(t.channelId),
+    uniqueIndex('channel_assign_uniq').on(t.channelId, t.targetType, t.targetId),
+  ],
+);
+
+/**
+ * Maps channel sender IDs (e.g. telegram:12345) to hub users.
+ * Used by the gateway to resolve user identity from channel messages.
+ */
+export const channelIdentities = pgTable(
+  'channel_identities',
+  {
+    id: text('id').primaryKey(),
+    userId: uuid('user_id')
+      .notNull()
+      .references(() => profiles.id, { onDelete: 'cascade' }),
+    channel: text('channel').notNull(),
+    channelUserId: text('channel_user_id').notNull(),
+    displayName: text('display_name'),
+    verifiedAt: timestamp('verified_at', { withTimezone: true }),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    uniqueIndex('idx_channel_identity_unique').on(t.channel, t.channelUserId),
+    index('idx_channel_identity_user').on(t.userId),
+  ],
+);

package/src/pg/schema/chat-messages.ts

@@ -0,0 +1,30 @@
+import { pgTable, uuid, text, bigserial, timestamp, index } from 'drizzle-orm/pg-core';
+import { gateway } from './gateway.js';
+
+/**
+ * Persisted chat transcript. Mirrors Turso `chat_messages`.
+ * FK remap: server_id → gateway_id, tenant_id → organizations.id (soft-ref).
+ * id: SQLite autoincrement integer → Postgres bigserial.
+ * timestamp / created_at: integer epoch (ms) → timestamptz.
+ */
+export const chatMessages = pgTable(
+  'chat_messages',
+  {
+    id: bigserial('id', { mode: 'number' }).primaryKey(),
+    tenantId: uuid('tenant_id').notNull(),
+    gatewayId: uuid('gateway_id')
+      .notNull()
+      .references(() => gateway.id, { onDelete: 'cascade' }),
+    agentId: text('agent_id').notNull(),
+    sessionKey: text('session_key').notNull(),
+    role: text('role', { enum: ['user', 'assistant'] }).notNull(),
+    content: text('content').notNull(),
+    runId: text('run_id'),
+    timestamp: timestamp('timestamp', { withTimezone: true }).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    index('idx_chat_tenant').on(t.tenantId),
+    index('idx_chat_by_agent').on(t.agentId, t.sessionKey, t.timestamp),
+  ],
+);

package/src/pg/schema/device-identities.ts

@@ -0,0 +1,11 @@
+import { pgTable, uuid, text, timestamp } from 'drizzle-orm/pg-core';
+
+/** Per-tenant device keypair. Mirrors Turso `device_identities`. tenant_id → organizations.id. */
+export const deviceIdentities = pgTable('device_identities', {
+  id: text('id').primaryKey(),
+  tenantId: uuid('tenant_id').notNull().unique(),
+  deviceId: text('device_id').notNull(),
+  publicKeyPem: text('public_key_pem').notNull(),
+  privateKeyPem: text('private_key_pem').notNull(),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+});

package/src/pg/schema/files.ts

@@ -0,0 +1,19 @@
+import { pgTable, uuid, text, bigint, timestamp, index } from 'drizzle-orm/pg-core';
+import { profiles } from './profiles.js';
+
+/** B2-backed file records. Mirrors Turso `files`. tenant_id → organizations.id, uploaded_by → profiles.id. */
+export const files = pgTable(
+  'files',
+  {
+    id: text('id').primaryKey(),
+    tenantId: uuid('tenant_id').notNull(),
+    uploadedBy: uuid('uploaded_by').references(() => profiles.id, { onDelete: 'set null' }),
+    b2FileKey: text('b2_file_key').notNull(),
+    fileName: text('file_name').notNull(),
+    contentType: text('content_type').notNull(),
+    sizeBytes: bigint('size_bytes', { mode: 'number' }).notNull(),
+    category: text('category').notNull().default('general'),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [index('idx_files_tenant').on(t.tenantId)],
+);

package/src/pg/schema/index.ts

@@ -12,3 +12,39 @@ export type {
 } from '../identity-mapper.js';
 export { sealSecret, openSecret } from '../crypto.js';
 export { gateway, userGateway } from './gateway.js';
+export { messages } from './messages.js';
+// App tables migrated off Turso (telemetry/app split) — see
+// docs/superpowers/specs/2026-06-05-turso-supabase-split-migration.md
+export { userPreferences } from './user-preferences.js';
+export { personalAgents } from './personal-agents.js';
+export { settings } from './settings.js';
+export { workshopSaves } from './workshop-saves.js';
+export { deviceIdentities } from './device-identities.js';
+export { files } from './files.js';
+export { agentGroups, agentGroupMembers } from './agent-groups.js';
+export { marketplaceAgents, marketplaceInstalls } from './marketplace.js';
+export {
+  builtSkills,
+  builtSkillTools,
+  builtChapters,
+  builtChapterEdges,
+  builtChapterTools,
+  builtAgents,
+  builtAgentSkills,
+  agentBuiltSkills,
+  builtTools,
+} from './builder.js';
+export { channels, channelAssignments, channelIdentities } from './channels.js';
+export { sessions, sessionTasks } from './sessions.js';
+export { missions, tasks } from './missions.js';
+export { chatMessages } from './chat-messages.js';
+export { userAgents } from './user-agents.js';
+export { skills, skillExecutionStats } from './skills.js';
+export {
+  serverBackups,
+  serverProvisionConfigs,
+  backupConfigs,
+  configSnapshots,
+} from './server-ops.js';
+export { workspaceMembership } from './workspace-membership.js';
+export type { WorkspaceMembership, NewWorkspaceMembership } from './workspace-membership.js';

package/src/pg/schema/marketplace.ts

@@ -0,0 +1,47 @@
+import { pgTable, uuid, text, integer, timestamp, index } from 'drizzle-orm/pg-core';
+import { gateway } from './gateway.js';
+
+/** Marketplace agent catalog. Mirrors Turso `marketplace_agents`. */
+export const marketplaceAgents = pgTable('marketplace_agents', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  role: text('role').notNull(),
+  category: text('category').notNull(),
+  tags: text('tags').notNull(),
+  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: timestamp('synced_at', { withTimezone: true }).notNull().defaultNow(),
+  filesLoadedAt: timestamp('files_loaded_at', { withTimezone: true }),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+/** Per-tenant marketplace installs. tenant_id → organizations.id, server_id → gateway.id. */
+export const marketplaceInstalls = pgTable(
+  'marketplace_installs',
+  {
+    id: text('id').primaryKey(),
+    tenantId: uuid('tenant_id').notNull(),
+    agentId: text('agent_id')
+      .notNull()
+      .references(() => marketplaceAgents.id, { onDelete: 'cascade' }),
+    gatewayId: uuid('gateway_id')
+      .notNull()
+      .references(() => gateway.id, { onDelete: 'cascade' }),
+    installedAt: timestamp('installed_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    index('idx_marketplace_installs_tenant').on(t.tenantId),
+    index('idx_marketplace_installs_agent').on(t.agentId),
+  ],
+);

package/src/pg/schema/messages.ts

@@ -0,0 +1,48 @@
+import { pgTable, uuid, text, boolean, timestamp, jsonb, index, uniqueIndex } from 'drizzle-orm/pg-core';
+
+/**
+ * Universal, org-scoped message ledger. Every comms channel writes here via the
+ * gateway outbox → hub ingest path. Standard columns are the cross-channel
+ * intersection; anything channel-specific goes in `metadata`.
+ *
+ * RLS (org isolation) is added in the hand-written companion migration
+ * `<ts>_messages_rls.sql` (role app_ledger + app.current_org_id GUC). Drizzle
+ * does not manage roles/policies.
+ */
+export const messages = pgTable(
+  'messages',
+  {
+    id: uuid('id').primaryKey().defaultRandom(),
+    // Ingest idempotency key, generated by the gateway per row.
+    clientId: text('client_id').notNull(),
+    // RLS pivot. Better Auth org id (text), matches flows.tenant_id convention.
+    orgId: text('org_id').notNull(),
+    // Producing gateway/server id (hub servers.id; text — not a PG uuid).
+    gatewayId: text('gateway_id'),
+    direction: text('direction', { enum: ['inbound', 'outbound'] }).notNull(),
+    channel: text('channel').notNull(),
+    accountId: text('account_id'),
+    chatId: text('chat_id'),
+    isGroup: boolean('is_group'),
+    senderId: text('sender_id'),
+    senderName: text('sender_name'),
+    senderHandle: text('sender_handle'),
+    isBot: boolean('is_bot'),
+    content: text('content'),
+    messageId: text('message_id'),
+    agentId: text('agent_id'),
+    sessionKey: text('session_key'),
+    success: boolean('success'),
+    error: text('error'),
+    occurredAt: timestamp('occurred_at', { withTimezone: true }),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    metadata: jsonb('metadata').notNull().default({}),
+  },
+  (t) => ({
+    clientIdUnique: uniqueIndex('messages_client_id_uniq').on(t.clientId),
+    orgChatIdx: index('messages_org_chat_idx').on(t.orgId, t.channel, t.chatId, t.occurredAt),
+    orgTimeIdx: index('messages_org_time_idx').on(t.orgId, t.occurredAt),
+    orgAgentIdx: index('messages_org_agent_idx').on(t.orgId, t.agentId),
+    messageIdIdx: index('messages_message_id_idx').on(t.messageId),
+  }),
+);

package/src/pg/schema/missions.ts

@@ -0,0 +1,58 @@
+import { pgTable, uuid, text, integer, timestamp, index } from 'drizzle-orm/pg-core';
+import { gateway } from './gateway.js';
+import { sessions } from './sessions.js';
+
+/**
+ * Missions (per-session goals) + their tasks.
+ * Mirrors Turso `missions` / `tasks`.
+ * FK remap: server_id → gateway_id, tenant_id → organizations.id (soft-ref),
+ * session_id → sessions.id, integer epoch timestamps → timestamptz.
+ */
+
+export const missions = pgTable(
+  'missions',
+  {
+    id: text('id').primaryKey(),
+    tenantId: uuid('tenant_id').notNull(),
+    gatewayId: uuid('gateway_id')
+      .notNull()
+      .references(() => gateway.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: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    index('idx_missions_tenant').on(t.tenantId),
+    index('idx_missions_session').on(t.sessionId),
+    index('idx_missions_gateway').on(t.gatewayId),
+  ],
+);
+
+export const tasks = pgTable(
+  'tasks',
+  {
+    id: text('id').primaryKey(),
+    tenantId: uuid('tenant_id').notNull(),
+    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: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [index('idx_tasks_tenant').on(t.tenantId), index('idx_tasks_mission').on(t.missionId)],
+);

package/src/pg/schema/personal-agents.ts

@@ -0,0 +1,44 @@
+import { pgTable, uuid, text, boolean, integer, timestamp, index } from 'drizzle-orm/pg-core';
+import { profiles } from './profiles.js';
+import { gateway } from './gateway.js';
+
+/**
+ * Per-user personal agent. Mirrors Turso `personal_agents`.
+ * FK remap on migration: user_id → profile_id (profiles.id),
+ * server_id → gateway_id (gateway.id, matched via gateway.legacy_server_id).
+ */
+export const personalAgents = pgTable(
+  'personal_agents',
+  {
+    id: text('id').primaryKey(),
+    profileId: uuid('profile_id')
+      .notNull()
+      .unique()
+      .references(() => profiles.id, { onDelete: 'cascade' }),
+    agentId: text('agent_id').notNull(),
+    gatewayId: uuid('gateway_id').references(() => gateway.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: boolean('personality_configured').notNull().default(false),
+    provisioningStatus: text('provisioning_status', {
+      enum: ['pending', 'provisioning', 'active', 'error'],
+    })
+      .notNull()
+      .default('pending'),
+    provisioningError: text('provisioning_error'),
+    lastRetryAt: timestamp('last_retry_at', { withTimezone: true }),
+    retryCount: integer('retry_count').notNull().default(0),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    index('idx_personal_agents_profile').on(t.profileId),
+    index('idx_personal_agents_agent').on(t.agentId),
+    index('idx_personal_agents_status').on(t.provisioningStatus),
+  ],
+);

package/src/pg/schema/profiles.ts

@@ -11,6 +11,8 @@ export const profiles = pgTable('profiles', {
   id: uuid('id').primaryKey(), // == auth.users.id
   email: text('email').notNull(),
   displayName: text('display_name'),
+  // Public avatar URL (B2-served signed URL or external provider image).
+  avatarUrl: text('avatar_url'),
   role: text('role', { enum: ['user', 'admin'] })
     .notNull()
     .default('user'),