maf 0.6.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df94fb01940bd1e9d53fbd46bd33d023ef9584eebafcf018a11c71fcc2edf4e9
-  data.tar.gz: 063fcde6929e5a1476ec12db56bcc65dff75dc1d9f3867208b4a8e91fa865335
+  metadata.gz: 0600cae448899ea324b41b1cc21c2fefc40f9f1b5b349bfd0d6ae6ea2fdd90dc
+  data.tar.gz: 32d55e40cfa8de776f1ba464a3316c8872737a1bfe4953bae45462678792046c
 SHA512:
-  metadata.gz: f60c0cbcb6a60b2a079e09e3ccf9587c3501c1420f33cbfb6424c80211440d2831b1ddce1894d4adc171299ac7a25bd2cdebc84b2b8d565c54ff88623cbe44da
-  data.tar.gz: 8a86dbb9aa864b37426c7db5f3d2e4d26ebd145086cc0f766053468f79d5863598ef9aadd645bce991879ac86acd2efbe962690ca8e660efa38fe2bda58ed12a
+  metadata.gz: 2efc01c78cd25e6a017361df5c735880c7ddad65d4b40e7e3b9c6b8659bb5b3fed7680009838ed9ff1e84cb0ec65c9f9261f70229800d50e35d71d860e4c0044
+  data.tar.gz: 752dd79b5d7ea15a8206a7aaf3b6097f21c5d8d51a7f45ef66d60822d46ea948272d0095b66a4959670f5d00495242c11774fcbd30784fd21e2ab65dd54bab0c

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+## [0.7.1] - 2026-10-29
+
+- Changed: the dispatcher no longer escalates a crash or a LaunchServices denial of a macOS
+  service (a program in `/System/`, `MTLCompilerService`, `intelligencecontextd`). It writes a log
+  line only. Before, each one reached the project manager as an `ESCALATION` that needed no action.
+- Fixed: the macOS sandbox lets an agent connect to the PostgreSQL socket in `/tmp`
+  (`/tmp/.s.PGSQL.<port>`). Before, a Rails test that used the socket got `Operation not permitted`.
+- Fixed: when the pull request of a goal merges, coord keeps the goal branch while a task of the
+  goal is still open. Before, `coord gc` deleted it and the open task could not land.
+
+## [0.7.0] - 2026-10-24
+
+- Changed: the project manager interviews the user until no decision stays silently assumed. It asks
+  about the what only and gives no recommended option unless the user asks for one. It keeps a goal
+  brief in `$COORD_DIR/artifacts/<goal>/goal.md` and hands the goal to the architect only after the
+  user confirms a summary of the brief. Its default effort is now `high`.
+- Changed: the architect plans the how from the goal brief and sends open what-questions to the
+  project manager. It cuts tasks as vertical slices and does wide renames as expand, migrate, contract.
+- Changed: the tester ranks three to five hypotheses before it looks for the cause of a bug, and
+  the reviewer checks the diff against the task spec and the goal brief in a separate section.
+- New: a new install turns the sandbox on for the dispatched runs. At the first install,
+  `maf add` writes `{ "mode": "auto", "scope": "dispatch" }` to `.maf/sandbox.json`. New flags
+  `--sandbox off|auto|seatbelt|bwrap` and `--sandbox-scope dispatch|all` choose a different
+  policy, at the install or later. The interactive `maf add` asks for the sandbox at the first
+  install. `install.md` has a new step that asks the user. An existing install keeps its policy:
+  with no file, the sandbox stays off. Turn it on with `maf add --sandbox auto`.
+
 ## [0.6.0] - 2026-10-22
 
 - New: `.maf/sandbox.json` key `scope`. `dispatch` (the default) runs only the dispatched runs

data/assets/coord

@@ -1577,6 +1577,7 @@ end
     def goal_reason(name)
       goal = @tasks.find_short(name.delete_prefix("goal/"))
       return "goal is not done" unless goal["status"] == "completed"
