@controlflow-ai/daemon 0.1.0

package/src/migrations/005_artifacts.ts

@@ -0,0 +1,24 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 5;
+export const name = 'artifacts';
+
+export function up(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS artifacts (
+      id TEXT PRIMARY KEY,
+      token_hash TEXT NOT NULL UNIQUE,
+      title TEXT NOT NULL DEFAULT '',
+      filename TEXT NOT NULL DEFAULT '',
+      mime_type TEXT NOT NULL,
+      size_bytes INTEGER NOT NULL,
+      content BLOB NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      expires_at TEXT NOT NULL,
+      revoked_at TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_artifacts_expires_at ON artifacts(expires_at);
+    CREATE INDEX IF NOT EXISTS idx_artifacts_revoked_at ON artifacts(revoked_at);
+  `);
+}

package/src/migrations/006_lark_channel_foundation.ts

@@ -0,0 +1,119 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 6;
+export const name = 'lark_channel_foundation';
+
+export function up(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS channel_accounts (
+      id TEXT PRIMARY KEY,
+      channel TEXT NOT NULL CHECK (channel IN ('lark')),
+      name TEXT NOT NULL,
+      app_id TEXT NOT NULL,
+      bot_open_id TEXT,
+      status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'disabled')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(channel, app_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS channel_conversations (
+      id TEXT PRIMARY KEY,
+      channel_account_id TEXT NOT NULL REFERENCES channel_accounts(id) ON DELETE CASCADE,
+      lock_chat_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
+      conversation_key TEXT NOT NULL UNIQUE,
+      external_chat_id TEXT NOT NULL,
+      external_root_id TEXT,
+      external_thread_id TEXT,
+      scope TEXT NOT NULL CHECK (scope IN ('chat', 'thread', 'p2p')),
+      chat_type TEXT NOT NULL CHECK (chat_type IN ('group', 'p2p')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS lock_transcript_messages (
+      id TEXT PRIMARY KEY,
+      lock_message_id INTEGER REFERENCES messages(id) ON DELETE SET NULL,
+      conversation_id TEXT NOT NULL REFERENCES channel_conversations(id) ON DELETE CASCADE,
+      channel_type TEXT NOT NULL DEFAULT 'lark' CHECK (channel_type IN ('lark', 'internal')),
+      direction TEXT NOT NULL CHECK (direction IN ('inbound', 'outbound', 'internal')),
+      sender_type TEXT NOT NULL CHECK (sender_type IN ('user', 'bot', 'agent', 'system')),
+      sender_id TEXT NOT NULL,
+      recipient_ref TEXT,
+      content TEXT NOT NULL,
+      content_type TEXT NOT NULL DEFAULT 'text',
+      source_type TEXT NOT NULL,
+      source_unique_key TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'recorded' CHECK (status IN ('recorded', 'superseded', 'redacted')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      recorded_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(source_type, source_unique_key)
+    );
+
+    CREATE TABLE IF NOT EXISTS lock_provider_evidence (
+      id TEXT PRIMARY KEY,
+      transcript_message_id TEXT NOT NULL REFERENCES lock_transcript_messages(id) ON DELETE CASCADE,
+      provider TEXT NOT NULL DEFAULT 'lark' CHECK (provider IN ('lark')),
+      provider_message_id TEXT,
+      provider_event_id TEXT,
+      attempt_id TEXT,
+      evidence_type TEXT NOT NULL CHECK (evidence_type IN ('send_attempt', 'send_result', 'send_error', 'receive_event')),
+      receipt_state TEXT NOT NULL CHECK (receipt_state IN ('pending', 'delivered', 'failed', 'unknown')),
+      error_code TEXT,
+      error_message TEXT,
+      raw_payload_redacted_json TEXT NOT NULL DEFAULT '{}',
+      observed_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS channel_messages (
+      id TEXT PRIMARY KEY,
+      channel_account_id TEXT NOT NULL REFERENCES channel_accounts(id) ON DELETE CASCADE,
+      channel_conversation_id TEXT NOT NULL REFERENCES channel_conversations(id) ON DELETE CASCADE,
+      lock_message_id INTEGER REFERENCES messages(id) ON DELETE SET NULL,
+      transcript_message_id TEXT REFERENCES lock_transcript_messages(id) ON DELETE SET NULL,
+      direction TEXT NOT NULL CHECK (direction IN ('inbound', 'outbound')),
+      external_message_id TEXT,
+      external_chat_id TEXT NOT NULL,
+      external_root_id TEXT,
+      external_thread_id TEXT,
+      sender_open_id TEXT,
+      sender_type TEXT NOT NULL DEFAULT 'unknown',
+      raw_type TEXT NOT NULL DEFAULT 'text',
+      status TEXT NOT NULL CHECK (status IN ('mapped', 'ignored', 'rejected', 'sent', 'failed')),
+      reason_code TEXT,
+      source TEXT NOT NULL DEFAULT 'local_fixture' CHECK (source IN ('local_fixture', 'channel_adapter')),
+      admitted INTEGER NOT NULL DEFAULT 0 CHECK (admitted IN (0, 1)),
+      raw_payload_redacted_json TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_channel_messages_external_id
+      ON channel_messages(channel_account_id, external_message_id)
+      WHERE external_message_id IS NOT NULL;
+
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_channel_messages_lock_message
+      ON channel_messages(channel_account_id, lock_message_id, channel_conversation_id, direction)
+      WHERE lock_message_id IS NOT NULL;
+
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_provider_evidence_event_id
+      ON lock_provider_evidence(provider, provider_event_id)
+      WHERE provider_event_id IS NOT NULL;
+
+    CREATE TABLE IF NOT EXISTS channel_outbox (
+      id TEXT PRIMARY KEY,
+      channel_account_id TEXT NOT NULL REFERENCES channel_accounts(id) ON DELETE CASCADE,
+      channel_conversation_id TEXT NOT NULL REFERENCES channel_conversations(id) ON DELETE CASCADE,
+      transcript_message_id TEXT NOT NULL REFERENCES lock_transcript_messages(id) ON DELETE CASCADE,
+      lock_message_id INTEGER NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+      purpose TEXT NOT NULL DEFAULT 'reply',
+      idempotency_key TEXT NOT NULL UNIQUE,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_channel_conversations_account ON channel_conversations(channel_account_id, external_chat_id);
+    CREATE INDEX IF NOT EXISTS idx_transcript_conversation ON lock_transcript_messages(conversation_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_provider_evidence_transcript ON lock_provider_evidence(transcript_message_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_channel_outbox_created_at ON channel_outbox(created_at);
+  `);
+}

