maf 0.1.0 → 0.3.0

data/lib/maf/flow/models.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "open3"
-
 module Maf
   module Flow
     # Models finds the installed harnesses and the models that each one offers.
@@ -9,52 +7,30 @@ module Maf
     # harness does not know: a typo makes every dispatched run fail.
     # A list is nil when maf cannot read it. Then every name counts as known.
     module Models
-      # Claude Code has no command that lists models. The aliases follow the
-      # newest model of each family. A full ID is claude-<family>-<version>.
-      CLAUDE = %w[claude-opus-5-5 claude-sonnet-5-5 claude-haiku-5-5 claude-fable-5-1 opus sonnet haiku fable].freeze
-      CLAUDE_NAME = /\A(?:(?:opus|sonnet|haiku|fable)(?:\[1m\])?|opusplan|default|best|
-                       (?:[\w.-]+\.)?(?:anthropic\.)?claude-(?:opus|sonnet|haiku|fable)-\d[\w.:@\[\]-]*)\z/x
-      CODEX_CACHE = File.join(Dir.home, ".codex", "models_cache.json")
-
       # Without any harness on PATH, maf shows all of them: the user may install one later.
       def self.installed
-        found = HARNESSES.select { |harness| on_path?(harness) }
-        found.empty? ? HARNESSES : found
-      end
-
-      def self.on_path?(command)
-        ENV["PATH"].to_s.split(File::PATH_SEPARATOR).any? { |dir| File.executable?(File.join(dir, command)) }
+        found = Harness.all.select(&:installed?).map(&:name)
+        found.empty? ? Harness.names : found
       end
 
+      # A harness can read its list from a CLI, so each list is read once.
       def self.for(harness)
         @lists ||= {}
-        return @lists[harness] if @lists.key?(harness)
-
-        @lists[harness] = { "claude" => -> { CLAUDE }, "codex" => -> { codex }, "opencode" => -> { opencode } }
-                          .fetch(harness, -> {}).call
+        @lists.key?(harness) ? @lists[harness] : @lists[harness] = Harness[harness]&.models
       end
 
-      def self.known?(harness, model)
-        return model.match?(CLAUDE_NAME) if harness == "claude"
-
-        self.for(harness).nil? || self.for(harness).include?(model)
-      end
-
-      # Codex keeps the model list of the account in a cache file. Hidden models are internal.
-      def self.codex
-        models = JSON.parse(File.read(CODEX_CACHE)).fetch("models")
-        models.select { |m| m["visibility"] == "list" }.map { |m| m["slug"] }
-      rescue SystemCallError, JSON::ParserError, KeyError, NoMethodError
-        nil
-      end
+      def self.known?(harness, model) = Harness[harness]&.known_model?(model, self.for(harness)) != false
+      def self.default(harness) = Harness[harness]&.default_model
+      # Without a model, the levels of the default model of the harness.
+      def self.efforts(harness, model) = Harness[harness]&.efforts(model || default(harness))
 
-      def self.opencode
-        return nil unless on_path?("opencode")
+      # The level of the role if the harness lists it. A model that runs only
+      # with a level gets the lowest level instead.
+      def self.default_effort(harness, level, model)
+        levels = efforts(harness, model).to_a
+        return level if levels.include?(level)
 
-        out, status = Open3.capture2("opencode", "models", err: File::NULL)
-        status.success? && !out.strip.empty? ? out.split : nil
-      rescue SystemCallError
-        nil
+        levels.first if Harness[harness]&.effort_required?(model)
       end
     end
   end

data/lib/maf/flow/options.rb

@@ -4,8 +4,8 @@ module Maf
   module Flow
     # Options parses the command line and holds the settings of one run.
     class Options
-      attr_accessor :project, :agents
-      attr_reader :removed, :models, :hermes_dir, :list_roles
+      attr_accessor :project, :agents, :role_efforts
+      attr_reader :removed, :models, :efforts, :hermes_dir, :list_roles
 
       # Each flag: the OptionParser arguments, and a block that runs in the
       # Options instance with the flag value.
