taski 0.8.3 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cddae184fb1f55c69b42995e51c3bf5711d31f978ec383a00a73d2ce3531ca15
-  data.tar.gz: 3e79ca2bf3a6cd163272bbff98ff3b980f3a3b69293607dd45879501d50904c4
+  metadata.gz: 1ad85c90c371fc1ea2f61e1d7e9817c7a9cc3fa9f258be2bf1154ced5f4c0349
+  data.tar.gz: a56399d990f0a3ecfddff0f24b5a45c8319ea88e58299a3d3a22a2336295f5cc
 SHA512:
-  metadata.gz: 9310e8b52be98d9087de88b4b7f5d105896edd85137c2f43e6c968c8daaf00dc6b4843ff9d1f228a089dcd7ceb379715c2b640d3c547ce173659dc7130cd1768
-  data.tar.gz: 65bade2024691c9c7527f6249294d01714563ff35c211472e6d984e82ba5acd0767251d33e05d8ade4208eabc8b1326eb47fc4f932b4699bf0b986e208fffcea
+  metadata.gz: f6969545ce4924434c3e031dca9fff39a974dfd53ee73fb610979cdc3fd09842f50b8871efec23a79dd40d1985bb97c92b651744655a38a12edbdeb9c0f05daa
+  data.tar.gz: 94a9f76f2da179d4b202b788f3abf27531b8a1df4ccd186eb84a5c695dfcbca3c78f75f2350ba052dcb98b68da7427e60b0a493e67340c1d04440278b4c3ab7f

data/CHANGELOG.md

