swarm_memory 2.1.5 → 2.1.6

data/lib/claude_swarm/tools/reset_session_tool.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module ClaudeSwarm
-  module Tools
-    class ResetSessionTool < FastMcp::Tool
-      tool_name "reset_session"
-      description "Reset the Claude session for this agent, starting fresh on the next task"
-
-      arguments do
-        # No arguments needed
-      end
-
-      def call
-        executor = ClaudeMcpServer.executor
-        executor.reset_session
-
-        {
-          success: true,
-          message: "Session has been reset",
-        }
-      end
-    end
-  end
-end

data/lib/claude_swarm/tools/session_info_tool.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module ClaudeSwarm
-  module Tools
-    class SessionInfoTool < FastMcp::Tool
-      tool_name "session_info"
-      description "Get information about the current Claude session for this agent"
-
-      arguments do
-        # No arguments needed
-      end
-
-      def call
-        executor = ClaudeMcpServer.executor
-
-        {
-          has_session: executor.has_session?,
-          session_id: executor.session_id,
-          working_directory: executor.working_directory,
-        }
-      end
-    end
-  end
-end

data/lib/claude_swarm/tools/task_tool.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module ClaudeSwarm
-  module Tools
-    class TaskTool < FastMcp::Tool
-      tool_name "task"
-      description "Execute a task using Claude Code. There is no description parameter."
-      annotations(read_only_hint: true, open_world_hint: false, destructive_hint: false)
-
-      arguments do
-        required(:prompt).filled(:string).description("The task or question for the agent")
-        optional(:new_session).filled(:bool).description("Start a new session (default: false)")
-        optional(:system_prompt).filled(:string).description("Override the system prompt for this request")
-        optional(:description).filled(:string).description("A description for the request")
-        optional(:thinking_budget).filled(:string).description("Thinking budget: \"think\" < \"think hard\" < \"think harder\" < \"ultrathink\". Each level increases Claude's thinking allocation. Auto-select based on task complexity.")
-      end
-
-      def call(prompt:, new_session: false, system_prompt: nil, description: nil, thinking_budget: nil)
-        executor = ClaudeMcpServer.executor
-        instance_config = ClaudeMcpServer.instance_config
-
-        # Prepend thinking budget to prompt if provided
-        final_prompt = if thinking_budget
-          "#{thinking_budget}: #{prompt}"
-        else
-          prompt
-        end
-
-        options = {
-          new_session: new_session,
-          system_prompt: system_prompt || instance_config[:prompt],
-          description: description,
-        }
-
-        # Add allowed tools from instance config
-        options[:allowed_tools] = instance_config[:allowed_tools] if instance_config[:allowed_tools]&.any?
-
-        # Add disallowed tools from instance config
-        options[:disallowed_tools] = instance_config[:disallowed_tools] if instance_config[:disallowed_tools]&.any?
-
-        # Add connections from instance config
-        options[:connections] = instance_config[:connections] if instance_config[:connections]&.any?
-
-        response = executor.execute(final_prompt, options)
-
-        # Validate the response has a result
-        unless response.is_a?(Hash) && response.key?("result")
-          raise "Invalid response from executor: missing 'result' field. Response structure: #{response.keys.join(", ")}"
-        end
-
-        result = response["result"]
-
-        # Validate the result is not empty
-        if result.nil? || (result.is_a?(String) && result.strip.empty?)
-          raise "Agent #{instance_config[:name]} returned an empty response. The task was executed but no content was provided."
-        end
-
-        # Return just the result text as expected by MCP
-        result
-      end
-    end
-  end
-end

data/lib/claude_swarm/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module ClaudeSwarm
-  VERSION = "1.0.10"
-end

data/lib/claude_swarm/worktree_manager.rb

