maf 0.1.0 → 0.2.0

data/lib/maf/uninstall/mcp_entries.rb

@@ -2,15 +2,14 @@
 
 module Maf
   module Uninstall
-    # Removes the graphify server that an older maf wrote into the project's
-    # .mcp.json and opencode.json. Today the server lives in .maf/mcp/. A
+    # Removes the graphify server that an older maf wrote into a project file
+    # (Harness#legacy_mcp_file). Today the server lives in .maf/mcp/. A
     # foreign entry and all other settings stay. A file goes only if nothing
     # else is left in it.
     class McpEntries
-      PROJECT_FILES = { "claude" => ".mcp.json", "opencode" => "opencode.json" }.freeze
-
       def initialize(project)
-        @files = Flow::McpConfig.targets.map { |harness, t| [File.join(project, PROJECT_FILES.fetch(harness)), t] }
+        harnesses = Maf::Shared::Harness.all.select { |harness| harness.mcp && harness.legacy_mcp_file }
+        @files = harnesses.map { |harness| [File.join(project, harness.legacy_mcp_file), harness.mcp] }
       end
 
       def steps

data/lib/maf/uninstall/notes.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../vm"
+
 module Maf
   module Uninstall
     # Tells the user what the uninstaller keeps on purpose.
@@ -7,7 +9,7 @@ module Maf
       def initialize(project) = @project = project
 
       def lines
-        [kept_dirs, branches, global_hooks].compact
+        [kept_dirs, branches, global_hooks, vm].compact
       end
 
       private
@@ -22,8 +24,17 @@ module Maf
         "kept   branches #{list.join(", ")} (delete with git branch -D)" if list.any?
       end
 
+      def vm
+        return unless Maf::Shared::Harness.on_path?(Vm::LIMACTL)
+
+        name = Vm.new([], @project).name
+        "kept   the VM #{name} (delete with maf vm delete)" if vm_names.include?(name)
+      end
+
+      def vm_names = IO.popen([Vm::LIMACTL, "list", "--quiet"], err: File::NULL, &:readlines).map(&:strip)
+
       def global_hooks
-        hooks = GLOBAL_HOOKS.select { |path| File.exist?(path) }
+        hooks = Uninstall.global_files.select { |path| File.exist?(path) }
         "kept   global hooks #{hooks.join(", ")} (other projects can use them)" if hooks.any?
       end
     end

data/lib/maf/uninstall/role_files.rb

@@ -5,8 +5,6 @@ module Maf
     # Removes the role files in .maf/agents/ and the symlink of each harness
     # folder that points there.
     class RoleFiles
-      DIRS = %w[claude opencode codex].map { |harness| [".maf", "agents", harness] }.freeze
-
       def initialize(project, manifest)
         @project = project
         @manifest = manifest
@@ -14,28 +12,28 @@ module Maf
 
       def steps
         links.map { |path| Owned.remove(path) } + project_files.map { |path| Owned.remove(path) } +
-          @manifest.hermes_skills.select { |path| Owned.marked?(path) }.map { |path| hermes_step(path) }
+          @manifest.outside_role_files.select { |path| Owned.marked?(path) }.map { |path| outside_step(path) }
       end
 
       private
 
       def project_files
-        DIRS.flat_map { |parts| Dir.glob(File.join(@project, *parts, "*.md")) }.select { |path| Owned.marked?(path) }
+        Dir.glob(File.join(@project, ".maf", "agents", "*", "*.md")).select { |path| Owned.marked?(path) }
       end
 
       def links = folder_links + file_links
 
       def folder_links
-        Flow::HARNESS_DIRS.filter_map do |harness, dir|
-          path = File.join(@project, dir)
-          path if File.symlink?(path) && File.readlink(path) == Flow::AgentLinks.target(harness)
+        harnesses.filter_map do |harness|
+          path = File.join(@project, harness.role_dir)
+          path if File.symlink?(path) && File.readlink(path) == Flow::AgentLinks.target(harness.name)
         end
       end
 
       # The links of single role files in a harness folder with the user's own files.
       def file_links
-        Flow::HARNESS_DIRS.flat_map do |harness, dir|
-          Dir.glob(File.join(@project, dir, "*.md")).select { |path| file_link?(path, harness) }
+        harnesses.flat_map do |harness|
+          Dir.glob(File.join(@project, harness.role_dir, "*.md")).select { |path| file_link?(path, harness.name) }
         end
       end
 
@@ -43,7 +41,10 @@ module Maf
         File.symlink?(path) && File.readlink(path) == Flow::AgentLinks.file_target(harness, File.basename(path))
       end
 
-      def hermes_step(path)
+      def harnesses = Maf::Shared::Harness.all.select(&:role_dir)
+
+      # A role file outside the project lives in a folder of its own.
+      def outside_step(path)
         Step.new("remove #{File.dirname(path)}", -> { FileUtils.rm(path) && Owned.prune(File.dirname(path)) })
       end
     end

data/lib/maf/uninstall/runner.rb

