From b3b7a2f83d99f6bcaf0d7560bd0f7e4110d87c6d Mon Sep 17 00:00:00 2001
From: Docs Test <docs@example.com>
Date: Fri, 4 Sep 2026 10:08:30 -0400
Subject: [PATCH 1/4] feat: show stack position in the pull request list

Maintainers working through a stack had to open each pull request to learn
whether it was stacked and where it sat. The sidebar showed workspace, review,
and CI indicators but nothing about stacks, so a stacked pull request looked
the same as a standalone one.

Each list row now carries a compact stack indicator: the stack icon followed
by the pull request's position and the stack size, for example "4/7". It sits
just before the CI cluster in the row's indicator group. The list API returns
this placement directly so the sidebar does not fetch the full stack context
for every row. Only stacks with more than one visible member are reported,
matching when the detail view shows its stack chip. Members hidden as removed
upstream are excluded and the remaining members are renumbered, so the list
and the detail view always agree on position and size.

The detail view's stack chip drops the word "Stacked" from its visible label.
The icon already says that, so the chip now shows just the position and size.
The accessible name keeps the full wording for screen readers.

Generated with Claude Code (claude-fable-5-1)
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
---
 context/platform-sync-invariants.md           |  7 ++-
 frontend/openapi/openapi.yaml                 | 17 ++++++
 frontend/src/lib/api/generated/schema.ts      | 13 +++++
 .../lib/components/detail/StackStatus.svelte  |  2 +-
 .../lib/components/sidebar/PullItem.svelte    | 27 +++++++++
 .../lib/components/sidebar/PullItem.test.ts   | 14 +++++
 frontend/tests/e2e/stack-status.spec.ts       | 11 +++-
 internal/apiclient/generated/client.gen.go    | 10 ++++
 internal/db/queries_stacks.go                 | 55 ++++++++++++++++++
 internal/db/queries_stacks_test.go            | 53 +++++++++++++++++
 internal/db/types.go                          |  7 +++
 internal/server/pullapi/handler_test.go       | 58 +++++++++++++++++++
 internal/server/pullapi/routes.go             |  7 +++
 internal/server/pullapi/types.go              | 10 ++++
 14 files changed, 287 insertions(+), 4 deletions(-)

diff --git a/context/platform-sync-invariants.md b/context/platform-sync-invariants.md
index 00a229b747..a3bbc4c7ba 100644
--- a/context/platform-sync-invariants.md
+++ b/context/platform-sync-invariants.md
@@ -500,10 +500,13 @@ Repository import requests and route/query shapes should carry
   pushed-head refresh, manual workspace refresh, and on-demand worktree sync
   must check item visibility before item-specific provider access. Workspace and
   Fleet projections retain local records but omit removed parent metadata;
-  visible stack members are renumbered contiguously after filtering.
+  visible stack members are renumbered contiguously after filtering, and the
+  pull list's per-row stack placement must report the same position and size
+  as the detail stack context.
   `inaccessible` items remain visible.
   (`internal/server/pullapi/helpers.go::visibleMergeRequest`,
-  `internal/server/issueapi/mutation_handlers.go::requireVisibleIssue`)
+  `internal/server/issueapi/mutation_handlers.go::requireVisibleIssue`,
+  `internal/db/queries_stacks.go::ListStackPlacementsForMRs`)
 - Embedded navigation events for repo-bound routes must publish identity from
   parsed route state, not from global embed config. When a route carries repo
   identity, event payloads should include `provider`, `platform_host`, and
diff --git a/frontend/openapi/openapi.yaml b/frontend/openapi/openapi.yaml
index e928e88f5a..fa41f46f0d 100644
--- a/frontend/openapi/openapi.yaml
+++ b/frontend/openapi/openapi.yaml
@@ -5081,6 +5081,8 @@ components:
           type:
             - array
             - "null"
+        stack:
+          $ref: "#/components/schemas/StackPlacementResponse"
         workspace:
           $ref: "#/components/schemas/WorkspaceRef"
         worktree_links:
@@ -8663,6 +8665,21 @@ components:
         - base_branch
         - blocked_by
       type: object
+    StackPlacementResponse:
+      additionalProperties: false
+      properties:
+        position:
+          description: 1-based position of this pull request in its stack
+          format: int64
+          type: integer
+        size:
+          description: Number of visible pull requests in the stack
+          format: int64
+          type: integer
+      required:
+        - position
+        - size
+      type: object
     StackResponse:
       additionalProperties: false
       properties:
diff --git a/frontend/src/lib/api/generated/schema.ts b/frontend/src/lib/api/generated/schema.ts
index c5b23ee69c..09c134774d 100644
--- a/frontend/src/lib/api/generated/schema.ts
+++ b/frontend/src/lib/api/generated/schema.ts
@@ -7399,6 +7399,7 @@ export interface components {
             repo_name: string;
             repo_owner: string;
             requested_reviewers?: string[] | null;
+            stack?: components["schemas"]["StackPlacementResponse"];
             workspace?: components["schemas"]["WorkspaceRef"];
             worktree_links: components["schemas"]["WorktreeLinkResponse"][] | null;
         };
