opencode-swarm-plugin 0.26.1 → 0.27.2

package/dist/index.js

@@ -27051,10 +27051,10 @@ echo "Project directory: $1"
   };
 });
 
-// src/beads.ts
+// src/hive.ts
 init_dist();
 import {
-  createBeadsAdapter,
+  createHiveAdapter,
   FlushManager,
   importFromJSONL,
   getSwarmMail
@@ -27062,32 +27062,32 @@ import {
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
-// src/schemas/bead.ts
+// src/schemas/cell.ts
 init_zod();
-var BeadStatusSchema = exports_external.enum([
+var CellStatusSchema = exports_external.enum([
   "open",
   "in_progress",
   "blocked",
   "closed"
 ]);
-var BeadTypeSchema = exports_external.enum([
+var CellTypeSchema = exports_external.enum([
   "bug",
   "feature",
   "task",
   "epic",
   "chore"
 ]);
-var BeadDependencySchema = exports_external.object({
+var CellDependencySchema = exports_external.object({
   id: exports_external.string(),
   type: exports_external.enum(["blocks", "blocked-by", "related", "discovered-from"])
 });
-var BeadSchema = exports_external.object({
-  id: exports_external.string().regex(/^[a-z0-9]+(-[a-z0-9]+)+(\.[\w-]+)?$/, "Invalid bead ID format (expected: project-slug-hash or project-slug-hash.N)"),
+var CellSchema = exports_external.object({
+  id: exports_external.string().regex(/^[a-z0-9]+(-[a-z0-9]+)+(\.[\w-]+)?$/, "Invalid cell ID format (expected: project-slug-hash or project-slug-hash.N)"),
   title: exports_external.string().min(1, "Title required"),
   description: exports_external.string().optional().default(""),
-  status: BeadStatusSchema.default("open"),
+  status: CellStatusSchema.default("open"),
   priority: exports_external.number().int().min(0).max(3).default(2),
-  issue_type: BeadTypeSchema.default("task"),
+  issue_type: CellTypeSchema.default("task"),
   created_at: exports_external.string().datetime({
     offset: true,
     message: "Must be ISO-8601 datetime with timezone (e.g., 2024-01-15T10:30:00Z)"
@@ -27098,30 +27098,30 @@ var BeadSchema = exports_external.object({
   }).optional(),
   closed_at: exports_external.string().datetime({ offset: true }).optional(),
   parent_id: exports_external.string().optional(),
-  dependencies: exports_external.array(BeadDependencySchema).default([]),
+  dependencies: exports_external.array(CellDependencySchema).default([]),
   metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
 });
-var BeadCreateArgsSchema = exports_external.object({
+var CellCreateArgsSchema = exports_external.object({
   title: exports_external.string().min(1, "Title required"),
-  type: BeadTypeSchema.default("task"),
+  type: CellTypeSchema.default("task"),
   priority: exports_external.number().int().min(0).max(3).default(2),
   description: exports_external.string().optional(),
   parent_id: exports_external.string().optional(),
   id: exports_external.string().optional()
 });
-var BeadUpdateArgsSchema = exports_external.object({
+var CellUpdateArgsSchema = exports_external.object({
   id: exports_external.string(),
-  status: BeadStatusSchema.optional(),
+  status: CellStatusSchema.optional(),
   description: exports_external.string().optional(),
   priority: exports_external.number().int().min(0).max(3).optional()
 });
-var BeadCloseArgsSchema = exports_external.object({
+var CellCloseArgsSchema = exports_external.object({
   id: exports_external.string(),
   reason: exports_external.string().min(1, "Reason required")
 });
-var BeadQueryArgsSchema = exports_external.object({
-  status: BeadStatusSchema.optional(),
-  type: BeadTypeSchema.optional(),
+var CellQueryArgsSchema = exports_external.object({
+  status: CellStatusSchema.optional(),
+  type: CellTypeSchema.optional(),
   ready: exports_external.boolean().optional(),
   limit: exports_external.number().int().positive().default(20)
 });
@@ -27132,7 +27132,7 @@ var SubtaskSpecSchema = exports_external.object({
   dependencies: exports_external.array(exports_external.number().int().min(0)).default([]),
   estimated_complexity: exports_external.number().int().min(1).max(5).default(3)
 });
-var BeadTreeSchema = exports_external.object({
+var CellTreeSchema = exports_external.object({
   epic: exports_external.object({
     title: exports_external.string().min(1),
     description: exports_external.string().optional().default("")
@@ -27152,10 +27152,19 @@ var EpicCreateArgsSchema = exports_external.object({
 });
 var EpicCreateResultSchema = exports_external.object({
   success: exports_external.boolean(),
-  epic: BeadSchema,
-  subtasks: exports_external.array(BeadSchema),
+  epic: CellSchema,
+  subtasks: exports_external.array(CellSchema),
   rollback_hint: exports_external.string().optional()
 });
+var BeadStatusSchema = CellStatusSchema;
+var BeadTypeSchema = CellTypeSchema;
+var BeadDependencySchema = CellDependencySchema;
+var BeadSchema = CellSchema;
+var BeadCreateArgsSchema = CellCreateArgsSchema;
+var BeadUpdateArgsSchema = CellUpdateArgsSchema;
+var BeadCloseArgsSchema = CellCloseArgsSchema;
+var BeadQueryArgsSchema = CellQueryArgsSchema;
+var BeadTreeSchema = CellTreeSchema;
 // src/schemas/evaluation.ts
 init_zod();
 var CriterionEvaluationSchema = exports_external.object({
@@ -27437,29 +27446,29 @@ var QuerySwarmContextsArgsSchema = exports_external.object({
   strategy: SwarmStrategySchema.optional(),
   has_errors: exports_external.boolean().optional()
 });
-// src/schemas/bead-events.ts
+// src/schemas/cell-events.ts
 init_zod();
-var BaseBeadEventSchema = exports_external.object({
+var BaseCellEventSchema = exports_external.object({
   id: exports_external.number().optional(),
   type: exports_external.string(),
   project_key: exports_external.string(),
   timestamp: exports_external.number(),
   sequence: exports_external.number().optional()
 });
-var BeadCreatedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_created"),
-  bead_id: exports_external.string(),
+var CellCreatedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_created"),
+  cell_id: exports_external.string(),
   title: exports_external.string(),
   description: exports_external.string().optional(),
-  issue_type: BeadTypeSchema,
+  issue_type: CellTypeSchema,
   priority: exports_external.number().int().min(0).max(3),
   parent_id: exports_external.string().optional(),
   created_by: exports_external.string().optional(),
   metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
 });
-var BeadUpdatedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_updated"),
-  bead_id: exports_external.string(),
+var CellUpdatedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_updated"),
+  cell_id: exports_external.string(),
   updated_by: exports_external.string().optional(),
   changes: exports_external.object({
     title: exports_external.object({
@@ -27476,167 +27485,167 @@ var BeadUpdatedEventSchema = BaseBeadEventSchema.extend({
     }).optional()
   })
 });
-var BeadStatusChangedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_status_changed"),
-  bead_id: exports_external.string(),
-  from_status: BeadStatusSchema,
-  to_status: BeadStatusSchema,
+var CellStatusChangedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_status_changed"),
+  cell_id: exports_external.string(),
+  from_status: CellStatusSchema,
+  to_status: CellStatusSchema,
   changed_by: exports_external.string().optional(),
   reason: exports_external.string().optional()
 });
-var BeadClosedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_closed"),
-  bead_id: exports_external.string(),
+var CellClosedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_closed"),
+  cell_id: exports_external.string(),
   reason: exports_external.string(),
   closed_by: exports_external.string().optional(),
   files_touched: exports_external.array(exports_external.string()).optional(),
   duration_ms: exports_external.number().optional()
 });
-var BeadReopenedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_reopened"),
-  bead_id: exports_external.string(),
+var CellReopenedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_reopened"),
+  cell_id: exports_external.string(),
   reason: exports_external.string().optional(),
   reopened_by: exports_external.string().optional()
 });
-var BeadDeletedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_deleted"),
-  bead_id: exports_external.string(),
+var CellDeletedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_deleted"),
+  cell_id: exports_external.string(),
   reason: exports_external.string().optional(),
   deleted_by: exports_external.string().optional()
 });
-var BeadDependencyAddedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_dependency_added"),
-  bead_id: exports_external.string(),
-  dependency: BeadDependencySchema,
+var CellDependencyAddedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_dependency_added"),
+  cell_id: exports_external.string(),
+  dependency: CellDependencySchema,
   added_by: exports_external.string().optional(),
   reason: exports_external.string().optional()
 });
-var BeadDependencyRemovedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_dependency_removed"),
-  bead_id: exports_external.string(),
-  dependency: BeadDependencySchema,
+var CellDependencyRemovedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_dependency_removed"),
+  cell_id: exports_external.string(),
+  dependency: CellDependencySchema,
   removed_by: exports_external.string().optional(),
   reason: exports_external.string().optional()
 });
-var BeadLabelAddedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_label_added"),
-  bead_id: exports_external.string(),
+var CellLabelAddedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_label_added"),
+  cell_id: exports_external.string(),
   label: exports_external.string(),
   added_by: exports_external.string().optional()
 });
-var BeadLabelRemovedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_label_removed"),
-  bead_id: exports_external.string(),
+var CellLabelRemovedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_label_removed"),
+  cell_id: exports_external.string(),
   label: exports_external.string(),
   removed_by: exports_external.string().optional()
 });
-var BeadCommentAddedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_comment_added"),
-  bead_id: exports_external.string(),
+var CellCommentAddedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_comment_added"),
+  cell_id: exports_external.string(),
   comment_id: exports_external.number().optional(),
   author: exports_external.string(),
   body: exports_external.string(),
   parent_comment_id: exports_external.number().optional(),
   metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
 });
-var BeadCommentUpdatedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_comment_updated"),
-  bead_id: exports_external.string(),
+var CellCommentUpdatedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_comment_updated"),
+  cell_id: exports_external.string(),
   comment_id: exports_external.number(),
   old_body: exports_external.string(),
   new_body: exports_external.string(),
   updated_by: exports_external.string()
 });
-var BeadCommentDeletedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_comment_deleted"),
-  bead_id: exports_external.string(),
+var CellCommentDeletedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_comment_deleted"),
+  cell_id: exports_external.string(),
   comment_id: exports_external.number(),
   deleted_by: exports_external.string(),
   reason: exports_external.string().optional()
 });
-var BeadEpicChildAddedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_epic_child_added"),
-  bead_id: exports_external.string(),
+var CellEpicChildAddedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_epic_child_added"),
+  cell_id: exports_external.string(),
   child_id: exports_external.string(),
   child_index: exports_external.number().optional(),
   added_by: exports_external.string().optional()
 });
-var BeadEpicChildRemovedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_epic_child_removed"),
-  bead_id: exports_external.string(),
+var CellEpicChildRemovedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_epic_child_removed"),
+  cell_id: exports_external.string(),
   child_id: exports_external.string(),
   removed_by: exports_external.string().optional(),
   reason: exports_external.string().optional()
 });
-var BeadEpicClosureEligibleEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_epic_closure_eligible"),
-  bead_id: exports_external.string(),
+var CellEpicClosureEligibleEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_epic_closure_eligible"),
+  cell_id: exports_external.string(),
   child_ids: exports_external.array(exports_external.string()),
   total_duration_ms: exports_external.number().optional(),
   all_files_touched: exports_external.array(exports_external.string()).optional()
 });
-var BeadAssignedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_assigned"),
-  bead_id: exports_external.string(),
+var CellAssignedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_assigned"),
+  cell_id: exports_external.string(),
   agent_name: exports_external.string(),
   task_description: exports_external.string().optional()
 });
-var BeadWorkStartedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_work_started"),
-  bead_id: exports_external.string(),
+var CellWorkStartedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_work_started"),
+  cell_id: exports_external.string(),
   agent_name: exports_external.string(),
   reserved_files: exports_external.array(exports_external.string()).optional()
 });
