maf 0.1.0 → 0.3.0

data/assets/harness-hooks/context-watch.rb

@@ -151,7 +151,8 @@ module ContextWatch
     # maf start gives the role file in the first prompt, not as a system
     # prompt. /clear drops it, so a cleared session gets the role file again.
     # The hook puts the file text in the context: a Read costs one model call.
-    ROLE_FILES = { "claude" => ".maf/agents/claude/%s.md", "codex" => ".codex/prompts/%s.md" }.freeze
+    # The flow keeps the role file of each harness in .maf/agents/<harness>/.
+    def role_path(harness, role) = File.join(".maf", "agents", harness, "#{role}.md")
 
     def session_start
       @store.save("session_id" => @input["session_id"], "asked" => nil)
@@ -170,10 +171,10 @@ module ContextWatch
     end
 
     # The harness guess comes first. The file that exists in the worktree wins.
+    # The role file of this harness first, then the file of another harness of the role.
     def role_file
-      names = ROLE_FILES.keys.sort_by { |name| name == harness ? 0 : 1 }
-      paths = names.map { |name| format(ROLE_FILES[name], @env["COORD_ROLE"]) }
-      paths.find { |file| File.exist?(file) } || paths.first
+      own = role_path(harness, @env["COORD_ROLE"])
+      File.exist?(own) ? own : Dir.glob(role_path("*", @env["COORD_ROLE"])).min || own
     end
 
     def note_text

data/assets/lima/maf.yaml.erb

@@ -0,0 +1,61 @@
+minimumLimaVersion: 2.2.0
+
+base:
+- template:_images/ubuntu-26.04
+
+vmType: <%= vm_type %>
+mountType: <%= mount_type %>
+cpus: <%= cpus %>
+memory: "<%= memory %>GiB"
+disk: "<%= disk %>GiB"
+
+mounts:
+# JSON quoting is valid YAML, so a quote in the path stays in the path.
+- location: <%= project.to_json %>
+  writable: true
+
+containerd:
+  system: false
+  user: false
+
+provision:
+- mode: system
+  script: |
+    #!/bin/bash
+    set -eux -o pipefail
+    export DEBIAN_FRONTEND=noninteractive
+    command -v maf >/dev/null 2>&1 && exit 0
+    apt-get update
+    apt-get install -y ruby-full git tmux curl bubblewrap nodejs npm build-essential cmake cargo rustc uuid-dev libsqlite3-dev
+    cd /tmp
+    curl -fsSL -o task.tar.gz <%= taskwarrior_url %>
+    echo "<%= taskwarrior_sha256 %>  task.tar.gz" | sha256sum -c -
+    tar xzf task.tar.gz && cd task-<%= taskwarrior %>
+    cmake -S . -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build -j"$(nproc)" && cmake --install build
+    cd / && rm -rf /tmp/task.tar.gz /tmp/task-<%= taskwarrior %> /root/.cargo/registry && apt-get clean
+    gem install <%= gem_args %>
+<% harness_installs.each do |name, (cli, install)| -%>
+- mode: user
+  script: |
+    #!/bin/bash
+    set -eux -o pipefail
+    export PATH="$HOME/.local/bin:$HOME/.opencode/bin:$PATH"
+    command -v <%= cli %> >/dev/null 2>&1 && exit 0
+    <%= install %>
+<% end -%>
+- mode: user
+  script: |
+    #!/bin/bash
+    grep -q 'maf vm' ~/.bashrc && exit 0
+    echo 'export PATH="$HOME/.local/bin:$HOME/.opencode/bin:$PATH" # maf vm' >> ~/.bashrc
+
+probes:
+- description: maf is installed
+  script: |
+    #!/bin/bash
+    set -eux -o pipefail
+    if ! timeout 1800s bash -c "until command -v maf >/dev/null 2>&1; do sleep 5; done"; then
+      echo >&2 "maf is not installed yet"
+      exit 1
+    fi
+  hint: See /var/log/cloud-init-output.log in the VM.

data/install.md

@@ -198,7 +198,12 @@ list with the existing entries plus the new entry.
 The second command approves the hook one time. Hermes stores the consent for this
 version of the script. A new script version needs a new approval.
 
-Confirm that every check from `hermes hooks doctor` passes. Then continue.
+Confirm that every check from `hermes hooks doctor` passes.
+
+Hermes gives the commands of an agent only the variables in
+`terminal.client_env_passthrough`. If `maf add` prints a `hermes config set
+terminal.client_env_passthrough` command, run it. It keeps the names that the
+list has now. Then continue.
 
 ## Step 5c - Set the Gemini key for the doc-graph refresh
 

