claude_swarm 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a52559fb6574ce20ff8c8f2582a8657475a359f2ee8fcbb07cb9594abfb236d
-  data.tar.gz: 784bb012843d17c605626ea43edfc6460e0c5229db08d89d8e324d2f7cc6f60d
+  metadata.gz: cb6e856b4f12c1e30c5fb61a01d76e94cc7e660659d64e2458d535a0bf6d3af4
+  data.tar.gz: 65820e42a8d90b659464dcb871d9fde02219a61f74d5522c08a8f46f13e37d37
 SHA512:
-  metadata.gz: 96b0037178cdb76a8c5c6d0bfefbbe51261ec5904502e63ae0313338c59b3b580cf8c9a78f86c6c2fd73864e9d259300b79d64b917a55d87ddbc3c2513cecdc8
-  data.tar.gz: 32e006014e9856d1a6c0822bf3c6b713035722e6241de91d8e89282251c16ae9479c1bcb930b11781a73babc0c468892eca44e434117e92c582a1ba5b14f123a
+  metadata.gz: 617e5743416494dea623905ed448057ce54479b956549b48377739667767582de8039500904805e8e521329c2b5e1c7f1c2d931c239ef2436e737842ba3cc4b8
+  data.tar.gz: 8572a1c389b3b31684cb18a210d8872fd66c9d1deea4ffb737205efc129e2f0e00201d5e6ed88b32cd9a9df14e7c10a80a4b6a633c55d8845a2cbcbeefd19d44

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [1.0.3]
+
+### Fixed
+- **Fixed uninitialized constant VERSION error**: Resolved an issue where the VERSION constant was not properly initialized in the Zeitwerk autoloader setup
+  - The gem version is now correctly loaded before Zeitwerk setup
+  - Prevents "uninitialized constant ClaudeSwarm::VERSION" errors during gem loading
+  - Ensures version information is available throughout the application
+
+### Changed
+- **Process spawning now uses chdir option**: Replaced `Dir.chdir` blocks with the `chdir:` option when spawning processes
+  - Commands are now executed with explicit working directory using `Open3.capture2e`, `Open3.popen2e`, and `system` with `chdir:` parameter
+  - Avoids changing the process's working directory which could cause issues in concurrent operations
+  - More explicit and safer approach for executing commands in specific directories
+  - Removed `CLAUDE_SWARM_ROOT_DIR` environment variable in favor of passing root directory explicitly
+
 ## [1.0.2]
 
 ### Changed

data/Rakefile

@@ -14,8 +14,8 @@ namespace :claude_swarm do
     # Expand globs and subtract to get only claude_swarm tests
     all_tests = Dir.glob("test/**/*_test.rb")
     exclude_tests = Dir.glob("test/swarm_sdk/**/*_test.rb") +
-                    Dir.glob("test/swarm_memory/**/*_test.rb") +
-                    Dir.glob("test/swarm_cli/**/*_test.rb")
+      Dir.glob("test/swarm_memory/**/*_test.rb") +
+      Dir.glob("test/swarm_cli/**/*_test.rb")
     t.test_globs = all_tests - exclude_tests
     t.warning = false
   end
@@ -24,8 +24,8 @@ namespace :claude_swarm do
     # Expand patterns and subtract
     all_patterns = Dir.glob("lib/claude_swarm.rb") + Dir.glob("lib/claude_swarm/**/*.rb") + Dir.glob("test/**/*_test.rb")
     exclude_patterns = Dir.glob("test/swarm_sdk/**/*.rb") +
-                       Dir.glob("test/swarm_memory/**/*.rb") +
-                       Dir.glob("test/swarm_cli/**/*.rb")
+      Dir.glob("test/swarm_memory/**/*.rb") +
+      Dir.glob("test/swarm_cli/**/*.rb")
     t.patterns = all_patterns - exclude_patterns
   end
 

data/docs/v2/CHANGELOG.swarm_cli.md

