@automagik/genie 0.260202.1901 → 0.260203.135

package/src/term-commands/work.ts

@@ -9,17 +9,18 @@
  * 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 * as beadsRegistry from '../lib/beads-registry.js';
-import { WorktreeManager } from '../lib/worktree.js';
-import { EventMonitor, detectState } from '../lib/orchestrator/index.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();
@@ -33,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[];
 }
 
@@ -46,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
@@ -72,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 {
@@ -99,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 || [],
       };
     }
@@ -138,52 +148,54 @@ 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
+ * 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> {
-  // 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;
-      }
+  const fs = await import('fs/promises');
+  const worktreeDir = join(repoPath, WORKTREE_DIR_NAME);
+  const worktreePath = join(worktreeDir, taskId);
 
-      // 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`);
-    }
+  // Ensure .genie/worktrees exists
+  try {
+    await fs.mkdir(worktreeDir, { recursive: true });
+  } catch {
+    // Directory may already exist
   }
 
-  // Fallback to WorktreeManager
+  // Check if worktree already exists
   try {
-    const manager = new WorktreeManager({
-      baseDir: WORKTREE_BASE,
-      repoPath,
-    });
-
-    // Check if worktree already exists
-    if (await manager.worktreeExists(taskId)) {
+    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 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'));
 
-    // Create new worktree with branch
-    const info = await manager.createWorktree(taskId, true);
-    return info.path;
+    return worktreePath;
   } catch (error: any) {
     console.error(`⚠️  Failed to create worktree: ${error.message}`);
     return null;
@@ -191,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`);
@@ -211,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
@@ -366,6 +441,78 @@ export async function workCommand(
       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);
@@ -410,7 +557,10 @@ export async function workCommand(
 
     const { paneId } = paneResult;
 
-    // 7. Register worker (write to both registries during transition)
+    // 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,
@@ -422,6 +572,7 @@ export async function workCommand(
       state: 'spawning',
       lastStateChange: new Date().toISOString(),
       repoPath,
+      claudeSessionId,
     };
 
     // Register in beads (creates agent bead)
@@ -434,6 +585,7 @@ export async function workCommand(
           repoPath,
           taskId,
           taskTitle: issue.title,
+          claudeSessionId,
         });
 
         // Bind work to agent
@@ -449,20 +601,28 @@ export async function workCommand(
     // Also register in JSON registry (parallel operation during transition)
     await registry.register(worker);
 
-    // 8. Start Claude in pane
-    await tmux.executeCommand(paneId, 'claude', false, false);
-
-    // Wait a bit for Claude to start
-    await new Promise(r => setTimeout(r, 2000));
-
-    // 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, "'\\''");
+
+    // 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) {
@@ -473,8 +633,8 @@ When you're done, commit your changes and let me know.`;
     // 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.ts

@@ -21,6 +21,8 @@ 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';
+import * as spawnCmd from './term-commands/spawn.js';
+import * as createCmd from './term-commands/create.js';
 
 const program = new Command();
 
@@ -36,6 +38,12 @@ Collaborative Usage:
 Workflow: new → exec → read → rm
 Full control: window new/ls/rm, pane ls/rm, split, status
 
+Skill-Based Spawning:
+  term spawn          - Pick skill interactively
+  term spawn <skill>  - Spawn Claude with skill loaded
+  term skills         - List available skills
+  term create <title> - Create beads issue
+
 Worker Orchestration:
   term work <bd-id>   - Spawn worker bound to beads issue
   term work next      - Work on next ready issue
@@ -111,9 +119,11 @@ program
 
 program
   .command('send <session> <keys>')
-  .description('Send raw keys to a tmux session')
-  .action(async (session: string, keys: string) => {
-    await sendCmd.sendKeysToSession(session, keys);
+  .description('Send keys to a tmux session (appends Enter by default)')
+  .option('--no-enter', 'Send raw keys without appending Enter')
+  .option('-p, --pane <id>', 'Target specific pane ID (e.g., %16)')
+  .action(async (session: string, keys: string, options: { enter?: boolean; pane?: string }) => {
+    await sendCmd.sendKeysToSession(session, keys, options);
   });
 
 // Pane splitting
@@ -126,9 +136,9 @@ program
     await splitCmd.splitSessionPane(session, direction, options);
   });
 
-// Status command
+// Info command (renamed from status)
 program
-  .command('status <session>')
+  .command('info <session>')
   .description('Check session state (idle/busy, pane count)')
   .option('--command <id>', 'Check specific command status')
   .option('--json', 'Output as JSON')
@@ -214,14 +224,79 @@ program
     await shortcutsCmd.handleShortcuts(options);
   });
 
