maf 0.2.0 → 0.3.0

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.

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

@@ -3,6 +3,7 @@
 # maf shared library - code that the maf CLI and the scripts in .maf/bin share.
 # The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
 # Use the Ruby stdlib only: a script loads this file without a gem bundle.
+require "open3"
 require_relative "../harness/traits"
 
 module Maf
@@ -37,7 +38,7 @@ module Maf
           name: <%= role %>
           description: <%= description %>
           <% if model -%>
-          model: <%= model %>
+          model: <%= Maf::Shared::Harnesses::CursorModels.name(model, effort) %>
           <% end -%>
           readonly: <%= !can_edit %>
           ---
@@ -45,20 +46,75 @@ module Maf
           <%= prompt %>
         ERB
 
-        def launch(role, model)
-          ["agent", *model_flag(model), "Read #{role_path(role)} and follow it exactly. Start your work loop now."]
+        def launch(role, model, effort = nil)
+          warn "maf: Cursor takes the level in the model name. Without a model, maf drops --effort." if effort && !model
+          ["agent", *model_flag(CursorModels.name(model, effort)),
+           "Read #{role_path(role)} and follow it exactly. Start your work loop now."]
         end
 
         # `agent -p --output-format json` prints one result object with session_id and result.
         def build_command(config, prompt, session_id)
-          %w[agent -p --output-format json --force --trust --approve-mcps] + model_flag(config.model) +
+          %w[agent -p --output-format json --force --trust
+             --approve-mcps] + model_flag(CursorModels.name(config.model, config.effort)) +
             resume(session_id, "--resume") + [first_prompt(config.role, prompt, session_id)]
         end
 
+        # Cursor has no effort flag. The level is a part of the model name, so
+        # maf lists each model without its level, and the levels of each model.
+        def models = CursorModels.bases
+
+        def known_model?(model, list = models)
+          list.nil? || list.include?(model) || CursorModels.listed.include?(model)
+        end
+
+        def efforts(model = nil) = CursorModels.efforts(model)
+        def effort_required?(model) = CursorModels.effort_required?(model)
+
         # A failed run prints no JSON, only an error on stderr. So a resume
         # without a result event and with "not found" is stale. Cursor reports no token usage.
         def stale_session?(output) = result_event(output).empty? && output.match?(/not found/i)
       end
