claude_swarm 0.3.8 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a256a8d09a86290b06002437b38bc9092b7d83c1e4d1e0f4866b37cd1251bd99
-  data.tar.gz: d5eeec5e3a350dac2a04860c64c00043a8618fd29d40b9e1acf77e86b2f3fd49
+  metadata.gz: a44d1b33e538b1efaeca7eb223f09bd617fcb4ba2288d7844773ae5908a10248
+  data.tar.gz: 28312f81eada550b05bbf568807be51c5077366c08d168b928a35a4d356148da
 SHA512:
-  metadata.gz: 3bb8119400be33d056b795aaea4f7f3d045d85a29d830cc42fe8c3dba0fd406100553b68740fe884e2e769e9685c439983d3a38ee52f55730f9f1ff7b40ddbff
-  data.tar.gz: a2dd8483358b673698e7ca3a71d1952fa0b2c85d0daf9cd2ff06c5f62d78f7ffebacc95a0e622cfb3f62f229e81c8177c5d6b263303b88c26c592ba53e7c7607
+  metadata.gz: 2d8ba31f8a64f91060b980ee90bea57c736e4541410eeb36c4c78bdc602f7c3335ea82a388c0b61847a04c90210fb432c2d525df4f4bfa85cbe3725a0034b260
+  data.tar.gz: 15180a4a4df3f9ccc55da9dd40769435c1ba650a575b476c10d7c0b16d650bb1f65524b8d44a10d731e9aed3dcda886b0bb63fd2b64e5665c5ba1cc22633182b

data/.claude/commands/release.md

@@ -0,0 +1,27 @@
+---
+description: Bump version, update changelog, and prepare for release
+allowed-tools: [Read, Edit, Bash]
+---
+
+Prepare a new release for Claude Swarm by:
+
+1. Read the current version from @lib/claude_swarm/version.rb
+2. Determine the new version number: $ARGUMENTS (should be in format like 0.3.11 or use patch/minor/major)
+3. Update the version in @lib/claude_swarm/version.rb 
+4. Update @CHANGELOG.md:
+   - Change "## [Unreleased]" to "## [new_version]"
+   - Add a new "## [Unreleased]" section at the top for future changes
+5. Run these commands:
+   - `git add .`
+   - `bundle install` 
+   - `git add .`
+   - `git commit -m "Release version X.X.X"`
+   - `git push`
+
+Make sure all tests pass before releasing. The version argument should be either:
+- A specific version number (e.g., 0.3.11)
+- "patch" for incrementing the patch version (0.3.10 -> 0.3.11)
+- "minor" for incrementing the minor version (0.3.10 -> 0.4.0)
+- "major" for incrementing the major version (0.3.10 -> 1.0.0)
+
+If no argument is provided, default to "patch".

data/CHANGELOG.md

@@ -1,3 +1,38 @@
+## [0.3.10]
+
+### Added
+- **Token-based cost calculation for main instance**: Main instance costs in interactive mode are now calculated from token usage using Claude model pricing
+  - Opus: $15/MTok input, $75/MTok output, $18.75/MTok cache write, $1.50/MTok cache read
+  - Sonnet: $3/MTok input, $15/MTok output, $3.75/MTok cache write, $0.30/MTok cache read  
+  - Haiku: $0.80/MTok input, $4/MTok output, $1/MTok cache write, $0.08/MTok cache read
+  - Automatically extracts usage data from assistant messages in session logs
+
+### Changed
+- **Simplified cost calculation**: Switched from cumulative `total_cost_usd` to per-request `cost_usd` for non-main instances
+  - Removed complex session reset detection logic
+  - Now uses simple summation of individual request costs
+  - More accurate and maintainable cost tracking
+- **Improved ps command cost display**: 
+  - Only shows cost warning when sessions are missing main instance data
+  - Adds asterisk (*) indicator to costs that exclude main instance
+  - Displays accurate total costs including main instance when available
+
+### Fixed
+- **Main instance log format consistency**: Fixed transcript logs in interactive mode to match standard instance log format
+  - Converted transcript wrapper to request/assistant event structure
+  - Properly extracts text content from nested message arrays
+  - Ensures uniform log parsing across all instances
+
+## [0.3.9]
+
+### Added
+- **Main instance transcript integration**: Main Claude instance activity is now captured in session.log.json during interactive mode
+  - Automatically configures SessionStart hook for main instance to capture transcript path
+  - Background thread continuously tails transcript file and integrates entries into session.log.json
+  - Filters out summary entries to avoid duplicate conversation titles
+  - Uses file locking for thread-safe writes to maintain consistency
+  - Provides complete session history including main instance interactions
+
 ## [0.3.8]
 
 ### Added
@@ -9,6 +44,14 @@
   - Connected instances receive hooks via SDK's `settings` attribute
   - Full environment variable interpolation support in hook configurations
   - See README.md "Hooks Configuration" section for usage examples
