relay-flow 0.2.7-alpha → 0.2.8-alpha

package/README.md

@@ -24,13 +24,13 @@ same `relay-flow-plugin` package with host-specific entrypoints.
 **OpenCode**
 
 ```sh
-opencode plugin relay-flow-plugin@0.2.7-alpha
+opencode plugin relay-flow-plugin@0.2.8-alpha
 ```
 
 **Pi**
 
 ```sh
-pi install npm:relay-flow-plugin@0.2.7-alpha
+pi install npm:relay-flow-plugin@0.2.8-alpha
 ```
 
 Pi loads the package's `pi.ts` extension from its manifest. Do not add
@@ -154,7 +154,7 @@ OpenCode plugin configuration uses both entrypoints. The server entrypoint is li
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": ["relay-flow-plugin@0.2.7-alpha"]
+  "plugin": ["relay-flow-plugin@0.2.8-alpha"]
 }
 ```
 
@@ -163,7 +163,7 @@ The native HITL approval entrypoint is listed in `.opencode/tui.json`:
 ```json
 {
   "$schema": "https://opencode.ai/tui.json",
-  "plugin": ["relay-flow-plugin@0.2.7-alpha"]
+  "plugin": ["relay-flow-plugin@0.2.8-alpha"]
 }
 ```
 
@@ -179,7 +179,7 @@ Pi plugin: install the same published package manually in Pi's global package
 settings before starting a Pi harness session:
 
 ```sh
-pi install npm:relay-flow-plugin@0.2.7-alpha
+pi install npm:relay-flow-plugin@0.2.8-alpha
 ```
 
 Relay-flow does not install or configure the package automatically. Pi resolves
@@ -255,11 +255,23 @@ orca repo add --path /work/payments   # displayName becomes "payments"
 relay-flow repo register
 ```
 
-Shows a multi-select titled `Select repositories`; use Space to select Orca repos and Enter to confirm. Enter the Jira project once. Each repo is registered sequentially with its Orca name/path and a Jira component derived from that repo name. Earlier registrations remain if a later one fails.
+Shows a multi-select titled `Select repositories`; use Space to select Orca repos and Enter to confirm. Enter the Jira project once, then choose the repository's start, work, and end statuses from the statuses discovered for that project. Each repo is registered sequentially with its Orca name/path and a Jira component derived from that repo name. Earlier registrations remain if a later one fails.
 
 Each Jira poll uses REST v3 enhanced search and requests linked-issue status with the candidate fields. Tickets with any unfinished inward `Blocks` issue are filtered before routing; no per-ticket blocker lookup is made.
 
-For scripted Jira registration, use `relay-flow repo register --name <name> --path <path> --set project=<project>`. Component is always derived from `--name` and cannot be overridden. Registration is rejected while another repo already holds the same canonical task scope.
+For scripted Jira registration, pass all three repository status defaults explicitly:
+
+```sh
+relay-flow repo register \
+  --name payments \
+  --path /work/payments \
+  --set project=PAY \
+  --set statusDefaults.start="Open" \
+  --set statusDefaults.work="Working" \
+  --set statusDefaults.end="Closed"
+```
+
+The values must be statuses available to the Jira project. Component is always derived from `--name` and cannot be overridden. Registration is rejected while another repo already holds the same canonical task scope.
 
 ### Beads task system
 

package/cmd/relay-flow/commands_test.go

@@ -640,9 +640,13 @@ type registerServer struct {
 	calls      int
 }
 