package/src/migrations/007_agents_a0.ts

@@ -0,0 +1,17 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 7;
+export const name = 'agents_a0';
+
+export function up(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agents (
+      id TEXT PRIMARY KEY,
+      agent_key TEXT NOT NULL UNIQUE,
+      display_name TEXT NOT NULL,
+      description TEXT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}

package/src/migrations/008_b0_chat_history.ts

@@ -0,0 +1,31 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 8;
+export const name = 'b0_chat_history';
+
+export function up(db: Database): void {
+  db.exec(`
+    ALTER TABLE lock_transcript_messages ADD COLUMN mentions_json TEXT NOT NULL DEFAULT '[]';
+    ALTER TABLE lock_transcript_messages ADD COLUMN reply_to_transcript_id TEXT REFERENCES lock_transcript_messages(id) ON DELETE SET NULL;
+    ALTER TABLE lock_transcript_messages ADD COLUMN quote_root_transcript_id TEXT REFERENCES lock_transcript_messages(id) ON DELETE SET NULL;
+    ALTER TABLE lock_transcript_messages ADD COLUMN quote_message_transcript_id TEXT REFERENCES lock_transcript_messages(id) ON DELETE SET NULL;
+
+    CREATE INDEX IF NOT EXISTS idx_transcript_conversation_order
+      ON lock_transcript_messages(conversation_id, created_at, id);
+
+    CREATE INDEX IF NOT EXISTS idx_transcript_reply_to
+      ON lock_transcript_messages(reply_to_transcript_id);
+
+    CREATE INDEX IF NOT EXISTS idx_transcript_quote_root
+      ON lock_transcript_messages(quote_root_transcript_id);
+
+    CREATE INDEX IF NOT EXISTS idx_channel_conversations_external
+      ON channel_conversations(channel_account_id, external_chat_id, external_thread_id);
+
+    CREATE INDEX IF NOT EXISTS idx_channel_messages_external_thread
+      ON channel_messages(channel_account_id, external_chat_id, external_thread_id);
+
+    CREATE INDEX IF NOT EXISTS idx_channel_messages_external_root
+      ON channel_messages(channel_account_id, external_chat_id, external_root_id);
+  `);
+}

package/src/migrations/009_b0_transcript_ingest_seq.ts

@@ -0,0 +1,35 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 9;
+export const name = 'b0_transcript_ingest_seq';
+
+function hasColumn(db: Database, table: string, column: string): boolean {
+  const rows = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return rows.some((row) => row.name === column);
+}
+
+function hasIndex(db: Database, name: string): boolean {
+  const row = db.query("SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?").get(name) as { name: string } | null;
+  return row !== null;
+}
+
+export function up(db: Database): void {
+  if (!hasColumn(db, 'lock_transcript_messages', 'ingest_seq')) {
+    db.exec('ALTER TABLE lock_transcript_messages ADD COLUMN ingest_seq INTEGER NOT NULL DEFAULT 0');
+    db.exec(`
+      UPDATE lock_transcript_messages
+      SET ingest_seq = (
+        SELECT COUNT(*) FROM lock_transcript_messages AS earlier
+        WHERE earlier.rowid <= lock_transcript_messages.rowid
+      )
+      WHERE ingest_seq = 0;
+    `);
+  }
+
+  if (!hasIndex(db, 'idx_transcript_conversation_ingest_seq')) {
+    db.exec('CREATE INDEX idx_transcript_conversation_ingest_seq ON lock_transcript_messages(conversation_id, ingest_seq)');
+  }
+  if (!hasIndex(db, 'idx_transcript_ingest_seq')) {
+    db.exec('CREATE UNIQUE INDEX idx_transcript_ingest_seq ON lock_transcript_messages(ingest_seq)');
+  }
+}

package/src/migrations/010_b0_transcript_shadow_external_ids.ts

@@ -0,0 +1,32 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 10;
+export const name = 'b0_transcript_shadow_external_ids';
+
+function hasColumn(db: Database, table: string, column: string): boolean {
+  const rows = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return rows.some((row) => row.name === column);
+}
+
+function hasIndex(db: Database, name: string): boolean {
+  const row = db.query("SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?").get(name) as { name: string } | null;
+  return row !== null;
+}
+
+export function up(db: Database): void {
+  for (const column of ['reply_to_external_message_id', 'quote_root_external_message_id', 'quote_message_external_message_id']) {
+    if (!hasColumn(db, 'lock_transcript_messages', column)) {
+      db.exec(`ALTER TABLE lock_transcript_messages ADD COLUMN ${column} TEXT`);
+    }
+  }
+
+  if (!hasIndex(db, 'idx_transcript_reply_external')) {
+    db.exec('CREATE INDEX idx_transcript_reply_external ON lock_transcript_messages(conversation_id, reply_to_external_message_id) WHERE reply_to_external_message_id IS NOT NULL');
+  }
+  if (!hasIndex(db, 'idx_transcript_quote_root_external')) {
+    db.exec('CREATE INDEX idx_transcript_quote_root_external ON lock_transcript_messages(conversation_id, quote_root_external_message_id) WHERE quote_root_external_message_id IS NOT NULL');
+  }
+  if (!hasIndex(db, 'idx_transcript_quote_message_external')) {
+    db.exec('CREATE INDEX idx_transcript_quote_message_external ON lock_transcript_messages(conversation_id, quote_message_external_message_id) WHERE quote_message_external_message_id IS NOT NULL');
+  }
+}

package/src/migrations/011_b0_channel_conversation_audit_only.ts

@@ -0,0 +1,27 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 11;
+export const name = 'b0_channel_conversation_audit_only';
+
+function hasColumn(db: Database, table: string, column: string): boolean {
+  const rows = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return rows.some((row) => row.name === column);
+}
+
+function hasIndex(db: Database, name: string): boolean {
+  const row = db.query("SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?").get(name) as { name: string } | null;
+  return row !== null;
+}
+
+export function up(db: Database): void {
+  if (!hasColumn(db, 'channel_conversations', 'audit_only')) {
+    db.exec('ALTER TABLE channel_conversations ADD COLUMN audit_only INTEGER NOT NULL DEFAULT 0 CHECK (audit_only IN (0, 1))');
+  }
+  if (!hasIndex(db, 'idx_channel_conversations_canonical')) {
+    db.exec(`
+      CREATE INDEX idx_channel_conversations_canonical
+      ON channel_conversations(channel_account_id, external_chat_id, external_thread_id)
+      WHERE audit_only = 0
+    `);
+  }
+}

package/src/migrations/012_b0_cross_conversation_invariant.ts

@@ -0,0 +1,45 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 12;
+export const name = 'b0_cross_conversation_invariant';
+
+interface InvariantViolation {
+  transcript_id: string;
+  conversation_id: string;
+  column: 'reply_to_transcript_id' | 'quote_root_transcript_id' | 'quote_message_transcript_id';
+  referenced_transcript_id: string;
+  referenced_conversation_id: string;
+}
+
+export function up(db: Database): void {
+  const violations: InvariantViolation[] = [];
+
+  for (const column of ['reply_to_transcript_id', 'quote_root_transcript_id', 'quote_message_transcript_id'] as const) {
+    const rows = db.query(`
+      SELECT child.id AS transcript_id,
+             child.conversation_id AS conversation_id,
+             child.${column} AS referenced_transcript_id,
+             parent.conversation_id AS referenced_conversation_id
+      FROM lock_transcript_messages AS child
+      INNER JOIN lock_transcript_messages AS parent
+        ON parent.id = child.${column}
+      WHERE child.${column} IS NOT NULL
+        AND parent.conversation_id <> child.conversation_id
+    `).all() as Array<{
+      transcript_id: string;
+      conversation_id: string;
+      referenced_transcript_id: string;
+      referenced_conversation_id: string;
+    }>;
+    for (const row of rows) {
+      violations.push({ ...row, column });
+    }
+  }
+
+  if (violations.length > 0) {
+    const summary = violations
+      .map((violation) => `${violation.transcript_id}.${violation.column} → ${violation.referenced_transcript_id} (${violation.referenced_conversation_id} != ${violation.conversation_id})`)
+      .join('; ');
+    throw new Error(`CROSS_CONVERSATION_INVARIANT_VIOLATION (migration 012): ${violations.length} row(s): ${summary}`);
+  }
+}

package/src/migrations/013_b1_0_eng_inbound_raw_events.ts

@@ -0,0 +1,56 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 13;
+export const name = 'b1_0_eng_inbound_raw_events';
+
+function hasColumn(db: Database, table: string, column: string): boolean {
+  const rows = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return rows.some((row) => row.name === column);
+}
+
+function hasIndex(db: Database, name: string): boolean {
+  const row = db.query("SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?").get(name) as { name: string } | null;
+  return row !== null;
+}
+
+function hasTable(db: Database, name: string): boolean {
+  const row = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(name) as { name: string } | null;
+  return row !== null;
+}
+
+export function up(db: Database): void {
+  if (!hasTable(db, 'channel_inbound_raw_events')) {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS channel_inbound_raw_events (
+        id TEXT PRIMARY KEY,
+        received_at TEXT NOT NULL DEFAULT (datetime('now')),
+        app_id TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        event_id TEXT NOT NULL,
+        parse_ok INTEGER NOT NULL CHECK (parse_ok IN (0, 1)),
+        raw_body_bytes BLOB NOT NULL
+      );
+    `);
+  } else {
+    if (!hasColumn(db, 'channel_inbound_raw_events', 'event_id')) {
+      db.exec('ALTER TABLE channel_inbound_raw_events ADD COLUMN event_id TEXT NOT NULL DEFAULT ""');
+    }
+    if (!hasColumn(db, 'channel_inbound_raw_events', 'parse_ok')) {
+      db.exec('ALTER TABLE channel_inbound_raw_events ADD COLUMN parse_ok INTEGER NOT NULL DEFAULT 0 CHECK (parse_ok IN (0, 1))');
+    }
+  }
+
+  if (!hasIndex(db, 'idx_raw_events_event_id')) {
+    db.exec(`
+      CREATE UNIQUE INDEX idx_raw_events_event_id
+        ON channel_inbound_raw_events(event_id)
+        WHERE event_id IS NOT NULL;
+    `);
+  }
+  if (!hasIndex(db, 'idx_raw_events_received_at')) {
+    db.exec('CREATE INDEX idx_raw_events_received_at ON channel_inbound_raw_events(received_at)');
+  }
+  if (!hasIndex(db, 'idx_raw_events_app_type')) {
+    db.exec('CREATE INDEX idx_raw_events_app_type ON channel_inbound_raw_events(app_id, event_type)');
+  }
+}

package/src/migrations/014_agents_runtime.ts

@@ -0,0 +1,10 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 14;
+export const name = 'agents_runtime';
+
+export function up(db: Database): void {
+  db.exec(`
+    ALTER TABLE agents ADD COLUMN runtime TEXT NULL;
+  `);
+}

package/src/migrations/015_agent_runtime_sessions.ts

@@ -0,0 +1,15 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 15;
+export const name = 'agent_runtime_sessions';
+
+function hasColumn(db: Database, table: string, column: string): boolean {
+  const rows = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return rows.some((row) => row.name === column);
+}
+
+export function up(db: Database): void {
+  if (!hasColumn(db, 'agent_sessions', 'runtime_session_id')) {
+    db.exec('ALTER TABLE agent_sessions ADD COLUMN runtime_session_id TEXT');
+  }
+}

package/src/migrations/016_room_participants.ts

@@ -0,0 +1,27 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 16;
+export const name = 'room_participants';
+
+export function up(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS room_participants (
+      id TEXT PRIMARY KEY,
+      room_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
+      participant_id TEXT NOT NULL,
+      kind TEXT NOT NULL CHECK (kind IN ('user', 'bot', 'agent')),
+      display_name TEXT,
+      source TEXT NOT NULL CHECK (source IN ('lark_member_api', 'known_bot', 'event', 'local_agent')),
+      last_seen_at TEXT NOT NULL DEFAULT (datetime('now')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(room_id, participant_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_room_participants_room
+      ON room_participants(room_id, kind, participant_id);
+
+    CREATE INDEX IF NOT EXISTS idx_room_participants_seen
+      ON room_participants(room_id, last_seen_at);
+  `);
+}

package/src/migrations/017_unified_room_delivery.ts

@@ -0,0 +1,203 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 17;
+export const name = 'unified_room_delivery';
+
+function hasColumn(db: Database, table: string, column: string): boolean {
+  const rows = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return rows.some((row) => row.name === column);
+}
+
+function addColumnIfMissing(db: Database, table: string, column: string, ddl: string): void {
+  if (!hasColumn(db, table, column)) {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl}`);
+  }
+}
+
+export function up(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS servers (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS users (
+      id TEXT PRIMARY KEY,
+      display_name TEXT NOT NULL,
+      role TEXT NOT NULL DEFAULT 'owner' CHECK (role IN ('owner', 'admin', 'member')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS user_sessions (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+      token_hash TEXT NOT NULL UNIQUE,
+      expires_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS server_memberships (
+      id TEXT PRIMARY KEY,
+      server_id TEXT NOT NULL REFERENCES servers(id) ON DELETE CASCADE,
+      participant_id TEXT NOT NULL,
+      participant_kind TEXT NOT NULL CHECK (participant_kind IN ('user', 'agent')),
+      role TEXT NOT NULL DEFAULT 'member' CHECK (role IN ('owner', 'admin', 'member')),
+      status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'removed')),
+      joined_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(server_id, participant_id, participant_kind)
+    );
+  `);
+
+  db.query(`INSERT OR IGNORE INTO servers (id, name) VALUES ('default', 'Default')`).run();
+  db.query(`INSERT OR IGNORE INTO users (id, display_name, role) VALUES ('owner', 'Owner', 'owner')`).run();
+  db.query(`
+    INSERT OR IGNORE INTO server_memberships (id, server_id, participant_id, participant_kind, role, status)
+    VALUES ('default-owner', 'default', 'owner', 'user', 'owner', 'active')
+  `).run();
+
+  addColumnIfMissing(db, 'chats', 'server_id', `server_id TEXT NOT NULL DEFAULT 'default'`);
+  addColumnIfMissing(db, 'chats', 'provider', `provider TEXT NOT NULL DEFAULT 'web' CHECK (provider IN ('web', 'lark', 'wechat'))`);
+  addColumnIfMissing(db, 'chats', 'dm_type', `dm_type TEXT CHECK (dm_type IN ('agent_agent', 'user_agent', 'user_user'))`);
+  addColumnIfMissing(db, 'chats', 'capabilities_json', `capabilities_json TEXT NOT NULL DEFAULT '{"topics":"native"}'`);
+  addColumnIfMissing(db, 'chats', 'audit_visibility', `audit_visibility TEXT NOT NULL DEFAULT 'members' CHECK (audit_visibility IN ('members', 'admins'))`);
+
+  addColumnIfMissing(db, 'room_participants', 'status', `status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'removed'))`);
+  addColumnIfMissing(db, 'room_participants', 'joined_at', `joined_at TEXT`);
+  addColumnIfMissing(db, 'room_participants', 'delivery_cursor_message_id', `delivery_cursor_message_id INTEGER`);
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS room_channels (
+      id TEXT PRIMARY KEY,
+      room_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
+      kind TEXT NOT NULL DEFAULT 'topic' CHECK (kind IN ('topic')),
+      name TEXT NOT NULL,
+      external_ref TEXT,
+      created_by TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(room_id, name)
+    );
+  `);
+
+  addColumnIfMissing(db, 'messages', 'channel_id', `channel_id TEXT`);
+  addColumnIfMissing(db, 'messages', 'provider', `provider TEXT NOT NULL DEFAULT 'web' CHECK (provider IN ('web', 'lark', 'wechat'))`);
+  addColumnIfMissing(db, 'messages', 'mentions_json', `mentions_json TEXT NOT NULL DEFAULT '[]'`);
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_room_subscriptions (
+      id TEXT PRIMARY KEY,
+      agent TEXT NOT NULL,
+      room_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
+      channel_id TEXT REFERENCES room_channels(id) ON DELETE CASCADE,
+      mode TEXT NOT NULL DEFAULT 'mentions' CHECK (mode IN ('all', 'periodic', 'mentions', 'muted', 'off')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(agent, room_id, channel_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS provider_accounts (
+      id TEXT PRIMARY KEY,
+      provider TEXT NOT NULL CHECK (provider IN ('lark', 'wechat')),
+      external_account_id TEXT NOT NULL,
+      agent TEXT NOT NULL,
+      bot_external_user_id TEXT,
+      status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'disabled')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(provider, external_account_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS provider_conversations (
+      id TEXT PRIMARY KEY,
+      provider_account_id TEXT NOT NULL REFERENCES provider_accounts(id) ON DELETE CASCADE,
+      room_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
+      channel_id TEXT,
+      external_room_id TEXT NOT NULL,
+      external_channel_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_seen_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(provider_account_id, external_room_id, external_channel_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS pending_inbound_events (
+      id TEXT PRIMARY KEY,
+      raw_event_id TEXT NOT NULL,
+      provider TEXT NOT NULL CHECK (provider IN ('lark', 'wechat')),
+      provider_account_id TEXT,
+      reason TEXT NOT NULL,
+      retry_count INTEGER NOT NULL DEFAULT 0,
+      next_retry_at TEXT,
+      last_error TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'resolved', 'dead')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(raw_event_id, reason)
+    );
+
+    CREATE TABLE IF NOT EXISTS provider_identity_cache (
+      id TEXT PRIMARY KEY,
+      provider TEXT NOT NULL CHECK (provider IN ('lark', 'wechat')),
+      app_id TEXT NOT NULL,
+      open_id TEXT NOT NULL,
+      union_id TEXT NOT NULL,
+      fetched_at TEXT NOT NULL DEFAULT (datetime('now')),
+      expires_at TEXT,
+      UNIQUE(provider, app_id, open_id)
+    );
+  `);
+
+  addColumnIfMissing(db, 'channel_accounts', 'agent', `agent TEXT`);
+  addColumnIfMissing(db, 'channel_accounts', 'provider_account_id', `provider_account_id TEXT REFERENCES provider_accounts(id) ON DELETE SET NULL`);
+
+  db.exec(`
+    INSERT OR IGNORE INTO provider_accounts (id, provider, external_account_id, agent, bot_external_user_id, status, created_at, updated_at)
+    SELECT id, 'lark', app_id, COALESCE(agent, ''), bot_open_id, status, created_at, updated_at
+    FROM channel_accounts
+    WHERE agent IS NOT NULL AND agent != '';
+
+    UPDATE channel_accounts
+    SET provider_account_id = id
+    WHERE provider_account_id IS NULL AND agent IS NOT NULL AND agent != '';
+
+    UPDATE chats
+    SET capabilities_json = '{"topics":"unsupported"}'
+    WHERE kind = 'dm';
+
+    UPDATE chats
+    SET provider = 'lark',
+        kind = CASE WHEN name LIKE 'lark:group:%' THEN 'group' ELSE 'dm' END,
+        capabilities_json = CASE WHEN name LIKE 'lark:group:%' THEN '{"topics":"native"}' ELSE '{"topics":"unsupported"}' END,
+        dm_type = CASE WHEN name LIKE 'lark:group:%' THEN dm_type ELSE COALESCE(dm_type, 'user_agent') END
+    WHERE name LIKE 'lark:%';
+
+    UPDATE messages
+    SET provider = 'lark'
+    WHERE chat_id IN (SELECT id FROM chats WHERE provider = 'lark');
+
+    DROP VIEW IF EXISTS chat_stats;
+    CREATE VIEW chat_stats AS
+    SELECT
+      c.id,
+      c.name,
+      c.kind,
+      c.server_id,
+      c.provider,
+      c.dm_type,
+      c.capabilities_json,
+      c.audit_visibility,
+      c.created_at,
+      COUNT(m.id) AS message_count,
+      MAX(m.created_at) AS last_message_at
+    FROM chats c
+    LEFT JOIN messages m ON m.chat_id = c.id
+    GROUP BY c.id;
+
+    CREATE INDEX IF NOT EXISTS idx_room_channels_room ON room_channels(room_id, kind, name);
+    CREATE INDEX IF NOT EXISTS idx_agent_room_subscriptions_room ON agent_room_subscriptions(room_id, mode, agent);
+    CREATE INDEX IF NOT EXISTS idx_provider_accounts_agent ON provider_accounts(provider, agent, status);
+    CREATE INDEX IF NOT EXISTS idx_pending_inbound_events_status ON pending_inbound_events(status, next_retry_at, created_at);
+  `);
+}