relay-flow 0.1.0-alpha.0

package/internal/tasks/jira/jira.go

@@ -0,0 +1,231 @@
+// Package jira is the built-in Tasks adapter for Jira. It talks to Jira
+// via the acli CLI and knows nothing about runners, terminals, or agents.
+// States are Jira status names; claims are Jira labels (wf:<workflow>).
+package jira
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/rajpopat27/relay-flow/internal/acli"
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/tasks"
+)
+
+func init() {
+	tasks.Register("jira", tasks.Factory{
+		UnmarshalConfig: unmarshalConfig,
+		New: func(cfg any, wfName string, nodes map[string]config.Node, assignee, repoName string) (tasks.Tasks, error) {
+			c, ok := cfg.(JiraConfig)
+			if !ok {
+				return nil, fmt.Errorf("internal: jira factory received %T", cfg)
+			}
+			if repoName == "" {
+				return nil, fmt.Errorf("jira adapter requires a repo name (used as the JQL component filter)")
+			}
+			return newJira(c, wfName, nodes, assignee, repoName, nil)
+		},
+	})
+}
+
+// JiraConfig is the strictly-unmarshalled tasks.config for type jira.
+type JiraConfig struct {
+	// Query is a JQL fragment (no issuetype / assignee / ORDER BY — those
+	// are appended by the adapter or rejected).
+	Query string `yaml:"query"`
+	// IssueTypes restricts the workflow to these Jira issue types.
+	IssueTypes []string `yaml:"issueTypes"`
+	// AssigneeIsAgent marks centralized mode (org server owns the queue,
+	// tickets assigned upstream to bot accounts): no assignee clause.
+	AssigneeIsAgent bool `yaml:"assigneeIsAgent"`
+}
+
+var (
+	issueTypeRe = regexp.MustCompile(`(?i)\bissuetype\b`)
+	assigneeRe  = regexp.MustCompile(`(?i)\bassignee\b`)
+)
+
+func unmarshalConfig(m map[string]any) (any, error) {
+	var c JiraConfig
+	if err := strictDecode(m, &c); err != nil {
+		return nil, err
+	}
+	if strings.TrimSpace(c.Query) == "" {
+		return nil, fmt.Errorf("query must not be empty")
+	}
+	if strings.Contains(strings.ToUpper(c.Query), "ORDER BY") {
+		return nil, fmt.Errorf("query must not contain ORDER BY (always ordered by updated)")
+	}
+	if issueTypeRe.MatchString(c.Query) {
+		return nil, fmt.Errorf("query must not contain issuetype; use the issueTypes field")
+	}
+	if assigneeRe.MatchString(c.Query) {
+		return nil, fmt.Errorf("query must not contain assignee; identity comes from machine config or assigneeIsAgent")
+	}
+	if len(c.IssueTypes) == 0 {
+		return nil, fmt.Errorf("issueTypes must not be empty")
+	}
+	for _, it := range c.IssueTypes {
+		if strings.TrimSpace(it) == "" {
+			return nil, fmt.Errorf("issueTypes must not contain empty values")
+		}
+	}
+	return c, nil
+}
+
+// aclier is the seam to Jira. *acli.Client satisfies it; tests fake it.
+type aclier interface {
+	Search(jql string) ([]acli.Ticket, error)
+	View(key string) (acli.Ticket, error)
+	AddLabel(key string, existing []string, label string) error
+	Transition(key, status string) error
+	Comment(key, body string) error
+}
+
+type jiraTasks struct {
+	cfg        JiraConfig
+	wfName     string
+	nodes      map[string]config.Node
+	assignee   string
+	repoComponent string
+	jql        string
+	ac         aclier
+}
+
+// newJira builds the adapter. repoComponent is the Jira component name
+// (the Orca repo displayName); empty in unit tests → clause omitted.
+// ac nil → real acli client.
+func newJira(cfg JiraConfig, wfName string, nodes map[string]config.Node, assignee, repoComponent string, ac aclier) (*jiraTasks, error) {
+	if ac == nil {
+		ac = acli.New()
+	}
+	j := &jiraTasks{cfg: cfg, wfName: wfName, nodes: nodes, assignee: assignee, repoComponent: repoComponent, ac: ac}
+	j.jql = j.buildJQL()
+	return j, nil
+}
+
+func (j *jiraTasks) buildJQL() string {
+	quoted := make([]string, 0, len(j.cfg.IssueTypes))
+	for _, it := range j.cfg.IssueTypes {
+		quoted = append(quoted, fmt.Sprintf("%q", it))
+	}
+	q := fmt.Sprintf("(%s) AND issuetype IN (%s)", j.cfg.Query, strings.Join(quoted, ", "))
+	if j.repoComponent != "" {
+		q += fmt.Sprintf(" AND component = %q", j.repoComponent)
+	}
+	// Assignee comes from the machine config (per-person, uncommitted),
+	// never the shared workflow YAML. Centralized mode skips the clause.
+	if j.assignee != "" && !j.cfg.AssigneeIsAgent {
+		q += fmt.Sprintf(" AND assignee = %q", j.assignee)
+	}
+	return q + " ORDER BY updated"
+}
+
+func claimLabel(wfName string) string { return "wf:" + wfName }
+
+// List runs the workflow's one JQL query and maps each ticket's Jira
+// status back to a node via the `when` values ("" = unmapped). ClaimedBy
+// is read off the wf:* labels.
+func (j *jiraTasks) List() ([]tasks.Ticket, error) {
+	found, err := j.ac.Search(j.jql)
+	if err != nil {
+		return nil, err
+	}
+	out := make([]tasks.Ticket, 0, len(found))
+	for _, t := range found {
+		tk := tasks.Ticket{Key: t.Key, Summary: t.Summary}
+		for name, n := range j.nodes {
+			if strings.EqualFold(n.When, t.Status) {
+				tk.Node = name
+				break
+			}
+		}
+		for _, l := range t.Labels {
+			if strings.HasPrefix(l, "wf:") {
+				tk.ClaimedBy = strings.TrimPrefix(l, "wf:")
+				break
+			}
+		}
+		out = append(out, tk)
+	}
+	return out, nil
+}
+
+// Claim attaches this workflow's claim label. Labels are never removed:
+// they are the cross-restart mutex.
+func (j *jiraTasks) Claim(t tasks.Ticket) error {
+	cur, err := j.ac.View(t.Key)
+	if err != nil {
+		return fmt.Errorf("claim %s: view: %w", t.Key, err)
+	}
+	return j.ac.AddLabel(t.Key, cur.Labels, claimLabel(j.wfName))
+}
+
+// Report transitions the ticket to the target node's Jira status and
+// posts the summary as a comment. Self-loop (target status == current
+// status) → comment only (Jira has no self-transitions).
+func (j *jiraTasks) Report(t tasks.Ticket, outcome, targetNode, summary string) error {
+	target, ok := j.nodes[targetNode]
+	if !ok {
+		return fmt.Errorf("unknown node %q", targetNode)
+	}
+	cur, err := j.ac.View(t.Key)
+	if err != nil {
+		return fmt.Errorf("view %s: %w", t.Key, err)
+	}
+	agent := j.nodes[t.Node].Agent
+	body := fmt.Sprintf("[%s] %s (agent: %s, node: %s) reported %s → %s\n\n%s", j.wfName, t.Key, agent, t.Node, outcome, targetNode, summary)
+	if strings.EqualFold(cur.Status, target.When) {
+		return j.ac.Comment(t.Key, body)
+	}
+	if err := j.ac.Transition(t.Key, target.When); err != nil {
+		return fmt.Errorf("transition %s → %q: %w", t.Key, target.When, err)
+	}
+	return j.ac.Comment(t.Key, body)
+}
+
+// ProjectKeyFromQuery extracts the project key from a JQL fragment (used
+// by submit-time status validation).
+func ProjectKeyFromQuery(query string) (string, error) {
+	re := regexp.MustCompile(`(?i)\bproject\s*=\s*("?[A-Za-z][A-Za-z0-9]*"?)`)
+	m := re.FindStringSubmatch(query)
+	if m == nil {
+		return "", fmt.Errorf("could not find 'project = <KEY>' in query %q; it is required for status validation", query)
+	}
+	return strings.Trim(m[1], `"`), nil
+}
+
+// UnmarshalConfigForValidation exposes the strict config decode for
+// submit-time validation (server needs the query/assigneeIsAgent fields).
+func UnmarshalConfigForValidation(m map[string]any) (JiraConfig, error) {
+	c, err := unmarshalConfig(m)
+	if err != nil {
+		return JiraConfig{}, err
+	}
+	return c.(JiraConfig), nil
+}
+
+// StatusValidator is the seam ValidateStates uses. *acli.Client fits.
+type StatusValidator interface {
+	ValidateStatus(projectKey, status string) error
+}
+
+// ValidateStates probes every node's `when` status against the Jira
+// project; Jira's JQL parser rejects unknown statuses with a hard error,
+// so a typo fails at submit instead of silently matching zero tickets.
+func ValidateStates(v StatusValidator, nodes map[string]config.Node, projectKey string) ([]string, error) {
+	seen := map[string]bool{}
+	var bad []string
+	for _, n := range nodes {
+		key := strings.ToLower(strings.TrimSpace(n.When))
+		if key == "" || seen[key] {
+			continue
+		}
+		seen[key] = true
+		if err := v.ValidateStatus(projectKey, n.When); err != nil {
+			bad = append(bad, n.When)
+		}
+	}
+	return bad, nil
+}