@@ -14,6 +14,7 @@ module Maf
         [["--agent SPEC", "HARNESS:ROLE[:MODEL]"], ->(v) { @agents << parse_agent(v) }],
         [["--remove SPEC", "HARNESS:ROLE"], ->(v) { @removed << parse_agent(v) }],
         [["--model PAIR", "ROLE=MODEL"], ->(v) { @models.store(*v.split("=", 2)) }],
+        [["--effort PAIR", "ROLE=LEVEL"], ->(v) { @efforts.store(*v.split("=", 2)) }],
         [["--hermes-dir DIR"], ->(v) { @hermes_dir = File.expand_path(v) }],
         [["--check"], ->(_) { @check = true }],
         [["--force"], ->(_) { @force = true }],
@@ -22,8 +23,8 @@ module Maf
       ].freeze
 
       def initialize(argv)
-        @argv, @agents, @removed, @models = argv, [], [], {}
-        @hermes_dir = DEFAULT_HERMES_DIR
+        @argv, @agents, @removed, @models, @efforts = argv, [], [], {}, {}
+        @role_efforts = {}
         @check = @force = @list_roles = false
         @bootstrap = true
       end
@@ -32,6 +33,9 @@ module Maf
       def force? = @force
       def bootstrap? = @bootstrap
 
+      # The settings that a harness reads for its role file folder.
+      def settings = { "hermes_dir" => @hermes_dir }.compact
+
       def parse
         parser.parse!(@argv)
         self
@@ -43,11 +47,35 @@ module Maf
       end
 
       def model_for(agent)
-        agent[:model] || @models[agent[:role]] || agent[:saved_model] || DEFAULT_MODELS[agent[:harness]]
+        agent[:model] || @models[agent[:role]] || agent[:saved_model] || Harness[agent[:harness]]&.default_model
+      end
+
+      # An empty --effort ROLE= clears the level: the harness default applies.
+      # A saved level belongs to the saved model, so a new model gets the role default.
+      def effort_for(agent)
+        flag = effort_flag(agent)
+        return (flag unless flag.empty?) if flag
+
+        (agent[:saved_effort] unless model_changed?(agent)) ||
+          Models.default_effort(agent[:harness], @role_efforts[agent[:role]], model_for(agent))
       end
 
       private
 
+      # --effort ROLE=LEVEL applies to the agents of this run. Without one of
+      # the role, it applies to the saved agents of the role.
+      def effort_flag(agent)
+        role = agent[:role]
+        @efforts[role] if run_agent?(agent) || @agents.none? { |a| a[:role] == role && run_agent?(a) }
+      end
+
+      def run_agent?(agent) = agent.key?(:model)
+
+      def model_changed?(agent)
+        chosen = agent[:model] || @models[agent[:role]]
+        chosen && chosen != agent[:saved_model]
+      end
+
       def parser
         OptionParser.new do |o|
           o.banner = "Usage: maf add|remove|update [HARNESS:ROLE ...] [options]"

data/lib/maf/flow/prompt_builder.rb

@@ -26,26 +26,19 @@ module Maf
         "#{intro(data)}\n\n#{duties_block(data)}\n\n#{loop_text}"
       end
 
-      # Claude Code wakes an idle session with the board-watch hook, and opencode
-      # with the board-watch plugin. So these agents stop instead of waiting:
-      # each return of a wait costs one model call over the whole context.
-      # Codex waits in its stop hook after `coord await`. Hermes cannot be
-      # woken, so it blocks in `coord next --wait`.
-      # The dispatcher adds the report block rule to each dispatched prompt.
-      def no_task_line(harness)
-        return NO_TASK_AWAIT if harness == "codex"
-
-        WAKE_HARNESSES.include?(harness) ? NO_TASK_STOP : NO_TASK_WAIT
-      end
+      # A harness that wakes an idle session lets the agent stop instead of
+      # waiting: each return of a wait costs one model call over the whole
+      # context. The dispatcher adds the report block rule to each dispatched prompt.
+      def no_task_line(harness) = NO_TASK.fetch(harness.wait)
 
       def architect_prompt(harness, data)
         loop_text = project_manager? ? ARCHITECT_LOOP_PM : ARCHITECT_LOOP_DIRECT
         "#{intro(data)} You do not implement code yourself.\n\n#{duties_block(data)}\n\n" \
