relay-flow 0.2.3-alpha → 0.2.4-alpha

package/internal/runner/herdr/herdrcli/contract.go

@@ -0,0 +1,128 @@
+// Package herdrcli defines the narrow internal boundary between the Herdr
+// runner adapter and the public Herdr CLI.
+package herdrcli
+
+import (
+	"context"
+	"errors"
+)
+
+// Herdr reports failures as JSON error envelopes on stderr with a stable
+// code. These sentinels expose the codes the adapter must react to; every
+// other failure is returned unchanged so it can be retried.
+var (
+	ErrPaneNotFound      = errors.New("pane not found")
+	ErrWorkspaceNotFound = errors.New("workspace not found")
+	ErrWorktreeNotFound  = errors.New("worktree not found")
+	ErrNotGitWorktree    = errors.New("path is not inside a Git work tree")
+)
+
+// Client is the adapter-facing Herdr CLI contract. The production adapter
+// receives a *CLI; tests may provide a client implementing this interface.
+type Client interface {
+	Snapshot(ctx context.Context) (Snapshot, error)
+	WorktreeList(ctx context.Context, repoPath string) (WorktreeListing, error)
+	WorktreeCreate(ctx context.Context, repoPath, branch, base, label string) (Workspace, error)
+	WorktreeOpen(ctx context.Context, repoPath, branch, label string) (Workspace, error)
+	CreateTab(ctx context.Context, workspaceID, cwd, label string) (Tab, Pane, error)
+	ListTabs(ctx context.Context, workspaceID string) ([]Tab, error)
+	ListPanes(ctx context.Context, workspaceID string) ([]Pane, error)
+	GetPane(ctx context.Context, paneID string) (Pane, error)
+	ProcessInfo(ctx context.Context, paneID string) (ProcessInfo, error)
+	RenamePane(ctx context.Context, paneID, label string) error
+	RunPane(ctx context.Context, paneID, command string) error
+	ClosePane(ctx context.Context, paneID string) error
+	CloseWorkspace(ctx context.Context, workspaceID string) error
+}
+
+// Options selects the Herdr session or explicit socket used by the CLI.
+type Options struct {
+	Session    string
+	SocketPath string
+}
+
+// CLI is the production client backed by the herdr executable.
+type CLI struct {
+	options Options
+}
+
+// New constructs a production Herdr CLI client.
+func New(options Options) *CLI {
+	return &CLI{options: options}
+}
+
+// WorkspaceWorktree is the Git identity Herdr reports for a workspace. The
+// source checkout of a repository has IsLinked false; every ticket worktree
+// workspace has IsLinked true and the same RepoRoot.
+type WorkspaceWorktree struct {
+	CheckoutPath string
+	RepoName     string
+	RepoRoot     string
+	IsLinked     bool
+}
+
+// Workspace is the subset of Herdr workspace output used by relay-flow.
+type Workspace struct {
+	ID       string
+	Label    string
+	Worktree WorkspaceWorktree
+}
+
+// Worktree is one checkout reported by worktree list. OpenWorkspaceID is
+// empty when the checkout exists but is not open as a workspace.
+type Worktree struct {
+	Path            string
+	Branch          string
+	IsLinked        bool
+	OpenWorkspaceID string
+}
+
+// WorktreeSource identifies the repository a worktree listing belongs to.
+type WorktreeSource struct {
+	RepoName           string
+	RepoRoot           string
+	SourceCheckoutPath string
+}
+
+// WorktreeListing is the response of worktree list for one repository.
+type WorktreeListing struct {
+	Source    WorktreeSource
+	Worktrees []Worktree
+}
+
+// Tab is the subset of Herdr tab output used by relay-flow.
+type Tab struct {
+	ID          string
+	WorkspaceID string
+	Label       string
+}
+
+// Pane is the subset of Herdr pane output used by relay-flow.
+type Pane struct {
+	ID          string
+	TerminalID  string
+	WorkspaceID string
+	TabID       string
+	Label       string
+	CWD         string
+}
+
+// Snapshot contains the workspace, tab, and pane records returned by Herdr.
+type Snapshot struct {
+	Workspaces []Workspace
+	Tabs       []Tab
+	Panes      []Pane
+}
+
+// ProcessInfo contains the process records returned for a pane.
+type ProcessInfo struct {
+	PaneID              string
+	ShellPID            *uint32
+	ForegroundProcesses []ForegroundProcess
+}
+
+// ForegroundProcess is the observed process shape returned by Herdr.
+type ForegroundProcess struct {
+	PID  uint32
+	Name string
+}

