taski 0.8.3 → 0.9.1

data/sig/taski.rbs

@@ -1,23 +1,19 @@
 module Taski
   VERSION: String
 
-  self.@global_registry: Execution::Registry?
-  self.@progress_display: Execution::TreeProgressDisplay?
+  NOT_CONFIGURED: Object
+  self.@progress_display: Progress::Layout::Base | Object | nil
   self.@args: Args?
   self.@args_monitor: Monitor
 
   # Type alias for Task class (singleton type with class methods)
   # This represents a Class that inherits from Taski::Task
   type task_class = singleton(Task)
-
-  # Module-level methods
-  def self.global_registry: () -> Execution::Registry
-  def self.reset_global_registry!: () -> void
-  def self.progress_display: () -> Execution::TreeProgressDisplay?
-  def self.progress_disabled?: () -> bool
+  def self.progress_display: () -> (Progress::Layout::Base | untyped)?
+  def self.progress_display=: (untyped display) -> void
   def self.reset_progress_display!: () -> void
   def self.args: () -> Args?
-  def self.start_args: (options: Hash[Symbol, untyped], root_task: Class) -> void
+  def self.start_args: (options: Hash[Symbol, untyped]) -> void
   def self.reset_args!: () -> void
   def self.args_worker_count: () -> Integer?
 
@@ -37,11 +33,13 @@ module Taski
   class TaskFailure
     @task_class: Class
     @error: Exception
+    @output_lines: Array[String]
 
     attr_reader task_class: Class
     attr_reader error: Exception
+    attr_reader output_lines: Array[String]
 
-    def initialize: (task_class: Class, error: Exception) -> void
+    def initialize: (task_class: Class, error: Exception, ?output_lines: Array[String]) -> void
   end
 
   # Mixin for exception classes to enable transparent rescue matching with AggregateError
@@ -80,15 +78,8 @@ module Taski
   # Args class for execution arguments management
   class Args
     @options: Hash[Symbol | String, untyped]
-    @root_task: Class
-    @started_at: Time
-    @working_directory: String
-
-    attr_reader started_at: Time
-    attr_reader working_directory: String
-    attr_reader root_task: Class
 
-    def initialize: (options: Hash[Symbol | String, untyped], root_task: Class) -> void
+    def initialize: (options: Hash[Symbol | String, untyped]) -> void
     def []: (Symbol | String key) -> untyped
     def fetch: (Symbol | String key, ?untyped default) ?{ () -> untyped } -> untyped
     def key?: (Symbol | String key) -> bool
@@ -109,7 +100,7 @@ module Taski
     def self.clear_dependency_cache: () -> void
     def self.run: (?args: Hash[Symbol, untyped], ?workers: Integer?) -> untyped
     def self.clean: (?args: Hash[Symbol, untyped], ?workers: Integer?) -> void
-    def self.run_and_clean: (?args: Hash[Symbol, untyped], ?workers: Integer?) -> untyped
+    def self.run_and_clean: (?args: Hash[Symbol, untyped], ?workers: Integer?, ?clean_on_failure: bool) ?{ () -> void } -> untyped
     def self.registry: () -> Execution::Registry
     def self.reset!: () -> void
     def self.tree: () -> String
@@ -117,6 +108,7 @@ module Taski
     # Instance methods
     def run: () -> void
     def clean: () -> void
+    def group: (String name) { () -> untyped } -> untyped
     def system: (*untyped args, **untyped opts) -> bool?
     def reset!: () -> void
 
@@ -130,36 +122,18 @@ module Taski
     def self.validate_workers!: (untyped workers) -> void
   end
 
-  # Section class for abstraction layers (inherits from Task)
-  class Section < Task
-    def self.interfaces: (*Symbol interface_methods) -> void
-
-    def run: () -> void
-    def impl: () -> task_class
-
-    private
-
-    def apply_interface_to_implementation: (task_class implementation_class) -> void
-  end
-
   # Execution module
   module Execution
