relay-flow 0.2.11-alpha → 0.3.1-alpha

package/internal/runner/herdr/herdr.go

@@ -282,24 +282,24 @@ func (*adapter) SetEnvironmentStatus(context.Context, runner.Environment, string
 // ticketWorkspace resolves the ticket's currently open worktree workspace
 // without creating anything. found is false when the repository, the ticket
 // checkout, or its workspace is absent, which lets cleanup roll forward.
-func (a *adapter) ticketWorkspace(ctx context.Context, spec runner.RunSpec) (string, bool, error) {
+func (a *adapter) ticketWorkspace(ctx context.Context, spec runner.RunSpec) (string, string, bool, error) {
 	repoPath := normalizePath(spec.RepoPath)
 	if repoPath == "" {
-		return "", false, nil
+		return "", "", false, nil
 	}
 	listing, err := a.cli.WorktreeList(ctx, repoPath)
 	if err != nil {
 		if errors.Is(err, herdrcli.ErrNotGitWorktree) || errors.Is(err, herdrcli.ErrWorktreeNotFound) {
-			return "", false, nil
+			return "", "", false, nil
 		}
-		return "", false, err
+		return "", "", false, err
 	}
 	for _, worktree := range listing.Worktrees {
 		if worktree.Branch == spec.TicketKey && worktree.OpenWorkspaceID != "" {
-			return worktree.OpenWorkspaceID, true, nil
+			return worktree.OpenWorkspaceID, normalizePath(worktree.Path), true, nil
 		}
 	}
-	return "", false, nil
+	return "", "", false, nil
 }
 
 // --- Terminals ---
@@ -307,7 +307,7 @@ func (a *adapter) ticketWorkspace(ctx context.Context, spec runner.RunSpec) (str
 // DiscoverTerminal finds an existing live pane by its stable title during
 // explicit projection recovery. It never creates a workspace or pane.
 func (a *adapter) DiscoverTerminal(ctx context.Context, spec runner.RunSpec, title string) (runner.Terminal, bool, error) {
-	workspaceID, found, err := a.ticketWorkspace(ctx, spec)
+	workspaceID, _, found, err := a.ticketWorkspace(ctx, spec)
 	if err != nil || !found {
 		return runner.Terminal{}, false, err
 	}
@@ -549,7 +549,7 @@ func (a *adapter) CloseTerminal(ctx context.Context, terminal runner.Terminal) e
 func (a *adapter) CloseTerminals(ctx context.Context, spec runner.RunSpec) error {
 	attrs := []any{"ticket", spec.TicketKey, "runID", string(spec.RunID)}
 	logCall("close-terminals", attrs...)
-	workspaceID, found, err := a.ticketWorkspace(ctx, spec)
+	workspaceID, _, found, err := a.ticketWorkspace(ctx, spec)
 	if err != nil {
 		logOutcome("close-terminals", "error", attrs...)
 		return err
@@ -606,15 +606,29 @@ func (a *adapter) CloseTerminals(ctx context.Context, spec runner.RunSpec) error
 
 // CleanupRun releases the runner-owned resources for the run: node panes and
 // the ticket workspace. The Git worktree, its branch, and its files are
-// deliberately preserved; a later run reopens the same checkout.
+// deliberately preserved; a later run reopens the same checkout. The ticket
+// checkout must be clean before the workspace is closed.
 func (a *adapter) CleanupRun(ctx context.Context, spec runner.RunSpec) error {
 	attrs := []any{"ticket", spec.TicketKey, "runID", string(spec.RunID)}
 	logCall("cleanup-run", attrs...)
+	workspaceID, checkout, found, err := a.ticketWorkspace(ctx, spec)
+	if err != nil {
+		logOutcome("cleanup-run", "error", attrs...)
+		return err
+	}
+	if !found {
+		logOutcome("cleanup-run", "no-environment", attrs...)
+		return nil
+	}
+	if err := runner.CheckCleanCheckout(ctx, spec.TicketKey, checkout); err != nil {
+		logOutcome("cleanup-run", "error", attrs...)
+		return err
+	}
 	if err := a.CloseTerminals(ctx, spec); err != nil {
 		logOutcome("cleanup-run", "error", attrs...)
 		return err
 	}
-	workspaceID, found, err := a.ticketWorkspace(ctx, spec)
+	workspaceID, _, found, err = a.ticketWorkspace(ctx, spec)
 	if err != nil {
 		logOutcome("cleanup-run", "error", attrs...)
 		return err

package/internal/runner/herdr/herdr_test.go

@@ -739,6 +739,72 @@ func TestCleanupRunClosesTicketWorkspaceAndKeepsWorktree(t *testing.T) {
 	}
 }
 
+func TestCleanupRunBlocksDirtyCheckoutBeforeClosingHerdrResources(t *testing.T) {
+	repo := newGitRepo(t, "main")
+	if err := os.WriteFile(filepath.Join(repo, "dirty.txt"), []byte("uncommitted\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	cli := cleanupClientAt(repo)
+	spec := runSpec()
+	spec.RepoPath = repo
+	if err := newAdapter(cli).CleanupRun(context.Background(), spec); err == nil || !strings.Contains(err.Error(), "commit required") {
+		t.Fatalf("CleanupRun error = %v, want commit-required dirty-check error", err)
+	}
+	if len(cli.closedPanes) != 0 || len(cli.closedWorkspaces) != 0 {
+		t.Fatalf("dirty cleanup touched Herdr resources: panes=%v workspaces=%v", cli.closedPanes, cli.closedWorkspaces)
+	}
+}
+
+func TestCleanupRunAllowsCleanCheckoutAndLaterRetry(t *testing.T) {
+	repo := newGitRepo(t, "main")
+	dirty := filepath.Join(repo, "dirty.txt")
+	if err := os.WriteFile(dirty, []byte("uncommitted\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	cli := cleanupClientAt(repo)
+	spec := runSpec()
+	spec.RepoPath = repo
+	a := newAdapter(cli)
+	if err := a.CleanupRun(context.Background(), spec); err == nil {
+		t.Fatal("dirty CleanupRun succeeded")
+	}
+	if err := os.Remove(dirty); err != nil {
+		t.Fatal(err)
+	}
+	if err := a.CleanupRun(context.Background(), spec); err != nil {
+		t.Fatalf("clean retry CleanupRun = %v", err)
+	}
+	if len(cli.closedPanes) != 1 || len(cli.closedWorkspaces) != 1 {
+		t.Fatalf("clean retry resources: panes=%v workspaces=%v", cli.closedPanes, cli.closedWorkspaces)
+	}
+}
+
+func TestCleanupRunPropagatesGitStatusFailureBeforeClosingHerdrResources(t *testing.T) {
+	repo := t.TempDir()
+	cli := cleanupClientAt(repo)
+	spec := runSpec()
+	spec.RepoPath = repo
+	if err := newAdapter(cli).CleanupRun(context.Background(), spec); err == nil {
+		t.Fatal("CleanupRun treated Git status failure as clean")
+	}
+	if len(cli.closedPanes) != 0 || len(cli.closedWorkspaces) != 0 {
+		t.Fatalf("Git status failure touched Herdr resources: panes=%v workspaces=%v", cli.closedPanes, cli.closedWorkspaces)
+	}
+}
+
+func cleanupClientAt(repo string) *fakeClient {
+	return &fakeClient{
+		listing: herdrcli.WorktreeListing{
+			Source: herdrcli.WorktreeSource{RepoName: "payments", RepoRoot: repo, SourceCheckoutPath: repo},
+			Worktrees: []herdrcli.Worktree{
+				{Path: repo, Branch: "PAY-101", IsLinked: true, OpenWorkspaceID: "w2"},
+			},
+		},
+		tabs:  []herdrcli.Tab{{ID: "w2:t2", WorkspaceID: "w2", Label: "PAY-101:coding"}},
+		panes: []herdrcli.Pane{{ID: "w2:p2", WorkspaceID: "w2", TabID: "w2:t2", Label: "PAY-101:coding"}},
+	}
+}
+
 func TestCleanupRollsForwardWhenTicketWorktreeIsGone(t *testing.T) {
 	cases := map[string]*fakeClient{
 		"repository is not a git work tree": {listingErr: herdrcli.ErrNotGitWorktree},

package/internal/runner/orca/orca.go

@@ -457,14 +457,28 @@ func (a *adapter) CloseTerminals(ctx context.Context, spec runner.RunSpec) error
 }
 
 // CleanupRun removes all runner-owned run resources: terminals, then the
-// ticket worktree itself.
+// ticket worktree itself. The ticket checkout must be clean before either
+// resource is released.
 func (a *adapter) CleanupRun(ctx context.Context, spec runner.RunSpec) error {
 	slog.Debug("orca call", "op", "cleanup-run", "ticket", spec.TicketKey, "runID", string(spec.RunID))
+	env, ok, err := a.findEnvironment(ctx, spec)
+	if err != nil || !ok {
+		if err != nil {
+			slog.Info("orca outcome", "op", "cleanup-run", "ticket", spec.TicketKey, "result", "error", "error", sanitizeErr(err))
+		} else {
+			slog.Info("orca outcome", "op", "cleanup-run", "ticket", spec.TicketKey, "result", "no-environment")
+		}
+		return err
+	}
+	if err := runner.CheckCleanCheckout(ctx, spec.TicketKey, env.Path); err != nil {
+		slog.Info("orca outcome", "op", "cleanup-run", "ticket", spec.TicketKey, "result", "error", "error", sanitizeErr(err))
+		return err
+	}
 	if err := a.CloseTerminals(ctx, spec); err != nil {
 		slog.Info("orca outcome", "op", "cleanup-run", "ticket", spec.TicketKey, "result", "error", "error", sanitizeErr(err))
 		return err
 	}
-	env, ok, err := a.findEnvironment(ctx, spec)
+	env, ok, err = a.findEnvironment(ctx, spec)
 	if err != nil || !ok {
 		if err != nil {
 			slog.Info("orca outcome", "op", "cleanup-run", "ticket", spec.TicketKey, "result", "error", "error", sanitizeErr(err))

package/internal/runner/orca/orca_test.go

@@ -3,6 +3,7 @@ package orca
 import (
 	"context"
 	"errors"
+	"os"
 	"os/exec"
 	"strings"
 	"testing"
@@ -404,7 +405,7 @@ func TestCloseTerminalsContinuesAfterStaleHandle(t *testing.T) {
 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"}},
+		worktrees:       []orcacli.Worktree{{ID: "wt-PAY-1", RepoID: "r1", DisplayName: "PAY-1", Path: "/wt/PAY-1"}},
 		listedTerminals: []orcacli.Terminal{{Handle: "term-stale", Title: "PAY-1:implement", Connected: true}},
 		closeErrors:     map[string]error{"term-stale": orcacli.ErrTerminalUnavailable},
 	}
@@ -422,6 +423,107 @@ func TestCleanupRunDeletesWorktreeAfterStaleHandle(t *testing.T) {
 	}
 }
 
+func TestCleanupRunBlocksDirtyCheckoutBeforeResourceCleanup(t *testing.T) {
+	repo := newOrcaCleanCheckout(t)
+	if err := os.WriteFile(repo+"/dirty.txt", []byte("uncommitted\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	fx := &fakeCLI{
+		repos:           []orcacli.Repo{{ID: "r1", DisplayName: "app", Path: repo}},
+		worktrees:       []orcacli.Worktree{{ID: "wt-PAY-1", RepoID: "r1", DisplayName: "PAY-1", Path: repo}},
+		listedTerminals: []orcacli.Terminal{{Handle: "term-live", Title: "PAY-1:implement", Connected: true}},
+	}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = a.CleanupRun(context.Background(), runner.RunSpec{RepoName: "app", RepoPath: repo, TicketKey: "PAY-1"})
+	if err == nil || !strings.Contains(err.Error(), "commit required") {
+		t.Fatalf("CleanupRun error = %v, want commit-required dirty-check error", err)
+	}
+	if len(fx.closedHandles) != 0 || len(fx.deletedWorktrees) != 0 {
+		t.Fatalf("dirty cleanup touched runner resources: closed=%v deleted=%v", fx.closedHandles, fx.deletedWorktrees)
+	}
+}
+
+func TestCleanupRunAllowsCleanCheckoutAndLaterRetry(t *testing.T) {
+	repo := newOrcaCleanCheckout(t)
+	dirty := repo + "/dirty.txt"
+	if err := os.WriteFile(dirty, []byte("uncommitted\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	fx := &fakeCLI{
+		repos:           []orcacli.Repo{{ID: "r1", DisplayName: "app", Path: repo}},
+		worktrees:       []orcacli.Worktree{{ID: "wt-PAY-1", RepoID: "r1", DisplayName: "PAY-1", Path: repo}},
+		listedTerminals: []orcacli.Terminal{{Handle: "term-live", Title: "PAY-1:implement", Connected: true}},
+	}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	spec := runner.RunSpec{RepoName: "app", RepoPath: repo, TicketKey: "PAY-1"}
+	if err := a.CleanupRun(context.Background(), spec); err == nil {
+		t.Fatal("dirty CleanupRun succeeded")
+	}
+	if err := os.Remove(dirty); err != nil {
+		t.Fatal(err)
+	}
+	if err := a.CleanupRun(context.Background(), spec); err != nil {
+		t.Fatalf("clean retry CleanupRun = %v", err)
+	}
+	if len(fx.closedHandles) != 1 || len(fx.deletedWorktrees) != 1 {
+		t.Fatalf("clean retry resources: closed=%v deleted=%v", fx.closedHandles, fx.deletedWorktrees)
+	}
+}
+
+func TestCleanupRunPropagatesGitStatusFailureBeforeResourceCleanup(t *testing.T) {
+	repo := t.TempDir()
+	fx := &fakeCLI{
+		repos:     []orcacli.Repo{{ID: "r1", DisplayName: "app", Path: repo}},
+		worktrees: []orcacli.Worktree{{ID: "wt-PAY-1", RepoID: "r1", DisplayName: "PAY-1", Path: repo}},
+	}
+	a, err := New(fx, config.RawValues{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := a.CleanupRun(context.Background(), runner.RunSpec{RepoName: "app", RepoPath: repo, TicketKey: "PAY-1"}); err == nil {
+		t.Fatal("CleanupRun treated Git status failure as clean")
+	}
+	if len(fx.closedHandles) != 0 || len(fx.deletedWorktrees) != 0 {
+		t.Fatalf("Git status failure touched runner resources: closed=%v deleted=%v", fx.closedHandles, fx.deletedWorktrees)
+	}
+}
+
+func newOrcaCleanCheckout(t *testing.T) string {
+	t.Helper()
+	repo := t.TempDir()
+	for _, args := range [][]string{
+		{"init", "-q", "-b", "main"},
+		{"config", "user.email", "relay-flow@example.invalid"},
+		{"config", "user.name", "Relay Flow"},
+	} {
+		cmd := exec.Command("git", args...)
+		cmd.Dir = repo
+		if output, err := cmd.CombinedOutput(); err != nil {
+			t.Fatalf("git %v: %v: %s", args, err, output)
+		}
+	}
+	if err := os.WriteFile(repo+"/tracked.txt", []byte("clean\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command("git", "add", "tracked.txt")
+	cmd.Dir = repo
+	if output, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("git add: %v: %s", err, output)
+	}
+	cmd = exec.Command("git", "commit", "-qm", "initial")
+	cmd.Dir = repo
+	if output, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("git commit: %v: %s", err, output)
+	}
+	return repo
+}
+
 // 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-flow",
-  "version": "0.2.11-alpha",
+  "version": "0.3.1-alpha",
   "description": "Graph-based agent workflow engine — tracker-agnostic, pluggable runners",
   "bin": {
     "relay-flow": "./bin/relay-flow.js",