ace-task 0.31.0

data/lib/ace/task/atoms/task_frontmatter_defaults.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Ace
+  module Task
+    module Atoms
+      # Builds default frontmatter hash for new tasks matching the task schema.
+      module TaskFrontmatterDefaults
+        VALID_STATUSES = %w[pending in-progress done blocked draft skipped cancelled].freeze
+        VALID_PRIORITIES = %w[critical high medium low].freeze
+
+        # Build a frontmatter hash with defaults for missing values.
+        #
+        # @param id [String] Formatted task ID (required)
+        # @param status [String] Task status (default: "pending")
+        # @param priority [String, nil] Priority level
+        # @param tags [Array<String>] Tags
+        # @param dependencies [Array<String>] Dependency task IDs
+        # @param created_at [Time, nil] Creation time
+        # @param parent [String, nil] Parent task ID for subtasks
+        # @return [Hash] Frontmatter hash
+        def self.build(id:, status: "pending", priority: nil, tags: [], dependencies: [], created_at: nil, parent: nil, estimate: nil)
+          fm = {
+            "id" => id,
+            "status" => status || "pending",
+            "priority" => priority || "medium",
+            "created_at" => format_time(created_at)
+          }
+          fm["estimate"] = estimate
+          fm["dependencies"] = dependencies || []
+          fm["tags"] = tags || []
+          fm["parent"] = parent if parent
+          fm
+        end
+
+        # Format time for frontmatter
+        # @param time [Time, nil]
+        # @return [String, nil]
+        def self.format_time(time)
+          return nil unless time
+
+          time.strftime("%Y-%m-%d %H:%M:%S")
+        end
+      end
+    end
+  end
+end

data/lib/ace/task/atoms/task_id_formatter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "ace/b36ts"
+require "ace/support/items"
+
+module Ace
+  module Task
+    module Atoms
+      # Wraps ItemIdFormatter with the ".t." type marker for tasks.
+      #
+      # @example Generate and format a task ID
+      #   TaskIdFormatter.generate
+      #   # => ItemId(prefix: "8pp", type_marker: "t", suffix: "q7w", formatted_id: "8pp.t.q7w")
+      #
+      # @example Format an existing b36ts ID
+      #   TaskIdFormatter.format("8ppq7w")
+      #   # => ItemId with formatted_id "8pp.t.q7w"
+      class TaskIdFormatter
+        TYPE_MARKER = "t"
+
+        # Generate a new task ID from current time
+        # @param time [Time] Time to encode (default: now)
+        # @return [Ace::Support::Items::Models::ItemId]
+        def self.generate(time = Time.now.utc)
+          raw = Ace::B36ts.encode(time, format: :"2sec")
+          Ace::Support::Items::Atoms::ItemIdFormatter.split(raw, type_marker: TYPE_MARKER)
+        end
+
+        # Format an existing 6-char b36ts ID as a task ID
+        # @param raw_b36ts [String] 6-character b36ts ID
+        # @return [Ace::Support::Items::Models::ItemId]
+        def self.format(raw_b36ts)
+          Ace::Support::Items::Atoms::ItemIdFormatter.split(raw_b36ts, type_marker: TYPE_MARKER)
+        end
+
+        # Reconstruct raw b36ts from a formatted task ID
+        # @param formatted_id [String] e.g., "8pp.t.q7w"
+        # @return [String] Raw 6-char b36ts ID
+        def self.reconstruct(formatted_id)
+          Ace::Support::Items::Atoms::ItemIdFormatter.reconstruct(formatted_id)
+        end
+
+        # Build folder name from formatted ID and slug
+        # @param formatted_id [String] e.g., "8pp.t.q7w"
+        # @param slug [String] e.g., "fix-login"
+        # @return [String] e.g., "8pp.t.q7w-fix-login"
+        def self.folder_name(formatted_id, slug)
+          Ace::Support::Items::Atoms::ItemIdFormatter.folder_name(formatted_id, slug)
+        end
+
+        # Build spec filename from formatted ID and slug
+        # @param formatted_id [String] e.g., "8pp.t.q7w"
+        # @param slug [String] e.g., "fix-login"
+        # @return [String] e.g., "8pp.t.q7w-fix-login.s.md"
+        def self.spec_filename(formatted_id, slug)
+          base = folder_name(formatted_id, slug)
+          "#{base}.s.md"
+        end
+      end
+    end
+  end
+end

