refactor(cli): unify error formatting at the process boundary

Previously the entry point did:

    os.Stderr.WriteString("Error: " + err.Error() + "\n")

which works for ad-hoc errors but loses structure when the error is a
*git.OpError. Users saw messages like:

    Error: git: checkout branch failed: exit status 1 (command: git checkout main)

which buries the actually useful part (the op and the underlying reason)
behind a long one-liner.

This patch adds writeCLIError(w, err, verbose): it uses errors.As to
detect *git.OpError and prints a two-line summary:

    Error: checkout branch failed
      already on main

When GGC_VERBOSE=1 is set, a third line shows the raw git command for
debugging. All other errors keep the historical single-line format, so
no existing test or user workflow changes.

Adds main_cli_error_test.go covering plain, OpError, verbose, and
errors.Join-wrapped OpError cases.

Author: bmf-san

main.go

@@ -3,6 +3,9 @@ package main
 
 import (
 	"context"
+	"errors"
+	"fmt"
+	"io"
 	"os"
 	"os/signal"
 	"runtime/debug"
@@ -76,7 +79,26 @@ func RunApp(args []string) error {
 
 func main() {
 	if err := RunApp(os.Args[1:]); err != nil {
-		_, _ = os.Stderr.WriteString("Error: " + err.Error() + "\n")
+		writeCLIError(os.Stderr, err, os.Getenv("GGC_VERBOSE") == "1")
 		os.Exit(1)
 	}
 }
+
+// writeCLIError renders a terminal-facing error consistently across the CLI.
+//
+// For *git.OpError we print a two-line summary (what failed, then the
+// underlying message). The raw git command is only shown when GGC_VERBOSE=1
+// because it can be long and is usually noise in normal use. Non-git errors
+// keep their historical single-line format so we don't churn existing tests
+// or user expectations.
+func writeCLIError(w io.Writer, err error, verbose bool) {
+	var opErr *git.OpError
+	if errors.As(err, &opErr) {
+		_, _ = fmt.Fprintf(w, "Error: %s failed\n  %s\n", opErr.Op, opErr.Err)
+		if verbose && opErr.Command != "" {
+			_, _ = fmt.Fprintf(w, "  command: %s\n", opErr.Command)
+		}
+		return
+	}
+	_, _ = fmt.Fprintf(w, "Error: %s\n", err.Error())
+}

main_cli_error_test.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/bmf-san/ggc/v8/internal/git"
+)
+
+func TestWriteCLIError_PlainError(t *testing.T) {
+	var buf bytes.Buffer
+	writeCLIError(&buf, errors.New("boom"), false)
+	got := buf.String()
+	want := "Error: boom\n"
+	if got != want {
+		t.Fatalf("plain error: got %q, want %q", got, want)
+	}
+}
+
+func TestWriteCLIError_OpErrorHidesCommandByDefault(t *testing.T) {
+	var buf bytes.Buffer
+	err := git.NewOpError("checkout branch", "git checkout main", errors.New("already on main"))
+	writeCLIError(&buf, err, false)
+	got := buf.String()
+
+	if !strings.Contains(got, "Error: checkout branch failed") {
+		t.Errorf("missing op summary: %q", got)
+	}
+	if !strings.Contains(got, "already on main") {
+		t.Errorf("missing underlying message: %q", got)
+	}
+	if strings.Contains(got, "git checkout main") {
+		t.Errorf("raw command leaked without verbose mode: %q", got)
+	}
+}
+
+func TestWriteCLIError_OpErrorVerboseShowsCommand(t *testing.T) {
+	var buf bytes.Buffer
+	err := git.NewOpError("checkout branch", "git checkout main", errors.New("already on main"))
+	writeCLIError(&buf, err, true)
+	got := buf.String()
+
+	if !strings.Contains(got, "command: git checkout main") {
+		t.Errorf("verbose mode should include command: %q", got)
+	}
+}
+
+func TestWriteCLIError_WrappedOpError(t *testing.T) {
+	var buf bytes.Buffer
+	inner := git.NewOpError("push", "git push origin main", errors.New("rejected"))
+	wrapped := errors.Join(inner, errors.New("post-run cleanup also failed"))
+	writeCLIError(&buf, wrapped, false)
+	got := buf.String()
+
+	if !strings.Contains(got, "Error: push failed") {
+		t.Errorf("errors.As through join should still find OpError: %q", got)
+	}
+}