-    # TaskTiming struct (Data.define)
-    class TaskTiming
-      attr_reader start_time: Time
-      attr_reader end_time: Time?
-
-      # Data.define provides both positional and keyword argument constructors
-      def initialize: (Time start_time, Time? end_time) -> void
-                    | (start_time: Time, end_time: Time?) -> void
-
-      def self.new: (Time start_time, Time? end_time) -> TaskTiming
-                  | (start_time: Time, end_time: Time?) -> TaskTiming
-
-      def self.start_now: () -> TaskTiming
-      def duration_ms: () -> (Integer | Float)?
-      def with_end_now: () -> TaskTiming
-      def with: (?start_time: Time, ?end_time: Time?) -> TaskTiming
+    # Base class for observers of the execution lifecycle
+    class TaskObserver
+      attr_accessor context: ExecutionFacade?
+
+      def on_ready: () -> void
+      def on_start: () -> void
+      def on_stop: () -> void
+      def on_task_updated: (Class task_class, previous_state: Symbol?, current_state: Symbol, phase: Symbol, timestamp: Time) -> void
+      def on_group_started: (Class task_class, String group_name, phase: Symbol, timestamp: Time) -> void
+      def on_group_completed: (Class task_class, String group_name, phase: Symbol, timestamp: Time) -> void
     end
 
     # Registry class for task instance management
@@ -171,57 +145,55 @@ module Taski
 
       def initialize: () -> void
       def get_or_create: (Class task_class) { () -> TaskWrapper } -> TaskWrapper
-      def get_task: (Class task_class) -> TaskWrapper?
+      def create_wrapper: (Class task_class, execution_facade: ExecutionFacade) -> TaskWrapper
       def register: (Class task_class, TaskWrapper wrapper) -> void
       def register_thread: (Thread thread) -> void
       def wait_all: () -> void
       def reset!: () -> void
       def request_abort!: () -> void
       def abort_requested?: () -> bool
-      def run: (Class task_class, Array[Symbol] exported_methods) -> untyped
+      def registered?: (Class task_class) -> bool
       def failed_wrappers: () -> Array[TaskWrapper]
       def failed_clean_wrappers: () -> Array[TaskWrapper]
     end
 
-    # ExecutionContext manages execution state and notifies observers about execution events
-    class ExecutionContext
+    # ExecutionFacade is the central hub for execution events with both Push and Pull APIs
+    class ExecutionFacade
       THREAD_LOCAL_KEY: Symbol
 
+      attr_reader root_task_class: Class?
+      attr_reader dependency_graph: StaticAnalysis::DependencyGraph?
+
+      @root_task_class: Class?
+      @dependency_graph: StaticAnalysis::DependencyGraph?
       @monitor: Monitor
       @observers: Array[untyped]
-      @execution_trigger: (^(Class, Registry) -> void)?
-      @clean_trigger: (^(Class, Registry) -> void)?
       @output_capture: TaskOutputRouter?
       @original_stdout: IO?
-      @runtime_dependencies: Hash[Class, Set[Class]]
+      @original_stderr: IO?
 
-      def self.current: () -> ExecutionContext?
-      def self.current=: (ExecutionContext? context) -> void
+      def self.build_default: (root_task_class: Class) -> ExecutionFacade
+      def self.current: () -> ExecutionFacade?
+      def self.current=: (ExecutionFacade? context) -> void
 
-      def initialize: () -> void
+      def initialize: (root_task_class: Class) -> void
       def output_capture_active?: () -> bool
+      def original_stdout: () -> IO?
+      def original_stderr: () -> IO?
       def setup_output_capture: (IO output_io) -> void
       def teardown_output_capture: () -> void
       def output_capture: () -> TaskOutputRouter?
-      def execution_trigger=: ((^(Class, Registry) -> void)? trigger) -> void
-      def clean_trigger=: ((^(Class, Registry) -> void)? trigger) -> void
       def trigger_execution: (Class task_class, registry: Registry) -> void
-      def trigger_clean: (Class task_class, registry: Registry) -> untyped
-      def register_runtime_dependency: (Class from_class, Class to_class) -> void
-      def runtime_dependencies: () -> Hash[Class, Set[Class]]
+      def trigger_clean: (Class task_class, registry: Registry) -> void
       def add_observer: (untyped observer) -> void
       def remove_observer: (untyped observer) -> void
       def observers: () -> Array[untyped]
-      def notify_task_registered: (Class task_class) -> void
-      def notify_task_started: (Class task_class) -> void
-      def notify_task_completed: (Class task_class, ?duration: Float?, ?error: Exception?) -> void
-      def notify_section_impl_selected: (Class section_class, Class impl_class) -> void
-      def notify_set_root_task: (Class task_class) -> void
-      def notify_set_output_capture: (TaskOutputRouter output_capture) -> void
+      def notify_ready: () -> void
       def notify_start: () -> void
       def notify_stop: () -> void
