From 991819481224cba39122c028ccecaff63c9ca132 Mon Sep 17 00:00:00 2001
From: Vitalii Mishchenko <vitalii.mishchenko@mongodb.com>
Date: Thu, 14 May 2026 19:53:55 -0700
Subject: [PATCH 1/4] Add run_agent.py to execute prompt templates with auggie

Implements a universal Python script to run prompt templates against
the auggie coding agent. Resolves template paths, substitutes
environment variables (DRAFT_REPO_DIR, DRAFT_BRANCH,
DRAFT_BASE_BRANCH, DRAFT_SPEC_FILE), validates auggie auth, and
handles output verdicts (approval if no issues found, rejection if
FOUND_ISSUES present). Includes comprehensive test coverage for all
functionality. Will serve as a reviewer in the review-implementation
step of config.yaml.
---
 scripts/run_agent.py          | 128 +++++++++++++++++++++++
 tests/draft/test_run_agent.py | 190 ++++++++++++++++++++++++++++++++++
 2 files changed, 318 insertions(+)
 create mode 100755 scripts/run_agent.py
 create mode 100644 tests/draft/test_run_agent.py

diff --git a/scripts/run_agent.py b/scripts/run_agent.py
new file mode 100755
index 0000000..8f38524
--- /dev/null
+++ b/scripts/run_agent.py
@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Runs a prompt template against auggie.
+
+Usage: run_agent.py <template> <model>
+
+<template> is a path to a prompt template file — absolute or relative to
+DRAFT_REPO_DIR. The template may contain these placeholders which are
+substituted from the corresponding environment variables:
+  {DRAFT_REPO_DIR}  {DRAFT_BRANCH}  {DRAFT_BASE_BRANCH}  {DRAFT_SPEC_FILE}
+
+<model> is forwarded to auggie (e.g. gpt-4.1).
+
+Verdict contract: stdout empty → approval; stdout non-empty → rejection;
+rc != 0 → infra failure.
+"""
+
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+TEMPLATE_VARS = ("DRAFT_REPO_DIR", "DRAFT_BRANCH", "DRAFT_BASE_BRANCH", "DRAFT_SPEC_FILE")
+
+
+def die(msg: str) -> None:
+    print(f"run_agent.py: {msg}", file=sys.stderr)
+    sys.exit(1)
+
+
+def resolve_template_path(template: str, repo_dir: str) -> Path:
+    p = Path(template)
+    return p if p.is_absolute() else Path(repo_dir) / p
+
+
+def fill_template(text: str, env: dict[str, str]) -> str:
+    for var in TEMPLATE_VARS:
+        text = text.replace(f"{{{var}}}", env.get(var, ""))
+    return text
+
+
+def check_auggie_auth() -> None:
+    result = subprocess.run(
+        ["auggie", "token", "print"], capture_output=True, text=True
+    )
+    out = result.stdout + result.stderr
+    if result.returncode != 0 or "SESSION=" not in out:
+        print(
+            "run_agent.py: auggie pre-flight auth check failed;"
+            " run 'auggie login' or export AUGMENT_SESSION_AUTH",
+            file=sys.stderr,
+        )
+        if out.strip():
+            print("--- auggie token print output ---", file=sys.stderr)
+            print(out, file=sys.stderr)
+        sys.exit(1)
+
+
+def run_auggie(prompt: str, model: str, workspace_root: str) -> str:
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
+        f.write(prompt)
+        prompt_file = f.name
+    try:
+        result = subprocess.run(
+            [
+                "auggie",
+                "--print",
+                "--quiet",
+                "--ask",
+                "--workspace-root",
+                workspace_root,
+                "--allow-indexing",
+                "--max-turns",
+                "10",
+                "--model",
+                model,
+                "--instruction-file",
+                prompt_file,
+            ],
+            stdout=subprocess.PIPE,
+            text=True,
+        )
+    finally:
+        os.unlink(prompt_file)
+
+    if result.returncode != 0:
+        print(
+            f"run_agent.py: auggie call failed with rc={result.returncode}",
+            file=sys.stderr,
+        )
+        sys.exit(result.returncode)
+
+    return result.stdout
+
+
+def main() -> None:
+    if len(sys.argv) != 3:
+        die("usage: run_agent.py <template> <model>")
+
+    template_arg, model = sys.argv[1], sys.argv[2]
+
+    env: dict[str, str] = {}
+    for var in TEMPLATE_VARS:
+        val = os.environ.get(var, "")
+        if not val:
+            die(f"{var} is unset or empty")
+        env[var] = val
+
+    template_path = resolve_template_path(template_arg, env["DRAFT_REPO_DIR"])
+    if not template_path.is_file():
+        die(f"template not found: {template_path}")
+
+    template_text = template_path.read_text()
+    if not template_text.strip():
+        die(f"template is empty: {template_path}")
+
+    prompt = fill_template(template_text, env)
+
+    check_auggie_auth()
+
+    stdout = run_auggie(prompt, model, env["DRAFT_REPO_DIR"])
+
+    if "FOUND_ISSUES" in stdout:
+        print(stdout, end="")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/draft/test_run_agent.py b/tests/draft/test_run_agent.py
new file mode 100644
index 0000000..330fdf5
--- /dev/null
+++ b/tests/draft/test_run_agent.py
@@ -0,0 +1,190 @@
+import importlib.util
+from pathlib import Path
+from unittest import mock
+
+import pytest
+
+# Load scripts/run_agent.py without installing it as a package.
+_script_path = Path(__file__).parents[2] / "scripts" / "run_agent.py"
+_spec = importlib.util.spec_from_file_location("run_agent", _script_path)
+run_agent = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(run_agent)
+
+
+class TestResolveTemplatePath:
+    def test_absolute_path_returned_unchanged(self, tmp_path):
+        p = tmp_path / "prompt.md"
+        result = run_agent.resolve_template_path(str(p), "/some/repo")
+        assert result == p
+
+    def test_relative_path_joined_with_repo_dir(self, tmp_path):
+        result = run_agent.resolve_template_path("templates/review.md", str(tmp_path))
+        assert result == tmp_path / "templates" / "review.md"
+
+    def test_relative_path_basename_only(self, tmp_path):
+        result = run_agent.resolve_template_path("prompt.md", str(tmp_path))
+        assert result == tmp_path / "prompt.md"
+
+
+class TestFillTemplate:
+    def test_replaces_all_vars(self):
+        template = "repo={DRAFT_REPO_DIR} branch={DRAFT_BRANCH} base={DRAFT_BASE_BRANCH} spec={DRAFT_SPEC_FILE}"
+        env = {
+            "DRAFT_REPO_DIR": "/repo",
+            "DRAFT_BRANCH": "feature/x",
+            "DRAFT_BASE_BRANCH": "main",
+            "DRAFT_SPEC_FILE": "/repo/spec.md",
+        }
+        result = run_agent.fill_template(template, env)
+        assert result == "repo=/repo branch=feature/x base=main spec=/repo/spec.md"
+
+    def test_missing_var_replaced_with_empty_string(self):
+        result = run_agent.fill_template("branch={DRAFT_BRANCH}", {})
+        assert result == "branch="
+
+    def test_no_placeholders_unchanged(self):
+        text = "no placeholders here"
+        assert run_agent.fill_template(text, {"DRAFT_BRANCH": "main"}) == text
+
+    def test_partial_replacement(self):
+        result = run_agent.fill_template(
+            "{DRAFT_BRANCH} on {DRAFT_BASE_BRANCH}",
+            {"DRAFT_BRANCH": "feat", "DRAFT_BASE_BRANCH": "main"},
+        )
+        assert result == "feat on main"
+
+    def test_repeated_placeholder(self):
+        result = run_agent.fill_template(
+            "{DRAFT_BRANCH} and {DRAFT_BRANCH}",
+            {"DRAFT_BRANCH": "dev"},
+        )
+        assert result == "dev and dev"
+
+
+class TestCheckAuggieAuth:
+    def _run_check(self, returncode, output):
+        with mock.patch("subprocess.run") as mock_run:
+            mock_run.return_value = mock.MagicMock(
+                returncode=returncode, stdout=output, stderr=""
+            )
+            run_agent.check_auggie_auth()
+        return mock_run
+
+    def test_passes_when_session_present(self):
+        self._run_check(0, "SESSION=abc123")  # should not raise
+
+    def test_exits_when_returncode_nonzero(self):
+        with mock.patch("subprocess.run") as mock_run:
+            mock_run.return_value = mock.MagicMock(
+                returncode=1, stdout="", stderr="error"
+            )
+            with pytest.raises(SystemExit) as exc:
+                run_agent.check_auggie_auth()
+        assert exc.value.code == 1
+
+    def test_exits_when_session_missing(self):
+        with mock.patch("subprocess.run") as mock_run:
+            mock_run.return_value = mock.MagicMock(
+                returncode=0, stdout="no session here", stderr=""
+            )
+            with pytest.raises(SystemExit) as exc:
+                run_agent.check_auggie_auth()
+        assert exc.value.code == 1
+
+
+class TestRunAuggie:
+    def test_returns_stdout_on_success(self, tmp_path):
+        with mock.patch("subprocess.run") as mock_run:
+            mock_run.return_value = mock.MagicMock(
+                returncode=0, stdout="FOUND_ISSUES\n\n## issue\n"
+            )
+            result = run_agent.run_auggie("my prompt", "gpt-4.1", str(tmp_path))
+        assert result == "FOUND_ISSUES\n\n## issue\n"
+
+    def test_exits_on_auggie_failure(self, tmp_path):
+        with mock.patch("subprocess.run") as mock_run:
+            mock_run.return_value = mock.MagicMock(returncode=2, stdout="")
+            with pytest.raises(SystemExit) as exc:
+                run_agent.run_auggie("prompt", "gpt-4.1", str(tmp_path))
+        assert exc.value.code == 2
+
+    def test_passes_correct_args(self, tmp_path):
+        with mock.patch("subprocess.run") as mock_run:
+            mock_run.return_value = mock.MagicMock(returncode=0, stdout="NO_ISSUES")
+            run_agent.run_auggie("prompt", "gpt-4.1", "/repo")
+
+        cmd = mock_run.call_args[0][0]
+        assert cmd[0] == "auggie"
+        assert "--model" in cmd
+        model_idx = cmd.index("--model")
+        assert cmd[model_idx + 1] == "gpt-4.1"
+        assert "--workspace-root" in cmd
+        ws_idx = cmd.index("--workspace-root")
+        assert cmd[ws_idx + 1] == "/repo"
+
+
+class TestMain:
+    def _base_env(self, tmp_path):
+        spec_file = tmp_path / "spec.md"
+        spec_file.write_text("the spec")
+        template_file = tmp_path / "prompt.md"
+        template_file.write_text("branch={DRAFT_BRANCH}")
+        return {
+            "DRAFT_REPO_DIR": str(tmp_path),
+            "DRAFT_BRANCH": "feat",
+            "DRAFT_BASE_BRANCH": "main",
+            "DRAFT_SPEC_FILE": str(spec_file),
+        }, template_file
+
+    def test_approval_produces_no_output(self, tmp_path, capsys):
+        env, tmpl = self._base_env(tmp_path)
+        with (
+            mock.patch.dict("os.environ", env),
+            mock.patch("sys.argv", ["run_agent.py", str(tmpl), "gpt-4.1"]),
+            mock.patch.object(run_agent, "check_auggie_auth"),
+            mock.patch.object(run_agent, "run_auggie", return_value="NO_ISSUES"),
+        ):
+            run_agent.main()
+        captured = capsys.readouterr()
+        assert captured.out == ""
+
+    def test_rejection_prints_found_issues(self, tmp_path, capsys):
+        env, tmpl = self._base_env(tmp_path)
+        auggie_out = "FOUND_ISSUES\n\n## bad thing\n"
+        with (
+            mock.patch.dict("os.environ", env),
+            mock.patch("sys.argv", ["run_agent.py", str(tmpl), "gpt-4.1"]),
+            mock.patch.object(run_agent, "check_auggie_auth"),
+            mock.patch.object(run_agent, "run_auggie", return_value=auggie_out),
+        ):
+            run_agent.main()
+        captured = capsys.readouterr()
+        assert "FOUND_ISSUES" in captured.out
+
+    def test_missing_env_var_exits(self, tmp_path):
+        env, tmpl = self._base_env(tmp_path)
+        env.pop("DRAFT_BRANCH")
+        with (
+            mock.patch.dict("os.environ", env, clear=True),
+            mock.patch("sys.argv", ["run_agent.py", str(tmpl), "gpt-4.1"]),
+            pytest.raises(SystemExit),
+        ):
+            run_agent.main()
+
+    def test_missing_template_exits(self, tmp_path):
+        env, _ = self._base_env(tmp_path)
+        with (
+            mock.patch.dict("os.environ", env),
+            mock.patch("sys.argv", ["run_agent.py", "nonexistent.md", "gpt-4.1"]),
+            pytest.raises(SystemExit),
+        ):
+            run_agent.main()
+
+    def test_wrong_arg_count_exits(self, tmp_path):
+        env, _ = self._base_env(tmp_path)
+        with (
+            mock.patch.dict("os.environ", env),
+            mock.patch("sys.argv", ["run_agent.py", "only-one-arg"]),
+            pytest.raises(SystemExit),
+        ):
+            run_agent.main()

From 1e9e56bb93d9c705e7d2fdbd0956896c5fe5169c Mon Sep 17 00:00:00 2001
From: Vitalii Mishchenko <vitalii.mishchenko@mongodb.com>
Date: Thu, 14 May 2026 19:57:54 -0700
Subject: [PATCH 2/4] address review: forward any non-empty stdout; require
 only DRAFT_REPO_DIR
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Replace `"FOUND_ISSUES" in stdout` guard with `stdout.strip()` — review
  contract treats any non-empty output as rejection, not just sentinel
- Require only `DRAFT_REPO_DIR` up front; collect remaining vars from env
  as optional substitutions — templates may use only a subset of vars
- Update approval test to return `""` instead of `"NO_ISSUES"` to match
  the real approval signal
- Update missing-var test to pop `DRAFT_REPO_DIR`, the only mandatory var
---
 scripts/run_agent.py          | 13 ++++++-------
 tests/draft/test_run_agent.py |  4 ++--
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/scripts/run_agent.py b/scripts/run_agent.py
index 8f38524..1510ba2 100755
--- a/scripts/run_agent.py
+++ b/scripts/run_agent.py
@@ -99,12 +99,11 @@ def main() -> None:
 
     template_arg, model = sys.argv[1], sys.argv[2]
 
-    env: dict[str, str] = {}
-    for var in TEMPLATE_VARS:
-        val = os.environ.get(var, "")
-        if not val:
-            die(f"{var} is unset or empty")
-        env[var] = val
+    repo_dir = os.environ.get("DRAFT_REPO_DIR", "")
+    if not repo_dir:
+        die("DRAFT_REPO_DIR is unset or empty")
+
+    env: dict[str, str] = {var: os.environ.get(var, "") for var in TEMPLATE_VARS}
 
     template_path = resolve_template_path(template_arg, env["DRAFT_REPO_DIR"])
     if not template_path.is_file():
@@ -120,7 +119,7 @@ def main() -> None:
 
     stdout = run_auggie(prompt, model, env["DRAFT_REPO_DIR"])
 
-    if "FOUND_ISSUES" in stdout:
+    if stdout.strip():
         print(stdout, end="")
 
 
diff --git a/tests/draft/test_run_agent.py b/tests/draft/test_run_agent.py
index 330fdf5..67adb05 100644
--- a/tests/draft/test_run_agent.py
+++ b/tests/draft/test_run_agent.py
@@ -142,7 +142,7 @@ def test_approval_produces_no_output(self, tmp_path, capsys):
             mock.patch.dict("os.environ", env),
             mock.patch("sys.argv", ["run_agent.py", str(tmpl), "gpt-4.1"]),
             mock.patch.object(run_agent, "check_auggie_auth"),
-            mock.patch.object(run_agent, "run_auggie", return_value="NO_ISSUES"),
+            mock.patch.object(run_agent, "run_auggie", return_value=""),
         ):
             run_agent.main()
         captured = capsys.readouterr()
@@ -163,7 +163,7 @@ def test_rejection_prints_found_issues(self, tmp_path, capsys):
 
     def test_missing_env_var_exits(self, tmp_path):
         env, tmpl = self._base_env(tmp_path)
-        env.pop("DRAFT_BRANCH")
+        env.pop("DRAFT_REPO_DIR")
         with (
             mock.patch.dict("os.environ", env, clear=True),
             mock.patch("sys.argv", ["run_agent.py", str(tmpl), "gpt-4.1"]),

From fe52fe22a1a745067e3755c3da43fc6195ca73ee Mon Sep 17 00:00:00 2001
From: Vitalii Mishchenko <vitalii.mishchenko@mongodb.com>
Date: Thu, 14 May 2026 20:04:31 -0700
Subject: [PATCH 3/4] address review: delete review.sh, extract prompt
 template, guard auggie PATH
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Delete scripts/review.sh — review issue: old bash script was not removed
  when run_agent.py was introduced as its replacement
- Add scripts/review.md with prompt extracted from review.sh — review issue:
  run_agent.py requires a template file but the prompt was never migrated out
  of the deleted script
- Convert ${VAR} bash syntax to {VAR} brace syntax in review.md — required by
  run_agent.py's fill_template substitution logic
- Remove FOUND_ISSUES sentinel contract from review.md output rules — review
  issue: run_agent.py forwards all non-empty stdout, no sentinel filtering
- Add shutil.which("auggie") guard before subprocess.run — review issue:
  missing PATH check would surface as opaque FileNotFoundError traceback
---
 scripts/review.md    |  59 ++++++++++++++++++
 scripts/review.sh    | 138 -------------------------------------------
 scripts/run_agent.py |   3 +
 3 files changed, 62 insertions(+), 138 deletions(-)
 create mode 100644 scripts/review.md
 delete mode 100755 scripts/review.sh

diff --git a/scripts/review.md b/scripts/review.md
new file mode 100644
index 0000000..7cddee2
--- /dev/null
+++ b/scripts/review.md
@@ -0,0 +1,59 @@
+You are a code reviewer for a draft-managed change about to be committed.
+
+Branch: {DRAFT_BRANCH}
+Base branch: {DRAFT_BASE_BRANCH}
+
+Run `git diff {DRAFT_BASE_BRANCH}...HEAD` in the repository at `{DRAFT_REPO_DIR}` to get the diff.
+Read the spec from `{DRAFT_SPEC_FILE}`.
+
+## Review rules
+
+- The spec is the source of truth.
+- Flag errors or bugs related to the changed files (anything wrong inside the diff).
+- Flag mismatches between the diff and the spec (the spec asks for X, the diff does Y).
+- Do NOT flag nice-to-have features. If the spec doesn't ask for it, don't suggest adding it.
+- Do NOT flag refactoring opportunities. If the existing code is not buggy, leave it alone, even if it could be cleaner.
+- Do NOT flag stylistic preferences without a correctness impact.
+- Report at most 3 items. If more real issues exist, pick the most severe (severity = potential to cause incorrect runtime behaviour or spec violation) and drop the rest.
+
+## Output
+
+There are exactly two valid outputs. Choose one. Never both. Never something else.
+
+(a) If no issues meet the criteria above, output nothing at all (empty output).
+
+(b) Otherwise, output up to 3 items in the format below. No preamble. Items separated by a blank line.
+
+## <name (1-4 words)>
+
+**Summary**: <one to three sentences>
+
+**Details**:
+<free-form, as long as needed: file/line references, code excerpts, spec excerpts, failure scenarios>
+
+**Proposed fix**:
+<free-form, as long as needed: concrete change recommendation>
+
+Example of a single well-formed item:
+
+## Missing null check
+
+**Summary**: `parse_config` dereferences the result of `os.environ.get("DRAFT_SPEC_FILE")` without checking for None, which crashes the step when the env var is unset.
+
+**Details**:
+At `src/draft/steps/review_implementation/__init__.py:42`, the diff introduces:
+
+    spec_path = os.environ.get("DRAFT_SPEC_FILE")
+    with open(spec_path) as f:
+        ...
+
+The spec says `DRAFT_SPEC_FILE` is always set, but `open(None)` raises `TypeError`, which surfaces as an opaque crash.
+
+**Proposed fix**:
+Guard the lookup:
+
+    spec_path = os.environ.get("DRAFT_SPEC_FILE")
+    if not spec_path:
+        raise StepError("review-implementation", "DRAFT_SPEC_FILE is required")
+    with open(spec_path) as f:
+        ...
diff --git a/scripts/review.sh b/scripts/review.sh
deleted file mode 100755
index ad01e06..0000000
--- a/scripts/review.sh
+++ /dev/null
@@ -1,138 +0,0 @@
-#!/usr/bin/env bash
-# Invokes auggie to review the working-tree diff against a spec.
-# Usage: review.sh <model>
-# This script is model-agnostic; the caller picks the model.
-# Recommended: pass an OpenAI model (e.g. gpt-4.1) to avoid Auggie's Anthropic default.
-# Verdict contract: stdout empty → approval; stdout non-empty → rejection; rc != 0 → infra failure.
-# Required env vars: DRAFT_REPO_DIR, DRAFT_BRANCH, DRAFT_BASE_BRANCH, DRAFT_SPEC_FILE.
-# Authentication: run 'auggie login' once or export AUGMENT_SESSION_AUTH before invoking.
-# Full contract: features/260423-draft-cli/scopes/260514-scope-review-model-arg.md
-
-set -euo pipefail
-
-# Maximum number of review items to report
-MAX_REVIEW_ITEMS=3
-
-die() { echo "review.sh: $*" >&2; exit 1; }
-
-MODEL="${1:-}"
-[[ -n "$MODEL" ]] || die "usage: review.sh <model>"
-
-for v in DRAFT_REPO_DIR DRAFT_BRANCH DRAFT_BASE_BRANCH DRAFT_SPEC_FILE; do
-  [[ -n "${!v:-}" ]] || die "$v is unset or empty"
-done
-[[ -r "$DRAFT_SPEC_FILE" ]] || die "DRAFT_SPEC_FILE not readable: $DRAFT_SPEC_FILE"
-
-command -v auggie >/dev/null || die "auggie not on PATH"
-
-if ! auth_out="$(auggie token print 2>&1)"; then
-  echo "review.sh: auggie pre-flight auth check failed; run 'auggie login' or export AUGMENT_SESSION_AUTH" >&2
-  echo "--- auggie token print output ---" >&2
-  echo "$auth_out" >&2
-  exit 1
-fi
-[[ "$auth_out" == *"SESSION="* ]] || die "auggie token print did not return a SESSION; run 'auggie login'"
-
-if ! diff_text="$(git diff "$DRAFT_BASE_BRANCH"...HEAD 2>&1)"; then
-  echo "review.sh: git diff $DRAFT_BASE_BRANCH...HEAD failed:" >&2
-  echo "$diff_text" >&2
-  exit 1
-fi
-[[ -n "$diff_text" ]] || die "empty diff (HEAD == merge-base of $DRAFT_BASE_BRANCH and HEAD); pipeline invariant violated"
-
-spec_text="$(<"$DRAFT_SPEC_FILE")"
-[[ -n "$spec_text" ]] || die "DRAFT_SPEC_FILE is empty: $DRAFT_SPEC_FILE"
-
-prompt_file="$(mktemp)"
-trap 'rm -f "$prompt_file"' EXIT
-
-cat > "$prompt_file" <<DRAFT_REVIEW_PROMPT_END
-You are a code reviewer for a draft-managed change about to be committed.
-
-Branch: ${DRAFT_BRANCH}
-Base branch: ${DRAFT_BASE_BRANCH}
-
-## Spec
-
-${spec_text}
-
-## Diff
-
-${diff_text}
-
-## Review rules
-
-- The spec is the source of truth.
-- Flag errors or bugs related to the changed files (anything wrong inside the diff).
-- Flag mismatches between the diff and the spec (the spec asks for X, the diff does Y).
-- Do NOT flag nice-to-have features. If the spec doesn't ask for it, don't suggest adding it.
-- Do NOT flag refactoring opportunities. If the existing code is not buggy, leave it alone, even if it could be cleaner.
-- Do NOT flag stylistic preferences without a correctness impact.
-- Report at most ${MAX_REVIEW_ITEMS} items. If more real issues exist, pick the most severe (severity = potential to cause incorrect runtime behaviour or spec violation) and drop the rest.
-
-## Output
-
-There are exactly two valid outputs. Choose one. Never both. Never something else.
-
-(a) If no issues meet the criteria above, print EXACTLY this line and nothing else:
-
-NO_ISSUES
-
-(b) Otherwise, the FIRST line of your output MUST be exactly:
-
-FOUND_ISSUES
-
-followed by a blank line, then up to ${MAX_REVIEW_ITEMS} items in the format below. No preamble before FOUND_ISSUES, no NO_ISSUES sentinel mixed in. Items separated by a blank line.
-
-## <name (1-4 words)>
-
-**Summary**: <one to three sentences>
-
-**Details**:
-<free-form, as long as needed: file/line references, code excerpts, spec excerpts, failure scenarios>
-
-**Proposed fix**:
-<free-form, as long as needed: concrete change recommendation>
-
-Example of a single well-formed item:
-
-## Missing null check
-
-**Summary**: \`parse_config\` dereferences the result of \`os.environ.get("DRAFT_SPEC_FILE")\` without checking for None, which crashes the step when the env var is unset.
-
-**Details**:
-At \`src/draft/steps/review_implementation/__init__.py:42\`, the diff introduces:
-
-    spec_path = os.environ.get("DRAFT_SPEC_FILE")
-    with open(spec_path) as f:
-        ...
-
-The spec says \`DRAFT_SPEC_FILE\` is always set, but \`open(None)\` raises \`TypeError\`, which surfaces as an opaque crash.
-
-**Proposed fix**:
-Guard the lookup:
-
-    spec_path = os.environ.get("DRAFT_SPEC_FILE")
-    if not spec_path:
-        raise StepError("review-implementation", "DRAFT_SPEC_FILE is required")
-    with open(spec_path) as f:
-        ...
-DRAFT_REVIEW_PROMPT_END
-
-if ! auggie_stdout="$(auggie --print --quiet --ask \
-    --workspace-root "$DRAFT_REPO_DIR" \
-    --allow-indexing \
-    --max-turns 10 \
-    --model "$MODEL" \
-    --instruction-file "$prompt_file")"; then
-  rc=$?
-  echo "review.sh: auggie review call failed with rc=$rc" >&2
-  exit "$rc"
-fi
-
-# Rejection = FOUND_ISSUES sentinel present anywhere in stdout.
-# Anything else (NO_ISSUES, empty output, stray metadata, etc.) is approval.
-if [[ "$auggie_stdout" == *"FOUND_ISSUES"* ]]; then
-  printf '%s' "$auggie_stdout"
-fi
-exit 0
diff --git a/scripts/run_agent.py b/scripts/run_agent.py
index 1510ba2..54d212d 100755
--- a/scripts/run_agent.py
+++ b/scripts/run_agent.py
@@ -15,6 +15,7 @@
 """
 
 import os