data/lib/ace/task/atoms/task_validation_rules.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Ace
+  module Task
+    module Atoms
+      module TaskValidationRules
+        VALID_STATUSES = %w[pending in-progress done blocked draft skipped cancelled].freeze
+        TERMINAL_STATUSES = %w[done skipped cancelled].freeze
+        REQUIRED_FIELDS = %w[id status title].freeze
+        RECOMMENDED_FIELDS = %w[tags created_at].freeze
+        MAX_TITLE_LENGTH = 80
+
+        def self.valid_status?(status)
+          VALID_STATUSES.include?(status.to_s)
+        end
+
+        def self.terminal_status?(status)
+          TERMINAL_STATUSES.include?(status.to_s)
+        end
+
+        def self.valid_id?(id)
+          id.to_s.match?(/^[0-9a-z]{3}\.[a-z]\.[0-9a-z]{3}$/)
+        end
+
+        def self.scope_consistent?(status, special_folder)
+          issues = []
+          if terminal_status?(status) && special_folder != "_archive"
+            issues << {type: :warning, message: "Task with terminal status '#{status}' not in _archive/"}
+          end
+          if special_folder == "_archive" && !terminal_status?(status) && status
+            issues << {type: :warning, message: "Task in _archive/ but status is '#{status}' (expected terminal status)"}
+          end
+          if special_folder == "_maybe" && terminal_status?(status)
+            issues << {type: :warning, message: "Task in _maybe/ with terminal status '#{status}' (should be in _archive/)"}
+          end
+          issues
+        end
+
+        def self.missing_required_fields(frontmatter)
+          return REQUIRED_FIELDS.dup if frontmatter.nil? || !frontmatter.is_a?(Hash)
+          REQUIRED_FIELDS.select { |field| frontmatter[field].nil? || frontmatter[field].to_s.strip.empty? }
+        end
+
+        def self.missing_recommended_fields(frontmatter)
+          return RECOMMENDED_FIELDS.dup if frontmatter.nil? || !frontmatter.is_a?(Hash)
+          RECOMMENDED_FIELDS.select { |field| frontmatter[field].nil? }
+        end
+      end
+    end
+  end
+end

