@controlflow-ai/daemon 0.1.0

package/src/lark-fixture.ts

@@ -0,0 +1,277 @@
+import type { MessageDelivery } from './types.js';
+import type { MessageStore } from './db.js';
+
+export const LARK_FIXTURE_DISCLAIMER = 'Synthetic local fixture contract only; does not prove real Lark provider payloads or semantics.';
+
+export type LarkFixtureChatType = 'group' | 'p2p';
+export type LarkFixtureMessageType = 'text' | 'post' | 'image' | 'file' | 'unknown';
+export type LarkFixtureScope = 'thread' | 'p2p' | 'ignored' | 'rejected';
+
+export interface LarkFixtureEvent {
+  fixture_id: string;
+  app_id: string;
+  chat_id: string;
+  chat_type: LarkFixtureChatType;
+  message_id: string;
+  root_id?: string | null;
+  parent_id?: string | null;
+  thread_id?: string | null;
+  sender_open_id: string;
+  sender_type: 'user' | 'bot' | 'app' | 'unknown';
+  mentions?: string[];
+  message_type: LarkFixtureMessageType;
+  content: string;
+  quote_root_id?: string | null;
+  quote_message_id?: string | null;
+  allowed_sender?: boolean;
+}
+
+export interface NormalizedLarkFixtureEvent {
+  fixture_id: string;
+  app_id: string;
+  chat_id: string;
+  chat_type: LarkFixtureChatType;
+  message_id: string;
+  root_id: string | null;
+  parent_id: string | null;
+  thread_id: string | null;
+  sender_open_id: string;
+  sender_type: LarkFixtureEvent['sender_type'];
+  mentions: string[];
+  message_type: LarkFixtureMessageType;
+  content: string;
+  quote_root_id: string | null;
+  quote_message_id: string | null;
+  reply_external_message_id: string | null;
+  scope: LarkFixtureScope;
+  conversation_key: string | null;
+  delivery_recipient: 'neeko' | null;
+  audit_status: 'mapped' | 'ignored' | 'rejected';
+  rejection_reason: string | null;
+}
+
+export interface ApplyFixtureResult {
+  normalized: NormalizedLarkFixtureEvent;
+  transcriptId: string | null;
+  mappingId: string | null;
+  delivery: MessageDelivery | null;
+}
+
+const REQUIRED_FIELDS = ['fixture_id', 'app_id', 'chat_id', 'chat_type', 'message_id', 'sender_open_id', 'sender_type', 'message_type', 'content'] as const;
+
+export function normalizeLarkFixtureEvent(event: LarkFixtureEvent, botOpenId: string): NormalizedLarkFixtureEvent {
+  const result = normalizeLarkFixtureEventInner(event, botOpenId);
+  // B0 spec lock round 2 invariant: ignored events must never carry a conversation_key.
+  if (result.audit_status === 'ignored' && result.conversation_key !== null) {
+    throw new Error(`normalizeLarkFixtureEvent invariant violated: audit_status='ignored' but conversation_key is not null (${result.conversation_key})`);
+  }
+  return result;
+}
+
+function normalizeLarkFixtureEventInner(event: LarkFixtureEvent, botOpenId: string): NormalizedLarkFixtureEvent {
+  for (const field of REQUIRED_FIELDS) {
+    if (!String(event[field] ?? '').trim()) throw new Error(`fixture field ${field} is required`);
+  }
+
+  const mentions = event.mentions ?? [];
+  const allowed = event.allowed_sender !== false;
+  const mentionedBot = mentions.includes(botOpenId);
+  const rootId = event.root_id ?? null;
+  const threadId = event.thread_id ?? null;
+  const parentId = event.parent_id ?? null;
+  const quoteRootId = event.quote_root_id ?? null;
+  const quoteMessageId = event.quote_message_id ?? null;
+
+  if (!allowed) {
+    return normalized(event, mentions, 'rejected', null, null, 'rejected', 'sender_not_allowed');
+  }
+
+  if (event.chat_type === 'p2p') {
+    return normalized(event, mentions, 'p2p', `lark:${event.app_id}:p2p:${event.sender_open_id}`, 'neeko', 'mapped', null);
+  }
+
+  if (quoteRootId || quoteMessageId) {
+    if (!quoteRootId || !quoteMessageId) return normalized(event, mentions, 'rejected', null, null, 'rejected', 'quote_root_only_missing_required_quote_fields');
+    if (threadId || rootId || parentId) return normalized(event, mentions, 'rejected', null, null, 'rejected', 'quote_root_only_conflicts_with_thread_or_parent_fields');
+    if (!mentionedBot) return normalized(event, mentions, 'ignored', null, null, 'ignored', 'quote_root_only_without_bot_mention');
+    const key = `lark:${event.app_id}:${event.chat_id}:quote:${quoteRootId}:${quoteMessageId}`;
+    return normalized(event, mentions, 'thread', key, 'neeko', 'mapped', null);
+  }
+
+  if (threadId) {
+    const admitsByContext = Boolean(mentionedBot || parentId || rootId);
+    const key = admitsByContext ? `lark:${event.app_id}:${event.chat_id}:thread:${threadId}` : null;
+    return normalized(
+      event,
+      mentions,
+      'thread',
+      key,
+      admitsByContext ? 'neeko' : null,
+      admitsByContext ? 'mapped' : 'ignored',
+      admitsByContext ? null : 'group_message_without_mention_or_thread_context',
+    );
+  }
+
+  if (!mentionedBot) {
+    return normalized(event, mentions, 'ignored', null, null, 'ignored', 'group_message_without_bot_mention');
+  }
+
+  return normalized(event, mentions, 'thread', `lark:${event.app_id}:${event.chat_id}:root:${event.message_id}`, 'neeko', 'mapped', null);
+}
+
+function normalized(
+  event: LarkFixtureEvent,
+  mentions: string[],
+  scope: LarkFixtureScope,
+  conversationKey: string | null,
+  deliveryRecipient: 'neeko' | null,
+  auditStatus: NormalizedLarkFixtureEvent['audit_status'],
+  rejectionReason: string | null,
+): NormalizedLarkFixtureEvent {
+  return {
+    fixture_id: event.fixture_id,
+    app_id: event.app_id,
+    chat_id: event.chat_id,
+    chat_type: event.chat_type,
+    message_id: event.message_id,
+    root_id: event.root_id ?? null,
+    parent_id: event.parent_id ?? null,
+    thread_id: event.thread_id ?? null,
+    sender_open_id: event.sender_open_id,
+    sender_type: event.sender_type,
+    mentions,
+    message_type: event.message_type,
+    content: event.content,
+    quote_root_id: event.quote_root_id ?? null,
+    quote_message_id: event.quote_message_id ?? null,
+    reply_external_message_id: event.parent_id ?? null,
+    scope,
+    conversation_key: conversationKey,
+    delivery_recipient: deliveryRecipient,
+    audit_status: auditStatus,
+    rejection_reason: rejectionReason,
+  };
+}
+
+function resolveReplyToTranscriptId(store: MessageStore, accountId: string, conversationId: string, normalized: NormalizedLarkFixtureEvent): string | null {
+  const externalParent = normalized.reply_external_message_id;
+  if (!externalParent) return null;
+  const found = store.findTranscriptByExternalMessage({ accountId, externalChatId: normalized.chat_id, externalMessageId: externalParent });
+  if (!found) return null;
+  return found.conversation_id === conversationId ? found.id : null;
+}
+
+function resolveQuoteTranscriptId(store: MessageStore, accountId: string, conversationId: string, externalChatId: string, externalMessageId: string | null): string | null {
+  if (!externalMessageId) return null;
+  const found = store.findTranscriptByExternalMessage({ accountId, externalChatId, externalMessageId });
+  if (!found) return null;
+  return found.conversation_id === conversationId ? found.id : null;
+}
+
+export function applyLarkFixtureToStore(store: MessageStore, event: LarkFixtureEvent, options: { accountName: string; botOpenId: string }): ApplyFixtureResult {
+  const normalized = normalizeLarkFixtureEvent(event, options.botOpenId);
+  const account = store.registerChannelAccount({ name: options.accountName, appId: normalized.app_id, botOpenId: options.botOpenId });
+
+  if (normalized.audit_status !== 'mapped' || !normalized.conversation_key) {
+    const result = store.ingestAuditEnvelope({
+      conversation: {
+        accountId: account.id,
+        chatName: normalized.chat_type === 'p2p' ? `p2p-${normalized.sender_open_id}` : `lark-${normalized.chat_id}`,
+        conversationKey: `lark:${normalized.app_id}:audit:${normalized.chat_id}:${normalized.message_id}`,
+        externalChatId: normalized.chat_id,
+        externalRootId: null,
+        externalThreadId: null,
+        scope: normalized.chat_type === 'p2p' ? 'p2p' : 'chat',
+        chatType: normalized.chat_type,
+      },
+      envelope: {
+        accountId: account.id,
+        conversationId: '',
+        direction: 'inbound',
+        externalMessageId: normalized.message_id,
+        externalChatId: normalized.chat_id,
+        externalRootId: normalized.root_id,
+        externalThreadId: normalized.thread_id,
+        senderOpenId: normalized.sender_open_id,
+        senderType: normalized.sender_type,
+        rawType: normalized.message_type,
+        status: normalized.audit_status,
+        reasonCode: normalized.rejection_reason,
+        admitted: false,
+        rawPayloadRedactedJson: JSON.stringify({ fixture_id: normalized.fixture_id }),
+      },
+    });
+    return { normalized, transcriptId: null, mappingId: result.mapping.id, delivery: null };
+  }
+
+  const conversationInput = {
+    accountId: account.id,
+    chatName: normalized.chat_type === 'p2p' ? `p2p-${normalized.sender_open_id}` : `lark-${normalized.chat_id}`,
+    conversationKey: normalized.conversation_key,
+    externalChatId: normalized.chat_id,
+    externalRootId: normalized.root_id ?? normalized.message_id,
+    externalThreadId: normalized.thread_id,
+    scope: (normalized.chat_type === 'p2p' ? 'p2p' : 'thread') as 'p2p' | 'thread',
+    chatType: normalized.chat_type,
+  };
+
+  const result = store.ingestCanonicalEnvelope({
+    conversation: conversationInput,
+    transcript: {
+      direction: 'inbound',
+      senderType: normalized.sender_type === 'user' ? 'user' : 'bot',
+      senderId: normalized.sender_open_id,
+      content: normalized.content,
+      contentType: normalized.message_type,
+      sourceType: 'lark_fixture_event',
+      sourceUniqueKey: `${normalized.app_id}:${normalized.message_id}`,
+      mentions: normalized.mentions,
+      replyToExternalMessageId: normalized.reply_external_message_id,
+      quoteRootExternalMessageId: normalized.quote_root_id,
+      quoteMessageExternalMessageId: normalized.quote_message_id,
+    },
+    envelope: {
+      accountId: account.id,
+      direction: 'inbound',
+      externalMessageId: normalized.message_id,
+      externalChatId: normalized.chat_id,
+      externalRootId: normalized.root_id,
+      externalThreadId: normalized.thread_id,
+      senderOpenId: normalized.sender_open_id,
+      senderType: normalized.sender_type,
+      rawType: normalized.message_type,
+      status: normalized.audit_status,
+      reasonCode: normalized.rejection_reason,
+      admitted: true,
+      rawPayloadRedactedJson: JSON.stringify({ fixture_id: normalized.fixture_id }),
+    },
+  });
+
+  // P1-D: backfill same-conversation reply/quote transcript ids that arrived before their parents.
+  store.resolvePendingTranscriptRelations(result.conversation.id);
+
+  // Re-read transcript to capture any same-event same-conversation relation ids that this insertion
+  // unblocked for prior orphans, and to expose the resolved reply/quote transcript ids for the caller.
+  const created = result.transcript!;
+  const transcriptId = created.id;
+  const replyParent = resolveReplyToTranscriptId(store, account.id, result.conversation.id, normalized);
+  const quoteRoot = resolveQuoteTranscriptId(store, account.id, result.conversation.id, normalized.chat_id, normalized.quote_root_id);
+  const quoteMessage = resolveQuoteTranscriptId(store, account.id, result.conversation.id, normalized.chat_id, normalized.quote_message_id);
+  if (replyParent || quoteRoot || quoteMessage) {
+    store.createTranscript({
+      conversationId: result.conversation.id,
+      direction: created.direction,
+      senderType: created.sender_type,
+      senderId: created.sender_id,
+      content: created.content,
+      contentType: created.content_type,
+      sourceType: created.source_type,
+      sourceUniqueKey: created.source_unique_key,
+      replyToTranscriptId: replyParent,
+      quoteRootTranscriptId: quoteRoot,
+      quoteMessageTranscriptId: quoteMessage,
+    });
+  }
+
+  return { normalized, transcriptId, mappingId: result.mapping.id, delivery: null };
+}

