claude_swarm 0.1.19 → 0.2.0

data/lib/claude_swarm/cli.rb

@@ -1,109 +1,190 @@
 # frozen_string_literal: true
 
-require "thor"
-require "json"
-require_relative "configuration"
-require_relative "mcp_generator"
-require_relative "orchestrator"
-require_relative "claude_mcp_server"
-
 module ClaudeSwarm
   class CLI < Thor
-    def self.exit_on_failure?
-      true
+    include SystemUtils
+    class << self
+      def exit_on_failure?
+        true
+      end
     end
 
     desc "start [CONFIG_FILE]", "Start a Claude Swarm from configuration file"
-    method_option :config, aliases: "-c", type: :string, default: "claude-swarm.yml",
-                           desc: "Path to configuration file"
-    method_option :vibe, type: :boolean, default: false,
-                         desc: "Run with --dangerously-skip-permissions for all instances"
-    method_option :prompt, aliases: "-p", type: :string,
-                           desc: "Prompt to pass to the main Claude instance (non-interactive mode)"
-    method_option :stream_logs, type: :boolean, default: false,
-                                desc: "Stream session logs to stdout (only works with -p)"
-    method_option :debug, type: :boolean, default: false,
-                          desc: "Enable debug output"
-    method_option :session_id, type: :string,
-                               desc: "Resume a previous session by ID or path"
-    method_option :worktree, type: :string, aliases: "-w",
-                             desc: "Create instances in Git worktrees with the given name (auto-generated if true)",
-                             banner: "[NAME]"
+    method_option :vibe,
+      type: :boolean,
+      default: false,
+      desc: "Run with --dangerously-skip-permissions for all instances"
+    method_option :prompt,
+      aliases: "-p",
+      type: :string,
+      desc: "Prompt to pass to the main Claude instance (non-interactive mode)"
+    method_option :stream_logs,
+      type: :boolean,
+      default: false,
+      desc: "Stream session logs to stdout (only works with -p)"
+    method_option :debug,
+      type: :boolean,
+      default: false,
+      desc: "Enable debug output"
+    method_option :worktree,
+      type: :string,
+      aliases: "-w",
+      desc: "Create instances in Git worktrees with the given name (auto-generated if true)",
+      banner: "[NAME]"
+    method_option :session_id,
+      type: :string,
+      desc: "Use a specific session ID instead of generating one"
     def start(config_file = nil)
-      # Handle session restoration
-      if options[:session_id]
-        restore_session(options[:session_id])
-        return
-      end
-
-      config_path = config_file || options[:config]
+      config_path = config_file || "claude-swarm.yml"
       unless File.exist?(config_path)
-        error "Configuration file not found: #{config_path}"
-        exit 1
+        error("Configuration file not found: #{config_path}")
+        exit(1)
       end
 
-      say "Starting Claude Swarm from #{config_path}..." unless options[:prompt]
+      say("Starting Claude Swarm from #{config_path}...") unless options[:prompt]
 
       # Validate stream_logs option
       if options[:stream_logs] && !options[:prompt]
-        error "--stream-logs can only be used with -p/--prompt"
-        exit 1
+        error("--stream-logs can only be used with -p/--prompt")
+        exit(1)
       end
 
       begin
-        config = Configuration.new(config_path, base_dir: Dir.pwd)
+        config = Configuration.new(config_path, base_dir: Dir.pwd, options: options)
         generator = McpGenerator.new(config, vibe: options[:vibe])
-        orchestrator = Orchestrator.new(config, generator,
-                                        vibe: options[:vibe],
-                                        prompt: options[:prompt],
-                                        stream_logs: options[:stream_logs],
-                                        debug: options[:debug],
-                                        worktree: options[:worktree])
+        orchestrator = Orchestrator.new(
+          config,
+          generator,
+          vibe: options[:vibe],
+          prompt: options[:prompt],
+          stream_logs: options[:stream_logs],
+          debug: options[:debug],
+          worktree: options[:worktree],
+          session_id: options[:session_id],
+        )
         orchestrator.start
       rescue Error => e
-        error e.message
-        exit 1
+        error(e.message)
+        exit(1)
       rescue StandardError => e