@@ -1,475 +0,0 @@
-# frozen_string_literal: true
-
-module ClaudeSwarm
-  class WorktreeManager
-    include SystemUtils
-
-    attr_reader :shared_worktree_name, :created_worktrees
-
-    def initialize(cli_worktree_option = nil, session_id: nil)
-      @cli_worktree_option = cli_worktree_option
-      @session_id = session_id
-      # Generate a name based on session ID if no option given, empty string, or default "worktree" from Thor
-      @shared_worktree_name = if cli_worktree_option.nil? || cli_worktree_option.empty? || cli_worktree_option == "worktree"
-        generate_worktree_name
-      else
-        cli_worktree_option
-      end
-      @created_worktrees = {} # Maps "repo_root:worktree_name" to worktree_path
-      @instance_worktree_configs = {} # Stores per-instance worktree settings
-      @instance_directories = {} # Stores original resolved directories for each instance
-      @instance_worktree_paths = {} # Stores worktree paths for each instance
-    end
-
-    def setup_worktrees(instances)
-      # First pass: determine worktree configuration for each instance
-      instances.each do |instance|
-        worktree_config = determine_worktree_config(instance)
-        @instance_worktree_configs[instance[:name]] = worktree_config
-      end
-
-      # Second pass: create necessary worktrees
-      worktrees_to_create = collect_worktrees_to_create(instances)
-      worktrees_to_create.each do |repo_root, worktree_name|
-        create_worktree(repo_root, worktree_name)
-      end
-
-      # Third pass: map instance directories to worktree paths
-      instances.each do |instance|
-        worktree_config = @instance_worktree_configs[instance[:name]]
-
-        if ENV["CLAUDE_SWARM_DEBUG"]
-          puts "Debug [WorktreeManager]: Processing instance #{instance[:name]}"
-          puts "Debug [WorktreeManager]: Worktree config: #{worktree_config.inspect}"
-        end
-
-        # Store original directories (resolved)
-        original_dirs = instance[:directories] || [instance[:directory]]
-        resolved_dirs = original_dirs.map { |dir| dir ? File.expand_path(dir) : nil }.compact
-        @instance_directories[instance[:name]] = resolved_dirs
-
-        if worktree_config[:skip]
-          # No worktree, paths remain the same
-          @instance_worktree_paths[instance[:name]] = resolved_dirs
-          next
-        end
-
-        worktree_name = worktree_config[:name]
-        mapped_dirs = original_dirs.map { |dir| map_to_worktree_path(dir, worktree_name) }
-
-        # Store the worktree paths
-        @instance_worktree_paths[instance[:name]] = mapped_dirs
-
-        if ENV["CLAUDE_SWARM_DEBUG"]
-          puts "Debug [WorktreeManager]: Original dirs: #{original_dirs.inspect}"
-          puts "Debug [WorktreeManager]: Mapped dirs: #{mapped_dirs.inspect}"
-        end
-
-        if instance[:directories]
-          instance[:directories] = mapped_dirs
-          # Also update the single directory field for backward compatibility
-          instance[:directory] = mapped_dirs.first
-        else
-          instance[:directory] = mapped_dirs.first
-        end
-
-        puts "Debug [WorktreeManager]: Updated instance[:directory] to: #{instance[:directory]}" if ENV["CLAUDE_SWARM_DEBUG"]
-      end
-    end
-
-    def map_to_worktree_path(original_path, worktree_name)
-      return original_path unless original_path
-
-      expanded_path = File.expand_path(original_path)
-      repo_root = find_git_root(expanded_path)
-
-      if ENV["CLAUDE_SWARM_DEBUG"]
-        puts "Debug [map_to_worktree_path]: Original path: #{original_path}"
-        puts "Debug [map_to_worktree_path]: Expanded path: #{expanded_path}"
-        puts "Debug [map_to_worktree_path]: Repo root: #{repo_root}"
-      end
-
-      return original_path unless repo_root
-
-      # Check if we have a worktree for this repo and name
-      worktree_key = "#{repo_root}:#{worktree_name}"
-      worktree_path = @created_worktrees[worktree_key]
-
-      if ENV["CLAUDE_SWARM_DEBUG"]
-        puts "Debug [map_to_worktree_path]: Worktree key: #{worktree_key}"
-        puts "Debug [map_to_worktree_path]: Worktree path: #{worktree_path}"
-        puts "Debug [map_to_worktree_path]: Created worktrees: #{@created_worktrees.inspect}"
-      end
-
-      return original_path unless worktree_path
-
-      # Calculate relative path from repo root
-      relative_path = Pathname.new(expanded_path).relative_path_from(Pathname.new(repo_root)).to_s
-
-      # Return the equivalent path in the worktree
-      result = if relative_path == "."
-        worktree_path
-      else
-        File.join(worktree_path, relative_path)
-      end
-
-      puts "Debug [map_to_worktree_path]: Result: #{result}" if ENV["CLAUDE_SWARM_DEBUG"]
-
-      result
-    end
-
-    def cleanup_worktrees
-      @created_worktrees.each do |worktree_key, worktree_path|
-        repo_root = worktree_key.split(":", 2).first
-        next unless File.exist?(worktree_path)
-
-        # Check for uncommitted changes
-        if has_uncommitted_changes?(worktree_path)
-          puts "⚠️  Warning: Worktree has uncommitted changes, skipping cleanup: #{worktree_path}" unless ENV["CLAUDE_SWARM_PROMPT"]
-          next
-        end
-
-        # Check for unpushed commits
-        has_unpushed = has_unpushed_commits?(worktree_path)
-
-        if has_unpushed
-          puts "⚠️  Warning: Worktree has unpushed commits, skipping cleanup: #{worktree_path}" unless ENV["CLAUDE_SWARM_PROMPT"]
-          next
-        end
-
-        puts "Removing worktree: #{worktree_path}" unless ENV["CLAUDE_SWARM_PROMPT"]
-
-        # Remove the worktree
-        output, status = Open3.capture2e("git", "-C", repo_root, "worktree", "remove", worktree_path)
-        next if status.success?
-
-        puts "Warning: Failed to remove worktree: #{output}"
-        # Try force remove
-        output, status = Open3.capture2e("git", "-C", repo_root, "worktree", "remove", "--force", worktree_path)
-        puts "Force remove result: #{output}" unless status.success?
-      end
-
-      # Clean up external worktree directories
-      cleanup_external_directories
-    rescue StandardError => e
-      puts "Error during worktree cleanup: #{e.message}"
-    end
-
-    def cleanup_external_directories
-      # Remove session-specific worktree directory if it exists and is empty
-      return unless @session_id
-
-      session_worktree_dir = ClaudeSwarm.joined_worktrees_dir(@session_id)
-      return unless File.exist?(session_worktree_dir)
-
-      # Try to remove the directory tree
-      begin
-        # Remove all empty directories recursively
-        Dir.glob(File.join(session_worktree_dir, "**/*"), File::FNM_DOTMATCH).reverse_each do |path|
-          next if path.end_with?("/.", "/..")
-
-          FileUtils.rmdir(path) if File.directory?(path) && Dir.empty?(path)
-        end
-        # Finally try to remove the session directory itself
-        FileUtils.rmdir(session_worktree_dir) if Dir.empty?(session_worktree_dir)
-      rescue Errno::ENOTEMPTY
-        puts "Note: Session worktree directory not empty, leaving in place: #{session_worktree_dir}" unless ENV["CLAUDE_SWARM_PROMPT"]
-      rescue StandardError => e
-        puts "Warning: Error cleaning up worktree directories: #{e.message}" unless ENV["CLAUDE_SWARM_PROMPT"]
-      end
-    end
-
-    def session_metadata
-      # Build instance details with resolved paths and worktree mappings
-      instance_details = {}
-
-      @instance_worktree_configs.each do |instance_name, worktree_config|
-        instance_details[instance_name] = {
-          worktree_config: worktree_config,
-          directories: @instance_directories[instance_name] || {},
-          worktree_paths: @instance_worktree_paths[instance_name] || {},
-        }
-      end
-
-      {
-        enabled: true,
-        shared_name: @shared_worktree_name,
-        created_paths: @created_worktrees.dup,
-        instance_configs: instance_details,
-      }
-    end
-
-    # Deprecated method for backward compatibility
-    def worktree_name
-      @shared_worktree_name
-    end
-
-    private
-
-    def external_worktree_path(repo_root, worktree_name)
-      # Get repository name from path
-      repo_name = sanitize_repo_name(File.basename(repo_root))
-
-      # Add a short hash of the full path to handle multiple repos with same name
-      path_hash = Digest::SHA256.hexdigest(repo_root)[0..7]
-      unique_repo_name = "#{repo_name}-#{path_hash}"
-
-      # Build external path: ~/.claude-swarm/worktrees/[session_id]/[repo_name-hash]/[worktree_name]
-      base_dir = ClaudeSwarm.joined_worktrees_dir
-
-      # Validate base directory is accessible
-      begin
-        FileUtils.mkdir_p(base_dir)
-      rescue Errno::EACCES
-        # Fall back to temp directory if home is not writable
-        base_dir = File.join(Dir.tmpdir, ".claude-swarm", "worktrees")
-        FileUtils.mkdir_p(base_dir)
-      end
-
-      session_dir = @session_id || "default"
-      File.join(base_dir, session_dir, unique_repo_name, worktree_name)
-    end
-
-    def sanitize_repo_name(name)
-      # Replace problematic characters with underscores
-      name.gsub(/[^a-zA-Z0-9._-]/, "_")
-    end
-
-    def generate_worktree_name
-      # Use session ID if available, otherwise generate a random suffix
-      if @session_id
-        "worktree-#{@session_id}"
-      else
-        # Fallback to random suffix for tests or when session ID is not available
-        random_suffix = SecureRandom.alphanumeric(5).downcase
-        "worktree-#{random_suffix}"
-      end
-    end
-
-    def determine_worktree_config(instance)
-      # Check instance-level worktree setting
-      instance_worktree = instance[:worktree]
-
-      if instance_worktree.nil?
-        # No instance-level setting, follow CLI behavior
-        if @cli_worktree_option.nil?
-          { skip: true }
-        else
-          { skip: false, name: @shared_worktree_name }
-        end
-      elsif instance_worktree == false
-        # Explicitly disabled for this instance
-        { skip: true }
-      elsif instance_worktree == true
-        # Use shared worktree (either from CLI or auto-generated)
-        { skip: false, name: @shared_worktree_name }
-      elsif instance_worktree.is_a?(String)
-        # Use custom worktree name
-        { skip: false, name: instance_worktree }
-      else
-        raise Error, "Invalid worktree configuration for instance '#{instance[:name]}': #{instance_worktree.inspect}"
-      end
-    end
-
-    def collect_worktrees_to_create(instances)
-      worktrees_needed = {}
-
-      instances.each do |instance|
-        worktree_config = @instance_worktree_configs[instance[:name]]
-        next if worktree_config[:skip]
-
-        worktree_name = worktree_config[:name]
-        directories = instance[:directories] || [instance[:directory]]
-
-        directories.each do |dir|
-          next unless dir
-
-          expanded_dir = File.expand_path(dir)
-          repo_root = find_git_root(expanded_dir)
-          next unless repo_root
-
-          # Track unique repo_root:worktree_name combinations
-          worktrees_needed[repo_root] ||= Set.new
-          worktrees_needed[repo_root].add(worktree_name)
-        end
-      end
-
-      # Convert to array of [repo_root, worktree_name] pairs
-      result = []
-      worktrees_needed.each do |repo_root, worktree_names|
-        worktree_names.each do |worktree_name|
-          result << [repo_root, worktree_name]
-        end
-      end
-      result
-    end
-
-    def find_git_root(path)
-      current = File.expand_path(path)
-
-      while current != "/"
-        return current if File.exist?(File.join(current, ".git"))
-
-        current = File.dirname(current)
-      end
-
-      nil
-    end
-
-    def create_worktree(repo_root, worktree_name)
-      worktree_key = "#{repo_root}:#{worktree_name}"
-      # Create worktrees in external directory
-      worktree_path = external_worktree_path(repo_root, worktree_name)
-
-      # Check if worktree already exists
-      if File.exist?(worktree_path)
-        puts "Using existing worktree: #{worktree_path}" unless ENV["CLAUDE_SWARM_PROMPT"]
-        @created_worktrees[worktree_key] = worktree_path
-        return
-      end
-
-      # Ensure parent directory exists with proper error handling
-      begin
-        FileUtils.mkdir_p(File.dirname(worktree_path))
-      rescue Errno::EACCES => e
-        raise Error, "Permission denied creating worktree directory: #{e.message}"
-      rescue Errno::ENOSPC => e
-        raise Error, "Not enough disk space for worktree: #{e.message}"
-      rescue StandardError => e
-        raise Error, "Failed to create worktree directory: #{e.message}"
-      end
-
-      # Get current branch
-      output, status = Open3.capture2e("git", "-C", repo_root, "rev-parse", "--abbrev-ref", "HEAD")
-      raise Error, "Failed to get current branch in #{repo_root}: #{output}" unless status.success?
-
-      current_branch = output.strip
-
-      # Create worktree with a new branch based on current branch
-      branch_name = worktree_name
-      puts "Creating worktree: #{worktree_path} with branch: #{branch_name}" unless ENV["CLAUDE_SWARM_PROMPT"]
-
-      # Create worktree with a new branch
-      output, status = Open3.capture2e("git", "-C", repo_root, "worktree", "add", "-b", branch_name, worktree_path, current_branch)
-
-      # If branch already exists, try without -b flag
-      if !status.success? && output.include?("already exists")
-        puts "Branch #{branch_name} already exists, using existing branch" unless ENV["CLAUDE_SWARM_PROMPT"]
-        output, status = Open3.capture2e("git", "-C", repo_root, "worktree", "add", worktree_path, branch_name)
-      end
-
-      # If worktree path is already in use, it might be from a previous run
-      if !status.success? && output.include?("is already used by worktree")
-        puts "Worktree path already in use, checking if it's valid" unless ENV["CLAUDE_SWARM_PROMPT"]
-        # Check if the worktree actually exists at that path
-        if File.exist?(File.join(worktree_path, ".git"))
-          puts "Using existing worktree: #{worktree_path}" unless ENV["CLAUDE_SWARM_PROMPT"]
-          @created_worktrees[worktree_key] = worktree_path
-          return
-        else
-          # The worktree is registered but the directory doesn't exist, prune and retry
-          puts "Pruning stale worktree references" unless ENV["CLAUDE_SWARM_PROMPT"]
-          begin
-            system!("git", "-C", repo_root, "worktree", "prune")
-          rescue Error
-            # Ignore errors when pruning
-          end
-          output, status = Open3.capture2e("git", "-C", repo_root, "worktree", "add", worktree_path, branch_name)
-        end
-      end
-
-      raise Error, "Failed to create worktree: #{output}" unless status.success?
-
-      @created_worktrees[worktree_key] = worktree_path
-    end
-
-    def has_uncommitted_changes?(worktree_path)
-      # Check if there are any uncommitted changes (staged or unstaged)
-      output, status = Open3.capture2e("git", "-C", worktree_path, "status", "--porcelain")
-      return false unless status.success?
-
-      # If output is not empty, there are changes
-      !output.strip.empty?
-    end
-
-    def has_unpushed_commits?(worktree_path)
-      # Get the current branch
-      branch_output, branch_status = Open3.capture2e("git", "-C", worktree_path, "rev-parse", "--abbrev-ref", "HEAD")
-      return false unless branch_status.success?
-
-      current_branch = branch_output.strip
-
-      # Check if the branch has an upstream
-      _, upstream_status = Open3.capture2e("git", "-C", worktree_path, "rev-parse", "--abbrev-ref", "#{current_branch}@{upstream}")
-
-      # If branch has upstream, check against it
-      if upstream_status.success?
-        # Check for unpushed commits against upstream
-        unpushed_output, unpushed_status = Open3.capture2e("git", "-C", worktree_path, "rev-list", "HEAD", "^#{current_branch}@{upstream}")
-        return false unless unpushed_status.success?
-
-        # If output is not empty, there are unpushed commits
-        return !unpushed_output.strip.empty?
-      end
-
-      # No upstream - this is likely a new branch created by the worktree
-      # The key insight: when git worktree add -b creates a branch, it creates it in BOTH
-      # the worktree AND the main repository. So we need to check the reflog in the worktree
-      # to see if any NEW commits were made after the worktree was created.
-
-      # Use reflog to check if any commits were made in this worktree
-      reflog_output, reflog_status = Open3.capture2e("git", "-C", worktree_path, "reflog", "--format=%H %gs", current_branch)
-
-      if reflog_status.success? && !reflog_output.strip.empty?
-        reflog_lines = reflog_output.strip.split("\n")
-
-        # Look for commit entries (not branch creation)
-        commit_entries = reflog_lines.select { |line| line.include?(" commit:") || line.include?(" commit (amend):") }
-
-        # If there are commit entries in the reflog, there are unpushed commits
-        return !commit_entries.empty?
-      end
-
-      # As a fallback, assume no unpushed commits
-      false
-    end
-
-    def find_original_repo_for_worktree(worktree_path)
-      # Get the git directory for this worktree
-      _, git_dir_status = Open3.capture2e("git", "-C", worktree_path, "rev-parse", "--git-dir")
-      return unless git_dir_status.success?
-
-      # Read the gitdir file to find the main repository
-      # Worktree .git files contain: gitdir: /path/to/main/repo/.git/worktrees/worktree-name
-      if File.file?(File.join(worktree_path, ".git"))
-        gitdir_content = File.read(File.join(worktree_path, ".git")).strip
-        if gitdir_content =~ /^gitdir: (.+)$/
-          git_path = ::Regexp.last_match(1)
-          # Extract the main repo path from the worktree git path
-          # Format: /path/to/repo/.git/worktrees/worktree-name
-          return ::Regexp.last_match(1) if git_path =~ %r{^(.+)/\.git/worktrees/[^/]+$}
-        end
-      end
-
-      nil
-    end
-
-    def find_base_branch(repo_path)
-      # Try to find the base branch - check for main, master, or the default branch
-      ["main", "master"].each do |branch|
-        _, status = Open3.capture2e("git", "-C", repo_path, "rev-parse", "--verify", "refs/heads/#{branch}")
-        return branch if status.success?
-      end
-
-      # Try to get the default branch from HEAD
-      output, status = Open3.capture2e("git", "-C", repo_path, "symbolic-ref", "refs/remotes/origin/HEAD")
-      if status.success?
-        # Extract branch name from refs/remotes/origin/main
-        branch_match = output.strip.match(%r{refs/remotes/origin/(.+)$})
-        return branch_match[1] if branch_match
-      end
-
-      nil
-    end
-  end
-end

