relay-flow 0.2.6-alpha → 0.2.8-alpha

package/README.md

@@ -1,36 +1,160 @@
 # relay-flow
 
-Durable, graph-based agent workflow runner. A ticket is the unit of work; a workflow YAML declares nodes and routes; a durable engine (go-workflows + SQLite) drives progression, waits, retries, and recovery. The task system (Jira and Beads built-ins) supplies parent tickets and mailbox subtasks; the runner (Orca built-in) owns worktrees and terminals; the harness (OpenCode and Pi built-ins) owns agent sessions and report semantics. All three are pluggable.
+Durable, graph-based agent workflow runner. A ticket is the unit of work; a workflow YAML declares nodes and routes; a durable executor drives progression, waits, retries, and recovery. Task systems (Jira and Beads), runners (Orca and Herdr), harnesses (OpenCode and Pi), and durable executors (go-workflows and Temporal) are selectable independently.
 
 This is a ground-up rewrite. The previous per-workflow, in-memory daemon is gone. There is no migration path and no compatibility layer.
 
 ---
 
-## Setup
+## Quick start
 
-### Prerequisites
+### 1. Install relay-flow
 
-| Tool | Why |
-|---|---|
-| [opencode](https://opencode.ai) | Agents run in opencode sessions (harness) |
-| [Orca](https://github.com/Necmttn/orca) CLI + app | Worktrees + terminals (runner) |
-| `bd` CLI | Beads task-system access (required when `taskPlugin: beads`) |
-| Dolt | External/server-backed Beads only |
-| Jira API token | Jira REST API v3 access (required when `taskPlugin: jira`) |
-| Go 1.24+ | Build the CLI |
+Install the latest released CLI with Homebrew:
 
-### Install
+```sh
+brew install rajpopat27/tap/relay-flow
+```
+
+### 2. Install the harness extension
+
+Choose the harness that will run your agent sessions. Both commands install the
+same `relay-flow-plugin` package with host-specific entrypoints.
+
+**OpenCode**
+
+```sh
+opencode plugin relay-flow-plugin@0.2.8-alpha
+```
+
+**Pi**
+
+```sh
+pi install npm:relay-flow-plugin@0.2.8-alpha
+```
+
+Pi loads the package's `pi.ts` extension from its manifest. Do not add
+`-e`/`--extension` to relay-flow's Pi launch command.
+
+### 3. Initialize relay-flow
+
+Choose one task system, runner, harness, and durable executor. This example
+uses Jira, Orca, OpenCode, and the default embedded executor:
+
+```sh
+relay-flow init \
+  --task-plugin jira \
+  --runner-plugin orca \
+  --harness-plugin opencode
+```
+
+The default executor is `goworkflows` with SQLite. To use Temporal instead,
+add `--executor-plugin temporal`, `--temporal-address <host:port>`, and
+`--temporal-namespace <name>` to the command.
+
+### 4. Authenticate the task system
+
+For Jira, authenticate the selected task plugin:
+
+```sh
+relay-flow task auth
+```
+
+For Beads, skip this command and initialize/authenticate the Beads workspace
+with `bd` and, when needed, Dolt. See [Beads task system](#beads-task-system)
+below.
+
+### 5. Start the server
+
+```sh
+relay-flow serve --background
+```
+
+### 6. Register a repository
+
+The repository must already exist in the selected runner. For Orca:
+
+```sh
+orca repo add --path /work/payments
+relay-flow repo register
+```
+
+For Herdr, register the repository path directly; relay-flow creates ticket
+worktrees lazily. The interactive registration asks for the task-system values
+required by the selected task plugin.
+
+### 7. Submit a workflow
+
+```sh
+relay-flow workflow submit --file examples/minimal-jira-task-workflow.yaml
+relay-flow workflow list
+```
+
+Replace the example workflow with
+`examples/minimal-beads-task-workflow.yaml` when using Beads. The workflow's
+`repos` value must match the name used during repository registration.
+
+## Supported plugins
+
+Each category is a replaceable boundary. Select one plugin from each category
+at initialization; the workflow YAML and core orchestration do not change when
+you switch an implementation.
+
+| Category | Supported plugins | Owns |
+|---|---|---|
+| Task system | `jira`, `beads` | Parent tickets, mailbox subtasks, task state, labels, comments, and task configuration |
+| Runner | `orca`, `herdr` | Ticket worktrees, environments, terminals, process liveness, and cleanup |
+| Harness | `opencode`, `pi` | Agent launch commands, sessions, prompts, report parsing, nudges, and resume behavior |
+| Durable executor | `goworkflows`, `temporal` | Graph progression, waits, retries, recovery, and durable execution state |
+
+The default durable executor is `goworkflows`, which stores execution state in
+SQLite. `temporal` uses an external Temporal server and is selected with the
+Temporal address and namespace during `init`.
+
+The plugin composition is explicit:
+
+```text
+Task system (Jira or Beads)
+        │
+        ▼
+Durable executor (go-workflows or Temporal)
+        │
+        ▼
+Runner (Orca or Herdr)
+        │
+        ▼
+Harness (OpenCode or Pi)
+        │
+        ▼
+relay-flow report transport
+```
+
+The equivalent non-interactive selection is:
 
 ```sh
-go install github.com/rajpopat27/relay-flow/cmd/relay-flow@latest
+relay-flow init \
+  --task-plugin <jira|beads> \
+  --runner-plugin <orca|herdr> \
+  --harness-plugin <opencode|pi> \
+  --executor-plugin <goworkflows|temporal>
 ```
 
+`--executor-plugin` defaults to `goworkflows`. Jira requires Jira credentials;
+Beads requires the `bd` CLI and a configured workspace. Orca requires its CLI
+and app; Herdr requires its CLI/server. OpenCode and Pi each require their
+corresponding agent runtime. These integrations remain behind their small
+contracts, so task-system fields do not leak into runners or harnesses.
+
+## Detailed setup
+
+### Harness configuration
+
 OpenCode plugin configuration uses both entrypoints. The server entrypoint is listed in `opencode.json`:
 
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": ["relay-flow-plugin"]
+  "plugin": ["relay-flow-plugin@0.2.8-alpha"]
 }
 ```
 
@@ -39,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"]
+  "plugin": ["relay-flow-plugin@0.2.8-alpha"]
 }
 ```
 
@@ -55,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@<version>
+pi install npm:relay-flow-plugin@0.2.8-alpha
 ```
 
 Relay-flow does not install or configure the package automatically. Pi resolves
@@ -71,14 +195,14 @@ structured report, applies the agent/HITL nudge policy, and delivers
 `reportId` comes from the harness session/message identity; `nodeVisitID` is
 internal and is never part of either plugin payload.
 
-### One-time machine setup
+### Machine setup details
 
 ```sh
 relay-flow init
 relay-flow task auth
 ```
 
-`init` only selects the task system, runner, and harness (singleton options are automatic), writes machine config, and initializes SQLite. `task auth` delegates authentication to that selected task plug-in. Jira prompts for its site, email, and masked API token, validates `/myself`, and owns the system-wide `credentials.yaml`; for scripts, pass `task auth --site`, `--email`, and `--token`. A normal init rerun refuses existing state. `relay-flow init --force` updates safe stopped instances while preserving durable and repo state.
+`init` selects the task system, runner, harness, and durable executor (singleton options are automatic), writes machine config, and initializes the selected execution backend. `task auth` delegates authentication to that selected task plug-in. Jira prompts for its site, email, and masked API token, validates `/myself`, and owns the system-wide `credentials.yaml`; for scripts, pass `task auth --site`, `--email`, and `--token`. A normal init rerun refuses existing state. `relay-flow init --force` updates safe stopped instances while preserving durable and repo state.
 
 For Beads, select the plugin explicitly when scripting setup:
 
@@ -131,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 scripts, 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
 
@@ -229,10 +365,7 @@ Workflows live at `~/.relay-flow/workflows/<name>.yaml` after submit. Replacemen
 
 Use [`examples/config-reference.yaml`](examples/config-reference.yaml) for the complete machine configuration, [`examples/workflow-reference.yaml`](examples/workflow-reference.yaml) for the complete workflow schema, or the provider-specific minimal workflows [`examples/minimal-jira-task-workflow.yaml`](examples/minimal-jira-task-workflow.yaml) and [`examples/minimal-beads-task-workflow.yaml`](examples/minimal-beads-task-workflow.yaml). Runtime node agents should follow [`docs/agent-instructions.md`](docs/agent-instructions.md). The existing [`examples/default-story-workflow.yaml`](examples/default-story-workflow.yaml) remains a more detailed Jira Story example, while [`examples/beads-workflow.yaml`](examples/beads-workflow.yaml) shows the Beads lifecycle shape. Replace the repo name and uncomment only the optional fields you need.
 
-Task, runner, and harness plugins are selected machine-wide. A single relay-flow
-configuration cannot run Jira and Beads simultaneously; use separate
-`RELAY_FLOW_HOME` directories or machine configurations when both providers are
-needed.
+Task, runner, harness, and durable executor plugins are selected machine-wide. A single relay-flow configuration cannot run Jira and Beads simultaneously; use separate `RELAY_FLOW_HOME` directories or machine configurations when both providers are needed.
 
 ### Run
 
@@ -262,6 +395,8 @@ cleanupRunnerOnEnd: false        # optional; when true the runner tears down at
 taskConfig:                      # optional; adapter-owned; merged root → repo → workflow → node
   filters:
     parentStatuses: [To Do]
+    labels: ["workflow:true"]
+    assignees: ["currentUser()"] # Jira resolves this to the authenticated email.
 
 nodes:
   start:
@@ -271,20 +406,43 @@ nodes:
     onSuccess: [{ target: coding }]
 
   coding:
-    type: agent                  # or hitl
-    agent: build                 # opencode agent
+    type: agent
+    agent: build
     description: |               # becomes the mailbox description and launch prompt
-      Implement the ticket.
+      Implement the ticket in the current worktree.
+    nudgePrompt: |
+      Continue working on {{ticket}}. Read the parent {{taskSystem}} ticket
+      {{ticket}} and your assigned ticket {{mailbox}} to understand the requirements. Read
+      the latest feedback, address the requested changes, and work on the next
+      bounded task slice. Return the complete report. Valid choices are:
+      {{nextSteps}}.
     onSuccess: [{ target: reviewing, when: "work complete" }]
     onFailure: [{ target: coding,   when: "retry" }]
-    nudgePrompt: "Check edge cases for {{ticket}} before reporting." # optional custom instructions
 
   reviewing:
+    type: agent
+    agent: plan
+    description: Review the completed implementation and report required changes.
+    nudgePrompt: |
+      Review {{ticket}}. Read the parent {{taskSystem}} ticket {{ticket}} and
+      your assigned ticket {{mailbox}} to understand the requirements. Re-check the
+      implementation and latest coding feedback, then return the complete
+      report. Valid choices are:
+      {{nextSteps}}.
+    onSuccess: [{ target: humanReview, when: "ready for human review" }]
+    onFailure: [{ target: coding,      when: "changes required" }]
+
+  humanReview:
     type: hitl
-    agent: build
-    description: Human review.
-    onSuccess: [{ target: end }]
-    onFailure: [{ target: coding }]
+    agent: plan
+    description: Approve the reviewed implementation or request changes.
+    nudgePrompt: |
+      Review the completed work for {{ticket}} with the human. Read the parent
+      {{taskSystem}} ticket {{ticket}} and your assigned ticket {{mailbox}} to
+      understand the requirements. Return the complete report. Valid choices are:
+      {{nextSteps}}.
+    onSuccess: [{ target: end,    when: "approved" }]
+    onFailure: [{ target: coding, when: "changes requested" }]
 
   end: {}
 ```
@@ -468,7 +626,7 @@ tickets are not reopened automatically.
 ## Architecture
 
 - **Task system** owns parent tickets, mailbox subtasks, task state, labels, comments, and adapter config. The parent ticket is the unit of work.
-- **Durable workflow engine** (go-workflows + SQLite) owns graph progression, waits, reports, retries, and recovery. No custom state machine.
+- **Durable workflow engine** (`goworkflows` + SQLite or `temporal`) owns graph progression, waits, reports, retries, and recovery. No custom state machine.
 - **Mailbox subtask** is one agent/HITL node's scratch space; its description defines the node's work and its comments hold the node's summary plus selected incoming feedback.
 - **Harness** owns agent launch, session/report behavior, parsing, nudging, and resume semantics.
 - **Runner** owns ticket worktrees/environments, terminals, liveness, and execution of harness commands.

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