relay-flow 0.3.1-alpha → 0.3.3-alpha

package/README.md

@@ -24,13 +24,13 @@ same `relay-flow-plugin` package with host-specific entrypoints.
 **OpenCode**
 
 ```sh
-opencode plugin relay-flow-plugin@0.3.1-alpha
+opencode plugin relay-flow-plugin@0.3.3-alpha
 ```
 
 **Pi**
 
 ```sh
-pi install npm:relay-flow-plugin@0.3.1-alpha
+pi install npm:relay-flow-plugin@0.3.3-alpha
 ```
 
 Pi loads the package's `pi.ts` extension from its manifest. Do not add
@@ -160,7 +160,7 @@ OpenCode plugin configuration uses both entrypoints. The server entrypoint is li
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": ["relay-flow-plugin@0.3.1-alpha"]
+  "plugin": ["relay-flow-plugin@0.3.3-alpha"]
 }
 ```
 
@@ -169,7 +169,7 @@ The native HITL approval entrypoint is listed in `.opencode/tui.json`:
 ```json
 {
   "$schema": "https://opencode.ai/tui.json",
-  "plugin": ["relay-flow-plugin@0.3.1-alpha"]
+  "plugin": ["relay-flow-plugin@0.3.3-alpha"]
 }
 ```
 
@@ -185,7 +185,7 @@ Pi plugin: install the same published package manually in Pi's global package
 settings before starting a Pi harness session:
 
 ```sh
