maf 0.2.0 → 0.4.0

data/lib/maf/flow/prompt_text.rb

@@ -99,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.
@@ -209,13 +212,16 @@ module Maf
     # run the team. Dispatched workers cost no tokens while idle, so the rules
     # scale on backlog, not on cost.
     TEAM_RULES = <<~TEXT.strip
-      - If the user gives you a team budget, record it: `maf team set --max <n> --allow <harness[:model]> ...`.
-        Then manage the team yourself in dispatch mode. `maf prepare ... --dispatch` starts the worker in the background.
+      - Only the user sets the team budget: `maf team set --max <n> --allow <harness[:model]> ...`.
+        If the user gives you a budget in words, give the user that command.
+        With a budget, manage the team yourself in dispatch mode. `maf prepare ... --dispatch` starts the worker in the background.
+        In the macOS sandbox, maf cannot start it. Give the user the two commands that it prints.
       - Check the team with `maf team`. It shows the budget, each worker, and the tasks by role.
       - Staff the architect first, with `--dispatch`. A goal needs the architect before any other worker.
         A dispatched architect starts on each message. An idle interactive architect reads nothing.
       - Check who runs with `coord who`. A role without a live worker does not read its messages.
-      - If coord reports "No worker runs role <role>", add a worker for that role.
+      - If coord reports "No worker runs role <role>", add a worker for that role if the budget has a free slot.
+        Without a budget, tell the user.
       - If a role has more than three backlog tasks and the budget has a free slot, add a worker for that role.
       - If a role has no tasks and no open goal needs it, retire its extra workers.
         Keep one worker per role that an open goal needs.
@@ -239,7 +245,8 @@ module Maf
 
       Rules:
       - Never edit source files. Never create tasks; only the architect creates tasks.
-      - Change the team when the user asks. Do not ask the user to run setup steps.
+      - Change the team only when the user asks, or within the team budget. Without a budget, `maf prepare` refuses.
+        Then give the user the command, or ask the user for a budget.
         Add a worker: `maf prepare <harness> <role>_<n>`.
         Replace a worker: `maf prepare <harness> <role>_<n> --replace <old-role>_<n>`.
         Remove a worker: `maf retire <role>_<n>`.

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)

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

@@ -20,14 +20,14 @@ module Maf
 
       def generate_agent(agent)
         harness = Harness.fetch(agent[:harness])
-        model = @options.model_for(agent)
+        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]), model)
-        { agent: agent, dest: dest, status: write(dest, content), model: model }
+        content = render(harness, agent[:role], @roles.fetch(agent[:role]), choice)
+        { agent: agent, dest: dest, status: write(dest, content), **choice }
       end
 
-      def render(harness, role, data, model)
-        harness.render_role(**template_values(role, data), prompt: @prompts.build(harness, role, data), model: model)
+      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.rb

@@ -4,7 +4,7 @@
 #
 # 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 a harness of the registry: one file in lib/maf/shared/harnesses/.
@@ -52,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"
@@ -61,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,21 +56,18 @@ 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::Models.default(harness) || "the harness default"
@@ -78,10 +75,47 @@ module Maf
     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/restore.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# restore.rb - maf restore: put the flow config back from a backup.
+require "fileutils"
+require_relative "backup"
+
+module Maf
+  # Restore copies the files of a backup into .maf/. It keeps a file that
+  # exists, unless --force is given. Then it runs maf update.
+  class Restore
+    USAGE = "usage: maf restore [--list] [BACKUP] [--force]"
+
+    def initialize(root, argv)
+      @root = root
+      @backup = Backup.new(root)
+      @list = argv.include?("--list")
+      @force = argv.include?("--force")
+      @name = argv.find { |arg| !arg.start_with?("-") }
+    end
+
+    def run
+      return list if @list
+
+      dir = @name ? @backup.find(@name) : @backup.latest
+      abort(@name ? "maf: no backup #{@name}. Run: maf restore --list" : "maf: no backup in #{@root}") unless dir
+      restore(dir)
+    end
+
+    private
+
+    def list
+      return puts("No backup yet. maf makes one when a maf command runs.") if @backup.snapshots.empty?
+
+      @backup.snapshots.reverse_each { |dir| puts line(dir) }
+    end
+
+    def line(dir)
+      files = @backup.read(dir)
+      agents = JSON.parse(files.fetch("config.json", "{}")).fetch("agents", []).size
+      "#{File.basename(dir)}  #{@backup.time(dir)}  #{agents} agents  #{files.keys.join(", ")}"
+    rescue JSON::ParserError
+      "#{File.basename(dir)}  #{@backup.time(dir)}  #{files.keys.join(", ")}"
+    end
+
+    def restore(dir)
+      puts "Backup #{File.basename(dir)} (#{@backup.time(dir)}):"
+      written = @backup.read(dir).select { |name, text| put(name, text) }
+      return puts("Nothing to restore. --force replaces the files that exist.") if written.empty?
+
+      Dir.chdir(@root) { Maf.flow } if written.key?("config.json")
+    end
+
+    def put(name, text)
+      path = File.join(@root, ".maf", name)
+      return puts("  keep     .maf/#{name} (exists; --force replaces it)") || false if File.exist?(path) && !@force
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, text)
+      puts("  restore  .maf/#{name}") || true
+    end
+  end
+end

