relay-flow 0.2.0-alpha → 0.2.2-alpha

package/internal/task/jira/rest/client_test.go

@@ -0,0 +1,381 @@
+package rest
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+)
+
+type requestRecord struct {
+	Method string
+	Path   string
+	Body   []byte
+}
+
+type jiraServer struct {
+	t       *testing.T
+	server  *httptest.Server
+	mu      sync.Mutex
+	records []requestRecord
+	handle  func(http.ResponseWriter, *http.Request, []byte)
+}
+
+func newJiraServer(t *testing.T, handle func(http.ResponseWriter, *http.Request, []byte)) *jiraServer {
+	t.Helper()
+	s := &jiraServer{t: t, handle: handle}
+	s.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		body, err := io.ReadAll(r.Body)
+		if err != nil {
+			t.Fatal(err)
+		}
+		user, token, ok := r.BasicAuth()
+		if !ok || user != "bot@example.com" || token != "secret" {
+			http.Error(w, "bad auth", http.StatusUnauthorized)
+			return
+		}
+		s.mu.Lock()
+		s.records = append(s.records, requestRecord{Method: r.Method, Path: r.URL.Path, Body: body})
+		s.mu.Unlock()
+		handle(w, r, body)
+	}))
+	t.Cleanup(s.server.Close)
+	return s
+}
+
+func (s *jiraServer) client(t *testing.T) *HTTPClient {
+	t.Helper()
+	c, err := New(s.server.URL, "bot@example.com", "secret")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return c
+}
+
+func (s *jiraServer) count(method, path string) int {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	n := 0
+	for _, record := range s.records {
+		if record.Method == method && record.Path == path {
+			n++
+		}
+	}
+	return n
+}
+
+func writeJSON(w http.ResponseWriter, value any) {
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(value)
+}
+
+func TestValidateCredentialsUsesMyselfAndBasicAuth(t *testing.T) {
+	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, _ []byte) {
+		if r.Method != http.MethodGet || r.URL.Path != "/rest/api/3/myself" {
+			http.NotFound(w, r)
+			return
+		}
+		writeJSON(w, map[string]any{"accountId": "abc"})
+	})
+	if err := s.client(t).ValidateCredentials(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestNewRejectsNonHTTPSRemoteSite(t *testing.T) {
+	if _, err := New("http://jira.example.com", "bot@example.com", "secret"); err == nil {
+		t.Fatal("insecure remote Jira site accepted")
+	}
+}
+
+func TestSearchPaginatesAndRequestsIssueLinks(t *testing.T) {
+	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, body []byte) {
+		if r.URL.Path != "/rest/api/3/search/jql" || r.Method != http.MethodPost {
+			http.NotFound(w, r)
+			return
+		}
+		var request struct {
+			Fields        []string `json:"fields"`
+			NextPageToken string   `json:"nextPageToken"`
+		}
+		if err := json.Unmarshal(body, &request); err != nil {
+			t.Fatal(err)
+		}
+		if !contains(request.Fields, "issuelinks") {
+			t.Fatalf("search fields = %v, missing issuelinks", request.Fields)
+		}
+		if request.NextPageToken == "" {
+			writeJSON(w, map[string]any{"issues": []any{issue("PAY-1")}, "nextPageToken": "next", "isLast": false})
+			return
+		}
+		writeJSON(w, map[string]any{"issues": []any{issue("PAY-2")}, "isLast": true})
+	})
+	raw, err := s.client(t).Search(context.Background(), "project = PAY")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var issues []json.RawMessage
+	if err := json.Unmarshal(raw, &issues); err != nil || len(issues) != 2 {
+		t.Fatalf("issues = %s, err=%v", raw, err)
+	}
+	if s.count(http.MethodPost, "/rest/api/3/search/jql") != 2 {
+		t.Fatal("search did not use exactly one call per page")
+	}
+}
+
+func issue(key string) map[string]any {
+	return map[string]any{"id": key, "key": key, "fields": map[string]any{
+		"summary": key, "status": map[string]any{"name": "To Do"}, "issuetype": map[string]any{"name": "Task"}, "labels": []string{},
+	}}
+}
+
+func TestCreateSubtasksBatchesAndIncludesADFParentAndLabel(t *testing.T) {
+	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, body []byte) {
+		if r.URL.Path != "/rest/api/3/issue/bulk" {
+			http.NotFound(w, r)
+			return
+		}
+		var request struct {
+			IssueUpdates []struct {
+				Fields map[string]json.RawMessage `json:"fields"`
+			} `json:"issueUpdates"`
+		}
+		if err := json.Unmarshal(body, &request); err != nil {
+			t.Fatal(err)
+		}
+		created := make([]any, len(request.IssueUpdates))
+		for i, update := range request.IssueUpdates {
+			for _, field := range []string{"parent", "description", "labels"} {
+				if len(update.Fields[field]) == 0 {
+					t.Fatalf("bulk create missing %s: %s", field, body)
+				}
+			}
+			if !strings.Contains(string(update.Fields["description"]), `"type":"doc"`) {
+				t.Fatalf("description is not ADF: %s", update.Fields["description"])
+			}
+			created[i] = map[string]any{"id": fmt.Sprint(i + 1), "key": fmt.Sprintf("PAY-%d", i+2)}
+		}
+		writeJSON(w, map[string]any{"issues": created, "errors": []any{}})
+	})
+	client := s.client(t)
+	client.subtaskTypes["PAY"] = "10001"
+	specs := make([]SubtaskSpec, 51)
+	for i := range specs {
+		specs[i] = SubtaskSpec{Title: fmt.Sprintf("PAY-1:n%d", i), Description: "Work:\nDo it"}
+	}
+	created, err := client.CreateSubtasks(context.Background(), "PAY-1", "PAY", "wf:flow", specs)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(created) != 51 || s.count(http.MethodPost, "/rest/api/3/issue/bulk") != 2 {
+		t.Fatalf("created=%d calls=%d, want 51/2", len(created), s.count(http.MethodPost, "/rest/api/3/issue/bulk"))
+	}
+}
+
+func TestTransitionCombinesAssigneeAndCachesLookups(t *testing.T) {
+	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, body []byte) {
+		switch {
+		case r.URL.Path == "/rest/api/3/search/jql":
+			writeJSON(w, map[string]any{"issues": []any{issue("PAY-1")}, "isLast": true})
+		case r.URL.Path == "/rest/api/3/issue/PAY-1/transitions" && r.Method == http.MethodGet:
+			writeJSON(w, map[string]any{"transitions": []any{map[string]any{
+				"id": "21", "to": map[string]any{"name": "In Progress"}, "fields": map[string]any{"assignee": map[string]any{}},
+			}}})
+		case r.URL.Path == "/rest/api/3/user/assignable/search":
+			writeJSON(w, []any{map[string]any{"accountId": "acct", "emailAddress": "worker@example.com"}})
+		case r.URL.Path == "/rest/api/3/issue/PAY-1/transitions" && r.Method == http.MethodPost:
+			if !strings.Contains(string(body), `"assignee":{"accountId":"acct"}`) {
+				t.Fatalf("transition did not include assignee: %s", body)
+			}
+			w.WriteHeader(http.StatusNoContent)
+		default:
+			http.NotFound(w, r)
+		}
+	})
+	c := s.client(t)
+	if _, err := c.Search(context.Background(), "key = PAY-1"); err != nil {
+		t.Fatal(err)
+	}
+	if err := c.Transition(context.Background(), "PAY-1", "In Progress", "worker@example.com"); err != nil {
+		t.Fatal(err)
+	}
+	if s.count(http.MethodPut, "/rest/api/3/issue/PAY-1/assignee") != 0 {
+		t.Fatal("assignment used a separate call despite transition-screen support")
+	}
+}
+
+func TestTransitionFallsBackToSeparateAssignment(t *testing.T) {
+	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, _ []byte) {
+		switch {
+		case r.URL.Path == "/rest/api/3/search/jql":
+			writeJSON(w, map[string]any{"issues": []any{issue("PAY-1")}, "isLast": true})
+		case r.URL.Path == "/rest/api/3/issue/PAY-1/transitions" && r.Method == http.MethodGet:
+			writeJSON(w, map[string]any{"transitions": []any{map[string]any{
+				"id": "21", "to": map[string]any{"name": "In Progress"}, "fields": map[string]any{},
+			}}})
+		case r.URL.Path == "/rest/api/3/user/assignable/search":
+			writeJSON(w, []any{map[string]any{"accountId": "acct", "emailAddress": "worker@example.com"}})
+		case r.URL.Path == "/rest/api/3/issue/PAY-1/assignee" && r.Method == http.MethodPut:
+			w.WriteHeader(http.StatusNoContent)
+		case r.URL.Path == "/rest/api/3/issue/PAY-1/transitions" && r.Method == http.MethodPost:
+			w.WriteHeader(http.StatusNoContent)
+		default:
+			http.NotFound(w, r)
+		}
+	})
+	c := s.client(t)
+	if _, err := c.Search(context.Background(), "key = PAY-1"); err != nil {
+		t.Fatal(err)
+	}
+	if err := c.Transition(context.Background(), "PAY-1", "In Progress", "worker@example.com"); err != nil {
+		t.Fatal(err)
+	}
+	if s.count(http.MethodPut, "/rest/api/3/issue/PAY-1/assignee") != 1 {
+		t.Fatal("transition without assignee field did not use assignment fallback")
+	}
+}
+
+func TestUpdateMailboxIsOneCall(t *testing.T) {
+	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, body []byte) {
+		if r.Method != http.MethodPut || r.URL.Path != "/rest/api/3/issue/PAY-2" {
+			http.NotFound(w, r)
+			return
+		}
+		if !strings.Contains(string(body), `"description"`) || !strings.Contains(string(body), `"labels"`) {
+			t.Fatalf("combined update missing fields: %s", body)
+		}
+		w.WriteHeader(http.StatusNoContent)
+	})
+	if err := s.client(t).UpdateMailbox(context.Background(), "PAY-2", "Work:\nDo it", "wf:flow"); err != nil {
+		t.Fatal(err)
+	}
+	if s.count(http.MethodPut, "/rest/api/3/issue/PAY-2") != 1 {
+		t.Fatal("mailbox reconciliation was not one call")
+	}
+}
+
+func TestEnsureLabelIsOneAddCall(t *testing.T) {
+	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, body []byte) {
+		if r.Method != http.MethodPut || r.URL.Path != "/rest/api/3/issue/PAY-1" {
+			http.NotFound(w, r)
+			return
+		}
+		if !strings.Contains(string(body), `"add":"wf:flow"`) {
+			t.Fatalf("label update = %s", body)
+		}
+		w.WriteHeader(http.StatusNoContent)
+	})
+	if err := s.client(t).EnsureLabel(context.Background(), "PAY-1", "wf:flow"); err != nil {
+		t.Fatal(err)
+	}
+	if s.count(http.MethodPut, "/rest/api/3/issue/PAY-1") != 1 {
+		t.Fatal("claim label was not one call")
+	}
+}
+
+func TestTransitionAlreadyAtTargetMakesNoTransitionCall(t *testing.T) {
+	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, _ []byte) {
+		if r.URL.Path == "/rest/api/3/search/jql" {
+			item := issue("PAY-1")
+			item["fields"].(map[string]any)["status"] = map[string]any{"name": "Done"}
+			writeJSON(w, map[string]any{"issues": []any{item}, "isLast": true})
+			return
+		}
+		http.NotFound(w, r)
+	})
+	c := s.client(t)
+	if _, err := c.Search(context.Background(), "key = PAY-1"); err != nil {
+		t.Fatal(err)
+	}
+	if err := c.Transition(context.Background(), "PAY-1", "Done", ""); err != nil {
+		t.Fatal(err)
+	}
+	if s.count(http.MethodGet, "/rest/api/3/issue/PAY-1/transitions") != 0 {
+		t.Fatal("already-completed issue queried transitions")
+	}
+}
+
+func TestCommentsUseADFAndParseMarker(t *testing.T) {
+	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, body []byte) {
+		if r.URL.Path != "/rest/api/3/issue/PAY-2/comment" {
+			http.NotFound(w, r)
+			return
+		}
+		if r.Method == http.MethodGet {
+			writeJSON(w, map[string]any{"comments": []any{map[string]any{"body": ADF("summary\n\n<!-- visit:summary -->")}}, "startAt": 0, "total": 1})
+			return
+		}
+		if !strings.Contains(string(body), `"type":"doc"`) {
+			t.Fatalf("comment is not ADF: %s", body)
+		}
+		w.WriteHeader(http.StatusCreated)
+	})
+	c := s.client(t)
+	comments, err := c.ListComments(context.Background(), "PAY-2")
+	if err != nil || len(comments) != 1 || !strings.Contains(comments[0], "visit:summary") {
+		t.Fatalf("comments=%v err=%v", comments, err)
+	}
+	if err := c.AddComment(context.Background(), "PAY-2", "SUMMARY:\nDone"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestRetries429WithoutExposingCredentials(t *testing.T) {
+	calls := 0
+	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, _ []byte) {
+		calls++
+		if calls == 1 {
+			w.Header().Set("Retry-After", "0")
+			http.Error(w, "limited", http.StatusTooManyRequests)
+			return
+		}
+		writeJSON(w, map[string]any{"accountId": "abc"})
+	})
+	if err := s.client(t).ValidateCredentials(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	if calls != 2 {
+		t.Fatalf("calls=%d, want one retry", calls)
+	}
+}
+
+func TestErrorRedactsToken(t *testing.T) {
+	s := newJiraServer(t, func(w http.ResponseWriter, _ *http.Request, _ []byte) {
+		http.Error(w, "rejected secret for bot@example.com", http.StatusUnauthorized)
+	})
+	err := s.client(t).ValidateCredentials(context.Background())
+	if err == nil || strings.Contains(err.Error(), "secret") || strings.Contains(err.Error(), "bot@example.com") {
+		t.Fatalf("error did not redact Jira credentials: %v", err)
+	}
+}
+
+func TestADFFormatsHeadingsListsAndRoundTripsMarker(t *testing.T) {
+	doc := ADF("### Summary\n\n**Node:** implement\n\n- first\n- second\n\n```\ngo test ./...\n```\n\n<!-- visit:summary -->")
+	raw, err := json.Marshal(doc)
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(raw)
+	for _, want := range []string{`"type":"heading"`, `"type":"bulletList"`, `"type":"codeBlock"`, `"type":"strong"`} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("ADF %s missing %s", text, want)
+		}
+	}
+	if got := ADFText(raw); !strings.Contains(got, "visit:summary") {
+		t.Fatalf("ADF marker round trip = %q", got)
+	}
+}
+
+func contains(values []string, want string) bool {
+	for _, value := range values {
+		if value == want {
+			return true
+		}
+	}
+	return false
+}