+      return "goal has open tasks" if @tasks.for_goal(goal["uuid"]).any?
 
       Git.ancestor?(@root, name, ref) ? nil : "not merged into #{ref}"
     end

data/assets/dispatcher

@@ -758,6 +758,10 @@ module Dispatcher
              "apps outside the sandbox. An app with its own sandbox (Chrome) also needs it off (--no-sandbox), " \
              "because macOS cannot start a sandbox in a sandbox. Tell the user."
 
+    SYSTEM = %w[MTLCompilerService intelligencecontextd].freeze
+    IGNORED = "Dispatcher of %<worker>s: in the macOS sandbox, these macOS services crashed or were refused " \
+              "LaunchServices: %<apps>s. maf ignores them."
+
     @seen = []
 
     def self.guard(harness, config, env, &block)
@@ -774,9 +778,21 @@ module Dispatcher
     def self.report(config, env, crashes, denied)
       crashes = crashes.except(*@seen)
       denied -= @seen
+      @seen.concat(crashes.keys, denied)
+      ignore(config, crashes.keys + denied)
+      escalate(config, env, crashes.reject { |app, _| system?(app) }, denied.reject { |app| system?(app) })
+    end
+
+    def self.system?(app) = app.start_with?("/System/") || SYSTEM.include?(File.basename(app, ".*"))
+
+    def self.ignore(config, apps)
+      ignored = apps.select { |app| system?(app) }.uniq
+      Log.line(format(IGNORED, worker: config.worker, apps: ignored.join(", "))) if ignored.any?
+    end
+
+    def self.escalate(config, env, crashes, denied)
       return if crashes.empty? && denied.empty?
 
-      @seen.concat(crashes.keys, denied)
       text = format(NOTICE, worker: config.worker, found: found(crashes, denied))
       Log.line(text)
       CoordCall.run(env, "escalate", text)

data/install.md

@@ -141,10 +141,33 @@ If the workflow is `panel`, propose a different model family for each of
 `reviewer`, `skeptic`, and `auditor`. Example: Claude, GPT, and Gemini.
 Different models miss different defects. The user makes the final choice.
 
+## Step 4b - Ask the user for the sandbox
+
+A dispatched agent runs without approval prompts. The sandbox limits its writes to the
+project, the board, and the state paths of its harness. See `FLOW/docs/sandbox.md`.
+
+Ask: "Which sandbox do you want? Choose one."
+
+| Choice | Flags for Step 5 | Effect |
+|---|---|---|
+| Dispatched runs only (default) | none | The dispatched runs and the analyst run in the sandbox. Interactive sessions run on the host, with approvals. |
+| Dispatched runs and interactive sessions | `--sandbox-scope all` | Each agent runs in the sandbox. |
+| Off | `--sandbox off` | No agent runs in the sandbox. |
+
+Recommend the default. If the user chooses `Off`, tell the user that a dispatched
+agent can then change each file of the user.
+
+On Linux, the sandbox needs bubblewrap 0.10 or later. Run `bwrap --version`.
+If it is missing or older, tell the user to install it, or to choose `Off`.
+On macOS, the sandbox needs nothing.
+
+`maf add` writes the choice to `.maf/sandbox.json` at the first install.
+A later `maf add` changes the file only with a `--sandbox` or `--sandbox-scope` flag.
+
 ## Step 5 - Add the agents
 
 Give one `HARNESS:ROLE` argument per role. Add one `--model ROLE=MODEL` flag
-per chosen model.
+per chosen model. Add the sandbox flags from Step 4b.
 
 Preview first. This writes nothing.
 
@@ -164,6 +187,7 @@ Then run the same command without `--check`.
 1. Sets up the coordination layer.
 2. Writes a role file for each role, in the format of its harness.
 3. Writes a manifest at `$PROJECT/.maf/config.json`.
