maf 0.1.0

data/lib/maf/setup_agent.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# setup_agent.rb - create a worktree for one agent and launch its harness session.
+#
+# Usage: maf start HARNESS ROLE[_WORKER] [model:MODEL] [--model MODEL]
+#                  [--dispatch [DISPATCHER FLAGS...]]
+#   maf start claude backend-developer_1
+#   maf start opencode reviewer --model openrouter/deepseek-v3
+#   maf start hermes tester --dispatch --model openrouter/deepseek-v3
+#   maf start claude reviewer --dispatch --cache-window 1500
+#
+# Without --dispatch, the harness starts as an interactive session. With
+# --dispatch, the worktree runs dispatcher instead: the agent starts only
+# when there is work and exits when the work is done. Other flags after the
+# positional arguments go to the dispatcher (for example --interval,
+# --timeout, --cache-window). WORKER defaults to 1, or to "bot" with
+# --dispatch, so a dispatched and an interactive instance of one role get
+# separate worktrees. --detach (only with --dispatch) starts the dispatcher
+# in the background, logs to .maf/coordination/sessions/<worker>.log, and records
+# its pid in .maf/coordination/workers.json. `maf retire` stops it.
+#
+# HARNESS:ROLE must already exist in .maf/config.json (maf add HARNESS:ROLE
+# adds one). Run from the project root.
+
+require "json"
+require "rbconfig"
+require "fileutils"
+require_relative "flow"
+require_relative "workers"
+require_relative "shared/git_identity"
+
+abort "setup_agent: Ruby 3.0+ required (current: #{RUBY_VERSION})." if RUBY_VERSION.split(".").first.to_i < 3
+
+module Maf
+  module SetupAgent
+    MANIFEST = ".maf/config.json"
+
+    def self.run(argv)
+      args = Args.parse(argv)
+      manifest = Manifest.load(MANIFEST).tap { |m| m.verify!(args.harness, args.role) }
+      worktree = enter_worktree(args)
+      register(args, manifest.model_for(args.harness, args.role))
+      launch(args, manifest, worktree)
+    end
+
+    # `maf start` without arguments, inside a worktree that `maf prepare` made.
+    def self.run_here
+      root = Project.root
+      entry = Maf::Workers.at(root).find(File.basename(Dir.pwd))
+      abort "maf: #{Dir.pwd} is not a prepared worktree. Run: maf start HARNESS ROLE[_WORKER]" unless entry
+
+      Dir.chdir(root)
+      run(start_args(entry))
+    end
+
+    def self.start_args(entry)
+      args = [entry["harness"], "#{entry["role"]}_#{entry["worker_id"]}"]
+      args += ["--model", entry["model"]] if entry["model"]
+      entry["dispatch"] ? args + ["--dispatch"] : args
+    end
+
+    def self.register(args, saved_model)
+      entry = { "role" => args.role, "worker_id" => args.worker_id, "harness" => args.harness,
+                "model" => args.model || saved_model, "dispatch" => args.dispatch, "dir" => Dir.pwd }
+      Maf::Workers.at(Project.root).add(args.worker, entry.compact)
+    end
+
+    def self.enter_worktree(args)
+      worktree = prepare_worktree(args)
+      Dir.chdir(worktree.dir)
+      worktree.export_env!
+      worktree
+    end
+
+    def self.prepare_worktree(args)
+      worktree = Worktree.ensure(args.role, args.worker_id, args.harness)
+      RoleFile.copy(Dir.pwd, worktree.dir, args.harness, args.role)
+      RuntimeHooks.install(worktree.dir, args.harness)
+      worktree
+    end
+
+    def self.launch(args, manifest, _worktree)
+      identify(args)
+      model = args.model || manifest.model_for(args.harness, args.role)
+      return Dispatch.launch(args, model) if args.dispatch
+
+      MafSession.register(Project.root, args.harness)
+      Launcher.for(args.harness).launch(args.role, args.worker, model)
+    end
+
+    # The session and the dispatcher pass the environment to each child, so
+    # each commit of the agent uses the git persona of the agents.
+    def self.identify(args)
+      ENV["COORD_ROLE"] = args.role
+      ENV["COORD_WORKER"] = args.worker
+      Maf::Shared::GitIdentity.apply(Project.manifest)
+    end
+  end
+end
+
+require_relative "setup_agent/args"
+require_relative "setup_agent/dispatch"
+require_relative "setup_agent/role_file"
+require_relative "setup_agent/manifest"
+require_relative "setup_agent/worktree"
+require_relative "setup_agent/launcher"
+require_relative "setup_agent/hermes_launcher"
+require_relative "setup_agent/project"
+require_relative "setup_agent/hermes_skill"
+require_relative "setup_agent/runtime_hooks"
+require_relative "../../assets/harness-hooks/session-guard"