+- **Persistent HTTP connections for OpenAI**: Added `faraday-net_http_persistent` dependency and configured OpenAI client to use persistent connections
+  - Improves performance when making multiple API requests by reusing HTTP connections
+  - Automatically configured for all OpenAI instances
+
+### Changed
+- **Improved OpenAI executor code organization**: Refactored internal methods for better maintainability
+  - Extracted configuration building and response handling into focused private methods
+  - Improved code readability with functional patterns
 
 ### Fixed
 - **Settings integration**: Fixed passing settings to Claude instances

data/README.md

@@ -824,8 +824,8 @@ swarm:
 claude-swarm
 
 # Specify a different configuration file
-claude-swarm my-swarm.yml
-claude-swarm team-config.yml
+claude-swarm start my-swarm.yml
+claude-swarm start team-config.yml
 
 # Run with --dangerously-skip-permissions for all instances
 claude-swarm --vibe

data/lib/claude_swarm/cli.rb

@@ -693,7 +693,12 @@ module ClaudeSwarm
     def build_generation_prompt(readme_content, output_file)
       template_path = File.expand_path("templates/generation_prompt.md.erb", __dir__)
       template = File.read(template_path)
-      ERB.new(template, trim_mode: "-").result(binding)
+      <<~PROMPT
+        #{ERB.new(template, trim_mode: "-").result(binding)}
+
+        Start the conversation by greeting the user and asking: 'What kind of project would you like to create a Claude Swarm for?'
+        Say: 'I am ready to start'
+      PROMPT
     end
   end
 end

data/lib/claude_swarm/commands/ps.rb

@@ -34,6 +34,9 @@ module ClaudeSwarm
           return
         end
 
+        # Check if any session is missing main instance costs
+        any_missing_main = sessions.any? { |s| !s[:main_has_cost] }
+
         # Column widths
         col_session = 15
         col_swarm = 25
@@ -50,13 +53,23 @@ module ClaudeSwarm
         }  #{
           "UPTIME".ljust(col_uptime)
         }  DIRECTORY"
-        puts "\n⚠️  \e[3mTotal cost does not include the cost of the main instance\e[0m\n\n"
+
+        # Only show warning if any session is missing main instance costs
+        if any_missing_main
+          puts "\n⚠️  \e[3mTotal cost does not include the cost of the main instance for some sessions\e[0m\n\n"
+        else
+          puts
+        end
+
         puts header
         puts "-" * header.length
 
         # Display sessions sorted by start time (newest first)
         sessions.sort_by { |s| s[:start_time] }.reverse.each do |session|
           cost_str = format("$%.4f", session[:cost])
+          # Add asterisk if this session is missing main instance cost
+          cost_str += "*" unless session[:main_has_cost]
+
           puts "#{
             session[:id].ljust(col_session)
           }  #{
@@ -107,7 +120,12 @@ module ClaudeSwarm
 
         # Calculate total cost from JSON log
         log_file = File.join(session_dir, "session.log.json")
-        total_cost = SessionCostCalculator.calculate_simple_total(log_file)
+        cost_result = SessionCostCalculator.calculate_total_cost(log_file)
+        total_cost = cost_result[:total_cost]
+
+        # Check if main instance has cost data
+        instances_with_cost = cost_result[:instances_with_cost]
+        main_has_cost = main_instance && instances_with_cost.include?(main_instance)
 
         # Get uptime from session metadata or fallback to directory creation time
         start_time = get_start_time(session_dir)
@@ -117,6 +135,7 @@ module ClaudeSwarm
           id: session_id,
           name: swarm_name,
           cost: total_cost,
+          main_has_cost: main_has_cost,
           uptime: uptime,
           directory: directories_str,
           start_time: start_time,

data/lib/claude_swarm/hooks/session_start_hook.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This hook is called when Claude Code starts a session
+# It saves the transcript path for the main instance so the orchestrator can tail it
+
+require "json"
+require "fileutils"
+
+# Read input from stdin
+begin
+  stdin_data = $stdin.read
+  input = JSON.parse(stdin_data)
+rescue => e
+  # Return error response
+  puts JSON.generate({
+    "success" => false,
+    "error" => "Failed to read/parse input: #{e.message}",
+  })
+  exit(1)
+end
+
+# Get session path from command-line argument or environment
+session_path = ARGV[0] || ENV["CLAUDE_SWARM_SESSION_PATH"]
+
+if session_path && input["transcript_path"]
+  # Write the transcript path to a known location
+  path_file = File.join(session_path, "main_instance_transcript.path")
+  File.write(path_file, input["transcript_path"])
+
+  # Return success
+  puts JSON.generate({
+    "success" => true,
+  })
+else
+  # Return error if missing required data
+  puts JSON.generate({
+    "success" => false,
+    "error" => "Missing session path or transcript path",
+  })
+  exit(1)
+end

data/lib/claude_swarm/openai/executor.rb

@@ -1,8 +1,32 @@
 # frozen_string_literal: true
 
+require "openai"
+require "faraday/net_http_persistent"
+require "faraday/retry"
+
 module ClaudeSwarm
   module OpenAI
     class Executor < BaseExecutor