package/internal/runner/herdr/herdrcli/exec.go

@@ -0,0 +1,68 @@
+package herdrcli
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+// execute invokes the installed Herdr executable and keeps its two output
+// streams separate. Command-specific response parsing and error handling are
+// deliberately left to the callers that implement the public operations.
+func (c *CLI) execute(ctx context.Context, args ...string) (stdout, stderr []byte, err error) {
+	if err := validateAbsoluteCWD(args); err != nil {
+		return nil, nil, err
+	}
+
+	cmd := exec.CommandContext(ctx, "herdr", args...)
+	cmd.Env = c.environment(os.Environ())
+
+	var out bytes.Buffer
+	var errOut bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = &errOut
+	err = cmd.Run()
+	return out.Bytes(), errOut.Bytes(), err
+}
+
+func (c *CLI) environment(base []string) []string {
+	env := append([]string(nil), base...)
+	if c.options.Session != "" {
+		env = setEnvironmentValue(env, "HERDR_SESSION", c.options.Session)
+	}
+	if c.options.SocketPath != "" {
+		env = setEnvironmentValue(env, "HERDR_SOCKET_PATH", c.options.SocketPath)
+	}
+	return env
+}
+
+func setEnvironmentValue(env []string, key, value string) []string {
+	prefix := key + "="
+	for i, entry := range env {
+		if strings.HasPrefix(entry, prefix) {
+			env[i] = prefix + value
+			return env
+		}
+	}
+	return append(env, prefix+value)
+}
+
+func validateAbsoluteCWD(args []string) error {
+	for i, arg := range args {
+		if arg != "--cwd" {
+			continue
+		}
+		if i+1 >= len(args) {
+			return fmt.Errorf("herdr --cwd requires a path")
+		}
+		cwd := args[i+1]
+		if !filepath.IsAbs(cwd) {
+			return fmt.Errorf("herdr --cwd must be absolute: %q", cwd)
+		}
+	}
+	return nil
+}

package/internal/runner/herdr/herdrcli/herdrcli_test.go

