maf 0.1.0 → 0.3.0

data/lib/maf/untrack.rb

@@ -11,7 +11,6 @@ module Maf
   # locally, and runs maf update. The user reviews the change and commits it.
   class Untrack
     USAGE = "Usage: maf untrack [--check] [--yes]"
-    PATHS = [".maf", ".opencode/agents", ".codex/prompts", Bootstrap::OPENCODE_PLUGIN].freeze
 
     def initialize(root, argv)
       @root = root
@@ -19,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?
@@ -30,8 +34,8 @@ module Maf
     private
 
     def plan
-      cleaners = [Uninstall::MarkedFiles.new(@root, keep_rules: false), Uninstall::ClaudeSettings.new(@root),
-                  Uninstall::McpEntries.new(@root)]
+      cleaners = [Uninstall::MarkedFiles.new(@root, keep_rules: false),
+                  *Uninstall.harness_cleaners(@root, legacy_only: true), Uninstall::McpEntries.new(@root)]
       [untrack_step, *cleaners.flat_map(&:steps)].compact
     end
 
@@ -59,29 +63,12 @@ module Maf
       $stdin.gets.to_s.strip.match?(/\Ay(es)?\z/i)
     end
 
-    # The tracked paths of the flow, and each tracked link into .maf/agents/.
-    def tracked = (git_files(*PATHS).map { |path| top(path) } + agent_links + codex_hooks).uniq
-
-    def top(path) = path.start_with?(".maf/") ? ".maf" : path
-
-    def agent_links
-      git_files(".claude/agents").select { |path| File.symlink?(File.join(@root, path)) && link_to_flow?(path) }
-    end
-
-    def link_to_flow?(path) = File.readlink(File.join(@root, path)).include?("#{Bootstrap::MAF_DIR}/agents")
-
-    # A .codex/hooks.json with only the flow hooks belongs to the flow.
-    def codex_hooks
-      path = Flow::CodexHooks::FILE
-      git_files(path).select { |file| (hook_commands(file) - Flow::CodexHooks::COMMANDS).empty? }
-    end
+    public
 
-    def hook_commands(file)
-      data = JSON.parse(File.read(File.join(@root, file)))
-      entries = data.fetch("hooks", {}).values.flatten
-      entries.flat_map { |entry| entry.fetch("hooks", []) }.map { |hook| hook["command"] }
-    rescue JSON::ParserError
-      [nil]
+    # 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)) }
+      ((git_files(".maf").empty? ? [] : [".maf"]) + harness_paths).uniq
     end
 
     def git_files(*paths) = IO.popen(["git", "-C", @root, "ls-files", "--", *paths], err: File::NULL, &:readlines)

data/lib/maf/version.rb

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

data/lib/maf/vm/login.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "../prompt"
+
+module Maf
+  class Vm
+    # Login copies the login of each harness from the host into the VM.
+    class Login
+      # The command runs in the VM. It writes stdin to a new file with mode 600,
+      # then moves the file to ~/DEST. An old file at DEST does not keep its mode.
+      WRITE = 'cd && umask 077 && mkdir -p "$(dirname "$1")" && tmp=$(mktemp "$1.XXXXXX") && ' \
+              'cat > "$tmp" && chmod 600 "$tmp" && mv -f "$tmp" "$1"'
+
+      def initialize(name, harnesses, mode, prompt = Prompt.new)
+        @name = name
+        @harnesses = harnesses
+        @mode = mode
+        @prompt = prompt
+      end
+
+      def run = @harnesses.each { |harness| copy?(harness) ? copy(harness) : hint(harness) }
+
+      private
+
+      def copy?(harness)
+        return false if harness.vm_credentials.empty? || @mode == :none
+
+        @mode == :all || @prompt.confirm?("Copy your #{harness.name} login from this computer into the VM?")
+      end
+
+      def copy(harness)
+        logins = harness.vm_credentials.filter_map { |credential| (text = credential.read) && [credential.dest, text] }
+        return hint(harness, "maf found no login on this computer. ") if logins.empty?
+
+        logins.each { |dest, text| written?(dest, text) || abort(not_running) }
+        @prompt.say("copied  #{harness.name} login")
+      end
+
+      def not_running = "maf: cannot write to the VM #{@name}. Run: maf vm start"
+
+      def written?(dest, text)
+        command = [LIMACTL, "shell", "--workdir", "/", @name, "sh", "-c", WRITE, "sh", dest]
+        Open3.capture2e(*command, stdin_data: text).last.success?
+      end
+
+      def hint(harness, reason = "")
+        @prompt.say("#{harness.name}: #{reason}Log in in the VM: #{harness.vm_login_hint}")
+      end
+    end
+  end
+end

