@automagik/genie 0.260202.1901 → 0.260203.135

package/scripts/sync.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * Sync script for automagik-genie
+ *
+ * Deploys the built plugin to the install target:
+ *   ~/.claude/plugins/automagik-genie/
+ *
+ * Uses pure Node.js - no rsync dependency.
+ * Also triggers worker restart after sync.
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, copyFileSync, rmSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import http from 'http';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.join(__dirname, '..');
+const pluginDir = path.join(rootDir, 'plugin');
+const INSTALLED_PATH = path.join(os.homedir(), '.claude', 'plugins', 'automagik-genie');
+const WORKER_PORT = 48888;
+
+/**
+ * Recursively copy directory contents
+ */
+function copyDir(src, dest) {
+  mkdirSync(dest, { recursive: true });
+
+  const entries = readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Clean directory but preserve .git if it exists
+ */
+function cleanDir(dir) {
+  if (!existsSync(dir)) return;
+
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    // Preserve .git directory for git-based updates
+    if (entry.name === '.git') continue;
+
+    const fullPath = path.join(dir, entry.name);
+    rmSync(fullPath, { recursive: true, force: true });
+  }
+}
+
+function getPluginVersion() {
+  try {
+    const pluginJsonPath = path.join(pluginDir, '.claude-plugin', 'plugin.json');
+    const pluginJson = JSON.parse(readFileSync(pluginJsonPath, 'utf-8'));
+    return pluginJson.version;
+  } catch (error) {
+    console.error('Failed to read plugin version:', error.message);
+    return null;
+  }
+}
+
+function triggerWorkerRestart() {
+  return new Promise((resolve) => {
+    console.log('\nTriggering worker restart...');
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: WORKER_PORT,
+      path: '/api/admin/restart',
+      method: 'POST',
+      timeout: 2000
+    }, (res) => {
+      if (res.statusCode === 200) {
+        console.log('Worker restart triggered');
+      } else {
+        console.log(`Worker restart returned status ${res.statusCode}`);
+      }
+      resolve();
+    });
+    req.on('error', () => {
+      console.log('Worker not running, will start on next hook');
+      resolve();
+    });
+    req.on('timeout', () => {
+      req.destroy();
+      console.log('Worker restart timed out');
+      resolve();
+    });
+    req.end();
+  });
+}
+
+async function main() {
+  const version = getPluginVersion();
+  console.log(`Syncing automagik-genie ${version || 'unknown'} to ${INSTALLED_PATH}...`);
+
+  try {
+    // Ensure target directory exists
+    mkdirSync(INSTALLED_PATH, { recursive: true });
+
+    // Clean existing files (preserving .git)
+    console.log('Cleaning target directory...');
+    cleanDir(INSTALLED_PATH);
+
+    // Copy plugin files
+    console.log('Copying plugin files...');
+    copyDir(pluginDir, INSTALLED_PATH);
+
+    // Run bun install in target
+    console.log('\nRunning bun install in target...');
+    execSync('bun install', { cwd: INSTALLED_PATH, stdio: 'inherit' });
+
+    console.log('\nSync complete!');
+
+    // Trigger worker restart
+    await triggerWorkerRestart();
+
+  } catch (error) {
+    console.error('Sync failed:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/src/lib/beads-registry.ts

@@ -85,6 +85,7 @@ export async function createAgent(
     repoPath: string;
     taskId: string;
     taskTitle?: string;
+    claudeSessionId?: string;
   }
 ): Promise<string> {
   // Create agent bead with metadata
@@ -115,6 +116,7 @@ export async function createAgent(
     repoPath: metadata.repoPath,
     taskId: metadata.taskId,
     taskTitle: metadata.taskTitle,
+    claudeSessionId: metadata.claudeSessionId,
     startedAt: new Date().toISOString(),
   });
 
@@ -135,6 +137,7 @@ export async function ensureAgent(
     repoPath: string;
     taskId: string;
     taskTitle?: string;
+    claudeSessionId?: string;
   }
 ): Promise<string> {
   // Check if agent already exists
@@ -302,6 +305,7 @@ interface AgentMetadata {
   startedAt: string;
   wishSlug?: string;
   groupNumber?: number;
+  claudeSessionId?: string;
 }
 
 /**
@@ -321,6 +325,7 @@ function agentToWorker(agent: AgentBead, metadata: AgentMetadata): Worker {
     state: mapFromBeadsState(agent.state || 'idle'),
     lastStateChange: new Date().toISOString(), // Would need to track this in beads
     repoPath: metadata.repoPath,
+    claudeSessionId: metadata.claudeSessionId,
   };
 }
 
@@ -391,6 +396,14 @@ export async function hasWorkerForTask(taskId: string): Promise<boolean> {
   return worker !== null;
 }
 
+/**
+ * Find worker by Claude session ID
+ */
+export async function findBySessionId(sessionId: string): Promise<Worker | null> {
+  const workers = await listWorkers();
+  return workers.find(w => w.claudeSessionId === sessionId) || null;
+}
+
 // ============================================================================
 // Daemon Management
 // ============================================================================
@@ -524,6 +537,7 @@ export async function register(worker: Worker): Promise<void> {
     repoPath: worker.repoPath,
     taskId: worker.taskId,
     taskTitle: worker.taskTitle,
+    claudeSessionId: worker.claudeSessionId,
   });
 
   await setAgentState(worker.id, worker.state);
@@ -544,3 +558,38 @@ export async function updateState(workerId: string, state: WorkerState): Promise
   await setAgentState(workerId, state);
   await heartbeat(workerId);
 }