package/internal/tasks/jira/jira_test.go

@@ -0,0 +1,259 @@
+package jira
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/acli"
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/tasks"
+)
+
+var testNodes = map[string]config.Node{
+	"coding":    {Agent: "build", When: "In Progress", OnSuccess: "reviewing", OnFailure: "coding"},
+	"reviewing": {Agent: "build", When: "In Review", OnSuccess: "done", OnFailure: "coding"},
+	"done":      {When: "Done"},
+}
+
+func TestClaimLabel(t *testing.T) {
+	if got := claimLabel("xyzTaskFlow"); got != "wf:xyzTaskFlow" {
+		t.Errorf("claimLabel = %q", got)
+	}
+}
+
+func TestBuildJQL(t *testing.T) {
+	cfg := JiraConfig{Query: "project = xyz", IssueTypes: []string{"Task"}}
+	j, err := newJira(cfg, "wf", testNodes, "Jane Doe", "repo:xyz", nil)
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	want := `(project = xyz) AND issuetype IN ("Task") AND component = "repo:xyz" AND assignee = "Jane Doe" ORDER BY updated`
+	if j.jql != want {
+		t.Errorf("jql =\n  %q\nwant\n  %q", j.jql, want)
+	}
+}
+
+func TestBuildJQLCentralizedSkipsAssignee(t *testing.T) {
+	cfg := JiraConfig{Query: "project = xyz", IssueTypes: []string{"Task", "Story"}, AssigneeIsAgent: true}
+	j, err := newJira(cfg, "wf", testNodes, "", "repo:xyz", nil)
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	if strings.Contains(j.jql, "assignee") {
+		t.Errorf("assigneeIsAgent must skip assignee clause: %q", j.jql)
+	}
+	if !strings.Contains(j.jql, `"Task", "Story"`) {
+		t.Errorf("issueTypes list: %q", j.jql)
+	}
+}
+
+func TestConfigValidation(t *testing.T) {
+	base := map[string]any{"query": "project = xyz", "issueTypes": []any{"Task"}}
+	goodAny, err := unmarshalConfig(base)
+	if err != nil {
+		t.Fatalf("valid config rejected: %v", err)
+	}
+	good := goodAny.(JiraConfig)
+	if good.Query != "project = xyz" || len(good.IssueTypes) != 1 {
+		t.Errorf("%+v", good)
+	}
+
+	bad := []struct {
+		name string
+		mut  func(map[string]any)
+		want string
+	}{
+		{"empty query", func(m map[string]any) { m["query"] = "" }, "query"},
+		{"no issueTypes", func(m map[string]any) { delete(m, "issueTypes") }, "issueTypes"},
+		{"ORDER BY in query", func(m map[string]any) { m["query"] = "project = xyz ORDER BY rank" }, "ORDER BY"},
+		{"issuetype in query", func(m map[string]any) { m["query"] = "project = xyz AND issuetype = Bug" }, "issuetype"},
+		{"assignee in query", func(m map[string]any) { m["query"] = "project = xyz AND assignee = bob" }, "assignee"},
+		{"unknown field", func(m map[string]any) { m["bogus"] = 1 }, "bogus"},
+	}
+	for _, tc := range bad {
+		t.Run(tc.name, func(t *testing.T) {
+			m := map[string]any{"query": "project = xyz", "issueTypes": []any{"Task"}}
+			tc.mut(m)
+			if _, err := unmarshalConfig(m); err == nil || !strings.Contains(err.Error(), tc.want) {
+				t.Errorf("err = %v, want mention %q", err, tc.want)
+			}
+		})
+	}
+}
+
+type fakeAcli struct {
+	tickets       []acli.Ticket
+	labelsAdded   []string
+	transitions   []string
+	comments      []string
+	views         map[string]acli.Ticket
+	transitionErr error
+}
+
+func (f *fakeAcli) Search(jql string) ([]acli.Ticket, error) { return f.tickets, nil }
+func (f *fakeAcli) AddLabel(key string, existing []string, label string) error {
+	f.labelsAdded = append(f.labelsAdded, key+":"+label)
+	return nil
+}
+func (f *fakeAcli) Transition(key, status string) error {
+	f.transitions = append(f.transitions, key+":"+status)
+	return f.transitionErr
+}
+func (f *fakeAcli) Comment(key, body string) error {
+	f.comments = append(f.comments, key+":"+body)
+	return nil
+}
+func (f *fakeAcli) View(key string) (acli.Ticket, error) {
+	t, ok := f.views[key]
+	if !ok {
+		t = acli.Ticket{Key: key}
+	}
+	return t, nil
+}
+
+func mustJira(t *testing.T, ac aclier) *jiraTasks {
+	t.Helper()
+	j, err := newJira(JiraConfig{Query: "project = xyz", IssueTypes: []string{"Task"}}, "wf", testNodes, "", "repo:xyz", ac)
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	return j
+}
+
+func TestListMapsStateToNode(t *testing.T) {
+	fa := &fakeAcli{tickets: []acli.Ticket{
+		{Key: "XYZ-1", Summary: "s", Status: "In Progress"},
+		{Key: "XYZ-2", Summary: "s", Status: "In Review", Labels: []string{"wf:otherFlow"}},
+		{Key: "XYZ-3", Summary: "s", Status: "Backlog"},
+	}}
+	j := mustJira(t, fa)
+	got, err := j.List()
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	if len(got) != 3 {
+		t.Fatalf("len = %d", len(got))
+	}
+	if got[0].Node != "coding" || got[0].ClaimedBy != "" {
+		t.Errorf("t1 = %+v", got[0])
+	}
+	if got[1].Node != "reviewing" || got[1].ClaimedBy != "otherFlow" {
+		t.Errorf("t2 = %+v", got[1])
+	}
+	if got[2].Node != "" {
+		t.Errorf("unmapped state must yield empty Node: %+v", got[2])
+	}
+}
+
+func TestClaim(t *testing.T) {
+	fa := &fakeAcli{views: map[string]acli.Ticket{"XYZ-1": {Key: "XYZ-1", Labels: []string{"existing"}}}}
+	j := mustJira(t, fa)
+	err := j.Claim(tasksTicket("XYZ-1"))
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	if len(fa.labelsAdded) != 1 || fa.labelsAdded[0] != "XYZ-1:wf:wf" {
+		t.Errorf("labelsAdded = %v", fa.labelsAdded)
+	}
+}
+
+func TestReportTransitions(t *testing.T) {
+	fa := &fakeAcli{views: map[string]acli.Ticket{
+		"XYZ-1": {Key: "XYZ-1", Status: "In Progress"},
+	}}
+	j := mustJira(t, fa)
+	err := j.Report(tasksTicket("XYZ-1"), "success", "reviewing", "did the thing")
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	if len(fa.transitions) != 1 || fa.transitions[0] != "XYZ-1:In Review" {
+		t.Errorf("transitions = %v", fa.transitions)
+	}
+	if len(fa.comments) != 1 || !strings.Contains(fa.comments[0], "did the thing") {
+		t.Errorf("comments = %v", fa.comments)
+	}
+}
+
+func TestReportSelfLoopCommentsOnly(t *testing.T) {
+	fa := &fakeAcli{views: map[string]acli.Ticket{
+		"XYZ-1": {Key: "XYZ-1", Status: "In Progress"},
+	}}
+	j := mustJira(t, fa)
+	// coding onFailure = coding: target state == current state.
+	err := j.Report(tasksTicket("XYZ-1"), "failure", "coding", "still broken")
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	if len(fa.transitions) != 0 {
+		t.Errorf("self-loop must not transition: %v", fa.transitions)
+	}
+	if len(fa.comments) != 1 {
+		t.Errorf("self-loop must comment: %v", fa.comments)
+	}
+}
+
+func TestReportUnknownTargetNode(t *testing.T) {
+	fa := &fakeAcli{views: map[string]acli.Ticket{"XYZ-1": {Key: "XYZ-1", Status: "In Progress"}}}
+	j := mustJira(t, fa)
+	if err := j.Report(tasksTicket("XYZ-1"), "success", "nowhere", "x"); err == nil ||
+		!strings.Contains(err.Error(), "unknown node") {
+		t.Errorf("err = %v", err)
+	}
+}
+
+func TestProjectKeyFromQuery(t *testing.T) {
+	got, err := ProjectKeyFromQuery("project = xyz AND foo = bar")
+	if err != nil || got != "xyz" {
+		t.Errorf("got %q err %v", got, err)
+	}
+	got, err = ProjectKeyFromQuery(`PROJECT = "ABC"`)
+	if err != nil || got != "ABC" {
+		t.Errorf("got %q err %v", got, err)
+	}
+	if _, err = ProjectKeyFromQuery("foo = bar"); err == nil {
+		t.Error("expected error for missing project")
+	}
+}
+
+func TestValidateStates(t *testing.T) {
+	fa := &fakeValidator{good: map[string]bool{"In Progress": true, "In Review": true}}
+	bad, err := ValidateStates(fa, testNodes, "xyz")
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	if len(bad) != 1 || bad[0] != "Done" {
+		t.Errorf("bad = %v", bad)
+	}
+}
+
+type fakeValidator struct{ good map[string]bool }
+
+func (f *fakeValidator) ValidateStatus(projectKey, status string) error {
+	if f.good[status] {
+		return nil
+	}
+	return errInvalidStatus
+}
+
+var errInvalidStatus = errorString("invalid status")
+
+type errorString string
+
+func (e errorString) Error() string { return string(e) }
+
+func tasksTicket(key string) tasks.Ticket { return tasks.Ticket{Key: key} }
+
+func TestReportTransitionFailurePropagates(t *testing.T) {
+	fa := &fakeAcli{
+		views:         map[string]acli.Ticket{"XYZ-1": {Key: "XYZ-1", Status: "In Progress"}},
+		transitionErr: errorString("No allowed transitions found for given status"),
+	}
+	j := mustJira(t, fa)
+	err := j.Report(tasks.Ticket{Key: "XYZ-1"}, "success", "reviewing", "x")
+	if err == nil || !strings.Contains(err.Error(), "No allowed transitions") {
+		t.Errorf("transition failure must propagate, got %v", err)
+	}
+	if len(fa.comments) != 0 {
+		t.Errorf("no comment on failed transition: %v", fa.comments)
+	}
+}