@@ -0,0 +1,274 @@
+package herdrcli
+
+import (
+	"context"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCLIUsesExactProductionCommandShapes(t *testing.T) {
+	installStrictFakeHerdr(t)
+	cli := newTestCLI()
+	ctx := context.Background()
+
+	if _, err := cli.Snapshot(ctx); err != nil {
+		t.Fatalf("Snapshot: %v", err)
+	}
+	if _, err := cli.WorktreeList(ctx, "/work/payments"); err != nil {
+		t.Fatalf("WorktreeList: %v", err)
+	}
+	if _, err := cli.WorktreeOpen(ctx, "/work/payments", "PAY-101", "PAY-101"); err != nil {
+		t.Fatalf("WorktreeOpen: %v", err)
+	}
+	if _, err := cli.WorktreeCreate(ctx, "/work/payments", "PAY-101", "origin/main", "PAY-101"); err != nil {
+		t.Fatalf("WorktreeCreate: %v", err)
+	}
+	if _, _, err := cli.CreateTab(ctx, "w2", "/work/worktrees/payments/pay-101", "PAY-101:coding"); err != nil {
+		t.Fatalf("CreateTab: %v", err)
+	}
+	if _, err := cli.ListTabs(ctx, "w2"); err != nil {
+		t.Fatalf("ListTabs: %v", err)
+	}
+	if _, err := cli.ListPanes(ctx, "w2"); err != nil {
+		t.Fatalf("ListPanes: %v", err)
+	}
+	if _, err := cli.GetPane(ctx, "w2:p2"); err != nil {
+		t.Fatalf("GetPane: %v", err)
+	}
+	if _, err := cli.ProcessInfo(ctx, "w2:p2"); err != nil {
+		t.Fatalf("ProcessInfo: %v", err)
+	}
+	if err := cli.RenamePane(ctx, "w2:p2", "PAY-101:coding"); err != nil {
+		t.Fatalf("RenamePane: %v", err)
+	}
+	if err := cli.RunPane(ctx, "w2:p2", "RELAY_FLOW_NODE='coding' 'opencode' '--prompt' 'line one\nline two'"); err != nil {
+		t.Fatalf("RunPane: %v", err)
+	}
+	if err := cli.ClosePane(ctx, "w2:p2"); err != nil {
+		t.Fatalf("ClosePane: %v", err)
+	}
+	if err := cli.CloseWorkspace(ctx, "w2"); err != nil {
+		t.Fatalf("CloseWorkspace: %v", err)
+	}
+}
+
+func TestCLIDecodesCapturedResponseLocations(t *testing.T) {
+	installStrictFakeHerdr(t)
+	cli := newTestCLI()
+	ctx := context.Background()
+
+	snapshot, err := cli.Snapshot(ctx)
+	if err != nil {
+		t.Fatalf("Snapshot: %v", err)
+	}
+	if len(snapshot.Workspaces) != 2 {
+		t.Fatalf("Snapshot workspaces = %+v", snapshot.Workspaces)
+	}
+	source := snapshot.Workspaces[0]
+	if source.ID != "w1" || source.Worktree.RepoRoot != "/work/payments" || source.Worktree.IsLinked {
+		t.Fatalf("source workspace = %+v", source)
+	}
+	ticket := snapshot.Workspaces[1]
+	if ticket.ID != "w2" || ticket.Label != "PAY-101" || !ticket.Worktree.IsLinked ||
+		ticket.Worktree.CheckoutPath != "/work/worktrees/payments/pay-101" ||
+		ticket.Worktree.RepoRoot != "/work/payments" {
+		t.Fatalf("ticket workspace = %+v", ticket)
+	}
+	if len(snapshot.Tabs) != 3 || snapshot.Tabs[2] != (Tab{ID: "w2:t2", WorkspaceID: "w2", Label: "PAY-101:coding"}) {
+		t.Fatalf("Snapshot tabs = %+v", snapshot.Tabs)
+	}
+	if len(snapshot.Panes) != 3 || snapshot.Panes[2].ID != "w2:p2" || snapshot.Panes[2].TerminalID == "" {
+		t.Fatalf("Snapshot panes = %+v", snapshot.Panes)
+	}
+
+	listing, err := cli.WorktreeList(ctx, "/work/payments")
+	if err != nil {
+		t.Fatalf("WorktreeList: %v", err)
+	}
+	if listing.Source.RepoRoot != "/work/payments" || listing.Source.RepoName != "repo" {
+		t.Fatalf("WorktreeList source = %+v", listing.Source)
+	}
+	if len(listing.Worktrees) != 2 {
+		t.Fatalf("WorktreeList worktrees = %+v", listing.Worktrees)
+	}
+	if listing.Worktrees[1] != (Worktree{
+		Path:            "/work/worktrees/payments/pay-101",
+		Branch:          "PAY-101",
+		IsLinked:        true,
+		OpenWorkspaceID: "w2",
+	}) {
+		t.Fatalf("ticket worktree = %+v", listing.Worktrees[1])
+	}
+
+	created, err := cli.WorktreeCreate(ctx, "/work/payments", "PAY-101", "origin/main", "PAY-101")
+	if err != nil {
+		t.Fatalf("WorktreeCreate: %v", err)
+	}
+	if created.ID != "w2" || created.Worktree.CheckoutPath != "/work/worktrees/payments/pay-101" {
+		t.Fatalf("WorktreeCreate workspace = %+v", created)
+	}
+	opened, err := cli.WorktreeOpen(ctx, "/work/payments", "PAY-101", "PAY-101")
+	if err != nil {
+		t.Fatalf("WorktreeOpen: %v", err)
+	}
+	if opened.ID != "w2" || opened.Worktree.CheckoutPath != "/work/worktrees/payments/pay-101" {
+		t.Fatalf("WorktreeOpen workspace = %+v", opened)
+	}
+
+	tab, rootPane, err := cli.CreateTab(ctx, "w2", "/work/worktrees/payments/pay-101", "PAY-101:coding")
+	if err != nil {
+		t.Fatalf("CreateTab: %v", err)
+	}
+	if tab != (Tab{ID: "w2:t2", WorkspaceID: "w2", Label: "PAY-101:coding"}) {
+		t.Fatalf("CreateTab tab = %+v", tab)
+	}
+	if rootPane.ID != "w2:p2" || rootPane.TabID != "w2:t2" || rootPane.CWD != "/work/worktrees/payments/pay-101" {
+		t.Fatalf("CreateTab root pane = %+v", rootPane)
+	}
+
+	tabs, err := cli.ListTabs(ctx, "w2")
+	if err != nil || len(tabs) != 2 || tabs[1].Label != "PAY-101:coding" {
+		t.Fatalf("ListTabs = %+v, %v", tabs, err)
+	}
+	panes, err := cli.ListPanes(ctx, "w2")
+	if err != nil || len(panes) != 2 || panes[1].Label != "PAY-101:coding" {
+		t.Fatalf("ListPanes = %+v, %v", panes, err)
+	}
+	pane, err := cli.GetPane(ctx, "w2:p2")
+	if err != nil || pane.ID != "w2:p2" || pane.Label != "PAY-101:coding" {
+		t.Fatalf("GetPane = %+v, %v", pane, err)
+	}
+
+	info, err := cli.ProcessInfo(ctx, "w2:p2")
+	if err != nil || info.PaneID != "w2:p2" || info.ShellPID == nil || len(info.ForegroundProcesses) != 1 {
+		t.Fatalf("ProcessInfo = %+v, %v", info, err)
+	}
+	if info.ForegroundProcesses[0].PID == *info.ShellPID {
+		t.Fatalf("running command fixture must not report the shell as foreground: %+v", info)
+	}
+	shellInfo, err := cli.ProcessInfo(ctx, "shell")
+	if err != nil || shellInfo.ShellPID == nil || len(shellInfo.ForegroundProcesses) != 1 {
+		t.Fatalf("ProcessInfo(shell) = %+v, %v", shellInfo, err)
+	}
+	if shellInfo.ForegroundProcesses[0].PID != *shellInfo.ShellPID {
+		t.Fatalf("restored shell fixture must report the shell as foreground: %+v", shellInfo)
+	}
+}
+
+func TestCLIHandlesEmptyResults(t *testing.T) {
+	installStrictFakeHerdr(t)
+	cli := newTestCLI()
+	ctx := context.Background()
+
+	tabs, err := cli.ListTabs(ctx, "empty")
+	if err != nil || tabs == nil || len(tabs) != 0 {
+		t.Fatalf("ListTabs(empty) = %+v, %v", tabs, err)
+	}
+	panes, err := cli.ListPanes(ctx, "empty")
+	if err != nil || panes == nil || len(panes) != 0 {
+		t.Fatalf("ListPanes(empty) = %+v, %v", panes, err)
+	}
+}
+
+func TestCLIMapsHerdrErrorCodesToSentinels(t *testing.T) {
+	installStrictFakeHerdr(t)
+	cli := newTestCLI()
+	ctx := context.Background()
+
+	if _, err := cli.GetPane(ctx, "missing"); !errors.Is(err, ErrPaneNotFound) {
+		t.Fatalf("GetPane(missing) = %v, want ErrPaneNotFound", err)
+	}
+	if _, err := cli.ProcessInfo(ctx, "missing"); !errors.Is(err, ErrPaneNotFound) {
+		t.Fatalf("ProcessInfo(missing) = %v, want ErrPaneNotFound", err)
+	}
+	if err := cli.ClosePane(ctx, "missing"); !errors.Is(err, ErrPaneNotFound) {
+		t.Fatalf("ClosePane(missing) = %v, want ErrPaneNotFound", err)
+	}
+	if _, err := cli.ListTabs(ctx, "missing"); !errors.Is(err, ErrWorkspaceNotFound) {
+		t.Fatalf("ListTabs(missing) = %v, want ErrWorkspaceNotFound", err)
+	}
+	if _, err := cli.ListPanes(ctx, "missing"); !errors.Is(err, ErrWorkspaceNotFound) {
+		t.Fatalf("ListPanes(missing) = %v, want ErrWorkspaceNotFound", err)
+	}
+	if err := cli.CloseWorkspace(ctx, "missing"); !errors.Is(err, ErrWorkspaceNotFound) {
+		t.Fatalf("CloseWorkspace(missing) = %v, want ErrWorkspaceNotFound", err)
+	}
+	if _, err := cli.WorktreeOpen(ctx, "/work/payments", "MISSING-1", "MISSING-1"); !errors.Is(err, ErrWorktreeNotFound) {
+		t.Fatalf("WorktreeOpen(missing) = %v, want ErrWorktreeNotFound", err)
+	}
+	if _, err := cli.WorktreeList(ctx, "/work/not-a-repo"); !errors.Is(err, ErrNotGitWorktree) {
+		t.Fatalf("WorktreeList(non-repo) = %v, want ErrNotGitWorktree", err)
+	}
+	if _, err := cli.GetPane(ctx, "missing"); !strings.Contains(err.Error(), "pane w9:p9 not found") {
+		t.Fatalf("error message = %v, want Herdr's own message", err)
+	}
+}
+
+func TestCLIReportsMalformedOutputAndToleratesStderrWarnings(t *testing.T) {
+	installStrictFakeHerdr(t)
+	cli := newTestCLI()
+	ctx := context.Background()
+
+	if _, err := cli.GetPane(ctx, "malformed"); err == nil {
+		t.Fatal("GetPane accepted malformed JSON")
+	}
+	if pane, err := cli.GetPane(ctx, "warning"); err != nil || pane.ID != "w2:p2" {
+		t.Fatalf("GetPane(warning) = %+v, %v", pane, err)
+	}
+}
+
+func TestCLIRejectsRelativeCWD(t *testing.T) {
+	installStrictFakeHerdr(t)
+	cli := newTestCLI()
+	if _, err := cli.WorktreeList(context.Background(), "relative/path"); err == nil {
+		t.Fatal("WorktreeList accepted a relative --cwd")
+	}
+}
+
+func TestStrictFakeHerdrRejectsUnsupportedProductionShapes(t *testing.T) {
+	fake := installStrictFakeHerdr(t)
+	unsupported := [][]string{
+		{"workspace", "create", "--cwd", "/work/payments", "--label", "payments", "--no-focus"},
+		{"worktree", "remove", "--workspace", "w2"},
+		{"terminal", "create", "--pane", "w2:p2"},
+		{"pane", "get", "--pane", "w2:p2"},
+		{"pane", "process-info", "w2:p2"},
+		{"tab", "list", "w2"},
+		{"tab", "create", "--workspace", "w2", "--cwd", "/work/payments", "--label", "x", "--no-focus", "--env", "K=V"},
+	}
+	for _, args := range unsupported {
+		if err := exec.Command(fake, args...).Run(); err == nil {
+			t.Errorf("strict fake accepted unsupported invocation %v", args)
+		}
+	}
+}
+
+func newTestCLI() *CLI {
+	return New(Options{Session: "relay-flow", SocketPath: "/tmp/relay-flow-herdr.sock"})
+}
+
+func installStrictFakeHerdr(t *testing.T) string {
+	t.Helper()
+	binDir := t.TempDir()
+	fake := filepath.Join(binDir, "herdr")
+	script, err := os.ReadFile(filepath.Join("testdata", "strict-herdr.sh"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(fake, script, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	fixtureDir, err := filepath.Abs("testdata")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("PATH", binDir+string(os.PathListSeparator)+os.Getenv("PATH"))
+	t.Setenv("HERDR_FIXTURE_DIR", fixtureDir)
+	t.Setenv("HERDR_EXPECT_SESSION", "relay-flow")
+	t.Setenv("HERDR_EXPECT_SOCKET_PATH", "/tmp/relay-flow-herdr.sock")
+	return fake
+}

package/internal/runner/herdr/herdrcli/live_test.go

@@ -0,0 +1,132 @@
+package herdrcli
+
+import (
+	"context"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+// TestLiveInstalledHerdr drives the production wrapper against the installed
+// Herdr binary. It is skipped unless RELAY_FLOW_HERDR_LIVE=1 so default CI,
+// which has no Herdr, stays green; the fixtures in this package are captured
+// from exactly this flow. It never touches the default Herdr session.
+//
+//	RELAY_FLOW_HERDR_LIVE=1 go test ./internal/runner/herdr/herdrcli/ -run Live -v
+func TestLiveInstalledHerdr(t *testing.T) {
+	if os.Getenv("RELAY_FLOW_HERDR_LIVE") != "1" {
+		t.Skip("set RELAY_FLOW_HERDR_LIVE=1 to run against the installed Herdr binary")
+	}
+	if _, err := exec.LookPath("herdr"); err != nil {
+		t.Fatalf("herdr executable not found: %v", err)
+	}
+
+	ctx := context.Background()
+	session := "relay-flow-live-" + filepath.Base(t.TempDir())
+	repo := t.TempDir()
+	runGit(t, repo, "init", "-q", "-b", "main", ".")
+	runGit(t, repo, "config", "user.email", "live@relay-flow.test")
+	runGit(t, repo, "config", "user.name", "live")
+	if err := os.WriteFile(filepath.Join(repo, "README.md"), []byte("live\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	runGit(t, repo, "add", "-A")
+	runGit(t, repo, "commit", "-qm", "init")
+
+	server := exec.Command("herdr", "--session", session, "server")
+	if err := server.Start(); err != nil {
+		t.Fatalf("start herdr server: %v", err)
+	}
+	cli := New(Options{Session: session})
+	t.Cleanup(func() {
+		_ = exec.Command("herdr", "--session", session, "server", "stop").Run()
+		_ = server.Wait()
+		_ = exec.Command("herdr", "session", "delete", session, "--json").Run()
+	})
+
+	var ready bool
+	for i := 0; i < 200; i++ {
+		if _, err := cli.Snapshot(ctx); err == nil {
+			ready = true
+			break
+		}
+	}
+	if !ready {
+		t.Fatal("herdr session never became ready through the production wrapper")
+	}
+
+	// Missing branch must be reported as ErrWorktreeNotFound so the adapter
+	// can create instead of failing the run.
+	if _, err := cli.WorktreeOpen(ctx, repo, "LIVE-1", "LIVE-1"); !errors.Is(err, ErrWorktreeNotFound) {
+		t.Fatalf("WorktreeOpen(missing) = %v, want ErrWorktreeNotFound", err)
+	}
+	workspace, err := cli.WorktreeCreate(ctx, repo, "LIVE-1", "main", "LIVE-1")
+	if err != nil {
+		t.Fatalf("WorktreeCreate: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = os.RemoveAll(workspace.Worktree.CheckoutPath)
+		// Herdr groups checkouts under a per-repository directory; remove it
+		// too when this test's checkout was the only one in it.
+		_ = os.Remove(filepath.Dir(workspace.Worktree.CheckoutPath))
+	})
+	if workspace.ID == "" || workspace.Worktree.CheckoutPath == "" || workspace.Worktree.RepoRoot == "" {
+		t.Fatalf("WorktreeCreate workspace = %+v", workspace)
+	}
+	if reopened, err := cli.WorktreeOpen(ctx, repo, "LIVE-1", "LIVE-1"); err != nil || reopened.ID != workspace.ID {
+		t.Fatalf("WorktreeOpen = %+v, %v", reopened, err)
+	}
+
+	listing, err := cli.WorktreeList(ctx, repo)
+	if err != nil {
+		t.Fatalf("WorktreeList: %v", err)
+	}
+	if listing.Source.RepoRoot == "" || len(listing.Worktrees) < 2 {
+		t.Fatalf("WorktreeList = %+v", listing)
+	}
+
+	_, pane, err := cli.CreateTab(ctx, workspace.ID, workspace.Worktree.CheckoutPath, "LIVE-1:coding")
+	if err != nil {
+		t.Fatalf("CreateTab: %v", err)
+	}
+	if err := cli.RenamePane(ctx, pane.ID, "LIVE-1:coding"); err != nil {
+		t.Fatalf("RenamePane: %v", err)
+	}
+	// A real multiline, env-carrying command line, exactly as the adapter
+	// renders it.
+	if err := cli.RunPane(ctx, pane.ID, "RELAY_FLOW_NODE='coding' sleep 30"); err != nil {
+		t.Fatalf("RunPane: %v", err)
+	}
+	if got, err := cli.GetPane(ctx, pane.ID); err != nil || got.Label != "LIVE-1:coding" {
+		t.Fatalf("GetPane = %+v, %v", got, err)
+	}
+	if _, err := cli.ProcessInfo(ctx, pane.ID); err != nil {
+		t.Fatalf("ProcessInfo: %v", err)
+	}
+	if _, err := cli.GetPane(ctx, "w99:p99"); !errors.Is(err, ErrPaneNotFound) {
+		t.Fatalf("GetPane(missing) = %v, want ErrPaneNotFound", err)
+	}
+	if _, err := cli.ListTabs(ctx, "w99"); !errors.Is(err, ErrWorkspaceNotFound) {
+		t.Fatalf("ListTabs(missing) = %v, want ErrWorkspaceNotFound", err)
+	}
+	if _, err := cli.WorktreeList(ctx, t.TempDir()); !errors.Is(err, ErrNotGitWorktree) {
+		t.Fatalf("WorktreeList(non-repo) = %v, want ErrNotGitWorktree", err)
+	}
+	if err := cli.ClosePane(ctx, pane.ID); err != nil {
+		t.Fatalf("ClosePane: %v", err)
+	}
+	if err := cli.CloseWorkspace(ctx, workspace.ID); err != nil {
+		t.Fatalf("CloseWorkspace: %v", err)
+	}
+}
+
+func runGit(t *testing.T, dir string, args ...string) {
+	t.Helper()
+	cmd := exec.Command("git", args...)
+	cmd.Dir = dir
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("git %v: %v: %s", args, err, out)
+	}
+}