relay-flow 0.2.3-alpha → 0.2.5-alpha

package/README.md

@@ -1,6 +1,6 @@
 # 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 built-in) 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 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.
 
 This is a ground-up rewrite. The previous per-workflow, in-memory daemon is gone. There is no migration path and no compatibility layer.
 
@@ -51,6 +51,26 @@ assistant report it shows a native Approve/Reject dialog. Approval delivers
 delivers nothing. `reportId` comes from the harness session/message identity;
 `nodeVisitID` is internal and is never part of either plugin payload.
 
+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>
+```
+
+Relay-flow does not install or configure the package automatically. Pi resolves
+`pi.ts` from the package's `pi.extensions` manifest entry, so do not add
+`-e`/`--extension` to the relay-flow launch command. The runner launches Pi in
+an interactive PTY; the package's OpenCode entry point remains available for
+OpenCode sessions.
+
+The plugin is the report-path half of the harness contract: it registers each
+emitted harness session with `{runId, node, sessionId}`, parses the agent's
+structured report, applies the agent/HITL nudge policy, and delivers
+`{runId, node, reportId, report}` via `relay-flow report` with retry.
+`reportId` comes from the harness session/message identity; `nodeVisitID` is
+internal and is never part of either plugin payload.
+
 ### One-time machine setup
 
 ```sh
@@ -68,6 +88,13 @@ relay-flow init --task-plugin beads --runner-plugin orca --harness-plugin openco
 
 Beads authentication is owned by the Beads workspace and its `bd`/Dolt configuration. `relay-flow task auth` is a no-op for Beads and does not create relay-flow credentials; do not add a Jira token to a Beads-only installation.
 
+Pi is available through the existing harness selection. For a non-interactive
+setup, select it with the existing flags:
+
+```sh
+relay-flow init --task-plugin jira --runner-plugin orca --harness-plugin pi
+```
+
 The full machine layout is fixed under `~/.relay-flow` (0700):
 
 ```
@@ -174,10 +201,14 @@ Beads workflow filters are structured and evaluated in relay-flow. For example,
 taskConfig:
   filters:
     parentStatuses: [open]
-    issueTypes: [epic]
+    issueTypes: [task]
     labels: [relay-ready]
 ```
 
+Jira and Beads use the same conceptual `Task` issue type, but each adapter
+keeps its provider-native spelling: Jira uses `Task` and Beads uses `task`.
+Filter values are exact and are not translated between providers.
+
 The supported Beads status names are `open`, `in_progress`, `blocked`, `deferred`, `hooked`, and `closed`. The claimed-parent poll uses the canonical active set `open,in_progress,blocked,deferred`; it intentionally does not substitute `hooked` for `deferred`. Omitted lifecycle settings move the parent to `in_progress` at `start`, a work-node mailbox to `in_progress`, and the parent to `closed` at `end` — the same shape as Jira, with Beads-native values. Relay-flow creates one Repo Poller per registered repo, not one poller per workflow. Each poll reads ready top-level parents and relay-owned active parents, deduplicates them, and never routes mailbox children. Claims are permanent `wf:<workflow>` labels.
 
 Beads does not need relay-flow credentials or a Beads-specific poller. In server mode, leave Dolt and Beads server setup running outside relay-flow and point each repo at its own `beadsDir`.
@@ -190,7 +221,12 @@ relay-flow workflow submit --file <path>
 
 Workflows live at `~/.relay-flow/workflows/<name>.yaml` after submit. Replacement and removal are rejected while any run of that workflow is active.
 
-Use [`examples/default-story-workflow.yaml`](examples/default-story-workflow.yaml) as a fully annotated Jira-oriented starting point, or [`examples/beads-workflow.yaml`](examples/beads-workflow.yaml) for the Beads filter and lifecycle shape. Replace the repo name and uncomment only the optional fields you need.
+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.
 
 ### Run
 
