relay-flow 0.2.0-alpha → 0.2.2-alpha

package/internal/runner/orca/orca.go

@@ -114,6 +114,17 @@ func (a *adapter) EnsureEnvironment(ctx context.Context, spec runner.RunSpec) (r
 	return env, err
 }
 
+func (a *adapter) SetEnvironmentStatus(ctx context.Context, env runner.Environment, status string) error {
+	slog.Debug("orca call", "op", "set-environment-status", "envID", env.ID, "status", status)
+	err := a.cli.SetWorktreeStatus(ctx, env.ID, status)
+	if err != nil {
+		slog.Info("orca outcome", "op", "set-environment-status", "envID", env.ID, "status", status, "result", "error", "error", sanitizeErr(err))
+	} else {
+		slog.Info("orca outcome", "op", "set-environment-status", "envID", env.ID, "status", status, "result", "ok")
+	}
+	return err
+}
+
 // ensureEnvironment is the unlogged body factored out so the public method
 // can emit one outcome line (created/exists/error) without duplicate
 // logging on the inner re-reads.
@@ -183,26 +194,6 @@ func primaryBranch(w *orcacli.Worktree) string {
 
 // --- Terminals ---
 
-// FindTerminal returns the terminal titled exactly title in the environment
-// when it is live and usable; stale/disconnected records are treated as
-// absent.
-func (a *adapter) FindTerminal(ctx context.Context, env runner.Environment, title string) (runner.Terminal, bool, error) {
-	slog.Debug("orca call", "op", "find-terminal", "title", title, "envID", env.ID)
-	terms, err := a.cli.ListTerminals(ctx, "id:"+env.ID)
-	if err != nil {
-		slog.Info("orca outcome", "op", "find-terminal", "title", title, "result", "error", "error", sanitizeErr(err))
-		return runner.Terminal{}, false, err
-	}
-	for _, t := range terms {
-		if t.Title == title && t.Connected {
-			slog.Info("orca outcome", "op", "find-terminal", "title", title, "result", "found")
-			return runner.Terminal{ID: t.Handle, Title: t.Title}, true, nil
-		}
-	}
-	slog.Info("orca outcome", "op", "find-terminal", "title", title, "result", "absent")
-	return runner.Terminal{}, false, nil
-}
-
 // CloseTerminal closes one terminal by handle.
 func (a *adapter) CloseTerminal(ctx context.Context, terminal runner.Terminal) error {
 	slog.Debug("orca call", "op", "close-terminal", "title", terminal.Title, "handle", terminal.ID)
@@ -215,20 +206,29 @@ func (a *adapter) CloseTerminal(ctx context.Context, terminal runner.Terminal) e
 	return err
 }
 
-// InspectTerminal addresses a persisted handle directly. Normal execution
-// never lists terminals or rediscovers by title.
-func (a *adapter) InspectTerminal(ctx context.Context, terminal runner.Terminal) (runner.Terminal, bool, error) {
+// FindTerminal addresses a persisted handle directly. Normal execution never
+// lists terminals or rediscovers by title.
+func (a *adapter) FindTerminal(ctx context.Context, terminal runner.Terminal) (runner.Terminal, bool, error) {
+	slog.Debug("orca call", "op", "find-terminal", "title", terminal.Title, "handle", terminal.ID)
+	if terminal.ID == "" {
+		slog.Info("orca outcome", "op", "find-terminal", "title", terminal.Title, "result", "absent")
+		return runner.Terminal{}, false, nil
+	}
 	t, err := a.cli.ShowTerminal(ctx, terminal.ID)
 	if errors.Is(err, orcacli.ErrTerminalUnavailable) {
+		slog.Info("orca outcome", "op", "find-terminal", "title", terminal.Title, "result", "absent")
 		return runner.Terminal{}, false, nil
 	}
 	if err != nil {
+		slog.Info("orca outcome", "op", "find-terminal", "title", terminal.Title, "result", "error", "error", sanitizeErr(err))
 		return runner.Terminal{}, false, err
 	}
 	if !t.Connected {
+		slog.Info("orca outcome", "op", "find-terminal", "title", terminal.Title, "result", "absent")
 		return runner.Terminal{}, false, nil
 	}
-	return runner.Terminal{ID: t.Handle, Title: t.Title}, true, nil
+	slog.Info("orca outcome", "op", "find-terminal", "title", terminal.Title, "result", "found")
+	return runner.Terminal{ID: t.Handle, Title: terminal.Title}, true, nil
 }
 
 func (a *adapter) SendTerminal(ctx context.Context, terminal runner.Terminal, text string) error {
@@ -242,51 +242,27 @@ func (a *adapter) CreateTerminal(ctx context.Context, env runner.Environment, ti
 	if err != nil {
 		return runner.Terminal{}, err
 	}
-	if commandResumesSession(command) {
-		t, showErr := a.cli.ShowTerminal(ctx, handle)
-		if errors.Is(showErr, orcacli.ErrTerminalUnavailable) || (showErr == nil && !t.Connected) {
-			_ = a.cli.CloseTerminal(ctx, handle)
-			return runner.Terminal{}, runner.ErrSessionUnavailable
-		}
-		if showErr != nil {
-			return runner.Terminal{}, showErr
-		}
-	}
 	return runner.Terminal{ID: handle, Title: title}, nil
 }
 
-func commandResumesSession(command runner.Command) bool {
-	for i, arg := range command.Args {
-		if arg == "--session" && i+1 < len(command.Args) && command.Args[i+1] != "" {
-			return true
-		}
-	}
-	return false
-}
-
-// EnsureTerminal is idempotent: it returns the live terminal with the stable
-// title when present, otherwise creates one running command. The title
-// contains only <ticket>:<node>; visit metadata lives in the command's
-// environment, never the title.
-func (a *adapter) EnsureTerminal(ctx context.Context, env runner.Environment, title string, command runner.Command) (runner.Terminal, error) {
+// EnsureTerminal checks the persisted terminal, then creates a replacement
+// only when that terminal is unavailable. The title is used only for creation.
+func (a *adapter) EnsureTerminal(ctx context.Context, env runner.Environment, stored runner.Terminal, title string, command runner.Command) (runner.Terminal, error) {
 	slog.Debug("orca call", "op", "ensure-terminal", "title", title, "envID", env.ID)
-	if t, ok, err := a.FindTerminal(ctx, env, title); err != nil {
+	if t, ok, err := a.FindTerminal(ctx, stored); err != nil {
 		slog.Info("orca outcome", "op", "ensure-terminal", "title", title, "result", "error", "error", sanitizeErr(err))
 		return runner.Terminal{}, err
 	} else if ok {
 		slog.Info("orca outcome", "op", "ensure-terminal", "title", title, "result", "exists")
 		return t, nil
 	}
-	// The worktree display name is the ticket key (EnsureEnvironment names
-	// it after the ticket).
-	name := strings.SplitN(title, ":", 2)[0]
-	handle, err := a.cli.CreateTerminal(ctx, name, title, shellCommand(command))
+	terminal, err := a.CreateTerminal(ctx, env, title, command)
 	if err != nil {
 		slog.Info("orca outcome", "op", "ensure-terminal", "title", title, "result", "error", "error", sanitizeErr(err))
 		return runner.Terminal{}, err
 	}
 	slog.Info("orca outcome", "op", "ensure-terminal", "title", title, "result", "created")
-	return runner.Terminal{ID: handle, Title: title}, nil
+	return terminal, nil
 }
 
 // sanitizeErr strips the leading "orca [args...]:" prefix from orcacli

package/internal/runner/orca/orca_test.go

@@ -41,9 +41,14 @@ func TestSanitizeErr(t *testing.T) {
 type fakeCLI struct {
 	repos     []orcacli.Repo
 	worktrees []orcacli.Worktree
+	terminals map[string]orcacli.Terminal
 
 	createdBaseBranch string
 	createdParent     string
+	status            string
+	showHandles       []string
+	createCommands    []string
+	createN           int
 }
 
 func (f *fakeCLI) ListRepos(context.Context) ([]orcacli.Repo, error) { return f.repos, nil }
@@ -62,16 +67,32 @@ func (f *fakeCLI) CreateWorktree(_ context.Context, ticketKey, repoID, parentWor
 	})
 	return nil
 }
+func (f *fakeCLI) SetWorktreeStatus(_ context.Context, _, status string) error {
+	f.status = status
+	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) ShowTerminal(_ context.Context, handle string) (orcacli.Terminal, error) {
+	f.showHandles = append(f.showHandles, handle)
+	t, ok := f.terminals[handle]
+	if !ok {
+		return orcacli.Terminal{}, orcacli.ErrTerminalUnavailable
+	}
+	return t, nil
 }
 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) CreateTerminal(_ context.Context, _ string, title, command string) (string, error) {
+	f.createN++
+	f.createCommands = append(f.createCommands, command)
+	handle := "term-created-" + string(rune('0'+f.createN))
+	if f.terminals == nil {
+		f.terminals = map[string]orcacli.Terminal{}
+	}
+	f.terminals[handle] = orcacli.Terminal{Handle: handle, Title: title, Connected: true}
+	return handle, nil
 }
 func (f *fakeCLI) CloseTerminal(context.Context, string) error { return nil }
 
@@ -122,6 +143,124 @@ func TestEnsureEnvironment_BaseRefOverride(t *testing.T) {
 	}
 }
 
+func TestSetEnvironmentStatus(t *testing.T) {
+	fx := &fakeCLI{}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := a.SetEnvironmentStatus(context.Background(), runner.Environment{ID: "wt-PAY-1"}, runner.WorkspaceStatusInReview); err != nil {
+		t.Fatal(err)
+	}
+	if fx.status != runner.WorkspaceStatusInReview {
+		t.Fatalf("status = %q, want %q", fx.status, runner.WorkspaceStatusInReview)
+	}
+}
+
+func TestFindTerminalUsesPersistedID(t *testing.T) {
+	fx := &fakeCLI{terminals: map[string]orcacli.Terminal{
+		"term-stored": {Handle: "term-stored", Title: "PAY-1:implement", Connected: true},
+	}}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	got, ok, err := a.FindTerminal(context.Background(), runner.Terminal{ID: "term-stored", Title: "PAY-1:implement"})
+	if err != nil || !ok || got.ID != "term-stored" {
+		t.Fatalf("FindTerminal = %+v, %v, %v", got, ok, err)
+	}
+	if len(fx.showHandles) != 1 || fx.showHandles[0] != "term-stored" {
+		t.Fatalf("ShowTerminal handles = %v, want [term-stored]", fx.showHandles)
+	}
+}
+
+func TestFindTerminalReturnsOnlyLiveUsable(t *testing.T) {
+	fx := &fakeCLI{terminals: map[string]orcacli.Terminal{
+		"term-dead": {Handle: "term-dead", Title: "PAY-1:implement", Connected: false},
+	}}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if _, ok, err := a.FindTerminal(context.Background(), runner.Terminal{}); err != nil || ok {
+		t.Fatalf("FindTerminal(empty) ok=%v err=%v, want absent", ok, err)
+	}
+	if _, ok, err := a.FindTerminal(context.Background(), runner.Terminal{ID: "term-dead"}); err != nil || ok {
+		t.Fatalf("FindTerminal(dead) ok=%v err=%v, want absent", ok, err)
+	}
+	if len(fx.showHandles) != 1 || fx.showHandles[0] != "term-dead" {
+		t.Fatalf("ShowTerminal handles = %v, want [term-dead]", fx.showHandles)
+	}
+}
+
+func TestEnsureTerminalFindsBeforeCreate(t *testing.T) {
+	fx := &fakeCLI{terminals: map[string]orcacli.Terminal{
+		"term-stored": {Handle: "term-stored", Title: "PAY-1:implement", Connected: true},
+	}}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	stored := runner.Terminal{ID: "term-stored", Title: "PAY-1:implement"}
+
+	got, err := a.EnsureTerminal(context.Background(), runner.Environment{ID: "wt-PAY-1"}, stored, "PAY-1:implement", runner.Command{Executable: "opencode"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.ID != stored.ID || fx.createN != 0 {
+		t.Fatalf("EnsureTerminal = %+v, creates=%d; want stored terminal and no create", got, fx.createN)
+	}
+}
+
+func TestEnsureTerminalCreatesWhenStoredTerminalUnavailable(t *testing.T) {
+	fx := &fakeCLI{}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	command := runner.Command{Executable: "custom-harness", Args: []string{"--session", "opaque", "--prompt", "work", "--agent", "review"}}
+
+	got, err := a.EnsureTerminal(context.Background(), runner.Environment{ID: "wt-PAY-1"}, runner.Terminal{ID: "term-stale"}, "PAY-1:implement", command)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.ID != "term-created-1" || fx.createN != 1 {
+		t.Fatalf("EnsureTerminal = %+v, creates=%d", got, fx.createN)
+	}
+	if len(fx.showHandles) != 1 || fx.showHandles[0] != "term-stale" {
+		t.Fatalf("ShowTerminal handles = %v, want [term-stale]", fx.showHandles)
+	}
+	if len(fx.createCommands) != 1 || fx.createCommands[0] != shellCommand(command) {
+		t.Fatalf("CreateTerminal commands = %v, want opaque command unchanged", fx.createCommands)
+	}
+}
+
+func TestCreateTerminalAlwaysCreatesAndTreatsCommandAsOpaque(t *testing.T) {
+	fx := &fakeCLI{}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	command := runner.Command{Executable: "custom-harness", Args: []string{"--session", "opaque"}}
+
+	first, err := a.CreateTerminal(context.Background(), runner.Environment{ID: "wt-PAY-1"}, "PAY-1:implement", command)
+	if err != nil {
+		t.Fatal(err)
+	}
+	second, err := a.CreateTerminal(context.Background(), runner.Environment{ID: "wt-PAY-1"}, "PAY-1:implement", command)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if first.ID == second.ID || fx.createN != 2 {
+		t.Fatalf("CreateTerminal IDs = %q, %q; creates=%d", first.ID, second.ID, fx.createN)
+	}
+	if len(fx.showHandles) != 0 {
+		t.Fatalf("CreateTerminal parsed resume syntax and inspected terminals: %v", fx.showHandles)
+	}
+}
+
 // 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) {

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

@@ -45,6 +45,7 @@ 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
+	SetWorktreeStatus(ctx context.Context, worktreeID, status 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
@@ -90,6 +91,10 @@ func (CLI) CreateWorktree(ctx context.Context, ticketKey, repoID, parentWorktree
 		"--parent-worktree", "worktree:"+parentWorktreeID, "--base-branch", baseBranch, "--json")
 }
 
+func (CLI) SetWorktreeStatus(ctx context.Context, worktreeID, status string) error {
+	return run(ctx, "worktree", "set", "--worktree", "id:"+worktreeID, "--workspace-status", status, "--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.

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

@@ -33,6 +33,9 @@ func TestCLIContractsAgainstCapturedRealOutput(t *testing.T) {
 	if err := cli.CreateWorktree(ctx, "PAY-101", "repo-1", "wt-main", "origin/alice/PAY-101"); err != nil {
 		t.Fatal(err)
 	}
+	if err := cli.SetWorktreeStatus(ctx, "wt-PAY-101", "in-review"); err != nil {
+		t.Fatal(err)
+	}
 	if err := cli.DeleteWorktree(ctx, "wt-PAY-101"); err != nil {
 		t.Fatal(err)
 	}

package/internal/runner/orca/orcacli/testdata/strict-orca.sh

@@ -8,6 +8,8 @@ elif [ "$#" -eq 3 ] && [ "$1" = worktree ] && [ "$2" = list ] && [ "$3" = --json
   fixture=worktree-list.json
 elif [ "$#" -eq 11 ] && [ "$1" = worktree ] && [ "$2" = create ] && [ "$3" = --name ] && [ "$4" = PAY-101 ] && [ "$5" = --repo ] && [ "$6" = id:repo-1 ] && [ "$7" = --parent-worktree ] && [ "$8" = worktree:wt-main ] && [ "$9" = --base-branch ] && [ "${10}" = origin/alice/PAY-101 ] && [ "${11}" = --json ]; then
   fixture=worktree-create.json
+elif [ "$#" -eq 7 ] && [ "$1" = worktree ] && [ "$2" = set ] && [ "$3" = --worktree ] && [ "$4" = id:wt-PAY-101 ] && [ "$5" = --workspace-status ] && [ "$6" = in-review ] && [ "$7" = --json ]; then
+  fixture=worktree-create.json
 elif [ "$#" -eq 5 ] && [ "$1" = worktree ] && [ "$2" = rm ] && [ "$3" = --worktree ] && [ "$4" = id:wt-PAY-101 ] && [ "$5" = --json ]; then
   fixture=worktree-remove.json
 elif [ "$#" -eq 6 ] && [ "$1" = terminal ] && [ "$2" = list ] && [ "$3" = --worktree ] && [ "$4" = id:wt-PAY-101 ] && [ "$5" = --include-visual-layouts ] && [ "$6" = --json ]; then

package/internal/runner/runner.go

@@ -13,6 +13,12 @@ import (
 
 var ErrSessionUnavailable = errors.New("stored session unavailable")
 
+const (
+	WorkspaceStatusInProgress = "in-progress"
+	WorkspaceStatusInReview   = "in-review"
+	WorkspaceStatusCompleted  = "completed"
+)
+
 type RepoCandidate struct {
 	Name string `json:"name"`
 	Path string `json:"path"`
@@ -42,10 +48,11 @@ type RunSpec struct {
 }
 
 // Runner owns ticket-scoped environments, terminals, and liveness.
-// FindTerminal returns only a live usable terminal. CloseTerminals closes
-// agent terminals while preserving the environment/workspace; CleanupRun
-// removes all runner-owned run resources at end. Both reconstruct identity
-// from RunSpec without SQLite IDs.
+// FindTerminal checks a persisted terminal handle against the external runner
+// and returns only a live usable terminal. CloseTerminals closes agent terminals
+// while preserving the environment/workspace; CleanupRun removes all
+// runner-owned run resources at end. Both reconstruct identity from RunSpec
+// without SQLite IDs.
 //
 // Terminal titles are stable and minimal: only "<ticket>:<node>" — never
 // nodeVisitID, workflow name, agent name, or other changing metadata.
@@ -53,12 +60,12 @@ type Runner interface {
 	DiscoverRepos(ctx context.Context) ([]RepoCandidate, error)
 	ValidateRepo(ctx context.Context, name, path string) error
 	EnsureEnvironment(ctx context.Context, spec RunSpec) (Environment, error)
-	InspectTerminal(ctx context.Context, terminal Terminal) (Terminal, bool, error)
-	SendTerminal(ctx context.Context, terminal Terminal, text string) error
+	SetEnvironmentStatus(ctx context.Context, env Environment, status string) error
+	FindTerminal(ctx context.Context, terminal Terminal) (Terminal, bool, error)
 	CreateTerminal(ctx context.Context, env Environment, title string, command Command) (Terminal, error)
-	FindTerminal(ctx context.Context, env Environment, title string) (Terminal, bool, error)
+	EnsureTerminal(ctx context.Context, env Environment, terminal Terminal, title string, command Command) (Terminal, error)
+	SendTerminal(ctx context.Context, terminal Terminal, text string) error
 	CloseTerminal(ctx context.Context, terminal Terminal) error
-	EnsureTerminal(ctx context.Context, env Environment, title string, command Command) (Terminal, error)
 	CloseTerminals(ctx context.Context, spec RunSpec) error
 	CleanupRun(ctx context.Context, spec RunSpec) error
 }

package/internal/task/auth_test.go

@@ -0,0 +1,48 @@
+package task_test
+
+import (
+	"context"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/task"
+)
+
+const alternateAuthPlugin = "alternate-auth-format-test"
+
+var registerAlternateAuth sync.Once
+
+func TestAlternativeTaskPluginOwnsCredentialsFormat(t *testing.T) {
+	registerAlternateAuth.Do(func() {
+		task.Register(alternateAuthPlugin, task.Factory{
+			RequiredRepoKeys: func() []string { return nil },
+			TaskScopeKey:     func(_, _ config.RawValues) (string, error) { return "alternate", nil },
+			Auth: func(_ context.Context, _ []string, stdin io.Reader) error {
+				key, err := io.ReadAll(stdin)
+				if err != nil {
+					return err
+				}
+				return os.WriteFile(filepath.Join(os.Getenv("RELAY_FLOW_HOME"), "credentials.yaml"),
+					[]byte("alternateApiKey: "+strings.TrimSpace(string(key))+"\n"), 0o600)
+			},
+			New: func(context.Context, task.RepoSpec) (task.System, error) { return nil, nil },
+		})
+	})
+	root := t.TempDir()
+	t.Setenv("RELAY_FLOW_HOME", root)
+	if err := task.Auth(context.Background(), alternateAuthPlugin, nil, strings.NewReader("different-secret")); err != nil {
+		t.Fatal(err)
+	}
+	raw, err := os.ReadFile(filepath.Join(root, "credentials.yaml"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(raw) != "alternateApiKey: different-secret\n" {
+		t.Fatalf("alternate credentials = %q", raw)
+	}
+}