-        error "Unexpected error: #{e.message}"
-        error e.backtrace.join("\n") if options[:verbose]
-        exit 1
+        error("Unexpected error: #{e.message}")
+        error(e.backtrace.join("\n")) if options[:verbose]
+        exit(1)
       end
     end
 
     desc "mcp-serve", "Start an MCP server for a Claude instance"
-    method_option :name, aliases: "-n", type: :string, required: true,
-                         desc: "Instance name"
-    method_option :directory, aliases: "-d", type: :string, required: true,
-                              desc: "Working directory for the instance"
-    method_option :directories, type: :array,
-                                desc: "All directories (including main directory) for the instance"
-    method_option :model, aliases: "-m", type: :string, required: true,
-                          desc: "Claude model to use (e.g., opus, sonnet)"
-    method_option :prompt, aliases: "-p", type: :string,
-                           desc: "System prompt for the instance"
-    method_option :description, type: :string,
-                                desc: "Description of the instance's role"
-    method_option :allowed_tools, aliases: "-t", type: :array,
-                                  desc: "Allowed tools for the instance"
-    method_option :disallowed_tools, type: :array,
-                                     desc: "Disallowed tools for the instance"
-    method_option :connections, type: :array,
-                                desc: "Connections to other instances"
-    method_option :mcp_config_path, type: :string,
-                                    desc: "Path to MCP configuration file"
-    method_option :debug, type: :boolean, default: false,
-                          desc: "Enable debug output"
-    method_option :vibe, type: :boolean, default: false,
-                         desc: "Run with --dangerously-skip-permissions"
-    method_option :calling_instance, type: :string, required: true,
-                                     desc: "Name of the instance that launched this MCP server"
-    method_option :calling_instance_id, type: :string,
-                                        desc: "Unique ID of the instance that launched this MCP server"
-    method_option :instance_id, type: :string,
-                                desc: "Unique ID of this instance"
-    method_option :claude_session_id, type: :string,
-                                      desc: "Claude session ID to resume"
+    method_option :name,
+      aliases: "-n",
+      type: :string,
+      required: true,
+      desc: "Instance name"
+    method_option :directory,
+      aliases: "-d",
+      type: :string,
+      required: true,
+      desc: "Working directory for the instance"
+    method_option :directories,
+      type: :array,
+      desc: "All directories (including main directory) for the instance"
+    method_option :model,
+      aliases: "-m",
+      type: :string,
+      required: true,
+      desc: "Claude model to use (e.g., opus, sonnet)"
+    method_option :prompt,
+      aliases: "-p",
+      type: :string,
+      desc: "System prompt for the instance"
+    method_option :description,
+      type: :string,
+      desc: "Description of the instance's role"
+    method_option :allowed_tools,
+      aliases: "-t",
+      type: :array,
+      desc: "Allowed tools for the instance"
+    method_option :disallowed_tools,
+      type: :array,
+      desc: "Disallowed tools for the instance"
+    method_option :connections,
+      type: :array,
+      desc: "Connections to other instances"
+    method_option :mcp_config_path,
+      type: :string,
+      desc: "Path to MCP configuration file"
+    method_option :debug,
+      type: :boolean,
+      default: false,
+      desc: "Enable debug output"
+    method_option :vibe,
+      type: :boolean,
+      default: false,
+      desc: "Run with --dangerously-skip-permissions"
+    method_option :calling_instance,
+      type: :string,
+      required: true,
+      desc: "Name of the instance that launched this MCP server"
+    method_option :calling_instance_id,
+      type: :string,
+      desc: "Unique ID of the instance that launched this MCP server"
+    method_option :instance_id,
+      type: :string,
+      desc: "Unique ID of this instance"
+    method_option :claude_session_id,
+      type: :string,
+      desc: "Claude session ID to resume"
+    method_option :provider,
+      type: :string,
+      desc: "Provider to use (claude or openai)"
+    method_option :temperature,
+      type: :numeric,
+      desc: "Temperature for OpenAI models"
+    method_option :api_version,
+      type: :string,
+      desc: "API version for OpenAI (chat_completion or responses)"
+    method_option :openai_token_env,
+      type: :string,
+      desc: "Environment variable name for OpenAI API key"
+    method_option :base_url,
+      type: :string,
+      desc: "Base URL for OpenAI API"
+    method_option :reasoning_effort,
+      type: :string,
+      desc: "Reasoning effort for OpenAI models"
     def mcp_serve
