relay-flow 0.0.1

package/internal/daemon/daemon.go

@@ -0,0 +1,218 @@
+// Package daemon runs one workflow's poll loop: list tickets from the
+// tasks adapter, route each through the 3-way claim switch, and dispatch
+// agent sessions through the runner adapter. It contains no tracker- or
+// runner-specific logic — both arrive as interfaces.
+package daemon
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/tasks"
+)
+
+// Daemon polls one workflow and dispatches tickets. Long-lived: one poll
+// goroutine per submitted workflow; dispatch/bounce run as short-lived
+// goroutines per ticket.
+type Daemon struct {
+	cfg      *config.Config
+	tasks    tasks.Tasks
+	runner   runner.Runner
+	repoID   string
+	repoName string
+	dryRun   bool
+
+	// nudged marks key → node for which a prompt/nudge was already
+	// delivered, so each node visit prompts exactly once. Cleared when a
+	// report moves the ticket (re-arming the next visit).
+	nudgedMu sync.Mutex
+	nudged   map[string]string
+
+	wg sync.WaitGroup // tracks dispatch/bounce goroutines; Wait blocks tests
+}
+
+// New builds a daemon for one validated workflow config.
+func New(cfg *config.Config, tk tasks.Tasks, rn runner.Runner, repoID, repoName string, dryRun bool) *Daemon {
+	return &Daemon{
+		cfg: cfg, tasks: tk, runner: rn,
+		repoID: repoID, repoName: repoName, dryRun: dryRun,
+		nudged: map[string]string{},
+	}
+}
+
+// PollLoop ticks until ctx is cancelled (server shutdown/remove).
+func (d *Daemon) PollLoop(ctx context.Context) {
+	interval := time.Duration(d.cfg.PollIntervalSeconds) * time.Second
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+	d.PollOnce()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			d.PollOnce()
+		}
+	}
+}
+
+// Wait blocks until in-flight dispatch/bounce goroutines finish. Tests
+// call it after PollOnce; production never needs it.
+func (d *Daemon) Wait() { d.wg.Wait() }
+
+// PollOnce lists tickets once and routes each:
+//
+//	claimed by another workflow → skip (cross-workflow mutex)
+//	unmapped tracker state        → log + skip
+//	node in closeOn               → runner.Close (terminal teardown)
+//	claimed by me, not prompted   → bounce: Find → Nudge (or respawn)
+//	unclaimed                     → dispatch: Claim → Spawn
+func (d *Daemon) PollOnce() {
+	found, err := d.tasks.List()
+	if err != nil {
+		log.Printf("poll %s: %v", d.cfg.Name, err)
+		return
+	}
+	for _, t := range found {
+		switch {
+		case t.ClaimedBy != "" && t.ClaimedBy != d.cfg.Name:
+			// Foreign workflow owns it — never touch.
+		case t.Node == "":
+			log.Printf("poll %s: %s at unmapped state, skipping", d.cfg.Name, t.Key)
+		case d.cfg.CloseOn.Has(t.Node):
+			log.Printf("poll %s: %s at terminal node %q, closing terminals", d.cfg.Name, t.Key, t.Node)
+			if err := d.runner.Close(t); err != nil {
+				log.Printf("poll %s: close %s: %v", d.cfg.Name, t.Key, err)
+			}
+			d.ClearNudged(t.Key)
+		case d.cfg.Nodes[t.Node].Agent == "":
+			// Human gate: no automation. Claim it so foreign workflows
+			// leave it alone, then leave the ticket for the human.
+			if t.ClaimedBy == "" {
+				if err := d.tasks.Claim(t); err != nil {
+					log.Printf("poll %s: claim %s (gate node): %v", d.cfg.Name, t.Key, err)
+				}
+			}
+		case t.ClaimedBy == d.cfg.Name:
+			d.wg.Add(1)
+			go d.bounce(t)
+		default:
+			d.wg.Add(1)
+			go d.dispatch(t)
+		}
+	}
+}
+
+// dispatch claims an unclaimed ticket and spawns its agent session.
+func (d *Daemon) dispatch(t tasks.Ticket) {
+	defer d.wg.Done()
+	node := d.cfg.Nodes[t.Node]
+	if err := d.tasks.Claim(t); err != nil {
+		log.Printf("dispatch %s: claim: %v", t.Key, err)
+		return
+	}
+	prompt := initialPrompt(d.cfg, t.Node, t)
+	env := map[string]string{
+		"RELAY_FLOW_WORKFLOW": d.cfg.Name,
+		"RELAY_FLOW_TICKET":   t.Key,
+		"RELAY_FLOW_NODE":     t.Node,
+		"RELAY_FLOW_AGENT":    node.Agent,
+	}
+	if err := d.runner.Spawn(t, t.Node, node.Agent, prompt, env); err != nil {
+		log.Printf("dispatch %s: spawn: %v", t.Key, err)
+		return
+	}
+	d.markNudged(t.Key, t.Node)
+	log.Printf("dispatch %s: spawned %q for node %q", t.Key, node.Agent, t.Node)
+}
+
+// bounce handles a ticket this workflow claimed but has no in-memory
+// record of (server restart): find the live terminal and nudge it, once
+// per node visit. No terminal → spawn fresh (claim already held).
+func (d *Daemon) bounce(t tasks.Ticket) {
+	defer d.wg.Done()
+	node := d.cfg.Nodes[t.Node]
+	sess, ok, err := d.runner.Find(t, t.Node)
+	if err != nil {
+		log.Printf("bounce %s: find: %v", t.Key, err)
+		return
+	}
+	if !ok {
+		// No live session: marker is irrelevant — always respawn (a
+		// terminal may have died after we marked it prompted).
+		d.ClearNudged(t.Key)
+		// Crash took the terminal with it: spawn a fresh session.
+		prompt := initialPrompt(d.cfg, t.Node, t)
+		env := map[string]string{
+			"RELAY_FLOW_WORKFLOW": d.cfg.Name,
+			"RELAY_FLOW_TICKET":   t.Key,
+			"RELAY_FLOW_NODE":     t.Node,
+			"RELAY_FLOW_AGENT":    node.Agent,
+		}
+		if err := d.runner.Spawn(t, t.Node, node.Agent, prompt, env); err != nil {
+			log.Printf("bounce %s: spawn: %v", t.Key, err)
+			return
+		}
+		d.markNudged(t.Key, t.Node)
+		log.Printf("bounce %s: no live session, spawned fresh for node %q", t.Key, t.Node)
+		return
+	}
+	if d.nudgedNode(t.Key) == t.Node {
+		return // session alive and already prompted for this visit
+	}
+	prompt := renderNudge(node.NudgePrompt, t.Key, t.Node)
+	if err := d.runner.Nudge(sess, prompt); err != nil {
+		log.Printf("bounce %s: nudge: %v (retry next poll)", t.Key, err)
+		return
+	}
+	d.markNudged(t.Key, t.Node)
+	log.Printf("bounce %s: nudged %q for node %q", t.Key, sess.Title, t.Node)
+}
+
+// ClearNudged drops the prompted marker for a ticket — called when a
+// report moves it to a new node, re-arming the next visit's nudge.
+func (d *Daemon) ClearNudged(key string) {
+	d.nudgedMu.Lock()
+	delete(d.nudged, key)
+	d.nudgedMu.Unlock()
+}
+
+func (d *Daemon) markNudged(key, node string) {
+	d.nudgedMu.Lock()
+	d.nudged[key] = node
+	d.nudgedMu.Unlock()
+}
+
+func (d *Daemon) nudgedNode(key string) string {
+	d.nudgedMu.Lock()
+	defer d.nudgedMu.Unlock()
+	return d.nudged[key]
+}
+
+// initialPrompt tells the agent which ticket it owns and the STATUS/
+// SUMMARY handoff contract (statuses success|failure). The agent fetches
+// ticket details itself via acli — nothing is injected here so feedback
+// is always picked up fresh. Flattened to one line: the command is typed
+// into a pty via keystroke simulation.
+func initialPrompt(cfg *config.Config, nodeName string, t tasks.Ticket) string {
+	prompt := fmt.Sprintf(
+		"You have been assigned ticket %s. Run `acli jira workitem view %s --fields summary,description,comment --json` "+
+			"to fetch its details and full comment history. When you are done, end your final message with exactly: "+
+			"STATUS: <success or failure> SUMMARY: <one-line summary of what you did>",
+		t.Key, t.Key)
+	return strings.Join(strings.Fields(prompt), " ")
+}
+
+// renderNudge applies {{ticket}}/{{node}} templating and flattens to one
+// line (keystroke simulation submits on newline).
+func renderNudge(tmpl, ticket, node string) string {
+	s := strings.ReplaceAll(tmpl, "{{ticket}}", ticket)
+	s = strings.ReplaceAll(s, "{{node}}", node)
+	return strings.Join(strings.Fields(s), " ")
+}