-pi install npm:relay-flow-plugin@0.3.1-alpha
+pi install npm:relay-flow-plugin@0.3.3-alpha
 ```
 
 Relay-flow does not install or configure the package automatically. Pi resolves
@@ -379,7 +379,7 @@ Jira and Beads use the same conceptual `Task` issue type, but each adapter
 keeps its provider-native spelling: Jira uses `Task` and Beads uses `task`.
 Filter values are exact and are not translated between providers.
 
-The supported Beads status names are `open`, `in_progress`, `blocked`, `deferred`, `hooked`, and `closed`. The claimed-parent poll uses the canonical active set `open,in_progress,blocked,deferred`; it intentionally does not substitute `hooked` for `deferred`. Omitted lifecycle settings move the parent to `in_progress` at `start`, a work-node mailbox to `in_progress`, and the parent to `closed` at `end` — the same shape as Jira, with Beads-native values. Relay-flow creates one Repo Poller per registered repo, not one poller per workflow. Each poll reads ready top-level parents and relay-owned active parents, deduplicates them, and never routes mailbox children. Claims are permanent `wf:<workflow>` labels.
+The supported Beads status names are `open`, `in_progress`, `blocked`, `deferred`, `hooked`, and `closed`. The claimed-parent poll uses the canonical active set `open,in_progress,blocked,deferred`; it intentionally does not substitute `hooked` for `deferred`. Omitted lifecycle settings move the parent to `in_progress` at `start`, both the parent and current work-node mailbox to `in_progress` when work begins, and the parent to `closed` at `end` — the same shape as Jira, with Beads-native values. Relay-flow creates one Repo Poller per registered repo, not one poller per workflow. Each poll reads ready top-level parents and relay-owned active parents, deduplicates them, and never routes mailbox children. Claims are permanent `wf:<workflow>` labels.
 
 Beads does not need relay-flow credentials or a Beads-specific poller. In server mode, leave Dolt and Beads server setup running outside relay-flow; each registered code repository still supplies its `beadsDir`, and repositories that share that workspace are isolated by their derived `repo:` labels.
 
@@ -494,18 +494,18 @@ Rules enforced at submit:
 
 ### Jira transition defaults
 
-Omitted transitions default to:
+Omitted transitions use the repository-configured Jira lifecycle statuses:
 
-- `start`: parent → `In Progress`
-- work node: mailbox → `In Progress` (parent unchanged)
-- `end`: parent → `Done`
+- `start`: parent → `statusDefaults.start`
+- work node: parent and current mailbox → `statusDefaults.work` before the node runtime launches
+- `end`: parent → `statusDefaults.end`
 
 ### Beads transition defaults
 
 Beads follows the same lifecycle shape with Beads-native values:
 
 - `start`: parent → `in_progress`
-- work node: mailbox → `in_progress` (parent unchanged)
+- work node: parent and mailbox → `in_progress`
 - `end`: parent → `closed`
 
 A parent moved to `in_progress` stays visible to the claimed-parent poll, which reads `open,in_progress,blocked,deferred`. Entering a node reuses that node's mailbox: a fresh mailbox moves `open → in_progress` and a revisited one moves `closed → in_progress`. Beads reads the issue before every status write, so an already-applied status is a no-op and a status relay-flow did not set (for example a human marking an issue `blocked`) blocks the transition and retries instead of being overwritten.

package/cmd/relay-flow/main.go

@@ -853,8 +853,8 @@ func cmdServe(p paths.Paths, args []string) int {
 }
 
 var (
-	backgroundServeStartupTimeout = 10 * time.Second
-	backgroundServePollInterval   = 50 * time.Millisecond
+	backgroundServeStartupTimeout = 5 * time.Minute
+	backgroundServePollInterval   = 250 * time.Millisecond
 )
 
 func startBackgroundServe(p paths.Paths, recover, debug bool) error {

package/examples/beads-workflow.yaml

@@ -30,7 +30,7 @@ taskConfig:
 
 # transitionTo describes one lifecycle point, so configure it on a node.
 # Omitting it entirely already gives the Jira-equivalent lifecycle:
-# start parent -> in_progress, work mailbox -> in_progress, end parent -> closed.
+# start parent -> in_progress, work parent and mailbox -> in_progress, end parent -> closed.
 # Values are Beads-native, not Jira values such as "In Progress" or "Done".
 nodes:
   start:

package/internal/harness/opencode/opencode_test.go

@@ -14,7 +14,7 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
-const configuredPlugin = "relay-flow-plugin@0.3.1-alpha"
+const configuredPlugin = "relay-flow-plugin@0.3.3-alpha"
 
 func TestBuildCommandArgv(t *testing.T) {
 	t.Setenv("RELAY_FLOW_HOME", "/var/lib/relay-flow-test")

package/internal/harness/opencode/repo_setup.go

@@ -10,7 +10,7 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/config"
 )
 
-const relayFlowPlugin = "relay-flow-plugin@0.3.1-alpha"
+const relayFlowPlugin = "relay-flow-plugin@0.3.3-alpha"
 
 type jsoncToken struct {
 	kind       byte

package/internal/task/beads/beads.go

@@ -851,9 +851,12 @@ func (s *system) StartDefaults() config.RawValues {
 	return s.lifecycleDefaults(transitionDefault("parentStatus", statusInProgress))
 }
 
-// WorkDefaults starts a work mailbox in progress and leaves the parent alone.
+// WorkDefaults starts both the parent and current mailbox in progress.
 func (s *system) WorkDefaults() config.RawValues {
-	return s.lifecycleDefaults(transitionDefault("taskStatus", statusInProgress))
+	return s.lifecycleDefaults(config.RawValues{"transitionTo": map[string]any{
+		"parentStatus": statusInProgress,
+		"taskStatus":   statusInProgress,
+	}})
 }
 
 // EndDefaults closes the parent after workflow completion.

package/internal/task/beads/lifecycle_inheritance_test.go

@@ -60,7 +60,7 @@ func TestLifecycleDefaultsCarryInheritedTransitionTo(t *testing.T) {
 	})
 
 	t.Run("repo taskStatus reaches a work node", func(t *testing.T) {
-		client := newStatusClient(map[string]string{"demo-parent.1": "open"})
+		client := newStatusClient(map[string]string{"demo-parent": "open", "demo-parent.1": "open"})
 		sys := repoScopedSystem(client, config.RawValues{
 			"transitionTo": map[string]any{"taskStatus": "blocked"},
 		})
@@ -69,26 +69,30 @@ func TestLifecycleDefaultsCarryInheritedTransitionTo(t *testing.T) {
 		if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), cfg); err != nil {
 			t.Fatal(err)
 		}
-		if len(client.updates) != 1 || client.updates[0].input.Status != "blocked" {
-			t.Fatalf("updates = %+v, want the inherited repo value to beat the built-in default", client.updates)
+		if len(client.updates) != 2 || client.updates[0].issueID != "demo-parent.1" || client.updates[0].input.Status != "blocked" ||
+			client.updates[1].issueID != "demo-parent" || client.updates[1].input.Status != statusInProgress {
+			t.Fatalf("updates = %+v, want inherited mailbox value followed by built-in parent work value", client.updates)
 		}
 	})
 }
 
 func TestLifecycleDefaultsCarryInheritedAssignee(t *testing.T) {
-	client := newStatusClient(map[string]string{"demo-parent.1": "open"})
+	client := newStatusClient(map[string]string{"demo-parent": "open", "demo-parent.1": "open"})
 	sys := repoScopedSystem(client, config.RawValues{"assignee": "repo-bot@example.com"})
 	cfg := operationConfig(lifecycleDefaultsOf(t, sys).WorkDefaults(), nil, nil)
 
 	if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), cfg); err != nil {
 		t.Fatal(err)
 	}
-	if len(client.updates) != 1 {
-		t.Fatalf("updates = %+v, want one combined update", client.updates)
+	if len(client.updates) != 2 {
+		t.Fatalf("updates = %+v, want mailbox and parent updates", client.updates)
 	}
-	update := client.updates[0].input
-	if update.Status != "in_progress" || update.Assignee != "repo-bot@example.com" {
-		t.Fatalf("update = %+v, want the built-in status plus the inherited repo assignee", update)
+	mailboxUpdate := client.updates[0].input
+	if mailboxUpdate.Status != "in_progress" || mailboxUpdate.Assignee != "repo-bot@example.com" {
+		t.Fatalf("mailbox update = %+v, want the built-in status plus the inherited repo assignee", mailboxUpdate)
+	}
+	if client.updates[1].issueID != "demo-parent" || client.updates[1].input.Status != statusInProgress {
+		t.Fatalf("parent update = %+v, want built-in parent work status", client.updates[1])
 	}
 }
 
@@ -113,7 +117,7 @@ func TestLifecycleDefaultsPrecedenceDefaultRepoWorkflowNode(t *testing.T) {
 		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
-			client := newStatusClient(map[string]string{"demo-parent.1": "open"})
+			client := newStatusClient(map[string]string{"demo-parent": "open", "demo-parent.1": "open"})
 			sys := repoScopedSystem(client, config.RawValues{
 				"transitionTo": map[string]any{"taskStatus": "blocked"},
 			})
@@ -122,13 +126,41 @@ func TestLifecycleDefaultsPrecedenceDefaultRepoWorkflowNode(t *testing.T) {
 			if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), cfg); err != nil {
 				t.Fatal(err)
 			}
-			if len(client.updates) != 1 || client.updates[0].input.Status != tc.want {
-				t.Fatalf("updates = %+v, want [%s]", client.updates, tc.want)
+			if len(client.updates) != 2 || client.updates[0].input.Status != tc.want ||
+				client.updates[1].issueID != "demo-parent" || client.updates[1].input.Status != statusInProgress {
+				t.Fatalf("updates = %+v, want mailbox %s followed by parent %s", client.updates, tc.want, statusInProgress)
 			}
 		})
 	}
 }
 
+func TestWorkDefaultsUseParentAndMailboxInProgress(t *testing.T) {
+	sys := repoScopedSystem(newStatusClient(nil), nil)
+	transition, ok := sys.WorkDefaults()["transitionTo"].(map[string]any)
+	if !ok {
+		t.Fatalf("WorkDefaults transitionTo = %#v, want map", sys.WorkDefaults()["transitionTo"])
+	}
+	if transition["parentStatus"] != statusInProgress || transition["taskStatus"] != statusInProgress {
+		t.Fatalf("WorkDefaults transitionTo = %#v, want both statuses %s", transition, statusInProgress)
+	}
+}
+
+func TestWorkNodeParentAndTaskOverridesAreIndependent(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent": "open", "demo-parent.1": "in_progress"})
+	sys := repoScopedSystem(client, nil)
+	cfg := operationConfig(lifecycleDefaultsOf(t, sys).WorkDefaults(),
+		config.RawValues{"transitionTo": map[string]any{"parentStatus": "closed"}},
+		config.RawValues{"transitionTo": map[string]any{"taskStatus": "closed"}})
+
+	if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), cfg); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.updates) != 2 || client.updates[0].issueID != "demo-parent.1" || client.updates[0].input.Status != "closed" ||
+		client.updates[1].issueID != "demo-parent" || client.updates[1].input.Status != "closed" {
+		t.Fatalf("updates = %+v, want independent mailbox and parent overrides", client.updates)
+	}
+}
+
 // With nothing inherited, the built-in lifecycle values still apply: the
 // parent opens the run in_progress, a work mailbox moves to in_progress, and
 // the parent closes at end.

package/internal/task/beads/runtime_config_test.go

@@ -13,7 +13,7 @@ import (
 // mirrored by the Jira adapter.
 
 func TestNodeAssigneeOverridesInheritedRepoAssignee(t *testing.T) {
-	client := newStatusClient(map[string]string{"demo-parent.1": "open"})
+	client := newStatusClient(map[string]string{"demo-parent": "open", "demo-parent.1": "open"})
 	sys := repoScopedSystem(client, config.RawValues{"assignee": "repo-bot@example.com"})
 	node := config.RawValues{"assignee": "dev@example.com"}
 
@@ -21,8 +21,9 @@ func TestNodeAssigneeOverridesInheritedRepoAssignee(t *testing.T) {
 	if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), cfg); err != nil {
 		t.Fatal(err)
 	}
-	if len(client.updates) != 1 || client.updates[0].input.Assignee != "dev@example.com" {
-		t.Fatalf("updates = %+v, want the node assignee to win", client.updates)
+	if len(client.updates) != 2 || client.updates[0].input.Assignee != "dev@example.com" ||
+		client.updates[1].issueID != "demo-parent" || client.updates[1].input.Status != statusInProgress {
+		t.Fatalf("updates = %+v, want node assignee on mailbox and work status on parent", client.updates)
 	}
 }
 

package/internal/task/beads/status_test.go

@@ -115,6 +115,40 @@ func TestApplyTaskConfigParentStatusUsesReadBeforeWrite(t *testing.T) {
 	}
 }
 
+func TestWorkNodeParentTransitionIsIdempotentAcrossEntries(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent": "open", "demo-parent.1": "open"})
+	sys := &system{cli: client}
+	target := statusTarget("demo-parent.1")
+	defaults := sys.WorkDefaults()
+
+	if err := sys.ApplyTaskConfig(context.Background(), target, defaults); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.ApplyTaskConfig(context.Background(), target, defaults); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.updates) != 2 || client.updates[0].issueID != "demo-parent.1" || client.updates[0].input.Status != statusInProgress ||
+		client.updates[1].issueID != "demo-parent" || client.updates[1].input.Status != statusInProgress {
+		t.Fatalf("updates = %+v, want only first mailbox and parent transitions", client.updates)
+	}
+}
+
+func TestWorkNodeIncompatibleParentStateReturnsConflict(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent": "blocked", "demo-parent.1": "open"})
+	sys := &system{cli: client}
+
+	err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), sys.WorkDefaults())
+	if err == nil {
+		t.Fatal("incompatible parent status was accepted")
+	}
+	if got := retry.Classify(err).Kind; got != retry.Conflict {
+		t.Fatalf("failure kind = %q, want conflict: %v", got, err)
+	}
+	if len(client.updates) != 1 || client.updates[0].issueID != "demo-parent.1" {
+		t.Fatalf("updates = %+v, want only the mailbox update before parent conflict", client.updates)
+	}
+}
+
 func TestCompleteMailboxUsesReadBeforeWriteAndIsIdempotent(t *testing.T) {
 	client := newStatusClient(map[string]string{"demo-parent.1": "in_progress"})
 	sys := &system{cli: client}

package/internal/task/jira/jira.go

@@ -643,10 +643,14 @@ func (s *system) StartDefaults() config.RawValues {
 	return s.lifecycleDefaults(transitionDefault("parentStatus", s.startStatus()))
 }
 
-// WorkDefaults uses the repository-selected active mailbox status; the parent
-// is left unchanged when parentStatus is omitted.
+// WorkDefaults uses the repository-selected active status for both the parent
+// and the current mailbox.
 func (s *system) WorkDefaults() config.RawValues {
-	return s.lifecycleDefaults(transitionDefault("taskStatus", s.workStatus()))
+	status := s.workStatus()
+	return s.lifecycleDefaults(config.RawValues{"transitionTo": map[string]any{
+		"parentStatus": status,
+		"taskStatus":   status,
+	}})
 }
 
 // EndDefaults uses the repository-selected parent completion status.
@@ -740,9 +744,9 @@ func (s *system) EnsureMailboxes(ctx context.Context, parent task.TicketRef, wor
 
 // ApplyTaskConfig applies the adapter-owned taskConfig to the parent and
 // optional mailbox. An omitted work-node taskStatus uses the repository's
-// selected work status and leaves the parent unchanged; an omitted
-// parent-only parentStatus uses the selected start status. Run orchestration
-// merges EndDefaults into the end node's config before that call.
+// selected work status. Run orchestration merges WorkDefaults or EndDefaults
+// into the node config before that call, so omitted work-node defaults apply
+// the selected work status to both the parent and mailbox.
 func (s *system) ApplyTaskConfig(ctx context.Context, target task.Target, taskConfig config.RawValues) error {
 	cfg, err := decodeConfig(taskConfig)
 	if err != nil {

package/internal/task/jira/lifecycle_inheritance_test.go

@@ -85,6 +85,9 @@ func TestLifecycleDefaultsCarryInheritedTransitionTo(t *testing.T) {
 			t.Fatalf("mailbox transitions = %v, want the inherited repo value to beat the registered lifecycle value",
 				fake.taskTransitions)
 		}
+		if len(fake.parentTransitions) != 1 || fake.parentTransitions[0] != defaultWorkTaskStatus {
+			t.Fatalf("parent transitions = %v, want the built-in work value", fake.parentTransitions)
+		}
 	})
 }
 
@@ -160,8 +163,8 @@ func TestLifecycleDefaultsWithoutInheritedValues(t *testing.T) {
 	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent}, operationConfig(d.EndDefaults(), nil, nil)); err != nil {
 		t.Fatal(err)
 	}
-	if len(fake.parentTransitions) != 2 || fake.parentTransitions[0] != defaultStartParentStatus || fake.parentTransitions[1] != defaultEndParentStatus {
-		t.Fatalf("parent transitions = %v, want [%s %s]", fake.parentTransitions, defaultStartParentStatus, defaultEndParentStatus)
+	if len(fake.parentTransitions) != 3 || fake.parentTransitions[0] != defaultStartParentStatus || fake.parentTransitions[1] != defaultWorkTaskStatus || fake.parentTransitions[2] != defaultEndParentStatus {
+		t.Fatalf("parent transitions = %v, want [%s %s %s]", fake.parentTransitions, defaultStartParentStatus, defaultWorkTaskStatus, defaultEndParentStatus)
 	}
 	if len(fake.taskTransitions) != 1 || fake.taskTransitions[0] != defaultWorkTaskStatus {
 		t.Fatalf("mailbox transitions = %v, want [%s]", fake.taskTransitions, defaultWorkTaskStatus)
@@ -170,3 +173,23 @@ func TestLifecycleDefaultsWithoutInheritedValues(t *testing.T) {
 		t.Fatalf("assignments = %v, want none when no assignee is configured", fake.assignments)
 	}
 }
+
+func TestWorkNodeParentAndTaskOverridesAreIndependent(t *testing.T) {
+	fake := &fakeJira{}
+	sys := repoScopedSystem(t, fake, nil)
+	parent := task.TicketRef{ID: "1", Key: "PAY-101"}
+	mailbox := &task.Mailbox{ID: "2", Key: "PAY-102", Node: "implement"}
+	cfg := operationConfig(lifecycleDefaultsOf(t, sys).WorkDefaults(),
+		config.RawValues{"transitionTo": map[string]any{"parentStatus": "Workflow Parent"}},
+		config.RawValues{"transitionTo": map[string]any{"taskStatus": "Node Task"}})
+
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: mailbox}, cfg); err != nil {
+		t.Fatal(err)
+	}
+	if len(fake.parentTransitions) != 1 || fake.parentTransitions[0] != "Workflow Parent" {
+		t.Fatalf("parent transitions = %v, want workflow parent override", fake.parentTransitions)
+	}
+	if len(fake.taskTransitions) != 1 || fake.taskTransitions[0] != "Node Task" {
+		t.Fatalf("mailbox transitions = %v, want node task override", fake.taskTransitions)
+	}
+}

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

@@ -97,10 +97,8 @@ func inlineContent(parent ast.Node, source []byte, marks []any) []any {
 			if value := string(node.Text(source)); value != "" {
 				content = append(content, textNode(value, marks))
 			}
-			if node.HardLineBreak() {
+			if node.HardLineBreak() || node.SoftLineBreak() {
 				content = append(content, map[string]any{"type": "hardBreak"})
-			} else if node.SoftLineBreak() {
-				content = append(content, textNode(" ", marks))
 			}
 		case *ast.String:
 			if value := string(node.Value); value != "" {
@@ -146,20 +144,31 @@ func textNode(value string, marks []any) map[string]any {
 
 func ADFText(raw json.RawMessage) string {
 	var node struct {
+		Type    string            `json:"type"`
 		Text    string            `json:"text"`
 		Content []json.RawMessage `json:"content"`
 	}
 	if json.Unmarshal(raw, &node) != nil {
 		return ""
 	}
+	if node.Type == "hardBreak" {
+		return "\n"
+	}
+	if len(node.Content) == 0 {
+		return node.Text
+	}
+
+	separator := ""
+	switch node.Type {
+	case "doc", "blockquote", "bulletList", "orderedList", "listItem":
+		separator = "\n"
+	}
 	parts := make([]string, 0, len(node.Content)+1)
 	if node.Text != "" {
 		parts = append(parts, node.Text)
 	}
 	for _, child := range node.Content {
-		if text := ADFText(child); text != "" {
-			parts = append(parts, text)
-		}
+		parts = append(parts, ADFText(child))
 	}
-	return strings.Join(parts, "\n")
+	return strings.Join(parts, separator)
 }

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

@@ -48,13 +48,93 @@ func TestADFDoesNotInferFormatting(t *testing.T) {
 	}
 }
 
+func TestADFPreservesTaskTextLineBreaks(t *testing.T) {
+	value := strings.Join([]string{
+		"Parent ticket: PAY-1",
+		"Workflow: relayFlow",
+		"Node: coding",
+		"Node type: agent",
+		"Agent: coder",
+		"Mailbox: PAY-1:coding",
+		"Node work: inspect the change",
+		"Keep this instruction on its own line",
+	}, "\n")
+	doc := ADF(value)
+	paragraph := doc["content"].([]any)[0].(map[string]any)
+	inline := paragraph["content"].([]any)
+	hardBreaks := 0
+	for _, item := range inline {
+		if item.(map[string]any)["type"] == "hardBreak" {
+			hardBreaks++
+		}
+	}
+	if hardBreaks != strings.Count(value, "\n") {
+		t.Fatalf("hard break count = %d, want %d: %#v", hardBreaks, strings.Count(value, "\n"), inline)
+	}
+	raw, err := json.Marshal(doc)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := ADFText(raw); got != value {
+		t.Fatalf("ADFText() = %q, want %q", got, value)
+	}
+}
+
+func TestADFReportLabelsRemainSeparate(t *testing.T) {
+	value := strings.Join([]string{
+		"STATUS: success",
+		"NEXT STEP: reviewer",
+		"",
+		"SUMMARY:",
+		"COMPLETED: implemented",
+		"COMMITS: abc123",
+		"NOT COMPLETED: None",
+		"ISSUES DISCOVERED: None",
+		"VERIFICATION: go test ./...",
+		"NOTES: None",
+		"",
+		"FEEDBACK:",
+		"REASON FOR NEXT STEP: ready",
+		"REQUIRED ACTIONS: None",
+		"RELEVANT CONTEXT: None",
+		"EXPECTED RESULT: review",
+	}, "\n")
+	raw, err := json.Marshal(ADF(value))
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := ADFText(raw)
+	for _, want := range []string{
+		"STATUS: success", "NEXT STEP: reviewer", "SUMMARY:",
+		"COMPLETED: implemented", "COMMITS: abc123", "NOT COMPLETED: None",
+		"ISSUES DISCOVERED: None", "VERIFICATION: go test ./...", "NOTES: None",
+		"FEEDBACK:", "REASON FOR NEXT STEP: ready", "REQUIRED ACTIONS: None",
+		"RELEVANT CONTEXT: None", "EXPECTED RESULT: review",
+	} {
+		found := false
+		for _, line := range strings.Split(got, "\n") {
+			if line == want {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("ADFText() = %q, missing separate report line %q", got, want)
+		}
+	}
+}
+
 func TestADFMarkerRoundTrip(t *testing.T) {
 	const marker = "<!-- run-1:summary -->"
-	raw, err := json.Marshal(ADF("Done.\n\n" + marker))
+	raw, err := json.Marshal(ADF("Done on line one\nDone on line two\n\n" + marker))
 	if err != nil {
 		t.Fatal(err)
 	}
-	if got := ADFText(raw); !strings.Contains(got, marker) {
+	got := ADFText(raw)
+	if !strings.Contains(got, "Done on line one\nDone on line two") {
+		t.Fatalf("ADFText() lost hard break: %q", got)
+	}
+	if !strings.Contains(got, marker) {
 		t.Fatalf("ADFText() = %q, want marker %q", got, marker)
 	}
 }

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

@@ -183,6 +183,9 @@ func TestCreateSubtasksBatchesAndIncludesADFParentAndLabel(t *testing.T) {
 			if !strings.Contains(string(update.Fields["description"]), `"type":"doc"`) {
 				t.Fatalf("description is not ADF: %s", update.Fields["description"])
 			}
+			if got := ADFText(update.Fields["description"]); got != "Work:\nDo it" {
+				t.Fatalf("description lost its line break: %q", got)
+			}
 			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{}})
@@ -274,6 +277,17 @@ func TestUpdateMailboxIsOneCall(t *testing.T) {
 		if !strings.Contains(string(body), `"description"`) || !strings.Contains(string(body), `"labels"`) {
 			t.Fatalf("combined update missing fields: %s", body)
 		}
+		var request struct {
+			Fields struct {
+				Description json.RawMessage `json:"description"`
+			} `json:"fields"`
+		}
+		if err := json.Unmarshal(body, &request); err != nil {
+			t.Fatal(err)
+		}
+		if got := ADFText(request.Fields.Description); got != "Work:\nDo it" {
+			t.Fatalf("mailbox description lost its line break: %q", got)
+		}
 		w.WriteHeader(http.StatusNoContent)
 	})
 	if err := s.client(t).UpdateMailbox(context.Background(), "PAY-2", "Work:\nDo it", "wf:flow"); err != nil {
@@ -338,6 +352,15 @@ func TestCommentsUseADFAndParseMarker(t *testing.T) {
 		if !strings.Contains(string(body), `"type":"doc"`) {
 			t.Fatalf("comment is not ADF: %s", body)
 		}
+		var request struct {
+			Body json.RawMessage `json:"body"`
+		}
+		if err := json.Unmarshal(body, &request); err != nil {
+			t.Fatal(err)
+		}
+		if got := ADFText(request.Body); got != "SUMMARY:\nDone" {
+			t.Fatalf("comment lost its line break: %q", got)
+		}
 		w.WriteHeader(http.StatusCreated)
 	})
 	c := s.client(t)
@@ -350,6 +373,37 @@ func TestCommentsUseADFAndParseMarker(t *testing.T) {
 	}
 }
 
+func TestCommentsPreserveMultilineReportsAndMarkers(t *testing.T) {
+	want := []string{
+		"SUMMARY:\nCOMPLETED: implemented\nCOMMITS: abc123",
+		"FEEDBACK:\nREASON FOR NEXT STEP: ready\nREQUIRED ACTIONS: fix it\n<!-- visit:feedback -->",
+	}
+	got := make([]string, 0, len(want))
+	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, body []byte) {
+		if r.Method != http.MethodPost || r.URL.Path != "/rest/api/3/issue/PAY-2/comment" {
+			http.NotFound(w, r)
+			return
+		}
+		var request struct {
+			Body json.RawMessage `json:"body"`
+		}
+		if err := json.Unmarshal(body, &request); err != nil {
+			t.Fatal(err)
+		}
+		got = append(got, ADFText(request.Body))
+		w.WriteHeader(http.StatusCreated)
+	})
+	client := s.client(t)
+	for _, body := range want {
+		if err := client.AddComment(context.Background(), "PAY-2", body); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("comments = %#v, want %#v", got, want)
+	}
+}
+
 func TestRetries429WithoutExposingCredentials(t *testing.T) {
 	calls := 0
 	s := newJiraServer(t, func(w http.ResponseWriter, r *http.Request, _ []byte) {

package/internal/task/jira/status_defaults_test.go

@@ -54,8 +54,8 @@ func TestRepositoryStatusDefaultsDriveLifecycleAndMailboxCompletion(t *testing.T
 	if err := sys.CompleteMailbox(context.Background(), mailbox); err != nil {
 		t.Fatal(err)
 	}
-	if len(fake.parentTransitions) != 1 || fake.parentTransitions[0] != "Open" {
-		t.Fatalf("parent transitions = %v, want [Open]", fake.parentTransitions)
+	if len(fake.parentTransitions) != 2 || fake.parentTransitions[0] != "Open" || fake.parentTransitions[1] != "Working" {
+		t.Fatalf("parent transitions = %v, want [Open Working]", fake.parentTransitions)
 	}
 	if len(fake.taskTransitions) != 2 || fake.taskTransitions[0] != "Working" || fake.taskTransitions[1] != "Closed" {
 		t.Fatalf("mailbox transitions = %v, want [Working Closed]", fake.taskTransitions)

package/internal/task/jira/transition_defaults_test.go

@@ -11,8 +11,8 @@ import (
 )
 
 // Jira repository status defaults are deterministic: omitted transitions use
-// the registered start/work/end values, and an omitted work-node parent
-// transition leaves the parent unchanged.
+// the registered start/work/end values, and omitted work-node defaults apply
+// the work status to both the parent and mailbox.
 //
 // This test is package-local (package jira) so it can drive the adapter's
 // ApplyTaskConfig against a test-local fake client without inventing an
@@ -67,20 +67,21 @@ func TestStartDefaultParentInProgress(t *testing.T) {
 	}
 }
 
-func TestWorkNodeDefaultMailboxInProgressParentUnchanged(t *testing.T) {
+func TestWorkNodeDefaultParentAndMailboxInProgress(t *testing.T) {
 	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"}
 
-	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: &mb}, config.RawValues{}); err != nil {
+	defaults := sys.(task.LifecycleDefaults).WorkDefaults()
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: &mb}, defaults); err != nil {
 		t.Fatalf("ApplyTaskConfig failed: %v", err)
 	}
 	if len(fake.taskTransitions) != 1 || fake.taskTransitions[0] != "In Progress" {
 		t.Fatalf("mailbox transitions = %v, want [In Progress]", fake.taskTransitions)
 	}
-	if len(fake.parentTransitions) != 0 {
-		t.Fatalf("parent transitions = %v, want none (parent unchanged when omitted)", fake.parentTransitions)
+	if len(fake.parentTransitions) != 1 || fake.parentTransitions[0] != "In Progress" {
+		t.Fatalf("parent transitions = %v, want [In Progress]", fake.parentTransitions)
 	}
 	if len(fake.assignments) != 0 {
 		t.Fatalf("mailbox assignments = %v, want none when assignee omitted", fake.assignments)
@@ -93,17 +94,21 @@ func TestWorkNodeAssignsMailboxBeforeTransition(t *testing.T) {
 	parent := task.TicketRef{ID: "1", Key: "PAY-101", Title: "parent"}
 	mb := task.Mailbox{ID: "2", Key: "PAY-102", Node: "coding"}
 
-	err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: &mb}, config.RawValues{
-		"assignee": "reviewer@example.com",
-	})
+	err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: &mb}, config.Merge(
+		sys.(task.LifecycleDefaults).WorkDefaults(),
+		config.RawValues{"assignee": "reviewer@example.com"},
+	))
 	if err != nil {
 		t.Fatalf("ApplyTaskConfig failed: %v", err)
 	}
 	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) != 1 || fake.events[0] != "transition" {
-		t.Fatalf("mailbox events = %v, want one combined transition", fake.events)
+	if len(fake.events) != 2 || fake.events[0] != "transition" || fake.events[1] != "transition" {
+		t.Fatalf("transition events = %v, want mailbox and parent transitions", fake.events)
+	}
+	if len(fake.parentTransitions) != 1 || fake.parentTransitions[0] != "In Progress" {
+		t.Fatalf("parent transitions = %v, want [In Progress]", fake.parentTransitions)
 	}
 }
 
@@ -178,6 +183,27 @@ func TestPrepareRestartPreservesHumanJiraStateOnConflict(t *testing.T) {
 	}
 }
 
+func TestWorkDefaultsUseConfiguredWorkStatusForParentAndMailbox(t *testing.T) {
+	fake := &fakeJira{}
+	sys, err := newSystem(context.Background(), &fakeClient{fake: fake}, task.RepoSpec{
+		Name: "payments",
+		RepoConfig: config.RawValues{
+			"project": "PAY", "component": "api",
+			"statusDefaults": map[string]any{"start": "Open", "work": "Working", "end": "Closed"},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	transition, ok := sys.WorkDefaults()["transitionTo"].(map[string]any)
+	if !ok {
+		t.Fatalf("WorkDefaults transitionTo = %#v, want map", sys.WorkDefaults()["transitionTo"])
+	}
+	if transition["parentStatus"] != "Working" || transition["taskStatus"] != "Working" {
+		t.Fatalf("WorkDefaults transitionTo = %#v, want both statuses Working", transition)
+	}
+}
+
 func TestExplicitTransitionsWin(t *testing.T) {
 	fake := &fakeJira{}
 	sys := newSystemWithFake(t, fake)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-flow",
-  "version": "0.3.1-alpha",
+  "version": "0.3.3-alpha",
   "description": "Graph-based agent workflow engine — tracker-agnostic, pluggable runners",
   "bin": {
     "relay-flow": "./bin/relay-flow.js",