+import shutil
 import subprocess
 import sys
 import tempfile
@@ -40,6 +41,8 @@ def fill_template(text: str, env: dict[str, str]) -> str:
 
 
 def check_auggie_auth() -> None:
+    if not shutil.which("auggie"):
+        die("auggie not found on PATH")
     result = subprocess.run(
         ["auggie", "token", "print"], capture_output=True, text=True
     )

From 6cca7d53d69e20da0ac82257e741acaeffb1adcb Mon Sep 17 00:00:00 2001
From: Vitalii Mishchenko <vitalii.mishchenko@mongodb.com>
Date: Thu, 14 May 2026 20:06:25 -0700
Subject: [PATCH 4/4] Mock shutil.which for auggie availability check

The test now mocks shutil.which alongside subprocess.run to
simulate auggie being available, fixing CI failures when auggie
is not installed in the test environment.
---
 tests/draft/test_run_agent.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/draft/test_run_agent.py b/tests/draft/test_run_agent.py
index 67adb05..b3c5780 100644
--- a/tests/draft/test_run_agent.py
+++ b/tests/draft/test_run_agent.py
@@ -63,7 +63,10 @@ def test_repeated_placeholder(self):
 
 class TestCheckAuggieAuth:
     def _run_check(self, returncode, output):
-        with mock.patch("subprocess.run") as mock_run:
+        with (
+            mock.patch("shutil.which", return_value="/usr/bin/auggie"),
+            mock.patch("subprocess.run") as mock_run,
+        ):
             mock_run.return_value = mock.MagicMock(
                 returncode=returncode, stdout=output, stderr=""
             )