@automagik/genie 0.260202.1833 → 0.260202.1901

package/src/term-commands/daemon.ts

@@ -0,0 +1,176 @@
+/**
+ * Daemon command - Manage beads daemon
+ *
+ * Usage:
+ *   term daemon start      - Start beads daemon (auto-commit, auto-sync)
+ *   term daemon stop       - Stop beads daemon
+ *   term daemon status     - Show daemon status
+ *   term daemon restart    - Restart daemon
+ *
+ * Options:
+ *   --auto-commit         - Enable auto-commit (default: true for start)
+ *   --auto-push           - Enable auto-push to remote
+ *   --json                - Output as JSON
+ */
+
+import * as beadsRegistry from '../lib/beads-registry.js';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface DaemonStartOptions {
+  autoCommit?: boolean;
+  autoPush?: boolean;
+}
+
+export interface DaemonStatusOptions {
+  json?: boolean;
+}
+
+// ============================================================================
+// Commands
+// ============================================================================
+
+/**
+ * Start the beads daemon
+ */
+export async function startCommand(options: DaemonStartOptions = {}): Promise<void> {
+  try {
+    // Check if already running
+    const status = await beadsRegistry.checkDaemonStatus();
+    if (status.running) {
+      console.log('ℹ️  Daemon is already running');
+      if (status.pid) {
+        console.log(`   PID: ${status.pid}`);
+      }
+      return;
+    }
+
+    console.log('🚀 Starting beads daemon...');
+    const started = await beadsRegistry.startDaemon({
+      autoCommit: options.autoCommit !== false, // Default to true
+      autoPush: options.autoPush,
+    });
+
+    if (started) {
+      console.log('   ✅ Daemon started');
+
+      // Show updated status
+      const newStatus = await beadsRegistry.checkDaemonStatus();
+      if (newStatus.pid) {
+        console.log(`   PID: ${newStatus.pid}`);
+      }
+      if (newStatus.autoCommit) {
+        console.log('   Auto-commit: enabled');
+      }
+      if (newStatus.autoPush) {
+        console.log('   Auto-push: enabled');
+      }
+    } else {
+      console.error('❌ Failed to start daemon');
+      console.log('   Check `bd daemon status` for details');
+      process.exit(1);
+    }
+  } catch (error: any) {
+    console.error(`❌ Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Stop the beads daemon
+ */
+export async function stopCommand(): Promise<void> {
+  try {
+    // Check if running
+    const status = await beadsRegistry.checkDaemonStatus();
+    if (!status.running) {
+      console.log('ℹ️  Daemon is not running');
+      return;
+    }
+
+    console.log('🛑 Stopping beads daemon...');
+    const stopped = await beadsRegistry.stopDaemon();
+
+    if (stopped) {
+      console.log('   ✅ Daemon stopped');
+    } else {
+      console.error('❌ Failed to stop daemon');
+      process.exit(1);
+    }
+  } catch (error: any) {
+    console.error(`❌ Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Show daemon status
+ */
+export async function statusCommand(options: DaemonStatusOptions = {}): Promise<void> {
+  try {
+    const status = await beadsRegistry.checkDaemonStatus();
+
+    if (options.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+
+    console.log('Beads Daemon Status');
+    console.log('───────────────────');
+    console.log(`Running: ${status.running ? '✅ yes' : '❌ no'}`);
+
+    if (status.running) {
+      if (status.pid) {
+        console.log(`PID: ${status.pid}`);
+      }
+      if (status.lastSync) {
+        console.log(`Last sync: ${status.lastSync}`);
+      }
+      if (status.autoCommit !== undefined) {
+        console.log(`Auto-commit: ${status.autoCommit ? 'enabled' : 'disabled'}`);
+      }
+      if (status.autoPush !== undefined) {
+        console.log(`Auto-push: ${status.autoPush ? 'enabled' : 'disabled'}`);
+      }
+    } else {
+      console.log('\nRun `term daemon start` to start the daemon');
+    }
+  } catch (error: any) {
+    console.error(`❌ Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Restart the beads daemon
+ */
+export async function restartCommand(options: DaemonStartOptions = {}): Promise<void> {
+  try {
+    // Check if running and stop
+    const status = await beadsRegistry.checkDaemonStatus();
+    if (status.running) {
+      console.log('🛑 Stopping beads daemon...');
+      await beadsRegistry.stopDaemon();
+      console.log('   ✅ Stopped');
+    }
+
+    // Start with new options
+    console.log('🚀 Starting beads daemon...');
+    const started = await beadsRegistry.startDaemon({
+      autoCommit: options.autoCommit !== false,
+      autoPush: options.autoPush,
+    });
+
+    if (started) {
+      console.log('   ✅ Daemon restarted');
+    } else {
+      console.error('❌ Failed to restart daemon');
+      process.exit(1);
+    }
+  } catch (error: any) {
+    console.error(`❌ Error: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/term-commands/kill.ts

@@ -12,10 +12,14 @@
 import { confirm } from '@inquirer/prompts';
 import * as tmux from '../lib/tmux.js';
 import * as registry from '../lib/worker-registry.js';
+import * as beadsRegistry from '../lib/beads-registry.js';
 import { WorktreeManager } from '../lib/worktree.js';
 import { join } from 'path';
 import { homedir } from 'os';
 
+// Use beads registry when enabled
+const useBeads = beadsRegistry.isBeadsRegistryEnabled();
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -49,8 +53,22 @@ async function killWorkerPane(paneId: string): Promise<boolean> {
 
 /**
  * Remove worktree
+ * Uses bd worktree when beads registry is enabled
+ * Falls back to WorktreeManager otherwise
  */
 async function removeWorktree(taskId: string, repoPath: string): Promise<boolean> {
+  // Try bd worktree first when beads is enabled
+  if (useBeads) {
+    try {
+      const removed = await beadsRegistry.removeWorktree(taskId);
+      if (removed) return true;
+      // Fall through to WorktreeManager if bd worktree fails
+    } catch {
+      // Fall through
+    }
+  }
+
+  // Fallback to WorktreeManager
   try {
     const manager = new WorktreeManager({
       baseDir: WORKTREE_BASE,
@@ -77,19 +95,32 @@ export async function killCommand(
   options: KillOptions = {}
 ): Promise<void> {
   try {
-    // Find worker by ID or pane
+    // Find worker by ID or pane (check both registries during transition)
     let worker = await registry.get(target);
 
+    if (!worker && useBeads) {
+      // Try beads registry
+      worker = await beadsRegistry.getWorker(target);
+    }
+
     if (!worker) {
       // Try finding by pane ID
       worker = await registry.findByPane(target);
     }
 
+    if (!worker && useBeads) {
+      worker = await beadsRegistry.findByPane(target);
+    }
+
     if (!worker) {
       // Try finding by task ID
       worker = await registry.findByTask(target);
     }
 
+    if (!worker && useBeads) {
+      worker = await beadsRegistry.findByTask(target);
+    }
+
     if (!worker) {
       console.error(`❌ Worker "${target}" not found.`);
       console.log(`   Run \`term workers\` to see active workers.`);
@@ -127,7 +158,19 @@ export async function killCommand(
       }
     }
 
-    // 3. Unregister worker
+    // 3. Unregister worker from both registries
+    if (useBeads) {
+      try {
+        // Unbind work from agent
+        await beadsRegistry.unbindWork(worker.id);
+        // Set agent state to error (killed, not done)
+        await beadsRegistry.setAgentState(worker.id, 'error');
+        // Delete agent bead
+        await beadsRegistry.deleteAgent(worker.id);
+      } catch {
+        // Non-fatal if beads cleanup fails
+      }
+    }
     await registry.unregister(worker.id);
     console.log(`   ✅ Worker unregistered`);
 

package/src/term-commands/split.ts

@@ -38,6 +38,9 @@ export async function splitSessionPane(
     // Determine direction
     const splitDirection = direction === 'h' ? 'horizontal' : 'vertical';
 
+    // Get source pane's current working directory
+    const sourcePath = await tmux.executeTmux(`display-message -p -t '${paneId}' '#{pane_current_path}'`);
+
     // Handle workspace and worktree options
     let workingDir: string | undefined;
 
@@ -62,20 +65,18 @@ export async function splitSessionPane(
       workingDir = manager.getWorktreePath(options.worktree);
     } else if (options.workspace) {
       workingDir = options.workspace;
+    } else {
+      // Default to source pane's current directory
+      workingDir = sourcePath.trim() || undefined;
     }
 
-    // Split pane
-    const newPane = await tmux.splitPane(paneId, splitDirection);
+    // Split pane with working directory (tmux -c flag handles this natively)
+    const newPane = await tmux.splitPane(paneId, splitDirection, undefined, workingDir);
     if (!newPane) {
       console.error('❌ Failed to split pane');
       process.exit(1);
     }
 
-    // Change to working directory if specified
-    if (workingDir && newPane) {
-      await tmux.executeTmux(`send-keys -t '${newPane.id}' 'cd ${workingDir}' Enter`);
-    }
-
     console.log(`✅ Pane split ${splitDirection}ly in session "${sessionName}"`);
     if (workingDir) {
       console.log(`   Working directory: ${workingDir}`);

package/src/term-commands/work.ts

@@ -15,11 +15,15 @@
 import { $ } from 'bun';
 import * as tmux from '../lib/tmux.js';
 import * as registry from '../lib/worker-registry.js';
+import * as beadsRegistry from '../lib/beads-registry.js';
 import { WorktreeManager } from '../lib/worktree.js';
 import { EventMonitor, detectState } from '../lib/orchestrator/index.js';
 import { join } from 'path';
 import { homedir } from 'os';
 
+// Use beads registry when enabled
+const useBeads = beadsRegistry.isBeadsRegistryEnabled();
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -135,11 +139,36 @@ async function getCurrentSession(): Promise<string | null> {
 
 /**
  * Create worktree for worker
+ * Uses bd worktree when beads registry is enabled (auto .beads redirect)
+ * Falls back to WorktreeManager otherwise
  */
 async function createWorktree(
   taskId: string,
   repoPath: string
 ): Promise<string | null> {
+  // Try bd worktree first when beads is enabled
+  if (useBeads) {
+    try {
+      // Check if worktree exists via beads
+      const existing = await beadsRegistry.getWorktree(taskId);
+      if (existing) {
+        console.log(`ℹ️  Worktree for ${taskId} already exists`);
+        return existing.path;
+      }
+
+      // Create via bd worktree (includes .beads redirect)
+      const info = await beadsRegistry.createWorktree(taskId);
+      if (info) {
+        return info.path;
+      }
+      // Fall through to WorktreeManager if bd worktree fails
+      console.log(`⚠️  bd worktree failed, falling back to git worktree`);
+    } catch (error: any) {
+      console.log(`⚠️  bd worktree error: ${error.message}, falling back`);
+    }
+  }
+
+  // Fallback to WorktreeManager
   try {
     const manager = new WorktreeManager({
       baseDir: WORKTREE_BASE,
@@ -210,6 +239,7 @@ async function spawnWorkerPane(
 
 /**
  * Start monitoring worker state and update registry
+ * Updates both beads and JSON registry during transition
  */
 function startWorkerMonitoring(
   workerId: string,
@@ -250,6 +280,10 @@ function startWorkerMonitoring(
     }
 
     try {
+      // Update both registries during transition
+      if (useBeads) {
+        await beadsRegistry.updateState(workerId, newState);
+      }
       await registry.updateState(workerId, newState);
     } catch {
       // Ignore errors in background monitoring
@@ -258,6 +292,9 @@ function startWorkerMonitoring(
 
   monitor.on('poll_error', () => {
     // Pane may have been killed - unregister worker
+    if (useBeads) {
+      beadsRegistry.unregister(workerId).catch(() => {});
+    }
     registry.unregister(workerId).catch(() => {});
     monitor.stop();
   });
@@ -282,6 +319,20 @@ export async function workCommand(
     // Get current working directory as repo path
     const repoPath = process.cwd();
 
+    // Ensure beads daemon is running for auto-sync
+    if (useBeads) {
+      const daemonStatus = await beadsRegistry.checkDaemonStatus();
+      if (!daemonStatus.running) {
+        console.log('🔄 Starting beads daemon for auto-sync...');
+        const started = await beadsRegistry.startDaemon({ autoCommit: true });
+        if (started) {
+          console.log('   ✅ Daemon started');
+        } else {
+          console.log('   ⚠️  Daemon failed to start (non-fatal)');
+        }
+      }
+    }
+
     // 1. Resolve target
     let issue: BeadsIssue | null = null;
 
@@ -307,8 +358,13 @@ export async function workCommand(
 
     const taskId = issue.id;
 
-    // 2. Check not already assigned
-    const existingWorker = await registry.findByTask(taskId);
+    // 2. Check not already assigned (check both registries)
+    let existingWorker = useBeads
+      ? await beadsRegistry.findByTask(taskId)
+      : null;
+    if (!existingWorker) {
+      existingWorker = await registry.findByTask(taskId);
+    }
     if (existingWorker) {
       console.error(`❌ ${taskId} already has a worker (pane ${existingWorker.paneId})`);
       console.log(`   Run \`term kill ${existingWorker.id}\` first, or work on a different issue.`);
@@ -354,7 +410,7 @@ export async function workCommand(
 
     const { paneId } = paneResult;
 
-    // 7. Register worker
+    // 7. Register worker (write to both registries during transition)
     const worker: registry.Worker = {
       id: taskId,
       paneId,
@@ -368,6 +424,29 @@ export async function workCommand(
       repoPath,
     };
 
+    // Register in beads (creates agent bead)
+    if (useBeads) {
+      try {
+        const agentId = await beadsRegistry.ensureAgent(taskId, {
+          paneId,
+          session,
+          worktree: worktreePath,
+          repoPath,
+          taskId,
+          taskTitle: issue.title,
+        });
+
+        // Bind work to agent
+        await beadsRegistry.bindWork(taskId, taskId);
+
+        // Set initial state
+        await beadsRegistry.setAgentState(taskId, 'spawning');
+      } catch (error: any) {
+        console.log(`⚠️  Beads registration failed: ${error.message} (non-fatal)`);
+      }
+    }
+
+    // Also register in JSON registry (parallel operation during transition)
     await registry.register(worker);
 
     // 8. Start Claude in pane
@@ -385,7 +464,10 @@ When you're done, commit your changes and let me know.`;
 
     await tmux.executeCommand(paneId, prompt, false, false);
 
-    // 10. Update state to working
+    // 10. Update state to working (both registries)
+    if (useBeads) {
+      await beadsRegistry.setAgentState(taskId, 'working').catch(() => {});
+    }
     await registry.updateState(taskId, 'working');
 
     // 11. Start monitoring

package/src/term-commands/workers.ts

@@ -10,8 +10,12 @@
 import { $ } from 'bun';
 import * as tmux from '../lib/tmux.js';
 import * as registry from '../lib/worker-registry.js';
+import * as beadsRegistry from '../lib/beads-registry.js';
 import { detectState, stripAnsi } from '../lib/orchestrator/index.js';
 
+// Use beads registry when enabled
+const useBeads = beadsRegistry.isBeadsRegistryEnabled();
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -153,7 +157,30 @@ function formatElapsed(startedAt: string): string {
 
 export async function workersCommand(options: WorkersOptions = {}): Promise<void> {
   try {
-    const workers = await registry.list();
+    // Get workers from beads or JSON registry
+    // During transition, merge results from both
+    let workers: registry.Worker[] = [];
+
+    if (useBeads) {
+      try {
+        const beadsWorkers = await beadsRegistry.listWorkers();
+        workers = beadsWorkers;
+      } catch {
+        // Fallback to JSON registry
+        workers = await registry.list();
+      }
+    } else {
+      workers = await registry.list();
+    }
+
+    // Also check JSON registry for any workers not in beads
+    const jsonWorkers = await registry.list();
+    const beadsIds = new Set(workers.map(w => w.id));
+    for (const jw of jsonWorkers) {
+      if (!beadsIds.has(jw.id)) {
+        workers.push(jw);
+      }
+    }
 
     // Gather display data for each worker
     const displayData: WorkerDisplay[] = [];
@@ -166,10 +193,17 @@ export async function workersCommand(options: WorkersOptions = {}): Promise<void
         // Get live state from pane
         currentState = await getCurrentState(worker.paneId);
 
-        // Update registry if state differs
+        // Update both registries if state differs
         const mappedState = mapDisplayStateToRegistry(currentState);
         if (mappedState && mappedState !== worker.state) {
+          if (useBeads) {
+            // Update beads and send heartbeat
+            await beadsRegistry.updateState(worker.id, mappedState).catch(() => {});
+          }
           await registry.updateState(worker.id, mappedState);
+        } else if (useBeads) {
+          // Just send heartbeat even if state unchanged
+          await beadsRegistry.heartbeat(worker.id).catch(() => {});
         }
       } else {
         currentState = '💀 dead';

package/src/term.ts

@@ -20,6 +20,7 @@ import * as workCmd from './term-commands/work.js';
 import * as workersCmd from './term-commands/workers.js';
 import * as closeCmd from './term-commands/close.js';
 import * as killCmd from './term-commands/kill.js';
+import * as daemonCmd from './term-commands/daemon.js';
 
 const program = new Command();
 
@@ -40,7 +41,8 @@ Worker Orchestration:
   term work next      - Work on next ready issue
   term workers        - List all workers and states
   term close <bd-id>  - Close issue, cleanup worker
-  term kill <worker>  - Force kill a stuck worker`)
+  term kill <worker>  - Force kill a stuck worker
+  term daemon start   - Start beads daemon for auto-sync`)
   .version(VERSION);
 
 // Session management
@@ -297,6 +299,42 @@ program
     });
   });
 
+// Daemon management (beads auto-sync)
+const daemonProgram = program.command('daemon').description('Manage beads daemon for auto-sync');
+
+daemonProgram
+  .command('start')
+  .description('Start beads daemon (auto-commit, auto-sync)')
+  .option('--no-auto-commit', 'Disable auto-commit')
+  .option('--auto-push', 'Enable auto-push to remote')
+  .action(async (options: daemonCmd.DaemonStartOptions) => {
+    await daemonCmd.startCommand(options);
+  });
+
+daemonProgram
+  .command('stop')
+  .description('Stop beads daemon')
+  .action(async () => {
+    await daemonCmd.stopCommand();
+  });
+
+daemonProgram
+  .command('status')
+  .description('Show daemon status')
+  .option('--json', 'Output as JSON')
+  .action(async (options: daemonCmd.DaemonStatusOptions) => {
+    await daemonCmd.statusCommand(options);
+  });
+
+daemonProgram
+  .command('restart')
+  .description('Restart beads daemon')
+  .option('--no-auto-commit', 'Disable auto-commit')
+  .option('--auto-push', 'Enable auto-push to remote')
+  .action(async (options: daemonCmd.DaemonStartOptions) => {
+    await daemonCmd.restartCommand(options);
+  });
+
 // Orchestration commands (Claude Code automation)
 const orcProgram = program.command('orc').description('Orchestrate Claude Code sessions');