relay-flow 0.2.1-alpha → 0.2.2-alpha

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_test.go

@@ -9,6 +9,8 @@ import (
 	"time"
 
 	"github.com/rajpopat27/relay-flow/internal/execution/goworkflows"
+	"github.com/rajpopat27/relay-flow/internal/harness"
+	"github.com/rajpopat27/relay-flow/internal/harness/opencode"
 	"github.com/rajpopat27/relay-flow/internal/identity"
 	"github.com/rajpopat27/relay-flow/internal/repo"
 	"github.com/rajpopat27/relay-flow/internal/run"
@@ -44,33 +46,34 @@ func TestMailboxDescriptionAndLaunchPromptAreTaskSystemNeutral(t *testing.T) {
 	wf := linearWorkflow(false)
 	node := wf.Nodes["coding"]
 	node.Type = workflow.NodeHITL
-	description := goworkflows.MailboxSpecForNode(&wf, "PAY-101", "coding", node).Description
+	spec := goworkflows.MailboxSpecForNode(&wf, "PAY-101", "coding", node)
+	description := spec.Description
 	for _, want := range []string{
-		"Parent ticket: PAY-101",
-		"Do not make code changes",
-		"until the human is satisfied with the review",
+		"Required report format:",
+		"Node names identify workflow stages",
+		"SUMMARY is written to this current mailbox",
+		"requested changes in FEEDBACK",
 	} {
 		if !strings.Contains(description, want) {
 			t.Fatalf("HITL mailbox description missing %q:\n%s", want, description)
 		}
 	}
-	for _, unwanted := range []string{"Jira", "OpenCode", "Question tool"} {
+	for _, unwanted := range []string{"Jira", "OpenCode", "Question tool", "Approve and Reject", "Discuss the task with the human"} {
 		if strings.Contains(description, unwanted) {
 			t.Fatalf("generic mailbox description contains %q:\n%s", unwanted, description)
 		}
 	}
 
-	node.Type = workflow.NodeAgent
-	agentDescription := goworkflows.MailboxSpecForNode(&wf, "PAY-101", "coding", node).Description
-	if strings.Contains(agentDescription, "Question tool") {
-		t.Fatalf("agent mailbox description contains HITL Question instruction:\n%s", agentDescription)
-	}
-
 	for _, taskSystem := range []string{"jira", "linear"} {
-		prompt := goworkflows.BuildLaunchSpecPrompt(taskSystem, "PAY-101", "PAY-234")
-		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."
+		prompt, err := opencode.New().RenderPrompt(harness.PromptInitial, harness.PromptData{
+			TaskSystem: taskSystem, Ticket: "PAY-101", Mailbox: "PAY-234", NodeType: workflow.NodeHITL,
+		}, "")
+		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\nBefore submitting your report, present the complete proposed report through OpenCode's built-in Question tool with exactly two options: Approve and Reject. Submit it only after an explicit Approve answer."
 		if prompt != want {
-			t.Fatalf("BuildLaunchSpecPrompt(%s) = %q, want %q", taskSystem, prompt, want)
+			t.Fatalf("RenderPrompt(%s) = %q, want %q", taskSystem, prompt, want)
 		}
 		if strings.Contains(prompt, "Jira") || strings.Contains(prompt, "subtask") {
 			t.Fatalf("launch prompt contains task-system-specific mailbox wording: %q", prompt)
@@ -182,7 +185,11 @@ func TestRunBeginsAtStartAndFollowsEntryEdge(t *testing.T) {
 		Repos: repoRegistryWith("payments", sys), Runner: fr, Harness: fh,
 	})
 
-	rid, err := startRun(engine, linearWorkflow(false))
+	wf := linearWorkflow(false)
+	node := wf.Nodes["coding"]
+	node.NudgePrompt = "Continue {{ticket}} at {{node}}. Valid next steps: {{nextSteps}}."
+	wf.Nodes["coding"] = node
+	rid, err := startRun(engine, wf)
 	if err != nil {
 		t.Fatalf("EnsureRun failed: %v", err)
 	}
@@ -206,6 +213,17 @@ func TestRunBeginsAtStartAndFollowsEntryEdge(t *testing.T) {
 	if runtime.TerminalID == "" || runtime.NodeVisitID != r.CurrentNodeVisitID {
 		t.Fatalf("terminal was not persisted for current visit: %+v", runtime)
 	}
+	promptCalls := fh.promptCalls()
+	if len(promptCalls) != 1 {
+		t.Fatalf("RenderPrompt calls = %+v, want one initial prompt", promptCalls)
+	}
+	call := promptCalls[0]
+	if call.NudgeTemplate != node.NudgePrompt {
+		t.Fatalf("nudge passed to harness = %q, want raw template %q", call.NudgeTemplate, node.NudgePrompt)
+	}
+	if call.Data.Ticket != "PAY-101" || call.Data.Workflow != wf.Name || call.Data.Repo != "payments" || call.Data.Node != "coding" || call.Data.NextSteps == "" {
+		t.Fatalf("nudge prompt data = %+v, want current workflow values", call.Data)
+	}
 
 	// Pre-edge gate: before following the start edge the run ensures the
 	// runner environment AND validates every referenced agent, and applies

package/internal/execution/goworkflows/fakes_test.go

@@ -74,6 +74,7 @@ type fakeTaskSystem struct {
 	specs         []task.MailboxSpec
 	comments      []recordedComment
 	resets        []string
+	renderText    func(task.TextKind, task.TextData) (string, error)
 
 	// Failure/crash/slow injection — the fake IS the documented injection
 	// seam (allowed seam a). These make the fake adapter fail/stall so the
@@ -122,6 +123,22 @@ func (s *fakeTaskSystem) ValidateConfig(context.Context, config.RawValues, map[s
 	return nil
 }
 
+func (s *fakeTaskSystem) RenderText(kind task.TextKind, data task.TextData) (string, error) {
+	if s.renderText != nil {
+		return s.renderText(kind, data)
+	}
+	switch kind {
+	case task.TextMailboxDescription:
+		return "Parent ticket: " + data.Ticket + "\nNode: " + data.Node + "\nType: " + data.NodeType + "\nAgent: " + data.Agent + "\nWork: " + data.NodeDescription + "\nMailbox: " + data.Mailbox, nil
+	case task.TextSummaryComment:
+		return "SUMMARY\n" + data.SummaryReport, nil
+	case task.TextFeedbackComment:
+		return "Feedback from " + data.SourceNode + " to " + data.TargetNode + " mailbox " + data.Mailbox + "\n" + data.FeedbackReport, nil
+	default:
+		return "", fmt.Errorf("unknown task text kind %q", kind)
+	}
+}
+
 func (s *fakeTaskSystem) EnsureMailboxes(_ context.Context, parent task.TicketRef, wf string, specs []task.MailboxSpec) (map[string]task.Mailbox, error) {
 	s.log.add("ensureMailboxes:" + parent.Key)
 	s.mu.Lock()
@@ -455,16 +472,25 @@ func (f *fakeRunner) killTerminals() {
 type fakeHarness struct {
 	log *eventLog
 
-	mu             sync.Mutex
-	validated      []string
-	sessions       map[string]harness.Session
-	reconcileNudge int // nudges sent to idle live HITL sessions (must stay 0)
+	mu              sync.Mutex
+	validated       []string
+	sessions        map[string]harness.Session
+	renderedPrompts []renderedPromptCall
+	reconcileNudge  int // nudges sent to idle live HITL sessions (must stay 0)
+}
+
+type renderedPromptCall struct {
+	Kind          harness.PromptKind
+	Data          harness.PromptData
+	NudgeTemplate string
 }
 
 func newFakeHarness(log *eventLog) *fakeHarness {
 	return &fakeHarness{log: log, sessions: map[string]harness.Session{}}
 }
 
+func (f *fakeHarness) SetupRepo(context.Context, string) error { return nil }
+
 func (f *fakeHarness) ValidateAgent(_ context.Context, _, agent string) error {
 	f.mu.Lock()
 	f.validated = append(f.validated, agent)
@@ -481,6 +507,26 @@ func (f *fakeHarness) FindSession(_ context.Context, _, title string) (harness.S
 	return s, ok, nil
 }
 
+func (f *fakeHarness) RenderPrompt(kind harness.PromptKind, data harness.PromptData, nudge string) (string, error) {
+	f.mu.Lock()
+	f.renderedPrompts = append(f.renderedPrompts, renderedPromptCall{Kind: kind, Data: data, NudgeTemplate: nudge})
+	f.mu.Unlock()
+	prompt := string(kind) + ":" + data.TaskSystem + ":" + data.Mailbox
+	if data.NodeType == workflow.NodeHITL {
+		prompt += ":hitl"
+	}
+	if nudge != "" {
+		prompt += ":" + nudge
+	}
+	return prompt, nil
+}
+
+func (f *fakeHarness) promptCalls() []renderedPromptCall {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return append([]renderedPromptCall(nil), f.renderedPrompts...)
+}
+
 func (f *fakeHarness) BuildCommand(spec harness.LaunchSpec) (runner.Command, error) {
 	f.log.add("buildCommand:" + spec.Node + ":" + string(spec.NodeVisitID) + ":resume=" + spec.ResumeID)
 	return runner.Command{Executable: "opencode"}, nil

package/internal/execution/goworkflows/interpreter.go

@@ -188,22 +188,9 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 
 		title := start.Ticket.Key + ":" + current
 
-		// Build the finished launch metadata from the workflow snapshot: the
-		// prompt carries the node description, optional custom instructions,
-		// complete report contract, and valid next steps. Custom instructions
-		// are also retained separately for live-terminal revisits.
+		// Build task-system-neutral prompt data from the workflow snapshot. The
+		// selected harness owns rendering initial, feedback, and HITL text.
 		nextSteps := append(append([]workflow.Route{}, node.OnSuccess...), node.OnFailure...)
-		nudge, err := wf.RenderNudge(current, workflow.NudgeTemplateData{
-			TaskSystem: a.TaskSystem,
-			Ticket:     start.Ticket.Key,
-			Workflow:   wf.Name,
-			Repo:       start.Repo,
-			Node:       current,
-			NextSteps:  nextStepsText(nextSteps),
-		})
-		if err != nil {
-			return err
-		}
 		spec := harness.LaunchSpec{
 			RunID:       start.ID,
 			NodeVisitID: visitID,
@@ -215,9 +202,20 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 			NodeType:    node.Type,
 			Agent:       node.Agent,
 			Title:       title,
-			Prompt:      BuildLaunchSpecPrompt(a.TaskSystem, start.Ticket.Key, mb.Key),
-			NudgePrompt: nudge,
-			NextSteps:   nextSteps,
+			NudgePrompt: node.NudgePrompt,
+			PromptData: harness.PromptData{
+				TaskSystem:      a.TaskSystem,
+				Ticket:          start.Ticket.Key,
+				Workflow:        wf.Name,
+				Repo:            start.Repo,
+				Node:            current,
+				NodeType:        node.Type,
+				Agent:           node.Agent,
+				NodeDescription: node.Description,
+				NextSteps:       nextStepsText(nextSteps),
+				Mailbox:         mb.Key,
+			},
+			NextSteps: nextSteps,
 		}
 		if runtime.SessionID != "" {
 			spec.ResumeID = runtime.SessionID
@@ -305,10 +303,14 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 		// complete current -> process next node.
 		if _, err := retryLoop(ctx, start.ID, a, work, current,
 			func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
+				summaryReport := renderSummaryReport(report)
 				return goworkflow.ExecuteActivity[struct{}](ctx2, noNativeRetries, a.Comment, start.Repo, run.CommentWork{
-					RunID:  start.ID,
-					Item:   task.Target{Parent: work.Parent, Mailbox: &mb},
-					Body:   renderSummary(report),
+					RunID: start.ID, Item: task.Target{Parent: work.Parent, Mailbox: &mb},
+					TextKind: task.TextSummaryComment,
+					TextData: task.TextData{RunID: string(start.ID), Ticket: work.Parent.Key,
+						Workflow: wf.Name, Repo: start.Repo, Node: current, NodeType: string(node.Type),
+						Agent: node.Agent, NodeDescription: node.Description, Mailbox: mb.Key,
+						SourceNode: current, TargetNode: current, SummaryReport: summaryReport},
 					Marker: string(visitID) + ":summary",
 				})
 			}); err != nil {
@@ -320,10 +322,15 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 			nextMb := mailboxes[next]
 			if _, err := retryLoop(ctx, start.ID, a, work, current,
 				func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
+					feedbackReport := renderFeedbackReport(report)
 					return goworkflow.ExecuteActivity[struct{}](ctx2, noNativeRetries, a.Comment, start.Repo, run.CommentWork{
-						RunID:  start.ID,
-						Item:   task.Target{Parent: work.Parent, Mailbox: &nextMb},
-						Body:   renderFeedback(current, report),
+						RunID: start.ID, Item: task.Target{Parent: work.Parent, Mailbox: &nextMb},
+						TextKind: task.TextFeedbackComment,
+						TextData: task.TextData{RunID: string(start.ID), Ticket: work.Parent.Key,
+							Workflow: wf.Name, Repo: start.Repo, Node: next, NodeType: string(wf.Nodes[next].Type),
+							Agent: wf.Nodes[next].Agent, NodeDescription: wf.Nodes[next].Description, Mailbox: nextMb.Key,
+							SourceNode: current, TargetNode: next, SummaryReport: renderSummaryReport(report),
+							FeedbackReport: feedbackReport},
 						Marker: string(visitID) + ":feedback",
 					})
 				}); err != nil {
@@ -602,12 +609,12 @@ func nextStepsText(routes []workflow.Route) string {
 	return b.String()
 }
 
-func renderSummary(r workflow.Report) string {
-	return fmt.Sprintf("SUMMARY\nCOMPLETED:\n%s\n\nCOMMITS:\n%s\n\nNOT COMPLETED:\n%s\n\nISSUES DISCOVERED:\n%s\n\nVERIFICATION:\n%s\n\nNOTES:\n%s\n",
+func renderSummaryReport(r workflow.Report) string {
+	return fmt.Sprintf("COMPLETED:\n%s\n\nCOMMITS:\n%s\n\nNOT COMPLETED:\n%s\n\nISSUES DISCOVERED:\n%s\n\nVERIFICATION:\n%s\n\nNOTES:\n%s",
 		r.Summary.Completed, r.Summary.Commits, r.Summary.NotCompleted, r.Summary.IssuesDiscovered, r.Summary.Verification, r.Summary.Notes)
 }
 
-func renderFeedback(source string, r workflow.Report) string {
-	return fmt.Sprintf("Feedback from %s\nCOMMITS:\n%s\n\nREASON FOR NEXT STEP:\n%s\n\nREQUIRED ACTIONS:\n%s\n\nRELEVANT CONTEXT:\n%s\n\nEXPECTED RESULT:\n%s\n",
-		source, r.Summary.Commits, r.Feedback.ReasonForNextStep, r.Feedback.RequiredActions, r.Feedback.RelevantContext, r.Feedback.ExpectedResult)
+func renderFeedbackReport(r workflow.Report) string {
+	return fmt.Sprintf("COMMITS:\n%s\n\nREASON FOR NEXT STEP:\n%s\n\nREQUIRED ACTIONS:\n%s\n\nRELEVANT CONTEXT:\n%s\n\nEXPECTED RESULT:\n%s",
+		r.Summary.Commits, r.Feedback.ReasonForNextStep, r.Feedback.RequiredActions, r.Feedback.RelevantContext, r.Feedback.ExpectedResult)
 }

package/internal/execution/goworkflows/mailbox_test.go

@@ -266,6 +266,91 @@ func TestSummaryCurrentFeedbackSelectedNextOnly(t *testing.T) {
 	}
 }
 
+func TestTaskSystemTemplatesRenderMailboxAndSplitOneReport(t *testing.T) {
+	log := newEventLog()
+	sys := newFakeTaskSystem(log)
+	seen := map[task.TextKind][]task.TextData{}
+	sys.renderText = func(kind task.TextKind, data task.TextData) (string, error) {
+		seen[kind] = append(seen[kind], data)
+		switch kind {
+		case task.TextMailboxDescription:
+			return "custom mailbox " + data.Node + " work=" + data.NodeDescription, nil
+		case task.TextSummaryComment:
+			return "custom summary node=" + data.Node + " mailbox=" + data.Mailbox + "\n" + data.SummaryReport, nil
+		case task.TextFeedbackComment:
+			return "custom feedback source=" + data.SourceNode + " target=" + data.TargetNode + " mailbox=" + data.Mailbox + "\n" + data.FeedbackReport, nil
+		default:
+			return "", nil
+		}
+	}
+	engine := newEngine(t, goworkflows.Dependencies{
+		Repos: repoRegistryWith("payments", sys), Runner: newFakeRunner(log), Harness: newFakeHarness(log), TaskSystem: "custom-task",
+	})
+	rid, _ := startRun(engine, threeNodeWorkflow())
+	waitFor(t, 10*time.Second, func() bool {
+		r, _ := engine.GetRun(context.Background(), rid)
+		return r.CurrentNode == "exploration"
+	})
+	if got := sys.specs[1].Description; !strings.Contains(got, "custom mailbox exploration work=explore the code") || !strings.Contains(got, "Required report format:") {
+		t.Fatalf("rendered mailbox description = %q", got)
+	}
+	var explorationData task.TextData
+	for _, data := range seen[task.TextMailboxDescription] {
+		if data.Node == "exploration" {
+			explorationData = data
+		}
+	}
+	for name, got := range map[string]string{
+		"runID":  explorationData.RunID,
+		"ticket": explorationData.Ticket, "workflow": explorationData.Workflow,
+		"repo": explorationData.Repo, "node": explorationData.Node,
+		"nodeType": explorationData.NodeType, "agent": explorationData.Agent,
+		"nodeDescription": explorationData.NodeDescription, "mailbox": explorationData.Mailbox,
+	} {
+		if got == "" {
+			t.Fatalf("mailbox template value %s was empty: %+v", name, explorationData)
+		}
+	}
+	for name, got := range map[string]string{"nextSteps": explorationData.NextSteps, "successRoutes": explorationData.SuccessRoutes, "failureRoutes": explorationData.FailureRoutes} {
+		if !strings.Contains(got, "coding") && name != "failureRoutes" {
+			t.Fatalf("mailbox template %s = %q", name, got)
+		}
+		if name == "failureRoutes" && !strings.Contains(got, "exploration") {
+			t.Fatalf("mailbox template failureRoutes = %q", got)
+		}
+	}
+	report := successReport("coding")
+	report.Feedback = workflow.Feedback{ReasonForNextStep: "reviewed", RequiredActions: "implement", RelevantContext: "ctx", ExpectedResult: "done"}
+	if _, err := engine.SubmitReport(context.Background(), reportRequest(rid, "exploration", report)); err != nil {
+		t.Fatal(err)
+	}
+	waitFor(t, 10*time.Second, func() bool {
+		r, _ := engine.GetRun(context.Background(), rid)
+		return r.CurrentNode == "coding"
+	})
+	summary := sys.commentBodies("PAY-101-exploration")
+	feedback := sys.commentBodies("PAY-101-coding")
+	if len(summary) != 1 || !strings.Contains(summary[0].Body, "custom summary node=exploration mailbox=PAY-101-exploration") || !strings.Contains(summary[0].Body, "COMPLETED:") {
+		t.Fatalf("summary comments = %+v", summary)
+	}
+	if len(feedback) != 1 || !strings.Contains(feedback[0].Body, "source=exploration target=coding mailbox=PAY-101-coding") || !strings.Contains(feedback[0].Body, "REQUIRED ACTIONS:") {
+		t.Fatalf("feedback comments = %+v", feedback)
+	}
+	if len(seen[task.TextSummaryComment]) != 1 || seen[task.TextSummaryComment][0].SummaryReport == "" {
+		t.Fatalf("summary template data = %+v", seen[task.TextSummaryComment])
+	}
+	if len(seen[task.TextFeedbackComment]) != 1 {
+		t.Fatalf("feedback template data = %+v", seen[task.TextFeedbackComment])
+	}
+	feedbackData := seen[task.TextFeedbackComment][0]
+	if feedbackData.SourceNode != "exploration" || feedbackData.TargetNode != "coding" || feedbackData.Mailbox != "PAY-101-coding" || feedbackData.FeedbackReport == "" {
+		t.Fatalf("feedback template data = %+v", feedbackData)
+	}
+	if len(sys.commentBodies("PAY-101-review")) != 0 {
+		t.Fatal("one report sent feedback to an unselected mailbox")
+	}
+}
+
 // 3.28: end/mailbox behavior, manual status not routing, HITL lifecycle.
 
 func TestManualMailboxStatusDoesNotRouteGraph(t *testing.T) {

package/internal/execution/goworkflows/node_runtime_test.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"errors"
 	"path/filepath"
+	"reflect"
 	"testing"
 	"time"
 
@@ -222,15 +223,18 @@ func TestEnsureNodeRuntimeUsesDirectIDsAndFallsBackFresh(t *testing.T) {
 	if rt.TerminalID == "" || rt.TerminalID == "dead-term" || rt.SessionID != "dead-session" {
 		t.Fatalf("failed direct IDs not replaced atomically: %+v", rt)
 	}
-	if fr.findCalls != 1 || fh.buildCalls != 1 || fr.createCalls != 1 {
+	if fr.findCalls != 2 || fh.buildCalls != 1 || fr.createCalls != 1 {
 		t.Fatalf("stored-ID replacement calls: find=%d build=%d create=%d", fr.findCalls, fh.buildCalls, fr.createCalls)
 	}
-	if len(fr.findIDs) != 1 || fr.findIDs[0] != "dead-term" {
-		t.Fatalf("FindTerminal IDs = %v, want [dead-term]", fr.findIDs)
+	if len(fr.findIDs) != 2 || fr.findIDs[0] != "dead-term" || fr.findIDs[1] != "dead-term" {
+		t.Fatalf("FindTerminal IDs = %v, want [dead-term dead-term]", fr.findIDs)
 	}
 	if len(fh.resumeIDs) != 1 || fh.resumeIDs[0] != "dead-session" {
 		t.Fatalf("BuildCommand ResumeIDs = %v, want [dead-session]", fh.resumeIDs)
 	}
+	if !reflect.DeepEqual(fh.rendered, []harness.PromptKind{harness.PromptInitial}) {
+		t.Fatalf("dead-terminal rendered prompts = %v, want initial", fh.rendered)
+	}
 	for _, prompt := range fh.prompts {
 		if prompt != "work" {
 			t.Fatalf("same-visit relaunch prompt = %q, want standard prompt only", prompt)
@@ -261,7 +265,7 @@ func TestEnsureNodeRuntimeInitialLaunchAppendsCustomInstructions(t *testing.T) {
 	if err := a.EnsureNodeRuntime(ctx, nw, "", spec, NodeRuntime{}); err != nil {
 		t.Fatal(err)
 	}
-	if len(fh.prompts) != 1 || fh.prompts[0] != "standard prompt\n\ncustom instructions" {
+	if len(fh.prompts) != 1 || fh.prompts[0] != "work\n\ncustom instructions" {
 		t.Fatalf("initial prompt = %q", fh.prompts)
 	}
 	if len(fr.statuses) != 1 || fr.statuses[0] != runner.WorkspaceStatusInReview {
@@ -298,7 +302,7 @@ func TestEnsureNodeRuntimeSendFailureClosesLiveTerminal(t *testing.T) {
 	if fr.closeCalls != 1 || fr.closedIDs[0] != "live-old" {
 		t.Fatalf("old live terminal not closed before replacement: %+v", fr.closedIDs)
 	}
-	if len(fr.sentTexts) != 1 || fr.sentTexts[0] != "New feedback was added to the comments section of your mailbox subtask PAY-234. Read it.\n\nRead the latest review feedback." {
+	if len(fr.sentTexts) != 1 || fr.sentTexts[0] != "feedback\n\nRead the latest review feedback." {
 		t.Fatalf("live revisit prompt = %q", fr.sentTexts)
 	}
 	if len(fh.prompts) != 1 || fh.prompts[0] != "work\n\nRead the latest review feedback." {
@@ -311,6 +315,9 @@ func TestEnsureNodeRuntimeSendFailureClosesLiveTerminal(t *testing.T) {
 	if len(fh.resumeIDs) != 1 || fh.resumeIDs[0] != "session-old" {
 		t.Fatalf("replacement ResumeIDs = %v, want [session-old]", fh.resumeIDs)
 	}
+	if !reflect.DeepEqual(fh.rendered, []harness.PromptKind{harness.PromptFeedback, harness.PromptInitial}) {
+		t.Fatalf("rendered prompts = %v, want feedback then replacement initial", fh.rendered)
+	}
 }
 
 func TestEnsureNodeRuntimeSameVisitSendsNothing(t *testing.T) {
@@ -338,6 +345,10 @@ func TestEnsureNodeRuntimeSameVisitSendsNothing(t *testing.T) {
 	if len(fr.sentTexts) != 0 || fr.createCalls != 0 {
 		t.Fatalf("same visit sent=%q creates=%d", fr.sentTexts, fr.createCalls)
 	}
+	fh := a.Harness.(*runtimeTestHarness)
+	if len(fh.rendered) != 0 || fh.buildCalls != 0 {
+		t.Fatalf("same visit rendered=%v buildCalls=%d, want silence", fh.rendered, fh.buildCalls)
+	}
 }
 
 func TestEnsureNodeRuntimeRejectsStaleVisitWithoutLaunch(t *testing.T) {
@@ -487,8 +498,22 @@ type runtimeTestHarness struct {
 	buildCalls int
 	prompts    []string
 	resumeIDs  []string
+	rendered   []harness.PromptKind
+}
+
+func (h *runtimeTestHarness) RenderPrompt(kind harness.PromptKind, _ harness.PromptData, nudge string) (string, error) {
+	h.rendered = append(h.rendered, kind)
+	prompt := "work"
+	if kind == harness.PromptFeedback {
+		prompt = "feedback"
+	}
+	if nudge != "" {
+		prompt += "\n\n" + nudge
+	}
+	return prompt, nil
 }
 
+func (*runtimeTestHarness) SetupRepo(context.Context, string) error             { return nil }
 func (*runtimeTestHarness) ValidateAgent(context.Context, string, string) error { return nil }
 func (*runtimeTestHarness) FindSession(context.Context, string, string) (harness.Session, bool, error) {
 	return harness.Session{}, false, nil

package/internal/execution/goworkflows/recovery_test.go

@@ -759,8 +759,8 @@ func recoverTickets(ctx context.Context, engine *goworkflows.Engine, sys *fakeTa
 		return err
 	}
 	rm := &run.RunManager{Executor: engine, Runs: engine}
-	specsFor := func(w *workflow.Workflow, key string) []task.MailboxSpec {
-		return goworkflows.MailboxSpecs(w, key)
+	specsFor := func(system task.System, work run.Work, w *workflow.Workflow) ([]task.MailboxSpec, error) {
+		return goworkflows.RenderMailboxSpecs(system, work, w)
 	}
 	return recoverpkg.FromTaskSystem(ctx, reg, fr, rm, specsFor)
 }

package/internal/execution/goworkflows/report_contract_fixture_test.go

@@ -0,0 +1,31 @@
+package goworkflows
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/run"
+)
+
+func TestSharedReportContractFixtureRendersCommentValues(t *testing.T) {
+	b, err := os.ReadFile("../../../testdata/report-contract.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var fixtures map[string]struct {
+		Envelope       run.ReportRequest `json:"envelope"`
+		SummaryReport  string            `json:"summaryReport"`
+		FeedbackReport string            `json:"feedbackReport"`
+	}
+	if err := json.Unmarshal(b, &fixtures); err != nil {
+		t.Fatal(err)
+	}
+	fixture := fixtures["work"]
+	if got := renderSummaryReport(fixture.Envelope.Report); got != fixture.SummaryReport {
+		t.Fatalf("summaryReport mismatch\ngot:\n%s\nwant:\n%s", got, fixture.SummaryReport)
+	}
+	if got := renderFeedbackReport(fixture.Envelope.Report); got != fixture.FeedbackReport {
+		t.Fatalf("feedbackReport mismatch\ngot:\n%s\nwant:\n%s", got, fixture.FeedbackReport)
+	}
+}

package/internal/harness/contract_test.go

@@ -32,6 +32,8 @@ func newFakeHarness() *fakeHarness {
 	}
 }
 
+func (f *fakeHarness) SetupRepo(context.Context, string) error { return nil }
+
 func (f *fakeHarness) ValidateAgent(_ context.Context, _, agent string) error {
 	if !f.agents[agent] {
 		return errUnknownAgent
@@ -44,6 +46,14 @@ func (f *fakeHarness) FindSession(_ context.Context, _, title string) (harness.S
 	return s, ok, nil
 }
 
+func (f *fakeHarness) RenderPrompt(_ harness.PromptKind, data harness.PromptData, nudge string) (string, error) {
+	prompt := data.TaskSystem + ":" + data.Ticket + ":" + data.Mailbox
+	if nudge != "" {
+		prompt += "\n\n" + nudge
+	}
+	return prompt, nil
+}
+
 func (f *fakeHarness) BuildCommand(spec harness.LaunchSpec) (runner.Command, error) {
 	// The fake mirrors the required env contract; the real opencode harness
 	// builds the executable/args. NEXT_STEPS_JSON carries the legal targets