-var BeadCompactedEventSchema = BaseBeadEventSchema.extend({
-  type: exports_external.literal("bead_compacted"),
-  bead_id: exports_external.string(),
+var CellCompactedEventSchema = BaseCellEventSchema.extend({
+  type: exports_external.literal("cell_compacted"),
+  cell_id: exports_external.string(),
   events_archived: exports_external.number(),
   new_start_sequence: exports_external.number()
 });
-var BeadEventSchema = exports_external.discriminatedUnion("type", [
-  BeadCreatedEventSchema,
-  BeadUpdatedEventSchema,
-  BeadStatusChangedEventSchema,
-  BeadClosedEventSchema,
-  BeadReopenedEventSchema,
-  BeadDeletedEventSchema,
-  BeadDependencyAddedEventSchema,
-  BeadDependencyRemovedEventSchema,
-  BeadLabelAddedEventSchema,
-  BeadLabelRemovedEventSchema,
-  BeadCommentAddedEventSchema,
-  BeadCommentUpdatedEventSchema,
-  BeadCommentDeletedEventSchema,
-  BeadEpicChildAddedEventSchema,
-  BeadEpicChildRemovedEventSchema,
-  BeadEpicClosureEligibleEventSchema,
-  BeadAssignedEventSchema,
-  BeadWorkStartedEventSchema,
-  BeadCompactedEventSchema
+var CellEventSchema = exports_external.discriminatedUnion("type", [
+  CellCreatedEventSchema,
+  CellUpdatedEventSchema,
+  CellStatusChangedEventSchema,
+  CellClosedEventSchema,
+  CellReopenedEventSchema,
+  CellDeletedEventSchema,
+  CellDependencyAddedEventSchema,
+  CellDependencyRemovedEventSchema,
+  CellLabelAddedEventSchema,
+  CellLabelRemovedEventSchema,
+  CellCommentAddedEventSchema,
+  CellCommentUpdatedEventSchema,
+  CellCommentDeletedEventSchema,
+  CellEpicChildAddedEventSchema,
+  CellEpicChildRemovedEventSchema,
+  CellEpicClosureEligibleEventSchema,
+  CellAssignedEventSchema,
+  CellWorkStartedEventSchema,
+  CellCompactedEventSchema
 ]);
-function createBeadEvent(type, data) {
+function createCellEvent(type, data) {
   const event = {
     type,
     timestamp: Date.now(),
     ...data
   };
-  const result = BeadEventSchema.safeParse(event);
+  const result = CellEventSchema.safeParse(event);
   if (!result.success) {
-    throw new Error(`Invalid bead event: ${result.error.message}`);
+    throw new Error(`Invalid cell event: ${result.error.message}`);
   }
   return result.data;
 }
-function isBeadEventType(event, type) {
+function isCellEventType(event, type) {
   return event.type === type;
 }
-function getBeadIdFromEvent(event) {
-  return event.bead_id;
+function getCellIdFromEvent(event) {
+  return event.cell_id;
 }
 function isStateTransitionEvent(event) {
-  return event.type === "bead_status_changed" || event.type === "bead_closed" || event.type === "bead_reopened";
+  return event.type === "cell_status_changed" || event.type === "cell_closed" || event.type === "cell_reopened";
 }
 function isEpicEvent(event) {
-  return event.type === "bead_epic_child_added" || event.type === "bead_epic_child_removed" || event.type === "bead_epic_closure_eligible";
+  return event.type === "cell_epic_child_added" || event.type === "cell_epic_child_removed" || event.type === "cell_epic_closure_eligible";
 }
 function isAgentEvent(event) {
   if ("agent_name" in event)
@@ -27659,17 +27668,43 @@ function isAgentEvent(event) {
     return false;
   });
 }
-// src/beads.ts
+var BaseBeadEventSchema = BaseCellEventSchema;
+var BeadCreatedEventSchema = CellCreatedEventSchema;
+var BeadUpdatedEventSchema = CellUpdatedEventSchema;
+var BeadStatusChangedEventSchema = CellStatusChangedEventSchema;
+var BeadClosedEventSchema = CellClosedEventSchema;
+var BeadReopenedEventSchema = CellReopenedEventSchema;
+var BeadDeletedEventSchema = CellDeletedEventSchema;
+var BeadDependencyAddedEventSchema = CellDependencyAddedEventSchema;
+var BeadDependencyRemovedEventSchema = CellDependencyRemovedEventSchema;
+var BeadLabelAddedEventSchema = CellLabelAddedEventSchema;
+var BeadLabelRemovedEventSchema = CellLabelRemovedEventSchema;
+var BeadCommentAddedEventSchema = CellCommentAddedEventSchema;
+var BeadCommentUpdatedEventSchema = CellCommentUpdatedEventSchema;
+var BeadCommentDeletedEventSchema = CellCommentDeletedEventSchema;
+var BeadEpicChildAddedEventSchema = CellEpicChildAddedEventSchema;
+var BeadEpicChildRemovedEventSchema = CellEpicChildRemovedEventSchema;
+var BeadEpicClosureEligibleEventSchema = CellEpicClosureEligibleEventSchema;
+var BeadAssignedEventSchema = CellAssignedEventSchema;
+var BeadWorkStartedEventSchema = CellWorkStartedEventSchema;
+var BeadCompactedEventSchema = CellCompactedEventSchema;
+var BeadEventSchema = CellEventSchema;
+var createBeadEvent = createCellEvent;
+var isBeadEventType = isCellEventType;
+var getBeadIdFromEvent = getCellIdFromEvent;
+// src/hive.ts
 import { createEvent, appendEvent } from "swarm-mail";
-var beadsWorkingDirectory = null;
-function setBeadsWorkingDirectory(directory) {
-  beadsWorkingDirectory = directory;
+var hiveWorkingDirectory = null;
+function setHiveWorkingDirectory(directory) {
+  hiveWorkingDirectory = directory;
 }
-function getBeadsWorkingDirectory() {
-  return beadsWorkingDirectory || process.cwd();
+function getHiveWorkingDirectory() {
+  return hiveWorkingDirectory || process.cwd();
 }
+var setBeadsWorkingDirectory = setHiveWorkingDirectory;
+var getBeadsWorkingDirectory = getHiveWorkingDirectory;
 async function runGitCommand(args) {
-  const cwd = getBeadsWorkingDirectory();
+  const cwd = getHiveWorkingDirectory();
   const proc = Bun.spawn(["git", ...args], {
     cwd,
     stdout: "pipe",
@@ -27683,7 +27718,7 @@ async function runGitCommand(args) {
   return { exitCode, stdout, stderr };
 }
 
-class BeadError extends Error {
+class HiveError extends Error {
   command;
   exitCode;
   stderr;
@@ -27692,38 +27727,41 @@ class BeadError extends Error {
     this.command = command;
     this.exitCode = exitCode;
     this.stderr = stderr;
-    this.name = "BeadError";
+    this.name = "HiveError";
   }
 }
+var BeadError = HiveError;
 
-class BeadValidationError extends Error {
+class HiveValidationError extends Error {
   zodError;
   constructor(message, zodError) {
     super(message);
     this.zodError = zodError;
-    this.name = "BeadValidationError";
+    this.name = "HiveValidationError";
   }
 }
+var BeadValidationError = HiveValidationError;
 var adapterCache = new Map;
-async function getBeadsAdapter(projectKey) {
+async function getHiveAdapter(projectKey) {
   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);
   await adapter.runMigrations();
   await autoMigrateFromJSONL(adapter, projectKey);
   adapterCache.set(projectKey, adapter);
   return adapter;
 }
+var getBeadsAdapter = getHiveAdapter;
 async function autoMigrateFromJSONL(adapter, projectKey) {
-  const jsonlPath = join(projectKey, ".beads", "issues.jsonl");
+  const jsonlPath = join(projectKey, ".hive", "issues.jsonl");
   if (!existsSync(jsonlPath)) {
     return;
   }
-  const existingBeads = await adapter.queryBeads(projectKey, { limit: 1 });
-  if (existingBeads.length > 0) {
+  const existingCells = await adapter.queryCells(projectKey, { limit: 1 });
+  if (existingCells.length > 0) {
     return;
   }
   try {
@@ -27732,62 +27770,62 @@ async function autoMigrateFromJSONL(adapter, projectKey) {
       skipExisting: true
     });
     if (result.created > 0 || result.updated > 0) {
-      console.log(`[beads] Auto-migrated ${result.created} beads from ${jsonlPath} (${result.skipped} skipped, ${result.errors.length} errors)`);
+      console.log(`[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}`));
+      console.warn(`[hive] Migration errors:`, result.errors.slice(0, 5).map((e) => `${e.cellId}: ${e.error}`));
     }
   } catch (error45) {
-    console.warn(`[beads] Failed to auto-migrate from ${jsonlPath}:`, error45 instanceof Error ? error45.message : String(error45));
+    console.warn(`[hive] Failed to auto-migrate from ${jsonlPath}:`, error45 instanceof Error ? error45.message : String(error45));
   }
 }
-function formatBeadForOutput(adapterBead) {
+function formatCellForOutput(adapterCell) {
   return {
-    id: adapterBead.id,
-    title: adapterBead.title,
-    description: adapterBead.description || "",
-    status: adapterBead.status,
-    priority: adapterBead.priority,
-    issue_type: adapterBead.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() : undefined,
-    parent_id: adapterBead.parent_id || undefined,
+    id: adapterCell.id,
+    title: adapterCell.title,
+    description: adapterCell.description || "",
+    status: adapterCell.status,
+    priority: adapterCell.priority,
+    issue_type: adapterCell.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: adapterCell.parent_id || undefined,
     dependencies: [],
     metadata: {}
   };
 }
-var beads_create = tool({
-  description: "Create a new bead with type-safe validation",
+var 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().describe("Issue type (default: task)"),
     priority: tool.schema.number().min(0).max(3).optional().describe("Priority 0-3 (default: 2)"),
-    description: tool.schema.string().optional().describe("Bead description"),
-    parent_id: tool.schema.string().optional().describe("Parent bead ID for epic children")
+    description: tool.schema.string().optional().describe("Cell description"),
+    parent_id: tool.schema.string().optional().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,
         description: validated.description,
         parent_id: validated.parent_id
       });
-      await adapter.markDirty(projectKey, bead.id);
-      const formatted = formatBeadForOutput(bead);
+      await adapter.markDirty(projectKey, cell.id);
+      const formatted = formatCellForOutput(cell);
       return JSON.stringify(formatted, null, 2);
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
-      throw new BeadError(`Failed to create bead: ${message}`, "beads_create");
+      throw new HiveError(`Failed to create cell: ${message}`, "hive_create");
     }
   }
 });
-var beads_create_epic = tool({
+var hive_create_epic = tool({
   description: "Create epic with subtasks in one atomic operation",
   args: {
     epic_title: tool.schema.string().describe("Epic title"),
@@ -27810,11 +27848,11 @@ var beads_create_epic = tool({
   },
   async execute(args, ctx) {
     const validated = EpicCreateArgsSchema.parse(args);
-    const projectKey = getBeadsWorkingDirectory();
-    const adapter = await getBeadsAdapter(projectKey);
+    const projectKey = getHiveWorkingDirectory();
+    const adapter = await getHiveAdapter(projectKey);
     const created = [];
     try {
-      const epic = await adapter.createBead(projectKey, {
+      const epic = await adapter.createCell(projectKey, {
         title: validated.epic_title,
         type: "epic",
         priority: 1,
@@ -27823,19 +27861,19 @@ var beads_create_epic = tool({
       await adapter.markDirty(projectKey, epic.id);
       created.push(epic);
       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 = {
         success: true,
-        epic: formatBeadForOutput(epic),
-        subtasks: created.slice(1).map((b) => formatBeadForOutput(b))
+        epic: formatCellForOutput(epic),
+        subtasks: created.slice(1).map((c) => formatCellForOutput(c))
       };
       if (args.project_key) {
         try {
@@ -27855,27 +27893,27 @@ var beads_create_epic = tool({
           });
           await appendEvent(event, args.project_key);
         } catch (error45) {
-          console.warn("[beads_create_epic] Failed to emit DecompositionGeneratedEvent:", error45);
+          console.warn("[hive_create_epic] Failed to emit DecompositionGeneratedEvent:", error45);
         }
       }
       return JSON.stringify(result, null, 2);
     } catch (error45) {
       const rollbackErrors = [];
-      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) {
           const errMsg = 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 = error45 instanceof Error ? error45.message : String(error45);
       let rollbackInfo = `
 
-Rolled back ${created.length - rollbackErrors.length} bead(s)`;
+Rolled back ${created.length - rollbackErrors.length} cell(s)`;
       if (rollbackErrors.length > 0) {
         rollbackInfo += `
 
@@ -27883,151 +27921,151 @@ Rollback failures (${rollbackErrors.length}):
 ${rollbackErrors.join(`
 `)}`;
       }
-      throw new BeadError(`Epic creation failed: ${errorMsg}${rollbackInfo}`, "beads_create_epic", 1);
+      throw new HiveError(`Epic creation failed: ${errorMsg}${rollbackInfo}`, "hive_create_epic", 1);
     }
   }
 });
-var beads_query = tool({
-  description: "Query beads with filters (replaces bd list, bd ready, bd wip)",
+var 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"]).optional().describe("Filter by status"),
     type: tool.schema.enum(["bug", "feature", "task", "epic", "chore"]).optional().describe("Filter by type"),
-    ready: tool.schema.boolean().optional().describe("Only show unblocked beads (uses bd ready)"),
+    ready: tool.schema.boolean().optional().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;
+      let cells;
       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 (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
-      throw new BeadError(`Failed to query beads: ${message}`, "beads_query");
+      throw new HiveError(`Failed to query cells: ${message}`, "hive_query");
     }
   }
 });
-var beads_update = tool({
-  description: "Update bead status/description",
+var 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().describe("New status"),
     description: tool.schema.string().optional().describe("New description"),
     priority: tool.schema.number().min(0).max(3).optional().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;
+      let cell;
       if (validated.status) {
-        bead = await adapter.changeBeadStatus(projectKey, validated.id, validated.status);
+        cell = await adapter.changeCellStatus(projectKey, validated.id, validated.status);
       }
       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) {
-        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 (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
-      throw new BeadError(`Failed to update bead: ${message}`, "beads_update");
+      throw new HiveError(`Failed to update cell: ${message}`, "hive_update");
     }
   }
 });
-var beads_close = tool({
-  description: "Close a bead with reason",
+var 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(projectKey, validated.id, validated.reason);
+      const cell = await adapter.closeCell(projectKey, validated.id, validated.reason);
       await adapter.markDirty(projectKey, validated.id);
-      return `Closed ${bead.id}: ${validated.reason}`;
+      return `Closed ${cell.id}: ${validated.reason}`;
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
-      throw new BeadError(`Failed to close bead: ${message}`, "beads_close");
+      throw new HiveError(`Failed to close cell: ${message}`, "hive_close");
     }
   }
 });
-var beads_start = tool({
-  description: "Mark a bead as in-progress (shortcut for update --status in_progress)",
+var hive_start = tool({
+  description: "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(projectKey, args.id, "in_progress");
+      const cell = await adapter.changeCellStatus(projectKey, args.id, "in_progress");
       await adapter.markDirty(projectKey, args.id);
-      return `Started: ${bead.id}`;
+      return `Started: ${cell.id}`;
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
-      throw new BeadError(`Failed to start bead: ${message}`, "beads_start");
+      throw new HiveError(`Failed to start cell: ${message}`, "hive_start");
     }
   }
 });
-var beads_ready = tool({
-  description: "Get the next ready bead (unblocked, highest priority)",
+var 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);
-      if (!bead) {
-        return "No ready beads";
+      const cell = await adapter.getNextReadyCell(projectKey);
+      if (!cell) {
+        return "No ready cells";
       }
-      const formatted = formatBeadForOutput(bead);
+      const formatted = formatCellForOutput(cell);
       return JSON.stringify(formatted, null, 2);
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
-      throw new BeadError(`Failed to get ready beads: ${message}`, "beads_ready");
+      throw new HiveError(`Failed to get ready cells: ${message}`, "hive_ready");
     }
   }
 });
-var beads_sync = tool({
-  description: "Sync beads to git and push (MANDATORY at session end)",
+var hive_sync = tool({
+  description: "Sync hive to git and push (MANDATORY at session end)",
   args: {
     auto_pull: tool.schema.boolean().optional().describe("Pull before sync (default: true)")
   },
   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;
     const withTimeout = async (promise2, timeoutMs, operation) => {
       let timeoutId;
       const timeoutPromise = new Promise((_, reject) => {
-        timeoutId = setTimeout(() => reject(new BeadError(`Operation timed out after ${timeoutMs}ms`, operation)), timeoutMs);
+        timeoutId = setTimeout(() => reject(new HiveError(`Operation timed out after ${timeoutMs}ms`, operation)), timeoutMs);
       });
       try {
         return await Promise.race([promise2, timeoutPromise]);
@@ -28040,74 +28078,156 @@ var beads_sync = tool({
     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");
-    if (flushResult.beadsExported === 0) {
-      return "No beads to sync";
+    const flushResult = await withTimeout(flushManager.flush(), TIMEOUT_MS, "flush hive");
+    if (flushResult.cellsExported === 0) {
+      return "No cells to sync";
     }
-    const beadsStatusResult = await runGitCommand([
+    const hiveStatusResult = await runGitCommand([
       "status",
       "--porcelain",
-      ".beads/"
+      ".hive/"
     ]);
-    const hasChanges = beadsStatusResult.stdout.trim() !== "";
+    const hasChanges = hiveStatusResult.stdout.trim() !== "";
     if (hasChanges) {
-      const addResult = await runGitCommand(["add", ".beads/"]);
+      const addResult = await runGitCommand(["add", ".hive/"]);
       if (addResult.exitCode !== 0) {
-        throw new BeadError(`Failed to stage beads: ${addResult.stderr}`, "git add .beads/", addResult.exitCode);
+        throw new HiveError(`Failed to stage hive: ${addResult.stderr}`, "git add .hive/", addResult.exitCode);
       }
-      const commitResult = await withTimeout(runGitCommand(["commit", "-m", "chore: sync beads"]), TIMEOUT_MS, "git commit");
+      const commitResult = await withTimeout(runGitCommand(["commit", "-m", "chore: sync hive"]), TIMEOUT_MS, "git commit");
       if (commitResult.exitCode !== 0 && !commitResult.stdout.includes("nothing to commit")) {
-        throw new BeadError(`Failed to commit beads: ${commitResult.stderr}`, "git commit", commitResult.exitCode);
+        throw new HiveError(`Failed to commit hive: ${commitResult.stderr}`, "git commit", commitResult.exitCode);
       }
     }
     if (autoPull) {
       const pullResult = await withTimeout(runGitCommand(["pull", "--rebase"]), TIMEOUT_MS, "git pull --rebase");
       if (pullResult.exitCode !== 0) {
-        throw new BeadError(`Failed to pull: ${pullResult.stderr}`, "git pull --rebase", pullResult.exitCode);
+        throw new HiveError(`Failed to pull: ${pullResult.stderr}`, "git pull --rebase", pullResult.exitCode);
       }
     }
     const pushResult = await withTimeout(runGitCommand(["push"]), TIMEOUT_MS, "git push");
     if (pushResult.exitCode !== 0) {
-      throw new BeadError(`Failed to push: ${pushResult.stderr}`, "git push", pushResult.exitCode);
+      throw new HiveError(`Failed to push: ${pushResult.stderr}`, "git push", pushResult.exitCode);
     }
-    return "Beads synced and pushed successfully";
+    return "Hive synced and pushed successfully";
   }
 });
-var beads_link_thread = tool({
-  description: "Add metadata linking bead to Agent Mail thread",
+var 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);
-      if (!bead) {
-        throw new BeadError(`Bead not found: ${args.bead_id}`, "beads_link_thread");
+      const cell = await adapter.getCell(projectKey, args.cell_id);
+      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}
 
 ${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);
-      return `Linked bead ${args.bead_id} to thread ${args.thread_id}`;
+      await adapter.markDirty(projectKey, args.cell_id);
+      return `Linked cell ${args.cell_id} to thread ${args.thread_id}`;
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
-      throw new BeadError(`Failed to link thread: ${message}`, "beads_link_thread");
+      throw new HiveError(`Failed to link thread: ${message}`, "hive_link_thread");
     }
   }
 });
+var hiveTools = {
+  hive_create,
+  hive_create_epic,
+  hive_query,
+  hive_update,
+  hive_close,
+  hive_start,
+  hive_ready,
+  hive_sync,
+  hive_link_thread
+};
+var warnedTools = new Set;
+function warnDeprecated(oldName, newName) {
+  if (warnedTools.has(oldName)) {
+    return;
+  }
+  warnedTools.add(oldName);
+  console.warn(`[DEPRECATED] ${oldName} is deprecated, use ${newName} instead. Will be removed in v1.0`);
+}
+var beads_create = tool({
+  ...hive_create,
+  async execute(args, ctx) {
+    warnDeprecated("beads_create", "hive_create");
+    return hive_create.execute(args, ctx);
+  }
+});
+var 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);
+  }
+});
+var beads_query = tool({
+  ...hive_query,
+  async execute(args, ctx) {
+    warnDeprecated("beads_query", "hive_query");
+    return hive_query.execute(args, ctx);
+  }
+});
+var beads_update = tool({
+  ...hive_update,
+  async execute(args, ctx) {
+    warnDeprecated("beads_update", "hive_update");
+    return hive_update.execute(args, ctx);
+  }
+});
+var beads_close = tool({
+  ...hive_close,
+  async execute(args, ctx) {
+    warnDeprecated("beads_close", "hive_close");
+    return hive_close.execute(args, ctx);
+  }
+});
+var beads_start = tool({
+  ...hive_start,
+  async execute(args, ctx) {
+    warnDeprecated("beads_start", "hive_start");
+    return hive_start.execute(args, ctx);
+  }
+});
+var beads_ready = tool({
+  ...hive_ready,
+  async execute(args, ctx) {
+    warnDeprecated("beads_ready", "hive_ready");
+    return hive_ready.execute(args, ctx);
+  }
+});
+var beads_sync = tool({
+  ...hive_sync,
+  async execute(args, ctx) {
+    warnDeprecated("beads_sync", "hive_sync");
+    return hive_sync.execute(args, ctx);
+  }
+});
+var 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);
+  }
+});
 var beadsTools = {
   beads_create,
   beads_create_epic,
@@ -28237,6 +28357,29 @@ var toolCheckers = {
       };
     }
   },
+  hive: async () => {
+    const exists = await commandExists("hive");
+    if (!exists) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: "hive command not found"
+      };
+    }
+    try {
+      const result = await Bun.$`hive --version`.quiet().nothrow();
+      return {
+        available: result.exitCode === 0,
+        checkedAt: new Date().toISOString()
+      };
+    } catch (e) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: String(e)
+      };
+    }
+  },
   beads: async () => {
     const exists = await commandExists("bd");
     if (!exists) {
@@ -28290,7 +28433,8 @@ var fallbackBehaviors = {
   "semantic-memory": "Learning data stored in-memory only (lost on session end)",
   cass: "Decomposition proceeds without historical context from past sessions",
   ubs: "Subtask completion skips bug scanning - manual review recommended",
-  beads: "Swarm cannot track issues - task coordination will be less reliable",
+  hive: "Swarm cannot track issues - task coordination will be less reliable",
+  beads: "DEPRECATED: Use hive instead. Swarm cannot track issues - task coordination will be less reliable",
   "swarm-mail": "Multi-agent coordination disabled - file conflicts possible if multiple agents active",
   "agent-mail": "DEPRECATED: Use swarm-mail instead. Legacy MCP server mode - file conflicts possible if multiple agents active"
 };
@@ -28321,6 +28465,7 @@ async function checkAllTools() {
     "semantic-memory",
     "cass",
     "ubs",
+    "hive",
     "beads",
     "swarm-mail",
     "agent-mail"
@@ -29922,7 +30067,7 @@ function formatZodErrors(error45) {
 var SCHEMA_REGISTRY = {
   evaluation: EvaluationSchema,
   task_decomposition: TaskDecompositionSchema,
-  bead_tree: BeadTreeSchema
+  cell_tree: CellTreeSchema
 };
 function getSchemaByName(name) {
   const schema = SCHEMA_REGISTRY[name];
@@ -30058,7 +30203,7 @@ var structured_validate = tool({
   description: "Validate agent response against a schema. Extracts JSON and validates with Zod. Returns structured errors for retry feedback.",
   args: {
     response: tool.schema.string().describe("Agent response to validate"),
-    schema_name: tool.schema.enum(["evaluation", "task_decomposition", "bead_tree"]).describe("Schema to validate against: " + "evaluation = agent self-eval with criteria, " + "task_decomposition = swarm task breakdown, " + "bead_tree = epic with subtasks"),
+    schema_name: tool.schema.enum(["evaluation", "task_decomposition", "cell_tree"]).describe("Schema to validate against: " + "evaluation = agent self-eval with criteria, " + "task_decomposition = swarm task breakdown, " + "cell_tree = epic with subtasks"),
     max_retries: tool.schema.number().min(1).max(5).optional().describe("Max retries (for tracking - actual retry logic is external)")
   },
   async execute(args, ctx) {
@@ -30244,15 +30389,15 @@ var structured_parse_decomposition = tool({
     }
   }
 });
-var structured_parse_bead_tree = tool({
-  description: "Parse and validate bead tree response. Uses BeadTreeSchema. Validates before creating epic with subtasks.",
+var structured_parse_cell_tree = tool({
+  description: "Parse and validate bead tree response. Uses CellTreeSchema. Validates before creating epic with subtasks.",
   args: {
     response: tool.schema.string().describe("Agent response containing bead tree")
   },
   async execute(args, ctx) {
     try {
       const [extracted, method] = extractJsonFromText(args.response);
-      const validated = BeadTreeSchema.parse(extracted);
+      const validated = CellTreeSchema.parse(extracted);
       const allFiles = validated.subtasks.flatMap((s) => s.files);
       const uniqueFiles = [...new Set(allFiles)];
       return JSON.stringify({
@@ -30311,7 +30456,7 @@ var structuredTools = {
   structured_validate,
   structured_parse_evaluation,
   structured_parse_decomposition,
-  structured_parse_bead_tree
+  structured_parse_cell_tree
 };
 
 // src/swarm.ts
@@ -30334,9 +30479,9 @@ var DECOMPOSITION_PROMPT = `You are decomposing a task into parallelizable subta
 
 After decomposition, the coordinator will:
 1. Create an epic bead for the overall task
-2. Create child beads for each subtask
+2. Create child cells for each subtask
 3. Track progress through bead status updates
-4. Close beads with summaries when complete
+4. Close cells with summaries when complete
 
 Agents MUST update their bead status as they work. No silent progress.
 
@@ -30356,7 +30501,7 @@ Respond with a JSON object matching this schema:
 \`\`\`typescript
 {
   epic: {
-    title: string,        // Epic title for the beads tracker
+    title: string,        // Epic title for the hive tracker
     description?: string  // Brief description of the overall goal
   },
   subtasks: [
@@ -30407,9 +30552,9 @@ var STRATEGY_DECOMPOSITION_PROMPT = `You are decomposing a task into paralleliza
 
 After decomposition, the coordinator will:
 1. Create an epic bead for the overall task
-2. Create child beads for each subtask
+2. Create child cells for each subtask
 3. Track progress through bead status updates
-4. Close beads with summaries when complete
+4. Close cells with summaries when complete
 
 Agents MUST update their bead status as they work. No silent progress.
 
@@ -30429,7 +30574,7 @@ Respond with a JSON object matching this schema:
 \`\`\`typescript
 {
   epic: {
-    title: string,        // Epic title for the beads tracker
+    title: string,        // Epic title for the hive tracker
     description?: string  // Brief description of the overall goal
   },
   subtasks: [
@@ -30619,7 +30764,7 @@ ${fullContext}` : `## Additional Context
     const prompt = DECOMPOSITION_PROMPT.replace("{task}", args.task).replace("{max_subtasks}", (args.max_subtasks ?? 5).toString()).replace("{context_section}", contextSection);
     return JSON.stringify({
       prompt,
-      expected_schema: "BeadTree",
+      expected_schema: "CellTree",
       schema_hint: {
         epic: { title: "string", description: "string?" },
         subtasks: [
@@ -30632,21 +30777,21 @@ ${fullContext}` : `## Additional Context
           }
         ]
       },
-      validation_note: "Parse agent response as JSON and validate with BeadTreeSchema from schemas/bead.ts",
+      validation_note: "Parse agent response as JSON and validate with CellTreeSchema from schemas/bead.ts",
       cass_history: cassResultInfo,
       memory_query: formatMemoryQueryForDecomposition2(args.task, 3)
     }, null, 2);
   }
 });
 var swarm_validate_decomposition = tool({
-  description: "Validate a decomposition response against BeadTreeSchema",
+  description: "Validate a decomposition response against CellTreeSchema",
   args: {
-    response: tool.schema.string().describe("JSON response from agent (BeadTree format)")
+    response: tool.schema.string().describe("JSON response from agent (CellTree format)")
   },
   async execute(args) {
     try {
       const parsed = JSON.parse(args.response);
-      const validated = BeadTreeSchema.parse(parsed);
+      const validated = CellTreeSchema.parse(parsed);
       const conflicts = detectFileConflicts(validated.subtasks);
       if (conflicts.length > 0) {
         return JSON.stringify({
@@ -30677,7 +30822,7 @@ var swarm_validate_decomposition = tool({
       const instructionConflicts = detectInstructionConflicts(validated.subtasks);
       return JSON.stringify({
         valid: true,
-        bead_tree: validated,
+        cell_tree: validated,
         stats: {
           subtask_count: validated.subtasks.length,
           total_files: new Set(validated.subtasks.flatMap((s) => s.files)).size,
@@ -30779,7 +30924,7 @@ ${args.context}` : `## Additional Context
     const subagentInstructions = `
 ## CRITICAL: Output Format
 
-You are a planner subagent. Your ONLY output must be valid JSON matching the BeadTree schema.
+You are a planner subagent. Your ONLY output must be valid JSON matching the CellTree schema.
 
 DO NOT include:
 - Explanatory text before or after the JSON
@@ -30813,7 +30958,7 @@ OUTPUT ONLY the raw JSON object.
   ]
 }
 
-Now generate the BeadTree for the given task.`;
+Now generate the CellTree for the given task.`;
     const fullPrompt = `${planningPrompt}
 
 ${subagentInstructions}`;
@@ -30825,12 +30970,12 @@ ${subagentInstructions}`;
         selected: selectedStrategy,
         reasoning: strategyReasoning
       },
-      expected_output: "BeadTree JSON (raw JSON, no markdown)",
+      expected_output: "CellTree JSON (raw JSON, no markdown)",
       next_steps: [
         "1. Spawn subagent with Task tool using returned prompt",
         "2. Parse subagent response as JSON",
         "3. Validate with swarm_validate_decomposition",
-        "4. Create beads with beads_create_epic"
+        "4. Create cells with hive_create_epic"
       ],
       cass_history: cassResultInfo,
       skills: skillsInfo,
@@ -31089,17 +31234,17 @@ var STRATEGY_DECOMPOSITION_PROMPT2 = `You are decomposing a task into paralleliz
 
 {skills_context}
 
-## MANDATORY: Beads Issue Tracking
+## MANDATORY: Hive Issue Tracking
 
-**Every subtask MUST become a bead.** This is non-negotiable.
+**Every subtask MUST become a cell.** This is non-negotiable.
 
 After decomposition, the coordinator will:
-1. Create an epic bead for the overall task
-2. Create child beads for each subtask
-3. Track progress through bead status updates
-4. Close beads with summaries when complete
+1. Create an epic cell for the overall task
+2. Create child cells for each subtask
+3. Track progress through cell status updates
+4. Close cells with summaries when complete
 
-Agents MUST update their bead status as they work. No silent progress.
+Agents MUST update their cell status as they work. No silent progress.
 
 ## Requirements
 
@@ -31117,7 +31262,7 @@ Respond with a JSON object matching this schema:
 \`\`\`typescript
 {
   epic: {
-    title: string,        // Epic title for the beads tracker
+    title: string,        // Epic title for the hive tracker
     description?: string  // Brief description of the overall goal
   },
   subtasks: [
@@ -31138,7 +31283,7 @@ var SUBTASK_PROMPT = `You are a swarm agent working on a subtask of a larger epi
 
 ## Your Identity
 - **Agent Name**: {agent_name}
-- **Bead ID**: {bead_id}
+- **Cell ID**: {bead_id}
 - **Epic ID**: {epic_id}
 
 ## Your Subtask
@@ -31156,16 +31301,16 @@ send a message to the coordinator requesting the change.
 ## Shared Context
 {shared_context}
 
-## MANDATORY: Beads Tracking
+## MANDATORY: Hive Tracking
 
-You MUST keep your bead updated as you work:
+You MUST keep your cell updated as you work:
 
-1. **Your bead is already in_progress** - don't change this unless blocked
-2. **If blocked**: \`bd update {bead_id} --status blocked\` and message coordinator
-3. **When done**: Use \`swarm_complete\` - it closes your bead automatically
-4. **Discovered issues**: Create new beads with \`bd create "issue" -t bug\`
+1. **Your cell is already in_progress** - don't change this unless blocked
+2. **If blocked**: \`hive_update {bead_id} --status blocked\` and message coordinator
+3. **When done**: Use \`swarm_complete\` - it closes your cell automatically
+4. **Discovered issues**: Create new cells with \`hive_create "issue" -t bug\`
 
-**Never work silently.** Your bead status is how the swarm tracks progress.
+**Never work silently.** Your cell status is how the swarm tracks progress.
 
 ## MANDATORY: Swarm Mail Communication
 
@@ -31188,11 +31333,11 @@ swarmmail_send(
 
 ## Coordination Protocol
 
-1. **Start**: Your bead is already marked in_progress
+1. **Start**: Your cell is already marked in_progress
 2. **Progress**: Use swarm_progress to report status updates
 3. **Blocked**: Report immediately via Swarm Mail - don't spin
 4. **Complete**: Use swarm_complete when done - it handles:
-   - Closing your bead with a summary
+   - Closing your cell with a summary
    - Releasing file reservations
    - Notifying the coordinator
 
@@ -31219,7 +31364,7 @@ var SUBTASK_PROMPT_V2 = `You are a swarm agent working on: **{subtask_title}**
 
 ## [IDENTITY]
 Agent: (assigned at spawn)
-Bead: {bead_id}
+Cell: {bead_id}
 Epic: {epic_id}
 
 ## [TASK]
@@ -31363,7 +31508,7 @@ swarm_complete(
 - Records learning signals
 - Notifies coordinator
 
-**DO NOT manually close the bead with beads_close.** Use swarm_complete.
+**DO NOT manually close the cell with hive_close.** Use swarm_complete.
 
 ## [SWARM MAIL COMMUNICATION]
 
@@ -31382,7 +31527,7 @@ swarmmail_send(
   importance="high",
   thread_id="{epic_id}"
 )
-beads_update(id="{bead_id}", status="blocked")
+hive_update(id="{bead_id}", status="blocked")
 \`\`\`
 
 ### Report Issues to Other Agents
@@ -31403,15 +31548,15 @@ swarmmail_release()  # Manually release reservations
 **Note:** \`swarm_complete\` automatically releases reservations. Only use manual release if aborting work.
 
 ## [OTHER TOOLS]
-### Beads - You Have Autonomy to File Issues
-You can create new beads against this epic when you discover:
+### Hive - You Have Autonomy to File Issues
+You can create new cells against this epic when you discover:
 - **Bugs**: Found a bug while working? File it.
 - **Tech debt**: Spotted something that needs cleanup? File it.
 - **Follow-up work**: Task needs more work than scoped? File a follow-up.
 - **Dependencies**: Need something from another agent? File and link it.
 
 \`\`\`
-beads_create(
+hive_create(
   title="<descriptive title>",
   type="bug",  # or "task", "chore"
   priority=2,
@@ -31422,9 +31567,9 @@ beads_create(
 
 **Don't silently ignore issues.** File them so they get tracked and addressed.
 
-Other bead operations:
-- beads_update(id, status) - Mark blocked if stuck
-- beads_query(status="open") - See what else needs work
+Other cell operations:
+- hive_update(id, status) - Mark blocked if stuck
+- hive_query(status="open") - See what else needs work
 
 ### Skills
 - skills_list() - Discover available skills
@@ -31438,7 +31583,7 @@ Other bead operations:
 2. Step 2 (semantic-memory_find) MUST happen before starting work
 3. Step 4 (swarmmail_reserve) - YOU reserve files, not coordinator
 4. Step 6 (swarm_progress) - Report at milestones, don't work silently
-5. Step 9 (swarm_complete) - Use this to close, NOT beads_close
+5. Step 9 (swarm_complete) - Use this to close, NOT hive_close
 
 **If you skip these steps:**
 - Your work won't be tracked (swarm_complete will fail)
@@ -31451,7 +31596,7 @@ Begin now.`;
 var EVALUATION_PROMPT = `Evaluate the work completed for this subtask.
 
 ## Subtask
-**Bead ID**: {bead_id}
+**Cell ID**: {bead_id}
 **Title**: {subtask_title}
 
 ## Files Modified
@@ -31553,7 +31698,7 @@ var swarm_subtask_prompt = tool({
   }
 });
 var swarm_spawn_subtask = tool({
-  description: "Prepare a subtask for spawning. Returns prompt with Agent Mail/beads instructions. IMPORTANT: Pass project_path for swarmmail_init.",
+  description: "Prepare a subtask for spawning. Returns prompt with Agent Mail/hive tracking instructions. IMPORTANT: Pass project_path for swarmmail_init.",
   args: {
     bead_id: tool.schema.string().describe("Subtask bead ID"),
     epic_id: tool.schema.string().describe("Parent epic bead ID"),
@@ -31678,7 +31823,7 @@ ${args.context}` : `## Additional Context
         guidelines: STRATEGIES2[selectedStrategy].guidelines,
         anti_patterns: STRATEGIES2[selectedStrategy].antiPatterns
       },
-      expected_schema: "BeadTree",
+      expected_schema: "CellTree",
       schema_hint: {
         epic: { title: "string", description: "string?" },
         subtasks: [
@@ -31710,12 +31855,672 @@ init_learning();
 import {
   getSwarmInbox as getSwarmInbox2,
   releaseSwarmFiles as releaseSwarmFiles2,
-  sendSwarmMessage as sendSwarmMessage2,
+  sendSwarmMessage as sendSwarmMessage3,
   getAgent,
   createEvent as createEvent2,
   appendEvent as appendEvent2
 } from "swarm-mail";
 init_skills();
+
+// src/swarm-worktree.ts
+init_dist();
+init_zod();
+import { join as join6 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+var WORKTREE_DIR = ".swarm/worktrees";
+function getWorktreePath(projectPath, taskId) {
+  const safeTaskId = taskId.replace(/[^a-zA-Z0-9.-]/g, "_");
+  return join6(projectPath, WORKTREE_DIR, safeTaskId);
+}
+function parseTaskIdFromPath(worktreePath) {
+  const parts = worktreePath.split("/");
+  const worktreesIdx = parts.indexOf("worktrees");
+  if (worktreesIdx >= 0 && worktreesIdx < parts.length - 1) {
+    return parts[worktreesIdx + 1];
+  }
+  return null;
+}
+async function isGitRepo(path) {
+  const result = await Bun.$`git -C ${path} rev-parse --git-dir`.quiet().nothrow();
+  return result.exitCode === 0;
+}
+async function hasUncommittedChanges(path) {
+  const result = await Bun.$`git -C ${path} status --porcelain`.quiet().nothrow();
+  if (result.exitCode !== 0)
+    return true;
+  return result.stdout.toString().trim().length > 0;
+}
+async function getCurrentCommit(path) {
+  const result = await Bun.$`git -C ${path} rev-parse HEAD`.quiet().nothrow();
+  if (result.exitCode !== 0)
+    return null;
+  return result.stdout.toString().trim();
+}
+async function getWorktreeCommits(worktreePath, startCommit) {
+  const result = await Bun.$`git -C ${worktreePath} log --format=%H ${startCommit}..HEAD`.quiet().nothrow();
+  if (result.exitCode !== 0)
+    return [];
+  return result.stdout.toString().trim().split(`
+`).filter((c) => c.length > 0);
+}
+async function ensureWorktreeDir(projectPath) {
+  const worktreeDir = join6(projectPath, WORKTREE_DIR);
+  await Bun.$`mkdir -p ${worktreeDir}`.quiet().nothrow();
+}
+var swarm_worktree_create = tool({
+  description: "Create a git worktree for isolated task execution. Worker operates in worktree, not main branch.",
+  args: {
+    project_path: exports_external.string().describe("Absolute path to project root"),
+    task_id: exports_external.string().describe("Task/bead ID (e.g., bd-abc123.1)"),
+    start_commit: exports_external.string().describe("Commit SHA to create worktree at (swarm start point)")
+  },
+  async execute(args) {
+    if (!await isGitRepo(args.project_path)) {
+      const result2 = {
+        success: false,
+        error: `${args.project_path} is not a git repository`
+      };
+      return JSON.stringify(result2, null, 2);
+    }
+    const worktreePath = getWorktreePath(args.project_path, args.task_id);
+    const exists = existsSync5(worktreePath);
+    if (exists) {
+      const result2 = {
+        success: false,
+        error: `Worktree already exists for task ${args.task_id}`,
+        worktree_path: worktreePath
+      };
+      return JSON.stringify(result2, null, 2);
+    }
+    await ensureWorktreeDir(args.project_path);
+    const createResult = await Bun.$`git -C ${args.project_path} worktree add --detach ${worktreePath} ${args.start_commit}`.quiet().nothrow();
+    if (createResult.exitCode !== 0) {
+      const result2 = {
+        success: false,
+        error: `Failed to create worktree: ${createResult.stderr.toString()}`
+      };
+      return JSON.stringify(result2, null, 2);
+    }
+    const result = {
+      success: true,
+      worktree_path: worktreePath,
+      task_id: args.task_id,
+      created_at_commit: args.start_commit
+    };
+    return JSON.stringify(result, null, 2);
+  }
+});
+var swarm_worktree_merge = tool({
+  description: "Cherry-pick commits from worktree back to main branch. Call after worker completes.",
+  args: {
+    project_path: exports_external.string().describe("Absolute path to project root"),
+    task_id: exports_external.string().describe("Task/bead ID"),
+    start_commit: exports_external.string().optional().describe("Original start commit (to find new commits)")
+  },
+  async execute(args) {
+    const worktreePath = getWorktreePath(args.project_path, args.task_id);
+    const exists = existsSync5(worktreePath);
+    if (!exists) {
+      const result2 = {
+        success: false,
+        error: `Worktree not found for task ${args.task_id}`
+      };
+      return JSON.stringify(result2, null, 2);
+    }
+    let startCommit = args.start_commit;
+    if (!startCommit) {
+      const mergeBaseResult = await Bun.$`git -C ${args.project_path} merge-base HEAD ${worktreePath}`.quiet().nothrow();
+      if (mergeBaseResult.exitCode === 0) {
+        startCommit = mergeBaseResult.stdout.toString().trim();
+      }
+    }
+    if (!startCommit) {
+      const result2 = {
+        success: false,
+        error: "Could not determine start commit for cherry-pick"
+      };
+      return JSON.stringify(result2, null, 2);
+    }
+    const commits = await getWorktreeCommits(worktreePath, startCommit);
+    if (commits.length === 0) {
+      const result2 = {
+        success: false,
+        error: `Worktree has no commits since ${startCommit.slice(0, 7)}`
+      };
+      return JSON.stringify(result2, null, 2);
+    }
+    const reversedCommits = commits.reverse();
+    let lastMergedCommit = null;
+    for (const commit of reversedCommits) {
+      const cherryResult = await Bun.$`git -C ${args.project_path} cherry-pick ${commit}`.quiet().nothrow();
+      if (cherryResult.exitCode !== 0) {
+        const stderr = cherryResult.stderr.toString();
+        if (stderr.includes("conflict") || stderr.includes("CONFLICT")) {
+          const statusResult = await Bun.$`git -C ${args.project_path} status --porcelain`.quiet().nothrow();
+          const conflictingFiles = statusResult.stdout.toString().split(`
+`).filter((line) => line.startsWith("UU") || line.startsWith("AA")).map((line) => line.slice(3).trim());
+          await Bun.$`git -C ${args.project_path} cherry-pick --abort`.quiet().nothrow();
+          const result3 = {
+            success: false,
+            error: `Merge conflict during cherry-pick of ${commit.slice(0, 7)}`,
+            conflicting_files: conflictingFiles
+          };
+          return JSON.stringify(result3, null, 2);
+        }
+        const result2 = {
+          success: false,
+          error: `Failed to cherry-pick ${commit.slice(0, 7)}: ${stderr}`
+        };
+        return JSON.stringify(result2, null, 2);
+      }
+      lastMergedCommit = commit;
+    }
+    const result = {
+      success: true,
+      task_id: args.task_id,
+      merged_commit: lastMergedCommit || undefined
+    };
+    return JSON.stringify(result, null, 2);
+  }
+});
+var swarm_worktree_cleanup = tool({
+  description: "Remove a worktree after completion or abort. Idempotent - safe to call multiple times.",
+  args: {
+    project_path: exports_external.string().describe("Absolute path to project root"),
+    task_id: exports_external.string().optional().describe("Task/bead ID to clean up"),
+    cleanup_all: exports_external.boolean().optional().describe("Remove all worktrees for this project")
+  },
+  async execute(args) {
+    if (args.cleanup_all) {
+      const listResult = await Bun.$`git -C ${args.project_path} worktree list --porcelain`.quiet().nothrow();
+      if (listResult.exitCode !== 0) {
+        const result3 = {
+          success: false,
+          error: `Failed to list worktrees: ${listResult.stderr.toString()}`
+        };
+        return JSON.stringify(result3, null, 2);
+      }
+      const output = listResult.stdout.toString();
+      const worktreeDir = join6(args.project_path, WORKTREE_DIR);
+      const worktrees = output.split(`
+
+`).filter((block) => block.includes(worktreeDir)).map((block) => {
+        const pathMatch = block.match(/^worktree (.+)$/m);
+        return pathMatch ? pathMatch[1] : null;
+      }).filter((p) => p !== null);
+      let removedCount = 0;
+      for (const wt of worktrees) {
+        const removeResult2 = await Bun.$`git -C ${args.project_path} worktree remove --force ${wt}`.quiet().nothrow();
+        if (removeResult2.exitCode === 0) {
+          removedCount++;
+        }
+      }
+      const result2 = {
+        success: true,
+        removed_count: removedCount
+      };
+      return JSON.stringify(result2, null, 2);
+    }
+    if (!args.task_id) {
+      const result2 = {
+        success: false,
+        error: "Either task_id or cleanup_all must be provided"
+      };
+      return JSON.stringify(result2, null, 2);
+    }
+    const worktreePath = getWorktreePath(args.project_path, args.task_id);
+    const exists = existsSync5(worktreePath);
+    if (!exists) {
+      const result2 = {
+        success: true,
+        already_removed: true,
+        removed_path: worktreePath
+      };
+      return JSON.stringify(result2, null, 2);
+    }
+    const removeResult = await Bun.$`git -C ${args.project_path} worktree remove --force ${worktreePath}`.quiet().nothrow();
+    if (removeResult.exitCode !== 0) {
+      await Bun.$`rm -rf ${worktreePath}`.quiet().nothrow();
+      await Bun.$`git -C ${args.project_path} worktree prune`.quiet().nothrow();
+    }
+    const result = {
+      success: true,
+      removed_path: worktreePath,
+      task_id: args.task_id
+    };
+    return JSON.stringify(result, null, 2);
+  }
+});
+var swarm_worktree_list = tool({
+  description: "List all active worktrees for a project",
+  args: {
+    project_path: exports_external.string().describe("Absolute path to project root")
+  },
+  async execute(args) {
+    const listResult = await Bun.$`git -C ${args.project_path} worktree list --porcelain`.quiet().nothrow();
+    if (listResult.exitCode !== 0) {
+      return JSON.stringify({
+        worktrees: [],
+        count: 0,
+        error: `Failed to list worktrees: ${listResult.stderr.toString()}`
+      }, null, 2);
+    }
+    const output = listResult.stdout.toString();
+    const worktreeDir = join6(args.project_path, WORKTREE_DIR);
+    const worktrees = [];
+    const blocks = output.split(`
+
+`).filter((b) => b.trim());
+    for (const block of blocks) {
+      const pathMatch = block.match(/^worktree (.+)$/m);
+      const commitMatch = block.match(/^HEAD ([a-f0-9]+)$/m);
+      const branchMatch = block.match(/^branch (.+)$/m);
+      if (pathMatch && pathMatch[1].includes(worktreeDir)) {
+        const path = pathMatch[1];
+        const taskId = parseTaskIdFromPath(path);
+        if (taskId) {
+          worktrees.push({
+            task_id: taskId,
+            path,
+            commit: commitMatch ? commitMatch[1] : "unknown",
+            branch: branchMatch ? branchMatch[1] : undefined
+          });
+        }
+      }
+    }
+    return JSON.stringify({
+      worktrees,
+      count: worktrees.length
+    }, null, 2);
+  }
+});
+async function canUseWorktreeIsolation(projectPath) {
+  if (!await isGitRepo(projectPath)) {
+    return { canUse: false, reason: "Not a git repository" };
+  }
+  if (await hasUncommittedChanges(projectPath)) {
+    return {
+      canUse: false,
+      reason: "Uncommitted changes exist - commit or stash first"
+    };
+  }
+  return { canUse: true };
+}
+async function getStartCommit(projectPath) {
+  return getCurrentCommit(projectPath);
+}
+var worktreeTools = {
+  swarm_worktree_create,
+  swarm_worktree_merge,
+  swarm_worktree_cleanup,
+  swarm_worktree_list
+};
+
+// src/swarm-review.ts
+init_dist();
+init_zod();
+import { sendSwarmMessage as sendSwarmMessage2 } from "swarm-mail";
+var ReviewIssueSchema = exports_external.object({
+  file: exports_external.string(),
+  line: exports_external.number().optional(),
+  issue: exports_external.string(),
+  suggestion: exports_external.string().optional()
+});
+var ReviewResultSchema = exports_external.object({
+  status: exports_external.enum(["approved", "needs_changes"]),
+  summary: exports_external.string().optional(),
+  issues: exports_external.array(ReviewIssueSchema).optional(),
+  remaining_attempts: exports_external.number().optional()
+}).refine((data) => {
+  if (data.status === "needs_changes") {
+    return data.issues && data.issues.length > 0;
+  }
+  return true;
+}, {
+  message: "issues array is required when status is 'needs_changes'"
+});
+var reviewAttempts = new Map;
+var MAX_REVIEW_ATTEMPTS = 3;
+function getAttemptCount(taskId) {
+  return reviewAttempts.get(taskId) || 0;
+}
+function incrementAttempt(taskId) {
+  const current = getAttemptCount(taskId);
+  const newCount = current + 1;
+  reviewAttempts.set(taskId, newCount);
+  return newCount;
+}
+function clearAttempts(taskId) {
+  reviewAttempts.delete(taskId);
+}
+function getRemainingAttempts(taskId) {
+  return MAX_REVIEW_ATTEMPTS - getAttemptCount(taskId);
+}
+function generateReviewPrompt(context) {
+  const sections = [];
+  sections.push(`# Code Review: ${context.task_title}`);
+  sections.push("");
+  sections.push("## Epic Goal");
+  sections.push(`**${context.epic_title}**`);
+  if (context.epic_description) {
+    sections.push(context.epic_description);
+  }
+  sections.push("");
+  sections.push("## Task Requirements");
+  sections.push(`**${context.task_title}**`);
+  if (context.task_description) {
+    sections.push(context.task_description);
+  }
+  sections.push("");
+  if (context.completed_dependencies && context.completed_dependencies.length > 0) {
+    sections.push("## This Task Builds On");
+    for (const dep of context.completed_dependencies) {
+      sections.push(`- **${dep.title}** (${dep.id})`);
+      if (dep.summary) {
+        sections.push(`  ${dep.summary}`);
+      }
+    }
+    sections.push("");
+  }
+  if (context.downstream_tasks && context.downstream_tasks.length > 0) {
+    sections.push("## Downstream Tasks (depend on this)");
+    for (const task of context.downstream_tasks) {
+      sections.push(`- **${task.title}** (${task.id})`);
+    }
+    sections.push("");
+  }
+  sections.push("## Files Modified");
+  for (const file2 of context.files_touched) {
+    sections.push(`- \`${file2}\``);
+  }
+  sections.push("");
+  sections.push("## Code Changes");
+  sections.push("```diff");
+  sections.push(context.diff);
+  sections.push("```");
+  sections.push("");
+  sections.push("## Review Criteria");
+  sections.push("");
+  sections.push("Please evaluate the changes against these criteria:");
+  sections.push("");
+  sections.push("1. **Fulfills Requirements**: Does the code implement what the task requires?");
+  sections.push("2. **Serves Epic Goal**: Does this work contribute to the overall epic objective?");
+  sections.push("3. **Enables Downstream**: Can downstream tasks use this work as expected?");
+  sections.push("4. **Type Safety**: Are types correct and complete?");
+  sections.push("5. **No Critical Bugs**: Are there any obvious bugs or issues?");
+  sections.push("6. **Test Coverage**: Are there tests for the new code? (warning only)");
+  sections.push("");
+  sections.push("## Response Format");
+  sections.push("");
+  sections.push("Respond with a JSON object:");
+  sections.push("```json");
+  sections.push(`{
+  "status": "approved" | "needs_changes",
+  "summary": "Brief summary of your review",
+  "issues": [
+    {
+      "file": "path/to/file.ts",
+      "line": 42,
+      "issue": "Description of the problem",
+      "suggestion": "How to fix it"
+    }
+  ]
+}`);
+  sections.push("```");
+  return sections.join(`
+`);
+}
+async function getHiveAdapterSafe(projectPath) {
+  try {
+    return getHiveAdapter(projectPath);
+  } catch {
+    return null;
+  }
+}
+async function getCellDependencies(adapter, projectKey, _cellId, epicId) {
+  const completedDependencies = [];
+  const downstreamTasks = [];
+  try {
+    const subtasks = await adapter.queryCells(projectKey, { parent_id: epicId });
+    for (const subtask of subtasks) {
+      if (subtask.id === _cellId)
+        continue;
+      if (subtask.status === "closed") {
+        completedDependencies.push({
+          id: subtask.id,
+          title: subtask.title,
+          summary: subtask.closed_reason ?? undefined
+        });
+      }
+      if (subtask.status !== "closed") {
+        downstreamTasks.push({
+          id: subtask.id,
+          title: subtask.title
+        });
+      }
+    }
+  } catch {}
+  return { completed: completedDependencies, downstream: downstreamTasks };
+}
+var swarm_review = tool({
+  description: "Generate a review prompt for a completed subtask. Includes epic context, dependencies, and diff.",
+  args: {
+    project_key: exports_external.string().describe("Project path"),
+    epic_id: exports_external.string().describe("Epic cell ID"),
+    task_id: exports_external.string().describe("Subtask cell ID to review"),
+    files_touched: exports_external.array(exports_external.string()).optional().describe("Files modified (will get diff for these)")
+  },
+  async execute(args) {
+    let epicTitle = args.epic_id;
+    let epicDescription;
+    let taskTitle = args.task_id;
+    let taskDescription;
+    let completedDependencies = [];
+    let downstreamTasks = [];
+    const adapter = await getHiveAdapterSafe(args.project_key);
+    if (adapter) {
+      try {
+        const epic = await adapter.getCell(args.project_key, args.epic_id);
+        if (epic) {
+          epicTitle = epic.title || epicTitle;
+          epicDescription = epic.description ?? undefined;
+        }
+        const task = await adapter.getCell(args.project_key, args.task_id);
+        if (task) {
+          taskTitle = task.title || taskTitle;
+          taskDescription = task.description ?? undefined;
+        }
+        const deps = await getCellDependencies(adapter, args.project_key, args.task_id, args.epic_id);
+        completedDependencies = deps.completed;
+        downstreamTasks = deps.downstream;
+      } catch {}
+    }
+    let diff = "";
+    if (args.files_touched && args.files_touched.length > 0) {
+      try {
+        const diffResult = await Bun.$`git diff HEAD~1 -- ${args.files_touched}`.cwd(args.project_key).quiet().nothrow();
+        if (diffResult.exitCode === 0) {
+          diff = diffResult.stdout.toString();
+        } else {
+          const stagedResult = await Bun.$`git diff --cached -- ${args.files_touched}`.cwd(args.project_key).quiet().nothrow();
+          diff = stagedResult.stdout.toString();
+        }
+      } catch {}
+    }
+    const reviewPrompt = generateReviewPrompt({
+      epic_id: args.epic_id,
+      epic_title: epicTitle,
+      epic_description: epicDescription,
+      task_id: args.task_id,
+      task_title: taskTitle,
+      task_description: taskDescription,
+      files_touched: args.files_touched || [],
+      diff: diff || "(no diff available)",
+      completed_dependencies: completedDependencies.length > 0 ? completedDependencies : undefined,
+      downstream_tasks: downstreamTasks.length > 0 ? downstreamTasks : undefined
+    });
+    return JSON.stringify({
+      review_prompt: reviewPrompt,
+      context: {
+        epic_id: args.epic_id,
+        epic_title: epicTitle,
+        task_id: args.task_id,
+        task_title: taskTitle,
+        files_touched: args.files_touched || [],
+        completed_dependencies: completedDependencies.length,
+        downstream_tasks: downstreamTasks.length,
+        remaining_attempts: getRemainingAttempts(args.task_id)
+      }
+    }, null, 2);
+  }
+});
+var swarm_review_feedback = tool({
+  description: "Send review feedback to a worker. Tracks attempts (max 3). Fails task after 3 rejections.",
+  args: {
+    project_key: exports_external.string().describe("Project path"),
+    task_id: exports_external.string().describe("Subtask cell ID"),
+    worker_id: exports_external.string().describe("Worker agent name"),
+    status: exports_external.enum(["approved", "needs_changes"]).describe("Review status"),
+    summary: exports_external.string().optional().describe("Review summary"),
+    issues: exports_external.string().optional().describe("JSON array of ReviewIssue objects (for needs_changes)")
+  },
+  async execute(args) {
+    let parsedIssues = [];
+    if (args.issues) {
+      try {
+        parsedIssues = JSON.parse(args.issues);
+      } catch {
+        return JSON.stringify({
+          success: false,
+          error: "Failed to parse issues JSON"
+        }, null, 2);
+      }
+    }
+    if (args.status === "needs_changes" && parsedIssues.length === 0) {
+      return JSON.stringify({
+        success: false,
+        error: "needs_changes status requires at least one issue"
+      }, null, 2);
+    }
+    const epicId = args.task_id.includes(".") ? args.task_id.split(".")[0] : args.task_id;
+    if (args.status === "approved") {
+      markReviewApproved(args.task_id);
+      await sendSwarmMessage2({
+        projectPath: args.project_key,
+        fromAgent: "coordinator",
+        toAgents: [args.worker_id],
+        subject: `APPROVED: ${args.task_id}`,
+        body: `## Review Approved ✓
+
+${args.summary || "Your work has been approved."}
+
+You may now complete the task with \`swarm_complete\`.`,
+        threadId: epicId,
+        importance: "normal"
+      });
+      return JSON.stringify({
+        success: true,
+        status: "approved",
+        task_id: args.task_id,
+        message: "Review approved. Worker can now complete the task."
+      }, null, 2);
+    }
+    const attemptNumber = incrementAttempt(args.task_id);
+    const remaining = MAX_REVIEW_ATTEMPTS - attemptNumber;
+    if (remaining <= 0) {
+      const adapter = await getHiveAdapterSafe(args.project_key);
+      if (adapter) {
+        try {
+          await adapter.changeCellStatus(args.project_key, args.task_id, "blocked");
+        } catch {}
+      }
+      await sendSwarmMessage2({
+        projectPath: args.project_key,
+        fromAgent: "coordinator",
+        toAgents: [args.worker_id],
+        subject: `FAILED: ${args.task_id} - max review attempts reached`,
+        body: `## Task Failed ✗
+
+Maximum review attempts (${MAX_REVIEW_ATTEMPTS}) reached.
+
+**Last Issues:**
+${parsedIssues.map((i) => `- ${i.file}${i.line ? `:${i.line}` : ""}: ${i.issue}`).join(`
+`)}
+
+The task has been marked as blocked. A human or different approach is needed.`,
+        threadId: epicId,
+        importance: "urgent"
+      });
+      return JSON.stringify({
+        success: true,
+        status: "needs_changes",
+        task_failed: true,
+        task_id: args.task_id,
+        attempt: attemptNumber,
+        remaining_attempts: 0,
+        message: `Task failed after ${MAX_REVIEW_ATTEMPTS} review attempts`
+      }, null, 2);
+    }
+    const issuesList = parsedIssues.map((i) => {
+      let line = `- **${i.file}**`;
+      if (i.line)
+        line += `:${i.line}`;
+      line += `: ${i.issue}`;
+      if (i.suggestion)
+        line += `
+  → ${i.suggestion}`;
+      return line;
+    }).join(`
+`);
+    await sendSwarmMessage2({
+      projectPath: args.project_key,
+      fromAgent: "coordinator",
+      toAgents: [args.worker_id],
+      subject: `NEEDS CHANGES: ${args.task_id} (attempt ${attemptNumber}/${MAX_REVIEW_ATTEMPTS})`,
+      body: `## Review: Changes Needed
+
+${args.summary || "Please address the following issues:"}
+
+**Issues:**
+${issuesList}
+
+**Remaining attempts:** ${remaining}
+
+Please fix these issues and request another review.`,
+      threadId: epicId,
+      importance: "high"
+    });
+    return JSON.stringify({
+      success: true,
+      status: "needs_changes",
+      task_id: args.task_id,
+      attempt: attemptNumber,
+      remaining_attempts: remaining,
+      issues: parsedIssues,
+      message: `Feedback sent. ${remaining} attempt(s) remaining.`
+    }, null, 2);
+  }
+});
+var reviewStatus = new Map;
+function markReviewApproved(taskId) {
+  reviewStatus.set(taskId, { approved: true, timestamp: Date.now() });
+  clearAttempts(taskId);
+}
+function getReviewStatus(taskId) {
+  const status = reviewStatus.get(taskId);
+  return {
+    reviewed: status !== undefined,
+    approved: status?.approved ?? false,
+    attempt_count: getAttemptCount(taskId),
+    remaining_attempts: getRemainingAttempts(taskId)
+  };
+}
+var reviewTools = {
+  swarm_review,
+  swarm_review_feedback
+};
+
+// src/swarm-orchestrate.ts
 async function queryEpicSubtasks(epicId) {
   const beadsAvailable = await isToolAvailable("beads");
   if (!beadsAvailable) {
@@ -31985,7 +32790,8 @@ var globalStrikeStorage = new InMemoryStrikeStorage;
 var swarm_init = tool({
   description: "Initialize swarm session: discovers available skills, checks tool availability. ALWAYS call at swarm start.",
   args: {
-    project_path: tool.schema.string().optional().describe("Project path (for Agent Mail init)")
+    project_path: tool.schema.string().optional().describe("Project path (for Agent Mail init)"),
+    isolation: tool.schema.enum(["worktree", "reservation"]).optional().default("reservation").describe("Isolation mode: 'worktree' for git worktree isolation (requires clean git state), 'reservation' for file reservations (default)")
   },
   async execute(args) {
     const availability = await checkAllTools();
@@ -32027,8 +32833,39 @@ var swarm_init = tool({
     } else {
       skillsGuidance = "No skills found. Add skills to .opencode/skills/ or .claude/skills/ for specialized guidance.";
     }
+    const isolationMode = args.isolation ?? "reservation";
+    let isolationInfo = {
+      mode: isolationMode,
+      available: true
+    };
+    if (isolationMode === "worktree" && args.project_path) {
+      const worktreeCheck = await canUseWorktreeIsolation(args.project_path);
+      if (worktreeCheck.canUse) {
+        const startCommit = await getStartCommit(args.project_path);
+        isolationInfo = {
+          mode: "worktree",
+          available: true,
+          start_commit: startCommit ?? undefined
+        };
+      } else {
+        isolationInfo = {
+          mode: "reservation",
+          available: false,
+          reason: `Worktree mode unavailable: ${worktreeCheck.reason}. Falling back to reservation mode.`
+        };
+        warnings.push(`⚠️  Worktree isolation unavailable: ${worktreeCheck.reason}. Using file reservations instead.`);
+      }
+    } else if (isolationMode === "worktree" && !args.project_path) {
+      isolationInfo = {
+        mode: "reservation",
+        available: false,
+        reason: "Worktree mode requires project_path. Falling back to reservation mode."
+      };
+      warnings.push("⚠️  Worktree isolation requires project_path. Using file reservations instead.");
+    }
     return JSON.stringify({
       ready: true,
+      isolation: isolationInfo,
       tool_availability: Object.fromEntries(Array.from(availability.entries()).map(([k, v]) => [
         k,
         {
@@ -32042,7 +32879,8 @@ var swarm_init = tool({
       recommendations: {
         skills: skillsGuidance,
         beads: beadsAvailable ? "✓ Use beads for all task tracking" : "Install beads: npm i -g @joelhooks/beads",
-        agent_mail: agentMailAvailable2 ? "✓ Use Agent Mail for coordination" : "Start Agent Mail: agent-mail serve"
+        agent_mail: agentMailAvailable2 ? "✓ Use Agent Mail for coordination" : "Start Agent Mail: agent-mail serve",
+        isolation: isolationInfo.mode === "worktree" ? "✓ Using git worktree isolation" : "✓ Using file reservation isolation"
       },
       report
     }, null, 2);
@@ -32134,7 +32972,7 @@ var swarm_progress = tool({
       await Bun.$`bd update ${args.bead_id} --status ${beadStatus} --json`.quiet().nothrow();
     }
     const epicId = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
-    await sendSwarmMessage2({
+    await sendSwarmMessage3({
       projectPath: args.project_key,
       fromAgent: args.agent_name,
       toAgents: [],
@@ -32202,7 +33040,7 @@ ${args.files_affected.map((f) => `- \`${f}\``).join(`
     ].filter(Boolean).join(`
 `);
     const mailImportance = args.importance === "blocker" ? "urgent" : args.importance === "warning" ? "high" : "normal";
-    await sendSwarmMessage2({
+    await sendSwarmMessage3({
       projectPath: args.project_path,
       fromAgent: args.agent_name,
       toAgents: [],
@@ -32237,10 +33075,42 @@ var swarm_complete = tool({
     planned_files: tool.schema.array(tool.schema.string()).optional().describe("Files that were originally planned to be modified"),
     start_time: tool.schema.number().optional().describe("Task start timestamp (Unix ms) for duration calculation"),
     error_count: tool.schema.number().optional().describe("Number of errors encountered during task"),
-    retry_count: tool.schema.number().optional().describe("Number of retry attempts during task")
+    retry_count: tool.schema.number().optional().describe("Number of retry attempts during task"),
+    skip_review: tool.schema.boolean().optional().describe("Skip review gate check (default: false). Use only for tasks that don't require coordinator review.")
   },
   async execute(args, _ctx) {
     const epicId = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
+    if (!args.skip_review) {
+      const reviewStatusResult = getReviewStatus(args.bead_id);
+      if (!reviewStatusResult.approved) {
+        if (!reviewStatusResult.reviewed) {
+          return JSON.stringify({
+            success: false,
+            error: "Review required before completion",
+            review_status: reviewStatusResult,
+            hint: `This task requires coordinator review before completion.
+
+**Next steps:**
+1. Request review with swarm_review(project_key="${args.project_key}", epic_id="${epicId}", task_id="${args.bead_id}", files_touched=[...])
+2. Wait for coordinator to review and approve with swarm_review_feedback
+3. Once approved, call swarm_complete again
+
+Or use skip_review=true to bypass (not recommended for production work).`
+          }, null, 2);
+        }
+        return JSON.stringify({
+          success: false,
+          error: "Review not approved",
+          review_status: reviewStatusResult,
+          hint: `Task was reviewed but not approved. ${reviewStatusResult.remaining_attempts} attempt(s) remaining.
+
+**Next steps:**
+1. Address the feedback from the reviewer
+2. Request another review with swarm_review
+3. Once approved, call swarm_complete again`
+        }, null, 2);
+      }
+    }
     try {
       const projectKey = args.project_key.replace(/\//g, "-").replace(/\\/g, "-");
       let agentRegistered = false;
@@ -32335,7 +33205,7 @@ Continuing with completion, but this should be fixed for future subtasks.`;
         const isNotFoundError = stderrOutput.includes("not found") || stderrOutput.includes("does not exist");
         return JSON.stringify({
           success: false,
-          error: "Failed to close bead",
+          error: "Failed to close cell",
           failed_step: "bd close",
           details: stderrOutput || stdoutOutput || "Unknown error from bd close command",
           bead_id: args.bead_id,
@@ -32344,15 +33214,15 @@ Continuing with completion, but this should be fixed for future subtasks.`;
             steps: isNoDatabaseError ? [
               `1. Verify project_key is correct: "${args.project_key}"`,
               `2. Check .beads/ exists in that directory`,
-              `3. Bead ID prefix "${args.bead_id.split("-")[0]}" should match project`,
-              `4. Try: beads_close(id="${args.bead_id}", reason="...")`
+              `3. Cell ID prefix "${args.bead_id.split("-")[0]}" should match project`,
+              `4. Try: hive_close(id="${args.bead_id}", reason="...")`
             ] : [
-              `1. Check bead exists: bd show ${args.bead_id}`,
-              `2. Check bead status (might already be closed): beads_query()`,
-              `3. If bead is blocked, unblock first: beads_update(id="${args.bead_id}", status="in_progress")`,
-              `4. Try closing directly: beads_close(id="${args.bead_id}", reason="...")`
+              `1. Check cell exists: bd show ${args.bead_id}`,
+              `2. Check cell status (might already be closed): hive_query()`,
+              `3. If cell is blocked, unblock first: hive_update(id="${args.bead_id}", status="in_progress")`,
+              `4. Try closing directly: hive_close(id="${args.bead_id}", reason="...")`
             ],
-            hint: isNoDatabaseError ? `The project_key "${args.project_key}" doesn't have a .beads/ directory. Make sure you're using the correct project path.` : isNotFoundError ? `Bead "${args.bead_id}" not found. It may have been closed already or the ID is incorrect.` : "If bead is in 'blocked' status, you must change it to 'in_progress' or 'open' before closing."
+            hint: isNoDatabaseError ? `The project_key "${args.project_key}" doesn't have a .beads/ directory. Make sure you're using the correct project path.` : isNotFoundError ? `Cell "${args.bead_id}" not found. It may have been closed already or the ID is incorrect.` : "If cell is in 'blocked' status, you must change it to 'in_progress' or 'open' before closing."
           }
         }, null, 2);
       }
@@ -32420,7 +33290,7 @@ Continuing with completion, but this should be fixed for future subtasks.`;
       let messageSent = false;
       let messageError;
       try {
-        await sendSwarmMessage2({
+        await sendSwarmMessage3({
           projectPath: args.project_key,
           fromAgent: args.agent_name,
           toAgents: [],
@@ -32530,14 +33400,14 @@ ${errorStack.slice(0, 1000)}
         "",
         `### Recovery Actions`,
         "1. Check error message for specific issue",
-        "2. Review failed step (UBS scan, typecheck, bead close, etc.)",
+        "2. Review failed step (UBS scan, typecheck, cell close, etc.)",
         "3. Fix underlying issue or use skip flags if appropriate",
         "4. Retry swarm_complete after fixing"
       ].filter(Boolean).join(`
 `);
       let notificationSent = false;
       try {
-        await sendSwarmMessage2({
+        await sendSwarmMessage3({
           projectPath: args.project_key,
           fromAgent: args.agent_name,
           toAgents: [],
@@ -32575,7 +33445,7 @@ ${errorStack.slice(0, 1000)}
           common_fixes: {
             "Verification Gate": "Use skip_verification=true to bypass (not recommended)",
             "UBS scan": "Use skip_ubs_scan=true to bypass",
-            "Bead close": "Check bead status with beads_query(), may need beads_update() first",
+            "Cell close": "Check cell status with hive_query(), may need hive_update() first",
             "Self-evaluation": "Check evaluation JSON format matches EvaluationSchema"
           }
         }
@@ -32674,7 +33544,7 @@ var swarm_record_outcome = tool({
 var swarm_accumulate_error = tool({
   description: "Record an error during subtask execution. Errors feed into retry prompts.",
   args: {
-    bead_id: tool.schema.string().describe("Bead ID where error occurred"),
+    bead_id: tool.schema.string().describe("Cell ID where error occurred"),
     error_type: tool.schema.enum(["validation", "timeout", "conflict", "tool_failure", "unknown"]).describe("Category of error"),
     message: tool.schema.string().describe("Human-readable error message"),
     stack_trace: tool.schema.string().optional().describe("Stack trace for debugging"),
@@ -32701,7 +33571,7 @@ var swarm_accumulate_error = tool({
 var swarm_get_error_context = tool({
   description: "Get accumulated errors for a bead. Returns formatted context for retry prompts.",
   args: {
-    bead_id: tool.schema.string().describe("Bead ID to get errors for"),
+    bead_id: tool.schema.string().describe("Cell ID to get errors for"),
     include_resolved: tool.schema.boolean().optional().describe("Include resolved errors (default: false)")
   },
   async execute(args) {
@@ -32737,7 +33607,7 @@ var swarm_resolve_error = tool({
 var swarm_check_strikes = tool({
   description: "Check 3-strike status for a bead. Records failures, detects architectural problems, generates architecture review prompts.",
   args: {
-    bead_id: tool.schema.string().describe("Bead ID to check"),
+    bead_id: tool.schema.string().describe("Cell ID to check"),
     action: tool.schema.enum(["check", "add_strike", "clear", "get_prompt"]).describe("Action: check count, add strike, clear strikes, or get prompt"),
     attempt: tool.schema.string().optional().describe("Description of fix attempt (required for add_strike)"),
     reason: tool.schema.string().optional().describe("Why the fix failed (required for add_strike)")
@@ -33002,7 +33872,7 @@ ${args.files_context.map((f) => `- \`${f}\``).join(`
 *Learned from swarm execution on ${new Date().toISOString().split("T")[0]}*`;
       const { getSkill: getSkill2, invalidateSkillsCache: invalidateSkillsCache2 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
       const { mkdir: mkdir2, writeFile: writeFile2 } = await import("node:fs/promises");
-      const { join: join6 } = await import("node:path");
+      const { join: join7 } = await import("node:path");
       const existing = await getSkill2(args.skill_name);
       if (existing) {
         return JSON.stringify({
@@ -33013,8 +33883,8 @@ ${args.files_context.map((f) => `- \`${f}\``).join(`
           suggestion: "Use skills_update to add to existing skill, or choose a different name"
         }, null, 2);
       }
-      const skillDir = join6(process.cwd(), ".opencode", "skills", args.skill_name);
-      const skillPath = join6(skillDir, "SKILL.md");
+      const skillDir = join7(process.cwd(), ".opencode", "skills", args.skill_name);
+      const skillPath = join7(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${args.skill_name}`,
@@ -34184,14 +35054,14 @@ var DEFAULT_GUARDRAIL_CONFIG = {
     cass_stats: 8000
   },
   skipTools: [
-    "beads_create",
-    "beads_create_epic",
-    "beads_query",
-    "beads_update",
-    "beads_close",
-    "beads_start",
-    "beads_ready",
-    "beads_sync",
+    "hive_create",
+    "hive_create_epic",
+    "hive_query",
+    "hive_update",
+    "hive_close",
+    "hive_start",
+    "hive_ready",
+    "hive_sync",
     "agentmail_init",
     "agentmail_send",
     "agentmail_inbox",
@@ -34211,7 +35081,7 @@ var DEFAULT_GUARDRAIL_CONFIG = {
     "structured_validate",
     "structured_parse_evaluation",
     "structured_parse_decomposition",
-    "structured_parse_bead_tree",
+    "structured_parse_cell_tree",
     "swarm_select_strategy",
     "swarm_plan_prompt",
     "swarm_decompose",
@@ -34395,7 +35265,7 @@ function analyzeTodoWrite(args) {
       warning: `⚠️  This looks like a multi-file implementation plan (${fileModificationCount}/${todos.length} items are file modifications).
 
 Consider using swarm instead:
-  swarm_decompose → beads_create_epic → parallel task spawns
+  swarm_decompose → hive_create_epic → parallel task spawns
 
 TodoWrite is for tracking progress, not parallelizable implementation work.
 Swarm workers can complete these ${fileModificationCount} tasks in parallel.
@@ -34876,9 +35746,88 @@ async function resetStorage() {
 
 // src/index.ts
 init_skills();
+
+// src/compaction-hook.ts
+var SWARM_COMPACTION_CONTEXT = `## \uD83D\uDC1D SWARM ACTIVE - Keep Cooking
+
+You are the **COORDINATOR** of an active swarm. Context was compacted but the swarm is still running.
+
+**YOUR JOB:** Keep orchestrating. Spawn agents. Monitor progress. Unblock work. Ship it.
+
+### Preserve in Summary
+
+Extract from session context:
+
+1. **Epic & Subtasks** - IDs, titles, status, file assignments
+2. **What's Running** - Which agents are active, what they're working on  
+3. **What's Blocked** - Blockers and what's needed to unblock
+4. **What's Done** - Completed work and any follow-ups needed
+5. **What's Next** - Pending subtasks ready to spawn
+
+### Summary Format
+
+\`\`\`
+## \uD83D\uDC1D Swarm State
+
+**Epic:** <bd-xxx> - <title>
+**Project:** <path>
+**Progress:** X/Y subtasks complete
+
+**Active:**
+- <bd-xxx>: <title> [in_progress] → <agent> working on <files>
+
+**Blocked:**
+- <bd-xxx>: <title> - BLOCKED: <reason>
+
+**Completed:**
+- <bd-xxx>: <title> ✓
+
+**Ready to Spawn:**
+- <bd-xxx>: <title> (files: <...>)
+\`\`\`
+
+### On Resume - IMMEDIATELY
+
+1. \`swarm_status(epic_id="<epic>", project_key="<path>")\` - Get current state
+2. \`swarmmail_inbox(limit=5)\` - Check for agent messages
+3. **Spawn ready subtasks** - Don't wait, fire them off
+4. **Unblock blocked work** - Resolve dependencies, reassign if needed
+5. **Collect completed work** - Close done subtasks, verify quality
+
+### Keep the Swarm Cooking
+
+- **Spawn aggressively** - If a subtask is ready and unblocked, spawn an agent
+- **Monitor actively** - Check status, read messages, respond to blockers
+- **Close the loop** - When all subtasks done, verify and close the epic
+- **Don't stop** - The swarm runs until the epic is closed
+
+**You are not waiting for instructions. You are the coordinator. Coordinate.**
+`;
+async function hasSwarmSign() {
+  try {
+    const projectKey = getHiveWorkingDirectory();
+    const adapter = await getHiveAdapter(projectKey);
+    const cells = await adapter.queryCells(projectKey, {});
+    if (!Array.isArray(cells))
+      return false;
+    return cells.some((c) => c.status === "in_progress" || c.status === "open" && c.parent_id || c.type === "epic" && c.status !== "closed");
+  } catch {
+    return false;
+  }
+}
+function createCompactionHook() {
+  return async (_input, output) => {
+    const hasSign = await hasSwarmSign();
+    if (hasSign) {
+      output.context.push(SWARM_COMPACTION_CONTEXT);
+    }
+  };
+}
+
+// src/index.ts
 var SwarmPlugin = async (input) => {
   const { $, directory } = input;
-  setBeadsWorkingDirectory(directory);
+  setHiveWorkingDirectory(directory);
   setSkillsProjectDirectory(directory);
   setAgentMailProjectDirectory(directory);
   setSwarmMailProjectDirectory(directory);
@@ -34913,10 +35862,12 @@ var SwarmPlugin = async (input) => {
   }
   return {
     tool: {
-      ...beadsTools,
+      ...hiveTools,
       ...swarmMailTools,
       ...structuredTools,
       ...swarmTools,
+      ...worktreeTools,
+      ...reviewTools,
       ...repoCrawlTools,
       ...skillsTools,
       ...mandateTools
@@ -34965,7 +35916,7 @@ var SwarmPlugin = async (input) => {
       if (toolName === "swarm_complete" && activeAgentMailState) {
         await releaseReservations();
       }
-      if (toolName === "beads_close") {
+      if (toolName === "hive_close" || toolName === "hive_close") {
         $`bd sync`.quiet().nothrow();
       }
     }
@@ -34973,10 +35924,12 @@ var SwarmPlugin = async (input) => {
 };
 var src_default = SwarmPlugin;
 var allTools = {
-  ...beadsTools,
+  ...hiveTools,
   ...swarmMailTools,
   ...structuredTools,
   ...swarmTools,
+  ...worktreeTools,
+  ...reviewTools,
   ...repoCrawlTools,
   ...skillsTools,
   ...mandateTools
@@ -34996,6 +35949,7 @@ export {
   setStorage,
   setSkillsProjectDirectory,
   setMandateStorage,
+  setHiveWorkingDirectory,
   setBeadsWorkingDirectory,
   setAgentMailProjectDirectory,
   selectStrategy,
@@ -35014,11 +35968,22 @@ export {
   isSemanticMemoryAvailable,
   isProjectNotFoundError,
   isEpicEvent,
+  isCellEventType,
   isBeadEventType,
   isAgentNotFoundError,
   isAgentEvent,
   invalidateSkillsCache,
   ifToolAvailable,
+  hive_update,
+  hive_sync,
+  hive_start,
+  hive_ready,
+  hive_query,
+  hive_link_thread,
+  hive_create_epic,
+  hive_create,
+  hive_close,
+  hiveTools,
   guardrailOutput,
   groupByTransition,
   getToolAvailability,
@@ -35029,6 +35994,9 @@ export {
   getSkill,
   getSchemaByName,
   getMandateStorage,
+  getHiveWorkingDirectory,
+  getHiveAdapter,
+  getCellIdFromEvent,
   getBeadsWorkingDirectory,
   getBeadsAdapter,
   getBeadIdFromEvent,
@@ -35050,6 +36018,8 @@ export {
   createStorage,
   createMetrics,
   createMandateStorage,
+  createCompactionHook,
+  createCellEvent,
   createBeadEvent,
   createAgentMailError,
   clearSessionState,
@@ -35089,6 +36059,7 @@ export {
   SemanticMemoryStorage,
   SemanticMemoryMandateStorage,
   ScoreCalculationResultSchema,
+  SWARM_COMPACTION_CONTEXT,
   SUBTASK_PROMPT_V2,
   STRATEGIES,
   RepoCrawlError,
@@ -35101,6 +36072,8 @@ export {
   MandateContentTypeSchema,
   InMemoryStorage,
   InMemoryMandateStorage,
+  HiveValidationError,
+  HiveError,
   FileReservationConflictError,
   EvaluationSchema,
   EvaluationRequestSchema,
@@ -35119,6 +36092,35 @@ export {
   CriterionEvaluationSchema,
   CreateSwarmContextArgsSchema,
   CreateMandateArgsSchema,
+  CellWorkStartedEventSchema,
+  CellUpdatedEventSchema,
+  CellUpdateArgsSchema,
+  CellTypeSchema,
+  CellTreeSchema,
+  CellStatusSchema,
+  CellStatusChangedEventSchema,
+  CellSchema,
+  CellReopenedEventSchema,
+  CellQueryArgsSchema,
+  CellLabelRemovedEventSchema,
+  CellLabelAddedEventSchema,
+  CellEventSchema,
+  CellEpicClosureEligibleEventSchema,
+  CellEpicChildRemovedEventSchema,
+  CellEpicChildAddedEventSchema,
+  CellDependencySchema,
+  CellDependencyRemovedEventSchema,
+  CellDependencyAddedEventSchema,
+  CellDeletedEventSchema,
+  CellCreatedEventSchema,
+  CellCreateArgsSchema,
+  CellCompactedEventSchema,
+  CellCommentUpdatedEventSchema,
+  CellCommentDeletedEventSchema,
+  CellCommentAddedEventSchema,
+  CellClosedEventSchema,
+  CellCloseArgsSchema,
+  CellAssignedEventSchema,
   CastVoteArgsSchema,
   BeadWorkStartedEventSchema,
   BeadValidationError,
@@ -35151,6 +36153,7 @@ export {
   BeadClosedEventSchema,
   BeadCloseArgsSchema,
   BeadAssignedEventSchema,
+  BaseCellEventSchema,
   BaseBeadEventSchema,
   AgentProgressSchema,
   AgentMailNotInitializedError,