data/lib/ace/task/cli/commands/create.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+
+module Ace
+  module Task
+    module CLI
+      module Commands
+        # ace-support-cli Command class for ace-task create
+        class Create < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc <<~DESC.strip
+            Create a new task
+
+            Creates a new task with a B36TS-based type-marked ID (xxx.t.yyy).
+          DESC
+
+          example [
+            '"Fix login bug"                              # Create task with title',
+            '"Fix auth" --priority high --tags auth,security  # With priority and tags',
+            '"Setup DB" --child-of q7w                    # Create as subtask',
+            '"Quick task" --in maybe                      # Create in _maybe/ folder',
+            '"Draft spec" --status draft --estimate TBD   # Create as draft with estimate',
+            '"Preview only" --dry-run                     # Show what would be created'
+          ]
+
+          argument :title, required: true, desc: "Task title"
+
+          option :priority, type: :string, aliases: %w[-p], desc: "Priority (critical, high, medium, low)"
+          option :tags, type: :string, aliases: %w[-T], desc: "Tags (comma-separated)"
+          option :status, type: :string, aliases: %w[-s], desc: "Initial status (draft, pending, blocked, ...)"
+          option :estimate, type: :string, aliases: %w[-e], desc: "Effort estimate (e.g. TBD, 2h, 1d)"
+          option :"child-of", type: :string, desc: "Parent task reference (creates subtask)"
+          option :in, type: :string, aliases: %w[-i], desc: "Target folder (e.g. next, maybe)"
+          option :"dry-run", type: :boolean, aliases: %w[-n], desc: "Preview without writing"
+
+          option :git_commit, type: :boolean, aliases: %w[--gc], desc: "Auto-commit changes"
+
+          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+          option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
+          option :debug, type: :boolean, aliases: %w[-d], desc: "Show debug output"
+
+          def call(title:, **options)
+            dry_run = options[:"dry-run"]
+            priority = options[:priority]
+            tags_str = options[:tags]
+            tags = tags_str ? tags_str.split(",").map(&:strip).reject(&:empty?) : []
+            status = options[:status]
+            estimate = options[:estimate]
+            child_of = options[:"child-of"]
+            in_folder = options[:in]
+
+            if status
+              valid = Ace::Task::Atoms::TaskValidationRules::VALID_STATUSES
+              unless valid.include?(status)
+                raise Ace::Support::Cli::Error.new("Invalid status '#{status}'. Valid: #{valid.join(", ")}")
+              end
+            end
+
+            if dry_run
+              puts "Would create task:"
+              puts "  Title:    #{title}"
+              puts "  Status:   #{status}" if status
+              puts "  Priority: #{priority}" if priority
+              puts "  Estimate: #{estimate}" if estimate
+              puts "  Tags:     #{tags.join(", ")}" if tags.any?
+              puts "  Parent:   #{child_of}" if child_of
+              puts "  Folder:   #{in_folder}" if in_folder
+              return
+            end
+
+            manager = Ace::Task::Organisms::TaskManager.new
+
+            task = if child_of
+              manager.create_subtask(child_of, title, status: status, priority: priority, tags: tags, estimate: estimate)
+            else
+              manager.create(title, status: status, priority: priority, tags: tags, estimate: estimate)
+            end
+
+            unless task
+              raise Ace::Support::Cli::Error.new("Parent task '#{child_of}' not found") if child_of
+              raise Ace::Support::Cli::Error.new("Failed to create task")
+            end
+
+            # Move to folder if specified
+            if in_folder && !child_of
+              task = manager.move(task.id, to: in_folder)
+            end
+
+            puts "Created task #{task.id}"
+            puts "  Path: #{task.file_path}"
+
+            if options[:git_commit]
+              Ace::Support::Items::Molecules::GitCommitter.commit(
+                paths: [task.path],
+                intention: "create task #{task.id}"
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/task/cli/commands/doctor.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require "ace/core"
+require_relative "../../organisms/task_doctor"
+require_relative "../../molecules/task_doctor_fixer"
+require_relative "../../molecules/task_doctor_reporter"
+require_relative "../../molecules/task_config_loader"
+
+module Ace
+  module Task
+    module CLI
+      module Commands
+        # ace-support-cli Command class for ace-task doctor
+        #
+        # Runs health checks on tasks and optionally auto-fixes issues.
+        class Doctor < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc <<~DESC.strip
+            Run health checks on tasks
+
+            Validates frontmatter, file structure, and scope/status consistency
+            across all tasks in the repository. Supports auto-fixing safe issues.
+
+          DESC
+
+          example [
+            "                          # Run all health checks",
+            "--auto-fix                # Auto-fix safe issues",
+            "--auto-fix --dry-run      # Preview fixes without applying",
+            "--auto-fix-with-agent     # Auto-fix then launch agent for remaining",
+            "--check frontmatter       # Run specific check (frontmatter|structure|scope)",
+            "--json                    # Output as JSON",
+            "--verbose                 # Show all warnings"
+          ]
+
+          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+          option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
+          option :auto_fix, type: :boolean, aliases: %w[-f], desc: "Auto-fix safe issues"
+          option :auto_fix_with_agent, type: :boolean, desc: "Auto-fix then launch agent for remaining"
+          option :model, type: :string, desc: "Provider:model for agent session"
+          option :errors_only, type: :boolean, desc: "Show only errors, not warnings"
+          option :no_color, type: :boolean, desc: "Disable colored output"
+          option :json, type: :boolean, desc: "Output in JSON format"
+          option :dry_run, type: :boolean, aliases: %w[-n], desc: "Preview fixes without applying"
+          option :check, type: :string, desc: "Run specific check (frontmatter, structure, scope)"
+
+          def call(**options)
+            execute_doctor(options)
+          end
+
+          private
+
+          def execute_doctor(options)
+            config = Molecules::TaskConfigLoader.load
+            root_dir = Molecules::TaskConfigLoader.root_dir(config)
+
+            unless Dir.exist?(root_dir)
+              puts "Error: Tasks directory not found: #{root_dir}"
+              raise Ace::Support::Cli::Error.new("Tasks directory not found")
+            end
+
+            # Normalize options
+            format = options[:json] ? :json : :terminal
+            fix = options[:auto_fix] || options[:auto_fix_with_agent]
+            colors = !options[:no_color]
+            colors = false if format == :json
+
+            doctor_opts = {}
+            doctor_opts[:check] = options[:check] if options[:check]
+
+            if options[:quiet]
+              results = run_diagnosis(root_dir, doctor_opts)
+              raise Ace::Support::Cli::Error.new("Health check failed") unless results[:valid]
+              return
+            end
+
+            results = run_diagnosis(root_dir, doctor_opts)
+
+            # Filter errors-only
+            if options[:errors_only] && results[:issues]
+              results[:issues] = results[:issues].select { |i| i[:type] == :error }
+            end
+
+            output = Molecules::TaskDoctorReporter.format_results(
+              results,
+              format: format,
+              verbose: options[:verbose],
+              colors: colors
+            )
+            puts output
+
+            if fix && results[:issues]&.any?
+              handle_auto_fix(results, root_dir, doctor_opts, options, colors)
+            end
+
+            if options[:auto_fix_with_agent]
+              handle_agent_fix(root_dir, doctor_opts, options, config)
+            end
+
+            raise Ace::Support::Cli::Error.new("Health check failed") unless results[:valid]
+          rescue Ace::Support::Cli::Error
+            raise
+          rescue => e
+            raise Ace::Support::Cli::Error.new(e.message)
+          end
+
+          def run_diagnosis(root_dir, doctor_opts)
+            doctor = Organisms::TaskDoctor.new(root_dir, doctor_opts)
+            doctor.run_diagnosis
+          end
+
+          def handle_auto_fix(results, root_dir, doctor_opts, options, colors)
+            doctor = Organisms::TaskDoctor.new(root_dir, doctor_opts)
+            fixable_issues = results[:issues].select { |issue| doctor.auto_fixable?(issue) }
+
+            if fixable_issues.empty?
+              puts "\nNo auto-fixable issues found"
+              return
+            end
+
+            unless options[:quiet] || options[:dry_run]
+              puts "\nFound #{fixable_issues.size} auto-fixable issues"
+              print "Apply fixes? (y/N): "
+              response = $stdin.gets.chomp.downcase
+              return unless response == "y" || response == "yes"
+            end
+
+            fixer = Molecules::TaskDoctorFixer.new(dry_run: options[:dry_run], root_dir: root_dir)
+            fix_results = fixer.fix_issues(fixable_issues)
+
+            output = Molecules::TaskDoctorReporter.format_fix_results(
+              fix_results,
+              colors: colors
+            )
+            puts output
+
+            unless options[:dry_run]
+              puts "\nRe-running health check after fixes..."
+              new_results = run_diagnosis(root_dir, doctor_opts)
+
+              output = Molecules::TaskDoctorReporter.format_results(
+                new_results,
+                format: :summary,
+                verbose: false,
+                colors: colors
+              )
+              puts output
+            end
+          end
+
+          def handle_agent_fix(root_dir, doctor_opts, options, config)
+            require "ace/llm"
+            results = run_diagnosis(root_dir, doctor_opts)
+            remaining = results[:issues]&.reject { |i| i[:type] == :info }
+
+            if remaining.nil? || remaining.empty?
+              puts "\nNo remaining issues for agent to fix."
+              return
+            end
+
+            issue_list = remaining.map { |i|
+              prefix = (i[:type] == :error) ? "ERROR" : "WARNING"
+              "- [#{prefix}] #{i[:message]}#{" (#{i[:location]})" if i[:location]}"
+            }.join("\n")
+
+            provider_model = options[:model] || config.dig("task", "doctor_agent_model") || "gemini:flash-latest@yolo"
+
+            prompt = <<~PROMPT
+              The following #{remaining.size} task issues could NOT be auto-fixed and need manual intervention:
+
+              #{issue_list}
+
+              ---
+
+              Fix each issue listed above in the .ace-tasks/ directory.
+
+              IMPORTANT RULES:
+              - For invalid ID format issues, inspect the folder name and fix the frontmatter ID to match
+              - For YAML syntax errors, read the file and fix the YAML
+              - For missing opening delimiter, add '---' at the start of the file
+              - Do NOT delete content files — prefer fixing in place
+              - For folder naming issues, rename the folder to match {id}-{slug} convention
+
+              ---
+
+              Run `ace-task doctor --verbose` to verify all issues are fixed.
+            PROMPT
+
+            puts "\nLaunching agent to fix #{remaining.size} remaining issues..."
+            query_options = {
+              system: nil,
+              timeout: 600,
+              fallback: false
+            }
+
+            response = Ace::LLM::QueryInterface.query(provider_model, prompt, **query_options)
+
+            puts response[:text]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/task/cli/commands/list.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+
+module Ace
+  module Task
+    module CLI
+      module Commands
+        # ace-support-cli Command class for ace-task list
+        class List < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          C = Ace::Support::Items::Atoms::AnsiColors
+          desc "List tasks\n\n" \
+            "Lists all tasks with optional filtering by status, tags, or folder.\n\n" \
+            "Status legend:\n" \
+            "  #{C::CYAN}◇ draft#{C::RESET}    #{C::RESET}○ pending    #{C::YELLOW}▶ in-progress#{C::RESET}    #{C::GREEN}✓ done#{C::RESET}\n" \
+            "  #{C::RED}✗ blocked#{C::RESET}    #{C::DIM}– skipped  — cancelled#{C::RESET}\n\n" \
+            "Priority: #{C::RED}▲ critical#{C::RESET}  ▲ high  #{C::DIM}▼ low#{C::RESET}    Subtasks: ›N"
+          remove_const(:C)
+
+          example [
+            "                           # Active tasks (root only, default)",
+            "--in all                   # All tasks including archived/maybe",
+            "--in maybe                 # Tasks in _maybe/",
+            "--status pending           # Filter by status",
+            "--tags ux,design           # Tasks matching any tag",
+            "--in next --status pending # Combined filters",
+            "--filter status:pending --filter tags:ux|design  # Generic filters",
+            "--sort id                   # Sort by ID (chronological)",
+            "--sort priority             # Sort by priority level"
+          ]
+
+          option :status, type: :string, aliases: %w[-s], desc: "Filter by status (pending, in-progress, done, blocked)"
+          option :tags, type: :string, aliases: %w[-T], desc: "Filter by tags (comma-separated, any match)"
+          option :in, type: :string, aliases: %w[-i], desc: "Filter by folder (next=root only [default], all=everything, maybe, archive)"
+          option :root, type: :string, aliases: %w[-r], desc: "Override root path (subpath within tasks root)"
+          option :filter, type: :array, aliases: %w[-f], desc: "Filter by key:value (repeatable, supports key:a|b and key:!value)"
+          option :sort, type: :string, aliases: %w[-S], desc: "Sort order: smart (default), id, priority, created"
+
+          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+          option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
+          option :debug, type: :boolean, aliases: %w[-d], desc: "Show debug output"
+
+          def call(**options)
+            status = options[:status]
+            in_folder = options[:in]
+            root = options[:root]
+            tags_str = options[:tags]
+            tags = tags_str ? tags_str.split(",").map(&:strip).reject(&:empty?) : []
+            filters = options[:filter]
+            sort = options[:sort] || "smart"
+
+            manager = if root
+              Ace::Task::Organisms::TaskManager.new(root_dir: File.expand_path(root))
+            else
+              Ace::Task::Organisms::TaskManager.new
+            end
+
+            list_opts = {status: status, tags: tags, filters: filters, sort: sort}
+            list_opts[:in_folder] = in_folder if in_folder
+            tasks = manager.list(**list_opts)
+
+            puts Ace::Task::Molecules::TaskDisplayFormatter.format_list(
+              tasks, total_count: manager.last_list_total,
+              global_folder_stats: manager.last_folder_counts
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/task/cli/commands/plan.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require_relative "../../molecules/task_plan_cache"
+require_relative "../../molecules/task_plan_generator"
+require_relative "../../molecules/task_config_loader"
+require_relative "../../organisms/task_manager"
+
+module Ace
+  module Task
+    module CLI
+      module Commands
+        # ace-support-cli Command class for ace-task plan
+        class Plan < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc <<~DESC.strip
+            Resolve or generate a task implementation plan
+
+            Reuses fresh cached plans when available, otherwise regenerates.
+          DESC
+
+          example [
+            "q7w                          # Reuse fresh plan or generate new",
+            "q7w --refresh                # Force regeneration",
+            "q7w --content                # Print full plan content",
+            "q7w --model gemini:flash-latest  # Override planning model"
+          ]
+
+          argument :ref, required: true, desc: "Task reference (full ID, short ref, or suffix)"
+
+          option :refresh, type: :boolean, desc: "Force plan regeneration"
+          option :content, type: :boolean, desc: "Print full plan content instead of path"
+          option :model, type: :string, desc: "Provider:model override for plan generation"
+
+          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+          option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
+          option :debug, type: :boolean, aliases: %w[-d], desc: "Show debug output"
+
+          class << self
+            attr_accessor :generator_class
+          end
+
+          def call(ref:, **options)
+            task = resolve_task(ref)
+            cache = Molecules::TaskPlanCache.new(task_id: task.id)
+            config = Molecules::TaskConfigLoader.load
+
+            plan_path = cache.resolve_latest_plan
+            refresh = options[:refresh]
+
+            unless refresh
+              if plan_path && cache.fresh?(plan_path, task_file: task.file_path)
+                output_plan(plan_path, options)
+                return
+              end
+            end
+
+            context_files = capture_context_files(task)
+            model = options[:model] || default_model(config)
+            generator = plan_generator(model)
+            content = generator.generate(
+              task: task,
+              context_files: context_files,
+              cache_dir: cache.cache_dir
+            )
+            plan_path = cache.write_plan(
+              content: content,
+              model: model,
+              task_file: task.file_path,
+              context_files: context_files,
+              prompt_files: generator.prompt_paths
+            )
+
+            output_plan(plan_path, options)
+          end
+
+          private
+
+          def resolve_task(ref)
+            manager = Organisms::TaskManager.new
+            task = manager.show(ref)
+            return task if task
+
+            raise Ace::Support::Cli::Error.new("Task '#{ref}' not found. Run `ace-task list` to discover valid refs.")
+          end
+
+          def capture_context_files(task)
+            files = Array(task.metadata.dig("bundle", "files"))
+            expanded = files.map { |path| File.expand_path(path, Dir.pwd) }.uniq
+            resolved = expanded.select { |path| File.file?(path) }
+
+            missing = expanded - resolved
+            missing.each { |path| warn "Warning: context file not found: #{path}" } if missing.any?
+
+            resolved
+          end
+
+          def output_plan(plan_path, options)
+            if options[:content]
+              puts File.read(plan_path)
+            else
+              puts plan_path
+            end
+          end
+
+          def plan_generator(model, cli_args: nil)
+            klass = self.class.generator_class || Molecules::TaskPlanGenerator
+            klass.new(model: model, cli_args: cli_args)
+          end
+
+          def default_model(config)
+            config.dig("task", "plan", "model") || "gemini:flash-latest"
+          end
+        end
+      end
+    end
+  end
+end