+      # Validate reasoning_effort if provided
+      if options[:reasoning_effort]
+        # Only validate if provider is openai (or not specified, since it could be set elsewhere)
+        if options[:provider] && options[:provider] != "openai"
+          error("reasoning_effort is only supported for OpenAI models")
+          exit(1)
+        end
+
+        # Validate it's used with an o-series model
+        model = options[:model]
+        unless model&.match?(ClaudeSwarm::Configuration::O_SERIES_MODEL_PATTERN)
+          error("reasoning_effort is only supported for o-series models (o1, o1 Preview, o1-mini, o1-pro, o3, o3-mini, o3-pro, o3-deep-research, o4-mini, o4-mini-deep-research, etc.)")
+          error("Current model: #{model}")
+          exit(1)
+        end
+
+        # Validate the value
+        unless ClaudeSwarm::Configuration::VALID_REASONING_EFFORTS.include?(options[:reasoning_effort])
+          error("reasoning_effort must be 'low', 'medium', or 'high'")
+          exit(1)
+        end
+      end
+
+      # Validate temperature is not used with o-series models
+      if options[:temperature] && options[:provider] == "openai"
+        model = options[:model]
+        if model&.match?(ClaudeSwarm::Configuration::O_SERIES_MODEL_PATTERN)
+          error("temperature parameter is not supported for o-series models (#{model})")
+          error("O-series models use deterministic reasoning and don't accept temperature settings")
+          exit(1)
+        end
+      end
+
       instance_config = {
         name: options[:name],
         directory: options[:directory],
@@ -117,33 +198,42 @@ module ClaudeSwarm
         mcp_config_path: options[:mcp_config_path],
         vibe: options[:vibe] || false,
         instance_id: options[:instance_id],
-        claude_session_id: options[:claude_session_id]
+        claude_session_id: options[:claude_session_id],
+        provider: options[:provider],
+        temperature: options[:temperature],
+        api_version: options[:api_version],
+        openai_token_env: options[:openai_token_env],
+        base_url: options[:base_url],
+        reasoning_effort: options[:reasoning_effort],
       }
 
       begin
         server = ClaudeMcpServer.new(
           instance_config,
           calling_instance: options[:calling_instance],
-          calling_instance_id: options[:calling_instance_id]
+          calling_instance_id: options[:calling_instance_id],
         )
         server.start
       rescue StandardError => e
-        error "Error starting MCP server: #{e.message}"
-        error e.backtrace.join("\n") if options[:debug]
-        exit 1
+        error("Error starting MCP server: #{e.message}")
+        error(e.backtrace.join("\n")) if options[:debug]
+        exit(1)
       end
     end
 
     desc "init", "Initialize a new claude-swarm.yml configuration file"
-    method_option :force, aliases: "-f", type: :boolean, default: false,
-                          desc: "Overwrite existing configuration file"
+    method_option :force,
+      aliases: "-f",
+      type: :boolean,
+      default: false,
+      desc: "Overwrite existing configuration file"
     def init
       config_path = "claude-swarm.yml"
 
       if File.exist?(config_path) && !options[:force]
-        error "Configuration file already exists: #{config_path}"
-        error "Use --force to overwrite"
-        exit 1
+        error("Configuration file already exists: #{config_path}")
+        error("Use --force to overwrite")
+        exit(1)
       end
 
       template = <<~YAML
@@ -160,7 +250,8 @@ module ClaudeSwarm
               description: "Lead developer who coordinates the team and makes architectural decisions"
               directory: .
               model: sonnet
-              prompt: "You are the lead developer coordinating the team"
+              prompt: |
+                You are the lead developer coordinating the team
               allowed_tools: [Read, Edit, Bash, Write]
               # connections: [frontend_dev, backend_dev]
 
@@ -170,47 +261,59 @@ module ClaudeSwarm
             #   description: "Frontend developer specializing in React and modern web technologies"
             #   directory: ./frontend
             #   model: sonnet
