@@ -112,7 +112,18 @@ jobs:
         # which is the CLI's default base. The CLI resolves that case on its own
         # now, but naming the branch the event came from is exact rather than
         # inferred.
-        run: simplycubed run ${{ inputs['dry-run'] && '--dry-run' || '' }} "${GITHUB_REPOSITORY}#${{ inputs['issue-number'] }}" --actor "${{ inputs['actor-login'] }}" --model "${{ inputs.model }}" --base "origin/${{ github.event.repository.default_branch }}" --repo-dir .
+        env:
+          COMMENT_BODY: ${{ inputs['comment-body'] }}
+        # A comment goes through the parser, which recognises a fixed vocabulary
+        # and does nothing otherwise. Without this every comment beginning with
+        # the mention would start a full run, including "help" and including a
+        # comment asking it NOT to proceed.
+        run: |
+          if [ -n "${COMMENT_BODY}" ]; then
+            simplycubed command ${{ inputs['dry-run'] && '--dry-run' || '' }} --body "${COMMENT_BODY}" "${GITHUB_REPOSITORY}#${{ inputs['issue-number'] }}" --actor "${{ inputs['actor-login'] }}" --model "${{ inputs.model }}" --base "origin/${{ github.event.repository.default_branch }}" --repo-dir .
+          else
+            simplycubed run ${{ inputs['dry-run'] && '--dry-run' || '' }} "${GITHUB_REPOSITORY}#${{ inputs['issue-number'] }}" --actor "${{ inputs['actor-login'] }}" --model "${{ inputs.model }}" --base "origin/${{ github.event.repository.default_branch }}" --repo-dir .
+          fi
 
   address:
     if: ${{ inputs['pr-number'] != '' }}
@@ -166,4 +177,11 @@ jobs:
           GH_TOKEN: ${{ steps.app-token.outputs.token }}
           AZURE_OPENAI_ENDPOINT: ${{ inputs['azure-openai-endpoint'] }}
           AZURE_OPENAI_API_KEY: ${{ secrets['azure-openai-api-key'] }}
-        run: simplycubed address ${{ inputs['dry-run'] && '--dry-run' || '' }} "${GITHUB_REPOSITORY}#${{ inputs['pr-number'] }}" --actor "${{ inputs['actor-login'] }}" --model "${{ inputs.model }}" --repo-dir .
+        env:
+          COMMENT_BODY: ${{ inputs['comment-body'] }}
+        run: |
+          if [ -n "${COMMENT_BODY}" ]; then
+            simplycubed command ${{ inputs['dry-run'] && '--dry-run' || '' }} --body "${COMMENT_BODY}" "${GITHUB_REPOSITORY}#${{ inputs['pr-number'] }}" --actor "${{ inputs['actor-login'] }}" --model "${{ inputs.model }}" --repo-dir .
+          else
+            simplycubed address ${{ inputs['dry-run'] && '--dry-run' || '' }} "${GITHUB_REPOSITORY}#${{ inputs['pr-number'] }}" --actor "${{ inputs['actor-login'] }}" --model "${{ inputs.model }}" --repo-dir .
+          fi
@@ -206,24 +206,47 @@ func newRunner(cfg *config.Config, codexHome string) engine.Runner {
 	return r
 }
 
