relay-flow 0.2.7-alpha → 0.2.9-alpha

package/internal/server/server.go

@@ -12,9 +12,11 @@ import (
 	"net/http"
 	"strings"
 
+	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/repo"
 	"github.com/rajpopat27/relay-flow/internal/run"
 	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/task"
 	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
@@ -41,7 +43,7 @@ type Deps interface {
 
 	// Repos
 	DiscoverRepos(ctx context.Context) ([]runner.RepoCandidate, error)
-	TaskFields(ctx context.Context) ([]string, error)
+	TaskRegistrationFields(ctx context.Context, values config.RawValues) ([]task.RegistrationField, error)
 	RegisterRepo(ctx context.Context, input repo.RegisterInput) (repo.Info, error)
 	ListRepos(ctx context.Context) ([]repo.Info, error)
 	GetRepo(ctx context.Context, name string) (repo.Info, error)
@@ -83,6 +85,7 @@ func New(deps Deps) http.Handler {
 	mux.HandleFunc("/workflows", s.handleWorkflows)
 	mux.HandleFunc("/workflows/", s.handleWorkflowByName)
 	mux.HandleFunc("/repos/discover", s.handleReposDiscover)
+	mux.HandleFunc("/repos/ensure", s.handleRepoEnsure)
 	mux.HandleFunc("/repos/task-fields", s.handleRepoTaskFields)
 	mux.HandleFunc("/repos", s.handleRepos)
 	mux.HandleFunc("/repos/", s.handleRepoByName)
@@ -97,6 +100,14 @@ type server struct {
 	deps Deps
 }
 
+// repoEnsurer is implemented by the composition root when the selected
+// runner can provision a repository resource. It is intentionally separate
+// from Deps so existing task/run service seams do not need a runner-specific
+// method.
+type repoEnsurer interface {
+	EnsureRepo(context.Context, runner.RepoCandidate) error
+}
+
 // --- envelope helpers ---
 
 func writeOK(w http.ResponseWriter, status int, data any) {
@@ -245,16 +256,81 @@ func (s *server) handleReposDiscover(w http.ResponseWriter, r *http.Request) {
 	writeOK(w, http.StatusOK, candidates)
 }
 
+func (s *server) handleRepoEnsure(w http.ResponseWriter, r *http.Request) {
+	if !methodOnly(w, r, http.MethodPost) {
+		return
+	}
+	ensurer, ok := s.deps.(repoEnsurer)
+	if !ok {
+		mapErr(w, fmt.Errorf("%w: runner repository provisioning is unavailable", ErrInvalid))
+		return
+	}
+	body, err := readBody(r)
+	if err != nil {
+		writeErr(w, http.StatusBadRequest, "invalid", err.Error())
+		return
+	}
+	var candidate runner.RepoCandidate
+	if err := decodeStrict(body, &candidate); err != nil {
+		writeErr(w, http.StatusBadRequest, "invalid", err.Error())
+		return
+	}
+	candidate.Name = strings.TrimSpace(candidate.Name)
+	candidate.Path = strings.TrimSpace(candidate.Path)
+	if candidate.Name == "" || candidate.Path == "" {
+		writeErr(w, http.StatusBadRequest, "invalid", "repository name and path are required")
+		return
+	}
+	if err := ensurer.EnsureRepo(r.Context(), candidate); err != nil {
+		mapErr(w, err)
+		return
+	}
+	writeOK(w, http.StatusOK, candidate)
+}
+
 func (s *server) handleRepoTaskFields(w http.ResponseWriter, r *http.Request) {
-	if !methodOnly(w, r, http.MethodGet) {
+	if r.Method == http.MethodGet {
+		fields, err := s.deps.TaskRegistrationFields(r.Context(), nil)
+		if err != nil {
+			mapErr(w, err)
+			return
+		}
+		keys := make([]string, 0, len(fields))
+		for _, field := range fields {
+			keys = append(keys, field.Key)
+		}
+		// Keep the documented fields list for callers that only need the
+		// required keys, and include plugin-owned metadata for the CLI's
+		// initial prompt construction.
+		writeOK(w, http.StatusOK, map[string]any{
+			"fields":       keys,
+			"registration": task.Registration{Fields: fields},
+		})
 		return
 	}
-	fields, err := s.deps.TaskFields(r.Context())
+	if !methodOnly(w, r, http.MethodPost) {
+		return
+	}
+	body, err := readBody(r)
+	if err != nil {
+		writeErr(w, http.StatusBadRequest, "invalid", err.Error())
+		return
+	}
+	var payload struct {
+		Values config.RawValues `json:"values,omitempty"`
+	}
+	if len(strings.TrimSpace(string(body))) > 0 {
+		if err := decodeStrict(body, &payload); err != nil {
+			writeErr(w, http.StatusBadRequest, "invalid", err.Error())
+			return
+		}
+	}
+	fields, err := s.deps.TaskRegistrationFields(r.Context(), payload.Values)
 	if err != nil {
 		mapErr(w, err)
 		return
 	}
-	writeOK(w, http.StatusOK, map[string]any{"fields": fields})
+	writeOK(w, http.StatusOK, task.Registration{Fields: fields})
 }
 
 func (s *server) handleRepos(w http.ResponseWriter, r *http.Request) {

package/internal/task/beads/beads.go

@@ -81,10 +81,15 @@ func DefaultConfig() config.RawValues {
 	}}
 }
 
+func registrationFields(context.Context, config.RawValues) ([]task.RegistrationField, error) {
+	return []task.RegistrationField{{Key: "beadsDir", Title: "Beads workspace"}}, nil
+}
+
 func init() {
 	task.Register("beads", task.Factory{
-		RequiredRepoKeys: func() []string { return []string{"beadsDir"} },
-		TaskScopeKey:     beadsTaskScopeKey,
+		RequiredRepoKeys:   func() []string { return []string{"beadsDir"} },
+		RegistrationFields: registrationFields,
+		TaskScopeKey:       beadsTaskScopeKey,
 		RegistrationKey: func(spec task.RepoRegistrationSpec) (string, error) {
 			label, err := RepositoryLabel(spec.Name)
 			if err != nil {

package/internal/task/beads/beads_test.go

@@ -29,6 +29,19 @@ func TestBeadsFactoryIsRegisteredWithBeadsDirRequirement(t *testing.T) {
 	}
 }
 
+func TestBeadsRegistrationDoesNotExposeJiraStatusFields(t *testing.T) {
+	fields, err := task.RegistrationFields(context.Background(), "beads", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(fields) != 1 || fields[0].Key != "beadsDir" {
+		t.Fatalf("registration fields = %#v, want only beadsDir", fields)
+	}
+	if len(fields[0].Options) != 0 || fields[0].Default != "" {
+		t.Fatalf("Beads registration field unexpectedly has status choices: %#v", fields[0])
+	}
+}
+
 func TestBeadsConfigRejectsUnknownFields(t *testing.T) {
 	for _, field := range []string{"unknownField", "project", "component"} {
 		t.Run(field, func(t *testing.T) {

package/internal/task/factory.go

@@ -36,13 +36,15 @@ type RepoRegistrationSpec struct {
 // the complete registration identity when a plugin permits sharing a
 // physical scope with distinct logical repositories.
 type Factory struct {
-	RequiredRepoKeys   func() []string
-	TaskScopeKey       func(rootConfig, repoConfig config.RawValues) (string, error)
-	RegistrationKey    func(RepoRegistrationSpec) (string, error)
-	Auth               func(context.Context, []string, io.Reader) error
-	DefaultConfig      func() config.RawValues
-	ValidateTextConfig func(config.RawValues) error
-	New                func(context.Context, RepoSpec) (System, error)
+	RequiredRepoKeys     func() []string
+	TaskScopeKey         func(rootConfig, repoConfig config.RawValues) (string, error)
+	RegistrationKey      func(RepoRegistrationSpec) (string, error)
+	RegistrationFields   func(context.Context, config.RawValues) ([]RegistrationField, error)
+	ValidateRegistration func(context.Context, RepoRegistrationSpec) error
+	Auth                 func(context.Context, []string, io.Reader) error
+	DefaultConfig        func() config.RawValues
+	ValidateTextConfig   func(config.RawValues) error
+	New                  func(context.Context, RepoSpec) (System, error)
 }
 
 var (

package/internal/task/jira/auth_test.go

@@ -75,7 +75,15 @@ func TestAuthWritesLoadsAndNewUsesJiraOwnedCredentials(t *testing.T) {
 	}
 	if _, err := task.New(context.Background(), "jira", task.RepoSpec{
 		Name: "payments", RootConfig: machine.TaskConfig,
-		RepoConfig: config.RawValues{"project": "PAY", "component": "api"},
+		RepoConfig: config.RawValues{
+			"project":   "PAY",
+			"component": "api",
+			"statusDefaults": map[string]any{
+				"start": defaultStartParentStatus,
+				"work":  defaultWorkTaskStatus,
+				"end":   defaultEndParentStatus,
+			},
+		},
 	}); err != nil {
 		t.Fatalf("task.New did not load Jira-owned credentials: %v", err)
 	}

package/internal/task/jira/filters_test.go

@@ -284,7 +284,7 @@ func TestCompileFilterDoesNotUseEffectiveAssigneeAsFilter(t *testing.T) {
 	sys, err := newSystem(context.Background(), &fakeClient{fake: &fakeJira{}}, task.RepoSpec{
 		Name:       "payments",
 		RootConfig: config.RawValues{"assignee": "root@example.com"},
-		RepoConfig: config.RawValues{"project": "PAY", "component": "api", "assignee": "Repo.Bot@Example.com"},
+		RepoConfig: testRepoConfig(config.RawValues{"assignee": "Repo.Bot@Example.com"}),
 	})
 	if err != nil {
 		t.Fatal(err)
@@ -304,7 +304,7 @@ func TestCompileFilterWorkflowAssigneesOverrideEffectiveAssignee(t *testing.T) {
 	sys, err := newSystem(context.Background(), &fakeClient{fake: &fakeJira{}}, task.RepoSpec{
 		Name:       "payments",
 		RootConfig: config.RawValues{"assignee": "root@example.com"},
-		RepoConfig: config.RawValues{"project": "PAY", "component": "api"},
+		RepoConfig: testRepoConfig(nil),
 	})
 	if err != nil {
 		t.Fatal(err)

package/internal/task/jira/helpers_test.go

@@ -3,6 +3,7 @@ package jira
 import (
 	"context"
 
+	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/task"
 	"github.com/rajpopat27/relay-flow/internal/task/jira/rest"
 )
@@ -67,6 +68,18 @@ func (notFakedError) Error() string { return "not faked" }
 
 var errNotFaked = notFakedError{}
 
+func testStatusDefaults() config.RawValues {
+	return config.RawValues{"statusDefaults": map[string]any{
+		"start": defaultStartParentStatus,
+		"work":  defaultWorkTaskStatus,
+		"end":   defaultEndParentStatus,
+	}}
+}
+
+func testRepoConfig(values config.RawValues) config.RawValues {
+	return config.Merge(config.RawValues{"project": "PAY", "component": "api"}, testStatusDefaults(), values)
+}
+
 // 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

@@ -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)
 		}
 	}