package/src/local-api.ts

@@ -0,0 +1,155 @@
+import { LockClient } from './client.js';
+import { assertLocalRequest, assertLoopbackBindHost } from './local-auth.js';
+import { failure, HttpError, json, numberParam, readJson, stringParam } from './http.js';
+import type { RunAction } from './types.js';
+
+interface LocalApiOptions {
+  serverUrl: string;
+  token?: string;
+  daemonAuth?: ConstructorParameters<typeof LockClient>[1];
+}
+
+interface ArtifactBody {
+  content_base64?: string;
+  mime_type?: string;
+  title?: string;
+  filename?: string;
+  ttl_seconds?: number;
+  source_path?: string;
+  path?: string;
+}
+
+interface SendBody {
+  chat?: string;
+  room?: string;
+  chat_id?: string;
+  room_id?: string;
+  parent_id?: number;
+  channel_id?: string | null;
+  sender?: string;
+  recipient?: string | null;
+  content?: string;
+  type?: 'message' | 'system';
+  idempotency_key?: string | null;
+  mentions?: string[];
+}
+
+function routeNotFound(): Response {
+  return Response.json({ ok: false, code: 'NOT_FOUND', message: 'not found' }, { status: 404 });
+}
+
+export async function localRoute(request: Request, options: LocalApiOptions): Promise<Response> {
+  try {
+    assertLocalRequest(request, options.token);
+    const client = new LockClient(options.serverUrl, options.daemonAuth ?? null);
+    const url = new URL(request.url);
+    const { pathname } = url;
+
+    if (request.method === 'GET' && pathname === '/local/health') {
+      return json({ status: 'ok', mode: 'daemon' });
+    }
+
+    if (request.method === 'GET' && pathname === '/local/chats') {
+      return json({ chats: await client.listChats() });
+    }
+
+    if (request.method === 'GET' && pathname === '/local/rooms') {
+      return json({ rooms: await client.listRooms() });
+    }
+
+    const roomMembersMatch = pathname.match(/^\/local\/rooms\/([^/]+)\/members$/);
+    if (request.method === 'GET' && roomMembersMatch) {
+      return json(await client.listRoomMembers(decodeURIComponent(roomMembersMatch[1]!)));
+    }
+
+
+    const roomInviteMatch = pathname.match(/^\/local\/rooms\/([^/]+)\/agents$/);
+    if (request.method === 'POST' && roomInviteMatch) {
+      const body = await readJson<{ agent?: string; mode?: string }>(request);
+      return json(await client.inviteAgentToRoom(decodeURIComponent(roomInviteMatch[1]!), { agent: body.agent ?? '', mode: body.mode as never }), 201);
+    }
+
+    const roomTopicMatch = pathname.match(/^\/local\/rooms\/([^/]+)\/topics$/);
+    if (request.method === 'POST' && roomTopicMatch) {
+      const body = await readJson<{ name?: string; created_by?: string | null }>(request);
+      if (!body.name?.trim()) throw new HttpError(400, 'MISSING_TOPIC_NAME', 'name is required');
+      const channel = await client.createTopic(decodeURIComponent(roomTopicMatch[1]!), { name: body.name, created_by: body.created_by });
+      return json({ channel }, 201);
+    }
+
+    if (request.method === 'GET' && pathname === '/local/messages') {
+      const params = new URLSearchParams();
+      for (const key of ['chat', 'room', 'chat_id', 'room_id', 'parent_id', 'channel_id', 'after', 'limit', 'q']) {
+        const value = url.searchParams.get(key);
+        if (value !== null) params.set(key, value);
+      }
+      return json({ messages: await client.getMessages(params) });
+    }
+
+    const messageMatch = pathname.match(/^\/local\/messages\/(\d+)$/);
+    if (request.method === 'GET' && messageMatch) {
+      return json({ message: await client.getMessage(Number(messageMatch[1])) });
+    }
+
+    if (request.method === 'POST' && pathname === '/local/messages') {
+      const body = await readJson<SendBody>(request);
+      if (!body.sender?.trim()) throw new HttpError(400, 'MISSING_SENDER', 'sender is required');
+      if (!body.content?.trim()) throw new HttpError(400, 'MISSING_CONTENT', 'content is required');
+      const message = await client.sendMessage({
+        chat: body.room ?? body.chat,
+        room: body.room,
+        chat_id: body.room_id ?? body.chat_id,
+        room_id: body.room_id,
+        parent_id: body.parent_id,
+        channel_id: body.channel_id,
+        sender: body.sender,
+        recipient: body.recipient,
+        content: body.content,
+        type: body.type,
+        idempotency_key: body.idempotency_key,
+        mentions: body.mentions,
+      });
+      return json({ message }, 201);
+    }
+
+    if (request.method === 'GET' && pathname === '/local/runs') {
+      return json({ runs: await client.listRuns() });
+    }
+
+    if (request.method === 'POST' && pathname === '/local/artifacts') {
+      const body = await readJson<ArtifactBody>(request);
+      if (body.source_path || body.path) throw new HttpError(400, 'PATH_NOT_ALLOWED', 'artifact upload must include content, not a path');
+      if (!body.content_base64) throw new HttpError(400, 'MISSING_CONTENT', 'content_base64 is required');
+      if (!body.mime_type?.trim()) throw new HttpError(400, 'MISSING_MIME', 'mime_type is required');
+      const artifact = await client.createArtifact({
+        content_base64: body.content_base64,
+        mime_type: body.mime_type,
+        title: body.title,
+        filename: body.filename,
+        ttl_seconds: body.ttl_seconds,
+      });
+      return json(artifact, 201);
+    }
+
+    const actionMatch = pathname.match(/^\/local\/runs\/([^/]+)\/(kill|restart)$/);
+    if (request.method === 'POST' && actionMatch) {
+      const run = await client.requestRunAction(actionMatch[1]!, actionMatch[2] as RunAction);
+      return json({ run });
+    }
+
+    return routeNotFound();
+  } catch (error) {
+    return failure(error);
+  }
+}
+
+export function startLocalApi(options: LocalApiOptions & { host: string; port: number }): ReturnType<typeof Bun.serve> {
+  assertLoopbackBindHost(options.host);
+  return Bun.serve({
+    hostname: options.host,
+    port: options.port,
+    fetch(request) {
+      return localRoute(request, options);
+    },
+  });
+}

