Use the API PR title/body for existing PRs and fix new-PR defaults

For existing PRs, the submit TUI showed a commit/template-derived draft
instead of the pull request's real title and body. Fetch the actual title
and body and render them in the read-only card:

- open/draft/queued (tracked) and adopted-open PRs now carry title/body
  through the existing batch sync (added the fields to the GraphQL queries
  and PRDetails — no extra round trips), and
- merged branches (which skip the live refresh) are filled in by a targeted
  enrichment step run only when the submit TUI opens.

Also align the new-PR defaults with the non-TUI submit's defaultPRTitleBody:

- Title: the commit subject only when the branch has exactly one commit,
  otherwise the humanized branch name (was: the oldest commit's subject even
  for multi-commit branches).
- Description: the PR template, else the single commit's body, else empty
  (removed the bulleted commit-subject list for multi-commit branches).

Author: skarim

cmd/submit.go

@@ -194,7 +194,7 @@ func runSubmit(cfg *config.Config, opts *submitOptions) error {
 	// auto-generated titles and bodies (today's behavior).
 	var drafts map[string]*submitview.PRDraft
 	if cfg.IsInteractive() && !opts.auto {
-		collected, cancelled, tuiErr := collectPRDrafts(cfg, s, currentBranch, prDetails, templateContent)
+		collected, cancelled, tuiErr := collectPRDrafts(cfg, client, s, currentBranch, prDetails, templateContent)
 		if tuiErr != nil {
 			cfg.Errorf("failed to run the submit editor: %s", tuiErr)
 			return ErrSilent
@@ -255,7 +255,11 @@ func runSubmit(cfg *config.Config, opts *submitOptions) error {
 // returns the per-branch overrides, whether the user cancelled, and any error.
 // When the stack contains no branches without a PR, it skips the TUI and
 // returns nil drafts so the normal push/relink path runs.
-func collectPRDrafts(cfg *config.Config, s *stack.Stack, currentBranch string, prDetails map[string]*github.PRDetails, templateContent string) (map[string]*submitview.PRDraft, bool, error) {
+func collectPRDrafts(cfg *config.Config, client github.ClientOps, s *stack.Stack, currentBranch string, prDetails map[string]*github.PRDetails, templateContent string) (map[string]*submitview.PRDraft, bool, error) {
+	// Fill in the real title/description for existing PRs that were synced
+	// without them (e.g. merged branches) so the read-only cards show API data.
+	enrichPRContent(client, prDetails)
+
 	fmt.Fprintf(cfg.Err, "Loading stack...")
 	viewNodes := stackview.LoadBranchNodes(cfg, s, currentBranch, prDetails)
 	fmt.Fprintf(cfg.Err, "\r\033[2K")

cmd/submit_tui_test.go

@@ -76,7 +76,7 @@ func TestCollectPRDrafts_SkipsWhenNoNewBranches(t *testing.T) {
 		"b2": {Number: 2, State: "OPEN"},
 	}
 
-	drafts, cancelled, err := collectPRDrafts(cfg, s, "b1", prDetails, "")
+	drafts, cancelled, err := collectPRDrafts(cfg, nil, s, "b1", prDetails, "")
 	require.NoError(t, err)
 	assert.False(t, cancelled)
 	assert.Nil(t, drafts, "no NEW branches means the TUI is skipped and drafts are nil")

cmd/utils.go

@@ -412,6 +412,8 @@ func syncStackPRs(cfg *config.Config, s *stack.Stack) map[string]*github.PRDetai
 				Number:   pr.Number,
 				State:    "OPEN",
 				URL:      pr.URL,
+				Title:    pr.Title,
+				Body:     pr.Body,
 				IsDraft:  pr.IsDraft,
 				Merged:   false,
 				IsQueued: pr.IsQueued(),
@@ -458,6 +460,8 @@ func prDetailsFromPR(pr *github.PullRequest) *github.PRDetails {
 		Number:   pr.Number,
 		State:    pr.State,
 		URL:      pr.URL,
+		Title:    pr.Title,
+		Body:     pr.Body,
 		IsDraft:  pr.IsDraft,
 		Merged:   pr.Merged,
 		IsQueued: pr.IsQueued(),
@@ -481,6 +485,35 @@ func prDetailsFromTracked(ref *stack.PullRequestRef) *github.PRDetails {
 	}
 }
 
+// enrichPRContent fills in the Title and Body of any existing PR whose details
+// were built without them (e.g. merged branches, which skip the live refresh in
+// syncStackPRs). It is used before the submit TUI renders an existing PR's
+// read-only card so it shows the real PR title and description. PRs that already
+// have a title (the common open/draft/queued case) are left untouched.
+func enrichPRContent(client github.ClientOps, details map[string]*github.PRDetails) {
+	if client == nil {
+		return
+	}
+	var wg sync.WaitGroup
+	sem := make(chan struct{}, maxAPIConcurrency)
+	for _, d := range details {
+		if d == nil || d.Number == 0 || strings.TrimSpace(d.Title) != "" {
+			continue
+		}
+		wg.Add(1)
+		go func(d *github.PRDetails) {
+			defer wg.Done()
+			sem <- struct{}{}
+			defer func() { <-sem }()
+			if pr, err := client.FindPRByNumber(d.Number); err == nil && pr != nil {
+				d.Title = pr.Title
+				d.Body = pr.Body
+			}
+		}(d)
+	}
+	wg.Wait()
+}
+
 // syncStackPRsFromRemote uses the stack API to sync PR state. The remote
 // stack's PR list is the source of truth — PRs stay associated even if
 // closed. Returns the PRDetails map and true if sync succeeded, or nil and

cmd/utils_test.go

@@ -810,3 +810,25 @@ func TestEnsureLocalTrunk_CreateFails(t *testing.T) {
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "could not create local trunk branch main")
 }
+
+func TestEnrichPRContent(t *testing.T) {
+	calls := 0
+	client := &github.MockClient{
+		FindPRByNumberFn: func(number int) (*github.PullRequest, error) {
+			calls++
+			return &github.PullRequest{Number: number, Title: "Fetched title", Body: "Fetched body"}, nil
+		},
+	}
+	details := map[string]*github.PRDetails{
+		"merged": {Number: 10, State: "MERGED"},                // missing title -> fetched
+		"open":   {Number: 11, State: "OPEN", Title: "Has it"}, // already has a title -> skipped
+		"nonum":  {Number: 0, State: "OPEN"},                   // no number -> skipped
+	}
+
+	enrichPRContent(client, details)
+
+	assert.Equal(t, 1, calls, "only the title-less PR with a number is fetched")
+	assert.Equal(t, "Fetched title", details["merged"].Title)
+	assert.Equal(t, "Fetched body", details["merged"].Body)
+	assert.Equal(t, "Has it", details["open"].Title, "PRs that already have a title are untouched")
+}

internal/github/github.go

@@ -29,6 +29,8 @@ type PullRequest struct {
 	Number           int               `graphql:"number"`
 	State            string            `graphql:"state"`
 	URL              string            `graphql:"url"`
+	Title            string            `graphql:"title"`
+	Body             string            `graphql:"body"`
 	HeadRefName      string            `graphql:"headRefName"`
 	BaseRefName      string            `graphql:"baseRefName"`
 	IsDraft          bool              `graphql:"isDraft"`
@@ -101,6 +103,8 @@ func (c *Client) FindPRForBranch(branch string) (*PullRequest, error) {
 					ID               string            `graphql:"id"`
 					Number           int               `graphql:"number"`
 					URL              string            `graphql:"url"`
+					Title            string            `graphql:"title"`
+					Body             string            `graphql:"body"`
 					BaseRefName      string            `graphql:"baseRefName"`
 					IsDraft          bool              `graphql:"isDraft"`
 					MergeQueueEntry  *MergeQueueEntry  `graphql:"mergeQueueEntry"`
@@ -130,6 +134,8 @@ func (c *Client) FindPRForBranch(branch string) (*PullRequest, error) {
 		ID:               n.ID,
 		Number:           n.Number,
 		URL:              n.URL,
+		Title:            n.Title,
+		Body:             n.Body,
 		BaseRefName:      n.BaseRefName,
 		IsDraft:          n.IsDraft,
 		MergeQueueEntry:  n.MergeQueueEntry,
@@ -279,6 +285,8 @@ type PRDetails struct {
 	Number   int
 	State    string // OPEN, CLOSED, MERGED
 	URL      string
+	Title    string
+	Body     string
 	IsDraft  bool
 	Merged   bool
 	IsQueued bool
@@ -342,6 +350,8 @@ func (c *Client) FindPRByNumber(number int) (*PullRequest, error) {
 				Number           int               `graphql:"number"`
 				State            string            `graphql:"state"`
 				URL              string            `graphql:"url"`
+				Title            string            `graphql:"title"`
+				Body             string            `graphql:"body"`
 				HeadRefName      string            `graphql:"headRefName"`
 				BaseRefName      string            `graphql:"baseRefName"`
 				IsDraft          bool              `graphql:"isDraft"`
@@ -371,6 +381,8 @@ func (c *Client) FindPRByNumber(number int) (*PullRequest, error) {
 		Number:           n.Number,
 		State:            n.State,
 		URL:              n.URL,
+		Title:            n.Title,
+		Body:             n.Body,
 		HeadRefName:      n.HeadRefName,
 		BaseRefName:      n.BaseRefName,
 		IsDraft:          n.IsDraft,

internal/tui/submitview/data.go

@@ -40,61 +40,53 @@ func DeriveState(node stackview.BranchNode) BranchState {
 	return StateNew
 }
 
-// PrefillTitle returns the default PR title for a node: the subject of the
-// branch's first (oldest) commit when it has any commits, otherwise the
-// humanized branch name. git.LogRange returns commits newest-first, so the
-// oldest commit — the one that established the branch — is the last element.
+// PrefillTitle returns the default PR title for a new branch: the subject of its
+// single commit when the branch has exactly one commit, otherwise the humanized
+// branch name. This mirrors the non-TUI submit's defaultPRTitleBody.
 func PrefillTitle(node stackview.BranchNode) string {
-	if n := len(node.Commits); n > 0 {
-		if subject := strings.TrimSpace(node.Commits[n-1].Subject); subject != "" {
+	if commits := node.Commits; len(commits) == 1 {
+		if subject := strings.TrimSpace(commits[0].Subject); subject != "" {
 			return subject
 		}
 	}
 	return humanize(node.Ref.Branch)
 }
 
-// PrefillDescription returns the default PR description following the spec's
-// priority order: the repo PR template if one exists, otherwise the single
-// commit body, otherwise a bulleted list of commit subjects for multi-commit
-// branches. The attribution footer is appended later, at submit time.
+// PrefillDescription returns the default PR description for a new branch: the
+// repo PR template if one exists, otherwise the body of the branch's single
+// commit, otherwise empty. Multi-commit branches with no template get an empty
+// description (no bulleted commit list). This mirrors the non-TUI submit. The
+// attribution footer is appended later, at submit time.
 func PrefillDescription(node stackview.BranchNode, template string) string {
 	if t := strings.TrimSpace(template); t != "" {
 		return t
 	}
-
-	commits := node.Commits
-	switch {
-	case len(commits) == 1:
+	if commits := node.Commits; len(commits) == 1 {
 		return strings.TrimSpace(commits[0].Body)
-	case len(commits) > 1:
-		var b strings.Builder
-		// List oldest commit first so the body reads like a changelog.
-		for i := len(commits) - 1; i >= 0; i-- {
-			subject := strings.TrimSpace(commits[i].Subject)
-			if subject == "" {
-				continue
-			}
-			b.WriteString("- ")
-			b.WriteString(subject)
-			b.WriteString("\n")
-		}
-		return strings.TrimSpace(b.String())
-	default:
-		return ""
 	}
+	return ""
 }
 
 // NewSubmitNodes builds the per-branch UI state for the submit TUI from loaded
-// branch display data. NEW branches default to included; every node's title and
-// description are prefilled. New PRs default to ready for review; the per-PR
-// draft toggle starts off. The prefill snapshots are retained for edit
-// detection.
+// branch display data. NEW branches default to included; new PRs have their
+// title and description prefilled from commits and the PR template, while
+// existing PRs show their real title and description fetched from the API. New
+// PRs default to ready for review; the per-PR draft toggle starts off. The
+// prefill snapshots are retained for edit detection.
 func NewSubmitNodes(nodes []stackview.BranchNode, template string) []SubmitNode {
 	out := make([]SubmitNode, len(nodes))
 	for i, n := range nodes {
 		state := DeriveState(n)
 		title := PrefillTitle(n)
 		desc := PrefillDescription(n, template)
+		// Existing PRs render their real title/description from the API instead
+		// of the commit/template-derived draft used for new PRs.
+		if state != StateNew && n.PR != nil {
+			desc = n.PR.Body
+			if t := strings.TrimSpace(n.PR.Title); t != "" {
+				title = t
+			}
+		}
 		out[i] = SubmitNode{
 			BranchNode:   n,
 			State:        state,

internal/tui/submitview/data_test.go

@@ -102,11 +102,11 @@ func TestPrefillTitle(t *testing.T) {
 		assert.Equal(t, "Add auth middleware", PrefillTitle(n))
 	})
 
-	t.Run("multiple commits use the first (oldest) commit subject", func(t *testing.T) {
-		// git.LogRange returns commits newest-first, so the last element is the
-		// oldest — the commit that established the branch.
+	t.Run("multiple commits humanize the branch name", func(t *testing.T) {
+		// Only a single-commit branch uses the commit subject; multi-commit
+		// branches default to the humanized branch name (matches non-TUI submit).
 		n := node("feat/auth-middleware", commit("Polish middleware", ""), commit("Add auth middleware", ""))
-		assert.Equal(t, "Add auth middleware", PrefillTitle(n))
+		assert.Equal(t, "feat/auth middleware", PrefillTitle(n))
 	})
 
 	t.Run("zero commits humanize branch name", func(t *testing.T) {
@@ -131,11 +131,10 @@ func TestPrefillDescription(t *testing.T) {
 		assert.Equal(t, "Detailed body\nsecond line", PrefillDescription(n, ""))
 	})
 
-	t.Run("multi commit lists subjects oldest first", func(t *testing.T) {
-		// LogRange returns newest first; the body should read oldest first.
+	t.Run("multi commit with no template is empty", func(t *testing.T) {
+		// No bulleted commit list — multi-commit branches default to empty.
 		n := node("feat/a", commit("newest", ""), commit("middle", ""), commit("oldest", ""))
-		got := PrefillDescription(n, "")
-		assert.Equal(t, "- oldest\n- middle\n- newest", got)
+		assert.Equal(t, "", PrefillDescription(n, ""))
 	})
 
 	t.Run("no commits no template is empty", func(t *testing.T) {
@@ -167,6 +166,20 @@ func TestNewSubmitNodes(t *testing.T) {
 	assert.False(t, got[1].Included)
 }
 
+func TestNewSubmitNodes_ExistingPRUsesAPIContent(t *testing.T) {
+	// An existing PR shows its real title/body from the API, not the
+	// commit-subject / template prefill used for new PRs.
+	nodes := []stackview.BranchNode{
+		withPR(node("feat/b", commit("commit subject", "commit body")),
+			&ghapi.PRDetails{Number: 2, State: "OPEN", Title: "Real PR title", Body: "Real PR body"}),
+	}
+	got := NewSubmitNodes(nodes, "## Template")
+	assert.Len(t, got, 1)
+	assert.Equal(t, StateOpen, got[0].State)
+	assert.Equal(t, "Real PR title", got[0].Title, "existing PR uses the API title")
+	assert.Equal(t, "Real PR body", got[0].Description, "existing PR uses the API body, not the template")
+}
+
 func TestCounts(t *testing.T) {
 	nodes := []SubmitNode{
 		{State: StateNew, Included: true},