relay-flow 0.2.2-alpha → 0.2.3-alpha

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/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

@@ -633,6 +633,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 +692,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.3-alpha",
   "description": "Graph-based agent workflow engine — tracker-agnostic, pluggable runners",
   "bin": {
     "relay-flow": "./bin/relay-flow.js",