@automagik/genie 0.260202.1833 → 0.260203.43

package/src/term-commands/work.ts

@@ -9,16 +9,21 @@
  * Options:
  *   --no-worktree         - Use shared repo instead of worktree
  *   -s, --session <name>  - Target tmux session
- *   --focus               - Focus the worker pane (default: true)
+ *   --focus               - Focus the worker pane (default: false)
+ *   --resume              - Resume previous Claude session if available (default: true)
+ *   --no-resume           - Start fresh session even if previous exists
  */
 
 import { $ } from 'bun';
+import { randomUUID } from 'crypto';
 import * as tmux from '../lib/tmux.js';
 import * as registry from '../lib/worker-registry.js';
-import { WorktreeManager } from '../lib/worktree.js';
-import { EventMonitor, detectState } from '../lib/orchestrator/index.js';
+import * as beadsRegistry from '../lib/beads-registry.js';
+import { EventMonitor } from '../lib/orchestrator/index.js';
 import { join } from 'path';
-import { homedir } from 'os';
+
+// Use beads registry when enabled
+const useBeads = beadsRegistry.isBeadsRegistryEnabled();
 
 // ============================================================================
 // Types
@@ -29,12 +34,15 @@ export interface WorkOptions {
   session?: string;
   focus?: boolean;
   prompt?: string;
+  /** Resume previous Claude session if available */
+  resume?: boolean;
 }
 
 interface BeadsIssue {
   id: string;
   title: string;
   status: string;
+  description?: string;
   blockedBy?: string[];
 }
 