data/lib/maf/shared/git_exclude.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# maf shared library - code that the maf CLI and the scripts in .maf/bin share.
+# The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
+# Use the Ruby stdlib only: a script loads this file without a gem bundle.
+
+require "open3"
+
+module Maf
+  module Shared
+    # GitExclude finds the info/exclude file of a clone. Every worktree of the
+    # repository shares this file. The path is nil outside a git repository.
+    module GitExclude
+      NOT_FOUND = "maf: no git exclude file for %s. Git can show the flow files as untracked."
+
+      def self.path(dir)
+        out = git_path(dir)
+        return File.expand_path(out, dir) unless out.empty?
+
+        warn format(NOT_FOUND, dir)
+      end
+
+      # --path-format=absolute needs git 2.31. Without it, git can give a path
+      # relative to dir, so the caller makes it absolute.
+      def self.git_path(dir)
+        out, status = Open3.capture2("git", "-C", dir, "rev-parse", "--git-path", "info/exclude", err: File::NULL)
+        status.success? ? out.strip : ""
+      rescue Errno::ENOENT
+        ""
+      end
+    end
+  end
+end

data/lib/maf/shared/git_identity.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# maf shared library - code that the maf CLI and the scripts in .maf/bin share.
+# The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
+# Use the Ruby stdlib only: a script loads this file without a gem bundle.
+
+require "json"
+
+module Maf
+  module Shared
+    # GitIdentity is the git persona of the agents: the author and committer
+    # of each commit that an agent or the flow makes. The key git_identity
+    # ({"name", "email"}) of .maf/config.json sets it. Without that key, the
+    # bot_user and bot_email of the github section count. Without both, git
+    # uses its own config, as for a commit of the user.
+    module GitIdentity
+      KEYS = %w[GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_COMMITTER_NAME GIT_COMMITTER_EMAIL].freeze
+
+      def self.pair(config)
+        own = config["git_identity"] || {}
+        bot = config.fetch("github", {})
+        pair = own.empty? ? bot.values_at("bot_user", "bot_email") : own.values_at("name", "email")
+        pair unless pair.any? { |value| value.to_s.empty? }
+      end
+
+      # The environment variables of git win over every git config file.
+      def self.env(config)
+        name, email = pair(config)
+        name ? KEYS.zip([name, email, name, email]).to_h : {}
+      end
+
+      def self.apply(config) = ENV.update(env(config))
+
+      def self.read(path)
+        File.exist?(path) ? JSON.parse(File.read(path)) : {}
+      rescue JSON::ParserError
+        {}
+      end
+    end
+  end
+end

data/lib/maf/shared/peak_rate.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# maf shared library - code that the maf CLI and the scripts in .maf/bin share.
+# The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
+# Use the Ruby stdlib only: a script loads this file without a gem bundle.
+
+module Maf
+  module Shared
+    # PeakRate knows the DeepSeek peak hours: 01:00-04:00 and 06:00-10:00 UTC,
+    # Monday to Friday. The off-peak rate is half the peak rate. Chinese public
+    # holidays are off-peak in full, but maf does not know them.
+    module PeakRate
+      HOURS = [1...4, 6...10].freeze
+
+      # The peak hours that cover TIME (UTC), or nil off-peak.
+      def self.hours(time) = time.wday.between?(1, 5) ? HOURS.find { |range| range.cover?(time.hour) } : nil
+      def self.peak?(time) = !hours(time).nil?
+    end
+  end
+end

