relay-flow 0.2.8-alpha → 0.2.9-alpha

package/internal/runner/herdr/herdr.go

@@ -91,11 +91,15 @@ func (a *adapter) DiscoverRepos(ctx context.Context) ([]runner.RepoCandidate, er
 	}
 	candidates := make(map[string]runner.RepoCandidate)
 	for _, workspace := range snapshot.Workspaces {
-		root := normalizePath(workspace.Worktree.RepoRoot)
-		if root == "" {
+		candidate, ok, err := a.workspaceRepository(ctx, workspace, snapshot.Panes)
+		if err != nil {
+			logOutcome("discover-repos", "error")
+			return nil, err
+		}
+		if !ok {
 			continue
 		}
-		candidates[root] = runner.RepoCandidate{Name: workspace.Worktree.RepoName, Path: root}
+		candidates[canonicalCandidatePath(candidate.Path)] = candidate
 	}
 	out := make([]runner.RepoCandidate, 0, len(candidates))
 	for _, candidate := range candidates {
@@ -111,8 +115,102 @@ func (a *adapter) DiscoverRepos(ctx context.Context) ([]runner.RepoCandidate, er
 	return out, nil
 }
 
+// workspaceRepository resolves the Git identity of a workspace. Herdr's
+// snapshot includes worktree metadata for linked worktrees, but plain source
+// workspaces may omit the worktree object; their pane CWD is the supported
+// lookup handle for worktree list.
+func (a *adapter) workspaceRepository(ctx context.Context, workspace herdrcli.Workspace, panes []herdrcli.Pane) (runner.RepoCandidate, bool, error) {
+	if root := normalizePath(workspace.Worktree.RepoRoot); root != "" {
+		name := workspace.Worktree.RepoName
+		if name == "" {
+			name = workspace.Label
+		}
+		return runner.RepoCandidate{Name: name, Path: root}, true, nil
+	}
+	for _, pane := range panes {
+		if pane.WorkspaceID != workspace.ID || !filepath.IsAbs(strings.TrimSpace(pane.CWD)) {
+			continue
+		}
+		listing, err := a.cli.WorktreeList(ctx, pane.CWD)
+		if errors.Is(err, herdrcli.ErrNotGitWorktree) {
+			continue
+		}
+		if err != nil {
+			return runner.RepoCandidate{}, false, err
+		}
+		root := normalizePath(listing.Source.RepoRoot)
+		if root == "" {
+			continue
+		}
+		name := listing.Source.RepoName
+		if name == "" {
+			name = workspace.Label
+		}
+		return runner.RepoCandidate{Name: name, Path: root}, true, nil
+	}
+	return runner.RepoCandidate{}, false, nil
+}
+
+func canonicalCandidatePath(path string) string {
+	if normalized := normalizePath(path); normalized != "" {
+		return normalized
+	}
+	return path
+}
+
+// EnsureRepo opens a source repository as a Herdr workspace when it is not
+// already open. WorktreeList is the source of truth for both the repository
+// root and the source workspace handle; it is checked before workspace create
+// so repeated registration remains idempotent even when snapshots omit
+// worktree metadata for plain source workspaces.
+func (a *adapter) EnsureRepo(ctx context.Context, name, path string) error {
+	attrs := []any{"repo", name}
+	logCall("ensure-repo", attrs...)
+	root := normalizePath(path)
+	if root == "" {
+		logOutcome("ensure-repo", "error", attrs...)
+		return fmt.Errorf("herdr: repository %q has an empty path", name)
+	}
+	listing, err := a.cli.WorktreeList(ctx, root)
+	if err != nil {
+		logOutcome("ensure-repo", "error", attrs...)
+		return err
+	}
+	if reported := normalizePath(listing.Source.RepoRoot); reported != root {
+		logOutcome("ensure-repo", "error", attrs...)
+		return fmt.Errorf("herdr: repository %q path %q is not its repository root %q", name, path, reported)
+	}
+	if hasOpenSourceWorkspace(listing) {
+		logOutcome("ensure-repo", "exists", attrs...)
+		return nil
+	}
+	registrar, ok := a.cli.(herdrcli.RepositoryRegistrar)
+	if !ok {
+		logOutcome("ensure-repo", "error", attrs...)
+		return fmt.Errorf("herdr: repository workspace provisioning is unavailable")
+	}
+	if _, err := registrar.CreateWorkspace(ctx, root, name); err != nil {
+		logOutcome("ensure-repo", "error", attrs...)
+		return err
+	}
+	logOutcome("ensure-repo", "created", attrs...)
+	return nil
+}
+
+func hasOpenSourceWorkspace(listing herdrcli.WorktreeListing) bool {
+	if listing.Source.SourceWorkspaceID != "" {
+		return true
+	}
+	for _, worktree := range listing.Worktrees {
+		if !worktree.IsLinked && worktree.OpenWorkspaceID != "" {
+			return true
+		}
+	}
+	return false
+}
+
 // ValidateRepo verifies the registered path is the root of a Git repository
-// Herdr can manage. Registration needs no Herdr workspace and creates none.
+// Herdr can manage without creating a workspace.
 func (a *adapter) ValidateRepo(ctx context.Context, name, path string) error {
 	logCall("validate-repo", "repo", name)
 	registered := normalizePath(path)
@@ -590,3 +688,4 @@ func normalizePath(path string) string {
 }
 
 var _ runner.Runner = (*adapter)(nil)
+var _ runner.RepoRegistrar = (*adapter)(nil)

package/internal/runner/herdr/herdr_test.go

@@ -29,8 +29,11 @@ type fakeClient struct {
 	openWorkspace herdrcli.Workspace
 	openErr       error
 
-	createWorkspace herdrcli.Workspace
-	createErr       error
+	createWorkspace        herdrcli.Workspace
+	createErr              error
+	createdSourceWorkspace herdrcli.Workspace
+	createdSourceErr       error
+	workspaceCreateCalls   []worktreeCall
 
 	tabs    []herdrcli.Tab
 	tabsErr error
@@ -95,6 +98,13 @@ func (f *fakeClient) WorktreeOpen(_ context.Context, repoPath, branch, label str
 	return f.openWorkspace, f.openErr
 }
 
+func (f *fakeClient) CreateWorkspace(_ context.Context, repoPath, label string) (herdrcli.Workspace, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.workspaceCreateCalls = append(f.workspaceCreateCalls, worktreeCall{RepoPath: repoPath, Label: label})
+	return f.createdSourceWorkspace, f.createdSourceErr
+}
+
 func (f *fakeClient) CreateTab(_ context.Context, workspaceID, cwd, label string) (herdrcli.Tab, herdrcli.Pane, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
@@ -240,6 +250,26 @@ func TestDiscoverReposDeduplicatesRepositoryRoots(t *testing.T) {
 	}
 }
 
+func TestDiscoverReposResolvesPlainSourceWorkspaceFromPaneCWD(t *testing.T) {
+	cli := &fakeClient{
+		snapshot: herdrcli.Snapshot{
+			Workspaces: []herdrcli.Workspace{{ID: "w-source", Label: "payments"}},
+			Panes:      []herdrcli.Pane{{ID: "w-source:p1", WorkspaceID: "w-source", CWD: repoPath}},
+		},
+		listing: herdrcli.WorktreeListing{
+			Source: herdrcli.WorktreeSource{RepoName: "payments", RepoRoot: repoPath, SourceCheckoutPath: repoPath},
+		},
+	}
+	got, err := newAdapter(cli).DiscoverRepos(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []runner.RepoCandidate{{Name: "payments", Path: repoPath}}
+	if len(got) != 1 || got[0] != want[0] {
+		t.Fatalf("DiscoverRepos = %+v, want %+v", got, want)
+	}
+}
+
 func TestValidateRepoAcceptsRepositoryRootAndRejectsInnerPaths(t *testing.T) {
 	cli := &fakeClient{listing: herdrcli.WorktreeListing{
 		Source: herdrcli.WorktreeSource{RepoName: "payments", RepoRoot: repoPath, SourceCheckoutPath: repoPath},
@@ -278,6 +308,46 @@ func TestValidateRepoCreatesNothing(t *testing.T) {
 	}
 }
 
+func TestEnsureRepoReusesAnOpenSourceWorkspace(t *testing.T) {
+	cli := &fakeClient{
+		listing:  herdrcli.WorktreeListing{Source: herdrcli.WorktreeSource{RepoRoot: repoPath, SourceWorkspaceID: "w-source"}},
+		snapshot: herdrcli.Snapshot{Workspaces: []herdrcli.Workspace{{ID: "w-source"}}},
+	}
+	a := newAdapter(cli)
+	if err := a.EnsureRepo(context.Background(), "payments", repoPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := a.EnsureRepo(context.Background(), "payments", repoPath); err != nil {
+		t.Fatal(err)
+	}
+	if len(cli.workspaceCreateCalls) != 0 {
+		t.Fatalf("CreateWorkspace calls = %+v, want none", cli.workspaceCreateCalls)
+	}
+}
+
+func TestEnsureRepoOpensMissingSourceWorkspace(t *testing.T) {
+	cli := &fakeClient{
+		listing:                herdrcli.WorktreeListing{Source: herdrcli.WorktreeSource{RepoRoot: repoPath}},
+		createdSourceWorkspace: herdrcli.Workspace{ID: "source-workspace"},
+	}
+	if err := newAdapter(cli).EnsureRepo(context.Background(), "payments", repoPath); err != nil {
+		t.Fatal(err)
+	}
+	if len(cli.workspaceCreateCalls) != 1 || cli.workspaceCreateCalls[0] != (worktreeCall{RepoPath: repoPath, Label: "payments"}) {
+		t.Fatalf("CreateWorkspace calls = %+v", cli.workspaceCreateCalls)
+	}
+}
+
+func TestEnsureRepoPropagatesSourceWorkspaceFailure(t *testing.T) {
+	cli := &fakeClient{
+		listing:          herdrcli.WorktreeListing{Source: herdrcli.WorktreeSource{RepoRoot: repoPath}},
+		createdSourceErr: errors.New("herdr unavailable"),
+	}
+	if err := newAdapter(cli).EnsureRepo(context.Background(), "payments", repoPath); err == nil || !strings.Contains(err.Error(), "herdr unavailable") {
+		t.Fatalf("EnsureRepo error = %v, want workspace creation failure", err)
+	}
+}
+
 // --- Environment ---
 
 func TestEnsureEnvironmentReusesExistingTicketWorktree(t *testing.T) {

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

@@ -35,6 +35,13 @@ type Client interface {
 	CloseWorkspace(ctx context.Context, workspaceID string) error
 }
 
+// RepositoryRegistrar is the optional repository-workspace provisioning seam
+// used by the Herdr runner adapter. It remains separate from Client so
+// existing runtime-only test clients do not need to implement registration.
+type RepositoryRegistrar interface {
+	CreateWorkspace(ctx context.Context, cwd, label string) (Workspace, error)
+}
+
 // Options selects the Herdr session or explicit socket used by the CLI.
 type Options struct {
 	Session    string
@@ -51,9 +58,10 @@ 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.
+// WorkspaceWorktree is the Git identity Herdr may report for a workspace.
+// Linked ticket workspaces have IsLinked true and the source RepoRoot. Plain
+// source workspaces can omit this object; callers resolve those through their
+// pane CWD and worktree list.
 type WorkspaceWorktree struct {
 	CheckoutPath string
 	RepoName     string
@@ -82,6 +90,7 @@ type WorktreeSource struct {
 	RepoName           string
 	RepoRoot           string
 	SourceCheckoutPath string
+	SourceWorkspaceID  string
 }
 
 // WorktreeListing is the response of worktree list for one repository.

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

@@ -24,6 +24,9 @@ func TestCLIUsesExactProductionCommandShapes(t *testing.T) {
 	if _, err := cli.WorktreeOpen(ctx, "/work/payments", "PAY-101", "PAY-101"); err != nil {
 		t.Fatalf("WorktreeOpen: %v", err)
 	}
+	if _, err := cli.CreateWorkspace(ctx, "/work/payments", "payments"); err != nil {
+		t.Fatalf("CreateWorkspace: %v", err)
+	}
 	if _, err := cli.WorktreeCreate(ctx, "/work/payments", "PAY-101", "origin/main", "PAY-101"); err != nil {
 		t.Fatalf("WorktreeCreate: %v", err)
 	}
@@ -85,11 +88,19 @@ func TestCLIDecodesCapturedResponseLocations(t *testing.T) {
 		t.Fatalf("Snapshot panes = %+v", snapshot.Panes)
 	}
 
+	sourceWorkspace, err := cli.CreateWorkspace(ctx, "/work/payments", "payments")
+	if err != nil {
+		t.Fatalf("CreateWorkspace: %v", err)
+	}
+	if sourceWorkspace.ID != "w1" || sourceWorkspace.Label != "payments" || sourceWorkspace.Worktree.RepoRoot != "" {
+		t.Fatalf("CreateWorkspace = %+v, want the captured plain source workspace shape", sourceWorkspace)
+	}
+
 	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" {
+	if listing.Source.RepoRoot != "/work/payments" || listing.Source.RepoName != "repo" || listing.Source.SourceWorkspaceID != "w1" {
 		t.Fatalf("WorktreeList source = %+v", listing.Source)
 	}
 	if len(listing.Worktrees) != 2 {
@@ -231,8 +242,12 @@ func TestCLIRejectsRelativeCWD(t *testing.T) {
 
 func TestStrictFakeHerdrRejectsUnsupportedProductionShapes(t *testing.T) {
 	fake := installStrictFakeHerdr(t)
+	// This test invokes the fake executable directly rather than through CLI,
+	// so provide the same selector environment the production wrapper sets.
+	t.Setenv("HERDR_SESSION", "relay-flow")
+	t.Setenv("HERDR_SOCKET_PATH", "/tmp/relay-flow-herdr.sock")
 	unsupported := [][]string{
-		{"workspace", "create", "--cwd", "/work/payments", "--label", "payments", "--no-focus"},
+		{"workspace", "get", "w2"},
 		{"worktree", "remove", "--workspace", "w2"},
 		{"terminal", "create", "--pane", "w2:p2"},
 		{"pane", "get", "--pane", "w2:p2"},

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

@@ -26,6 +26,7 @@ type worktreeSourceResponse struct {
 	RepoName           string `json:"repo_name"`
 	RepoRoot           string `json:"repo_root"`
 	SourceCheckoutPath string `json:"source_checkout_path"`
+	SourceWorkspaceID  string `json:"source_workspace_id"`
 }
 
 type tabResponse struct {
@@ -72,6 +73,20 @@ func (c *CLI) Snapshot(ctx context.Context) (Snapshot, error) {
 	}, nil
 }
 
+// CreateWorkspace opens a repository path as a Herdr workspace. A source
+// workspace is enough for repository discovery; ticket worktrees are still
+// created lazily by EnsureEnvironment.
+func (c *CLI) CreateWorkspace(ctx context.Context, cwd, label string) (Workspace, error) {
+	var response struct {
+		Workspace workspaceResponse `json:"workspace"`
+	}
+	if err := c.runJSON(ctx, "workspace create", &response,
+		"workspace", "create", "--cwd", cwd, "--label", label, "--no-focus"); err != nil {
+		return Workspace{}, err
+	}
+	return convertWorkspace(response.Workspace), nil
+}
+
 func (c *CLI) WorktreeList(ctx context.Context, repoPath string) (WorktreeListing, error) {
 	var response struct {
 		Source    worktreeSourceResponse `json:"source"`
@@ -85,6 +100,7 @@ func (c *CLI) WorktreeList(ctx context.Context, repoPath string) (WorktreeListin
 			RepoName:           response.Source.RepoName,
 			RepoRoot:           response.Source.RepoRoot,
 			SourceCheckoutPath: response.Source.SourceCheckoutPath,
+			SourceWorkspaceID:  response.Source.SourceWorkspaceID,
 		},
 		Worktrees: convertWorktrees(response.Worktrees),
 	}, nil

package/internal/runner/herdr/herdrcli/testdata/strict-herdr.sh

@@ -162,6 +162,14 @@ case "$#:${1-}:${2-}" in
       *) emit_result pane-close.json ;;
     esac
     ;;
+  7:workspace:create)
+    [ "$3" = --cwd ] || fail "$@"
+    check_absolute_cwd "$4"
+    [ "$5" = --label ] || fail "$@"
+    check_value "$6"
+    [ "$7" = --no-focus ] || fail "$@"
+    emit_result workspace-create.json
+    ;;
   3:workspace:close)
     check_value "$3"
     case "$3" in

package/internal/runner/herdr/herdrcli/testdata/workspace-create.json

@@ -0,0 +1 @@
+{"id":"cli:workspace:create","result":{"root_pane":{"agent_status":"unknown","cwd":"/tmp/relay-flow-herdr-fixture-9wIblp/repo","focused":true,"foreground_cwd":"/tmp/relay-flow-herdr-fixture-9wIblp/repo","pane_id":"w1:p1","revision":0,"scroll":{"max_offset_from_bottom":0,"offset_from_bottom":0,"viewport_rows":40},"tab_id":"w1:t1","terminal_id":"term_65b0ccebd6e821","workspace_id":"w1"},"tab":{"agent_status":"unknown","focused":true,"label":"1","number":1,"pane_count":1,"tab_id":"w1:t1","workspace_id":"w1"},"type":"workspace_created","workspace":{"active_tab_id":"w1:t1","agent_status":"unknown","focused":true,"label":"payments","number":1,"pane_count":1,"tab_count":1,"workspace_id":"w1"}}}

package/internal/runner/orca/orca.go

@@ -13,6 +13,7 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
+	"path/filepath"
 	"strings"
 
 	"github.com/rajpopat27/relay-flow/internal/config"
@@ -65,6 +66,42 @@ func (a *adapter) DiscoverRepos(ctx context.Context) ([]runner.RepoCandidate, er
 	return out, nil
 }
 
+// EnsureRepo makes an Orca repository available by canonical path. Orca
+// derives its display name from the path, so the relay-flow registration name
+// is intentionally not used as the Orca identity.
+func (a *adapter) EnsureRepo(ctx context.Context, name, path string) error {
+	slog.Debug("orca call", "op", "ensure-repo", "repo", name)
+	canonical := normalizePath(path)
+	if canonical == "" {
+		err := fmt.Errorf("orca: repository %q has an empty path", name)
+		slog.Info("orca outcome", "op", "ensure-repo", "repo", name, "result", "error", "error", sanitizeErr(err))
+		return err
+	}
+	repos, err := a.cli.ListRepos(ctx)
+	if err != nil {
+		slog.Info("orca outcome", "op", "ensure-repo", "repo", name, "result", "error", "error", sanitizeErr(err))
+		return err
+	}
+	for _, r := range repos {
+		if normalizePath(r.Path) == canonical {
+			slog.Info("orca outcome", "op", "ensure-repo", "repo", name, "result", "exists")
+			return nil
+		}
+	}
+	adder, ok := a.cli.(orcacli.RepoRegistrar)
+	if !ok {
+		err := fmt.Errorf("orca: repository provisioning is unavailable")
+		slog.Info("orca outcome", "op", "ensure-repo", "repo", name, "result", "error", "error", sanitizeErr(err))
+		return err
+	}
+	if err := adder.AddRepo(ctx, canonical); err != nil {
+		slog.Info("orca outcome", "op", "ensure-repo", "repo", name, "result", "error", "error", sanitizeErr(err))
+		return err
+	}
+	slog.Info("orca outcome", "op", "ensure-repo", "repo", name, "result", "created")
+	return nil
+}
+
 // ValidateRepo verifies the named repo exists in Orca at the given path.
 func (a *adapter) ValidateRepo(ctx context.Context, name, path string) error {
 	if _, err := a.repoID(ctx, name, path); err != nil {
@@ -73,22 +110,41 @@ func (a *adapter) ValidateRepo(ctx context.Context, name, path string) error {
 	return nil
 }
 
-// repoID resolves a registered repo to its Orca repo ID. The repo path is
-// the stable identity (the Orca repo ID is an internal detail that can
-// change across machines); name is matched as a secondary check.
+// repoID resolves a registered repo to its Orca repo ID. The canonical repo
+// path is the stable identity (the Orca repo ID is an internal detail that
+// can change across machines); relay-flow's name is independent metadata.
 func (a *adapter) repoID(ctx context.Context, name, path string) (string, error) {
+	canonical := normalizePath(path)
+	if canonical == "" {
+		return "", fmt.Errorf("orca: repo %q has an empty path", name)
+	}
 	repos, err := a.cli.ListRepos(ctx)
 	if err != nil {
 		return "", err
 	}
 	for _, r := range repos {
-		if r.Path == path && r.DisplayName == name {
+		if normalizePath(r.Path) == canonical {
 			return r.ID, nil
 		}
 	}
 	return "", fmt.Errorf("orca: repo %q at %q not registered", name, path)
 }
 
+func normalizePath(path string) string {
+	if strings.TrimSpace(path) == "" {
+		return ""
+	}
+	absolute, err := filepath.Abs(path)
+	if err != nil {
+		return filepath.Clean(path)
+	}
+	absolute = filepath.Clean(absolute)
+	if resolved, err := filepath.EvalSymlinks(absolute); err == nil {
+		return filepath.Clean(resolved)
+	}
+	return absolute
+}
+
 // --- Environment ---
 
 // EnsureEnvironment returns the ticket-scoped worktree, creating it from the
@@ -198,6 +254,10 @@ func primaryBranch(w *orcacli.Worktree) string {
 func (a *adapter) CloseTerminal(ctx context.Context, terminal runner.Terminal) error {
 	slog.Debug("orca call", "op", "close-terminal", "title", terminal.Title, "handle", terminal.ID)
 	err := a.cli.CloseTerminal(ctx, terminal.ID)
+	if errors.Is(err, orcacli.ErrTerminalUnavailable) {
+		slog.Info("orca outcome", "op", "close-terminal", "title", terminal.Title, "result", "absent")
+		return nil
+	}
 	if err != nil {
 		slog.Info("orca outcome", "op", "close-terminal", "title", terminal.Title, "result", "error", "error", sanitizeErr(err))
 	} else {
@@ -386,14 +446,10 @@ func (a *adapter) CloseTerminals(ctx context.Context, spec runner.RunSpec) error
 		if !strings.HasPrefix(t.Title, prefix) {
 			continue
 		}
-		// 9.5: one outcome line per actual terminal close, with its title.
-		slog.Debug("orca call", "op", "close-terminal", "title", t.Title, "handle", t.Handle)
-		if err := a.cli.CloseTerminal(ctx, t.Handle); err != nil {
-			slog.Info("orca outcome", "op", "close-terminal", "title", t.Title, "result", "error", "error", sanitizeErr(err))
+		if err := a.CloseTerminal(ctx, runner.Terminal{ID: t.Handle, Title: t.Title}); err != nil {
 			slog.Info("orca outcome", "op", "close-terminals", "ticket", spec.TicketKey, "result", "error", "error", sanitizeErr(err))
 			return fmt.Errorf("close terminal %q: %w", t.Title, err)
 		}
-		slog.Info("orca outcome", "op", "close-terminal", "title", t.Title, "result", "ok")
 		closed++
 	}
 	slog.Info("orca outcome", "op", "close-terminals", "ticket", spec.TicketKey, "result", "ok", "closed", closed)
@@ -443,3 +499,6 @@ func (a *adapter) findEnvironment(ctx context.Context, spec runner.RunSpec) (run
 	}
 	return runner.Environment{}, false, nil
 }
+
+var _ runner.Runner = (*adapter)(nil)
+var _ runner.RepoRegistrar = (*adapter)(nil)

package/internal/runner/orca/orca_test.go

@@ -50,6 +50,9 @@ type fakeCLI struct {
 	showHandles       []string
 	createCommands    []string
 	createN           int
+	closedHandles     []string
+	closeErrors       map[string]error
+	deletedWorktrees  []string
 }
 
 func (f *fakeCLI) ListRepos(context.Context) ([]orcacli.Repo, error) { return f.repos, nil }
@@ -72,7 +75,10 @@ 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) DeleteWorktree(_ context.Context, worktreeID string) error {
+	f.deletedWorktrees = append(f.deletedWorktrees, worktreeID)
+	return nil
+}
 func (f *fakeCLI) ShowTerminal(_ context.Context, handle string) (orcacli.Terminal, error) {
 	f.showHandles = append(f.showHandles, handle)
 	t, ok := f.terminals[handle]
@@ -95,7 +101,59 @@ func (f *fakeCLI) CreateTerminal(_ context.Context, _ string, title, command str
 	f.terminals[handle] = orcacli.Terminal{Handle: handle, Title: title, Connected: true}
 	return handle, nil
 }
-func (f *fakeCLI) CloseTerminal(context.Context, string) error { return nil }
+func (f *fakeCLI) CloseTerminal(_ context.Context, handle string) error {
+	f.closedHandles = append(f.closedHandles, handle)
+	if err, ok := f.closeErrors[handle]; ok {
+		return err
+	}
+	return nil
+}
+
+type repoAddingCLI struct {
+	*fakeCLI
+	addPaths []string
+	addErr   error
+}
+
+func (f *repoAddingCLI) AddRepo(_ context.Context, path string) error {
+	f.addPaths = append(f.addPaths, path)
+	return f.addErr
+}
+
+func TestEnsureRepoSkipsAnExistingCanonicalPath(t *testing.T) {
+	path := t.TempDir()
+	fx := &repoAddingCLI{fakeCLI: &fakeCLI{repos: []orcacli.Repo{{ID: "r1", DisplayName: "runner-name", Path: path}}}}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := a.(runner.RepoRegistrar).EnsureRepo(context.Background(), "relay-name", path+"/."); err != nil {
+		t.Fatal(err)
+	}
+	if len(fx.addPaths) != 0 {
+		t.Fatalf("AddRepo calls = %v, want none for an existing path", fx.addPaths)
+	}
+}
+
+func TestEnsureRepoAddsMissingPathAndPropagatesFailures(t *testing.T) {
+	path := t.TempDir()
+	fx := &repoAddingCLI{fakeCLI: &fakeCLI{}}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := a.(runner.RepoRegistrar).EnsureRepo(context.Background(), "payments", path); err != nil {
+		t.Fatal(err)
+	}
+	if len(fx.addPaths) != 1 || fx.addPaths[0] != path {
+		t.Fatalf("AddRepo calls = %v, want [%q]", fx.addPaths, path)
+	}
+
+	fx.addErr = errors.New("orca unavailable")
+	if err := a.(runner.RepoRegistrar).EnsureRepo(context.Background(), "other", t.TempDir()); err == nil || !strings.Contains(err.Error(), "orca unavailable") {
+		t.Fatalf("EnsureRepo error = %v, want AddRepo failure", err)
+	}
+}
 
 // 9.16: when the repo's primary worktree is on master (refs/heads/master),
 // EnsureEnvironment must pass --base-branch master (via CreateWorktree), not
@@ -290,6 +348,80 @@ func TestCreateTerminalAlwaysCreatesAndTreatsCommandAsOpaque(t *testing.T) {
 	}
 }
 
+func TestCloseTerminalTreatsUnavailableAsAbsent(t *testing.T) {
+	fx := &fakeCLI{closeErrors: map[string]error{
+		"term-stale": orcacli.ErrTerminalUnavailable,
+	}}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := a.CloseTerminal(context.Background(), runner.Terminal{ID: "term-stale", Title: "PAY-1:implement"}); err != nil {
+		t.Fatalf("CloseTerminal(stale) = %v, want nil", err)
+	}
+	if len(fx.closedHandles) != 1 || fx.closedHandles[0] != "term-stale" {
+		t.Fatalf("closed handles = %v, want [term-stale]", fx.closedHandles)
+	}
+}
+
+func TestCloseTerminalPropagatesGenuineFailure(t *testing.T) {
+	wantErr := errors.New("orca permission denied")
+	fx := &fakeCLI{closeErrors: map[string]error{"term-failed": wantErr}}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := a.CloseTerminal(context.Background(), runner.Terminal{ID: "term-failed", Title: "PAY-1:implement"}); !errors.Is(err, wantErr) {
+		t.Fatalf("CloseTerminal(genuine failure) = %v, want %v", err, wantErr)
+	}
+}
+
+func TestCloseTerminalsContinuesAfterStaleHandle(t *testing.T) {
+	fx := &fakeCLI{
+		repos:     []orcacli.Repo{{ID: "r1", DisplayName: "app", Path: "/srv/app"}},
+		worktrees: []orcacli.Worktree{{ID: "wt-PAY-1", RepoID: "r1", DisplayName: "PAY-1"}},
+		listedTerminals: []orcacli.Terminal{
+			{Handle: "term-stale", Title: "PAY-1:stale", Connected: true},
+			{Handle: "term-live", Title: "PAY-1:implement", Connected: true},
+			{Handle: "term-user", Title: "shell", Connected: true},
+		},
+		closeErrors: map[string]error{"term-stale": orcacli.ErrTerminalUnavailable},
+	}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := a.CloseTerminals(context.Background(), runner.RunSpec{
+		RepoName: "app", RepoPath: "/srv/app", TicketKey: "PAY-1",
+	}); err != nil {
+		t.Fatalf("CloseTerminals = %v, want nil after stale handle", err)
+	}
+	if len(fx.closedHandles) != 2 || fx.closedHandles[0] != "term-stale" || fx.closedHandles[1] != "term-live" {
+		t.Fatalf("closed handles = %v, want stale and live run terminals", fx.closedHandles)
+	}
+}
+
+func TestCleanupRunDeletesWorktreeAfterStaleHandle(t *testing.T) {
+	fx := &fakeCLI{
+		repos:           []orcacli.Repo{{ID: "r1", DisplayName: "app", Path: "/srv/app"}},
+		worktrees:       []orcacli.Worktree{{ID: "wt-PAY-1", RepoID: "r1", DisplayName: "PAY-1"}},
+		listedTerminals: []orcacli.Terminal{{Handle: "term-stale", Title: "PAY-1:implement", Connected: true}},
+		closeErrors:     map[string]error{"term-stale": orcacli.ErrTerminalUnavailable},
+	}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := a.CleanupRun(context.Background(), runner.RunSpec{
+		RepoName: "app", RepoPath: "/srv/app", TicketKey: "PAY-1",
+	}); err != nil {
+		t.Fatalf("CleanupRun = %v, want nil after stale handle", err)
+	}
+	if len(fx.deletedWorktrees) != 1 || fx.deletedWorktrees[0] != "wt-PAY-1" {
+		t.Fatalf("deleted worktrees = %v, want [wt-PAY-1]", fx.deletedWorktrees)
+	}
+}
+
 // 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) {