@@ -8984,6 +8985,18 @@ export interface components {
             state: string;
             title: string;
         };
+        StackPlacementResponse: {
+            /**
+             * Format: int64
+             * @description 1-based position of this pull request in its stack
+             */
+            position: number;
+            /**
+             * Format: int64
+             * @description Number of visible pull requests in the stack
+             */
+            size: number;
+        };
         StackResponse: {
             health: string;
             /** Format: int64 */
diff --git a/frontend/src/lib/components/detail/StackStatus.svelte b/frontend/src/lib/components/detail/StackStatus.svelte
index 434c363e9a..de228d359e 100644
--- a/frontend/src/lib/components/detail/StackStatus.svelte
+++ b/frontend/src/lib/components/detail/StackStatus.svelte
@@ -278,7 +278,7 @@
         {expanded}
       >
         <Layers2Icon size={12} strokeWidth={2.3} aria-hidden="true" />
-        <span class="stack-chip-label">Stacked: {data.position}/{data.size}</span>
+        <span class="stack-chip-label">{data.position}/{data.size}</span>
         {#if downstackBlockerCount > 0}
           <span class="stack-chip-failure" aria-hidden="true">
             <XIcon size={14} strokeWidth={2.8} /><span class="stack-chip-failure-count">{downstackBlockerCount}</span>
diff --git a/frontend/src/lib/components/sidebar/PullItem.svelte b/frontend/src/lib/components/sidebar/PullItem.svelte
index 49a2684c17..dcfc98f191 100644
--- a/frontend/src/lib/components/sidebar/PullItem.svelte
+++ b/frontend/src/lib/components/sidebar/PullItem.svelte
@@ -12,6 +12,7 @@
   import CITokenCluster, { composeAriaLabel } from "../shared/CITokenCluster.svelte";
   import CircleAlertIcon from "@lucide/svelte/icons/circle-alert";
   import CircleCheckBigIcon from "@lucide/svelte/icons/circle-check-big";
+  import Layers2Icon from "@lucide/svelte/icons/layers-2";
   import OctagonXIcon from "@lucide/svelte/icons/octagon-x";
   import LabelRow from "../shared/LabelRow.svelte";
   import WorkspaceIndicator from "../shared/WorkspaceIndicator.svelte";
@@ -222,6 +223,16 @@
           </svg>
         </span>
       {/if}
+      {#if pr.stack}
+        <span
+          class="stack-indicator"
+          aria-label={`Stacked: ${pr.stack.position}/${pr.stack.size}`}
+          title={`Stacked: ${pr.stack.position}/${pr.stack.size}`}
+        >
+          <Layers2Icon size={13} strokeWidth={2.2} aria-hidden="true" />
+          <span class="stack-indicator-count" aria-hidden="true">{pr.stack.position}/{pr.stack.size}</span>
+        </span>
+      {/if}
       {#if parsed.error !== null}
         <span
           class="ci ci-unavailable"
@@ -440,6 +451,21 @@
     color: var(--accent-red);
   }
 
+  .stack-indicator {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--space-1);
+    flex: 0 0 auto;
+    color: var(--text-muted);
+  }
+
+  .stack-indicator-count {
+    font-size: var(--font-size-2xs);
+    font-weight: 500;
+    font-variant-numeric: tabular-nums;
+    line-height: 1;
+  }
+
   .ci-unavailable {
     color: var(--state-warn, var(--accent-amber, #c08a2a));
     opacity: 0.85;
@@ -553,6 +579,7 @@
   :global(.mobile-main) .meta-text,
   :global(.mobile-main) .time,
   :global(.mobile-main) .worktree-name,
+  :global(.mobile-main) .stack-indicator-count,
   :global(.mobile-main) .item-number,
   :global(.mobile-main) .repo-name {
     font-size: var(--font-size-sm);
diff --git a/frontend/src/lib/components/sidebar/PullItem.test.ts b/frontend/src/lib/components/sidebar/PullItem.test.ts
index 1cbaf821d8..35d2b57b1b 100644
--- a/frontend/src/lib/components/sidebar/PullItem.test.ts
+++ b/frontend/src/lib/components/sidebar/PullItem.test.ts
@@ -293,6 +293,20 @@ describe("PullItem kanban status", () => {
     expect(screen.getByLabelText("Workspace attached (ready)")).toBeTruthy();
   });
 
+  it("shows the stack position and size when the PR belongs to a stack", () => {
+    renderItem(mkPR({ stack: { position: 4, size: 7 } }));
+
+    const indicator = screen.getByLabelText("Stacked: 4/7");
+    expect(indicator.textContent?.trim()).toBe("4/7");
+    expect(indicator.querySelector("svg")).toBeTruthy();
+  });
+
+  it("hides the stack indicator when the PR is not stacked", () => {
+    renderItem(mkPR({}));
+
+    expect(screen.queryByLabelText(/^Stacked:/)).toBeNull();
+  });
+
   it("shows an approved indicator when the PR is approved", () => {
     renderItem(
       mkPR({
diff --git a/frontend/tests/e2e/stack-status.spec.ts b/frontend/tests/e2e/stack-status.spec.ts
index a3a834d9d6..1d7ad6a469 100644
--- a/frontend/tests/e2e/stack-status.spec.ts
+++ b/frontend/tests/e2e/stack-status.spec.ts
@@ -220,7 +220,11 @@ async function mockStackedPR(
     const method = route.request().method();
 
     if (method === "GET" && pathname === "/api/v1/pulls") {
-      await fulfillJson(route, [pr]);
+      const currentStackMembers = options.stackMembers?.() ?? stackMembers;
+      const position = currentStackMembers.findIndex((member) => member.number === pr.Number) + 1;
+      const stack =
+        position > 0 && currentStackMembers.length > 1 ? { position, size: currentStackMembers.length } : undefined;
+      await fulfillJson(route, [{ ...pr, stack }]);
       return;
     }
 
@@ -447,6 +451,11 @@ test("stack status shares the PR detail expandable slot with CI", async ({ page
 
   await page.goto("/pulls/github/acme/widgets/102");
 
+  const listStackIndicator = page.locator(".pull-item").getByLabel("Stacked: 2/7");
+  await expect(listStackIndicator).toHaveText("2/7");
+  await expect(page.getByTestId("stack-chip")).toContainText("2/7");
+  await expect(page.getByTestId("stack-chip")).not.toContainText("Stacked");
+
   await page.getByTestId("ci-chip").click();
   await expect(page.getByText("frontend / vp check")).toBeVisible();
 
diff --git a/internal/apiclient/generated/client.gen.go b/internal/apiclient/generated/client.gen.go
index 851a61276e..2bf512af33 100644
--- a/internal/apiclient/generated/client.gen.go
+++ b/internal/apiclient/generated/client.gen.go
@@ -3516,6 +3516,7 @@ type MergeRequestResponse struct {
 	RepoName                string                           `json:"repo_name"`
 	RepoOwner               string                           `json:"repo_owner"`
 	RequestedReviewers      *[]string                        `json:"requested_reviewers,omitempty"`
+	Stack                   *StackPlacementResponse          `json:"stack,omitempty"`
 	Workspace               *WorkspaceRef                    `json:"workspace,omitempty"`
 	WorktreeLinks           *[]WorktreeLinkResponse          `json:"worktree_links"`
 }
@@ -5099,6 +5100,15 @@ type StackMemberResponse struct {
 	Title          string `json:"title"`
 }
 
+// StackPlacementResponse defines model for StackPlacementResponse.
+type StackPlacementResponse struct {
+	// Position 1-based position of this pull request in its stack
+	Position int64 `json:"position"`
+
+	// Size Number of visible pull requests in the stack
+	Size int64 `json:"size"`
+}
+
 // StackResponse defines model for StackResponse.
 type StackResponse struct {
 	Health    string                 `json:"health"`
diff --git a/internal/db/queries_stacks.go b/internal/db/queries_stacks.go
index 3d23395146..ef3a8b034e 100644
--- a/internal/db/queries_stacks.go
+++ b/internal/db/queries_stacks.go
@@ -360,6 +360,61 @@ func (d *DB) getStackForPRWhere(ctx context.Context, where string, args ...any)
 	return &stack, members, rows.Err()
 }
 
+// ListStackPlacementsForMRs returns the visible stack position and size for
+// each merge request that belongs to a stack. Members hidden as removed
+// upstream are excluded and the remaining members are renumbered contiguously,
+// matching GetStackForPR.
+func (d *DB) ListStackPlacementsForMRs(ctx context.Context, mrIDs []int64) (map[int64]StackPlacement, error) {
+	placements := make(map[int64]StackPlacement)
+	if len(mrIDs) == 0 {
+		return placements, nil
+	}
+
+	args := make([]any, len(mrIDs))
+	for i, id := range mrIDs {
+		args[i] = id
+	}
+
+	rows, err := d.roQueryContext(ctx, `
+		WITH visible AS (
+		    SELECT sm.stack_id, sm.merge_request_id,
+		           ROW_NUMBER() OVER (PARTITION BY sm.stack_id ORDER BY sm.position) AS position,
+		           COUNT(*) OVER (PARTITION BY sm.stack_id) AS size
+		    FROM forge_stack_members sm
+		    JOIN forge_merge_requests p ON p.id = sm.merge_request_id
+		    WHERE sm.stack_id IN (
+		        SELECT stack_id FROM forge_stack_members
+		        WHERE merge_request_id IN (`+sqlPlaceholders(len(mrIDs))+`)
+		    )
+		    AND NOT EXISTS (
+		        SELECT 1 FROM forge_archive_items ai
+		        WHERE ai.repo_id = p.repo_id
+		          AND ai.item_type = 'merge_request'
+		          AND ai.item_number = p.number
+		          AND ai.lifecycle_state = 'removed_upstream'
+		    )
+		)
+		SELECT merge_request_id, position, size
+		FROM visible
+		WHERE merge_request_id IN (`+sqlPlaceholders(len(mrIDs))+`)`,
+		append(append([]any{}, args...), args...)...,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("list stack placements: %w", err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var id int64
+		var placement StackPlacement
+		if err := rows.Scan(&id, &placement.Position, &placement.Size); err != nil {
+			return nil, fmt.Errorf("scan stack placement: %w", err)
+		}
+		placements[id] = placement
+	}
+	return placements, rows.Err()
+}
+
 // ListMRsBlockedByStackConflicts returns merge request IDs whose stack has an
 // earlier non-merged dirty member. It is used by API response assembly to
 // surface the stack-root conflict without mutating the provider-sourced PR row.
diff --git a/internal/db/queries_stacks_test.go b/internal/db/queries_stacks_test.go
index f1672d8762..e8c6bdd11f 100644
--- a/internal/db/queries_stacks_test.go
+++ b/internal/db/queries_stacks_test.go
@@ -202,6 +202,59 @@ func TestListMRsBlockedByStackConflicts(t *testing.T) {
 	assert.True(blocked[mrID3])
 }
 
+func TestListStackPlacementsForMRs(t *testing.T) {
+	assert := assert.New(t)
+	require := require.New(t)
+	d := openTestDB(t)
+	ctx := t.Context()
+	repoID := insertTestRepo(t, d, "org", "repo")
+
+	mrID1 := insertTestMRWithBranches(t, d, repoID, 1, "feature/a", "main", "merged")
+	mrID2 := insertTestMRWithBranches(t, d, repoID, 2, "feature/b", "feature/a", "open")
+	mrID3 := insertTestMRWithBranches(t, d, repoID, 3, "feature/c", "feature/b", "open")
+	mrID4 := insertTestMRWithBranches(t, d, repoID, 4, "feature/d", "feature/c", "open")
+	soloID := insertTestMRWithBranches(t, d, repoID, 9, "solo", "main", "open")
+	stackID, err := d.UpsertStack(ctx, repoID, 1, "feature")
+	require.NoError(err)
+	err = d.ReplaceStackMembers(ctx, stackID, []StackMember{
+		{StackID: stackID, MergeRequestID: mrID1, Position: 1},
+		{StackID: stackID, MergeRequestID: mrID2, Position: 2},
+		{StackID: stackID, MergeRequestID: mrID3, Position: 3},
+		{StackID: stackID, MergeRequestID: mrID4, Position: 4},
+	})
+	require.NoError(err)
+
+	placements, err := d.ListStackPlacementsForMRs(ctx, []int64{mrID2, mrID4, soloID})
+	require.NoError(err)
+	assert.Equal(StackPlacement{Position: 2, Size: 4}, placements[mrID2])
+	assert.Equal(StackPlacement{Position: 4, Size: 4}, placements[mrID4])
+	_, requested := placements[mrID1]
+	assert.False(requested, "unrequested members must not be returned")
+	_, inStack := placements[soloID]
+	assert.False(inStack, "merge requests outside a stack must not be returned")
+
+	// Hiding a member removed upstream renumbers the visible members.
+	_, err = d.WriteDB().ExecContext(ctx, `
+		INSERT INTO forge_archive_items (
+			repo_id, item_type, item_number, provider_item_id,
+			provider_created_at, provider_updated_at, lifecycle_state
+		) VALUES (?, 'merge_request', 2, 'pull-2', ?, ?, 'removed_upstream')`,
+		repoID, baseTime(), baseTime(),
+	)
+	require.NoError(err)
+
+	placements, err = d.ListStackPlacementsForMRs(ctx, []int64{mrID2, mrID3, mrID4})
+	require.NoError(err)
+	_, hidden := placements[mrID2]
+	assert.False(hidden, "hidden members must not be returned")
+	assert.Equal(StackPlacement{Position: 2, Size: 3}, placements[mrID3])
+	assert.Equal(StackPlacement{Position: 3, Size: 3}, placements[mrID4])
+
+	empty, err := d.ListStackPlacementsForMRs(ctx, nil)
+	require.NoError(err)
+	assert.Empty(empty)
+}
+
 func TestDeleteStaleStacks(t *testing.T) {
 	assert := assert.New(t)
 	require := require.New(t)
diff --git a/internal/db/types.go b/internal/db/types.go
index 29798da464..68bf9d6612 100644
--- a/internal/db/types.go
+++ b/internal/db/types.go
@@ -1179,6 +1179,13 @@ type StackMemberWithPR struct {
 	MergeableState string
 }
 
+// StackPlacement is a merge request's contiguous position within its stack
+// after hidden members are filtered, plus the visible stack size.
+type StackPlacement struct {
+	Position int
+	Size     int
+}
+
 // GitHubNativeStack is a cached GitHub stack resource. It remains separate
 // from Stack, which is the provider-neutral projection served to the UI.
 type GitHubNativeStack struct {
diff --git a/internal/server/pullapi/handler_test.go b/internal/server/pullapi/handler_test.go
index 02601d1645..7b54e561d2 100644
--- a/internal/server/pullapi/handler_test.go
+++ b/internal/server/pullapi/handler_test.go
@@ -147,6 +147,64 @@ func TestListPullsTreatsAssociatedWorkspaceSubjectAsHasWorkspace(t *testing.T) {
 	assert.Equal(t, "ws-adhoc", result.Body[0].Workspace.ID)
 }
 
+func TestListPullsReportsStackPlacementForMultiMemberStacks(t *testing.T) {
+	assert := assert.New(t)
+	require := require.New(t)
+	database := dbtest.Open(t)
+	ctx := t.Context()
+	now := time.Date(2026, 8, 9, 12, 0, 0, 0, time.UTC)
+	identity := db.GitHubRepoIdentity("github.com", "acme", "widget")
+	identity.PlatformRepoID = "repo-acme-widget"
+	repoID, err := database.UpsertRepo(ctx, identity)
+	require.NoError(err)
+	insert := func(number int, head, base string) int64 {
+		id, err := database.UpsertMergeRequest(ctx, &db.MergeRequest{
+			RepoID: repoID, PlatformID: int64(number), Number: number, Title: "PR",
+			Author: "alice", State: db.MergeRequestStateOpen, HeadBranch: head, BaseBranch: base,
+			CreatedAt: now, UpdatedAt: now, LastActivityAt: now,
+		})
+		require.NoError(err)
+		return id
+	}
+	firstID := insert(1, "feature/a", "main")
+	secondID := insert(2, "feature/b", "feature/a")
+	thirdID := insert(3, "feature/c", "feature/b")
+	insert(4, "solo", "main")
+	loneID := insert(5, "lone", "main")
+
+	stackID, err := database.UpsertStack(ctx, repoID, 1, "feature")
+	require.NoError(err)
+	require.NoError(database.ReplaceStackMembers(ctx, stackID, []db.StackMember{
+		{StackID: stackID, MergeRequestID: firstID, Position: 1},
+		{StackID: stackID, MergeRequestID: secondID, Position: 2},
+		{StackID: stackID, MergeRequestID: thirdID, Position: 3},
+	}))
+	loneStackID, err := database.UpsertStack(ctx, repoID, 5, "lone")
+	require.NoError(err)
+	require.NoError(database.ReplaceStackMembers(ctx, loneStackID, []db.StackMember{
+		{StackID: loneStackID, MergeRequestID: loneID, Position: 1},
+	}))
+
+	handler := New(Deps{
+		DB:       database,
+		Resolver: httpapi.NewRepositoryResolver(httpapi.RepositoryResolverDeps{DB: database}),
+	})
+	result, err := handler.listPulls(ctx, &listPullsInput{State: "open"})
+	require.NoError(err)
+
+	byNumber := map[int]MergeRequestResponse{}
+	for _, row := range result.Body {
+		byNumber[row.Number] = row
+	}
+	require.Len(byNumber, 5)
+	require.NotNil(byNumber[2].Stack)
+	assert.Equal(StackPlacementResponse{Position: 2, Size: 3}, *byNumber[2].Stack)
+	require.NotNil(byNumber[3].Stack)
+	assert.Equal(StackPlacementResponse{Position: 3, Size: 3}, *byNumber[3].Stack)
+	assert.Nil(byNumber[4].Stack, "pull requests outside a stack carry no placement")
+	assert.Nil(byNumber[5].Stack, "single-member stacks are not shown as stacked")
+}
+
 type stubPullProviderSource struct {
 	rows   []MergeRequestResponse
 	detail MergeRequestDetailResponse
diff --git a/internal/server/pullapi/routes.go b/internal/server/pullapi/routes.go
index 7ccf163b42..499a7635c1 100644
--- a/internal/server/pullapi/routes.go
+++ b/internal/server/pullapi/routes.go
@@ -453,6 +453,10 @@ func (s *Handler) listPullsRouteCore(ctx context.Context, input *listPullsInput)
 	if err != nil {
 		return nil, httpapi.Internal("load stack conflict state failed")
 	}
+	stackPlacements, err := s.db.ListStackPlacementsForMRs(ctx, mrIDs)
+	if err != nil {
+		return nil, httpapi.Internal("load stack placements failed")
+	}
 	links, err := s.db.GetWorktreeLinksForMRs(ctx, mrIDs)
 	if err != nil {
 		return nil, httpapi.Internal("load worktree links failed")
@@ -495,6 +499,9 @@ func (s *Handler) listPullsRouteCore(ctx context.Context, input *listPullsInput)
 		if mr.DetailFetchedAt != nil {
 			resp.DetailFetchedAt = formatUTCRFC3339(*mr.DetailFetchedAt)
 		}
+		if placement, ok := stackPlacements[mr.ID]; ok && placement.Size > 1 {
+			resp.Stack = &StackPlacementResponse{Position: placement.Position, Size: placement.Size}
+		}
 		out = append(out, resp)
 	}
 
diff --git a/internal/server/pullapi/types.go b/internal/server/pullapi/types.go
index eb3ecccbb4..805f1876e0 100644
--- a/internal/server/pullapi/types.go
+++ b/internal/server/pullapi/types.go
@@ -26,6 +26,16 @@ type MergeRequestResponse struct {
 	LastWorkspaceActivityAt string                     `json:"last_workspace_activity_at,omitempty" format:"date-time"`
 	DetailLoaded            bool                       `json:"detail_loaded"`
 	DetailFetchedAt         string                     `json:"detail_fetched_at,omitempty"`
+	// Stack is present only when the pull request belongs to a stack with more
+	// than one visible member, so list rows can show a stack indicator without
+	// loading the full stack context.
+	Stack *StackPlacementResponse `json:"stack,omitempty"`
+}
+
+// StackPlacementResponse is a pull request's position within its stack.
+type StackPlacementResponse struct {
+	Position int `json:"position" doc:"1-based position of this pull request in its stack"`
+	Size     int `json:"size" doc:"Number of visible pull requests in the stack"`
 }
 
 type mergeRequestEventResponse struct {

From 22d9bd149c257366c486ac0eae6e52aaee2fd1eb Mon Sep 17 00:00:00 2001
From: Docs Test <docs@example.com>
Date: Fri, 4 Sep 2026 11:43:04 -0400
Subject: [PATCH 2/4] test: scope stack chip assertions so the sidebar row does
 not match

The stack-status e2e test looked up the detail chip with a page-wide button
role query for "Stacked: 2/2". The sidebar row is also a button, and its
accessible name now includes the new stack indicator label, so the query
matched both elements. The row's label reflects the list response and does
not change when the detail refresh replaces the stack, which made the "no
longer 2/7" assertion fail in CI.

Assert the chip's accessible name through its test id instead, which is the
element the test is about. The testing context notes the row-name behavior so
future chip assertions are scoped from the start.

Generated with Claude Code (claude-fable-5-1)
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
---
 context/testing.md                      | 4 ++++
 frontend/tests/e2e/stack-status.spec.ts | 5 +++--
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/context/testing.md b/context/testing.md
index 79479cd4e7..8d1cfc2e13 100644
--- a/context/testing.md
+++ b/context/testing.md
@@ -187,6 +187,10 @@ the diff, so scope diff locators to `.diff-area`.
 Pane tab headers are `role="tab"` with an `aria-label`, so use
 `getByRole("tab", { name })` — `getByRole(..., { hasText })` is not a valid
 option and silently matches every tab.
+Sidebar item rows are `<button>`s whose accessible name concatenates every
+descendant label, including indicator `aria-label`s such as "Stacked: 2/7", so
+a page-wide `getByRole("button", { name })` for a detail chip also matches the
+row; scope chip assertions to the chip's test id.
 
 Every `@lucide/svelte/icons/<name>` import added anywhere in `frontend/src`
 must also be added to the `optimizeDeps.include` list in
diff --git a/frontend/tests/e2e/stack-status.spec.ts b/frontend/tests/e2e/stack-status.spec.ts
index 1d7ad6a469..7bc6065471 100644
--- a/frontend/tests/e2e/stack-status.spec.ts
+++ b/frontend/tests/e2e/stack-status.spec.ts
@@ -546,8 +546,9 @@ test("stack status follows refreshed detail stack data", async ({ page }) => {
   ];
   await emitPRDetailRefreshed(page, 102);
 
-  await expect(page.getByRole("button", { name: /Stacked: 2\/2/i })).toBeVisible();
-  await expect(page.getByRole("button", { name: /Stacked: 2\/7/i })).toHaveCount(0);
+  // Scope to the chip: the sidebar row button also exposes "Stacked: n/m"
+  // through its accessible name, so a page-wide role query would match it.
+  await expect(page.getByTestId("stack-chip")).toHaveAccessibleName(/Stacked: 2\/2/i);
 
   currentStackMembers = [];
   await emitPRDetailRefreshed(page, 102);

From b62bf780a50e260063386eda43a881ee5cb37a69 Mon Sep 17 00:00:00 2001
From: Docs Test <docs@example.com>
Date: Fri, 4 Sep 2026 12:08:25 -0400
Subject: [PATCH 3/4] test: split the workspace recency typography test so it
 fits the CI budget

The workspace recency typography test failed its first attempt in every e2e
mock job since it landed, on main and on pull requests, and only passed on
retry. It made four full page loads in one test. The 30 second limit applies
to the whole test, and each load goes through the Vite dev server, which
slows several-fold while 14 workers share it. On retry the server is quieter,
so the same test passed and the run reported it as flaky.

Split it into a desktop test and a phone test with two loads each. The
assertions are unchanged. The testing context records the budget rule so new
tests keep their navigation count small.

Generated with Claude Code (claude-fable-5-1)
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
---
 context/testing.md                           |  4 ++++
 frontend/tests/e2e/workspace-sidebar.spec.ts | 12 +++++++++++-
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/context/testing.md b/context/testing.md
index 8d1cfc2e13..ac34e05f78 100644
--- a/context/testing.md
+++ b/context/testing.md
@@ -187,6 +187,10 @@ the diff, so scope diff locators to `.diff-area`.
 Pane tab headers are `role="tab"` with an `aria-label`, so use
 `getByRole("tab", { name })` — `getByRole(..., { hasText })` is not a valid
 option and silently matches every tab.
+The mock Playwright config's 30 s timeout covers the whole test, and every
+`page.goto` is a full Vite dev-server load that slows several-fold under CI's
+14 workers; keep a test to two navigations or split it, or it fails on the
+first attempt and only passes on retry. (`frontend/playwright.config.ts`)
 Sidebar item rows are `<button>`s whose accessible name concatenates every
 descendant label, including indicator `aria-label`s such as "Stacked: 2/7", so
 a page-wide `getByRole("button", { name })` for a detail chip also matches the
diff --git a/frontend/tests/e2e/workspace-sidebar.spec.ts b/frontend/tests/e2e/workspace-sidebar.spec.ts
index 021e68802a..6aaa308d76 100644
--- a/frontend/tests/e2e/workspace-sidebar.spec.ts
+++ b/frontend/tests/e2e/workspace-sidebar.spec.ts
@@ -4689,7 +4689,10 @@ test.describe("workspace list bubble opens right sidebar", () => {
     expect(maxRight - minRight).toBeLessThanOrEqual(1);
   });
 
-  test("workspace recency uses item-list typography without phone overflow", async ({ page }) => {
+  // Desktop and phone parity are separate tests: each full navigation through
+  // the Vite dev server is slow under CI worker load, and four in one test
+  // exhausted the per-test budget on the first attempt.
+  test("workspace recency uses item-list typography on desktop", async ({ page }) => {
     await setupTerminalMocks(page);
     await page.addInitScript(() => {
       localStorage.setItem("kenn-forge:workspaceListSort", "created");
@@ -4711,6 +4714,13 @@ test.describe("workspace list bubble opens right sidebar", () => {
       return { fontFamily: style.fontFamily, fontSize: style.fontSize, lineHeight: style.lineHeight };
     });
     expect(desktopTypography).toEqual(pullTypography);
+  });
+
+  test("workspace recency uses item-list typography on phones without overflow", async ({ page }) => {
+    await setupTerminalMocks(page);
+    await page.addInitScript(() => {
+      localStorage.setItem("kenn-forge:workspaceListSort", "created");
+    });
 
     await page.setViewportSize({ width: 390, height: 844 });
     await page.goto("/m/pulls");

From 666b2325bcf92043773cea0f5c1d0557896bd497 Mon Sep 17 00:00:00 2001
From: Docs Test <docs@example.com>
Date: Fri, 4 Sep 2026 12:14:58 -0400
Subject: [PATCH 4/4] fix: keep stack placement lookups working for very large
 pull lists

The pull list endpoint has no size cap. The stack placement lookup expanded
the merge request IDs into placeholders and bound each one twice, so a list
of about 16,000 pull requests would exceed SQLite's 32,766 bound-variable
limit and turn the whole list response into a 500. The sibling worktree link
lookup already batches for the same reason.

Bind the IDs once as a JSON array through json_each instead. The database
test now includes an ID set of 70,000 to prove the lookup survives beyond the
limit.

Also add a phone-viewport e2e case for the sidebar stack indicator. The
indicator is enabled on phone rows, but coverage ran only at desktop width,
so the row's fit beside the review, CI, and time indicators was unchecked.

Generated with Claude Code (claude-fable-5-1)
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
---
 context/db-migrations.md                |  6 ++++++
 frontend/tests/e2e/stack-status.spec.ts | 25 +++++++++++++++++++++++++
 internal/db/queries_stacks.go           | 21 +++++++++++++--------
 internal/db/queries_stacks_test.go      | 12 ++++++++++++
 4 files changed, 56 insertions(+), 8 deletions(-)

diff --git a/context/db-migrations.md b/context/db-migrations.md
index 4fc4864e22..60467fb137 100644
--- a/context/db-migrations.md
+++ b/context/db-migrations.md
@@ -60,6 +60,12 @@ schema migrations.
   reader reloads the stored statistics (`internal/db/db.go::Optimize`).
 - Migrations must never drop or rebuild `sqlite_stat1`, and a query-plan assertion
   needs seeded rows plus `DB.Optimize` first (`internal/db/db.go::Optimize`).
+- Lookups keyed by an unbounded ID list, such as pull-list enrichment, must not
+  expand the list into `IN (?, ?, ...)` placeholders: SQLite caps a statement at
+  32,766 bound variables. Bind the list once as a JSON array through
+  `json_each(?)`, or batch it
+  (`internal/db/queries_stacks.go::ListStackPlacementsForMRs`,
+  `internal/db/queries.go::GetWorktreeLinksForMRs`).
 
 ## Federation Spoke Preparation
 
diff --git a/frontend/tests/e2e/stack-status.spec.ts b/frontend/tests/e2e/stack-status.spec.ts
index 7bc6065471..6a4069a51c 100644
--- a/frontend/tests/e2e/stack-status.spec.ts
+++ b/frontend/tests/e2e/stack-status.spec.ts
@@ -556,6 +556,31 @@ test("stack status follows refreshed detail stack data", async ({ page }) => {
   await expect(page.getByTestId("stack-chip")).toHaveCount(0);
 });
 
+test("phone pull rows fit the stack indicator beside the other indicators", async ({ page }) => {
+  await page.setViewportSize({ width: 390, height: 844 });
+  await mockStackedPR(page);
+
+  await page.goto("/m/pulls");
+  const row = page.locator(".mobile-shell .pull-item").first();
+  const indicator = row.getByLabel("Stacked: 2/7");
+  await expect(indicator).toHaveText("2/7");
+  // The fixture also renders the approved review, CI cluster, and time
+  // indicators, so the row exercises the full trailing cluster.
+  await expect(row.locator(".review-indicator--approved")).toBeVisible();
+  await expect(row.locator(".ci")).toBeVisible();
+
+  const rowBox = await row.boundingBox();
+  const indicatorBox = await indicator.boundingBox();
+  expect(rowBox).not.toBeNull();
+  expect(indicatorBox).not.toBeNull();
+  if (rowBox && indicatorBox) {
+    expect(rowBox.x + rowBox.width).toBeLessThanOrEqual(390);
+    expect(indicatorBox.x).toBeGreaterThanOrEqual(rowBox.x);
+    expect(indicatorBox.x + indicatorBox.width).toBeLessThanOrEqual(rowBox.x + rowBox.width);
+  }
+  expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBeLessThanOrEqual(390);
+});
+
 test("stack status stays rendered while navigating to a stack member", async ({ page }) => {
   let releaseStackResponse: () => void = () => {};
   const delayedStackResponse = new Promise<void>((resolve) => {
diff --git a/internal/db/queries_stacks.go b/internal/db/queries_stacks.go
index ef3a8b034e..59124a0c03 100644
--- a/internal/db/queries_stacks.go
+++ b/internal/db/queries_stacks.go
@@ -3,6 +3,7 @@ package db
 import (
 	"context"
 	"database/sql"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"strings"
@@ -363,20 +364,24 @@ func (d *DB) getStackForPRWhere(ctx context.Context, where string, args ...any)
 // ListStackPlacementsForMRs returns the visible stack position and size for
 // each merge request that belongs to a stack. Members hidden as removed
 // upstream are excluded and the remaining members are renumbered contiguously,
-// matching GetStackForPR.
+// matching GetStackForPR. The IDs are bound once as a JSON array so the pull
+// list size is not limited by SQLite's bind-parameter ceiling.
 func (d *DB) ListStackPlacementsForMRs(ctx context.Context, mrIDs []int64) (map[int64]StackPlacement, error) {
 	placements := make(map[int64]StackPlacement)
 	if len(mrIDs) == 0 {
 		return placements, nil
 	}
 
-	args := make([]any, len(mrIDs))
-	for i, id := range mrIDs {
-		args[i] = id
+	payload, err := json.Marshal(mrIDs)
+	if err != nil {
+		return nil, fmt.Errorf("encode stack placement ids: %w", err)
 	}
 
 	rows, err := d.roQueryContext(ctx, `
-		WITH visible AS (
+		WITH requested AS (
+		    SELECT CAST(value AS INTEGER) AS merge_request_id FROM json_each(?)
+		),
+		visible AS (
 		    SELECT sm.stack_id, sm.merge_request_id,
 		           ROW_NUMBER() OVER (PARTITION BY sm.stack_id ORDER BY sm.position) AS position,
 		           COUNT(*) OVER (PARTITION BY sm.stack_id) AS size
@@ -384,7 +389,7 @@ func (d *DB) ListStackPlacementsForMRs(ctx context.Context, mrIDs []int64) (map[
 		    JOIN forge_merge_requests p ON p.id = sm.merge_request_id
 		    WHERE sm.stack_id IN (
 		        SELECT stack_id FROM forge_stack_members
-		        WHERE merge_request_id IN (`+sqlPlaceholders(len(mrIDs))+`)
+		        WHERE merge_request_id IN (SELECT merge_request_id FROM requested)
 		    )
 		    AND NOT EXISTS (
 		        SELECT 1 FROM forge_archive_items ai
@@ -396,8 +401,8 @@ func (d *DB) ListStackPlacementsForMRs(ctx context.Context, mrIDs []int64) (map[
 		)
 		SELECT merge_request_id, position, size
 		FROM visible
-		WHERE merge_request_id IN (`+sqlPlaceholders(len(mrIDs))+`)`,
-		append(append([]any{}, args...), args...)...,
+		WHERE merge_request_id IN (SELECT merge_request_id FROM requested)`,
+		string(payload),
 	)
 	if err != nil {
 		return nil, fmt.Errorf("list stack placements: %w", err)
diff --git a/internal/db/queries_stacks_test.go b/internal/db/queries_stacks_test.go
index e8c6bdd11f..e0ec436633 100644
--- a/internal/db/queries_stacks_test.go
+++ b/internal/db/queries_stacks_test.go
@@ -253,6 +253,18 @@ func TestListStackPlacementsForMRs(t *testing.T) {
 	empty, err := d.ListStackPlacementsForMRs(ctx, nil)
 	require.NoError(err)
 	assert.Empty(empty)
+
+	// The pull list has no size cap, so the lookup must survive an ID set far
+	// beyond SQLite's bind-parameter ceiling (32,766 variables).
+	large := make([]int64, 0, 70_000)
+	for id := int64(1_000_000); id < 1_070_000; id++ {
+		large = append(large, id)
+	}
+	large = append(large, mrID3, mrID4)
+	placements, err = d.ListStackPlacementsForMRs(ctx, large)
+	require.NoError(err)
+	assert.Len(placements, 2)
+	assert.Equal(StackPlacement{Position: 2, Size: 3}, placements[mrID3])
 }
 
 func TestDeleteStaleStacks(t *testing.T) {