data/lib/maf/vm/options.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Maf
+  class Vm
+    VmOptions = Struct.new(:cpus, :memory, :disk, :gem, :login, keyword_init: true) do
+      def self.parse(argv, root)
+        options = new(cpus: 4, memory: 4, disk: 20, gem: "maf", login: $stdin.tty? ? :ask : :none)
+        parse!(options, argv)
+        options.gem = copy_gem(options.gem, root) if options.gem.end_with?(".gem")
+        options
+      end
+
+      def self.parse!(options, argv)
+        parser(options).parse!(argv.dup)
+      rescue OptionParser::ParseError => e
+        abort "maf: #{e.message}\n#{USAGE}"
+      end
+
+      def self.parser(options)
+        OptionParser.new(USAGE) do |o|
+          %i[cpus memory disk].each { |key| o.on("--#{key} N", Integer) { |value| options[key] = positive(value) } }
+          o.on("--gem FILE") { |file| options.gem = file }
+          o.on("--[no-]copy-logins") { |copy| options.login = copy ? :all : :none }
+        end
+      end
+
+      def self.positive(value)
+        value.positive? ? value : raise(OptionParser::InvalidArgument, "#{value} (use a number above 0)")
+      end
+
+      def self.copy_gem(file, root)
+        abort "maf: #{file} missing." unless File.exist?(file)
+
+        dest = File.join(root, ".maf", "vm", File.basename(file))
+        FileUtils.mkdir_p(File.dirname(dest))
+        FileUtils.cp(file, dest)
+        dest
+      end
+    end
+  end
+end

data/lib/maf/vm/template.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+require "shellwords"
+
+module Maf
+  class Vm
+    # Template renders assets/lima/maf.yaml.erb for one project.
+    class Template
+      FILE = File.join(Flow::ROOT, "assets", "lima", "maf.yaml.erb")
+      TASKWARRIOR = "3.5.0"
+      # The VM checks the download. Change the checksum with the version.
+      TASKWARRIOR_SHA256 = "9ea64b411f8314414f440ec765dfdf5a86c9f6159df47e2f60cff3db6b31157a"
+      TASKWARRIOR_URL = "https://github.com/GothenburgBitFactory/taskwarrior/releases/download/" \
+                        "v%<version>s/task-%<version>s.tar.gz"
+      HOSTS = { "darwin" => { vm_type: "vz", mount_type: "virtiofs" },
+                "linux" => { vm_type: "qemu", mount_type: "9p" } }.freeze
+
+      def initialize(root, options, harnesses)
+        @root = root
+        @options = options
+        @harnesses = harnesses
+      end
+
+      def render = ERB.new(File.read(FILE), trim_mode: "-").result_with_hash(**values)
+
+      def notes = @harnesses.reject(&:vm_install).map { |harness| "Install #{harness.name} in the VM yourself." }
+
+      private
+
+      def values
+        { project: @root, cpus: @options.cpus, memory: @options.memory, disk: @options.disk, gem_args: gem_args,
+          taskwarrior: TASKWARRIOR, taskwarrior_url: format(TASKWARRIOR_URL, version: TASKWARRIOR),
+          taskwarrior_sha256: TASKWARRIOR_SHA256,
+          harness_installs: @harnesses.select(&:vm_install).to_h { |h| [h.name, [h.command, h.vm_install]] },
+          **HOSTS.fetch(host) }
+      end
+
+      def gem_args = @options.gem == "maf" ? "maf -v #{Maf::VERSION.shellescape}" : @options.gem.shellescape
+
+      def host = RUBY_PLATFORM.include?("darwin") ? "darwin" : "linux"
+    end
+  end
+end

