feat: add pi and omp agent vendors (#639)

* feat: add pi and omp agent vendors

Support Pi (pi) and Oh My Pi (omp) as fresh-run agent vendors, following
the grok-build pattern: config/CLI allowlists, spawn argv defaults,
model catalog probe, dashboard selectors, and docs. Native resume and
interactive takeover remain unsupported.

* fix: preserve opaque Pi model identifiers

Parse rows by the aligned pi model table structure instead of enforcing a lowercase identifier alphabet, and cover uppercase/colon values.

Generated-By: looper 0.11.8 (runner=fixer, agent=codex)

Author: mrcfps

README.md

@@ -35,7 +35,7 @@ The loops compose: planner hands off to reviewer↔fixer, reviewer↔fixer hands
 - 🐙 **The forge is the source of truth.** Issues, PRs, labels, reviews, and assignees *are* the workflow — no external task tracker, no YAML pipeline. GitHub is fully supported; Forgejo supports planner, worker, native reviewer requests/reviews, and summary-comment compatibility flows.
 - 🛰️ **Many repos, one daemon.** Register your projects once — Looper watches them together and runs loops across repos in parallel.
 - 🌳 **Parallel-safe by design.** Every loop runs in its own git worktree, so agents work across issues and repos without stepping on each other.
-- 🤖 **Bring your own agent.** Pluggable vendor layer (`opencode`, `claude-code`, `codex`, `cursor-cli`, `grok-build`) so you're not locked into one model or CLI.
+- 🤖 **Bring your own agent.** Pluggable vendor layer (`opencode`, `claude-code`, `codex`, `cursor-cli`, `grok-build`, `pi`, `omp`) so you're not locked into one model or CLI.
 - 🧰 **Local, inspectable, stoppable.** Daemon on your machine, thin CLI to drive it. `looper ps`, `looper logs`, `looper stop` — no hosted control plane.
 
 ## Quick start
@@ -120,7 +120,7 @@ looper takeover acme/repo#42
 - starts a continuous **reviewer** loop and **fixer** loop on the PR, which ping-pong until the review comes back clean;
 - with `--merge`, lets the reviewer enable GitHub auto-merge so the PR merges itself once it's approved and green.
 
-It picks your coding agent automatically when exactly one of `claude` / `codex` / `grok` / `opencode` is on `PATH`, prompts when it's ambiguous, and accepts `--agent-vendor` / `--yes` for non-interactive (agent-driven) runs:
+It picks your coding agent automatically when exactly one of `claude` / `codex` / `grok` / `opencode` / `pi` / `omp` is on `PATH`, prompts when it's ambiguous, and accepts `--agent-vendor` / `--yes` for non-interactive (agent-driven) runs:
 
 ```bash
 looper takeover acme/repo#42 --merge --agent-vendor claude-code
@@ -135,7 +135,7 @@ looper takeover stop acme/repo#42    # stop this takeover's reviewer + fixer loo
 looper takeover stop --all
 ```
 
-Requirements: `git`, an authenticated `gh`, and one supported agent CLI installed locally (the agent runs on your machine with your own credentials). Grok Build from xAI uses `agent.vendor = "grok-build"` and the `grok` executable; see [Grok Build configuration](docs/configuration.md#grok-build-xai) for daemon authentication and automation limits.
+Requirements: `git`, an authenticated `gh`, and one supported agent CLI installed locally (the agent runs on your machine with your own credentials). Grok Build from xAI uses `agent.vendor = "grok-build"` and the `grok` executable; see [Grok Build configuration](docs/configuration.md#grok-build-xai). Pi uses `agent.vendor = "pi"` (`pi` binary); Oh My Pi uses `agent.vendor = "omp"` (`omp` binary)—see [Pi](docs/configuration.md#pi) and [Oh My Pi](docs/configuration.md#oh-my-pi-omp).
 
 ### One-liner for not-yet-installed users
 

docs/configuration.md

@@ -369,6 +369,36 @@ For fresh unattended runs, Looper supplies `--always-approve` and `--sandbox off
 
 Grok Build support is fresh-run only. Daemon native resume and interactive takeover through `looper resume` are unsupported. A retry uses a fresh checkpoint prompt, and Looper never uses Grok Build's ambient `--continue`.
 
+## Pi
+
+Use `pi` as the `agent.vendor` identifier. Looper invokes the [Pi](https://pi.dev) coding agent executable as `pi`:
+
+```toml
+[agent]
+vendor = "pi"
+```
+
+Authenticate via Pi's own login/config (project-local `.pi` and vendor credentials). Prefer vendor authentication over storing secrets in Looper configuration.
+
+For fresh unattended runs, Looper supplies `-p` with the generated task prompt and `--approve` (trusts project-local `.pi` for the run). Configured `agent.params.args` override these defaults: if `-p`/`--print` is already present, Looper does not append its prompt (operator owns print/prompt); if any of `-a`/`--approve`/`-na`/`--no-approve` is present, Looper does not add `--approve`. There is no `--cwd` flag—Looper sets the process working directory to the worktree.
+
+Pi support is fresh-run only. Daemon native resume and interactive takeover through `looper resume` are unsupported. A retry uses a fresh checkpoint prompt.
+
+## Oh My Pi (omp)
+
+Use `omp` as the `agent.vendor` identifier (not `oh-my-pi`). Looper invokes the [Oh My Pi](https://omp.sh) executable as `omp`:
+
+```toml
+[agent]
+vendor = "omp"
+```
+
+Authenticate via omp's own login/config. Prefer vendor authentication over storing secrets in Looper configuration.
+
+For fresh unattended runs, Looper supplies `-p` with the generated task prompt, `--cwd <worktree>` when the workdir is non-empty, and `--auto-approve`. Configured arguments override defaults: if `-p`/`--print` is already present, Looper does not append its prompt; if `--cwd` is present, Looper does not add workdir; if `--auto-approve` or `--approval-mode` (including `--approval-mode=...`) is present, Looper does not add `--auto-approve`.
+
+Oh My Pi support is fresh-run only. Daemon native resume and interactive takeover through `looper resume` are unsupported. A retry uses a fresh checkpoint prompt.
+
 ## Provider support
 
 Looper supports three provider kinds:

docs/users-guide.md

@@ -45,6 +45,14 @@ For xAI Grok Build, configure `agent.vendor = "grok-build"`; Looper runs the `gr
 
 Configured Grok arguments take precedence: `--permission-mode` can prompt or fail unattended work, a non-`plain` `--output-format` can break direct completion-marker parsing, and `-p`/`--single` replaces Looper's generated task prompt. Grok Build has no daemon native resume or interactive `looper resume` takeover. Retries start with a fresh checkpoint prompt; Looper never uses ambient `--continue`.
 
+### Pi
+
+For Pi ([pi.dev](https://pi.dev)), configure `agent.vendor = "pi"`; Looper runs the `pi` executable. Authenticate with Pi's own login/config (project-local `.pi`). Looper defaults to `-p <prompt> --approve` for unattended fresh runs. Configured `-p`/`--print` means you own the prompt; any of `-a`/`--approve`/`-na`/`--no-approve` skips the default approve flag. Pi has no daemon native resume or interactive `looper resume` takeover.
+
+### Oh My Pi (omp)
+
+For Oh My Pi ([omp.sh](https://omp.sh)), configure `agent.vendor = "omp"` (not `oh-my-pi`); Looper runs the `omp` executable. Authenticate with omp's own login/config. Looper defaults to `-p <prompt> --cwd <worktree> --auto-approve`. Configured print, cwd, or approval flags (`--auto-approve` / `--approval-mode`) override those defaults. Oh My Pi has no daemon native resume or interactive `looper resume` takeover.
+
 ## 1a. Local-only vs Routed projects
 
 Looper supports two project modes:
@@ -562,7 +570,7 @@ looper takeover owner/repo#42 --merge   # also auto-merge once approved + green
 3. starts a continuous reviewer loop and fixer loop on the target PR (skip the fixer with `--no-fix`);
 4. with `--merge`, sets `roles.reviewer.autoMerge.enabled` for the project so the reviewer enables GitHub auto-merge once the PR is approved and checks are green.
 
-Agent selection: `takeover` reuses the vendor already in your config; otherwise it auto-detects an installed `claude` / `codex` / `grok` / `opencode` CLI, prompts when the choice is ambiguous, and accepts `--agent-vendor` plus `--yes` for non-interactive runs. Auto-merge still depends on the repository allowing it (and, by default, on branch protection with required checks); when GitHub refuses, the reviewer keeps reviewing and reports why instead.
+Agent selection: `takeover` reuses the vendor already in your config; otherwise it auto-detects an installed `claude` / `codex` / `grok` / `opencode` / `pi` / `omp` CLI, prompts when the choice is ambiguous, and accepts `--agent-vendor` plus `--yes` for non-interactive runs. Auto-merge still depends on the repository allowing it (and, by default, on branch protection with required checks); when GitHub refuses, the reviewer keeps reviewing and reports why instead.
 
 Manage and stop takeovers:
 

internal/agent/executor.go

@@ -1967,7 +1967,8 @@ func shellSingleQuote(s string) string {
 
 // ResolveCommand returns the agent binary used for spawn for vendor + params.
 // When params["command"] is a non-empty string it wins; otherwise vendor defaults
-// apply (claude, codex, opencode, agent for cursor-cli, grok for grok-build).
+// apply (claude, codex, opencode, agent for cursor-cli, grok for grok-build,
+// pi for pi, omp for omp).
 // Same resolution as process spawn — callers may LookPath for an absolute path.
 func ResolveCommand(vendor config.AgentVendor, params map[string]any) string {
 	return resolveCommand(ExecutorConfig{Vendor: vendor, Params: params})
@@ -1985,6 +1986,7 @@ func resolveCommand(cfg ExecutorConfig) string {
 	case config.AgentVendorGrokBuild:
 		return "grok"
 	default:
+		// pi, omp, codex, opencode, and any future vendor whose id matches the binary.
 		return string(cfg.Vendor)
 	}
 }
@@ -2002,6 +2004,10 @@ func resolveArgs(cfg ExecutorConfig, workingDirectory string, prompt string) []s
 		return resolveCursorArgs(cfg, resolvedArgs, prompt)
 	case config.AgentVendorGrokBuild:
 		return resolveGrokArgs(cfg, resolvedArgs, workingDirectory, prompt)
+	case config.AgentVendorPi:
+		return resolvePiArgs(cfg, resolvedArgs, prompt)
+	case config.AgentVendorOmp:
+		return resolveOmpArgs(cfg, resolvedArgs, workingDirectory, prompt)
 	default:
 		return append([]string{}, resolvedArgs...)
 	}
@@ -2079,6 +2085,38 @@ func resolveGrokArgs(cfg ExecutorConfig, args []string, workingDirectory string,
 	return resolved
 }
 
+// resolvePiArgs builds argv for the Pi coding agent (https://pi.dev).
+// -p/--print is boolean; the prompt is a positional message. No --cwd flag —
+// Looper already sets process cmd.Dir to the worktree. Fresh-run only.
+func resolvePiArgs(cfg ExecutorConfig, args []string, prompt string) []string {
+	resolved := prependModelFlag(args, cfg.Model, "--model", []string{"--model"})
+	if !hasAnyFlag(resolved, []string{"-p", "--print"}) {
+		// Operator-owned print/prompt: when -p/--print is already configured,
+		// do not append Looper's generated prompt (matches claude-code).
+		resolved = append(resolved, "-p", prompt)
+	}
+	if !hasAnyFlag(resolved, []string{"-a", "--approve", "-na", "--no-approve"}) {
+		resolved = append(resolved, "--approve")
+	}
+	return resolved
+}
+
+// resolveOmpArgs builds argv for Oh My Pi / omp (https://omp.sh).
+// Print mode matches pi (-p/--print boolean + positional prompt). Fresh-run only.
+func resolveOmpArgs(cfg ExecutorConfig, args []string, workingDirectory string, prompt string) []string {
+	resolved := prependModelFlag(args, cfg.Model, "--model", []string{"--model"})
+	if !hasAnyFlag(resolved, []string{"-p", "--print"}) {
+		resolved = append(resolved, "-p", prompt)
+	}
+	if strings.TrimSpace(workingDirectory) != "" && !hasAnyFlag(resolved, []string{"--cwd"}) {
+		resolved = append(resolved, "--cwd", workingDirectory)
+	}
+	if !hasAnyFlag(resolved, []string{"--auto-approve", "--approval-mode"}) {
+		resolved = append(resolved, "--auto-approve")
+	}
+	return resolved
+}
+
 func resolveNativeResumeArgs(cfg ExecutorConfig, workingDirectory string, args []string, sessionID string, prompt string) []string {
 	switch cfg.Vendor {
 	case config.AgentVendorClaudeCode:

internal/agent/modelcatalog/catalog.go

@@ -338,7 +338,7 @@ func cloneResult(in Result) Result {
 func isKnownVendor(vendor config.AgentVendor) bool {
 	switch vendor {
 	case config.AgentVendorClaudeCode, config.AgentVendorCodex, config.AgentVendorOpenCode,
-		config.AgentVendorCursorCLI, config.AgentVendorGrokBuild:
+		config.AgentVendorCursorCLI, config.AgentVendorGrokBuild, config.AgentVendorPi, config.AgentVendorOmp:
 		return true
 	default:
 		return false
@@ -347,7 +347,8 @@ func isKnownVendor(vendor config.AgentVendor) bool {
 
 func supportsProbe(vendor config.AgentVendor) bool {
 	switch vendor {
-	case config.AgentVendorCodex, config.AgentVendorOpenCode, config.AgentVendorCursorCLI, config.AgentVendorGrokBuild:
+	case config.AgentVendorCodex, config.AgentVendorOpenCode, config.AgentVendorCursorCLI, config.AgentVendorGrokBuild,
+		config.AgentVendorPi, config.AgentVendorOmp:
 		return true
 	default:
 		return false

internal/agent/modelcatalog/catalog_test.go

@@ -41,6 +41,8 @@ func TestLoadStaticCatalog(t *testing.T) {
 		config.AgentVendorOpenCode,
 		config.AgentVendorCursorCLI,
 		config.AgentVendorGrokBuild,
+		config.AgentVendorPi,
+		config.AgentVendorOmp,
 	} {
 		if len(catalog[vendor]) == 0 {
 			t.Fatalf("static catalog empty for %s", vendor)
@@ -157,6 +159,55 @@ func TestParseCursorAndGrokFixtures(t *testing.T) {
 	}
 }
 
+func TestParsePiModelsFixture(t *testing.T) {
+	got := parsePiModels(readTestdata(t, "pi_models.txt"))
+	want := []string{"openai/gpt-4o", "anthropic/claude-sonnet-4-5", "google/gemini-2.5-pro"}
+	if !reflect.DeepEqual(modelIDs(got), want) {
+		t.Fatalf("pi ids = %#v, want %#v", modelIDs(got), want)
+	}
+	for _, m := range got {
+		if m.Source != SourceProbe {
+			t.Fatalf("source = %q, want probe", m.Source)
+		}
+	}
+}
+
+func TestParsePiModelsSkipsHeaderAndNoise(t *testing.T) {
+	raw := []byte("provider  model  context\nNot logged in\nopenai  gpt-4o  128K\n")
+	got := parsePiModels(raw)
+	if !reflect.DeepEqual(modelIDs(got), []string{"openai/gpt-4o"}) {
+		t.Fatalf("ids = %#v", modelIDs(got))
+	}
+}
+
+func TestParsePiModelsPreservesOpaqueIdentifiers(t *testing.T) {
+	raw := []byte("provider  model  context\nAcme:Cloud  Model:Preview  128K\n")
+	got := parsePiModels(raw)
+	if !reflect.DeepEqual(modelIDs(got), []string{"Acme:Cloud/Model:Preview"}) {
+		t.Fatalf("ids = %#v", modelIDs(got))
+	}
+}
+
+func TestParseOmpModelsFixture(t *testing.T) {
+	got, err := parseOmpModels(readTestdata(t, "omp_models.json"))
+	if err != nil {
+		t.Fatalf("parseOmpModels() error = %v", err)
+	}
+	want := []string{"anthropic/claude-sonnet-4-5", "openai/gpt-5.4", "google/gemini-2.5-pro", "sonnet"}
+	if !reflect.DeepEqual(modelIDs(got), want) {
+		t.Fatalf("omp ids = %#v, want %#v", modelIDs(got), want)
+	}
+	if got[0].Label != "Claude Sonnet 4.5" {
+		t.Fatalf("label = %q, want Claude Sonnet 4.5", got[0].Label)
+	}
+	if got[2].ID != "google/gemini-2.5-pro" || got[2].Label != "Gemini 2.5 Pro" {
+		t.Fatalf("provider/id fallback entry = %#v", got[2])
+	}
+	if got[3].ID != "sonnet" || got[3].Label != "Sonnet alias" {
+		t.Fatalf("bare id entry = %#v", got[3])
+	}
+}
+
 func TestParseLineModelsRejectsLoggedOutWarning(t *testing.T) {
 	raw := []byte("Not logged in\nPlease authenticate first\nauto - Auto\n")
 	got := parseLineModels(raw)

internal/agent/modelcatalog/parse.go

@@ -19,6 +19,124 @@ func parseGrokModels(stdout []byte) []Model {
 	return parseTableOrIDLines(stdout)
 }
 
+// parsePiModels parses `pi --list-models` multi-column table output:
+//
+//	provider               model                                               context  ...
+//	openai                 gpt-4o                                              128K     ...
+//
+// Model IDs are provider/model when both columns are present (pi accepts that form).
+func parsePiModels(stdout []byte) []Model {
+	lines := strings.Split(string(stdout), "\n")
+	out := make([]Model, 0, len(lines))
+	seen := make(map[string]struct{})
+	inTable := false
+	columnCount := 0
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" || shouldSkipDecorLine(line) {
+			continue
+		}
+		columns := splitPiTableColumns(line)
+		if len(columns) >= 2 && strings.EqualFold(columns[0], "provider") && strings.EqualFold(columns[1], "model") {
+			inTable = true
+			columnCount = len(columns)
+			continue
+		}
+		if !inTable || len(columns) != columnCount {
+			continue
+		}
+		provider := columns[0]
+		model := columns[1]
+		id := provider + "/" + model
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		out = append(out, Model{ID: id, Source: SourceProbe})
+	}
+	return out
+}
+
+// splitPiTableColumns splits the aligned columns emitted by pi --list-models.
+// Two or more spaces (or a tab) delimit columns; single spaces stay in values.
+func splitPiTableColumns(line string) []string {
+	var columns []string
+	start := 0
+	for i := 0; i < len(line); {
+		if line[i] != '\t' && line[i] != ' ' {
+			i++
+			continue
+		}
+		end := i + 1
+		for end < len(line) && (line[end] == ' ' || line[end] == '\t') {
+			end++
+		}
+		if line[i] == '\t' || end-i >= 2 {
+			if column := strings.TrimSpace(line[start:i]); column != "" {
+				columns = append(columns, column)
+			}
+			start = end
+		}
+		i = end
+	}
+	if column := strings.TrimSpace(line[start:]); column != "" {
+		columns = append(columns, column)
+	}
+	return columns
+}
+
+type ompModelsPayload struct {
+	Models []ompModelEntry `json:"models"`
+}
+
+type ompModelEntry struct {
+	Provider string `json:"provider"`
+	ID       string `json:"id"`
+	Selector string `json:"selector"`
+	Name     string `json:"name"`
+}
+
+// parseOmpModels parses `omp models --json` output. Prefer selector as Model.ID;
+// fallback provider/id or bare id. Use name as Label when present.
+func parseOmpModels(stdout []byte) ([]Model, error) {
+	trimmed := bytesTrimSpace(stdout)
+	if len(trimmed) == 0 {
+		return nil, nil
+	}
+	var payload ompModelsPayload
+	if err := json.Unmarshal(trimmed, &payload); err != nil {
+		var arr []ompModelEntry
+		if err2 := json.Unmarshal(trimmed, &arr); err2 != nil {
+			return nil, err
+		}
+		payload.Models = arr
+	}
+	out := make([]Model, 0, len(payload.Models))
+	seen := make(map[string]struct{})
+	for _, e := range payload.Models {
+		id := strings.TrimSpace(e.Selector)
+		if id == "" {
+			provider := strings.TrimSpace(e.Provider)
+			rawID := strings.TrimSpace(e.ID)
+			switch {
+			case provider != "" && rawID != "":
+				id = provider + "/" + rawID
+			case rawID != "":
+				id = rawID
+			default:
+				continue
+			}
+		}
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		label := strings.TrimSpace(e.Name)
+		out = append(out, Model{ID: id, Label: label, Source: SourceProbe})
+	}
+	return out, nil
+}
+
 // parseLineModels is the shared text parser used by cursor/grok-style output.
 // Kept as an alias for tests and call sites that want the table-tolerant path.
 func parseLineModels(stdout []byte) []Model {

internal/agent/modelcatalog/probe.go

@@ -303,6 +303,18 @@ func (s *Service) probe(ctx context.Context, vendor config.AgentVendor, binary s
 			return nil, err
 		}
 		return parseGrokModels(out), nil
+	case config.AgentVendorPi:
+		out, err := s.runner.Run(runCtx, env, binary, "--list-models")
+		if err != nil {
+			return nil, err
+		}
+		return parsePiModels(out), nil
+	case config.AgentVendorOmp:
+		out, err := s.runner.Run(runCtx, env, binary, "models", "--json")
+		if err != nil {
+			return nil, err
+		}
+		return parseOmpModels(out)
 	default:
 		return nil, errors.New("probe unsupported")
 	}