-      def notify_clean_started: (Class task_class) -> void
-      def notify_clean_completed: (Class task_class, ?duration: Float?, ?error: Exception?) -> void
+      def notify_task_updated: (Class task_class, previous_state: Symbol?, current_state: Symbol, phase: Symbol, timestamp: Time) -> void
+      def notify_group_started: (Class task_class, String group_name, phase: Symbol, timestamp: Time) -> void
+      def notify_group_completed: (Class task_class, String group_name, phase: Symbol, timestamp: Time) -> void
 
       private
 
@@ -230,41 +202,49 @@ module Taski
 
     # TaskOutputRouter for routing task output
     class TaskOutputRouter
-      def initialize: (IO original_io) -> void
+      def initialize: (IO original_io, ?ExecutionFacade? execution_facade) -> void
       def current_write_io: () -> IO?
       def start_capture: (Class task_class) -> void
       def stop_capture: () -> void
+      def read: (Class task_class, ?limit: Integer?) -> Array[String]
     end
 
     # Scheduler manages task dependency state and determines execution order
     class Scheduler
       STATE_PENDING: Symbol
-      STATE_ENQUEUED: Symbol
+      STATE_RUNNING: Symbol
       STATE_COMPLETED: Symbol
-      CLEAN_STATE_PENDING: Symbol
-      CLEAN_STATE_ENQUEUED: Symbol
-      CLEAN_STATE_COMPLETED: Symbol
+      STATE_FAILED: Symbol
+      STATE_SKIPPED: Symbol
 
-      @dependencies: Hash[Class, Set[Class]]
+      @dependencies: Hash[Class, Array[Class]]
       @task_states: Hash[Class, Symbol]
-      @completed_tasks: Set[Class]
+      @finished_tasks: Set[Class]
+      @run_reverse_deps: Hash[Class, Set[Class]]
       @reverse_dependencies: Hash[Class, Set[Class]]
       @clean_task_states: Hash[Class, Symbol]
-      @clean_completed_tasks: Set[Class]
+      @clean_finished_tasks: Set[Class]
 
       def initialize: () -> void
-      def build_dependency_graph: (Class root_task_class) -> void
+      def load_graph: (StaticAnalysis::DependencyGraph dependency_graph, Class root_task_class) -> void
       def next_ready_tasks: () -> Array[Class]
-      def mark_enqueued: (Class task_class) -> void
+      def mark_running: (Class task_class) -> void
       def mark_completed: (Class task_class) -> void
-      def completed?: (Class task_class) -> bool
+      def mark_failed: (Class task_class) -> void
+      def pending?: (Class task_class) -> bool
+      def finished?: (Class task_class) -> bool
       def running_tasks?: () -> bool
-      def merge_runtime_dependencies: (Hash[Class, Set[Class]] runtime_deps) -> void
-      def build_reverse_dependency_graph: (Class root_task_class) -> void
+      def task_count: () -> Integer
+      def never_started_task_classes: () -> Array[Class]
+      def mark_skipped: (Class task_class) -> bool
+      def skipped_count: () -> Integer
+      def pending_dependents_of: (Class task_class) -> Array[Class]
+      def build_reverse_dependency_graph: () -> void
       def next_ready_clean_tasks: () -> Array[Class]
-      def mark_clean_enqueued: (Class task_class) -> void
+      def mark_clean_running: (Class task_class) -> void
       def mark_clean_completed: (Class task_class) -> void
-      def clean_completed?: (Class task_class) -> bool
+      def mark_clean_failed: (Class task_class) -> void
+      def clean_finished?: (Class task_class) -> bool
       def running_clean_tasks?: () -> bool
 
       private
@@ -273,72 +253,94 @@ module Taski
       def ready_to_clean?: (Class task_class) -> bool
     end
 
-    # WorkerPool manages a pool of worker threads that execute tasks
+    def self.default_worker_count: () -> Integer
+
+    # WorkerPool manages N threads, each with its own command Queue
+    # Tasks are executed within Fibers on worker threads
     class WorkerPool
-      attr_reader execution_queue: Thread::Queue
+      attr_reader worker_count: Integer
 
-      @worker_count: Integer
       @registry: Registry