+
+/**
+ * Update Claude session ID for a worker
+ */
+export async function updateSessionId(workerId: string, sessionId: string): Promise<void> {
+  const agent = await findAgentByWorkerId(workerId);
+  if (!agent) {
+    throw new Error(`Agent not found for worker ${workerId}`);
+  }
+
+  // Get current metadata
+  const { stdout, exitCode } = await runBd(['show', agent.id, '--json']);
+  if (exitCode !== 0 || !stdout) {
+    throw new Error(`Failed to get agent metadata for ${workerId}`);
+  }
+
+  const fullAgent = parseJson<AgentBead & { metadata?: AgentMetadata }>(stdout);
+  if (!fullAgent?.metadata) {
+    throw new Error(`Agent ${workerId} has no metadata`);
+  }
+
+  // Update metadata with new session ID
+  const updatedMetadata = { ...fullAgent.metadata, claudeSessionId: sessionId };
+  const metadataJson = JSON.stringify(updatedMetadata);
+
+  const { exitCode: updateExitCode, stderr } = await runBd([
+    'update',
+    agent.id,
+    `--metadata=${metadataJson}`,
+  ]);
+
+  if (updateExitCode !== 0) {
+    throw new Error(`Failed to update session ID: ${stderr}`);
+  }
+}

package/src/lib/orchestrator/event-monitor.ts

@@ -96,7 +96,9 @@ export class EventMonitor extends EventEmitter {
     await this.poll();
 
     // Start polling
+    // Use unref() so the timer doesn't prevent process exit
     this.pollTimer = setInterval(() => this.poll(), this.options.pollIntervalMs);
+    this.pollTimer.unref();
 
     this.emit('started', { sessionName: this.sessionName, paneId: this.paneId });
   }

package/src/lib/skill-loader.ts

