maf 0.1.0 → 0.2.0

data/lib/maf/flow/bootstrapper.rb

@@ -18,12 +18,12 @@ module Maf
 
       private
 
-      # Bootstrap adds the Claude Code hooks only if .claude/ exists, and the
-      # opencode plugin only if .opencode/ exists. Flow writes the role files
-      # after bootstrap, so create these dirs first.
+      # Bootstrap installs the hooks of a harness only if its folder exists
+      # (Harness#bootstrap_dir). Flow writes the role files after bootstrap,
+      # so create these dirs first.
       def make_harness_dirs
-        used = %w[claude opencode] & @options.agents.map { |a| a[:harness] }
-        used.each { |harness| FileUtils.mkdir_p(File.join(@options.project, ".#{harness}")) }
+        dirs = @options.agents.map { |a| Harness.fetch(a[:harness]).bootstrap_dir }.compact.uniq
+        dirs.each { |dir| FileUtils.mkdir_p(File.join(@options.project, dir)) }
       end
 
       def command

data/lib/maf/flow/codex_hooks.rb

@@ -10,6 +10,14 @@ module Maf
       FILE = ".codex/hooks.json"
       TIMEOUT = { "timeout" => 3600 }.freeze
 
+      # A hooks file with only the flow hooks belongs to the flow.
+      def self.flow_only?(path)
+        hooks = JSON.parse(File.read(path)).fetch("hooks", {}).values.flatten.flat_map { |e| e.fetch("hooks", []) }
+        (hooks.map { |hook| hook["command"] } - COMMANDS).empty?
+      rescue JSON::ParserError, SystemCallError
+        false
+      end
+
       def initialize(project)
         @project = project
         @path = File.join(project, FILE)
@@ -25,8 +33,11 @@ module Maf
       private
 
       def save(data)
+        text = JSON.pretty_generate(data)
+        return if File.exist?(@path) && File.read(@path) == text
+
         FileUtils.mkdir_p(File.dirname(@path))
-        File.write(@path, JSON.pretty_generate(data))
+        File.write(@path, text)
       end
 
       # A project that tracks its own Codex hooks keeps the file in git.

data/lib/maf/flow/generator.rb

@@ -37,7 +37,7 @@ module Maf
       end
 
       def finish(results)
-        pending = @options.check? ? false : HookInstaller.new(@options.agents, @options.project).install
+        pending = @options.check? ? false : HookInstaller.new(@options.agents, @options.project).install.any?
         manifest.write
         Report.new(@options.project, @roles, pending).print(results)
       end

data/lib/maf/flow/harness_linker.rb

@@ -18,8 +18,8 @@ module Maf
 
       private
 
-      def harnesses = @options.agents.map { |a| a[:harness] }.uniq.select { |h| HARNESS_DIRS.key?(h) }
-      def dir(harness) = HARNESS_DIRS.fetch(harness)
+      def harnesses = @options.agents.map { |a| a[:harness] }.uniq.select { |h| Harness.fetch(h).role_dir }
+      def dir(harness) = Harness.fetch(harness).role_dir
 
       def link_role_files(harness)
         return warn_not_linked(harness) if File.symlink?(File.join(@options.project, dir(harness)))

data/lib/maf/flow/hook_files.rb

@@ -4,6 +4,12 @@ module Maf
   module Flow
     # HookFiles copies a hook script from the assets and makes it executable.
     module HookFiles
+      # Installs a hook script of the assets in .maf/coordination/harness-hooks/ of the project.
+      def self.install(project, name)
+        dest = File.join(project, ".maf", "coordination", "harness-hooks", name)
+        copy(File.join(ASSETS, "harness-hooks", name), dest)
+      end
+
       def self.copy(src, dest)
         FileUtils.mkdir_p(File.dirname(dest))
         return if File.exist?(dest) && File.read(dest) == File.read(src)

data/lib/maf/flow/hook_installer.rb

@@ -3,31 +3,17 @@
 module Maf
   module Flow
     # HookInstaller installs the harness hooks that pick up tasks when a