data/lib/maf/vm.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# vm.rb - run the whole team in a Lima VM (https://lima-vm.io).
+#
+#   maf vm create [--cpus N] [--memory GIB] [--disk GIB] [--gem FILE] [--[no-]copy-logins]
+#   maf vm login [--copy-logins]
+#   maf vm start | stop | delete | status
+#   maf vm shell [COMMAND ...]
+#
+# The VM mounts only the project folder, at the same path as on the host.
+# The host is macOS (Apple Virtualization) or Linux (QEMU with KVM).
+# Run maf, coord, and each agent in the VM. Read and review the work on the host.
+require "digest"
+require "erb"
+require "fileutils"
+require "json"
+require "optparse"
+require "tempfile"
+require_relative "flow"
+require_relative "shared/harness"
+
+module Maf
+  # Vm runs limactl for the VM of the project.
+  class Vm
+    USAGE = "usage: maf vm create [--cpus N] [--memory GIB] [--disk GIB] [--gem FILE] [--[no-]copy-logins]" \
+            "|login|start|stop|delete|status|shell [COMMAND ...]"
+    ACTIONS = %w[create login start stop delete status shell].freeze
+    LIMACTL = "limactl"
+    INSTALL = "brew install lima (macOS), or Lima and QEMU from https://lima-vm.io/docs/installation/ (Linux)"
+
+    def initialize(argv, root)
+      @action, *@args = argv
+      @root = File.realpath(root)
+    end
+
+    def run
+      abort USAGE unless ACTIONS.include?(@action)
+      abort "maf: maf vm needs Lima. Install it: #{INSTALL}" unless Shared::Harness.on_path?(LIMACTL)
+
+      owned! unless @action == "create"
+      %w[start stop delete].include?(@action) ? lifecycle : send(@action)
+    end
+
+    def name = "maf-#{slug}-#{Digest::SHA256.hexdigest(@root)[0, 8]}"
+    def slug = File.basename(@root).downcase.gsub(/[^a-z0-9-]/, "-")[0, 30]
+
+    ENV_SCRIPT = '[ -f .maf/env.sh ] && . ./.maf/env.sh; export PATH="$HOME/.local/bin:$HOME/.opencode/bin:$PATH"; ' \
+                 '[ $# -gt 0 ] || set -- bash -l; exec "$@"'
+
+    def shell_command = [LIMACTL, "shell", "--workdir", @root, name, "bash", "-c", ENV_SCRIPT, "bash", *@args]
+
+    private
+
+    def owned!
+      mounts = IO.popen([LIMACTL, "list", "--format", "{{json .Config.Mounts}}", name], err: File::NULL, &:read)
+      abort "maf: no VM for this project. Run: maf vm create" if mounts.strip.empty?
+      return if Array(JSON.parse(mounts)).any? { |mount| mount["location"] == @root }
+
+      abort "maf: the VM #{name} does not mount #{@root}. maf does not touch it."
+    end
+
+    def lifecycle
+      limactl(@action, *("--force" if @action == "delete"), name)
+    end
+
+    def create
+      options = VmOptions.parse(@args, @root)
+      template = Template.new(@root, options, harnesses)
+      Tempfile.create(["maf-vm", ".yaml"]) { |file| create_from(file.path, template.render) }
+      template.notes.each { |note| puts note }
+      Login.new(name, harnesses, options.login).run
+    end
+
+    def login = Login.new(name, harnesses, VmOptions.parse(@args, @root).login).run
+
+    def harnesses
+      ids = Shared::Project.manifest.fetch("agents", []).map { |agent| agent["harness"] }
+      ids.uniq.filter_map { |id| Shared::Harness[id] }
+    end
+
+    def create_from(path, yaml)
+      File.write(path, yaml)
+      limactl("create", "--tty=false", "--name=#{name}", path) && limactl("start", name)
+    end
+
+    def shell = Kernel.exec(*shell_command)
+    def status = limactl("list", name)
+    def limactl(*args) = system(LIMACTL, *args) || abort("maf: #{LIMACTL} #{args.first} failed.")
+  end
+end
+
+require_relative "vm/options"
+require_relative "vm/template"
+require_relative "vm/login"

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,11 +39,24 @@ 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
       return puts("#{@worker} is already stopped.") unless live?
 
