The routine card remembers which project Run now targets (#1647)

The card's "Run in" pick was component state, so it was forgotten whenever
the card unmounted — open a run, come back — and the picker read the first
registered project again: the user's real repo. The next click fired a triage
there and pushed an empty triage branch to its origin.

The pick is now a preference, `autoPmProject`, beside the opt-outs and the
concurrency it sits with on the card: written when the picker changes, read
back on every render, so it holds across navigations, reloads and tabs. The
card still validates it against the projects it shows, so a remembered project
that is no longer registered falls back to the first.

Author: suleimansh

FEATURES-SPEC.md

@@ -23,7 +23,7 @@ happens while nobody is at the keyboard.
 - Pre-flight warnings before spending (no `gh`, logged out, repo can't auto-merge)
 - Start an agent from a ticket row
 - Start an agent from a queue entry's play button
-- "Run now" on a routine
+- "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
 - What a routine's "Run now" is about to spend, on hover — what that routine does, how many agents it costs, which model it will use, and where it runs
 - The whole CLI is one command: `the-framework` serves the dashboard — four options, no verbs

packages/the-framework/dashboard/components/RoutineWork.SPEC.md

@@ -3,6 +3,7 @@ The Overview's Routine work card: the jobs fired by the scheduled sweep — the
 ## Flows
 
 - The list is read straight from the definition the daemon runs, so screen and schedule cannot drift; Run now starts the work at once rather than asking the sweep to come sooner.
+- The project a Run now targets is picked once and kept as one of the user's settings, so leaving the Overview to look at a run and coming back — or reloading — does not quietly put the first project, the user's real repo, back in the picker. A remembered project that is no longer registered falls back to the first.
 - The two routines that fan out — queue-draining and ticket-planning — have their Run now ask the sweep for that routine's work only, which is the one path that can spin up several agents, up to the concurrency setting. Draining visits every project; planning stays in the project the card has picked. The two triage routines ask the sweep too, for a different reason: each works on one fixed branch, and only the sweep deletes a leftover copy of it before starting — started directly, the agent read the leftover as a triage already under way and gave up. Every other routine's Run now is one agent started directly, because concurrent copies of it would undo each other. Card-fired routines run unattended, like the sweep's own.
 - Two checkbox tiers: the master switch turns the schedule on or off, a row's box takes that one routine in or out of it — recorded as opt-outs, so a routine added by a later version runs by default.
 - "Trigger routine now" sweeps once even with auto-run off (the click is the consent), and the sweep answers on the card per project, so "ran and found nothing" never looks like "never ran".

packages/the-framework/dashboard/components/RoutineWork.test.SPEC.md

@@ -1,4 +1,4 @@
-Covers the Routine work card: routines listed by label with Run now starting the prompt verbatim (unattended, then jumping to the agent), the drain and the planning routine firing a fan-out-capable sweep instead and each triage routine asking the sweep for itself by its branch, per-routine opt-out boxes versus the master auto-agent switch, the on-demand trigger working with auto-run off, the sweep's per-project answers landing on the card, the concurrency setting's clamping, "Configure first, then run" carrying the prompt to the picked project's launcher instead of starting anything (and saying so on the drain), each Run now naming on hover what the routine does and the model and place its start would use (and the drain saying instead that every project decides its own), and the picker, empty, failure, and busy states.
+Covers the Routine work card: routines listed by label with Run now starting the prompt verbatim (unattended, then jumping to the agent), the drain and the planning routine firing a fan-out-capable sweep instead and each triage routine asking the sweep for itself by its branch, per-routine opt-out boxes versus the master auto-agent switch, the on-demand trigger working with auto-run off, the sweep's per-project answers landing on the card, the concurrency setting's clamping, "Configure first, then run" carrying the prompt to the picked project's launcher instead of starting anything (and saying so on the drain), each Run now naming on hover what the routine does and the model and place its start would use (and the drain saying instead that every project decides its own), and the picker (kept as a setting, falling back to the first project when the remembered one is gone), empty, failure, and busy states.
 
 ## Before modifying/creating SPEC.md files
 

packages/the-framework/dashboard/components/RoutineWork.test.tsx

@@ -236,14 +236,38 @@ describe('RoutineWork (#1159)', () => {
 
   test('the prompt goes to the project the card has picked, not the first one (#1507)', async () => {
     onProjects.mockResolvedValue([project('p1', 'gemstack'), project('p2', 'other')])
+    // The pick is the setting (#1647); the picker writes it, and the card reads it back.
+    prefs = { autoPmProject: 'p2' }
     const selected: string[] = []
     renderCard({ onSelectProject: id => selected.push(id) })
     await waitFor(() => expect(screen.getAllByText('Run now').length).toBe(AUTO_PM_ROUTINES.length))
-    fireEvent.change(screen.getByLabelText('Run in'), { target: { value: 'p2' } })
     fireEvent.click(await openRunMenu(ROTATION_JOB))
     await waitFor(() => expect(selected).toEqual(['p2']))
   })
 
+  // #1647: the pick is a preference. Held as card state it was forgotten whenever the card
+  // unmounted — open a run, come back — and the next click landed on the first project, the real
+  // repo, which pushed an empty triage branch there.
+  test('the picked project is a setting, so it holds across navigations and reloads (#1647)', async () => {
+    onProjects.mockResolvedValue([project('p1', 'gemstack'), project('p2', 'other')])
+    prefs = { autoPmProject: 'p2' }
+    renderCard()
+    await waitFor(() => expect(screen.getAllByText('Run now').length).toBe(AUTO_PM_ROUTINES.length))
+    // Read back from the setting, not defaulted to the first project.
+    expect((screen.getByLabelText('Run in') as HTMLSelectElement).value).toBe('p2')
+    // Written as the setting, so a remount reads the same answer.
+    fireEvent.change(screen.getByLabelText('Run in'), { target: { value: 'p1' } })
+    expect(updatePreferences).toHaveBeenCalledWith({ autoPmProject: 'p1' })
+  })
+
+  test('a remembered project that is no longer registered falls back to the first (#1647)', async () => {
+    onProjects.mockResolvedValue([project('p1', 'gemstack'), project('p2', 'other')])
+    prefs = { autoPmProject: 'gone' }
+    renderCard()
+    await waitFor(() => expect(screen.getAllByText('Run now').length).toBe(AUTO_PM_ROUTINES.length))
+    expect((screen.getByLabelText('Run in') as HTMLSelectElement).value).toBe('p1')
+  })
+
   test("the drain's menu item says it is one agent, not the fan-out its Run now fires (#1507)", async () => {
     renderCard()
     await openRunMenu(AUTO_PM_DRAIN_JOB)
@@ -390,9 +414,10 @@ describe('RoutineWork (#1159)', () => {
 
   test('several projects get a picker, and Run now honours it', async () => {
     onProjects.mockResolvedValue([project('p1', 'gemstack'), project('p2', 'rudder')])
+    // The picker's pick is the setting (#1647), so this is what a picked card reads.
+    prefs = { autoPmProject: 'p2' }
     renderCard()
-    const select = await screen.findByLabelText('Run in')
-    fireEvent.change(select, { target: { value: 'p2' } })
+    expect(((await screen.findByLabelText('Run in')) as HTMLSelectElement).value).toBe('p2')
     fireEvent.click(screen.getAllByText('Run now')[1]!)
     await waitFor(() => expect(start).toHaveBeenCalled())
     expect(start.mock.calls[0]![0]).toBe('p2')

packages/the-framework/dashboard/components/RoutineWork.tsx

@@ -103,16 +103,21 @@ export function RoutineWork({
   const preferences = usePreferences()
   const report = useAutoPm()
   const { busy, error, start } = useStartAgent()
-  const [picked, setPicked] = useState<string | null>(null)
   // Which routine is in flight, so only its own button says "Starting…".
   const [starting, setStarting] = useState<string | null>(null)
   // The on-demand sweep (#1210): in flight, and anything worth saying about the last attempt.
   const [sweeping, setSweeping] = useState(false)
   const [sweepNote, setSweepNote] = useState<string | null>(null)
 
+  // The pick is a preference, not card state (#1647): the card unmounts on the most common
+  // navigation there is — open a run, come back — and a pick held here went with it, so the next
+  // click landed on the first project, which is the user's real repo. As a setting it holds
+  // across navigations, reloads and tabs, the way the opt-outs beside it do.
+  //
   // The list arrives after the first render, and a project can be removed under a stale pick, so
   // the selection is validated against what is actually there rather than trusted.
-  const projectId = (picked !== null && projects.some(p => p.id === picked) ? picked : projects[0]?.id) ?? null
+  const picked = preferences.autoPmProject
+  const projectId = (picked !== undefined && projects.some(p => p.id === picked) ? picked : projects[0]?.id) ?? null
 
   const autoAgent = preferences.autoPm ?? false
   // Absent = nothing opted out, which is also what the store saves an empty list back as.
@@ -231,7 +236,7 @@ export function RoutineWork({
                   id="routine-project"
                   className="min-w-0 flex-1 rounded-md border border-border bg-transparent px-2 py-1 text-sm"
                   value={projectId ?? ''}
-                  onChange={e => setPicked(e.target.value)}
+                  onChange={e => updatePreferences({ autoPmProject: e.target.value })}
                 >
                   {projects.map(p => (
                     <option key={p.id} value={p.id}>

packages/the-framework/src/registry.test.ts

@@ -322,6 +322,18 @@ test('writePreferences round-trips and clamps the spend-limit slider (#960)', as
   assert.deepEqual(await readPreferences(fs, ENV), {})
 })
 
+test('writePreferences keeps the routine card\'s picked project, trimmed, and drops an empty one (#1647)', async () => {
+  const fs = memFs({ [FILE]: JSON.stringify({ projects: [APP_A], preferences: {} }) })
+  await writePreferences({ autoPmProject: ' tf-1334-dogfood-f8nvbw ' }, fs, ENV)
+  assert.deepEqual(await readPreferences(fs, ENV), { autoPmProject: 'tf-1334-dogfood-f8nvbw' })
+  // Not checked against the project list here: the card validates the id against the projects it
+  // shows, so a project removed since falls back there rather than being erased on read.
+  await writePreferences({ autoPmProject: '' }, fs, ENV)
+  assert.deepEqual(await readPreferences(fs, ENV), {})
+  await writePreferences({ autoPmProject: 42 as never }, fs, ENV)
+  assert.deepEqual(await readPreferences(fs, ENV), {})
+})
+
 test('writePreferences round-trips and clamps the concurrent-agents setting (#1204)', async () => {
   const fs = memFs({ [FILE]: JSON.stringify({ projects: [APP_A], preferences: {} }) })
   await writePreferences({ autoPmConcurrency: 4 }, fs, ENV)

packages/the-framework/src/registry.ts

@@ -137,6 +137,16 @@ export interface Preferences {
    * the queue file, so it stays one agent per tick whatever this says.
    */
   autoPmConcurrency?: number
+  /**
+   * The project the Routine work card's "Run now" targets (#1647), by project id. Absent = the
+   * first registered project, which is what the card showed before this existed.
+   *
+   * A setting rather than card state, because the pick decides which repo spends quota and gets
+   * branches pushed, and card state forgot it on the most common navigation there is — open a
+   * run, come back — so the next click landed on the first project, the user's real one. An id
+   * that no longer names a registered project reads as absent.
+   */
+  autoPmProject?: string
   /**
    * How far the automatic-consumption limit sits from the quota boundary, in percentage points
    * (#960). Absent defaults to {@link DEFAULT_SPEND_OFFSET} — a half-day cushion ahead of the
@@ -383,6 +393,12 @@ function sanitizePreferences(value: unknown): Preferences {
   const concurrency = input['autoPmConcurrency']
   if (typeof concurrency === 'number' && Number.isFinite(concurrency))
     preferences.autoPmConcurrency = Math.min(Math.max(Math.round(concurrency), 1), MAX_AUTO_PM_CONCURRENCY)
+  // `autoPmProject` (#1647) is a project id, kept as a bounded free-form string rather than checked
+  // against the project list for the reason the opt-out names are not checked against the
+  // catalog: the card validates it against the projects it shows, and an id of a project removed
+  // since simply falls back there. Empty is dropped, which is exactly what absent means.
+  const routineProject = input['autoPmProject']
+  if (typeof routineProject === 'string' && routineProject.trim()) preferences.autoPmProject = routineProject.trim().slice(0, 100)
   return preferences
 }