-          "#{format(loop_text, roles: dispatch_roles_text)}#{claude_rule(harness)}#{workflow_block}"
+          "#{format(loop_text, roles: dispatch_roles_text)}#{harness_rule(harness)}#{workflow_block}"
       end
 
       # The loop text ends with a newline, so the rule lands as the last rule line.
-      def claude_rule(harness) = harness == "claude" ? "#{CLAUDE_ARCHITECT_RULE}\n" : ""
+      def harness_rule(harness) = harness.architect_rule ? "#{harness.architect_rule}\n" : ""
 
       # The workflow goes into the orchestrator prompt only. Workers stay workflow-blind.
       def workflow_block = @workflow ? "\n\n#{@workflow}" : ""
@@ -56,7 +49,7 @@ module Maf
 
       def project_manager_prompt(harness, data)
         "#{intro(data)} You do not plan tasks or implement code yourself.\n\n" \
-          "#{duties_block(data)}\n\n#{format(PM_LOOP, wait_instruction: PM_WAIT.fetch(harness, PM_WAIT_DEFAULT))}"
+          "#{duties_block(data)}\n\n#{format(PM_LOOP, wait_instruction: PM_WAIT.fetch(harness.wait))}"
       end
 
       def intro(data)

data/lib/maf/flow/prompt_text.rb

@@ -21,8 +21,7 @@ module Maf
       - Do not use subagents to verify your work.
     TEXT
 
-    # Harnesses with a watcher that wakes an idle session.
-    WAKE_HARNESSES = %w[claude opencode].freeze
+    # The no-task rule of a worker, by the wait of the harness (Harness::RoleFiles#wait).
     NO_TASK_STOP = "- If no task and no message is available, stop. The board watcher wakes you when work arrives.\n" \
                    "  Do not wait in a loop: each return of a wait costs one model call."
     NO_TASK_WAIT = <<~TEXT.strip
@@ -37,15 +36,16 @@ module Maf
         The stop hook waits for work and wakes you. Do not wait in a loop.
     TEXT
 
+    NO_TASK = { watch: NO_TASK_STOP, await: NO_TASK_AWAIT, poll: NO_TASK_WAIT }.freeze
+
     # The project manager waits for reports. Each check in a loop sends the
     # whole context again, so the wait must not call the model.
     PM_WAIT = {
-      "claude" => "End your turn to wait for reports. The board watcher wakes you when a message arrives.",
-      "opencode" => "End your turn to wait for reports. The board watcher wakes you when a message arrives.",
-      "codex" => "To wait for reports, run `coord await`. Tell the user that you wait. Then end your turn.\n" \
-                 "   The stop hook wakes you when a message arrives."
+      watch: "End your turn to wait for reports. The board watcher wakes you when a message arrives.",
+      await: "To wait for reports, run `coord await`. Tell the user that you wait. Then end your turn.\n" \
+             "   The stop hook wakes you when a message arrives.",
+      poll: "Wait for reports with `coord inbox project-manager --wait --timeout 540`."
     }.freeze
-    PM_WAIT_DEFAULT = "Wait for reports with `coord inbox project-manager --wait --timeout 540`."
 
     # Every role except the project manager reads the code graph before work.
     # A query output stays in the context for each later call, so the budget is small.
@@ -56,10 +56,6 @@ module Maf
         Put one line in the report of that task or plan: "Graph: fresh", "Graph: stale", or "Graph: missing".
     TEXT
 
-    # Only Claude Code has ScheduleWakeup. Other harnesses never see this rule.
-    CLAUDE_ARCHITECT_RULE = "- Never call ScheduleWakeup with `stop:false` and no `prompt`. " \
-                            "The call fails. Poll worker status through the task tool instead."
-
     # The coordination contract that every role shares. It lives in the role
     # prompt, not in the project's AGENTS.md: only a session that maf starts
     # needs it, and the project keeps no trace of the tool.
