relay-flow 0.2.0-alpha → 0.2.2-alpha

package/internal/config/merge_test.go

@@ -49,6 +49,24 @@ func TestMergeMapsRecursively(t *testing.T) {
 	}
 }
 
+func TestMergeRawValuesMapsRecursively(t *testing.T) {
+	defaults := config.RawValues{"templates": map[string]any{
+		"mailboxDescription": "default mailbox",
+		"summaryComment":     "default summary",
+	}}
+	override := config.RawValues{"templates": config.RawValues{
+		"mailboxDescription": "custom mailbox",
+	}}
+	got := config.Merge(defaults, override)
+	templates, ok := got["templates"].(map[string]any)
+	if !ok {
+		t.Fatalf("templates = %#v", got["templates"])
+	}
+	if templates["mailboxDescription"] != "custom mailbox" || templates["summaryComment"] != "default summary" {
+		t.Fatalf("templates = %#v", templates)
+	}
+}
+
 func TestMergeListReplaces(t *testing.T) {
 	root := config.RawValues{"labels": []any{"a", "b"}}
 	wf := config.RawValues{"labels": []any{"c"}}

package/internal/execution/goworkflows/activities.go

@@ -2,7 +2,6 @@ package goworkflows
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"log/slog"
 	"sort"
@@ -21,10 +20,11 @@ import (
 // Activities holds the replaceable dependencies shared by every durable
 // activity. One Activities value is registered with the activity worker.
 type Activities struct {
-	Repos   *repo.Registry
-	Runner  runner.Runner
-	Harness harness.Harness
-	Runs    *RunProjection
+	Repos      *repo.Registry
+	Runner     runner.Runner
+	Harness    harness.Harness
+	TaskSystem string
+	Runs       *RunProjection
 }
 
 func (a *Activities) taskSystem(repoName string) (task.System, error) {
@@ -51,6 +51,16 @@ func (a *Activities) EnsureMailboxes(ctx context.Context, w run.Work, specs []ta
 	if err != nil {
 		return nil, err
 	}
+	for i := range specs {
+		data := specs[i].TextData
+		data.RunID = string(w.RunID)
+		data.Repo = w.Repo
+		custom, err := sys.RenderText(task.TextMailboxDescription, data)
+		if err != nil {
+			return nil, fmt.Errorf("render mailbox %q description: %w", specs[i].Node, err)
+		}
+		specs[i].Description = appendText(custom, specs[i].Description)
+	}
 	return sys.EnsureMailboxes(ctx, w.Parent, w.Workflow, specs)
 }
 
@@ -97,13 +107,23 @@ func (a *Activities) EnsureEnvironment(ctx context.Context, w run.Work, repoPath
 	return a.Runner.EnsureEnvironment(ctx, spec)
 }
 
+func (a *Activities) SetEnvironmentStatus(ctx context.Context, w run.Work, repoPath, status string) error {
+	spec := a.runSpec(w)
+	spec.RepoPath = repoPath
+	env, err := a.Runner.EnsureEnvironment(ctx, spec)
+	if err != nil {
+		return err
+	}
+	return a.Runner.SetEnvironmentStatus(ctx, env, status)
+}
+
 func (a *Activities) LoadNodeRuntime(ctx context.Context, id run.ID, node string) (NodeRuntime, error) {
 	return a.Runs.loadNodeRuntime(ctx, id, node)
 }
 
 // EnsureNodeRuntime uses only persisted terminal/session IDs on the normal
-// path. A live terminal is rebound to the new visit; otherwise a fresh
-// terminal is created and its direct IDs atomically replace the old binding.
+// path. A live terminal is rebound to the new visit; otherwise EnsureTerminal
+// creates a replacement and its direct ID is persisted immediately.
 func (a *Activities) EnsureNodeRuntime(ctx context.Context, nw run.NodeWork, repoPath string, spec harness.LaunchSpec, rt NodeRuntime) error {
 	a.Runs.runtimeMu.Lock()
 	defer a.Runs.runtimeMu.Unlock()
@@ -124,81 +144,78 @@ func (a *Activities) EnsureNodeRuntime(ctx context.Context, nw run.NodeWork, rep
 	if err != nil {
 		return err
 	}
-	hadRuntime := currentRuntime.TerminalID != "" || currentRuntime.SessionID != ""
+	rs := a.runSpec(nw.Work)
+	rs.RepoPath = repoPath
+	env, err := a.Runner.EnsureEnvironment(ctx, rs)
+	if err != nil {
+		return err
+	}
+	status := runner.WorkspaceStatusInProgress
+	if spec.NodeType == workflow.NodeHITL {
+		status = runner.WorkspaceStatusInReview
+	}
+	if err := a.Runner.SetEnvironmentStatus(ctx, env, status); err != nil {
+		return err
+	}
 	// IDs come from the guarded current row; the activity input's prior visit
 	// is used only to decide whether a live process needs rebinding.
 	rt.TerminalID = currentRuntime.TerminalID
 	rt.SessionID = currentRuntime.SessionID
-	freshSession := false
-	if rt.TerminalID != "" {
-		terminal := runner.Terminal{ID: rt.TerminalID, Title: spec.Title}
-		_, ok, inspectErr := a.Runner.InspectTerminal(ctx, terminal)
-		if inspectErr != nil {
-			return inspectErr
+	spec.ResumeID = rt.SessionID
+	stored := runner.Terminal{ID: rt.TerminalID, Title: spec.Title}
+	terminal, live, err := a.Runner.FindTerminal(ctx, stored)
+	if err != nil {
+		return err
+	}
+	if live {
+		if err := a.Runs.replaceNodeRuntime(ctx, nw.RunID, nw.Node, nw.NodeVisitID,
+			terminal.ID, rt.SessionID, rt.SessionID); err != nil {
+			return err
 		}
-		if ok {
-			// Same-visit retry/restart leaves the running turn untouched. A
-			// revisit sends only the new work prompt to the retained session.
-			if !revisit {
-				return a.Runs.replaceNodeRuntime(ctx, nw.RunID, nw.Node, nw.NodeVisitID,
-					rt.TerminalID, rt.SessionID, rt.SessionID)
-			}
-			prompt := followUpPrompt(nw.Mailbox.Key)
-			if spec.NudgePrompt != "" {
-				prompt += "\n\n" + spec.NudgePrompt
-			}
-			if err := a.Runner.SendTerminal(ctx, terminal, prompt); err == nil {
-				return a.Runs.replaceNodeRuntime(ctx, nw.RunID, nw.Node, nw.NodeVisitID,
-					rt.TerminalID, rt.SessionID, rt.SessionID)
-			}
-			// Direct use failed. Close the known live terminal before replacing
-			// it so a second agent process cannot be left running.
-			if err := a.Runner.CloseTerminal(ctx, terminal); err != nil {
-				return err
-			}
-			freshSession = true
+		if !revisit {
+			// Same-visit retry/restart is silent: do not render, build, or send.
+			return nil
+		}
+		prompt, err := a.Harness.RenderPrompt(harness.PromptFeedback, spec.PromptData, spec.NudgePrompt)
+		if err != nil {
+			return err
+		}
+		if err := a.Runner.SendTerminal(ctx, terminal, prompt); err == nil {
+			return nil
+		}
+		// Direct use failed. Close the known live terminal before replacing it
+		// so a second agent process cannot be left running.
+		if err := a.Runner.CloseTerminal(ctx, terminal); err != nil {
+			return err
 		}
 	}
 
-	if rt.SessionID != "" && !freshSession {
-		spec.ResumeID = rt.SessionID
+	// An initial or replacement terminal resumes the stored session and
+	// receives the rendered initial prompt. Same-visit replacements omit the
+	// node nudge; a new visit includes it.
+	nudge := ""
+	if rt.NodeVisitID == "" || revisit {
+		nudge = spec.NudgePrompt
 	}
-	// Custom instructions belong to a node entry, not same-visit recovery.
-	if !hadRuntime || revisit {
-		spec.Prompt = appendPrompt(spec.Prompt, spec.NudgePrompt)
-	}
-	cmd, err := a.Harness.BuildCommand(spec)
+	spec.Prompt, err = a.Harness.RenderPrompt(harness.PromptInitial, spec.PromptData, nudge)
 	if err != nil {
 		return err
 	}
-	rs := a.runSpec(nw.Work)
-	rs.RepoPath = repoPath
-	env, err := a.Runner.EnsureEnvironment(ctx, rs)
+	cmd, err := a.Harness.BuildCommand(spec)
 	if err != nil {
 		return err
 	}
-	terminal, err := a.Runner.CreateTerminal(ctx, env, spec.Title, cmd)
-	sessionID := rt.SessionID
-	if errors.Is(err, runner.ErrSessionUnavailable) && rt.SessionID != "" {
-		spec.ResumeID = ""
-		cmd, buildErr := a.Harness.BuildCommand(spec)
-		if buildErr != nil {
-			return buildErr
-		}
-		terminal, err = a.Runner.CreateTerminal(ctx, env, spec.Title, cmd)
-		sessionID = ""
-	}
-	if freshSession {
-		sessionID = ""
-	}
+	replacement, err := a.Runner.EnsureTerminal(ctx, env, stored, spec.Title, cmd)
 	if err != nil {
 		return err
 	}
+	// Persist a newly created/replacement handle before any later external
+	// effect. Runtime session registration may update SessionID independently.
 	if err := a.Runs.replaceNodeRuntime(ctx, nw.RunID, nw.Node, nw.NodeVisitID,
-		terminal.ID, rt.SessionID, sessionID); err != nil {
-		// The visit changed after terminal creation. Close the terminal whose
-		// binding was rejected so stale work cannot leak or report.
-		_ = a.Runner.CloseTerminal(ctx, terminal)
+		replacement.ID, rt.SessionID, rt.SessionID); err != nil {
+		if replacement.ID != rt.TerminalID {
+			_ = a.Runner.CloseTerminal(ctx, replacement)
+		}
 		return err
 	}
 	return nil
@@ -274,7 +291,14 @@ func (a *Activities) Comment(ctx context.Context, repoName string, cw run.Commen
 	if err != nil {
 		return err
 	}
-	if err := sys.Comment(ctx, cw.Item, cw.Body, cw.Marker); err != nil {
+	body := cw.Body
+	if cw.TextKind != "" {
+		body, err = sys.RenderText(cw.TextKind, cw.TextData)
+		if err != nil {
+			return fmt.Errorf("render %s: %w", cw.TextKind, err)
+		}
+	}
+	if err := sys.Comment(ctx, cw.Item, body, cw.Marker); err != nil {
 		return err
 	}
 	// Log AFTER the write succeeds so the line is a true effect record.
@@ -393,19 +417,7 @@ func (a *Activities) ProjectionUpdateRetry(ctx context.Context, id run.ID, statu
 // description, and every legal route with its when explanation.
 func MailboxSpecForNode(wf *workflow.Workflow, ticketKey, name string, n workflow.Node) task.MailboxSpec {
 	var b strings.Builder
-	fmt.Fprintf(&b, "Parent Jira ticket: %s\nNode: %s\nType: %s\nAgent: %s\n\nWork:\n%s\n\nRead this subtask's comments for feedback from previous nodes.",
-		ticketKey, name, n.Type, n.Agent, n.Description)
-	if n.Type == workflow.NodeHITL {
-		b.WriteString(`
-
-1. Discuss the task with the human, request the PR link or any missing context, and review the changes. Do not make code changes.
-2. Resolve questions and requested review updates through normal conversation until the human is satisfied with the review.
-3. Present the complete report through OpenCode's Question tool with exactly two options: Approve and Reject.
-4. If approved, output the report verbatim. If rejected, return to step 1.`)
-	}
-	b.WriteString(`
-
-Required report format:
+	b.WriteString(`Required report format:
 
 STATUS: success | failure
 NEXT STEP: <one valid node name>
@@ -424,7 +436,9 @@ REQUIRED ACTIONS:
 RELEVANT CONTEXT:
 EXPECTED RESULT:
 
-Every field is required; use None for an intentionally empty section. COMMITS must contain the relevant commit IDs or None. NEXT STEP must name exactly one target listed below for your status. When NEXT STEP is end, every FEEDBACK field must be None.`)
+Every field is required; use None for an intentionally empty section. COMMITS must contain the relevant commit IDs or None.
+
+Node names identify workflow stages; they are not task-system statuses. STATUS describes whether the work at this node succeeded or failed, not the status of the parent or mailbox. NEXT STEP must name exactly one target listed below for that STATUS. Submit one report only: its SUMMARY is written to this current mailbox, while its FEEDBACK is written only to the selected next node's mailbox. For review nodes, put requested changes in FEEDBACK and select the node responsible for acting on them. Relay-flow and the task system own parent and mailbox status changes. When NEXT STEP is end, every FEEDBACK field must be None.`)
 	writeRoutes := func(label string, routes []workflow.Route) {
 		if len(routes) == 0 {
 			return
@@ -440,11 +454,20 @@ Every field is required; use None for an intentionally empty section. COMMITS mu
 	}
 	writeRoutes("On success", n.OnSuccess)
 	writeRoutes("On failure", n.OnFailure)
+	successRoutes := routesText(n.OnSuccess)
+	failureRoutes := routesText(n.OnFailure)
 	return task.MailboxSpec{
 		Node:        name,
 		Title:       ticketKey + ":" + name,
 		Description: b.String(),
 		TaskConfig:  n.TaskConfig,
+		TextData: task.TextData{
+			Ticket: ticketKey, Workflow: wf.Name, Node: name, NodeType: string(n.Type),
+			Agent: n.Agent, NodeDescription: n.Description,
+			NextSteps:     nextStepsText(append(append([]workflow.Route{}, n.OnSuccess...), n.OnFailure...)),
+			SuccessRoutes: successRoutes, FailureRoutes: failureRoutes,
+			Mailbox: ticketKey + ":" + name,
+		},
 	}
 }
 
@@ -464,20 +487,46 @@ func MailboxSpecs(wf *workflow.Workflow, ticketKey string) []task.MailboxSpec {
 	return out
 }
 
-// BuildLaunchSpecPrompt points the agent to its parent and isolated mailbox.
-func BuildLaunchSpecPrompt(ticketKey, mailboxKey string) string {
-	return fmt.Sprintf("Read parent Jira ticket %s for the original task context.\n\nYour Jira mailbox subtask is %s. Read only its description and comments for your node instructions and feedback.", ticketKey, mailboxKey)
+// RenderMailboxSpecs asks the selected task system to render customizable
+// mailbox text, then appends the fixed report contract and legal routes.
+// It is shared by normal execution and explicit database-loss recovery.
+func RenderMailboxSpecs(sys task.System, w run.Work, wf *workflow.Workflow) ([]task.MailboxSpec, error) {
+	specs := MailboxSpecs(wf, w.Parent.Key)
+	for i := range specs {
+		data := specs[i].TextData
+		data.RunID = string(w.RunID)
+		data.Repo = w.Repo
+		custom, err := sys.RenderText(task.TextMailboxDescription, data)
+		if err != nil {
+			return nil, fmt.Errorf("render mailbox %q description: %w", specs[i].Node, err)
+		}
+		specs[i].Description = appendText(custom, specs[i].Description)
+	}
+	return specs, nil
 }
 
-func followUpPrompt(mailboxKey string) string {
-	return fmt.Sprintf("New feedback was added to the comments section of your mailbox subtask %s. Read it.", mailboxKey)
+func routesText(routes []workflow.Route) string {
+	var b strings.Builder
+	for i, route := range routes {
+		if i > 0 {
+			b.WriteString("\n")
+		}
+		b.WriteString(route.Target)
+		if route.When != "" {
+			b.WriteString(" — when: " + route.When)
+		}
+	}
+	return b.String()
 }
 
-func appendPrompt(prompt, extra string) string {
-	if extra == "" {
-		return prompt
+func appendText(first, second string) string {
+	if first == "" {
+		return second
+	}
+	if second == "" {
+		return first
 	}
-	return prompt + "\n\n" + extra
+	return first + "\n\n" + second
 }
 
 // mergeTaskConfig overlays node task config onto workflow task config using

package/internal/execution/goworkflows/end_feedback_test.go

@@ -0,0 +1,124 @@
+package goworkflows_test
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/rajpopat27/relay-flow/internal/execution/goworkflows"
+	"github.com/rajpopat27/relay-flow/internal/identity"
+	"github.com/rajpopat27/relay-flow/internal/run"
+	"github.com/rajpopat27/relay-flow/internal/task"
+	"github.com/rajpopat27/relay-flow/internal/workflow"
+)
+
+func TestEndSelectionSkipsFeedbackCommentActivity(t *testing.T) {
+	log := newEventLog()
+	sys := newFakeTaskSystem(log)
+	engine := newEndFeedbackTestEngine(t, sys)
+	wf := workflow.Workflow{
+		Name:  "endFeedback",
+		Repos: []string{"payments"},
+		Nodes: map[string]workflow.Node{
+			"start": {OnSuccess: []workflow.Route{{Target: "implement"}}},
+			"implement": {
+				Type: workflow.NodeAgent, Agent: "build", Description: "implement",
+				OnSuccess: []workflow.Route{{Target: "end"}},
+				OnFailure: []workflow.Route{{Target: "implement"}},
+			},
+			"end": {},
+		},
+	}
+	rid := identity.NewRunID("payments", wf.Name, "PAY-101")
+	if _, err := engine.EnsureRun(context.Background(), run.Start{
+		ID: rid, Repo: "payments", RepoPath: "/srv/payments", Workflow: wf,
+		Ticket: task.TicketRef{ID: "demo-parent", Key: "demo-parent", Title: "parent"},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	waitForEndFeedbackTest(t, engine, rid, func(r run.Run) bool {
+		return r.CurrentNode == "implement"
+	})
+
+	if _, err := engine.SubmitReport(context.Background(), run.ReportRequest{
+		RunID: rid, Node: "implement", ReportID: "end-feedback-test",
+		Report: endFeedbackSuccessReport(),
+	}); err != nil {
+		t.Fatal(err)
+	}
+	waitForEndFeedbackTest(t, engine, rid, func(r run.Run) bool {
+		return r.State == run.StateCompleted
+	})
+
+	events := log.all()
+	if !hasEvent(events, "comment:demo-parent-implement") {
+		t.Fatalf("current summary comment missing: %v", events)
+	}
+	if countEvent(events, "comment:demo-parent-implement") != 1 {
+		t.Fatalf("summary comment count = %d; events=%v", countEvent(events, "comment:demo-parent-implement"), events)
+	}
+	if hasEventPrefixExcept(events, "comment:", "comment:demo-parent-implement") {
+		t.Fatalf("end selection wrote feedback comment; events=%v", events)
+	}
+}
+
+func endFeedbackSuccessReport() workflow.Report {
+	none := "None"
+	return workflow.Report{
+		Status: workflow.OutcomeSuccess, NextStep: "end",
+		Summary: workflow.Summary{
+			Completed: "done", Commits: "abc123", NotCompleted: none,
+			IssuesDiscovered: none, Verification: "tested", Notes: none,
+		},
+		Feedback: workflow.Feedback{
+			ReasonForNextStep: none, RequiredActions: none,
+			RelevantContext: none, ExpectedResult: none,
+		},
+	}
+}
+
+func newEndFeedbackTestEngine(t *testing.T, sys task.System) *goworkflows.Engine {
+	t.Helper()
+	return newEngine(t, goworkflows.Dependencies{
+		Repos:   repoRegistryWith("payments", sys),
+		Runner:  newFakeRunner(newEventLog()),
+		Harness: newFakeHarness(newEventLog()),
+	})
+}
+
+func waitForEndFeedbackTest(t *testing.T, engine *goworkflows.Engine, id run.ID, predicate func(run.Run) bool) {
+	t.Helper()
+	waitFor(t, 10*time.Second, func() bool {
+		r, err := engine.GetRun(context.Background(), id)
+		return err == nil && predicate(r)
+	})
+}
+
+func hasEvent(events []string, want string) bool {
+	for _, event := range events {
+		if event == want {
+			return true
+		}
+	}
+	return false
+}
+
+func countEvent(events []string, want string) int {
+	count := 0
+	for _, event := range events {
+		if event == want {
+			count++
+		}
+	}
+	return count
+}
+
+func hasEventPrefixExcept(events []string, prefix, allowed string) bool {
+	for _, event := range events {
+		if strings.HasPrefix(event, prefix) && event != allowed {
+			return true
+		}
+	}
+	return false
+}

package/internal/execution/goworkflows/engine.go

@@ -32,9 +32,10 @@ import (
 
 // Dependencies carries the replaceable boundaries used by activities.
 type Dependencies struct {
-	Repos   *repo.Registry
-	Runner  runner.Runner
-	Harness harness.Harness
+	Repos      *repo.Registry
+	Runner     runner.Runner
+	Harness    harness.Harness
+	TaskSystem string
 
 	// RetentionDays bounds completed/canceled run retention; zero uses the
 	// machine default of 30 days.
@@ -91,6 +92,23 @@ func InitDatabase(path string) error {
 	return nil
 }
 
+// HasNonterminalRuns inspects an existing database without migrating or
+// otherwise modifying it. It is used by init --force before config changes.
+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
+}
+
 // New opens the SQLite database at path (created with mode 0600 when
 // missing), migrates the relay_runs projection, and constructs the engine.
 // A corrupt database file fails here.
@@ -130,10 +148,11 @@ func New(path string, deps Dependencies) (*Engine, error) {
 		return nil, fmt.Errorf("migrate relay_runs: %w", err)
 	}
 	activities := &Activities{
-		Repos:   deps.Repos,
-		Runner:  deps.Runner,
-		Harness: deps.Harness,
-		Runs:    proj,
+		Repos:      deps.Repos,
+		Runner:     deps.Runner,
+		Harness:    deps.Harness,
+		TaskSystem: deps.TaskSystem,
+		Runs:       proj,
 	}
 	retention := 30 * 24 * time.Hour
 	if deps.RetentionDays > 0 {
@@ -204,6 +223,7 @@ func (e *Engine) registerActivities() error {
 		a.ValidateAgents,
 		a.ApplyTaskConfig,
 		a.EnsureEnvironment,
+		a.SetEnvironmentStatus,
 		a.LoadNodeRuntime,
 		a.EnsureNodeRuntime,
 		a.CloseTerminals,
@@ -291,6 +311,19 @@ func (e *Engine) EnsureRun(ctx context.Context, start run.Start) (bool, error) {
 	if err != nil {
 		return false, err
 	}
+	if r.State != run.StateCompleted && r.State != run.StateCanceled && r.State != run.StateCanceling {
+		if _, err := e.instance(ctx, start.ID); errors.Is(err, sql.ErrNoRows) {
+			start.Runtime = e.runtime
+			if _, err := e.client.CreateWorkflowInstance(ctx,
+				client.WorkflowInstanceOptions{InstanceID: string(start.ID)},
+				e.activities.TicketWorkflow, start); err != nil && !errors.Is(err, backend.ErrInstanceAlreadyExists) {
+				return false, fmt.Errorf("create missing workflow instance %s: %w", start.ID, err)
+			}
+			return true, nil
+		} else if err != nil {
+			return false, err
+		}
+	}
 	// Existing run: reconcile only an active run at a work node.
 	if r.State == run.StateCompleted || r.State == run.StateCanceled || r.State == run.StateCanceling {
 		return false, nil
@@ -304,7 +337,7 @@ func (e *Engine) EnsureRun(ctx context.Context, start run.Start) (bool, error) {
 	}
 	ok := false
 	if runtime.TerminalID != "" {
-		_, ok, _ = e.activities.Runner.InspectTerminal(ctx, runner.Terminal{
+		_, ok, _ = e.activities.Runner.FindTerminal(ctx, runner.Terminal{
 			ID: runtime.TerminalID, Title: r.Ticket.Key + ":" + r.CurrentNode,
 		})
 	}