data/lib/maf/setup_agent/args.rb

@@ -3,18 +3,23 @@
 module Maf
   module SetupAgent
     # Args reads the positional arguments (HARNESS ROLE[_WORKER] [model:M]),
-    # then the flags. --dispatch and --model M are setup_agent's own flags; all
-    # other flags go to the dispatcher and need --dispatch.
+    # then the flags. --dispatch, --model M, and --effort L are setup_agent's own
+    # flags; all other flags go to the dispatcher and need --dispatch.
     class Args
-      Parsed = Struct.new(:harness, :role, :worker_id, :worker, :model, :dispatch, :detach, :dispatcher_args,
-                          keyword_init: true)
+      Parsed = Struct.new(:harness, :role, :worker_id, :worker, :model, :effort, :dispatch, :detach,
+                          :dispatcher_args, keyword_init: true)
 
       def self.parse(argv)
         dispatch, detach, positional, flags = split(argv)
-        model = take_model(flags)
+        model, effort = %w[--model --effort].map { |flag| take_value(flags, flag) }
+        check_flags(flags, dispatch, detach)
+        Parsed.new(**identity(positional, model, dispatch), effort: effort, dispatch: dispatch, detach: detach,
+                                                            dispatcher_args: flags)
+      end
+
+      def self.check_flags(flags, dispatch, detach)
         reject_stray(flags, dispatch)
         abort "setup_agent: --detach works only with --dispatch" if detach && !dispatch
-        Parsed.new(**identity(positional, model, dispatch), dispatch: dispatch, detach: detach, dispatcher_args: flags)
       end
 
       def self.split(argv)
@@ -31,10 +36,10 @@ module Maf
           model: model || model_arg&.sub(/\Amodel:/, "") }
       end
 
-      def self.take_model(flags)
-        index = flags.index("--model")
+      def self.take_value(flags, flag)
+        index = flags.index(flag)
         value = index && flags.slice!(index, 2)[1]
-        abort "setup_agent: --model needs a value" if index && (value.nil? || value.start_with?("--"))
+        abort "setup_agent: #{flag} needs a value" if index && (value.nil? || value.start_with?("--"))
         value
       end
 
@@ -50,7 +55,8 @@ module Maf
       end
 
       def self.abort_usage
-        abort "usage: maf start HARNESS ROLE[_WORKER] [model:MODEL] [--model MODEL] [--dispatch [FLAGS...]]"
+        abort "usage: maf start HARNESS ROLE[_WORKER] [model:MODEL] [--model MODEL] [--effort LEVEL] " \
+              "[--dispatch [FLAGS...]]"
       end
     end
   end

data/lib/maf/setup_agent/dispatch.rb

@@ -9,11 +9,11 @@ module Maf
     module Dispatch
       DISPATCHER = ".maf/bin/dispatcher"
 
-      def self.launch(args, model)
+      def self.launch(args)
         dispatcher = File.join(Project.root, DISPATCHER)
         require_dispatcher!(dispatcher)
         cmd = [RbConfig.ruby, dispatcher, args.role, "--harness", args.harness]
-        cmd += ["--model", model] if model
+        cmd += { "--model" => args.model, "--effort" => args.effort }.compact.flatten
         cmd += args.dispatcher_args
         args.detach ? detach(cmd, args.worker) : Launcher.exec_or_die(cmd)
       end

