relay-flow 0.2.0-alpha → 0.2.2-alpha

package/internal/execution/goworkflows/engine_test.go

@@ -2,12 +2,15 @@ package goworkflows_test
 
 import (
 	"context"
+	"database/sql"
 	"path/filepath"
 	"strings"
 	"testing"
 	"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"
@@ -39,38 +42,45 @@ func linearWorkflow(cleanup bool) workflow.Workflow {
 	}
 }
 
-func TestMailboxDescriptionRequiresQuestionForHITL(t *testing.T) {
+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{
-		"Do not make code changes",
-		"until the human is satisfied with the review",
-		"OpenCode's Question tool",
-		"Approve and Reject",
-		"If approved, output the report verbatim",
-		"If rejected, return to step 1",
+		"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)
 		}
 	}
-
-	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 _, 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)
+		}
 	}
 
-	prompt := goworkflows.BuildLaunchSpecPrompt("PAY-101", "PAY-234")
-	for _, want := range []string{"parent Jira ticket PAY-101", "mailbox subtask is PAY-234", "description and comments"} {
-		if !strings.Contains(prompt, want) {
-			t.Fatalf("compact launch prompt missing %q: %q", want, prompt)
+	for _, taskSystem := range []string{"jira", "linear"} {
+		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("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)
+		}
+		if strings.Contains(prompt, "STATUS:") || strings.Contains(prompt, node.Description) {
+			t.Fatalf("launch prompt duplicates mailbox instructions: %q", prompt)
 		}
-	}
-	if strings.Contains(prompt, "STATUS:") || strings.Contains(prompt, node.Description) {
-		t.Fatalf("launch prompt duplicates mailbox instructions: %q", prompt)
 	}
 }
 
@@ -104,6 +114,50 @@ func newEngine(t *testing.T, deps goworkflows.Dependencies) *goworkflows.Engine
 	return e
 }
 
