relay-flow 0.0.1 → 0.2.0-alpha

package/internal/runner/orca/orca_test.go

@@ -1,201 +1,175 @@
 package orca
 
 import (
+	"context"
+	"errors"
+	"os/exec"
+	"strings"
 	"testing"
-	"time"
 
-	"github.com/rajpopat27/relay-flow/internal/orcacli"
+	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/runner"
-	"github.com/rajpopat27/relay-flow/internal/tasks"
+	"github.com/rajpopat27/relay-flow/internal/runner/orca/orcacli"
 )
 
-type fakeOrca struct {
-	listErr      error
-	worktrees    []orcacli.Worktree
-	terminals    map[string][]orcacli.Terminal // worktree name → terminals
-	created      []string
-	sent         []string
-	closed       []string
-	waitErr      error
-	createErr    error
-	findBranchFn func(repoPath, key string) (string, bool, error)
-	agentExists  bool
-}
-
-func (f *fakeOrca) WorktreeList() ([]orcacli.Worktree, error) { return f.worktrees, nil }
-func (f *fakeOrca) WorktreeCreate(ticketKey, repoID, parentWorktreeID, baseBranch string) error {
-	f.created = append(f.created, ticketKey)
-	f.worktrees = append(f.worktrees, orcacli.Worktree{ID: "wt-" + ticketKey, DisplayName: ticketKey, RepoID: repoID, Branch: baseBranch})
-	return nil
-}
-func (f *fakeOrca) FindWorktree(repoID, displayName string) (orcacli.Worktree, bool, error) {
-	for _, w := range f.worktrees {
-		if w.RepoID == repoID && w.DisplayName == displayName {
-			return w, true, nil
-		}
+// 9.5: info-level outcome logs must never embed argv payloads. sanitizeErr
+// strips the "[args...]" middle from orcacli errors so the agent prompt and
+// RELAY_FLOW_* env carried by --command are never written to server.log.
+func TestSanitizeErr(t *testing.T) {
+	// Shape from runJSON/run: "orca [terminal create ... --command 'PAYLOAD']: exit status 1: boom"
+	// wrapped by CreateTerminal as "orca terminal create: %w".
+	wrapped := errors.New("orca terminal create: orca [terminal create --worktree name:PAY-1 --title PAY-1:coding --command 'PAYLOAD']: exit status 1: boom")
+	got := sanitizeErr(wrapped)
+	if strings.Contains(got, "PAYLOAD") || strings.Contains(got, "--command") {
+		t.Fatalf("sanitizeErr leaked argv payload: %q", got)
+	}
+	if !strings.Contains(got, "boom") {
+		t.Fatalf("sanitizeErr dropped failure reason: %q", got)
 	}
-	return orcacli.Worktree{}, false, nil
-}
-func (f *fakeOrca) MainWorktree(repoID string) (orcacli.Worktree, bool, error) {
-	for _, w := range f.worktrees {
-		if w.RepoID == repoID && w.IsMainWorktree {
-			return w, true, nil
-		}
+
+	if got := sanitizeErr(nil); got != "" {
+		t.Fatalf("sanitizeErr(nil) = %q, want empty", got)
 	}
-	return orcacli.Worktree{}, false, nil
-}
-func (f *fakeOrca) TerminalList(worktree string) ([]orcacli.Terminal, error) {
-	if f.listErr != nil {
-		return nil, f.listErr
+
+	plain := errors.New("unwrapped failure")
+	if got := sanitizeErr(plain); got != "unwrapped failure" {
+		t.Fatalf("sanitizeErr(plain) = %q", got)
 	}
-	return f.terminals[worktree], nil
 }
-func (f *fakeOrca) TerminalCreate(ticketKey, title, command string) (string, error) {
-	if f.createErr != nil {
-		return "", f.createErr
-	}
-	h := "h-" + title
-	f.terminals["name:"+ticketKey] = append(f.terminals["name:"+ticketKey], orcacli.Terminal{Handle: h, Title: title, Connected: true})
-	return h, nil
+
+// fakeCLI is the orcacli.Client seam used by the Orca runner tests.
+type fakeCLI struct {
+	repos     []orcacli.Repo
+	worktrees []orcacli.Worktree
+
+	createdBaseBranch string
+	createdParent     string
 }
-func (f *fakeOrca) TerminalWait(handle, forState string, timeoutMs int) error { return f.waitErr }
-func (f *fakeOrca) TerminalClose(handle string) error {
-	f.closed = append(f.closed, handle)
+
+func (f *fakeCLI) ListRepos(context.Context) ([]orcacli.Repo, error) { return f.repos, nil }
+func (f *fakeCLI) ListWorktrees(context.Context) ([]orcacli.Worktree, error) {
+	return f.worktrees, nil
+}
+func (f *fakeCLI) CreateWorktree(_ context.Context, ticketKey, repoID, parentWorktreeID, baseBranch string) error {
+	f.createdBaseBranch = baseBranch
+	f.createdParent = parentWorktreeID
+	f.worktrees = append(f.worktrees, orcacli.Worktree{
+		ID:          "wt-new",
+		RepoID:      repoID,
+		DisplayName: ticketKey,
+		Branch:      "refs/heads/" + ticketKey,
+		Path:        "/wt/" + ticketKey,
+	})
 	return nil
 }
-func (f *fakeOrca) TerminalSend(handle, text string) error {
-	f.sent = append(f.sent, handle+":"+text)
-	return nil
+func (f *fakeCLI) DeleteWorktree(context.Context, string) error { return nil }
+func (f *fakeCLI) ShowTerminal(context.Context, string) (orcacli.Terminal, error) {
+	return orcacli.Terminal{}, orcacli.ErrTerminalUnavailable
+}
+func (f *fakeCLI) SendTerminal(context.Context, string, string) error { return nil }
+func (f *fakeCLI) ListTerminals(context.Context, string) ([]orcacli.Terminal, error) {
+	return nil, nil
 }
+func (f *fakeCLI) CreateTerminal(context.Context, string, string, string) (string, error) {
+	return "", nil
+}
+func (f *fakeCLI) CloseTerminal(context.Context, string) error { return nil }
 
-func newTestRunner(f *fakeOrca) *orcaRunner {
-	return &orcaRunner{
-		repoID: "repo-1",
-		orca:   f,
-		exists: func(string) (bool, error) { return f.agentExists, nil },
-		sleep:  func(time.Duration) {},
-		findBranch: func(repoPath, key string) (string, bool, error) {
-			if f.findBranchFn != nil {
-				return f.findBranchFn(repoPath, key)
-			}
-			return "", false, nil
+// 9.16: when the repo's primary worktree is on master (refs/heads/master),
+// EnsureEnvironment must pass --base-branch master (via CreateWorktree), not
+// the hardcoded "main".
+func TestEnsureEnvironment_PrimaryBranchMaster(t *testing.T) {
+	fx := &fakeCLI{
+		repos: []orcacli.Repo{{ID: "r1", DisplayName: "app", Path: "/srv/app"}},
+		worktrees: []orcacli.Worktree{
+			{ID: "wt-main", RepoID: "r1", DisplayName: "app-main", Branch: "refs/heads/master", Path: "/srv/app", IsMainWorktree: true},
 		},
 	}
-}
-
-func TestUnmarshalConfig(t *testing.T) {
-	if _, err := unmarshalConfig(map[string]any{}); err != nil {
-		t.Fatalf("empty config must be valid: %v", err)
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
 	}
-	if _, err := unmarshalConfig(nil); err != nil {
-		t.Fatalf("nil config must be valid: %v", err)
+	_, err = a.EnsureEnvironment(context.Background(), runner.RunSpec{TicketKey: "PAY-1", RepoName: "app", RepoPath: "/srv/app"})
+	if err != nil {
+		t.Fatal(err)
 	}
-	if _, err := unmarshalConfig(map[string]any{"bogus": 1}); err == nil {
-		t.Fatal("unknown field must be rejected")
+	if fx.createdBaseBranch != "master" {
+		t.Fatalf("CreateWorktree baseBranch = %q, want %q", fx.createdBaseBranch, "master")
+	}
+	if fx.createdParent != "wt-main" {
+		t.Fatalf("CreateWorktree parent = %q, want %q", fx.createdParent, "wt-main")
 	}
 }
 
-func TestSpawnCreatesWorktreeAndTerminal(t *testing.T) {
-	f := &fakeOrca{
-		worktrees:   []orcacli.Worktree{{ID: "main", DisplayName: "main", RepoID: "repo-1", IsMainWorktree: true, Branch: "main", Path: "/tmp"}},
-		terminals:   map[string][]orcacli.Terminal{},
-		agentExists: true,
-	}
-	r := newTestRunner(f)
-	tk := tasks.Ticket{Key: "XYZ-1"}
-	err := r.Spawn(tk, "coding", "build", "do the work", map[string]string{
-		"RELAY_FLOW_WORKFLOW": "wf", "RELAY_FLOW_TICKET": "XYZ-1", "RELAY_FLOW_NODE": "coding", "RELAY_FLOW_AGENT": "build",
-	})
+// Explicit baseRef config overrides the primary worktree's branch.
+func TestEnsureEnvironment_BaseRefOverride(t *testing.T) {
+	fx := &fakeCLI{
+		repos: []orcacli.Repo{{ID: "r1", DisplayName: "app", Path: "/srv/app"}},
+		worktrees: []orcacli.Worktree{
+			{ID: "wt-main", RepoID: "r1", DisplayName: "app-main", Branch: "refs/heads/master", Path: "/srv/app", IsMainWorktree: true},
+		},
+	}
+	a, err := New(fx, config.RawValues{"baseRef": "release/1.x"})
 	if err != nil {
-		t.Fatalf("%v", err)
+		t.Fatal(err)
 	}
-	if len(f.created) != 1 || f.created[0] != "XYZ-1" {
-		t.Errorf("worktree created = %v", f.created)
+	_, err = a.EnsureEnvironment(context.Background(), runner.RunSpec{TicketKey: "PAY-1", RepoName: "app", RepoPath: "/srv/app"})
+	if err != nil {
+		t.Fatal(err)
 	}
-	terms := f.terminals["name:XYZ-1"]
-	if len(terms) != 1 || terms[0].Title != "XYZ-1:build:coding" {
-		t.Errorf("terminals = %+v", terms)
+	if fx.createdBaseBranch != "release/1.x" {
+		t.Fatalf("CreateWorktree baseBranch = %q, want %q", fx.createdBaseBranch, "release/1.x")
 	}
 }
 
-func TestSpawnUnknownAgent(t *testing.T) {
-	f := &fakeOrca{terminals: map[string][]orcacli.Terminal{}, agentExists: false}
-	r := newTestRunner(f)
-	if err := r.Spawn(tasks.Ticket{Key: "XYZ-1"}, "coding", "ghost", "p", nil); err == nil {
-		t.Fatal("unknown agent must error")
-	}
-	if len(f.created) != 0 {
-		t.Errorf("no worktree should be created for unknown agent: %v", f.created)
+// An existing ticket branch must win even over a configured baseRef. Passing
+// any other base would make Orca hit its branch-name collision behavior.
+func TestEnsureEnvironment_ExistingTicketBranchAvoidsCollision(t *testing.T) {
+	repo := t.TempDir()
+	runGit := func(args ...string) {
+		t.Helper()
+		cmdArgs := append([]string{"-C", repo}, args...)
+		if out, err := exec.Command("git", cmdArgs...).CombinedOutput(); err != nil {
+			t.Fatalf("git %s: %v: %s", strings.Join(args, " "), err, out)
+		}
 	}
-}
+	runGit("init", "--quiet")
+	runGit("-c", "user.name=Relay Flow", "-c", "user.email=relay-flow@example.invalid", "commit", "--allow-empty", "--quiet", "-m", "initial")
+	runGit("branch", "alice/PAY-1")
 
-func TestFindExactTitle(t *testing.T) {
-	f := &fakeOrca{terminals: map[string][]orcacli.Terminal{
-		"name:XYZ-1": {
-			{Handle: "h1", Title: "XYZ-1:build:coding"},
-			{Handle: "h2", Title: "XYZ-1:build:reviewing"},
-			{Handle: "h3", Title: "Terminal 1"},
+	fx := &fakeCLI{
+		repos: []orcacli.Repo{{ID: "r1", DisplayName: "app", Path: repo}},
+		worktrees: []orcacli.Worktree{
+			{ID: "wt-main", RepoID: "r1", DisplayName: "app-main", Branch: "refs/heads/master", Path: repo, IsMainWorktree: true},
 		},
-	}}
-	r := newTestRunner(f)
-	s, ok, err := r.Find(tasks.Ticket{Key: "XYZ-1"}, "coding")
-	if err != nil || !ok || s.ID != "h1" {
-		t.Errorf("Find coding = %+v ok=%v err=%v", s, ok, err)
-	}
-	if _, ok, _ := r.Find(tasks.Ticket{Key: "XYZ-1"}, "nowhere"); ok {
-		t.Error("Find nowhere must miss")
 	}
-	if _, ok, _ := r.Find(tasks.Ticket{Key: "XYZ-9"}, "coding"); ok {
-		t.Error("Find unknown ticket must miss")
-	}
-}
-
-func TestFindMissingWorktreeIsNotFound(t *testing.T) {
-	// selector_not_found (worktree gone after crash) must be "no session",
-	// not an error — otherwise bounce never reaches the respawn branch.
-	f := &fakeOrca{listErr: errSelectorNotFound}
-	r := newTestRunner(f)
-	if _, ok, err := r.Find(tasks.Ticket{Key: "XYZ-9"}, "coding"); err != nil || ok {
-		t.Errorf("Find = ok=%v err=%v, want no-session", ok, err)
-	}
-	// Real errors still propagate.
-	f.listErr = errBoom
-	if _, _, err := r.Find(tasks.Ticket{Key: "XYZ-9"}, "coding"); err == nil {
-		t.Error("real list error must propagate")
+	a, err := New(fx, config.RawValues{"baseRef": "release/1.x"})
+	if err != nil {
+		t.Fatal(err)
 	}
-}
-
-var errSelectorNotFound = errorString("exit status 1: selector_not_found")
-var errBoom = errorString("boom")
-
-type errorString string
-
-func (e errorString) Error() string { return string(e) }
-
-func TestNudgeSendsPrompt(t *testing.T) {
-	f := &fakeOrca{}
-	r := newTestRunner(f)
-	if err := r.Nudge(runner.Session{ID: "h1", Title: "XYZ-1:build:coding"}, "continue please"); err != nil {
-		t.Fatalf("%v", err)
+	if _, err := a.EnsureEnvironment(context.Background(), runner.RunSpec{TicketKey: "PAY-1", RepoName: "app", RepoPath: repo}); err != nil {
+		t.Fatal(err)
 	}
-	if len(f.sent) != 1 || f.sent[0] != "h1:continue please" {
-		t.Errorf("sent = %v", f.sent)
+	if fx.createdBaseBranch != "alice/PAY-1" {
+		t.Fatalf("CreateWorktree baseBranch = %q, want existing ticket branch", fx.createdBaseBranch)
 	}
 }
 
-func TestCloseClosesTicketTerminals(t *testing.T) {
-	f := &fakeOrca{terminals: map[string][]orcacli.Terminal{
-		"name:XYZ-1": {
-			{Handle: "h1", Title: "XYZ-1:build:coding"},
-			{Handle: "h2", Title: "XYZ-1:build:reviewing"},
-			{Handle: "h3", Title: "Setup"}, // not ours — survives
-		},
-	}}
-	r := newTestRunner(f)
-	if err := r.Close(tasks.Ticket{Key: "XYZ-1"}); err != nil {
-		t.Fatalf("%v", err)
-	}
-	if len(f.closed) != 2 {
-		t.Errorf("closed = %v, want h1+h2 only", f.closed)
+func TestPrimaryBranch(t *testing.T) {
+	cases := []struct {
+		in, want string
+	}{
+		{"refs/heads/master", "master"},
+		{"refs/heads/main", "main"},
+		{"refs/heads/release/1.x", "release/1.x"},
+		{"master", "master"},    // already bare
+		{"", "main"},            // empty → main fallback
+		{"refs/heads/", "main"}, // empty name → main fallback
+	}
+	for _, c := range cases {
+		got := primaryBranch(&orcacli.Worktree{Branch: c.in})
+		if got != c.want {
+			t.Errorf("primaryBranch(%q) = %q, want %q", c.in, got, c.want)
+		}
 	}
 }

package/internal/runner/orca/orcacli/orcacli.go

@@ -0,0 +1,215 @@
+// Package orcacli wraps the Orca CLI behind a small fakeable interface.
+// Every call is real; there is no dry-run mode.
+package orcacli
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os/exec"
+	"regexp"
+	"strings"
+)
+
+var ErrTerminalUnavailable = errors.New("terminal unavailable")
+
+// Repo is an Orca-registered repository.
+type Repo struct {
+	ID          string `json:"id"`
+	DisplayName string `json:"displayName"`
+	Path        string `json:"path"`
+}
+
+// Worktree is an Orca worktree (a runner environment).
+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 set
+// via --title, which persists — unlike the pane-level title, which the
+// running program resets.
+type Terminal struct {
+	Handle    string
+	Title     string
+	Connected bool
+}
+
+// Client is the fakeable Orca CLI seam used by the Orca runner adapter.
+type Client interface {
+	ListRepos(ctx context.Context) ([]Repo, error)
+	ListWorktrees(ctx context.Context) ([]Worktree, error)
+	CreateWorktree(ctx context.Context, ticketKey, repoID, parentWorktreeID, baseBranch string) error
+	DeleteWorktree(ctx context.Context, worktreeID string) error
+	ShowTerminal(ctx context.Context, handle string) (Terminal, error)
+	SendTerminal(ctx context.Context, handle, text string) error
+	ListTerminals(ctx context.Context, worktree string) ([]Terminal, error)
+	CreateTerminal(ctx context.Context, ticketKey, title, command string) (handle string, err error)
+	CloseTerminal(ctx context.Context, handle string) error
+}
+
+// CLI is the production Client backed by the orca binary.
+type CLI struct{}
+
+func New() *CLI { return &CLI{} }
+
+func (CLI) ListRepos(ctx context.Context) ([]Repo, error) {
+	var res struct {
+		Result struct {
+			Repos []Repo `json:"repos"`
+		} `json:"result"`
+	}
+	if err := runJSON(ctx, &res, "repo", "list", "--json"); err != nil {
+		return nil, fmt.Errorf("orca repo list: %w", err)
+	}
+	return res.Result.Repos, nil
+}
+
+func (CLI) ListWorktrees(ctx context.Context) ([]Worktree, error) {
+	var res struct {
+		Result struct {
+			Worktrees []Worktree `json:"worktrees"`
+		} `json:"result"`
+	}
+	if err := runJSON(ctx, &res, "worktree", "list", "--json"); err != nil {
+		return nil, fmt.Errorf("orca worktree list: %w", err)
+	}
+	return res.Result.Worktrees, nil
+}
+
+// CreateWorktree always sets --parent-worktree and --base-branch explicitly
+// (never Orca's inferred defaults) so every ticket worktree has a
+// deliberate, known ancestry.
+func (CLI) CreateWorktree(ctx context.Context, ticketKey, repoID, parentWorktreeID, baseBranch string) error {
+	return run(ctx, "worktree", "create", "--name", ticketKey, "--repo", "id:"+repoID,
+		"--parent-worktree", "worktree:"+parentWorktreeID, "--base-branch", baseBranch, "--json")
+}
+
+// FindExistingBranch returns the first local or remote-tracking branch whose
+// short ref contains ticketKey. The returned ref is suitable for Orca's
+// --base-branch argument.
+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, strings.TrimSpace(string(out)))
+	}
+	match := regexp.MustCompile(regexp.QuoteMeta(ticketKey))
+	for _, line := range strings.Split(string(out), "\n") {
+		branch := strings.TrimSpace(line)
+		if branch != "" && match.MatchString(branch) {
+			return branch, true, nil
+		}
+	}
+	return "", false, nil
+}
+
+func (CLI) DeleteWorktree(ctx context.Context, worktreeID string) error {
+	return run(ctx, "worktree", "rm", "--worktree", "id:"+worktreeID, "--json")
+}
+
+func (CLI) ShowTerminal(ctx context.Context, handle string) (Terminal, error) {
+	var res struct {
+		Result struct {
+			Terminal struct {
+				Handle    string `json:"handle"`
+				Title     string `json:"title"`
+				Connected bool   `json:"connected"`
+				Writable  bool   `json:"writable"`
+			} `json:"terminal"`
+		} `json:"result"`
+	}
+	if err := runJSON(ctx, &res, "terminal", "show", "--terminal", handle, "--json"); err != nil {
+		if strings.Contains(err.Error(), "terminal_handle_stale") {
+			return Terminal{}, ErrTerminalUnavailable
+		}
+		return Terminal{}, fmt.Errorf("orca terminal show: %w", err)
+	}
+	t := res.Result.Terminal
+	return Terminal{Handle: t.Handle, Title: t.Title, Connected: t.Connected && t.Writable}, nil
+}
+
+func (CLI) SendTerminal(ctx context.Context, handle, text string) error {
+	return run(ctx, "terminal", "send", "--terminal", handle, "--text", text, "--enter", "--json")
+}
+
+// ListTerminals returns tabs (with their persistent tab-level title) for a
+// worktree, e.g. "name:PAY-101". --include-visual-layouts is mandatory:
+// orca omits visualLayouts from JSON without it.
+func (CLI) ListTerminals(ctx context.Context, worktree string) ([]Terminal, error) {
+	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 := runJSON(ctx, &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
+}
+
+// CreateTerminal launches the given shell command in a fresh terminal on
+// the ticket's worktree.
+func (CLI) CreateTerminal(ctx context.Context, ticketKey, title, command string) (string, error) {
+	var res struct {
+		Result struct {
+			Terminal struct {
+				Handle string `json:"handle"`
+			} `json:"terminal"`
+		} `json:"result"`
+	}
+	if err := runJSON(ctx, &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 (CLI) CloseTerminal(ctx context.Context, handle string) error {
+	return run(ctx, "terminal", "close", "--terminal", handle, "--json")
+}
+
+func run(ctx context.Context, args ...string) error {
+	cmd := exec.CommandContext(ctx, "orca", args...)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("orca %v: %w: %s", args, err, strings.TrimSpace(string(out)))
+	}
+	return nil
+}
+
+func runJSON(ctx context.Context, dest any, args ...string) error {
+	cmd := exec.CommandContext(ctx, "orca", args...)
+	out, err := cmd.Output()
+	if err != nil {
+		// orca prints its JSON error envelope to stdout even on failure.
+		return fmt.Errorf("orca %v: %w: %s", args, err, strings.TrimSpace(string(out)))
+	}
+	if err := json.Unmarshal(out, dest); err != nil {
+		return fmt.Errorf("orca %v: parse json: %w", args, err)
+	}
+	return nil
+}