-      @on_execute: ^(Class, TaskWrapper) -> void
-      @execution_queue: Thread::Queue
-      @workers: Array[Thread]
+      @execution_facade: ExecutionFacade
+      @worker_count: Integer
+      @completion_queue: Thread::Queue
+      @threads: Array[Thread]
+      @thread_queues: Array[Thread::Queue]
+      @next_thread_index: Integer
+      @fiber_contexts_mutex: Mutex
+      @fiber_contexts: Hash[Integer, Array[untyped]]
+      @task_start_times: Hash[Class, Time]
 
-      def initialize: (registry: Registry, ?worker_count: Integer?) { (Class, TaskWrapper) -> void } -> void
+      def initialize: (registry: Registry, execution_facade: ExecutionFacade, completion_queue: Thread::Queue, ?worker_count: Integer?) -> void
       def start: () -> void
       def enqueue: (Class task_class, TaskWrapper wrapper) -> void
+      def enqueue_clean: (Class task_class, TaskWrapper wrapper) -> void
       def shutdown: () -> void
-      def enqueue_shutdown_signals: () -> void
 
       private
 
-      def default_worker_count: () -> Integer
-      def worker_loop: () -> void
-      def debug_log: (String message) -> void
+      def worker_loop: (Thread::Queue queue) -> void
+      def drive_fiber: (Class task_class, TaskWrapper wrapper, Thread::Queue queue) -> void
+      def drive_fiber_loop: (Fiber fiber, Class task_class, TaskWrapper wrapper, Thread::Queue queue, ?untyped resume_value) -> void
+      def handle_dependency: (Class dep_class, Symbol method, Fiber fiber, Class task_class, TaskWrapper wrapper, Thread::Queue queue) -> void
+      def resume_fiber: (Fiber fiber, untyped value, Thread::Queue queue) -> void
+      def resume_fiber_with_error: (Fiber fiber, Exception error, Thread::Queue queue) -> void
+      def start_dependency: (Class dep_class, TaskWrapper dep_wrapper, Thread::Queue queue) -> void
+      def complete_task: (Class task_class, TaskWrapper wrapper, untyped result) -> void
+      def fail_task: (Class task_class, TaskWrapper wrapper, Exception error) -> void
+      def execute_clean_task: (Class task_class, TaskWrapper wrapper) -> void
+      def setup_clean_thread_locals: () -> void
+      def setup_run_thread_locals: () -> void
+      def teardown_thread_locals: () -> void
+      def start_output_capture: (Class task_class) -> void
+      def stop_output_capture: () -> void
+      def store_fiber_context: (Fiber fiber, Class task_class, TaskWrapper wrapper) -> void
+      def get_fiber_context: (Fiber fiber) -> Array[untyped]?
+      def task_duration_ms: (Class task_class) -> Float?
     end
 
-    # Executor class for parallel task execution (Producer-Consumer pattern)
+    # Executor orchestrates both run and clean phases of task execution
+    # Both run and clean phases use WorkerPool
     class Executor
       @registry: Registry
       @completion_queue: Thread::Queue
-      @execution_context: ExecutionContext
+      @execution_facade: ExecutionFacade
       @scheduler: Scheduler
       @effective_worker_count: Integer?
-      @worker_pool: WorkerPool
-      @clean_worker_pool: WorkerPool?
+      @worker_pool: WorkerPool?
+      @saved_output_capture: TaskOutputRouter?
 
-      def self.execute: (Class root_task_class, registry: Registry, ?execution_context: ExecutionContext?) -> void
-      def self.execute_clean: (Class root_task_class, registry: Registry, ?execution_context: ExecutionContext?) -> void
-      def initialize: (registry: Registry, ?worker_count: Integer?, ?execution_context: ExecutionContext?) -> void
+      def self.execute: (Class root_task_class, registry: Registry, execution_facade: ExecutionFacade) -> void
+      def self.execute_clean: (Class root_task_class, registry: Registry, execution_facade: ExecutionFacade) -> void
+      def initialize: (registry: Registry, execution_facade: ExecutionFacade, ?worker_count: Integer?) -> void
       def execute: (Class root_task_class) -> void
       def execute_clean: (Class root_task_class) -> void
 
       private
 
-      def enqueue_ready_tasks: () -> void
-      def enqueue_task: (Class task_class) -> void
-      def get_or_create_wrapper: (Class task_class) -> TaskWrapper
-      def execute_task: (Class task_class, TaskWrapper wrapper) -> void
+      def pre_start_leaf_tasks: () -> void
+      def enqueue_root_if_needed: (Class root_task_class) -> void
       def run_main_loop: (Class root_task_class) -> void
       def handle_completion: (Hash[Symbol, untyped] event) -> void
