relay-flow 0.2.0-alpha → 0.2.1-alpha

package/internal/task/jira/effects_test.go

@@ -0,0 +1,39 @@
+package jira
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/task"
+)
+
+func TestClaimUsesOneLabelAdd(t *testing.T) {
+	fake := &fakeJira{}
+	sys := newSystemWithFake(t, fake)
+	if err := sys.Claim(context.Background(), task.TicketRef{Key: "PAY-1"}, "flow"); err != nil {
+		t.Fatal(err)
+	}
+	if len(fake.labelCalls) != 1 || fake.labelCalls[0] != "PAY-1:wf:flow" {
+		t.Fatalf("label calls = %v, want one claim update", fake.labelCalls)
+	}
+}
+
+func TestCommentKeepsMarkerIdempotency(t *testing.T) {
+	fake := &fakeJira{comments: []string{"existing\n<!-- visit:summary -->"}}
+	sys := newSystemWithFake(t, fake)
+	target := task.Target{Parent: task.TicketRef{Key: "PAY-1"}}
+	if err := sys.Comment(context.Background(), target, "summary", "visit:summary"); err != nil {
+		t.Fatal(err)
+	}
+	if len(fake.addedComments) != 0 {
+		t.Fatal("duplicate marked comment was posted")
+	}
+	fake.comments = nil
+	if err := sys.Comment(context.Background(), target, "summary", "visit:summary"); err != nil {
+		t.Fatal(err)
+	}
+	if len(fake.addedComments) != 1 || !strings.Contains(fake.addedComments[0], "visit:summary") {
+		t.Fatalf("posted comments = %v", fake.addedComments)
+	}
+}

package/internal/task/jira/filters_test.go