@@ -103,9 +99,12 @@ module Maf
       - Before you continue a claimed task after a pause, run `coord show <id>`. If the status is not pending,
         or the worker is not you, stop work on that task. `coord reap` releases the claims of stalled workers.
       - Finish the whole task. Report done only when each acceptance criterion passes.
-      - If you cannot finish, do the parts you can. Keep the claim, so another worker
-        does not hit the same blocker. Annotate the blocker and the missing parts.
-        Message the architect. Stop. Do not retry a failing approach.
+      - If you cannot finish, do the parts you can and commit them on the task branch.
+        Then block the task: `coord block <id> --kind <kind> "<blocker and missing parts>"`.
+        Kinds: needs_input (a decision of the user), dependency (other work must land first),
+        capability (a missing tool, access, or model). coord tells the role that can remove the blocker.
+        A blocked task leaves `coord next`, so no other worker hits the blocker.
+        Stop. Do not retry a failing approach.
       %{no_task_instruction}
       - Record durable knowledge in the shared vault or #{DECISIONS}.
       - Never write ad-hoc verification scripts. The test suite is the verification.

data/lib/maf/flow/report.rb

@@ -12,20 +12,21 @@ module Maf
 
       def print(results)
         puts "", "Generated role files:", results.map { |result| generated_line(result) }
-        %i[print_missing_models print_unknown_models print_unembeddable print_sessions]
-          .each { |name| send(name, results) }
+        %i[print_missing_models print_unknown_models print_unembeddable].each { |name| send(name, results) }
+        EffortReport.print(results)
+        print_sessions(results)
         print_hermes_reminder
       end
 
       private
 
-      # The hook steps print at install time, far above the last lines the user
+      # The Hermes steps print at install time, far above the last lines the user
       # reads. Repeat the state here so the flow is not started with a dead hook.
       def print_hermes_reminder
         return unless @hermes_pending
 
-        puts "The Hermes hook is not active yet. Finish the steps above.",
-             "Then run `maf update` to confirm the hook is ready."
+        puts "The Hermes setup is not done yet. Finish the steps above.",
+             "Then run `maf update` to confirm that Hermes is ready."
       end
 
       def generated_line(result)
@@ -74,16 +75,14 @@ module Maf
       def pm?(result) = result[:agent][:role] == "project-manager"
 
       def print_unembeddable(results)
-        list = results.select { |r| r[:model] && %w[codex hermes].include?(r[:agent][:harness]) }
+        list = results.select { |r| r[:model] && model_command(r) }
         return if list.empty?
 
         puts "", "These harnesses cannot embed a model in the role file. Set it in the harness:",
              list.map { |r| "  #{r[:agent][:harness]}:#{r[:agent][:role]} -> #{model_command(r)}" }
       end
 
-      def model_command(result)
-        result[:agent][:harness] == "codex" ? "codex -m #{result[:model]}" : "hermes model"
-      end
+      def model_command(result) = Harness.fetch(result[:agent][:harness]).model_hint(result[:model])
     end
   end
 end

data/lib/maf/flow/role_catalog.rb

@@ -6,7 +6,7 @@ module Maf
     # role in .maf/roles.yml adds a role or replaces a built-in role.
     class RoleCatalog
       FILE = ".maf/roles.yml"
-      DEFAULTS = { "model_hint" => "", "can_edit" => true }.freeze
+      DEFAULTS = { "model_hint" => "", "can_edit" => true, "effort" => nil }.freeze
 
       def initialize(project)
         @project = project

data/lib/maf/flow/role_files.rb

@@ -19,30 +19,15 @@ module Maf
       private
 
       def generate_agent(agent)