@@ -5,6 +5,15 @@ All notable changes to SwarmCLI will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.1]
+
+### Fixed
+- **`swarm mcp tools` command initialization** - Fixed crash on startup
+  - Bug: Used non-existent `SwarmSDK::Scratchpad` class
+  - Fix: Changed to `SwarmSDK::Tools::Stores::ScratchpadStorage` (correct class)
+  - Added comprehensive test suite to prevent similar initialization bugs
+  - Tests verify command initializes without errors
+
 ## [2.1.0]
 - Bump gem version with the rest of the gems.
 

data/docs/v2/CHANGELOG.swarm_memory.md

@@ -5,6 +5,19 @@ All notable changes to SwarmMemory will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.2]
+
+### Changed
+- **Stub redirect logic moved to Storage layer** - Architectural improvement for adapter-agnostic redirects
+  - Redirect following moved from `FilesystemAdapter` to `Storage#read_entry`
+  - Uses metadata-based detection (`stub: true`, `redirect_to`) instead of content parsing
+  - All future adapters (PostgreSQL, Redis, S3) get redirect support for free
+  - Improved error handling with helpful diagnostic messages
+  - Detects circular redirects immediately with full cycle path
+  - Enforces depth limit (5 redirects) to prevent infinite chains
+  - Added comprehensive test suite with 10 tests covering all edge cases
+  - Added validation to `Defragmenter#create_stub` to prevent malformed stubs
+
 ## [2.1.1]
 
 ### Added
@@ -14,6 +27,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Helpful error message guides users to split large content into multiple linked memories
   - Promotes better organization through multiple focused entries with `related` field links
 
+- **MemoryGlob result truncation**: Prevents overwhelming output from broad searches
+  - Maximum 1000 results per query (matches Glob tool behavior)
+  - System reminder added when results are truncated
+  - Encourages users to use more specific patterns
+  - Sorted by most recently modified (first 1000 shown)
+
 ### Changed
 - **Memory Assistant prompt improvements**: Updated examples and guidance
   - Updated examples from 5000-word to 250-word entries

data/docs/v2/CHANGELOG.swarm_sdk.md

@@ -5,6 +5,51 @@ All notable changes to SwarmSDK will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.2]
+
+### Added
+
+- **Node Workflow Control Flow**: Dynamic control methods in NodeContext
+  - `ctx.goto_node(:node_name, content:)` - Jump to any node with custom content
+  - `ctx.halt_workflow(content:)` - Stop entire workflow and return final result
+  - `ctx.skip_execution(content:)` - Skip node LLM execution and use provided content
+  - Enables loops, conditional branching, and dynamic routing in workflows
+  - All methods validate that content is not nil (raises ArgumentError with helpful message if nil)
+  - Use for implementing retry logic, convergence checks, caching, and iterative refinement
+
+- **Context Preservation Across Nodes**: `reset_context` parameter for node agents
+  - `agent(:name, reset_context: false)` preserves conversation history across nodes
+  - Default: `reset_context: true` (fresh context for each node - safe default)
+  - NodeOrchestrator caches and reuses agent instances when `reset_context: false`
+  - Enables stateful workflows where agents remember previous node conversations
+  - Perfect for iterative refinement, self-reflection loops, and chain-of-thought reasoning
+
+### Changed
+
+- **Result object**: Cost and tokens now calculated dynamically from logs
+  - `result.cost` and `result.tokens` now properly populated after swarm execution
+  - Values are calculated from usage data in logs, not stored during initialization
+  - Fixed issue where these attributes were always 0/empty
+
+- **Plugin serialization**: New `serialize_config` hook for plugin extensibility
+  - Plugins can now contribute to `Agent::Definition.to_h` via `serialize_config` hook
+  - Removes memory-specific code from SwarmSDK core (moved to SwarmMemory plugin)
+  - Maintains backward compatibility - permissions remain in core SDK (not plugin-specific)
+  - Enables clean separation between core SDK and plugin features (memory, skills, etc.)
+  - Plugins can preserve their configuration when agents are cloned in NodeOrchestrator
+
+- **NodeOrchestrator**: Passes scratchpad configuration to mini-swarms
+  - Bug fix: `scratchpad_enabled` now correctly propagated to node-level swarms
+  - Ensures `use_scratchpad false` works properly in node workflows
+
+- **CLI ConfigLoader**: Accepts both Swarm and NodeOrchestrator instances
+  - Bug fix: CLI now correctly handles NodeOrchestrator execution
+  - Enables node workflows to work seamlessly with CLI commands
+
+- **Error handling in Agent::Chat**: More robust exception handling
+  - Changed nil response error from `RubyLLM::Error` to `StandardError`
+  - Prevents "undefined method 'body'" error when handling malformed API responses
+
 ## [2.1.1]
 
 ### Added