-            #   prompt: "You specialize in frontend development with React, TypeScript, and modern web technologies"
+            #   prompt: |
+            #     You specialize in frontend development with React, TypeScript, and modern web technologies
             #   allowed_tools: [Read, Edit, Write, "Bash(npm:*)", "Bash(yarn:*)", "Bash(pnpm:*)"]
 
             # backend_dev:
-            #   description: "Backend developer focusing on APIs, databases, and server architecture"
+            #   description: |
+            #     Backend developer focusing on APIs, databases, and server architecture
             #   directory: ../other-app/backend
             #   model: sonnet
-            #   prompt: "You specialize in backend development, APIs, databases, and server architecture"
+            #   prompt: |
+            #     You specialize in backend development, APIs, databases, and server architecture
             #   allowed_tools: [Read, Edit, Write, Bash]
 
             # devops_engineer:
             #   description: "DevOps engineer managing infrastructure, CI/CD, and deployments"
             #   directory: .
             #   model: sonnet
-            #   prompt: "You specialize in infrastructure, CI/CD, containerization, and deployment"
+            #   prompt: |
+            #     You specialize in infrastrujcture, CI/CD, containerization, and deployment
             #   allowed_tools: [Read, Edit, Write, "Bash(docker:*)", "Bash(kubectl:*)", "Bash(terraform:*)"]
 
             # qa_engineer:
             #   description: "QA engineer ensuring quality through comprehensive testing"
             #   directory: ./tests
             #   model: sonnet
-            #   prompt: "You specialize in testing, quality assurance, and test automation"
+            #   prompt: |
+            #     You specialize in testing, quality assurance, and test automation
             #   allowed_tools: [Read, Edit, Write, Bash]
       YAML
 
       File.write(config_path, template)
-      say "Created #{config_path}", :green
-      say "Edit this file to configure your swarm, then run 'claude-swarm' to start"
+      say("Created #{config_path}", :green)
+      say("Edit this file to configure your swarm, then run 'claude-swarm' to start")
     end
 
     desc "generate", "Launch Claude to help generate a swarm configuration interactively"
-    method_option :output, aliases: "-o", type: :string,
-                           desc: "Output file path for the generated configuration"
-    method_option :model, aliases: "-m", type: :string, default: "sonnet",
-                          desc: "Claude model to use for generation"
+    method_option :output,
+      aliases: "-o",
+      type: :string,
+      desc: "Output file path for the generated configuration"
+    method_option :model,
+      aliases: "-m",
+      type: :string,
+      default: "sonnet",
+      desc: "Claude model to use for generation"
     def generate
       # Check if claude command exists
-      unless system("which claude > /dev/null 2>&1")
-        error "Claude CLI is not installed or not in PATH"
-        say "To install Claude CLI, visit: https://docs.anthropic.com/en/docs/claude-code"
-        exit 1
+      begin
+        system!("command -v claude > /dev/null 2>&1")
+      rescue Error
+        error("Claude CLI is not installed or not in PATH")
+        say("To install Claude CLI, visit: https://docs.anthropic.com/en/docs/claude-code")
+        exit(1)
       end
 
       # Read README for context about claude-swarm capabilities
@@ -223,8 +326,9 @@ module ClaudeSwarm
       # Launch Claude in interactive mode with the initial prompt
       cmd = [
         "claude",
-        "--model", options[:model],
-        preprompt
+        "--model",
+        options[:model],
+        preprompt,
       ]
 
       # Execute and let the user take over
@@ -233,92 +337,87 @@ module ClaudeSwarm
 
     desc "version", "Show Claude Swarm version"
     def version
-      say "Claude Swarm #{VERSION}"
+      say("Claude Swarm #{VERSION}")
     end
 
     desc "ps", "List running Claude Swarm sessions"
     def ps
-      require_relative "commands/ps"
       Commands::Ps.new.execute
     end
 
     desc "show SESSION_ID", "Show detailed session information"
     def show(session_id)
-      require_relative "commands/show"
       Commands::Show.new.execute(session_id)
     end
 