-    # session ends. Claude Code and opencode get theirs from bootstrap.
+    # session ends. Each harness installs its own (Harness#install_hooks).
+    # Some harnesses get theirs from bootstrap instead (Harness#bootstrap_dir).
     class HookInstaller
       def initialize(agents, project)
-        @harnesses = agents.map { |a| a[:harness] }.uniq
+        names = agents.map { |a| a[:harness] }
+        @harnesses = Harness.all.select { |harness| names.include?(harness.name) }
         @project = project
       end
 
-      # Returns true when the Hermes hook needs steps from the user.
-      def install
-        install_codex if @harnesses.include?("codex")
-        @harnesses.include?("hermes") && HermesHookSetup.new.install
-      end
-
-      private
-
-      def install_codex
-        %w[next-task.rb session-guard.rb].each { |name| copy_hook(name) }
-        CodexHooks.new(@project).install
-        LegacyCodexHook.new.remove
-      end
-
-      def copy_hook(name)
-        HookFiles.copy(File.join(ASSETS, "harness-hooks", name),
-                       File.join(@project, ".maf", "coordination", "harness-hooks", name))
-      end
+      # Returns the result of each harness. A truthy result: the hook needs steps from the user.
+      def install = @harnesses.map { |harness| harness.install_hooks(@project) }
     end
   end
 end

data/lib/maf/flow/manifest.rb

@@ -24,9 +24,9 @@ module Maf
 
       def data
         data = kept_keys.merge("generated_at" => Time.now.utc.iso8601, "agents" => @options.agents.map { |a| entry(a) })
-        # Only record hermes_dir when it differs from the default: the default is
+        # Only record hermes_dir when --hermes-dir sets it: the default is
         # an absolute home path that would leak into a committed manifest.
-        data["hermes_dir"] = @options.hermes_dir unless @options.hermes_dir == DEFAULT_HERMES_DIR
+        data["hermes_dir"] = @options.hermes_dir if @options.hermes_dir
         data
       end
 

data/lib/maf/flow/mcp_config.rb

@@ -3,36 +3,22 @@
 module Maf
   module Flow
     # McpConfig writes the graphify MCP server into a config file of the flow,
-    # in .maf/mcp/. The project's .mcp.json and opencode.json stay as they are.
-    # `maf start` and the dispatcher pass the file: Claude Code reads it with
-    # --mcp-config, opencode with the OPENCODE_CONFIG variable.
+    # in .maf/mcp/. The project's own config files stay as they are. maf start
+    # and the dispatcher pass the file to the harness (Harness#launch and
+    # Harness#build_command). Harness#mcp names the file and the entry.
     # The server runs `vault mcp`. A foreign entry with the same name stays.
-    # Codex and Hermes keep MCP servers in a global user file. maf does not
-    # edit that file. It prints the command that adds the server instead.
+    # A harness with a global MCP config gives a command instead
+    # (Harness#mcp_command). maf does not edit that file. It prints the command.
     class McpConfig
       NAME = "graphify"
-      ARGS = %w[ruby .maf/bin/vault mcp].freeze
-      SCHEMA = "https://opencode.ai/config.json"
-      TARGETS = {
-        "claude" => { file: ".maf/mcp/claude.json", key: "mcpServers",
-                      entry: { "command" => ARGS.first, "args" => ARGS.drop(1) } },
-        "opencode" => { file: ".maf/mcp/opencode.json", key: "mcp",
-                        entry: { "type" => "local", "command" => ARGS, "enabled" => true } }
-      }.freeze
-
-      def self.targets = TARGETS
-
-      GLOBAL_COMMANDS = { "codex" => "codex mcp add %<name>s -- ruby %<vault>s mcp",
-                          "hermes" => "hermes mcp add %<name>s --command ruby --args %<vault>s mcp" }.freeze
 
       # The shell command for a harness with a global MCP config, or nil.
       def self.global_command(harness, project)
-        vault = File.join(project, ".maf", "bin", "vault")
-        GLOBAL_COMMANDS[harness]&.then { |text| format(text, name: "#{NAME}-#{File.basename(project)}", vault: vault) }
+        harness.mcp_command("#{NAME}-#{File.basename(project)}", File.join(project, ".maf", "bin", "vault"))
       end
 
       def initialize(project, harness)
