relay-flow 0.2.4-alpha → 0.2.6-alpha

package/internal/execution/goworkflows/activities.go

@@ -44,6 +44,21 @@ func (a *Activities) runSpec(w run.Work) runner.RunSpec {
 	}
 }
 
+// agentEnv returns the repo task system's agent workspace environment, or nil
+// when the adapter exposes none. It is resolved at launch time so no workspace
+// value is carried in durable workflow history.
+func (a *Activities) agentEnv(repoName string) (map[string]string, error) {
+	sys, err := a.taskSystem(repoName)
+	if err != nil {
+		return nil, err
+	}
+	provider, ok := sys.(task.AgentEnvironment)
+	if !ok {
+		return nil, nil
+	}
+	return provider.AgentEnv(), nil
+}
+
 // EnsureMailboxes ensures one mailbox per work node and returns the
 // node-to-mailbox map.
 func (a *Activities) EnsureMailboxes(ctx context.Context, w run.Work, specs []task.MailboxSpec) (map[string]task.Mailbox, error) {
@@ -220,6 +235,10 @@ func (a *Activities) EnsureNodeRuntime(ctx context.Context, nw run.NodeWork, rep
 	if err != nil {
 		return err
 	}
+	spec.TaskEnv, err = a.agentEnv(nw.Repo)
+	if err != nil {
+		return err
+	}
 	cmd, err := a.Harness.BuildCommand(spec)
 	if err != nil {
 		return err

package/internal/execution/goworkflows/engine.go

@@ -23,6 +23,7 @@ import (
 	goworkflow "github.com/cschleiden/go-workflows/workflow"
 	"github.com/google/uuid"
 
+	"github.com/rajpopat27/relay-flow/internal/execution/projection"
 	"github.com/rajpopat27/relay-flow/internal/harness"
 	"github.com/rajpopat27/relay-flow/internal/identity"
 	"github.com/rajpopat27/relay-flow/internal/repo"
@@ -68,46 +69,13 @@ type Engine struct {
 	workerName   string
 }
 
-// InitDatabase creates the SQLite database at path (mode 0600) with the
-// relay_runs projection schema and closes it. Used by `relay-flow init`;
-// serve uses New to open the full engine.
-func InitDatabase(path string) error {
-	db, err := sql.Open("sqlite", fmt.Sprintf("file:%s?_txlock=immediate", path))
-	if err != nil {
-		return fmt.Errorf("open %s: %w", path, err)
-	}
-	defer db.Close()
-	if _, err := db.Exec(`PRAGMA schema_version`); err != nil {
-		return fmt.Errorf("open %s: %w", path, err)
-	}
-	if _, err := db.Exec("PRAGMA journal_mode=WAL;"); err != nil {
-		return fmt.Errorf("open %s: %w", path, err)
-	}
-	if err := os.Chmod(path, 0o600); err != nil && !os.IsNotExist(err) {
-		return fmt.Errorf("chmod %s: %w", path, err)
-	}
-	proj := &RunProjection{DB: db}
-	if err := proj.migrate(); err != nil {
-		return fmt.Errorf("migrate relay_runs: %w", err)
-	}
-	return nil
-}
+// InitDatabase preserves the embedded-engine public helper while delegating
+// relay-owned schema lifecycle to the shared projection package.
+func InitDatabase(path string) error { return projection.InitDatabase(path) }
 
-// HasNonterminalRuns inspects an existing database without migrating or
-// otherwise modifying it. It is used by init --force before config changes.
+// HasNonterminalRuns inspects the shared projection without migrating it.
 func HasNonterminalRuns(path string) (bool, error) {
-	db, err := sql.Open("sqlite", fmt.Sprintf("file:%s?mode=ro", path))
-	if err != nil {
-		return false, fmt.Errorf("open %s: %w", path, err)
-	}
-	defer db.Close()
-	var active bool
-	if err := db.QueryRow(`SELECT EXISTS(
-		SELECT 1 FROM relay_runs WHERE state NOT IN ('completed', 'canceled')
-	)`).Scan(&active); err != nil {
-		return false, fmt.Errorf("inspect %s: %w", path, err)
-	}
-	return active, nil
+	return projection.HasNonterminalRuns(path)
 }
 
 // New opens the SQLite database at path (created with mode 0600 when
@@ -148,6 +116,13 @@ func New(path string, deps Dependencies) (*Engine, error) {
 		db.Close()
 		return nil, fmt.Errorf("migrate relay_runs: %w", err)
 	}
+	// A marker-less legacy database is adopted only by the embedded executor;
+	// a persisted Temporal identity fails closed rather than being combined
+	// with go-workflows state.
+	if err := (&projection.RunProjection{DB: db}).VerifyIdentity(context.Background(), projection.ExecutorIdentity{ExecutorPlugin: "goworkflows"}); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("verify executor identity: %w", err)
+	}
 	activities := &Activities{
 		Repos:      deps.Repos,
 		Runner:     deps.Runner,

package/internal/execution/goworkflows/engine_test.go

@@ -71,7 +71,7 @@ func TestMailboxDescriptionAndLaunchPromptAreTaskSystemNeutral(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		want := "Task system: " + taskSystem + "\nUse the " + taskSystem + " tools to read the parent ticket PAY-101.\n\nYour mailbox is PAY-234. Read its description and comments for node instructions and feedback.\n\nReturn the complete report directly. Relay-flow will show a native TUI approval dialog after the report is valid. Do not use OpenCode's Question tool for relay-flow approval."
+		want := "Task system: " + taskSystem + "\nUse the " + taskSystem + " tools to read the parent ticket PAY-101.\n\nYour mailbox is PAY-234. Read its description and comments for node instructions and feedback.\n\nKeep the summary brief, and make the feedback as detailed and actionable as possible for the next agent.\n\nReturn the complete report directly. Relay-flow will show a native TUI approval dialog after the report is valid. Do not use OpenCode's Question tool for relay-flow approval."
 		if prompt != want {
 			t.Fatalf("RenderPrompt(%s) = %q, want %q", taskSystem, prompt, want)
 		}

package/internal/execution/goworkflows/node_runtime_test.go

@@ -9,6 +9,7 @@ import (
 	"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/run"
@@ -210,7 +211,7 @@ func TestEnsureNodeRuntimeUsesDirectIDsAndFallsBackFresh(t *testing.T) {
 	}); err != nil {
 		t.Fatal(err)
 	}
-	a := &Activities{Runner: fr, Harness: fh, Runs: p}
+	a := &Activities{Repos: runtimeTestRepos(&runtimeTestTaskSystem{}), Runner: fr, Harness: fh, Runs: p}
 	nw := run.NodeWork{Work: run.Work{RunID: id, Repo: "payments", Workflow: "basic", Parent: task.TicketRef{Key: "PAY-101"}}, Node: "implement", NodeVisitID: "visit-2"}
 	spec := harness.LaunchSpec{RunID: id, NodeVisitID: "visit-2", RepoName: "payments", Workflow: "basic", Ticket: "PAY-101", Node: "implement", Agent: "build", Title: "PAY-101:implement", Prompt: "work", NudgePrompt: "custom instructions"}
 	if err := a.EnsureNodeRuntime(ctx, nw, "/srv/payments", spec, NodeRuntime{NodeVisitID: "visit-2"}); err != nil {
@@ -259,8 +260,8 @@ func TestEnsureNodeRuntimeInitialLaunchAppendsCustomInstructions(t *testing.T) {
 	}
 	fh := &runtimeTestHarness{}
 	fr := &runtimeTestRunner{}
-	a := &Activities{Runner: fr, Harness: fh, Runs: p}
-	nw := run.NodeWork{Work: run.Work{RunID: id}, Node: "implement", NodeVisitID: "visit-first"}
+	a := &Activities{Repos: runtimeTestRepos(&runtimeTestTaskSystem{}), Runner: fr, Harness: fh, Runs: p}
+	nw := run.NodeWork{Work: run.Work{RunID: id, Repo: "payments"}, Node: "implement", NodeVisitID: "visit-first"}
 	spec := harness.LaunchSpec{RunID: id, NodeVisitID: "visit-first", Node: "implement", NodeType: workflow.NodeHITL, Agent: "build", Prompt: "standard prompt", NudgePrompt: "custom instructions"}
 	if err := a.EnsureNodeRuntime(ctx, nw, "", spec, NodeRuntime{}); err != nil {
 		t.Fatal(err)
@@ -273,6 +274,63 @@ func TestEnsureNodeRuntimeInitialLaunchAppendsCustomInstructions(t *testing.T) {
 	}
 }
 
+// TestEnsureNodeRuntimeSuppliesTaskSystemAgentEnv asserts the repo's task
+// system supplies the agent workspace environment at launch time, so the
+// harness/runner command addresses the same workspace as relay-flow. Adapters
+// without the optional capability supply nothing.
+func TestEnsureNodeRuntimeSuppliesTaskSystemAgentEnv(t *testing.T) {
+	ctx := context.Background()
+	db := openProjectionDB(t, filepath.Join(t.TempDir(), "state.db"))
+	defer db.Close()
+	p := &RunProjection{DB: db}
+	if err := p.migrate(); err != nil {
+		t.Fatal(err)
+	}
+	id := run.ID("payments/basic/PAY-105")
+	if err := p.insertStart(ctx, run.Start{ID: id, Repo: "payments", Workflow: workflow.Workflow{Name: "basic"}, Ticket: task.TicketRef{ID: "5", Key: "PAY-105"}}, time.Now().UTC()); err != nil {
+		t.Fatal(err)
+	}
+	if err := p.updateNodeRuntimeVisit(ctx, id, "implement", "visit-first"); err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]string{"BEADS_DIR": "/var/lib/beads/payments/.beads", "BEADS_DB": "", "BD_DB": ""}
+	fh := &runtimeTestHarness{}
+	a := &Activities{
+		Repos:   runtimeTestRepos(&runtimeTestTaskSystem{agentEnv: want}),
+		Runner:  &runtimeTestRunner{},
+		Harness: fh,
+		Runs:    p,
+	}
+	nw := run.NodeWork{Work: run.Work{RunID: id, Repo: "payments", Workflow: "basic", Parent: task.TicketRef{Key: "PAY-105"}}, Node: "implement", NodeVisitID: "visit-first"}
+	spec := harness.LaunchSpec{RunID: id, NodeVisitID: "visit-first", RepoName: "payments", Node: "implement", Agent: "build", Title: "PAY-105:implement"}
+	if err := a.EnsureNodeRuntime(ctx, nw, "/srv/payments", spec, NodeRuntime{}); err != nil {
+		t.Fatal(err)
+	}
+	if len(fh.taskEnvs) != 1 || !reflect.DeepEqual(fh.taskEnvs[0], want) {
+		t.Fatalf("launch TaskEnv = %#v, want [%#v]", fh.taskEnvs, want)
+	}
+
+	// An adapter without the optional capability supplies no environment.
+	plain := &runtimeTestHarness{}
+	b := &Activities{
+		Repos:   runtimeTestRepos(&runtimeTestPlainTaskSystem{System: &runtimeTestTaskSystem{}}),
+		Runner:  &runtimeTestRunner{},
+		Harness: plain,
+		Runs:    p,
+	}
+	if err := p.updateNodeRuntimeVisit(ctx, id, "review", "visit-review"); err != nil {
+		t.Fatal(err)
+	}
+	nw.Node, nw.NodeVisitID = "review", "visit-review"
+	spec.Node, spec.NodeVisitID, spec.Title = "review", "visit-review", "PAY-105:review"
+	if err := b.EnsureNodeRuntime(ctx, nw, "/srv/payments", spec, NodeRuntime{}); err != nil {
+		t.Fatal(err)
+	}
+	if len(plain.taskEnvs) != 1 || plain.taskEnvs[0] != nil {
+		t.Fatalf("TaskEnv without a configured workspace = %#v, want [nil]", plain.taskEnvs)
+	}
+}
+
 func TestEnsureNodeRuntimeSendFailureClosesLiveTerminal(t *testing.T) {
 	ctx := context.Background()
 	db := openProjectionDB(t, filepath.Join(t.TempDir(), "state.db"))
@@ -293,7 +351,7 @@ func TestEnsureNodeRuntimeSendFailureClosesLiveTerminal(t *testing.T) {
 	}
 	fr := &runtimeTestRunner{live: true, sendErr: errors.New("send failed")}
 	fh := &runtimeTestHarness{}
-	a := &Activities{Runner: fr, Harness: fh, Runs: p}
+	a := &Activities{Repos: runtimeTestRepos(&runtimeTestTaskSystem{}), Runner: fr, Harness: fh, Runs: p}
 	nw := run.NodeWork{Work: run.Work{RunID: id, Repo: "payments", Workflow: "basic", Parent: task.TicketRef{Key: "PAY-102"}}, Node: "implement", NodeVisitID: "visit-new", Mailbox: task.Mailbox{Key: "PAY-234", Node: "implement"}}
 	spec := harness.LaunchSpec{RunID: id, NodeVisitID: "visit-new", Node: "implement", Agent: "build", Title: "PAY-102:implement", Prompt: "work", NudgePrompt: "Read the latest review feedback."}
 	if err := a.EnsureNodeRuntime(ctx, nw, "/srv/payments", spec, NodeRuntime{RunID: id, Node: "implement", TerminalID: "live-old", SessionID: "session-old", NodeVisitID: "visit-old"}); err != nil {
@@ -499,6 +557,7 @@ type runtimeTestHarness struct {
 	prompts    []string
 	resumeIDs  []string
 	rendered   []harness.PromptKind
+	taskEnvs   []map[string]string
 }
 
 func (h *runtimeTestHarness) RenderPrompt(kind harness.PromptKind, _ harness.PromptData, nudge string) (string, error) {
@@ -522,9 +581,59 @@ func (h *runtimeTestHarness) BuildCommand(spec harness.LaunchSpec) (runner.Comma
 	h.buildCalls++
 	h.prompts = append(h.prompts, spec.Prompt)
 	h.resumeIDs = append(h.resumeIDs, spec.ResumeID)
+	h.taskEnvs = append(h.taskEnvs, spec.TaskEnv)
 	return runner.Command{Executable: "opencode", Args: []string{spec.ResumeID}}, nil
 }
 
+// runtimeTestTaskSystem is a repo-bound task system stub. Only the optional
+// task.AgentEnvironment capability is exercised here; every other method is an
+// unused stub for the node runtime tests.
+type runtimeTestTaskSystem struct {
+	agentEnv map[string]string
+}
+
+func (s *runtimeTestTaskSystem) AgentEnv() map[string]string { return s.agentEnv }
+
+func (*runtimeTestTaskSystem) Poll(context.Context) ([]task.Ticket, error) { return nil, nil }
+func (*runtimeTestTaskSystem) CompileFilter(config.RawValues) (func(task.Ticket) bool, error) {
+	return func(task.Ticket) bool { return true }, nil
+}
+func (*runtimeTestTaskSystem) Claim(context.Context, task.TicketRef, string) error { return nil }
+func (*runtimeTestTaskSystem) ValidateConfig(context.Context, config.RawValues, map[string]config.RawValues) error {
+	return nil
+}
+func (*runtimeTestTaskSystem) RenderText(task.TextKind, task.TextData) (string, error) {
+	return "", nil
+}
+func (*runtimeTestTaskSystem) EnsureMailboxes(context.Context, task.TicketRef, string, []task.MailboxSpec) (map[string]task.Mailbox, error) {
+	return map[string]task.Mailbox{}, nil
+}
+func (*runtimeTestTaskSystem) ApplyTaskConfig(context.Context, task.Target, config.RawValues) error {
+	return nil
+}
+func (*runtimeTestTaskSystem) CompleteMailbox(context.Context, task.Mailbox) error { return nil }
+func (*runtimeTestTaskSystem) HasComment(context.Context, task.Target, string) (bool, error) {
+	return false, nil
+}
+func (*runtimeTestTaskSystem) Comment(context.Context, task.Target, string, string) error {
+	return nil
+}
+func (*runtimeTestTaskSystem) ResetForRecovery(context.Context, task.TicketRef, []task.Mailbox, config.RawValues) error {
+	return nil
+}
+
+// runtimeTestPlainTaskSystem forwards the task.System contract without
+// exposing the optional AgentEnvironment capability.
+type runtimeTestPlainTaskSystem struct {
+	task.System
+}
+
+func runtimeTestRepos(sys task.System) *repo.Registry {
+	reg := &repo.Registry{}
+	reg.Replace(&repo.Repo{Name: "payments", Path: "/srv/payments", TaskSystem: sys})
+	return reg
+}
+
 func openProjectionDB(t *testing.T, path string) *sql.DB {
 	t.Helper()
 	db, err := sql.Open("sqlite", path)