-    desc "clean", "Remove stale session symlinks"
-    method_option :days, aliases: "-d", type: :numeric, default: 7,
-                         desc: "Remove sessions older than N days"
+    desc "clean", "Remove stale session symlinks and orphaned worktrees"
+    method_option :days,
+      aliases: "-d",
+      type: :numeric,
+      default: 7,
+      desc: "Remove sessions older than N days"
     def clean
-      run_dir = File.expand_path("~/.claude-swarm/run")
-      unless Dir.exist?(run_dir)
-        say "No run directory found", :yellow
-        return
-      end
+      # Clean stale symlinks
+      cleaned_symlinks = clean_stale_symlinks(options[:days])
 
-      cleaned = 0
-      Dir.glob("#{run_dir}/*").each do |symlink|
-        next unless File.symlink?(symlink)
+      # Clean orphaned worktrees
+      cleaned_worktrees = clean_orphaned_worktrees(options[:days])
 
-        begin
-          # Remove if target doesn't exist (stale)
-          unless File.exist?(File.readlink(symlink))
-            File.unlink(symlink)
-            cleaned += 1
-            next
-          end
-
-          # Remove if older than specified days
-          if File.stat(symlink).mtime < Time.now - (options[:days] * 86_400)
-            File.unlink(symlink)
-            cleaned += 1
-          end
-        rescue StandardError
-          # Skip problematic symlinks
-        end
+      if cleaned_symlinks.positive? || cleaned_worktrees.positive?
+        say("Cleaned #{cleaned_symlinks} stale symlink#{"s" unless cleaned_symlinks == 1}", :green)
+        say("Cleaned #{cleaned_worktrees} orphaned worktree#{"s" unless cleaned_worktrees == 1}", :green)
+      else
+        say("No cleanup needed", :green)
       end
+    end
 
-      say "Cleaned #{cleaned} stale session#{"s" unless cleaned == 1}", :green
+    desc "restore SESSION_ID", "Restore a previous session by ID"
+    def restore(session_id)
+      restore_session(session_id)
     end
 
     desc "watch SESSION_ID", "Watch session logs"
-    method_option :lines, aliases: "-n", type: :numeric, default: 100,
-                          desc: "Number of lines to show initially"
+    method_option :lines,
+      aliases: "-n",
+      type: :numeric,
+      default: 100,
+      desc: "Number of lines to show initially"
     def watch(session_id)
       # Find session path
       run_symlink = File.join(File.expand_path("~/.claude-swarm/run"), session_id)
       session_path = if File.symlink?(run_symlink)
-                       File.readlink(run_symlink)
-                     else
-                       # Search in sessions directory
-                       Dir.glob(File.expand_path("~/.claude-swarm/sessions/*/*")).find do |path|
-                         File.basename(path) == session_id
-                       end
-                     end
+        File.readlink(run_symlink)
+      else
+        # Search in sessions directory
+        Dir.glob(File.expand_path("~/.claude-swarm/sessions/*/*")).find do |path|
+          File.basename(path) == session_id
+        end
+      end
 
       unless session_path && Dir.exist?(session_path)
-        error "Session not found: #{session_id}"
-        exit 1
+        error("Session not found: #{session_id}")
+        exit(1)
       end
 
       log_file = File.join(session_path, "session.log")
       unless File.exist?(log_file)
-        error "Log file not found for session: #{session_id}"
-        exit 1
+        error("Log file not found for session: #{session_id}")
+        exit(1)
       end
 
       exec("tail", "-f", "-n", options[:lines].to_s, log_file)
     end
 
     desc "list-sessions", "List all available Claude Swarm sessions"
-    method_option :limit, aliases: "-l", type: :numeric, default: 10,
-                          desc: "Maximum number of sessions to display"
+    method_option :limit,
+      aliases: "-l",
+      type: :numeric,
+      default: 10,
+      desc: "Maximum number of sessions to display"
     def list_sessions
       sessions_dir = File.expand_path("~/.claude-swarm/sessions")
       unless Dir.exist?(sessions_dir)
-        say "No sessions found", :yellow
+        say("No sessions found", :yellow)
         return
       end
 