@@ -7,6 +7,45 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-02-08
+
+### Added
+- Fiber-based lazy dependency resolution replacing Monitor-based approach ([#157](https://github.com/ahogappa/taski/pull/157))
+- Layout/Theme architecture for progress display ([#150](https://github.com/ahogappa/taski/pull/150))
+- Layout::Tree for hierarchical task display with TTY/non-TTY dual mode ([#151](https://github.com/ahogappa/taski/pull/151))
+- Structured logging support for debugging and monitoring ([#141](https://github.com/ahogappa/taski/pull/141))
+- Skipped task reporting in progress display and logging ([#157](https://github.com/ahogappa/taski/pull/157))
+- `clean_on_failure` option for `run_and_clean` ([#169](https://github.com/ahogappa/taski/pull/169))
+- `short_name` filter for template name formatting ([#151](https://github.com/ahogappa/taski/pull/151))
+- TaskDrop and ExecutionDrop for structured template variables ([#151](https://github.com/ahogappa/taski/pull/151))
+- Group duration computation in Layout::Base ([#167](https://github.com/ahogappa/taski/pull/167))
+- `mark_clean_failed` in Scheduler for symmetric failure tracking ([#167](https://github.com/ahogappa/taski/pull/167))
+- Ruby 4.0 support in CI ([#160](https://github.com/ahogappa/taski/pull/160))
+
+### Changed
+- Replace ExecutionContext with ExecutionFacade/TaskObserver architecture ([#167](https://github.com/ahogappa/taski/pull/167))
+- Remove SharedState, unify task state in TaskWrapper ([#167](https://github.com/ahogappa/taski/pull/167))
+- Remove Section API in favor of simple if-statement selection (BREAKING) ([#157](https://github.com/ahogappa/taski/pull/157))
+- Simplify clean API by removing `Task.clean` and `Task.new` (BREAKING) ([#163](https://github.com/ahogappa/taski/pull/163))
+- Simplify progress display configuration to single setter API ([#161](https://github.com/ahogappa/taski/pull/161))
+- Rename `completed?`/`clean_completed?` to `finished?`/`clean_finished?` (BREAKING) ([#167](https://github.com/ahogappa/taski/pull/167))
+- Unify `STATE_ERROR` to `STATE_FAILED` across execution layer (BREAKING) ([#167](https://github.com/ahogappa/taski/pull/167))
+- Rename Template to Theme, Layout::Plain to Layout::Log ([#151](https://github.com/ahogappa/taski/pull/151))
+- Rename `execution_context` to `execution_facade` across codebase ([#167](https://github.com/ahogappa/taski/pull/167))
+- Merge FiberExecutor into Executor, rename FiberWorkerPool to WorkerPool ([#157](https://github.com/ahogappa/taski/pull/157))
+- Replace inline `Class.new(Taski::Task)` with named fixture classes in tests ([#166](https://github.com/ahogappa/taski/pull/166))
+- Drop Ruby 3.2 from CI ([#160](https://github.com/ahogappa/taski/pull/160))
+
+### Fixed
+- Recursively add transitive dependencies in `merge_runtime_dependencies` ([#142](https://github.com/ahogappa/taski/pull/142))
+- Handle `Errno::EBADF` in TaskOutputRouter pipe operations ([#159](https://github.com/ahogappa/taski/pull/159))
+- Truncate simple progress line to terminal width ([#152](https://github.com/ahogappa/taski/pull/152))
+- Improve thread safety in Registry and WorkerPool ([#167](https://github.com/ahogappa/taski/pull/167))
+- Restore fiber context on resume, scope output capture per-fiber ([#157](https://github.com/ahogappa/taski/pull/157))
+- Prevent duplicate `:start` responses and ensure observer event ordering ([#157](https://github.com/ahogappa/taski/pull/157))
+- Route observer errors through structured logger instead of `warn` ([#167](https://github.com/ahogappa/taski/pull/167))
+- Resolve Bundler permission error on Ruby 4.0 CI ([#162](https://github.com/ahogappa/taski/pull/162))
+
 ## [0.8.3] - 2026-01-26
 
 ### Fixed

data/README.md

@@ -12,9 +12,9 @@
 
 - **Automatic Dependency Resolution**: Dependencies detected via static analysis
 - **Parallel Execution**: Independent tasks run concurrently for maximum performance
-- **Two Simple APIs**: Exports (value sharing) and Section (runtime selection)
+- **Exports API**: Simple value sharing between tasks
 - **Real-time Progress**: Visual feedback with parallel task progress display
-- **Thread-Safe**: Built on Monitor-based synchronization for reliable concurrent execution
+- **Fiber-Based Execution**: Lightweight Fiber-based dependency resolution for efficient parallel execution
 
 ## Quick Start
 
@@ -77,42 +77,32 @@ class Server < Taski::Task
 end
 ```
 
-### Section - Runtime Implementation Selection
+### Conditional Logic - Runtime Selection
 
-Switch implementations based on environment:
+Use `if` statements to switch behavior based on environment:
 
 ```ruby
-class DatabaseSection < Taski::Section
-  interfaces :host, :port
+class DatabaseConfig < Taski::Task
+  exports :host, :port
 
-  class Production < Taski::Task
-    def run
+  def run
+    if ENV['RAILS_ENV'] == 'production'
       @host = "prod.example.com"
       @port = 5432
-    end
-  end
-
-  class Development < Taski::Task
-    def run
+    else
       @host = "localhost"
       @port = 5432
     end
   end
-
-  def impl
-    ENV['RAILS_ENV'] == 'production' ? Production : Development
-  end
 end
 
 class App < Taski::Task
   def run
-    puts "Connecting to #{DatabaseSection.host}:#{DatabaseSection.port}"
+    puts "Connecting to #{DatabaseConfig.host}:#{DatabaseConfig.port}"
   end
 end
 ```
 
-> **Note**: Nested implementation classes automatically inherit Section's `interfaces` as `exports`.
-
 ## Best Practices
 
 ### Keep Tasks Small and Focused
@@ -236,16 +226,47 @@ Env API (execution environment):
 RandomTask.value  # => 42
 RandomTask.value  # => 99 (different value - fresh execution)
 
-# Instance-level caching
-instance = RandomTask.new
-instance.run        # => 42
-instance.run        # => 42 (cached within instance)
-instance.value      # => 42
-
 # Dependencies within same execution share results
 DoubleConsumer.run  # RandomTask runs once, both accesses get same value
 ```
 
+### Error Handling
+
+When a task fails, Taski wraps the error with task-specific context. Each task class automatically gets a `::Error` subclass for targeted rescue:
+
+```ruby
+class FetchData < Taski::Task
+  exports :data
+  def run
+    @data = API.fetch  # may raise
+  end
+end
+
+class ProcessData < Taski::Task
+  def run
+    FetchData.data
+  end
+end
+
+# Rescue a specific task's error
+begin
+  ProcessData.run
+rescue FetchData::Error => e
+  puts "FetchData failed: #{e.cause.message}"
+end
+
+# Rescue all task failures with AggregateError
+begin
+  ProcessData.run
+rescue Taski::AggregateError => e
+  e.errors.each do |failure|
+    puts "#{failure.task_class}: #{failure.error.message}"
+  end
+end
+```
+
+`AggregateError` collects all failures from parallel execution. Task-specific `::Error` classes work transparently with `rescue` — even when errors are wrapped inside an `AggregateError`.
+
 ### Aborting Execution
 
 Stop all pending tasks when a critical error occurs:
@@ -282,17 +303,24 @@ end
 # Run then clean in one call
 DatabaseSetup.run_and_clean
 
-# Or separately
-DatabaseSetup.run
-# ... do work ...
-DatabaseSetup.clean
+# Run, do something with exported values, then clean
+DatabaseSetup.run_and_clean do
+  deploy(DatabaseSetup.connection)
+end
 ```
 
-See [docs/guide.md](docs/guide.md#lifecycle-management) for details.
+See [docs/GUIDE.md](docs/GUIDE.md#lifecycle-management) for details.
 
 ### Progress Display
 
-Tree-based progress visualization is enabled by default:
+Simple progress display is enabled by default:
+
+```text
+⠹ [3/5] DeployTask | Uploading files...
+✓ [5/5] All tasks completed (1234ms)
+```
+
+**Tree mode** provides full dependency tree visualization:
 
 ```
 WebServer (Task)
@@ -302,14 +330,7 @@ WebServer (Task)
 └── ◻ Server (Task)
 ```
 
-**Simple mode** provides a compact single-line display:
-
-```
-⠹ [3/5] DeployTask | Uploading files...
-✓ [5/5] All tasks completed (1234ms)
-```
-
-**Plain mode** provides text output without escape codes (for CI/logs):
+**Log mode** provides text output without escape codes (for CI/logs):
 
 ```
 [START] DatabaseSetup
@@ -322,18 +343,12 @@ WebServer (Task)
 **Configuration:**
 
 ```ruby
-# Via API
-Taski.progress_mode = :tree    # Tree display (default)
-Taski.progress_mode = :simple  # Single-line display
-Taski.progress_mode = :plain   # Plain text (CI/logs)
-
-# Via environment variable
-TASKI_PROGRESS_MODE=simple ruby your_script.rb
-TASKI_PROGRESS_MODE=plain ruby your_script.rb
+Taski.progress_display = Taski::Progress::Layout::Simple.new  # Simple display (default)
+Taski.progress_display = Taski::Progress::Layout::Tree.new     # Tree display
+Taski.progress_display = Taski::Progress::Layout::Log.new      # Log output (CI/logs)
+Taski.progress_display = nil                                    # Disable
 ```
 
-To disable: `TASKI_PROGRESS_DISABLE=1 ruby your_script.rb`
-
 ### Tree Visualization
 
 ```ruby

data/docs/GUIDE.md

@@ -87,7 +87,9 @@ rescue DatabaseTask::Error => e
 end
 ```
 
-This works transparently with `AggregateError` - when you rescue `DatabaseTask::Error`, it matches an `AggregateError` that contains a `DatabaseTask::Error`.
+This works transparently with `AggregateError` — when you rescue `DatabaseTask::Error`, it matches an `AggregateError` that contains a `DatabaseTask::Error`.
+
+**How this works:** Ruby's `rescue` uses the `===` operator to match exceptions. Taski's `AggregateAware` module (extended by `TaskError` and all `TaskClass::Error` classes) overrides `===` to check whether an `AggregateError` *contains* an error of that type. This means `rescue Taski::TaskError` will match an `AggregateError` wrapping TaskError instances, even though `AggregateError` does not inherit from `TaskError`.
 
 ### TaskAbortException
 
@@ -140,7 +142,7 @@ end
 
 ## Lifecycle Management
 
-Taski supports resource cleanup with `run`, `clean`, and `run_and_clean` methods.
+Taski supports resource cleanup with `run_and_clean`, which executes the run phase followed by the clean phase in a single operation.
 
 ### Basic Lifecycle
 
@@ -168,27 +170,24 @@ class WebServer < Taski::Task
   end
 end
 
-# Start
-WebServer.run
+# Run then clean in one call
+WebServer.run_and_clean
 # => Database connected
-# => Server started with postgresql://localhost:5432/myapp
-
-# Clean (reverse dependency order)
-WebServer.clean
+# => Server started
 # => Server stopped
 # => Database disconnected
 ```
 
-### run_and_clean
+### run_and_clean with Block
 
-Execute run followed by clean in a single operation:
+Use a block to execute code between run and clean phases. This is useful when you need to use exported values before cleanup:
 
 ```ruby
-WebServer.run_and_clean
-# => Database connected
-# => Server started
-# => Server stopped
-# => Database disconnected
+DatabaseSetup.run_and_clean do
+  # Exported values are accessible here
+  deploy(DatabaseSetup.connection)
+end
+# Clean runs automatically after the block
 ```
 
 ### Idempotent Clean Methods
@@ -289,21 +288,9 @@ After completion:
 
 ### Display Modes
 
-Taski supports two progress display modes:
-
-#### Tree Mode (Default)
+Taski supports three progress display modes:
 
-Full dependency tree visualization with status for each task:
-
-```
-WebServer (Task)
-├── ⠋ Config (Task) | Reading config.yml...
-│   ├── ✅ Database (Task) 45.2ms
-│   └── ⠙ Cache (Task) | Connecting...
-└── ◻ Server (Task)
-```
-
-#### Simple Mode
+#### Simple Mode (Default)
 
 Compact single-line display showing current progress:
 
@@ -324,7 +311,19 @@ On failure:
 ✗ [3/5] DeployTask failed: Connection refused
 ```
 
-#### Plain Mode
+#### Tree Mode
+
+Full dependency tree visualization with status for each task:
+
+```
+WebServer (Task)
+├── ⠋ Config (Task) | Reading config.yml...
+│   ├── ✅ Database (Task) 45.2ms
+│   └── ⠙ Cache (Task) | Connecting...
+└── ◻ Server (Task)
+```
+
+#### Log Mode
 
 Plain text output without escape codes, designed for CI/logs:
 
@@ -336,28 +335,13 @@ Plain text output without escape codes, designed for CI/logs:
 [TASKI] Completed: 2/2 tasks (165ms)
 ```
 
-### Configuring Progress Mode
-
-**Via API:**
+### Configuring Progress Display
 
 ```ruby
-Taski.progress_mode = :tree    # Tree display (default)
-Taski.progress_mode = :simple  # Single-line display
-Taski.progress_mode = :plain   # Plain text (CI/logs)
-```
-
-**Via environment variable:**
-
-```bash
-TASKI_PROGRESS_MODE=tree ruby your_script.rb
-TASKI_PROGRESS_MODE=simple ruby your_script.rb
-TASKI_PROGRESS_MODE=plain ruby your_script.rb
-```
-
-### Disabling Progress Display
-
-```bash
-TASKI_PROGRESS_DISABLE=1 ruby your_script.rb
+Taski.progress_display = Taski::Progress::Layout::Simple.new  # Simple display (default)
+Taski.progress_display = Taski::Progress::Layout::Tree.new     # Tree display
+Taski.progress_display = Taski::Progress::Layout::Log.new      # Log output (CI/logs)
+Taski.progress_display = nil                                    # Disable
 ```
 
 ### File Output Mode
@@ -372,13 +356,14 @@ ruby build.rb > build.log 2>&1
 
 ## Debugging
 
-### Environment Variables
+### Structured Logging
+
+```ruby
+require "logger"
+Taski.logger = Logger.new($stdout, level: Logger::DEBUG)
+```
 
-| Variable | Purpose |
-|----------|---------|
-| `TASKI_PROGRESS_DISABLE=1` | Disable progress display |
-| `TASKI_PROGRESS_MODE=tree\|simple\|plain` | Set progress display mode (default: tree) |
-| `TASKI_DEBUG=1` | Enable debug output |
+Set `Taski.logger` to a Ruby `Logger` instance to enable structured logging of execution events.
 
 ### Dependency Tree Visualization
 

data/examples/README.md

@@ -19,22 +19,7 @@ ruby examples/quick_start.rb
 
 ---
 
-### 2. section_demo.rb - Runtime Implementation Selection
-
-Switch implementations based on environment using the Section API.
-
-```bash
-ruby examples/section_demo.rb
-```
-
-**Covers:**
-- `interfaces` for defining contracts
-- Environment-specific implementations
-- Dependency tree visualization with `.tree`
-
----
-
-### 3. args_demo.rb - Runtime Args and Options
+### 2. args_demo.rb - Runtime Args and Options
 
 Access execution args and pass custom options to tasks.
 
@@ -52,22 +37,21 @@ ruby examples/args_demo.rb
 
 ---
 
-### 4. reexecution_demo.rb - Scope-Based Execution
+### 3. reexecution_demo.rb - Scope-Based Execution
 
 Understand scope-based execution and caching behavior.
 
 ```bash
-TASKI_PROGRESS_DISABLE=1 ruby examples/reexecution_demo.rb
+ruby examples/reexecution_demo.rb
 ```
 
 **Covers:**
 - Fresh execution for each class method call
-- Instance-level caching with `Task.new`
 - Scope-based dependency caching
 
 ---
 
-### 5. clean_demo.rb - Lifecycle Management
+### 4. clean_demo.rb - Lifecycle Management
 
 Demonstrates resource cleanup with clean methods.
 
@@ -79,10 +63,11 @@ ruby examples/clean_demo.rb
 - Defining `clean` methods for resource cleanup
 - Reverse dependency order execution
 - `run_and_clean` combined operation
+- `run_and_clean` with block support
 
 ---
 
-### 6. group_demo.rb - Task Output Grouping
+### 5. group_demo.rb - Task Output Grouping
 
 Organize task output into logical phases with groups.
 
@@ -97,7 +82,7 @@ ruby examples/group_demo.rb
 
 ---
 
-### 7. message_demo.rb - User-Facing Messages
+### 6. message_demo.rb - User-Facing Messages
 
 Output messages that bypass the progress display capture.
 
@@ -112,14 +97,12 @@ ruby examples/message_demo.rb
 
 ---
 
-### 8. progress_demo.rb - Progress Display Modes
+### 7. progress_demo.rb - Progress Display Modes
 
 Real-time progress visualization during parallel execution.
 
 ```bash
-ruby examples/progress_demo.rb                              # Tree mode
-TASKI_PROGRESS_MODE=simple ruby examples/progress_demo.rb   # Simple mode
-TASKI_PROGRESS_DISABLE=1 ruby examples/progress_demo.rb     # Disabled
+ruby examples/progress_demo.rb   # Simple mode (default)
 ```
 
 **Covers:**
@@ -136,7 +119,6 @@ TASKI_PROGRESS_DISABLE=1 ruby examples/progress_demo.rb     # Disabled
 | Example | Feature | Complexity |
 |---------|---------|------------|
 | quick_start | Exports API | Basic |
-| section_demo | Section API | Intermediate |
 | args_demo | Args/Env API | Intermediate |
 | reexecution_demo | Scope-Based Execution | Intermediate |
 | clean_demo | Lifecycle Management | Intermediate |
@@ -150,8 +132,7 @@ TASKI_PROGRESS_DISABLE=1 ruby examples/progress_demo.rb     # Disabled
 # Run each example
 for f in examples/*.rb; do echo "=== $f ===" && ruby "$f" && echo; done
 
-# Disable progress display if needed
-TASKI_PROGRESS_DISABLE=1 ruby examples/progress_demo.rb
+# Disable progress display if needed (add Taski.progress_display = nil in script)
 ```
 
 ## Next Steps

data/examples/clean_demo.rb

@@ -6,7 +6,7 @@
 # This example demonstrates the clean functionality:
 # - Defining clean methods for resource cleanup
 # - Reverse dependency order execution (dependents cleaned before dependencies)
-# - Parallel clean execution when possible
+# - run_and_clean with block support
 #
 # Run: ruby examples/clean_demo.rb
 
@@ -22,24 +22,14 @@ BUILD_DIR = "/tmp/taski_clean_demo"
 class SetupBuildDir < Taski::Task
   exports :build_path
 
-  ##
-  # Prepares the task's build directory and simulates its creation.
-  #
-  # Sets the task's exported `build_path` to the "build" subdirectory under `BUILD_DIR`
-  # and performs a simulated creation step with informational output.
   def run
     @build_path = "#{BUILD_DIR}/build"
     puts "[SetupBuildDir] Creating build directory: #{@build_path}"
-    # Simulated directory creation
     sleep 0.8
   end
 
-  ##
-  # Removes the directory referenced by @build_path.
-  # Cleans up build artifacts created by this task.
   def clean
     puts "[SetupBuildDir] Removing build directory: #{@build_path}"
-    # Simulated directory removal
     sleep 0.8
   end
 end
@@ -48,9 +38,6 @@ end
 class CompileSource < Taski::Task
   exports :binary_path
 
-  ##
-  # Compiles source artifacts and sets the compiled binary path for downstream tasks.
-  # This method sets @binary_path to the build directory's "app.bin" file and emits a console message indicating the compilation target.
   def run
     build_dir = SetupBuildDir.build_path
     @binary_path = "#{build_dir}/app.bin"
@@ -58,9 +45,6 @@ class CompileSource < Taski::Task
     sleep 1.5
   end
 
-  ##
-  # Removes the compiled binary produced by this task.
-  # Performs the task's cleanup step and simulates the deletion process.
   def clean
     puts "[CompileSource] Removing compiled binary: #{@binary_path}"
     sleep 0.6
@@ -71,11 +55,6 @@ end
 class GenerateDocs < Taski::Task
   exports :docs_path
 
-  ##
-  # Generates documentation for the build and records the output path.
-  #
-  # Sets the task's `@docs_path` to the "docs" subdirectory under `SetupBuildDir.build_path`
-  # and prints a progress message to STDOUT.
   def run
     build_dir = SetupBuildDir.build_path
     @docs_path = "#{build_dir}/docs"
@@ -83,9 +62,6 @@ class GenerateDocs < Taski::Task
     sleep 1.2
   end
 
-  ##
-  # Removes the generated documentation at the task's docs_path.
-  # Prints a removal message for @docs_path and simulates its deletion.
   def clean
     puts "[GenerateDocs] Removing generated docs: #{@docs_path}"
     sleep 0.5
@@ -96,9 +72,6 @@ end
 class CreateRelease < Taski::Task
   exports :release_path
 
-  ##
-  # Creates the release package path and announces the included artifacts.
-  # Uses CompileSource.binary_path and GenerateDocs.docs_path to determine the package inputs, sets @release_path to "#{BUILD_DIR}/release.zip", and prints the binary, docs, and output paths.
   def run
     binary = CompileSource.binary_path
     docs = GenerateDocs.docs_path
@@ -110,9 +83,6 @@ class CreateRelease < Taski::Task
     sleep 0.7
   end
 
-  ##
-  # Removes the release package produced by this task.
-  # Uses the task's `@release_path` as the target for cleanup.
   def clean
     puts "[CreateRelease] Removing release package: #{@release_path}"
     sleep 0.5
@@ -123,54 +93,44 @@ puts "\n--- Task Tree Structure ---"
 puts CreateRelease.tree
 puts
 
-puts "--- Running build process ---"
-CreateRelease.run
+puts "--- run_and_clean Demo ---"
+puts "The run_and_clean method executes both phases in a single operation."
+puts "Key benefits:"
+puts "  - Single progress display session for both phases"
+puts "  - Clean always runs, even if run fails (resource release)"
+puts "  - Cleaner API for the common use case"
 puts
 
-puts "Build completed!"
-puts "  Release: #{CreateRelease.release_path}"
-puts
+CreateRelease.run_and_clean
 
-puts "--- Cleaning up (reverse dependency order) ---"
-puts "Note: CreateRelease cleans first, then CompileSource/GenerateDocs in parallel,"
-puts "      and finally SetupBuildDir cleans last."
+puts
+puts "Both run and clean phases completed in a single call!"
 puts
 
-# Reset to allow clean execution
+# Demonstrate block support
 Taski::Task.reset!
 
-# Re-run to set up state for clean
-CreateRelease.run
-
-puts "\nNow cleaning..."
-CreateRelease.clean
-
-puts
-puts "Clean completed! All artifacts removed."
-
-puts
 puts "=" * 40
-puts "run_and_clean Demo"
+puts "run_and_clean with Block Demo"
 puts "=" * 40
 puts
-puts "The run_and_clean method executes both phases in a single operation."
-puts "Key benefits:"
-puts "  - Single progress display session for both phases"
-puts "  - Clean always runs, even if run fails (resource release)"
-puts "  - Cleaner API for the common use case"
+puts "Use a block to execute code between run and clean phases."
+puts "Exported values are accessible within the block."
 puts
 
-# Reset for new demonstration
-Taski::Task.reset!
-
-puts "--- Using run_and_clean ---"
-puts "This is equivalent to calling run followed by clean, but in a single operation."
-puts
-
-CreateRelease.run_and_clean
+CreateRelease.run_and_clean do
+  puts
+  puts "[Block] Release created at: #{CreateRelease.release_path}"
+  puts "[Block] Binary: #{CompileSource.binary_path}"
+  puts "[Block] Docs: #{GenerateDocs.docs_path}"
+  puts "[Block] Deploying release..."
+  sleep 0.3
+  puts "[Block] Deploy complete!"
+  puts
+end
 
 puts
-puts "Both run and clean phases completed in a single call!"
+puts "Block executed between run and clean phases!"
 puts
 
 # Demonstrate error handling