+      abort "maf: #{@worker}: maf cannot check pid #{pid}. Stop it with: kill #{pid}" unless ours?
+
       @entry["dispatch"] ? stop_dispatcher : stop_session
     end
 
@@ -84,13 +97,8 @@ module Maf
     def coord_dir = File.join(@root, ".maf", "coordination")
     def presence = read(File.join(coord_dir, "presence", "#{@worker}.json"))
     def pid = presence["pid"].to_i
-    def live? = Shared::Processes.alive?(pid) && started_matches?
-
-    # A pid can belong to a new process. The start time tells them apart.
-    def started_matches?
-      recorded = presence["started"].to_s
-      recorded.empty? || recorded == Shared::Processes.started_at(pid)
-    end
+    def live? = Shared::Processes.live?(presence)
+    def ours? = Shared::Processes.same?(pid, presence["started"])
 
     # The context-watch hook records the transcript of Claude Code and Codex
     # sessions. opencode has no such hook, so its idle state is unknown.

data/lib/maf/worker_list.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# worker_list.rb - list the workers that run now: sessions and dispatchers.
+require "json"
+require "time"
+require_relative "workers"
+require_relative "shared/processes"
+
+module Maf
+  # WorkerList shows each running worker process of the project. A worker
+  # can run twice, for example as a session and as a dispatcher.
+  class WorkerList
+    Row = Struct.new(:worker, :role, :harness, :mode, :pid, :started)
+    HEADER = %w[WORKER ROLE HARNESS MODE PID STARTED].freeze
+    LSTART = "%a %b %d %H:%M:%S %Y %z"
+
+    def initialize(root)
+      @root = root
+      @workers = Workers.at(root)
+    end
+
+    def run
+      rows = running
+      puts rows.empty? ? "No worker runs." : table([HEADER] + rows.map { |row| row.to_a.map(&:to_s) }), warnings(rows)
+    end
+
+    private
+
+    def running = (sessions + dispatchers + registered).uniq(&:pid).sort_by { |row| [row.worker, row.mode] }
+
+    def coord_dir = File.join(@root, ".maf", "coordination")
+    def records(dir, pattern) = Dir.glob(File.join(coord_dir, dir, pattern)).map { |path| [path, read(path)] }
+
+    def sessions
+      records("sessions", "*.maf.json").filter_map do |path, record|
+        row(record, "session") if session_live?(record["pid"], File.mtime(path))
+      end
+    end
+
+    def session_live?(pid, registered)
+      started = Shared::Processes.started_at(pid)
+      Shared::Processes.alive?(pid) && !started.empty? && Time.strptime("#{started} +0000", LSTART) <= registered
+    rescue ArgumentError
+      false
+    end
+
+    def dispatchers
+      records("presence", "*.json").filter_map do |_, entry|
+        row(entry, "dispatch") if entry["mode"] == "dispatch" && Shared::Processes.live?(entry)
+      end
+    end
+
+    def registered
+      @workers.all.filter_map do |worker, entry|
+        row(entry.merge("worker" => worker), "dispatch") if @workers.dispatcher?(worker)
+      end
+    end
+
+    def row(data, mode)
+      entry = @workers.find(data["worker"]).to_h
+      Row.new(data["worker"], data["role"] || entry["role"], data["harness"] || entry["harness"], mode,
+              data["pid"].to_i, Shared::Processes.started_at(data["pid"]))
+    end
+
+    def table(lines)
+      widths = lines.transpose.map { |column| column.map(&:size).max }
+      lines.map { |line| line.zip(widths).map { |text, width| text.ljust(width) }.join("  ").rstrip }
+    end
+
+    def warnings(rows)
+      twice = rows.group_by(&:worker).select { |_, list| list.size > 1 }
+      stopped = @workers.all.keys - rows.map(&:worker)
+      twice.map { |worker, list| "warning: #{worker} runs #{list.size} times (pids #{list.map(&:pid).join(", ")})" } +
+        (stopped.empty? ? [] : ["stopped: #{stopped.join(", ")}"])
+    end
+
+    def read(path)
+      JSON.parse(File.read(path))
+    rescue JSON::ParserError, SystemCallError
+      {}
+    end
+  end
+end