-        role = agent[:role]
-        model = @options.model_for(agent)
-        dest = destination(agent[:harness], role)
-        content = render(agent[:harness], role, @roles.fetch(role), model)
-        { agent: agent, dest: dest, status: write(dest, content), model: model }
+        harness = Harness.fetch(agent[:harness])
+        choice = { model: @options.model_for(agent), effort: @options.effort_for(agent) }
+        dest = harness.role_destination(@options.project, agent[:role], @options.settings)
+        content = render(harness, agent[:role], @roles.fetch(agent[:role]), choice)
+        { agent: agent, dest: dest, status: write(dest, content), **choice }
       end
 
-      # Hermes skills live in a global ~/.hermes/skills/ directory, not the
-      # project. Namespace by project so two projects using the same role
-      # don't overwrite each other's skill.
-      def destination(harness, role)
-        return hermes_path(role) if harness == "hermes"
-
-        File.join(@options.project, Flow.role_path(harness, role)) if %w[opencode claude codex].include?(harness)
-      end
-
-      def hermes_path(role)
-        File.join(@options.hermes_dir, "#{File.basename(@options.project)}-#{role}", "SKILL.md")
-      end
-
-      def render(harness, role, data, model)
-        template = File.read(File.join(TEMPLATES, "#{harness}.md.erb"))
-        values = { prompt: @prompts.build(harness, role, data), model: model }
-        ERB.new(template, trim_mode: "-").result_with_hash(**template_values(role, data), **values)
+      def render(harness, role, data, choice)
+        harness.render_role(**template_values(role, data), prompt: @prompts.build(harness, role, data), **choice)
       end
 
       def template_values(role, data)

data/lib/maf/flow/roster.rb

@@ -3,7 +3,8 @@
 module Maf
   module Flow
     # Roster merges the agents saved in .maf/config.json with the --agent and
-    # --remove specs of this run. A saved model ranks below --model.
+    # --remove specs of this run. A saved model ranks below --model, a saved
+    # effort below --effort.
     class Roster
       def initialize(project)
         path = File.join(project, ".maf/config.json")
@@ -11,7 +12,7 @@ module Maf
       end
 
       def merge(added, removed)
-        kept = saved.map { |a| added.find { |b| same?(a, b) }&.merge(saved_model: a[:saved_model]) || a }
+        kept = saved.map { |a| added.find { |b| same?(a, b) }&.merge(a.slice(:saved_model, :saved_effort)) || a }
         agents = kept + added.reject { |b| kept.any? { |a| same?(a, b) } }
         agents.reject { |a| removed.any? { |b| same?(a, b) } }
       end
@@ -19,7 +20,9 @@ module Maf
       private
 
       def saved
-        @saved.map { |a| { harness: a["harness"], role: a["role"], saved_model: a["model"] } }
+        @saved.map do |a|
+          { harness: a["harness"], role: a["role"], saved_model: a["model"], saved_effort: a["effort"] }
+        end
       end
 
       def same?(one, other) = one[:harness] == other[:harness] && one[:role] == other[:role]

data/lib/maf/flow/validator.rb

@@ -28,11 +28,11 @@ module Maf
       private
 
       def check(agent)
-        abort "flow: unknown harness '#{agent[:harness]}' (use #{HARNESSES.join(", ")})" unless known?(agent)
+        abort "flow: unknown harness '#{agent[:harness]}' (use #{Harness.names.join(", ")})" unless known?(agent)
         abort "flow: unknown role '#{agent[:role]}'" unless @roles.key?(agent[:role])
       end
 
-      def known?(agent) = HARNESSES.include?(agent[:harness])
+      def known?(agent) = Harness.known?(agent[:harness])
     end
   end
 end

data/lib/maf/flow.rb

@@ -4,10 +4,10 @@
 #
 # maf add, maf remove, maf update, and maf roles run Flow::Generator.
 # Options: --project DIR [--agent HARNESS:ROLE ...] [--remove HARNESS:ROLE ...]
-#          [--model ROLE=MODEL] [--hermes-dir DIR] [--check] [--force] [--no-bootstrap]
+#          [--model ROLE=MODEL] [--effort ROLE=LEVEL] [--hermes-dir DIR] [--check] [--force] [--no-bootstrap]
 #          [--list-roles]
 #