data/docs/v2/guides/complete-tutorial.md

@@ -1889,7 +1889,119 @@ input do |ctx|
 end
 ```
 
-### 5.8 Complex Workflow Example
+**Control Flow Methods**:
+
+NodeContext provides three methods for dynamic workflow control:
+
+**1. goto_node - Jump to any node**:
+```ruby
+output do |ctx|
+  if needs_revision?(ctx.content)
+    # Jump back to revision node instead of continuing forward
+    ctx.goto_node(:revision, content: ctx.content)
+  else
+    ctx.content  # Continue to next node normally
+  end
+end
+```
+
+**2. halt_workflow - Stop entire workflow**:
+```ruby
+output do |ctx|
+  if converged?(ctx.content)
+    # Stop workflow early with final result
+    ctx.halt_workflow(content: ctx.content)
+  else
+    ctx.content  # Continue to next node
+  end
+end
+```
+
+**3. skip_execution - Skip node's LLM call** (input transformers only):
+```ruby
+input do |ctx|
+  cached = check_cache(ctx.content)
+  if cached
+    # Skip expensive LLM call and use cached result
+    ctx.skip_execution(content: cached)
+  else
+    ctx.content  # Execute node normally
+  end
+end
+```
+
+**Creating loops with goto_node**:
+```ruby
+node :reasoning do
+  agent(:thinker, reset_context: false)  # Preserve context across iterations
+
+  output do |ctx|
+    # Loop until convergence
+    if ctx.all_results.size > 10
+      ctx.halt_workflow(content: "Max iterations reached")
+    else
+      ctx.goto_node(:reflection, content: ctx.content)
+    end
+  end
+end
+
+node :reflection do
+  agent(:critic, reset_context: false)
+
+  output do |ctx|
+    # Loop back to reasoning
+    ctx.goto_node(:reasoning, content: ctx.content)
+  end
+end
+
+start_node :reasoning
+```
+
+**Note:** All control flow methods validate that `content` is not nil. If a node fails with an error, check for errors before calling goto_node:
+
+```ruby
+output do |ctx|
+  if ctx.error
+    ctx.halt_workflow(content: "Error: #{ctx.error.message}")
+  else
+    ctx.goto_node(:next_node, content: ctx.content)
+  end
+end
+```
+
+### 5.8 Context Preservation Across Nodes
+
+By default, agents get fresh conversation context in each node (`reset_context: true`). To preserve an agent's conversation history across nodes, use `reset_context: false`:
+
+```ruby
+agent :architect do
+  model "gpt-4"
+  system_prompt "You design systems"
+end
+
+node :planning do
+  agent(:architect, reset_context: false)  # Preserve context
+end
+
+node :revision do
+  agent(:architect, reset_context: false)  # Same instance - remembers planning!
+  depends_on :planning
+end
+```
+
+**When to preserve context:**
+- Iterative refinement workflows
+- Agent builds on its previous decisions
+- Chain of thought reasoning across stages
+- Self-reflection loops
+
+**When to reset context (default):**
+- Independent validation/review
+- Fresh perspective needed
+- Memory management in long workflows
+- Different roles for same agent in different stages
+
+### 5.9 Complex Workflow Example
 
 **Multi-stage development pipeline**:
 

data/docs/v2/reference/ruby-dsl.md

@@ -1382,23 +1382,40 @@ Configure an agent for this node (returns fluent config object).
 
 **Signature:**
 ```ruby