data/lib/maf/workers.rb

@@ -8,6 +8,7 @@
 require "json"
 require "fileutils"
 require "time"
+require_relative "shared/processes"
 
 module Maf
   class Workers
@@ -27,8 +28,34 @@ module Maf
     def remove(worker) = write(all.except(worker))
     def update(worker, fields) = add(worker, find(worker).to_h.merge(fields))
 
+    def dispatcher?(worker)
+      pid = find(worker)&.fetch("pid", nil)
+      pid ? Shared::Processes.same?(pid, started(worker)) : false
+    end
+
+    def started(worker)
+      entry = find(worker).to_h
+      presence = presence(worker)
+      recorded = entry["started"].to_s
+      recorded.empty? && presence["pid"].to_i == entry["pid"].to_i ? presence["started"] : entry["started"]
+    end
+
+    def running?(worker)
+      return dispatcher?(worker) unless started(worker).to_s.empty?
+
+      presence(worker)["pid"].to_i == find(worker).to_h["pid"].to_i && Shared::Processes.live?(presence(worker))
+    end
+
+    def presence(worker) = read(File.join(File.dirname(@path), "presence", "#{worker}.json"))
+
     private
 
+    def read(path)
+      File.exist?(path) ? JSON.parse(File.read(path)) : {}
+    rescue JSON::ParserError
+      {}
+    end
+
     def write(data)
       FileUtils.mkdir_p(File.dirname(@path))
       File.write(@path, JSON.pretty_generate(data))

data/templates/roles.yml

@@ -4,6 +4,9 @@
 # the model with --model ROLE=MODEL. If the user does not choose a model,
 # claude roles get lib/maf/flow.rb's DEFAULT_MODELS entry (claude-opus-5-5).
 #
+# `effort` is the default effort level. A role gets it when the harness lists
+# the level. --effort ROLE=LEVEL overrides it. A lower level uses fewer tokens.
+#
 # `description` is also the routing line in the architect's "Available roles"
 # list. Keep it short and specific to the role.
 #
@@ -42,6 +45,7 @@ roles:
       - If a message starts with "ESCALATION", a role cannot fix a problem. Tell the user in plain words:
         what failed, which task, and the impact. Give two or three options with a recommended one.
         Wait for the answer. Then send the answer to the role with `coord msg`.
+        If the escalation names a blocked task, run `coord unblock <id>` after you send the answer.
       - If the architect escalates a repeated review failure, forward the
         options to the user. Do not send a new goal until the user decides.
 