@@ -0,0 +1,215 @@
+/**
+ * Skill Loader - Find and load Claude skills
+ *
+ * Skills are stored in:
+ *   1. .claude/skills/<skill-name>/SKILL.md (project local)
+ *   2. ~/.claude/skills/<skill-name>/SKILL.md (user global)
+ *
+ * Skill names are simple (wish, forge, review) and map to directories:
+ *   - Direct match: wish -> wish/
+ *   - Prefixed: wish -> genie-wish/
+ */
+
+import { access, readFile } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+
+export interface SkillInfo {
+  name: string;
+  path: string;
+  skillFile: string;
+  description?: string;
+}
+
+/**
+ * Get possible directory names for a skill
+ * e.g., "wish" -> ["wish", "genie-wish"]
+ */
+function skillNameToDirs(skillName: string): string[] {
+  return [skillName, `genie-${skillName}`];
+}
+
+/**
+ * Check if a path exists
+ */
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Find a skill by name
+ *
+ * Search order:
+ * 1. .claude/skills/<skill-dir>/SKILL.md (project local)
+ * 2. ~/.claude/skills/<skill-dir>/SKILL.md (user global)
+ *
+ * For each location, tries both exact name and genie-prefixed name.
+ *
+ * @param skillName - Skill name (e.g., "wish", "forge", "review")
+ * @param projectRoot - Project root directory (defaults to cwd)
+ * @returns SkillInfo if found, null otherwise
+ */
+export async function findSkill(
+  skillName: string,
+  projectRoot?: string
+): Promise<SkillInfo | null> {
+  const dirNames = skillNameToDirs(skillName);
+  const cwd = projectRoot || process.cwd();
+
+  // Search locations in order of precedence
+  const searchLocations = [
+    join(cwd, '.claude', 'skills'),
+    join(homedir(), '.claude', 'skills'),
+  ];
+
+  for (const location of searchLocations) {
+    for (const dirName of dirNames) {
+      const skillPath = join(location, dirName);
+      const skillFile = join(skillPath, 'SKILL.md');
+
+      if (await pathExists(skillFile)) {
+        // Parse description from frontmatter if available
+        let description: string | undefined;
+        try {
+          const content = await readFile(skillFile, 'utf-8');
+          const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+          if (frontmatterMatch) {
+            const descMatch = frontmatterMatch[1].match(/description:\s*["']?([^"'\n]+)["']?/);
+            if (descMatch) {
+              description = descMatch[1];
+            }
+          }
+        } catch {
+          // Ignore parse errors
+        }
+
+        return {
+          name: skillName,
+          path: skillPath,
+          skillFile,
+          description,
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Validate that a skill exists and has required files
+ *
+ * @param skillPath - Path to skill directory
+ * @returns true if valid, false otherwise
+ */
+export async function validateSkill(skillPath: string): Promise<boolean> {
+  const skillFile = join(skillPath, 'SKILL.md');
+  return pathExists(skillFile);
+}
+
+/**
+ * Read skill content from SKILL.md
+ *
+ * @param skillFile - Path to SKILL.md
+ * @returns Skill content as string
+ */
+export async function readSkillContent(skillFile: string): Promise<string> {
+  return readFile(skillFile, 'utf-8');
+}
+
+/**
+ * Build a prompt that loads a skill
+ *
+ * Reads the skill file and includes its content directly in the prompt.
+ *
+ * @param skill - SkillInfo from findSkill
+ * @param additionalPrompt - Optional additional context/instructions
+ * @returns Combined prompt string
+ */
+export async function buildSkillPrompt(
+  skill: SkillInfo,
+  additionalPrompt?: string
+): Promise<string> {
+  // Read the skill content
+  const skillContent = await readFile(skill.skillFile, 'utf-8');
+
+  const parts = [
+    `You are running skill: ${skill.name}`,
+    '',
+    '## Skill Instructions',
+    '',
+    skillContent,
+  ];
+
+  if (additionalPrompt) {
+    parts.push('', '---', '', '## Additional Context', '', additionalPrompt);
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Parse skill name from SKILL.md frontmatter
+ * Falls back to directory name conversion if no frontmatter name
+ */
+async function parseSkillName(skillFile: string, dirName: string): Promise<string> {
+  try {
+    const content = await readFile(skillFile, 'utf-8');
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+      const nameMatch = frontmatterMatch[1].match(/name:\s*["']?([^"'\n]+)["']?/);
+      if (nameMatch) {
+        return nameMatch[1].trim();
+      }
+    }
+  } catch {
+    // Ignore errors
+  }
+  // Fallback: convert first hyphen to colon (genie-wish -> genie:wish)
+  // but leave subsequent hyphens as-is for multi-word names
+  return dirName.replace(/-/, ':');
+}
+
+/**
+ * List all available skills
+ *
+ * @param projectRoot - Project root directory (defaults to cwd)
+ * @returns Array of skill names found
+ */
+export async function listSkills(projectRoot?: string): Promise<string[]> {
+  const { readdir } = await import('fs/promises');
+  const cwd = projectRoot || process.cwd();
+  const skills: string[] = [];
+
+  const searchPaths = [
+    join(cwd, '.claude', 'skills'),
+    join(homedir(), '.claude', 'skills'),
+  ];
+
+  for (const searchPath of searchPaths) {
+    try {
+      const entries = await readdir(searchPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillFile = join(searchPath, entry.name, 'SKILL.md');
+          if (await pathExists(skillFile)) {
+            // Get skill name from frontmatter or convert directory name
+            const skillName = await parseSkillName(skillFile, entry.name);
+            if (!skills.includes(skillName)) {
+              skills.push(skillName);
+            }
+          }
+        }
+      }
+    } catch {
+      // Directory doesn't exist, skip
+    }
+  }
+
+  return skills.sort();
+}

package/src/lib/tmux.ts

@@ -240,6 +240,7 @@ export async function splitPane(
   workingDir?: string
 ): Promise<TmuxPane | null> {
   // Build the split-window command
+  // Order follows tmux convention: flags, -c, -p, -t, -F
   let splitCommand = 'split-window';
 
   // Add direction flag (-h for horizontal, -v for vertical)
@@ -249,30 +250,34 @@ export async function splitPane(
     splitCommand += ' -v';
   }
 
-  // Add target pane
-  splitCommand += ` -t '${targetPaneId}'`;
+  // Add working directory if specified (must come before -t)
+  if (workingDir) {
+    splitCommand += ` -c '${escapeShellPath(workingDir)}'`;
+  }
 
   // Add size if specified (as percentage)
   if (size !== undefined && size > 0 && size < 100) {
     splitCommand += ` -p ${size}`;
   }
 
-  // Add working directory if specified
-  if (workingDir) {
-    splitCommand += ` -c '${escapeShellPath(workingDir)}'`;
-  }
+  // Add target pane
+  splitCommand += ` -t '${targetPaneId}'`;
 
-  // Execute the split command
-  await executeTmux(splitCommand);
+  // Add -P flag to print new pane info, with format to get pane ID
+  splitCommand += ` -P -F '#{pane_id}'`;
 
-  // Get the window ID from the target pane to list all panes
-  const windowInfo = await executeTmux(`display-message -p -t '${targetPaneId}' '#{window_id}'`);
+  // Execute the split command - returns the new pane ID
+  const newPaneId = (await executeTmux(splitCommand)).trim();
 
-  // List all panes in the window to find the newly created one
-  const panes = await listPanes(windowInfo);
+  // Get the window ID for the new pane
+  const windowId = await executeTmux(`display-message -p -t '${newPaneId}' '#{window_id}'`);
 
-  // The newest pane is typically the last one in the list
-  return panes.length > 0 ? panes[panes.length - 1] : null;
+  return {
+    id: newPaneId,
+    windowId: windowId.trim(),
+    active: false,
+    title: ''
+  };
 }
 
 // Map to track ongoing command executions

package/src/lib/version.ts

@@ -1,5 +1,5 @@
 // Runtime version (baked in at build time)
-export const VERSION = '0.260202.1901';
+export const VERSION = '0.260203.0135';
 
 // Generate version string from current datetime
 // Format: 0.YYMMDD.HHMM (e.g., 0.260201.1430 = Feb 1, 2026 at 14:30)

package/src/lib/worker-registry.ts

@@ -47,6 +47,8 @@ export interface Worker {
   lastStateChange: string;
   /** Repository path where worker operates */
   repoPath: string;
+  /** Claude session ID for resume capability */
+  claudeSessionId?: string;
 }
 
 export interface WorkerRegistry {
@@ -176,6 +178,14 @@ export async function findByWish(wishSlug: string): Promise<Worker[]> {
   return workers.filter(w => w.wishSlug === wishSlug);
 }
 
+/**
+ * Find worker by Claude session ID
+ */
+export async function findBySessionId(sessionId: string): Promise<Worker | null> {
+  const workers = await list();
+  return workers.find(w => w.claudeSessionId === sessionId) || null;
+}
+
 /**
  * Check if a worker exists for a given task
  */