package/internal/daemon/daemon_test.go

@@ -0,0 +1,204 @@
+package daemon
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/tasks"
+)
+
+func testConfig() *config.Config {
+	return &config.Config{
+		Name:                "wf",
+		PollIntervalSeconds: 15,
+		CloseOn:             config.StringList{"done"},
+		Nodes: map[string]config.Node{
+			"coding":    {Agent: "build", When: "In Progress", OnSuccess: "reviewing", OnFailure: "coding", NudgePrompt: "back to work on {{ticket}} at {{node}}"},
+			"reviewing": {Agent: "build", When: "In Review", OnSuccess: "done", OnFailure: "coding", NudgePrompt: "review {{ticket}}"},
+			"done":      {When: "Done"},
+		},
+	}
+}
+
+type fakeTasks struct {
+	listed  []Ticket
+	claims  []string
+	reports []string
+}
+
+type Ticket = tasks.Ticket
+
+func (f *fakeTasks) List() ([]tasks.Ticket, error) { return f.listed, nil }
+func (f *fakeTasks) Claim(t tasks.Ticket) error {
+	f.claims = append(f.claims, t.Key)
+	return nil
+}
+func (f *fakeTasks) Report(t tasks.Ticket, outcome, targetNode, summary string) error {
+	f.reports = append(f.reports, t.Key+":"+outcome+":"+targetNode)
+	return nil
+}
+
+type fakeRunner struct {
+	spawned []string
+	nudged  []string
+	closed  []string
+	found   map[string]runner.Session
+}
+
+func (f *fakeRunner) Spawn(t tasks.Ticket, node, agent, prompt string, env map[string]string) error {
+	f.spawned = append(f.spawned, t.Key+":"+node+":"+agent+":"+env["RELAY_FLOW_WORKFLOW"]+":"+env["RELAY_FLOW_TICKET"])
+	return nil
+}
+func (f *fakeRunner) Find(t tasks.Ticket, node string) (runner.Session, bool, error) {
+	s, ok := f.found[t.Key+":"+node]
+	return s, ok, nil
+}
+func (f *fakeRunner) Nudge(s runner.Session, prompt string) error {
+	f.nudged = append(f.nudged, s.Title+":"+prompt)
+	return nil
+}
+func (f *fakeRunner) Close(t tasks.Ticket) error {
+	f.closed = append(f.closed, t.Key)
+	return nil
+}
+
+func newDaemon(ft *fakeTasks, fr *fakeRunner) *Daemon {
+	return New(testConfig(), ft, fr, "repo-1", "repo:xyz", false)
+}
+
+func TestPollDispatchesUnclaimed(t *testing.T) {
+	ft := &fakeTasks{listed: []Ticket{{Key: "XYZ-1", Node: "coding"}}}
+	fr := &fakeRunner{}
+	d := newDaemon(ft, fr)
+	d.PollOnce()
+	d.Wait()
+	if len(ft.claims) != 1 || ft.claims[0] != "XYZ-1" {
+		t.Errorf("claims = %v", ft.claims)
+	}
+	if len(fr.spawned) != 1 || fr.spawned[0] != "XYZ-1:coding:build:wf:XYZ-1" {
+		t.Errorf("spawned = %v", fr.spawned)
+	}
+}
+
+func TestPollSkipsForeignClaim(t *testing.T) {
+	ft := &fakeTasks{listed: []Ticket{{Key: "XYZ-1", Node: "coding", ClaimedBy: "otherFlow"}}}
+	fr := &fakeRunner{}
+	d := newDaemon(ft, fr)
+	d.PollOnce()
+	d.Wait()
+	if len(ft.claims) != 0 || len(fr.spawned) != 0 {
+		t.Errorf("foreign ticket touched: claims=%v spawned=%v", ft.claims, fr.spawned)
+	}
+}
+
+func TestPollSkipsUnmappedState(t *testing.T) {
+	ft := &fakeTasks{listed: []Ticket{{Key: "XYZ-1", Node: ""}}}
+	fr := &fakeRunner{}
+	d := newDaemon(ft, fr)
+	d.PollOnce()
+	d.Wait()
+	if len(fr.spawned) != 0 || len(fr.closed) != 0 {
+		t.Errorf("unmapped ticket touched: spawned=%v closed=%v", fr.spawned, fr.closed)
+	}
+}
+
+func TestPollHumanGateNode(t *testing.T) {
+	cfg := testConfig()
+	cfg.Nodes["gate"] = config.Node{When: "In Review"} // agentless, not in closeOn
+	ft := &fakeTasks{listed: []Ticket{{Key: "XYZ-5", Node: "gate"}}}
+	fr := &fakeRunner{}
+	d := New(cfg, ft, fr, "repo-1", "repo:xyz", false)
+	d.PollOnce()
+	d.Wait()
+	if len(fr.spawned) != 0 || len(fr.nudged) != 0 || len(fr.closed) != 0 {
+		t.Errorf("gate node must not spawn/nudge/close: %+v", fr)
+	}
+	if len(ft.claims) != 1 {
+		t.Errorf("gate node must claim: %v", ft.claims)
+	}
+}
+
+func TestPollClosesTerminalNode(t *testing.T) {
+	ft := &fakeTasks{listed: []Ticket{{Key: "XYZ-1", Node: "done", ClaimedBy: "wf"}}}
+	fr := &fakeRunner{}
+	d := newDaemon(ft, fr)
+	d.PollOnce()
+	d.Wait()
+	if len(fr.closed) != 1 || fr.closed[0] != "XYZ-1" {
+		t.Errorf("closed = %v", fr.closed)
+	}
+	if len(fr.spawned) != 0 {
+		t.Errorf("terminal node must not spawn: %v", fr.spawned)
+	}
+}
+
+func TestBounceNudgesExistingSession(t *testing.T) {
+	ft := &fakeTasks{listed: []Ticket{{Key: "XYZ-1", Node: "coding", ClaimedBy: "wf"}}}
+	fr := &fakeRunner{found: map[string]runner.Session{
+		"XYZ-1:coding": {ID: "h1", Title: "XYZ-1:build:coding"},
+	}}
+	d := newDaemon(ft, fr)
+	d.PollOnce()
+	d.Wait()
+	if len(fr.spawned) != 0 {
+		t.Errorf("bounce must not spawn: %v", fr.spawned)
+	}
+	if len(fr.nudged) != 1 || fr.nudged[0] != "XYZ-1:build:coding:back to work on XYZ-1 at coding" {
+		t.Errorf("nudged = %v", fr.nudged)
+	}
+}
+
+func TestBounceWithoutSessionSpawnsFresh(t *testing.T) {
+	ft := &fakeTasks{listed: []Ticket{{Key: "XYZ-1", Node: "coding", ClaimedBy: "wf"}}}
+	fr := &fakeRunner{found: map[string]runner.Session{}}
+	d := newDaemon(ft, fr)
+	d.PollOnce()
+	d.Wait()
+	if len(fr.spawned) != 1 {
+		t.Errorf("crash-without-terminal must respawn: spawned=%v", fr.spawned)
+	}
+	if len(ft.claims) != 0 {
+		t.Errorf("already-claimed ticket must not re-claim: %v", ft.claims)
+	}
+}
+
+func TestBounceNudgesOncePerNodeVisit(t *testing.T) {
+	ft := &fakeTasks{listed: []Ticket{{Key: "XYZ-1", Node: "coding", ClaimedBy: "wf"}}}
+	fr := &fakeRunner{found: map[string]runner.Session{
+		"XYZ-1:coding": {ID: "h1", Title: "XYZ-1:build:coding"},
+	}}
+	d := newDaemon(ft, fr)
+	d.PollOnce()
+	d.Wait()
+	d.PollOnce()
+	d.Wait()
+	if len(fr.nudged) != 1 {
+		t.Errorf("same node visit must nudge once: %v", fr.nudged)
+	}
+	// Status change (report moved it) re-arms the marker.
+	d.ClearNudged("XYZ-1")
+	d.PollOnce()
+	d.Wait()
+	if len(fr.nudged) != 2 {
+		t.Errorf("re-armed marker must allow another nudge: %v", fr.nudged)
+	}
+}
+
+func TestSpawnPromptMentionsOutcomes(t *testing.T) {
+	p := initialPrompt(testConfig(), "coding", tasks.Ticket{Key: "XYZ-1"})
+	if !strings.Contains(p, "XYZ-1") || !strings.Contains(p, "success") || !strings.Contains(p, "failure") {
+		t.Errorf("prompt = %q", p)
+	}
+	if strings.Contains(p, "\n") {
+		t.Errorf("prompt must be flattened to one line")
+	}
+}
+
+func TestNudgeTemplating(t *testing.T) {
+	got := renderNudge(testConfig().Nodes["coding"].NudgePrompt, "XYZ-7", "coding")
+	if got != "back to work on XYZ-7 at coding" {
+		t.Errorf("%q", got)
+	}
+}