+func TestEnsureRunCreatesMissingWorkflowForExistingProjection(t *testing.T) {
+	log := newEventLog()
+	sys := newFakeTaskSystem(log)
+	path := filepath.Join(t.TempDir(), "state.db")
+	deps := goworkflows.Dependencies{
+		Repos: repoRegistryWith("payments", sys), Runner: newFakeRunner(log), Harness: newFakeHarness(log),
+	}
+	engine, err := goworkflows.New(path, deps)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wf := linearWorkflow(false)
+	rid := identity.NewRunID("payments", wf.Name, "PAY-101")
+	db, err := sql.Open("sqlite", path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := db.Exec(`INSERT INTO relay_runs
+		(id, repo, workflow, ticket_id, ticket_key, state, started_at, updated_at)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, rid, "payments", wf.Name, "1", "PAY-101", run.StateStarting, time.Now(), time.Now()); err != nil {
+		t.Fatal(err)
+	}
+	db.Close()
+	if err := engine.Start(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = engine.Shutdown(context.Background()) })
+
+	created, err := engine.EnsureRun(context.Background(), run.Start{
+		ID: rid, Repo: "payments", RepoPath: "/srv/payments", Workflow: wf,
+		Ticket: task.TicketRef{ID: "1", Key: "PAY-101"},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !created {
+		t.Fatal("EnsureRun did not create the missing workflow instance")
+	}
+	waitFor(t, 10*time.Second, func() bool {
+		r, err := engine.GetRun(context.Background(), rid)
+		return err == nil && r.CurrentNode == "coding"
+	})
+}
+
 func successReport(next string) workflow.Report {
 	none := "None"
 	return workflow.Report{
@@ -131,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)
 	}
@@ -155,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
@@ -233,6 +302,9 @@ func TestRevisitCreatesNewVisit(t *testing.T) {
 		r, _ := engine.GetRun(context.Background(), rid)
 		return r.CurrentNode == "coding" && r.CurrentNodeVisitID != ""
 	})
+	if indexOf(log.all(), "environmentStatus:in-progress") < 0 {
+		t.Fatalf("agent node did not set workspace status in-progress; events=%v", log.all())
+	}
 
 	r, _ := engine.GetRun(context.Background(), rid)
 	first := r.CurrentNodeVisitID
@@ -329,6 +401,9 @@ func TestEndCleanupDisabledKeepsRetainedRunner(t *testing.T) {
 		r, _ := engine.GetRun(context.Background(), rid)
 		return r.State == run.StateCompleted
 	})
+	if indexOf(log.all(), "environmentStatus:completed") < 0 {
+		t.Fatalf("end did not set workspace status completed; events=%v", log.all())
+	}
 	if len(fr.cleaned) != 0 || fr.liveTerminals() != 1 {
 		t.Fatalf("cleanup disabled: CleanupRun calls=%v live terminals=%d, want 0 and 1", fr.cleaned, fr.liveTerminals())
 	}
@@ -378,6 +453,10 @@ func TestTransitionOrdering(t *testing.T) {
 		r, _ := engine.GetRun(context.Background(), rid)
 		return r.CurrentNode == "review"
 	})
+	events := log.all()
+	if statusIdx, terminalIdx := indexOf(events, "environmentStatus:in-review"), indexOf(events, "ensureTerminal:PAY-101:review"); statusIdx < 0 || terminalIdx < 0 || statusIdx >= terminalIdx {
+		t.Fatalf("HITL status was not set before terminal start; events=%v", events)
+	}
 
 	// Exact cross-primitive order, observed through the fake-adapter and fake-
 	// runner call logs (the settled observation seam):
@@ -388,7 +467,6 @@ func TestTransitionOrdering(t *testing.T) {
 	// (recovery_test.go): a crash after acceptance, with comment injection
 	// failing, restarts on the same db and resumes the PERSISTED selected route
 	// without re-asking the agent or re-running effects.
-	events := log.all()
 	idx := map[string]int{}
 	for _, want := range []string{
 		"comment:PAY-101-coding",         // summary to current mailbox

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()
@@ -337,21 +354,17 @@ func (f *fakeRunner) EnsureEnvironment(_ context.Context, spec runner.RunSpec) (
 	return e, nil
 }
 
-func (f *fakeRunner) FindTerminal(_ context.Context, env runner.Environment, title string) (runner.Terminal, bool, error) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	f.log.add("findTerminal:" + title)
-	ft, ok := f.terminals[env.ID+"/"+title]
-	if !ok || !ft.live {
-		return runner.Terminal{}, false, nil
-	}
-	return ft.term, true, nil
+func (f *fakeRunner) SetEnvironmentStatus(_ context.Context, _ runner.Environment, status string) error {
+	f.log.add("environmentStatus:" + status)
+	return nil
 }
 
-func (f *fakeRunner) InspectTerminal(_ context.Context, terminal runner.Terminal) (runner.Terminal, bool, error) {
+func (f *fakeRunner) FindTerminal(_ context.Context, terminal runner.Terminal) (runner.Terminal, bool, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
-	f.log.add("inspectTerminal:" + terminal.ID)
+	if terminal.ID != "" {
+		f.log.add("findTerminalID:" + terminal.ID)
+	}
 	for _, ft := range f.terminals {
 		if ft.term.ID == terminal.ID && ft.live {
 			return ft.term, true, nil
@@ -381,17 +394,13 @@ func (f *fakeRunner) CreateTerminal(ctx context.Context, env runner.Environment,
 	return t, nil
 }
 
-func (f *fakeRunner) EnsureTerminal(_ context.Context, env runner.Environment, title string, _ runner.Command) (runner.Terminal, error) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	key := env.ID + "/" + title
-	if ft, ok := f.terminals[key]; ok && ft.live {
-		return ft.term, nil
+func (f *fakeRunner) EnsureTerminal(ctx context.Context, env runner.Environment, stored runner.Terminal, title string, command runner.Command) (runner.Terminal, error) {
+	if terminal, ok, err := f.FindTerminal(ctx, stored); err != nil {
+		return runner.Terminal{}, err
+	} else if ok {
+		return terminal, nil
 	}
-	t := runner.Terminal{ID: "t-" + key, Title: title}
-	f.terminals[key] = &fakeTerminal{term: t, live: true, title: title}
-	f.log.add("ensureTerminal:" + title)
-	return t, nil
+	return f.CreateTerminal(ctx, env, title, command)
 }
 
 func (f *fakeRunner) CloseTerminal(_ context.Context, t runner.Terminal) error {
@@ -463,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)
@@ -489,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,21 +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{
-			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,
@@ -214,9 +202,20 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 			NodeType:    node.Type,
 			Agent:       node.Agent,
 			Title:       title,
-			Prompt:      BuildLaunchSpecPrompt(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
@@ -304,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 {
@@ -319,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 {
@@ -360,6 +368,13 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 		}); err != nil {
 		return err
 	}
+	if _, err := retryLoop(ctx, start.ID, a, work, "end",
+		func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
+			return goworkflow.ExecuteActivity[struct{}](ctx2, noNativeRetries,
+				a.SetEnvironmentStatus, work, start.RepoPath, runner.WorkspaceStatusCompleted)
+		}); err != nil {
+		return err
+	}
 	finalPolicy := work.Runtime
 	if wf.CleanupRunnerOnEnd {
 		finalPolicy.KeepTerminalsAlive = false
@@ -401,7 +416,7 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 // run-level activities like EnsureMailboxes / start/end ApplyTaskConfig).
 // The log is wrapped in a replay-safe SideEffect so replays never re-emit
 // it, and the error message is sanitized so info logs never embed argv
-// payloads (acli/orca --body/--command/JQL/prompt strings).
+// payloads (Jira/Orca request bodies, commands, JQL, and prompt strings).
 func retryLoop[T any](ctx goworkflow.Context, id run.ID, a *Activities, work run.Work, node string, schedule func(goworkflow.Context) goworkflow.Future[T]) (T, error) {
 	var zero T
 	attempt := 0
@@ -475,7 +490,7 @@ func logRetry(ctx goworkflow.Context, work run.Work, node string, f retry.Failur
 }
 
 // sanitizeRetryMessage strips each "[...]: " argv-listing span that adapter
-// wrappers embed (acli [args...]:, orca [args...]:) so the info-level retry
+// wrappers may embed argv/request context, so the info-level retry
 // record never leaks --body/--command/JQL/prompt payloads. Keeps the
 // surrounding wrap context and trailing exit status / stderr fragment that
 // carry the failure reason. The original error returned to callers is
@@ -594,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_integration_test.go

@@ -84,8 +84,8 @@ func TestPersistedRuntimeLoopAndRestart(t *testing.T) {
 	if err != nil || !staleAck.Duplicate {
 		t.Fatalf("stale ack=%+v err=%v", staleAck, err)
 	}
-	if log.count("findTerminal:") != 0 {
-		t.Fatalf("normal path used title discovery: %v", log.all())
+	if log.count("findTerminalID:") == 0 {
+		t.Fatalf("normal path did not check persisted terminal IDs: %v", log.all())
 	}
 	if log.count("findSession:") != 0 {
 		t.Fatalf("normal path used session discovery: %v", log.all())
@@ -93,7 +93,7 @@ func TestPersistedRuntimeLoopAndRestart(t *testing.T) {
 
 	oldTerminal := secondRT.TerminalID
 	fr.killTerminals()
-	findTerminalBefore := log.count("findTerminal:")
+	findTerminalBefore := log.count("findTerminalID:")
 	findSessionBefore := log.count("findSession:")
 	e2 := restartEngine(t, db, deps, e1)
 	waitFor(t, 10*time.Second, func() bool {
@@ -104,13 +104,19 @@ func TestPersistedRuntimeLoopAndRestart(t *testing.T) {
 		t.Fatal(err)
 	}
 	resumeEvent := "buildCommand:implement:" + string(second.CurrentNodeVisitID) + ":resume=session-implement"
-	waitFor(t, 10*time.Second, func() bool { return log.count(resumeEvent) == 1 })
+	waitFor(t, 10*time.Second, func() bool {
+		runtime, _ := e2.GetNodeRuntime(context.Background(), rid, "implement")
+		return runtime.TerminalID != "" && runtime.TerminalID != oldTerminal
+	})
 	after, _ := e2.GetNodeRuntime(context.Background(), rid, "implement")
 	if after.TerminalID == oldTerminal || after.SessionID != "session-implement" || after.NodeVisitID != second.CurrentNodeVisitID {
 		t.Fatalf("restart did not resume/replace direct runtime: old=%+v after=%+v", secondRT, after)
 	}
-	if log.count("findTerminal:") != findTerminalBefore || log.count("findSession:") != findSessionBefore {
-		t.Fatalf("restart used discovery: %v", log.all())
+	if log.count("findTerminalID:") == findTerminalBefore || log.count("findSession:") != findSessionBefore {
+		t.Fatalf("restart did not use only the persisted terminal/session IDs: %v", log.all())
+	}
+	if log.count(resumeEvent) < 1 {
+		t.Fatalf("restart did not pass persisted session ID to harness: %v", log.all())
 	}
 }