relay-flow 0.2.0-alpha → 0.2.2-alpha

package/internal/task/beads/repo_composition_test.go

@@ -0,0 +1,232 @@
+package beads
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/harness"
+	"github.com/rajpopat27/relay-flow/internal/repo"
+	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/task"
+)
+
+func TestBeadsRepoRegistrationUsesIndependentSystemsAndPollers(t *testing.T) {
+	root := t.TempDir()
+	logPath := installRepoCompositionFakeBD(t)
+	configPath := filepath.Join(root, "config.yaml")
+	if err := config.SaveMachine(configPath, &config.Machine{
+		TaskPlugin: "beads", RunnerPlugin: "orca", HarnessPlugin: "opencode",
+		Repos: map[string]config.Repo{},
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	paymentsPath := filepath.Join(root, "code", "payments")
+	platformPath := filepath.Join(root, "code", "platform")
+	paymentsBeads := filepath.Join(root, "beads", "payments", ".beads")
+	platformBeads := filepath.Join(root, "beads", "platform", ".beads")
+	for _, path := range []string{paymentsPath, platformPath, paymentsBeads, platformBeads} {
+		if err := os.MkdirAll(path, 0o755); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	svc := repo.NewService(repo.ServiceConfig{
+		ConfigPath: configPath,
+		TaskPlugin: "beads",
+		Runner:     &compositionRunner{},
+		Harness:    &compositionHarness{},
+		Active:     &compositionActive{},
+		Workflows:  &compositionWorkflowRefs{},
+	})
+	if _, err := svc.Register(context.Background(), repo.RegisterInput{
+		Name: "payments", Path: paymentsPath,
+		TaskConfig: config.RawValues{"beadsDir": paymentsBeads},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := svc.Register(context.Background(), repo.RegisterInput{
+		Name: "platform", Path: platformPath,
+		TaskConfig: config.RawValues{"beadsDir": platformBeads},
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	registered := svc.Registry().List()
+	if len(registered) != 2 {
+		t.Fatalf("registered repos = %d, want 2", len(registered))
+	}
+	if registered[0].TaskSystem == registered[1].TaskSystem {
+		t.Fatal("independent Beads repos shared one task system")
+	}
+
+	var handledMu sync.Mutex
+	handled := map[string]int{}
+	group := repo.NewPollerGroup(10, func(_ context.Context, r *repo.Repo, _ []task.Ticket) {
+		handledMu.Lock()
+		handled[r.Name]++
+		handledMu.Unlock()
+	})
+	group.Interval = 10 * time.Millisecond
+	group.ReplaceRepos(registered)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	go group.Run(ctx)
+
+	deadline := time.Now().Add(3 * time.Second)
+	for time.Now().Before(deadline) {
+		handledMu.Lock()
+		complete := handled["payments"] > 0 && handled["platform"] > 0
+		handledMu.Unlock()
+		if complete {
+			break
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	handledMu.Lock()
+	if handled["payments"] == 0 || handled["platform"] == 0 {
+		t.Fatalf("poller handlers = %v, want both registered repos", handled)
+	}
+	handledMu.Unlock()
+
+	assertBDInvocationReachedRepoAndWorkspace(t, logPath, paymentsPath, paymentsBeads)
+	assertBDInvocationReachedRepoAndWorkspace(t, logPath, platformPath, platformBeads)
+}
+
+func TestBeadsRepoRegistrationRejectsSharedCanonicalWorkspace(t *testing.T) {
+	root := t.TempDir()
+	installRepoCompositionFakeBD(t)
+	configPath := filepath.Join(root, "config.yaml")
+	if err := config.SaveMachine(configPath, &config.Machine{
+		TaskPlugin: "beads", RunnerPlugin: "orca", HarnessPlugin: "opencode",
+		Repos: map[string]config.Repo{},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	firstPath := filepath.Join(root, "code", "payments")
+	secondPath := filepath.Join(root, "code", "platform")
+	workspace := filepath.Join(root, "beads", "shared", ".beads")
+	for _, path := range []string{firstPath, secondPath, workspace} {
+		if err := os.MkdirAll(path, 0o755); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	svc := repo.NewService(repo.ServiceConfig{
+		ConfigPath: configPath,
+		TaskPlugin: "beads",
+		Runner:     &compositionRunner{},
+		Harness:    &compositionHarness{},
+		Active:     &compositionActive{},
+		Workflows:  &compositionWorkflowRefs{},
+	})
+	if _, err := svc.Register(context.Background(), repo.RegisterInput{
+		Name: "payments", Path: firstPath,
+		TaskConfig: config.RawValues{"beadsDir": workspace},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := svc.Register(context.Background(), repo.RegisterInput{
+		Name: "platform", Path: secondPath,
+		TaskConfig: config.RawValues{"beadsDir": filepath.Join(workspace, ".")},
+	}); err == nil {
+		t.Fatal("second repo sharing canonical beadsDir was accepted")
+	}
+	if len(svc.Registry().List()) != 1 {
+		t.Fatalf("registry after duplicate scope rejection = %d, want 1", len(svc.Registry().List()))
+	}
+}
+
+func installRepoCompositionFakeBD(t *testing.T) string {
+	t.Helper()
+	binDir := t.TempDir()
+	fake := filepath.Join(binDir, "bd")
+	script, err := os.ReadFile(filepath.Join("testdata", "strict-bd-repo.sh"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(fake, script, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	logPath := filepath.Join(t.TempDir(), "bd-invocations.log")
+	if err := os.WriteFile(logPath, nil, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("PATH", binDir+string(os.PathListSeparator)+os.Getenv("PATH"))
+	t.Setenv("BD_LOG", logPath)
+	// These must not leak into the child command environment. The adapter
+	// explicitly selects BEADS_DIR and removes unrelated Beads selectors.
+	t.Setenv("BEADS_DIR", "/ambient/workspace")
+	t.Setenv("BEADS_DB", "/ambient/beads.db")
+	t.Setenv("BD_DB", "/ambient/legacy.db")
+	return logPath
+}
+
+func assertBDInvocationReachedRepoAndWorkspace(t *testing.T, logPath, repoPath, beadsDir string) {
+	t.Helper()
+	raw, err := os.ReadFile(logPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantPrefix := repoPath + "|" + beadsDir + "|"
+	for _, line := range strings.Split(strings.TrimSpace(string(raw)), "\n") {
+		if strings.HasPrefix(line, wantPrefix) {
+			return
+		}
+	}
+	t.Fatalf("no bd invocation used cmd.Dir=%q and BEADS_DIR=%q; log=%q", repoPath, beadsDir, raw)
+}
+
+type compositionRunner struct{}
+
+func (*compositionRunner) DiscoverRepos(context.Context) ([]runner.RepoCandidate, error) {
+	return nil, nil
+}
+func (*compositionRunner) ValidateRepo(context.Context, string, string) error { return nil }
+func (*compositionRunner) EnsureEnvironment(context.Context, runner.RunSpec) (runner.Environment, error) {
+	return runner.Environment{}, nil
+}
+func (*compositionRunner) SetEnvironmentStatus(context.Context, runner.Environment, string) error {
+	return nil
+}
+func (*compositionRunner) FindTerminal(context.Context, runner.Terminal) (runner.Terminal, bool, error) {
+	return runner.Terminal{}, false, nil
+}
+func (*compositionRunner) CreateTerminal(context.Context, runner.Environment, string, runner.Command) (runner.Terminal, error) {
+	return runner.Terminal{}, nil
+}
+func (*compositionRunner) EnsureTerminal(context.Context, runner.Environment, runner.Terminal, string, runner.Command) (runner.Terminal, error) {
+	return runner.Terminal{}, nil
+}
+func (*compositionRunner) SendTerminal(context.Context, runner.Terminal, string) error { return nil }
+func (*compositionRunner) CloseTerminal(context.Context, runner.Terminal) error        { return nil }
+func (*compositionRunner) CloseTerminals(context.Context, runner.RunSpec) error        { return nil }
+func (*compositionRunner) CleanupRun(context.Context, runner.RunSpec) error            { return nil }
+
+type compositionHarness struct{}
+
+func (*compositionHarness) SetupRepo(context.Context, string) error             { return nil }
+func (*compositionHarness) ValidateAgent(context.Context, string, string) error { return nil }
+func (*compositionHarness) FindSession(context.Context, string, string) (harness.Session, bool, error) {
+	return harness.Session{}, false, nil
+}
+func (*compositionHarness) RenderPrompt(harness.PromptKind, harness.PromptData, string) (string, error) {
+	return "", nil
+}
+func (*compositionHarness) BuildCommand(harness.LaunchSpec) (runner.Command, error) {
+	return runner.Command{}, nil
+}
+
+type compositionActive struct{}
+
+func (*compositionActive) HasActiveRepo(context.Context, string) (bool, error) { return false, nil }
+
+type compositionWorkflowRefs struct{}
+
+func (*compositionWorkflowRefs) ReferencesRepo(string) bool { return false }

package/internal/task/beads/runtime_config_test.go

@@ -0,0 +1,81 @@
+package beads
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+)
+
+// Beads-specific runtime configuration behavior. The shared inheritance and
+// precedence invariants live in lifecycle_inheritance_test.go, which is
+// mirrored by the Jira adapter.
+
+func TestNodeAssigneeOverridesInheritedRepoAssignee(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "open"})
+	sys := repoScopedSystem(client, config.RawValues{"assignee": "repo-bot@example.com"})
+	node := config.RawValues{"assignee": "dev@example.com"}
+
+	cfg := operationConfig(sys.WorkDefaults(), nil, node)
+	if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), cfg); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.updates) != 1 || client.updates[0].input.Assignee != "dev@example.com" {
+		t.Fatalf("updates = %+v, want the node assignee to win", client.updates)
+	}
+}
+
+// transitionTo is a lifecycle-point setting: a value configured above node
+// scope applies to every lifecycle point that reads it, including end. This
+// test pins that uniform precedence so the behavior is deliberate rather than
+// discovered, and is why the documentation configures transitionTo on nodes.
+func TestInheritedParentStatusAppliesToEveryLifecyclePoint(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent": "in_progress"})
+	sys := repoScopedSystem(client, config.RawValues{
+		"transitionTo": map[string]any{"parentStatus": "in_progress"},
+	})
+
+	cfg := operationConfig(sys.EndDefaults(), nil, nil)
+	if err := sys.ApplyTaskConfig(context.Background(), endTarget(), cfg); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.updates) != 0 {
+		t.Fatalf("updates = %+v, want the inherited parentStatus to win over the end default", client.updates)
+	}
+
+	// The end node's own value restores closing behavior.
+	node := config.RawValues{"transitionTo": map[string]any{"parentStatus": "closed"}}
+	if err := sys.ApplyTaskConfig(context.Background(), endTarget(), operationConfig(sys.EndDefaults(), nil, node)); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.updates) != 1 || client.updates[0].input.Status != "closed" {
+		t.Fatalf("updates = %+v, want end node parentStatus closed", client.updates)
+	}
+}
+
+// RenderText has a fixed task.System signature and receives no workflow/node
+// config. Beads therefore chooses the explicit limitation: lower-scope
+// template overrides are rejected rather than accepted without runtime effect.
+func TestBeadsLowerScopeTemplateOverridesAreRejected(t *testing.T) {
+	sys := repoScopedSystem(nil, nil)
+	workflow := config.RawValues{"templates": map[string]any{
+		"summaryComment": "workflow {{summaryReport}}",
+	}}
+	node := config.RawValues{"templates": map[string]any{
+		"feedbackComment": "node {{feedbackReport}}",
+	}}
+
+	err := sys.ValidateConfig(context.Background(), workflow, map[string]config.RawValues{"implement": node})
+	lower := strings.ToLower(errString(err))
+	if err == nil || !strings.Contains(lower, "template") || !strings.Contains(lower, "scope") {
+		t.Fatalf("lower-scope template override validation error = %v, want explicit unsupported-scope error", err)
+	}
+}
+
+func errString(err error) string {
+	if err == nil {
+		return ""
+	}
+	return err.Error()
+}

package/internal/task/beads/status_compatibility_test.go

@@ -0,0 +1,233 @@
+package beads
+
+import (
+	"context"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/retry"
+	"github.com/rajpopat27/relay-flow/internal/task"
+	"github.com/rajpopat27/relay-flow/internal/task/beads/bdcli"
+)
+
+func transitionConfig(parentStatus, taskStatus string) config.RawValues {
+	transition := map[string]any{}
+	if parentStatus != "" {
+		transition["parentStatus"] = parentStatus
+	}
+	if taskStatus != "" {
+		transition["taskStatus"] = taskStatus
+	}
+	return config.RawValues{"transitionTo": transition}
+}
+
+func statusTarget(mailboxID string) task.Target {
+	return task.Target{
+		Parent:  task.TicketRef{ID: "demo-parent", Key: "demo-parent"},
+		Mailbox: &task.Mailbox{ID: mailboxID, Key: mailboxID, Node: "implement"},
+	}
+}
+
+// endTarget is the parent-only target used for the start and end lifecycle
+// points.
+func endTarget() task.Target {
+	return task.Target{Parent: task.TicketRef{ID: "demo-parent", Key: "demo-parent"}}
+}
+
+func TestApplyTaskConfigOpensMailboxForFirstWorkEntry(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "open"})
+	sys := &system{cli: client}
+
+	if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), transitionConfig("", "in_progress")); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.shown) != 1 || client.shown[0] != "demo-parent.1" {
+		t.Fatalf("show calls = %v, want one mailbox read", client.shown)
+	}
+	if len(client.updates) != 1 || client.updates[0].issueID != "demo-parent.1" || client.updates[0].input.Status != "in_progress" {
+		t.Fatalf("updates = %+v, want open → in_progress", client.updates)
+	}
+}
+
+func TestCompleteMailboxClosesInProgressMailbox(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "in_progress"})
+	sys := &system{cli: client}
+
+	if err := sys.CompleteMailbox(context.Background(), task.Mailbox{ID: "demo-parent.1", Key: "demo-parent.1", Node: "implement"}); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.shown) != 1 || client.shown[0] != "demo-parent.1" {
+		t.Fatalf("show calls = %v, want one mailbox read", client.shown)
+	}
+	if len(client.updates) != 1 || client.updates[0].issueID != "demo-parent.1" || client.updates[0].input.Status != "closed" {
+		t.Fatalf("updates = %+v, want in_progress → closed", client.updates)
+	}
+}
+
+func TestApplyTaskConfigTargetStateRetryDoesNotWrite(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "in_progress"})
+	sys := &system{cli: client}
+
+	if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), transitionConfig("", "in_progress")); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.shown) != 1 || client.shown[0] != "demo-parent.1" {
+		t.Fatalf("show calls = %v, want one target-state read", client.shown)
+	}
+	if len(client.updates) != 0 {
+		t.Fatalf("target-state retry issued an update: %+v", client.updates)
+	}
+}
+
+func TestApplyTaskConfigReopensClosedMailboxOnWorkflowRevisit(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "closed"})
+	sys := &system{cli: client}
+
+	if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), transitionConfig("", "in_progress")); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.shown) != 1 || client.shown[0] != "demo-parent.1" {
+		t.Fatalf("show calls = %v, want one mailbox read", client.shown)
+	}
+	if len(client.updates) != 1 || client.updates[0].issueID != "demo-parent.1" || client.updates[0].input.Status != "in_progress" {
+		t.Fatalf("updates = %+v, want closed → in_progress", client.updates)
+	}
+}
+
+func TestApplyTaskConfigRejectsIncompatibleManualMailboxState(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "blocked"})
+	sys := &system{cli: client}
+
+	err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), transitionConfig("", "in_progress"))
+	if err == nil {
+		t.Fatal("incompatible manual mailbox state was accepted")
+	}
+	if got := retry.Classify(err).Kind; got != retry.Conflict {
+		t.Fatalf("failure kind = %q, want conflict: %v", got, err)
+	}
+	if len(client.updates) != 0 {
+		t.Fatalf("incompatible manual state issued an update: %+v", client.updates)
+	}
+}
+
+// relay-flow only ever drives a parent through open and in_progress, so those
+// are the only states a close may follow. Any other state is human-owned and
+// blocks the transition, exactly like the mailbox rule.
+func TestApplyTaskConfigClosesParentOnlyFromRelayFlowStates(t *testing.T) {
+	for _, tc := range []struct {
+		name       string
+		status     string
+		wantUpdate bool
+		wantConfli bool
+	}{
+		{name: "open", status: "open", wantUpdate: true},
+		{name: "in progress", status: "in_progress", wantUpdate: true},
+		{name: "already closed", status: "closed"},
+		{name: "human blocked", status: "blocked", wantConfli: true},
+		{name: "human deferred", status: "deferred", wantConfli: true},
+		{name: "human hooked", status: "hooked", wantConfli: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			client := newStatusClient(map[string]string{"demo-parent": tc.status})
+			sys := &system{cli: client}
+			target := task.Target{Parent: task.TicketRef{ID: "demo-parent", Key: "demo-parent"}}
+
+			err := sys.ApplyTaskConfig(context.Background(), target, transitionConfig("closed", ""))
+			if tc.wantConfli {
+				if err == nil {
+					t.Fatalf("human-owned parent status %q was overwritten", tc.status)
+				}
+				if got := retry.Classify(err).Kind; got != retry.Conflict {
+					t.Fatalf("failure kind = %q, want conflict: %v", got, err)
+				}
+				if len(client.updates) != 0 {
+					t.Fatalf("human-owned parent status issued an update: %+v", client.updates)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(client.shown) != 1 || client.shown[0] != "demo-parent" {
+				t.Fatalf("show calls = %v, want one parent read", client.shown)
+			}
+			if tc.wantUpdate {
+				if len(client.updates) != 1 || client.updates[0].issueID != "demo-parent" || client.updates[0].input.Status != "closed" {
+					t.Fatalf("updates = %+v, want parent → closed", client.updates)
+				}
+				return
+			}
+			if len(client.updates) != 0 {
+				t.Fatalf("already-target parent issued an update: %+v", client.updates)
+			}
+		})
+	}
+}
+
+// Jira parity: the run start moves the parent to in_progress, and the parent
+// stays visible to the claimed-parent poll because that query includes
+// in_progress.
+func TestStartDefaultsMoveParentInProgress(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent": "open"})
+	sys := &system{cli: client}
+	target := task.Target{Parent: task.TicketRef{ID: "demo-parent", Key: "demo-parent"}}
+
+	if err := sys.ApplyTaskConfig(context.Background(), target, sys.StartDefaults()); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.updates) != 1 || client.updates[0].input.Status != "in_progress" {
+		t.Fatalf("updates = %+v, want parent open → in_progress at start", client.updates)
+	}
+	if got := client.issues["demo-parent"].Status; got != "in_progress" {
+		t.Fatalf("parent status = %q, want in_progress", got)
+	}
+}
+
+// Jira parity: entering a node assigns that node's mailbox to the configured
+// assignee in the same update that moves its status.
+func TestApplyTaskConfigAssignsMailboxToConfiguredAssignee(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "open"})
+	sys := &system{cli: client}
+	cfg := config.Merge(transitionConfig("", "in_progress"), config.RawValues{"assignee": "dev@example.com"})
+
+	if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), cfg); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.shown) != 1 || len(client.updates) != 1 {
+		t.Fatalf("calls = show:%v updates:%+v, want one read and one write", client.shown, client.updates)
+	}
+	update := client.updates[0].input
+	if update.Status != "in_progress" || update.Assignee != "dev@example.com" {
+		t.Fatalf("update = %+v, want status and assignee in one call", update)
+	}
+}
+
+func TestApplyTaskConfigAssigneeIsIdempotentAndStandalone(t *testing.T) {
+	t.Run("already assigned at target status", func(t *testing.T) {
+		client := newStatusClient(map[string]string{"demo-parent.1": "in_progress"})
+		client.issues["demo-parent.1"] = bdcli.Issue{ID: "demo-parent.1", Status: "in_progress", Assignee: "dev@example.com"}
+		sys := &system{cli: client}
+		cfg := config.Merge(transitionConfig("", "in_progress"), config.RawValues{"assignee": "dev@example.com"})
+
+		if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), cfg); err != nil {
+			t.Fatal(err)
+		}
+		if len(client.updates) != 0 {
+			t.Fatalf("retried assignment issued an update: %+v", client.updates)
+		}
+	})
+
+	t.Run("assignee without a transition", func(t *testing.T) {
+		client := newStatusClient(map[string]string{"demo-parent.1": "in_progress"})
+		sys := &system{cli: client}
+
+		if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"),
+			config.RawValues{"assignee": "dev@example.com"}); err != nil {
+			t.Fatal(err)
+		}
+		if len(client.updates) != 1 || client.updates[0].input.Status != "" ||
+			client.updates[0].input.Assignee != "dev@example.com" {
+			t.Fatalf("updates = %+v, want an assignee-only update", client.updates)
+		}
+	})
+}