@@ -40,14 +40,15 @@ module Maf
         manifest = Manifest.new(project)
         [VaultWatcher.new(project), Worktrees.new(project, @opts[:force]), Scripts.new(project),
          CommitGuard.new(project), DocGraphHooks.new(project), RoleFiles.new(project, manifest),
-         ClaudeSettings.new(project), CodexHooks.new(project), McpEntries.new(project),
-         MarkedFiles.new(project), LocalFiles.new(project), Coordination.new(project), manifest].flat_map(&:steps)
+         *Uninstall.harness_cleaners(project), *file_cleaners, manifest].flat_map(&:steps)
       end
 
+      def file_cleaners = [McpEntries, MarkedFiles, LocalFiles, Coordination, VmFiles].map { |step| step.new(project) }
+
       def apply(steps)
         abort "uninstall: cancelled" unless @opts[:yes] || confirmed?
         steps.each(&:run)
-        EMPTY_DIRS.each { |parts| Owned.prune(File.join(project, *parts)) }
+        Uninstall.empty_dirs.each { |parts| Owned.prune(File.join(project, *parts)) }
         finish("removed the multi-agent flow from #{project}")
       end
 

data/lib/maf/uninstall/scripts.rb

@@ -28,7 +28,7 @@ module Maf
       # The files of the shared library. A file without the signature stays.
       def shared
         dir = File.join(@project, Bootstrap::MAF_DIR, Bootstrap::SHARED_DIR)
-        Dir.glob(File.join(dir, "*.rb")).map { |path| [path, Bootstrap::SHARED_SIGNATURE] }
+        Dir.glob(File.join(dir, "**", "*.rb")).map { |path| [path, Bootstrap::SHARED_SIGNATURE] }
       end
     end
   end

data/lib/maf/uninstall/vm_files.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Maf
+  module Uninstall
+    # VmFiles removes the gem file that maf vm create copied into .maf/vm/.
+    class VmFiles
+      def initialize(project) = @dir = File.join(project, ".maf", "vm")
+
+      def steps
+        return [] unless Dir.exist?(@dir)
+
+        [Step.new("remove #{@dir} (the gem file for maf vm)", -> { FileUtils.rm_rf(@dir) })]
+      end
+    end
+  end
+end

data/lib/maf/uninstall.rb

@@ -20,18 +20,32 @@ require_relative "flow"
 require_relative "env_exclude"
 require_relative "local_exclude"
 require_relative "migrate"
+require_relative "shared/sandbox"
 
 module Maf
+  # Uninstall removes the flow from a project. Each harness adds its own
+  # folders, files, and cleaners (Maf::Shared::Harness).
   module Uninstall
     KEPT_DIRS = %w[graphify-out].freeze
+    # The folders of the shared library in .maf/lib/. Children come before parents.
+    LIB_DIRS = [*%w[harness harnesses sandbox].map { |dir| [".maf", "lib", "maf", "shared", dir] },
+                %w[.maf lib maf shared], %w[.maf lib maf], %w[.maf lib]].freeze
 
     # Removed after all steps if empty. Children come before parents.
-    EMPTY_DIRS = [%w[.claude agents], %w[.claude], %w[.opencode agents], %w[.opencode plugins], %w[.opencode],
-                  %w[.codex prompts], %w[.codex], %w[.maf bin], %w[.maf agents claude], %w[.maf agents opencode],
-                  %w[.maf agents codex], %w[.maf agents], %w[.maf worktrees],
-                  %w[.maf lib maf shared], %w[.maf lib maf], %w[.maf lib], %w[.maf]].freeze
+    def self.empty_dirs
+      harnesses = Maf::Shared::Harness.all
+      harnesses.flat_map(&:empty_dirs).map { |dir| dir.split("/") } + [%w[.maf bin]] +
+        harnesses.map { |harness| [".maf", "agents", harness.name] } +
+        [%w[.maf agents], %w[.maf worktrees], *LIB_DIRS, %w[.maf]]
+    end
+
+    # Files outside the project that uninstall keeps: other projects can use them.
+    def self.global_files = Maf::Shared::Harness.all.flat_map(&:global_files)
 
-    GLOBAL_HOOKS = [File.join(Dir.home, ".hermes", "agent-hooks", "next-task.sh")].freeze
+    # The cleaners of each harness. untrack runs only the legacy cleaners.
+    def self.harness_cleaners(project, legacy_only: false)
+      Maf::Shared::Harness.all.flat_map { |h| h.legacy_cleaners(project) + (legacy_only ? [] : h.cleaners(project)) }
+    end
 
     # Step is one removal. --check prints the label and runs nothing.
     Step = Struct.new(:label, :work) do
@@ -56,4 +70,5 @@ require_relative "uninstall/marked_files"
 require_relative "uninstall/coordination"
 require_relative "uninstall/local_files"
 require_relative "uninstall/notes"
+require_relative "uninstall/vm_files"
 require_relative "uninstall/runner"

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
@@ -30,8 +29,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 +58,10 @@ 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
-
-    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.2.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

@@ -44,6 +44,8 @@ module Maf
     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 +86,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/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))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: maf
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.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
@@ -117,20 +118,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 +168,17 @@ 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/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 +206,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: []