package/internal/discovery/discovery.go

@@ -0,0 +1,122 @@
+// Package discovery resolves the current Orca repo and manages the
+// central relay-flow server's fixed-location artifacts under ~/.relay-flow/
+// (socket + flock). Single-instance enforcement is flock-based: the
+// kernel releases the lock on any process exit, so there is no stale
+// state and no pid files anywhere.
+package discovery
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"syscall"
+)
+
+func dir(workflowName string) (string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+	d := filepath.Join(home, ".relay-flow", workflowName)
+	if err := os.MkdirAll(d, 0o755); err != nil {
+		return "", err
+	}
+	return d, nil
+}
+
+// CurrentRepo resolves the repoId and the *repo's* displayName (not the
+// worktree's own displayName, which is a different, worktree-scoped
+// value) for the repo the CLI is running in, via `orca worktree current`
+// followed by `orca repo show`.
+func CurrentRepo() (repoID, repoDisplayName string, err error) {
+	return RepoFromPath(".")
+}
+
+// RepoFromPath is CurrentRepo rooted at an arbitrary directory instead of
+// the process cwd — used by the server, which receives the repo path from
+// the submitting client.
+func RepoFromPath(path string) (repoID, repoDisplayName string, err error) {
+	cmd := exec.Command("orca", "worktree", "current", "--json")
+	cmd.Dir = path
+	out, err := cmd.Output()
+	if err != nil {
+		return "", "", fmt.Errorf("orca worktree current: %w", err)
+	}
+	var wres struct {
+		Result struct {
+			Worktree struct {
+				RepoID string `json:"repoId"`
+			} `json:"worktree"`
+		} `json:"result"`
+	}
+	if err := json.Unmarshal(out, &wres); err != nil || wres.Result.Worktree.RepoID == "" {
+		return "", "", fmt.Errorf("orca worktree current: no repoId in output")
+	}
+	repoID = wres.Result.Worktree.RepoID
+
+	repoCmd := exec.Command("orca", "repo", "show", "--repo", "id:"+repoID, "--json")
+	repoCmd.Dir = path
+	out, err = repoCmd.Output()
+	if err != nil {
+		return "", "", fmt.Errorf("orca repo show: %w", err)
+	}
+	var rres struct {
+		Result struct {
+			Repo struct {
+				DisplayName string `json:"displayName"`
+			} `json:"repo"`
+		} `json:"result"`
+	}
+	if err := json.Unmarshal(out, &rres); err != nil || rres.Result.Repo.DisplayName == "" {
+		return "", "", fmt.Errorf("orca repo show: no displayName in output")
+	}
+	return repoID, rres.Result.Repo.DisplayName, nil
+}
+
+// SocketPath returns the unix socket the central `serve` process listens
+// on: ~/.relay-flow/server.sock.
+func SocketPath() (string, error) {
+	d, err := dir("")
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(d, "server.sock"), nil
+}
+
+// ServerLockPath returns the flock file enforcing a single `serve`
+// process: ~/.relay-flow/server.lock.
+func ServerLockPath() (string, error) {
+	d, err := dir("")
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(d, "server.lock"), nil
+}
+
+// AcquireServerLock takes an exclusive non-blocking flock on the server
+// lock file. The lock is held by the kernel for the life of the returned
+// file's descriptor: process exit (clean, crash, or kill -9) releases it
+// automatically, so there is no stale-state cleanup. Returns a release
+// func (also runs at process exit implicitly).
+func AcquireServerLock() (release func(), err error) {
+	path, err := ServerLockPath()
+	if err != nil {
+		return nil, err
+	}
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
+	if err != nil {
+		return nil, err
+	}
+	if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil {
+		f.Close()
+		return nil, fmt.Errorf("server already running (lock held: %s)", path)
+	}
+	return func() {
+		syscall.Flock(int(f.Fd()), syscall.LOCK_UN)
+		f.Close()
+	}, nil
+}
+
+