@@ -284,19 +320,94 @@ A parent moved to `in_progress` stays visible to the claimed-parent poll, which
 
 Beads and Jira use the shared `filters`, `templates`, optional top-level
 `assignee`, and `transitionTo` field names. `transitionTo` uses
-`parentStatus` for the parent issue and `taskStatus` for a mailbox. In both
-adapters `assignee` is the default assignee filter when `filters.assignees` is
-absent, and an `assignee` in effect for a node also assigns that node's
-mailbox. Beads requires the repo-only `taskConfig.beadsDir` shown above; Jira
-instead uses its repo `project` and `component` keys. `project` and
-`component` are not Beads fields, and a Beads issue prefix is not a component
-or workspace selector. Beads status values remain native (`open`,
+`parentStatus` for the parent issue and `taskStatus` for a mailbox. Both
+adapters support the structured `filters.assignees` list. Jira values are
+normalized account emails; Beads values are the provider's assignee strings.
+Jira additionally supports the reserved `currentUser()` value inside
+`filters.assignees`; relay-flow resolves it to the authenticated Jira email
+without sending it as JQL. On first Jira authentication, when no root
+`taskConfig.assignee` is configured, relay-flow stores the authenticated email
+as the root mailbox assignee. In both adapters `assignee` applies to a node's
+mailbox assignment; only `filters.assignees` controls parent-ticket pickup.
+When `filters.assignees` is absent, there is no assignee filter. To make that
+explicit while keeping mailbox assignment, set an empty list:
+
+```yaml
+taskConfig:
+  filters:
+    assignees: []
+```
+
+This still applies the other filters, such as project, status, issue type, and
+labels. If mailbox assignment should also be disabled for a workflow, override
+`assignee` with an empty string at that scope as well. Beads requires the repo-only
+`taskConfig.beadsDir` shown above; Jira instead uses its repo `project` and
+`component` keys. `project` and `component` are not Beads fields, and a Beads
+issue prefix is not a component or workspace selector. Beads status values remain native (`open`,
 `in_progress`, `blocked`, `deferred`, `hooked`, `closed`), while Jira values
 remain native (`In Progress`, `Done`, and so on); relay-flow does not
 translate arbitrary values between providers. Beads rejects workflow/node-level
 template overrides because the fixed task text rendering contract has no
 lower-scope input.
 
+### Pi harness
+
+Pi has one built-in coding agent. Relay-flow keeps Pi's configured model,
+provider, tools, extensions, and settings, while allowing a workflow node to
+select a project-owned prompt template. `agent: default` uses Pi's built-in
+coding agent without an additional prompt template. A non-default value such as
+`coder` or `reviewer` selects Pi's native project template
+`.pi/prompts/<agent>.md` and submits the rendered task text as the template's
+arguments with `/<agent> ...`.
+
+Pi owns prompt-template discovery and expansion. Relay-flow does not maintain a
+named-agent registry or inspect template files; it only validates the safe
+template command name and passes Pi the corresponding
+`--prompt-template .pi/prompts/<agent>.md` resource. The workflow agent value is
+never treated as a model ID and relay-flow never passes an OpenCode-style
+`--agent` option.
+
+For example, a Pi workflow with project prompt templates uses:
+
+```yaml
+type: agent
+agent: coder
+```
+
+with project templates:
+
+```text
+.pi/prompts/coder.md
+.pi/prompts/reviewer.md
+```
+
+Pi node launches use the installed Pi interactive command contract:
+
+```text
+pi --name <ticket>:<node> [--prompt-template .pi/prompts/<agent>.md] [--session-id <persisted-session-id>] <prompt>
+```
+
+For a named agent, `<prompt>` is `/agent <rendered relay-flow task or
+feedback prompt>`; `default` keeps the rendered prompt unchanged.
+
+The prompt is one positional argument. Pi 0.84.1 rejects a bare `--`, so the
+launch command does not include one. A persisted session uses
+`--session-id`; print mode, JSON/RPC mode, and extension-install flags are not
+used. The runner supplies a PTY for both standard streams, and the Pi process
+remains available for interactive input after a response settles.
+
+For a `hitl` node, a valid report is approved directly in Pi's host UI with
+`ctx.ui.select`:
+
+```text
+Approve relay-flow report for <ticket>:<node>
+  Approve
+  Reject
+```
+
+Approve delivers the report. Reject or Escape submits nothing and leaves the
+durable run waiting; Pi does not require an LLM Question tool for this step.
+
 ---
 
 ## Structured node report

package/cmd/relay-flow/backend_selection_test.go

@@ -0,0 +1,149 @@
+package main
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/execution/projection"
+	"github.com/rajpopat27/relay-flow/internal/paths"
+	"github.com/rajpopat27/relay-flow/internal/server"
+	_ "modernc.org/sqlite"
+)
+
+// These integration tests are deliberately live-gated because they exercise
+// the selected durable backend and the local Temporal service. They use the
+// same fake task/runner/harness factories as the composition scenario, but no
+// task-system state or workflow is needed to prove worker selection.
+func TestServeSelectsConfiguredTemporalExecutor(t *testing.T) {
+	if os.Getenv("RELAY_FLOW_TEMPORAL_LIVE") != "1" {
+		t.Skip("set RELAY_FLOW_TEMPORAL_LIVE=1 to run backend selection against Temporal")
+	}
+	assertServeUsesTemporal(t, false)
+}
+
+func TestServeRecoverSelectsConfiguredTemporalExecutor(t *testing.T) {
+	if os.Getenv("RELAY_FLOW_TEMPORAL_LIVE") != "1" {
+		t.Skip("set RELAY_FLOW_TEMPORAL_LIVE=1 to run backend recovery against Temporal")
+	}
+	assertServeUsesTemporal(t, true)
+}
+
+func assertServeUsesTemporal(t *testing.T, recover bool) {
+	t.Helper()
+	log := newScenarioLog()
+	setScenarioFactoryAdapters(newScenarioTaskSystem(log), newScenarioRunner(log), newScenarioHarness(log))
+
+	root := filepath.Join(t.TempDir(), ".relay-flow")
+	t.Setenv("RELAY_FLOW_HOME", root)
+	p := pathsForRoot(root)
+	if err := paths.Ensure(p); err != nil {
+		t.Fatal(err)
+	}
+	namespace := fmt.Sprintf("relay-flow-serve-%d", time.Now().UnixNano())
+	if err := ensureTemporalNamespace(context.Background(), "localhost:7233", namespace, 30); err != nil {
+		t.Fatal(err)
+	}
+	// Namespace registration is acknowledged before every frontend worker
+	// necessarily observes it.
+	time.Sleep(5 * time.Second)
+	if err := config.SaveMachine(p.Config, &config.Machine{
+		TaskPlugin:                scenarioTaskPlugin,
+		RunnerPlugin:              scenarioRunnerPlugin,
+		HarnessPlugin:             scenarioHarnessPlugin,
+		ExecutorPlugin:            "temporal",
+		TemporalAddress:           "localhost:7233",
+		TemporalNamespace:         namespace,
+		CompletedRunRetentionDays: 30,
+	}); err != nil {
+		t.Fatal(err)
+	}
+	if err := projection.InitDatabaseWithIdentity(p.Database, projection.ExecutorIdentity{
+		ExecutorPlugin: "temporal", TemporalAddress: "localhost:7233", TemporalNamespace: namespace,
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	done := make(chan error, 1)
+	go func() { done <- serveRoot(ctx, p, recover) }()
+	client := server.NewClient(p.Socket)
+	waitForServerOrError(t, client, done)
+
+	assertNoEmbeddedExecutionTables(t, p.Database)
+	if err := client.Stop(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	select {
+	case err := <-done:
+		if err != nil {
+			t.Fatalf("serveRoot(%v): %v", recover, err)
+		}
+	case <-time.After(15 * time.Second):
+		t.Fatalf("serveRoot(%v) did not stop", recover)
+	}
+}
+
+func waitForServerOrError(t *testing.T, client *server.Client, done <-chan error) {
+	t.Helper()
+	deadline := time.Now().Add(20 * time.Second)
+	for time.Now().Before(deadline) {
+		select {
+		case err := <-done:
+			t.Fatalf("serveRoot exited before socket became ready: %v", err)
+		default:
+		}
+		ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+		_, err := client.ListRepos(ctx)
+		cancel()
+		if err == nil {
+			return
+		}
+		time.Sleep(20 * time.Millisecond)
+	}
+	select {
+	case err := <-done:
+		t.Fatalf("serveRoot exited before socket became ready: %v", err)
+	default:
+		t.Fatal("server did not become ready")
+	}
+}
+
+func assertNoEmbeddedExecutionTables(t *testing.T, databasePath string) {
+	t.Helper()
+	db, err := sql.Open("sqlite", databasePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	var count int
+	if err := db.QueryRow(`SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name IN ('instances', 'history_events', 'activity_tasks')`).Scan(&count); err != nil {
+		t.Fatal(err)
+	}
+	if count != 0 {
+		t.Fatalf("Temporal projection contains embedded go-workflows tables: %d", count)
+	}
+	var plugin, address, namespace string
+	if err := db.QueryRow(`SELECT executor_plugin, temporal_address, temporal_namespace FROM relay_executor_identity WHERE singleton = 1`).Scan(&plugin, &address, &namespace); err != nil {
+		t.Fatal(err)
+	}
+	if plugin != "temporal" || address != "localhost:7233" || namespace == "" {
+		t.Fatalf("executor identity = %q/%q/%q", plugin, address, namespace)
+	}
+}
+
+func pathsForRoot(root string) paths.Paths {
+	return paths.Paths{
+		Root: root, Config: filepath.Join(root, "config.yaml"),
+		Credentials: filepath.Join(root, "credentials.yaml"), Workflows: filepath.Join(root, "workflows"),
+		Database: filepath.Join(root, "state.db"), Socket: filepath.Join(root, "server.sock"),
+		Lock: filepath.Join(root, "server.lock"), ServerLog: filepath.Join(root, "server.log"),
+		PluginLog: filepath.Join(root, "plugin.log"),
+	}
+}

package/cmd/relay-flow/main.go

@@ -24,7 +24,7 @@ import (
 	"github.com/charmbracelet/huh"
 	"github.com/mattn/go-isatty"
 	"github.com/rajpopat27/relay-flow/internal/config"
-	"github.com/rajpopat27/relay-flow/internal/execution/goworkflows"
+	"github.com/rajpopat27/relay-flow/internal/execution/projection"
 	"github.com/rajpopat27/relay-flow/internal/harness"
 	"github.com/rajpopat27/relay-flow/internal/logging"
 	"github.com/rajpopat27/relay-flow/internal/paths"
@@ -37,6 +37,8 @@ import (
 	// Adapter registrations (factories registered via init for plugin
 	// name validation at init-time).
 	_ "github.com/rajpopat27/relay-flow/internal/harness/opencode"
+	_ "github.com/rajpopat27/relay-flow/internal/harness/pi"
+	_ "github.com/rajpopat27/relay-flow/internal/runner/herdr"
 	_ "github.com/rajpopat27/relay-flow/internal/runner/orca"
 	_ "github.com/rajpopat27/relay-flow/internal/task/beads"
 	_ "github.com/rajpopat27/relay-flow/internal/task/jira"
@@ -132,6 +134,8 @@ func usage(w io.Writer) {
 
 Usage:
   relay-flow init [--force] [--task-plugin <name> --runner-plugin <name> --harness-plugin <name>]
+                   [--executor-plugin <goworkflows|temporal>]
+                   [--temporal-address <host:port>] [--temporal-namespace <name>]
   relay-flow task auth [task-plugin options]
   relay-flow serve [--recover] [--debug] [--background]
   relay-flow stop
@@ -168,6 +172,9 @@ func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
 	taskName := fs.String("task-plugin", "", "task plugin name (non-interactive)")
 	runnerName := fs.String("runner-plugin", "", "runner plugin name (non-interactive)")
 	harnessName := fs.String("harness-plugin", "", "harness plugin name (non-interactive)")
+	executorName := fs.String("executor-plugin", "", "durable executor name (goworkflows or temporal)")
+	temporalAddress := fs.String("temporal-address", "", "Temporal server address")
+	temporalNamespace := fs.String("temporal-namespace", "", "Temporal namespace/team name")
 	force := fs.Bool("force", false, "update plugin selections while preserving existing state")
 	if err := fs.Parse(args); err != nil {
 		return exitUsage
@@ -213,7 +220,7 @@ func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
 		}
 		defer unlock()
 		if databaseExists {
-			active, err := goworkflows.HasNonterminalRuns(p.Database)
+			active, err := projection.HasNonterminalRuns(p.Database)
 			if err != nil {
 				fmt.Fprintln(os.Stderr, "init: "+err.Error())
 				return exitFail
@@ -225,9 +232,11 @@ func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
 		}
 	}
 
-	// Selection precedence: flags → TTY form → stdin lines. The stdin path
-	// is the documented test seam and script path.
+	// Selection precedence: flags → TTY form → legacy stdin lines. The
+	// three-line stdin path remains embedded-mode input and never consumes
+	// Temporal answers.
 	var names []string
+	executor := strings.TrimSpace(*executorName)
 	switch {
 	case flagged:
 		names = []string{*taskName, *runnerName, *harnessName}
@@ -238,6 +247,10 @@ func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
 			fmt.Fprintln(os.Stderr, "init: "+err.Error())
 			return exitFail
 		}
+		if len(names) == 4 {
+			executor = names[3]
+			names = names[:3]
+		}
 	default:
 		names = readInitLines(stdin)
 		if names == nil {
@@ -245,6 +258,22 @@ func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
 			return exitFail
 		}
 	}
+	if executor == executorTemporal && isTTY(stdin) {
+		address, namespace, err := promptTemporalSettings(*temporalAddress, *temporalNamespace)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "init: "+err.Error())
+			return exitFail
+		}
+		*temporalAddress = address
+		*temporalNamespace = namespace
+	}
+	if executor == "" {
+		executor = executorGoworkflows
+	}
+	if executor != executorGoworkflows && executor != executorTemporal {
+		fmt.Fprintln(os.Stderr, "init: unknown executor plugin "+executor)
+		return exitUsage
+	}
 	// Validate against the registered factories; unknown names list the
 	// registered set per design (no silent acceptance).
 	if err := task.ValidateName(names[0]); err != nil {
@@ -260,13 +289,42 @@ func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
 		return exitFail
 	}
 
-	cfg := &config.Machine{KeepTerminalsAlive: true, KeepSessionsAlive: true}
+	cfg := &config.Machine{
+		PollIntervalSeconds: 15, CompletedRunRetentionDays: 30,
+		KeepTerminalsAlive: true, KeepSessionsAlive: true,
+		ExecutorPlugin: executor,
+	}
 	if *force && configExists {
 		cfg, err = config.LoadMachine(p.Config)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			return exitFail
 		}
+		if strings.TrimSpace(*executorName) == "" {
+			executor = cfg.ExecutorPlugin
+		}
+		cfg.ExecutorPlugin = executor
+	}
+	if executor == executorTemporal {
+		if strings.TrimSpace(*temporalAddress) != "" {
+			cfg.TemporalAddress = strings.TrimSpace(*temporalAddress)
+		} else if cfg.TemporalAddress == "" {
+			cfg.TemporalAddress = defaultTemporalAddr
+		}
+		if strings.TrimSpace(*temporalNamespace) != "" {
+			cfg.TemporalNamespace = strings.TrimSpace(*temporalNamespace)
+		}
+		if cfg.TemporalNamespace == "" {
+			fmt.Fprintln(os.Stderr, "init: --temporal-namespace is required for executor-plugin temporal")
+			return exitUsage
+		}
+	} else {
+		if strings.TrimSpace(*temporalAddress) != "" || strings.TrimSpace(*temporalNamespace) != "" {
+			fmt.Fprintln(os.Stderr, "init: Temporal address/namespace require executor-plugin temporal")
+			return exitUsage
+		}
+		cfg.TemporalAddress = ""
+		cfg.TemporalNamespace = ""
 	}
 	cfg.TaskPlugin = names[0]
 	cfg.RunnerPlugin = names[1]
@@ -295,17 +353,37 @@ func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
 	} else {
 		cfg.HarnessConfig = config.Merge(harnessDefaults, cfg.HarnessConfig)
 	}
-	if err := config.SaveMachine(p.Config, cfg); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		return exitFail
+	identity := projection.ExecutorIdentity{
+		ExecutorPlugin:    executor,
+		TemporalAddress:   cfg.TemporalAddress,
+		TemporalNamespace: cfg.TemporalNamespace,
+	}
+	// Force mode verifies the immutable durable identity before contacting
+	// Temporal or replacing configuration. Legacy marker-less homes may only
+	// be adopted by goworkflows.
+	if databaseExists {
+		if err := verifyExecutorIdentity(p.Database, identity); err != nil {
+			fmt.Fprintln(os.Stderr, "init: "+err.Error())
+			return exitFail
+		}
+	}
+	if executor == executorTemporal {
+		if err := ensureTemporalNamespace(context.Background(), cfg.TemporalAddress, cfg.TemporalNamespace, cfg.CompletedRunRetentionDays); err != nil {
+			fmt.Fprintln(os.Stderr, "init: "+err.Error())
+			return exitFail
+		}
 	}
 	if !databaseExists {
-		if err := goworkflows.InitDatabase(p.Database); err != nil {
-			fmt.Fprintln(os.Stderr, err)
+		if err := projection.InitDatabaseWithIdentity(p.Database, identity); err != nil {
+			fmt.Fprintln(os.Stderr, "init: "+err.Error())
 			return exitFail
 		}
 	}
-	fmt.Printf("Task system: %s\nRunner: %s\nHarness: %s\nRelay-flow initialized\n", names[0], names[1], names[2])
+	if err := config.SaveMachine(p.Config, cfg); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return exitFail
+	}
+	fmt.Printf("Task system: %s\nRunner: %s\nHarness: %s\nExecutor: %s\nRelay-flow initialized\n", names[0], names[1], names[2], executor)
 	return exitOK
 }
 
@@ -343,8 +421,8 @@ func isTTY(stdin io.Reader) bool {
 
 // pickPluginsInteractive runs one searchable select per plugin type.
 func pickPluginsInteractive() ([]string, error) {
-	names := make([]string, 3)
-	groups := make([]*huh.Group, 0, 3)
+	names := make([]string, 4)
+	groups := make([]*huh.Group, 0, 4)
 	for _, selection := range []struct {
 		title   string
 		options []string
@@ -362,6 +440,11 @@ func pickPluginsInteractive() ([]string, error) {
 			groups = append(groups, huh.NewGroup(field))
 		}
 	}
+	executorField, err := executorSelectField(&names[3])
+	if err != nil {
+		return nil, err
+	}
+	groups = append(groups, huh.NewGroup(executorField))
 	if len(groups) == 0 {
 		return names, nil
 	}

package/cmd/relay-flow/pi_wiring_test.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"bytes"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/harness"
+)
+
+func TestPiAppearsInDynamicHarnessSelection(t *testing.T) {
+	names := harness.Names()
+	if !containsHarnessName(names, "pi") {
+		t.Fatalf("harness.Names() = %v, want pi", names)
+	}
+
+	var selected string
+	field, err := pluginSelectField("Select harness", names, &selected)
+	if err != nil {
+		t.Fatalf("pluginSelectField: %v", err)
+	}
+	var output bytes.Buffer
+	if err := field.RunAccessible(&output, strings.NewReader("1\n")); err != nil {
+		t.Fatalf("RunAccessible: %v", err)
+	}
+	if !strings.Contains(output.String(), "Select harness") {
+		t.Fatalf("selection output %q missing unchanged harness title", output.String())
+	}
+}
+
+func TestInitPiFlagUsesGenericHarnessSelectionPath(t *testing.T) {
+	home := t.TempDir()
+	code, output := captureStdout(t, func() int {
+		return cli(t, home, "", "init",
+			"--task-plugin", "jira",
+			"--runner-plugin", "orca",
+			"--harness-plugin", "pi")
+	})
+	if code != 0 {
+		t.Fatalf("Pi init exit = %d, want 0", code)
+	}
+	if !strings.Contains(output, "Harness: pi") {
+		t.Fatalf("Pi init output = %q, want generic harness summary", output)
+	}
+
+	cfg, err := config.LoadMachine(filepath.Join(home, ".relay-flow", "config.yaml"))
+	if err != nil {
+		t.Fatalf("load Pi machine config: %v", err)
+	}
+	if cfg.HarnessPlugin != "pi" {
+		t.Fatalf("harnessPlugin = %q, want pi", cfg.HarnessPlugin)
+	}
+}
+
+func containsHarnessName(names []string, want string) bool {
+	for _, name := range names {
+		if name == want {
+			return true
+		}
+	}
+	return false
+}

package/cmd/relay-flow/scenario_test.go

@@ -801,6 +801,8 @@ type scenarioTaskSystem struct {
 	creates          map[string]int
 	completions      map[string]int
 	completeFailures int
+	recoveryTickets  []task.Ticket
+	recoveryPolls    int
 }
 
 var _ task.System = (*scenarioTaskSystem)(nil)
@@ -816,11 +818,19 @@ func newScenarioTaskSystem(log *scenarioLog) *scenarioTaskSystem {
 func (s *scenarioTaskSystem) Poll(context.Context) ([]task.Ticket, error) {
 	s.log.add("poll")
 	s.mu.Lock()
-	defer s.mu.Unlock()
 	if s.claimed {
+		if s.recoveryPolls > 0 {
+			s.recoveryPolls--
+			tickets := append([]task.Ticket(nil), s.recoveryTickets...)
+			s.mu.Unlock()
+			return tickets, nil
+		}
+		s.mu.Unlock()
 		return nil, nil
 	}
-	return []task.Ticket{{ID: "ticket-1", Key: scenarioTicket, Title: "Scenario ticket"}}, nil
+	tickets := []task.Ticket{{ID: "ticket-1", Key: scenarioTicket, Title: "Scenario ticket"}}
+	s.mu.Unlock()
+	return tickets, nil
 }
 
 func (s *scenarioTaskSystem) CompileFilter(config.RawValues) (func(task.Ticket) bool, error) {
@@ -958,6 +968,13 @@ func (s *scenarioTaskSystem) setCompleteFailures(n int) {
 	s.mu.Unlock()
 }
 
+func (s *scenarioTaskSystem) setRecoveryTickets(tickets []task.Ticket, polls int) {
+	s.mu.Lock()
+	s.recoveryTickets = append([]task.Ticket(nil), tickets...)
+	s.recoveryPolls = polls
+	s.mu.Unlock()
+}
+
 func (s *scenarioTaskSystem) mailboxCreateCount(node string) int {
 	s.mu.Lock()
 	defer s.mu.Unlock()