-agent(name) → AgentConfig
+agent(name, reset_context: true) → AgentConfig
 ```
 
 **Parameters:**
 - `name` (Symbol, required): Agent name
+- `reset_context` (Boolean, keyword, optional): Whether to reset conversation context
+  - `true` (default): Fresh context for each node execution
+  - `false`: Preserve conversation history from previous nodes
 
 **Returns:** `AgentConfig` with `.delegates_to(*names)` method
 
 **Example:**
 ```ruby
-# With delegation
-agent(:backend).delegates_to(:tester, :database)
+# Fresh context (default)
+agent(:backend)
 
-# Without delegation
-agent(:planner)
+# Preserve context from previous nodes
+agent(:backend, reset_context: false).delegates_to(:tester)
+
+# Without delegation, preserving context
+agent(:planner, reset_context: false)
 ```
 
+**When to use `reset_context: false`:**
+- Iterative refinement workflows
+- Agent needs to remember previous node conversations
+- Chain of thought reasoning across stages
+- Self-reflection or debate loops
+
+**When to use `reset_context: true` (default):**
+- Independent validation or fresh perspective
+- Memory management in long workflows
+- Different roles for same agent in different stages
+
 ---
 
 ### depends_on
@@ -2044,6 +2061,122 @@ Success status from previous_result or result.
 
 ---
 
+### Control Flow Methods
+
+Methods for dynamic workflow control (loops, conditional branching, early termination).
+
+**goto_node**
+```ruby
+ctx.goto_node(node_name, content:) → Hash
+```
+Jump to a different node with custom content, bypassing normal dependency order.
+
+**Parameters:**
+- `node_name` (Symbol, required): Target node name
+- `content` (String, required): Content to pass to target node (validated non-nil)
+
+**Returns:** Control hash (processed by NodeOrchestrator)
+
+**Valid in:** Both input and output transformers
+
+**Example:**
+```ruby
+output do |ctx|
+  if needs_revision?(ctx.content)
+    # Jump back to revision node
+    ctx.goto_node(:revision, content: ctx.content)
+  else
+    ctx.content  # Continue to next node normally
+  end
+end
+```
+
+**Use cases:**
+- Implementing loops in workflows
+- Conditional branching based on results
+- Dynamic workflow routing
+- Retry logic
+
+**halt_workflow**
+```ruby
+ctx.halt_workflow(content:) → Hash
+```
+Stop entire workflow execution immediately and return content as final result.
+
+**Parameters:**
+- `content` (String, required): Final content to return (validated non-nil)
+
+**Returns:** Control hash (processed by NodeOrchestrator)
+
+**Valid in:** Both input and output transformers
+
+**Example:**
+```ruby
+output do |ctx|
+  if converged?(ctx.content)
+    # Stop workflow early
+    ctx.halt_workflow(content: ctx.content)
+  else
+    ctx.content  # Continue to next node
+  end
+end
+```
+
+**Use cases:**
+- Early termination on success
+- Error handling and bailout
+- Loop termination conditions
+- Convergence checks
+
+**skip_execution**
+```ruby
+ctx.skip_execution(content:) → Hash
+```
+Skip LLM execution for current node and use provided content instead.
+
+**Parameters:**
+- `content` (String, required): Content to use instead of LLM execution (validated non-nil)
+
+**Returns:** Control hash (processed by NodeOrchestrator)
+
+**Valid in:** Input transformers only
+
+**Example:**
+```ruby
+input do |ctx|
+  cached = check_cache(ctx.content)
+  if cached
+    # Skip expensive LLM call
+    ctx.skip_execution(content: cached)
+  else
+    ctx.content  # Execute node normally
+  end
+end
+```
+
+**Use cases:**
+- Caching node results
+- Conditional execution
+- Performance optimization
+- Validation checks
+
+**Error Handling with Control Flow:**
+
+All control flow methods validate that content is not nil. If a node fails, check for errors:
+
+```ruby
+output do |ctx|
+  if ctx.error
+    # Don't try to continue with nil content
+    ctx.halt_workflow(content: "Error: #{ctx.error.message}")
+  else
+    ctx.goto_node(:next_node, content: ctx.content)
+  end
+end
+```
+
+---
+
 ## Complete Example
 
 ```ruby