data/lib/claude_swarm/yaml_loader.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module ClaudeSwarm
-  # Provides consistent YAML loading across the application
-  module YamlLoader
-    class << self
-      # Load a YAML configuration file (enables aliases for configuration flexibility)
-      # @param file_path [String] Path to the configuration file
-      # @return [Hash] The loaded configuration
-      # @raise [ClaudeSwarm::Error] Re-raises with a more descriptive error message
-      def load_config_file(file_path)
-        YAML.load_file(file_path, aliases: true)
-      rescue Errno::ENOENT
-        raise ClaudeSwarm::Error, "Configuration file not found: #{file_path}"
-      rescue Psych::SyntaxError => e
-        raise ClaudeSwarm::Error, "Invalid YAML syntax in #{file_path}: #{e.message}"
-      rescue Psych::BadAlias => e
-        raise ClaudeSwarm::Error, "Invalid YAML alias in #{file_path}: #{e.message}"
-      end
-    end
-  end
-end

data/lib/claude_swarm.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-# Standard library dependencies
-require "bundler"
-require "digest"
-require "English"
-require "erb"
-require "fileutils"
-require "io/console"
-require "json"
-require "logger"
-require "open3"
-require "pathname"
-require "pty"
-require "securerandom"
-require "set"
-require "shellwords"
-require "time"
-require "timeout"
-require "tmpdir"
-require "yaml"
-
-# External dependencies
-require "claude_sdk"
-require "fast_mcp"
-require "mcp_client"
-require "thor"
-
-require_relative "claude_swarm/version"
-# Zeitwerk setup
-require "zeitwerk"
-loader = Zeitwerk::Loader.new
-loader.tag = File.basename(__FILE__, ".rb")
-loader.ignore("#{__dir__}/claude_swarm/templates")
-loader.push_dir("#{__dir__}/claude_swarm", namespace: ClaudeSwarm)
-loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
-loader.inflector.inflect(
-  "cli" => "CLI",
-  "openai" => "OpenAI",
-)
-loader.setup
-
-module ClaudeSwarm
-  class Error < StandardError; end
-
-  class << self
-    def home_dir
-      ENV.fetch("CLAUDE_SWARM_HOME") { File.expand_path("~/.claude-swarm") }
-    end
-
-    def joined_home_dir(*strings)
-      File.join(home_dir, *strings)
-    end
-
-    def joined_run_dir(*strings)
-      joined_home_dir("run", *strings)
-    end
-
-    def joined_sessions_dir(*strings)
-      joined_home_dir("sessions", *strings)
-    end
-
-    def joined_worktrees_dir(*strings)
-      joined_home_dir("worktrees", *strings)
-    end
-  end
-end