@@ -354,7 +453,7 @@ module ClaudeSwarm
           main_instance: main_instance,
           instances_count: mcp_files.size,
           swarm_name: swarm_name,
-          config_path: config_file
+          config_path: config_file,
         }
       rescue StandardError
         # Skip invalid manifests
@@ -362,7 +461,7 @@ module ClaudeSwarm
       end
 
       if sessions.empty?
-        say "No sessions found", :yellow
+        say("No sessions found", :yellow)
         return
       end
 
@@ -371,18 +470,18 @@ module ClaudeSwarm
       sessions = sessions.first(options[:limit])
 
       # Display sessions
-      say "\nAvailable sessions (newest first):\n", :bold
+      say("\nAvailable sessions (newest first):\n", :bold)
       sessions.each do |session|
-        say "\n#{session[:project]}/#{session[:id]}", :green
-        say "  Created: #{session[:created_at].strftime("%Y-%m-%d %H:%M:%S")}"
-        say "  Main: #{session[:main_instance]}"
-        say "  Instances: #{session[:instances_count]}"
-        say "  Swarm: #{session[:swarm_name]}"
-        say "  Config: #{session[:config_path]}", :cyan
+        say("\n#{session[:project]}/#{session[:id]}", :green)
+        say("  Created: #{session[:created_at].strftime("%Y-%m-%d %H:%M:%S")}")
+        say("  Main: #{session[:main_instance]}")
+        say("  Instances: #{session[:instances_count]}")
+        say("  Swarm: #{session[:swarm_name]}")
+        say("  Config: #{session[:config_path]}", :cyan)
       end
 
-      say "\nTo resume a session, run:", :bold
-      say "  claude-swarm --session-id <session-id>", :cyan
+      say("\nTo resume a session, run:", :bold)
+      say("  claude-swarm restore <session-id>", :cyan)
     end
 
     default_task :start
@@ -390,33 +489,33 @@ module ClaudeSwarm
     private
 
     def error(message)
-      say message, :red
+      say(message, :red)
     end
 
     def restore_session(session_id)
-      say "Restoring session: #{session_id}", :green
+      say("Restoring session: #{session_id}", :green)
 
       # Find the session path
       session_path = find_session_path(session_id)
       unless session_path
-        error "Session not found: #{session_id}"
-        exit 1
+        error("Session not found: #{session_id}")
+        exit(1)
       end
 
       begin
         # Load session info from instance ID in MCP config
         mcp_files = Dir.glob(File.join(session_path, "*.mcp.json"))
         if mcp_files.empty?
-          error "No MCP configuration files found in session"
-          exit 1
+          error("No MCP configuration files found in session")
+          exit(1)
         end
 
         # Load the configuration from the session directory
         config_file = File.join(session_path, "config.yml")
 
         unless File.exist?(config_file)
-          error "Configuration file not found in session"
-          exit 1
+          error("Configuration file not found in session")
+          exit(1)
         end
 
         # Change to the original start directory if it exists
@@ -425,10 +524,10 @@ module ClaudeSwarm
           original_dir = File.read(start_dir_file).strip
           if Dir.exist?(original_dir)
             Dir.chdir(original_dir)
-            say "Changed to original directory: #{original_dir}", :green unless options[:prompt]
+            say("Changed to original directory: #{original_dir}", :green) unless options[:prompt]
           else
-            error "Original directory no longer exists: #{original_dir}"
-            exit 1
+            error("Original directory no longer exists: #{original_dir}")
+            exit(1)
           end
         end
 
@@ -441,33 +540,34 @@ module ClaudeSwarm
           metadata = JSON.parse(File.read(session_metadata_file))
           if metadata["worktree"] && metadata["worktree"]["enabled"]
             worktree_name = metadata["worktree"]["name"]
-            say "Restoring with worktree: #{worktree_name}", :green unless options[:prompt]
+            say("Restoring with worktree: #{worktree_name}", :green) unless options[:prompt]
           end
         end
 
         # Create orchestrator with restoration mode
         generator = McpGenerator.new(config, vibe: options[:vibe], restore_session_path: session_path)