+
+      # CursorModels reads `agent --list-models`. A name is BASE-LEVEL or
+      # BASE-LEVEL-fast, for example gpt-5.3-codex-high-fast.
+      module CursorModels
+        LEVELS = %w[low medium high xhigh max].freeze
+        LEVEL = /-(#{LEVELS.join("|")})(?=(?:-fast)?\z)/
+
+        def self.listed
+          return @listed if defined?(@listed)
+
+          @listed = read
+        end
+
+        def self.read
+          out, status = Open3.capture2("agent", "--list-models", err: File::NULL)
+          status.success? ? out.scan(/^(\S+) - /).flatten : nil
+        rescue SystemCallError
+          nil
+        end
+
+        def self.bases = listed&.map { |model| model.sub(LEVEL, "") }&.uniq
+
+        # nil: maf cannot read the list. A name with a level takes no other level.
+        def self.efforts(model)
+          return nil unless listed
+          return [] if model.nil? || (model.match?(LEVEL) && listed.include?(model))
+
+          LEVELS.select { |level| listed.include?(name(model, level)) }
+        end
+
+        # A base that Cursor does not list by itself runs only with a level.
+        def self.effort_required?(model) = !listed.nil? && !listed.include?(model) && !efforts(model).to_a.empty?
+
+        # A name with a level gets the new level instead.
+        def self.name(model, effort)
+          return model unless model && effort
+
+          model = model.sub(LEVEL, "")
+          model.end_with?("-fast") ? model.sub(/-fast\z/, "-#{effort}-fast") : "#{model}-#{effort}"
+        end
+      end
     end
   end
 end

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

@@ -13,16 +13,14 @@ module Maf
       # outside the project. `--skills <project>-<role>` loads one. Hermes has
       # no agent flag and cannot be woken, so an idle agent blocks in
       # `coord next --wait`. A role with can_edit false starts without the
-      # file-writing toolsets. Hermes keeps hooks and MCP servers in global
+      # file-writing toolsets. No role gets the kanban or delegation
+      # toolset. Hermes keeps hooks and MCP servers in global
       # files, so maf prints the commands that add them.
       class Hermes < Harness::Base
         include Harness::ResultEvent
 
         DEFAULT_DIR = File.join(Dir.home, ".hermes", "skills")
         MAX_TURNS = 50
-        # Stop Hermes before the dispatcher kills it, so it can still write its
-        # result event. NOTE: assets/dispatcher Spawn::GRACE.
-        KILL_GRACE = 5
 
         def sandbox_dirs = [File.join(Dir.home, ".hermes")]
         PROTECTED = %w[config.yaml .env shell_init.sh SOUL.md hooks agent-hooks shell-hooks-allowlist.json bin scripts
@@ -56,8 +54,11 @@ module Maf
         ERB
 
         def model_hint(_model) = "hermes model"
+        EFFORTS = %w[none minimal low medium high xhigh max ultra].freeze
+        def efforts(_model = nil) = EFFORTS
+        def effort_flag(effort) = super(effort, "--reasoning")
         def mcp_command(server, vault) = "hermes mcp add #{server} --command ruby --args #{vault} mcp"
-        def install_hooks(_project) = Flow::HermesHookSetup.new.install
+        def install_hooks(_project) = Flow::HermesHookSetup.new.install | Flow::HermesEnvSetup.new.install
         def global_files = [File.join(Dir.home, ".hermes", "agent-hooks", "next-task.sh")]
 
         # The skill name uses the main checkout's name, from the project root
@@ -74,7 +75,11 @@ module Maf
           Project.manifest.fetch("agents", []).any? { |agent| agent["role"] == role && agent["can_edit"] == false }
         end
 
-        def tools(role) = read_only?(role) ? ["-t", Roles::READ_ONLY_TOOLSETS] : []
+        # With -t, Hermes loads an MCP server only when the list names its toolset.
+        def tools(role)
+          toolsets = read_only?(role) ? Roles::READ_ONLY_TOOLSETS : Roles::EDIT_TOOLSETS
+          ["-t", "#{toolsets},mcp-graphify-#{File.basename(Project.root)}"]
+        end
 
         PROMPT = "Follow the coordination rules of your role skill as role %<role>s. " \
                  "Run coord inbox, then coord next --wait. Claim a task, do the work, finish it. Repeat."
@@ -82,10 +87,10 @@ module Maf
                       "You are a lead role. Never claim a task. Run coord inbox --wait and handle each message."
 
         # `-q` on a TTY seeds an interactive session with the prompt.
-        def launch(role, model)
+        def launch(role, model, effort = nil)
           prompt = format(Roles::LEADS.include?(role) ? LEAD_PROMPT : PROMPT, role: role)
-          ["hermes", "chat", *skill(role)&.then { |name| ["--skills", name] }, *model_flag(model), *tools(role),
-           "-q", prompt]
+          ["hermes", "chat", *skill(role)&.then { |name| ["--skills", name] }, *model_flag(model), *effort_flag(effort),
+           *tools(role), "-q", prompt]
         end
 
         # --no-skill drops the skill. Without --skill, the generated skill of the role loads.
@@ -99,11 +104,16 @@ module Maf
         # `hermes chat --oneshot` with JSONL output and the skill preloaded.
         def build_command(config, prompt, session_id)
           cmd = %w[hermes chat --oneshot --yolo --format stream-json -Q]
-          cmd += [*(["--skills", config.skill] if config.skill), *model_flag(config.model), *tools(config.role)]
-          cmd += ["--max-turns", config.max_turns.to_s, "--run-budget", [config.timeout - KILL_GRACE, 1].max.to_s]
+          cmd += run_flags(config)
+          cmd += ["--max-turns", config.max_turns.to_s]
           cmd + resume(session_id, "--resume") + ["-q", prompt]
         end
 
+        def run_flags(config)
+          [*(["--skills", config.skill] if config.skill), *model_flag(config.model), *effort_flag(config.effort),
+           *tools(config.role)]
+        end
+
         def stale_session?(output) = output.include?("Session not found")
         def result_text(output) = result_event(output)["text"]
       end

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

@@ -37,6 +37,9 @@ module Maf
           <% if model -%>
           model: <%= model %>
           <% end -%>
+          <% if effort -%>
+          variant: <%= effort %>
+          <% end -%>
           temperature: 0.1
           permission:
             edit: <%= can_edit ? "allow" : "deny" %>
@@ -92,15 +95,19 @@ module Maf
         def run_env(config) = config_env(run_file(config, "mcp", "opencode.json"))
         def config_env(file) = File.exist?(file) ? { "OPENCODE_CONFIG" => file } : {}
 
-        def launch(role, model)
+        # The TUI has no variant flag. It reads the variant from the agent file.
+        def launch(role, model, effort = nil)
+          OpencodeVariant.warn_unused(File.join(role_dir, "#{role}.md"), role, effort)
           ["opencode", ".", "--agent", role, "--prompt", "Start your work loop now.", *model_flag(model)]
         end
 
+        def effort_flag(effort) = super(effort, "--variant")
+
         # `opencode run --format json`. The result event shape is not verified,
         # so the log shows no result text.
         def build_command(config, prompt, session_id)
           %w[opencode run --format json --agent] + [config.role] + model_flag(config.model, "-m") +
-            resume(session_id, "--session") + [prompt]
+            effort_flag(config.effort) + resume(session_id, "--session") + [prompt]
         end
 
         # DeepSeek costs twice as much at peak hours.
@@ -164,6 +171,22 @@ module Maf
             "and json_extract(data,'$.type') = 'tool'"
         end
       end
+
+      # OpencodeVariant tells the user how to change the level of an interactive session.
+      module OpencodeVariant
+        PATTERN = /\A---\n(?:(?!^---$).)*?^variant:\s*(\S+)/m
+        HINT = "maf: the opencode TUI cannot take --effort %<effort>s. The session starts with %<current>s. " \
+               "In the session, press ctrl+t to pick the variant %<effort>s. If the agent is in its work " \
+               "loop, stop it (Esc) and restart the loop: \"Start your work loop now.\" " \
+               "To keep the level for each session: maf add opencode:%<role>s --effort %<role>s=%<effort>s"
+
+        def self.warn_unused(path, role, effort)
+          current = File.exist?(path) ? File.read(path)[PATTERN, 1] : nil
+          return if effort.nil? || effort == current
+
+          warn format(HINT, effort: effort, role: role, current: current ? "variant #{current}" : "the default variant")
+        end
+      end
     end
   end
 end

data/lib/maf/shared/roles.rb

@@ -14,6 +14,10 @@ module Maf
       # Hermes toolsets for a role with can_edit false: no file, code_execution,
       # or delegation toolset. The shell stays, because the role needs coord and git.
       READ_ONLY_TOOLSETS = "terminal,web,skills,todo,memory,session_search,clarify"
+
+      # Hermes toolsets for a role that edits. coord is the only task board and
+      # maf starts the workers, so kanban, delegation, and cronjob stay off.
+      EDIT_TOOLSETS = "#{READ_ONLY_TOOLSETS},file,code_execution,browser,vision".freeze
     end
   end
 end

data/lib/maf/team.rb

@@ -2,7 +2,7 @@
 
 # team.rb - add, replace, and retire workers in one command.
 #
-#   maf prepare HARNESS ROLE[_WORKER] [--model M] [--dispatch | --interactive] [--replace WORKER]
+#   maf prepare HARNESS ROLE[_WORKER] [--model M] [--effort L] [--dispatch | --interactive] [--replace WORKER]
 #   maf retire WORKER
 #
 # The project manager runs these commands. `maf prepare` adds the role file,
@@ -72,7 +72,7 @@ module Maf
     end
 
     def prepare
-      Maf.flow("--agent", spec) unless Maf.agent_specs.include?("#{@args.harness}:#{@args.role}")
+      Maf.flow("--agent", spec, *effort_flag) unless Maf.agent_specs.include?("#{@args.harness}:#{@args.role}")
       worktree = SetupAgent::Worktree.ensure(@args.role, @args.worker_id, @args.harness)
       SetupAgent::RoleFile.copy(@root, worktree.dir, @args.harness, @args.role)
       archive_on_harness_change
@@ -87,6 +87,7 @@ module Maf
     end
 
     def spec = [@args.harness, @args.role, @args.model].compact.join(":")
+    def effort_flag = @args.effort ? ["--effort", "#{@args.role}=#{@args.effort}"] : []
 
     def workers_after
       all = Workers.at(@root).all
@@ -98,12 +99,12 @@ module Maf
     def start_dispatcher
       Dir.chdir(@root)
       args = [@args.harness, "#{@args.role}_#{@args.worker_id}", "--dispatch", "--detach"]
-      SetupAgent.run(@args.model ? args + ["--model", @args.model] : args)
+      SetupAgent.run(args + { "--model" => @args.model, "--effort" => @args.effort }.compact.flatten)
     end
 
     def entry(dir)
       { "role" => @args.role, "worker_id" => @args.worker_id, "harness" => @args.harness,
-        "model" => @args.model, "dispatch" => @args.dispatch, "dir" => dir }.compact
+        "model" => @args.model, "effort" => @args.effort, "dispatch" => @args.dispatch, "dir" => dir }.compact
     end
 
     def print_next_steps

data/lib/maf/team_command.rb

@@ -32,10 +32,12 @@ module Maf
 
     def line(id, entry)
       mode = entry["dispatch"] ? "dispatch" : "interactive"
-      [id.ljust(28), entry["role"].to_s.ljust(20), entry["harness"], entry["model"] || "-", mode, state(id, entry)]
+      [id.ljust(28), entry["role"].to_s.ljust(20), entry["harness"], model(entry), mode, state(id, entry)]
         .join("  ")
     end
 
+    def model(entry) = [entry["model"] || "-", entry["effort"]].compact.join("/")
+
     def state(id, entry)
       pid = entry["pid"]
       return "-" unless pid

data/lib/maf/untrack.rb

@@ -18,6 +18,11 @@ module Maf
       @yes = argv.include?("--yes")
     end
 
+    TRACKED = "maf: git tracks files of the flow. Each maf update changes them in every worktree, " \
+              "and coord start-task refuses a dirty worktree. Run maf untrack --check, then maf untrack, then commit."
+
+    def self.warn_tracked(root) = (warn TRACKED unless new(root, []).tracked.empty?)
+
     def run
       steps = plan
       return puts("maf: git tracks no file of the flow in #{@root}.") if steps.empty?
@@ -58,6 +63,8 @@ module Maf
       $stdin.gets.to_s.strip.match?(/\Ay(es)?\z/i)
     end
 
+    public
+
     # The tracked files of .maf/, and the tracked paths of each harness (Harness#untrack_paths).
     def tracked
       harness_paths = Maf::Shared::Harness.all.flat_map { |harness| harness.untrack_paths(@root, method(:git_files)) }

data/lib/maf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Maf
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/maf/worker_control.rb

@@ -26,7 +26,7 @@ module Maf
       @root = root
       @force = force
       @limits = limits
-      @worker = Workers.id(spec)
+      @worker = resolve(Workers.at(root).all, Workers.id(spec))
       @entry = Workers.at(root).find(@worker) || abort("maf: no worker #{@worker}")
     end
 
@@ -39,6 +39,17 @@ module Maf
 
     private
 
+    def resolve(workers, worker)
+      return worker if workers.key?(worker)
+
+      only_worker(worker, workers.select { |_, entry| entry["role"] == worker }.keys) || worker
+    end
+
+    def only_worker(role, names)
+      abort "maf: role #{role} has more than one worker: #{names.join(", ")}. Name one." if names.size > 1
+      names.first
+    end
+
     def status = puts("#{@worker}: #{live? ? "running (pid #{pid})" : "stopped"}")
 
     def stop