@@ -42,7 +50,8 @@ interface BeadsIssue {
 // Configuration
 // ============================================================================
 
-const WORKTREE_BASE = join(homedir(), '.local', 'share', 'term', 'worktrees');
+// Worktrees are created inside the project at .genie/worktrees/<taskId>
+const WORKTREE_DIR_NAME = '.genie/worktrees';
 
 // ============================================================================
 // Helper Functions
@@ -68,11 +77,15 @@ async function getBeadsIssue(id: string): Promise<BeadsIssue | null> {
   if (exitCode !== 0 || !stdout) return null;
 
   try {
-    const issue = JSON.parse(stdout);
+    const parsed = JSON.parse(stdout);
+    // bd show --json returns an array with single element
+    const issue = Array.isArray(parsed) ? parsed[0] : parsed;
+    if (!issue) return null;
     return {
       id: issue.id,
       title: issue.title || issue.description?.substring(0, 50) || 'Untitled',
       status: issue.status,
+      description: issue.description,
       blockedBy: issue.blockedBy || [],
     };
   } catch {
@@ -95,6 +108,7 @@ async function getNextReadyIssue(): Promise<BeadsIssue | null> {
         id: issue.id,
         title: issue.title || issue.description?.substring(0, 50) || 'Untitled',
         status: issue.status,
+        description: issue.description,
         blockedBy: issue.blockedBy || [],
       };
     }
@@ -134,27 +148,54 @@ async function getCurrentSession(): Promise<string | null> {
 }
 
 /**
- * Create worktree for worker
+ * Create worktree for worker in .genie/worktrees/<taskId>
+ * Creates a .genie redirect file so bd commands work in the worktree
  */
 async function createWorktree(
   taskId: string,
   repoPath: string
 ): Promise<string | null> {
+  const fs = await import('fs/promises');
+  const worktreeDir = join(repoPath, WORKTREE_DIR_NAME);
+  const worktreePath = join(worktreeDir, taskId);
+
+  // Ensure .genie/worktrees exists
   try {
-    const manager = new WorktreeManager({
-      baseDir: WORKTREE_BASE,
-      repoPath,
-    });
+    await fs.mkdir(worktreeDir, { recursive: true });
+  } catch {
+    // Directory may already exist
+  }
 
-    // Check if worktree already exists
-    if (await manager.worktreeExists(taskId)) {
+  // Check if worktree already exists
+  try {
+    const stat = await fs.stat(worktreePath);
+    if (stat.isDirectory()) {
       console.log(`ℹ️  Worktree for ${taskId} already exists`);
-      return manager.getWorktreePath(taskId);
+      return worktreePath;
+    }
+  } catch {
+    // Doesn't exist, will create
+  }
+
+  // Create worktree using git directly (with branch)
+  const branchName = `work/${taskId}`;
+  try {
+    // Create branch if it doesn't exist (ignore error if it already exists)
+    try {
+      await $`git -C ${repoPath} branch ${branchName}`.quiet();
+    } catch {
+      // Branch may already exist, that's ok
     }
 
-    // Create new worktree with branch
-    const info = await manager.createWorktree(taskId, true);
-    return info.path;
+    // Create worktree
+    await $`git -C ${repoPath} worktree add ${worktreePath} ${branchName}`.quiet();
+
+    // Set up .genie redirect so bd commands work in the worktree
+    const genieRedirect = join(worktreePath, '.genie');
+    await fs.mkdir(genieRedirect, { recursive: true });
+    await fs.writeFile(join(genieRedirect, 'redirect'), join(repoPath, '.genie'));
+
+    return worktreePath;
   } catch (error: any) {
     console.error(`⚠️  Failed to create worktree: ${error.message}`);
     return null;
@@ -162,14 +203,71 @@ async function createWorktree(
 }
 
 /**
- * Spawn Claude worker in new pane
+ * Remove worktree for a worker
+ */
+async function removeWorktree(taskId: string, repoPath: string): Promise<void> {
+  const worktreePath = join(repoPath, WORKTREE_DIR_NAME, taskId);
+
+  try {
+    // Remove worktree
+    await $`git -C ${repoPath} worktree remove ${worktreePath} --force`.quiet();
+  } catch {
+    // Ignore errors - worktree may already be removed
+  }
+}
+
+/**
+ * Wait for Claude CLI to be ready to accept input
+ * Polls pane content looking for Claude's input prompt indicator
+ */
+async function waitForClaudeReady(
+  paneId: string,
+  timeoutMs: number = 30000,
+  pollIntervalMs: number = 500
+): Promise<boolean> {
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeoutMs) {
+    try {
+      const content = await tmux.capturePaneContent(paneId, 50);
+
+      // Claude CLI shows ">" prompt when ready for input
+      // Also check for the input area indicator
+      // The prompt appears at the end of output when Claude is waiting for input
+      const lines = content.split('\n').filter(l => l.trim());
+      if (lines.length > 0) {
+        const lastFewLines = lines.slice(-5).join('\n');
+        // Claude shows "❯" prompt when ready for input
+        // Also detect welcome messages or input hints
+        if (
+          lastFewLines.includes('❯') ||
+          lastFewLines.includes('? for shortcuts') ||
+          lastFewLines.includes('What would you like') ||
+          lastFewLines.includes('How can I help')
+        ) {
+          return true;
+        }
+      }
+    } catch {
+      // Pane may not exist yet, continue polling
+    }
+
+    await new Promise(r => setTimeout(r, pollIntervalMs));
+  }
+
+  // Timeout - return false but don't fail (caller can decide)
+  return false;
+}
+
+/**
+ * Spawn Claude worker in new pane (splits the CURRENT active pane)
  */
 async function spawnWorkerPane(
   session: string,
   workingDir: string
 ): Promise<{ paneId: string } | null> {
   try {
-    // Find current window
+    // Find session
     const sessionObj = await tmux.findSessionByName(session);
     if (!sessionObj) {
       console.error(`❌ Session "${session}" not found`);
@@ -182,15 +280,21 @@ async function spawnWorkerPane(
       return null;
     }
 
-    const panes = await tmux.listPanes(windows[0].id);
+    // Find the ACTIVE window (not first window)
+    const activeWindow = windows.find(w => w.active) || windows[0];
+
+    const panes = await tmux.listPanes(activeWindow.id);
     if (!panes || panes.length === 0) {
-      console.error(`❌ No panes in session "${session}"`);
+      console.error(`❌ No panes in window "${activeWindow.name}"`);
       return null;
     }
 
+    // Find the ACTIVE pane (not first pane)
+    const activePane = panes.find(p => p.active) || panes[0];
+
     // Split current pane horizontally (side by side)
     const newPane = await tmux.splitPane(
-      panes[0].id,
+      activePane.id,
       'horizontal',
       50,
       workingDir
@@ -210,6 +314,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 +355,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 +367,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 +394,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,9 +433,86 @@ 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) {
+      // If worker exists and has a session ID, offer to resume
+      if (existingWorker.claudeSessionId && options.resume !== false) {
+        console.log(`📋 Found existing worker for ${taskId} with resumable session`);
+        console.log(`   Session ID: ${existingWorker.claudeSessionId}`);
+        console.log(`   Resuming previous Claude session...`);
+
+        // Get session
+        const session = options.session || await getCurrentSession();
+        if (!session) {
+          console.error('❌ Not in a tmux session. Attach to a session first or use --session.');
+          process.exit(1);
+        }
+
+        // Spawn a new pane for the resumed session
+        const workingDir = existingWorker.worktree || existingWorker.repoPath;
+        console.log(`🚀 Spawning worker pane...`);
+        const paneResult = await spawnWorkerPane(session, workingDir);
+        if (!paneResult) {
+          process.exit(1);
+        }
+
+        const { paneId } = paneResult;
+
+        // Update worker with new pane ID
+        await registry.update(existingWorker.id, {
+          paneId,
+          session,
+          state: 'spawning',
+          lastStateChange: new Date().toISOString(),
+        });
+        if (useBeads) {
+          await beadsRegistry.setAgentState(existingWorker.id, 'spawning').catch(() => {});
+        }
+
+        // Set BEADS_DIR so bd commands work in the worktree
+        const beadsDir = join(existingWorker.repoPath, '.genie');
+        const escapedWorkingDir = workingDir.replace(/'/g, "'\\''");
+
+        // Resume Claude with the stored session ID
+        await tmux.executeCommand(
+          paneId,
+          `cd '${escapedWorkingDir}' && BEADS_DIR='${beadsDir}' claude --resume '${existingWorker.claudeSessionId}'`,
+          true,
+          false
+        );
+
+        // Update state to working
+        if (useBeads) {
+          await beadsRegistry.setAgentState(existingWorker.id, 'working').catch(() => {});
+        }
+        await registry.updateState(existingWorker.id, 'working');
+
+        // Start monitoring
+        startWorkerMonitoring(existingWorker.id, session, paneId);
+
+        // Focus pane (only if explicitly requested)
+        if (options.focus === true) {
+          await tmux.executeTmux(`select-pane -t '${paneId}'`);
+        }
+
+        console.log(`\n✅ Resumed worker for ${taskId}`);
+        console.log(`   Pane: ${paneId}`);
+        console.log(`   Session: ${session}`);
+        console.log(`   Claude Session: ${existingWorker.claudeSessionId}`);
+        console.log(`\nCommands:`);
+        console.log(`   term workers        - Check worker status`);
+        console.log(`   term approve ${taskId}  - Approve permissions`);
+        console.log(`   term close ${taskId}    - Close issue when done`);
+        console.log(`   term kill ${taskId}     - Force kill worker`);
+        return;
+      }
+
       console.error(`❌ ${taskId} already has a worker (pane ${existingWorker.paneId})`);
       console.log(`   Run \`term kill ${existingWorker.id}\` first, or work on a different issue.`);
       process.exit(1);
@@ -354,7 +557,10 @@ export async function workCommand(
 
     const { paneId } = paneResult;
 
-    // 7. Register worker
+    // 7. Generate Claude session ID for resume capability
+    const claudeSessionId = randomUUID();
+
+    // 8. Register worker (write to both registries during transition)
     const worker: registry.Worker = {
       id: taskId,
       paneId,
@@ -366,33 +572,69 @@ export async function workCommand(
       state: 'spawning',
       lastStateChange: new Date().toISOString(),
       repoPath,
+      claudeSessionId,
     };
 
-    await registry.register(worker);
-
-    // 8. Start Claude in pane
-    await tmux.executeCommand(paneId, 'claude', false, false);
+    // Register in beads (creates agent bead)
+    if (useBeads) {
+      try {
+        const agentId = await beadsRegistry.ensureAgent(taskId, {
+          paneId,
+          session,
+          worktree: worktreePath,
+          repoPath,
+          taskId,
+          taskTitle: issue.title,
+          claudeSessionId,
+        });
+
+        // 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)`);
+      }
+    }
 
-    // Wait a bit for Claude to start
-    await new Promise(r => setTimeout(r, 2000));
+    // Also register in JSON registry (parallel operation during transition)
+    await registry.register(worker);
 
-    // 9. Send initial prompt
+    // 9. Build prompt and start Claude with it as argument
     const prompt = options.prompt || `Work on beads issue ${taskId}: "${issue.title}"
 
-Read the issue details with: bd show ${taskId}
+## Description
+${issue.description || 'No description provided.'}
 
 When you're done, commit your changes and let me know.`;
 
-    await tmux.executeCommand(paneId, prompt, false, false);
+    // Escape the prompt for shell (single quotes)
+    const escapedPrompt = prompt.replace(/'/g, "'\\''");
+
+    // Set BEADS_DIR so bd commands work in the worktree
+    const beadsDir = join(repoPath, '.genie');
+
+    // Escape workingDir for shell
+    const escapedWorkingDir = workingDir.replace(/'/g, "'\\''");
 
-    // 10. Update state to working
+    // Start Claude with session ID for resume capability
+    // First cd to correct directory (shell rc files may have overridden tmux -c)
+    await tmux.executeCommand(paneId, `cd '${escapedWorkingDir}' && BEADS_DIR='${beadsDir}' claude --session-id '${claudeSessionId}' '${escapedPrompt}'`, true, false);
+
+    console.log(`   Session ID: ${claudeSessionId}`);
+
+    // 10. Update state to working (both registries)
+    if (useBeads) {
+      await beadsRegistry.setAgentState(taskId, 'working').catch(() => {});
+    }
     await registry.updateState(taskId, 'working');
 
     // 11. Start monitoring
     startWorkerMonitoring(taskId, session, paneId);
 
-    // 12. Focus pane (unless disabled)
-    if (options.focus !== false) {
+    // 12. Focus pane (only if explicitly requested)
+    if (options.focus === true) {
       await tmux.executeTmux(`select-pane -t '${paneId}'`);
     }
 

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';