opencode-swarm-plugin 0.26.1 → 0.27.2

package/src/{beads.ts → hive.ts}

@@ -1,26 +1,26 @@
 /**
- * Beads Module - Type-safe wrappers using BeadsAdapter
+ * Hive Module - Type-safe wrappers using HiveAdapter
  *
- * This module provides validated, type-safe operations for the beads
- * issue tracker using the BeadsAdapter from swarm-mail.
+ * This module provides validated, type-safe operations for the Hive
+ * issue tracker using the HiveAdapter from swarm-mail.
  *
  * Key principles:
- * - Use BeadsAdapter for all operations (no CLI commands)
+ * - Use HiveAdapter for all operations (no CLI commands)
  * - Validate all inputs with Zod schemas
  * - Throw typed errors on failure
  * - Support atomic epic creation with rollback
  *
- * IMPORTANT: Call setBeadsWorkingDirectory() before using tools to ensure
+ * IMPORTANT: Call setHiveWorkingDirectory() before using tools to ensure
  * operations run in the correct project directory.
  */
 import { tool } from "@opencode-ai/plugin";
 import { z } from "zod";
 import {
-  createBeadsAdapter,
+  createHiveAdapter,
   FlushManager,
   importFromJSONL,
-  type BeadsAdapter,
-  type Bead as AdapterBead,
+  type HiveAdapter,
+  type Cell as AdapterCell,
   getSwarmMail,
 } from "swarm-mail";
 import { existsSync, readFileSync } from "node:fs";
@@ -31,37 +31,41 @@ import { join } from "node:path";
 // ============================================================================
 
 /**
- * Module-level working directory for beads commands.
- * Set this via setBeadsWorkingDirectory() before using tools.
+ * Module-level working directory for hive commands.
+ * Set this via setHiveWorkingDirectory() before using tools.
  * If not set, commands run in process.cwd() which may be wrong for plugins.
  */
-let beadsWorkingDirectory: string | null = null;
+let hiveWorkingDirectory: string | null = null;
 
 /**
- * Set the working directory for all beads commands.
+ * Set the working directory for all hive commands.
  * Call this from the plugin initialization with the project directory.
  *
  * @param directory - Absolute path to the project directory
  */
