swarm-mail 0.2.1 → 0.3.0

package/dist/index.js

@@ -18229,7 +18229,7 @@ var init_store = __esm(() => {
   TIMESTAMP_SAFE_UNTIL = new Date("2286-01-01").getTime();
 });
 
-// src/beads/dependencies.ts
+// src/hive/dependencies.ts
 var exports_dependencies = {};
 __export(exports_dependencies, {
   wouldCreateCycle: () => wouldCreateCycle,
@@ -18238,82 +18238,82 @@ __export(exports_dependencies, {
   invalidateBlockedCache: () => invalidateBlockedCache,
   getOpenBlockers: () => getOpenBlockers
 });
-async function wouldCreateCycle(db, beadId, dependsOnId) {
+async function wouldCreateCycle(db, cellId, dependsOnId) {
   const result = await db.query(`WITH RECURSIVE paths AS (
        -- Start from the target (what we want to depend on)
        SELECT
-         bead_id,
+         cell_id,
          depends_on_id,
          1 as depth
        FROM bead_dependencies
-       WHERE bead_id = $2
+       WHERE cell_id = $2
        
        UNION
        
        -- Follow dependencies transitively
        SELECT
-         bd.bead_id,
+         bd.cell_id,
          bd.depends_on_id,
          p.depth + 1
        FROM bead_dependencies bd
-       JOIN paths p ON bd.bead_id = p.depends_on_id
+       JOIN paths p ON bd.cell_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]);
+     ) as exists`, [cellId, dependsOnId, MAX_DEPENDENCY_DEPTH]);
   return result.rows[0]?.exists ?? false;
 }
-async function getOpenBlockers(db, projectKey, beadId) {
+async function getOpenBlockers(db, projectKey, cellId) {
   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'
+       WHERE cell_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
+       JOIN blockers b ON bd.cell_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]);
+     WHERE bead.project_key = $2 AND bead.status != 'closed' AND bead.deleted_at IS NULL`, [cellId, 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);
+async function rebuildBeadBlockedCache(db, projectKey, cellId) {
+  const blockerIds = await getOpenBlockers(db, projectKey, cellId);
   if (blockerIds.length > 0) {
-    await db.query(`INSERT INTO blocked_beads_cache (bead_id, blocker_ids, updated_at)
+    await db.query(`INSERT INTO blocked_beads_cache (cell_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()]);
+       ON CONFLICT (cell_id) 
+       DO UPDATE SET blocker_ids = $2, updated_at = $3`, [cellId, blockerIds, Date.now()]);
   } else {
-    await db.query(`DELETE FROM blocked_beads_cache WHERE bead_id = $1`, [beadId]);
+    await db.query(`DELETE FROM blocked_beads_cache WHERE cell_id = $1`, [cellId]);
   }
 }
 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
+     JOIN bead_dependencies bd ON b.id = bd.cell_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]);
+async function invalidateBlockedCache(db, projectKey, cellId) {
+  await rebuildBeadBlockedCache(db, projectKey, cellId);
+  const dependents = await db.query(`SELECT cell_id FROM bead_dependencies WHERE depends_on_id = $1`, [cellId]);
   for (const row of dependents.rows) {
-    await rebuildBeadBlockedCache(db, projectKey, row.bead_id);
+    await rebuildBeadBlockedCache(db, projectKey, row.cell_id);
   }
 }
 var MAX_DEPENDENCY_DEPTH = 100;
 