-        @target = TARGETS.fetch(harness)
+        @target = harness.mcp
         @path = File.join(project, @target[:file])
       end
 
@@ -63,7 +49,7 @@ module Maf
       end
 
       def save(data)
-        data = { "$schema" => SCHEMA }.merge(data) if @target[:key] == "mcp" && !data.key?("$schema")
+        data = { "$schema" => @target[:schema] }.merge(data) if @target[:schema] && !data.key?("$schema")
         FileUtils.mkdir_p(File.dirname(@path))
         File.write(@path, "#{JSON.pretty_generate(data)}\n")
       end

data/lib/maf/flow/mcp_installer.rb

@@ -13,13 +13,13 @@ module Maf
       def install
         return if @options.check? || disabled?
 
-        @options.agents.map { |a| a[:harness] }.uniq.each { |harness| install_for(harness) }
+        @options.agents.map { |a| a[:harness] }.uniq.each { |name| install_for(Harness.fetch(name)) }
       end
 
       private
 
       def install_for(harness)
-        if McpConfig.targets.key?(harness)
+        if harness.mcp
           report(harness, McpConfig.new(@project, harness).write)
         elsif (command = McpConfig.global_command(harness, @project))
           puts "mcp: the #{harness} harness keeps MCP servers in a global file. Add the server yourself:\n  #{command}"
@@ -27,7 +27,7 @@ module Maf
       end
 
       def report(harness, status)
-        file = McpConfig.targets.fetch(harness).fetch(:file)
+        file = harness.mcp.fetch(:file)
         return puts("mcp: wrote the graphify server to #{file}") if status == :create
         return unless status == :refuse
 

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,53 +7,20 @@ 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
-      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
+        @lists.key?(harness) ? @lists[harness] : @lists[harness] = Harness[harness]&.models
       end
 
-      def self.opencode
-        return nil unless on_path?("opencode")
-
-        out, status = Open3.capture2("opencode", "models", err: File::NULL)
-        status.success? && !out.strip.empty? ? out.split : nil
-      rescue SystemCallError
-        nil
-      end
+      def self.known?(harness, model) = Harness[harness]&.known_model?(model, self.for(harness)) != false
+      def self.default(harness) = Harness[harness]&.default_model
     end
   end
 end

data/lib/maf/flow/options.rb

@@ -23,7 +23,6 @@ module Maf
 
       def initialize(argv)
         @argv, @agents, @removed, @models = argv, [], [], {}
-        @hermes_dir = DEFAULT_HERMES_DIR
         @check = @force = @list_roles = false
         @bootstrap = true
       end
@@ -32,6 +31,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,7 +45,7 @@ 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
 
       private

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.

data/lib/maf/flow/report.rb

@@ -74,16 +74,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_files.rb

@@ -19,30 +19,15 @@ module Maf
       private
 
       def generate_agent(agent)
-        role = agent[:role]
+        harness = Harness.fetch(agent[:harness])
         model = @options.model_for(agent)
-        dest = destination(agent[:harness], role)
-        content = render(agent[:harness], role, @roles.fetch(role), model)
+        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 }
       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)
+        harness.render_role(**template_values(role, data), prompt: @prompts.build(harness, role, data), model: model)
       end
 
       def template_values(role, data)

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

@@ -7,7 +7,7 @@
 #          [--model ROLE=MODEL] [--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
 

data/lib/maf/menu.rb

@@ -73,7 +73,7 @@ module Maf
       @prompt.confirm?("#{harness} does not list #{answer}. Use it anyway?") ? answer : ask_model(harness, role, models)
     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

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

data/lib/maf/retire.rb

@@ -7,7 +7,12 @@ require_relative "shared/processes"
 
 module Maf
   class Retire