+   At the first install, also writes the sandbox policy at `$PROJECT/.maf/sandbox.json`.
 4. Writes the graphify MCP server into `.maf/mcp/` for Claude Code and opencode.
    `maf start` passes the file to the harness. The project's `.mcp.json` and `opencode.json` stay as they are.
    For Codex and Hermes, `maf add` prints a command. Run it to add the server.
@@ -251,7 +275,7 @@ If `git ls-files .maf` lists files, an older maf version committed them. Run
 
 ## Step 7 - Report to the user
 
-Report the generated files. Then print one `maf start` command for each worker.
+Report the generated files and the sandbox line of `maf add`. Then print one `maf start` command for each worker.
 Use the number of workers from Step 3b. A worker role with N workers gets the
 names `ROLE_1` to `ROLE_N`. A role with one worker may use the bare role name.
 Then give the user these instructions.

data/lib/maf/cli.rb

@@ -42,8 +42,8 @@ module Maf
 
   class CLI
     COMMANDS = {
-      "add" => "[HARNESS:ROLE[:MODEL] ...] [--model ROLE=MODEL] [--effort ROLE=LEVEL]  add agents and install " \
-               "the flow; without arguments it asks",
+      "add" => "[HARNESS:ROLE[:MODEL] ...] [--model ROLE=MODEL] [--effort ROLE=LEVEL] [--sandbox MODE] " \
+               "[--sandbox-scope dispatch|all]  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",

data/lib/maf/flow/generator.rb

@@ -39,8 +39,10 @@ module Maf
 
       def finish(results)
         pending = @options.check? ? false : HookInstaller.new(@options.agents, @options.project).install.any?
+        sandbox = SandboxPolicy.new(@options).tap(&:write)
         manifest.write
         Report.new(@options.project, @roles, pending).print(results)
+        sandbox.report
       end
 
       def manifest = Manifest.new(@options, @roles)

data/lib/maf/flow/options.rb

@@ -5,7 +5,7 @@ module Maf
     # Options parses the command line and holds the settings of one run.
     class Options
       attr_accessor :project, :agents, :role_efforts
-      attr_reader :removed, :models, :efforts, :hermes_dir, :list_roles
+      attr_reader :removed, :models, :efforts, :hermes_dir, :list_roles, :sandbox
 
       # Each flag: the OptionParser arguments, and a block that runs in the
       # Options instance with the flag value.
@@ -15,6 +15,8 @@ module Maf
         [["--remove SPEC", "HARNESS:ROLE"], ->(v) { @removed << parse_agent(v) }],
         [["--model PAIR", "ROLE=MODEL"], ->(v) { @models.store(*v.split("=", 2)) }],
         [["--effort PAIR", "ROLE=LEVEL"], ->(v) { @efforts.store(*v.split("=", 2)) }],
+        [["--sandbox MODE", "off, auto, seatbelt, or bwrap"], ->(v) { @sandbox["mode"] = v }],
+        [["--sandbox-scope SCOPE", "dispatch or all"], ->(v) { @sandbox["scope"] = v }],
         [["--hermes-dir DIR"], ->(v) { @hermes_dir = File.expand_path(v) }],
         [["--check"], ->(_) { @check = true }],
         [["--force"], ->(_) { @force = true }],
@@ -24,7 +26,7 @@ module Maf
 
       def initialize(argv)
         @argv, @agents, @removed, @models, @efforts = argv, [], [], {}, {}
-        @role_efforts = {}
+        @role_efforts, @sandbox = {}, {}
         @check = @force = @list_roles = false
         @bootstrap = true
       end

data/lib/maf/flow/prompt_text.rb

@@ -248,8 +248,8 @@ module Maf
       2. Turn the request into one goal. Create the goal at the start of the interview:
          `coord goal add --title "<outcome>"`.
          The command prints the goal id and creates the goal branch. The glossary draft path needs the goal id.
-      3. When the interview ends, hand the goal to the architect:
-           coord msg --from project-manager architect "GOAL <goal-id>: <goal>"
+      3. When the user confirms the summary of the goal brief, hand the goal to the architect:
+           coord msg --from project-manager architect "GOAL <goal-id>: <goal>. Brief: $COORD_DIR/artifacts/<goal-id>/goal.md"
       4. Check status with `coord goal list` and `coord goal show <goal-id>` when the user asks.
          %{wait_instruction}
          Never poll with sleep or with repeated status commands. Each check sends your whole context again.

data/lib/maf/flow/sandbox_policy.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Maf
+  module Flow
+    # SandboxPolicy writes the mode and the scope of .maf/sandbox.json.
+    # A new install gets DEFAULT. A later run changes the file only for a --sandbox flag.
+    class SandboxPolicy
+      FILE = File.join(MAF_DIR, "sandbox.json")
+      CHOICES = { "mode" => %w[off auto seatbelt bwrap], "scope" => %w[dispatch all] }.freeze
+      DEFAULT = { "mode" => "auto", "scope" => "dispatch" }.freeze
+      HINT = "  Change it with: maf add --sandbox off|auto|seatbelt|bwrap --sandbox-scope dispatch|all"
+
+      def self.validate!(chosen)
+        chosen.each do |key, value|
+          allowed = CHOICES.fetch(key)
+          abort "flow: unknown sandbox #{key} '#{value}' (use #{allowed.join(", ")})" unless allowed.include?(value)
+        end
+      end
+
+      def initialize(options)
+        @options = options
+        @fresh = !File.exist?(File.join(options.project, MAF_DIR, "config.json"))
+      end
+
+      def write
+        return if @options.check? || (!@fresh && @options.sandbox.empty?)
+
+        @policy = (@fresh ? DEFAULT.merge(current) : current).merge(@options.sandbox)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, "#{JSON.pretty_generate(@policy)}\n")
+      end
+
+      def report
+        return unless @policy
+
+        puts "", "Sandbox: #{summary} (#{FILE})", HINT
+        warn_bwrap if bwrap? && !bwrap_installed?
+      end
+
+      private
+
+      def path = File.join(@options.project, FILE)
+
+      def current
+        File.exist?(path) ? JSON.parse(File.read(path)) : {}
+      rescue JSON::ParserError
+        abort "flow: #{FILE} is not valid JSON. Fix the file, or delete it."
+      end
+
+      def mode = @policy["mode"] || "off"
+      def summary = mode == "off" ? "off" : "#{mode}, scope #{@policy["scope"] || "dispatch"}"
+      def bwrap? = mode == "bwrap" || (mode == "auto" && !RUBY_PLATFORM.include?("darwin"))
+      def bwrap_installed? = ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? { File.executable?("#{_1}/bwrap") }
+
+      def warn_bwrap
+        puts "WARNING: the Linux sandbox needs bubblewrap 0.10 or later. Install it before a dispatched run,",
+             "  or turn the sandbox off: maf add --sandbox off"
+      end
+    end
+  end
+end