package/src/local-auth.ts

@@ -0,0 +1,45 @@
+import { HttpError } from './http.js';
+
+const ALLOWED_HOSTS = new Set(['127.0.0.1', 'localhost', '[::1]', '::1']);
+const LOOPBACK_BIND_HOSTS = new Set(['127.0.0.1', 'localhost', '::1']);
+
+function hostName(value: string | null): string {
+  if (!value) return '';
+  const withoutPort = value.startsWith('[') ? value.slice(0, value.indexOf(']') + 1) : value.split(':')[0]!;
+  return withoutPort.toLowerCase();
+}
+
+export function assertLocalRequest(request: Request, token: string | undefined): void {
+  const host = hostName(request.headers.get('host'));
+  if (!ALLOWED_HOSTS.has(host)) {
+    throw new HttpError(403, 'BAD_HOST', 'local daemon host is not allowed');
+  }
+
+  const origin = request.headers.get('origin');
+  if (origin) {
+    throw new HttpError(403, 'CORS_DENIED', 'browser origins are not allowed');
+  }
+
+  if (request.method === 'OPTIONS') {
+    throw new HttpError(403, 'CORS_DENIED', 'CORS preflight is not allowed');
+  }
+
+  if (!token) {
+    throw new HttpError(401, 'UNAUTHORIZED', 'local daemon token is required');
+  }
+
+  const header = request.headers.get('authorization');
+  if (header !== `Bearer ${token}`) {
+    throw new HttpError(401, 'UNAUTHORIZED', 'invalid local daemon token');
+  }
+}
+
+export function assertLoopbackBindHost(host: string): void {
+  if (!LOOPBACK_BIND_HOSTS.has(host.toLowerCase())) {
+    throw new Error('local daemon API must bind to a loopback host');
+  }
+}
+
+export function localHeaders(token: string | undefined): HeadersInit {
+  return token ? { authorization: `Bearer ${token}`, 'x-lock-client': 'cli' } : { 'x-lock-client': 'cli' };
+}