package/internal/tasks/jira/jql_test.go

@@ -0,0 +1,16 @@
+package jira
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDistributedJQLHasAssignee(t *testing.T) {
+	j, err := newJira(JiraConfig{Query: "project = XYZ", IssueTypes: []string{"Task"}}, "wf", testNodes, "Jane Doe", "xyz-repo", nil)
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	if !strings.Contains(j.jql, `assignee = "Jane Doe"`) {
+		t.Errorf("distributed JQL missing assignee: %q", j.jql)
+	}
+}

package/internal/tasks/tasks.go

@@ -0,0 +1,90 @@
+// Package tasks defines the ticket-system plug point. Jira ships built in
+// (internal/tasks/jira); beads/linear/github adapters register the same
+// way via init() — the database/sql driver pattern: import to register,
+// then resolve by type name from the workflow YAML's `tasks.type`.
+package tasks
+
+import (
+	"fmt"
+	"sort"
+	"sync"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+)
+
+// Ticket is one unit of work as seen by the daemon. Adapters fill Node by
+// reverse-mapping the ticket's tracker state through the workflow's node
+// `when` values ("" = unmapped state), and ClaimedBy from claim labels
+// ("" = unclaimed).
+type Ticket struct {
+	Key       string
+	Summary   string
+	Node      string
+	ClaimedBy string
+}
+
+// Tasks is the tracker adapter interface: list candidate tickets, claim
+// one, report an outcome. One List call per poll cycle per workflow.
+type Tasks interface {
+	List() ([]Ticket, error)
+	Claim(t Ticket) error
+	// Report records the agent outcome: transitions the ticket to the
+	// target node's tracker state (adapter resolves it) and posts the
+	// summary. Self-loop (target state == current) → comment only.
+	Report(t Ticket, outcome, targetNode, summary string) error
+}
+
+// Factory builds an adapter instance for one submitted workflow.
+type Factory struct {
+	// UnmarshalConfig strictly decodes the YAML's tasks.config map into
+	// the adapter's own config struct.
+	UnmarshalConfig func(map[string]any) (any, error)
+	// New builds the adapter. wfName is the workflow identity (claim
+	// labels); nodes carry the `when` state map; assignee is the machine
+	// user's tracker identity ("" when the adapter doesn't need it);
+	// repoName is the repo's display name (tracker-side component/label
+	// scoping; "" when the adapter doesn't scope by repo).
+	New func(cfg any, wfName string, nodes map[string]config.Node, assignee, repoName string) (Tasks, error)
+}
+
+var (
+	mu        sync.RWMutex
+	factories = map[string]Factory{}
+)
+
+// Register makes an adapter available under `type: <name>`. Called from
+// adapter init(); panics on duplicate names (programmer error).
+func Register(name string, f Factory) {
+	mu.Lock()
+	defer mu.Unlock()
+	if _, dup := factories[name]; dup {
+		panic("tasks: duplicate adapter registration " + name)
+	}
+	factories[name] = f
+}
+
+// New resolves a tasks adapter by type name and builds an instance.
+func New(typeName string, rawCfg map[string]any, wfName string, nodes map[string]config.Node, assignee, repoName string) (Tasks, error) {
+	mu.RLock()
+	f, ok := factories[typeName]
+	mu.RUnlock()
+	if !ok {
+		return nil, fmt.Errorf("unknown tasks type %q (registered: %v)", typeName, registered())
+	}
+	cfg, err := f.UnmarshalConfig(rawCfg)
+	if err != nil {
+		return nil, fmt.Errorf("tasks type %q config: %w", typeName, err)
+	}
+	return f.New(cfg, wfName, nodes, assignee, repoName)
+}
+
+func registered() []string {
+	mu.RLock()
+	defer mu.RUnlock()
+	names := make([]string, 0, len(factories))
+	for n := range factories {
+		names = append(names, n)
+	}
+	sort.Strings(names)
+	return names
+}