data/lib/maf/bootstrap/claude_settings.rb

@@ -2,9 +2,10 @@
 
 module Maf
   module Bootstrap
-    # ClaudeSettings plans and applies the Claude Code hooks in the settings
-    # file of the flow, .maf/claude/settings.json. `maf start` passes the file
-    # with --settings. Claude Code runs these hooks next to the project's own.
+    # ClaudeSettings plans and applies the Claude Code hooks and environment in
+    # the settings file of the flow, .maf/claude/settings.json. `maf start`
+    # passes the file with --settings. Claude Code runs these hooks next to the
+    # project's own. The --settings env wins over the env of the user settings.
     class ClaudeSettings
       def initialize(project)
         @project = project
@@ -12,23 +13,30 @@ module Maf
 
       def plan
         file = @project.path(CLAUDE_SETTINGS)
-        [@project.action(status(file), file, "#{file} (next-task + board-watch hooks)", :claude_stop_hook)]
+        [@project.action(status(file), file, "#{file} (next-task + board-watch hooks, env)", :claude_stop_hook)]
       end
 
       def configure(file)
         settings = read(file)
-        missing = missing_hooks(settings)
-        missing.each { |event, hook| add_hook(settings, event, hook) }
-        write(file, settings) unless missing.empty?
-        !missing.empty?
+        return false if current?(settings)
+
+        write(file, update(settings))
+        true
       end
 
       private
 
       def status(file)
-        File.exist?(file) && missing_hooks(read(file)).empty? ? :skip : :configure_claude_hook
+        File.exist?(file) && current?(read(file)) ? :skip : :configure_claude_hook
+      end
+
+      def update(settings)
+        missing_hooks(settings).each { |event, hook| add_hook(settings, event, hook) }
+        settings.merge("env" => (settings["env"] || {}).merge(CLAUDE_ENV))
       end
 
+      def current?(settings) = missing_hooks(settings).empty? && (settings["env"] || {}) >= CLAUDE_ENV
+
       def read(file)
         File.exist?(file) ? (JSON.parse(File.read(file)) rescue {}) : {}
       end

data/lib/maf/bootstrap/script_planner.rb

@@ -20,7 +20,7 @@ module Maf
 
       # The shared library that the scripts load. Each file is planned as a script.
       def shared
-        Dir.children(File.join(@project.assets, SHARED_SOURCE)).sort.map do |name|
+        Dir.glob("**/*.rb", base: File.join(@project.assets, SHARED_SOURCE)).sort.map do |name|
           script(File.join(SHARED_SOURCE, name), SHARED_SIGNATURE, @project.path(MAF_DIR, SHARED_DIR, name))
         end
       end

data/lib/maf/bootstrap.rb

@@ -64,6 +64,10 @@ module Maf
       end
     ].freeze
 
+    # Claude Code environment of a flow session. Agent teams stay off: with
+    # them on, a subagent that Claude names starts as a teammate.
+    CLAUDE_ENV = { "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS" => "0" }.freeze
+
     # The knowledge graph and the Obsidian vault, at the project root where graphify looks by default.
     GRAPH_DIR = "graphify-out"
 

data/lib/maf/cli.rb

@@ -12,7 +12,9 @@ require_relative "menu"
 require_relative "team"
 require_relative "team_command"
 require_relative "worker_control"
+require_relative "worker_list"
 require_relative "untrack"
+require_relative "vm"
 require_relative "version"
 
 module Maf
@@ -20,6 +22,7 @@ module Maf
 
   def self.flow(*args) = Flow::Generator.new(["--project", Dir.pwd, *args]).run
   def self.role_names = Flow::RoleCatalog.new(Dir.pwd).roles.keys
+  def self.role_effort(role) = Flow::RoleCatalog.new(Dir.pwd).roles.dig(role, "effort")
 
   def self.agents = File.exist?(MANIFEST) ? JSON.parse(File.read(MANIFEST)).fetch("agents") : []
   def self.agent_specs = agents.map { |a| "#{a["harness"]}:#{a["role"]}" }