+      def enqueue_for_execution: (Class task_class) -> void
+      def skip_pending_dependents: (Class failed_task_class) -> void
+      def notify_skipped_tasks: () -> void
       def enqueue_ready_clean_tasks: () -> void
       def enqueue_clean_task: (Class task_class) -> void
-      def execute_clean_task: (Class task_class, TaskWrapper wrapper) -> void
-      def run_clean_main_loop: (Class root_task_class) -> void
+      def run_clean_main_loop: () -> void
       def handle_clean_completion: (Hash[Symbol, untyped] event) -> void
       def all_tasks_cleaned?: () -> bool
-      def setup_progress_display: (Class root_task_class) -> void
+      def with_display_lifecycle: (Class root_task_class) { () -> void } -> void
       def setup_output_capture_if_needed: () -> bool
-      def teardown_output_capture: () -> void
-      def start_progress_display: () -> void
-      def stop_progress_display: () -> void
-      def create_default_execution_context: () -> ExecutionContext
-      def debug_log: (String message) -> void
       def raise_if_any_failures: () -> void
-      def flatten_failures: (Array[TaskWrapper] failed_wrappers) -> Array[TaskFailure]
-      def wrap_with_task_error: (Class task_class, Exception error) -> TaskError
       def raise_if_any_clean_failures: () -> void
-      def flatten_clean_failures: (Array[TaskWrapper] failed_wrappers) -> Array[TaskFailure]
+      def raise_if_any_failures_from: (Array[TaskWrapper] failed_wrappers, error_accessor: ^(TaskWrapper) -> StandardError?) -> void
+      def flatten_failures_from: (Array[TaskWrapper] failed_wrappers, error_accessor: ^(TaskWrapper) -> StandardError?) -> Array[TaskFailure]
+      def wrap_with_task_error: (Class task_class, Exception error) -> TaskError
       def error_identity: (Exception error) -> Integer
+      def log_execution_started: (Class root_task_class) -> void
+      def log_execution_completed: (Class root_task_class, Time start_time) -> void
+      def log_error_detail: (Class task_class, Exception error) -> void
     end
 
     # TaskWrapper class for task execution
@@ -347,11 +349,11 @@ module Taski
       attr_reader result: untyped
       attr_reader error: StandardError?
       attr_reader clean_error: StandardError?
-      attr_reader timing: TaskTiming?
 
       @task: Task
       @registry: Registry
-      @execution_context: ExecutionContext?
+      @execution_facade: ExecutionFacade?
+      @args: Hash[Symbol, untyped]?
       @result: untyped
       @clean_result: untyped
       @error: StandardError?
@@ -361,26 +363,30 @@ module Taski
       @clean_condition: MonitorMixin::ConditionVariable
       @state: Symbol
       @clean_state: Symbol
-      @timing: TaskTiming?
+      @waiters: Array[Array[untyped]]
 
       STATE_PENDING: Symbol
       STATE_RUNNING: Symbol
       STATE_COMPLETED: Symbol
       STATE_FAILED: Symbol
+      STATE_SKIPPED: Symbol
 
-      def initialize: (Task task, registry: Registry, ?execution_context: ExecutionContext?) -> void
+      def initialize: (Task task, registry: Registry, ?execution_facade: ExecutionFacade?, ?args: Hash[Symbol, untyped]?) -> void
       def state: () -> Symbol
       def pending?: () -> bool
       def completed?: () -> bool
       def failed?: () -> bool
-      def clean_failed?: () -> bool
+      def skipped?: () -> bool
       def run: () -> untyped
       def clean: () -> untyped
-      def run_and_clean: () -> untyped
+      def reset!: () -> void
+      def run_and_clean: (?clean_on_failure: bool) ?{ () -> void } -> untyped
       def get_exported_value: (Symbol method_name) -> untyped
+      def request_value: (Symbol method, Thread::Queue thread_queue, Fiber fiber) -> Array[untyped]
       def mark_running: () -> bool
       def mark_completed: (untyped result) -> void
       def mark_failed: (StandardError error) -> void
+      def mark_skipped: () -> bool
       def mark_clean_running: () -> bool
       def mark_clean_completed: (untyped result) -> void
       def mark_clean_failed: (StandardError error) -> void
@@ -391,89 +397,44 @@ module Taski
 
       private
 