data/lib/maf/flow/validator.rb

@@ -19,6 +19,7 @@ module Maf
 
       # A removal may leave no agents. Only a run that removes nothing needs one.
       def run
+        SandboxPolicy.validate!(@options.sandbox)
         @options.agents = Roster.new(@options.project).merge(@options.agents, @options.removed)
         abort "flow: no agents. Add one with --agent HARNESS:ROLE" if @options.agents.empty? && @options.removed.empty?
 

data/lib/maf/flow.rb

@@ -4,7 +4,8 @@
 #
 # maf add, maf remove, maf update, and maf roles run Flow::Generator.
 # Options: --project DIR [--agent HARNESS:ROLE ...] [--remove HARNESS:ROLE ...]
-#          [--model ROLE=MODEL] [--effort ROLE=LEVEL] [--hermes-dir DIR] [--check] [--force] [--no-bootstrap]
+#          [--model ROLE=MODEL] [--effort ROLE=LEVEL] [--sandbox MODE] [--sandbox-scope SCOPE]
+#          [--hermes-dir DIR] [--check] [--force] [--no-bootstrap]
 #          [--list-roles]
 #
 # HARNESS is a harness of the registry: one file in lib/maf/shared/harnesses/.
@@ -61,6 +62,7 @@ require_relative "flow/mcp_config"
 require_relative "flow/mcp_installer"
 require_relative "flow/role_files"
 require_relative "flow/manifest"