-        orchestrator = Orchestrator.new(config, generator,
-                                        vibe: options[:vibe],
-                                        prompt: options[:prompt],
-                                        stream_logs: options[:stream_logs],
-                                        debug: options[:debug],
-                                        restore_session_path: session_path,
-                                        worktree: worktree_name)
+        orchestrator = Orchestrator.new(
+          config,
+          generator,
+          vibe: options[:vibe],
+          prompt: options[:prompt],
+          stream_logs: options[:stream_logs],
+          debug: options[:debug],
+          restore_session_path: session_path,
+          worktree: worktree_name,
+          session_id: options[:session_id],
+        )
         orchestrator.start
       rescue StandardError => e
-        error "Failed to restore session: #{e.message}"
-        error e.backtrace.join("\n") if options[:debug]
-        exit 1
+        error("Failed to restore session: #{e.message}")
+        error(e.backtrace.join("\n")) if options[:debug]
+        exit(1)
       end
     end
 
     def find_session_path(session_id)
       sessions_dir = File.expand_path("~/.claude-swarm/sessions")
 
-      # Check if it's a full path
-      return session_id if File.exist?(File.join(session_id, "config.yml"))
-
       # Search for the session ID in all projects
       Dir.glob("#{sessions_dir}/*/#{session_id}").each do |path|
         config_path = File.join(path, "config.yml")
@@ -477,81 +577,100 @@ module ClaudeSwarm
       nil
     end
 
+    def clean_stale_symlinks(days)
+      run_dir = File.expand_path("~/.claude-swarm/run")
+      return 0 unless Dir.exist?(run_dir)
+
+      cleaned = 0
+      Dir.glob("#{run_dir}/*").each do |symlink|
+        next unless File.symlink?(symlink)
+
+        begin
+          # Remove if target doesn't exist (stale)
+          unless File.exist?(File.readlink(symlink))
+            File.unlink(symlink)
+            cleaned += 1
+            next
+          end
+
+          # Remove if older than specified days
+          if File.stat(symlink).mtime < Time.now - (days * 86_400)
+            File.unlink(symlink)
+            cleaned += 1
+          end
+        rescue StandardError
+          # Skip problematic symlinks
+        end
+      end
+
+      cleaned
+    end
+
+    def clean_orphaned_worktrees(days)
+      worktrees_dir = File.expand_path("~/.claude-swarm/worktrees")
+      return 0 unless Dir.exist?(worktrees_dir)
+
+      sessions_dir = File.expand_path("~/.claude-swarm/sessions")
+      cleaned = 0
+
+      Dir.glob("#{worktrees_dir}/*").each do |session_worktree_dir|
+        session_id = File.basename(session_worktree_dir)
+
+        # Skip if session still exists
+        next if Dir.glob("#{sessions_dir}/*/#{session_id}").any? { |path| File.exist?(File.join(path, "config.yml")) }
+
+        # Check age of worktree directory
+        begin
+          if File.stat(session_worktree_dir).mtime < Time.now - (days * 86_400)
+            # Remove all git worktrees in this session directory
+            Dir.glob("#{session_worktree_dir}/*/*").each do |worktree_path|
+              next unless File.directory?(worktree_path)
+
+              # Try to find the git repo and remove the worktree properly
+              git_dir = File.join(worktree_path, ".git")
+              if File.exist?(git_dir)
+                # Read the gitdir file to find the repo
+                gitdir_content = File.read(git_dir).strip
+                if gitdir_content.start_with?("gitdir:")
+                  repo_git_path = gitdir_content.sub("gitdir: ", "")
+                  # Extract repo path from .git/worktrees path
+                  repo_path = repo_git_path.split("/.git/worktrees/").first
+
+                  # Try to remove worktree via git
+                  system!(
+                    "git",
+                    "-C",
+                    repo_path,
+                    "worktree",
+                    "remove",
+                    worktree_path,
+                    "--force",
+                    out: File::NULL,
+                    err: File::NULL,
+                  )
+                end
+              end
+
+              # Force remove directory if it still exists
+              FileUtils.rm_rf(worktree_path)
+            end
+
+            # Remove the session worktree directory
+            FileUtils.rm_rf(session_worktree_dir)
+            cleaned += 1
+          end
+        rescue StandardError => e
+          say("Warning: Failed to clean worktree directory #{session_worktree_dir}: #{e.message}", :yellow) if options[:debug]
+        end
+      end
+
+      cleaned
+    end
+
     def build_generation_prompt(readme_content, output_file)