data/lib/maf/shared/processes.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# maf shared library - code that the maf CLI and the scripts in .maf/bin share.
+# The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
+# Use the Ruby stdlib only: a script loads this file without a gem bundle.
+
+module Maf
+  module Shared
+    # Processes tells if a pid runs and when it started. A presence record
+    # holds the start time, so every reader must get it the same way.
+    module Processes
+      PS_ENV = { "TZ" => "UTC", "LC_ALL" => "C" }.freeze
+
+      # EPERM means the process exists but belongs to another user.
+      def self.alive?(pid)
+        pid.to_i.positive? && Process.kill(0, pid.to_i) && true
+      rescue Errno::ESRCH
+        false
+      rescue Errno::EPERM
+        true
+      end
+
+      # The start time as ps prints it, or "" when ps fails.
+      def self.started_at(pid)
+        IO.popen(PS_ENV, ["ps", "-o", "lstart=", "-p", pid.to_s], err: File::NULL, &:read).to_s.strip
+      rescue SystemCallError
+        ""
+      end
+    end
+  end
+end

data/lib/maf/shared/project.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# maf shared library - code that the maf CLI and the scripts in .maf/bin share.
+# The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
+# Use the Ruby stdlib only: a script loads this file without a gem bundle.
+
+require "json"
+
+module Maf
+  module Shared
+    # Project finds the main checkout from any worktree. `git rev-parse
+    # --git-common-dir` returns the main repo's .git dir (relative at the root,
+    # absolute in a worktree), so its parent is the main checkout.
+    module Project
+      MANIFEST = ".maf/config.json"
+      # All worktrees live inside the project, so agents need no access outside it.
+      WORKTREES_DIR = ".maf/worktrees"
+
+      def self.root
+        common = IO.popen(%w[git rev-parse --git-common-dir], err: File::NULL, &:read).to_s.strip
+        common.empty? ? Dir.pwd : File.dirname(File.expand_path(common))
+      end
+
+      def self.manifest
+        JSON.parse(File.read(File.join(root, MANIFEST)))
+      rescue Errno::ENOENT, JSON::ParserError
+        {}
+      end
+
+      # coord creates the worktree of a worker here, and maf start finds it here.
+      def self.worktree_dir(root, slug) = File.join(root, WORKTREES_DIR, slug)
+    end
+  end
+end

data/lib/maf/shared/roles.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# maf shared library - code that the maf CLI and the scripts in .maf/bin share.
+# The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
+# Use the Ruby stdlib only: a script loads this file without a gem bundle.
+
+module Maf
+  module Shared
+    module Roles
+      # Lead roles dispatch or coordinate instead of implementing. They own no
+      # tasks: they get an inbox prompt and no task polling.
+      LEADS = %w[project-manager architect].freeze
+
+      # Hermes toolsets for a role with can_edit false: no file, code_execution,
+      # or delegation toolset. The shell stays, because the role needs coord and git.
+      READ_ONLY_TOOLSETS = "terminal,web,skills,todo,memory,session_search,clarify"
+    end
+  end
+end