@@ -30,7 +30,7 @@ func (p *pollCountingSystem) Poll(ctx context.Context) ([]task.Ticket, error) {
 }
 
 func TestCompileFilterMatchesNormalizedFields(t *testing.T) {
-	sys := newSystemWithFake(t, &fakeACLI{})
+	sys := newSystemWithFake(t, &fakeJira{})
 
 	match, err := sys.CompileFilter(config.RawValues{
 		"filters": map[string]any{
@@ -57,7 +57,7 @@ func TestCompileFilterMatchesNormalizedFields(t *testing.T) {
 }
 
 func TestCompileFilterRejectsNonMatching(t *testing.T) {
-	sys := newSystemWithFake(t, &fakeACLI{})
+	sys := newSystemWithFake(t, &fakeJira{})
 	match, err := sys.CompileFilter(config.RawValues{
 		"filters": map[string]any{"parentStatuses": []any{"To Do"}},
 	})
@@ -80,7 +80,7 @@ func TestCompileFilterRejectsNonMatching(t *testing.T) {
 }
 
 func TestCompileFilterRejectsUnknownField(t *testing.T) {
-	sys := newSystemWithFake(t, &fakeACLI{})
+	sys := newSystemWithFake(t, &fakeJira{})
 	if _, err := sys.CompileFilter(config.RawValues{
 		"filters": map[string]any{"jql": "project = PAY"},
 	}); err == nil {
@@ -91,7 +91,7 @@ func TestCompileFilterRejectsUnknownField(t *testing.T) {
 func TestMatchingIsInMemoryNoRequery(t *testing.T) {
 	// One repo poll fetches the batch; the compiled matcher then evaluates
 	// every ticket in memory with no per-workflow re-query.
-	fake := &fakeACLI{searchJSON: []byte(`[{"id":"1","key":"PAY-1","fields":{"summary":"a","status":{"name":"To Do"},"issuetype":{"name":"Task"},"labels":[]}},{"id":"2","key":"PAY-2","fields":{"summary":"b","status":{"name":"Done"},"issuetype":{"name":"Task"},"labels":[]}},{"id":"3","key":"PAY-3","fields":{"summary":"c","status":{"name":"To Do"},"issuetype":{"name":"Task"},"labels":[]}}]`)}
+	fake := &fakeJira{searchJSON: []byte(`[{"id":"1","key":"PAY-1","fields":{"summary":"a","status":{"name":"To Do"},"issuetype":{"name":"Task"},"labels":[]}},{"id":"2","key":"PAY-2","fields":{"summary":"b","status":{"name":"Done"},"issuetype":{"name":"Task"},"labels":[]}},{"id":"3","key":"PAY-3","fields":{"summary":"c","status":{"name":"To Do"},"issuetype":{"name":"Task"},"labels":[]}}]`)}
 	base := newSystemWithFake(t, fake)
 	counting := &pollCountingSystem{System: base}
 
@@ -130,7 +130,7 @@ func TestJiraJSONNormalization(t *testing.T) {
 	// The adapter normalizes Jira search JSON (status, issue type, labels,
 	// assignee) into task.Ticket.Fields. Package-local so it can call the
 	// adapter's unexported normalization directly.
-	// acli emits a BARE ARRAY of issue objects (no REST envelope), and the
+	// The REST boundary supplies a normalized array of issue objects, and the
 	// normalized assignee is the user's email address — the stable identity
 	// workflow filters match on, not the human-readable display name.
 	raw := []byte(`[{"id":"1","key":"PAY-101","fields":{"summary":"parent","status":{"name":"To Do"},"issuetype":{"name":"Task"},"labels":["coding"],"assignee":{"displayName":"Relay Bot","emailAddress":"relay@bot"}}}]`)
@@ -159,21 +159,41 @@ func TestJiraJSONNormalization(t *testing.T) {
 	}
 }
 
-func TestJiraJSONNormalizationParsesRealAcliSearchShape(t *testing.T) {
-	// 9.9: parse the REAL acli wire shape captured live from
-	//   acli jira workitem search --jql ... --fields key,summary,status,issuetype,labels,assignee --json
-	// Fixture stored under testdata/ so regressions in the parser are
-	// caught against the actual acli contract, not a hand-written envelope.
-	raw, err := os.ReadFile("testdata/acli_search.json")
+func TestJiraJSONNormalizationFiltersOnlyOpenInwardBlockers(t *testing.T) {
+	raw := []byte(`[
+		{"id":"1","key":"PAY-1","fields":{"summary":"open blocker","status":{"name":"To Do"},"issuetype":{"name":"Task"},"labels":[],"issuelinks":[
+			{"type":{"name":"Blocks"},"inwardIssue":{"key":"OTHER-1","fields":{"status":{"statusCategory":{"key":"done"}}}}},
+			{"type":{"name":"Blocks"},"inwardIssue":{"key":"OTHER-2","fields":{"status":{"statusCategory":{"key":"new"}}}}}
+		]}},
+		{"id":"2","key":"PAY-2","fields":{"summary":"closed blockers","status":{"name":"To Do"},"issuetype":{"name":"Task"},"labels":[],"issuelinks":[
+			{"type":{"name":"Blocks"},"inwardIssue":{"key":"OTHER-3","fields":{"status":{"statusCategory":{"key":"done"}}}}}
+		]}},
+		{"id":"3","key":"PAY-3","fields":{"summary":"blocks another","status":{"name":"To Do"},"issuetype":{"name":"Task"},"labels":[],"issuelinks":[
+			{"type":{"name":"Blocks"},"outwardIssue":{"key":"OTHER-4","fields":{"status":{"statusCategory":{"key":"new"}}}}}
+		]}}
+	]`)
+	tickets, err := normalizeSearchResponse(raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(tickets) != 2 || tickets[0].Key != "PAY-2" || tickets[1].Key != "PAY-3" {
+		t.Fatalf("eligible tickets = %+v, want PAY-2 and PAY-3", tickets)
+	}
+}
+
+func TestJiraJSONNormalizationParsesCapturedIssueShape(t *testing.T) {
+	// Preserve the captured issue-field fixture while the REST client contract
+	// itself is exercised through strict HTTP tests.
+	raw, err := os.ReadFile("testdata/jira_search_issues.json")
 	if err != nil {
-		t.Fatalf("read acli fixture: %v", err)
+		t.Fatalf("read Jira fixture: %v", err)
 	}
 	tickets, err := normalizeSearchResponse(raw)
 	if err != nil {
-		t.Fatalf("normalization of real acli output failed: %v", err)
+		t.Fatalf("normalization of captured Jira output failed: %v", err)
 	}
 	if len(tickets) == 0 {
-		t.Fatal("real acli fixture yielded no tickets")
+		t.Fatal("captured Jira fixture yielded no tickets")
 	}
 	for _, tk := range tickets {
 		if tk.Key == "" || tk.ID == "" {
@@ -197,7 +217,7 @@ func TestJiraJSONNormalizationParsesRealAcliSearchShape(t *testing.T) {
 func TestCompileFilterAssigneeMatchesEmail(t *testing.T) {
 	// 9.9: workflow assignee filters match the normalized EMAIL identity,
 	// not the display name. e2e workflow.yaml filters on the user's email.
-	sys := newSystemWithFake(t, &fakeACLI{})
+	sys := newSystemWithFake(t, &fakeJira{})
 	match, err := sys.CompileFilter(config.RawValues{
 		"filters": map[string]any{"assignees": []any{"raj.popat@example.com"}},
 	})
@@ -218,7 +238,7 @@ func TestCompileFilterAssigneeMatchAndMismatch(t *testing.T) {
 	// assignee"); it matches the normalized ticket's assignee field.
 	// NOTE: the filter key `assignees` follows the same naming as
 	// parentStatuses/issueTypes/labels (plural); the docs do not pin the key.
-	sys := newSystemWithFake(t, &fakeACLI{})
+	sys := newSystemWithFake(t, &fakeJira{})
 	match, err := sys.CompileFilter(config.RawValues{
 		"filters": map[string]any{"assignees": []any{"relay-bot@example.com"}},
 	})

package/internal/task/jira/helpers_test.go

@@ -4,19 +4,21 @@ import (
 	"context"
 
 	"github.com/rajpopat27/relay-flow/internal/task"
+	"github.com/rajpopat27/relay-flow/internal/task/jira/rest"
 )
 
-// fakeClient adapts the test-local fakeACLI (transitions + raw search batch)
-// to the production acli.Client seam.
+// fakeClient adapts the test-local Jira fake to the production REST seam.
 type fakeClient struct {
-	fake *fakeACLI
+	fake *fakeJira
 }
 
 func (f *fakeClient) Search(context.Context, string) ([]byte, error) {
 	return f.fake.searchJSON, nil
 }
 
-func (f *fakeClient) ValidateAssignee(context.Context, string) error { return nil }
+func (f *fakeClient) ValidateCredentials(context.Context) error { return nil }
+
+func (f *fakeClient) ValidateAssignee(context.Context, string, string) error { return nil }
 
 func (f *fakeClient) ValidateStatus(context.Context, string, string) error { return nil }
 
@@ -24,29 +26,37 @@ func (f *fakeClient) View(context.Context, string) ([]byte, error) {
 	return []byte(`{"fields":{"labels":[],"subtasks":[]}}`), nil
 }
 
-func (f *fakeClient) CreateSubtask(context.Context, string, string, string) (string, string, error) {
-	return "", "", errNotFaked
-}
-
-func (f *fakeClient) Assign(_ context.Context, key, assignee string) error {
-	f.fake.assignments = append(f.fake.assignments, key+":"+assignee)
-	f.fake.events = append(f.fake.events, "assign")
-	return f.fake.assignErr
+func (f *fakeClient) CreateSubtasks(context.Context, string, string, string, []rest.SubtaskSpec) ([]rest.CreatedSubtask, error) {
+	return nil, errNotFaked
 }
 
-func (f *fakeClient) Transition(_ context.Context, key, status string) error {
+func (f *fakeClient) Transition(_ context.Context, key, status, assignee string) error {
+	if assignee != "" {
+		f.fake.assignments = append(f.fake.assignments, key+":"+assignee)
+		if f.fake.assignErr != nil {
+			return f.fake.assignErr
+		}
+	}
 	f.fake.events = append(f.fake.events, "transition")
 	f.fake.transition(key, status)
 	return nil
 }
 
-func (f *fakeClient) EnsureLabel(context.Context, string, string) error { return nil }
+func (f *fakeClient) EnsureLabel(_ context.Context, key, label string) error {
+	f.fake.labelCalls = append(f.fake.labelCalls, key+":"+label)
+	return nil
+}
 
-func (f *fakeClient) UpdateDescription(context.Context, string, string) error { return nil }
+func (f *fakeClient) UpdateMailbox(context.Context, string, string, string) error { return nil }
 
-func (f *fakeClient) ListComments(context.Context, string) ([]string, error) { return nil, nil }
+func (f *fakeClient) ListComments(context.Context, string) ([]string, error) {
+	return append([]string(nil), f.fake.comments...), nil
+}
 
-func (f *fakeClient) AddComment(context.Context, string, string) error { return nil }
+func (f *fakeClient) AddComment(_ context.Context, _ string, body string) error {
+	f.fake.addedComments = append(f.fake.addedComments, body)
+	return nil
+}
 
 type notFakedError struct{}
 
@@ -54,7 +64,7 @@ func (notFakedError) Error() string { return "not faked" }
 
 var errNotFaked = notFakedError{}
 
-// newSystemForTest builds the adapter around the test-local fake ACLI seam.
-func newSystemForTest(fake *fakeACLI) (task.System, error) {
+// newSystemForTest builds the adapter around the test-local REST seam.
+func newSystemForTest(fake *fakeJira) (task.System, error) {
 	return newSystemForCLI(&fakeClient{fake: fake})
 }

package/internal/task/jira/jira.go

@@ -8,11 +8,12 @@ import (
 	"log/slog"
 	"sort"
 	"strings"
+	"sync"
 
 	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/retry"
 	"github.com/rajpopat27/relay-flow/internal/task"
-	"github.com/rajpopat27/relay-flow/internal/task/jira/acli"
+	jirarest "github.com/rajpopat27/relay-flow/internal/task/jira/rest"
 )
 
 // Config is the adapter-owned typed config for every scope.
@@ -20,7 +21,6 @@ type Config struct {
 	Assignee   string       `yaml:"assignee,omitempty"`
 	Project    string       `yaml:"project,omitempty"`
 	Component  string       `yaml:"component,omitempty"`
-	Site       string       `yaml:"site,omitempty"`
 	Filters    Filters      `yaml:"filters,omitempty"`
 	Transition TransitionTo `yaml:"transitionTo,omitempty"`
 }
@@ -46,6 +46,14 @@ const (
 	defaultEndParentStatus   = "Done"
 )
 
+var (
+	clientsMu sync.Mutex
+	clients   = map[string]struct {
+		token  string
+		client *jirarest.HTTPClient
+	}{}
+)
+
 // claimLabel is the permanent workflow claim label.
 func claimLabel(workflow string) string { return "wf:" + workflow }
 
@@ -65,24 +73,60 @@ func init() {
 			if proj == "" || comp == "" {
 				return "", fmt.Errorf("jira task scope requires repo project and component")
 			}
-			return strings.Join([]string{root.Site, proj, comp}, "/"), nil
+			creds, err := loadCredentialsDefault()
+			if err != nil {
+				return "", fmt.Errorf("jira credentials: %w", err)
+			}
+			return strings.Join([]string{creds.Site, proj, comp}, "/"), nil
 		},
+		Auth: auth,
 		New: func(ctx context.Context, spec task.RepoSpec) (task.System, error) {
-			return newSystem(ctx, acli.New(), spec)
+			merged := config.Merge(spec.RootConfig, spec.RepoConfig)
+			var cfg Config
+			if err := config.DecodeStrict(merged, &cfg); err != nil {
+				return nil, fmt.Errorf("jira repo %q config: %w", spec.Name, err)
+			}
+			creds, err := loadCredentialsDefault()
+			if err != nil {
+				return nil, fmt.Errorf("jira credentials: %w", err)
+			}
+			client, err := sharedClient(creds.Site, creds.Email, creds.Token)
+			if err != nil {
+				return nil, err
+			}
+			return newSystem(ctx, client, spec)
 		},
 	})
 }
 
+func sharedClient(site, email, token string) (*jirarest.HTTPClient, error) {
+	key := strings.TrimRight(site, "/") + "\x00" + email
+	clientsMu.Lock()
+	defer clientsMu.Unlock()
+	if cached := clients[key]; cached.client != nil && cached.token == token {
+		return cached.client, nil
+	}
+	client, err := jirarest.New(site, email, token)
+	if err != nil {
+		return nil, err
+	}
+	clients[key] = struct {
+		token  string
+		client *jirarest.HTTPClient
+	}{token: token, client: client}
+	return client, nil
+}
+
 // system is the repo-bound Jira task.System. It is safe for concurrent use;
-// the ACLI client owns any subprocess serialization.
+// the REST client owns connection reuse, caches, and request limiting.
 type system struct {
-	cli       acli.Client
+	cli       jirarest.Client
 	repoName  string
 	base      config.RawValues
 	effective Config // root+repo merged
 }
 
-func newSystem(ctx context.Context, cli acli.Client, spec task.RepoSpec) (*system, error) {
+func newSystem(ctx context.Context, cli jirarest.Client, spec task.RepoSpec) (*system, error) {
 	if spec.Name == "" {
 		return nil, fmt.Errorf("jira: repo name is required")
 	}
@@ -92,7 +136,7 @@ func newSystem(ctx context.Context, cli acli.Client, spec task.RepoSpec) (*syste
 		return nil, fmt.Errorf("jira repo %q config: %w", spec.Name, err)
 	}
 	if cfg.Assignee != "" {
-		if err := cli.ValidateAssignee(ctx, cfg.Assignee); err != nil {
+		if err := cli.ValidateAssignee(ctx, cfg.Project, cfg.Assignee); err != nil {
 			return nil, fmt.Errorf("jira repo %q assignee %q: %w", spec.Name, cfg.Assignee, err)
 		}
 	}
@@ -110,11 +154,10 @@ func newSystem(ctx context.Context, cli acli.Client, spec task.RepoSpec) (*syste
 	return s, nil
 }
 
-// newSystemForCLI constructs a system around an explicit CLI seam (tests).
-func newSystemForCLI(cli acli.Client) (task.System, error) {
+// newSystemForCLI constructs a system around an explicit Jira client seam.
+func newSystemForCLI(cli jirarest.Client) (task.System, error) {
 	return newSystem(context.Background(), cli, task.RepoSpec{
 		Name:       "payments",
-		RootConfig: config.RawValues{},
 		RepoConfig: config.RawValues{"project": "PAY", "component": "api"},
 	})
 }
@@ -198,27 +241,10 @@ func (s *system) CompileFilter(workflowTaskConfig config.RawValues) (func(task.T
 
 // --- Claim ---
 
-// Claim adds wf:<workflow> to the parent. It re-reads the parent's claims,
-// treats the same claim as idempotent, and rejects a conflicting claim.
+// Claim adds wf:<workflow> using the claims already inspected by routing.
+// Jira's label-add operation is idempotent.
 func (s *system) Claim(ctx context.Context, ticket task.TicketRef, workflow string) error {
-	raw, err := s.cli.View(ctx, ticket.Key)
-	if err != nil {
-		return err
-	}
-	labels, err := labelsOf(raw)
-	if err != nil {
-		return err
-	}
-	want := claimLabel(workflow)
-	for _, l := range labels {
-		if l == want {
-			return nil // idempotent
-		}
-		if strings.HasPrefix(l, "wf:") {
-			return fmt.Errorf("ticket %s already claimed by %s", ticket.Key, l)
-		}
-	}
-	return s.cli.EnsureLabel(ctx, ticket.Key, want)
+	return s.cli.EnsureLabel(ctx, ticket.Key, claimLabel(workflow))
 }
 
 // --- Config validation ---
@@ -231,7 +257,7 @@ func (s *system) ValidateConfig(ctx context.Context, workflowTaskConfig config.R
 	if err != nil {
 		return fmt.Errorf("workflow taskConfig: %w", err)
 	}
-	if err := s.validateAssignee(ctx, "workflow", workflowCfg.Assignee); err != nil {
+	if err := s.validateAssignee(ctx, "workflow", workflowCfg.Project, workflowCfg.Assignee); err != nil {
 		return err
 	}
 	if err := s.validateTransition(ctx, "workflow", workflowCfg.Project, workflowCfg.Transition); err != nil {
@@ -247,7 +273,7 @@ func (s *system) ValidateConfig(ctx context.Context, workflowTaskConfig config.R
 		if err != nil {
 			return fmt.Errorf("node %q taskConfig: %w", n, err)
 		}
-		if err := s.validateAssignee(ctx, fmt.Sprintf("node %q", n), cfg.Assignee); err != nil {
+		if err := s.validateAssignee(ctx, fmt.Sprintf("node %q", n), cfg.Project, cfg.Assignee); err != nil {
 			return err
 		}
 		if err := s.validateTransition(ctx, fmt.Sprintf("node %q", n), cfg.Project, cfg.Transition); err != nil {
@@ -257,11 +283,11 @@ func (s *system) ValidateConfig(ctx context.Context, workflowTaskConfig config.R
 	return nil
 }
 
-func (s *system) validateAssignee(ctx context.Context, scope, assignee string) error {
+func (s *system) validateAssignee(ctx context.Context, scope, project, assignee string) error {
 	if assignee == "" {
 		return nil
 	}
-	if err := s.cli.ValidateAssignee(ctx, assignee); err != nil {
+	if err := s.cli.ValidateAssignee(ctx, project, assignee); err != nil {
 		return fmt.Errorf("%s assignee %q: %w", scope, assignee, err)
 	}
 	return nil
@@ -347,28 +373,38 @@ func (s *system) EnsureMailboxes(ctx context.Context, parent task.TicketRef, wor
 		return nil, err
 	}
 	out := map[string]task.Mailbox{}
+	missing := make([]task.MailboxSpec, 0)
 	for _, spec := range specs {
 		if mb, ok := existing[spec.Title]; ok {
-			// Found existing: reconcile the workflow label and description,
-			// and return the complete node-identified value.
-			if err := s.cli.EnsureLabel(ctx, mb.Key, claimLabel(workflow)); err != nil {
-				return nil, fmt.Errorf("label mailbox %q: %w", mb.Key, err)
-			}
-			if err := s.cli.UpdateDescription(ctx, mb.Key, spec.Description); err != nil {
-				return nil, fmt.Errorf("describe mailbox %q: %w", mb.Key, err)
+			if err := s.cli.UpdateMailbox(ctx, mb.Key, spec.Description, claimLabel(workflow)); err != nil {
+				return nil, fmt.Errorf("reconcile mailbox %q: %w", mb.Key, err)
 			}
 			mb.Node = spec.Node
 			out[spec.Node] = mb
 			continue
 		}
-		id, key, err := s.cli.CreateSubtask(ctx, parent.Key, spec.Title, spec.Description)
-		if err != nil {
-			return nil, fmt.Errorf("create mailbox %q: %w", spec.Title, err)
-		}
-		if err := s.cli.EnsureLabel(ctx, key, claimLabel(workflow)); err != nil {
-			return nil, fmt.Errorf("label mailbox %q: %w", key, err)
+		missing = append(missing, spec)
+	}
+	if len(missing) == 0 {
+		return out, nil
+	}
+	createSpecs := make([]jirarest.SubtaskSpec, 0, len(missing))
+	for _, spec := range missing {
+		createSpecs = append(createSpecs, jirarest.SubtaskSpec{Title: spec.Title, Description: spec.Description})
+	}
+	created, err := s.cli.CreateSubtasks(ctx, parent.Key, s.effective.Project, claimLabel(workflow), createSpecs)
+	if err != nil {
+		return nil, fmt.Errorf("create mailboxes: %w", err)
+	}
+	if len(created) != len(missing) {
+		return nil, fmt.Errorf("create mailboxes: created %d of %d", len(created), len(missing))
+	}
+	for i, mailbox := range created {
+		spec := missing[i]
+		if mailbox.ID == "" || mailbox.Key == "" {
+			return nil, fmt.Errorf("create mailbox %q: Jira returned no id/key", spec.Title)
 		}
-		out[spec.Node] = task.Mailbox{ID: id, Key: key, Node: spec.Node}
+		out[spec.Node] = task.Mailbox{ID: mailbox.ID, Key: mailbox.Key, Node: spec.Node}
 	}
 	return out, nil
 }
@@ -388,20 +424,15 @@ func (s *system) ApplyTaskConfig(ctx context.Context, target task.Target, taskCo
 	}
 	tr := cfg.Transition
 	if target.Mailbox != nil {
-		if cfg.Assignee != "" {
-			if err := s.cli.Assign(ctx, target.Mailbox.Key, cfg.Assignee); err != nil {
-				return err
-			}
-		}
 		status := tr.TaskStatus
 		if status == "" {
 			status = defaultWorkTaskStatus
 		}
-		if err := s.transition(ctx, target.Mailbox.Key, status); err != nil {
+		if err := s.transition(ctx, target.Mailbox.Key, status, cfg.Assignee); err != nil {
 			return err
 		}
 		if tr.ParentStatus != "" {
-			return s.transition(ctx, target.Parent.Key, tr.ParentStatus)
+			return s.transition(ctx, target.Parent.Key, tr.ParentStatus, "")
 		}
 		return nil
 	}
@@ -410,13 +441,13 @@ func (s *system) ApplyTaskConfig(ctx context.Context, target task.Target, taskCo
 	if status == "" {
 		status = defaultStartParentStatus
 	}
-	return s.transition(ctx, target.Parent.Key, status)
+	return s.transition(ctx, target.Parent.Key, status, "")
 }
 
 // transition applies a Jira status transition, mapping a human-incompatible
 // current state to a conflict.
-func (s *system) transition(ctx context.Context, key, status string) error {
-	err := s.cli.Transition(ctx, key, status)
+func (s *system) transition(ctx context.Context, key, status, assignee string) error {
+	err := s.cli.Transition(ctx, key, status, assignee)
 	if err != nil && isConflict(err) {
 		return retry.ConflictError(err)
 	}
@@ -431,7 +462,7 @@ func isConflict(err error) bool {
 
 // CompleteMailbox marks the mailbox Done using task-system semantics.
 func (s *system) CompleteMailbox(ctx context.Context, mailbox task.Mailbox) error {
-	return s.transition(ctx, mailbox.Key, "Done")
+	return s.transition(ctx, mailbox.Key, "Done", "")
 }
 
 // --- Comments ---
@@ -480,7 +511,7 @@ func (s *system) Comment(ctx context.Context, target task.Target, body, marker s
 // comments, labels, and history. No parent rollback runs.
 func (s *system) ResetForRecovery(ctx context.Context, _ task.TicketRef, mailboxes []task.Mailbox, _ config.RawValues) error {
 	for _, mb := range mailboxes {
-		if err := s.transition(ctx, mb.Key, "To Do"); err != nil {
+		if err := s.transition(ctx, mb.Key, "To Do", ""); err != nil {
 			return fmt.Errorf("reset mailbox %s: %w", mb.Key, err)
 		}
 	}

package/internal/task/jira/normalize.go

@@ -3,13 +3,12 @@ package jira
 import (
 	"encoding/json"
 	"fmt"
+	"strings"
 
 	"github.com/rajpopat27/relay-flow/internal/task"
 )
 
-// rawIssue matches one entry in acli's search output. acli emits a BARE
-// ARRAY of these (no {"issues":[...]} REST envelope) — the adapter owns
-// the acli wire contract, not the REST API's.
+// rawIssue is the subset of Jira REST issue fields normalized by the adapter.
 type rawIssue struct {
 	ID     string `json:"id"`
 	Key    string `json:"key"`
@@ -33,11 +32,26 @@ type rawIssue struct {
 				Summary string `json:"summary"`
 			} `json:"fields"`
 		} `json:"subtasks"`
+		IssueLinks []struct {
+			Type struct {
+				Name string `json:"name"`
+			} `json:"type"`
+			InwardIssue *struct {
+				Key    string `json:"key"`
+				Fields struct {
+					Status struct {
+						StatusCategory struct {
+							Key string `json:"key"`
+						} `json:"statusCategory"`
+					} `json:"status"`
+				} `json:"fields"`
+			} `json:"inwardIssue"`
+		} `json:"issuelinks"`
 	} `json:"fields"`
 }
 
-// normalizeSearchResponse converts raw acli search JSON (a bare array of
-// issue objects) into normalized parent tickets: status, issueType, labels,
+// normalizeSearchResponse converts REST issue objects into normalized parent
+// tickets: status, issueType, labels,
 // and assignee become plain Fields entries. Assignee is normalized to the
 // user's email address — the stable, machine-comparable identity workflow
 // filters match against (displayName is human-readable, not an identifier).
@@ -49,6 +63,9 @@ func normalizeSearchResponse(raw []byte) ([]task.Ticket, error) {
 	}
 	out := make([]task.Ticket, 0, len(issues))
 	for _, issue := range issues {
+		if hasOpenBlocker(issue) {
+			continue
+		}
 		fields := map[string]any{
 			"status":    issue.Fields.Status.Name,
 			"issueType": issue.Fields.IssueType.Name,
@@ -68,6 +85,16 @@ func normalizeSearchResponse(raw []byte) ([]task.Ticket, error) {
 	return out, nil
 }
 
+func hasOpenBlocker(issue rawIssue) bool {
+	for _, link := range issue.Fields.IssueLinks {
+		if link.Type.Name == "Blocks" && link.InwardIssue != nil &&
+			!strings.EqualFold(link.InwardIssue.Fields.Status.StatusCategory.Key, "done") {
+			return true
+		}
+	}
+	return false
+}
+
 func claimLabels(labels []string) []string {
 	var out []string
 	for _, l := range labels {
@@ -78,15 +105,6 @@ func claimLabels(labels []string) []string {
 	return out
 }
 
-// labelsOf extracts label strings from a raw Jira issue view.
-func labelsOf(raw []byte) ([]string, error) {
-	var issue rawIssue
-	if err := json.Unmarshal(raw, &issue); err != nil {
-		return nil, fmt.Errorf("jira view: parse json: %w", err)
-	}
-	return issue.Fields.Labels, nil
-}
-
 // subtasksOf maps existing subtask titles (<ticket>:<node>) to mailboxes.
 func subtasksOf(raw []byte) (map[string]task.Mailbox, error) {
 	var issue rawIssue