-export function setBeadsWorkingDirectory(directory: string): void {
-  beadsWorkingDirectory = directory;
+export function setHiveWorkingDirectory(directory: string): void {
+  hiveWorkingDirectory = directory;
 }
 
 /**
- * Get the current working directory for beads commands.
+ * Get the current working directory for hive commands.
  * Returns the configured directory or process.cwd() as fallback.
  */
-export function getBeadsWorkingDirectory(): string {
-  return beadsWorkingDirectory || process.cwd();
+export function getHiveWorkingDirectory(): string {
+  return hiveWorkingDirectory || process.cwd();
 }
 
+// Legacy aliases for backward compatibility
+export const setBeadsWorkingDirectory = setHiveWorkingDirectory;
+export const getBeadsWorkingDirectory = getHiveWorkingDirectory;
+
 /**
  * Run a git command in the correct working directory.
  */
 async function runGitCommand(
   args: string[],
 ): Promise<{ exitCode: number; stdout: string; stderr: string }> {
-  const cwd = getBeadsWorkingDirectory();
+  const cwd = getHiveWorkingDirectory();
   const proc = Bun.spawn(["git", ...args], {
     cwd,
     stdout: "pipe",
@@ -79,23 +83,23 @@ async function runGitCommand(
 }
 
 import {
-  BeadSchema,
-  BeadCreateArgsSchema,
-  BeadUpdateArgsSchema,
-  BeadCloseArgsSchema,
-  BeadQueryArgsSchema,
+  CellSchema,
+  CellCreateArgsSchema,
+  CellUpdateArgsSchema,
+  CellCloseArgsSchema,
+  CellQueryArgsSchema,
   EpicCreateArgsSchema,
   EpicCreateResultSchema,
-  type Bead,
-  type BeadCreateArgs,
+  type Cell,
+  type CellCreateArgs,
   type EpicCreateResult,
 } from "./schemas";
 import { createEvent, appendEvent } from "swarm-mail";
 
 /**
- * Custom error for bead operations
+ * Custom error for hive operations
  */
-export class BeadError extends Error {
+export class HiveError extends Error {
   constructor(
     message: string,
     public readonly command: string,
@@ -103,48 +107,54 @@ export class BeadError extends Error {
     public readonly stderr?: string,
   ) {
     super(message);
-    this.name = "BeadError";
+    this.name = "HiveError";
   }
 }
 
+// Legacy alias for backward compatibility
+export const BeadError = HiveError;
+
 /**
  * Custom error for validation failures
  */
-export class BeadValidationError extends Error {
+export class HiveValidationError extends Error {
   constructor(
     message: string,
     public readonly zodError: z.ZodError,
   ) {
     super(message);
-    this.name = "BeadValidationError";
+    this.name = "HiveValidationError";
   }
 }
 
+// Legacy alias for backward compatibility
+export const BeadValidationError = HiveValidationError;
+
 // ============================================================================
 // Adapter Singleton
 // ============================================================================
 
 /**
- * Lazy singleton for BeadsAdapter instances
- * Maps projectKey -> BeadsAdapter
+ * Lazy singleton for HiveAdapter instances
+ * Maps projectKey -> HiveAdapter
  */
-const adapterCache = new Map<string, BeadsAdapter>();
+const adapterCache = new Map<string, HiveAdapter>();
 
 /**
- * Get or create a BeadsAdapter instance for a project
+ * Get or create a HiveAdapter instance for a project
  * Exported for testing - allows tests to verify state directly
  * 
  * On first initialization, checks for .beads/issues.jsonl and imports
  * historical beads if the database is empty.
  */
-export async function getBeadsAdapter(projectKey: string): Promise<BeadsAdapter> {
+export async function getHiveAdapter(projectKey: string): Promise<HiveAdapter> {
   if (adapterCache.has(projectKey)) {
     return adapterCache.get(projectKey)!;
   }
 
   const swarmMail = await getSwarmMail(projectKey);
   const db = await swarmMail.getDatabase();
-  const adapter = createBeadsAdapter(db, projectKey);
+  const adapter = createHiveAdapter(db, projectKey);
 
   // Run migrations to ensure schema exists
   await adapter.runMigrations();
@@ -156,74 +166,77 @@ export async function getBeadsAdapter(projectKey: string): Promise<BeadsAdapter>
   return adapter;
 }
 
+// Legacy alias for backward compatibility
+export const getBeadsAdapter = getHiveAdapter;
+
 /**
- * Auto-migrate beads from .beads/issues.jsonl if:
+ * Auto-migrate cells from .hive/issues.jsonl if:
  * 1. The JSONL file exists
- * 2. The database has no beads for this project
+ * 2. The database has no cells for this project
  * 
  * This enables seamless migration from the old bd CLI to the new PGLite-based system.
  */
-async function autoMigrateFromJSONL(adapter: BeadsAdapter, projectKey: string): Promise<void> {
-  const jsonlPath = join(projectKey, ".beads", "issues.jsonl");
+async function autoMigrateFromJSONL(adapter: HiveAdapter, projectKey: string): Promise<void> {
+  const jsonlPath = join(projectKey, ".hive", "issues.jsonl");
   
   // Check if JSONL file exists
   if (!existsSync(jsonlPath)) {
     return;
   }
 
-  // Check if database already has beads
-  const existingBeads = await adapter.queryBeads(projectKey, { limit: 1 });
-  if (existingBeads.length > 0) {
-    return; // Already have beads, skip migration
+  // Check if database already has cells
+  const existingCells = await adapter.queryCells(projectKey, { limit: 1 });
+  if (existingCells.length > 0) {
+    return; // Already have cells, skip migration
   }
 
   // Read and import JSONL
   try {
     const jsonlContent = readFileSync(jsonlPath, "utf-8");
     const result = await importFromJSONL(adapter, projectKey, jsonlContent, {
-      skipExisting: true, // Safety: don't overwrite if somehow beads exist
+      skipExisting: true, // Safety: don't overwrite if somehow cells exist
     });
 
     if (result.created > 0 || result.updated > 0) {
       console.log(
-        `[beads] Auto-migrated ${result.created} beads from ${jsonlPath} (${result.skipped} skipped, ${result.errors.length} errors)`
+        `[hive] Auto-migrated ${result.created} cells from ${jsonlPath} (${result.skipped} skipped, ${result.errors.length} errors)`
       );
     }
 
     if (result.errors.length > 0) {
       console.warn(
-        `[beads] Migration errors:`,
-        result.errors.slice(0, 5).map((e) => `${e.beadId}: ${e.error}`)
+        `[hive] Migration errors:`,
+        result.errors.slice(0, 5).map((e) => `${e.cellId}: ${e.error}`)
       );
     }
   } catch (error) {
     // Non-fatal - log and continue
     console.warn(
-      `[beads] Failed to auto-migrate from ${jsonlPath}:`,
+      `[hive] Failed to auto-migrate from ${jsonlPath}:`,
       error instanceof Error ? error.message : String(error)
     );
   }
 }
 
 /**
- * Format adapter bead for output (map field names)
+ * Format adapter cell for output (map field names)
  * Adapter uses: type, created_at/updated_at (timestamps)
  * Schema expects: issue_type, created_at/updated_at (ISO strings)
  */
-function formatBeadForOutput(adapterBead: AdapterBead): Record<string, unknown> {
+function formatCellForOutput(adapterCell: AdapterCell): Record<string, unknown> {
   return {
-    id: adapterBead.id,
-    title: adapterBead.title,
-    description: adapterBead.description || "",
-    status: adapterBead.status,
-    priority: adapterBead.priority,
-    issue_type: adapterBead.type, // Adapter: type → Schema: issue_type
-    created_at: new Date(adapterBead.created_at).toISOString(),
-    updated_at: new Date(adapterBead.updated_at).toISOString(),
-    closed_at: adapterBead.closed_at
-      ? new Date(adapterBead.closed_at).toISOString()
+    id: adapterCell.id,
+    title: adapterCell.title,
+    description: adapterCell.description || "",
+    status: adapterCell.status,
+    priority: adapterCell.priority,
+    issue_type: adapterCell.type, // Adapter: type → Schema: issue_type
+    created_at: new Date(adapterCell.created_at).toISOString(),
+    updated_at: new Date(adapterCell.updated_at).toISOString(),
+    closed_at: adapterCell.closed_at
+      ? new Date(adapterCell.closed_at).toISOString()
       : undefined,
-    parent_id: adapterBead.parent_id || undefined,
+    parent_id: adapterCell.parent_id || undefined,
     dependencies: [], // TODO: fetch from adapter if needed
     metadata: {},
   };
@@ -234,12 +247,12 @@ function formatBeadForOutput(adapterBead: AdapterBead): Record<string, unknown>
 // ============================================================================
 
 /**
- * Create a new bead with type-safe validation
+ * Create a new cell with type-safe validation
  */
-export const beads_create = tool({
-  description: "Create a new bead with type-safe validation",
+export const hive_create = tool({
+  description: "Create a new cell in the hive with type-safe validation",
   args: {
-    title: tool.schema.string().describe("Bead title"),
+    title: tool.schema.string().describe("Cell title"),
     type: tool.schema
       .enum(["bug", "feature", "task", "epic", "chore"])
       .optional()
@@ -250,19 +263,19 @@ export const beads_create = tool({
       .max(3)
       .optional()
       .describe("Priority 0-3 (default: 2)"),
-    description: tool.schema.string().optional().describe("Bead description"),
+    description: tool.schema.string().optional().describe("Cell description"),
     parent_id: tool.schema
       .string()
       .optional()
-      .describe("Parent bead ID for epic children"),
+      .describe("Parent cell ID for epic children"),
   },
   async execute(args, ctx) {
-    const validated = BeadCreateArgsSchema.parse(args);
-    const projectKey = getBeadsWorkingDirectory();
-    const adapter = await getBeadsAdapter(projectKey);
+    const validated = CellCreateArgsSchema.parse(args);
+    const projectKey = getHiveWorkingDirectory();
+    const adapter = await getHiveAdapter(projectKey);
 
     try {
-      const bead = await adapter.createBead(projectKey, {
+      const cell = await adapter.createCell(projectKey, {
         title: validated.title,
         type: validated.type || "task",
         priority: validated.priority ?? 2,
@@ -271,15 +284,15 @@ export const beads_create = tool({
       });
 
       // Mark dirty for export
-      await adapter.markDirty(projectKey, bead.id);
+      await adapter.markDirty(projectKey, cell.id);
 
-      const formatted = formatBeadForOutput(bead);
+      const formatted = formatCellForOutput(cell);
       return JSON.stringify(formatted, null, 2);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      throw new BeadError(
-        `Failed to create bead: ${message}`,
-        "beads_create",
+      throw new HiveError(
+        `Failed to create cell: ${message}`,
+        "hive_create",
       );
     }
   },
@@ -288,7 +301,7 @@ export const beads_create = tool({
 /**
  * Create an epic with subtasks in one atomic operation
  */
-export const beads_create_epic = tool({
+export const hive_create_epic = tool({
   description: "Create epic with subtasks in one atomic operation",
   args: {
     epic_title: tool.schema.string().describe("Epic title"),
@@ -338,13 +351,13 @@ export const beads_create_epic = tool({
   },
   async execute(args, ctx) {
     const validated = EpicCreateArgsSchema.parse(args);
-    const projectKey = getBeadsWorkingDirectory();
-    const adapter = await getBeadsAdapter(projectKey);
-    const created: AdapterBead[] = [];
+    const projectKey = getHiveWorkingDirectory();
+    const adapter = await getHiveAdapter(projectKey);
+    const created: AdapterCell[] = [];
 
     try {
       // 1. Create epic
-      const epic = await adapter.createBead(projectKey, {
+      const epic = await adapter.createCell(projectKey, {
         title: validated.epic_title,
         type: "epic",
         priority: 1,
@@ -355,20 +368,20 @@ export const beads_create_epic = tool({
 
       // 2. Create subtasks
       for (const subtask of validated.subtasks) {
-        const subtaskBead = await adapter.createBead(projectKey, {
+        const subtaskCell = await adapter.createCell(projectKey, {
           title: subtask.title,
           type: "task",
           priority: subtask.priority ?? 2,
           parent_id: epic.id,
         });
-        await adapter.markDirty(projectKey, subtaskBead.id);
-        created.push(subtaskBead);
+        await adapter.markDirty(projectKey, subtaskCell.id);
+        created.push(subtaskCell);
       }
 
       const result: EpicCreateResult = {
         success: true,
-        epic: formatBeadForOutput(epic) as Bead,
-        subtasks: created.slice(1).map((b) => formatBeadForOutput(b) as Bead),
+        epic: formatCellForOutput(epic) as Cell,
+        subtasks: created.slice(1).map((c) => formatCellForOutput(c) as Cell),
       };
 
       // Emit DecompositionGeneratedEvent for learning system
@@ -392,7 +405,7 @@ export const beads_create_epic = tool({
         } catch (error) {
           // Non-fatal - log and continue
           console.warn(
-            "[beads_create_epic] Failed to emit DecompositionGeneratedEvent:",
+            "[hive_create_epic] Failed to emit DecompositionGeneratedEvent:",
             error,
           );
         }
@@ -400,12 +413,12 @@ export const beads_create_epic = tool({
 
       return JSON.stringify(result, null, 2);
     } catch (error) {
-      // Partial failure - rollback via deleteBead
+      // Partial failure - rollback via deleteCell
       const rollbackErrors: string[] = [];
 
-      for (const bead of created) {
+      for (const cell of created) {
         try {
-          await adapter.deleteBead(projectKey, bead.id, {
+          await adapter.deleteCell(projectKey, cell.id, {
             reason: "Rollback partial epic",
           });
         } catch (rollbackError) {
@@ -413,21 +426,21 @@ export const beads_create_epic = tool({
             rollbackError instanceof Error
               ? rollbackError.message
               : String(rollbackError);
-          console.error(`Failed to rollback bead ${bead.id}:`, rollbackError);
-          rollbackErrors.push(`${bead.id}: ${errMsg}`);
+          console.error(`Failed to rollback cell ${cell.id}:`, rollbackError);
+          rollbackErrors.push(`${cell.id}: ${errMsg}`);
         }
       }
 
       const errorMsg = error instanceof Error ? error.message : String(error);
-      let rollbackInfo = `\n\nRolled back ${created.length - rollbackErrors.length} bead(s)`;
+      let rollbackInfo = `\n\nRolled back ${created.length - rollbackErrors.length} cell(s)`;
 
       if (rollbackErrors.length > 0) {
         rollbackInfo += `\n\nRollback failures (${rollbackErrors.length}):\n${rollbackErrors.join("\n")}`;
       }
 
-      throw new BeadError(
+      throw new HiveError(
         `Epic creation failed: ${errorMsg}${rollbackInfo}`,
-        "beads_create_epic",
+        "hive_create_epic",
         1,
       );
     }
@@ -435,10 +448,10 @@ export const beads_create_epic = tool({
 });
 
 /**
- * Query beads with filters
+ * Query cells with filters
  */
-export const beads_query = tool({
-  description: "Query beads with filters (replaces bd list, bd ready, bd wip)",
+export const hive_query = tool({
+  description: "Query hive cells with filters (replaces bd list, bd ready, bd wip)",
   args: {
     status: tool.schema
       .enum(["open", "in_progress", "blocked", "closed"])
@@ -451,50 +464,50 @@ export const beads_query = tool({
     ready: tool.schema
       .boolean()
       .optional()
-      .describe("Only show unblocked beads (uses bd ready)"),
+      .describe("Only show unblocked cells"),
     limit: tool.schema
       .number()
       .optional()
       .describe("Max results to return (default: 20)"),
   },
   async execute(args, ctx) {
-    const validated = BeadQueryArgsSchema.parse(args);
-    const projectKey = getBeadsWorkingDirectory();
-    const adapter = await getBeadsAdapter(projectKey);
+    const validated = CellQueryArgsSchema.parse(args);
+    const projectKey = getHiveWorkingDirectory();
+    const adapter = await getHiveAdapter(projectKey);
 
     try {
-      let beads: AdapterBead[];
+      let cells: AdapterCell[];
 
       if (validated.ready) {
-        const readyBead = await adapter.getNextReadyBead(projectKey);
-        beads = readyBead ? [readyBead] : [];
+        const readyCell = await adapter.getNextReadyCell(projectKey);
+        cells = readyCell ? [readyCell] : [];
       } else {
-        beads = await adapter.queryBeads(projectKey, {
+        cells = await adapter.queryCells(projectKey, {
           status: validated.status,
           type: validated.type,
           limit: validated.limit || 20,
         });
       }
 
-      const formatted = beads.map((b) => formatBeadForOutput(b));
+      const formatted = cells.map((c) => formatCellForOutput(c));
       return JSON.stringify(formatted, null, 2);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      throw new BeadError(
-        `Failed to query beads: ${message}`,
-        "beads_query",
+      throw new HiveError(
+        `Failed to query cells: ${message}`,
+        "hive_query",
       );
     }
   },
 });
 
 /**
- * Update a bead's status or description
+ * Update a cell's status or description
  */
-export const beads_update = tool({
-  description: "Update bead status/description",
+export const hive_update = tool({
+  description: "Update cell status/description",
   args: {
-    id: tool.schema.string().describe("Bead ID"),
+    id: tool.schema.string().describe("Cell ID"),
     status: tool.schema
       .enum(["open", "in_progress", "blocked", "closed"])
       .optional()
@@ -508,16 +521,16 @@ export const beads_update = tool({
       .describe("New priority"),
   },
   async execute(args, ctx) {
-    const validated = BeadUpdateArgsSchema.parse(args);
-    const projectKey = getBeadsWorkingDirectory();
-    const adapter = await getBeadsAdapter(projectKey);
+    const validated = CellUpdateArgsSchema.parse(args);
+    const projectKey = getHiveWorkingDirectory();
+    const adapter = await getHiveAdapter(projectKey);
 
     try {
-      let bead: AdapterBead;
+      let cell: AdapterCell;
 
-      // Status changes use changeBeadStatus, other fields use updateBead
+      // Status changes use changeCellStatus, other fields use updateCell
       if (validated.status) {
-        bead = await adapter.changeBeadStatus(
+        cell = await adapter.changeCellStatus(
           projectKey,
           validated.id,
           validated.status,
@@ -526,52 +539,52 @@ export const beads_update = tool({
 
       // Update other fields if provided
       if (validated.description !== undefined || validated.priority !== undefined) {
-        bead = await adapter.updateBead(projectKey, validated.id, {
+        cell = await adapter.updateCell(projectKey, validated.id, {
           description: validated.description,
           priority: validated.priority,
         });
       } else if (!validated.status) {
         // No changes requested
-        const existingBead = await adapter.getBead(projectKey, validated.id);
-        if (!existingBead) {
-          throw new BeadError(
-            `Bead not found: ${validated.id}`,
-            "beads_update",
+        const existingCell = await adapter.getCell(projectKey, validated.id);
+        if (!existingCell) {
+          throw new HiveError(
+            `Cell not found: ${validated.id}`,
+            "hive_update",
           );
         }
-        bead = existingBead;
+        cell = existingCell;
       }
 
       await adapter.markDirty(projectKey, validated.id);
 
-      const formatted = formatBeadForOutput(bead!);
+      const formatted = formatCellForOutput(cell!);
       return JSON.stringify(formatted, null, 2);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      throw new BeadError(
-        `Failed to update bead: ${message}`,
-        "beads_update",
+      throw new HiveError(
+        `Failed to update cell: ${message}`,
+        "hive_update",
       );
     }
   },
 });
 
 /**
- * Close a bead with reason
+ * Close a cell with reason
  */
-export const beads_close = tool({
-  description: "Close a bead with reason",
+export const hive_close = tool({
+  description: "Close a cell with reason",
   args: {
-    id: tool.schema.string().describe("Bead ID"),
+    id: tool.schema.string().describe("Cell ID"),
     reason: tool.schema.string().describe("Completion reason"),
   },
   async execute(args, ctx) {
-    const validated = BeadCloseArgsSchema.parse(args);
-    const projectKey = getBeadsWorkingDirectory();
-    const adapter = await getBeadsAdapter(projectKey);
+    const validated = CellCloseArgsSchema.parse(args);
+    const projectKey = getHiveWorkingDirectory();
+    const adapter = await getHiveAdapter(projectKey);
 
     try {
-      const bead = await adapter.closeBead(
+      const cell = await adapter.closeCell(
         projectKey,
         validated.id,
         validated.reason,
@@ -579,32 +592,32 @@ export const beads_close = tool({
 
       await adapter.markDirty(projectKey, validated.id);
 
-      return `Closed ${bead.id}: ${validated.reason}`;
+      return `Closed ${cell.id}: ${validated.reason}`;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      throw new BeadError(
-        `Failed to close bead: ${message}`,
-        "beads_close",
+      throw new HiveError(
+        `Failed to close cell: ${message}`,
+        "hive_close",
       );
     }
   },
 });
 
 /**
- * Mark a bead as in-progress
+ * Mark a cell as in-progress
  */
-export const beads_start = tool({
+export const hive_start = tool({
   description:
-    "Mark a bead as in-progress (shortcut for update --status in_progress)",
+    "Mark a cell as in-progress (shortcut for update --status in_progress)",
   args: {
-    id: tool.schema.string().describe("Bead ID"),
+    id: tool.schema.string().describe("Cell ID"),
   },
   async execute(args, ctx) {
-    const projectKey = getBeadsWorkingDirectory();
-    const adapter = await getBeadsAdapter(projectKey);
+    const projectKey = getHiveWorkingDirectory();
+    const adapter = await getHiveAdapter(projectKey);
 
     try {
-      const bead = await adapter.changeBeadStatus(
+      const cell = await adapter.changeCellStatus(
         projectKey,
         args.id,
         "in_progress",
@@ -612,51 +625,51 @@ export const beads_start = tool({
 
       await adapter.markDirty(projectKey, args.id);
 
-      return `Started: ${bead.id}`;
+      return `Started: ${cell.id}`;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      throw new BeadError(
-        `Failed to start bead: ${message}`,
-        "beads_start",
+      throw new HiveError(
+        `Failed to start cell: ${message}`,
+        "hive_start",
       );
     }
   },
 });
 
 /**
- * Get the next ready bead
+ * Get the next ready cell
  */
-export const beads_ready = tool({
-  description: "Get the next ready bead (unblocked, highest priority)",
+export const hive_ready = tool({
+  description: "Get the next ready cell (unblocked, highest priority)",
   args: {},
   async execute(args, ctx) {
-    const projectKey = getBeadsWorkingDirectory();
-    const adapter = await getBeadsAdapter(projectKey);
+    const projectKey = getHiveWorkingDirectory();
+    const adapter = await getHiveAdapter(projectKey);
 
     try {
-      const bead = await adapter.getNextReadyBead(projectKey);
+      const cell = await adapter.getNextReadyCell(projectKey);
 
-      if (!bead) {
-        return "No ready beads";
+      if (!cell) {
+        return "No ready cells";
       }
 
-      const formatted = formatBeadForOutput(bead);
+      const formatted = formatCellForOutput(cell);
       return JSON.stringify(formatted, null, 2);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      throw new BeadError(
-        `Failed to get ready beads: ${message}`,
-        "beads_ready",
+      throw new HiveError(
+        `Failed to get ready cells: ${message}`,
+        "hive_ready",
       );
     }
   },
 });
 
 /**
- * Sync beads to git and push
+ * Sync hive to git and push
  */
-export const beads_sync = tool({
-  description: "Sync beads to git and push (MANDATORY at session end)",
+export const hive_sync = tool({
+  description: "Sync hive to git and push (MANDATORY at session end)",
   args: {
     auto_pull: tool.schema
       .boolean()
@@ -665,8 +678,8 @@ export const beads_sync = tool({
   },
   async execute(args, ctx) {
     const autoPull = args.auto_pull ?? true;
-    const projectKey = getBeadsWorkingDirectory();
-    const adapter = await getBeadsAdapter(projectKey);
+    const projectKey = getHiveWorkingDirectory();
+    const adapter = await getHiveAdapter(projectKey);
     const TIMEOUT_MS = 30000; // 30 seconds
 
     /**
@@ -683,7 +696,7 @@ export const beads_sync = tool({
         timeoutId = setTimeout(
           () =>
             reject(
-              new BeadError(
+              new HiveError(
                 `Operation timed out after ${timeoutMs}ms`,
                 operation,
               ),
@@ -701,45 +714,45 @@ export const beads_sync = tool({
       }
     };
 
-    // 1. Flush beads to JSONL using FlushManager
+    // 1. Flush cells to JSONL using FlushManager
     const flushManager = new FlushManager({
       adapter,
       projectKey,
-      outputPath: `${projectKey}/.beads/issues.jsonl`,
+      outputPath: `${projectKey}/.hive/issues.jsonl`,
     });
 
     const flushResult = await withTimeout(
       flushManager.flush(),
       TIMEOUT_MS,
-      "flush beads",
+      "flush hive",
     );
 
-    if (flushResult.beadsExported === 0) {
-      return "No beads to sync";
+    if (flushResult.cellsExported === 0) {
+      return "No cells to sync";
     }
 
     // 2. Check if there are changes to commit
-    const beadsStatusResult = await runGitCommand([
+    const hiveStatusResult = await runGitCommand([
       "status",
       "--porcelain",
-      ".beads/",
+      ".hive/",
     ]);
-    const hasChanges = beadsStatusResult.stdout.trim() !== "";
+    const hasChanges = hiveStatusResult.stdout.trim() !== "";
 
     if (hasChanges) {
-      // 3. Stage .beads changes
-      const addResult = await runGitCommand(["add", ".beads/"]);
+      // 3. Stage .hive changes
+      const addResult = await runGitCommand(["add", ".hive/"]);
       if (addResult.exitCode !== 0) {
-        throw new BeadError(
-          `Failed to stage beads: ${addResult.stderr}`,
-          "git add .beads/",
+        throw new HiveError(
+          `Failed to stage hive: ${addResult.stderr}`,
+          "git add .hive/",
           addResult.exitCode,
         );
       }
 
       // 4. Commit
       const commitResult = await withTimeout(
-        runGitCommand(["commit", "-m", "chore: sync beads"]),
+        runGitCommand(["commit", "-m", "chore: sync hive"]),
         TIMEOUT_MS,
         "git commit",
       );
@@ -747,8 +760,8 @@ export const beads_sync = tool({
         commitResult.exitCode !== 0 &&
         !commitResult.stdout.includes("nothing to commit")
       ) {
-        throw new BeadError(
-          `Failed to commit beads: ${commitResult.stderr}`,
+        throw new HiveError(
+          `Failed to commit hive: ${commitResult.stderr}`,
           "git commit",
           commitResult.exitCode,
         );
@@ -764,7 +777,7 @@ export const beads_sync = tool({
       );
 
       if (pullResult.exitCode !== 0) {
-        throw new BeadError(
+        throw new HiveError(
           `Failed to pull: ${pullResult.stderr}`,
           "git pull --rebase",
           pullResult.exitCode,
@@ -779,63 +792,63 @@ export const beads_sync = tool({
       "git push",
     );
     if (pushResult.exitCode !== 0) {
-      throw new BeadError(
+      throw new HiveError(
         `Failed to push: ${pushResult.stderr}`,
         "git push",
         pushResult.exitCode,
       );
     }
 
-    return "Beads synced and pushed successfully";
+    return "Hive synced and pushed successfully";
   },
 });
 
 /**
- * Link a bead to an Agent Mail thread
+ * Link a cell to an Agent Mail thread
  */
-export const beads_link_thread = tool({
-  description: "Add metadata linking bead to Agent Mail thread",
+export const hive_link_thread = tool({
+  description: "Add metadata linking cell to Agent Mail thread",
   args: {
-    bead_id: tool.schema.string().describe("Bead ID"),
+    cell_id: tool.schema.string().describe("Cell ID"),
     thread_id: tool.schema.string().describe("Agent Mail thread ID"),
   },
   async execute(args, ctx) {
-    const projectKey = getBeadsWorkingDirectory();
-    const adapter = await getBeadsAdapter(projectKey);
+    const projectKey = getHiveWorkingDirectory();
+    const adapter = await getHiveAdapter(projectKey);
 
     try {
-      const bead = await adapter.getBead(projectKey, args.bead_id);
+      const cell = await adapter.getCell(projectKey, args.cell_id);
 
-      if (!bead) {
-        throw new BeadError(
-          `Bead not found: ${args.bead_id}`,
-          "beads_link_thread",
+      if (!cell) {
+        throw new HiveError(
+          `Cell not found: ${args.cell_id}`,
+          "hive_link_thread",
         );
       }
 
-      const existingDesc = bead.description || "";
+      const existingDesc = cell.description || "";
       const threadMarker = `[thread:${args.thread_id}]`;
 
       if (existingDesc.includes(threadMarker)) {
-        return `Bead ${args.bead_id} already linked to thread ${args.thread_id}`;
+        return `Cell ${args.cell_id} already linked to thread ${args.thread_id}`;
       }
 
       const newDesc = existingDesc
         ? `${existingDesc}\n\n${threadMarker}`
         : threadMarker;
 
-      await adapter.updateBead(projectKey, args.bead_id, {
+      await adapter.updateCell(projectKey, args.cell_id, {
         description: newDesc,
       });
 
-      await adapter.markDirty(projectKey, args.bead_id);
+      await adapter.markDirty(projectKey, args.cell_id);
 
-      return `Linked bead ${args.bead_id} to thread ${args.thread_id}`;
+      return `Linked cell ${args.cell_id} to thread ${args.thread_id}`;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      throw new BeadError(
+      throw new HiveError(
         `Failed to link thread: ${message}`,
-        "beads_link_thread",
+        "hive_link_thread",
       );
     }
   },
@@ -845,14 +858,160 @@ export const beads_link_thread = tool({
 // Export all tools
 // ============================================================================
 
+export const hiveTools = {
+  hive_create,
+  hive_create_epic,
+  hive_query,
+  hive_update,
+  hive_close,
+  hive_start,
+  hive_ready,
+  hive_sync,
+  hive_link_thread,
+};
+
+// ============================================================================
+// Deprecation Warning System
+// ============================================================================
+
+/**
+ * Track which deprecated tools have been warned about.
+ * Only warn once per tool name to avoid spam.
+ */
+const warnedTools = new Set<string>();
+
+/**
+ * Log a deprecation warning for a renamed tool.
+ * Only warns once per tool name per session.
+ * 
+ * @param oldName - The deprecated tool name (e.g., "hive_create")
+ * @param newName - The new tool name to use instead (e.g., "hive_create")
+ */
+function warnDeprecated(oldName: string, newName: string): void {
+  if (warnedTools.has(oldName)) {
+    return; // Already warned
+  }
+  
+  warnedTools.add(oldName);
+  console.warn(
+    `[DEPRECATED] ${oldName} is deprecated, use ${newName} instead. Will be removed in v1.0`
+  );
+}
+
+// ============================================================================
+// Legacy Aliases (DEPRECATED - use hive_* instead)
+// ============================================================================
+
+/**
+ * @deprecated Use hive_create instead. Will be removed in v1.0
+ */
+export const beads_create = tool({
+  ...hive_create,
+  async execute(args, ctx) {
+    warnDeprecated('beads_create', 'hive_create');
+    return hive_create.execute(args, ctx);
+  }
+});
+
+/**
+ * @deprecated Use hive_create_epic instead. Will be removed in v1.0
+ */
+export const beads_create_epic = tool({
+  ...hive_create_epic,
+  async execute(args, ctx) {
+    warnDeprecated('beads_create_epic', 'hive_create_epic');
+    return hive_create_epic.execute(args, ctx);
+  }
+});
+
+/**
+ * @deprecated Use hive_query instead. Will be removed in v1.0
+ */
+export const beads_query = tool({
+  ...hive_query,
+  async execute(args, ctx) {
+    warnDeprecated('beads_query', 'hive_query');
+    return hive_query.execute(args, ctx);
+  }
+});
+
+/**
+ * @deprecated Use hive_update instead. Will be removed in v1.0
+ */
+export const beads_update = tool({
+  ...hive_update,
+  async execute(args, ctx) {
+    warnDeprecated('beads_update', 'hive_update');
+    return hive_update.execute(args, ctx);
+  }
+});
+
+/**
+ * @deprecated Use hive_close instead. Will be removed in v1.0
+ */
+export const beads_close = tool({
+  ...hive_close,
+  async execute(args, ctx) {
+    warnDeprecated('beads_close', 'hive_close');
+    return hive_close.execute(args, ctx);
+  }
+});
+
+/**
+ * @deprecated Use hive_start instead. Will be removed in v1.0
+ */
+export const beads_start = tool({
+  ...hive_start,
+  async execute(args, ctx) {
+    warnDeprecated('beads_start', 'hive_start');
+    return hive_start.execute(args, ctx);
+  }
+});
+
+/**
+ * @deprecated Use hive_ready instead. Will be removed in v1.0
+ */
+export const beads_ready = tool({
+  ...hive_ready,
+  async execute(args, ctx) {
+    warnDeprecated('beads_ready', 'hive_ready');
+    return hive_ready.execute(args, ctx);
+  }
+});
+
+/**
+ * @deprecated Use hive_sync instead. Will be removed in v1.0
+ */
+export const beads_sync = tool({
+  ...hive_sync,
+  async execute(args, ctx) {
+    warnDeprecated('beads_sync', 'hive_sync');
+    return hive_sync.execute(args, ctx);
+  }
+});
+
+/**
+ * @deprecated Use hive_link_thread instead. Will be removed in v1.0
+ */
+export const beads_link_thread = tool({
+  ...hive_link_thread,
+  async execute(args, ctx) {
+    warnDeprecated('beads_link_thread', 'hive_link_thread');
+    return hive_link_thread.execute(args, ctx);
+  }
+});
+
+/**
+ * @deprecated Use hiveTools instead. Will be removed in v1.0
+ */
 export const beadsTools = {
-  beads_create: beads_create,
-  beads_create_epic: beads_create_epic,
-  beads_query: beads_query,
-  beads_update: beads_update,
-  beads_close: beads_close,
-  beads_start: beads_start,
-  beads_ready: beads_ready,
-  beads_sync: beads_sync,
-  beads_link_thread: beads_link_thread,
+  beads_create,
+  beads_create_epic,
+  beads_query,
+  beads_update,
+  beads_close,
+  beads_start,
+  beads_ready,
+  beads_sync,
+  beads_link_thread,
 };