data/lib/maf/setup_agent/launcher.rb

@@ -8,15 +8,17 @@ module Maf
     # Launcher replaces this process with the interactive session of a harness.
     # The harness file builds the command (Maf::Shared::Harnesses).
     module Launcher
-      def self.launch(harness, role, model)
+      def self.launch(harness, role, model, effort = nil)
         ENV.update(harness.launch_env)
-        return exec_or_die(harness.launch(role, model)) if Maf::Shared::Sandbox.mode == "off"
+        return exec_or_die(harness.launch(role, model, effort)) if Maf::Shared::Sandbox.mode == "off"
 
         warn "maf: sandbox: #{Maf::Shared::Sandbox.describe(harness)}"
-        exit Maf::Shared::Sandbox.keeping_links(harness) { relay_or_die(sandboxed(harness, role, model)) }
+        exit Maf::Shared::Sandbox.keeping_links(harness) { relay_or_die(sandboxed(harness, role, model, effort)) }
       end
 
-      def self.sandboxed(harness, role, model) = Maf::Shared::Sandbox.wrap(harness.launch(role, model), harness)
+      def self.sandboxed(harness, role, model, effort)
+        Maf::Shared::Sandbox.wrap(harness.launch(role, model, effort), harness)
+      end
 
       def self.exec_or_die(cmd)
         Kernel.exec(*cmd)

data/lib/maf/setup_agent/manifest.rb

@@ -26,10 +26,16 @@ module Maf
       # maf add keeps the current agents, so the hint names only the missing agent.
       def add_hint(missing) = "  Fix: maf add #{missing}"
 
-      def model_for(harness, role)
-        entry = @agents.find { |a| a["harness"] == harness && a["role"] == role }
-        entry && entry["model"]
+      # The saved model and effort of the agent, unless args already name them.
+      def fill(args)
+        verify!(args.harness, args.role)
+        saved = entry(args.harness, args.role)
+        args.model ||= saved["model"]
+        args.effort ||= saved["effort"]
+        args
       end
+
+      def entry(harness, role) = @agents.find { |a| a["harness"] == harness && a["role"] == role }
     end
   end
 end

data/lib/maf/setup_agent.rb

@@ -2,10 +2,11 @@
 
 # setup_agent.rb - create a worktree for one agent and launch its harness session.
 #
-# Usage: maf start HARNESS ROLE[_WORKER] [model:MODEL] [--model MODEL]
+# Usage: maf start HARNESS ROLE[_WORKER] [model:MODEL] [--model MODEL] [--effort LEVEL]
 #                  [--dispatch [DISPATCHER FLAGS...]]
 #   maf start claude backend-developer_1
 #   maf start opencode reviewer --model openrouter/deepseek-v3
+#   maf start claude architect --effort high
 #   maf start hermes tester --dispatch --model openrouter/deepseek-v3
 #   maf start claude reviewer --dispatch --cache-window 1500
 #
@@ -36,11 +37,10 @@ module Maf
     MANIFEST = ".maf/config.json"
 
     def self.run(argv)
-      args = Args.parse(argv)
-      manifest = Manifest.load(MANIFEST).tap { |m| m.verify!(args.harness, args.role) }
+      args = Manifest.load(MANIFEST).fill(Args.parse(argv))
       worktree = enter_worktree(args)
-      register(args, manifest.model_for(args.harness, args.role))
-      launch(args, manifest, worktree)
+      register(args)
+      launch(args, worktree)
     end
 
     # `maf start` without arguments, inside a worktree that `maf prepare` made.
@@ -56,12 +56,13 @@ module Maf
     def self.start_args(entry)
       args = [entry["harness"], "#{entry["role"]}_#{entry["worker_id"]}"]
       args += ["--model", entry["model"]] if entry["model"]
+      args += ["--effort", entry["effort"]] if entry["effort"]
       entry["dispatch"] ? args + ["--dispatch"] : args
     end
 
-    def self.register(args, saved_model)
+    def self.register(args)
       entry = { "role" => args.role, "worker_id" => args.worker_id, "harness" => args.harness,
-                "model" => args.model || saved_model, "dispatch" => args.dispatch, "dir" => Dir.pwd }
+                "model" => args.model, "effort" => args.effort, "dispatch" => args.dispatch, "dir" => Dir.pwd }
       Maf::Workers.at(Project.root).add(args.worker, entry.compact)
     end
 