package/src/migrations/001_initial.ts

@@ -0,0 +1,61 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 1;
+export const name = 'initial';
+
+export function up(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS chats (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      kind TEXT NOT NULL DEFAULT 'group' CHECK (kind IN ('group', 'dm')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      chat_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
+      parent_id INTEGER REFERENCES messages(id) ON DELETE CASCADE,
+      depth INTEGER NOT NULL DEFAULT 0 CHECK (depth IN (0, 1)),
+      sender TEXT NOT NULL,
+      recipient TEXT,
+      content TEXT NOT NULL,
+      type TEXT NOT NULL DEFAULT 'message' CHECK (type IN ('message', 'system')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_runs (
+      id TEXT PRIMARY KEY,
+      message_id INTEGER NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+      agent TEXT NOT NULL,
+      status TEXT NOT NULL CHECK (status IN ('running', 'completed', 'failed', 'killed', 'restarted')),
+      action TEXT CHECK (action IN ('kill', 'restart')),
+      attempt INTEGER NOT NULL DEFAULT 1,
+      pid INTEGER,
+      cwd TEXT NOT NULL,
+      started_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      ended_at TEXT,
+      exit_code INTEGER,
+      output TEXT NOT NULL DEFAULT ''
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_chat_id ON messages(chat_id, id);
+    CREATE INDEX IF NOT EXISTS idx_messages_parent_id ON messages(parent_id, id);
+    CREATE INDEX IF NOT EXISTS idx_messages_recipient ON messages(recipient, id);
+    CREATE INDEX IF NOT EXISTS idx_agent_runs_message_id ON agent_runs(message_id, attempt);
+    CREATE INDEX IF NOT EXISTS idx_agent_runs_status ON agent_runs(status, updated_at);
+
+    CREATE VIEW IF NOT EXISTS chat_stats AS
+    SELECT
+      c.id,
+      c.name,
+      c.kind,
+      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;
+  `);
+}

package/src/migrations/002_daemon_deliveries.ts

@@ -0,0 +1,52 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 2;
+export const name = 'daemon_deliveries';
+
+export function up(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS daemon_instances (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      host TEXT NOT NULL DEFAULT '',
+      local_url TEXT NOT NULL DEFAULT '',
+      server_url TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'online' CHECK (status IN ('online', 'offline')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS daemon_agents (
+      daemon_id TEXT NOT NULL REFERENCES daemon_instances(id) ON DELETE CASCADE,
+      agent TEXT NOT NULL,
+      cwd TEXT NOT NULL DEFAULT '',
+      capabilities TEXT NOT NULL DEFAULT '{}',
+      status TEXT NOT NULL DEFAULT 'online' CHECK (status IN ('online', 'offline')),
+      last_seen_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (daemon_id, agent)
+    );
+
+    CREATE TABLE IF NOT EXISTS message_deliveries (
+      id TEXT PRIMARY KEY,
+      message_id INTEGER NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+      chat_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
+      agent TEXT NOT NULL,
+      status TEXT NOT NULL CHECK (status IN ('pending', 'claimed', 'processing_completed', 'acked', 'failed', 'canceled')),
+      daemon_id TEXT REFERENCES daemon_instances(id) ON DELETE SET NULL,
+      claim_token TEXT,
+      lease_until TEXT,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      idempotency_key TEXT NOT NULL UNIQUE,
+      run_id TEXT,
+      last_error TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      claimed_at TEXT,
+      acked_at TEXT,
+      failed_at TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_message_deliveries_status_lease ON message_deliveries(status, lease_until);
+    CREATE INDEX IF NOT EXISTS idx_message_deliveries_agent ON message_deliveries(agent, status, created_at);
+    CREATE INDEX IF NOT EXISTS idx_message_deliveries_message_id ON message_deliveries(message_id);
+  `);
+}

package/src/migrations/003_sessions_runs.ts

@@ -0,0 +1,49 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 3;
+export const name = 'sessions_runs';
+
+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 agent_sessions (
+      id TEXT PRIMARY KEY,
+      chat_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
+      agent TEXT NOT NULL,
+      daemon_id TEXT NOT NULL REFERENCES daemon_instances(id) ON DELETE CASCADE,
+      cwd TEXT NOT NULL DEFAULT '',
+      session_key TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_message_id INTEGER REFERENCES messages(id) ON DELETE SET NULL,
+      UNIQUE(chat_id, agent, daemon_id)
+    );
+  `);
+
+  addColumnIfMissing(db, 'agent_runs', 'session_id', 'session_id TEXT REFERENCES agent_sessions(id) ON DELETE SET NULL');
+  addColumnIfMissing(db, 'agent_runs', 'trigger_message_id', 'trigger_message_id INTEGER REFERENCES messages(id) ON DELETE SET NULL');
+  addColumnIfMissing(db, 'agent_runs', 'daemon_id', 'daemon_id TEXT REFERENCES daemon_instances(id) ON DELETE SET NULL');
+  addColumnIfMissing(db, 'agent_runs', 'delivery_id', 'delivery_id TEXT REFERENCES message_deliveries(id) ON DELETE SET NULL');
+
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_agent_sessions_lookup ON agent_sessions(chat_id, agent, daemon_id);
+    CREATE INDEX IF NOT EXISTS idx_agent_runs_session_id ON agent_runs(session_id, attempt);
+    CREATE INDEX IF NOT EXISTS idx_agent_runs_delivery_id ON agent_runs(delivery_id);
+  `);
+
+  db.exec(`
+    UPDATE agent_runs
+    SET trigger_message_id = message_id
+    WHERE trigger_message_id IS NULL;
+  `);
+}

package/src/migrations/004_message_idempotency.ts

@@ -0,0 +1,21 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 4;
+export const name = 'message_idempotency';
+
+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, 'messages', 'idempotency_key')) {
+    db.exec('ALTER TABLE messages ADD COLUMN idempotency_key TEXT');
+  }
+
+  db.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_messages_idempotency_key
+    ON messages(idempotency_key)
+    WHERE idempotency_key IS NOT NULL;
+  `);
+}