@@ -53,6 +57,7 @@ roles:
       - Process detail in reports. The user needs outcomes and decisions.
       - Optimistic status. Report blockers and failed checks as they are.
     model_hint: "Strongest reasoning and long context, conversational. Cloud: Claude Opus 5.5 (default for the claude harness), GPT-5.x."
+    effort: medium
     can_edit: false
 
   architect:
@@ -84,6 +89,8 @@ roles:
         Goal, Inputs, Out of scope, Acceptance, Report format.
         A worker drifts if a field is missing.
       - Write acceptance criteria as exact test files or commands. The worker runs each one before coord done.
+      - A message `BLOCKED task <id> (dependency)` waits for other work. Plan or order that work.
+        When it lands, run `coord unblock <id>`. A blocked task stays out of `coord next` until then.
       - If a review rejects the same kind of problem two times, stop the fix
         loop. Send the project manager two or three options with the cost of
         each option. A third patch of the same kind usually fails too.
@@ -96,6 +103,7 @@ roles:
       - Code in task specs. Describe behavior and constraints instead.
       - Trust in a worker report without a diff check.
     model_hint: "Strongest reasoning and long context. Cloud: Claude Opus 5.5 (default for the claude harness), GPT-5.x, deepseek-v4."
+    effort: high
     can_edit: false
 
   backend-developer:
@@ -123,6 +131,7 @@ roles:
       - Edits to a test that looks wrong. Report the test to the architect.
       - Claims about code that you did not read.
     model_hint: "A strong code model. A local Qwen3.8-27B is enough for well-scoped tasks; use a cloud coder for hard or large changes."
+    effort: medium
     can_edit: true
 
   frontend-developer:
@@ -149,6 +158,7 @@ roles:
       - Values that are hard-coded to make a test pass.
       - Visual changes outside the task scope.
     model_hint: "Same as backend-developer: local coder for scoped work, cloud coder for hard UI work."
+    effort: medium
     can_edit: true
 
   tester:
@@ -174,6 +184,7 @@ roles:
       - Assertions that only repeat the implementation.
       - Deleted or weakened tests. A test removal needs architect approval.
     model_hint: "Mechanical test work usually fits a local coder model; use cloud for subtle failure analysis."
+    effort: low
     can_edit: true
 
   reviewer:
@@ -216,6 +227,7 @@ roles:
       - Style comments that the project's linter already covers.
       - A warning or minor finding labeled critical to force another round.
     model_hint: "Judgment-heavy. Prefer a cloud model with strong review ability."
+    effort: high
     can_edit: false
 
   skeptic:
@@ -252,6 +264,7 @@ roles:
       - A warning or minor finding labeled critical to force another round.
       - Style comments. The reviewer and the linter cover style.
     model_hint: "Judgment-heavy. Use a different model family from reviewer and auditor, for example GPT-5.x if reviewer runs Claude. Different models miss different defects."
+    effort: high
     can_edit: false
 
   auditor:
@@ -286,4 +299,5 @@ roles:
       - A warning or minor finding labeled critical to force another round.
       - Style comments. The reviewer and the linter cover style.
     model_hint: "Judgment-heavy. Use a different model family from reviewer and skeptic, for example Gemini, Grok, or a strong local model. Different models miss different defects."
+    effort: high
     can_edit: false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: maf
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Dominik Alberski
@@ -24,9 +24,9 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.8'
 description: multi-agent-flow is a coordination layer for AI coding agents (Claude
-  Code, Codex, opencode, Hermes). Each agent works in its own git worktree. The agents
-  share a Taskwarrior task board, file locks, and a knowledge graph through the coord
-  CLI.
+  Code, Codex, opencode, Cursor, Hermes). Each agent works in its own git worktree.
+  The agents share a Taskwarrior task board, file locks, and a knowledge graph through
+  the coord CLI.
 executables:
 - maf
 extensions: []
@@ -52,6 +52,7 @@ files:
 - assets/harness-hooks/next-task-hermes.sh
 - assets/harness-hooks/next-task.rb
 - assets/harness-hooks/session-guard.rb