+require_relative "flow/sandbox_policy"
 require_relative "flow/models"
 require_relative "flow/effort_report"
 require_relative "flow/report"

data/lib/maf/menu.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "prompt"
+require_relative "sandbox_choice"
 
 module Maf
   # Menu is the interactive mode of maf. It runs the same steps as the
@@ -28,7 +29,7 @@ module Maf
       return if roles.empty?
 
       models = show_models(harness)
-      Maf.flow(*roles.flat_map { |role| agent_args(harness, role, models) })
+      Maf.flow(*roles.flat_map { |role| agent_args(harness, role, models) }, *SandboxChoice.new(@prompt).args)
     end
 
     private

data/lib/maf/sandbox_choice.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Maf
+  # SandboxChoice asks for the sandbox of a new install. A later maf add keeps .maf/sandbox.json.
+  class SandboxChoice
+    CHOICES = [["Dispatched runs only (recommended)", %w[auto dispatch]],
+               ["Dispatched runs and interactive sessions", %w[auto all]],
+               ["Off", %w[off dispatch]]].freeze
+
+    def initialize(prompt)
+      @prompt = prompt
+    end
+
+    def args
+      return [] if File.exist?(MANIFEST)
+
+      mode, scope = ask.last
+      ["--sandbox", mode, "--sandbox-scope", scope]
+    end
+
+    private
+
+    def ask
+      CHOICES.each_with_index { |(label, _), i| @prompt.say("  #{i + 1}) #{label}") }
+      number = Integer(@prompt.ask("Sandbox (number, Enter = 1):").to_s, exception: false)
+      number&.between?(1, CHOICES.size) ? CHOICES[number - 1] : CHOICES.first
+    end
+  end
+end

data/lib/maf/shared/sandbox/seatbelt.rb

@@ -15,6 +15,7 @@ module Maf
         DEVICES = '(literal "/dev/null") (literal "/dev/zero") (literal "/dev/dtracehelper") ' \
                   '(regex #"^/dev/tty") (regex #"^/dev/fd/") (regex #"^/dev/ptmx")'
         DNS = '(path-literal "/private/var/run/mDNSResponder")'
+        POSTGRES = '(regex #"^/private/tmp/\\.s\\.PGSQL\\.[0-9]+$")'
         TMP_PREFIX = "maf-sandbox-"
         # The map database of LaunchServices only reads: it turns a type name into a type.
         # Without it, pbcopy writes the text with a type that no app reads.
@@ -98,7 +99,7 @@ module Maf
         end
 
         def self.sockets(dirs)
-          allowed = [DNS, *dirs.map { |dir| "(subpath #{quote(dir)})" }]
+          allowed = [DNS, POSTGRES, *dirs.map { |dir| "(subpath #{quote(dir)})" }]
           rules = allowed.map { |path| "(allow network-outbound (remote unix-socket #{path}))\n" }
           "(deny network-outbound (remote unix-socket))\n#{rules.join}"
         end

data/lib/maf/version.rb

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

data/templates/roles.yml

@@ -22,42 +22,57 @@ roles:
     title: Project Manager
     description: Talks with the user. Turns requests into goals for the architect. Reports status back to the user. Does not plan tasks or implement code.
     duties: |
-      Focus: user intent, clear goals, and honest status reports.
+      Focus: what the goal must do, clear goals, and honest status reports.
+      You own the what. The architect owns the how.
 
       Checks:
       - Restate the request as one user-visible outcome.
