relay-flow 0.2.7-alpha → 0.2.8-alpha

package/internal/task/jira/jira.go

@@ -4,6 +4,7 @@ package jira
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"log/slog"
 	"regexp"
@@ -19,12 +20,21 @@ import (
 
 // Config is the adapter-owned typed config for every scope.
 type Config struct {
-	Assignee   string       `yaml:"assignee,omitempty"`
-	Project    string       `yaml:"project,omitempty"`
-	Component  string       `yaml:"component,omitempty"`
-	Filters    Filters      `yaml:"filters,omitempty"`
-	Transition TransitionTo `yaml:"transitionTo,omitempty"`
-	Templates  Templates    `yaml:"templates,omitempty"`
+	Assignee       string         `yaml:"assignee,omitempty"`
+	Project        string         `yaml:"project,omitempty"`
+	Component      string         `yaml:"component,omitempty"`
+	Filters        Filters        `yaml:"filters,omitempty"`
+	Transition     TransitionTo   `yaml:"transitionTo,omitempty"`
+	StatusDefaults StatusDefaults `yaml:"statusDefaults,omitempty"`
+	Templates      Templates      `yaml:"templates,omitempty"`
+}
+
+// StatusDefaults are repository-scoped Jira lifecycle statuses selected from
+// the statuses available to the configured project.
+type StatusDefaults struct {
+	Start string `yaml:"start,omitempty"`
+	Work  string `yaml:"work,omitempty"`
+	End   string `yaml:"end,omitempty"`
 }
 
 // Templates are Jira-owned task-system descriptions and comments.
@@ -103,10 +113,134 @@ var (
 // claimLabel is the permanent workflow claim label.
 func claimLabel(workflow string) string { return "wf:" + workflow }
 
+func jiraRegistrationFields(ctx context.Context, values config.RawValues) ([]task.RegistrationField, error) {
+	fields := []task.RegistrationField{
+		{Key: "project", Title: "Jira project"},
+		{Key: "component", Title: "Jira component", Derived: true},
+	}
+	project := registrationValue(values, "project")
+	if strings.TrimSpace(project) == "" {
+		return fields, nil
+	}
+	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
+	}
+	statusProvider, ok := any(client).(jirarest.StatusProvider)
+	if !ok {
+		return nil, errors.New("jira client does not support project status discovery")
+	}
+	statuses, err := statusProvider.Statuses(ctx, strings.TrimSpace(project))
+	if err != nil {
+		return nil, fmt.Errorf("discover Jira statuses for project %q: %w", project, err)
+	}
+	if len(statuses) == 0 {
+		return nil, fmt.Errorf("discover Jira statuses for project %q: no statuses returned", project)
+	}
+	return append(fields,
+		statusRegistrationField("statusDefaults.start", "Start status", statuses, defaultStartParentStatus),
+		statusRegistrationField("statusDefaults.work", "Work status", statuses, defaultWorkTaskStatus),
+		statusRegistrationField("statusDefaults.end", "End status", statuses, defaultEndParentStatus),
+	), nil
+}
+
+func statusRegistrationField(key, title string, statuses []string, conventional string) task.RegistrationField {
+	defaultValue := ""
+	for _, status := range statuses {
+		if status == conventional {
+			defaultValue = conventional
+			break
+		}
+	}
+	return task.RegistrationField{
+		Key: key, Title: title, Options: append([]string(nil), statuses...), Default: defaultValue,
+	}
+}
+
+func validateJiraRegistration(ctx context.Context, spec task.RepoRegistrationSpec) error {
+	if hasStatusDefaults(spec.RootConfig) {
+		return errors.New("Jira statusDefaults must be configured per repository")
+	}
+	var repoCfg Config
+	if err := config.DecodeStrict(spec.RepoConfig, &repoCfg); err != nil {
+		return fmt.Errorf("repo config: %w", err)
+	}
+	if strings.TrimSpace(repoCfg.Project) == "" {
+		return errors.New("Jira project is required")
+	}
+	if strings.TrimSpace(repoCfg.Component) == "" {
+		return errors.New("Jira component is required")
+	}
+	if repoCfg.Component != spec.Name {
+		return fmt.Errorf("Jira component %q must match repository name %q", repoCfg.Component, spec.Name)
+	}
+	if !hasStatusDefaults(spec.RepoConfig) {
+		return errors.New("statusDefaults.start, statusDefaults.work, and statusDefaults.end are required")
+	}
+	selected := repoCfg.StatusDefaults
+	if selected.Start == "" || selected.Work == "" || selected.End == "" {
+		return errors.New("statusDefaults.start, statusDefaults.work, and statusDefaults.end are required")
+	}
+	creds, err := loadCredentialsDefault()
+	if err != nil {
+		return fmt.Errorf("Jira credentials: %w", err)
+	}
+	client, err := sharedClient(creds.Site, creds.Email, creds.Token)
+	if err != nil {
+		return err
+	}
+	statusProvider, ok := any(client).(jirarest.StatusProvider)
+	if !ok {
+		return errors.New("jira client does not support project status discovery")
+	}
+	statuses, err := statusProvider.Statuses(ctx, repoCfg.Project)
+	if err != nil {
+		return fmt.Errorf("discover Jira statuses for project %q: %w", repoCfg.Project, err)
+	}
+	for key, value := range map[string]string{
+		"start": selected.Start, "work": selected.Work, "end": selected.End,
+	} {
+		if !contains(statuses, value) {
+			return fmt.Errorf("statusDefaults.%s %q is not available in Jira project %s", key, value, repoCfg.Project)
+		}
+	}
+	return nil
+}
+
+func registrationValue(values config.RawValues, key string) string {
+	if value, ok := values[key].(string); ok {
+		return strings.TrimSpace(value)
+	}
+	parts := strings.Split(key, ".")
+	var current any = map[string]any(values)
+	for _, part := range parts {
+		m, ok := current.(map[string]any)
+		if !ok {
+			if raw, ok := current.(config.RawValues); ok {
+				m = map[string]any(raw)
+			} else {
+				return ""
+			}
+		}
+		current, ok = m[part]
+		if !ok {
+			return ""
+		}
+	}
+	value, _ := current.(string)
+	return strings.TrimSpace(value)
+}
+
 func init() {
 	task.Register("jira", task.Factory{
-		RequiredRepoKeys: func() []string { return []string{"project", "component"} },
-		DefaultConfig:    DefaultConfig,
+		RequiredRepoKeys:     func() []string { return []string{"project", "component"} },
+		RegistrationFields:   jiraRegistrationFields,
+		ValidateRegistration: validateJiraRegistration,
+		DefaultConfig:        DefaultConfig,
 		ValidateTextConfig: func(raw config.RawValues) error {
 			var cfg Config
 			if err := config.DecodeStrict(raw, &cfg); err != nil {
@@ -190,6 +324,12 @@ func newSystem(ctx context.Context, cli jirarest.Client, spec task.RepoSpec) (*s
 	if spec.Name == "" {
 		return nil, fmt.Errorf("jira: repo name is required")
 	}
+	if hasStatusDefaults(spec.RootConfig) {
+		return nil, errors.New("jira statusDefaults must be configured per repository")
+	}
+	if !hasStatusDefaults(spec.RepoConfig) {
+		return nil, errors.New("jira repository taskConfig.statusDefaults requires start, work, and end values")
+	}
 	merged := config.Merge(DefaultConfig(), spec.RootConfig, spec.RepoConfig)
 	var cfg Config
 	if err := config.DecodeStrict(merged, &cfg); err != nil {
@@ -203,25 +343,37 @@ func newSystem(ctx context.Context, cli jirarest.Client, spec task.RepoSpec) (*s
 			return nil, fmt.Errorf("jira repo %q assignee %q: %w", spec.Name, cfg.Assignee, err)
 		}
 	}
-	s := &system{cli: cli, repoName: spec.Name, base: merged, effective: cfg}
+	s := &system{
+		cli:       cli,
+		repoName:  spec.Name,
+		base:      merged,
+		effective: cfg,
+	}
 	if err := s.validateTransition(ctx, "repo config", cfg.Project, cfg.Transition); err != nil {
 		return nil, fmt.Errorf("jira repo %q: %w", spec.Name, err)
 	}
-	for _, status := range []string{defaultStartParentStatus, defaultEndParentStatus, "To Do"} {
-		if err := cli.ValidateStatus(ctx, cfg.Project, status); err != nil {
-			return nil, fmt.Errorf("jira repo %q default status %q: %w", spec.Name, status, err)
-		}
+	if err := validateStatusDefaults(ctx, cli, "repo config", cfg.Project, cfg.StatusDefaults); err != nil {
+		return nil, fmt.Errorf("jira repo %q: %w", spec.Name, err)
 	}
-	// project/component are required repo keys enforced at registration
-	// (RequiredRepoKeys); construction also probes external Jira names.
+	// project/component are required repo keys enforced at registration. Do not
+	// probe conventional lifecycle names here: repository registration stores
+	// the project-specific defaults, and projects may not contain those names.
 	return s, nil
 }
 
 // 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",
-		RepoConfig: config.RawValues{"project": "PAY", "component": "api"},
+		Name: "payments",
+		RepoConfig: config.RawValues{
+			"project":   "PAY",
+			"component": "api",
+			"statusDefaults": map[string]any{
+				"start": defaultStartParentStatus,
+				"work":  defaultWorkTaskStatus,
+				"end":   defaultEndParentStatus,
+			},
+		},
 	})
 }
 
@@ -234,6 +386,25 @@ func decodeConfig(raw config.RawValues) (Config, error) {
 	return cfg, nil
 }
 
+func hasStatusDefaults(raw config.RawValues) bool {
+	_, ok := raw["statusDefaults"]
+	return ok
+}
+
+func validateStatusDefaults(ctx context.Context, cli jirarest.Client, scope, project string, defaults StatusDefaults) error {
+	if strings.TrimSpace(defaults.Start) == "" || strings.TrimSpace(defaults.Work) == "" || strings.TrimSpace(defaults.End) == "" {
+		return fmt.Errorf("%s statusDefaults.start, statusDefaults.work, and statusDefaults.end are required", scope)
+	}
+	for field, status := range map[string]string{
+		"start": defaults.Start, "work": defaults.Work, "end": defaults.End,
+	} {
+		if err := cli.ValidateStatus(ctx, project, status); err != nil {
+			return fmt.Errorf("%s statusDefaults.%s %q: %w", scope, field, status, err)
+		}
+	}
+	return nil
+}
+
 func validateTemplates(templates Templates) error {
 	for name, tmpl := range map[string]string{
 		"mailboxDescription": templates.MailboxDescription,
@@ -392,6 +563,9 @@ func (s *system) ValidateConfig(ctx context.Context, workflowTaskConfig config.R
 	if err := validateTemplates(workflowCfg.Templates); err != nil {
 		return fmt.Errorf("workflow taskConfig.templates: %w", err)
 	}
+	if hasStatusDefaults(workflowTaskConfig) {
+		return errors.New("workflow taskConfig.statusDefaults must be configured per repository")
+	}
 	if err := s.validateAssignee(ctx, "workflow", workflowCfg.Project, workflowCfg.Assignee); err != nil {
 		return err
 	}
@@ -404,6 +578,9 @@ func (s *system) ValidateConfig(ctx context.Context, workflowTaskConfig config.R
 	}
 	sort.Strings(nodes)
 	for _, n := range nodes {
+		if hasStatusDefaults(nodeTaskConfigs[n]) {
+			return fmt.Errorf("node %q taskConfig.statusDefaults must be configured per repository", n)
+		}
 		cfg, err := decodeConfig(config.Merge(s.base, workflowTaskConfig, nodeTaskConfigs[n]))
 		if err != nil {
 			return fmt.Errorf("node %q taskConfig: %w", n, err)
@@ -450,11 +627,9 @@ func (s *system) validateTransition(ctx context.Context, scope, project string,
 	return nil
 }
 
-// LifecycleDefaults exposure: the deterministic Jira transition defaults per
-// lifecycle point (spec: Jira transition defaults are deterministic). Run
-// orchestration merges these raw values under the effective node config
-// before ApplyTaskConfig, so the effective precedence is
-// built-in default < root < repo < workflow < node.
+// LifecycleDefaults exposes the repository-selected Jira transition values.
+// Run orchestration merges these raw values under the effective node config
+// before ApplyTaskConfig, so explicit workflow/node transition values win.
 //
 // The methods also carry the inherited root/repository transitionTo and
 // assignee values. ApplyTaskConfig receives only the workflow/node config the
@@ -463,29 +638,43 @@ func (s *system) validateTransition(ctx context.Context, scope, project string,
 // silently discarded. internal/task/beads implements the same rule; keep the
 // two adapters aligned.
 
-// StartDefaults defaults the parent to In Progress.
+// StartDefaults uses the repository-selected parent start status.
 func (s *system) StartDefaults() config.RawValues {
-	return s.lifecycleDefaults(transitionDefault("parentStatus", defaultStartParentStatus))
+	return s.lifecycleDefaults(transitionDefault("parentStatus", s.startStatus()))
 }
 
-// WorkDefaults defaults the mailbox task status to In Progress; the parent
+// WorkDefaults uses the repository-selected active mailbox status; the parent
 // is left unchanged when parentStatus is omitted.
 func (s *system) WorkDefaults() config.RawValues {
-	return s.lifecycleDefaults(transitionDefault("taskStatus", defaultWorkTaskStatus))
+	return s.lifecycleDefaults(transitionDefault("taskStatus", s.workStatus()))
 }
 
-// EndDefaults defaults the parent to Done.
+// EndDefaults uses the repository-selected parent completion status.
 func (s *system) EndDefaults() config.RawValues {
-	return s.lifecycleDefaults(transitionDefault("parentStatus", defaultEndParentStatus))
+	return s.lifecycleDefaults(transitionDefault("parentStatus", s.endStatus()))
+}
+
+func (s *system) startStatus() string { return s.effective.StatusDefaults.Start }
+
+func (s *system) workStatus() string { return s.effective.StatusDefaults.Work }
+
+func (s *system) endStatus() string { return s.effective.StatusDefaults.End }
+
+// Recovery/restart needs an initial mailbox state. It uses the same
+// repository-selected start status as a fresh run; there is no separate
+// hard-coded Jira reset status.
+func (s *system) mailboxResetStatus() string {
+	return s.startStatus()
 }
 
 func transitionDefault(key, value string) config.RawValues {
 	return config.RawValues{"transitionTo": map[string]any{key: value}}
 }
 
-// lifecycleDefaults layers the inherited root/repository operation values over
-// the built-in lifecycle default. Only the keys ApplyTaskConfig consumes are
-// carried, so unrelated configuration never enters durable activity inputs.
+// lifecycleDefaults layers inherited root/repository operation values over
+// the selected repository lifecycle value. Only the keys ApplyTaskConfig
+// consumes are carried, so unrelated configuration never enters durable
+// activity inputs.
 func (s *system) lifecycleDefaults(builtin config.RawValues) config.RawValues {
 	inherited := config.RawValues{}
 	for _, key := range []string{"transitionTo", "assignee"} {
@@ -550,11 +739,10 @@ func (s *system) EnsureMailboxes(ctx context.Context, parent task.TicketRef, wor
 // --- Transitions ---
 
 // ApplyTaskConfig applies the adapter-owned taskConfig to the parent and
-// optional mailbox. Deterministic defaults: an omitted work-node taskStatus
-// defaults the mailbox to In Progress and leaves the parent unchanged; an
-// omitted parent-only parentStatus defaults to In Progress. Run
-// orchestration merges EndDefaults into the end node's config before this
-// call, so end processing transitions the parent to Done when omitted.
+// optional mailbox. An omitted work-node taskStatus uses the repository's
+// selected work status and leaves the parent unchanged; an omitted
+// parent-only parentStatus uses the selected start status. Run orchestration
+// merges EndDefaults into the end node's config before that call.
 func (s *system) ApplyTaskConfig(ctx context.Context, target task.Target, taskConfig config.RawValues) error {
 	cfg, err := decodeConfig(taskConfig)
 	if err != nil {
@@ -564,7 +752,7 @@ func (s *system) ApplyTaskConfig(ctx context.Context, target task.Target, taskCo
 	if target.Mailbox != nil {
 		status := tr.TaskStatus
 		if status == "" {
-			status = defaultWorkTaskStatus
+			status = s.workStatus()
 		}
 		if err := s.transition(ctx, target.Mailbox.Key, status, cfg.Assignee); err != nil {
 			return err
@@ -577,7 +765,7 @@ func (s *system) ApplyTaskConfig(ctx context.Context, target task.Target, taskCo
 	// Parent-only target (start/end lifecycle processing).
 	status := tr.ParentStatus
 	if status == "" {
-		status = defaultStartParentStatus
+		status = s.startStatus()
 	}
 	return s.transition(ctx, target.Parent.Key, status, "")
 }
@@ -598,9 +786,10 @@ func isConflict(err error) bool {
 		strings.Contains(msg, "cannot") || strings.Contains(msg, "invalid"))
 }
 
-// CompleteMailbox marks the mailbox Done using task-system semantics.
+// CompleteMailbox uses the repository's selected end status. There is no
+// separate mailbox-completion status in the Jira registration contract.
 func (s *system) CompleteMailbox(ctx context.Context, mailbox task.Mailbox) error {
-	return s.transition(ctx, mailbox.Key, "Done", "")
+	return s.transition(ctx, mailbox.Key, s.endStatus(), "")
 }
 
 // --- Comments ---
@@ -651,7 +840,7 @@ func (s *system) Comment(ctx context.Context, target task.Target, body, marker s
 // 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 {
+		if err := s.transition(ctx, mailbox.Key, s.mailboxResetStatus(), ""); err != nil {
 			return fmt.Errorf("reopen mailbox %s for restart: %w", mailbox.Key, err)
 		}
 	}
@@ -660,11 +849,11 @@ func (s *system) PrepareRestart(ctx context.Context, _ task.TicketRef, mailboxes
 
 // --- Recovery ---
 
-// ResetForRecovery resets mailbox subtasks to To Do while preserving
-// comments, labels, and history. No parent rollback runs.
+// ResetForRecovery resets mailbox subtasks to the configured initial status
+// while preserving 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, s.mailboxResetStatus(), ""); err != nil {
 			return fmt.Errorf("reset mailbox %s: %w", mb.Key, err)
 		}
 	}

package/internal/task/jira/lifecycle_inheritance_test.go

@@ -16,7 +16,7 @@ import (
 //
 // The adapter therefore returns its inherited transitionTo/assignee values as
 // part of its lifecycle defaults, producing the effective precedence
-// built-in default < root < repo < workflow < node.
+// registered lifecycle value < root/repo inherited operation value < workflow < node.
 //
 // internal/task/beads/lifecycle_inheritance_test.go is the sibling of this
 // file and asserts the same invariants against the Beads adapter. Keep the two
@@ -26,7 +26,7 @@ import (
 // scopes that never appear in an ApplyTaskConfig argument.
 func repoScopedSystem(t *testing.T, fake *fakeJira, repoValues config.RawValues) task.System {
 	t.Helper()
-	repoConfig := config.Merge(config.RawValues{"project": "PAY", "component": "api"}, repoValues)
+	repoConfig := config.Merge(testRepoConfig(nil), repoValues)
 	sys, err := newSystem(context.Background(), &fakeClient{fake: fake}, task.RepoSpec{
 		Name:       "payments",
 		RepoConfig: repoConfig,
@@ -66,7 +66,7 @@ func TestLifecycleDefaultsCarryInheritedTransitionTo(t *testing.T) {
 			t.Fatal(err)
 		}
 		if len(fake.parentTransitions) != 1 || fake.parentTransitions[0] != "In Review" {
-			t.Fatalf("parent transitions = %v, want the inherited repo value to beat the built-in default",
+			t.Fatalf("parent transitions = %v, want the inherited repo value to beat the registered lifecycle value",
 				fake.parentTransitions)
 		}
 	})
@@ -82,7 +82,7 @@ func TestLifecycleDefaultsCarryInheritedTransitionTo(t *testing.T) {
 			t.Fatal(err)
 		}
 		if len(fake.taskTransitions) != 1 || fake.taskTransitions[0] != "In Review" {
-			t.Fatalf("mailbox transitions = %v, want the inherited repo value to beat the built-in default",
+			t.Fatalf("mailbox transitions = %v, want the inherited repo value to beat the registered lifecycle value",
 				fake.taskTransitions)
 		}
 	})
@@ -113,7 +113,7 @@ func TestLifecycleDefaultsPrecedenceDefaultRepoWorkflowNode(t *testing.T) {
 		node     config.RawValues
 		want     string
 	}{
-		{name: "repo beats built-in default", want: "Repo Status"},
+		{name: "repo operation value beats lifecycle value", want: "Repo Status"},
 		{
 			name:     "workflow beats repo",
 			workflow: config.RawValues{"transitionTo": map[string]any{"taskStatus": "Workflow Status"}},

package/internal/task/jira/rest/client.go

@@ -35,6 +35,14 @@ type CreatedSubtask struct {
 	Key string
 }
 
+// StatusProvider discovers the actual statuses configured for a Jira project.
+// It is intentionally separate from Client so existing adapter test doubles
+// and replaceable REST clients do not need provider-specific discovery unless
+// registration needs it.
+type StatusProvider interface {
+	Statuses(context.Context, string) ([]string, error)
+}
+
 type Client interface {
 	ValidateCredentials(context.Context) error
 	Search(context.Context, string) ([]byte, error)
@@ -70,6 +78,7 @@ type HTTPClient struct {
 	transitions  map[string]transitionInfo
 	accounts     map[string]string
 	statuses     map[string]map[string]bool
+	statusNames  map[string][]string
 	subtaskTypes map[string]string
 }
 
@@ -97,6 +106,7 @@ func New(site, email, token string) (*HTTPClient, error) {
 		transitions:  map[string]transitionInfo{},
 		accounts:     map[string]string{},
 		statuses:     map[string]map[string]bool{},
+		statusNames:  map[string][]string{},
 		subtaskTypes: map[string]string{},
 	}, nil
 }
@@ -186,43 +196,72 @@ func (c *HTTPClient) accountID(ctx context.Context, project, assignee string) (s
 	return "", fmt.Errorf("assignee %q is not assignable in project %s", assignee, project)
 }
 
+// Statuses returns the status names configured for all issue types in a Jira
+// project, preserving Jira's response order and removing case-insensitive
+// duplicates. The same discovery populates the subtask issue-type cache used
+// when mailboxes are created.
+func (c *HTTPClient) Statuses(ctx context.Context, project string) ([]string, error) {
+	_, names, err := c.loadStatuses(ctx, project)
+	if err != nil {
+		return nil, err
+	}
+	return append([]string(nil), names...), nil
+}
+
 func (c *HTTPClient) ValidateStatus(ctx context.Context, project, status string) error {
+	statuses, _, err := c.loadStatuses(ctx, project)
+	if err != nil {
+		return err
+	}
+	if !statuses[strings.ToLower(status)] {
+		return fmt.Errorf("status %q is not valid in project %s", status, project)
+	}
+	return nil
+}
+
+func (c *HTTPClient) loadStatuses(ctx context.Context, project string) (map[string]bool, []string, error) {
 	c.mu.Lock()
 	statuses, ok := c.statuses[project]
+	names := append([]string(nil), c.statusNames[project]...)
 	c.mu.Unlock()
-	if !ok {
-		var issueTypes []struct {
-			ID       string `json:"id"`
-			Subtask  bool   `json:"subtask"`
-			Statuses []struct {
-				Name string `json:"name"`
-			} `json:"statuses"`
-		}
-		path := "/rest/api/3/project/" + url.PathEscape(project) + "/statuses"
-		if err := c.request(ctx, http.MethodGet, path, nil, nil, &issueTypes, true); err != nil {
-			return err
-		}
-		statuses = map[string]bool{}
-		subtaskType := ""
-		for _, issueType := range issueTypes {
-			if issueType.Subtask && subtaskType == "" {
-				subtaskType = issueType.ID
-			}
-			for _, candidate := range issueType.Statuses {
-				statuses[strings.ToLower(candidate.Name)] = true
+	if ok {
+		return statuses, names, nil
+	}
+	var issueTypes []struct {
+		ID       string `json:"id"`
+		Subtask  bool   `json:"subtask"`
+		Statuses []struct {
+			Name string `json:"name"`
+		} `json:"statuses"`
+	}
+	path := "/rest/api/3/project/" + url.PathEscape(project) + "/statuses"
+	if err := c.request(ctx, http.MethodGet, path, nil, nil, &issueTypes, true); err != nil {
+		return nil, nil, err
+	}
+	statuses = map[string]bool{}
+	names = make([]string, 0)
+	subtaskType := ""
+	for _, issueType := range issueTypes {
+		if issueType.Subtask && subtaskType == "" {
+			subtaskType = issueType.ID
+		}
+		for _, candidate := range issueType.Statuses {
+			name := strings.TrimSpace(candidate.Name)
+			if name == "" || statuses[strings.ToLower(name)] {
+				continue
 			}
+			statuses[strings.ToLower(name)] = true
+			names = append(names, name)
 		}
-		c.mu.Lock()
-		c.statuses[project] = statuses
-		if subtaskType != "" {
-			c.subtaskTypes[project] = subtaskType
-		}
-		c.mu.Unlock()
 	}
-	if !statuses[strings.ToLower(status)] {
-		return fmt.Errorf("status %q is not valid in project %s", status, project)
+	c.mu.Lock()
+	c.statuses[project] = statuses
+	c.statusNames[project] = append([]string(nil), names...)
+	if subtaskType != "" {
+		c.subtaskTypes[project] = subtaskType
 	}
-	return nil
+	c.mu.Unlock()
+	return statuses, names, nil
 }
 
 func (c *HTTPClient) View(ctx context.Context, key string) ([]byte, error) {
@@ -251,7 +290,7 @@ func (c *HTTPClient) CreateSubtasks(ctx context.Context, parent, project, label
 	subtaskType := c.subtaskTypes[project]
 	c.mu.Unlock()
 	if subtaskType == "" {
-		if err := c.ValidateStatus(ctx, project, "To Do"); err != nil {
+		if _, _, err := c.loadStatuses(ctx, project); err != nil {
 			return nil, err
 		}
 		c.mu.Lock()
@@ -290,7 +329,10 @@ func (c *HTTPClient) CreateSubtasks(ctx context.Context, parent, project, label
 		}
 		created = append(created, result.Issues...)
 		for _, issue := range result.Issues {
-			c.setIssueState(issue.Key, "Sub-task", "To Do")
+			// Jira chooses the subtask's initial status from the project
+			// workflow. Leave the status unknown so the first transition reads
+			// the actual state instead of assuming a conventional name.
+			c.setIssueState(issue.Key, "Sub-task", "")
 		}
 	}
 	return created, nil

package/internal/task/jira/rest/client_test.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"reflect"
 	"strings"
 	"sync"
 	"testing"
@@ -93,6 +94,30 @@ func TestNewRejectsNonHTTPSRemoteSite(t *testing.T) {
 	}
 }
 
+func TestStatusesDiscoversProjectWorkflowStatuses(t *testing.T) {
+	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, _ []byte) {
+		if r.Method != http.MethodGet || r.URL.Path != "/rest/api/3/project/PAY/statuses" {
+			http.NotFound(w, r)
+			return
+		}
+		writeJSON(w, []any{
+			map[string]any{"id": "100", "subtask": true, "statuses": []any{
+				map[string]any{"name": "Open"},
+				map[string]any{"name": "Working"},
+				map[string]any{"name": "Closed"},
+			}},
+		})
+	})
+	statuses, err := s.client(t).Statuses(context.Background(), "PAY")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []string{"Open", "Working", "Closed"}
+	if !reflect.DeepEqual(statuses, want) {
+		t.Fatalf("statuses = %v, want %v", statuses, want)
+	}
+}
+
 func TestSearchPaginatesAndRequestsIssueLinks(t *testing.T) {
 	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, body []byte) {
 		if r.URL.Path != "/rest/api/3/search/jql" || r.Method != http.MethodPost {