+      # Static configuration for Faraday retry middleware
+      FARADAY_RETRY_CONFIG = {
+        max: 3, # Maximum number of retries
+        interval: 0.5, # Initial delay between retries (in seconds)
+        interval_randomness: 0.5, # Randomness factor for retry intervals
+        backoff_factor: 2, # Exponential backoff factor
+        exceptions: [
+          Faraday::TimeoutError,
+          Faraday::ConnectionFailed,
+          Faraday::ServerError, # Retry on 5xx errors
+        ].freeze,
+        retry_statuses: [429, 500, 502, 503, 504].freeze, # HTTP status codes to retry
+      }.freeze
+
+      # Static configuration for OpenAI client
+      OPENAI_CLIENT_CONFIG = {
+        log_errors: true,
+        request_timeout: 1800, # 30 minutes
+      }.freeze
+
       def initialize(working_directory: Dir.pwd, model: nil, mcp_config: nil, vibe: false,
         instance_name: nil, instance_id: nil, calling_instance: nil, calling_instance_id: nil,
         claude_session_id: nil, additional_directories: [], debug: false,
@@ -56,19 +80,8 @@ module ClaudeSwarm
         # Calculate duration
         duration_ms = ((Time.now - start_time) * 1000).round
 
-        # Format response similar to ClaudeCodeExecutor
-        response = {
-          "type" => "result",
-          "result" => result,
-          "duration_ms" => duration_ms,
-          "total_cost" => calculate_cost(result),
-          "session_id" => @session_id,
-        }
-
-        log_response(response)
-
-        @last_response = response
-        response
+        # Build and return response
+        build_response(result, duration_ms)
       rescue StandardError => e
         logger.error { "Unexpected error for #{@instance_name}: #{e.class} - #{e.message}" }
         logger.error { "Backtrace: #{e.backtrace.join("\n")}" }
@@ -92,35 +105,14 @@ module ClaudeSwarm
       private
 
       def setup_openai_client(token_env)
-        config = {
-          access_token: ENV.fetch(token_env),
-          log_errors: true,
-          request_timeout: 1800, # 30 minutes
-        }
-        config[:uri_base] = @base_url if @base_url
+        openai_client_config = build_openai_client_config(token_env)
+
+        @openai_client = ::OpenAI::Client.new(openai_client_config) do |faraday|
+          # Use persistent HTTP connections for better performance
+          faraday.adapter(:net_http_persistent)
 
-        @openai_client = ::OpenAI::Client.new(config) do |faraday|
           # Add retry middleware with custom configuration
-          faraday.request(
-            :retry,
-            max: 3, # Maximum number of retries
-            interval: 0.5, # Initial delay between retries (in seconds)
-            interval_randomness: 0.5, # Randomness factor for retry intervals
-            backoff_factor: 2, # Exponential backoff factor
-            exceptions: [
-              Faraday::TimeoutError,
-              Faraday::ConnectionFailed,
-              Faraday::ServerError, # Retry on 5xx errors
-            ],
-            retry_statuses: [429, 500, 502, 503, 504], # HTTP status codes to retry
-            retry_block: lambda do |env:, options:, retry_count:, exception:, will_retry:|
-              if will_retry
-                @logger.warn("Request failed (attempt #{retry_count}/#{options.max}): #{exception&.message || "HTTP #{env.status}"}. Retrying in #{options.interval * (options.backoff_factor**(retry_count - 1))} seconds...")
-              else
-                @logger.warn("Request failed after #{retry_count} attempts: #{exception&.message || "HTTP #{env.status}"}. Giving up.")
-              end
-            end,
-          )
+          faraday.request(:retry, **build_faraday_retry_config)
         end
       rescue KeyError
         raise ExecutionError, "OpenAI API key not found in environment variable: #{token_env}"
@@ -132,49 +124,21 @@ module ClaudeSwarm
         # Read MCP config to find MCP servers
         mcp_data = JSON.parse(File.read(@mcp_config))
 
-        # Create MCP client with all MCP servers from the config
-        if mcp_data["mcpServers"] && !mcp_data["mcpServers"].empty?
-          mcp_configs = []
-
-          mcp_data["mcpServers"].each do |name, server_config|
-            case server_config["type"]
-            when "stdio"
-              # Combine command and args into a single array
-              command_array = [server_config["command"]]
-              command_array.concat(server_config["args"] || [])
-
-              stdio_config = MCPClient.stdio_config(
-                command: command_array,
-                name: name,
-              )
-              stdio_config[:read_timeout] = 1800
-              mcp_configs << stdio_config
-            when "sse"
-              logger.warn { "SSE MCP servers not yet supported for OpenAI instances: #{name}" }
-              # TODO: Add SSE support when available in ruby-mcp-client
-            end
-          end
+        # Build MCP configurations from servers
+        mcp_configs = build_mcp_configs(mcp_data["mcpServers"])
+        return if mcp_configs.empty?
+
+        # Create MCP client with unbundled environment to avoid bundler conflicts
+        # This ensures MCP servers run in a clean environment without inheriting
+        # Claude Swarm's BUNDLE_* environment variables
+        Bundler.with_unbundled_env do
+          @mcp_client = MCPClient.create_client(
+            mcp_server_configs: mcp_configs,
+            logger: @logger,
+          )
 
-          if mcp_configs.any?
-            # Create MCP client with unbundled environment to avoid bundler conflicts
-            # This ensures MCP servers run in a clean environment without inheriting
-            # Claude Swarm's BUNDLE_* environment variables
-            Bundler.with_unbundled_env do
-              @mcp_client = MCPClient.create_client(
-                mcp_server_configs: mcp_configs,
-                logger: @logger,
-              )
-
-              # List available tools from all MCP servers
-              begin
-                @available_tools = @mcp_client.list_tools
-                logger.info { "Loaded #{@available_tools.size} tools from #{mcp_configs.size} MCP server(s)" }
-              rescue StandardError => e
-                logger.error { "Failed to load MCP tools: #{e.message}" }
-                @available_tools = []
-              end
-            end
-          end
+          # List available tools from all MCP servers
+          load_mcp_tools(mcp_configs)
         end
       rescue StandardError => e
         logger.error { "Failed to setup MCP client: #{e.message}" }
@@ -211,6 +175,80 @@ module ClaudeSwarm
         # Log streaming content similar to ClaudeCodeExecutor
         logger.debug { "#{instance_info} streaming: #{content}" }
       end
+
+      def build_faraday_retry_config
+        FARADAY_RETRY_CONFIG.merge(
+          retry_block: method(:handle_retry_logging),
+        )
+      end
+
+      def handle_retry_logging(env:, options:, retry_count:, exception:, will_retry:)
+        retry_delay = options.interval * (options.backoff_factor**(retry_count - 1))
+        error_info = exception&.message || "HTTP #{env.status}"
+
+        message = if will_retry
+          "Request failed (attempt #{retry_count}/#{options.max}): #{error_info}. Retrying in #{retry_delay} seconds..."
+        else
+          "Request failed after #{retry_count} attempts: #{error_info}. Giving up."
+        end
+
+        @logger.warn(message)
+      end
+
+      def build_openai_client_config(token_env)
+        OPENAI_CLIENT_CONFIG.merge(access_token: ENV.fetch(token_env)).tap do |config|
+          config[:uri_base] = @base_url if @base_url
+        end
+      end
+
+      def build_stdio_config(name, server_config)
+        # Combine command and args into a single array
+        command_array = [server_config["command"]]
+        command_array.concat(server_config["args"] || [])
+
+        MCPClient.stdio_config(
+          command: command_array,
+          name: name,
+        ).tap do |config|
+          config[:read_timeout] = 1800
+        end
+      end
+
+      def build_mcp_configs(mcp_servers)
+        return [] if mcp_servers.nil? || mcp_servers.empty?
+
+        mcp_servers.filter_map do |name, server_config|
+          case server_config["type"]
+          when "stdio"
+            build_stdio_config(name, server_config)
+          when "sse"
+            logger.warn { "SSE MCP servers not yet supported for OpenAI instances: #{name}" }
+            # TODO: Add SSE support when available in ruby-mcp-client
+            nil
+          end
+        end
+      end
+
+      def load_mcp_tools(mcp_configs)
+        @available_tools = @mcp_client.list_tools
+        logger.info { "Loaded #{@available_tools.size} tools from #{mcp_configs.size} MCP server(s)" }
+      rescue StandardError => e
+        logger.error { "Failed to load MCP tools: #{e.message}" }
+        @available_tools = []
+      end
+
+      def build_response(result, duration_ms)
+        {
+          "type" => "result",
+          "result" => result,
+          "duration_ms" => duration_ms,
+          "total_cost" => calculate_cost(result),
+          "session_id" => @session_id,
+        }.tap do |response|
+          log_response(response)
+          @last_response = response
+        end
+      end
     end
   end
 end

data/lib/claude_swarm/orchestrator.rb

@@ -17,15 +17,12 @@ module ClaudeSwarm
       restore_session_path: nil, worktree: nil, session_id: nil)
       @config = configuration
       @generator = mcp_generator
-      @settings_generator = SettingsGenerator.new(configuration)
       @vibe = vibe
       @non_interactive_prompt = prompt
       @interactive_prompt = interactive_prompt
       @stream_logs = stream_logs
       @debug = debug
       @restore_session_path = restore_session_path
-      @session_path = nil
-      @session_log_path = nil
       @provided_session_id = session_id
       # Store worktree option for later use
       @worktree_option = worktree
@@ -35,9 +32,41 @@ module ClaudeSwarm
       @modified_instances = nil
       # Track start time for runtime calculation
       @start_time = nil
+      # Track transcript tailing thread
+      @transcript_thread = nil
 
       # Set environment variable for prompt mode to suppress output
       ENV["CLAUDE_SWARM_PROMPT"] = "1" if @non_interactive_prompt
+
+      # Initialize session path
+      if @restore_session_path
+        # Use existing session path for restoration
+        @session_path = @restore_session_path
+        @session_log_path = File.join(@session_path, "session.log")
+      else
+        # Generate new session path
+        session_params = { working_dir: ClaudeSwarm.root_dir }
+        session_params[:session_id] = @provided_session_id if @provided_session_id
+        @session_path = SessionPath.generate(**session_params)
+        SessionPath.ensure_directory(@session_path)
+        @session_log_path = File.join(@session_path, "session.log")
+
+        # Extract session ID from path (the timestamp part)
+        @session_id = File.basename(@session_path)
+
+      end
+      ENV["CLAUDE_SWARM_SESSION_PATH"] = @session_path
+      ENV["CLAUDE_SWARM_ROOT_DIR"] = ClaudeSwarm.root_dir
+
+      # Initialize components that depend on session path
+      @process_tracker = ProcessTracker.new(@session_path)
+      @settings_generator = SettingsGenerator.new(@config)
+
+      # Initialize WorktreeManager if needed
+      if @needs_worktree_manager && !@restore_session_path
+        cli_option = @worktree_option.is_a?(String) && !@worktree_option.empty? ? @worktree_option : nil
+        @worktree_manager = WorktreeManager.new(cli_option, session_id: @session_id)
+      end
     end
 
     def start
@@ -50,25 +79,15 @@ module ClaudeSwarm
           puts "😎 Vibe mode ON" if @vibe
         end
 
-        # Use existing session path
-        session_path = @restore_session_path
-        @session_path = session_path
-        @session_log_path = File.join(@session_path, "session.log")
-        ENV["CLAUDE_SWARM_SESSION_PATH"] = session_path
-        ENV["CLAUDE_SWARM_ROOT_DIR"] = ClaudeSwarm.root_dir
-
         # Create run symlink for restored session
         create_run_symlink
 
         non_interactive_output do
-          puts "📝 Using existing session: #{session_path}/"
+          puts "📝 Using existing session: #{@session_path}/"
         end
 
-        # Initialize process tracker
-        @process_tracker = ProcessTracker.new(session_path)
-
         # Check if the original session used worktrees
-        restore_worktrees_if_needed(session_path)
+        restore_worktrees_if_needed(@session_path)
 
         # Regenerate MCP configurations with session IDs for restoration
         @generator.generate_all
@@ -87,34 +106,15 @@ module ClaudeSwarm
           puts "😎 Vibe mode ON" if @vibe
         end
 
-        # Generate and set session path for all instances
-        session_params = { working_dir: ClaudeSwarm.root_dir }
-        session_params[:session_id] = @provided_session_id if @provided_session_id
-        session_path = SessionPath.generate(**session_params)
-        SessionPath.ensure_directory(session_path)
-        @session_path = session_path
-        @session_log_path = File.join(@session_path, "session.log")
-
-        # Extract session ID from path (the timestamp part)
-        @session_id = File.basename(session_path)
-
-        ENV["CLAUDE_SWARM_SESSION_PATH"] = session_path
-        ENV["CLAUDE_SWARM_ROOT_DIR"] = ClaudeSwarm.root_dir
-
         # Create run symlink for new session
         create_run_symlink
 
         non_interactive_output do
-          puts "📝 Session files will be saved to: #{session_path}/"
+          puts "📝 Session files will be saved to: #{@session_path}/"
         end
 
-        # Initialize process tracker
-        @process_tracker = ProcessTracker.new(session_path)
-
-        # Create WorktreeManager if needed with session ID
-        if @needs_worktree_manager
-          cli_option = @worktree_option.is_a?(String) && !@worktree_option.empty? ? @worktree_option : nil
-          @worktree_manager = WorktreeManager.new(cli_option, session_id: @session_id)
+        # Setup worktrees if needed
+        if @worktree_manager
           non_interactive_output { print("🌳 Setting up Git worktrees...") }
 
           # Get all instances for worktree setup
@@ -141,7 +141,7 @@ module ClaudeSwarm
         end
 
         # Save swarm config path for restoration
-        save_swarm_config_path(session_path)
+        save_swarm_config_path(@session_path)
       end
 
       # Launch the main instance (fetch after worktree setup to get modified paths)
@@ -172,6 +172,9 @@ module ClaudeSwarm
       log_thread = nil
       log_thread = start_log_streaming if @non_interactive_prompt && @stream_logs
 
+      # Start transcript tailing thread for main instance
+      @transcript_thread = start_transcript_tailing
+
       # Write the current process PID (orchestrator) to a file for easy access
       main_pid_file = File.join(@session_path, "main_pid")
       File.write(main_pid_file, Process.pid.to_s)
@@ -217,6 +220,9 @@ module ClaudeSwarm
         log_thread.join
       end
 
+      # Clean up transcript tailing thread
+      cleanup_transcript_thread
+
       # Display runtime and cost summary
       display_summary
 
@@ -289,6 +295,7 @@ module ClaudeSwarm
 
     def cleanup_processes
       @process_tracker.cleanup_all
+      cleanup_transcript_thread
       puts "✓ Cleanup complete"
     rescue StandardError => e
       puts "⚠️  Error during cleanup: #{e.message}"
@@ -566,9 +573,6 @@ module ClaudeSwarm
           pretty_json = JSON.pretty_generate(json_data)
           logger.info { pretty_json }
         rescue JSON::ParserError
-          # Warn about non-JSON output since we expect stream-json format
-          warn("⚠️  Warning: Non-JSON output detected in stream-json mode: #{line.chomp}")
-          # Log the line as-is
           logger.info { line.chomp }
         end
 
@@ -576,6 +580,164 @@ module ClaudeSwarm
       end
     end
 
+    def start_transcript_tailing
+      Thread.new do
+        path_file = File.join(@session_path, "main_instance_transcript.path")
+
+        # Wait for path file to exist (created by SessionStart hook)
+        sleep(0.5) until File.exist?(path_file)
+
+        # Read the transcript path
+        transcript_path = File.read(path_file).strip
+
+        # Wait for transcript file to exist
+        sleep(0.5) until File.exist?(transcript_path)
+
+        # Tail the transcript file continuously (like tail -f)
+        File.open(transcript_path, "r") do |file|
+          # Start from the beginning to capture all entries
+          file.seek(0, IO::SEEK_SET) # Start at beginning of file
+
+          loop do
+            line = file.gets
+            if line
+              begin
+                # Parse JSONL entry
+                transcript_entry = JSON.parse(line)
+
+                # Skip summary entries - these are just conversation titles
+                next if transcript_entry["type"] == "summary"
+
+                # Convert to session.log.json format
+                session_entry = convert_transcript_to_session_format(transcript_entry)
+
+                # Only write if we got a valid conversion (skips summary and other non-relevant entries)
+                if session_entry
+                  # Write with file locking (same pattern as BaseExecutor)
+                  session_json_path = File.join(@session_path, "session.log.json")
+                  File.open(session_json_path, File::WRONLY | File::APPEND | File::CREAT) do |log_file|
+                    log_file.flock(File::LOCK_EX)
+                    log_file.puts(session_entry.to_json)
+                  end
+                end
+              rescue JSON::ParserError
+                # Silently skip unparseable lines
+              rescue StandardError
+                # Silently handle other errors to keep thread running
+              end
+            else
+              # No new data, sleep briefly
+              sleep(0.1)
+            end
+          end
+        end
+      rescue StandardError
+        # Silently handle thread errors
+      end
+    end
+
+    def convert_transcript_to_session_format(transcript_entry)
+      # Skip if no type
+      return unless transcript_entry["type"]
+
+      instance_name = @config.main_instance
+      instance_id = "main"
+      timestamp = transcript_entry["timestamp"] || Time.now.iso8601
+
+      case transcript_entry["type"]
+      when "user"
+        # User message - format as request from user to main instance
+        message = transcript_entry["message"]
+
+        # Extract prompt text - message might be a string or an object
+        prompt_text = if message.is_a?(String)
+          message
+        elsif message.is_a?(Hash)
+          content = message["content"]
+          if content.is_a?(String)
+            content
+          elsif content.is_a?(Array)
+            # For tool results or complex content, extract text
+            extract_text_from_array(content)
+          else
+            ""
+          end
+        else
+          ""
+        end
+
+        {
+          instance: instance_name,
+          instance_id: instance_id,
+          timestamp: timestamp,
+          event: {
+            type: "request",
+            from_instance: "user",
+            from_instance_id: "user",
+            to_instance: instance_name,
+            to_instance_id: instance_id,
+            prompt: prompt_text,
+            timestamp: timestamp,
+          },
+        }
+      when "assistant"
+        # Assistant message - format as assistant response
+        message = transcript_entry["message"]
+
+        # Build a clean message structure without transcript-specific fields
+        clean_message = {
+          "type" => "message",
+          "role" => "assistant",
+        }
+
+        # Handle different message formats
+        if message.is_a?(String)
+          # Simple string message
+          clean_message["content"] = [{ "type" => "text", "text" => message }]
+        elsif message.is_a?(Hash)
+          # Only include the fields that other instances include
+          clean_message["content"] = message["content"] if message["content"]
+          clean_message["model"] = message["model"] if message["model"]
+          clean_message["usage"] = message["usage"] if message["usage"]
+        end
+
+        {
+          instance: instance_name,
+          instance_id: instance_id,
+          timestamp: timestamp,
+          event: {
+            type: "assistant",
+            message: clean_message,
+            session_id: transcript_entry["sessionId"],
+          },
+        }
+      end
+      # For other types (like summary), return nil to skip them
+    end
+
+    def extract_text_from_array(content)
+      content.map do |item|
+        if item.is_a?(Hash)
+          item["text"] || item["content"] || ""
+        else
+          item.to_s
+        end
+      end.join("\n")
+    end
+
+    def cleanup_transcript_thread
+      return unless @transcript_thread
+
+      @transcript_thread.terminate if @transcript_thread.alive?
+      @transcript_thread.join(1) # Wait up to 1 second for thread to finish
+    rescue StandardError => e
+      logger.error { "Error cleaning up transcript thread: #{e.message}" }
+    end
+
+    def logger
+      @logger ||= Logger.new(File.join(@session_path, "session.log"), level: :info, progname: "orchestrator")
+    end
+
     def execute_commands(commands, phase:, fail_fast:)
       all_succeeded = true
 

data/lib/claude_swarm/session_cost_calculator.rb

@@ -4,26 +4,118 @@ module ClaudeSwarm
   module SessionCostCalculator
     extend self
 
+    # Model pricing in dollars per million tokens
+    MODEL_PRICING = {
+      opus: {
+        input: 15.0,
+        output: 75.0,
+        cache_write: 18.75,
+        cache_read: 1.50,
+      },
+      sonnet: {
+        input: 3.0,
+        output: 15.0,
+        cache_write: 3.75,
+        cache_read: 0.30,
+      },
+      haiku: {
+        input: 0.80,
+        output: 4.0,
+        cache_write: 1.0,
+        cache_read: 0.08,
+      },
+    }.freeze
+
+    # Determine model type from model name
+    def model_type_from_name(model_name)
+      return unless model_name
+
+      model_name_lower = model_name.downcase
+      if model_name_lower.include?("opus")
+        :opus
+      elsif model_name_lower.include?("sonnet")
+        :sonnet
+      elsif model_name_lower.include?("haiku")
+        :haiku
+      end
+    end
+
+    # Calculate cost from token usage
+    def calculate_token_cost(usage, model_name)
+      model_type = model_type_from_name(model_name)
+      return 0.0 unless model_type && usage
+
+      pricing = MODEL_PRICING[model_type]
+      return 0.0 unless pricing
+
+      cost = 0.0
+
+      # Regular input tokens
+      if usage["input_tokens"]
+        cost += (usage["input_tokens"] / 1_000_000.0) * pricing[:input]
+      end
+
+      # Output tokens
+      if usage["output_tokens"]
+        cost += (usage["output_tokens"] / 1_000_000.0) * pricing[:output]
+      end
+
+      # Cache creation tokens (write)
+      if usage["cache_creation_input_tokens"]
+        cost += (usage["cache_creation_input_tokens"] / 1_000_000.0) * pricing[:cache_write]
+      end
+
+      # Cache read tokens
+      if usage["cache_read_input_tokens"]
+        cost += (usage["cache_read_input_tokens"] / 1_000_000.0) * pricing[:cache_read]
+      end
+
+      cost
+    end
+
     # Calculate total cost from session log file
     # Returns a hash with:
-    # - total_cost: Total cost in USD
+    # - total_cost: Total cost in USD (sum of cost_usd for instances, token costs for main)
     # - instances_with_cost: Set of instance names that have cost data
     def calculate_total_cost(session_log_path)
       return { total_cost: 0.0, instances_with_cost: Set.new } unless File.exist?(session_log_path)
 
-      total_cost = 0.0
+      # Track costs per instance - simple sum of cost_usd
+      instance_costs = {}
       instances_with_cost = Set.new
+      main_instance_cost = 0.0
 
       File.foreach(session_log_path) do |line|
         data = JSON.parse(line)
-        if data.dig("event", "type") == "result" && (cost = data.dig("event", "total_cost_usd"))
-          total_cost += cost
-          instances_with_cost << data["instance"]
+        instance_name = data["instance"]
+        instance_id = data["instance_id"]
+
+        # Handle main instance token-based costs
+        if instance_id == "main" && data.dig("event", "type") == "assistant"
+          usage = data.dig("event", "message", "usage")
+          model = data.dig("event", "message", "model")
+          if usage && model
+            token_cost = calculate_token_cost(usage, model)
+            main_instance_cost += token_cost
+            instances_with_cost << instance_name if token_cost > 0
+          end
+        # Handle other instances with cost_usd (non-cumulative)
+        elsif instance_id != "main" && data.dig("event", "type") == "result"
+          # Use cost_usd (non-cumulative) instead of total_cost_usd (cumulative)
+          if (cost = data.dig("event", "cost_usd"))
+            instances_with_cost << instance_name
+            instance_costs[instance_name] ||= 0.0
+            instance_costs[instance_name] += cost
+          end
         end
       rescue JSON::ParserError
         next
       end
 
+      # Calculate total: sum of all instance costs + main instance token costs
+      other_instances_cost = instance_costs.values.sum
+      total_cost = other_instances_cost + main_instance_cost
+
       {
         total_cost: total_cost,
         instances_with_cost: instances_with_cost,
@@ -39,6 +131,8 @@ module ClaudeSwarm
     # Returns a hash of instances with their cost data and relationships
     def parse_instance_hierarchy(session_log_path)
       instances = {}
+      # Track main instance token costs
+      main_instance_costs = {}
 
       return instances unless File.exist?(session_log_path)
 
@@ -75,10 +169,24 @@ module ClaudeSwarm
           instances[calling_instance][:calls_to] << instance_name
         end
 
-        # Track costs and calls
-        if data.dig("event", "type") == "result"
+        # Handle main instance token-based costs
+        if instance_id == "main" && data.dig("event", "type") == "assistant"
+          usage = data.dig("event", "message", "usage")
+          model = data.dig("event", "message", "model")
+          if usage && model
+            token_cost = calculate_token_cost(usage, model)
+            if token_cost > 0
+              main_instance_costs[instance_name] ||= 0.0
+              main_instance_costs[instance_name] += token_cost
+              instances[instance_name][:has_cost_data] = true
+              instances[instance_name][:calls] += 1
+            end
+          end
+        # Track costs and calls for non-main instances using cost_usd
+        elsif data.dig("event", "type") == "result" && instance_id != "main"
           instances[instance_name][:calls] += 1
-          if (cost = data.dig("event", "total_cost_usd"))
+          # Use cost_usd (non-cumulative) instead of total_cost_usd
+          if (cost = data.dig("event", "cost_usd"))
             instances[instance_name][:cost] += cost
             instances[instance_name][:has_cost_data] = true
           end
@@ -87,6 +195,14 @@ module ClaudeSwarm
         next
       end
 
+      # Set main instance costs (replace, don't add)
+      main_instance_costs.each do |name, cost|
+        if instances[name]
+          # For main instances, use ONLY token costs, not cumulative costs
+          instances[name][:cost] = cost
+        end
+      end
+
       instances
     end
   end

data/lib/claude_swarm/settings_generator.rb

@@ -21,13 +21,7 @@ module ClaudeSwarm
     private
 
     def session_path
-      # In tests, use the session path from env if available, otherwise use a temp path
-      @session_path ||= if ENV["CLAUDE_SWARM_SESSION_PATH"]
-        SessionPath.from_env
-      else
-        # This should only happen in unit tests
-        Dir.pwd
-      end
+      @session_path ||= SessionPath.from_env
     end
 
     def ensure_session_directory
@@ -44,11 +38,40 @@ module ClaudeSwarm
         settings["hooks"] = instance[:hooks]
       end
 
+      # Add SessionStart hook for main instance to capture transcript path
+      if name == @config.main_instance
+        session_start_hook = build_session_start_hook
+
+        # Initialize hooks if not present
+        settings["hooks"] ||= {}
+        settings["hooks"]["SessionStart"] ||= []
+
+        # Add our hook to the SessionStart hooks
+        settings["hooks"]["SessionStart"] << session_start_hook
+      end
+
       # Only write settings file if there are settings to write
       return if settings.empty?
 
       # Write settings file
       File.write(settings_path(name), JSON.pretty_generate(settings))
     end
+
+    def build_session_start_hook
+      hook_script_path = File.expand_path("hooks/session_start_hook.rb", __dir__)
+      # Pass session path as an argument since ENV may not be inherited
+      session_path_arg = session_path
+
+      {
+        "matcher" => "startup",
+        "hooks" => [
+          {
+            "type" => "command",
+            "command" => "ruby #{hook_script_path} '#{session_path_arg}'",
+            "timeout" => 5,
+          },
+        ],
+      }
+    end
   end
 end

data/lib/claude_swarm/templates/generation_prompt.md.erb

@@ -1,4 +1,4 @@
-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.
+You are a Claude Swarm configuration generator assistant. Your role is to help the user create a well-structured swarm YAML 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).
@@ -10,6 +10,7 @@ Key capabilities:
 - 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)
+- Support for OpenAI instances
 
 ## Your Task
 1. Start by asking about the user's project structure and development needs
@@ -43,7 +44,7 @@ swarm:
     instance_name:
       description: "Clear description of role and responsibilities"
       directory: ./path/to/directory
-      model: sonnet  # or opus for complex tasks
+      model: opus
       allowed_tools: [Read, Edit, Write, Bash]
       connections: [other_instance_names]  # Optional
       prompt: |
@@ -57,7 +58,7 @@ swarm:
 - 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.
+- Set up logical connections (e.g., lead → team members, architect → implementers), but do not create 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
@@ -72,7 +73,6 @@ swarm:
 
 ## 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)?
@@ -225,6 +225,3 @@ The more precisely you explain what you want, the better Claude's response will
 * **Provide instructions as sequential steps:** Use numbered lists or bullet points to better ensure that Claude carries out the task the exact way you want it to.
 
 </prompt_best_practices>
-
-Start the conversation by greeting the user and asking: "What kind of project would you like to create a Claude Swarm for?"
-Say: I am ready to start

data/lib/claude_swarm/version.rb

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

data/lib/claude_swarm.rb

@@ -23,9 +23,7 @@ require "yaml"
 # External dependencies
 require "claude_sdk"
 require "fast_mcp_annotations"
-require "faraday/retry"
 require "mcp_client"
-require "openai"
 require "thor"
 
 # Zeitwerk setup

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: claude_swarm
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.10
 platform: ruby
 authors:
 - Paulo Arruda
@@ -51,6 +51,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: faraday-net_http_persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: faraday-retry
   requirement: !ruby/object:Gem::Requirement
@@ -126,6 +140,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".claude/commands/release.md"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - ".ruby-version"
@@ -155,6 +170,7 @@ files:
 - lib/claude_swarm/commands/ps.rb
 - lib/claude_swarm/commands/show.rb
 - lib/claude_swarm/configuration.rb
+- lib/claude_swarm/hooks/session_start_hook.rb
 - lib/claude_swarm/mcp_generator.rb
 - lib/claude_swarm/openai/chat_completion.rb
 - lib/claude_swarm/openai/executor.rb