swarm-mail 0.1.3 → 0.1.4

package/dist/index.js

@@ -14821,7 +14821,6 @@ async function debugEventsPaginated(options) {
     }) : batch;
     allEvents.push(...filtered);
     offset += batchSize;
-    console.log(`[SwarmMail] Fetched ${allEvents.length} events (batch size: ${batchSize})`);
   }
   allEvents.sort((a, b) => b.sequence - a.sequence);
   const limitedEvents = allEvents.slice(0, limit);
@@ -15063,7 +15062,7 @@ async function ensureVersionTable(db) {
 async function getCurrentVersion(db) {
   await ensureVersionTable(db);
   const result = await db.query(`SELECT MAX(version) as version FROM schema_version`);
-  return result.rows[0]?.version ?? 0;
+  return result.rows[0]?.version ?? -1;
 }
 async function getAppliedMigrations(db) {
   await ensureVersionTable(db);
@@ -15141,6 +15140,123 @@ async function getPendingMigrations(db) {
 var migrations;
 var init_migrations = __esm(() => {
   migrations = [
+    {
+      version: 0,
+      description: "Create core event store tables",
+      up: `
+      -- Events table: The source of truth (append-only)
+      CREATE TABLE IF NOT EXISTS events (
+        id SERIAL PRIMARY KEY,
+        type TEXT NOT NULL,
+        project_key TEXT NOT NULL,
+        timestamp BIGINT NOT NULL,
+        sequence SERIAL,
+        data JSONB NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+
+      -- Index for efficient queries
+      CREATE INDEX IF NOT EXISTS idx_events_project_key ON events(project_key);
+      CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_events_project_type ON events(project_key, type);
+
+      -- Agents materialized view (rebuilt from events)
+      CREATE TABLE IF NOT EXISTS agents (
+        id SERIAL PRIMARY KEY,
+        project_key TEXT NOT NULL,
+        name TEXT NOT NULL,
+        program TEXT DEFAULT 'opencode',
+        model TEXT DEFAULT 'unknown',
+        task_description TEXT,
+        registered_at BIGINT NOT NULL,
+        last_active_at BIGINT NOT NULL,
+        UNIQUE(project_key, name)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_agents_project ON agents(project_key);
+
+      -- Messages materialized view
+      CREATE TABLE IF NOT EXISTS messages (
+        id SERIAL PRIMARY KEY,
+        project_key TEXT NOT NULL,
+        from_agent TEXT NOT NULL,
+        subject TEXT NOT NULL,
+        body TEXT NOT NULL,
+        thread_id TEXT,
+        importance TEXT DEFAULT 'normal',
+        ack_required BOOLEAN DEFAULT FALSE,
+        created_at BIGINT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_messages_project ON messages(project_key);
+      CREATE INDEX IF NOT EXISTS idx_messages_thread ON messages(thread_id);
+      CREATE INDEX IF NOT EXISTS idx_messages_created ON messages(created_at DESC);
+
+      -- Message recipients (many-to-many)
+      CREATE TABLE IF NOT EXISTS message_recipients (
+        message_id INTEGER REFERENCES messages(id) ON DELETE CASCADE,
+        agent_name TEXT NOT NULL,
+        read_at BIGINT,
+        acked_at BIGINT,
+        PRIMARY KEY(message_id, agent_name)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_recipients_agent ON message_recipients(agent_name);
+
+      -- File reservations materialized view
+      CREATE TABLE IF NOT EXISTS reservations (
+        id SERIAL PRIMARY KEY,
+        project_key TEXT NOT NULL,
+        agent_name TEXT NOT NULL,
+        path_pattern TEXT NOT NULL,
+        exclusive BOOLEAN DEFAULT TRUE,
+        reason TEXT,
+        created_at BIGINT NOT NULL,
+        expires_at BIGINT NOT NULL,
+        released_at BIGINT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_reservations_project ON reservations(project_key);
+      CREATE INDEX IF NOT EXISTS idx_reservations_agent ON reservations(agent_name);
+      CREATE INDEX IF NOT EXISTS idx_reservations_expires ON reservations(expires_at);
+      CREATE INDEX IF NOT EXISTS idx_reservations_active ON reservations(project_key, released_at) WHERE released_at IS NULL;
+
+      -- Locks table for distributed mutual exclusion (DurableLock)
+      CREATE TABLE IF NOT EXISTS locks (
+        resource TEXT PRIMARY KEY,
+        holder TEXT NOT NULL,
+        seq INTEGER NOT NULL DEFAULT 0,
+        acquired_at BIGINT NOT NULL,
+        expires_at BIGINT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_locks_expires ON locks(expires_at);
+      CREATE INDEX IF NOT EXISTS idx_locks_holder ON locks(holder);
+    `,
+      down: `
+      DROP INDEX IF EXISTS idx_locks_holder;
+      DROP INDEX IF EXISTS idx_locks_expires;
+      DROP TABLE IF EXISTS locks;
+      DROP INDEX IF EXISTS idx_reservations_active;
+      DROP INDEX IF EXISTS idx_reservations_expires;
+      DROP INDEX IF EXISTS idx_reservations_agent;
+      DROP INDEX IF EXISTS idx_reservations_project;
+      DROP TABLE IF EXISTS reservations;
+      DROP INDEX IF EXISTS idx_recipients_agent;
+      DROP TABLE IF EXISTS message_recipients;
+      DROP INDEX IF EXISTS idx_messages_thread;
+      DROP INDEX IF EXISTS idx_messages_project;
+      DROP TABLE IF EXISTS messages;
+      DROP INDEX IF EXISTS idx_agents_project;
+      DROP TABLE IF EXISTS agents;
+      DROP INDEX IF EXISTS idx_events_project_type;
+      DROP INDEX IF EXISTS idx_events_timestamp;
+      DROP INDEX IF EXISTS idx_events_type;
+      DROP INDEX IF EXISTS idx_events_project_key;
+      DROP TABLE IF EXISTS events;
+    `
+    },
     {
       version: 1,
       description: "Add cursors table for DurableCursor",
@@ -15227,6 +15343,41 @@ var init_migrations = __esm(() => {
       CREATE INDEX IF NOT EXISTS idx_swarm_contexts_bead ON swarm_contexts(bead_id);
     `,
       down: `DROP TABLE IF EXISTS swarm_contexts;`
+    },
+    {
+      version: 5,
+      description: "Add project_key and checkpointed_at to swarm_contexts, change primary key",
+      up: `
+      -- Add new columns
+      ALTER TABLE swarm_contexts ADD COLUMN IF NOT EXISTS project_key TEXT;
+      ALTER TABLE swarm_contexts ADD COLUMN IF NOT EXISTS checkpointed_at BIGINT;
+      ALTER TABLE swarm_contexts ADD COLUMN IF NOT EXISTS recovered_at BIGINT;
+      ALTER TABLE swarm_contexts ADD COLUMN IF NOT EXISTS recovered_from_checkpoint BIGINT;
+      
+      -- Drop old primary key constraint on id
+      ALTER TABLE swarm_contexts DROP CONSTRAINT IF EXISTS swarm_contexts_pkey;
+      
+      -- Make id nullable since we're switching to composite key
+      ALTER TABLE swarm_contexts ALTER COLUMN id DROP NOT NULL;
+      
+      -- Create new indexes
+      CREATE INDEX IF NOT EXISTS idx_swarm_contexts_project ON swarm_contexts(project_key);
+      DROP INDEX IF EXISTS idx_swarm_contexts_epic;
+      DROP INDEX IF EXISTS idx_swarm_contexts_bead;
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_swarm_contexts_unique ON swarm_contexts(project_key, epic_id, bead_id);
+    `,
+      down: `
+      DROP INDEX IF EXISTS idx_swarm_contexts_unique;
+      DROP INDEX IF EXISTS idx_swarm_contexts_project;
+      ALTER TABLE swarm_contexts DROP COLUMN IF EXISTS project_key;
+      ALTER TABLE swarm_contexts DROP COLUMN IF EXISTS checkpointed_at;
+      ALTER TABLE swarm_contexts DROP COLUMN IF EXISTS recovered_at;
+      ALTER TABLE swarm_contexts DROP COLUMN IF EXISTS recovered_from_checkpoint;
+      ALTER TABLE swarm_contexts ALTER COLUMN id SET NOT NULL;
+      ALTER TABLE swarm_contexts ADD CONSTRAINT swarm_contexts_pkey PRIMARY KEY (id);
+      CREATE INDEX IF NOT EXISTS idx_swarm_contexts_epic ON swarm_contexts(epic_id);
+      CREATE INDEX IF NOT EXISTS idx_swarm_contexts_bead ON swarm_contexts(bead_id);
+    `
     }
   ];
 });
@@ -15868,11 +16019,6 @@ function parseTimestamp(timestamp) {
 async function appendEvent(event, projectPath, dbOverride) {
   const db = dbOverride ?? await getDatabase(projectPath);
   const { type, project_key, timestamp, ...rest } = event;
-  console.log("[SwarmMail] Appending event", {
-    type,
-    projectKey: project_key,
-    timestamp
-  });
   const result = await db.query(`INSERT INTO events (type, project_key, timestamp, data)
      VALUES ($1, $2, $3, $4)
      RETURNING id, sequence`, [type, project_key, timestamp, JSON.stringify(rest)]);
@@ -15881,13 +16027,6 @@ async function appendEvent(event, projectPath, dbOverride) {
     throw new Error("Failed to insert event - no row returned");
   }
   const { id, sequence } = row;
-  console.log("[SwarmMail] Event appended", {
-    type,
-    id,
-    sequence,
-    projectKey: project_key
-  });
-  console.debug("[SwarmMail] Updating materialized views", { type, id });
   await updateMaterializedViews(db, { ...event, id, sequence });
   return { ...event, id, sequence };
 }
@@ -16073,7 +16212,6 @@ async function replayEventsBatched2(projectKey, onBatch, options = {}, projectPa
       processed += events2.length;
       const percent = Math.round(processed / total * 100);
       await onBatch(events2, { processed, total, percent });
-      console.log(`[SwarmMail] Replaying events: ${processed}/${total} (${percent}%)`);
       offset += batchSize;
     }
     return {
@@ -16153,12 +16291,6 @@ async function handleAgentRegistered(db, event) {
   ]);
 }
 async function handleMessageSent(db, event) {
-  console.log("[SwarmMail] Handling message sent event", {
-    from: event.from_agent,
-    to: event.to_agents,
-    subject: event.subject,
-    projectKey: event.project_key
-  });
   const result = await db.query(`INSERT INTO messages (project_key, from_agent, subject, body, thread_id, importance, ack_required, created_at)
      VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
      RETURNING id`, [
@@ -16182,19 +16314,9 @@ async function handleMessageSent(db, event) {
     await db.query(`INSERT INTO message_recipients (message_id, agent_name)
        VALUES ${values}
        ON CONFLICT DO NOTHING`, params);
-    console.log("[SwarmMail] Message recipients inserted", {
-      messageId,
-      recipientCount: event.to_agents.length
-    });
   }
 }
 async function handleFileReserved(db, event) {
-  console.log("[SwarmMail] Handling file reservation event", {
-    agent: event.agent_name,
-    paths: event.paths,
-    exclusive: event.exclusive,
-    projectKey: event.project_key
-  });
   if (event.paths.length > 0) {
     const values = event.paths.map((_, i) => `($1, $2, $${i + 3}, $${event.paths.length + 3}, $${event.paths.length + 4}, $${event.paths.length + 5}, $${event.paths.length + 6})`).join(", ");
     const params = [
@@ -16215,10 +16337,6 @@ async function handleFileReserved(db, event) {
     }
     await db.query(`INSERT INTO reservations (project_key, agent_name, path_pattern, exclusive, reason, created_at, expires_at)
        VALUES ${values}`, params);
-    console.log("[SwarmMail] File reservations inserted", {
-      agent: event.agent_name,
-      reservationCount: event.paths.length
-    });
   }
 }
 async function handleFileReleased(db, event) {
@@ -16322,10 +16440,11 @@ async function handleSwarmCheckpointed(db, event) {
   if (event.type !== "swarm_checkpointed")
     return;
   await db.query(`INSERT INTO swarm_contexts (
-      project_key, epic_id, bead_id, strategy, files, dependencies, 
-      directives, recovery, checkpointed_at, updated_at
-    ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $9)
-    ON CONFLICT (project_key, epic_id, bead_id) DO UPDATE SET
+      id, project_key, epic_id, bead_id, strategy, files, dependencies, 
+      directives, recovery, created_at, checkpointed_at, updated_at
+    ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $10, $10)
+    ON CONFLICT (id) DO UPDATE SET
+      project_key = EXCLUDED.project_key,
       strategy = EXCLUDED.strategy,
       files = EXCLUDED.files,
       dependencies = EXCLUDED.dependencies,
@@ -16333,6 +16452,7 @@ async function handleSwarmCheckpointed(db, event) {
       recovery = EXCLUDED.recovery,
       checkpointed_at = EXCLUDED.checkpointed_at,
       updated_at = EXCLUDED.updated_at`, [
+    event.bead_id,
     event.project_key,
     event.epic_id,
     event.bead_id,
@@ -16428,6 +16548,218 @@ var init_store = __esm(() => {
   TIMESTAMP_SAFE_UNTIL = new Date("2286-01-01").getTime();
 });
 
+// src/beads/dependencies.ts
+var exports_dependencies = {};
+__export(exports_dependencies, {
+  wouldCreateCycle: () => wouldCreateCycle,
+  rebuildBeadBlockedCache: () => rebuildBeadBlockedCache,
+  rebuildAllBlockedCaches: () => rebuildAllBlockedCaches,
+  invalidateBlockedCache: () => invalidateBlockedCache,
+  getOpenBlockers: () => getOpenBlockers
+});
+async function wouldCreateCycle(db, beadId, dependsOnId) {
+  const result = await db.query(`WITH RECURSIVE paths AS (
+       -- Start from the target (what we want to depend on)
+       SELECT
+         bead_id,
+         depends_on_id,
+         1 as depth
+       FROM bead_dependencies
+       WHERE bead_id = $2
+       
+       UNION
+       
+       -- Follow dependencies transitively
+       SELECT
+         bd.bead_id,
+         bd.depends_on_id,
+         p.depth + 1
+       FROM bead_dependencies bd
+       JOIN paths p ON bd.bead_id = p.depends_on_id
+       WHERE p.depth < $3
+     )
+     SELECT EXISTS(
+       SELECT 1 FROM paths WHERE depends_on_id = $1
+     ) as exists`, [beadId, dependsOnId, MAX_DEPENDENCY_DEPTH]);
+  return result.rows[0]?.exists ?? false;
+}
+async function getOpenBlockers(db, projectKey, beadId) {
+  const result = await db.query(`WITH RECURSIVE blockers AS (
+       -- Direct blockers
+       SELECT depends_on_id as blocker_id, 1 as depth
+       FROM bead_dependencies
+       WHERE bead_id = $1 AND relationship = 'blocks'
+       
+       UNION
+       
+       -- Transitive blockers
+       SELECT bd.depends_on_id, b.depth + 1
+       FROM bead_dependencies bd
+       JOIN blockers b ON bd.bead_id = b.blocker_id
+       WHERE bd.relationship = 'blocks' AND b.depth < $3
+     )
+     SELECT DISTINCT b.blocker_id
+     FROM blockers b
+     JOIN beads bead ON b.blocker_id = bead.id
+     WHERE bead.project_key = $2 AND bead.status != 'closed' AND bead.deleted_at IS NULL`, [beadId, projectKey, MAX_DEPENDENCY_DEPTH]);
+  return result.rows.map((r) => r.blocker_id);
+}
+async function rebuildBeadBlockedCache(db, projectKey, beadId) {
+  const blockerIds = await getOpenBlockers(db, projectKey, beadId);
+  if (blockerIds.length > 0) {
+    await db.query(`INSERT INTO blocked_beads_cache (bead_id, blocker_ids, updated_at)
+       VALUES ($1, $2, $3)
+       ON CONFLICT (bead_id) 
+       DO UPDATE SET blocker_ids = $2, updated_at = $3`, [beadId, blockerIds, Date.now()]);
+  } else {
+    await db.query(`DELETE FROM blocked_beads_cache WHERE bead_id = $1`, [beadId]);
+  }
+}
+async function rebuildAllBlockedCaches(db, projectKey) {
+  const result = await db.query(`SELECT DISTINCT b.id FROM beads b
+     JOIN bead_dependencies bd ON b.id = bd.bead_id
+     WHERE b.project_key = $1 AND bd.relationship = 'blocks' AND b.deleted_at IS NULL`, [projectKey]);
+  for (const row of result.rows) {
+    await rebuildBeadBlockedCache(db, projectKey, row.id);
+  }
+}
+async function invalidateBlockedCache(db, projectKey, beadId) {
+  await rebuildBeadBlockedCache(db, projectKey, beadId);
+  const dependents = await db.query(`SELECT bead_id FROM bead_dependencies WHERE depends_on_id = $1`, [beadId]);
+  for (const row of dependents.rows) {
+    await rebuildBeadBlockedCache(db, projectKey, row.bead_id);
+  }
+}
+var MAX_DEPENDENCY_DEPTH = 100;
+
+// src/beads/migrations.ts
+var exports_migrations2 = {};
+__export(exports_migrations2, {
+  beadsMigrations: () => beadsMigrations,
+  beadsMigration: () => beadsMigration
+});
+var beadsMigration, beadsMigrations;
+var init_migrations2 = __esm(() => {
+  beadsMigration = {
+    version: 6,
+    description: "Add beads tables for issue tracking",
+    up: `
+    -- ========================================================================
+    -- Core Beads Table
+    -- ========================================================================
+    CREATE TABLE IF NOT EXISTS beads (
+      id TEXT PRIMARY KEY,
+      project_key TEXT NOT NULL,
+      type TEXT NOT NULL CHECK (type IN ('bug', 'feature', 'task', 'epic', 'chore', 'message')),
+      status TEXT NOT NULL DEFAULT 'open' CHECK (status IN ('open', 'in_progress', 'blocked', 'closed', 'tombstone')),
+      title TEXT NOT NULL CHECK (length(title) <= 500),
+      description TEXT,
+      priority INTEGER NOT NULL DEFAULT 2 CHECK (priority BETWEEN 0 AND 3),
+      parent_id TEXT REFERENCES beads(id) ON DELETE SET NULL,
+      assignee TEXT,
+      created_at BIGINT NOT NULL,
+      updated_at BIGINT NOT NULL,
+      closed_at BIGINT,
+      closed_reason TEXT,
+      deleted_at BIGINT,
+      deleted_by TEXT,
+      delete_reason TEXT,
+      created_by TEXT,
+      CHECK ((status = 'closed') = (closed_at IS NOT NULL))
+    );
+
+    -- Indexes for common queries
+    CREATE INDEX IF NOT EXISTS idx_beads_project ON beads(project_key);
+    CREATE INDEX IF NOT EXISTS idx_beads_status ON beads(status);
+    CREATE INDEX IF NOT EXISTS idx_beads_type ON beads(type);
+    CREATE INDEX IF NOT EXISTS idx_beads_priority ON beads(priority);
+    CREATE INDEX IF NOT EXISTS idx_beads_assignee ON beads(assignee);
+    CREATE INDEX IF NOT EXISTS idx_beads_parent ON beads(parent_id);
+    CREATE INDEX IF NOT EXISTS idx_beads_created ON beads(created_at);
+    CREATE INDEX IF NOT EXISTS idx_beads_project_status ON beads(project_key, status);
+
+    -- ========================================================================
+    -- Dependencies Table
+    -- ========================================================================
+    CREATE TABLE IF NOT EXISTS bead_dependencies (
+      bead_id TEXT NOT NULL REFERENCES beads(id) ON DELETE CASCADE,
+      depends_on_id TEXT NOT NULL REFERENCES beads(id) ON DELETE CASCADE,
+      relationship TEXT NOT NULL CHECK (relationship IN ('blocks', 'related', 'parent-child', 'discovered-from', 'replies-to', 'relates-to', 'duplicates', 'supersedes')),
+      created_at BIGINT NOT NULL,
+      created_by TEXT,
+      PRIMARY KEY (bead_id, depends_on_id, relationship)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_bead_deps_bead ON bead_dependencies(bead_id);
+    CREATE INDEX IF NOT EXISTS idx_bead_deps_depends_on ON bead_dependencies(depends_on_id);
+    CREATE INDEX IF NOT EXISTS idx_bead_deps_relationship ON bead_dependencies(relationship);
+
+    -- ========================================================================
+    -- Labels Table
+    -- ========================================================================
+    CREATE TABLE IF NOT EXISTS bead_labels (
+      bead_id TEXT NOT NULL REFERENCES beads(id) ON DELETE CASCADE,
+      label TEXT NOT NULL,
+      created_at BIGINT NOT NULL,
+      PRIMARY KEY (bead_id, label)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_bead_labels_label ON bead_labels(label);
+
+    -- ========================================================================
+    -- Comments Table
+    -- ========================================================================
+    CREATE TABLE IF NOT EXISTS bead_comments (
+      id SERIAL PRIMARY KEY,
+      bead_id TEXT NOT NULL REFERENCES beads(id) ON DELETE CASCADE,
+      author TEXT NOT NULL,
+      body TEXT NOT NULL,
+      parent_id INTEGER REFERENCES bead_comments(id) ON DELETE CASCADE,
+      created_at BIGINT NOT NULL,
+      updated_at BIGINT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_bead_comments_bead ON bead_comments(bead_id);
+    CREATE INDEX IF NOT EXISTS idx_bead_comments_author ON bead_comments(author);
+    CREATE INDEX IF NOT EXISTS idx_bead_comments_created ON bead_comments(created_at);
+
+    -- ========================================================================
+    -- Blocked Beads Cache
+    -- ========================================================================
+    -- Materialized view for fast blocked queries
+    -- Updated by projections when dependencies change
+    CREATE TABLE IF NOT EXISTS blocked_beads_cache (
+      bead_id TEXT PRIMARY KEY REFERENCES beads(id) ON DELETE CASCADE,
+      blocker_ids TEXT[] NOT NULL,
+      updated_at BIGINT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_blocked_beads_updated ON blocked_beads_cache(updated_at);
+
+    -- ========================================================================
+    -- Dirty Beads Table
+    -- ========================================================================
+    -- Tracks beads that need JSONL export (incremental sync)
+    CREATE TABLE IF NOT EXISTS dirty_beads (
+      bead_id TEXT PRIMARY KEY REFERENCES beads(id) ON DELETE CASCADE,
+      marked_at BIGINT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_dirty_beads_marked ON dirty_beads(marked_at);
+  `,
+    down: `
+    -- Drop in reverse order to handle foreign key constraints
+    DROP TABLE IF EXISTS dirty_beads;
+    DROP TABLE IF EXISTS blocked_beads_cache;
+    DROP TABLE IF EXISTS bead_comments;
+    DROP TABLE IF EXISTS bead_labels;
+    DROP TABLE IF EXISTS bead_dependencies;
+    DROP TABLE IF EXISTS beads;
+  `
+  };
+  beadsMigrations = [beadsMigration];
+});
+
 // src/adapter.ts
 init_store();
 init_projections();
@@ -16622,10 +16954,1553 @@ async function closeAllSwarmMail() {
 
 // src/index.ts
 init_streams();
+
+// src/beads/store.ts
+init_streams();
+
+// src/beads/projections.ts
+async function updateProjections(db, event) {
+  switch (event.type) {
+    case "bead_created":
+      await handleBeadCreated(db, event);
+      break;
+    case "bead_updated":
+      await handleBeadUpdated(db, event);
+      break;
+    case "bead_status_changed":
+      await handleBeadStatusChanged(db, event);
+      break;
+    case "bead_closed":
+      await handleBeadClosed(db, event);
+      break;
+    case "bead_reopened":
+      await handleBeadReopened(db, event);
+      break;
+    case "bead_deleted":
+      await handleBeadDeleted(db, event);
+      break;
+    case "bead_dependency_added":
+      await handleDependencyAdded(db, event);
+      break;
+    case "bead_dependency_removed":
+      await handleDependencyRemoved(db, event);
+      break;
+    case "bead_label_added":
+      await handleLabelAdded(db, event);
+      break;
+    case "bead_label_removed":
+      await handleLabelRemoved(db, event);
+      break;
+    case "bead_comment_added":
+      await handleCommentAdded(db, event);
+      break;
+    case "bead_comment_updated":
+      await handleCommentUpdated(db, event);
+      break;
+    case "bead_comment_deleted":
+      await handleCommentDeleted(db, event);
+      break;
+    case "bead_epic_child_added":
+      await handleEpicChildAdded(db, event);
+      break;
+    case "bead_epic_child_removed":
+      await handleEpicChildRemoved(db, event);
+      break;
+    case "bead_assigned":
+      await handleBeadAssigned(db, event);
+      break;
+    case "bead_work_started":
+      await handleWorkStarted(db, event);
+      break;
+    default:
+      console.warn(`[beads/projections] Unknown event type: ${event.type}`);
+  }
+  await markBeadDirty(db, event.project_key, event.bead_id);
+}
+async function handleBeadCreated(db, event) {
+  await db.query(`INSERT INTO beads (
+      id, project_key, type, status, title, description, priority,
+      parent_id, assignee, created_at, updated_at, created_by
+    ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`, [
+    event.bead_id,
+    event.project_key,
+    event.issue_type,
+    "open",
+    event.title,
+    event.description || null,
+    event.priority ?? 2,
+    event.parent_id || null,
+    null,
+    event.timestamp,
+    event.timestamp,
+    event.created_by || null
+  ]);
+}
+async function handleBeadUpdated(db, event) {
+  const changes = event.changes;
+  const updates = [];
+  const params = [];
+  let paramIndex = 1;
+  if (changes.title) {
+    updates.push(`title = $${paramIndex++}`);
+    params.push(changes.title.new);
+  }
+  if (changes.description) {
+    updates.push(`description = $${paramIndex++}`);
+    params.push(changes.description.new);
+  }
+  if (changes.priority) {
+    updates.push(`priority = $${paramIndex++}`);
+    params.push(changes.priority.new);
+  }
+  if (changes.assignee) {
+    updates.push(`assignee = $${paramIndex++}`);
+    params.push(changes.assignee.new);
+  }
+  if (updates.length > 0) {
+    updates.push(`updated_at = $${paramIndex++}`);
+    params.push(event.timestamp);
+    params.push(event.bead_id);
+    await db.query(`UPDATE beads SET ${updates.join(", ")} WHERE id = $${paramIndex}`, params);
+  }
+}
+async function handleBeadStatusChanged(db, event) {
+  await db.query(`UPDATE beads SET status = $1, updated_at = $2 WHERE id = $3`, [event.to_status, event.timestamp, event.bead_id]);
+}
+async function handleBeadClosed(db, event) {
+  await db.query(`UPDATE beads SET 
+      status = 'closed', 
+      closed_at = $1, 
+      closed_reason = $2, 
+      updated_at = $3 
+    WHERE id = $4`, [event.timestamp, event.reason, event.timestamp, event.bead_id]);
+  const { invalidateBlockedCache: invalidateBlockedCache2 } = await Promise.resolve().then(() => exports_dependencies);
+  await invalidateBlockedCache2(db, event.project_key, event.bead_id);
+}
+async function handleBeadReopened(db, event) {
+  await db.query(`UPDATE beads SET 
+      status = 'open', 
+      closed_at = NULL, 
+      closed_reason = NULL, 
+      updated_at = $1 
+    WHERE id = $2`, [event.timestamp, event.bead_id]);
+}
+async function handleBeadDeleted(db, event) {
+  await db.query(`UPDATE beads SET 
+      deleted_at = $1, 
+      deleted_by = $2, 
+      delete_reason = $3, 
+      updated_at = $4 
+    WHERE id = $5`, [event.timestamp, event.deleted_by || null, event.reason || null, event.timestamp, event.bead_id]);
+}
+async function handleDependencyAdded(db, event) {
+  const dep = event.dependency;
+  await db.query(`INSERT INTO bead_dependencies (bead_id, depends_on_id, relationship, created_at, created_by)
+     VALUES ($1, $2, $3, $4, $5)
+     ON CONFLICT (bead_id, depends_on_id, relationship) DO NOTHING`, [event.bead_id, dep.target, dep.type, event.timestamp, event.added_by || null]);
+  const { invalidateBlockedCache: invalidate } = await Promise.resolve().then(() => exports_dependencies);
+  await invalidate(db, event.project_key, event.bead_id);
+}
+async function handleDependencyRemoved(db, event) {
+  const dep = event.dependency;
+  await db.query(`DELETE FROM bead_dependencies 
+     WHERE bead_id = $1 AND depends_on_id = $2 AND relationship = $3`, [event.bead_id, dep.target, dep.type]);
+  const { invalidateBlockedCache: invalidate } = await Promise.resolve().then(() => exports_dependencies);
+  await invalidate(db, event.project_key, event.bead_id);
+}
+async function handleLabelAdded(db, event) {
+  await db.query(`INSERT INTO bead_labels (bead_id, label, created_at)
+     VALUES ($1, $2, $3)
+     ON CONFLICT (bead_id, label) DO NOTHING`, [event.bead_id, event.label, event.timestamp]);
+}
+async function handleLabelRemoved(db, event) {
+  await db.query(`DELETE FROM bead_labels WHERE bead_id = $1 AND label = $2`, [event.bead_id, event.label]);
+}
+async function handleCommentAdded(db, event) {
+  await db.query(`INSERT INTO bead_comments (bead_id, author, body, parent_id, created_at)
+     VALUES ($1, $2, $3, $4, $5)`, [event.bead_id, event.author, event.body, event.parent_comment_id || null, event.timestamp]);
+}
+async function handleCommentUpdated(db, event) {
+  await db.query(`UPDATE bead_comments SET body = $1, updated_at = $2 WHERE id = $3`, [event.new_body, event.timestamp, event.comment_id]);
+}
+async function handleCommentDeleted(db, event) {
+  await db.query(`DELETE FROM bead_comments WHERE id = $1`, [event.comment_id]);
+}
+async function handleEpicChildAdded(db, event) {
+  await db.query(`UPDATE beads SET parent_id = $1, updated_at = $2 WHERE id = $3`, [event.bead_id, event.timestamp, event.child_id]);
+}
+async function handleEpicChildRemoved(db, event) {
+  await db.query(`UPDATE beads SET parent_id = NULL, updated_at = $1 WHERE id = $2`, [event.timestamp, event.child_id]);
+}
+async function handleBeadAssigned(db, event) {
+  await db.query(`UPDATE beads SET assignee = $1, updated_at = $2 WHERE id = $3`, [event.assignee, event.timestamp, event.bead_id]);
+}
+async function handleWorkStarted(db, event) {
+  await db.query(`UPDATE beads SET status = 'in_progress', updated_at = $1 WHERE id = $2`, [event.timestamp, event.bead_id]);
+}
+async function getBead(db, projectKey, beadId) {
+  const result = await db.query(`SELECT * FROM beads WHERE project_key = $1 AND id = $2 AND deleted_at IS NULL`, [projectKey, beadId]);
+  return result.rows[0] ?? null;
+}
+async function queryBeads(db, projectKey, options = {}) {
+  const conditions = ["project_key = $1"];
+  const params = [projectKey];
+  let paramIndex = 2;
+  if (!options.include_deleted) {
+    conditions.push("deleted_at IS NULL");
+  }
+  if (options.status) {
+    const statuses = Array.isArray(options.status) ? options.status : [options.status];
+    conditions.push(`status = ANY($${paramIndex++})`);
+    params.push(statuses);
+  }
+  if (options.type) {
+    const types2 = Array.isArray(options.type) ? options.type : [options.type];
+    conditions.push(`type = ANY($${paramIndex++})`);
+    params.push(types2);
+  }
+  if (options.parent_id) {
+    conditions.push(`parent_id = $${paramIndex++}`);
+    params.push(options.parent_id);
+  }
+  if (options.assignee) {
+    conditions.push(`assignee = $${paramIndex++}`);
+    params.push(options.assignee);
+  }
+  let query = `SELECT * FROM beads WHERE ${conditions.join(" AND ")} ORDER BY priority DESC, created_at ASC`;
+  if (options.limit) {
+    query += ` LIMIT $${paramIndex++}`;
+    params.push(options.limit);
+  }
+  if (options.offset) {
+    query += ` OFFSET $${paramIndex++}`;
+    params.push(options.offset);
+  }
+  const result = await db.query(query, params);
+  return result.rows;
+}
+async function getDependencies(db, projectKey, beadId) {
+  const result = await db.query(`SELECT * FROM bead_dependencies WHERE bead_id = $1`, [beadId]);
+  return result.rows;
+}
+async function getDependents(db, projectKey, beadId) {
+  const result = await db.query(`SELECT * FROM bead_dependencies WHERE depends_on_id = $1`, [beadId]);
+  return result.rows;
+}
+async function isBlocked(db, projectKey, beadId) {
+  const result = await db.query(`SELECT EXISTS(SELECT 1 FROM blocked_beads_cache WHERE bead_id = $1) as exists`, [beadId]);
+  return result.rows[0]?.exists ?? false;
+}
+async function getBlockers(db, projectKey, beadId) {
+  const result = await db.query(`SELECT blocker_ids FROM blocked_beads_cache WHERE bead_id = $1`, [beadId]);
+  return result.rows[0]?.blocker_ids ?? [];
+}
+async function getLabels(db, projectKey, beadId) {
+  const result = await db.query(`SELECT label FROM bead_labels WHERE bead_id = $1 ORDER BY label`, [beadId]);
+  return result.rows.map((r) => r.label);
+}
+async function getComments(db, projectKey, beadId) {
+  const result = await db.query(`SELECT * FROM bead_comments WHERE bead_id = $1 ORDER BY created_at ASC`, [beadId]);
+  return result.rows;
+}
+async function getNextReadyBead(db, projectKey) {
+  const result = await db.query(`SELECT b.* FROM beads b
+     WHERE b.project_key = $1 
+       AND b.status = 'open'
+       AND b.deleted_at IS NULL
+       AND NOT EXISTS (
+         SELECT 1 FROM blocked_beads_cache bbc WHERE bbc.bead_id = b.id
+       )
+     ORDER BY b.priority DESC, b.created_at ASC
+     LIMIT 1`, [projectKey]);
+  return result.rows[0] ?? null;
+}
+async function getInProgressBeads(db, projectKey) {
+  const result = await db.query(`SELECT * FROM beads 
+     WHERE project_key = $1 AND status = 'in_progress' AND deleted_at IS NULL
+     ORDER BY priority DESC, created_at ASC`, [projectKey]);
+  return result.rows;
+}
+async function getBlockedBeads(db, projectKey) {
+  const result = await db.query(`SELECT b.*, bbc.blocker_ids 
+     FROM beads b
+     JOIN blocked_beads_cache bbc ON b.id = bbc.bead_id
+     WHERE b.project_key = $1 AND b.deleted_at IS NULL
+     ORDER BY b.priority DESC, b.created_at ASC`, [projectKey]);
+  return result.rows.map((r) => {
+    const { blocker_ids, ...bead } = r;
+    return { bead, blockers: blocker_ids };
+  });
+}
+async function markBeadDirty(db, projectKey, beadId) {
+  await db.query(`INSERT INTO dirty_beads (bead_id, marked_at)
+     VALUES ($1, $2)
+     ON CONFLICT (bead_id) DO UPDATE SET marked_at = $2`, [beadId, Date.now()]);
+}
+async function getDirtyBeads(db, projectKey) {
+  const result = await db.query(`SELECT db.bead_id FROM dirty_beads db
+     JOIN beads b ON db.bead_id = b.id
+     WHERE b.project_key = $1
+     ORDER BY db.marked_at ASC`, [projectKey]);
+  return result.rows.map((r) => r.bead_id);
+}
+async function clearDirtyBead(db, projectKey, beadId) {
+  await db.query(`DELETE FROM dirty_beads WHERE bead_id = $1`, [beadId]);
+}
+async function clearAllDirtyBeads(db, projectKey) {
+  await db.query(`DELETE FROM dirty_beads WHERE bead_id IN (
+       SELECT id FROM beads WHERE project_key = $1
+     )`, [projectKey]);
+}
+
+// src/beads/store.ts
+function parseTimestamp2(timestamp) {
+  const ts = parseInt(timestamp, 10);
+  if (Number.isNaN(ts)) {
+    throw new Error(`[BeadsStore] Invalid timestamp: ${timestamp}`);
+  }
+  if (ts > Number.MAX_SAFE_INTEGER) {
+    console.warn(`[BeadsStore] Timestamp ${timestamp} exceeds MAX_SAFE_INTEGER (year 2286+)`);
+  }
+  return ts;
+}
+async function appendBeadEvent(event, projectPath, dbOverride) {
+  const db = dbOverride ?? await getDatabase(projectPath);
+  const { type, project_key, timestamp, ...rest } = event;
+  const result = await db.query(`INSERT INTO events (type, project_key, timestamp, data)
+     VALUES ($1, $2, $3, $4)
+     RETURNING id, sequence`, [type, project_key, timestamp, JSON.stringify(rest)]);
+  const row = result.rows[0];
+  if (!row) {
+    throw new Error("[BeadsStore] Failed to insert event - no row returned");
+  }
+  const { id, sequence } = row;
+  await updateProjections(db, { ...event, id, sequence });
+  return { ...event, id, sequence };
+}
+async function readBeadEvents(options = {}, projectPath, dbOverride) {
+  return withTiming("readBeadEvents", async () => {
+    const db = dbOverride ?? await getDatabase(projectPath);
+    const conditions = [];
+    const params = [];
+    let paramIndex = 1;
+    conditions.push(`type LIKE 'bead_%'`);
+    if (options.projectKey) {
+      conditions.push(`project_key = $${paramIndex++}`);
+      params.push(options.projectKey);
+    }
+    if (options.beadId) {
+      conditions.push(`data->>'bead_id' = $${paramIndex++}`);
+      params.push(options.beadId);
+    }
+    if (options.types && options.types.length > 0) {
+      conditions.push(`type = ANY($${paramIndex++})`);
+      params.push(options.types);
+    }
+    if (options.since !== undefined) {
+      conditions.push(`timestamp >= $${paramIndex++}`);
+      params.push(options.since);
+    }
+    if (options.until !== undefined) {
+      conditions.push(`timestamp <= $${paramIndex++}`);
+      params.push(options.until);
+    }
+    if (options.afterSequence !== undefined) {
+      conditions.push(`sequence > $${paramIndex++}`);
+      params.push(options.afterSequence);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    let query = `
+      SELECT id, type, project_key, timestamp, sequence, data
+      FROM events
+      ${whereClause}
+      ORDER BY sequence ASC
+    `;
+    if (options.limit) {
+      query += ` LIMIT $${paramIndex++}`;
+      params.push(options.limit);
+    }
+    if (options.offset) {
+      query += ` OFFSET $${paramIndex++}`;
+      params.push(options.offset);
+    }
+    const result = await db.query(query, params);
+    return result.rows.map((row) => {
+      const data = typeof row.data === "string" ? JSON.parse(row.data) : row.data;
+      return {
+        id: row.id,
+        type: row.type,
+        project_key: row.project_key,
+        timestamp: parseTimestamp2(row.timestamp),
+        sequence: row.sequence,
+        ...data
+      };
+    });
+  });
+}
+async function replayBeadEvents(options = {}, projectPath, dbOverride) {
+  return withTiming("replayBeadEvents", async () => {
+    const startTime = Date.now();
+    const db = dbOverride ?? await getDatabase(projectPath);
+    if (options.clearViews) {
+      if (options.projectKey) {
+        await db.query(`DELETE FROM bead_comments WHERE bead_id IN (
+            SELECT id FROM beads WHERE project_key = $1
+          )`, [options.projectKey]);
+        await db.query(`DELETE FROM bead_labels WHERE bead_id IN (
+            SELECT id FROM beads WHERE project_key = $1
+          )`, [options.projectKey]);
+        await db.query(`DELETE FROM bead_dependencies WHERE bead_id IN (
+            SELECT id FROM beads WHERE project_key = $1
+          )`, [options.projectKey]);
+        await db.query(`DELETE FROM blocked_beads_cache WHERE bead_id IN (
+            SELECT id FROM beads WHERE project_key = $1
+          )`, [options.projectKey]);
+        await db.query(`DELETE FROM dirty_beads WHERE bead_id IN (
+            SELECT id FROM beads WHERE project_key = $1
+          )`, [options.projectKey]);
+        await db.query(`DELETE FROM beads WHERE project_key = $1`, [
+          options.projectKey
+        ]);
+      } else {
+        await db.exec(`
+          DELETE FROM bead_comments;
+          DELETE FROM bead_labels;
+          DELETE FROM bead_dependencies;
+          DELETE FROM blocked_beads_cache;
+          DELETE FROM dirty_beads;
+          DELETE FROM beads;
+        `);
+      }
+    }
+    const events2 = await readBeadEvents({
+      projectKey: options.projectKey,
+      afterSequence: options.fromSequence
+    }, projectPath, dbOverride);
+    for (const event of events2) {
+      await updateProjections(db, event);
+    }
+    return {
+      eventsReplayed: events2.length,
+      duration: Date.now() - startTime
+    };
+  });
+}
+
+// src/beads/adapter.ts
+function createBeadsAdapter(db, projectKey) {
+  return {
+    async createBead(projectKeyParam, options, projectPath) {
+      const event = {
+        type: "bead_created",
+        project_key: projectKeyParam,
+        bead_id: generateBeadId(projectKeyParam),
+        timestamp: Date.now(),
+        title: options.title,
+        description: options.description || null,
+        issue_type: options.type,
+        priority: options.priority ?? 2,
+        parent_id: options.parent_id || null,
+        created_by: options.created_by || null,
+        metadata: options.metadata || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+      if (options.assignee) {
+        const assignEvent = {
+          type: "bead_assigned",
+          project_key: projectKeyParam,
+          bead_id: event.bead_id,
+          timestamp: Date.now(),
+          assignee: options.assignee,
+          assigned_by: options.created_by || null
+        };
+        await appendBeadEvent(assignEvent, projectPath, db);
+      }
+      const bead = await getBead(db, projectKeyParam, event.bead_id);
+      if (!bead) {
+        throw new Error(`[BeadsAdapter] Failed to create bead - not found after insert`);
+      }
+      return bead;
+    },
+    async getBead(projectKeyParam, beadId, projectPath) {
+      return getBead(db, projectKeyParam, beadId);
+    },
+    async queryBeads(projectKeyParam, options, projectPath) {
+      return queryBeads(db, projectKeyParam, options);
+    },
+    async updateBead(projectKeyParam, beadId, options, projectPath) {
+      const existingBead = await getBead(db, projectKeyParam, beadId);
+      if (!existingBead) {
+        throw new Error(`[BeadsAdapter] Bead not found: ${beadId}`);
+      }
+      const changes = {};
+      if (options.title && options.title !== existingBead.title) {
+        changes.title = { old: existingBead.title, new: options.title };
+      }
+      if (options.description !== undefined && options.description !== existingBead.description) {
+        changes.description = { old: existingBead.description, new: options.description };
+      }
+      if (options.priority !== undefined && options.priority !== existingBead.priority) {
+        changes.priority = { old: existingBead.priority, new: options.priority };
+      }
+      if (options.assignee !== undefined && options.assignee !== existingBead.assignee) {
+        changes.assignee = { old: existingBead.assignee, new: options.assignee };
+      }
+      if (Object.keys(changes).length === 0) {
+        return existingBead;
+      }
+      const event = {
+        type: "bead_updated",
+        project_key: projectKeyParam,
+        bead_id: beadId,
+        timestamp: Date.now(),
+        changes,
+        updated_by: options.updated_by || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+      const updated = await getBead(db, projectKeyParam, beadId);
+      if (!updated) {
+        throw new Error(`[BeadsAdapter] Bead disappeared after update: ${beadId}`);
+      }
+      return updated;
+    },
+    async changeBeadStatus(projectKeyParam, beadId, toStatus, options, projectPath) {
+      const existingBead = await getBead(db, projectKeyParam, beadId);
+      if (!existingBead) {
+        throw new Error(`[BeadsAdapter] Bead not found: ${beadId}`);
+      }
+      const event = {
+        type: "bead_status_changed",
+        project_key: projectKeyParam,
+        bead_id: beadId,
+        timestamp: Date.now(),
+        from_status: existingBead.status,
+        to_status: toStatus,
+        reason: options?.reason || null,
+        changed_by: options?.changed_by || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+      const updated = await getBead(db, projectKeyParam, beadId);
+      if (!updated) {
+        throw new Error(`[BeadsAdapter] Bead disappeared after status change: ${beadId}`);
+      }
+      return updated;
+    },
+    async closeBead(projectKeyParam, beadId, reason, options, projectPath) {
+      const existingBead = await getBead(db, projectKeyParam, beadId);
+      if (!existingBead) {
+        throw new Error(`[BeadsAdapter] Bead not found: ${beadId}`);
+      }
+      const event = {
+        type: "bead_closed",
+        project_key: projectKeyParam,
+        bead_id: beadId,
+        timestamp: Date.now(),
+        reason,
+        closed_by: options?.closed_by || null,
+        files_touched: options?.files_touched || null,
+        duration_ms: options?.duration_ms || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+      const updated = await getBead(db, projectKeyParam, beadId);
+      if (!updated) {
+        throw new Error(`[BeadsAdapter] Bead disappeared after close: ${beadId}`);
+      }
+      return updated;
+    },
+    async reopenBead(projectKeyParam, beadId, options, projectPath) {
+      const existingBead = await getBead(db, projectKeyParam, beadId);
+      if (!existingBead) {
+        throw new Error(`[BeadsAdapter] Bead not found: ${beadId}`);
+      }
+      const event = {
+        type: "bead_reopened",
+        project_key: projectKeyParam,
+        bead_id: beadId,
+        timestamp: Date.now(),
+        reason: options?.reason || null,
+        reopened_by: options?.reopened_by || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+      const updated = await getBead(db, projectKeyParam, beadId);
+      if (!updated) {
+        throw new Error(`[BeadsAdapter] Bead disappeared after reopen: ${beadId}`);
+      }
+      return updated;
+    },
+    async deleteBead(projectKeyParam, beadId, options, projectPath) {
+      const existingBead = await getBead(db, projectKeyParam, beadId);
+      if (!existingBead) {
+        throw new Error(`[BeadsAdapter] Bead not found: ${beadId}`);
+      }
+      const event = {
+        type: "bead_deleted",
+        project_key: projectKeyParam,
+        bead_id: beadId,
+        timestamp: Date.now(),
+        reason: options?.reason || null,
+        deleted_by: options?.deleted_by || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+    },
+    async addDependency(projectKeyParam, beadId, dependsOnId, relationship, options, projectPath) {
+      const sourceBead = await getBead(db, projectKeyParam, beadId);
+      if (!sourceBead) {
+        throw new Error(`[BeadsAdapter] Bead not found: ${beadId}`);
+      }
+      const targetBead = await getBead(db, projectKeyParam, dependsOnId);
+      if (!targetBead) {
+        throw new Error(`[BeadsAdapter] Target bead not found: ${dependsOnId}`);
+      }
+      if (beadId === dependsOnId) {
+        throw new Error(`[BeadsAdapter] Bead cannot depend on itself`);
+      }
+      const { wouldCreateCycle: wouldCreateCycle2 } = await Promise.resolve().then(() => exports_dependencies);
+      const hasCycle = await wouldCreateCycle2(db, beadId, dependsOnId);
+      if (hasCycle) {
+        throw new Error(`[BeadsAdapter] Adding dependency would create a cycle`);
+      }
+      const event = {
+        type: "bead_dependency_added",
+        project_key: projectKeyParam,
+        bead_id: beadId,
+        timestamp: Date.now(),
+        dependency: {
+          target: dependsOnId,
+          type: relationship
+        },
+        reason: options?.reason || null,
+        added_by: options?.added_by || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+      const deps = await getDependencies(db, projectKeyParam, beadId);
+      const dep = deps.find((d) => d.depends_on_id === dependsOnId && d.relationship === relationship);
+      if (!dep) {
+        throw new Error(`[BeadsAdapter] Dependency not found after insert`);
+      }
+      return dep;
+    },
+    async removeDependency(projectKeyParam, beadId, dependsOnId, relationship, options, projectPath) {
+      const event = {
+        type: "bead_dependency_removed",
+        project_key: projectKeyParam,
+        bead_id: beadId,
+        timestamp: Date.now(),
+        dependency: {
+          target: dependsOnId,
+          type: relationship
+        },
+        reason: options?.reason || null,
+        removed_by: options?.removed_by || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+    },
+    async getDependencies(projectKeyParam, beadId, projectPath) {
+      return getDependencies(db, projectKeyParam, beadId);
+    },
+    async getDependents(projectKeyParam, beadId, projectPath) {
+      return getDependents(db, projectKeyParam, beadId);
+    },
+    async isBlocked(projectKeyParam, beadId, projectPath) {
+      return isBlocked(db, projectKeyParam, beadId);
+    },
+    async getBlockers(projectKeyParam, beadId, projectPath) {
+      return getBlockers(db, projectKeyParam, beadId);
+    },
+    async addLabel(projectKeyParam, beadId, label, options, projectPath) {
+      const event = {
+        type: "bead_label_added",
+        project_key: projectKeyParam,
+        bead_id: beadId,
+        timestamp: Date.now(),
+        label,
+        added_by: options?.added_by || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+      return {
+        bead_id: beadId,
+        label,
+        created_at: event.timestamp
+      };
+    },
+    async removeLabel(projectKeyParam, beadId, label, options, projectPath) {
+      const event = {
+        type: "bead_label_removed",
+        project_key: projectKeyParam,
+        bead_id: beadId,
+        timestamp: Date.now(),
+        label,
+        removed_by: options?.removed_by || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+    },
+    async getLabels(projectKeyParam, beadId, projectPath) {
+      return getLabels(db, projectKeyParam, beadId);
+    },
+    async getBeadsWithLabel(projectKeyParam, label, projectPath) {
+      return queryBeads(db, projectKeyParam, { labels: [label] });
+    },
+    async addComment(projectKeyParam, beadId, author, body, options, projectPath) {
+      const event = {
+        type: "bead_comment_added",
+        project_key: projectKeyParam,
+        bead_id: beadId,
+        timestamp: Date.now(),
+        author,
+        body,
+        parent_comment_id: options?.parent_id || null,
+        metadata: options?.metadata || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+      const comments = await getComments(db, projectKeyParam, beadId);
+      const comment = comments[comments.length - 1];
+      if (!comment) {
+        throw new Error(`[BeadsAdapter] Comment not found after insert`);
+      }
+      return comment;
+    },
+    async updateComment(projectKeyParam, commentId, newBody, updated_by, projectPath) {
+      const event = {
+        type: "bead_comment_updated",
+        project_key: projectKeyParam,
+        bead_id: "",
+        timestamp: Date.now(),
+        comment_id: commentId,
+        new_body: newBody,
+        updated_by
+      };
+      await appendBeadEvent(event, projectPath, db);
+      return {
+        id: commentId,
+        bead_id: "",
+        author: updated_by,
+        body: newBody,
+        parent_id: null,
+        created_at: Date.now(),
+        updated_at: event.timestamp
+      };
+    },
+    async deleteComment(projectKeyParam, commentId, deleted_by, options, projectPath) {
+      const event = {
+        type: "bead_comment_deleted",
+        project_key: projectKeyParam,
+        bead_id: "",
+        timestamp: Date.now(),
+        comment_id: commentId,
+        deleted_by,
+        reason: options?.reason || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+    },
+    async getComments(projectKeyParam, beadId, projectPath) {
+      return getComments(db, projectKeyParam, beadId);
+    },
+    async addChildToEpic(projectKeyParam, epicId, childId, options, projectPath) {
+      const event = {
+        type: "bead_epic_child_added",
+        project_key: projectKeyParam,
+        bead_id: epicId,
+        timestamp: Date.now(),
+        child_id: childId,
+        child_index: options?.child_index || null,
+        added_by: options?.added_by || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+    },
+    async removeChildFromEpic(projectKeyParam, epicId, childId, options, projectPath) {
+      const event = {
+        type: "bead_epic_child_removed",
+        project_key: projectKeyParam,
+        bead_id: epicId,
+        timestamp: Date.now(),
+        child_id: childId,
+        reason: options?.reason || null,
+        removed_by: options?.removed_by || null
+      };
+      await appendBeadEvent(event, projectPath, db);
+    },
+    async getEpicChildren(projectKeyParam, epicId, projectPath) {
+      return queryBeads(db, projectKeyParam, { parent_id: epicId });
+    },
+    async isEpicClosureEligible(projectKeyParam, epicId, projectPath) {
+      const children = await queryBeads(db, projectKeyParam, { parent_id: epicId });
+      return children.every((child) => child.status === "closed");
+    },
+    async getNextReadyBead(projectKeyParam, projectPath) {
+      return getNextReadyBead(db, projectKeyParam);
+    },
+    async getInProgressBeads(projectKeyParam, projectPath) {
+      return getInProgressBeads(db, projectKeyParam);
+    },
+    async getBlockedBeads(projectKeyParam, projectPath) {
+      return getBlockedBeads(db, projectKeyParam);
+    },
+    async markDirty(projectKeyParam, beadId, projectPath) {
+      await markBeadDirty(db, projectKeyParam, beadId);
+    },
+    async getDirtyBeads(projectKeyParam, projectPath) {
+      return getDirtyBeads(db, projectKeyParam);
+    },
+    async clearDirty(projectKeyParam, beadId, projectPath) {
+      await clearDirtyBead(db, projectKeyParam, beadId);
+    },
+    async runMigrations(projectPath) {
+      const { beadsMigration: beadsMigration2 } = await Promise.resolve().then(() => (init_migrations2(), exports_migrations2));
+      await db.exec(`
+        CREATE TABLE IF NOT EXISTS schema_version (
+          version INTEGER PRIMARY KEY,
+          applied_at BIGINT NOT NULL,
+          description TEXT
+        );
+      `);
+      await db.exec("BEGIN");
+      try {
+        await db.exec(beadsMigration2.up);
+        await db.query(`INSERT INTO schema_version (version, applied_at, description) VALUES ($1, $2, $3)
+           ON CONFLICT (version) DO NOTHING`, [beadsMigration2.version, Date.now(), beadsMigration2.description]);
+        await db.exec("COMMIT");
+      } catch (error45) {
+        await db.exec("ROLLBACK");
+        throw error45;
+      }
+    },
+    async getBeadsStats(projectPath) {
+      const [totalResult, openResult, inProgressResult, blockedResult, closedResult] = await Promise.all([
+        db.query("SELECT COUNT(*) as count FROM beads WHERE project_key = $1", [projectKey]),
+        db.query("SELECT COUNT(*) as count FROM beads WHERE project_key = $1 AND status = 'open'", [projectKey]),
+        db.query("SELECT COUNT(*) as count FROM beads WHERE project_key = $1 AND status = 'in_progress'", [projectKey]),
+        db.query("SELECT COUNT(*) as count FROM beads WHERE project_key = $1 AND status = 'blocked'", [projectKey]),
+        db.query("SELECT COUNT(*) as count FROM beads WHERE project_key = $1 AND status = 'closed'", [projectKey])
+      ]);
+      const byTypeResult = await db.query("SELECT type, COUNT(*) as count FROM beads WHERE project_key = $1 GROUP BY type", [projectKey]);
+      const by_type = {};
+      for (const row of byTypeResult.rows) {
+        by_type[row.type] = parseInt(row.count);
+      }
+      return {
+        total_beads: parseInt(totalResult.rows[0]?.count || "0"),
+        open: parseInt(openResult.rows[0]?.count || "0"),
+        in_progress: parseInt(inProgressResult.rows[0]?.count || "0"),
+        blocked: parseInt(blockedResult.rows[0]?.count || "0"),
+        closed: parseInt(closedResult.rows[0]?.count || "0"),
+        by_type
+      };
+    },
+    async rebuildBlockedCache(projectKeyParam, projectPath) {
+      const { rebuildAllBlockedCaches: rebuildAllBlockedCaches2 } = await Promise.resolve().then(() => exports_dependencies);
+      await rebuildAllBlockedCaches2(db, projectKeyParam);
+    },
+    async getDatabase(projectPath) {
+      return db;
+    },
+    async close(projectPath) {
+      if (db.close) {
+        await db.close();
+      }
+    },
+    async closeAll() {
+      if (db.close) {
+        await db.close();
+      }
+    }
+  };
+}
+function generateBeadId(projectKey) {
+  const hash2 = projectKey.split("").reduce((acc, char) => (acc << 5) - acc + char.charCodeAt(0) | 0, 0).toString(36).slice(0, 6);
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).slice(2, 5);
+  return `bd-${hash2}-${timestamp}${random}`;
+}
+
+// src/beads/index.ts
+init_migrations2();
+
+// src/beads/labels.ts
+async function getBeadsByLabel(db, projectKey, label) {
+  const result = await db.query(`SELECT b.* FROM beads b
+     JOIN bead_labels bl ON b.id = bl.bead_id
+     WHERE b.project_key = $1 AND bl.label = $2 AND b.deleted_at IS NULL
+     ORDER BY b.priority DESC, b.created_at ASC`, [projectKey, label]);
+  return result.rows;
+}
+async function getAllLabels(db, projectKey) {
+  const result = await db.query(`SELECT DISTINCT bl.label FROM bead_labels bl
+     JOIN beads b ON bl.bead_id = b.id
+     WHERE b.project_key = $1 AND b.deleted_at IS NULL
+     ORDER BY bl.label`, [projectKey]);
+  return result.rows.map((r) => r.label);
+}
+// src/beads/comments.ts
+async function getCommentById(db, commentId) {
+  const result = await db.query(`SELECT * FROM bead_comments WHERE id = $1`, [commentId]);
+  return result.rows[0] ?? null;
+}
+async function getCommentThread(db, rootCommentId) {
+  const result = await db.query(`WITH RECURSIVE thread AS (
+       -- Root comment
+       SELECT * FROM bead_comments WHERE id = $1
+       
+       UNION
+       
+       -- Replies
+       SELECT c.* FROM bead_comments c
+       JOIN thread t ON c.parent_id = t.id
+     )
+     SELECT * FROM thread ORDER BY created_at ASC`, [rootCommentId]);
+  return result.rows;
+}
+// src/beads/jsonl.ts
+import { createHash } from "node:crypto";
+function serializeToJSONL(bead) {
+  return JSON.stringify(bead);
+}
+function parseJSONL(jsonl) {
+  if (!jsonl || jsonl.trim() === "") {
+    return [];
+  }
+  const lines = jsonl.split(`
+`);
+  const beads = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      continue;
+    }
+    try {
+      const bead = JSON.parse(trimmed);
+      beads.push(bead);
+    } catch (err) {
+      throw new Error(`Invalid JSON in JSONL: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return beads;
+}
+function computeContentHash(bead) {
+  const canonical = JSON.stringify(bead, Object.keys(bead).sort());
+  return createHash("sha256").update(canonical).digest("hex");
+}
+async function exportToJSONL(adapter, projectKey, options = {}) {
+  const db = await adapter.getDatabase();
+  const conditions = ["project_key = $1"];
+  const params = [projectKey];
+  let paramIndex = 2;
+  if (!options.includeDeleted) {
+    conditions.push("deleted_at IS NULL");
+  }
+  if (options.beadIds && options.beadIds.length > 0) {
+    conditions.push(`id = ANY($${paramIndex++})`);
+    params.push(options.beadIds);
+  }
+  const query = `
+    SELECT * FROM beads
+    WHERE ${conditions.join(" AND ")}
+    ORDER BY id ASC
+  `;
+  const result = await db.query(query, params);
+  const beads = result.rows;
+  if (beads.length === 0) {
+    return "";
+  }
+  const lines = [];
+  for (const bead of beads) {
+    const deps = await getDependencies(db, projectKey, bead.id);
+    const dependencies = deps.map((d) => ({
+      depends_on_id: d.depends_on_id,
+      type: d.relationship
+    }));
+    const labels = await getLabels(db, projectKey, bead.id);
+    const comments = await getComments(db, projectKey, bead.id);
+    const commentExports = comments.map((c) => ({
+      author: c.author,
+      text: c.body
+    }));
+    const beadExport = {
+      id: bead.id,
+      title: bead.title,
+      description: bead.description || undefined,
+      status: bead.deleted_at ? "tombstone" : bead.status,
+      priority: bead.priority,
+      issue_type: bead.type,
+      created_at: new Date(bead.created_at).toISOString(),
+      updated_at: new Date(bead.updated_at).toISOString(),
+      closed_at: bead.closed_at ? new Date(bead.closed_at).toISOString() : undefined,
+      assignee: bead.assignee || undefined,
+      parent_id: bead.parent_id || undefined,
+      dependencies,
+      labels,
+      comments: commentExports
+    };
+    lines.push(serializeToJSONL(beadExport));
+  }
+  return lines.join(`
+`);
+}
+async function exportDirtyBeads(adapter, projectKey) {
+  const db = await adapter.getDatabase();
+  const dirtyIds = await getDirtyBeads(db, projectKey);
+  if (dirtyIds.length === 0) {
+    return { jsonl: "", beadIds: [] };
+  }
+  const jsonl = await exportToJSONL(adapter, projectKey, {
+    beadIds: dirtyIds
+  });
+  return { jsonl, beadIds: dirtyIds };
+}
+async function importFromJSONL(adapter, projectKey, jsonl, options = {}) {
+  const beads = parseJSONL(jsonl);
+  const result = {
+    created: 0,
+    updated: 0,
+    skipped: 0,
+    errors: []
+  };
+  for (const beadExport of beads) {
+    try {
+      await importSingleBead(adapter, projectKey, beadExport, options, result);
+    } catch (err) {
+      result.errors.push({
+        beadId: beadExport.id,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return result;
+}
+async function importSingleBead(adapter, projectKey, beadExport, options, result) {
+  const existing = await adapter.getBead(projectKey, beadExport.id);
+  if (existing && options.skipExisting) {
+    result.skipped++;
+    return;
+  }
+  if (existing) {
+    const existingHash = await computeBeadHash(adapter, projectKey, existing.id);
+    const importHash = computeContentHash(beadExport);
+    if (existingHash === importHash) {
+      result.skipped++;
+      return;
+    }
+  }
+  if (options.dryRun) {
+    if (existing) {
+      result.updated++;
+    } else {
+      result.created++;
+    }
+    return;
+  }
+  if (!existing) {
+    const db = await adapter.getDatabase();
+    await db.query(`INSERT INTO beads (
+        id, project_key, type, status, title, description, priority,
+        parent_id, assignee, created_at, updated_at
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, [
+      beadExport.id,
+      projectKey,
+      beadExport.issue_type,
+      beadExport.status === "tombstone" ? "closed" : beadExport.status,
+      beadExport.title,
+      beadExport.description || null,
+      beadExport.priority,
+      beadExport.parent_id || null,
+      beadExport.assignee || null,
+      new Date(beadExport.created_at).getTime(),
+      new Date(beadExport.updated_at).getTime()
+    ]);
+    if (beadExport.status === "closed" && beadExport.closed_at) {
+      await db.query("UPDATE beads SET closed_at = $1 WHERE id = $2", [new Date(beadExport.closed_at).getTime(), beadExport.id]);
+    }
+    if (beadExport.status === "tombstone") {
+      await db.query("UPDATE beads SET deleted_at = $1 WHERE id = $2", [Date.now(), beadExport.id]);
+    }
+    result.created++;
+  } else {
+    await adapter.updateBead(projectKey, beadExport.id, {
+      title: beadExport.title,
+      description: beadExport.description,
+      priority: beadExport.priority,
+      assignee: beadExport.assignee
+    });
+    if (existing.status !== beadExport.status) {
+      if (beadExport.status === "closed") {
+        await adapter.closeBead(projectKey, beadExport.id, "imported");
+      } else if (beadExport.status === "in_progress") {
+        const db = await adapter.getDatabase();
+        await db.query("UPDATE beads SET status = $1, updated_at = $2 WHERE id = $3", ["in_progress", Date.now(), beadExport.id]);
+      }
+    }
+    result.updated++;
+  }
+  await importDependencies(adapter, projectKey, beadExport);
+  await importLabels(adapter, projectKey, beadExport);
+  await importComments(adapter, projectKey, beadExport);
+}
+async function computeBeadHash(adapter, projectKey, beadId) {
+  const db = await adapter.getDatabase();
+  const beadResult = await db.query("SELECT * FROM beads WHERE project_key = $1 AND id = $2", [projectKey, beadId]);
+  const bead = beadResult.rows[0];
+  if (!bead) {
+    throw new Error(`Bead not found: ${beadId}`);
+  }
+  const deps = await getDependencies(db, projectKey, beadId);
+  const dependencies = deps.map((d) => ({
+    depends_on_id: d.depends_on_id,
+    type: d.relationship
+  }));
+  const labels = await getLabels(db, projectKey, beadId);
+  const comments = await getComments(db, projectKey, beadId);
+  const commentExports = comments.map((c) => ({
+    author: c.author,
+    text: c.body
+  }));
+  const beadExport = {
+    id: bead.id,
+    title: bead.title,
+    description: bead.description || undefined,
+    status: bead.deleted_at ? "tombstone" : bead.status,
+    priority: bead.priority,
+    issue_type: bead.type,
+    created_at: new Date(bead.created_at).toISOString(),
+    updated_at: new Date(bead.updated_at).toISOString(),
+    closed_at: bead.closed_at ? new Date(bead.closed_at).toISOString() : undefined,
+    assignee: bead.assignee || undefined,
+    parent_id: bead.parent_id || undefined,
+    dependencies,
+    labels,
+    comments: commentExports
+  };
+  return computeContentHash(beadExport);
+}
+async function importDependencies(adapter, projectKey, beadExport) {
+  const db = await adapter.getDatabase();
+  await db.query("DELETE FROM bead_dependencies WHERE bead_id = $1", [
+    beadExport.id
+  ]);
+  for (const dep of beadExport.dependencies) {
+    await adapter.addDependency(projectKey, beadExport.id, dep.depends_on_id, dep.type);
+  }
+}
+async function importLabels(adapter, projectKey, beadExport) {
+  const db = await adapter.getDatabase();
+  await db.query("DELETE FROM bead_labels WHERE bead_id = $1", [
+    beadExport.id
+  ]);
+  for (const label of beadExport.labels) {
+    await adapter.addLabel(projectKey, beadExport.id, label);
+  }
+}
+async function importComments(adapter, projectKey, beadExport) {
+  const db = await adapter.getDatabase();
+  await db.query("DELETE FROM bead_comments WHERE bead_id = $1", [
+    beadExport.id
+  ]);
+  for (const comment of beadExport.comments) {
+    await adapter.addComment(projectKey, beadExport.id, comment.author, comment.text);
+  }
+}
+// src/beads/flush-manager.ts
+import { writeFile } from "node:fs/promises";
+class FlushManager {
+  adapter;
+  projectKey;
+  outputPath;
+  debounceMs;
+  onFlush;
+  timer = null;
+  flushing = false;
+  constructor(options) {
+    this.adapter = options.adapter;
+    this.projectKey = options.projectKey;
+    this.outputPath = options.outputPath;
+    this.debounceMs = options.debounceMs ?? 30000;
+    this.onFlush = options.onFlush;
+  }
+  scheduleFlush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+    }
+    this.timer = setTimeout(() => {
+      this.flush().catch((err) => {
+        console.error("[FlushManager] Flush error:", err);
+      });
+    }, this.debounceMs);
+  }
+  async flush() {
+    const startTime = Date.now();
+    if (this.flushing) {
+      return {
+        beadsExported: 0,
+        bytesWritten: 0,
+        duration: 0
+      };
+    }
+    this.flushing = true;
+    try {
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = null;
+      }
+      const { jsonl, beadIds } = await exportDirtyBeads(this.adapter, this.projectKey);
+      if (beadIds.length === 0) {
+        return {
+          beadsExported: 0,
+          bytesWritten: 0,
+          duration: Date.now() - startTime
+        };
+      }
+      await writeFile(this.outputPath, jsonl, "utf-8");
+      const bytesWritten = Buffer.byteLength(jsonl, "utf-8");
+      const db = await this.adapter.getDatabase();
+      for (const beadId of beadIds) {
+        await clearDirtyBead(db, this.projectKey, beadId);
+      }
+      const result = {
+        beadsExported: beadIds.length,
+        bytesWritten,
+        duration: Date.now() - startTime
+      };
+      if (this.onFlush) {
+        this.onFlush(result);
+      }
+      return result;
+    } finally {
+      this.flushing = false;
+    }
+  }
+  stop() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+}
+// src/beads/merge.ts
+var DEFAULT_TOMBSTONE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+var MIN_TOMBSTONE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+var CLOCK_SKEW_GRACE_MS = 60 * 60 * 1000;
+var STATUS_TOMBSTONE = "tombstone";
+function makeKey(bead) {
+  const key = {
+    id: bead.id,
+    createdAt: bead.created_at,
+    createdBy: undefined
+  };
+  return JSON.stringify(key);
+}
+function isTombstone(bead) {
+  return bead.status === STATUS_TOMBSTONE;
+}
+function isExpiredTombstone(bead, ttlMs = DEFAULT_TOMBSTONE_TTL_MS) {
+  if (!isTombstone(bead)) {
+    return false;
+  }
+  if (!bead.closed_at) {
+    return false;
+  }
+  const deletedAt = new Date(bead.closed_at).getTime();
+  if (Number.isNaN(deletedAt)) {
+    return false;
+  }
+  const effectiveTtl = ttlMs + CLOCK_SKEW_GRACE_MS;
+  const expirationTime = deletedAt + effectiveTtl;
+  return Date.now() > expirationTime;
+}
+function isTimeAfter(t1, t2) {
+  if (!t1)
+    return false;
+  if (!t2)
+    return true;
+  const time1 = new Date(t1).getTime();
+  const time22 = new Date(t2).getTime();
+  const err1 = Number.isNaN(time1);
+  const err2 = Number.isNaN(time22);
+  if (err1 && err2)
+    return true;
+  if (err1)
+    return false;
+  if (err2)
+    return true;
+  return time1 >= time22;
+}
+function maxTime(t1, t2) {
+  if (!t1 && !t2)
+    return;
+  if (!t1)
+    return t2;
+  if (!t2)
+    return t1;
+  const time1 = new Date(t1).getTime();
+  const time22 = new Date(t2).getTime();
+  if (Number.isNaN(time1) && Number.isNaN(time22))
+    return t2;
+  if (Number.isNaN(time1))
+    return t2;
+  if (Number.isNaN(time22))
+    return t1;
+  return time1 > time22 ? t1 : t2;
+}
+function mergeField(base, left, right) {
+  if (base === left && base !== right)
+    return right;
+  if (base === right && base !== left)
+    return left;
+  return left;
+}
+function mergeFieldByUpdatedAt(base, left, right, leftUpdatedAt, rightUpdatedAt) {
+  if (base === left && base !== right)
+    return right;
+  if (base === right && base !== left)
+    return left;
+  if (left === right)
+    return left;
+  return isTimeAfter(leftUpdatedAt, rightUpdatedAt) ? left : right;
+}
+function mergeStatus(base, left, right) {
+  if (left === STATUS_TOMBSTONE || right === STATUS_TOMBSTONE) {
+    return STATUS_TOMBSTONE;
+  }
+  if (left === "closed" || right === "closed") {
+    return "closed";
+  }
+  return mergeField(base ?? "open", left ?? "open", right ?? "open");
+}
+function mergePriority(base, left, right) {
+  if (base === left && base !== right)
+    return right;
+  if (base === right && base !== left)
+    return left;
+  if (left === right)
+    return left;
+  if (left === 0 && right !== 0)
+    return right;
+  if (right === 0 && left !== 0)
+    return left;
+  return left < right ? left : right;
+}
+function mergeDependencies(left, right) {
+  const seen = new Set;
+  const result = [];
+  for (const dep of left) {
+    const key = `${dep.depends_on_id}:${dep.type}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(dep);
+    }
+  }
+  for (const dep of right) {
+    const key = `${dep.depends_on_id}:${dep.type}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(dep);
+    }
+  }
+  return result;
+}
+function mergeLabels(left, right) {
+  const seen = new Set;
+  const result = [];
+  for (const label of left) {
+    if (!seen.has(label)) {
+      seen.add(label);
+      result.push(label);
+    }
+  }
+  for (const label of right) {
+    if (!seen.has(label)) {
+      seen.add(label);
+      result.push(label);
+    }
+  }
+  return result;
+}
+function mergeComments(left, right) {
+  const seen = new Set;
+  const result = [];
+  for (const comment of left) {
+    const key = `${comment.author}:${comment.text}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(comment);
+    }
+  }
+  for (const comment of right) {
+    const key = `${comment.author}:${comment.text}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(comment);
+    }
+  }
+  return result;
+}
+function mergeTombstones(left, right) {
+  if (!left.closed_at && !right.closed_at)
+    return left;
+  if (!left.closed_at)
+    return right;
+  if (!right.closed_at)
+    return left;
+  return isTimeAfter(left.closed_at, right.closed_at) ? left : right;
+}
+function mergeIssue(base, left, right) {
+  const merged = {
+    id: base.id,
+    title: "",
+    status: "open",
+    priority: 0,
+    issue_type: base.issue_type,
+    created_at: base.created_at,
+    updated_at: "",
+    dependencies: [],
+    labels: [],
+    comments: []
+  };
+  merged.title = mergeFieldByUpdatedAt(base.title, left.title, right.title, left.updated_at, right.updated_at) ?? left.title;
+  merged.description = mergeFieldByUpdatedAt(base.description, left.description, right.description, left.updated_at, right.updated_at);
+  merged.status = mergeStatus(base.status, left.status, right.status);
+  merged.priority = mergePriority(base.priority, left.priority, right.priority);
+  merged.issue_type = mergeField(base.issue_type, left.issue_type, right.issue_type);
+  merged.updated_at = maxTime(left.updated_at, right.updated_at) ?? left.updated_at;
+  if (merged.status === "closed") {
+    merged.closed_at = maxTime(left.closed_at, right.closed_at);
+  }
+  merged.assignee = mergeField(base.assignee, left.assignee, right.assignee);
+  merged.parent_id = mergeField(base.parent_id, left.parent_id, right.parent_id);
+  merged.dependencies = mergeDependencies(left.dependencies, right.dependencies);
+  merged.labels = mergeLabels(left.labels, right.labels);
+  merged.comments = mergeComments(left.comments, right.comments);
+  return { merged, conflict: "" };
+}
+function merge3Way(base, left, right, options = {}) {
+  const ttl = options.tombstoneTtlMs ?? DEFAULT_TOMBSTONE_TTL_MS;
+  const debug2 = options.debug ?? false;
+  const baseMap = new Map;
+  for (const bead of base) {
+    baseMap.set(makeKey(bead), bead);
+  }
+  const leftMap = new Map;
+  for (const bead of left) {
+    leftMap.set(makeKey(bead), bead);
+  }
+  const rightMap = new Map;
+  for (const bead of right) {
+    rightMap.set(makeKey(bead), bead);
+  }
+  const allKeys = new Set;
+  for (const key of baseMap.keys())
+    allKeys.add(key);
+  for (const key of leftMap.keys())
+    allKeys.add(key);
+  for (const key of rightMap.keys())
+    allKeys.add(key);
+  const result = [];
+  const conflicts = [];
+  for (const key of allKeys) {
+    const baseBead = baseMap.get(key);
+    const leftBead = leftMap.get(key);
+    const rightBead = rightMap.get(key);
+    const leftTombstone = leftBead !== undefined && isTombstone(leftBead);
+    const rightTombstone = rightBead !== undefined && isTombstone(rightBead);
+    if (baseBead && leftBead && rightBead) {
+      if (leftTombstone && rightTombstone) {
+        result.push(mergeTombstones(leftBead, rightBead));
+        continue;
+      }
+      if (leftTombstone && !rightTombstone) {
+        if (isExpiredTombstone(leftBead, ttl)) {
+          result.push(rightBead);
+        } else {
+          result.push(leftBead);
+        }
+        continue;
+      }
+      if (rightTombstone && !leftTombstone) {
+        if (isExpiredTombstone(rightBead, ttl)) {
+          result.push(leftBead);
+        } else {
+          result.push(rightBead);
+        }
+        continue;
+      }
+      const { merged, conflict } = mergeIssue(baseBead, leftBead, rightBead);
+      if (conflict) {
+        conflicts.push(conflict);
+      } else {
+        result.push(merged);
+      }
+    } else if (!baseBead && leftBead && rightBead) {
+      if (leftTombstone && rightTombstone) {
+        result.push(mergeTombstones(leftBead, rightBead));
+        continue;
+      }
+      if (leftTombstone && !rightTombstone) {
+        if (isExpiredTombstone(leftBead, ttl)) {
+          result.push(rightBead);
+        } else {
+          result.push(leftBead);
+        }
+        continue;
+      }
+      if (rightTombstone && !leftTombstone) {
+        if (isExpiredTombstone(rightBead, ttl)) {
+          result.push(leftBead);
+        } else {
+          result.push(rightBead);
+        }
+        continue;
+      }
+      const emptyBase = {
+        id: leftBead.id,
+        title: "",
+        status: "open",
+        priority: 0,
+        issue_type: leftBead.issue_type,
+        created_at: leftBead.created_at,
+        updated_at: leftBead.created_at,
+        dependencies: [],
+        labels: [],
+        comments: []
+      };
+      const { merged } = mergeIssue(emptyBase, leftBead, rightBead);
+      result.push(merged);
+    } else if (baseBead && leftBead && !rightBead) {
+      if (leftTombstone) {
+        result.push(leftBead);
+      }
+    } else if (baseBead && !leftBead && rightBead) {
+      if (rightTombstone) {
+        result.push(rightBead);
+      }
+    } else if (!baseBead && leftBead && !rightBead) {
+      result.push(leftBead);
+    } else if (!baseBead && !leftBead && rightBead) {
+      result.push(rightBead);
+    }
+  }
+  if (debug2) {}
+  return { merged: result, conflicts };
+}
+function mergeJsonl(baseJsonl, leftJsonl, rightJsonl, options = {}) {
+  const parseJSONL2 = (jsonl2) => {
+    if (!jsonl2 || jsonl2.trim() === "")
+      return [];
+    return jsonl2.split(`
+`).filter((line) => line.trim() !== "").map((line) => JSON.parse(line));
+  };
+  const base = parseJSONL2(baseJsonl);
+  const left = parseJSONL2(leftJsonl);
+  const right = parseJSONL2(rightJsonl);
+  const { merged, conflicts } = merge3Way(base, left, right, options);
+  const jsonl = merged.map((bead) => JSON.stringify(bead)).join(`
+`);
+  return { jsonl, conflicts };
+}
+// src/index.ts
 var SWARM_MAIL_VERSION = "0.1.0";
 export {
+  wouldCreateCycle,
   withTiming,
   withTimeout,
+  updateProjections,
+  serializeToJSONL,
   sendSwarmMessage,
   sendMessage,
   sendAgentMessage,
@@ -16637,38 +18512,69 @@ export {
   reserveAgentFiles,
   replayEventsBatched2 as replayEventsBatched,
   replayEvents,
+  replayBeadEvents,
   releaseSwarmFiles,
   releaseAgentFiles,
   registerAgent,
+  rebuildBeadBlockedCache,
+  rebuildAllBlockedCaches,
   readSwarmMessage,
   readEvents,
+  readBeadEvents,
   readAgentMessage,
+  queryBeads,
+  parseJSONL,
   migrations,
+  mergeJsonl,
+  merge3Way,
+  markBeadDirty,
+  isTombstone,
   isMigrationApplied,
+  isExpiredTombstone,
   isEventType,
   isDatabaseHealthy,
+  isBlocked,
+  invalidateBlockedCache,
   inspectState,
   initSwarmAgent,
   initAgent,
+  importFromJSONL,
   getThreadMessages,
   getSwarmMail,
   getSwarmInbox,
   getPendingMigrations,
+  getOpenBlockers,
+  getNextReadyBead,
   getMessage,
   getLatestSequence,
+  getLabels,
   getInbox,
+  getInProgressBeads,
   getEventTimeline,
   getEvalStats,
   getEvalRecords,
+  getDirtyBeads,
+  getDependents,
+  getDependencies,
   getDatabaseStats,
   getDatabasePath2 as getDatabasePath,
   getDatabase,
   getCurrentVersion,
+  getComments,
+  getCommentThread,
+  getCommentById,
+  getBlockers,
+  getBlockedBeads,
+  getBeadsByLabel,
+  getBead,
   getAppliedMigrations,
+  getAllLabels,
   getAgents,
   getAgentInbox,
   getAgent,
   getActiveReservations,
+  exportToJSONL,
+  exportDirtyBeads,
   debugReservations,
   debugMessage,
   debugEvents,
@@ -16676,15 +18582,22 @@ export {
   createSwarmMailAdapter,
   createInMemorySwarmMail,
   createEvent,
+  createBeadsAdapter,
+  computeContentHash,
   closeSwarmMail,
   closeDatabase,
   closeAllSwarmMail,
   closeAllDatabases,
+  clearDirtyBead,
+  clearAllDirtyBeads,
   checkSwarmHealth,
   checkHealth,
   checkConflicts,
+  beadsMigrations,
+  beadsMigration,
   appendEvents,
   appendEvent,
+  appendBeadEvent,
   acknowledgeSwarmMessage,
   acknowledgeMessage,
   TaskStartedEventSchema,
@@ -16695,14 +18608,19 @@ export {
   SwarmCheckpointedEventSchema,
   SubtaskOutcomeEventSchema,
   SWARM_MAIL_VERSION,
+  STATUS_TOMBSTONE,
   PGlite2 as PGlite,
   MessageSentEventSchema,
   MessageReadEventSchema,
   MessageAckedEventSchema,
+  MIN_TOMBSTONE_TTL_MS,
   HumanFeedbackEventSchema,
+  FlushManager,
   FileReservedEventSchema,
   FileReleasedEventSchema,
   DecompositionGeneratedEventSchema,
+  DEFAULT_TOMBSTONE_TTL_MS,
+  CLOCK_SKEW_GRACE_MS,
   BaseEventSchema,
   AgentRegisteredEventSchema,
   AgentEventSchema,