relay-flow 0.2.1-alpha → 0.2.3-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.go

@@ -24,6 +24,7 @@ import (
 	"github.com/google/uuid"
 
 	"github.com/rajpopat27/relay-flow/internal/harness"
+	"github.com/rajpopat27/relay-flow/internal/identity"
 	"github.com/rajpopat27/relay-flow/internal/repo"
 	"github.com/rajpopat27/relay-flow/internal/run"
 	"github.com/rajpopat27/relay-flow/internal/runner"
@@ -220,6 +221,7 @@ func (e *Engine) registerActivities() error {
 	a := e.activities
 	for _, act := range []goworkflow.Activity{
 		a.EnsureMailboxes,
+		a.PrepareRestart,
 		a.ValidateAgents,
 		a.ApplyTaskConfig,
 		a.EnsureEnvironment,
@@ -283,6 +285,12 @@ func (e *Engine) Shutdown(ctx context.Context) error {
 // title and sends the reconcile signal only when that terminal is missing
 // or unusable. Repeated polls are harmless.
 func (e *Engine) EnsureRun(ctx context.Context, start run.Start) (bool, error) {
+	if start.LogicalID == "" {
+		start.LogicalID = run.ID(identity.LogicalRunID(start.ID))
+	}
+	if start.AttemptID == 0 {
+		start.AttemptID = 1
+	}
 	r, err := e.runs.get(ctx, start.ID)
 	if errors.Is(err, errRunNotFound) {
 		start.Runtime = e.runtime
@@ -358,6 +366,18 @@ func (e *Engine) EnsureRun(ctx context.Context, start run.Start) (bool, error) {
 // Attrs always carry ticket/runID/node/nodeVisitID when known.
 func (e *Engine) SubmitReport(ctx context.Context, req run.ReportRequest) (run.ReportAck, error) {
 	r, err := e.runs.get(ctx, req.RunID)
+	if errors.Is(err, errRunNotFound) {
+		// A retained newer attempt can outlive an old attempt row. Resolve the
+		// stable logical ID and acknowledge the old attempt as a stale
+		// duplicate; it must never be validated or signaled into the new run.
+		logicalID := run.ID(identity.LogicalRunID(req.RunID))
+		if latest, lookupErr := e.runs.findByLogicalID(ctx, logicalID); lookupErr == nil && latest.ID != req.RunID {
+			slog.Info("report duplicate ack", "ticket", latest.Ticket.Key,
+				"runID", string(req.RunID), "logicalRunID", string(logicalID),
+				"node", req.Node, "reportID", req.ReportID, "state", string(latest.State))
+			return run.ReportAck{Accepted: true, Duplicate: true}, nil
+		}
+	}
 	if err != nil {
 		return run.ReportAck{}, fmt.Errorf("resolve run %s: %w", req.RunID, err)
 	}

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\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("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
@@ -81,6 +82,7 @@ type fakeTaskSystem struct {
 	completeFail     int           // next N CompleteMailbox calls return transient error
 	completeConflict bool          // CompleteMailbox returns retry.ConflictError
 	completeSlow     time.Duration // CompleteMailbox sleeps (a running activity)
+	startConflict    bool          // start ApplyTaskConfig returns a status conflict
 	failComments     bool          // Comment returns transient error
 
 	// Recovery fixtures.
@@ -122,6 +124,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()
@@ -148,6 +166,15 @@ func (s *fakeTaskSystem) EnsureMailboxes(_ context.Context, parent task.TicketRe
 
 func (s *fakeTaskSystem) ApplyTaskConfig(_ context.Context, target task.Target, cfg config.RawValues) error {
 	key := target.Parent.Key
+	if target.Mailbox == nil {
+		s.mu.Lock()
+		conflict := s.startConflict
+		s.mu.Unlock()
+		if conflict {
+			s.log.add("applyTaskConfigConflict:" + key)
+			return retry.ConflictError(errStartConflict)
+		}
+	}
 	if target.Mailbox != nil {
 		key = target.Mailbox.Key
 		s.mu.Lock()
@@ -210,6 +237,16 @@ func (s *fakeTaskSystem) Comment(_ context.Context, target task.Target, body, ma
 	return nil
 }
 
+func (s *fakeTaskSystem) PrepareRestart(_ context.Context, parent task.TicketRef, mbs []task.Mailbox) error {
+	s.mu.Lock()
+	for _, mb := range mbs {
+		s.mailboxStatus[mb.Key] = "To Do"
+	}
+	s.mu.Unlock()
+	s.log.add("prepareRestart:" + parent.Key)
+	return nil
+}
+
 func (s *fakeTaskSystem) ResetForRecovery(_ context.Context, parent task.TicketRef, mbs []task.Mailbox, _ config.RawValues) error {
 	s.mu.Lock()
 	for _, mb := range mbs {
@@ -270,6 +307,12 @@ func (s *fakeTaskSystem) setMailboxStatus(key, status string) {
 	s.mu.Unlock()
 }
 
+func (s *fakeTaskSystem) setStartConflict(value bool) {
+	s.mu.Lock()
+	s.startConflict = value
+	s.mu.Unlock()
+}
+
 // seedMailbox pre-populates an existing mailbox (with labels) for recovery
 // and reuse tests.
 func (s *fakeTaskSystem) seedMailbox(parentKey string, mb task.Mailbox, labels []string) {
@@ -328,11 +371,12 @@ func (f *fakeRunner) ValidateRepo(context.Context, string, string) error { retur
 func (f *fakeRunner) EnsureEnvironment(_ context.Context, spec runner.RunSpec) (runner.Environment, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
-	if e, ok := f.envs[string(spec.RunID)]; ok {
+	key := spec.TicketKey
+	if e, ok := f.envs[key]; ok {
 		return e, nil
 	}
-	e := runner.Environment{ID: "env-" + string(spec.RunID), Path: spec.RepoPath}
-	f.envs[string(spec.RunID)] = e
+	e := runner.Environment{ID: "env-" + spec.TicketKey, Path: spec.RepoPath}
+	f.envs[key] = e
 	f.log.add("ensureEnvironment:" + string(spec.RunID))
 	return e, nil
 }
@@ -401,7 +445,7 @@ func (f *fakeRunner) CloseTerminal(_ context.Context, t runner.Terminal) error {
 func (f *fakeRunner) CloseTerminals(_ context.Context, spec runner.RunSpec) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
-	prefix := "env-" + string(spec.RunID) + "/"
+	prefix := "env-" + spec.TicketKey + "/"
 	for k, ft := range f.terminals {
 		if len(k) >= len(prefix) && k[:len(prefix)] == prefix {
 			ft.live = false
@@ -416,13 +460,13 @@ func (f *fakeRunner) CloseTerminals(_ context.Context, spec runner.RunSpec) erro
 func (f *fakeRunner) CleanupRun(_ context.Context, spec runner.RunSpec) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
-	prefix := "env-" + string(spec.RunID) + "/"
+	prefix := "env-" + spec.TicketKey + "/"
 	for k := range f.terminals {
 		if len(k) >= len(prefix) && k[:len(prefix)] == prefix {
 			delete(f.terminals, k)
 		}
 	}
-	delete(f.envs, string(spec.RunID))
+	delete(f.envs, spec.TicketKey)
 	f.cleaned = append(f.cleaned, string(spec.RunID))
 	f.log.add("cleanupRun:" + string(spec.RunID))
 	return nil
@@ -455,16 +499,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 +534,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
@@ -507,3 +580,4 @@ type conflictError struct{ msg string }
 func (e *conflictError) Error() string { return e.msg }
 
 var errConflict = &conflictError{msg: "human moved mailbox"}
+var errStartConflict = &conflictError{msg: "human moved ticket status"}

package/internal/execution/goworkflows/interpreter.go

@@ -57,10 +57,18 @@ func jitter(ctx goworkflow.Context) (float64, error) {
 // deterministic. On cancellation it runs cancellation cleanup on a
 // disconnected context.
 func (a *Activities) TicketWorkflow(ctx goworkflow.Context, start run.Start) error {
+	if start.LogicalID == "" {
+		start.LogicalID = run.ID(identity.LogicalRunID(start.ID))
+	}
+	if start.AttemptID == 0 {
+		start.AttemptID = 1
+	}
 	err := a.runGraph(ctx, start)
 	if err != nil && ctx.Err() != nil {
 		work := run.Work{
 			RunID:              start.ID,
+			LogicalID:          start.LogicalID,
+			AttemptID:          start.AttemptID,
 			Repo:               start.Repo,
 			Workflow:           start.Workflow.Name,
 			Parent:             start.Ticket,
@@ -76,6 +84,8 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 	wf := start.Workflow // value snapshot
 	work := run.Work{
 		RunID:              start.ID,
+		LogicalID:          start.LogicalID,
+		AttemptID:          start.AttemptID,
 		Repo:               start.Repo,
 		Workflow:           wf.Name,
 		Parent:             start.Ticket,
@@ -93,6 +103,26 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 		return err
 	}
 
+	// An explicit restart reuses the task-system mailboxes and ticket
+	// worktree, but resets relay-owned mailbox state and closes stale node
+	// terminals before the fresh start edge is processed. Human-owned
+	// incompatible states are returned as conflicts and keep this attempt
+	// blocked until the human restores a compatible state.
+	if start.AttemptID > 1 {
+		mailboxList := make([]task.Mailbox, 0, len(mailboxes))
+		for _, mailbox := range mailboxes {
+			mailboxList = append(mailboxList, mailbox)
+		}
+		sort.Slice(mailboxList, func(i, j int) bool { return mailboxList[i].Node < mailboxList[j].Node })
+		if _, err := retryLoop(ctx, start.ID, a, work, "start",
+			func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
+				return goworkflow.ExecuteActivity[struct{}](ctx2, noNativeRetries,
+					a.PrepareRestart, work, start.RepoPath, mailboxList)
+			}); err != nil {
+			return err
+		}
+	}
+
 	// Validate every referenced agent before the start edge.
 	agentSet := map[string]bool{}
 	for _, n := range wf.Nodes {
@@ -188,22 +218,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 +232,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 +333,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 +352,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 {
@@ -436,6 +473,7 @@ func retryLoop[T any](ctx goworkflow.Context, id run.ID, a *Activities, work run
 		}
 		f := classifyActivityError(err)
 		if f.Kind == retry.Conflict {
+			f.Message = blockedMessage(work, node, f.Message)
 			// Mark blocked, keep retrying on the capped schedule.
 			_, _ = scheduleState(ctx, a, id, run.StateBlocked, f.Message)
 			blocked = true
@@ -456,6 +494,18 @@ func retryLoop[T any](ctx goworkflow.Context, id run.ID, a *Activities, work run
 	}
 }
 
+func blockedMessage(work run.Work, node, message string) string {
+	message = strings.TrimRight(message, ". ")
+	lower := strings.ToLower(message)
+	if node == "start" && !strings.Contains(lower, "mailbox") {
+		return fmt.Sprintf("%s. Move ticket %s to an allowed active start status; relay-flow will retry automatically", message, work.Parent.Key)
+	}
+	if node != "" {
+		return fmt.Sprintf("%s. Restore the task-system state required for node %s; relay-flow will retry automatically", message, node)
+	}
+	return fmt.Sprintf("%s. Restore the task-system state required by this operation; relay-flow will retry automatically", message)
+}
+
 // logRetry emits the 9.6 retry-classification info line, replay-safe.
 // Attrs come from the always-known run.Work value carried by the caller,
 // so ticket/repo/workflow are present even if the projection is briefly
@@ -558,6 +608,10 @@ func mustJitter(ctx goworkflow.Context) float64 {
 // canceled. No rollback/compensation ever runs.
 func (a *Activities) cancelCleanup(ctx goworkflow.Context, work run.Work, repoPath, reason string) error {
 	dctx := goworkflow.NewDisconnectedContext(ctx)
+	markerID := work.LogicalID
+	if markerID == "" {
+		markerID = work.RunID
+	}
 	if _, err := retryLoop(dctx, work.RunID, a, work, "",
 		func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
 			return goworkflow.ExecuteActivity[struct{}](ctx2, noNativeRetries,
@@ -571,7 +625,7 @@ func (a *Activities) cancelCleanup(ctx goworkflow.Context, work run.Work, repoPa
 				RunID:  work.RunID,
 				Item:   task.Target{Parent: work.Parent},
 				Body:   "Run canceled: " + reason,
-				Marker: run.CancellationMarker(work.RunID),
+				Marker: run.CancellationMarker(markerID),
 			})
 		}); err != nil {
 		return err
@@ -602,12 +656,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)
 }