@@ -79,13 +80,12 @@ module Maf
       worktree
     end
 
-    def self.launch(args, manifest, _worktree)
+    def self.launch(args, _worktree)
       identify(args)
-      model = args.model || manifest.model_for(args.harness, args.role)
-      return Dispatch.launch(args, model) if args.dispatch
+      return Dispatch.launch(args) if args.dispatch
 
       MafSession.register(Project.root, args.harness)
-      Launcher.launch(Maf::Shared::Harness.fetch(args.harness), args.role, model)
+      Launcher.launch(Maf::Shared::Harness.fetch(args.harness), args.role, args.model, args.effort)
     end
 
     # The session and the dispatcher pass the environment to each child, so

data/lib/maf/shared/harness/defaults.rb

@@ -24,9 +24,9 @@ module Maf
         # files outside the project reads its folder there.
         def role_destination(project, role, _settings = {}) = role_path(role) && File.join(project, role_path(role))
 
-        # An ERB template. It gets role, title, description, can_edit, project, prompt, and model.
+        # An ERB template. It gets role, title, description, can_edit, project, prompt, model, and effort.
         def role_template = raise(NotImplementedError, "#{name}: role_template")
-        def render_role(values) = ERB.new(role_template, trim_mode: "-").result_with_hash(**values)
+        def render_role(values) = ERB.new(role_template, trim_mode: "-").result_with_hash(effort: nil, **values)
 
         # nil: the harness lists no models, so every name counts as known.
         def models = nil
@@ -37,6 +37,12 @@ module Maf
         # The command that sets the model, for a harness whose role file cannot set it.
         def model_hint(_model) = nil
 
+        # nil: the harness lists no effort levels, so every level counts as known.
+        def efforts(_model = nil) = nil
+        def known_effort?(effort, model = nil) = efforts(model).nil? || efforts(model).include?(effort)
+        # true: the model runs only with a level.
+        def effort_required?(_model) = false
+
         # How an idle agent waits for work. :watch - a watcher wakes the idle
         # session. :await - the stop hook waits after `coord await`.
         # :poll - the agent blocks in `coord next --wait`.
@@ -96,7 +102,7 @@ module Maf
       # Run: maf start (an interactive session) and the dispatcher (one run per task).
       module Run
         # The command of an interactive session.
-        def launch(_role, _model) = raise(NotImplementedError, "#{name}: launch")
+        def launch(_role, _model, _effort = nil) = raise(NotImplementedError, "#{name}: launch")
         def launch_env = {}
 
         def sandbox_dirs = []
@@ -133,6 +139,7 @@ module Maf
 
         def present(value) = value.to_s.empty? ? nil : value
         def model_flag(model, flag = "--model") = model ? [flag, model] : []
+        def effort_flag(effort, flag = "--effort") = effort ? [flag, effort] : []
         def resume(session_id, *flag) = session_id ? [*flag, session_id] : []
       end
     end

data/lib/maf/shared/harnesses/claude.rb

@@ -44,6 +44,8 @@ module Maf
         def models = MODELS
         def known_model?(model, _list = nil) = model.match?(MODEL_NAME)
         def default_model = "claude-opus-5-5"
+        EFFORTS = %w[low medium high xhigh max].freeze
+        def efforts(_model = nil) = EFFORTS
 
         def wait = :watch
         def vm_install = "curl -fsSL https://claude.ai/install.sh | bash"
@@ -91,10 +93,11 @@ module Maf
 
         # --settings adds the hooks of the flow, --mcp-config adds the graph server.
         # --mcp-config takes many values, so `--` ends the options before the prompt.
-        def launch(role, model)
+        def launch(role, model, effort = nil)
           prompt = "Read #{role_path(role)} and follow it exactly. Start your work loop now."
           ["claude", *flag_if("--settings", flow_file("claude", "settings.json")),
-           *flag_if("--mcp-config", flow_file("mcp", "claude.json")), *model_flag(model), "--", prompt]
+           *flag_if("--mcp-config", flow_file("mcp", "claude.json")), *model_flag(model), *effort_flag(effort),
+           "--", prompt]
         end
 
         # `claude -p` prints one JSON object with session_id and result.