+      def with_args_lifecycle: [T] () { () -> T } -> T
       def trigger_execution_and_wait: () -> void
       def trigger_clean_and_wait: () -> void
-      def execute_clean: () -> void
-      def wait_for_clean_dependencies: () -> void
+      def trigger_and_wait: (state_accessor: ^() -> Symbol, condition: MonitorMixin::ConditionVariable, trigger: ^(ExecutionFacade) -> void) -> void
       def check_abort!: () -> void
-      def update_progress: (Symbol state, ?duration: Numeric?, ?error: Exception?) -> void
-      def debug_log: (String message) -> void
+      def ensure_execution_facade: () -> ExecutionFacade
+      def create_shared_context: () -> ExecutionFacade
+      def notify_skipped: () -> void
+      def update_progress: (Symbol state, ?error: Exception?) -> void
+      def update_clean_progress: (Symbol state, ?error: Exception?) -> void
+      def notify_state_change: (previous_state: Symbol?, current_state: Symbol, phase: Symbol) -> void
+      def notify_fiber_waiters_completed: (Array[Array[untyped]] waiters) -> void
+      def notify_fiber_waiters_failed: (Array[Array[untyped]] waiters, Exception error) -> void
     end
+  end
 
-    # TreeProgressDisplay class for tree-based progress visualization
-    class TreeProgressDisplay
-      SPINNER_FRAMES: Array[String]
-      COLORS: Hash[Symbol, String]
-      ICONS: Hash[Symbol, String]
-
-      @output: IO
-      @tasks: Hash[Class, TaskProgress]
-      @monitor: Monitor
-      @spinner_index: Integer
-      @renderer_thread: Thread?
-      @running: bool
-      @nest_level: Integer
-      @root_task_class: Class?
-      @tree_structure: Hash[Symbol, untyped]?
-      @section_impl_map: Hash[Class, Class]
-      @last_line_count: Integer
-
-      # Shared class methods
-      def self.section_class?: (Class klass) -> bool
-      def self.nested_class?: (Class child_class, Class parent_class) -> bool
-      def self.render_static_tree: (Class root_task_class) -> String
-
-      # Static tree renderer (internal class)
-      class StaticTreeRenderer
-        @task_index_map: Hash[Class, Integer]
-
-        def render: (Class root_task_class) -> String
-
-        private
-
-        def build_tree: (Class task_class, String prefix, bool is_impl, Set[Class] ancestors) -> String
-        def render_dependency_branch: (Class dep, String prefix, bool is_last, bool is_impl, Set[Class] ancestors) -> String
-        def get_task_number: (Class task_class) -> String
-        def colored_type_label: (Class klass) -> String
+  # Progress module
+  module Progress
+    module Layout
+      # Base class for progress display layouts
+      class Base < Execution::TaskObserver
       end
 
-      class TaskProgress
-        attr_accessor state: Symbol
-        attr_accessor start_time: Time?
-        attr_accessor end_time: Time?
-        attr_accessor error: Exception?
-        attr_accessor duration: Numeric?
-        attr_accessor is_impl_candidate: bool
-
-        def initialize: () -> void
+      # Tree layout for hierarchical task display
+      class Tree < Base
+        def initialize: (?output: IO, ?theme: Theme::Base?) -> void
+        def render_tree: () -> String
       end
 
-      def initialize: (?output: IO) -> void
-      def set_root_task: (Class root_task_class) -> void
-      def register_section_impl: (Class section_class, Class impl_class) -> void
-      def register_task: (Class task_class) -> void
-      def task_registered?: (Class task_class) -> bool
-      def update_task: (Class task_class, state: Symbol, ?duration: Numeric?, ?error: Exception?) -> void
-      def task_state: (Class task_class) -> Symbol?
-      def start: () -> void
-      def stop: () -> void
-
-      private
+      # Simple layout for single-line progress display
+      class Simple < Base
+        def initialize: (?output: IO, ?theme: Theme::Base?) -> void
+      end
 
