From 0140ff1c79dddba9a4dc7735b25e716fe18f0a85 Mon Sep 17 00:00:00 2001
From: Subrahmanya Pavankumar Dubagunta <sdubagun@amd.com>
Date: Thu, 4 Jun 2026 16:17:00 +0000
Subject: [PATCH 1/4] fix(preprocess_v3): synthesize single-metric harness for
 flag-less/composite Path-A tasks (#258)

A flag-less Path-A test command (no GEAK mode flag) was copied byte-identically
into all four COMMANDMENT modes, silently. The correctness preflight then ran the
harness's full default sweep until it timed out, producing 0% kernel gain.

Two cooperating defects: the orchestrator prompt trained the LLM to mark all four
modes covered, and _substitute_mode_flag silently no-ops on a flag-less command, so
the renderer loop emitted no warning.

Fix:
- tools.py: add a deterministic flag-less backstop in
  commandment_from_user_command. When the command exposes no mode flag, is not a
  compound && shell contract, and yields no harness, refuse to render the
  all-modes-identical COMMANDMENT and return ok:False / PATH_A_FLAG_MISSING. This
  guard is independent of the modes_covered the LLM passes.
- orchestrator.py: split Case A into A1 (flag-aware -> today's happy path) and A2
  (flag-less/composite -> route into harness synthesis). A2 routes on whether the
  prompt carries shapes: with shapes, skip discovery and dispatch harness-generator
  with prompt shapes only; without shapes, fall through to discovery as Case C. Wire
  the PATH_A_FLAG_MISSING -> switch-to-A2 recovery and remove the all-four
  modes_covered example from the generic Case A default.
- tests: cover the deterministic backstop (no silent duplicates even with all four
  modes covered) and the A1 happy path (detector does not mis-fire).

Validated against the real k006 prompt on an AMD gfx942 GPU: the preprocessor now
emits four distinct modes backed by a synthesized single-shape (983040x128 bf16),
single-metric harness; correctness passes in ~66s instead of timing out at 600s.

Co-Authored-By: Claude Opus 4 <noreply@anthropic.com>
---
 .../run/preprocess_v3/orchestrator.py         | 22 ++++++--
 src/minisweagent/run/preprocess_v3/tools.py   | 31 +++++++++++
 tests/run/test_preprocess_v3_bugfixes.py      | 55 +++++++++++++++++++
 3 files changed, 104 insertions(+), 4 deletions(-)

diff --git a/src/minisweagent/run/preprocess_v3/orchestrator.py b/src/minisweagent/run/preprocess_v3/orchestrator.py
index 7abe40825..3eb3ad4e4 100644
--- a/src/minisweagent/run/preprocess_v3/orchestrator.py
+++ b/src/minisweagent/run/preprocess_v3/orchestrator.py
@@ -117,13 +117,20 @@ class LimitsExceeded(TerminatingException):
 **Case A — user provided explicit run instructions / commands.**
 Indicators: a literal command-line invocation (``python <script>``, ``pytest ... -k ...``, ``make ...``, shell script, existing custom harness command). The command is opaque: it may NOT support GEAK's four harness flags.
 
-Action: **skip ``run_discovery``** — the user already told you what to run, so test discovery is unnecessary and wastes time. Go directly to ``commandment_from_user_command`` with the extracted user command. Do not generate a harness.
+Split Case A on whether the command already speaks GEAK's harness contract:
+
+- **A1 — flag-aware command.** The command text literally contains one of ``--correctness`` / ``--benchmark`` / ``--full-benchmark`` / ``--profile`` (or the "Hints from the call site" section marks the harness **pre-validated** for the four standard modes). Follow the A1 action below.
+- **A2 — flag-less or composite command.** Otherwise (a plain ``python test.py`` / ``make ...`` with no GEAK flag, or a request to cover several op/shape/quant facets of one kernel). Follow the A2 action below.
+
+You do not have to classify A1 vs A2 perfectly: ``commandment_from_user_command`` has a deterministic backstop that refuses a flag-less command and returns ``ok: False`` with ``PATH_A_FLAG_MISSING`` — see the recovery rule under A2.
+
+**A1 action — flag-aware command.** **skip ``run_discovery``** — the user already told you what to run, so test discovery is unnecessary and wastes time. Go directly to ``commandment_from_user_command`` with the extracted user command. Do not generate a harness.
 
 **STRICT keyword-argument names for ``commandment_from_user_command``** (do NOT use synonyms — the tool will TypeError):
 
 ```
 commandment_from_user_command(
-    run_command="<user's verbatim shell command>",      # NOT command/cmd/user_command/raw_command/harness_command
+    run_command="<user's verbatim shell command, which already contains a GEAK mode flag>",  # NOT command/cmd/user_command/raw_command/harness_command
     out_path="<output_dir>/COMMANDMENT.md",             # NOT output/output_path/path/commandment_path
     modes_covered=["correctness","profile","benchmark","full_benchmark"],
     inferred_modes=[],
@@ -131,9 +138,16 @@ class LimitsExceeded(TerminatingException):
 )
 ```
 
-**Important exception**: if the "Hints from the call site" section says the harness is **pre-validated** and supports the four standard modes (``--correctness``, ``--benchmark``, ``--full-benchmark``, ``--profile``), you MUST list all four modes in ``modes_covered`` when calling ``commandment_from_user_command``. The tool will substitute the correct flag for each COMMANDMENT section automatically. Do NOT put all modes in ``inferred_modes`` — use ``modes_covered``.
+Listing all four in ``modes_covered`` is correct **only for A1** (the command/harness already supports the four flags, so the tool substitutes the right flag per section). Do NOT use this all-four call for a flag-less command — that is the A2 path.
+
+**A2 action — flag-less or composite command.** Do **NOT** call ``commandment_from_user_command`` with a flag-less command. Instead route on whether the **task prompt carries shapes** (a ``Shapes:`` line, explicit dims, or a dtype/quant tuple):
+
+- **A2-with-shapes:** **skip ``run_discovery``** (the prompt already gives the authoritative shapes) and dispatch ``harness-generator`` (then ``harness-verifier``, then ``render_commandment``) with the **prompt shapes ONLY**, mapped to the harness's CLI params (e.g. for the rmsnorm harness, weight ``(n,)`` → ``-n``, activation ``(m,n)`` → ``-m``, dtype → ``-d``, op → ``--mode``). The generated harness must use ONLY the prompt-provided shapes (same authoritative-override contract as Case B). A composite task (several facets of one source kernel) produces **one** harness that internally iterates all facets and emits **one** aggregate metric.
+- **A2-no-shapes:** the command is flag-less AND the prompt names no shapes/dims. Do **NOT** dispatch ``harness-generator`` blind — with neither flags nor shapes it would fall back to the harness's full default sweep (the timeout that motivated this rule). Instead fall through to ``run_discovery`` and proceed exactly as **Case C** (discovery's ATD is authoritative for source/shapes). Record the user's flag-less command in ``notes`` for audit; it is not executed as the eval contract.
+
+**A2 recovery (do not omit):** if you do call ``commandment_from_user_command`` and it returns ``ok: False`` / ``PATH_A_FLAG_MISSING``, the command was flag-less. **Switch to the A2 action** (route on shapes as above). Do NOT retry ``commandment_from_user_command`` with the same command — it will return ``ok: False`` again.
 
-**After ``commandment_from_user_command`` succeeds**, you **MUST** call ``collect_baseline`` before calling ``finish_preprocess``. Baseline is **required** for downstream verified-speedup evaluation:
+**After ``commandment_from_user_command`` succeeds (A1)**, you **MUST** call ``collect_baseline`` before calling ``finish_preprocess``. Baseline is **required** for downstream verified-speedup evaluation:
 
 - If the return value includes a ``harness_path``, call ``collect_baseline(harness_path=<path>)`` and ``collect_profile(harness_path=<path>)``.
 - If ``harness_path`` is null/absent, call ``collect_baseline(eval_command="<eval_command from the return value>")`` — use the ``eval_command`` field from ``commandment_from_user_command``'s return value (NOT the original ``run_command`` you passed in, because the tool sanitizes the command to add GEAK metric markers). This runs the eval command directly and parses ``GEAK_METRIC`` / ``GEAK_RESULT_LATENCY_MS`` markers from stdout.
diff --git a/src/minisweagent/run/preprocess_v3/tools.py b/src/minisweagent/run/preprocess_v3/tools.py
index 6505dd123..26431fefd 100644
--- a/src/minisweagent/run/preprocess_v3/tools.py
+++ b/src/minisweagent/run/preprocess_v3/tools.py
@@ -124,6 +124,11 @@ def _substitute_mode_flag(cmd: str, target_mode: str) -> str:
     for other_mode, other_flag in _MODE_TO_FLAG.items():
         if other_mode != target_mode and other_flag in cmd:
             return cmd.replace(other_flag, dst_flag)
+    # Case 3: no known flag at all -> returned unchanged. This silent no-op is a
+    # latent trap for a flag-less command (every mode collapses to one body); the
+    # only caller that matters for #258, ``_make_tool_commandment_from_user_command``,
+    # neutralizes it with the deterministic ``is_flagless`` backstop before this
+    # matters. Do not rely on this helper to signal a missing flag.
     return cmd
 
 
@@ -1487,6 +1492,32 @@ def _impl(
             original_harness_path = None
         if original_harness_path:
             agent._collected["harness_path"] = original_harness_path
+
+        # Deterministic backstop for the flag-less Path-A case (issue #258).
+        # A command that (a) exposes none of GEAK's four harness flags, (b) is
+        # not a compound ``&&`` shell contract, and (c) yielded no usable
+        # harness_path carries no per-mode contract: every COMMANDMENT section
+        # would receive the SAME command (``_substitute_mode_flag`` no-ops on a
+        # flag-less command, see its case 3), and the correctness preflight would
+        # then run the harness's full default sweep until it times out. Refuse to
+        # render that all-modes-identical artifact and signal the orchestrator to
+        # switch to harness synthesis (Case A2). This guard is independent of the
+        # ``modes_covered`` the LLM passed, so it cannot be defeated by the LLM
+        # listing all four modes as covered.
+        is_flagless = _extract_harness_from_command(cmd) is None and "&&" not in cmd and original_harness_path is None
+        if is_flagless:
+            return {
+                "ok": False,
+                "error": "PATH_A_FLAG_MISSING",
+                "warnings": [
+                    "PATH_A_FLAG_MISSING: flag-less command exposes none of "
+                    "--correctness/--benchmark/--full-benchmark/--profile and has no "
+                    "harness; dispatch harness-generator (Case A2) instead of copying "
+                    "the command into all four modes. Do NOT retry "
+                    "commandment_from_user_command with the same command."
+                ],
+            }
+
         # Preserve the sanitized command (with real paths) for
         # collect_baseline before we replace repo_root with ${GEAK_WORK_DIR}.
         eval_command_for_baseline = cmd
diff --git a/tests/run/test_preprocess_v3_bugfixes.py b/tests/run/test_preprocess_v3_bugfixes.py
index 8472d1ad9..2eb52aa7f 100644
--- a/tests/run/test_preprocess_v3_bugfixes.py
+++ b/tests/run/test_preprocess_v3_bugfixes.py
@@ -87,6 +87,61 @@ def test_path_a_commandment_runs_user_command_through_run_sh(tmp_path: Path) ->
     assert "${GEAK_WORK_DIR}/scripts/task_runner.py" in text
 
 
+def test_path_a_flagless_command_does_not_render_silent_duplicates(tmp_path: Path) -> None:
+    """Issue #258: a flag-less Path-A command must NOT render an all-modes-identical
+    COMMANDMENT, even when the LLM marks all four modes covered. The deterministic
+    backstop refuses and signals PATH_A_FLAG_MISSING instead."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    out_path = tmp_path / "COMMANDMENT.md"
+    agent = PreprocessOrchestratorAgent(
+        model=object(),
+        config=PreprocessOrchestratorConfig(repo=repo),
+    )
+
+    tool = _make_tool_commandment_from_user_command(agent)
+    result = tool(
+        run_command="timeout 600 python op_tests/test_rmsnorm2dFusedAddQuant.py",
+        out_path=str(out_path),
+        # Even with all four marked covered, the backstop must still fire.
+        modes_covered=["correctness", "profile", "benchmark", "full_benchmark"],
+        inferred_modes=[],
+    )
+
+    assert result["ok"] is False
+    assert result["error"] == "PATH_A_FLAG_MISSING"
+    assert any("PATH_A_FLAG_MISSING" in w for w in result["warnings"])
+    # No runnable COMMANDMENT may be written for the flag-less case.
+    assert not out_path.exists()
+
+
+def test_path_a_flag_aware_command_still_renders_four_modes(tmp_path: Path) -> None:
+    """A1 happy path: a command that already carries a GEAK mode flag still renders
+    four distinct mode sections. Confirms the is_flagless detector does NOT mis-fire."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    out_path = tmp_path / "COMMANDMENT.md"
+    agent = PreprocessOrchestratorAgent(
+        model=object(),
+        config=PreprocessOrchestratorConfig(repo=repo),
+    )
+
+    tool = _make_tool_commandment_from_user_command(agent)
+    result = tool(
+        run_command="python kernel_bench.py --benchmark",
+        out_path=str(out_path),
+        modes_covered=["correctness", "profile", "benchmark", "full_benchmark"],
+        inferred_modes=[],
+    )
+
+    assert result["ok"] is True
+    text = out_path.read_text()
+    # Each section carries its own real flag (substituted from --benchmark).
+    assert "--correctness" in text
+    assert "--full-benchmark" in text
+    assert "--profile" in text
+
+
 def test_dispatch_subagent_uses_sandbox_worktree_env(tmp_path: Path) -> None:
     repo = tmp_path / "repo"
     repo.mkdir()

From 303dc2d80f1ad80222072b59e8253f5819ed0264 Mon Sep 17 00:00:00 2001
From: Subrahmanya Pavankumar Dubagunta <sdubagun@amd.com>
Date: Thu, 4 Jun 2026 19:46:11 +0000
Subject: [PATCH 2/4] fix(preprocess_v3): refuse amalgamation && commands and
 route shape-bearing tasks to harness generator (#258 follow-up)

Two broken Path-A cases remained after the flag-less backstop (PR #264):

1. Amalgamation && (a non-build command chaining two tests, e.g. the same
   script run twice with different settings) was split blindly
   left=correctness / right=performance by _try_synthesize_shell_contract_harness,
   silently dropping one latency number. Crucially, a *flag-bearing* amalgamation
   also escaped the flag-less backstop: _extract_harness_from_command returns a
   path for it, so original_harness_path was set and the backstop's
   `original_harness_path is None` guard never fired.

2. A command that carries a mode flag (or a build-bearing &&) but whose prompt
   lists shapes the command does not pin was classified A1 and run as-is,
   ignoring the shapes and triggering the harness's full default sweep -> timeout.

Fix:
- tools.py: add _is_amalgamation_command (gated on infer_compile_command_from_eval
  so the keep/refuse decision stays consistent with the compile prefix the split
  path re-prepends; ImportError -> treat as amalgamation, the safe route). Refuse
  amalgamations in commandment_from_user_command BEFORE harness extraction so the
  guard is flag-independent and catches the flag-bearing case. Skip synthesis for
  non-build && in _try_synthesize_shell_contract_harness, with comments on the
  hard-coded correctness/performance ordering and the delegation of all non-build
  && to the generator.
- orchestrator.py: add a shapes pre-check ahead of the A1/A2 split so a flag-aware
  command whose prompt carries unpinned shapes routes to A2-with-shapes (the
  deterministic tool is shape-blind and cannot refuse on shape grounds). Bias to
  A2 when uncertain (perf cost vs. silent timeout). Enumerate the single-flag and
  build-bearing-&& shape cases under A2-with-shapes; never inject shapes into the
  command (generator owns shape handling).
- tests: cover flag-less and flag-bearing amalgamation refusal, and a regression
  guard that build-bearing && still synthesizes. Problems #2/#3 are LLM-prose
  routing and not unit-testable; they are covered by manual verification.

Co-Authored-By: Claude Opus 4 <noreply@anthropic.com>
---
 .../run/preprocess_v3/orchestrator.py         | 14 ++--
 src/minisweagent/run/preprocess_v3/tools.py   | 67 +++++++++++++++++
 tests/run/test_preprocess_v3_bugfixes.py      | 75 +++++++++++++++++++
 3 files changed, 150 insertions(+), 6 deletions(-)

diff --git a/src/minisweagent/run/preprocess_v3/orchestrator.py b/src/minisweagent/run/preprocess_v3/orchestrator.py
index 3eb3ad4e4..0db47256f 100644
--- a/src/minisweagent/run/preprocess_v3/orchestrator.py
+++ b/src/minisweagent/run/preprocess_v3/orchestrator.py
@@ -117,14 +117,16 @@ class LimitsExceeded(TerminatingException):
 **Case A — user provided explicit run instructions / commands.**
 Indicators: a literal command-line invocation (``python <script>``, ``pytest ... -k ...``, ``make ...``, shell script, existing custom harness command). The command is opaque: it may NOT support GEAK's four harness flags.
 
-Split Case A on whether the command already speaks GEAK's harness contract:
+**Shapes pre-check (decide this FIRST, before A1 vs A2).** If the task prompt carries shapes (a ``Shapes:`` line, explicit dims, or a dtype/quant tuple) **and** the user's command does not already pin those exact shapes (e.g. it has no matching ``-m/-n``/dim arguments), route to **A2-with-shapes** — *regardless of whether the command contains a GEAK mode flag*. A flag-aware command whose shapes are not pinned would otherwise be classified A1 and run the harness's full default sweep, ignoring the prompt shapes, until it times out. When you are **unsure** whether the command already pins the prompt's exact shapes, choose A2-with-shapes: needlessly sending a shape-pinning command to the generator only costs time / a possible regeneration (a perf cost), whereas wrongly keeping it in A1 silently drops the shapes and hits the default-sweep timeout (a correctness bug). Decide the shapes question BEFORE deciding the command is directly runnable.
 
-- **A1 — flag-aware command.** The command text literally contains one of ``--correctness`` / ``--benchmark`` / ``--full-benchmark`` / ``--profile`` (or the "Hints from the call site" section marks the harness **pre-validated** for the four standard modes). Follow the A1 action below.
-- **A2 — flag-less or composite command.** Otherwise (a plain ``python test.py`` / ``make ...`` with no GEAK flag, or a request to cover several op/shape/quant facets of one kernel). Follow the A2 action below.
+Split the remaining Case A (no unpinned prompt shapes) on whether the command already speaks GEAK's harness contract:
+
+- **A1 — flag-aware command.** The command text literally contains one of ``--correctness`` / ``--benchmark`` / ``--full-benchmark`` / ``--profile`` (or the "Hints from the call site" section marks the harness **pre-validated** for the four standard modes), **and** the shapes pre-check above did not divert it to A2. Follow the A1 action below.
+- **A2 — flag-less or composite command.** Otherwise (a plain ``python test.py`` / ``make ...`` with no GEAK flag, a request to cover several op/shape/quant facets of one kernel, or any command diverted by the shapes pre-check). Follow the A2 action below.
 
 You do not have to classify A1 vs A2 perfectly: ``commandment_from_user_command`` has a deterministic backstop that refuses a flag-less command and returns ``ok: False`` with ``PATH_A_FLAG_MISSING`` — see the recovery rule under A2.
 
-**A1 action — flag-aware command.** **skip ``run_discovery``** — the user already told you what to run, so test discovery is unnecessary and wastes time. Go directly to ``commandment_from_user_command`` with the extracted user command. Do not generate a harness.
+**A1 action — flag-aware command.** **skip ``run_discovery``** — the user already told you what to run, so test discovery is unnecessary and wastes time. Go directly to ``commandment_from_user_command`` with the extracted user command. Do not generate a harness. (Reminder: this applies only when the shapes pre-check did **not** divert the command — a flag-aware command whose prompt carries shapes the command does not already pin is the A2-with-shapes path, not A1.)
 
 **STRICT keyword-argument names for ``commandment_from_user_command``** (do NOT use synonyms — the tool will TypeError):
 
@@ -142,10 +144,10 @@ class LimitsExceeded(TerminatingException):
 
 **A2 action — flag-less or composite command.** Do **NOT** call ``commandment_from_user_command`` with a flag-less command. Instead route on whether the **task prompt carries shapes** (a ``Shapes:`` line, explicit dims, or a dtype/quant tuple):
 
-- **A2-with-shapes:** **skip ``run_discovery``** (the prompt already gives the authoritative shapes) and dispatch ``harness-generator`` (then ``harness-verifier``, then ``render_commandment``) with the **prompt shapes ONLY**, mapped to the harness's CLI params (e.g. for the rmsnorm harness, weight ``(n,)`` → ``-n``, activation ``(m,n)`` → ``-m``, dtype → ``-d``, op → ``--mode``). The generated harness must use ONLY the prompt-provided shapes (same authoritative-override contract as Case B). A composite task (several facets of one source kernel) produces **one** harness that internally iterates all facets and emits **one** aggregate metric.
+- **A2-with-shapes:** **skip ``run_discovery``** (the prompt already gives the authoritative shapes) and dispatch ``harness-generator`` (then ``harness-verifier``, then ``render_commandment``) with the **prompt shapes ONLY**, mapped to the harness's CLI params (e.g. for the rmsnorm harness, weight ``(n,)`` → ``-n``, activation ``(m,n)`` → ``-m``, dtype → ``-d``, op → ``--mode``). The generated harness must use ONLY the prompt-provided shapes (same authoritative-override contract as Case B). A composite task (several facets of one source kernel) produces **one** harness that internally iterates all facets and emits **one** aggregate metric. This bullet covers every shape-bearing command the pre-check diverts here, including: (a) a **single-flag** command whose prompt carries shapes it does not pin, and (b) a **build-bearing ``&&``** command whose prompt carries shapes. In all cases do **NOT** inject the shapes into the user's command yourself — the generator owns shape handling (there is no single way to add shapes; some harnesses take ``-m/-n`` flags, others need the shapes edited inside the file). A build-bearing ``&&`` command with **no** prompt shapes is not diverted and keeps the deterministic compile + correctness + performance route via ``commandment_from_user_command``.
 - **A2-no-shapes:** the command is flag-less AND the prompt names no shapes/dims. Do **NOT** dispatch ``harness-generator`` blind — with neither flags nor shapes it would fall back to the harness's full default sweep (the timeout that motivated this rule). Instead fall through to ``run_discovery`` and proceed exactly as **Case C** (discovery's ATD is authoritative for source/shapes). Record the user's flag-less command in ``notes`` for audit; it is not executed as the eval contract.
 
-**A2 recovery (do not omit):** if you do call ``commandment_from_user_command`` and it returns ``ok: False`` / ``PATH_A_FLAG_MISSING``, the command was flag-less. **Switch to the A2 action** (route on shapes as above). Do NOT retry ``commandment_from_user_command`` with the same command — it will return ``ok: False`` again.
+**A2 recovery (do not omit):** if you do call ``commandment_from_user_command`` and it returns ``ok: False`` / ``PATH_A_FLAG_MISSING``, the command was either flag-less or a non-build ``&&`` amalgamation. **Switch to the A2 action** (route on shapes as above). Do NOT retry ``commandment_from_user_command`` with the same command — it will return ``ok: False`` again.
 
 **After ``commandment_from_user_command`` succeeds (A1)**, you **MUST** call ``collect_baseline`` before calling ``finish_preprocess``. Baseline is **required** for downstream verified-speedup evaluation:
 
diff --git a/src/minisweagent/run/preprocess_v3/tools.py b/src/minisweagent/run/preprocess_v3/tools.py
index 26431fefd..a3a63da0c 100644
--- a/src/minisweagent/run/preprocess_v3/tools.py
+++ b/src/minisweagent/run/preprocess_v3/tools.py
@@ -186,6 +186,39 @@ def _extract_harness_from_command(cmd: str) -> str | None:
     return None
 
 
+def _is_amalgamation_command(cmd: str) -> bool:
+    """True when *cmd* chains segments with ``&&`` but has no confident leading
+    compile/build prefix — i.e. a joint/amalgamation command (the same script run
+    twice with different settings, or two different tests chained).
+
+    Such a command must be resolved into a single latency value by the harness
+    generator, NOT split blindly by :func:`_try_synthesize_shell_contract_harness`
+    (whose ``rsplit("&&", 1)`` treats left=correctness / right=performance and
+    would silently drop one metric). We gate on ``infer_compile_command_from_eval``
+    rather than a raw build-token substring scan so the keep-vs-refuse decision
+    stays consistent with the compile-prefix the split path actually re-prepends,
+    and to avoid whole-string false positives. This *reduces, not eliminates*,
+    false positives: a build substring living only inside a flag value of the
+    first segment (e.g. ``--mode compile_fwd``) still reads as a compile prefix and
+    is treated as build-bearing.
+
+    Flag-independent by design: it must catch flag-bearing amalgamations too, since
+    those would otherwise yield a harness path via ``_extract_harness_from_command``
+    and slip past the flag-less backstop in ``commandment_from_user_command``.
+    """
+    if "&&" not in cmd:
+        return False
+    try:
+        from minisweagent.run.preprocess.contract_normalize import (
+            infer_compile_command_from_eval,
+        )
+    except ImportError:
+        # Cannot determine a compile prefix -> treat as amalgamation and route to
+        # the harness generator (A2), the safe path, rather than risk a blind split.
+        return True
+    return infer_compile_command_from_eval(cmd) is None
+
+
 def _try_synthesize_shell_contract_harness(
     cmd: str,
     *,
@@ -221,6 +254,18 @@ def _try_synthesize_shell_contract_harness(
         return None
     if not repo_root_str:
         return None
+    # Only synthesize for a genuine build-bearing command. A non-build `&&` is an
+    # amalgamation (same script twice with different settings, or two different
+    # tests chained); its resolution is delegated to the harness generator (A2) —
+    # the deterministic split below is intentionally NOT used for it. We do not
+    # distinguish same-script-twice from different-scripts here: the generator
+    # handles both, so neither is a "limitation" of this path.
+    if _is_amalgamation_command(cmd):
+        return None
+    # The split below hard-codes left=correctness / right=performance ordering;
+    # this is an intentional assumption that holds for the canonical
+    # "compile && correctness && performance" pattern but degrades for 3+ mixed
+    # segments (e.g. "make && python a && python b"). Kept deliberately simple.
     # Only split when the command has multiple meaningful segments, not
     # when && is just directory navigation (e.g. "cd /dir && bash script.sh").
     # A cd-only left half is not a correctness command.
@@ -1467,6 +1512,28 @@ def _impl(
                 agent.model,
             )
 
+        # Deterministic amalgamation backstop (must run BEFORE harness extraction).
+        # A non-build ``&&`` command is a joint/amalgamation instruction (same
+        # script run twice with different settings, or two different tests chained).
+        # Splitting it left=correctness / right=performance silently drops one
+        # latency number. This guard is flag-INDEPENDENT on purpose: a flag-bearing
+        # amalgamation (e.g. "python t.py --benchmark --a && python t.py --benchmark
+        # --b") would otherwise yield a harness_path via
+        # ``_extract_harness_from_command`` and slip past the flag-less backstop
+        # below, running only the first half. Refuse here and route to A2.
+        if _is_amalgamation_command(cmd):
+            return {
+                "ok": False,
+                "error": "PATH_A_FLAG_MISSING",
+                "warnings": [
+                    "PATH_A_FLAG_MISSING: command chains segments with '&&' but has "
+                    "no build/compile prefix (amalgamation); a deterministic split "
+                    "would drop one metric. Dispatch harness-generator (Case A2) to "
+                    "resolve it into a single test emitting one metric. Do NOT retry "
+                    "commandment_from_user_command with the same command."
+                ],
+            }
+
         # Extract the harness path from the (possibly sanitized) command
         # so collect_baseline/collect_profile can use the real filesystem path.
         original_harness_path = _extract_harness_from_command(cmd)
diff --git a/tests/run/test_preprocess_v3_bugfixes.py b/tests/run/test_preprocess_v3_bugfixes.py
index 2eb52aa7f..ca3586699 100644
--- a/tests/run/test_preprocess_v3_bugfixes.py
+++ b/tests/run/test_preprocess_v3_bugfixes.py
@@ -142,6 +142,81 @@ def test_path_a_flag_aware_command_still_renders_four_modes(tmp_path: Path) -> N
     assert "--profile" in text
 
 
+def test_path_a_flagless_amalgamation_is_refused(tmp_path: Path) -> None:
+    """A non-build ``&&`` amalgamation (same script run twice with different
+    settings, no build step) must be refused with PATH_A_FLAG_MISSING rather than
+    blindly split left=correctness / right=performance (which drops one metric)."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    out_path = tmp_path / "COMMANDMENT.md"
+    agent = PreprocessOrchestratorAgent(
+        model=object(),
+        config=PreprocessOrchestratorConfig(repo=repo),
+    )
+
+    tool = _make_tool_commandment_from_user_command(agent)
+    result = tool(
+        run_command="python test.py --opt-a && python test.py --opt-b",
+        out_path=str(out_path),
+        modes_covered=["correctness", "benchmark"],
+        inferred_modes=[],
+    )
+
+    assert result["ok"] is False
+    assert result["error"] == "PATH_A_FLAG_MISSING"
+    assert not out_path.exists()
+
+
+def test_path_a_flag_bearing_amalgamation_is_refused(tmp_path: Path) -> None:
+    """R2-1: a *flag-bearing* amalgamation would yield a harness path via
+    _extract_harness_from_command and slip past the flag-less backstop, running
+    only the first half. The flag-independent amalgamation guard (placed before
+    harness extraction) must still refuse it."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    out_path = tmp_path / "COMMANDMENT.md"
+    agent = PreprocessOrchestratorAgent(
+        model=object(),
+        config=PreprocessOrchestratorConfig(repo=repo),
+    )
+
+    tool = _make_tool_commandment_from_user_command(agent)
+    result = tool(
+        run_command="python test.py --benchmark --opt-a && python test.py --benchmark --opt-b",
+        out_path=str(out_path),
+        modes_covered=["benchmark"],
+        inferred_modes=[],
+    )
+
+    assert result["ok"] is False
+    assert result["error"] == "PATH_A_FLAG_MISSING"
+    assert not out_path.exists()
+
+
+def test_path_a_build_bearing_amalgamation_still_synthesizes(tmp_path: Path) -> None:
+    """A build-bearing ``&&`` (compile + run) is NOT an amalgamation: it has a
+    confident leading compile prefix, so the deterministic split path is preserved
+    and the amalgamation guard does not mis-fire."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    out_path = tmp_path / "COMMANDMENT.md"
+    agent = PreprocessOrchestratorAgent(
+        model=object(),
+        config=PreprocessOrchestratorConfig(repo=repo),
+    )
+
+    tool = _make_tool_commandment_from_user_command(agent)
+    result = tool(
+        run_command="make && python test.py --benchmark",
+        out_path=str(out_path),
+        modes_covered=["benchmark"],
+        inferred_modes=["correctness"],
+    )
+
+    assert result["ok"] is True
+    assert out_path.exists()
+
+
 def test_dispatch_subagent_uses_sandbox_worktree_env(tmp_path: Path) -> None:
     repo = tmp_path / "repo"
     repo.mkdir()

From f4b68fe24ad5b31d58e9b8aadc37dc3b4eba9397 Mon Sep 17 00:00:00 2001
From: Subrahmanya Pavankumar Dubagunta <sdubagun@amd.com>
Date: Thu, 4 Jun 2026 20:20:25 +0000
Subject: [PATCH 3/4] fix(mini): gate CLI test-command && pre-split on a build
 prefix (#258 follow-up)

The previous amalgamation fix lived only in the preprocessor
(commandment_from_user_command), but the CLI intercepts a compound --test-command
first and did its own blind rsplit("&&", 1) into correctness/performance hints
before the preprocessor ran. So an amalgamation passed via --test-command
(the primary entry path) was split one layer up -- left=correctness,
right=performance -- silently dropping one metric, and never reached the
deterministic guard as a single string. Caught by running the real GEAK binary:
the CLI logged "Correctness command: ...--mode 1, Performance command: ...--mode 2".

Fix:
- contract_normalize.py: promote the amalgamation predicate to a shared, public
  is_amalgamation_command (stdlib-only module; no circular import) so the CLI and
  the preprocessor classify a compound command identically.
- tools.py: _is_amalgamation_command becomes a thin wrapper that imports the shared
  predicate, preserving the safe ImportError fallback (treat as amalgamation -> A2).
- mini.py: only pre-split a compound && into correctness/performance hints when it
  is build-bearing (is_amalgamation_command is False). A non-build && now passes
  through whole as eval_command, so the preprocessor's guard fires
  (PATH_A_FLAG_MISSING) and routes it to the harness generator (Case A2).
- tests: unit tests for is_amalgamation_command (no-&&, non-build &&, flag-bearing
  &&, build-bearing && / canonical compile-chain).

Verified end-to-end with the real binary on the k006 prompt: the amalgamation
--test-command no longer triggers the CLI's "Correctness/Performance command"
split; it is passed through whole.

Co-Authored-By: Claude Opus 4 <noreply@anthropic.com>
---
 src/minisweagent/run/mini.py                  | 12 ++++++-
 .../run/preprocess/contract_normalize.py      | 24 ++++++++++++++
 src/minisweagent/run/preprocess_v3/tools.py   | 33 +++++++------------
 tests/run/test_contract_normalize.py          | 32 ++++++++++++++++++
 4 files changed, 78 insertions(+), 23 deletions(-)

diff --git a/src/minisweagent/run/mini.py b/src/minisweagent/run/mini.py
index 836b14711..7ee1862ed 100644
--- a/src/minisweagent/run/mini.py
+++ b/src/minisweagent/run/mini.py
@@ -34,6 +34,7 @@
     apply_mode_presets,
     resolve_max_rounds,
 )
+from minisweagent.run.preprocess.contract_normalize import is_amalgamation_command
 from minisweagent.run.preprocess_v3.adapter import run_preprocess_v3 as run_preprocessor
 from minisweagent.run.state import (
     PreprocessState,
@@ -682,7 +683,16 @@ def _sigint_handler(_signum, _frame):  # noqa: ANN001
                 else:
                     raise
         else:
-            if isinstance(test_command, str) and "&&" in test_command:
+            # Only pre-split a compound ``cmd_a && cmd_b`` into correctness /
+            # performance hints when it is a genuine build-bearing contract
+            # (mirrors the preprocessor's _try_synthesize_shell_contract_harness
+            # split). A non-build ``&&`` is an amalgamation (same script run twice
+            # with different settings, or two different tests chained); splitting it
+            # left=correctness / right=performance silently drops one metric. Pass
+            # it through whole as eval_command so the preprocessor's deterministic
+            # amalgamation guard fires (PATH_A_FLAG_MISSING) and routes it to the
+            # harness generator (Case A2), which resolves it into one metric.
+            if isinstance(test_command, str) and "&&" in test_command and not is_amalgamation_command(test_command):
                 left, right = test_command.rsplit("&&", 1)
                 correctness_command = left.strip() or None
                 performance_command = right.strip() or None
diff --git a/src/minisweagent/run/preprocess/contract_normalize.py b/src/minisweagent/run/preprocess/contract_normalize.py
index 86fe436dd..db094b456 100644
--- a/src/minisweagent/run/preprocess/contract_normalize.py
+++ b/src/minisweagent/run/preprocess/contract_normalize.py
@@ -102,6 +102,30 @@ def infer_compile_command_from_eval(eval_command: str | None) -> str | None:
     return None
 
 
+def is_amalgamation_command(cmd: str) -> bool:
+    """True when *cmd* chains segments with ``&&`` but has no confident leading
+    compile/build prefix — i.e. a joint/amalgamation command (the same script run
+    twice with different settings, or two different tests chained).
+
+    Such a command must be resolved into a single latency value by the harness
+    generator (Case A2), NOT split blindly left=correctness / right=performance
+    (which silently drops one metric). We gate on
+    :func:`infer_compile_command_from_eval` rather than a raw build-token substring
+    scan so the keep-vs-refuse decision stays consistent with the compile-prefix the
+    split paths actually re-prepend, and to avoid whole-string false positives. This
+    *reduces, not eliminates*, false positives: a build substring living only inside
+    a flag value of the first segment (e.g. ``--mode compile_fwd``) still reads as a
+    compile prefix and is treated as build-bearing.
+
+    Shared by the preprocessor (``commandment_from_user_command``) and the CLI
+    entry point (``mini.py``) so a compound ``--test-command`` is classified the
+    same way regardless of which layer sees it first.
+    """
+    if "&&" not in cmd:
+        return False
+    return infer_compile_command_from_eval(cmd) is None
+
+
 def discovery_digest(discovery: dict[str, Any] | None, *, max_chars: int = 6000) -> dict[str, Any]:
     """Return a JSON-serializable, size-capped snapshot for contract.json."""
     if not discovery:
diff --git a/src/minisweagent/run/preprocess_v3/tools.py b/src/minisweagent/run/preprocess_v3/tools.py
index a3a63da0c..90554945a 100644
--- a/src/minisweagent/run/preprocess_v3/tools.py
+++ b/src/minisweagent/run/preprocess_v3/tools.py
@@ -187,36 +187,25 @@ def _extract_harness_from_command(cmd: str) -> str | None:
 
 
 def _is_amalgamation_command(cmd: str) -> bool:
-    """True when *cmd* chains segments with ``&&`` but has no confident leading
-    compile/build prefix — i.e. a joint/amalgamation command (the same script run
-    twice with different settings, or two different tests chained).
-
-    Such a command must be resolved into a single latency value by the harness
-    generator, NOT split blindly by :func:`_try_synthesize_shell_contract_harness`
-    (whose ``rsplit("&&", 1)`` treats left=correctness / right=performance and
-    would silently drop one metric). We gate on ``infer_compile_command_from_eval``
-    rather than a raw build-token substring scan so the keep-vs-refuse decision
-    stays consistent with the compile-prefix the split path actually re-prepends,
-    and to avoid whole-string false positives. This *reduces, not eliminates*,
-    false positives: a build substring living only inside a flag value of the
-    first segment (e.g. ``--mode compile_fwd``) still reads as a compile prefix and
-    is treated as build-bearing.
-
-    Flag-independent by design: it must catch flag-bearing amalgamations too, since
-    those would otherwise yield a harness path via ``_extract_harness_from_command``
-    and slip past the flag-less backstop in ``commandment_from_user_command``.
+    """Thin wrapper over :func:`contract_normalize.is_amalgamation_command`.
+
+    Kept local so this module's call sites read clearly and to preserve the safe
+    ImportError fallback: if the shared module cannot be imported, treat a ``&&``
+    command as an amalgamation and route to the harness generator (A2) rather than
+    risk a blind split. Flag-independent by design — it must catch flag-bearing
+    amalgamations too, since those would otherwise yield a harness path via
+    ``_extract_harness_from_command`` and slip past the flag-less backstop in
+    ``commandment_from_user_command``.
     """
     if "&&" not in cmd:
         return False
     try:
         from minisweagent.run.preprocess.contract_normalize import (
-            infer_compile_command_from_eval,
+            is_amalgamation_command,
         )
     except ImportError:
-        # Cannot determine a compile prefix -> treat as amalgamation and route to
-        # the harness generator (A2), the safe path, rather than risk a blind split.
         return True
-    return infer_compile_command_from_eval(cmd) is None
+    return is_amalgamation_command(cmd)
 
 
 def _try_synthesize_shell_contract_harness(
diff --git a/tests/run/test_contract_normalize.py b/tests/run/test_contract_normalize.py
index a9031b7e0..b15254938 100644
--- a/tests/run/test_contract_normalize.py
+++ b/tests/run/test_contract_normalize.py
@@ -9,6 +9,7 @@
     codebase_context_excerpt,
     discovery_digest,
     infer_compile_command_from_eval,
+    is_amalgamation_command,
 )
 
 
@@ -40,6 +41,37 @@ def test_no_build_token_returns_none(self) -> None:
         assert infer_compile_command_from_eval("pytest -q") is None
 
 
+class TestIsAmalgamationCommand:
+    def test_no_double_amp_is_not_amalgamation(self) -> None:
+        # A single command (flag-less or flag-bearing) is never an amalgamation.
+        assert is_amalgamation_command("python t.py") is False
+        assert is_amalgamation_command("python t.py --benchmark") is False
+
+    def test_non_build_double_amp_is_amalgamation(self) -> None:
+        # Same script run twice with different settings, no build step.
+        assert is_amalgamation_command("python t.py --mode 1 && python t.py --mode 2") is True
+        # Flag-bearing variant must also be caught (it would otherwise yield a
+        # harness path and slip past the flag-less backstop).
+        assert (
+            is_amalgamation_command(
+                "python t.py --benchmark --opt-a && python t.py --benchmark --opt-b"
+            )
+            is True
+        )
+
+    def test_build_bearing_double_amp_is_not_amalgamation(self) -> None:
+        # A genuine compile + run contract has a leading build prefix and may split.
+        assert is_amalgamation_command("make && python t.py --benchmark") is False
+        assert (
+            is_amalgamation_command(
+                "python3 scripts/task_runner.py compile && "
+                "python3 scripts/task_runner.py correctness && "
+                "python3 scripts/task_runner.py performance"
+            )
+            is False
+        )
+
+
 def test_discovery_digest_truncates_large_payload() -> None:
     digest = discovery_digest({"blob": "x" * 100}, max_chars=20)
 

From 3d170c6ec7c65273058743bcc1995df784fc452e Mon Sep 17 00:00:00 2001
From: Subrahmanya Pavankumar Dubagunta <sdubagun@amd.com>
Date: Thu, 4 Jun 2026 20:51:38 +0000
Subject: [PATCH 4/4] fix(preprocess_v3): export GEAK_WORK_DIR for baseline so
 the harness finds the kernel source

End-to-end testing of the A2 (harness-generator) path showed baseline collection
failing silently: every sample logged "produced no latency (rc=0)", no
benchmark_baseline.txt was written, and preprocess aborted at the 900s soft cap
during harness-init. The synthesized harness was correct (runs fine by hand) and
routing was correct; the bug was the baseline subprocess environment.

Root cause: the v3 baseline env builder never exported GEAK_WORK_DIR, and the
collect_baseline tool defaulted work_dir to None:
- baseline._build_env set only PYTHONPATH/HIP_VISIBLE_DEVICES/PYTHONUNBUFFERED,
  dropping the GEAK_WORK_DIR + GEAK_REPO_ROOT exports the legacy
  run_harness._build_env sets.
- collect_baseline's work_dir is an LLM-supplied arg with no default; the subagent
  often omits it, so baseline ran with work_dir=None (no PYTHONPATH, no
  GEAK_WORK_DIR at all).

A contract-compliant harness derives WORK_DIR = os.environ.get("GEAK_WORK_DIR")
or its own dir; with the var unset it fell back to its own directory (which has no
kernel source), ran nothing, and emitted no GEAK_RESULT_LATENCY_MS marker.

Fix:
- baseline.py: _build_env now exports GEAK_WORK_DIR=work_dir and
  setdefault GEAK_REPO_ROOT=work_dir when work_dir is given (mirrors the legacy
  contract; setdefault preserves an adapter-exported source root).
- tools.py: collect_baseline falls back to agent.config.repo (the source repo)
  when the subagent omits work_dir. At preprocess time no per-slot worktree exists
  yet, so the source repo is the correct target; optimization-time runs still pass
  their per-slot worktree explicitly via the legacy run_harness path.
- tools.py: add a comment documenting that compile_command is intentionally unset
  for HIP (the harness self-builds, mtime-keyed) so the absent COMMANDMENT compile
  line isn't mistaken for a bug.
- tests: _build_env exports the keys (and stays a no-op when work_dir is None);
  collect_baseline defaults work_dir to the configured source repo.

Verified via the real synthesized harness run through the fixed _build_env (cold
JIT cache): both facets build and run, and extract_latency_ms returns a value
where it previously returned None.

Co-Authored-By: Claude Opus 4 <noreply@anthropic.com>
---
 .../run/preprocess_v3/baseline.py             |  9 +++
 src/minisweagent/run/preprocess_v3/tools.py   | 19 +++++-
 tests/run/test_preprocess_v3_bugfixes.py      | 63 +++++++++++++++++++
 3 files changed, 90 insertions(+), 1 deletion(-)

diff --git a/src/minisweagent/run/preprocess_v3/baseline.py b/src/minisweagent/run/preprocess_v3/baseline.py
index 0b8ce951d..0acaacec7 100644
--- a/src/minisweagent/run/preprocess_v3/baseline.py
+++ b/src/minisweagent/run/preprocess_v3/baseline.py
@@ -202,6 +202,15 @@ def _build_env(
     if work_dir is not None:
         existing = env.get("PYTHONPATH", "")
         env["PYTHONPATH"] = f"{work_dir}:{existing}" if existing else str(work_dir)
+        # Worktree-awareness contract (mirrors run_harness._build_env): a
+        # contract-compliant harness resolves every repo path from GEAK_WORK_DIR
+        # (e.g. ``os.environ.get("GEAK_WORK_DIR", "<fallback>")``). Without this
+        # the harness falls back to its own directory and cannot find the kernel
+        # source, so it runs nothing and emits no GEAK_RESULT_LATENCY_MS marker
+        # (silent "produced no latency"). GEAK_REPO_ROOT uses setdefault so an
+        # already-exported source root (set by the adapter) is preserved.
+        env["GEAK_WORK_DIR"] = str(work_dir)
+        env.setdefault("GEAK_REPO_ROOT", str(work_dir))
     env["HIP_VISIBLE_DEVICES"] = str(gpu_id)
     env["PYTHONUNBUFFERED"] = "1"
     if extra:
diff --git a/src/minisweagent/run/preprocess_v3/tools.py b/src/minisweagent/run/preprocess_v3/tools.py
index 90554945a..18db6177e 100644
--- a/src/minisweagent/run/preprocess_v3/tools.py
+++ b/src/minisweagent/run/preprocess_v3/tools.py
@@ -1273,7 +1273,19 @@ def _impl(
                 eval_command = saved_eval
 
         resolved_gpu = gpu_id if gpu_id is not None else agent.config.gpu_id
-        resolved_work_dir = Path(work_dir) if work_dir else None
+        # Fall back to the orchestrator's source repo when the subagent omits
+        # work_dir (it has no schema default and is frequently not passed).
+        # A None work_dir means _build_env sets neither PYTHONPATH nor
+        # GEAK_WORK_DIR, so the harness can't find the kernel source and silently
+        # produces no latency. At preprocess time no per-slot worktree exists yet,
+        # so the source repo is the correct target; optimization-time runs pass
+        # their per-slot worktree explicitly via the legacy run_harness path.
+        if work_dir:
+            resolved_work_dir = Path(work_dir)
+        elif agent.config.repo:
+            resolved_work_dir = Path(agent.config.repo)
+        else:
+            resolved_work_dir = None
 
         if harness_path:
             baseline: BaselineMetrics = collect_baseline_metrics(
@@ -1412,6 +1424,11 @@ def _impl(
             except Exception as exc:  # noqa: BLE001 — never let the gate crash finalize
                 logger.debug("render_commandment bypass-gate skipped (validator error): %s", exc)
 
+        # compile_command is intentionally left unset: for HIP the harness owns
+        # its own build (the harness-generator contract requires it to self-build
+        # via subprocess.run(make/hipcc), mtime-keyed on the kernel source). So the
+        # rendered COMMANDMENT carries no compile step — that is by design, not a
+        # gap. A changed CK/HIP source is still recompiled by the harness/JIT layer.
         ctx = CommandmentContext(
             kernel_path=Path(kernel_path),
             harness_path=Path(harness_path),
diff --git a/tests/run/test_preprocess_v3_bugfixes.py b/tests/run/test_preprocess_v3_bugfixes.py
index ca3586699..5aa869827 100644
--- a/tests/run/test_preprocess_v3_bugfixes.py
+++ b/tests/run/test_preprocess_v3_bugfixes.py
@@ -10,6 +10,7 @@
     PreprocessOrchestratorConfig,
 )
 from minisweagent.run.preprocess_v3.tools import (
+    _make_tool_collect_baseline,
     _make_tool_commandment_from_user_command,
     _make_tool_dispatch_subagent,
     _make_tool_finish_preprocess,
@@ -217,6 +218,68 @@ def test_path_a_build_bearing_amalgamation_still_synthesizes(tmp_path: Path) ->
     assert out_path.exists()
 
 
+def test_baseline_build_env_exports_geak_work_dir(tmp_path: Path) -> None:
+    """_build_env must export GEAK_WORK_DIR (and GEAK_REPO_ROOT) when work_dir is
+    given, so a contract-compliant harness resolves the real source tree instead
+    of falling back to its own directory (silent 'produced no latency')."""
+    from minisweagent.run.preprocess_v3.baseline import _build_env
+
+    work = tmp_path / "repo"
+    work.mkdir()
+
+    env = _build_env(work, gpu_id=0)
+    assert env["GEAK_WORK_DIR"] == str(work)
+    assert env["GEAK_REPO_ROOT"] == str(work)
+    assert str(work) in env["PYTHONPATH"]
+
+    # When work_dir is None, neither key is added (preserves prior no-op behavior).
+    env_none = _build_env(None, gpu_id=0)
+    assert "GEAK_WORK_DIR" not in env_none
+    assert "GEAK_REPO_ROOT" not in env_none
+
+
+def test_collect_baseline_defaults_work_dir_to_source_repo(tmp_path: Path, monkeypatch) -> None:
+    """When the subagent omits work_dir, collect_baseline must fall back to the
+    orchestrator's source repo so baseline runs with a valid GEAK_WORK_DIR."""
+    import minisweagent.run.preprocess_v3.tools as tools_module
+
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    harness = tmp_path / "harness.py"
+    harness.write_text("print('GEAK_RESULT_LATENCY_MS=1.0')\n")
+
+    captured: dict[str, object] = {}
+
+    def fake_collect_baseline_metrics(harness_path, *, repeats, work_dir, gpu_id):
+        captured["work_dir"] = work_dir
+        return SimpleNamespace(
+            success=True,
+            median_ms=1.0,
+            samples_ms=[1.0],
+            stdev_ms=0.0,
+            repeats=repeats,
+            harness_path=harness_path,
+            command="",
+        )
+
+    monkeypatch.setattr(tools_module, "collect_baseline_metrics", fake_collect_baseline_metrics)
+    # capture_full_benchmark_stdout is imported lazily inside the tool from the
+    # baseline module; stub it there so this unit test runs no real subprocess.
+    import minisweagent.run.preprocess_v3.baseline as baseline_module
+
+    monkeypatch.setattr(baseline_module, "capture_full_benchmark_stdout", lambda *a, **k: None)
+
+    agent = PreprocessOrchestratorAgent(
+        model=object(),
+        config=PreprocessOrchestratorConfig(repo=repo),
+    )
+    tool = _make_tool_collect_baseline(agent)
+    # No work_dir passed -> must default to agent.config.repo.
+    tool(harness_path=str(harness), repeats=1)
+
+    assert captured["work_dir"] == repo
+
+
 def test_dispatch_subagent_uses_sandbox_worktree_env(tmp_path: Path) -> None:
     repo = tmp_path / "repo"
     repo.mkdir()