-# HARNESS is one of: opencode, claude, codex, hermes.
+# HARNESS is a harness of the registry: one file in lib/maf/shared/harnesses/.
 # A re-run keeps the agents in .maf/config.json. --agent adds an agent.
 # --remove drops an agent. Without --agent, a re-run regenerates the current agents.
 # Idempotent: identical files are skipped, changed files are updated, and
@@ -20,6 +20,7 @@ require "optparse"
 require "rbconfig"
 require "time"
 require_relative "shared/roles"
+require_relative "shared/harness"
 
 abort "flow: Ruby 3.0+ required (current: #{RUBY_VERSION})." if RUBY_VERSION.split(".").first.to_i < 3
 
@@ -28,32 +29,15 @@ module Maf
     ROOT = File.expand_path("../..", __dir__)
     TEMPLATES = File.join(ROOT, "templates")
     ASSETS = File.join(ROOT, "assets")
-    HARNESSES = %w[opencode claude codex hermes].freeze
-    DEFAULT_HERMES_DIR = File.join(Dir.home, ".hermes", "skills")
-
-    # Model a harness gets when neither --agent nor --model names one.
-    # Other harnesses have no safe default, so their CLI picks the model.
-    DEFAULT_MODELS = { "claude" => "claude-opus-5-5" }.freeze
+    # The registry of the harnesses. Each harness is one file in lib/maf/shared/harnesses/.
+    Harness = Maf::Shared::Harness
 
     # Roles that dispatch or coordinate instead of implementing. They are never
     # advertised as dispatch targets in the architect prompt.
     LEADS = Maf::Shared::Roles::LEADS
     DISPATCH_EXCLUDE = LEADS
 
-    READ_ONLY_TOOLSETS = Maf::Shared::Roles::READ_ONLY_TOOLSETS
-
     MAF_DIR = ".maf"
-
-    # The folder where a harness looks for role files. It is a symlink into
-    # .maf/agents/<harness>/, where the flow keeps the role files.
-    HARNESS_DIRS = { "opencode" => ".opencode/agents", "claude" => ".claude/agents",
-                     "codex" => ".codex/prompts" }.freeze
-
-    # The role file path inside the project. Hermes keeps role files outside
-    # the project, so it has no path here.
-    def self.role_path(harness, role)
-      HARNESS_DIRS.key?(harness) ? File.join(MAF_DIR, "agents", harness, "#{role}.md") : nil
-    end
   end
 end
 
@@ -68,6 +52,7 @@ require_relative "flow/options"
 require_relative "flow/prompt_builder"
 require_relative "flow/hook_files"
 require_relative "flow/hermes_hook_setup"
+require_relative "flow/hermes_env_setup"
 require_relative "flow/codex_hooks"
 require_relative "flow/legacy_codex_hook"
 require_relative "flow/hook_installer"
@@ -77,6 +62,7 @@ require_relative "flow/mcp_installer"
 require_relative "flow/role_files"
 require_relative "flow/manifest"
 require_relative "flow/models"
+require_relative "flow/effort_report"
 require_relative "flow/report"
 require_relative "flow/validator"
 require_relative "flow/harness_linker"

data/lib/maf/menu.rb

@@ -21,14 +21,14 @@ module Maf
       end
     end
 
-    # Only the installed harnesses are choices. Each role gets its own model.
+    # Only the installed harnesses are choices. Each role gets its own model and effort.
     def add
       harness = @prompt.choose("Harness", Flow::Models.installed) or return
       roles = @prompt.choose_many("Roles", Maf.role_names)
       return if roles.empty?
 
       models = show_models(harness)
-      Maf.flow(*roles.flat_map { |role| ["--agent", agent_spec(harness, role, models)] })
+      Maf.flow(*roles.flat_map { |role| agent_args(harness, role, models) })
     end
 
     private
@@ -56,32 +56,66 @@ module Maf
       @prompt.say("error: #{e.message}")
     end
 
-    def agent_spec(harness, role, models)
+    def agent_args(harness, role, models)
       model = ask_model(harness, role, models).to_s
