The heading button queues the shown set instead of starting agents

"Add all X tickets shown below to the AI queue": every unclaimed shown
ticket joins the AI queue exactly as the detail page's Queue action
queues one (#1164), in the shown order, skipping tickets an open entry
already links to. No agent starts — the queue is what the routine drain
fans out over (#1204) and what the queue card's play buttons work one
entry at a time (#855). After a click the button reads "Queued" and
rests until the shown set changes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019vS2EK2vVFJc3oDCtrgShR

Author: claude

FEATURES-SPEC.md

@@ -22,7 +22,6 @@ happens while nobody is at the keyboard.
 - Options gear writing straight to preferences
 - Pre-flight warnings before spending (no `gh`, logged out, repo can't auto-merge)
 - Start an agent from a ticket row
-- Spin up agents working on all the tickets the Tickets page's filters show — one agent per ticket, via the AI queue
 - Start an agent from a queue entry's play button
 - "Run now" on a routine, in a picked project the card remembers across navigations and reloads
 - "Configure first, then run" on a routine — the launcher opens with its prompt, so the model and location can be set first
@@ -99,6 +98,7 @@ happens while nobody is at the keyboard.
 - Ticket detail page
 - A plan page when a plan exists; a button to start an agent writing one when it doesn't
 - Queue a ticket into the AI queue
+- Queue every ticket the filters show into the AI queue, in one click from the page heading
 - Tickets carry a GitHub issue link, so merging closes the issue
 
 ## Handoff and what lands in git

packages/framework/dashboard/components/TicketsPage.SPEC.md

@@ -2,7 +2,7 @@ The dashboard's Tickets page: every registered project's `tickets/` backlog on o
 
 ## User story
 
-The user wants to see the whole backlog — not one project's slice of it — decide what to work next, and act on a ticket right there: read it, read its plan, have an agent plan it, or have an agent work it. And when the filters have carved out a coherent slice, they want to hand that whole slice to agents at once — one agent per ticket.
+The user wants to see the whole backlog — not one project's slice of it — decide what to work next, and act on a ticket right there: read it, read its plan, have an agent plan it, or have an agent work it. And when the filters have carved out a coherent slice, they want to queue that whole slice for the AI in one click.
 
 ## Business logic — TL;DR
 
@@ -11,7 +11,7 @@ The user wants to see the whole backlog — not one project's slice of it — de
 - **Grouped or flat** - grouped shows one section per project, each with that project's own ticket panel; flat pools every project's tickets into one order, each row naming its project — the only view that can answer which ticket is the highest-priority one anywhere.
 - **Click-to-filter** - clicking a row's topic adds that topic to the filter, clicking its claim marker narrows to claimed tickets; both add to what is already filtered rather than replacing it.
 - **Plan it or work it from the row** - a ticket can be handed to a planning agent or to an unattended work agent without leaving the page.
-- **Spin up the whole shown set** - a button beside the page's heading spins up one unattended agent per shown ticket, via the AI queue: each unclaimed shown ticket is queued (unless it already is) and gets its own agent working that one entry, and the button's label counts the agents one click costs.
+- **Queue the whole shown set** - a button beside the page's heading adds every unclaimed shown ticket to the AI queue (a ticket already queued stays as it is), counting on its label what one click adds; no agent starts — the queue's own consumers do that.
 - **Filtered-away tickets are accounted for** - the page says how many tickets the filters hide and offers to clear them; a project the user deselected disappears silently instead.
 
 ## Business logic
@@ -74,23 +74,23 @@ The user has decided a ticket is next and wants an agent on it now.
 
 Every ticket row offers to start a planning agent for that ticket, and to start an agent that works it. The work agent runs unattended with the ticket named on it, so the agent knows which ticket it is working. Both start in the project the ticket belongs to — in the flat list that is the row's own project, not a page-wide selection — and the dashboard shell is told an agent started so it can show it. A start that fails leaves a message on the page saying the planning agent or the work agent could not be started.
 
-### Spin up the whole shown set
+### Queue the whole shown set
 
 #### User story
 
-The user narrows the backlog to a coherent slice — a topic, a priority band, one project — and wants agents on everything left showing, one agent per ticket, rather than starting the rows one by one.
+The user narrows the backlog to a coherent slice — a topic, a priority band, one project — and wants everything left showing on the AI queue, rather than queueing the rows one by one.
 
 #### Business logic
 
-Whenever the filters leave at least one unclaimed ticket showing, the page's heading row offers a button that spins up one agent per shown ticket, via the AI queue. For each such ticket, in the shown order: the ticket is queued exactly as the ticket detail page's Queue action queues it — unless an open queue entry already links to it, in which case that entry stands and nothing is written twice — and an unattended agent is started on that one entry, exactly as the AI Queue card's per-entry play button starts one, with the ticket named on the agent. Each agent starts in the project its ticket belongs to, so a shown set spanning projects needs no special case.
+Whenever the filters leave at least one unclaimed ticket showing, the page's heading row offers a button that adds the shown tickets to the AI queue — "Add all X tickets shown below to the AI queue". Each ticket is queued exactly as the ticket detail page's Queue action queues it (the entry links back to the ticket and lands in its priority's section), walked in the shown order so entries within a priority section keep the order the reader saw, and each on its own project's queue, so a shown set spanning projects needs no special case. A ticket an open queue entry already links to is left as it stands — "add" means the set ends up queued, never queued twice. No agent starts: the queue is what the framework's own routine drain fans out over and what the AI Queue card's play buttons start one entry at a time.
 
-Claimed tickets — those an agent already holds — are skipped: they are left to the agents holding them, the same rule the daemon's own fan-out follows. The button's label is the spend readout: one agent per ticket, so it counts what one click costs — "Spin up agents working on all X tickets shown below" — and switches to counting unclaimed tickets the moment the shown set contains claimed ones, so it never promises a ticket it will skip; hovering explains the mechanics and says how many claimed tickets are being left alone. With nothing to start — nothing shown, or everything shown claimed — the button is not offered.
+Claimed tickets — those an agent already holds — are skipped: they are being worked, and the label then counts only the unclaimed tickets so it never promises a ticket it will skip; hovering explains the mechanics and says how many claimed tickets are being left alone. With nothing to add — nothing shown, or everything shown claimed — the button is not offered.
 
-The dashboard shell is told about one started agent — the first — rather than being bounced through every one. The work stops at the first failure, whose reason lands under the heading in grouped and flat mode alike; everything already queued or started stays.
+Once a click has queued the shown set, the button reads "Queued" and rests; any change to the shown set — a filter, newly arrived tickets — arms it again for the new set. The work stops at the first failure, whose reason lands under the heading in grouped and flat mode alike; everything already queued stays.
 
 #### Rationale
 
-Routing through the AI queue rather than starting bare agents makes each start durable: a queue entry outlives a failed or interrupted agent, so the routine drain picks up whatever the click could not finish. Reusing an existing open entry matters for the same reason in reverse — a duplicate entry would outlive its agent's check-off as an open entry naming a closed ticket, and the sweep would spend an agent on it. And the label carries the count precisely because the set is a side effect of the filters — the click's cost must be readable before it is paid.
+Queueing rather than starting agents keeps the one click cheap and durable: entries are what the framework already picks up on its own, survive anything that interrupts the work, and spend nothing until an agent actually starts. Skipping already-queued tickets matters because a duplicate entry would outlive its agent's check-off as an open entry naming a closed ticket, costing the sweep an agent.
 
 ### Filtered-away tickets are accounted for
 

packages/framework/dashboard/components/TicketsPage.test.SPEC.md

@@ -6,7 +6,7 @@ Filtering: searching narrows the rows, updates the shown/total tally beside the
 
 Grouping: the flat mode renders one cross-project list ordered across projects, with each row naming its project and no per-project update controls; opening a flat row still identifies its own project and file; and a flat row's start button runs the work agent in that row's own project, unattended, with the ticket named on it.
 
-The page-wide spin-up button: each shown ticket is queued the way the ticket detail page queues one (title as the entry, ticket linked, priority picking the section) and gets its own unattended agent started on that one entry with the ticket named on the agent, the shell pointed at the first started agent only; a ticket an open queue entry already links to is not queued twice — its agent is pointed at the existing entry verbatim, and a checked-off entry does not count as queued; claimed tickets are skipped, with the button's label counting only the unclaimed tickets it will start; and the button is absent when nothing is shown or every shown ticket is claimed.
+The page-wide queue-add button: every shown ticket is queued the way the ticket detail page queues one (title as the entry, ticket linked, priority picking the section) and no agent is started; after the click the button reads "Queued" and stays disabled until the shown set changes, when it arms again counting the new set; a ticket an open queue entry already links to is not queued twice, and a checked-off entry does not count as queued; claimed tickets are skipped, with the button's label counting only the unclaimed tickets it will add; and the button is absent when nothing is shown or every shown ticket is claimed.
 
 ## Before modifying/creating SPEC.md files
 

packages/framework/dashboard/components/TicketsPage.test.tsx

@@ -11,7 +11,6 @@ vi.mock('../rpc/reads.js', () => ({ onAllTickets, onTicketsMeta, onQueue }))
 vi.mock('../rpc/control.js', () => ({ sendQueueTicket: vi.fn(), sendStart: vi.fn() }))
 
 const { TicketsPage } = await import('./TicketsPage.js')
-const { workOnEntryPrompt } = await import('./AiQueue.js')
 
 const ticket = (over: Record<string, unknown> = {}) => ({
   file: 't.md',
@@ -257,18 +256,18 @@ describe('TicketsPage grouping (#1144)', () => {
   })
 })
 
-// The page-wide spin-up button: the row's play button lifted to the page's heading — one agent
-// per shown ticket, via the AI queue. Each unclaimed shown ticket is queued (unless an open
-// entry already links to it) and gets its own unattended agent working that one entry.
-describe('TicketsPage spin up the shown set', () => {
+// The page-wide queue-add button: the detail page's Queue action lifted to the page's heading —
+// every unclaimed shown ticket joins the AI queue (unless an open entry already links to it),
+// and no agent starts: the queue's own consumers do that.
+describe('TicketsPage add the shown set to the AI queue', () => {
   const controls = async () => {
     const { sendStart, sendQueueTicket } = await import('../rpc/control.js')
     vi.mocked(sendStart).mockClear().mockResolvedValue({ ok: true, agentId: 'a1' })
     vi.mocked(sendQueueTicket).mockClear().mockResolvedValue({ ok: true, file: 'TODO_AGENTS.md' })
     return { sendStart, sendQueueTicket }
   }
 
-  test('one agent per shown ticket: each is queued and started on its own entry', async () => {
+  test('every shown ticket joins the queue, and the button rests as Queued until the set changes', async () => {
     onAllTickets.mockResolvedValue([
       {
         projectId: 'p1',
@@ -277,29 +276,24 @@ describe('TicketsPage spin up the shown set', () => {
       },
     ])
     const { sendStart, sendQueueTicket } = await controls()
-    const onAgentStarted = vi.fn()
-    render(<TicketsPage onOpenTicket={() => {}} onAgentStarted={onAgentStarted} />)
-    fireEvent.click(await screen.findByRole('button', { name: 'Spin up agents working on all 2 tickets shown below' }))
+    render(<TicketsPage onOpenTicket={() => {}} />)
+    fireEvent.click(await screen.findByRole('button', { name: 'Add all 2 tickets shown below to the AI queue' }))
     // Queued exactly as the detail page's Queue button queues (#1164): title as the entry, the
     // ticket named so the entry links back, its priority picking the section.
     await waitFor(() => expect(sendQueueTicket).toHaveBeenCalledTimes(2))
     expect(sendQueueTicket).toHaveBeenCalledWith('p1', 'First', { file: 'a.md', priority: '7' })
     expect(sendQueueTicket).toHaveBeenCalledWith('p1', 'Second', { file: 'b.md' })
-    // Started exactly as the queue card's play button starts (#855): the per-entry ask on the
-    // very line the queue write produced, unattended, the ticket named on the agent (#1117).
-    const firstPrompt = workOnEntryPrompt('[First](tickets/a.md)')
-    await waitFor(() => expect(sendStart).toHaveBeenCalledTimes(2))
-    expect(sendStart).toHaveBeenCalledWith('p1', firstPrompt, 'prompt', { unattended: true, ticket: 'tickets/a.md' })
-    expect(sendStart).toHaveBeenCalledWith('p1', workOnEntryPrompt('[Second](tickets/b.md)'), 'prompt', {
-      unattended: true,
-      ticket: 'tickets/b.md',
-    })
-    // The shell is pointed at one agent, not bounced through all of them.
-    await waitFor(() => expect(onAgentStarted).toHaveBeenCalledTimes(1))
-    expect(onAgentStarted).toHaveBeenCalledWith('p1', firstPrompt, 'a1')
+    // Queueing is the whole act — the queue's own consumers start agents, not this button.
+    expect(sendStart).not.toHaveBeenCalled()
+    // Done, the button says so and rests for this exact set…
+    const queued = await screen.findByRole('button', { name: 'Queued' })
+    expect((queued as HTMLButtonElement).disabled).toBe(true)
+    // …and narrowing the shown set arms it again, counting the new set.
+    fireEvent.change(screen.getByRole('textbox', { name: /search tickets/i }), { target: { value: 'First' } })
+    expect(await screen.findByRole('button', { name: 'Add the ticket shown below to the AI queue' })).toBeTruthy()
   })
 
-  test('a ticket already on the queue is not queued twice — its open entry is worked as it stands', async () => {
+  test('a ticket already on the queue is not queued twice', async () => {
     onAllTickets.mockResolvedValue([
       {
         projectId: 'p1',
@@ -321,18 +315,13 @@ describe('TicketsPage spin up the shown set', () => {
         ],
       },
     ])
-    const { sendStart, sendQueueTicket } = await controls()
+    const { sendQueueTicket } = await controls()
     render(<TicketsPage onOpenTicket={() => {}} />)
-    fireEvent.click(await screen.findByRole('button', { name: 'Spin up agents working on all 2 tickets shown below' }))
-    await waitFor(() => expect(sendStart).toHaveBeenCalledTimes(2))
-    // Only the genuinely unqueued ticket is written; the queued one's agent is pointed at the
-    // existing line verbatim, note and all — that is the line it must find to check off.
+    fireEvent.click(await screen.findByRole('button', { name: 'Add all 2 tickets shown below to the AI queue' }))
+    // Only the genuinely unqueued ticket is written; a.md's open entry stands as it is.
+    await screen.findByRole('button', { name: 'Queued' })
     expect(sendQueueTicket).toHaveBeenCalledTimes(1)
     expect(sendQueueTicket).toHaveBeenCalledWith('p1', 'Second', { file: 'b.md' })
-    expect(sendStart).toHaveBeenCalledWith('p1', workOnEntryPrompt('[First](tickets/a.md) — needs the new API'), 'prompt', {
-      unattended: true,
-      ticket: 'tickets/a.md',
-    })
   })
 
   test('claimed tickets are left to the agents holding them, and the label says so', async () => {
@@ -343,17 +332,13 @@ describe('TicketsPage spin up the shown set', () => {
         tickets: [ticket({ file: 'a.md', title: 'First' }), ticket({ file: 'b.md', title: 'Second', locked: true, lockedBy: 'agent-1' })],
       },
     ])
-    const { sendStart, sendQueueTicket } = await controls()
+    const { sendQueueTicket } = await controls()
     render(<TicketsPage onOpenTicket={() => {}} />)
-    // The label counts only what the click will start, never promising the claimed row.
-    fireEvent.click(await screen.findByRole('button', { name: 'Spin up an agent working on the one unclaimed ticket shown below' }))
-    await waitFor(() => expect(sendStart).toHaveBeenCalledTimes(1))
+    // The label counts only what the click will add, never promising the claimed row.
+    fireEvent.click(await screen.findByRole('button', { name: 'Add the one unclaimed ticket shown below to the AI queue' }))
+    await screen.findByRole('button', { name: 'Queued' })
     expect(sendQueueTicket).toHaveBeenCalledTimes(1)
     expect(sendQueueTicket).toHaveBeenCalledWith('p1', 'First', { file: 'a.md' })
-    expect(sendStart).toHaveBeenCalledWith('p1', workOnEntryPrompt('[First](tickets/a.md)'), 'prompt', {
-      unattended: true,
-      ticket: 'tickets/a.md',
-    })
   })
 
   test('nothing shown, no button: an empty shown set is not an offer', async () => {
@@ -363,7 +348,7 @@ describe('TicketsPage spin up the shown set', () => {
     window.history.replaceState(null, '', '/tickets?q=zzz-no-match')
     render(<TicketsPage onOpenTicket={() => {}} />)
     await screen.findByText(/1 ticket hidden by the current filters/i)
-    expect(screen.queryByRole('button', { name: /spin up/i })).toBeNull()
+    expect(screen.queryByRole('button', { name: /to the ai queue/i })).toBeNull()
   })
 
   test('every shown ticket claimed, no button: the whole set is already being worked', async () => {
@@ -372,6 +357,6 @@ describe('TicketsPage spin up the shown set', () => {
     ])
     render(<TicketsPage onOpenTicket={() => {}} />)
     await screen.findByText('First')
-    expect(screen.queryByRole('button', { name: /spin up/i })).toBeNull()
+    expect(screen.queryByRole('button', { name: /to the ai queue/i })).toBeNull()
   })
 })