package/internal/tasks/tasks_test.go

@@ -0,0 +1,91 @@
+package tasks
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+)
+
+func testNodes() map[string]config.Node {
+	return map[string]config.Node{
+		"coding":    {Agent: "build", When: "In Progress", OnSuccess: "reviewing", OnFailure: "coding"},
+		"reviewing": {Agent: "build", When: "In Review", OnSuccess: "done", OnFailure: "coding"},
+		"done":      {When: "Done"},
+	}
+}
+
+type fakeTasks struct {
+	listed  []Ticket
+	claims  []string
+	reports []string
+}
+
+func (f *fakeTasks) List() ([]Ticket, error) { return f.listed, nil }
+func (f *fakeTasks) Claim(t Ticket) error {
+	f.claims = append(f.claims, t.Key)
+	return nil
+}
+func (f *fakeTasks) Report(t Ticket, outcome, targetNode, summary string) error {
+	f.reports = append(f.reports, t.Key+":"+outcome+":"+targetNode)
+	return nil
+}
+
+func TestRegistryNew(t *testing.T) {
+	fake := &fakeTasks{}
+	Register("fake", Factory{
+		UnmarshalConfig: func(m map[string]any) (any, error) {
+			if m["bad"] != nil {
+				return nil, errFakeConfig
+			}
+			return m, nil
+		},
+		New: func(cfg any, wfName string, nodes map[string]config.Node, assignee, repoName string) (Tasks, error) {
+			if repoName != "repo:xyz" {
+				t.Errorf("repoName = %q", repoName)
+			}
+			if wfName == "" {
+				t.Error("wfName empty")
+			}
+			if nodes["coding"].When != "In Progress" {
+				t.Error("nodes not passed")
+			}
+			return fake, nil
+		},
+	})
+
+	tk, err := New("fake", map[string]any{"k": "v"}, "xyzFlow", testNodes(), "Jane Doe", "repo:xyz")
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	tk.Claim(Ticket{Key: "XYZ-1"})
+	if len(fake.claims) != 1 || fake.claims[0] != "XYZ-1" {
+		t.Errorf("claims = %v", fake.claims)
+	}
+
+	if _, err := New("nonexistent-adapter", nil, "w", nil, "", ""); err == nil ||
+		!strings.Contains(err.Error(), "unknown tasks type") || !strings.Contains(err.Error(), "fake") {
+		t.Errorf("unknown adapter error = %v", err)
+	}
+
+	if _, err := New("fake", map[string]any{"bad": true}, "w", testNodes(), "", ""); err == nil || !strings.Contains(err.Error(), "bad config") {
+		t.Errorf("config unmarshal err = %v", err)
+	}
+}
+
+var errFakeConfig = errorString("bad config")
+
+type errorString string
+
+func (e errorString) Error() string { return string(e) }
+
+func TestDuplicateRegisterPanics(t *testing.T) {
+	defer func() {
+		if recover() == nil {
+			t.Fatal("expected panic on duplicate registration")
+		}
+	}()
+	f := Factory{}
+	Register("dup", f)
+	Register("dup", f)
+}