relay-flow 0.0.1 → 0.2.0-alpha

package/internal/daemon/daemon_test.go

@@ -1,204 +0,0 @@
-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

@@ -1,122 +0,0 @@
-// 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

@@ -1,62 +0,0 @@
-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

@@ -1,26 +0,0 @@
-// 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
-}

package/internal/orcacli/orcacli.go

@@ -1,264 +0,0 @@
-// Package orcacli wraps the `orca` CLI for worktree/terminal management.
-// Every call is skippable via DryRun for safe local testing. All real
-// `orca ... --json` output is wrapped as {id, ok, result: {...}}.
-package orcacli
-
-import (
-	"encoding/json"
-	"fmt"
-	"log"
-	"os/exec"
-	"regexp"
-	"strings"
-)
-
-type Client struct {
-	DryRun bool
-}
-
-func New(dryRun bool) *Client {
-	return &Client{DryRun: dryRun}
-}
-
-type Repo struct {
-	ID          string `json:"id"`
-	DisplayName string `json:"displayName"`
-}
-
-type Worktree struct {
-	ID             string `json:"id"`
-	RepoID         string `json:"repoId"`
-	DisplayName    string `json:"displayName"`
-	Branch         string `json:"branch"`
-	Path           string `json:"path"`
-	IsMainWorktree bool   `json:"isMainWorktree"`
-}
-
-// Terminal is a tab's persistent identity: Title is the tab-level title we
-// set via --title (visualLayouts[].root.tabs[].title), which persists —
-// unlike the pane-level title, which the running program (opencode) resets.
-type Terminal struct {
-	Handle    string
-	Title     string
-	Connected bool
-}
-
-// ListRepos returns all Orca-registered repos, used to resolve a Jira
-// ticket's component name to a repoId (component name == repo displayName).
-func (c *Client) ListRepos() ([]Repo, error) {
-	if c.DryRun {
-		log.Printf("[dry-run] orca repo list --json (skipped, returning empty)")
-		return nil, nil
-	}
-	var res struct {
-		Result struct {
-			Repos []Repo `json:"repos"`
-		} `json:"result"`
-	}
-	if err := runOrcaJSON(&res, "repo", "list", "--json"); err != nil {
-		return nil, fmt.Errorf("orca repo list: %w", err)
-	}
-	return res.Result.Repos, nil
-}
-
-func (c *Client) WorktreeList() ([]Worktree, error) {
-	if c.DryRun {
-		log.Printf("[dry-run] orca worktree list --json (skipped, returning empty)")
-		return nil, nil
-	}
-	var res struct {
-		Result struct {
-			Worktrees []Worktree `json:"worktrees"`
-		} `json:"result"`
-	}
-	if err := runOrcaJSON(&res, "worktree", "list", "--json"); err != nil {
-		return nil, fmt.Errorf("orca worktree list: %w", err)
-	}
-	return res.Result.Worktrees, nil
-}
-
-// WorktreeCreate always explicitly sets --parent-worktree and --base-branch
-// (never relies on Orca's inferred defaults) so every ticket's worktree has
-// a deliberate, known ancestry: main by default, or an explicit parent
-// ticket's worktree/branch for subtasks.
-func (c *Client) WorktreeCreate(ticketKey, repoID, parentWorktreeID, baseBranch string) error {
-	if c.DryRun {
-		log.Printf("[dry-run] orca worktree create --name %s --repo id:%s --parent-worktree worktree:%s --base-branch %s --json (skipped)", ticketKey, repoID, parentWorktreeID, baseBranch)
-		return nil
-	}
-	return runOrca("worktree", "create", "--name", ticketKey, "--repo", "id:"+repoID,
-		"--parent-worktree", "worktree:"+parentWorktreeID, "--base-branch", baseBranch, "--json")
-}
-
-// FindWorktree returns the worktree in repoID with the given displayName.
-func (c *Client) FindWorktree(repoID, displayName string) (Worktree, bool, error) {
-	wts, err := c.WorktreeList()
-	if err != nil {
-		return Worktree{}, false, err
-	}
-	for _, w := range wts {
-		if w.RepoID == repoID && w.DisplayName == displayName {
-			return w, true, nil
-		}
-	}
-	return Worktree{}, false, nil
-}
-
-// FindExistingBranch looks for a branch containing ticketKey
-// (prefix-agnostic — e.g. "Raj-Popat/KCC-1374" or "someone-else/KCC-1374"
-// both match) in the repo checked out at repoPath, checking BOTH local and
-// remote-tracking branches: Orca's worktree-create name-collision logic
-// consults remote branches too, so a leftover origin/Raj-Popat/KCC-1377
-// (pushed by an agent, local copy long deleted) would otherwise make Orca
-// silently suffix the new worktree (-2, -3, ...) and desync every
-// ticket-key-based lookup we do afterward.
-//
-// Return value is the ref to pass as --base-branch:
-//   - local-only branch  -> its name as-is ("Raj-Popat/KCC-1377")
-//   - remote-only branch -> the remote-qualified ref ("origin/Raj-Popat/KCC-1377");
-//     Orca recognizes this as "create the worktree on this existing branch"
-//     and does NOT suffix the worktree name (verified empirically).
-func FindExistingBranch(repoPath, ticketKey string) (string, bool, error) {
-	out, err := exec.Command("git", "-C", repoPath, "branch", "-a", "--list", "--format=%(refname:short)").CombinedOutput()
-	if err != nil {
-		return "", false, fmt.Errorf("git branch --list: %w: %s", err, out)
-	}
-	re := regexp.MustCompile(regexp.QuoteMeta(ticketKey))
-	for _, line := range strings.Split(string(out), "\n") {
-		branch := strings.TrimSpace(line)
-		if branch != "" && re.MatchString(branch) {
-			return branch, true, nil
-		}
-	}
-	return "", false, nil
-}
-
-// MainWorktree returns repoID's main worktree (the one checked out on the
-// repo's primary branch, e.g. main).
-func (c *Client) MainWorktree(repoID string) (Worktree, bool, error) {
-	wts, err := c.WorktreeList()
-	if err != nil {
-		return Worktree{}, false, err
-	}
-	for _, w := range wts {
-		if w.RepoID == repoID && w.IsMainWorktree {
-			return w, true, nil
-		}
-	}
-	return Worktree{}, false, nil
-}
-
-// TerminalList returns tabs (with their persistent tab-level title) for a
-// given worktree, e.g. "name:KCC-1373". --include-visual-layouts is
-// mandatory: orca omits visualLayouts from JSON without it, which would
-// make every lookup return zero tabs and the daemon would spawn duplicate
-// terminals on every poll.
-func (c *Client) TerminalList(worktree string) ([]Terminal, error) {
-	if c.DryRun {
-		log.Printf("[dry-run] orca terminal list --worktree %s --json (skipped, returning empty)", worktree)
-		return nil, nil
-	}
-	var res struct {
-		Result struct {
-			VisualLayouts []struct {
-				Root struct {
-					Tabs []struct {
-						Title string `json:"title"`
-						Panes struct {
-							Handle    string `json:"handle"`
-							Connected bool   `json:"connected"`
-						} `json:"panes"`
-					} `json:"tabs"`
-				} `json:"root"`
-			} `json:"visualLayouts"`
-		} `json:"result"`
-	}
-	if err := runOrcaJSON(&res, "terminal", "list", "--worktree", worktree, "--include-visual-layouts", "--json"); err != nil {
-		return nil, fmt.Errorf("orca terminal list: %w", err)
-	}
-	var terms []Terminal
-	for _, vl := range res.Result.VisualLayouts {
-		for _, tab := range vl.Root.Tabs {
-			terms = append(terms, Terminal{Handle: tab.Panes.Handle, Title: tab.Title, Connected: tab.Panes.Connected})
-		}
-	}
-	return terms, nil
-}
-
-// TerminalCreate launches the given shell command in a fresh terminal on
-// the ticket's worktree. (orca terminal create has no --agent/--prompt
-// flags — those exist only on `worktree create` — so the opencode
-// invocation, with its RELAY_* env markers, is a --command line.)
-func (c *Client) TerminalCreate(ticketKey, title, command string) (string, error) {
-	if c.DryRun {
-		log.Printf("[dry-run] orca terminal create --worktree name:%s --title %q --command %q --json (skipped)", ticketKey, title, command)
-		return "dry-run-handle", nil
-	}
-	var res struct {
-		Result struct {
-			Terminal struct {
-				Handle string `json:"handle"`
-			} `json:"terminal"`
-		} `json:"result"`
-	}
-	if err := runOrcaJSON(&res, "terminal", "create",
-		"--worktree", "name:"+ticketKey,
-		"--title", title,
-		"--command", command,
-		"--json"); err != nil {
-		return "", fmt.Errorf("orca terminal create: %w", err)
-	}
-	return res.Result.Terminal.Handle, nil
-}
-
-func (c *Client) TerminalWait(handle, forState string, timeoutMs int) error {
-	if c.DryRun {
-		log.Printf("[dry-run] orca terminal wait --terminal %s --for %s --timeout-ms %d --json (skipped)", handle, forState, timeoutMs)
-		return nil
-	}
-	return runOrca("terminal", "wait",
-		"--terminal", handle,
-		"--for", forState,
-		"--timeout-ms", fmt.Sprintf("%d", timeoutMs),
-		"--json")
-}
-
-func (c *Client) TerminalClose(handle string) error {
-	if c.DryRun {
-		log.Printf("[dry-run] orca terminal close --terminal %s (skipped)", handle)
-		return nil
-	}
-	return runOrca("terminal", "close", "--terminal", handle)
-}
-
-// TerminalSend types text into an existing terminal and presses Enter.
-// text must be pre-flattened to a single line by the caller — send works
-// via keystroke simulation, so an embedded newline would submit early.
-func (c *Client) TerminalSend(handle, text string) error {
-	if c.DryRun {
-		log.Printf("[dry-run] orca terminal send --terminal %s --text %q --enter --json (skipped)", handle, text)
-		return nil
-	}
-	return runOrca("terminal", "send", "--terminal", handle, "--text", text, "--enter", "--json")
-}
-
-func runOrca(args ...string) error {
-	out, err := exec.Command("orca", args...).CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("orca %v: %w: %s", args, err, string(out))
-	}
-	return nil
-}
-
-func runOrcaJSON(dest any, args ...string) error {
-	out, err := exec.Command("orca", args...).Output()
-	if err != nil {
-		// orca prints its JSON error envelope to stdout even on failure —
-		// surface it so callers can match on codes like selector_not_found.
-		return fmt.Errorf("%w: %s", err, strings.TrimSpace(string(out)))
-	}
-	if err := json.Unmarshal(out, dest); err != nil {
-		return fmt.Errorf("parse json: %w", err)
-	}
-	return nil
-}