relay-flow 0.2.2-alpha → 0.2.4-alpha

package/internal/server/client.go

@@ -205,6 +205,17 @@ func (c *Client) RegisterNodeSession(ctx context.Context, registration run.NodeR
 	return ack, nil
 }
 
+// RestartRun creates or returns the active fresh attempt for a canceled
+// ticket. The server resolves the current repo/workflow and task-system
+// boundaries; the client only transports the command.
+func (c *Client) RestartRun(ctx context.Context, ticket string) (run.Run, error) {
+	var out run.Run
+	if err := c.call(ctx, http.MethodPost, "/runs/by-ticket/"+url.PathEscape(ticket)+"/restart", nil, &out); err != nil {
+		return run.Run{}, err
+	}
+	return out, nil
+}
+
 // CancelRun cancels the active run for the given ticket with a reason.
 func (c *Client) CancelRun(ctx context.Context, ticket, reason string) error {
 	payload, _ := json.Marshal(map[string]string{"reason": reason})

package/internal/server/fixture_test.go

@@ -34,6 +34,9 @@ type fakeServices struct {
 	runtimeAck       run.NodeRuntimeRegistrationAck
 	processedReports map[string]bool
 	submittedReports int
+	restartRun       run.Run
+	restartErr       error
+	restarts         []string
 }
 
 func (f *fakeServices) SubmitWorkflow(_ context.Context, yaml []byte) (*workflow.Workflow, error) {
@@ -79,6 +82,21 @@ func (f *fakeServices) GetRunByTicket(_ context.Context, ticket string) (run.Run
 	}
 	return run.Run{}, errNotFound{ticket}
 }
+func (f *fakeServices) RestartRun(_ context.Context, ticket string) (run.Run, error) {
+	f.restarts = append(f.restarts, ticket)
+	if f.restartErr != nil {
+		return run.Run{}, f.restartErr
+	}
+	if f.restartRun.ID != "" {
+		return f.restartRun, nil
+	}
+	for _, r := range f.runs {
+		if r.Ticket.Key == ticket {
+			return r, nil
+		}
+	}
+	return run.Run{}, errNotFound{ticket}
+}
 func (f *fakeServices) CancelRun(_ context.Context, ticket, _ string) error {
 	for i, r := range f.runs {
 		if r.Ticket.Key == ticket {

package/internal/server/server.go

@@ -31,6 +31,7 @@ type Deps interface {
 	// Runs
 	ListRuns(ctx context.Context, filter run.Filter) ([]run.Run, error)
 	GetRunByTicket(ctx context.Context, ticket string) (run.Run, error)
+	RestartRun(ctx context.Context, ticket string) (run.Run, error)
 	CancelRun(ctx context.Context, ticket, reason string) error
 
 	// Reports
@@ -117,6 +118,8 @@ func writeEnv(w http.ResponseWriter, status int, env envelope) {
 // anything else is an unexpected 500.
 func mapErr(w http.ResponseWriter, err error) {
 	switch {
+	case errors.Is(err, run.ErrRestartConflict):
+		writeErr(w, http.StatusConflict, "conflict", err.Error())
 	case errors.Is(err, ErrNotFound):
 		writeErr(w, http.StatusNotFound, "notFound", err.Error())
 	case errors.Is(err, ErrConflict):
@@ -475,6 +478,7 @@ func (s *server) handleRuns(w http.ResponseWriter, r *http.Request) {
 
 func (s *server) handleRunByTicket(w http.ResponseWriter, r *http.Request) {
 	// /runs/by-ticket/{key}           GET
+	// /runs/by-ticket/{key}/restart   POST
 	// /runs/by-ticket/{key}/cancel    POST
 	rest := strings.TrimPrefix(r.URL.Path, "/runs/by-ticket/")
 	parts := strings.Split(rest, "/")
@@ -490,6 +494,18 @@ func (s *server) handleRunByTicket(w http.ResponseWriter, r *http.Request) {
 		writeOK(w, http.StatusOK, rn)
 		return
 	}
+	if len(parts) == 2 && parts[0] != "" && parts[1] == "restart" {
+		if !methodOnly(w, r, http.MethodPost) {
+			return
+		}
+		rn, err := s.deps.RestartRun(r.Context(), parts[0])
+		if err != nil {
+			mapErr(w, err)
+			return
+		}
+		writeOK(w, http.StatusOK, rn)
+		return
+	}
 	if len(parts) == 2 && parts[0] != "" && parts[1] == "cancel" {
 		if !methodOnly(w, r, http.MethodPost) {
 			return

package/internal/task/beads/beads.go

@@ -328,9 +328,6 @@ func (s *system) CompileFilter(workflowTaskConfig config.RawValues) (func(task.T
 		return nil, err
 	}
 	f := cfg.Filters
-	if !hasAssigneeFilter(merged) && cfg.Assignee != "" {
-		f.Assignees = []string{cfg.Assignee}
-	}
 	return func(ticket task.Ticket) bool {
 		if len(f.ParentStatuses) > 0 && !containsExact(f.ParentStatuses, stringField(ticket.Fields, "status")) {
 			return false
@@ -353,19 +350,6 @@ func (s *system) CompileFilter(workflowTaskConfig config.RawValues) (func(task.T
 	}, nil
 }
 
-func hasAssigneeFilter(raw config.RawValues) bool {
-	switch filters := raw["filters"].(type) {
-	case map[string]any:
-		_, ok := filters["assignees"]
-		return ok
-	case config.RawValues:
-		_, ok := filters["assignees"]
-		return ok
-	default:
-		return false
-	}
-}
-
 func containsExact(values []string, want string) bool {
 	for _, value := range values {
 		if value == want {
@@ -809,6 +793,21 @@ func (s *system) lifecycleDefaults(builtin config.RawValues) config.RawValues {
 	return config.Merge(builtin, inherited)
 }
 
+// PrepareRestart reopens relay-owned mailbox state for a new explicit
+// attempt. The parent is deliberately not changed here; the start task
+// configuration checks the parent's current state and leaves a human-owned
+// Blocked/Deferred/Closed status untouched. Mailbox states outside the
+// relay-owned open/in_progress/closed set return a conflict.
+func (s *system) PrepareRestart(ctx context.Context, _ task.TicketRef, mailboxes []task.Mailbox) error {
+	for _, mailbox := range mailboxes {
+		if err := s.reconcileIssue(ctx, mailbox.Key,
+			[]string{statusOpen, statusInProgress, statusClosed}, statusOpen, ""); err != nil {
+			return fmt.Errorf("reopen mailbox %s for restart: %w", mailbox.Key, err)
+		}
+	}
+	return nil
+}
+
 // ResetForRecovery reopens the parent and every known mailbox, clearing any
 // deferred state while preserving comments, labels, descriptions, history,
 // and issues themselves.
@@ -837,4 +836,5 @@ func (s *system) ResetForRecovery(ctx context.Context, parent task.TicketRef, ma
 var (
 	_ task.System            = (*system)(nil)
 	_ task.LifecycleDefaults = (*system)(nil)
+	_ task.RestartPreparer   = (*system)(nil)
 )

package/internal/task/beads/config_compatibility_test.go

@@ -50,7 +50,7 @@ func TestBeadsConfigRejectsJiraOnlyFields(t *testing.T) {
 	}
 }
 
-func TestBeadsCompileFilterUsesInheritedTopLevelAssignee(t *testing.T) {
+func TestBeadsCompileFilterDoesNotUseTopLevelAssignee(t *testing.T) {
 	sys := &system{base: config.Merge(DefaultConfig(), config.RawValues{
 		"assignee": "Repo.Bot@Example.com",
 	})}
@@ -58,15 +58,14 @@ func TestBeadsCompileFilterUsesInheritedTopLevelAssignee(t *testing.T) {
 	if err != nil {
 		t.Fatalf("CompileFilter failed: %v", err)
 	}
-	if !match(task.Ticket{Fields: map[string]any{"assignee": "repo.bot@example.COM"}}) {
-		t.Fatal("top-level assignee did not become the default filter")
-	}
-	if match(task.Ticket{Fields: map[string]any{"assignee": "other@example.com"}}) {
-		t.Fatal("ticket assigned to another user matched the default assignee filter")
+	for _, assignee := range []string{"repo.bot@example.COM", "other@example.com"} {
+		if !match(task.Ticket{Fields: map[string]any{"assignee": assignee}}) {
+			t.Fatalf("assignee %q was filtered without filters.assignees", assignee)
+		}
 	}
 }
 
-func TestBeadsExplicitAssigneeFilterOverridesInheritedDefault(t *testing.T) {
+func TestBeadsExplicitAssigneeFilterIsUsed(t *testing.T) {
 	sys := &system{base: config.Merge(DefaultConfig(), config.RawValues{
 		"assignee": "repo@example.com",
 	})}
@@ -84,7 +83,7 @@ func TestBeadsExplicitAssigneeFilterOverridesInheritedDefault(t *testing.T) {
 	}
 	for _, assignee := range []string{"repo@example.com", "workflow@example.com"} {
 		if match(task.Ticket{Fields: map[string]any{"assignee": assignee}}) {
-			t.Fatalf("inherited assignee %q overrode explicit assignee filter", assignee)
+			t.Fatalf("explicit assignee filter accepted %q", assignee)
 		}
 	}
 }

package/internal/task/beads/status_compatibility_test.go

@@ -94,6 +94,49 @@ func TestApplyTaskConfigReopensClosedMailboxOnWorkflowRevisit(t *testing.T) {
 	}
 }
 
+func TestPrepareRestartReopensRelayOwnedMailboxes(t *testing.T) {
+	client := newStatusClient(map[string]string{
+		"demo-parent.1": "closed",
+		"demo-parent.2": "in_progress",
+	})
+	sys := &system{cli: client}
+	preparer, ok := task.System(sys).(task.RestartPreparer)
+	if !ok {
+		t.Fatal("Beads system does not implement RestartPreparer")
+	}
+	mailboxes := []task.Mailbox{
+		{ID: "demo-parent.1", Key: "demo-parent.1", Node: "implement"},
+		{ID: "demo-parent.2", Key: "demo-parent.2", Node: "review"},
+	}
+	if err := preparer.PrepareRestart(context.Background(), task.TicketRef{Key: "demo-parent"}, mailboxes); err != nil {
+		t.Fatalf("PrepareRestart failed: %v", err)
+	}
+	if len(client.updates) != 2 || client.updates[0].input.Status != "open" || client.updates[1].input.Status != "open" {
+		t.Fatalf("updates = %+v, want both relay-owned mailboxes reopened to open", client.updates)
+	}
+	if client.issues["demo-parent"].Status != "" {
+		t.Fatalf("parent was unexpectedly inspected or changed: %+v", client.issues["demo-parent"])
+	}
+}
+
+func TestPrepareRestartDoesNotOverwriteHumanMailboxState(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "blocked"})
+	sys := &system{cli: client}
+	preparer := task.System(sys).(task.RestartPreparer)
+	err := preparer.PrepareRestart(context.Background(), task.TicketRef{Key: "demo-parent"}, []task.Mailbox{
+		{ID: "demo-parent.1", Key: "demo-parent.1", Node: "implement"},
+	})
+	if err == nil {
+		t.Fatal("human-owned blocked mailbox state was overwritten")
+	}
+	if got := retry.Classify(err).Kind; got != retry.Conflict {
+		t.Fatalf("failure kind = %q, want conflict: %v", got, err)
+	}
+	if len(client.updates) != 0 {
+		t.Fatalf("human-owned mailbox state issued an update: %+v", client.updates)
+	}
+}
+
 func TestApplyTaskConfigRejectsIncompatibleManualMailboxState(t *testing.T) {
 	client := newStatusClient(map[string]string{"demo-parent.1": "blocked"})
 	sys := &system{cli: client}

package/internal/task/jira/filters_test.go

@@ -232,6 +232,33 @@ func TestCompileFilterAssigneeMatchesEmail(t *testing.T) {
 	}
 }
 
+func TestCompileFilterCurrentUserMatchesAuthenticatedJiraEmail(t *testing.T) {
+	sys := newSystemWithFake(t, &fakeJira{}).(*system)
+	sys.currentUser = "me@example.com"
+	match, err := sys.CompileFilter(config.RawValues{
+		"filters": map[string]any{"assignees": []any{"currentUser()"}},
+	})
+	if err != nil {
+		t.Fatalf("CompileFilter failed: %v", err)
+	}
+	if !match(task.Ticket{Key: "PAY-1", Fields: map[string]any{"assignee": "ME@EXAMPLE.COM"}}) {
+		t.Fatal("currentUser() did not resolve to the authenticated Jira email")
+	}
+	if match(task.Ticket{Key: "PAY-2", Fields: map[string]any{"assignee": "other@example.com"}}) {
+		t.Fatal("currentUser() matched another Jira assignee")
+	}
+}
+
+func TestCompileFilterCurrentUserRequiresCredentials(t *testing.T) {
+	sys := newSystemWithFake(t, &fakeJira{})
+	_, err := sys.CompileFilter(config.RawValues{
+		"filters": map[string]any{"assignees": []any{"currentUser()"}},
+	})
+	if err == nil || !strings.Contains(err.Error(), "authenticated Jira credentials") {
+		t.Fatalf("CompileFilter error = %v, want authenticated-credentials error", err)
+	}
+}
+
 func TestCompileFilterAssigneeMatchAndMismatch(t *testing.T) {
 	// Assignee is a supported structured filter dimension
 	// (repo-workflow-routing: "parent statuses, issue types, labels, and
@@ -253,7 +280,7 @@ func TestCompileFilterAssigneeMatchAndMismatch(t *testing.T) {
 	}
 }
 
-func TestCompileFilterInheritsEffectiveAssigneeCaseInsensitively(t *testing.T) {
+func TestCompileFilterDoesNotUseEffectiveAssigneeAsFilter(t *testing.T) {
 	sys, err := newSystem(context.Background(), &fakeClient{fake: &fakeJira{}}, task.RepoSpec{
 		Name:       "payments",
 		RootConfig: config.RawValues{"assignee": "root@example.com"},
@@ -266,11 +293,10 @@ func TestCompileFilterInheritsEffectiveAssigneeCaseInsensitively(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if !match(task.Ticket{Fields: map[string]any{"assignee": "repo.bot@example.COM"}}) {
-		t.Fatal("effective repo assignee did not match normalized email case-insensitively")
-	}
-	if match(task.Ticket{Fields: map[string]any{"assignee": "other@example.com"}}) {
-		t.Fatal("ticket assigned to another user matched effective assignee")
+	for _, assignee := range []string{"root@example.com", "repo.bot@example.COM", "other@example.com"} {
+		if !match(task.Ticket{Fields: map[string]any{"assignee": assignee}}) {
+			t.Fatalf("assignee %q was filtered without filters.assignees", assignee)
+		}
 	}
 }
 

package/internal/task/jira/helpers_test.go

@@ -37,6 +37,9 @@ func (f *fakeClient) Transition(_ context.Context, key, status, assignee string)
 			return f.fake.assignErr
 		}
 	}
+	if f.fake.transitionErr != nil {
+		return f.fake.transitionErr
+	}
 	f.fake.events = append(f.fake.events, "transition")
 	f.fake.transition(key, status)
 	return nil

package/internal/task/jira/jira.go

@@ -53,6 +53,7 @@ const (
 	defaultStartParentStatus  = "In Progress"
 	defaultWorkTaskStatus     = "In Progress"
 	defaultEndParentStatus    = "Done"
+	currentUserAssigneeFilter = "currentUser()"
 	defaultMailboxDescription = `Parent ticket: {{ticket}}
 Workflow: {{workflow}}
 Node: {{node}}
@@ -147,7 +148,12 @@ func init() {
 			if err != nil {
 				return nil, err
 			}
-			return newSystem(ctx, client, spec)
+			sys, err := newSystem(ctx, client, spec)
+			if err != nil {
+				return nil, err
+			}
+			sys.currentUser = strings.TrimSpace(creds.Email)
+			return sys, nil
 		},
 	})
 }
@@ -173,10 +179,11 @@ func sharedClient(site, email, token string) (*jirarest.HTTPClient, error) {
 // system is the repo-bound Jira task.System. It is safe for concurrent use;
 // the REST client owns connection reuse, caches, and request limiting.
 type system struct {
-	cli       jirarest.Client
-	repoName  string
-	base      config.RawValues
-	effective Config // root+repo merged
+	cli         jirarest.Client
+	repoName    string
+	currentUser string
+	base        config.RawValues
+	effective   Config // root+repo merged
 }
 
 func newSystem(ctx context.Context, cli jirarest.Client, spec task.RepoSpec) (*system, error) {
@@ -323,9 +330,11 @@ func (s *system) CompileFilter(workflowTaskConfig config.RawValues) (func(task.T
 		return nil, err
 	}
 	f := cfg.Filters
-	if !hasAssigneeFilter(merged) && cfg.Assignee != "" {
-		f.Assignees = []string{cfg.Assignee}
+	resolvedAssignees, err := s.resolveAssigneeFilters(f.Assignees)
+	if err != nil {
+		return nil, err
 	}
+	f.Assignees = resolvedAssignees
 	return func(t task.Ticket) bool {
 		if len(f.ParentStatuses) > 0 && !contains(f.ParentStatuses, strField(t.Fields, "status")) {
 			return false
@@ -348,17 +357,18 @@ func (s *system) CompileFilter(workflowTaskConfig config.RawValues) (func(task.T
 	}, nil
 }
 
-func hasAssigneeFilter(raw config.RawValues) bool {
-	switch filters := raw["filters"].(type) {
-	case map[string]any:
-		_, ok := filters["assignees"]
-		return ok
-	case config.RawValues:
-		_, ok := filters["assignees"]
-		return ok
-	default:
-		return false
+func (s *system) resolveAssigneeFilters(values []string) ([]string, error) {
+	resolved := make([]string, 0, len(values))
+	for _, value := range values {
+		if value == currentUserAssigneeFilter {
+			if s.currentUser == "" {
+				return nil, fmt.Errorf("jira: filters.assignees value %q requires authenticated Jira credentials", currentUserAssigneeFilter)
+			}
+			value = s.currentUser
+		}
+		resolved = append(resolved, value)
 	}
+	return resolved, nil
 }
 
 // --- Claim ---
@@ -633,6 +643,21 @@ func (s *system) Comment(ctx context.Context, target task.Target, body, marker s
 	return s.cli.AddComment(ctx, key, body+"\n\n<!-- "+marker+" -->")
 }
 
+// PrepareRestart reopens existing relay-owned mailboxes before a fresh
+// explicit attempt. It does not change the parent ticket: the normal start
+// ApplyTaskConfig operation owns the parent status check, so a human-owned
+// parent status can put the new attempt in blocked state without being
+// overwritten. Jira transition failures are classified as conflicts by
+// transition and therefore retry without blind status writes.
+func (s *system) PrepareRestart(ctx context.Context, _ task.TicketRef, mailboxes []task.Mailbox) error {
+	for _, mailbox := range mailboxes {
+		if err := s.transition(ctx, mailbox.Key, "To Do", ""); err != nil {
+			return fmt.Errorf("reopen mailbox %s for restart: %w", mailbox.Key, err)
+		}
+	}
+	return nil
+}
+
 // --- Recovery ---
 
 // ResetForRecovery resets mailbox subtasks to To Do while preserving
@@ -677,4 +702,5 @@ func strSliceField(fields map[string]any, key string) []string {
 var (
 	_ task.System            = (*system)(nil)
 	_ task.LifecycleDefaults = (*system)(nil)
+	_ task.RestartPreparer   = (*system)(nil)
 )

package/internal/task/jira/transition_defaults_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/retry"
 	"github.com/rajpopat27/relay-flow/internal/task"
 )
 
@@ -27,6 +28,7 @@ type fakeJira struct {
 	taskTransitions   []string
 	assignments       []string
 	assignErr         error
+	transitionErr     error
 	events            []string
 	// searchJSON is the raw Jira search response Poll serves.
 	searchJSON    []byte
@@ -139,6 +141,47 @@ func TestEndDefaultParentDone(t *testing.T) {
 	}
 }
 
+func TestPrepareRestartReopensMailboxesWithoutChangingParent(t *testing.T) {
+	fake := &fakeJira{}
+	sys := newSystemWithFake(t, fake)
+	preparer, ok := sys.(task.RestartPreparer)
+	if !ok {
+		t.Fatal("Jira system does not implement RestartPreparer")
+	}
+	parent := task.TicketRef{ID: "1", Key: "PAY-101"}
+	mailboxes := []task.Mailbox{
+		{ID: "2", Key: "PAY-102", Node: "coding"},
+		{ID: "3", Key: "PAY-103", Node: "review"},
+	}
+	if err := preparer.PrepareRestart(context.Background(), parent, mailboxes); err != nil {
+		t.Fatalf("PrepareRestart failed: %v", err)
+	}
+	if len(fake.taskTransitions) != 2 || fake.taskTransitions[0] != "To Do" || fake.taskTransitions[1] != "To Do" {
+		t.Fatalf("mailbox transitions = %v, want two To Do transitions", fake.taskTransitions)
+	}
+	if len(fake.parentTransitions) != 0 {
+		t.Fatalf("parent transitions = %v, want none (start owns parent status)", fake.parentTransitions)
+	}
+}
+
+func TestPrepareRestartPreservesHumanJiraStateOnConflict(t *testing.T) {
+	fake := &fakeJira{transitionErr: errors.New(`transition to "To Do" is not available for PAY-102`)}
+	sys := newSystemWithFake(t, fake)
+	preparer := sys.(task.RestartPreparer)
+	err := preparer.PrepareRestart(context.Background(), task.TicketRef{Key: "PAY-101"}, []task.Mailbox{
+		{ID: "2", Key: "PAY-102", Node: "coding"},
+	})
+	if err == nil {
+		t.Fatal("incompatible Jira mailbox status was accepted")
+	}
+	if got := retry.Classify(err).Kind; got != retry.Conflict {
+		t.Fatalf("failure kind = %q, want conflict: %v", got, err)
+	}
+	if len(fake.parentTransitions) != 0 {
+		t.Fatalf("parent transitions = %v, want none", fake.parentTransitions)
+	}
+}
+
 func TestExplicitTransitionsWin(t *testing.T) {
 	fake := &fakeJira{}
 	sys := newSystemWithFake(t, fake)

package/internal/task/task.go

@@ -99,6 +99,14 @@ type System interface {
 	ResetForRecovery(ctx context.Context, parent TicketRef, mailboxes []Mailbox, taskConfig config.RawValues) error
 }
 
+// RestartPreparer is an optional adapter capability used only by explicit
+// run restarts. It reopens relay-owned mailbox state while preserving all
+// comments, labels, and descriptions. A human-owned incompatible state must
+// be returned as retry.ConflictError; core never names provider statuses.
+type RestartPreparer interface {
+	PrepareRestart(ctx context.Context, parent TicketRef, mailboxes []Mailbox) error
+}
+
 // LifecycleDefaults is an optional adapter capability: a System whose
 // taskConfig carries lifecycle-dependent defaults (e.g. Jira's deterministic
 // transitionTo defaults) exposes them here. The lifecycle-aware caller

package/package.json

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