data/lib/maf/team.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# team.rb - add, replace, and retire workers in one command.
+#
+#   maf prepare HARNESS ROLE[_WORKER] [--model M] [--dispatch | --interactive] [--replace WORKER]
+#   maf retire WORKER
+#
+# The project manager runs these commands. `maf prepare` adds the role file,
+# creates the worktree, and registers the worker. With --dispatch, it also
+# starts the dispatcher in the background. Without --dispatch, the user runs
+# two commands: `cd <worktree>` and `maf start`. The architect is dispatched
+# unless --interactive is given.
+require "rbconfig"
+require_relative "setup_agent"
+require_relative "workers"
+require_relative "retire"
+require_relative "budget"
+
+module Maf
+  module Team
+    def self.coord(root, *args, env: {})
+      command = [RbConfig.ruby, File.join(root, ".maf", "bin", "coord"), *args]
+      IO.popen(env, command, chdir: root, err: File::NULL, &:read).to_s
+    end
+
+    def self.notify(root, text) = coord(root, "msg", "--from", "maf", "architect", text)
+  end
+
+  # Prepare makes a worker ready to start. With --replace, it retires the
+  # old worker, so the old worker's tasks return to the pool. If the old and
+  # the new worker have the same id (only the harness or the model changes),
+  # the worker keeps its worktree and its claims. A new harness archives the
+  # session and the token data of the old one.
+  class Prepare
+    # The architect never talks to the user. A dispatched architect gets fresh
+    # sessions with a handoff note, so its context stays small.
+    DISPATCH_DEFAULT = %w[architect].freeze
+
+    def self.mode_args(argv)
+      return argv - ["--interactive"] if argv.include?("--interactive")
+
+      role = SetupAgent::Args.split_role(argv[1].to_s).first
+      DISPATCH_DEFAULT.include?(role) && !argv.include?("--dispatch") ? argv + ["--dispatch"] : argv
+    end
+
+    def initialize(argv)
+      @replace = take_replace(argv)
+      @args = SetupAgent::Args.parse(self.class.mode_args(argv))
+      @root = SetupAgent::Project.root
+      @budget = Budget.at(@root)
+      @args.model ||= @budget.default_model(@args.harness)
+    end
+
+    def run
+      @budget.check!(@args.harness, @args.model, @budget.count(workers_after))
+      retire = (Retire.new(@root, @replace).tap(&:check!) if @replace)
+      Dir.chdir(@root) { prepare }
+      retire.run if retire && Workers.id(@replace) != @args.worker
+      announce
+    end
+
+    def announce
+      Team.notify(@root, "Team change: worker #{@args.worker} (#{@args.harness}) joined as #{@args.role}.")
+      @args.dispatch ? start_dispatcher : print_next_steps
+    end
+
+    private
+
+    def take_replace(argv)
+      index = argv.index("--replace") or return nil
+      argv.slice!(index, 2)[1] || abort("maf: --replace needs a worker, for example backend-developer_2")
+    end
+
+    def prepare
+      Maf.flow("--agent", spec) unless Maf.agent_specs.include?("#{@args.harness}:#{@args.role}")
+      worktree = SetupAgent::Worktree.ensure(@args.role, @args.worker_id, @args.harness)
+      SetupAgent::RoleFile.copy(@root, worktree.dir, @args.harness, @args.role)
+      archive_on_harness_change
+      Workers.at(@root).add(@args.worker, entry(worktree.dir))
+    end
+
+    # The same worker on a new harness keeps its work, but not the session
+    # and the token data of the old harness. The dashboard shows them.
+    def archive_on_harness_change
+      old = Workers.at(@root).find(@args.worker)
+      WorkerArchive.new(@root, @args.worker).harness_change if old && old["harness"] != @args.harness
+    end
+
+    def spec = [@args.harness, @args.role, @args.model].compact.join(":")
+
+    def workers_after
+      all = Workers.at(@root).all
+      all = all.except(Workers.id(@replace)) if @replace
+      all.merge(@args.worker => { "role" => @args.role })
+    end
+
+    # SetupAgent.run changes into the worktree, so it runs after prepare.
+    def start_dispatcher
+      Dir.chdir(@root)
+      args = [@args.harness, "#{@args.role}_#{@args.worker_id}", "--dispatch", "--detach"]
+      SetupAgent.run(@args.model ? args + ["--model", @args.model] : args)
+    end
+
+    def entry(dir)
+      { "role" => @args.role, "worker_id" => @args.worker_id, "harness" => @args.harness,
+        "model" => @args.model, "dispatch" => @args.dispatch, "dir" => dir }.compact
+    end
+
+    def print_next_steps
+      dir = SetupAgent::Worktree.dir_for(@root, @args.worker)
+      puts "", "Worker #{@args.worker} is ready. Run in a new terminal:", "  cd #{dir}", "  maf start"
+    end
+  end
+end