-func (s *registerServer) TaskFields(context.Context) ([]string, error) {
+func (s *registerServer) TaskRegistrationFields(context.Context, config.RawValues) ([]task.RegistrationField, error) {
 	s.calls++
-	return s.fields, nil
+	out := make([]task.RegistrationField, 0, len(s.fields))
+	for _, field := range s.fields {
+		out = append(out, task.RegistrationField{Key: field, Title: field, Derived: field == "component"})
+	}
+	return out, nil
 }
 func (s *registerServer) RegisterRepo(_ context.Context, in repo.RegisterInput) (repo.Info, error) {
 	s.calls++
@@ -767,7 +771,67 @@ func TestRepoRegisterFlagsNonInteractive(t *testing.T) {
 	}
 }
 
-func TestRepoMultiSelectAndSharedJiraMapping(t *testing.T) {
+func TestRegistrationSelectRequiresExplicitChoiceWithoutDefault(t *testing.T) {
+	field := task.RegistrationField{Key: "statusDefaults.start", Options: []string{"Open", "Working"}}
+	options := registrationSelectOptions(field)
+	if len(options) != 3 {
+		t.Fatalf("options = %d, want empty choice plus two statuses", len(options))
+	}
+	var selected string
+	selectField := huh.NewSelect[string]().Options(options...).Value(&selected)
+	var out bytes.Buffer
+	if err := selectField.RunAccessible(&out, strings.NewReader("1\n")); err != nil {
+		t.Fatal(err)
+	}
+	if selected != "" {
+		t.Fatalf("empty choice selected %q, want empty value", selected)
+	}
+	if err := selectField.RunAccessible(&out, strings.NewReader("2\n")); err != nil {
+		t.Fatal(err)
+	}
+	if selected != "Open" {
+		t.Fatalf("explicit status selection = %q, want Open", selected)
+	}
+}
+
+func TestRegistrationTaskConfigBuildsNestedStatusDefaults(t *testing.T) {
+	registration := task.Registration{Fields: []task.RegistrationField{
+		{Key: "project", Title: "Project"},
+		{Key: "component", Title: "Component", Derived: true},
+		{Key: "statusDefaults.start", Title: "Start", Options: []string{"Open", "Working", "Closed"}},
+		{Key: "statusDefaults.work", Title: "Work", Options: []string{"Open", "Working", "Closed"}},
+		{Key: "statusDefaults.end", Title: "End", Options: []string{"Open", "Working", "Closed"}},
+	}}
+	got, err := registrationTaskConfig(registration, kvFlags{
+		"project":              "PAY",
+		"statusDefaults.start": "Open",
+		"statusDefaults.work":  "Working",
+		"statusDefaults.end":   "Closed",
+	}, "payments")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defaults, ok := got["statusDefaults"].(map[string]any)
+	if !ok || defaults["start"] != "Open" || defaults["work"] != "Working" || defaults["end"] != "Closed" {
+		t.Fatalf("nested statusDefaults = %#v", got["statusDefaults"])
+	}
+	for _, tc := range []struct {
+		name string
+		sets kvFlags
+		want string
+	}{
+		{name: "invalid status", sets: kvFlags{"project": "PAY", "statusDefaults.start": "Missing"}, want: "not one of the available choices"},
+		{name: "derived component", sets: kvFlags{"project": "PAY", "component": "other"}, want: "derived"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if _, err := registrationTaskConfig(registration, tc.sets, "payments"); err == nil || !strings.Contains(err.Error(), tc.want) {
+				t.Fatalf("registration error = %v, want %q", err, tc.want)
+			}
+		})
+	}
+}
+
+func TestRepoMultiSelectAndPluginMapping(t *testing.T) {
 	selected := []int{0, 1}
 	field := repoMultiSelect([]huh.Option[int]{
 		huh.NewOption("payments", 0),
@@ -783,9 +847,10 @@ func TestRepoMultiSelectAndSharedJiraMapping(t *testing.T) {
 	if fmt.Sprint(selected) != "[0 1]" {
 		t.Fatalf("selected = %v, want [0 1]", selected)
 	}
-	if got := registrationSharedFields([]string{"project", "component"}); fmt.Sprint(got) != "[project]" {
-		t.Fatalf("prompted fields = %v, want project only", got)
-	}
+	registration := task.Registration{Fields: []task.RegistrationField{
+		{Key: "project", Title: "Project"},
+		{Key: "component", Title: "Component", Derived: true},
+	}}
 
 	home := t.TempDir()
 	deps := serveRegister(t, home, []string{"project", "component"})
@@ -794,8 +859,8 @@ func TestRepoMultiSelectAndSharedJiraMapping(t *testing.T) {
 		{Name: "payments", Path: "/srv/payments"},
 		{Name: "checkout", Path: "/srv/checkout"},
 	}
-	if err := registerSelectedRepos(context.Background(), client, candidates, selected,
-		[]string{"project", "component"}, kvFlags{"project": "PAY"}); err != nil {
+	if err := registerSelectedReposDynamic(context.Background(), client, candidates, selected,
+		registration, kvFlags{"project": "PAY"}); err != nil {
 		t.Fatal(err)
 	}
 	if len(deps.successful) != 2 {
@@ -818,8 +883,12 @@ func TestRepoRegistrationPartialFailureKeepsPriorSuccess(t *testing.T) {
 		{Name: "checkout", Path: "/srv/checkout"},
 		{Name: "later", Path: "/srv/later"},
 	}
-	err := registerSelectedRepos(context.Background(), client, candidates, []int{0, 1, 2},
-		[]string{"project", "component"}, kvFlags{"project": "PAY"})
+	registration := task.Registration{Fields: []task.RegistrationField{
+		{Key: "project", Title: "Project"},
+		{Key: "component", Title: "Component", Derived: true},
+	}}
+	err := registerSelectedReposDynamic(context.Background(), client, candidates, []int{0, 1, 2},
+		registration, kvFlags{"project": "PAY"})
 	if err == nil || !strings.Contains(err.Error(), "checkout") {
 		t.Fatalf("partial failure = %v, want failed repo name", err)
 	}
@@ -1012,7 +1081,9 @@ func (s *ackServer) CancelRun(context.Context, string, string) error { panic("un
 func (s *ackServer) DiscoverRepos(context.Context) ([]runner.RepoCandidate, error) {
 	panic("unreachable")
 }
-func (s *ackServer) TaskFields(context.Context) ([]string, error) { panic("unreachable") }
+func (s *ackServer) TaskRegistrationFields(context.Context, config.RawValues) ([]task.RegistrationField, error) {
+	panic("unreachable")
+}
 func (s *ackServer) RegisterRepo(context.Context, repo.RegisterInput) (repo.Info, error) {
 	panic("unreachable")
 }

package/cmd/relay-flow/main.go

@@ -798,7 +798,7 @@ func cmdRepo(c *server.Client, args []string, stdin io.Reader) int {
 }
 
 // cmdRepoRegister registers one flagged repo or multiple interactively selected
-// runner repos. Jira project is shared and component is always the repo name.
+// runner repos using registration metadata supplied by the selected task plugin.
 func cmdRepoRegister(c *server.Client, flagName, flagPath string, sets kvFlags, stdin io.Reader) int {
 	ctx := context.Background()
 	flagged := flagName != "" || flagPath != "" || len(sets) > 0
@@ -809,16 +809,12 @@ func cmdRepoRegister(c *server.Client, flagName, flagPath string, sets kvFlags,
 			fmt.Fprintln(os.Stderr, "repo register: --name and --path are required for non-interactive registration")
 			return exitUsage
 		}
-		if _, ok := sets["component"]; ok {
-			fmt.Fprintln(os.Stderr, "repo register: component is derived from --name and cannot be overridden")
-			return exitUsage
-		}
-		fields, err := c.RepoTaskFields(ctx)
+		registration, err := loadRepoRegistration(ctx, c, sets)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			return exitFail
 		}
-		taskCfg, err := repoTaskConfig(fields, sets, flagName)
+		taskCfg, err := registrationTaskConfig(registration, sets, flagName)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, "repo register: "+err.Error())
 			return exitUsage
@@ -832,7 +828,7 @@ func cmdRepoRegister(c *server.Client, flagName, flagPath string, sets kvFlags,
 		return exitOK
 	}
 
-	fields, err := c.RepoTaskFields(ctx)
+	registration, err := c.RepoRegistrationFields(ctx, nil)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		return exitFail
@@ -864,27 +860,24 @@ func cmdRepoRegister(c *server.Client, flagName, flagPath string, sets kvFlags,
 		return exitFail
 	}
 
-	sharedFields := registrationSharedFields(fields)
-	values := make([]string, len(sharedFields))
-	inputs := make([]huh.Field, len(sharedFields))
-	for i, field := range sharedFields {
-		title := field
-		if field == "project" {
-			title = "Jira project"
-		}
-		inputs[i] = huh.NewInput().Title(title).Value(&values[i])
-	}
-	if len(inputs) > 0 {
-		if err := huh.NewForm(huh.NewGroup(inputs...)).Run(); err != nil {
+	shared := kvFlags{}
+	if err := promptRepoRegistration(registration, shared); err != nil {
+		fmt.Fprintln(os.Stderr, "repo register: "+err.Error())
+		return exitFail
+	}
+	if len(shared) > 0 {
+		dependent, err := c.RepoRegistrationFields(ctx, flatRegistrationValues(shared))
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			return exitFail
+		}
+		registration = mergeRegistration(registration, dependent)
+		if err := promptRepoRegistration(registration, shared); err != nil {
 			fmt.Fprintln(os.Stderr, "repo register: "+err.Error())
 			return exitFail
 		}
 	}
-	shared := kvFlags{}
-	for i, field := range sharedFields {
-		shared[field] = values[i]
-	}
-	if err := registerSelectedRepos(ctx, c, candidates, selected, fields, shared); err != nil {
+	if err := registerSelectedReposDynamic(ctx, c, candidates, selected, registration, shared); err != nil {
 		fmt.Fprintln(os.Stderr, "repo register: "+err.Error())
 		return exitFail
 	}
@@ -904,67 +897,6 @@ func repoMultiSelect(options []huh.Option[int], selected *[]int) *huh.MultiSelec
 		})
 }
 
-func registrationSharedFields(fields []string) []string {
-	shared := make([]string, 0, len(fields))
-	for _, field := range fields {
-		if field != "component" {
-			shared = append(shared, field)
-		}
-	}
-	return shared
-}
-
-func repoTaskConfig(fields []string, supplied kvFlags, repoName string) (config.RawValues, error) {
-	required := map[string]bool{}
-	for _, field := range fields {
-		required[field] = true
-	}
-	values := config.RawValues{}
-	for key, value := range supplied {
-		if !required[key] {
-			return nil, fmt.Errorf("unknown task key %q (required keys: %s)", key, strings.Join(fields, ", "))
-		}
-		if value == "" {
-			return nil, fmt.Errorf("task key %q requires a non-empty value", key)
-		}
-		values[key] = value
-	}
-	if required["component"] {
-		values["component"] = repoName
-	}
-	var missing []string
-	for _, field := range fields {
-		if _, ok := values[field]; !ok {
-			missing = append(missing, field)
-		}
-	}
-	if len(missing) > 0 {
-		return nil, fmt.Errorf("missing required task keys: %s (pass --set %s=<value>)",
-			strings.Join(missing, ", "), missing[0])
-	}
-	return values, nil
-}
-
-func registerSelectedRepos(ctx context.Context, c *server.Client, candidates []runner.RepoCandidate, selected []int, fields []string, shared kvFlags) error {
-	for _, index := range selected {
-		candidate := candidates[index]
-		taskCfg, err := repoTaskConfig(fields, shared, candidate.Name)
-		if err != nil {
-			return fmt.Errorf("%s: %w", candidate.Name, err)
-		}
-		info, err := c.RegisterRepo(ctx, repo.RegisterInput{
-			Name:       candidate.Name,
-			Path:       candidate.Path,
-			TaskConfig: taskCfg,
-		})
-		if err != nil {
-			return fmt.Errorf("%s: %w", candidate.Name, err)
-		}
-		fmt.Println(info.Name)
-	}
-	return nil
-}
-
 // kvFlags collects repeated key=value flags (registration task config).
 // Parse rejects malformed pairs, empty keys/values, and duplicates.
 type kvFlags map[string]string

package/cmd/relay-flow/repo_registration.go

@@ -0,0 +1,235 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/charmbracelet/huh"
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/repo"
+	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/server"
+	"github.com/rajpopat27/relay-flow/internal/task"
+)
+
+// loadRepoRegistration asks the selected task plugin for the fields needed by
+// registration. A second pass lets a plugin expose dependent choices after a
+// value such as a project has been supplied.
+func loadRepoRegistration(ctx context.Context, c *server.Client, supplied kvFlags) (task.Registration, error) {
+	initial, err := c.RepoRegistrationFields(ctx, nil)
+	if err != nil {
+		return task.Registration{}, err
+	}
+	if len(supplied) == 0 {
+		return initial, nil
+	}
+	dependent, err := c.RepoRegistrationFields(ctx, flatRegistrationValues(supplied))
+	if err != nil {
+		return task.Registration{}, err
+	}
+	return mergeRegistration(initial, dependent), nil
+}
+
+func flatRegistrationValues(values kvFlags) config.RawValues {
+	out := make(config.RawValues, len(values))
+	for key, value := range values {
+		out[key] = value
+	}
+	return out
+}
+
+func mergeRegistration(first, second task.Registration) task.Registration {
+	fields := make([]task.RegistrationField, 0, len(first.Fields)+len(second.Fields))
+	positions := map[string]int{}
+	for _, field := range append(append([]task.RegistrationField(nil), first.Fields...), second.Fields...) {
+		if index, ok := positions[field.Key]; ok {
+			fields[index] = field
+			continue
+		}
+		positions[field.Key] = len(fields)
+		fields = append(fields, field)
+	}
+	return task.Registration{Fields: fields}
+}
+
+// promptRepoRegistration renders only metadata returned by the task plugin.
+// The core CLI does not know which values are Jira statuses or how they are
+// validated.
+func promptRepoRegistration(reg task.Registration, values kvFlags) error {
+	for _, field := range reg.Fields {
+		if field.Derived || values[field.Key] != "" {
+			continue
+		}
+		title := field.Title
+		if title == "" {
+			title = field.Key
+		}
+		if len(field.Options) > 0 {
+			selected := field.Default
+			if err := huh.NewForm(huh.NewGroup(
+				huh.NewSelect[string]().Title(title).Options(registrationSelectOptions(field)...).Value(&selected),
+			)).Run(); err != nil {
+				return err
+			}
+			if strings.TrimSpace(selected) == "" {
+				return fmt.Errorf("task field %q requires a value", field.Key)
+			}
+			values[field.Key] = selected
+			continue
+		}
+		value := field.Default
+		input := huh.NewInput().Title(title).Value(&value).Validate(func(value string) error {
+			if strings.TrimSpace(value) == "" {
+				return fmt.Errorf("%s is required", title)
+			}
+			return nil
+		})
+		if err := huh.NewForm(huh.NewGroup(input)).Run(); err != nil {
+			return err
+		}
+		values[field.Key] = value
+	}
+	return nil
+}
+
+func registrationSelectOptions(field task.RegistrationField) []huh.Option[string] {
+	options := make([]huh.Option[string], 0, len(field.Options)+1)
+	if field.Default == "" {
+		// Huh selects the first option when Enter is pressed. Keep an explicit
+		// empty choice first so a missing conventional default cannot silently
+		// become the first real Jira status.
+		options = append(options, huh.NewOption("Select a value...", ""))
+	}
+	for _, option := range field.Options {
+		options = append(options, huh.NewOption(option, option))
+	}
+	return options
+}
+
+func registrationTaskConfig(reg task.Registration, supplied kvFlags, repoName string) (config.RawValues, error) {
+	known := make(map[string]task.RegistrationField, len(reg.Fields))
+	for _, field := range reg.Fields {
+		if strings.TrimSpace(field.Key) == "" {
+			return nil, errorsForRegistration("task plugin returned an empty registration key")
+		}
+		if _, exists := known[field.Key]; exists {
+			return nil, errorsForRegistration(fmt.Sprintf("duplicate task registration key %q", field.Key))
+		}
+		known[field.Key] = field
+	}
+	out := config.RawValues{}
+	for key, value := range supplied {
+		field, ok := known[key]
+		if !ok {
+			return nil, errorsForRegistration(fmt.Sprintf("unknown task key %q", key))
+		}
+		if field.Derived {
+			return nil, errorsForRegistration(fmt.Sprintf("task key %q is derived and cannot be overridden", key))
+		}
+		if strings.TrimSpace(value) == "" {
+			return nil, errorsForRegistration(fmt.Sprintf("task key %q requires a non-empty value", key))
+		}
+		if len(field.Options) > 0 && !containsRegistrationOption(field.Options, value) {
+			return nil, errorsForRegistration(fmt.Sprintf("task key %q value %q is not one of the available choices", key, value))
+		}
+		if err := setRegistrationValue(out, key, value); err != nil {
+			return nil, err
+		}
+	}
+	for _, field := range reg.Fields {
+		if field.Derived {
+			if err := setRegistrationValue(out, field.Key, repoName); err != nil {
+				return nil, err
+			}
+			continue
+		}
+		if registrationValue(out, field.Key) == "" {
+			return nil, errorsForRegistration(fmt.Sprintf("missing required task key %q", field.Key))
+		}
+	}
+	return out, nil
+}
+
+func errorsForRegistration(message string) error { return fmt.Errorf("%s", message) }
+
+func containsRegistrationOption(options []string, value string) bool {
+	for _, option := range options {
+		if option == value {
+			return true
+		}
+	}
+	return false
+}
+
+func registrationValue(values config.RawValues, key string) string {
+	parts := strings.Split(key, ".")
+	var current any = map[string]any(values)
+	for _, part := range parts {
+		var next map[string]any
+		switch value := current.(type) {
+		case map[string]any:
+			next = value
+		case config.RawValues:
+			next = map[string]any(value)
+		default:
+			return ""
+		}
+		value, ok := next[part]
+		if !ok {
+			return ""
+		}
+		current = value
+	}
+	value, _ := current.(string)
+	return strings.TrimSpace(value)
+}
+
+func setRegistrationValue(values config.RawValues, key, value string) error {
+	parts := strings.Split(key, ".")
+	if len(parts) == 0 || parts[0] == "" {
+		return errorsForRegistration("task plugin returned an invalid registration key")
+	}
+	current := values
+	for _, part := range parts[:len(parts)-1] {
+		if part == "" {
+			return errorsForRegistration(fmt.Sprintf("task plugin returned an invalid registration key %q", key))
+		}
+		existing, ok := current[part]
+		if !ok {
+			nested := map[string]any{}
+			current[part] = nested
+			current = nested
+			continue
+		}
+		var nested map[string]any
+		switch typed := existing.(type) {
+		case map[string]any:
+			nested = typed
+		case config.RawValues:
+			nested = map[string]any(typed)
+			current[part] = nested
+		default:
+			return errorsForRegistration(fmt.Sprintf("task registration key %q conflicts with another value", key))
+		}
+		current = nested
+	}
+	current[parts[len(parts)-1]] = value
+	return nil
+}
+
+func registerSelectedReposDynamic(ctx context.Context, c *server.Client, candidates []runner.RepoCandidate, selected []int, reg task.Registration, values kvFlags) error {
+	for _, index := range selected {
+		candidate := candidates[index]
+		taskCfg, err := registrationTaskConfig(reg, values, candidate.Name)
+		if err != nil {
+			return fmt.Errorf("%s: %w", candidate.Name, err)
+		}
+		info, err := c.RegisterRepo(ctx, repo.RegisterInput{Name: candidate.Name, Path: candidate.Path, TaskConfig: taskCfg})
+		if err != nil {
+			return fmt.Errorf("%s: %w", candidate.Name, err)
+		}
+		fmt.Println(info.Name)
+	}
+	return nil
+}

package/cmd/relay-flow/serve.go

@@ -565,8 +565,8 @@ func (d *serveDeps) RegisterNodeSession(ctx context.Context, registration runsvc
 func (d *serveDeps) DiscoverRepos(ctx context.Context) ([]runner.RepoCandidate, error) {
 	return d.repos.Discover(ctx)
 }
-func (d *serveDeps) TaskFields(context.Context) ([]string, error) {
-	return d.repos.RequiredRepoKeys(), nil
+func (d *serveDeps) TaskRegistrationFields(ctx context.Context, values config.RawValues) ([]task.RegistrationField, error) {
+	return d.repos.RegistrationFields(ctx, values)
 }
 func (d *serveDeps) RegisterRepo(ctx context.Context, input repo.RegisterInput) (repo.Info, error) {
 	info, err := d.repos.Register(ctx, input)

package/examples/config-reference.yaml

@@ -101,6 +101,13 @@ repos:
       # relay-flow repo name during repo registration.
       project: PAY
       component: payments
+      # These must be valid statuses in the PAY project. Interactive
+      # registration discovers them; scripted registration passes the same
+      # three keys with --set.
+      statusDefaults:
+        start: To Do
+        work: In Progress
+        end: Done
 
       # Optional repo-level overrides inherit into workflows and nodes.
       # assignee: relay-bot@example.com

package/internal/harness/opencode/opencode_test.go

@@ -14,7 +14,7 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
-const configuredPlugin = "relay-flow-plugin@0.2.7-alpha"
+const configuredPlugin = "relay-flow-plugin@0.2.8-alpha"
 
 func TestBuildCommandArgv(t *testing.T) {
 	t.Setenv("RELAY_FLOW_HOME", "/var/lib/relay-flow-test")

package/internal/harness/opencode/repo_setup.go

@@ -10,7 +10,7 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/config"
 )
 
-const relayFlowPlugin = "relay-flow-plugin@0.2.7-alpha"
+const relayFlowPlugin = "relay-flow-plugin@0.2.8-alpha"
 
 type jsoncToken struct {
 	kind       byte

package/internal/repo/service.go

@@ -79,6 +79,12 @@ func (s *Service) RequiredRepoKeys() []string {
 	return keys
 }
 
+// RegistrationFields returns task-plugin-owned registration prompts and
+// choices. Core repo management does not interpret the returned keys.
+func (s *Service) RegistrationFields(ctx context.Context, values config.RawValues) ([]task.RegistrationField, error) {
+	return task.RegistrationFields(ctx, s.taskPlugin, values)
+}
+
 type RegisterInput struct {
 	Name       string
 	Path       string
@@ -116,6 +122,13 @@ func (s *Service) Register(ctx context.Context, input RegisterInput) (Info, erro
 			return Info{}, fmt.Errorf("repo %q: required task config key %q is missing", input.Name, k)
 		}
 	}
+	if err := task.ValidateRegistration(ctx, s.taskPlugin, task.RepoRegistrationSpec{
+		Name:       input.Name,
+		RootConfig: cfg.TaskConfig,
+		RepoConfig: input.TaskConfig,
+	}); err != nil {
+		return Info{}, fmt.Errorf("repo %q: %w", input.Name, err)
+	}
 	// Duplicate registration identity: compute this repo's identity and compare
 	// against every registered repo. Most plugins use their physical task scope;
 	// Beads includes its derived repository label so distinct repositories may