-      <<~PROMPT
-        You are a Claude Swarm configuration generator assistant. Your role is to help the user create a well-structured claude-swarm.yml file through an interactive conversation.
-
-        ## Claude Swarm Overview
-        Claude Swarm is a Ruby gem that orchestrates multiple Claude Code instances as a collaborative AI development team. It enables running AI agents with specialized roles, tools, and directory contexts, communicating via MCP (Model Context Protocol).
-
-        Key capabilities:
-        - Define multiple AI instances with different roles and specializations
-        - Set up connections between instances for collaboration
-        - Restrict tools based on each instance's responsibilities
-        - Run instances in different directories or Git worktrees
-        - Support for custom system prompts per instance
-        - Choose appropriate models (opus for complex tasks, sonnet for simpler ones)
-
-        ## Your Task
-        1. Start by asking about the user's project structure and development needs
-        2. Understand what kind of team they need (roles, specializations)
-        3. Suggest an appropriate swarm topology based on their needs
-        4. Help them refine and customize the configuration
-        5. Generate the final claude-swarm.yml content
-        6. When the configuration is complete, save it to: #{output_file || "a descriptive filename based on the swarm's function"}
-
-        ## File Naming Convention
-        #{output_file ? "The user has specified the output file: #{output_file}" : "Since no output file was specified, name the file based on the swarm's function. Examples:\n        - web-dev-swarm.yml for full-stack web development teams\n        - data-pipeline-swarm.yml for data processing teams\n        - microservices-swarm.yml for microservice architectures\n        - mobile-app-swarm.yml for mobile development teams\n        - ml-research-swarm.yml for machine learning teams\n        - devops-swarm.yml for infrastructure and deployment teams\n        Use descriptive names that clearly indicate the swarm's purpose."}
-
-        ## Configuration Structure
-        ```yaml
-        version: 1
-        swarm:
-          name: "Descriptive Swarm Name"
-          main: main_instance_name
-          instances:
-            instance_name:
-              description: "Clear description of role and responsibilities"
-              directory: ./path/to/directory
-              model: sonnet  # or opus for complex tasks
-              prompt: "Custom system prompt for specialization"
-              allowed_tools: [Read, Edit, Write, Bash]
-              connections: [other_instance_names]  # Optional
-        ```
-
-        ## Best Practices to Follow
-        - Use descriptive, role-based instance names (e.g., frontend_dev, api_architect)
-        - Write clear descriptions explaining each instance's responsibilities
-        - Choose opus model for complex architectural or algorithmic tasks and routine development.
-        - Choose sonnet model for simpler tasks
-        - Set up logical connections (e.g., lead → team members, architect → implementers), but avoid circular dependencies.
-        - Always add this to the end of every prompt: `For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.`
-        - Select tools based on each instance's actual needs:
-          - Read: For code review and analysis roles
-          - Edit: For active development roles
-          - Write: For creating new files
-          - Bash: For running commands, tests, builds
-          - MultiEdit: For editing multiple files at once
-          - WebFetch: For fetching information from the web
-          - WebSearch: For searching the web
-        - Use custom prompts to specialize each instance's expertise
-        - Organize directories to match project structure
-
-        ## Interactive Questions to Ask
-        - What type of project are you working on?
-        - What's your project's directory structure?
-        - What are the main technologies/frameworks you're using?
-        - What development tasks do you need help with?
-        - Do you need specialized roles (testing, DevOps, documentation)?
-        - Are there specific areas that need focused attention?
-        - Do you have multiple repositories or services to coordinate?
-
-        <full_readme>
-        #{readme_content}
-        </full_readme>
-
-        Start the conversation by greeting the user and asking: "What kind of project would you like to create a Claude Swarm for?"
-      PROMPT
+      template_path = File.expand_path("templates/generation_prompt.md.erb", __dir__)
+      template = File.read(template_path)
+      ERB.new(template, trim_mode: "-").result(binding)
     end
   end
 end