data/lib/maf/team_command.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# team_command.rb - show the team, or set its limits.
+#
+#   maf team
+#   maf team set --max N [--allow HARNESS[:MODEL] ...]
+require "json"
+require "optparse"
+require_relative "workers"
+require_relative "budget"
+require_relative "retire"
+require_relative "team"
+
+module Maf
+  class TeamCommand
+    def initialize(argv, root)
+      @argv = argv
+      @root = root
+    end
+
+    def run = @argv.first == "set" ? set(@argv.drop(1)) : show
+
+    private
+
+    def show
+      puts Budget.at(@root).summary, ""
+      workers = Workers.at(@root).all
+      puts "No workers yet. Add one: maf prepare HARNESS ROLE[_WORKER]" if workers.empty?
+      workers.each { |id, entry| puts line(id, entry) }
+      puts "", "Tasks by role:", Team.coord(@root, "status")
+    end
+
+    def line(id, entry)
+      mode = entry["dispatch"] ? "dispatch" : "interactive"
+      [id.ljust(28), entry["role"].to_s.ljust(20), entry["harness"], entry["model"] || "-", mode, state(entry)]
+        .join("  ")
+    end
+
+    def state(entry)
+      pid = entry["pid"]
+      return "-" unless pid
+
+      Shared::Processes.alive?(pid) ? "running (pid #{pid})" : "stopped"
+    end
+
+    # The budget keys replace the old budget. Keep every other manifest key,
+    # and the timeouts and limits in the team key.
+    def set(args)
+      team = parse(args)
+      path = File.join(@root, ".maf/config.json")
+      data = manifest(path)
+      File.write(path, JSON.pretty_generate(data.merge("team" => data.fetch("team", {}).merge(team))))
+      puts Budget.new(team).summary
+    end
+
+    # A corrupt manifest must not be overwritten with only the team key: that
+    # would drop every agent. Stop with a clear message instead.
+    def manifest(path)
+      return {} unless File.exist?(path)
+
+      JSON.parse(File.read(path))
+    rescue JSON::ParserError
+      abort "maf: #{path} is not valid JSON. Fix it, then run this command again."
+    end
+
+    def parse(args)
+      team = { "allow" => [] }
+      parser = OptionParser.new { |o| o.on("--max N", Integer) { |v| team["max_workers"] = v } }
+      parser.on("--allow SPEC") { |v| team["allow"] << v }.parse!(args)
+      team
+    end
+  end
+end

data/lib/maf/uninstall/claude_settings.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Maf
+  module Uninstall
+    # Removes the flow hooks from .claude/settings.json. Other hooks and
+    # settings stay. The file goes only if nothing else is left in it.
+    class ClaudeSettings
+      COMMANDS = Bootstrap::CLAUDE_HOOKS.map { |_, hook| hook["command"] }.uniq.freeze
+
+      def initialize(project) = @path = File.join(project, ".claude", "settings.json")
+
+      def steps
+        return [] unless File.exist?(@path) && strip(settings) != settings
+
+        [Step.new("remove flow hooks from #{@path}", -> { clean })]
+      end
+
+      private
+
+      def settings = (JSON.parse(File.read(@path)) rescue {})
+
+      def clean
+        data = strip(settings)
+        data.empty? ? FileUtils.rm(@path) : File.write(@path, JSON.pretty_generate(data))
+      end
+
+      def strip(data)
+        hooks = data.fetch("hooks", {}).transform_values { |entries| strip_event(entries) }.reject { |_, v| v.empty? }
+        hooks.empty? ? data.except("hooks") : data.merge("hooks" => hooks)
+      end
+
+      def strip_event(entries)
+        entries.map { |entry| entry.merge("hooks" => entry.fetch("hooks", []).reject { |h| ours?(h) }) }
+               .reject { |entry| entry["hooks"].empty? }
+      end
+
+      def ours?(hook) = COMMANDS.include?(hook["command"])
+    end
+  end
+end

data/lib/maf/uninstall/codex_hooks.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Maf
+  module Uninstall
+    # Remove project MAF hooks. Preserve other project hooks.
+    class CodexHooks < ClaudeSettings
+      def initialize(project)
+        @path = File.join(project, ".codex", "hooks.json")
+      end
+
+      private
+
+      def ours?(hook)
+        Flow::CodexHooks::COMMANDS.include?(hook["command"])
+      end
+    end
+  end
+end