-    RUNTIME_PREFIXES = %w[.maf/ .claude/ .opencode/ .codex/].freeze
+    NOT_OURS = "maf: pid %<pid>s is not the dispatcher of %<worker>s: another process has the pid now. " \
+               "maf does not stop it."
+    DISPATCHER_COMMAND = %r{(\A|[\s/])\.maf/bin/dispatcher(\s|\z)}
+
+    # Changes in these folders belong to the flow, not to the work of the worker.
+    def self.runtime_prefixes = [".maf/"] + Maf::Shared::Harness.all.filter_map(&:home_dir).map { |dir| "#{dir}/" }
 
     def initialize(root, spec)
       @root = root
@@ -38,12 +43,42 @@ module Maf
     def stop_dispatcher
       pid = Workers.at(@root).find(@worker)&.fetch("pid", nil)
       return unless pid && Shared::Processes.alive?(pid)
+      return warn(format(NOT_OURS, pid: pid, worker: @worker)) unless dispatcher?(pid)
 
       puts "Stopping the dispatcher of #{@worker} (pid #{pid}). A running agent finishes first."
       RunningProcesses.terminate(pid)
       abort "maf: pid #{pid} did not stop. Stop it with: kill #{pid}" unless RunningProcesses.wait_for_exit(pid)
     end
 
+    def dispatcher?(pid)
+      workers = Workers.at(@root)
+      return workers.dispatcher?(@worker) unless workers.started(@worker).to_s.empty?
+      return true if legacy_dispatcher?(pid)
+
+      abort "maf: maf cannot check pid #{pid}. Stop it with: kill #{pid}, then run this again." if beating?(pid)
+      false
+    end
+
+    def legacy_dispatcher?(pid)
+      command = IO.popen(["ps", "-o", "command=", "-p", pid.to_s], err: File::NULL, &:read).to_s.strip
+      command.match?(DISPATCHER_COMMAND) && RunningProcesses.in(@dir).include?(pid.to_i)
+    rescue SystemCallError
+      false
+    end
+
+    def beating?(pid)
+      presence = read_presence
+      presence["pid"].to_i == pid.to_i && Shared::Processes.recent?(presence["seen_at"])
+    end
+
+    def read_presence
+      JSON.parse(File.read(presence_path))
+    rescue SystemCallError, JSON::ParserError
+      {}
+    end
+
+    def presence_path = File.join(@root, ".maf", "coordination", "presence", "#{@worker}.json")
+
     def release_tasks
       env = { "COORD_ROLE" => role, "COORD_WORKER" => @worker }
       ids = Team.coord(@root, "next", "--mine", env: env).scan(/^[0-9a-f-]{36}/)
@@ -56,10 +91,7 @@ module Maf
       Team.coord(@root, "annotate", id, "Worker #{@worker} was retired. Continue on the existing task branch.")
     end
 
-    def remove_presence
-      coord_dir = File.join(@root, ".maf", "coordination")
-      FileUtils.rm_f(File.join(coord_dir, "presence", "#{@worker}.json"))
-    end
+    def remove_presence = FileUtils.rm_f(presence_path)
 
     def remove_worker
       remove_worktree
@@ -72,7 +104,11 @@ module Maf
       return false unless Dir.exist?(@dir)
 
       lines = IO.popen(["git", "-C", @dir, "status", "--porcelain"], err: File::NULL, &:readlines)
-      lines.map { |line| line[3..].strip }.any? { |path| RUNTIME_PREFIXES.none? { |prefix| path.start_with?(prefix) } }
+      lines.map { |line| line[3..].strip }.any? do |path|
+        Retire.runtime_prefixes.none? do |prefix|
+          path.start_with?(prefix)
+        end
+      end
     end
 
     def remove_worktree

data/lib/maf/setup_agent/dispatch.rb

@@ -23,7 +23,7 @@ module Maf
       def self.detach(cmd, worker)
         log = File.join(ENV.fetch("COORD_DIR"), "sessions", "#{worker}.log")
         pid = spawn_detached(cmd, log)
-        Maf::Workers.at(Project.root).update(worker, "pid" => pid)
+        Maf::Workers.at(Project.root).update(worker, "pid" => pid, "started" => Maf::Shared::Processes.started_at(pid))
         puts "Started #{worker} in the background (pid #{pid}). Log: #{log}"
       end