+// takeBody removes --body (in either form) from argv and returns it with the
+// remaining arguments.
+func takeBody(argv []string) (body string, rest []string, err error) {
+	for i := 0; i < len(argv); i++ {
+		a := argv[i]
+		switch {
+		case a == "--body" || a == "-body":
+			if i+1 >= len(argv) {
+				return "", nil, fmt.Errorf("--body requires a value")
+			}
+			body = argv[i+1]
+			i++
+		case strings.HasPrefix(a, "--body="), strings.HasPrefix(a, "-body="):
+			_, v, _ := strings.Cut(a, "=")
+			body = v
+		default:
+			rest = append(rest, a)
+		}
+	}
+	return body, rest, nil
+}
+
 // commandCmd routes a comment addressed to the agent to the matching loop. The
 // comment body is untrusted, so it is parsed into a fixed vocabulary here and
 // never interpreted: an unrecognised comment does nothing at all.
 func commandCmd(argv []string, stdout io.Writer) error {
-	fs := flag.NewFlagSet("command", flag.ContinueOnError)
-	body := fs.String("body", "", "the comment body that triggered this run")
-	rest, err := parseInterleaved(fs, argv)
+	// --body is pulled out by hand and everything else is forwarded untouched,
+	// because run and address own the rest of the flags. Parsing them here would
+	// mean maintaining a second copy of that flag set.
+	body, rest, err := takeBody(argv)
 	if err != nil {
 		return err
 	}
-	switch command.Parse(*body) {
+	switch command.Parse(body) {
 	case command.Help:
 		fmt.Fprintln(stdout, command.HelpText)
 		return nil
 	case command.Go:
-		return runCmd(append([]string{}, rest...))
+		return runCmd(rest)
 	case command.Address:
-		return addressCmd(append([]string{}, rest...))
+		return addressCmd(rest)
 	default:
 		fmt.Fprintln(stdout, "no command recognised in that comment; nothing to do")
 		return nil
 
@@ -4,6 +4,10 @@ import (
 	"bytes"
 	"context"
 	"flag"
+	"github.com/simplycubed/code/internal/config"
+	"github.com/simplycubed/code/internal/domain"
+	"github.com/simplycubed/code/internal/engine/claude"
+	"github.com/simplycubed/code/internal/engine/codex"
 	"github.com/simplycubed/code/internal/forge/dryrun"
 	forgefake "github.com/simplycubed/code/internal/forge/fake"
 	vcsgit "github.com/simplycubed/code/internal/vcs/git"
@@ -492,6 +496,17 @@ func TestEngineEnvRejectsAnUnparseableEndpoint(t *testing.T) {
 	}
 }
 
+func TestDispatchRoutesCommand(t *testing.T) {
+	var out, errOut bytes.Buffer
+	// help is the one command that needs nothing else configured.
+	if code := dispatch([]string{"command", "--body", "@simplycubed-code help"}, &out, &errOut); code != 0 {
+		t.Fatalf("exit = %d, want 0", code)
+	}
+	if !strings.Contains(out.String(), "@simplycubed-code go") {
+		t.Fatalf("stdout = %q, want the help text", out.String())
+	}
+}
+
 func TestDispatch(t *testing.T) {
 	// Every command's exit code is part of the contract: a workflow step
 	// distinguishes "you asked for something that does not exist" (2) from
@@ -756,3 +771,204 @@ func TestInitWithWorkflowIsIdempotent(t *testing.T) {
 		t.Fatalf("the adopter's edit must survive: %q %v", got, err)
 	}
 }
+
+func TestTakeBody(t *testing.T) {
+	// The other flags belong to run and address and must survive untouched,
+	// or routing a comment would drop --actor and skip authorization.
+	for name, tc := range map[string]struct {
+		argv     []string
+		wantBody string
+		wantRest []string
+	}{
+		"separate value": {
+			[]string{"--body", "@simplycubed-code go", "--actor", "me", "o/r#1"},
+			"@simplycubed-code go", []string{"--actor", "me", "o/r#1"},
+		},
+		"equals form": {
+			[]string{"--body=@simplycubed-code address", "--dry-run", "o/r#2"},
+			"@simplycubed-code address", []string{"--dry-run", "o/r#2"},
+		},
+		"absent": {
+			[]string{"--actor", "me", "o/r#1"}, "", []string{"--actor", "me", "o/r#1"},
+		},
+	} {
+		body, rest, err := takeBody(tc.argv)
+		if err != nil {
+			t.Fatalf("%s: %v", name, err)
+		}
+		if body != tc.wantBody {
+			t.Fatalf("%s: body = %q, want %q", name, body, tc.wantBody)
+		}
+		if strings.Join(rest, " ") != strings.Join(tc.wantRest, " ") {
+			t.Fatalf("%s: rest = %v, want %v", name, rest, tc.wantRest)
+		}
+	}
+	if _, _, err := takeBody([]string{"--body"}); err == nil {
+		t.Fatal("a --body with no value must error rather than silently parse as empty")
+	}
+}
+
+// The parser exists so that a comment the agent does not understand does
+// nothing. Before this was wired, any comment beginning with the mention
+// started a full run, including one asking it not to.
+func TestCommandCmdDoesNotRunOnUnrecognisedComments(t *testing.T) {
+	for _, body := range []string{
+		"@simplycubed-code please do not do this one",
+		"thanks @simplycubed-code go",
+		"@simplycubed-code",
+	} {
+		var out bytes.Buffer
+		// A repo-dir that has no config would make a real run fail loudly, so
+		// reaching one is detectable.
+		err := commandCmd([]string{"--body", body, "--repo-dir", t.TempDir(), "o/r#1"}, &out)
+		if err != nil {
+			t.Fatalf("%q should be a quiet no-op, got: %v", body, err)
+		}
+		if !strings.Contains(out.String(), "nothing to do") {
+			t.Fatalf("%q should report nothing to do, got: %q", body, out.String())
+		}
+	}
+}
+
+// The routing branches are the point of the subcommand: a recognised verb has
+// to reach the matching loop, carrying the flags with it. Each case uses a
+// directory with no config, so reaching the loop fails at config load - which
+// is how we know it was reached at all.
+func TestCommandCmdRoutesRecognisedVerbsToTheirLoops(t *testing.T) {
+	t.Setenv("AZURE_OPENAI_ENDPOINT", "https://r.openai.azure.com")
+	t.Setenv("AZURE_OPENAI_API_KEY", "k")
+
+	for name, body := range map[string]string{
+		"go routes to run":          "@simplycubed-code go",
+		"address routes to address": "@simplycubed-code address",
+	} {
+		var out bytes.Buffer
+		err := commandCmd([]string{"--body", body, "--repo-dir", t.TempDir(), "o/r#1"}, &out)
+		if err == nil {
+			t.Fatalf("%s: expected the loop to be reached and fail on the missing config", name)
+		}
+		if !strings.Contains(err.Error(), "load config") {
+			t.Fatalf("%s: err = %v, want a config error proving the loop was reached", name, err)
+		}
+		if strings.Contains(out.String(), "nothing to do") {
+			t.Fatalf("%s: a recognised verb must not be treated as a no-op", name)
+		}
+	}
+}
+
+func TestCommandCmdRejectsABodyFlagWithNoValue(t *testing.T) {
+	if err := commandCmd([]string{"--body"}, io.Discard); err == nil {
+		t.Fatal("expected an error for --body with no value")
+	}
+}
+
+// Engine selection is a documented config key and had no test. The default
+// matters most: an existing repository must keep the engine it already had.
+func TestNewRunnerSelectsTheEngine(t *testing.T) {
+	if _, ok := newRunner(&config.Config{}, t.TempDir()).(*codex.Runner); !ok {
+		t.Fatal("the default engine must be codex")
+	}
+	if _, ok := newRunner(&config.Config{Engine: "claude"}, t.TempDir()).(*claude.Runner); !ok {
+		t.Fatal("engine: claude must select the Claude adapter")
+	}
+	// An unrecognised engine falls back rather than failing later with an
+	// error that says nothing about the cause.
+	if _, ok := newRunner(&config.Config{Engine: "nope"}, t.TempDir()).(*codex.Runner); !ok {
+		t.Fatal("an unknown engine must fall back to the default")
+	}
+}
+
+// The sandbox knob exists so an adopter with externally sandboxed runners can
+// widen it themselves. Nothing in this repository sets it, so the test asserts
+// both that the default is untouched and that an explicit value is honoured.
+func TestNewRunnerHonoursTheSandboxOverride(t *testing.T) {
+	r, ok := newRunner(&config.Config{}, t.TempDir()).(*codex.Runner)
+	if !ok {
+		t.Fatal("expected the codex runner")
+	}
+	if r.Sandbox != "workspace-write" {
+		t.Fatalf("the sandbox must stay on by default, got %q", r.Sandbox)
+	}
+	t.Setenv("SIMPLYCUBED_SANDBOX", "read-only")
+	r2, _ := newRunner(&config.Config{}, t.TempDir()).(*codex.Runner)
+	if r2.Sandbox != "read-only" {
+		t.Fatalf("an explicit sandbox mode must be honoured, got %q", r2.Sandbox)
+	}
+}
+
+// A local run has no bot identity to attribute commits to, and must not invent
+// one; an Actions run does, and a runner has no git identity without it.
+func TestNewVCSAttributesCommitsToTheCredential(t *testing.T) {
+	if v := newVCS(""); v.AuthorName != "" || v.AuthorEmail != "" {
+		t.Fatalf("a run with no known identity must not invent one: %+v", v)
+	}
+	v := newVCS("simplycubed-code[bot]")
+	if v.AuthorName != "simplycubed-code[bot]" {
+		t.Fatalf("AuthorName = %q", v.AuthorName)
+	}
+	if !strings.HasSuffix(v.AuthorEmail, "@users.noreply.github.com") || strings.Contains(v.AuthorEmail, "[bot]") {
+		t.Fatalf("AuthorEmail = %q, want a noreply address with the bot suffix stripped", v.AuthorEmail)
+	}
+}
+
+func TestIsReleaseVersion(t *testing.T) {
+	for in, want := range map[string]bool{
+		"0.1.6": true, "10.20.30": true,
+		"0.1": false, "0.1.6-rc1": false, "": false, "a.b.c": false, "0..6": false,
+	} {
+		if got := isReleaseVersion(in); got != want {
+			t.Fatalf("isReleaseVersion(%q) = %v, want %v", in, got, want)
+		}
+	}
+}
+
+// The issue title and body become the prompt, so fetching them wrong is not a
+// cosmetic failure: the agent would work from the wrong instructions.
+func TestFetchIssue(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("gh stub is a POSIX shell script")
+	}
+	stubDir := t.TempDir()
+	stub := filepath.Join(stubDir, "gh")
+	body := `{"title":"Fix the parser","body":"It drops the last line."}`
+	if err := os.WriteFile(stub, []byte("#!/bin/sh\ncat <<'J'\n"+body+"\nJ\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("PATH", stubDir+string(os.PathListSeparator)+os.Getenv("PATH"))
+
+	iss := domain.Issue{Repo: "o/r", Number: 12}
+	if err := fetchIssue(&iss); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if iss.Title != "Fix the parser" || iss.Body != "It drops the last line." {
+		t.Fatalf("issue = %+v", iss)
+	}
+
+	// Malformed output must be an error, not a silently empty prompt.
+	if err := os.WriteFile(stub, []byte("#!/bin/sh\necho 'not json'\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := fetchIssue(&domain.Issue{Repo: "o/r", Number: 1}); err == nil {
+		t.Fatal("malformed gh output must error")
+	}
+
+	// A gh failure must surface rather than leaving the issue blank.
+	if err := os.WriteFile(stub, []byte("#!/bin/sh\nexit 1\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := fetchIssue(&domain.Issue{Repo: "o/r", Number: 1}); err == nil {
+		t.Fatal("a gh failure must error")
+	}
+}
+
+func TestRunAndAddressRequireARef(t *testing.T) {
+	t.Setenv("AZURE_OPENAI_ENDPOINT", "https://r.openai.azure.com")
+	t.Setenv("AZURE_OPENAI_API_KEY", "k")
+	repo := repoWithConfig(t)
+	for name, fn := range map[string]func([]string) error{"run": runCmd, "address": addressCmd} {
+		err := fn([]string{"--repo-dir", repo, "--state-dir", t.TempDir()})
+		if err == nil || !strings.Contains(err.Error(), "missing") {
+			t.Fatalf("%s with no ref: err = %v, want a missing-ref error", name, err)
+		}
+	}
+}