-// src/beads/migrations.ts
+// src/hive/migrations.ts
 var exports_migrations2 = {};
 __export(exports_migrations2, {
   beadsMigrations: () => beadsMigrations,
@@ -18363,15 +18363,15 @@ var init_migrations2 = __esm(() => {
     -- Dependencies Table
     -- ========================================================================
     CREATE TABLE IF NOT EXISTS bead_dependencies (
-      bead_id TEXT NOT NULL REFERENCES beads(id) ON DELETE CASCADE,
+      cell_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)
+      PRIMARY KEY (cell_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_bead ON bead_dependencies(cell_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);
 
@@ -18379,10 +18379,10 @@ var init_migrations2 = __esm(() => {
     -- Labels Table
     -- ========================================================================
     CREATE TABLE IF NOT EXISTS bead_labels (
-      bead_id TEXT NOT NULL REFERENCES beads(id) ON DELETE CASCADE,
+      cell_id TEXT NOT NULL REFERENCES beads(id) ON DELETE CASCADE,
       label TEXT NOT NULL,
       created_at BIGINT NOT NULL,
-      PRIMARY KEY (bead_id, label)
+      PRIMARY KEY (cell_id, label)
     );
 
     CREATE INDEX IF NOT EXISTS idx_bead_labels_label ON bead_labels(label);
@@ -18392,7 +18392,7 @@ var init_migrations2 = __esm(() => {
     -- ========================================================================
     CREATE TABLE IF NOT EXISTS bead_comments (
       id SERIAL PRIMARY KEY,
-      bead_id TEXT NOT NULL REFERENCES beads(id) ON DELETE CASCADE,
+      cell_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,
@@ -18400,7 +18400,7 @@ var init_migrations2 = __esm(() => {
       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_bead ON bead_comments(cell_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);
 
@@ -18410,7 +18410,7 @@ var init_migrations2 = __esm(() => {
     -- 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,
+      cell_id TEXT PRIMARY KEY REFERENCES beads(id) ON DELETE CASCADE,
       blocker_ids TEXT[] NOT NULL,
       updated_at BIGINT NOT NULL
     );
@@ -18422,7 +18422,7 @@ var init_migrations2 = __esm(() => {
     -- ========================================================================
     -- 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,
+      cell_id TEXT PRIMARY KEY REFERENCES beads(id) ON DELETE CASCADE,
       marked_at BIGINT NOT NULL
     );
 
@@ -18912,74 +18912,74 @@ async function closeAllSwarmMail() {
 // src/index.ts
 init_streams();
 
-// src/beads/store.ts
+// src/hive/store.ts
 init_streams();
 
-// src/beads/projections.ts
+// src/hive/projections.ts
 async function updateProjections(db, event) {
   switch (event.type) {
-    case "bead_created":
+    case "cell_created":
       await handleBeadCreated(db, event);
       break;
-    case "bead_updated":
+    case "cell_updated":
       await handleBeadUpdated(db, event);
       break;
-    case "bead_status_changed":
-      await handleBeadStatusChanged(db, event);
+    case "cell_status_changed":
+      await handleCellStatusChanged(db, event);
       break;
-    case "bead_closed":
+    case "cell_closed":
       await handleBeadClosed(db, event);
       break;
-    case "bead_reopened":
+    case "cell_reopened":
       await handleBeadReopened(db, event);
       break;
-    case "bead_deleted":
+    case "cell_deleted":
       await handleBeadDeleted(db, event);
       break;
-    case "bead_dependency_added":
+    case "cell_dependency_added":
       await handleDependencyAdded(db, event);
       break;
-    case "bead_dependency_removed":
+    case "cell_dependency_removed":
       await handleDependencyRemoved(db, event);
       break;
-    case "bead_label_added":
+    case "cell_label_added":
       await handleLabelAdded(db, event);
       break;
-    case "bead_label_removed":
+    case "cell_label_removed":
       await handleLabelRemoved(db, event);
       break;
-    case "bead_comment_added":
+    case "cell_comment_added":
       await handleCommentAdded(db, event);
       break;
-    case "bead_comment_updated":
+    case "cell_comment_updated":
       await handleCommentUpdated(db, event);
       break;
-    case "bead_comment_deleted":
+    case "cell_comment_deleted":
       await handleCommentDeleted(db, event);
       break;
-    case "bead_epic_child_added":
+    case "cell_epic_child_added":
       await handleEpicChildAdded(db, event);
       break;
-    case "bead_epic_child_removed":
+    case "cell_epic_child_removed":
       await handleEpicChildRemoved(db, event);
       break;
-    case "bead_assigned":
+    case "cell_assigned":
       await handleBeadAssigned(db, event);
       break;
-    case "bead_work_started":
+    case "cell_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);
+  await markBeadDirty(db, event.project_key, event.cell_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.cell_id,
     event.project_key,
     event.issue_type,
     "open",
@@ -19017,12 +19017,12 @@ async function handleBeadUpdated(db, event) {
   if (updates.length > 0) {
     updates.push(`updated_at = $${paramIndex++}`);
     params.push(event.timestamp);
-    params.push(event.bead_id);
+    params.push(event.cell_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 handleCellStatusChanged(db, event) {
+  await db.query(`UPDATE beads SET status = $1, updated_at = $2 WHERE id = $3`, [event.to_status, event.timestamp, event.cell_id]);
 }
 async function handleBeadClosed(db, event) {
   await db.query(`UPDATE beads SET 
@@ -19030,9 +19030,9 @@ async function handleBeadClosed(db, event) {
       closed_at = $1, 
       closed_reason = $2, 
       updated_at = $3 
-    WHERE id = $4`, [event.timestamp, event.reason, event.timestamp, event.bead_id]);
+    WHERE id = $4`, [event.timestamp, event.reason, event.timestamp, event.cell_id]);
   const { invalidateBlockedCache: invalidateBlockedCache2 } = await Promise.resolve().then(() => exports_dependencies);
-  await invalidateBlockedCache2(db, event.project_key, event.bead_id);
+  await invalidateBlockedCache2(db, event.project_key, event.cell_id);
 }
 async function handleBeadReopened(db, event) {
   await db.query(`UPDATE beads SET 
@@ -19040,7 +19040,7 @@ async function handleBeadReopened(db, event) {
       closed_at = NULL, 
       closed_reason = NULL, 
       updated_at = $1 
-    WHERE id = $2`, [event.timestamp, event.bead_id]);
+    WHERE id = $2`, [event.timestamp, event.cell_id]);
 }
 async function handleBeadDeleted(db, event) {
   await db.query(`UPDATE beads SET 
@@ -19048,34 +19048,34 @@ async function handleBeadDeleted(db, event) {
       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]);
+    WHERE id = $5`, [event.timestamp, event.deleted_by || null, event.reason || null, event.timestamp, event.cell_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)
+  await db.query(`INSERT INTO bead_dependencies (cell_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]);
+     ON CONFLICT (cell_id, depends_on_id, relationship) DO NOTHING`, [event.cell_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);
+  await invalidate(db, event.project_key, event.cell_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]);
+     WHERE cell_id = $1 AND depends_on_id = $2 AND relationship = $3`, [event.cell_id, dep.target, dep.type]);
   const { invalidateBlockedCache: invalidate } = await Promise.resolve().then(() => exports_dependencies);
-  await invalidate(db, event.project_key, event.bead_id);
+  await invalidate(db, event.project_key, event.cell_id);
 }
 async function handleLabelAdded(db, event) {
-  await db.query(`INSERT INTO bead_labels (bead_id, label, created_at)
+  await db.query(`INSERT INTO bead_labels (cell_id, label, created_at)
      VALUES ($1, $2, $3)
-     ON CONFLICT (bead_id, label) DO NOTHING`, [event.bead_id, event.label, event.timestamp]);
+     ON CONFLICT (cell_id, label) DO NOTHING`, [event.cell_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]);
+  await db.query(`DELETE FROM bead_labels WHERE cell_id = $1 AND label = $2`, [event.cell_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]);
+  await db.query(`INSERT INTO bead_comments (cell_id, author, body, parent_id, created_at)
+     VALUES ($1, $2, $3, $4, $5)`, [event.cell_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]);
@@ -19084,22 +19084,22 @@ 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]);
+  await db.query(`UPDATE beads SET parent_id = $1, updated_at = $2 WHERE id = $3`, [event.cell_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]);
+  await db.query(`UPDATE beads SET assignee = $1, updated_at = $2 WHERE id = $3`, [event.assignee, event.timestamp, event.cell_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]);
+  await db.query(`UPDATE beads SET status = 'in_progress', updated_at = $1 WHERE id = $2`, [event.timestamp, event.cell_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]);
+async function getCell(db, projectKey, cellId) {
+  const result = await db.query(`SELECT * FROM beads WHERE project_key = $1 AND id = $2 AND deleted_at IS NULL`, [projectKey, cellId]);
   return result.rows[0] ?? null;
 }
-async function queryBeads(db, projectKey, options = {}) {
+async function queryCells(db, projectKey, options = {}) {
   const conditions = ["project_key = $1"];
   const params = [projectKey];
   let paramIndex = 2;
@@ -19136,81 +19136,81 @@ async function queryBeads(db, projectKey, options = {}) {
   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]);
+async function getDependencies(db, projectKey, cellId) {
+  const result = await db.query(`SELECT * FROM bead_dependencies WHERE cell_id = $1`, [cellId]);
   return result.rows;
 }
-async function getDependents(db, projectKey, beadId) {
-  const result = await db.query(`SELECT * FROM bead_dependencies WHERE depends_on_id = $1`, [beadId]);
+async function getDependents(db, projectKey, cellId) {
+  const result = await db.query(`SELECT * FROM bead_dependencies WHERE depends_on_id = $1`, [cellId]);
   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]);
+async function isBlocked(db, projectKey, cellId) {
+  const result = await db.query(`SELECT EXISTS(SELECT 1 FROM blocked_beads_cache WHERE cell_id = $1) as exists`, [cellId]);
   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]);
+async function getBlockers(db, projectKey, cellId) {
+  const result = await db.query(`SELECT blocker_ids FROM blocked_beads_cache WHERE cell_id = $1`, [cellId]);
   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]);
+async function getLabels(db, projectKey, cellId) {
+  const result = await db.query(`SELECT label FROM bead_labels WHERE cell_id = $1 ORDER BY label`, [cellId]);
   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]);
+async function getComments(db, projectKey, cellId) {
+  const result = await db.query(`SELECT * FROM bead_comments WHERE cell_id = $1 ORDER BY created_at ASC`, [cellId]);
   return result.rows;
 }
-async function getNextReadyBead(db, projectKey) {
+async function getNextReadyCell(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
+         SELECT 1 FROM blocked_beads_cache bbc WHERE bbc.cell_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) {
+async function getInProgressCells(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) {
+async function getBlockedCells(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
+     JOIN blocked_beads_cache bbc ON b.id = bcc.cell_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 };
+    const { blocker_ids, ...cellData } = r;
+    return { cell: cellData, blockers: blocker_ids };
   });
 }
-async function markBeadDirty(db, projectKey, beadId) {
-  await db.query(`INSERT INTO dirty_beads (bead_id, marked_at)
+async function markBeadDirty(db, projectKey, cellId) {
+  await db.query(`INSERT INTO dirty_beads (cell_id, marked_at)
      VALUES ($1, $2)
-     ON CONFLICT (bead_id) DO UPDATE SET marked_at = $2`, [beadId, Date.now()]);
+     ON CONFLICT (cell_id) DO UPDATE SET marked_at = $2`, [cellId, 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
+async function getDirtyCells(db, projectKey) {
+  const result = await db.query(`SELECT db.cell_id FROM dirty_beads db
+     JOIN beads b ON db.cell_id = b.id
      WHERE b.project_key = $1
      ORDER BY db.marked_at ASC`, [projectKey]);
-  return result.rows.map((r) => r.bead_id);
+  return result.rows.map((r) => r.cell_id);
 }
-async function clearDirtyBead(db, projectKey, beadId) {
-  await db.query(`DELETE FROM dirty_beads WHERE bead_id = $1`, [beadId]);
+async function clearDirtyBead(db, projectKey, cellId) {
+  await db.query(`DELETE FROM dirty_beads WHERE cell_id = $1`, [cellId]);
 }
 async function clearAllDirtyBeads(db, projectKey) {
-  await db.query(`DELETE FROM dirty_beads WHERE bead_id IN (
+  await db.query(`DELETE FROM dirty_beads WHERE cell_id IN (
        SELECT id FROM beads WHERE project_key = $1
      )`, [projectKey]);
 }
 
-// src/beads/store.ts
+// src/hive/store.ts
 function parseTimestamp2(timestamp) {
   const ts = parseInt(timestamp, 10);
   if (Number.isNaN(ts)) {
@@ -19221,7 +19221,7 @@ function parseTimestamp2(timestamp) {
   }
   return ts;
 }
-async function appendBeadEvent(event, projectPath, dbOverride) {
+async function appendCellEvent(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)
@@ -19235,20 +19235,20 @@ async function appendBeadEvent(event, projectPath, dbOverride) {
   await updateProjections(db, { ...event, id, sequence });
   return { ...event, id, sequence };
 }
-async function readBeadEvents(options = {}, projectPath, dbOverride) {
-  return withTiming("readBeadEvents", async () => {
+async function readCellEvents(options = {}, projectPath, dbOverride) {
+  return withTiming("readCellEvents", async () => {
     const db = dbOverride ?? await getDatabase(projectPath);
     const conditions = [];
     const params = [];
     let paramIndex = 1;
-    conditions.push(`type LIKE 'bead_%'`);
+    conditions.push(`type LIKE 'cell_%'`);
     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.cellId) {
+      conditions.push(`data->>'cell_id' = $${paramIndex++}`);
+      params.push(options.cellId);
     }
     if (options.types && options.types.length > 0) {
       conditions.push(`type = ANY($${paramIndex++})`);
@@ -19295,25 +19295,25 @@ async function readBeadEvents(options = {}, projectPath, dbOverride) {
     });
   });
 }
-async function replayBeadEvents(options = {}, projectPath, dbOverride) {
-  return withTiming("replayBeadEvents", async () => {
+async function replayCellEvents(options = {}, projectPath, dbOverride) {
+  return withTiming("replayCellEvents", 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 (
+        await db.query(`DELETE FROM bead_comments WHERE cell_id IN (
             SELECT id FROM beads WHERE project_key = $1
           )`, [options.projectKey]);
-        await db.query(`DELETE FROM bead_labels WHERE bead_id IN (
+        await db.query(`DELETE FROM bead_labels WHERE cell_id IN (
             SELECT id FROM beads WHERE project_key = $1
           )`, [options.projectKey]);
-        await db.query(`DELETE FROM bead_dependencies WHERE bead_id IN (
+        await db.query(`DELETE FROM bead_dependencies WHERE cell_id IN (
             SELECT id FROM beads WHERE project_key = $1
           )`, [options.projectKey]);
-        await db.query(`DELETE FROM blocked_beads_cache WHERE bead_id IN (
+        await db.query(`DELETE FROM blocked_beads_cache WHERE cell_id IN (
             SELECT id FROM beads WHERE project_key = $1
           )`, [options.projectKey]);
-        await db.query(`DELETE FROM dirty_beads WHERE bead_id IN (
+        await db.query(`DELETE FROM dirty_beads WHERE cell_id IN (
             SELECT id FROM beads WHERE project_key = $1
           )`, [options.projectKey]);
         await db.query(`DELETE FROM beads WHERE project_key = $1`, [
@@ -19330,7 +19330,7 @@ async function replayBeadEvents(options = {}, projectPath, dbOverride) {
         `);
       }
     }
-    const events2 = await readBeadEvents({
+    const events2 = await readCellEvents({
       projectKey: options.projectKey,
       afterSequence: options.fromSequence
     }, projectPath, dbOverride);
@@ -19344,14 +19344,14 @@ async function replayBeadEvents(options = {}, projectPath, dbOverride) {
   });
 }
 
-// src/beads/adapter.ts
-function createBeadsAdapter(db, projectKey) {
+// src/hive/adapter.ts
+function createHiveAdapter(db, projectKey) {
   return {
-    async createBead(projectKeyParam, options, projectPath) {
+    async createCell(projectKeyParam, options, projectPath) {
       const event = {
-        type: "bead_created",
+        type: "cell_created",
         project_key: projectKeyParam,
-        bead_id: generateBeadId(projectKeyParam),
+        cell_id: generateBeadId(projectKeyParam),
         timestamp: Date.now(),
         title: options.title,
         description: options.description || null,
@@ -19361,34 +19361,34 @@ function createBeadsAdapter(db, projectKey) {
         created_by: options.created_by || null,
         metadata: options.metadata || null
       };
-      await appendBeadEvent(event, projectPath, db);
+      await appendCellEvent(event, projectPath, db);
       if (options.assignee) {
         const assignEvent = {
-          type: "bead_assigned",
+          type: "cell_assigned",
           project_key: projectKeyParam,
-          bead_id: event.bead_id,
+          cell_id: event.cell_id,
           timestamp: Date.now(),
           assignee: options.assignee,
           assigned_by: options.created_by || null
         };
-        await appendBeadEvent(assignEvent, projectPath, db);
+        await appendCellEvent(assignEvent, projectPath, db);
       }
-      const bead = await getBead(db, projectKeyParam, event.bead_id);
+      const bead = await getCell(db, projectKeyParam, event.cell_id);
       if (!bead) {
-        throw new Error(`[BeadsAdapter] Failed to create bead - not found after insert`);
+        throw new Error(`[HiveAdapter] Failed to create bead - not found after insert`);
       }
       return bead;
     },
-    async getBead(projectKeyParam, beadId, projectPath) {
-      return getBead(db, projectKeyParam, beadId);
+    async getCell(projectKeyParam, cellId, projectPath) {
+      return getCell(db, projectKeyParam, cellId);
     },
-    async queryBeads(projectKeyParam, options, projectPath) {
-      return queryBeads(db, projectKeyParam, options);
+    async queryCells(projectKeyParam, options, projectPath) {
+      return queryCells(db, projectKeyParam, options);
     },
-    async updateBead(projectKeyParam, beadId, options, projectPath) {
-      const existingBead = await getBead(db, projectKeyParam, beadId);
+    async updateCell(projectKeyParam, cellId, options, projectPath) {
+      const existingBead = await getCell(db, projectKeyParam, cellId);
       if (!existingBead) {
-        throw new Error(`[BeadsAdapter] Bead not found: ${beadId}`);
+        throw new Error(`[HiveAdapter] Bead not found: ${cellId}`);
       }
       const changes = {};
       if (options.title && options.title !== existingBead.title) {
@@ -19407,120 +19407,120 @@ function createBeadsAdapter(db, projectKey) {
         return existingBead;
       }
       const event = {
-        type: "bead_updated",
+        type: "cell_updated",
         project_key: projectKeyParam,
-        bead_id: beadId,
+        cell_id: cellId,
         timestamp: Date.now(),
         changes,
         updated_by: options.updated_by || null
       };
-      await appendBeadEvent(event, projectPath, db);
-      const updated = await getBead(db, projectKeyParam, beadId);
+      await appendCellEvent(event, projectPath, db);
+      const updated = await getCell(db, projectKeyParam, cellId);
       if (!updated) {
-        throw new Error(`[BeadsAdapter] Bead disappeared after update: ${beadId}`);
+        throw new Error(`[HiveAdapter] Bead disappeared after update: ${cellId}`);
       }
       return updated;
     },
-    async changeBeadStatus(projectKeyParam, beadId, toStatus, options, projectPath) {
-      const existingBead = await getBead(db, projectKeyParam, beadId);
+    async changeCellStatus(projectKeyParam, cellId, toStatus, options, projectPath) {
+      const existingBead = await getCell(db, projectKeyParam, cellId);
       if (!existingBead) {
-        throw new Error(`[BeadsAdapter] Bead not found: ${beadId}`);
+        throw new Error(`[HiveAdapter] Bead not found: ${cellId}`);
       }
       const event = {
-        type: "bead_status_changed",
+        type: "cell_status_changed",
         project_key: projectKeyParam,
-        bead_id: beadId,
+        cell_id: cellId,
         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);
+      await appendCellEvent(event, projectPath, db);
+      const updated = await getCell(db, projectKeyParam, cellId);
       if (!updated) {
-        throw new Error(`[BeadsAdapter] Bead disappeared after status change: ${beadId}`);
+        throw new Error(`[HiveAdapter] Bead disappeared after status change: ${cellId}`);
       }
       return updated;
     },
-    async closeBead(projectKeyParam, beadId, reason, options, projectPath) {
-      const existingBead = await getBead(db, projectKeyParam, beadId);
+    async closeCell(projectKeyParam, cellId, reason, options, projectPath) {
+      const existingBead = await getCell(db, projectKeyParam, cellId);
       if (!existingBead) {
-        throw new Error(`[BeadsAdapter] Bead not found: ${beadId}`);
+        throw new Error(`[HiveAdapter] Bead not found: ${cellId}`);
       }
       const event = {
-        type: "bead_closed",
+        type: "cell_closed",
         project_key: projectKeyParam,
-        bead_id: beadId,
+        cell_id: cellId,
         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);
+      await appendCellEvent(event, projectPath, db);
+      const updated = await getCell(db, projectKeyParam, cellId);
       if (!updated) {
-        throw new Error(`[BeadsAdapter] Bead disappeared after close: ${beadId}`);
+        throw new Error(`[HiveAdapter] Bead disappeared after close: ${cellId}`);
       }
       return updated;
     },
-    async reopenBead(projectKeyParam, beadId, options, projectPath) {
-      const existingBead = await getBead(db, projectKeyParam, beadId);
+    async reopenCell(projectKeyParam, cellId, options, projectPath) {
+      const existingBead = await getCell(db, projectKeyParam, cellId);
       if (!existingBead) {
-        throw new Error(`[BeadsAdapter] Bead not found: ${beadId}`);
+        throw new Error(`[HiveAdapter] Bead not found: ${cellId}`);
       }
       const event = {
-        type: "bead_reopened",
+        type: "cell_reopened",
         project_key: projectKeyParam,
-        bead_id: beadId,
+        cell_id: cellId,
         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);
+      await appendCellEvent(event, projectPath, db);
+      const updated = await getCell(db, projectKeyParam, cellId);
       if (!updated) {
-        throw new Error(`[BeadsAdapter] Bead disappeared after reopen: ${beadId}`);
+        throw new Error(`[HiveAdapter] Bead disappeared after reopen: ${cellId}`);
       }
       return updated;
     },
-    async deleteBead(projectKeyParam, beadId, options, projectPath) {
-      const existingBead = await getBead(db, projectKeyParam, beadId);
+    async deleteCell(projectKeyParam, cellId, options, projectPath) {
+      const existingBead = await getCell(db, projectKeyParam, cellId);
       if (!existingBead) {
-        throw new Error(`[BeadsAdapter] Bead not found: ${beadId}`);
+        throw new Error(`[HiveAdapter] Bead not found: ${cellId}`);
       }
       const event = {
-        type: "bead_deleted",
+        type: "cell_deleted",
         project_key: projectKeyParam,
-        bead_id: beadId,
+        cell_id: cellId,
         timestamp: Date.now(),
         reason: options?.reason || null,
         deleted_by: options?.deleted_by || null
       };
-      await appendBeadEvent(event, projectPath, db);
+      await appendCellEvent(event, projectPath, db);
     },
-    async addDependency(projectKeyParam, beadId, dependsOnId, relationship, options, projectPath) {
-      const sourceBead = await getBead(db, projectKeyParam, beadId);
+    async addDependency(projectKeyParam, cellId, dependsOnId, relationship, options, projectPath) {
+      const sourceBead = await getCell(db, projectKeyParam, cellId);
       if (!sourceBead) {
-        throw new Error(`[BeadsAdapter] Bead not found: ${beadId}`);
+        throw new Error(`[HiveAdapter] Bead not found: ${cellId}`);
       }
-      const targetBead = await getBead(db, projectKeyParam, dependsOnId);
-      if (!targetBead) {
-        throw new Error(`[BeadsAdapter] Target bead not found: ${dependsOnId}`);
+      const targetCell = await getCell(db, projectKeyParam, dependsOnId);
+      if (!targetCell) {
+        throw new Error(`[HiveAdapter] Target bead not found: ${dependsOnId}`);
       }
-      if (beadId === dependsOnId) {
-        throw new Error(`[BeadsAdapter] Bead cannot depend on itself`);
+      if (cellId === dependsOnId) {
+        throw new Error(`[HiveAdapter] Bead cannot depend on itself`);
       }
       const { wouldCreateCycle: wouldCreateCycle2 } = await Promise.resolve().then(() => exports_dependencies);
-      const hasCycle = await wouldCreateCycle2(db, beadId, dependsOnId);
+      const hasCycle = await wouldCreateCycle2(db, cellId, dependsOnId);
       if (hasCycle) {
-        throw new Error(`[BeadsAdapter] Adding dependency would create a cycle`);
+        throw new Error(`[HiveAdapter] Adding dependency would create a cycle`);
       }
       const event = {
-        type: "bead_dependency_added",
+        type: "cell_dependency_added",
         project_key: projectKeyParam,
-        bead_id: beadId,
+        cell_id: cellId,
         timestamp: Date.now(),
         dependency: {
           target: dependsOnId,
@@ -19529,19 +19529,19 @@ function createBeadsAdapter(db, projectKey) {
         reason: options?.reason || null,
         added_by: options?.added_by || null
       };
-      await appendBeadEvent(event, projectPath, db);
-      const deps = await getDependencies(db, projectKeyParam, beadId);
+      await appendCellEvent(event, projectPath, db);
+      const deps = await getDependencies(db, projectKeyParam, cellId);
       const dep = deps.find((d) => d.depends_on_id === dependsOnId && d.relationship === relationship);
       if (!dep) {
-        throw new Error(`[BeadsAdapter] Dependency not found after insert`);
+        throw new Error(`[HiveAdapter] Dependency not found after insert`);
       }
       return dep;
     },
-    async removeDependency(projectKeyParam, beadId, dependsOnId, relationship, options, projectPath) {
+    async removeDependency(projectKeyParam, cellId, dependsOnId, relationship, options, projectPath) {
       const event = {
-        type: "bead_dependency_removed",
+        type: "cell_dependency_removed",
         project_key: projectKeyParam,
-        bead_id: beadId,
+        cell_id: cellId,
         timestamp: Date.now(),
         dependency: {
           target: dependsOnId,
@@ -19550,86 +19550,86 @@ function createBeadsAdapter(db, projectKey) {
         reason: options?.reason || null,
         removed_by: options?.removed_by || null
       };
-      await appendBeadEvent(event, projectPath, db);
+      await appendCellEvent(event, projectPath, db);
     },
-    async getDependencies(projectKeyParam, beadId, projectPath) {
-      return getDependencies(db, projectKeyParam, beadId);
+    async getDependencies(projectKeyParam, cellId, projectPath) {
+      return getDependencies(db, projectKeyParam, cellId);
     },
-    async getDependents(projectKeyParam, beadId, projectPath) {
-      return getDependents(db, projectKeyParam, beadId);
+    async getDependents(projectKeyParam, cellId, projectPath) {
+      return getDependents(db, projectKeyParam, cellId);
     },
-    async isBlocked(projectKeyParam, beadId, projectPath) {
-      return isBlocked(db, projectKeyParam, beadId);
+    async isBlocked(projectKeyParam, cellId, projectPath) {
+      return isBlocked(db, projectKeyParam, cellId);
     },
-    async getBlockers(projectKeyParam, beadId, projectPath) {
-      return getBlockers(db, projectKeyParam, beadId);
+    async getBlockers(projectKeyParam, cellId, projectPath) {
+      return getBlockers(db, projectKeyParam, cellId);
     },
-    async addLabel(projectKeyParam, beadId, label, options, projectPath) {
+    async addLabel(projectKeyParam, cellId, label, options, projectPath) {
       const event = {
-        type: "bead_label_added",
+        type: "cell_label_added",
         project_key: projectKeyParam,
-        bead_id: beadId,
+        cell_id: cellId,
         timestamp: Date.now(),
         label,
         added_by: options?.added_by || null
       };
-      await appendBeadEvent(event, projectPath, db);
+      await appendCellEvent(event, projectPath, db);
       return {
-        bead_id: beadId,
+        cell_id: cellId,
         label,
         created_at: event.timestamp
       };
     },
-    async removeLabel(projectKeyParam, beadId, label, options, projectPath) {
+    async removeLabel(projectKeyParam, cellId, label, options, projectPath) {
       const event = {
-        type: "bead_label_removed",
+        type: "cell_label_removed",
         project_key: projectKeyParam,
-        bead_id: beadId,
+        cell_id: cellId,
         timestamp: Date.now(),
         label,
         removed_by: options?.removed_by || null
       };
-      await appendBeadEvent(event, projectPath, db);
+      await appendCellEvent(event, projectPath, db);
     },
-    async getLabels(projectKeyParam, beadId, projectPath) {
-      return getLabels(db, projectKeyParam, beadId);
+    async getLabels(projectKeyParam, cellId, projectPath) {
+      return getLabels(db, projectKeyParam, cellId);
     },
-    async getBeadsWithLabel(projectKeyParam, label, projectPath) {
-      return queryBeads(db, projectKeyParam, { labels: [label] });
+    async getCellsWithLabel(projectKeyParam, label, projectPath) {
+      return queryCells(db, projectKeyParam, { labels: [label] });
     },
-    async addComment(projectKeyParam, beadId, author, body, options, projectPath) {
+    async addComment(projectKeyParam, cellId, author, body, options, projectPath) {
       const event = {
-        type: "bead_comment_added",
+        type: "cell_comment_added",
         project_key: projectKeyParam,
-        bead_id: beadId,
+        cell_id: cellId,
         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);
+      await appendCellEvent(event, projectPath, db);
+      const comments = await getComments(db, projectKeyParam, cellId);
       const comment = comments[comments.length - 1];
       if (!comment) {
-        throw new Error(`[BeadsAdapter] Comment not found after insert`);
+        throw new Error(`[HiveAdapter] Comment not found after insert`);
       }
       return comment;
     },
     async updateComment(projectKeyParam, commentId, newBody, updated_by, projectPath) {
       const event = {
-        type: "bead_comment_updated",
+        type: "cell_comment_updated",
         project_key: projectKeyParam,
-        bead_id: "",
+        cell_id: "",
         timestamp: Date.now(),
         comment_id: commentId,
         new_body: newBody,
         updated_by
       };
-      await appendBeadEvent(event, projectPath, db);
+      await appendCellEvent(event, projectPath, db);
       return {
         id: commentId,
-        bead_id: "",
+        cell_id: "",
         author: updated_by,
         body: newBody,
         parent_id: null,
@@ -19639,67 +19639,67 @@ function createBeadsAdapter(db, projectKey) {
     },
     async deleteComment(projectKeyParam, commentId, deleted_by, options, projectPath) {
       const event = {
-        type: "bead_comment_deleted",
+        type: "cell_comment_deleted",
         project_key: projectKeyParam,
-        bead_id: "",
+        cell_id: "",
         timestamp: Date.now(),
         comment_id: commentId,
         deleted_by,
         reason: options?.reason || null
       };
-      await appendBeadEvent(event, projectPath, db);
+      await appendCellEvent(event, projectPath, db);
     },
-    async getComments(projectKeyParam, beadId, projectPath) {
-      return getComments(db, projectKeyParam, beadId);
+    async getComments(projectKeyParam, cellId, projectPath) {
+      return getComments(db, projectKeyParam, cellId);
     },
     async addChildToEpic(projectKeyParam, epicId, childId, options, projectPath) {
       const event = {
-        type: "bead_epic_child_added",
+        type: "cell_epic_child_added",
         project_key: projectKeyParam,
-        bead_id: epicId,
+        cell_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);
+      await appendCellEvent(event, projectPath, db);
     },
     async removeChildFromEpic(projectKeyParam, epicId, childId, options, projectPath) {
       const event = {
-        type: "bead_epic_child_removed",
+        type: "cell_epic_child_removed",
         project_key: projectKeyParam,
-        bead_id: epicId,
+        cell_id: epicId,
         timestamp: Date.now(),
         child_id: childId,
         reason: options?.reason || null,
         removed_by: options?.removed_by || null
       };
-      await appendBeadEvent(event, projectPath, db);
+      await appendCellEvent(event, projectPath, db);
     },
     async getEpicChildren(projectKeyParam, epicId, projectPath) {
-      return queryBeads(db, projectKeyParam, { parent_id: epicId });
+      return queryCells(db, projectKeyParam, { parent_id: epicId });
     },
     async isEpicClosureEligible(projectKeyParam, epicId, projectPath) {
-      const children = await queryBeads(db, projectKeyParam, { parent_id: epicId });
+      const children = await queryCells(db, projectKeyParam, { parent_id: epicId });
       return children.every((child) => child.status === "closed");
     },
-    async getNextReadyBead(projectKeyParam, projectPath) {
-      return getNextReadyBead(db, projectKeyParam);
+    async getNextReadyCell(projectKeyParam, projectPath) {
+      return getNextReadyCell(db, projectKeyParam);
     },
-    async getInProgressBeads(projectKeyParam, projectPath) {
-      return getInProgressBeads(db, projectKeyParam);
+    async getInProgressCells(projectKeyParam, projectPath) {
+      return getInProgressCells(db, projectKeyParam);
     },
-    async getBlockedBeads(projectKeyParam, projectPath) {
-      return getBlockedBeads(db, projectKeyParam);
+    async getBlockedCells(projectKeyParam, projectPath) {
+      return getBlockedCells(db, projectKeyParam);
     },
-    async markDirty(projectKeyParam, beadId, projectPath) {
-      await markBeadDirty(db, projectKeyParam, beadId);
+    async markDirty(projectKeyParam, cellId, projectPath) {
+      await markBeadDirty(db, projectKeyParam, cellId);
     },
-    async getDirtyBeads(projectKeyParam, projectPath) {
-      return getDirtyBeads(db, projectKeyParam);
+    async getDirtyCells(projectKeyParam, projectPath) {
+      return getDirtyCells(db, projectKeyParam);
     },
-    async clearDirty(projectKeyParam, beadId, projectPath) {
-      await clearDirtyBead(db, projectKeyParam, beadId);
+    async clearDirty(projectKeyParam, cellId, projectPath) {
+      await clearDirtyBead(db, projectKeyParam, cellId);
     },
     async runMigrations(projectPath) {
       const { beadsMigration: beadsMigration2 } = await Promise.resolve().then(() => (init_migrations2(), exports_migrations2));
@@ -19721,7 +19721,7 @@ function createBeadsAdapter(db, projectKey) {
         throw error45;
       }
     },
-    async getBeadsStats(projectPath) {
+    async getCellsStats(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]),
@@ -19735,7 +19735,7 @@ function createBeadsAdapter(db, projectKey) {
         by_type[row.type] = parseInt(row.count);
       }
       return {
-        total_beads: parseInt(totalResult.rows[0]?.count || "0"),
+        total_cells: 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"),
@@ -19769,25 +19769,25 @@ function generateBeadId(projectKey) {
   return `bd-${hash2}-${timestamp}${random}`;
 }
 
-// src/beads/index.ts
+// src/hive/index.ts
 init_migrations2();
 
-// src/beads/labels.ts
-async function getBeadsByLabel(db, projectKey, label) {
+// src/hive/labels.ts
+async function getCellsByLabel(db, projectKey, label) {
   const result = await db.query(`SELECT b.* FROM beads b
-     JOIN bead_labels bl ON b.id = bl.bead_id
+     JOIN bead_labels bl ON b.id = bl.cell_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
+     JOIN beads b ON bl.cell_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
+// src/hive/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;
@@ -19806,10 +19806,10 @@ async function getCommentThread(db, rootCommentId) {
      SELECT * FROM thread ORDER BY created_at ASC`, [rootCommentId]);
   return result.rows;
 }
-// src/beads/jsonl.ts
+// src/hive/jsonl.ts
 import { createHash as createHash2 } from "node:crypto";
-function serializeToJSONL(bead) {
-  return JSON.stringify(bead);
+function serializeToJSONL(cell) {
+  return JSON.stringify(cell);
 }
 function parseJSONL(jsonl) {
   if (!jsonl || jsonl.trim() === "") {
@@ -19817,23 +19817,23 @@ function parseJSONL(jsonl) {
   }
   const lines = jsonl.split(`
 `);
-  const beads = [];
+  const cells = [];
   for (const line of lines) {
     const trimmed = line.trim();
     if (trimmed === "") {
       continue;
     }
     try {
-      const bead = JSON.parse(trimmed);
-      beads.push(bead);
+      const cell = JSON.parse(trimmed);
+      cells.push(cell);
     } catch (err) {
       throw new Error(`Invalid JSON in JSONL: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  return beads;
+  return cells;
 }
-function computeContentHash(bead) {
-  const canonical = JSON.stringify(bead, Object.keys(bead).sort());
+function computeContentHash(cell) {
+  const canonical = JSON.stringify(cell, Object.keys(cell).sort());
   return createHash2("sha256").update(canonical).digest("hex");
 }
 async function exportToJSONL(adapter, projectKey, options = {}) {
@@ -19844,12 +19844,12 @@ async function exportToJSONL(adapter, projectKey, options = {}) {
   if (!options.includeDeleted) {
     conditions.push("deleted_at IS NULL");
   }
-  if (options.beadIds && options.beadIds.length > 0) {
+  if (options.cellIds && options.cellIds.length > 0) {
     conditions.push(`id = ANY($${paramIndex++})`);
-    params.push(options.beadIds);
+    params.push(options.cellIds);
   }
   const query = `
-    SELECT * FROM beads
+    SELECT * FROM cells
     WHERE ${conditions.join(" AND ")}
     ORDER BY id ASC
   `;
@@ -19871,7 +19871,7 @@ async function exportToJSONL(adapter, projectKey, options = {}) {
       author: c.author,
       text: c.body
     }));
-    const beadExport = {
+    const cellExport = {
       id: bead.id,
       title: bead.title,
       description: bead.description || undefined,
@@ -19887,51 +19887,51 @@ async function exportToJSONL(adapter, projectKey, options = {}) {
       labels,
       comments: commentExports
     };
-    lines.push(serializeToJSONL(beadExport));
+    lines.push(serializeToJSONL(cellExport));
   }
   return lines.join(`
 `);
 }
 async function exportDirtyBeads(adapter, projectKey) {
   const db = await adapter.getDatabase();
-  const dirtyIds = await getDirtyBeads(db, projectKey);
+  const dirtyIds = await getDirtyCells(db, projectKey);
   if (dirtyIds.length === 0) {
-    return { jsonl: "", beadIds: [] };
+    return { jsonl: "", cellIds: [] };
   }
   const jsonl = await exportToJSONL(adapter, projectKey, {
-    beadIds: dirtyIds
+    cellIds: dirtyIds
   });
-  return { jsonl, beadIds: dirtyIds };
+  return { jsonl, cellIds: dirtyIds };
 }
 async function importFromJSONL(adapter, projectKey, jsonl, options = {}) {
-  const beads = parseJSONL(jsonl);
+  const cells = parseJSONL(jsonl);
   const result = {
     created: 0,
     updated: 0,
     skipped: 0,
     errors: []
   };
-  for (const beadExport of beads) {
+  for (const cellExport of cells) {
     try {
-      await importSingleBead(adapter, projectKey, beadExport, options, result);
+      await importSingleCell(adapter, projectKey, cellExport, options, result);
     } catch (err) {
       result.errors.push({
-        beadId: beadExport.id,
+        cellId: cellExport.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);
+async function importSingleCell(adapter, projectKey, cellExport, options, result) {
+  const existing = await adapter.getCell(projectKey, cellExport.id);
   if (existing && options.skipExisting) {
     result.skipped++;
     return;
   }
   if (existing) {
     const existingHash = await computeBeadHash(adapter, projectKey, existing.id);
-    const importHash = computeContentHash(beadExport);
+    const importHash = computeContentHash(cellExport);
     if (existingHash === importHash) {
       result.skipped++;
       return;
@@ -19947,124 +19947,124 @@ async function importSingleBead(adapter, projectKey, beadExport, options, result
   }
   if (!existing) {
     const db = await adapter.getDatabase();
-    const status = beadExport.status === "tombstone" ? "closed" : beadExport.status;
+    const status = cellExport.status === "tombstone" ? "closed" : cellExport.status;
     const isClosed = status === "closed";
-    const closedAt = isClosed ? beadExport.closed_at ? new Date(beadExport.closed_at).getTime() : new Date(beadExport.updated_at).getTime() : null;
-    await db.query(`INSERT INTO beads (
+    const closedAt = isClosed ? cellExport.closed_at ? new Date(cellExport.closed_at).getTime() : new Date(cellExport.updated_at).getTime() : null;
+    await db.query(`INSERT INTO cells (
         id, project_key, type, status, title, description, priority,
         parent_id, assignee, created_at, updated_at, closed_at
       ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`, [
-      beadExport.id,
+      cellExport.id,
       projectKey,
-      beadExport.issue_type,
+      cellExport.issue_type,
       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(),
+      cellExport.title,
+      cellExport.description || null,
+      cellExport.priority,
+      cellExport.parent_id || null,
+      cellExport.assignee || null,
+      new Date(cellExport.created_at).getTime(),
+      new Date(cellExport.updated_at).getTime(),
       closedAt
     ]);
-    if (beadExport.status === "tombstone") {
-      await db.query("UPDATE beads SET deleted_at = $1 WHERE id = $2", [Date.now(), beadExport.id]);
+    if (cellExport.status === "tombstone") {
+      await db.query("UPDATE beads SET deleted_at = $1 WHERE id = $2", [Date.now(), cellExport.id]);
     }
     result.created++;
   } else {
-    await adapter.updateBead(projectKey, beadExport.id, {
-      title: beadExport.title,
-      description: beadExport.description,
-      priority: beadExport.priority,
-      assignee: beadExport.assignee
+    await adapter.updateCell(projectKey, cellExport.id, {
+      title: cellExport.title,
+      description: cellExport.description,
+      priority: cellExport.priority,
+      assignee: cellExport.assignee
     });
-    if (existing.status !== beadExport.status) {
-      if (beadExport.status === "closed") {
-        await adapter.closeBead(projectKey, beadExport.id, "imported");
-      } else if (beadExport.status === "in_progress") {
+    if (existing.status !== cellExport.status) {
+      if (cellExport.status === "closed") {
+        await adapter.closeCell(projectKey, cellExport.id, "imported");
+      } else if (cellExport.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]);
+        await db.query("UPDATE beads SET status = $1, updated_at = $2 WHERE id = $3", ["in_progress", Date.now(), cellExport.id]);
       }
     }
     result.updated++;
   }
-  await importDependencies(adapter, projectKey, beadExport);
-  await importLabels(adapter, projectKey, beadExport);
-  await importComments(adapter, projectKey, beadExport);
+  await importDependencies(adapter, projectKey, cellExport);
+  await importLabels(adapter, projectKey, cellExport);
+  await importComments(adapter, projectKey, cellExport);
 }
-async function computeBeadHash(adapter, projectKey, beadId) {
+async function computeBeadHash(adapter, projectKey, cellId) {
   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 beadResult = await db.query("SELECT * FROM beads WHERE project_key = $1 AND id = $2", [projectKey, cellId]);
+  const cell = beadResult.rows[0];
+  if (!cell) {
+    throw new Error(`Cell not found: ${cellId}`);
   }
-  const deps = await getDependencies(db, projectKey, beadId);
+  const deps = await getDependencies(db, projectKey, cellId);
   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 labels = await getLabels(db, projectKey, cellId);
+  const comments = await getComments(db, projectKey, cellId);
   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,
+  const cellExport = {
+    id: cell.id,
+    title: cell.title,
+    description: cell.description || undefined,
+    status: cell.deleted_at ? "tombstone" : cell.status,
+    priority: cell.priority,
+    issue_type: cell.type,
+    created_at: new Date(cell.created_at).toISOString(),
+    updated_at: new Date(cell.updated_at).toISOString(),
+    closed_at: cell.closed_at ? new Date(cell.closed_at).toISOString() : undefined,
+    assignee: cell.assignee || undefined,
+    parent_id: cell.parent_id || undefined,
     dependencies,
     labels,
     comments: commentExports
   };
-  return computeContentHash(beadExport);
+  return computeContentHash(cellExport);
 }
-async function importDependencies(adapter, projectKey, beadExport) {
-  if (!beadExport.dependencies || beadExport.dependencies.length === 0) {
+async function importDependencies(adapter, projectKey, cellExport) {
+  if (!cellExport.dependencies || cellExport.dependencies.length === 0) {
     return;
   }
   const db = await adapter.getDatabase();
-  await db.query("DELETE FROM bead_dependencies WHERE bead_id = $1", [
-    beadExport.id
+  await db.query("DELETE FROM cell_dependencies WHERE cell_id = $1", [
+    cellExport.id
   ]);
-  for (const dep of beadExport.dependencies) {
-    await adapter.addDependency(projectKey, beadExport.id, dep.depends_on_id, dep.type);
+  for (const dep of cellExport.dependencies) {
+    await adapter.addDependency(projectKey, cellExport.id, dep.depends_on_id, dep.type);
   }
 }
-async function importLabels(adapter, projectKey, beadExport) {
-  if (!beadExport.labels || beadExport.labels.length === 0) {
+async function importLabels(adapter, projectKey, cellExport) {
+  if (!cellExport.labels || cellExport.labels.length === 0) {
     return;
   }
   const db = await adapter.getDatabase();
-  await db.query("DELETE FROM bead_labels WHERE bead_id = $1", [
-    beadExport.id
+  await db.query("DELETE FROM cell_labels WHERE cell_id = $1", [
+    cellExport.id
   ]);
-  for (const label of beadExport.labels) {
-    await adapter.addLabel(projectKey, beadExport.id, label);
+  for (const label of cellExport.labels) {
+    await adapter.addLabel(projectKey, cellExport.id, label);
   }
 }
-async function importComments(adapter, projectKey, beadExport) {
-  if (!beadExport.comments || beadExport.comments.length === 0) {
+async function importComments(adapter, projectKey, cellExport) {
+  if (!cellExport.comments || cellExport.comments.length === 0) {
     return;
   }
   const db = await adapter.getDatabase();
-  await db.query("DELETE FROM bead_comments WHERE bead_id = $1", [
-    beadExport.id
+  await db.query("DELETE FROM cell_comments WHERE cell_id = $1", [
+    cellExport.id
   ]);
-  for (const comment of beadExport.comments) {
-    await adapter.addComment(projectKey, beadExport.id, comment.author, comment.text);
+  for (const comment of cellExport.comments) {
+    await adapter.addComment(projectKey, cellExport.id, comment.author, comment.text);
   }
 }
-// src/beads/flush-manager.ts
+// src/hive/flush-manager.ts
 import { writeFile as writeFile2 } from "node:fs/promises";
 class FlushManager {
   adapter;
@@ -20095,7 +20095,7 @@ class FlushManager {
     const startTime = Date.now();
     if (this.flushing) {
       return {
-        beadsExported: 0,
+        cellsExported: 0,
         bytesWritten: 0,
         duration: 0
       };
@@ -20106,10 +20106,10 @@ class FlushManager {
         clearTimeout(this.timer);
         this.timer = null;
       }
-      const { jsonl, beadIds } = await exportDirtyBeads(this.adapter, this.projectKey);
-      if (beadIds.length === 0) {
+      const { jsonl, cellIds } = await exportDirtyBeads(this.adapter, this.projectKey);
+      if (cellIds.length === 0) {
         return {
-          beadsExported: 0,
+          cellsExported: 0,
           bytesWritten: 0,
           duration: Date.now() - startTime
         };
@@ -20117,11 +20117,11 @@ class FlushManager {
       await writeFile2(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);
+      for (const cellId of cellIds) {
+        await clearDirtyBead(db, this.projectKey, cellId);
       }
       const result = {
-        beadsExported: beadIds.length,
+        cellsExported: cellIds.length,
         bytesWritten,
         duration: Date.now() - startTime
       };
@@ -20140,30 +20140,30 @@ class FlushManager {
     }
   }
 }
-// src/beads/merge.ts
+// src/hive/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) {
+function makeKey(cell) {
   const key = {
-    id: bead.id,
-    createdAt: bead.created_at,
+    id: cell.id,
+    createdAt: cell.created_at,
     createdBy: undefined
   };
   return JSON.stringify(key);
 }
-function isTombstone(bead) {
-  return bead.status === STATUS_TOMBSTONE;
+function isTombstone(cell) {
+  return cell.status === STATUS_TOMBSTONE;
 }
-function isExpiredTombstone(bead, ttlMs = DEFAULT_TOMBSTONE_TTL_MS) {
-  if (!isTombstone(bead)) {
+function isExpiredTombstone(cell, ttlMs = DEFAULT_TOMBSTONE_TTL_MS) {
+  if (!isTombstone(cell)) {
     return false;
   }
-  if (!bead.closed_at) {
+  if (!cell.closed_at) {
     return false;
   }
-  const deletedAt = new Date(bead.closed_at).getTime();
+  const deletedAt = new Date(cell.closed_at).getTime();
   if (Number.isNaN(deletedAt)) {
     return false;
   }
@@ -20482,7 +20482,7 @@ export {
   reserveAgentFiles,
   replayEventsBatched2 as replayEventsBatched,
   replayEvents,
-  replayBeadEvents,
+  replayCellEvents,
   releaseSwarmFiles,
   releaseAgentFiles,
   registerAgent,
@@ -20490,9 +20490,9 @@ export {
   rebuildAllBlockedCaches,
   readSwarmMessage,
   readEvents,
-  readBeadEvents,
+  readCellEvents,
   readAgentMessage,
-  queryBeads,
+  queryCells,
   parseJSONL,
   migrations,
   mergeJsonl,
@@ -20520,16 +20520,16 @@ export {
   getPidFilePath,
   getPendingMigrations,
   getOpenBlockers,
-  getNextReadyBead,
+  getNextReadyCell,
   getMessage,
   getLatestSequence,
   getLabels,
   getInbox,
-  getInProgressBeads,
+  getInProgressCells,
   getEventTimeline,
   getEvalStats,
   getEvalRecords,
-  getDirtyBeads,
+  getDirtyCells,
   getDependents,
   getDependencies,
   getDatabaseStats,
@@ -20539,10 +20539,10 @@ export {
   getComments,
   getCommentThread,
   getCommentById,
+  getCellsByLabel,
+  getCell,
   getBlockers,
-  getBlockedBeads,
-  getBeadsByLabel,
-  getBead,
+  getBlockedCells,
   getAppliedMigrations,
   getAllLabels,
   getAgents,
@@ -20558,8 +20558,9 @@ export {
   createSwarmMailAdapter,
   createSocketAdapter,
   createInMemorySwarmMail,
+  createHiveAdapter,
   createEvent,
-  createBeadsAdapter,
+  createHiveAdapter as createBeadsAdapter,
   computeContentHash,
   closeSwarmMail,
   closeDatabase,
@@ -20574,7 +20575,7 @@ export {
   beadsMigration,
   appendEvents,
   appendEvent,
-  appendBeadEvent,
+  appendCellEvent,
   acknowledgeSwarmMessage,
   acknowledgeMessage,
   TaskStartedEventSchema,