@@ -37,23 +40,26 @@ module Maf
 
   class CLI
     COMMANDS = {
-      "add" => "[HARNESS:ROLE[:MODEL] ...] [--model ROLE=MODEL]  add agents and install the flow; " \
-               "without arguments it asks",
+      "add" => "[HARNESS:ROLE[:MODEL] ...] [--model ROLE=MODEL] [--effort ROLE=LEVEL]  add agents and install " \
+               "the flow; without arguments it asks",
       "remove" => "HARNESS:ROLE ...                        remove agents",
       "update" => "                                        regenerate the files of the current agents",
       "agents" => "                                        list the current agents",
       "roles" => "                                        list the built-in roles and the project roles",
       "role" => "add NAME                                add a stub role to .maf/roles.yml",
-      "start" => "[HARNESS ROLE[_WORKER]] [--dispatch [--detach]]  start one agent in its worktree",
-      "prepare" => "HARNESS ROLE[_WORKER] [--dispatch|--interactive] [--replace W]  prepare a worker; " \
+      "start" => "[HARNESS ROLE[_WORKER]] [--effort LEVEL] [--dispatch [--detach]]  start one agent in its worktree",
+      "prepare" => "HARNESS ROLE[_WORKER] [--effort LEVEL] [--dispatch|--interactive] [--replace W]  " \
+                   "prepare a worker; " \
                    "--dispatch starts it (default for the architect)",
       "retire" => "ROLE[_WORKER]                           remove a worker; its tasks return to the pool",
-      "worker" => "status|stop|start|restart ROLE[_WORKER] [--force] [--max-context N] [--max-session-runs N] " \
-                  "[--cache-window S]  control one worker; start and restart save the session limits of the role",
+      "worker" => "list | status|stop|start|restart ROLE[_WORKER] [--force] [--max-context N] " \
+                  "[--max-session-runs N] [--cache-window S]  list the running workers, or control one worker; " \
+                  "start and restart save the session limits of the role",
       "team" => "[set --max N --allow HARNESS[:MODEL]]   show the team, or set its budget",
       "uninstall" => "[--check] [--yes] [--force]             remove the flow from the project",
       "migrate" => "[--check] [--yes]                       move an old-layout install into .maf/",
       "untrack" => "[--check] [--yes]                       remove the flow from git; the files stay (then commit)",
+      "vm" => "create|login|start|stop|delete|status|shell [ARGS]  run the team in a Lima VM (macOS, Linux)",
       "menu" => "                                        interactive mode (also: maf without a command)",
       "guide" => "                                        print the setup guide for an AI agent (install.md)",
       "version" => "                                        print the maf version (also: --version)"
@@ -93,7 +99,10 @@ module Maf
     # Without arguments on a terminal, maf add asks for the harness, the roles, and the models.
     def run_add = @args.empty? && $stdin.tty? ? Menu.new.add : Maf.flow(*AgentArgs.convert(@args, "--agent"))
     def run_remove = Maf.flow(*AgentArgs.convert(@args, "--remove"))
-    def run_update = Maf.flow(*@args)
+    def run_update
+      Maf.flow(*@args)
+      Untrack.warn_tracked(SetupAgent::Project.root)
+    end
     def run_roles = Maf.flow("--list-roles")
 
     def run_role
@@ -106,17 +115,20 @@ module Maf
     def run_prepare = Prepare.new(@args).run
     def run_team = TeamCommand.new(@args, SetupAgent::Project.root).run
     def run_worker
+      return WorkerList.new(SetupAgent::Project.root).run if @args.first == "list"
+
       spec = @args[1] || abort(worker_usage)
       limits = RoleLimits.parse(@args)
       WorkerControl.new(SetupAgent::Project.root, spec, force: @args.include?("--force"), limits: limits)
         .run(@args[0].to_s)
     end
 
-    def worker_usage = "usage: maf worker #{WorkerControl::ACTIONS.join("|")} ROLE[_WORKER] [--force] " \
+    def worker_usage = "usage: maf worker list | #{WorkerControl::ACTIONS.join("|")} ROLE[_WORKER] [--force] " \
                        "[--max-context N] [--max-session-runs N] [--cache-window S]"
     def run_retire = Retire.new(SetupAgent::Project.root, @args.first || abort("usage: maf retire ROLE[_WORKER]")).run
     def run_uninstall = Uninstall::Runner.new(["--project", Dir.pwd, *@args]).run
     def run_menu = Menu.new.run
+    def run_vm = Vm.new(@args, SetupAgent::Project.root).run
     def run_guide = puts(File.read(File.join(Flow::ROOT, "install.md")))
     def run_version = puts("maf #{VERSION}")
     def run_untrack = Untrack.new(SetupAgent::Project.root, @args).run
@@ -129,7 +141,8 @@ module Maf
     end
 
     def agent_line(agent)
-      "#{agent["harness"]}:#{agent["role"]}".ljust(32) + agent["model"].to_s
+      effort = agent["effort"] && "effort=#{agent["effort"]}"
+      "#{agent["harness"]}:#{agent["role"]}".ljust(32) + [agent["model"], effort].compact.join(" ")
     end
   end
 end

data/lib/maf/flow/agent_links.rb

@@ -13,7 +13,7 @@ module Maf
       # Returns :create, :skip, or :refuse. :refuse means the folder holds files
       # that the flow does not own, or a symlink to another place.
       def link(harness)
-        path = File.join(@project, HARNESS_DIRS.fetch(harness))
+        path = File.join(@project, Harness.fetch(harness).role_dir)
         return exclude(path) && :skip if linked?(path, harness)
         return :refuse unless free?(path)
 
@@ -28,7 +28,7 @@ module Maf
       # relative symlink in it instead, so the harness still finds the role.
       # A user file with the same name stays, and its name is returned.
       def link_files(harness)
-        dir = File.join(@project, HARNESS_DIRS.fetch(harness))
+        dir = File.join(@project, Harness.fetch(harness).role_dir)
         prune(dir, harness)
         role_files(harness).reject { |source| link_file(dir, source) }.map { |source| File.basename(source) }
       end

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/effort_report.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Maf
+  module Flow
+    # EffortReport warns about an effort level that the harness does not list.
+    module EffortReport
+      def self.print(results)
+        list = results.select { |r| r[:effort] && !harness(r).known_effort?(r[:effort], r[:model]) }
+        return if list.empty?
+
+        puts "", "WARNING: the harness does not list these effort levels. Check the level for a typo:",
+             list.map { |r| "  #{name(r)} -> #{r[:effort]}" },
+             "  Fix one with: maf add HARNESS:ROLE --effort ROLE=LEVEL"
+      end
+
+      def self.harness(result) = Harness.fetch(result[:agent][:harness])
+      def self.name(result) = "#{result[:agent][:harness]}:#{result[:agent][:role]}"
+    end
+  end
+end

data/lib/maf/flow/generator.rb

@@ -26,6 +26,7 @@ module Maf
         Validator.project!(@options)
         @catalog = RoleCatalog.new(@options.project)
         @roles = @catalog.roles
+        @options.role_efforts = @roles.transform_values { |data| data["effort"] }
       end
 
       def generate_all
@@ -37,7 +38,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
@@ -51,7 +52,7 @@ module Maf
 
       def print_role(key, data)
         puts "", "  #{key} (#{@catalog.source(key)})", "    #{data.fetch("description")}",
-             "    model hint: #{data.fetch("model_hint")}"
+             "    model hint: #{data.fetch("model_hint")}", *("    effort: #{data["effort"]}" if data["effort"])
       end
 
       def finish_without_agents

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/hermes_env_setup.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Maf
+  module Flow
+    # HermesEnvSetup prints the step that lets Hermes give the flow variables to
+    # the commands of an agent. The flow never edits the Hermes config.
+    class HermesEnvSetup
+      KEY = "terminal.client_env_passthrough"
+      NAMES = %w[COORD_DIR COORD_ROLE COORD_WORKER COORD_DISPATCHED COORD_SLOT COORD_SESSION_PID TASKRC
+                 MAF_BIN].freeze
+
+      def initialize(config_yaml = File.join(Dir.home, ".hermes", "config.yaml"))
+        @config_yaml = config_yaml
+      end
+
+      # Returns true when the user has a step left.
+      def install
+        names = listed
+        return puts("  hermes env ready: #{KEY}") || false if (NAMES - names).empty?
+
+        print_step(names) || true
+      end
+
+      def command(names) = "hermes config set #{KEY} '#{JSON.generate((names + NAMES).uniq)}'"
+
+      def listed
+        list = config.dig("terminal", "client_env_passthrough")
+        list.is_a?(Array) ? list.map(&:to_s) : []
+      end
+
+      private
+
+      def print_step(names)
+        puts "", "  Hermes env: the commands of a Hermes agent get no COORD_* variables yet.",
+             "  Do this step one time. It keeps the names that the list has now.", "", "    #{command(names)}", ""
+      end
+
+      def config
+        data = YAML.safe_load_file(@config_yaml)
+        data.is_a?(Hash) ? data : {}
+      rescue SystemCallError, Psych::Exception
+        {}
+      end
+    end
+  end
+end

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
 
@@ -34,7 +34,7 @@ module Maf
       # a role without the role definitions.
       def entry(agent)
         { harness: agent[:harness], role: agent[:role], model: @options.model_for(agent),
-          can_edit: @roles.fetch(agent[:role]).fetch("can_edit") }
+          can_edit: @roles.fetch(agent[:role]).fetch("can_edit") }.merge({ effort: @options.effort_for(agent) }.compact)
       end
 
       # Other tools own other keys (maf team: "team"; users: "base_branch").

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