+// Skill-based spawning
+program
+  .command('spawn [skill]')
+  .description('Spawn Claude with a skill (interactive picker if no skill specified)')
+  .option('-s, --session <name>', 'Target tmux session')
+  .option('--no-worktree', 'Skip worktree creation when taskId provided')
+  .option('--no-focus', 'Don\'t focus the new pane')
+  .option('-p, --prompt <message>', 'Additional context for the skill')
+  .option('-t, --task-id <id>', 'Bind to beads issue')
+  .action(async (skill: string | undefined, options: spawnCmd.SpawnOptions) => {
+    await spawnCmd.spawnCommand(skill, options);
+  });
+
+program
+  .command('skills')
+  .description('List available skills')
+  .action(async () => {
+    await spawnCmd.listSkillsCommand();
+  });
+
+program
+  .command('brainstorm')
+  .description('Spawn Claude with brainstorm skill (idea → design → spec)')
+  .option('-s, --session <name>', 'Target tmux session')
+  .option('--no-focus', 'Don\'t focus the new pane')
+  .option('-p, --prompt <message>', 'Additional context')
+  .action(async (options: spawnCmd.SpawnOptions) => {
+    await spawnCmd.spawnCommand('brainstorm', options);
+  });
+
+// Watch session events (promoted from orc watch)
+program
+  .command('watch <session>')
+  .description('Watch session events in real-time')
+  .option('-p, --pane <id>', 'Target specific pane ID (e.g., %16)')
+  .option('--json', 'Output events as JSON')
+  .option('--poll <ms>', 'Poll interval in milliseconds')
+  .action(async (session: string, options: orchestrateCmd.WatchOptions) => {
+    await orchestrateCmd.watchSession(session, options);
+  });
+
+// Run task with monitoring (promoted from orc run)
+program
+  .command('run <session> <message>')
+  .description('Send task and auto-approve until idle (fire-and-forget)')
+  .option('-p, --pane <id>', 'Target specific pane ID (e.g., %16)')
+  .option('-a, --auto-approve', 'Auto-approve permissions and plans')
+  .option('-t, --timeout <ms>', 'Timeout in milliseconds (default: 300000)')
+  .option('--json', 'Output final state as JSON')
+  .action(async (session: string, message: string, options: orchestrateCmd.RunOptions) => {
+    await orchestrateCmd.runTask(session, message, options);
+  });
+
+// Create beads issue command
+program
+  .command('create <title>')
+  .description('Create a new beads issue')
+  .option('-d, --description <text>', 'Issue description')
+  .option('-p, --parent <id>', 'Parent issue ID (creates dependency)')
+  .option('--json', 'Output as JSON')
+  .action(async (title: string, options: createCmd.CreateOptions) => {
+    await createCmd.createCommand(title, options);
+  });
+
 // Worker management commands (beads + Claude orchestration)
 program
   .command('work <target>')
   .description('Spawn worker bound to beads issue (target: bd-id, "next", or "wish")')
   .option('--no-worktree', 'Use shared repo instead of worktree')
   .option('-s, --session <name>', 'Target tmux session')
-  .option('--no-focus', 'Don\'t focus the worker pane')
+  .option('--focus', 'Focus the worker pane after spawning')
   .option('-p, --prompt <message>', 'Custom initial prompt')
+  .option('--no-resume', 'Start fresh session even if previous exists')
   .action(async (target: string, options: workCmd.WorkOptions) => {
     await workCmd.workCommand(target, options);
   });