@@ -104,7 +107,7 @@ module Maf
 
         def build_command(config, prompt, session_id)
           cmd = %w[claude -p --output-format json --permission-mode bypassPermissions --agent] + [config.role]
-          cmd += model_flag(config.model)
+          cmd += model_flag(config.model) + effort_flag(config.effort)
           cmd += LEAN if config.lean
           cmd + flag_if("--mcp-config", run_file(config, "mcp", "claude.json")) +
             resume(session_id, "--resume") + ["--", prompt]

data/lib/maf/shared/harnesses/codex.rb

@@ -52,12 +52,10 @@ module Maf
         end
 
         # Codex keeps the model list of the account in a cache file. Hidden models are internal.
-        def models
-          models = JSON.parse(File.read(File.join(Dir.home, ".codex", "models_cache.json"))).fetch("models")
-          models.select { |m| m["visibility"] == "list" }.map { |m| m["slug"] }
-        rescue SystemCallError, JSON::ParserError, KeyError, NoMethodError
-          nil
-        end
+        def models = CodexModels.listed(home)
+        # Without a pinned model, Codex runs the model of its config file.
+        def efforts(model = nil) = CodexModels.efforts(model || CodexModels.configured(home), home)
+        def effort_flag(effort) = effort ? ["-c", "model_reasoning_effort=#{effort.to_s.dump}"] : []
 
         # Codex keeps MCP servers in a global user file. maf does not edit it.
         def mcp_command(server, vault) = "codex mcp add #{server} -- ruby #{vault} mcp"
@@ -79,12 +77,20 @@ module Maf
           tracked.call(role_dir) + hooks
         end
 
-        def launch(role, model)
+        def launch(role, model, effort = nil)
           abort "setup_agent: #{role_path(role)} missing." unless File.exist?(role_path(role))
 
           warn_untrusted
-          ["codex", "--add-dir", File.join(Project.root, ".maf", "coordination"), *model_flag(model),
-           File.read(role_path(role))]
+          ["codex", *no_daemon, "--add-dir", File.join(Project.root, ".maf", "coordination"), *model_flag(model),
+           *effort_flag(effort), File.read(role_path(role))]
+        end
+
+        def no_daemon = codex_help.include?("--no-daemon") ? ["--no-daemon"] : []
+
+        def codex_help
+          IO.popen(%w[codex --help], err: File::NULL, &:read)
+        rescue SystemCallError
+          ""
         end
 
         UNTRUSTED = "maf: Codex does not trust the hooks in %<file>s yet. Without the hooks, the session " \
@@ -105,7 +111,7 @@ module Maf
         def build_command(config, prompt, session_id)
           cmd = %w[codex exec] + (session_id ? ["resume"] : [])
           cmd += %w[--json --skip-git-repo-check --dangerously-bypass-approvals-and-sandbox]
-          cmd += model_flag(config.model, "-m")
+          cmd += model_flag(config.model, "-m") + effort_flag(config.effort)
           cmd += lean_flags if config.lean
           cmd + resume(session_id) + [first_prompt(config.role, prompt, session_id)]
         end
@@ -133,6 +139,29 @@ module Maf
         end
       end
 
+      # CodexModels reads the model list of the account from the cache file of Codex.
+      module CodexModels
+        def self.listed(home) = cache(home)&.select { |m| m["visibility"] == "list" }&.map { |m| m["slug"] }
+
+        # nil: no model, or a model outside the cache.
+        def self.efforts(model, home)
+          entry = model && cache(home)&.find { |m| m["slug"] == model }
+          entry&.fetch("supported_reasoning_levels", nil)&.map { |level| level["effort"] }
+        end
+
+        def self.configured(home)
+          path = File.join(home, "config.toml")
+          top = File.exist?(path) ? File.read(path).split(/^\[/, 2).first.to_s : ""
+          top[/^model\s*=\s*"([^"]+)"/, 1]
+        end
+
+        def self.cache(home)
+          JSON.parse(File.read(File.join(home, "models_cache.json"))).fetch("models")
+        rescue SystemCallError, JSON::ParserError, KeyError, NoMethodError
+          nil
+        end
+      end
+
       # CodexLean drops the parts of the user's Codex setup that a one-shot run
       # does not use. Each one adds tool schemas, skill lists, or MCP calls
       # to every model call. Only the graphify server of this project stays.