-      def build_tree_structure: () -> void
-      def build_tree_node: (Class task_class, Set[Class] ancestors) -> Hash[Symbol, untyped]?
-      def register_tasks_from_tree: (Hash[Symbol, untyped] node) -> void
-      def render_live: () -> void
-      def render_final: () -> void
-      def build_tree_display: () -> Array[String]
-      def build_root_tree_lines: (Hash[Symbol, untyped] node, String prefix, Array[String] lines) -> void
-      def render_children: (Hash[Symbol, untyped] node, String prefix, Array[String] lines, Class parent_task_class, bool ancestor_selected) -> void
-      def format_tree_line: (Class task_class, TaskProgress? progress, bool is_impl, bool is_selected) -> String
-      def format_unknown_task: (Class task_class, ?bool is_selected) -> String
-      def spinner_char: () -> String
-      def type_label_for: (Class task_class, ?bool is_selected) -> String
-      def section_class?: (Class klass) -> bool
-      def nested_class?: (Class child_class, Class parent_class) -> bool
+      # Log layout for non-TTY environments
+      class Log < Base
+        def initialize: (?output: IO, ?theme: Theme::Base?) -> void
+      end
     end
   end
 
@@ -485,7 +446,6 @@ module Taski
 
       private
 
-      def self.target_method_for: (Class task_class) -> Symbol
       def self.extract_method_location: (Class task_class, Symbol method_name) -> [String, Integer]?
     end
 
@@ -499,7 +459,7 @@ module Taski
 
       attr_reader dependencies: Set[task_class]
 
-      def initialize: (Class task_class, Symbol target_method) -> void
+      def initialize: (Class task_class, ?Symbol target_method, ?Array[Symbol]? methods_to_analyze) -> void
       def visit_class_node: (Prism::ClassNode node) -> untyped
       def visit_module_node: (Prism::ModuleNode node) -> untyped
       def visit_def_node: (Prism::DefNode node) -> untyped
@@ -507,19 +467,20 @@ module Taski
 
       private
 
+      def follow_method_calls: () -> void
+      def collect_method_definitions: (Prism::ClassNode class_node) -> void
       def within_namespace: (String? name) { () -> void } -> void
       def in_target_class?: () -> bool
-      def in_impl_method?: () -> bool
       def extract_constant_name: (untyped node) -> String?
+      def should_analyze_method?: (Symbol method_name) -> bool
+      def detect_method_call_to_follow: (Prism::CallNode node) -> void
+      def self_receiver?: (untyped receiver) -> bool
       def detect_task_dependency: (Prism::CallNode node) -> void
-      def detect_impl_candidate: (untyped node) -> void
       def extract_receiver_constant: (untyped receiver) -> String?
       def resolve_and_add_dependency: (String constant_name) -> void
       def resolve_constant: (String name) -> task_class?
       def resolve_with_namespace_prefix: (String name) -> task_class?
       def valid_dependency?: (task_class klass) -> bool
-      def is_parallel_task?: (task_class klass) -> boolish
-      def is_parallel_section?: (task_class klass) -> boolish
     end
 
     # DependencyGraph class for topological sorting and cycle detection
@@ -530,6 +491,7 @@ module Taski
 
       def initialize: () -> void
       def build_from: (Class root_task_class) -> self
+      def build_from_cached: (Class root_task_class) -> self
       def sorted: () -> Array[Class]
       def cyclic?: () -> bool
       def strongly_connected_components: () -> Array[Array[Class]]
@@ -544,6 +506,35 @@ module Taski
       private
 
       def collect_dependencies: (Class task_class) -> void
+      def collect_cached_dependencies: (Class task_class) -> void
     end
   end
+
+  # Logging module
+  module Logging
+    module Events
+      EXECUTION_STARTED: String
+      EXECUTION_COMPLETED: String
+      TASK_STARTED: String
+      TASK_COMPLETED: String
+      TASK_FAILED: String
+      TASK_CLEAN_STARTED: String
+      TASK_CLEAN_COMPLETED: String
+      TASK_CLEAN_FAILED: String
+      TASK_SKIPPED: String
+      DEPENDENCY_RESOLVED: String
+      TASK_ERROR_DETAIL: String
+      TASK_OUTPUT: String
+      WORKER_POOL_ENQUEUED: String
+      EXECUTOR_TASK_COMPLETED: String
+      EXECUTOR_CLEAN_COMPLETED: String
+      OUTPUT_ROUTER_START_CAPTURE: String
+      OUTPUT_ROUTER_STOP_CAPTURE: String
+      OUTPUT_ROUTER_STOP_CAPTURE_UNREGISTERED: String
+      OUTPUT_ROUTER_DRAIN_PIPE: String
+      OUTPUT_ROUTER_STORE_LINES: String
+      OBSERVER_ERROR: String
+    end
+
+  end
 end