data/lib/maf/uninstall/commit_guard.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Maf
+  module Uninstall
+    # The commit guard lives in the git hooks dir, outside the working tree.
+    class CommitGuard
+      def initialize(project) = @project = project
+
+      def steps
+        path = Git.lines(@project, "rev-parse", "--git-path", "hooks").first
+        hook = path && File.join(File.expand_path(path, @project), "pre-commit")
+        hook && Owned.signed?(hook, Bootstrap::COMMIT_GUARD_SIGNATURE) ? [Owned.remove(hook)] : []
+      end
+    end
+  end
+end

data/lib/maf/uninstall/coordination.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Maf
+  module Uninstall
+    class Coordination
+      def initialize(project) = @dir = File.join(project, ".maf", "coordination")
+
+      def steps
+        return [] unless Dir.exist?(@dir)
+
+        [Step.new("remove #{@dir} (task board, messages, locks, hooks)", -> { FileUtils.rm_rf(@dir) })]
+      end
+    end
+  end
+end

data/lib/maf/uninstall/doc_graph_hooks.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Maf
+  module Uninstall
+    # DocGraphHooks removes the flow block from the post-commit and post-merge
+    # hooks. A hook with nothing left but its shebang goes.
+    class DocGraphHooks
+      EVENTS = %w[post-commit post-merge].freeze
+
+      def initialize(project) = @project = project
+
+      def steps
+        EVENTS.map { |event| path(event) }.compact.select { |hook| Owned.marked?(hook) }
+              .map { |hook| Step.new("remove flow block from #{hook}", -> { clean(hook) }) }
+      end
+
+      private
+
+      def path(event)
+        hooks = Git.lines(@project, "rev-parse", "--git-path", "hooks").first
+        hooks && File.join(File.expand_path(hooks, @project), event)
+      end
+
+      def clean(hook)
+        text = Bootstrap::MarkedBlock.new(File.read(hook)).remove
+        return drop(hook) if foreign_lines(text).empty?
+
+        File.write(hook, "#{text.strip}\n")
+      end
+
+      def foreign_lines(text)
+        text.lines.map(&:strip).reject { |line| line.empty? || line.start_with?("#!") }
+      end
+
+      def drop(hook) = FileUtils.rm_f(hook)
+    end
+  end
+end

data/lib/maf/uninstall/git.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Maf
+  module Uninstall
+    module Git
+      def self.lines(project, *args)
+        IO.popen(["git", "-C", project, *args], err: File::NULL, &:readlines).map(&:chomp)
+      rescue Errno::ENOENT
+        []
+      end
+    end
+  end
+end

data/lib/maf/uninstall/local_files.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Maf
+  module Uninstall
+    # Removes the settings and the MCP config of the flow in .maf/, and the
+    # local git excludes. The excludes keep the kept graphify-out/ dir, so
+    # git does not show the generated files.
+    class LocalFiles
+      DIRS = [%w[.maf claude], %w[.maf mcp]].freeze
+
+      def initialize(project) = @project = project
+
+      def steps
+        dirs = DIRS.map { |parts| File.join(@project, *parts) }.select { |dir| Dir.exist?(dir) }
+        dirs.map { |dir| Step.new("remove #{dir}", -> { FileUtils.rm_rf(dir) }) } + exclude_steps
+      end
+
+      private
+
+      def exclude_steps
+        file = LocalExclude.exclude_path(@project)
+        return [] if file.nil? || LocalExclude.listed(file).empty?
+
+        [Step.new("remove the flow paths from #{file}", -> { keep_generated_dirs })]
+      end
+
+      def keep_generated_dirs
+        kept = KEPT_DIRS.select { |dir| Dir.exist?(File.join(@project, dir)) }.map { |dir| "#{dir}/" }
+        kept.empty? ? LocalExclude.remove(@project) : LocalExclude.replace(@project, kept)
+      end
+    end
+  end
+end