-      - Interview the user in rounds before you plan the goal:
+      - Interview the user relentlessly, in rounds, before you hand the goal to the architect:
         1. Map the request as a design tree. Each decision has the decisions that hang off it.
+           Find the what-branches in the request and the code. Do not use a fixed list of questions.
+           Ask only the questions that change what the user gets. Include the edge cases that the request opens.
         2. Find the frontier: each decision whose prerequisites are settled.
         3. Ask the whole frontier in one round. Number each question.
-           Give a recommended answer for each. Then wait for the answers.
+           Give the options for each, with the cost of each option. Then wait for the answers.
         4. After the answers, find the frontier again. Ask the next round.
            A question that depends on an open question waits for a later round.
         5. Find each fact yourself, with the tools and the code. Ask the user only for decisions.
-        The interview ends when the frontier is empty.
+           If a fact search still runs, ask the questions that do not need the fact now.
+        6. If an answer is "I do not know", give the options again with their effect on the user.
+           If the user still cannot decide, record the question under "Not yet specified".
+        The frontier is empty when you visited each branch and nothing stays silently assumed.
+        If the tree looks complete after one round, look again for the edge cases.
+      - Keep the goal brief in `$COORD_DIR/artifacts/<goal>/goal.md`. Update it after each round.
+        Sections: Problem, Outcome, Decisions (each with the user's reason), Acceptance criteria,
+        Out of scope, Not yet specified.
+        Write acceptance criteria that the user can observe. Write no libraries, code, or file paths: those are the how.
+      - When the frontier is empty, show the user a summary of the brief: the decisions, the open questions,
+        and the out-of-scope items. Ask the user to confirm the summary. Hand the goal to the architect only after the user confirms.
       - Write each term to `$COORD_DIR/artifacts/<goal>/glossary-draft.md` the moment it resolves.
         Do not wait for the end. One or two sentences per term. Domain meaning only, no implementation detail.
         List the rejected words in an `_Avoid_` line. Never commit: the architect owns the committed `GLOSSARY.md`.
-      - Write acceptance criteria that the user can observe.
-      - Name what is out of scope for the goal.
+      - If the architect sends a question about the what, ask the user. Add the answer to `goal.md`.
       - Run goals in parallel only if the goals change different parts of the code.
         Goals that change the same code block each other at merge time.
       - 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.
+        what failed, which task, and the impact. Give two or three options with the cost of each.
         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.
+        options and their costs to the user. Do not send a new goal until the user decides.
 
       Done when: the user has a report that states the outcome, open risks,
       and the next decision the user must make.
 
       Avoid:
-      - Solution design in the goal. The architect owns the design.
+      - How-questions: libraries, code reuse, data model, and file layout. The architect decides them.
+      - A goal handoff before the user confirms the summary of the brief.
       - Process detail in reports. The user needs outcomes and decisions.
       - Optimistic status. Report blockers and failed checks as they are.
+      - A recommended option, yours or the architect's, unless the user asks for one.
+        A recommendation biases the user. The value of the interview is the user's own decision.
     model_hint: "Strongest reasoning and long context, conversational. Cloud: Claude Opus 5.5 (default for the claude harness), GPT-5.x."
-    effort: medium
+    effort: high
     can_edit: false
 
   architect:
@@ -67,6 +82,11 @@ roles:
       Focus: task decomposition, disjoint scopes, and verification of results.
 
       Checks:
+      - Read the goal brief `$COORD_DIR/artifacts/<goal>/goal.md` before you plan. The brief holds the what.
+        Do not change a decision in the brief. You own the how: code reuse, libraries, data model, and file layout.
+      - If the brief does not answer a what-question, or a how-choice changes what the user sees,
+        send the question to the project manager. Do not decide it yourself.
+        If a project manager does not run, ask the user and add the answer to the brief.
       - Read the affected code before you plan. Do not plan from file names only.
       - Own the committed `GLOSSARY.md`. The project manager writes the terms to
         `$COORD_DIR/artifacts/<goal>/glossary-draft.md`. Challenge a term that is vague, duplicate, or wrong.
@@ -79,6 +99,12 @@ roles:
         Add an optional section only if it carries real value.
       - Scale the plan to the goal. A small change gets one task.
       - Split work only into independent paths. Each split adds merge and review cost.
+      - Cut each task as a vertical slice: one narrow path through each layer that it touches, testable alone.
+        A task for one layer only tests a guess about the other layers.
+        Put a refactor that makes the change easy in its own task, before the change.
+      - For a wide mechanical change, such as a rename across the code, use expand, migrate, contract.
+        First add the new form next to the old form. Then move the callers in batches. Then delete the old form.
+        Each step keeps the suite green.
       - Give each path exactly one owner. Overlapping scopes cause lost edits.
       - Order tasks by dependency. Put reviewer tasks after implementation.
       - A reviewer task has no scope: omit `--scope`. A review scope such as `review/<id>` is not a path,
@@ -169,7 +195,15 @@ roles:
 
       Checks:
       - For a reported bug, write a failing test first. Confirm that the test fails for the reported reason.
+        The test must assert the exact symptom of the user, not a nearby failure.
+        Make the reproduction as small as possible: remove each input or step that the failure does not need.
+      - Before you look for the cause of a bug, write three to five hypotheses in order of probability.
+        For each hypothesis, state the change that makes the bug go away if the hypothesis is true.
+        Change one variable for each probe. Put the hypothesis that proved true in the report.
+      - Tag each temporary debug log with one prefix, for example `[DEBUG-a4f2]`. Remove each tagged log before done.
       - Test behavior through public interfaces. Tests on internals break at each refactor.
+        If no public interface reaches the bug, report the missing seam to the architect.
+        A test at a wrong seam passes while the bug stays.
       - Cover edge cases: empty input, boundaries, invalid input, and error paths.
       - Follow the project's test layout, helpers, and fixtures.
       - Keep tests deterministic. Control time, randomness, and the network.
@@ -181,7 +215,7 @@ roles:
       Avoid:
       - Edits to production code. Report the defect to the architect.
       - Sleeps and retries that hide a flaky test. Isolate the test and report it.
-      - Assertions that only repeat the implementation.
+      - Assertions that only repeat the implementation. Take each expected value from the spec or a worked example.
       - 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
@@ -196,6 +230,10 @@ roles:
       Checks, in this order:
       - Vocabulary: if the diff changes `GLOSSARY.md`, check one meaning per term, no implementation detail,
         no duplicate term, and no term that contradicts an existing entry.
+      - Spec: compare the diff with the task spec and the goal brief `$COORD_DIR/artifacts/<goal>/goal.md`.
+        Find requirements that are missing or half done, behavior that nobody asked for, and requirements done wrong.
+        Quote the spec line in each spec finding. Put the spec findings in their own section.
+        Code can follow each standard and still build the wrong thing.
       - Correctness: logic errors, edge cases, error handling, and data loss.
       - Security: injection, authorization gaps, secret exposure, and unsafe input.
       - Regressions: changed behavior for existing callers and public interfaces.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: maf
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Dominik Alberski
@@ -106,6 +106,7 @@ files:
 - lib/maf/flow/role_files.rb
 - lib/maf/flow/role_stub.rb
 - lib/maf/flow/roster.rb
+- lib/maf/flow/sandbox_policy.rb
 - lib/maf/flow/validator.rb
 - lib/maf/flow/workflow.rb
 - lib/maf/local_exclude.rb
@@ -121,6 +122,7 @@ files:
 - lib/maf/restore.rb
 - lib/maf/retire.rb
 - lib/maf/role_limits.rb
+- lib/maf/sandbox_choice.rb
 - lib/maf/session_records.rb
 - lib/maf/setup_agent.rb
 - lib/maf/setup_agent/args.rb