+- assets/lima/maf.yaml.erb
 - assets/taskrc.append
 - assets/vault
 - assets/worktree-env.example.rb
@@ -82,8 +83,10 @@ files:
 - lib/maf/flow/agent_links.rb
 - lib/maf/flow/bootstrapper.rb
 - lib/maf/flow/codex_hooks.rb
+- lib/maf/flow/effort_report.rb
 - lib/maf/flow/generator.rb
 - lib/maf/flow/harness_linker.rb
+- lib/maf/flow/hermes_env_setup.rb
 - lib/maf/flow/hermes_hook.rb
 - lib/maf/flow/hermes_hook_setup.rb
 - lib/maf/flow/hook_files.rb
@@ -117,20 +120,37 @@ files:
 - lib/maf/setup_agent.rb
 - lib/maf/setup_agent/args.rb
 - lib/maf/setup_agent/dispatch.rb
-- lib/maf/setup_agent/hermes_launcher.rb
-- lib/maf/setup_agent/hermes_skill.rb
 - lib/maf/setup_agent/launcher.rb
 - lib/maf/setup_agent/manifest.rb
 - lib/maf/setup_agent/project.rb
+- lib/maf/setup_agent/pty_relay.rb
 - lib/maf/setup_agent/role_file.rb
 - lib/maf/setup_agent/runtime_hooks.rb
 - lib/maf/setup_agent/worktree.rb
 - lib/maf/shared/git_exclude.rb
 - lib/maf/shared/git_identity.rb
+- lib/maf/shared/harness.rb
+- lib/maf/shared/harness/base.rb
+- lib/maf/shared/harness/defaults.rb
+- lib/maf/shared/harness/output.rb
+- lib/maf/shared/harness/traits.rb
+- lib/maf/shared/harness/vm_credential.rb
+- lib/maf/shared/harnesses/claude.rb
+- lib/maf/shared/harnesses/codex.rb
+- lib/maf/shared/harnesses/cursor.rb
+- lib/maf/shared/harnesses/hermes.rb
+- lib/maf/shared/harnesses/opencode.rb
 - lib/maf/shared/peak_rate.rb
 - lib/maf/shared/processes.rb
 - lib/maf/shared/project.rb
 - lib/maf/shared/roles.rb
+- lib/maf/shared/sandbox.rb
+- lib/maf/shared/sandbox/bwrap.rb
+- lib/maf/shared/sandbox/harness_files.rb
+- lib/maf/shared/sandbox/links.rb
+- lib/maf/shared/sandbox/paths.rb
+- lib/maf/shared/sandbox/references.rb
+- lib/maf/shared/sandbox/seatbelt.rb
 - lib/maf/team.rb
 - lib/maf/team_command.rb
 - lib/maf/uninstall.rb
@@ -150,16 +170,18 @@ files:
 - lib/maf/uninstall/runner.rb
 - lib/maf/uninstall/scripts.rb
 - lib/maf/uninstall/vault_watcher.rb
+- lib/maf/uninstall/vm_files.rb
 - lib/maf/uninstall/worktrees.rb
 - lib/maf/untrack.rb
 - lib/maf/version.rb
+- lib/maf/vm.rb
+- lib/maf/vm/login.rb
+- lib/maf/vm/options.rb
+- lib/maf/vm/template.rb
 - lib/maf/worker_archive.rb
 - lib/maf/worker_control.rb
+- lib/maf/worker_list.rb
 - lib/maf/workers.rb
-- templates/claude.md.erb
-- templates/codex.md.erb
-- templates/hermes.md.erb
-- templates/opencode.md.erb
 - templates/role-stub.yml.erb
 - templates/roles.yml
 - templates/workflows/panel.md
@@ -187,7 +209,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.22
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Run several AI coding agents in parallel on one repository.
 test_files: []