package/internal/task/jira/templates_test.go

@@ -0,0 +1,118 @@
+package jira
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/run"
+	"github.com/rajpopat27/relay-flow/internal/task"
+)
+
+func TestTaskTextTemplatesExposeValues(t *testing.T) {
+	fake := &fakeJira{}
+	sys, err := newSystem(context.Background(), &fakeClient{fake: fake}, task.RepoSpec{
+		Name: "payments",
+		RootConfig: config.RawValues{"templates": map[string]any{
+			"mailboxDescription": "mailbox {{runID}}|{{ticket}}|{{workflow}}|{{repo}}|{{node}}|{{nodeType}}|{{agent}}|{{nodeDescription}}|{{nextSteps}}|{{successRoutes}}|{{failureRoutes}}|{{mailbox}}",
+			"summaryComment":     "summary {{sourceNode}}|{{targetNode}}|{{mailbox}}\n{{summaryReport}}",
+			"feedbackComment":    "feedback {{sourceNode}}|{{targetNode}}|{{mailbox}}\n{{feedbackReport}}",
+		}},
+		RepoConfig: config.RawValues{"project": "PAY", "component": "api"},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	data := task.TextData{
+		RunID: "run-1", Ticket: "PAY-1", Workflow: "flow", Repo: "payments",
+		Node: "review", NodeType: "hitl", Agent: "reviewer", NodeDescription: "Review changes.",
+		NextSteps: "implement; end", SuccessRoutes: "end", FailureRoutes: "implement",
+		Mailbox: "PAY-3", SourceNode: "review", TargetNode: "implement",
+		SummaryReport: "COMPLETED:\nreviewed", FeedbackReport: "REQUIRED ACTIONS:\nfix it",
+	}
+	description, err := sys.RenderText(task.TextMailboxDescription, data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"run-1", "PAY-1", "flow", "payments", "review", "hitl", "reviewer", "Review changes.", "implement; end", "PAY-3"} {
+		if !strings.Contains(description, want) {
+			t.Fatalf("description missing %q: %q", want, description)
+		}
+	}
+	summary, err := sys.RenderText(task.TextSummaryComment, data)
+	if err != nil || !strings.Contains(summary, data.SummaryReport) {
+		t.Fatalf("summary = %q, %v", summary, err)
+	}
+	feedback, err := sys.RenderText(task.TextFeedbackComment, data)
+	if err != nil || !strings.Contains(feedback, "feedback review|implement|PAY-3") || !strings.Contains(feedback, data.FeedbackReport) {
+		t.Fatalf("feedback = %q, %v", feedback, err)
+	}
+}
+
+func TestCommentTemplatesRequireReportValues(t *testing.T) {
+	for _, tc := range []struct {
+		name      string
+		override  map[string]any
+		wantError string
+	}{
+		{name: "summary", override: map[string]any{"summaryComment": "missing"}, wantError: "summaryComment must contain {{summaryReport}}"},
+		{name: "feedback", override: map[string]any{"feedbackComment": "missing"}, wantError: "feedbackComment must contain {{feedbackReport}}"},
+		{name: "unknown", override: map[string]any{"mailboxDescription": "{{mailboxInstructions}}"}, wantError: "unknown template variable {{mailboxInstructions}}"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			raw := config.Merge(DefaultConfig(), config.RawValues{"templates": tc.override})
+			var cfg Config
+			if err := config.DecodeStrict(raw, &cfg); err != nil {
+				t.Fatal(err)
+			}
+			err := validateTemplates(cfg.Templates)
+			if err == nil || !strings.Contains(err.Error(), tc.wantError) {
+				t.Fatalf("validateTemplates error = %v, want %q", err, tc.wantError)
+			}
+		})
+	}
+}
+
+func TestTaskTemplatesRenderSharedReportContractValues(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"]
+	sys, err := newSystem(context.Background(), &fakeClient{fake: &fakeJira{}}, task.RepoSpec{
+		Name: "payments", RepoConfig: config.RawValues{"project": "PAY", "component": "api"},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	data := task.TextData{
+		Node: "coding", SourceNode: "coding", TargetNode: "coding", Mailbox: "PAY-101:coding",
+		SummaryReport: fixture.SummaryReport, FeedbackReport: fixture.FeedbackReport,
+	}
+	summary, err := sys.RenderText(task.TextSummaryComment, data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if summary != "Summary for coding\n\n"+fixture.SummaryReport {
+		t.Fatalf("summary template did not render shared summaryReport:\n%s", summary)
+	}
+	feedback, err := sys.RenderText(task.TextFeedbackComment, data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantFeedback := "Feedback from coding to coding mailbox PAY-101:coding\n\n" + fixture.FeedbackReport
+	if feedback != wantFeedback {
+		t.Fatalf("feedback template did not render shared feedbackReport:\n%s", feedback)
+	}
+}

package/internal/task/jira/transition_defaults_test.go

@@ -16,23 +16,26 @@ import (
 // leaves the parent unchanged.
 //
 // This test is package-local (package jira) so it can drive the adapter's
-// ApplyTaskConfig against a test-local fake ACLI without inventing an
+// ApplyTaskConfig against a test-local fake client without inventing an
 // exported production constructor seam. The adapter resolves defaults
 // internally; the fake records the transitions the adapter issues.
 
-// fakeACLI is a test-local fakeable ACLI boundary recording transitions and
+// fakeJira is a test-local fakeable Jira boundary recording transitions and
 // serving a fixed search batch for Poll.
-type fakeACLI struct {
+type fakeJira struct {
 	parentTransitions []string
 	taskTransitions   []string
 	assignments       []string
 	assignErr         error
 	events            []string
 	// searchJSON is the raw Jira search response Poll serves.
-	searchJSON []byte
+	searchJSON    []byte
+	comments      []string
+	addedComments []string
+	labelCalls    []string
 }
 
-func (f *fakeACLI) transition(key, status string) {
+func (f *fakeJira) transition(key, status string) {
 	if key == "PAY-101" {
 		f.parentTransitions = append(f.parentTransitions, status)
 	} else {
@@ -40,9 +43,8 @@ func (f *fakeACLI) transition(key, status string) {
 	}
 }
 
-// newSystemWithFake builds the adapter around the test-local fake ACLI. The
-// adapter owns its ACLI wiring; the test injects only the CLI seam.
-func newSystemWithFake(t *testing.T, fake *fakeACLI) task.System {
+// newSystemWithFake builds the adapter around the test-local Jira client.
+func newSystemWithFake(t *testing.T, fake *fakeJira) task.System {
 	t.Helper()
 	sys, err := newSystemForTest(fake)
 	if err != nil {
@@ -52,7 +54,7 @@ func newSystemWithFake(t *testing.T, fake *fakeACLI) task.System {
 }
 
 func TestStartDefaultParentInProgress(t *testing.T) {
-	fake := &fakeACLI{}
+	fake := &fakeJira{}
 	sys := newSystemWithFake(t, fake)
 	parent := task.TicketRef{ID: "1", Key: "PAY-101", Title: "parent"}
 
@@ -66,7 +68,7 @@ func TestStartDefaultParentInProgress(t *testing.T) {
 }
 
 func TestWorkNodeDefaultMailboxInProgressParentUnchanged(t *testing.T) {
-	fake := &fakeACLI{}
+	fake := &fakeJira{}
 	sys := newSystemWithFake(t, fake)
 	parent := task.TicketRef{ID: "1", Key: "PAY-101", Title: "parent"}
 	mb := task.Mailbox{ID: "2", Key: "PAY-102", Node: "coding"}
@@ -86,7 +88,7 @@ func TestWorkNodeDefaultMailboxInProgressParentUnchanged(t *testing.T) {
 }
 
 func TestWorkNodeAssignsMailboxBeforeTransition(t *testing.T) {
-	fake := &fakeACLI{}
+	fake := &fakeJira{}
 	sys := newSystemWithFake(t, fake)
 	parent := task.TicketRef{ID: "1", Key: "PAY-101", Title: "parent"}
 	mb := task.Mailbox{ID: "2", Key: "PAY-102", Node: "coding"}
@@ -100,13 +102,13 @@ func TestWorkNodeAssignsMailboxBeforeTransition(t *testing.T) {
 	if len(fake.assignments) != 1 || fake.assignments[0] != "PAY-102:reviewer@example.com" {
 		t.Fatalf("mailbox assignments = %v, want [PAY-102:reviewer@example.com]", fake.assignments)
 	}
-	if len(fake.events) != 2 || fake.events[0] != "assign" || fake.events[1] != "transition" {
-		t.Fatalf("mailbox events = %v, want [assign transition]", fake.events)
+	if len(fake.events) != 1 || fake.events[0] != "transition" {
+		t.Fatalf("mailbox events = %v, want one combined transition", fake.events)
 	}
 }
 
 func TestWorkNodeAssignmentFailurePreventsTransition(t *testing.T) {
-	fake := &fakeACLI{assignErr: errors.New("assignment failed")}
+	fake := &fakeJira{assignErr: errors.New("assignment failed")}
 	sys := newSystemWithFake(t, fake)
 	parent := task.TicketRef{ID: "1", Key: "PAY-101", Title: "parent"}
 	mb := task.Mailbox{ID: "2", Key: "PAY-102", Node: "coding"}
@@ -120,14 +122,16 @@ func TestWorkNodeAssignmentFailurePreventsTransition(t *testing.T) {
 }
 
 func TestEndDefaultParentDone(t *testing.T) {
-	fake := &fakeACLI{}
+	fake := &fakeJira{}
 	sys := newSystemWithFake(t, fake)
 	parent := task.TicketRef{ID: "1", Key: "PAY-101", Title: "parent"}
 
 	// end: omitted transitionTo. The end effective config carries no
 	// transition; the adapter must still default the parent to Done. Run
-	// orchestration applies the end node config to the parent target.
-	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent}, endConfig(config.RawValues{})); err != nil {
+	// orchestration merges EndDefaults under the end node config before
+	// applying it to the parent target.
+	endCfg := config.Merge(sys.(task.LifecycleDefaults).EndDefaults(), config.RawValues{})
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent}, endCfg); err != nil {
 		t.Fatalf("ApplyTaskConfig end failed: %v", err)
 	}
 	if len(fake.parentTransitions) != 1 || fake.parentTransitions[0] != "Done" {
@@ -136,7 +140,7 @@ func TestEndDefaultParentDone(t *testing.T) {
 }
 
 func TestExplicitTransitionsWin(t *testing.T) {
-	fake := &fakeACLI{}
+	fake := &fakeJira{}
 	sys := newSystemWithFake(t, fake)
 	parent := task.TicketRef{ID: "1", Key: "PAY-101", Title: "parent"}
 	mb := task.Mailbox{ID: "2", Key: "PAY-102", Node: "review"}

package/internal/task/jira/validation_test.go

@@ -16,7 +16,7 @@ type validationClient struct {
 	statuses  []string
 }
 
-func (c *validationClient) ValidateAssignee(_ context.Context, assignee string) error {
+func (c *validationClient) ValidateAssignee(_ context.Context, _ string, assignee string) error {
 	c.assignees = append(c.assignees, assignee)
 	if assignee == "missing" {
 		return errors.New("invalid assignee")

package/internal/task/task.go

@@ -37,6 +37,37 @@ type MailboxSpec struct {
 	Title       string           `json:"title"`
 	Description string           `json:"description"`
 	TaskConfig  config.RawValues `json:"taskConfig,omitempty"`
+	TextData    TextData         `json:"textData"`
+}
+
+type TextKind string
+
+const (
+	TextMailboxDescription TextKind = "mailboxDescription"
+	TextSummaryComment     TextKind = "summaryComment"
+	TextFeedbackComment    TextKind = "feedbackComment"
+)
+
+// TextData contains existing run, mailbox, and node values supplied to a
+// task-system text template. The task system owns rendering; harness prompt
+// templates are a separate contract.
+type TextData struct {
+	RunID           string
+	Ticket          string
+	Workflow        string
+	Repo            string
+	Node            string
+	NodeType        string
+	Agent           string
+	NodeDescription string
+	NextSteps       string
+	SuccessRoutes   string
+	FailureRoutes   string
+	Mailbox         string
+	SourceNode      string
+	TargetNode      string
+	SummaryReport   string
+	FeedbackReport  string
 }
 
 type Target struct {
@@ -59,6 +90,7 @@ type System interface {
 	Claim(ctx context.Context, ticket TicketRef, workflow string) error
 
 	ValidateConfig(ctx context.Context, workflowTaskConfig config.RawValues, nodeTaskConfigs map[string]config.RawValues) error
+	RenderText(kind TextKind, data TextData) (string, error)
 	EnsureMailboxes(ctx context.Context, parent TicketRef, workflow string, specs []MailboxSpec) (map[string]Mailbox, error)
 	ApplyTaskConfig(ctx context.Context, target Target, taskConfig config.RawValues) error
 	CompleteMailbox(ctx context.Context, mailbox Mailbox) error