-      [harness, role, model].reject(&:empty?).join(":")
+      effort = ask_effort(harness, role, model.empty? ? nil : model).to_s
+      flags = effort.empty? ? [] : ["--effort", "#{role}=#{effort}"]
+      ["--agent", [harness, role, model].reject(&:empty?).join(":"), *flags]
     end
 
-    # The answer is a number of the list, a model name, or Enter for the default.
-    # A name that the harness does not list needs a confirmation: a typo makes
-    # every dispatched run fail.
+    # A model name that the harness does not list needs a confirmation: a typo
+    # makes every dispatched run fail.
     def ask_model(harness, role, models)
-      answer = @prompt.ask("Model for #{role} (number or name, Enter = #{default_label(harness)}):").to_s
-      number = Integer(answer, exception: false)
-      return models[number - 1] if number&.between?(1, models.size)
-      return answer if answer.empty? || Flow::Models.known?(harness, answer)
-
-      @prompt.confirm?("#{harness} does not list #{answer}. Use it anyway?") ? answer : ask_model(harness, role, models)
+      question = "Model for #{role} (number or name, Enter = #{default_label(harness)}):"
+      ask_listed(harness, question, models) { |name| Flow::Models.known?(harness, name) }
     end
 
-    def default_label(harness) = Flow::DEFAULT_MODELS.fetch(harness, "the harness default")
+    def default_label(harness) = Flow::Models.default(harness) || "the harness default"
 
     def show_models(harness)
       models = Flow::Models.for(harness).to_a
       @prompt.say(models.empty? ? "#{harness} lists no models. Type a name." : "Models of #{harness}:")
-      models.each_with_index { |model, i| @prompt.say("  #{i + 1}) #{model}") }
+      models.each_with_index { |model, i| @prompt.say("  #{i + 1}) #{model}#{levels_label(harness, model)}") }
       models
     end
 
+    def levels_label(harness, model)
+      levels = Flow::Models.efforts(harness, model).to_a
+      levels.empty? ? "" : "  (effort: #{levels.join(", ")})"
+    end
+
+    # An empty list: the model takes no level, so maf does not ask.
+    # nil: the harness lists no levels, so every level counts as known.
+    def ask_effort(harness, role, model)
+      levels = Flow::Models.efforts(harness, model)
+      return if levels == []
+
+      levels.to_a.each_with_index { |level, i| @prompt.say("  #{i + 1}) #{level}") }
+      question = "Effort for #{role} (number or name, Enter = #{effort_label(harness, role, model)}):"
+      ask_listed(harness, question, levels.to_a) { |name| levels.nil? || levels.include?(name) }
+    end
+
+    def effort_label(harness, role, model)
+      Flow::Models.default_effort(harness, Maf.role_effort(role), model) || "the harness default"
+    end
+
+    # The answer is a number of the list, a name, or Enter for the default.
+    def ask_listed(harness, question, list, &known)
+      answer = @prompt.ask(question).to_s
+      picked = pick(answer, list, &known)
+      return picked if picked
+      return answer if @prompt.confirm?("#{harness} does not list #{answer}. Use it anyway?")
+
+      ask_listed(harness, question, list, &known)
+    end
+
+    def pick(answer, list)
+      number = Integer(answer, exception: false)
+      return list[number - 1] if number&.between?(1, list.size)
+
+      answer if answer.empty? || yield(answer)
+    end
+
     def remove
       spec = @prompt.choose("Agent", Maf.agent_specs) or return
       Maf.flow("--remove", spec) if @prompt.confirm?("Remove #{spec}?")

data/lib/maf/migrate/role_files.rb

@@ -11,7 +11,9 @@ module Maf
       end
 
       def steps
-        Flow::HARNESS_DIRS.flat_map { |harness, dir| files(dir).map { |file| step(harness, dir, file) } }
+        Maf::Shared::Harness.all.select(&:role_dir).flat_map do |harness|
+          files(harness.role_dir).map { |file| step(harness.name, harness.role_dir, file) }
+        end
       end
 
       private