package/internal/discovery/discovery_test.go

@@ -0,0 +1,62 @@
+package discovery
+
+import (
+	"path/filepath"
+	"testing"
+)
+
+func TestSocketPath(t *testing.T) {
+	tmp := t.TempDir()
+	t.Setenv("HOME", tmp)
+	p, err := SocketPath()
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := filepath.Join(tmp, ".relay-flow", "server.sock")
+	if p != want {
+		t.Fatalf("SocketPath=%q, want %q", p, want)
+	}
+}
+
+func TestServerLockPath(t *testing.T) {
+	tmp := t.TempDir()
+	t.Setenv("HOME", tmp)
+	p, err := ServerLockPath()
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := filepath.Join(tmp, ".relay-flow", "server.lock")
+	if p != want {
+		t.Fatalf("ServerLockPath=%q, want %q", p, want)
+	}
+}
+
+func TestAcquireServerLock_SingleInstance(t *testing.T) {
+	tmp := t.TempDir()
+	t.Setenv("HOME", tmp)
+	release, err := AcquireServerLock()
+	if err != nil {
+		t.Fatalf("first AcquireServerLock: %v", err)
+	}
+	defer release()
+	// Second acquire while first is held must fail immediately.
+	if _, err := AcquireServerLock(); err == nil {
+		t.Fatal("second AcquireServerLock should fail while first is held")
+	}
+}
+
+func TestAcquireServerLock_ReacquireAfterRelease(t *testing.T) {
+	tmp := t.TempDir()
+	t.Setenv("HOME", tmp)
+	release, err := AcquireServerLock()
+	if err != nil {
+		t.Fatal(err)
+	}
+	release()
+	// After release (process exit), lock is free again — no stale state.
+	release2, err := AcquireServerLock()
+	if err != nil {
+		t.Fatalf("reacquire after release: %v", err)
+	}
+	release2()
+}

package/internal/opencode/opencode.go

@@ -0,0 +1,26 @@
+// Package opencode wraps the `opencode` CLI to validate agent names.
+package opencode
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+// Exists reports whether name is a known opencode agent, via
+// `opencode agent list` (agent names are the unindented lines).
+func Exists(name string) (bool, error) {
+	out, err := exec.Command("opencode", "agent", "list").Output()
+	if err != nil {
+		return false, fmt.Errorf("opencode agent list: %w", err)
+	}
+	for _, line := range strings.Split(string(out), "\n") {
+		if line == "" || line[0] == ' ' || line[0] == '[' || line[0] == '{' {
+			continue
+		}
+		if strings.Fields(line)[0] == name {
+			return true, nil
+		}
+	}
+	return false, nil
+}