@marcomigozzi/trailhead 0.15.0 → 0.16.1

package/plugins/trailhead/tests/map-pane-ui.test.ts

@@ -11,6 +11,17 @@ const FLOOR = 15_000
 const TIMER = 180_000
 const AMBER = '#e0af68'
 const URL = 'https://github.com/o/r/issues'
+const ROOT = '/repo'
+const ROOT_OTHER = '/other'
+// A linked worktree of ROOT: the repo's root is the main tree's, the checkout's own is this.
+const ROOT_TREE = '/repo-t5'
+// The checkout handed to a verb: base64url of the root, computed here by hand so the pane's own encoder is checked.
+// The helper's decodeIn cannot be imported here (the CommonJS template does not load in this suite); the node suite
+// checks decodeIn against Buffer's base64url, and these tests pin the same alphabet.
+const IN = (root: string) => {
+  const b64 = btoa(Array.from(new TextEncoder().encode(root), byte => String.fromCharCode(byte)).join(''))
+  return `--in=${b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')}`
+}
 
 const MAP = {
   title: 'trailhead mod',
@@ -63,12 +74,41 @@ const MAPS = [
 ]
 // The maps read: one GraphQL call that carries each map's sub-issue counts and the whiteboard's.
 const MAPS_QUERY =
-  'query($owner:String!,$repo:String!){repository(owner:$owner,name:$repo){issues(first:100,states:OPEN,labels:["trailhead:map"]){nodes{number title url subIssuesSummary{total completed}}}whiteboardOpen:issues(states:OPEN,labels:["trailhead:whiteboard"]){totalCount}whiteboardAll:issues(labels:["trailhead:whiteboard"]){totalCount}}}'
+  'query($owner:String!,$repo:String!){repository(owner:$owner,name:$repo){issues(first:100,states:OPEN,labels:["trailhead:map"]){nodes{number title url subIssuesSummary{total completed}}totalCount}whiteboardOpen:issues(states:OPEN,labels:["trailhead:whiteboard"]){totalCount}whiteboardAll:issues(labels:["trailhead:whiteboard"]){totalCount}}}'
 const MAPS_CALL = ['gh', 'api', 'graphql', '-F', 'owner={owner}', '-F', 'repo={repo}', '-f', `query=${MAPS_QUERY}`]
 const MAPS_LIST_CALL = ['gh', 'issue', 'list', '--label', 'trailhead:map', '--state', 'open', '--limit', '100', '--json', 'number,title,url']
-// The pending-UAT read of one scope (a map label, or the whiteboard): the tickets with their bodies.
-const uatCall = (scope: string) => ['gh', 'issue', 'list', '--label', 'trailhead:uat', '--label', scope, '--state', 'open', '--limit', '200', '--json', 'number,body']
-const isGraphql = (argv: readonly string[]) => argv[1] === 'api' && argv[2] === 'graphql'
+// The pending-UAT read: every open `trailhead:uat` ticket with its body and labels, one GraphQL page per call;
+// the scope (a map label, or the whiteboard) is filtered by the pane.
+const UAT_QUERY =
+  'query($owner:String!,$repo:String!,$after:String){repository(owner:$owner,name:$repo){issues(first:100,after:$after,states:OPEN,labels:["trailhead:uat"],orderBy:{field:CREATED_AT,direction:DESC}){nodes{number body labels(first:50){nodes{name}}}pageInfo{hasNextPage endCursor}}}}'
+const uatCall = (after?: string) => [
+  'gh', 'api', 'graphql', '-F', 'owner={owner}', '-F', 'repo={repo}', '-f', `query=${UAT_QUERY}`,
+  ...(after === undefined ? [] : ['-f', `after=${after}`]),
+]
+const isUatRead = (argv: readonly string[]) => argv[1] === 'api' && argv[2] === 'graphql' && argv.includes(`query=${UAT_QUERY}`)
+// The retired search read of the UAT parents: the pane must never run it.
+const isUatSearch = (argv: readonly string[]) => argv[2] === 'list' && argv.includes('trailhead:uat')
+const UAT_MAX_PAGES = 10
+// One open UAT ticket as the read returns it: its body and the labels it carries (the scope among them).
+const uatRow = (number: number, body: string, scope = 'trailhead:map-198') => ({ number, body, labels: [{ name: 'trailhead:uat' }, { name: scope }] })
+// The open-ticket read: one GraphQL page per call (`after=` carries the cursor of the next one).
+const TICKETS_QUERY =
+  'query($owner:String!,$repo:String!,$label:String!,$after:String){repository(owner:$owner,name:$repo){issues(first:100,after:$after,states:OPEN,labels:[$label],orderBy:{field:CREATED_AT,direction:DESC}){nodes{number title url labels(first:50){nodes{name}}assignees(first:10){nodes{login}}}pageInfo{hasNextPage endCursor}}}}'
+const ticketsCall = (label: string, after?: string) => [
+  'gh', 'api', 'graphql', '-F', 'owner={owner}', '-F', 'repo={repo}', '-f', `query=${TICKETS_QUERY}`, '-f', `label=${label}`,
+  ...(after === undefined ? [] : ['-f', `after=${after}`]),
+]
+const ticketsListCall = (label: string) => ['gh', 'issue', 'list', '--label', label, '--state', 'open', '--limit', '200', '--json', 'number,title,labels,assignees,url']
+const isTicketsRead = (argv: readonly string[]) => argv[1] === 'api' && argv[2] === 'graphql' && argv.includes(`query=${TICKETS_QUERY}`)
+// The maps read only: the ticket reads are GraphQL too, but answered and failed on their own.
+const isGraphql = (argv: readonly string[]) => argv[1] === 'api' && argv[2] === 'graphql' && !isTicketsRead(argv) && !isUatRead(argv) && !isCountRead(argv)
+// The open-ticket total: one aliased `totalCount` per open map (`m<n>`) plus the whiteboard (`wb`), in one call.
+const countQuery = (maps: number[]) =>
+  `query($owner:String!,$repo:String!){repository(owner:$owner,name:$repo){${[...maps.map(n => `m${n}:issues(states:OPEN,labels:["trailhead:map-${n}"]){totalCount}`), 'wb:issues(states:OPEN,labels:["trailhead:whiteboard"]){totalCount}'].join('')}}}`
+const countCall = (...maps: number[]) => ['gh', 'api', 'graphql', '-F', 'owner={owner}', '-F', 'repo={repo}', '-f', `query=${countQuery(maps)}`]
+const isCountRead = (argv: readonly string[]) => argv[1] === 'api' && argv[2] === 'graphql' && argv.some(a => a.startsWith('query=') && a.includes('wb:issues('))
+const flatNode = (t: any) => ({ ...t, labels: { nodes: t.labels }, assignees: { nodes: t.assignees } })
+const PAGE = 100
 const isMapsList = (argv: readonly string[]) => argv[2] === 'list' && argv.includes('trailhead:map')
 const OTHER_TICKETS = [issue(140, 'Old frontier ticket', ['trailhead:build']), issue(141, 'Old held ticket', ['trailhead:task'], ['carol'])]
 const OTHER_HISTORY = OTHER_TICKETS.map(t => hrow(t.number, t.labels.map(l => l.name), null))
@@ -97,7 +137,7 @@ const stateText = (over: Record<string, unknown> = {}): string =>
   })
 
 // The plugin's atoms, which the engine resets on /clear.
-const ATOM_KEYS = ['workState', 'isOrphaned', 'promptSnapshot', 'mapPane', 'activeMap', 'viewedMap', 'isDashboard', 'dashboardPane', 'pendingWork', 'paneAutoOpened', 'ownTicket']
+const ATOM_KEYS = ['workState', 'isOrphaned', 'promptSnapshot', 'mapPane', 'activeMap', 'viewedMap', 'isDashboard', 'dashboardPane', 'pendingWork', 'pendingPhase', 'paneAutoOpened', 'ownTicket', 'repoPin']
 
 const PANE_PROPS = {
   title: 'Map',
@@ -127,21 +167,58 @@ const rig = (on: On, engine?: any) => {
     mapSummary: { 198: { total: 23, completed: 16 }, 14: { total: 5, completed: 2 } } as Record<number, unknown>,
     // The whiteboard's open and total tickets as the same call reports them (null: the fields are absent).
     whiteboardCounts: { open: 3, total: 9 } as { open: number; total: number } | null,
+    // The open tickets per label, as the total's count read reports them (a missing label counts 0); `countMode`
+    // makes that read fail (`fail`), answer `errors` (`errors`) or non-JSON (`junk`), `countTotal` the maps read's `totalCount`.
+    openCounts: { 'trailhead:map-198': 5, 'trailhead:map-14': 2, 'trailhead:whiteboard': 3 } as Record<string, number>,
+    countMode: 'ok' as 'ok' | 'fail' | 'errors' | 'junk',
+    countTotal: null as number | null,
     otherMap: OTHER_MAP as unknown,
     otherTickets: OTHER_TICKETS as unknown[],
     otherHistory: OTHER_HISTORY as unknown[],
     whiteboard: WHITEBOARD as unknown[],
-    // The UAT read's answer: one row per UAT ticket, `{ number, body }`; null makes the read fail.
+    // The UAT read's answer: one row per open UAT ticket, `{ number, body, labels }` (the scope label rides
+    // in `labels`); null makes the read fail. `uatErrors` answers a reply with `errors`, `uatBroken` non-JSON.
     uat: [] as unknown[] | null,
+    uatErrors: false,
+    uatBroken: false,
     dashboard: DASHBOARD as unknown[],
     gh: null as Gh | null,
     // What `gh` answers when no test replaced it; a test can wrap it.
     defaultGh: null as unknown as Gh,
     deny: null as string | null,
+    // The session's working directory, which a shell `cd` moves, and what `session.repo` finds there
+    // (null outside any repo). Relative reads and a `gh` without its own cwd resolve against `cwd`.
+    cwd: '/repo',
+    repo: { root: '/repo', remote: 'git@github.com:o/r.git', internal: false } as { root: string; remote: string | null; internal: boolean } | null,
+    // The active-map marker of the second checkout (ROOT_OTHER); null: it has none.
+    otherActive: null as string | null,
+    // Runs once before the next read of the active-map marker, to land an event inside a check.
+    beforeMarkerRead: null as (() => Promise<void>) | null,
+    // The worktree checkout's marker, what `git rev-parse --show-toplevel` answers there (null: it fails), and the
+    // session's project root; every path read and every `git` run is recorded.
+    treeActive: null as string | null,
+    top: null as string | null,
+    sessionRoot: '/repo',
+    reads: [] as string[],
+    // The hosts `gh auth status --hostname` accepts besides github.com, and every host it was asked about.
+    authHosts: [] as string[],
+    authCalls: [] as string[],
+    gitCalls: [] as { argv: readonly string[]; cwd: string | undefined }[],
+    // The cwd every `gh` run carried (undefined: none given).
+    cwds: [] as (string | undefined)[],
     calls: [] as (readonly string[])[],
     panes: [] as { id: string; title: string; isShown: boolean; isFocused: boolean; isPlaced: boolean }[],
     isPlaced: true,
     logs: [] as string[],
+    toasts: [] as string[],
+    // What a Bash call prints on stdout (the created issue's URL for a `gh issue create`).
+    stdout: 'ok' as string,
+    // `session.repo` answers a denial (the checkout cannot be read).
+    repoFails: false,
+    // What `git remote get-url origin` answers (null: no origin), for a `session.repo` that answers null (#299).
+    gitRemote: null as string | null,
+    // Checkout roots that no longer exist: git answers 128 there (a removed worktree or clone).
+    gone: [] as string[],
     opens: [] as { id: string; title?: string }[],
     // `command.run` beneath the plugin: every run is recorded; `gate` holds a work run, `refuse` rejects it.
     // Every file write beneath the plugin: the pane must never write the active-map marker.
@@ -155,7 +232,15 @@ const rig = (on: On, engine?: any) => {
     // The clear answered by a `{ deny }` hook: it resolves the call and the session stays.
     denyClear: false,
     // Runs between the old session ending and the new one starting.
-    duringClear: null as (() => void) | null,
+    duringClear: null as (() => void | Promise<void>) | null,
+    // Runs once, in the next `session.id` read (a dispatch's own read before its clear).
+    beforeSessionId: null as (() => void | Promise<void>) | null,
+    // Every value written to the pendingPhase atom, in order.
+    phases: [] as unknown[],
+    // Atom values the engine reports whatever was written (a state a hot reload left); a write clears the key.
+    forced: {} as Record<string, unknown>,
+    // Runs once, before the next pendingPhase write lands (the row still reads what it read before).
+    beforePhaseWrite: null as (() => void | Promise<void>) | null,
     session: SESSION,
     clock: mock.clock(on, { now: T0 }),
     // The person opening the pane: the engine's own record, the plugin is not told.
@@ -164,22 +249,62 @@ const rig = (on: On, engine?: any) => {
     },
   }
   const defaultGh: Gh = argv => {
-    if (argv.includes('trailhead:uat')) return r.uat === null ? { exitCode: 1, stdout: '', stderr: 'boom' } : ok(JSON.stringify(r.uat))
+    if (isTicketsRead(argv)) {
+      const label = (argv.find(a => a.startsWith('label=')) ?? '').slice('label='.length)
+      const cursor = argv.find(a => a.startsWith('after='))
+      const all = (label === 'trailhead:whiteboard' ? r.whiteboard : label === 'trailhead:map-14' ? r.otherTickets : r.tickets) as unknown[]
+      const from = cursor === undefined ? 0 : Number(cursor.slice('after=c'.length))
+      const to = from + PAGE
+      const pageInfo = { hasNextPage: to < all.length, endCursor: `c${to}` }
+      return ok(JSON.stringify({ data: { repository: { issues: { nodes: all.slice(from, to).map(flatNode), pageInfo } } } }))
+    }
+    if (isUatRead(argv)) {
+      if (r.uat === null) return { exitCode: 1, stdout: '', stderr: 'boom' }
+      if (r.uatBroken) return ok('not json')
+      if (r.uatErrors) return ok(JSON.stringify({ data: { repository: { issues: { nodes: [] } } }, errors: [{ message: 'x' }] }))
+      const cursor = argv.find(a => a.startsWith('after='))
+      const from = cursor === undefined ? 0 : Number(cursor.slice('after=c'.length))
+      const to = from + PAGE
+      const pageInfo = { hasNextPage: to < r.uat.length, endCursor: `c${to}` }
+      const nodes = (r.uat as any[]).slice(from, to).map(u => ({ ...u, labels: { nodes: u.labels ?? [] } }))
+      return ok(JSON.stringify({ data: { repository: { issues: { nodes, pageInfo } } } }))
+    }
+    if (isCountRead(argv)) {
+      if (r.countMode === 'fail') return { exitCode: 1, stdout: '', stderr: 'boom' }
+      if (r.countMode === 'junk') return ok('not json')
+      const query = (argv.find(a => a.startsWith('query=')) ?? '').slice('query='.length)
+      const repo = Object.fromEntries([...query.matchAll(/(\w+):issues\(states:OPEN,labels:\["([^"]+)"\]\)\{totalCount\}/g)].map(m => [m[1], { totalCount: r.openCounts[m[2] as string] ?? 0 }]))
+      return ok(JSON.stringify({ data: { repository: repo }, ...(r.countMode === 'errors' ? { errors: [{ message: 'x' }] } : {}) }))
+    }
     if (argv.includes('trailhead:whiteboard')) return ok(JSON.stringify(r.whiteboard))
     if (argv.includes('trailhead:dashboard')) return ok(JSON.stringify(r.dashboard))
     if (isGraphql(argv)) {
       const nodes = (r.maps as { number: number }[]).map(m => ({ ...m, subIssuesSummary: r.mapSummary[m.number] }))
       const wb = r.whiteboardCounts
       const counts = wb === null ? {} : { whiteboardOpen: { totalCount: wb.open }, whiteboardAll: { totalCount: wb.total } }
-      return ok(JSON.stringify({ data: { repository: { issues: { nodes }, ...counts } } }))
+      const totalCount = r.countTotal ?? nodes.length
+      return ok(JSON.stringify({ data: { repository: { issues: { nodes, totalCount }, ...counts } } }))
     }
     if (isMapsList(argv)) return ok(JSON.stringify(r.maps))
     const isOther = argv.includes('14') || argv.includes('trailhead:map-14')
     if (argv[2] === 'view') return ok(JSON.stringify(isOther ? r.otherMap : r.map))
     return ok(JSON.stringify(argv.includes('all') ? (isOther ? r.otherHistory : r.history) : isOther ? r.otherTickets : r.tickets))
   }
-  on('fs.read', (_$, e) => {
-    const file = e.path.endsWith('/.trailhead/active-map') ? r.active : e.path.endsWith('/.trailhead/work-state.json') ? r.work : undefined
+  on('fs.read', async (_$, e) => {
+    // A relative path reaches the hook already resolved against the host's directory, not the repo's: put
+    // it under the session's working directory, which is what the engine resolves it against. A path under
+    // one of the repos is absolute (a pinned read) and stays.
+    const isAbsolute = [ROOT, ROOT_OTHER, ROOT_TREE].some(root => e.path.startsWith(`${root}/`))
+    const path = isAbsolute ? e.path : `${r.cwd}${e.path.slice(e.path.indexOf('/.trailhead/'))}`
+    r.reads.push(path)
+    if (path.endsWith('/.trailhead/active-map') && r.beforeMarkerRead !== null) {
+      const hook = r.beforeMarkerRead
+      r.beforeMarkerRead = null
+      await hook()
+    }
+    const root = path.startsWith(`${ROOT_TREE}/`) ? ROOT_TREE : path.startsWith(`${ROOT_OTHER}/`) ? ROOT_OTHER : path.startsWith(`${ROOT}/`) ? ROOT : null
+    const marker = root === ROOT_TREE ? r.treeActive : root === ROOT_OTHER ? r.otherActive : r.active
+    const file = path.endsWith('/.trailhead/active-map') ? (root === null ? null : marker) : path.endsWith('/.trailhead/work-state.json') ? (root === null ? null : r.work) : undefined
     if (file === undefined) return { deny: `unexpected read of ${e.path}` }
     if (file === null) return { deny: `ENOENT: no such file or directory, open '${e.path}'` }
     if (file instanceof Error) return { deny: file.message }
@@ -196,16 +321,24 @@ const rig = (on: On, engine?: any) => {
   const emptied = new Set<string>()
   let clears = 0
   on('state.get', { plugin: 'trailhead' }, async (_$, e, next) => {
+    if (e.key in r.forced) return { value: { value: r.forced[e.key], version: 1 } }
     const read = await next(e)
     return emptied.has(e.key) ? { value: { value: undefined, version: read.value?.version ?? 0 } } : read
   })
-  on('state.set', { plugin: 'trailhead' }, (_$, e, next) => {
+  on('state.set', { plugin: 'trailhead' }, async (_$, e, next) => {
+    if (e.key === 'pendingPhase') {
+      const hold = r.beforePhaseWrite
+      r.beforePhaseWrite = null
+      await hold?.()
+      r.phases.push(e.value)
+    }
+    delete r.forced[e.key]
     emptied.delete(e.key)
     return next(e)
   })
   const emulateClear = async () => {
     await engine.session.end({ reason: 'clear', sessionId: r.session, resume: {} })
-    r.duringClear?.()
+    await r.duringClear?.()
     ATOM_KEYS.forEach(key => emptied.add(key))
     r.session = `${NEXT_SESSION}-${(clears += 1)}`
     await engine.classic.SessionStart({ source: 'clear' })
@@ -224,14 +357,52 @@ const rig = (on: On, engine?: any) => {
     if (r.refuse !== null) throw new Error(r.refuse)
     return { text: '' }
   })
-  on('session.id', () => ({ value: r.session }))
+  on('session.id', async () => {
+    const hold = r.beforeSessionId
+    r.beforeSessionId = null
+    await hold?.()
+    return { value: r.session }
+  })
   on('ui.log', (_$, e) => {
     r.logs.push(e.text)
     return { value: undefined }
   })
   on('ui.status', () => ({ value: undefined }))
+  on('ui.toast', (_$, e) => {
+    r.toasts.push(e.text)
+    return { value: undefined }
+  })
+  on('session.repo', () => (r.repoFails ? { deny: 'repo read failed' } : { value: r.repo }))
+  on('session.root', () => ({ value: r.sessionRoot }))
+  on('session.cwd', () => ({ value: r.cwd }))
   on('process.run', async (_$, e) => {
+    // The pin's own `git rev-parse --show-toplevel`: answered apart, never counted as a `gh` call.
+    if (e.argv[0] === 'git') {
+      r.gitCalls.push({ argv: [...e.argv], cwd: e.init?.cwd })
+      // Answered per directory, like git: the worktree gives `top`, the other checkouts their own root.
+      const where = e.init?.cwd
+      if (e.argv[1] === 'remote') {
+        const remote = r.gitRemote === null ? { exitCode: 2, stdout: '', stderr: '' } : { exitCode: 0, stdout: `${r.gitRemote}\n`, stderr: '' }
+        return { value: { ...remote, isStdoutTruncated: false, isStderrTruncated: false } }
+      }
+      const top = where !== undefined && r.gone.includes(where) ? null : where === ROOT_TREE ? r.top : where === ROOT || where === ROOT_OTHER ? where : null
+      const out = top === null ? { exitCode: 128, stdout: '', stderr: 'fatal: not a git repository' } : { exitCode: 0, stdout: `${top}\n`, stderr: '' }
+      return { value: { ...out, isStdoutTruncated: false, isStderrTruncated: false } }
+    }
+    // The pin's host check: answered apart, never counted as a read of the pane.
+    if (e.argv[1] === 'auth') {
+      const host = e.argv[4] ?? ''
+      r.authCalls.push(host)
+      const out = r.authHosts.includes(host) ? { exitCode: 0, stdout: '', stderr: '' } : { exitCode: 1, stdout: '', stderr: `You are not logged into any accounts on ${host}` }
+      return { value: { ...out, isStdoutTruncated: false, isStderrTruncated: false } }
+    }
     r.calls.push([...e.argv])
+    r.cwds.push(e.init?.cwd)
+    // `gh` needs a repo around it: without its own cwd it uses the session's, wherever a `cd` left it.
+    const where = e.init?.cwd ?? r.cwd
+    if (where !== ROOT && where !== ROOT_OTHER && where !== ROOT_TREE) {
+      return { value: { exitCode: 1, stdout: '', stderr: 'failed to run git: fatal: not a git repository', isStdoutTruncated: false, isStderrTruncated: false } }
+    }
     if (r.deny !== null) return { deny: r.deny }
     const out = await (r.gh ?? defaultGh)(e.argv)
     return { value: { ...out, isStdoutTruncated: false, isStderrTruncated: false } }
@@ -249,7 +420,7 @@ const rig = (on: On, engine?: any) => {
     return { value: undefined }
   })
   on('ui.panes', () => ({ value: r.panes }))
-  on('tool.call', { tool: 'Bash' }, () => ({ result: 'ok' }) as never)
+  on('tool.call', { tool: 'Bash' }, () => ({ result: { stdout: r.stdout, stderr: '' } }) as never)
   on('session.start', (_$, e) => ({ cwd: e.cwd }))
   on('classic.SessionStart', () => ({}))
   on('turn.start', (_$, e) => ({ turnId: e.turnId }))
@@ -279,11 +450,11 @@ const settle = async (r: Rig) => {
   for (let i = 0; i < 10; i += 1) await r.clock.settle()
 }
 // The open-list reads; the history read rides along with each and is not counted.
-const fetches = (r: Rig) => r.calls.filter(argv => argv[2] === 'list' && argv.includes('open') && !argv.includes('trailhead:map') && !argv.includes('trailhead:uat')).length
+const fetches = (r: Rig) => r.calls.filter(argv => isTicketsRead(argv) && !argv.some(a => a.startsWith('after='))).length
 // A gh that answers as the default does, except for the history read.
 const withHistory = (r: Rig, answer: GhOut): Gh => argv => {
   if (argv.includes('all')) return answer
-  if (isGraphql(argv) || isMapsList(argv)) return r.defaultGh(argv)
+  if (isGraphql(argv) || isCountRead(argv) || isMapsList(argv)) return r.defaultGh(argv)
   return argv[2] === 'view' ? ok(JSON.stringify(r.map)) : ok(JSON.stringify(r.tickets))
 }
 const hasKey = async (ui: any, key: string): Promise<boolean> => (await ui.find({ key })) !== undefined
@@ -309,10 +480,11 @@ for (const surface of SURFACES) {
 
     expect(r.calls).toEqual([
       ['gh', 'issue', 'view', '198', '--json', 'title,body,url'],
-      ['gh', 'issue', 'list', '--label', 'trailhead:map-198', '--state', 'open', '--limit', '200', '--json', 'number,title,labels,assignees,url'],
+      ticketsCall('trailhead:map-198'),
       ['gh', 'issue', 'list', '--label', 'trailhead:map-198', '--state', 'all', '--limit', '5000', '--json', 'number,labels,createdAt,closedAt'],
       MAPS_CALL,
-      uatCall('trailhead:map-198'),
+      uatCall(),
+      countCall(14, 198),
     ])
     expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
     expect((await ui.find({ type: 'Link' }))?.props).toMatchObject({ href: `${URL}/198` })
@@ -369,9 +541,9 @@ for (const surface of SURFACES) {
       issue(243, 'Paused UAT', ['trailhead:task', 'trailhead:uat', 'trailhead:paused']),
     ]
     r.uat = [
-      { number: 240, body: `Run it\n\nUAT of: [Burn-down view of the map](${URL}/209)\n` },
-      { number: 241, body: `UAT of: #212` },
-      { number: 243, body: `UAT of: [Paused parent](${URL}/150)` },
+      uatRow(240, `Run it\n\nUAT of: [Burn-down view of the map](${URL}/209)\n`),
+      uatRow(241, `UAT of: #212`),
+      uatRow(243, `UAT of: [Paused parent](${URL}/150)`),
     ]
     await $.session.start(START)
     const ui = await openAndMount($, r)
@@ -391,6 +563,9 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'uat-of-241')).toBe('tests #212')
     expect(await hasKey(ui, 'uat-of-242')).toBe(false)
     expect(await textOf(ui, 'uat-of-243')).toBe('tests Paused parent #150')
+    // the parents come through one GraphQL read, never through the search index
+    expect(r.calls.filter(isUatRead)).toEqual([uatCall()])
+    expect(r.calls.filter(isUatSearch)).toEqual([])
     // a marker, not a state: a frontier UAT task keeps its work button, a held one its holder, a seed stays dim
     expect(await hasKey(ui, 'work-240')).toBe(true)
     expect(await textOf(ui, 'holder-242')).toBe('@alice')
@@ -417,20 +592,73 @@ for (const surface of SURFACES) {
     expect(await hasKey(ui, 'error')).toBe(false)
   })
 
+  test(`a UAT row of another scope does not set the parent of a row with the same number [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.tickets = [...TICKETS, issue(240, 'UAT of the burn-down', ['trailhead:task', 'trailhead:uat'])]
+    r.uat = [uatRow(240, `UAT of: [Elsewhere](${URL}/14)`, 'trailhead:map-14'), uatRow(241, `UAT of: #5`)]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'head-uat')).toBe('UAT · 1')
+    expect(await hasKey(ui, 'uat-of-240')).toBe(false)
+  })
+
+  test(`more than one page of follow-ups is read, the second call carrying the cursor [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.tickets = [...TICKETS, issue(500, 'Deep UAT', ['trailhead:task', 'trailhead:uat'])]
+    r.uat = [...Array.from({ length: 149 }, (_, i) => uatRow(1000 + i, 'no parent line')), uatRow(500, `UAT of: [Deep parent](${URL}/77)`)]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(r.calls.filter(isUatRead)).toEqual([uatCall(), uatCall('c100')])
+    expect(await textOf(ui, 'uat-of-500')).toBe('tests Deep parent #77')
+  })
+
+  const failClosed: [string, (r: Rig) => void][] = [
+    ['a failed second page', r => { r.gh = argv => (isUatRead(argv) && argv.some(a => a.startsWith('after=')) ? { exitCode: 1, stdout: '', stderr: 'boom' } : r.defaultGh(argv)) }],
+    ['a reply with errors', r => { r.uatErrors = true }],
+    ['a reply that is not JSON', r => { r.uatBroken = true }],
+  ]
+  for (const [name, arm] of failClosed) {
+    test(`${name} draws the UAT rows with no parent line, no fallback, no partial map [${surface}]`, async ($, on) => {
+      const r = rig(on, $)
+      r.tickets = [...TICKETS, issue(240, 'UAT of the burn-down', ['trailhead:task', 'trailhead:uat'])]
+      // the parent sits on page 1; a second page exists so the failed-page case has something to lose
+      r.uat = [uatRow(240, `UAT of: [Burn-down](${URL}/209)`), ...Array.from({ length: 120 }, (_, i) => uatRow(1000 + i, 'x'))]
+      arm(r)
+      await $.session.start(START)
+      const ui = await openAndMount($, r)
+      expect(await textOf(ui, 'head-uat')).toBe('UAT · 1')
+      expect(await hasKey(ui, 'uat-of-240')).toBe(false)
+      expect(await hasKey(ui, 'error')).toBe(false)
+      expect(r.calls.filter(isUatSearch)).toEqual([])
+    })
+  }
+
+  test(`a read still paging at the cap draws no parent line and stops at the cap [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.tickets = [...TICKETS, issue(240, 'UAT of the burn-down', ['trailhead:task', 'trailhead:uat'])]
+    r.uat = [uatRow(240, `UAT of: [Burn-down](${URL}/209)`), ...Array.from({ length: UAT_MAX_PAGES * PAGE + 5 }, (_, i) => uatRow(2000 + i, 'x'))]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(r.calls.filter(isUatRead)).toHaveLength(UAT_MAX_PAGES)
+    expect(await textOf(ui, 'head-uat')).toBe('UAT · 1')
+    expect(await hasKey(ui, 'uat-of-240')).toBe(false)
+  })
+
   test(`the dashboard view groups UAT whiteboard tickets with their parent, reading the whiteboard scope [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     r.whiteboard = [...WHITEBOARD, issue(306, 'Loose UAT', [...WB, 'trailhead:task', 'trailhead:uat'])]
-    r.uat = [{ number: 306, body: `UAT of: [Loose parent](${URL}/290)` }]
+    r.uat = [uatRow(306, `UAT of: [Loose parent](${URL}/290)`, 'trailhead:whiteboard'), uatRow(306, `UAT of: #1`, 'trailhead:map-14')]
     await $.session.start(START)
     const ui = await openAndMount($, r)
     await pressDashboard(ui, r)
-    expect(r.calls.some(argv => JSON.stringify(argv) === JSON.stringify(uatCall('trailhead:whiteboard')))).toBe(true)
+    expect(r.calls.filter(isUatRead)).toContainEqual(uatCall())
+    expect(r.calls.filter(isUatSearch)).toEqual([])
     expect(await textOf(ui, 'head-uat')).toBe('UAT · 1')
     expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-306', 'row-303'])
     expect(await textOf(ui, 'uat-of-306')).toBe('tests Loose parent #290')
   })
 
-  test(`a paused ticket sits under Paused between In progress and Blocked, with no work button [${surface}]`, async ($, on) => {
+  test(`a paused ticket sits under Paused between In progress and Blocked, with a resume button [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     r.work = stateText()
     r.tickets = [
@@ -449,11 +677,11 @@ for (const surface of SURFACES) {
     // a paused ticket appears in one group only: Frontier, In progress, Paused, Blocked in order
     expect(await keysOf(ui, 'row-')).toEqual(['row-209', 'row-210', 'row-214', 'row-208', 'row-212', 'row-230', 'row-231', 'row-232', 'row-211', 'row-213'])
     expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-frontier', 'group-in-progress', 'group-paused', 'group-blocked'])
-    expect(await textOf(ui, 'holder-230')).toBe('@ToRvaLDz')
-    expect((await ui.find({ key: 'holder-230' }))?.children[0].props).not.toHaveProperty('dimColor')
-    expect(await textOf(ui, 'holder-232')).toBe('@bob')
-    expect(await ui.find({ key: 'holder-231' })).toBeUndefined()
-    for (const n of [230, 231, 232]) expect(await hasKey(ui, `work-${n}`)).toBe(false)
+    for (const n of [230, 231, 232]) {
+      expect(await hasKey(ui, `resume-${n}`)).toBe(true)
+      expect(await hasKey(ui, `work-${n}`)).toBe(false)
+      expect(await hasKey(ui, `holder-${n}`)).toBe(false)
+    }
     expect((await ui.find({ key: 'ticket-231' }))?.children[0].props).not.toHaveProperty('dimColor')
   })
 
@@ -466,7 +694,63 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'head-paused')).toBe('Paused · 1')
     expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-305', 'row-303'])
     expect(await hasKey(ui, 'work-305')).toBe(false)
-    expect(await textOf(ui, 'holder-305')).toBe('@alice')
+    expect(await hasKey(ui, 'resume-305')).toBe(true)
+  })
+
+  test(`needs-you tickets sit in their own group first, once each, with a work button unless held [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.tickets = [
+      ...TICKETS,
+      issue(250, 'Needs you plain', ['trailhead:build', 'trailhead:needs-you']),
+      issue(251, 'Needs you paused', ['trailhead:build', 'trailhead:needs-you', 'trailhead:paused']),
+      issue(252, 'Needs you paused and held', ['trailhead:build', 'trailhead:needs-you', 'trailhead:paused'], ['bob']),
+      issue(253, 'Needs you UAT', ['trailhead:task', 'trailhead:needs-you', 'trailhead:uat']),
+      issue(254, 'Needs you held', ['trailhead:build', 'trailhead:needs-you'], ['alice']),
+      issue(255, 'Needs you blocked', ['trailhead:build', 'trailhead:needs-you', 'trailhead:blocked']),
+    ]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+
+    expect(await textOf(ui, 'head-needs-you')).toBe('Needs you · 6')
+    expect((await ui.find({ key: 'head-needs-you' }))?.children[0]).toMatchObject({ props: { bold: true } })
+    expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-needs-you', 'group-frontier', 'group-in-progress', 'group-blocked'])
+    // each ticket once, ahead of the frontier rows; the other counts leave them out
+    expect(await keysOf(ui, 'row-')).toEqual(['row-250', 'row-251', 'row-252', 'row-253', 'row-254', 'row-255', 'row-209', 'row-210', 'row-214', 'row-208', 'row-212', 'row-211', 'row-213'])
+    expect(await textOf(ui, 'head-frontier')).toBe('Frontier · 3')
+    expect(await hasKey(ui, 'head-paused')).toBe(false)
+    expect(await hasKey(ui, 'head-uat')).toBe(false)
+    for (const n of [250, 251, 253]) {
+      expect(await hasKey(ui, `work-${n}`)).toBe(true)
+      expect(await hasKey(ui, `resume-${n}`)).toBe(false)
+    }
+    for (const n of [252, 254]) {
+      expect(await textOf(ui, `holder-${n}`)).toBe(n === 252 ? '@bob' : '@alice')
+      expect(await hasKey(ui, `work-${n}`)).toBe(false)
+      expect(await hasKey(ui, `resume-${n}`)).toBe(false)
+    }
+    expect(await hasKey(ui, 'work-255')).toBe(false)
+    expect(await hasKey(ui, 'resume-255')).toBe(false)
+    expect(await hasKey(ui, 'holder-255')).toBe(false)
+    expect((await ui.find({ key: 'ticket-255' }))?.children[0].props).toMatchObject({ dimColor: true })
+
+    await ui.press({ key: 'work-251' })
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '251' }])
+  })
+
+  test(`the dashboard view puts a needs-you whiteboard ticket first in its own group [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.whiteboard = [...WHITEBOARD, issue(307, 'Loose needs you', [...WB, 'trailhead:task', 'trailhead:needs-you', 'trailhead:paused'])]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    expect(await textOf(ui, 'head-needs-you')).toBe('Needs you · 1')
+    // first ticket group, right after the maps group
+    expect((await keysOf(ui, 'group-')).slice(0, 2)).toEqual(['group-maps', 'group-needs-you'])
+    expect((await keysOf(ui, 'row-'))[0]).toBe('row-307')
+    expect(await hasKey(ui, 'head-paused')).toBe(false)
+    expect(await hasKey(ui, 'work-307')).toBe(true)
+    expect(await hasKey(ui, 'resume-307')).toBe(false)
   })
 
   test(`ticket rows are spaced apart on the desktop only [${surface}]`, async ($, on) => {
@@ -736,7 +1020,7 @@ for (const surface of SURFACES) {
     await completeTurn($)
     await settle(r)
     // the open maps are still read, so one can be picked; no map is
-    expect(r.calls).toEqual([MAPS_CALL])
+    expect(r.calls).toEqual([MAPS_CALL, countCall(14, 198)])
   })
 
   test(`first fetch in flight: the map number and Loading tickets [${surface}]`, async ($, on) => {
@@ -842,9 +1126,9 @@ for (const surface of SURFACES) {
     await openAndMount($, r)
     expect(fetches(r)).toBe(1)
 
+    // two turn ends with no write between: no flush, the trailing refresh is the only extra read
     await r.clock.advance(2_000)
     await completeTurn($)
-    await $.tool.call({ tool: 'Bash', command: 'gh issue close 5' } as never)
     await completeTurn($)
     await settle(r)
     expect(fetches(r)).toBe(1)
@@ -861,6 +1145,275 @@ for (const surface of SURFACES) {
     expect(fetches(r)).toBe(2)
   })
 
+  // A write followed by a turn end flushes: the turn end reads at once, inside the floor. The armed trailing
+  // refresh is kept, so the read after the search index caught up still follows, one floor after the flush.
+  test(`a write then a turn end inside the floor reads at once and keeps the trailing [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    await openAndMount($, r)
+    expect(fetches(r)).toBe(1)
+
+    await r.clock.advance(2_000)
+    await completeTurn($)
+    await $.tool.call({ tool: 'Bash', command: 'gh issue close 5' } as never)
+    await completeTurn($)
+    await settle(r)
+    expect(fetches(r)).toBe(2)
+    // a second turn end with no write since the flush adds nothing
+    await completeTurn($)
+    await settle(r)
+    expect(fetches(r)).toBe(2)
+
+    // the trailing one fires at the first floor's end, lands inside the flush's floor and waits for its end
+    await r.clock.advance(FLOOR - 2_000)
+    await settle(r)
+    expect(fetches(r)).toBe(2)
+    await r.clock.advance(2_000)
+    await settle(r)
+    expect(fetches(r)).toBe(3)
+    await r.clock.advance(FLOOR * 2)
+    await settle(r)
+    expect(fetches(r)).toBe(3)
+  })
+
+  // The host drops a refused timer silently (a closed ticket stayed on the pane for good): the pane must not
+  // wait on a dead handle.
+  test(`a slow timer the host dropped is started again by the next trigger [${surface}]`, async ($, on) => {
+    // Above the mock clock, which answers the wait without passing it on.
+    let isDropping = false
+    on('clock.every', { ms: TIMER }, async ($$, e, next) => (isDropping ? { deny: 'dropped' } : next(e)))
+    const r = rig(on, $)
+    await $.session.start(START)
+    // the first period is refused: the interval ends unseen
+    isDropping = true
+    await openAndMount($, r)
+    expect(fetches(r)).toBe(1)
+    await r.clock.advance(TIMER)
+    await settle(r)
+    isDropping = false
+    await r.clock.advance(TIMER)
+    await settle(r)
+    expect(fetches(r)).toBe(1)
+
+    // one trigger brings the timer back
+    await completeTurn($)
+    await settle(r)
+    expect(fetches(r)).toBe(2)
+    await r.clock.advance(TIMER)
+    await settle(r)
+    expect(fetches(r)).toBe(3)
+  })
+
+  // The trailing refresh is dropped like the slow timer (a closed ticket stayed on the pane as held): the turn
+  // end after a write reads at once, floor or not, so the final tracker state shows with no timer involved.
+  test(`a turn end after a write shows the close although the trailing refresh was dropped [${surface}]`, async ($, on) => {
+    on('clock.after', { ms: FLOOR }, async () => ({ deny: 'dropped' }))
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await r.clock.advance(FLOOR)
+    // the resolution comment reads at once, before the close
+    await $.tool.call({ tool: 'Bash', command: 'gh issue comment 209 -b done' } as never)
+    await settle(r)
+    r.tickets = TICKETS.filter(t => t.number !== 209)
+    await r.clock.advance(2_000)
+    await $.tool.call({ tool: 'Bash', command: 'gh issue close 209' } as never)
+    await completeTurn($)
+    await settle(r)
+    expect(await hasKey(ui, 'row-209')).toBe(false)
+  })
+
+  // Without a turn end, a pane drawn again past the dead trailing's due time and grace reads at once.
+  test(`a pane drawn again after a dropped trailing refresh reads at once [${surface}]`, async ($, on) => {
+    let isDropping = false
+    on('clock.after', { ms: FLOOR }, async ($$, e, next) => (isDropping ? { deny: 'dropped' } : next(e)))
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await r.clock.advance(FLOOR)
+    isDropping = true
+    await $.tool.call({ tool: 'Bash', command: 'gh issue comment 209 -b done' } as never)
+    await settle(r)
+    r.tickets = TICKETS.filter(t => t.number !== 209)
+    await r.clock.advance(2_000)
+    await $.tool.call({ tool: 'Bash', command: 'gh issue close 209' } as never)
+    await settle(r)
+    isDropping = false
+    // nothing fired for the close: the pane still shows the closed ticket
+    await r.clock.advance(FLOOR * 4)
+    await settle(r)
+    expect(await hasKey(ui, 'row-209')).toBe(true)
+    await ui.unmount()
+    const again = await mountPane($)
+    await settle(r)
+    expect(await hasKey(again, 'row-209')).toBe(false)
+  })
+
+  // The open list is a GraphQL read, never the search-backed `gh issue list --label`, which lags a write.
+  const listReads = (r: Rig) => r.calls.filter(argv => argv[2] === 'list' && argv.includes('--label') && argv.includes('trailhead:map-198') && argv.includes('open') && !argv.includes('trailhead:uat'))
+
+  test(`a gh issue create shows the new ticket's row without a manual refresh [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await hasKey(ui, 'row-240')).toBe(false)
+
+    r.tickets = [...TICKETS, issue(240, 'Just created', ['trailhead:build'])]
+    await r.clock.advance(FLOOR)
+    await $.tool.call({ tool: 'Bash', command: 'gh issue create -t t' } as never)
+    await settle(r)
+    expect(await hasKey(ui, 'row-240')).toBe(true)
+    expect(listReads(r)).toEqual([])
+  })
+
+  test(`a gh issue close drops the closed ticket's row without a manual refresh [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await hasKey(ui, 'row-209')).toBe(true)
+
+    r.tickets = TICKETS.filter(t => t.number !== 209)
+    await r.clock.advance(FLOOR)
+    await $.tool.call({ tool: 'Bash', command: 'gh issue close 209' } as never)
+    await settle(r)
+    expect(await hasKey(ui, 'row-209')).toBe(false)
+    expect(listReads(r)).toEqual([])
+  })
+
+  // The reads asked while the pane was undrawn (the person on another session) are dropped: drawn again with a
+  // list older than one slow-timer period, the pane reads at once instead of showing a closed ticket.
+  test(`a pane drawn again with an overdue list reads at once [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const first = await openAndMount($, r)
+    expect(fetches(r)).toBe(1)
+
+    await first.unmount()
+    r.panes = r.panes.map(p => ({ ...p, isPlaced: false }))
+    r.tickets = TICKETS.filter(t => t.number !== 209)
+    await r.clock.advance(FLOOR)
+    await $.tool.call({ tool: 'Bash', command: 'gh issue close 209' } as never)
+    await completeTurn($)
+    await r.clock.advance(TIMER + 30_001)
+    await settle(r)
+    expect(fetches(r)).toBe(1)
+
+    r.panes = r.panes.map(p => ({ ...p, isPlaced: true }))
+    const ui = await mountPane($)
+    await settle(r)
+    expect(fetches(r)).toBe(2)
+    expect(await hasKey(ui, 'row-209')).toBe(false)
+  })
+
+  test(`a create inside the floor shows at the floor's end [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await r.clock.advance(2_000)
+    r.tickets = [...TICKETS, issue(240, 'Just created', ['trailhead:build'])]
+    await $.tool.call({ tool: 'Bash', command: 'gh issue create -t t' } as never)
+    await settle(r)
+    expect(await hasKey(ui, 'row-240')).toBe(false)
+    await r.clock.advance(FLOOR - 2_000)
+    await settle(r)
+    expect(await hasKey(ui, 'row-240')).toBe(true)
+  })
+
+  test(`a close inside the floor drops the row at the floor's end [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await r.clock.advance(2_000)
+    r.tickets = TICKETS.filter(t => t.number !== 209)
+    await $.tool.call({ tool: 'Bash', command: 'gh issue close 209' } as never)
+    await settle(r)
+    expect(await hasKey(ui, 'row-209')).toBe(true)
+    await r.clock.advance(FLOOR - 2_000)
+    await settle(r)
+    expect(await hasKey(ui, 'row-209')).toBe(false)
+  })
+
+  test(`a list of 150 tickets is read in two pages [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.tickets = Array.from({ length: 150 }, (_, i) => issue(i + 1, `t${i + 1}`, ['trailhead:build']))
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(r.calls.filter(isTicketsRead)).toEqual([ticketsCall('trailhead:map-198'), ticketsCall('trailhead:map-198', 'c100')])
+    expect(await textOf(ui, 'head-frontier')).toBe('Frontier · 150')
+    expect(await hasKey(ui, 'capped')).toBe(false)
+    expect(listReads(r)).toEqual([])
+  })
+
+  test(`a failure on the second page discards the read and falls back to gh issue list once [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.tickets = Array.from({ length: 150 }, (_, i) => issue(i + 1, `t${i + 1}`, ['trailhead:build']))
+    r.gh = argv => (isTicketsRead(argv) && argv.some(a => a.startsWith('after=')) ? { exitCode: 1, stdout: '', stderr: 'boom' } : r.defaultGh(argv))
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(listReads(r)).toEqual([ticketsListCall('trailhead:map-198')])
+    // the fallback list is whole (the rig's list answer), never the 100 rows of page one
+    expect(await textOf(ui, 'head-frontier')).toBe('Frontier · 150')
+    expect(r.calls.filter(isTicketsRead)).toHaveLength(2)
+  })
+
+  test(`an unreadable first page falls back the same way [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.gh = argv => (isTicketsRead(argv) ? ok('not json') : argv[2] === 'list' && argv.includes('trailhead:map-198') && argv.includes('open') ? ok(JSON.stringify([issue(300, 'from the list', ['trailhead:build'])])) : r.defaultGh(argv))
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await keysOf(ui, 'row-')).toEqual(['row-300'])
+  })
+
+  test(`the whiteboard read keeps only the rows that are also tickets [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.whiteboard = [...WHITEBOARD, issue(310, 'Whiteboard label only', ['trailhead:whiteboard', 'trailhead:task'])]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-303'])
+  })
+
+  test(`a write that reads at once is followed by one more read at the floor's end [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    await openAndMount($, r)
+    await r.clock.advance(FLOOR)
+    const before = fetches(r)
+    await $.tool.call({ tool: 'Bash', command: 'gh issue close 5' } as never)
+    await settle(r)
+    expect(fetches(r)).toBe(before + 1)
+    await r.clock.advance(FLOOR - 1)
+    await settle(r)
+    expect(fetches(r)).toBe(before + 1)
+    await r.clock.advance(1)
+    await settle(r)
+    expect(fetches(r)).toBe(before + 2)
+    // the follow-up is spent
+    await r.clock.advance(FLOOR)
+    await settle(r)
+    expect(fetches(r)).toBe(before + 2)
+  })
+
+  test(`a burst of writes costs one read per floor plus one trailing [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    await openAndMount($, r)
+    await r.clock.advance(FLOOR)
+    const before = fetches(r)
+    for (const command of ['gh issue close 5', 'gh issue create -t a', 'gh issue comment 5 -b x', 'gh issue edit 5 --add-label y', 'gh issue close 6']) {
+      await $.tool.call({ tool: 'Bash', command } as never)
+      await r.clock.advance(1_000)
+    }
+    await settle(r)
+    expect(fetches(r)).toBe(before + 1)
+    await r.clock.advance(FLOOR)
+    await settle(r)
+    expect(fetches(r)).toBe(before + 2)
+    await r.clock.advance(FLOOR)
+    await settle(r)
+    expect(fetches(r)).toBe(before + 2)
+  })
+
   test(`session start, turn complete and the slow timer refresh an open pane [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     await $.session.start(START)
@@ -887,15 +1440,21 @@ for (const surface of SURFACES) {
     await $.session.start(START)
     await openAndMount($, r)
     const base = fetches(r)
-    for (const command of ['gh issue list --state open', 'ls -la', 'gh pr close 4', 'gh issue view 5']) {
+    for (const command of ['gh issue list --state open', 'ls -la', 'gh pr close 4', 'gh issue view 5', 'gh api repos/o/r/issues/5', 'gh api graphql -f query=x']) {
       await r.clock.advance(FLOOR)
       await $.tool.call({ tool: 'Bash', command } as never)
       await settle(r)
     }
     expect(fetches(r)).toBe(base)
 
-    for (const command of ['gh issue close 5', 'gh --repo o/r issue close 5', 'gh issue comment 5 -b hi', 'gh issue edit 5 --add-label x', 'gh issue create -t t', 'gh issue reopen 5']) {
-      await r.clock.advance(FLOOR)
+    for (const command of ['gh issue close 5', 'gh --repo o/r issue close 5', 'gh issue comment 5 -b hi', 'gh issue edit 5 --add-label x', 'gh issue create -t t', 'gh issue reopen 5', 'gh issue delete 5', 'gh api repos/o/r/issues/198/sub_issues -F sub_issue_id=1', 'node /t/trailhead-issue-body.js append --issue 198 --section x --line y']) {
+      // until a whole floor passes with no read (the previous write's follow-up, the slow timer), so this write starts outside one
+      let seen = -1
+      while (seen !== fetches(r)) {
+        seen = fetches(r)
+        await r.clock.advance(FLOOR)
+        await settle(r)
+      }
       const before = fetches(r)
       await $.tool.call({ tool: 'Bash', command } as never)
       await settle(r)
@@ -975,8 +1534,8 @@ for (const surface of SURFACES) {
     const first = ui.press({ key: 'work-209' })
     await settle(r)
     expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '209' }])
-    expect(await textOf(ui, 'queued-209')).toBe('queued')
-    expect((await ui.find({ key: 'queued-209' }))?.children[0]).toMatchObject({ props: { color: AMBER } })
+    expect(await textOf(ui, 'starting-209')).toBe('starting')
+    expect((await ui.find({ key: 'starting-209' }))?.children[0]).toMatchObject({ props: { color: AMBER } })
     expect(await ui.find({ key: 'work-209' })).toBeUndefined()
     expect(await ui.find({ key: 'work-210' })).toBeDefined()
 
@@ -984,12 +1543,12 @@ for (const surface of SURFACES) {
     await ui.press({ key: 'work-210' })
     await settle(r)
     expect(r.runs).toHaveLength(2)
-    expect(await ui.find({ key: 'queued-210' })).toBeUndefined()
+    expect(await ui.find({ key: 'starting-210' })).toBeUndefined()
 
     release()
     await first
     await settle(r)
-    expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'starting-209' })).toBeUndefined()
     expect(await ui.find({ key: 'work-209' })).toBeDefined()
 
     // free again: the next press goes through
@@ -1003,6 +1562,42 @@ for (const surface of SURFACES) {
     ])
   })
 
+  test(`a resume button on a paused row runs /trailhead:resume, shares the one-at-a-time guard and the refusal [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    let release: () => void = () => undefined
+    r.gate = new Promise<void>(resolve => (release = resolve))
+    r.tickets = [...TICKETS, issue(230, 'Paused one', ['trailhead:build', 'trailhead:paused'], ['alice'])]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect((await ui.find({ key: 'resume-230' }))?.props).toMatchObject({ label: 'resume', variant: 'primary' })
+
+    const first = ui.press({ key: 'resume-230' })
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:resume', args: '230' }])
+    expect(await textOf(ui, 'starting-230')).toBe('starting')
+    expect(await ui.find({ key: 'resume-230' })).toBeUndefined()
+
+    // a work press meanwhile is ignored: one in flight at a time
+    await ui.press({ key: 'work-210' })
+    await settle(r)
+    expect(r.runs).toHaveLength(2)
+
+    release()
+    await first
+    await settle(r)
+    expect(await ui.find({ key: 'starting-230' })).toBeUndefined()
+    expect(await ui.find({ key: 'resume-230' })).toBeDefined()
+
+    // outside the pinned repo it goes through, handing the pinned checkout to the verb
+    const runs = r.runs.length
+    r.cwd = ROOT_OTHER
+    r.repo = { root: ROOT_OTHER, remote: 'https://github.com/o/other.git', internal: false }
+    await ui.press({ key: 'resume-230' })
+    await settle(r)
+    expect(r.runs.slice(runs)).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:resume', args: `230 ${IN(ROOT)}` }])
+    expect(r.toasts).toEqual([])
+  })
+
   test(`a work command that is refused clears the queued mark [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     r.refuse = 'cannot run now'
@@ -1015,19 +1610,121 @@ for (const surface of SURFACES) {
     expect(await ui.find({ key: 'work-209' })).toBeDefined()
   })
 
-  test(`a work press clears the conversation first, the row staying queued across the reset [${surface}]`, async ($, on) => {
+  test(`a work press with the session outside any repo goes through with the pinned checkout handed over [${surface}]`, async ($, on) => {
     const r = rig(on, $)
-    let releaseClear: () => void = () => undefined
-    let releaseWork: () => void = () => undefined
-    r.clearGate = new Promise<void>(resolve => (releaseClear = resolve))
-    r.gate = new Promise<void>(resolve => (releaseWork = resolve))
     await $.session.start(START)
     const ui = await openAndMount($, r)
-
-    const first = ui.press({ key: 'work-209' })
+    r.cwd = '/tmp'
+    r.repo = null
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(r.toasts).toEqual([])
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: `209 ${IN(ROOT)}` }])
+    // The token the verb receives decodes (plain base64url, the helper's alphabet) to the pinned root; the suite has no Buffer.
+    const [number, word] = r.runs[1].args.split(' ')
+    expect(number).toBe('209')
+    expect(word).toMatch(/^--in=[A-Za-z0-9_-]+$/)
+    expect(word).toBe(IN(ROOT))
+    expect(atob(word.slice('--in='.length).replace(/-/g, '+').replace(/_/g, '/'))).toBe(ROOT)
+    expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+  })
+
+  test(`a work press with the session in another repo goes through with the pinned checkout handed over [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    r.cwd = ROOT_OTHER
+    r.repo = { root: ROOT_OTHER, remote: 'https://github.com/o/other.git', internal: false }
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(r.toasts).toEqual([])
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: `209 ${IN(ROOT)}` }])
+  })
+
+  test(`a pinned worktree checkout is handed over by its own root [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.top = ROOT_TREE
+    r.cwd = ROOT_TREE
+    r.sessionRoot = ROOT_TREE
+    r.active = '14\n'
+    r.treeActive = '198\n'
+    await $.session.start({ ...START, cwd: ROOT_TREE })
+    const ui = await openAndMount($, r)
+    // From inside it nothing is handed over.
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '209' }])
+    // A shell cd out of it: the token names the worktree root, not the main tree's.
+    r.cwd = ROOT_OTHER
+    r.repo = { root: ROOT_OTHER, remote: 'https://github.com/o/other.git', internal: false }
+    r.runs.length = 0
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: `209 ${IN(ROOT_TREE)}` }])
+  })
+
+  test(`a work press whose pinned checkout is gone while the session is out is refused before the clear [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    r.gone = [ROOT]
+    r.cwd = '/tmp'
+    r.repo = null
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(r.runs).toEqual([])
+    expect(r.toasts).toHaveLength(1)
+    expect(r.toasts[0]).toContain('#209')
+    expect(r.toasts[0]).toContain('unreadable')
+    expect(r.toasts[0].length).toBeLessThanOrEqual(40)
+    expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+  })
+
+  test(`a work press in the pinned repo goes through although session.repo answers null [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    r.repo = null
+    r.gitRemote = 'git@github.com:o/r.git'
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(r.toasts).toEqual([])
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '209' }])
+  })
+
+  test(`a work press whose checkout cannot be read is refused, and the next one from the repo goes through [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    r.repoFails = true
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(r.runs).toEqual([])
+    expect(r.toasts).toHaveLength(1)
+    expect(r.toasts[0]).toContain('unreadable')
+    expect(r.toasts[0]).not.toContain('cd into')
+    expect(r.toasts[0].length).toBeLessThanOrEqual(40)
+    r.repoFails = false
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '209' }])
+  })
+
+  test(`a work press clears the conversation first, the row staying starting across the reset [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    let releaseClear: () => void = () => undefined
+    let releaseWork: () => void = () => undefined
+    r.clearGate = new Promise<void>(resolve => (releaseClear = resolve))
+    r.gate = new Promise<void>(resolve => (releaseWork = resolve))
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+
+    const first = ui.press({ key: 'work-209' })
     await settle(r)
     expect(r.runs).toEqual([{ command: 'clear', args: '' }])
-    expect(await textOf(ui, 'queued-209')).toBe('queued')
+    expect(await textOf(ui, 'starting-209')).toBe('starting')
 
     // a second press while the clear is pending is ignored
     await ui.press({ key: 'work-210' })
@@ -1040,17 +1737,463 @@ for (const surface of SURFACES) {
     expect(r.session).toBe(`${NEXT_SESSION}-1`)
     expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '209' }])
     await ui.redraw()
-    expect(await textOf(ui, 'queued-209')).toBe('queued')
+    expect(await textOf(ui, 'starting-209')).toBe('starting')
     await ui.press({ key: 'work-210' })
     expect(r.runs).toHaveLength(2)
 
     releaseWork()
     await first
     await settle(r)
+    expect(await ui.find({ key: 'starting-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+  })
+
+  // The main loop's turn, as the host raises it: a press during it is held by the panel until it ends.
+  const startMainTurn = ($: any, id = 'held-turn') => $.turn.start({ text: 'go', turnId: id })
+  const abortTurn = ($: any) =>
+    $.turn.complete({ turnId: `t${(turns += 1)}`, answer: '', durationMs: 1, isAborted: true, reason: 'aborted' })
+
+  test(`a press during a running turn is held with a cancel button and runs when the turn ends [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await ui.find({ key: 'cancel-209' })).toBeUndefined()
+
+    await startMainTurn($)
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    // Nothing reaches the host while the turn runs.
+    expect(r.runs).toEqual([])
+    expect(await textOf(ui, 'queued-209')).toBe('queued')
+    expect((await ui.find({ key: 'queued-209' }))?.children[0]).toMatchObject({ props: { color: AMBER } })
+    expect((await ui.find({ key: 'cancel-209' }))?.props).toMatchObject({ label: 'cancel' })
+    expect(await ui.find({ key: 'starting-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeUndefined()
+
+    // A second press while one is held is ignored.
+    await ui.press({ key: 'work-210' })
+    await settle(r)
+    expect(r.runs).toEqual([])
+    expect(await ui.find({ key: 'queued-210' })).toBeUndefined()
+
+    await completeTurn($)
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '209' }])
+    expect(r.session).toBe(`${NEXT_SESSION}-1`)
     expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
     expect(await ui.find({ key: 'work-209' })).toBeDefined()
   })
 
+  test(`a press held in the repo while the session cd's out is sent with the pinned checkout handed over [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await startMainTurn($)
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(await textOf(ui, 'queued-209')).toBe('queued')
+    // The turn moves the session out of any repo (a GitHub repo would move the pin along with it).
+    r.cwd = '/tmp'
+    r.repo = null
+    await completeTurn($)
+    await settle(r)
+    expect(r.toasts).toEqual([])
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: `209 ${IN(ROOT)}` }])
+  })
+
+  test(`a held press whose checkout cannot be read at release is refused before the clear [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await startMainTurn($)
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(await textOf(ui, 'queued-209')).toBe('queued')
+    r.repoFails = true
+    await completeTurn($)
+    await settle(r)
+    expect(r.runs).toEqual([])
+    expect(r.toasts).toHaveLength(1)
+    expect(r.toasts[0]).toContain('unreadable')
+    expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+  })
+
+  test(`a cancel before the turn ends sends nothing, keeps the conversation and puts the work button back [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await startMainTurn($)
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(await ui.find({ key: 'cancel-209' })).toBeDefined()
+
+    await ui.press({ key: 'cancel-209' })
+    await settle(r)
+    expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'cancel-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+
+    await completeTurn($)
+    await settle(r)
+    expect(r.runs).toEqual([])
+    expect(r.session).toBe(SESSION)
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+
+    // The slot is free again: another row can be pressed and is held.
+    await startMainTurn($, 'second')
+    await ui.press({ key: 'work-210' })
+    await settle(r)
+    expect(await textOf(ui, 'queued-210')).toBe('queued')
+    expect(r.runs).toEqual([])
+    await completeTurn($)
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '210' }])
+  })
+
+  test(`a cancel of a held resume press sends nothing [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.tickets = [...TICKETS, issue(230, 'Paused one', ['trailhead:build', 'trailhead:paused'], ['alice'])]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await startMainTurn($)
+    await ui.press({ key: 'resume-230' })
+    await settle(r)
+    expect(await textOf(ui, 'queued-230')).toBe('queued')
+    await ui.press({ key: 'cancel-230' })
+    await completeTurn($)
+    await settle(r)
+    expect(r.runs).toEqual([])
+    expect(await ui.find({ key: 'resume-230' })).toBeDefined()
+  })
+
+  test(`a press with no turn running starts at once and reads starting, with no cancel button [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    let release: () => void = () => undefined
+    r.gate = new Promise<void>(resolve => (release = resolve))
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    const first = ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '209' }])
+    expect(await textOf(ui, 'starting-209')).toBe('starting')
+    expect((await ui.find({ key: 'starting-209' }))?.children[0]).toMatchObject({ props: { color: AMBER } })
+    expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'cancel-209' })).toBeUndefined()
+    release()
+    await first
+    await settle(r)
+    expect(await ui.find({ key: 'starting-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+  })
+
+  test(`an interrupted turn releases a held press too [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await startMainTurn($)
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(r.runs).toEqual([])
+    await abortTurn($)
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '209' }])
+  })
+
+  test(`a subagent's turn does not hold a press, nor does its end release one [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await $.turn.start({ text: 'sub', turnId: 'sub-1', agentId: 'agent-1' })
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '209' }])
+
+    await startMainTurn($, 'main-1')
+    await ui.press({ key: 'work-210' })
+    await settle(r)
+    expect(r.runs).toHaveLength(2)
+    await $.turn.complete({ turnId: 'sub-1', answer: '', durationMs: 1, isAborted: false, reason: 'answer', agentId: 'agent-1' })
+    await settle(r)
+    expect(r.runs).toHaveLength(2)
+    expect(await textOf(ui, 'queued-210')).toBe('queued')
+    await completeTurn($)
+    await settle(r)
+    expect(r.runs).toHaveLength(4)
+  })
+
+  test(`a turn that starts while the dispatch is still reading re-holds the press, cancel offered again [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await startMainTurn($)
+    await ui.press({ key: 'work-209' })
+    await completeTurn($)
+    // The next session id read is the dispatch's own, before its clear.
+    r.beforeSessionId = async () => void (await startMainTurn($, 'late'))
+    await settle(r)
+    expect(r.runs).toEqual([])
+    await ui.redraw()
+    expect(await textOf(ui, 'queued-209')).toBe('queued')
+    expect(await ui.find({ key: 'cancel-209' })).toBeDefined()
+    expect(await ui.find({ key: 'starting-209' })).toBeUndefined()
+
+    await completeTurn($)
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '209' }])
+    expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+  })
+
+  test(`a turn that starts between the end of one and the release keeps the press held until it ends [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await startMainTurn($)
+    await ui.press({ key: 'work-209' })
+    await completeTurn($)
+    // The release timer has not run yet: a queued prompt of the person's starts a turn.
+    await startMainTurn($, 'next')
+    await settle(r)
+    expect(r.runs).toEqual([])
+    expect(await textOf(ui, 'queued-209')).toBe('queued')
+    expect(await ui.find({ key: 'cancel-209' })).toBeDefined()
+
+    await completeTurn($)
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '209' }])
+  })
+
+  for (const reason of ['prompt_input_exit', 'logout', 'other'] as const) {
+    test(`a session that ends (${reason}) while a press is held drops it and resets the turn flag [${surface}]`, async ($, on) => {
+      const r = rig(on, $)
+      await $.session.start(START)
+      const ui = await openAndMount($, r)
+      await startMainTurn($)
+      await ui.press({ key: 'work-209' })
+      await settle(r)
+      expect(await textOf(ui, 'queued-209')).toBe('queued')
+
+      await $.session.end({ reason, sessionId: r.session, resume: {} })
+      await settle(r)
+      expect(r.runs).toEqual([])
+      await ui.redraw()
+      expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+      expect(await ui.find({ key: 'work-209' })).toBeDefined()
+
+      // No turn is running in the next session: a press goes straight through.
+      await ui.press({ key: 'work-210' })
+      await settle(r)
+      expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '210' }])
+    })
+  }
+
+  test(`a cancel pressed between the release and the clear sends nothing and puts the work button back [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await startMainTurn($)
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    await completeTurn($)
+    // The row on screen still reads queued with its cancel button when the press lands, before the clear.
+    let isPressed = false
+    r.beforePhaseWrite = async () => {
+      try {
+        await ui.press({ key: 'cancel-209' })
+        isPressed = true
+      } catch (err) {
+        r.logs.push(`seam press failed: ${String(err)}`)
+      }
+    }
+    await settle(r)
+    expect(r.logs.filter(l => l.startsWith('seam'))).toEqual([])
+    expect(isPressed).toBe(true)
+    expect(r.runs).toEqual([])
+    expect(r.session).toBe(SESSION)
+    await ui.redraw()
+    expect(await ui.find({ key: 'starting-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+    // The slot is free again.
+    await ui.press({ key: 'work-210' })
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '210' }])
+  })
+
+  // A cancel from a screen a frame behind: the row is drawn queued (the engine reports that phase) for the press.
+  const staleCancel = (ui: any, r: Rig, number: number) => async () => {
+    r.forced = { pendingPhase: 'queued' }
+    await ui.redraw()
+    await ui.press({ key: `cancel-${number}` })
+  }
+
+  test(`a cancel landing while a re-hold writes queued drops the press instead of holding it [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await startMainTurn($)
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    await completeTurn($)
+    // A turn starts during the dispatch's reads: it re-holds, and the cancel lands on that queued write.
+    r.beforeSessionId = async () => {
+      await startMainTurn($, 'late')
+      r.beforePhaseWrite = staleCancel(ui, r, 209)
+    }
+    await settle(r)
+    await completeTurn($)
+    await settle(r)
+    expect(r.runs).toEqual([])
+    expect(r.session).toBe(SESSION)
+    await ui.redraw()
+    expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'starting-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+  })
+
+  test(`a cancel landing between the queued write and the hold drops the press [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await startMainTurn($)
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    await ui.press({ key: 'cancel-209' })
+    await settle(r)
+
+    r.beforePhaseWrite = staleCancel(ui, r, 209)
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    await completeTurn($)
+    await settle(r)
+    expect(r.runs).toEqual([])
+    await ui.redraw()
+    expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+  })
+
+  test(`a press made right after a cancel keeps its queued mark and claim and runs when the turn ends [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await startMainTurn($)
+    await ui.press({ key: 'work-209' })
+    await settle(r)
+    // No settling in between: the cancel's own redraw must not let a stale-claim sweep erase the next press.
+    await ui.press({ key: 'cancel-209' })
+    await ui.press({ key: 'work-210' })
+    await settle(r)
+    await ui.redraw()
+    await settle(r)
+    expect(r.runs).toEqual([])
+    expect(await textOf(ui, 'queued-210')).toBe('queued')
+    expect(await ui.find({ key: 'cancel-210' })).toBeDefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+
+    await completeTurn($)
+    await settle(r)
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '210' }])
+  })
+
+  for (const phase of [null, 'starting'] as const) {
+    test(`a pending claim with phase ${phase} and no press behind it is cleared when the pane draws [${surface}]`, async ($, on) => {
+      const r = rig(on, $)
+      await $.session.start(START)
+      const ui = await openAndMount($, r)
+      // What a hot reload leaves: the atoms say pending, the module state is empty.
+      r.forced = { pendingWork: 209, pendingPhase: phase }
+      await ui.redraw()
+      await settle(r)
+      await ui.redraw()
+      expect(await ui.find({ key: 'starting-209' })).toBeUndefined()
+      expect(await ui.find({ key: 'work-209' })).toBeDefined()
+      await ui.press({ key: 'work-210' })
+      await settle(r)
+      expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '210' }])
+    })
+  }
+
+  test(`a press with no turn running never shows queued or a cancel button [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    let release: () => void = () => undefined
+    r.clearGate = new Promise<void>(resolve => (release = resolve))
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    const first = ui.press({ key: 'work-209' })
+    await settle(r)
+    // The phase went straight to starting: queued was never written, so no cancel was ever offered.
+    expect(r.phases[0]).toBe('starting')
+    expect(r.phases).not.toContain('queued')
+    expect(await ui.find({ key: 'cancel-209' })).toBeUndefined()
+    release()
+    await first
+    await settle(r)
+  })
+
+  for (const reason of ['clear', 'resume'] as const) {
+    test(`a session that ends (${reason}) while a press is held drops it [${surface}]`, async ($, on) => {
+      const r = rig(on, $)
+      await $.session.start(START)
+      const ui = await openAndMount($, r)
+      await startMainTurn($)
+      await ui.press({ key: 'work-209' })
+      await settle(r)
+      expect(await textOf(ui, 'queued-209')).toBe('queued')
+
+      await $.session.end({ reason, sessionId: r.session, resume: {} })
+      await settle(r)
+      expect(r.runs).toEqual([])
+      await ui.redraw()
+      expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+      expect(await ui.find({ key: 'work-209' })).toBeDefined()
+      // The turn flag was reset too: a press goes straight through.
+      await ui.press({ key: 'work-210' })
+      await settle(r)
+      expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '210' }])
+    })
+  }
+
+  test(`a cancel on a stuck queued row (nothing held, nothing sending) clears it [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    // What a hot reload leaves: the atoms say queued, the module state is empty.
+    r.forced = { pendingWork: 209, pendingPhase: 'queued' }
+    await ui.redraw()
+    expect(await ui.find({ key: 'cancel-209' })).toBeDefined()
+    await ui.press({ key: 'cancel-209' })
+    await settle(r)
+    await ui.redraw()
+    expect(r.runs).toEqual([])
+    expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+  })
+
+  test(`the mod's own clear leaves the row starting across the reset until the verb settles [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    let release: () => void = () => undefined
+    r.gate = new Promise<void>(resolve => (release = resolve))
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    let during: string | undefined
+    r.duringClear = async () => {
+      await ui.redraw()
+      during = await textOf(ui, 'starting-209')
+    }
+    const first = ui.press({ key: 'work-209' })
+    await settle(r)
+    expect(during).toBe('starting')
+    await ui.redraw()
+    expect(await textOf(ui, 'starting-209')).toBe('starting')
+    expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '209' }])
+    release()
+    await first
+    await settle(r)
+    expect(await ui.find({ key: 'starting-209' })).toBeUndefined()
+    expect(await ui.find({ key: 'work-209' })).toBeDefined()
+  })
+
   test(`a clear that is refused runs no work command and clears the queued mark [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     r.refuseClear = 'cannot clear now'
@@ -1235,6 +2378,27 @@ for (const surface of SURFACES) {
     expect((await panel($)).text).toBe('Map panel closed.')
   })
 
+  test(`/trailhead:panel shows a pane the auto-open left undrawn instead of closing it [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    // sessione vuota, terminale sotto la soglia dei pannelli non richiesti: l'auto-open resta non disegnato
+    r.isPlaced = false
+    await $.session.start(START)
+    await mountBand($, FULLSCREEN)
+    await settle(r)
+    expect(r.panes.map(p => [p.id, p.isPlaced])).toEqual([[PANE, false]])
+
+    // la richiesta della persona lo disegna a qualsiasi larghezza
+    r.isPlaced = true
+    expect((await panel($)).text).toBe('Map panel opened.')
+    expect(r.panes.map(p => [p.id, p.isPlaced])).toEqual([[PANE, true]])
+    await settle(r)
+    expect(fetches(r)).toBe(1)
+
+    // disegnato, il comando torna a chiuderlo
+    expect((await panel($)).text).toBe('Map panel closed.')
+    expect(r.panes).toEqual([])
+  })
+
   for (const withBand of [false, true]) {
     test(`the pane opens by itself once in fullscreen, the band ${withBand ? 'drawing' : 'yielding'} [${surface}]`, async ($, on) => {
       const r = rig(on, $)
@@ -1393,12 +2557,13 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'burndown-counts')).toBe('open 2 · done 0 · removed 0 · peak 2')
     // the ticket in play belongs to the other map: nothing here is marked
     expect(await hasKey(ui, 'mark-208')).toBe(false)
-    expect(r.calls.slice(-5).map(argv => argv.slice(0, 4))).toEqual([
+    expect(r.calls.slice(-6).map(argv => argv.slice(0, 4))).toEqual([
       ['gh', 'issue', 'view', '14'],
-      ['gh', 'issue', 'list', '--label'],
-      ['gh', 'issue', 'list', '--label'],
       ['gh', 'api', 'graphql', '-F'],
       ['gh', 'issue', 'list', '--label'],
+      ['gh', 'api', 'graphql', '-F'],
+      ['gh', 'api', 'graphql', '-F'],
+      ['gh', 'api', 'graphql', '-F'],
     ])
     expect(r.calls.some(argv => argv.includes('trailhead:map-14'))).toBe(true)
 
@@ -1601,10 +2766,11 @@ for (const surface of SURFACES) {
     await pressDashboard(ui, r)
 
     expect(r.calls.slice(before)).toEqual([
-      ['gh', 'issue', 'list', '--label', 'trailhead:ticket', '--label', 'trailhead:whiteboard', '--state', 'open', '--limit', '200', '--json', 'number,title,labels,assignees,url'],
+      ticketsCall('trailhead:whiteboard'),
       ['gh', 'issue', 'list', '--label', 'trailhead:dashboard', '--state', 'open', '--limit', '10', '--json', 'number,url'],
       MAPS_CALL,
-      uatCall('trailhead:whiteboard'),
+      uatCall(),
+      countCall(14, 198),
     ])
     expect(await textOf(ui, 'dashboard-title')).toBe('Dashboard')
     expect((await ui.find({ key: 'dashboard-title' }))?.children[0]).toMatchObject({ props: { bold: true, color: ACCENT } })
@@ -1789,25 +2955,185 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'map-aside-198')).toBe(' 7 open / 23 · active')
   })
 
-  test(`a failing counts read falls back to the name-only list with no footer error [${surface}]`, async ($, on) => {
+  test(`a failing counts read falls back to the name-only list with no footer error [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    const base = r.defaultGh
+    r.gh = argv => (isGraphql(argv) ? { exitCode: 1, stdout: '', stderr: 'boom' } : base(argv))
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(r.calls.filter(argv => argv.includes('trailhead:map') || isGraphql(argv))).toEqual([MAPS_CALL, MAPS_LIST_CALL])
+    expect(await textOf(ui, 'head-maps')).toBe('Maps · 2')
+    expect(await textOf(ui, 'map-aside-198')).toBe(' active')
+    expect(await hasKey(ui, 'map-aside-14')).toBe(false)
+    expect(await textOf(ui, 'age')).toBe('updated just now')
+
+    // a reply with errors is a failed read too
+    r.gh = argv => (isGraphql(argv) ? ok(JSON.stringify({ data: { repository: { issues: { nodes: [] } } }, errors: [{ message: 'x' }] })) : base(argv))
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await textOf(ui, 'head-maps')).toBe('Maps · 2')
+    expect(await hasKey(ui, 'map-aside-14')).toBe(false)
+  })
+
+  // The open-ticket total across every open map plus the whiteboard (5 + 2 + 3 with the default counts).
+  const TOTAL_TEXT = '10 open across all maps + whiteboard'
+  const totalLines = async (ui: any): Promise<number> => (await ui.findAll({ key: 'open-total' })).length
+  const refreshOnce = async ($: any, r: Rig) => {
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+  }
+
+  test(`the total line shows exactly once in the map view, under the Whiteboard row [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await totalLines(ui)).toBe(1)
+    expect(await textOf(ui, 'open-total')).toBe(TOTAL_TEXT)
+    expect((await ui.find({ key: 'open-total' }))?.children[0]).toMatchObject({ props: { dimColor: true } })
+    const keys = (await ui.findAll({ type: 'Box' })).map((el: any) => el.key)
+    expect(keys.indexOf('open-total')).toBeGreaterThan(keys.indexOf('whiteboard-row'))
+    expect(keys.indexOf('open-total')).toBeLessThan(keys.indexOf('group-frontier'))
+  })
+
+  test(`the total line shows exactly once in the loading state and the no-active-map view [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.active = null
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'empty')).toBe('No active map. Run /trailhead:map to pick one.')
+    await completeTurn($)
+    await settle(r)
+    expect(await totalLines(ui)).toBe(1)
+    expect(await textOf(ui, 'open-total')).toBe(TOTAL_TEXT)
+
+    // a map pressed while its read is held: Loading tickets, the last good total beside the Whiteboard row
+    const base = r.defaultGh
+    let release: () => void = () => undefined
+    const held = new Promise<void>(resolve => (release = resolve))
+    r.gh = async argv => {
+      if (argv[2] === 'view' || isTicketsRead(argv)) await held
+      return base(argv)
+    }
+    await ui.press({ key: 'map-14' })
+    await settle(r)
+    expect(await textOf(ui, 'loading')).toBe('Loading tickets…')
+    expect(await totalLines(ui)).toBe(1)
+    expect(await textOf(ui, 'open-total')).toBe(TOTAL_TEXT)
+    release()
+    await settle(r)
+  })
+
+  test(`the total line shows exactly once under the Dashboard header row [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    expect(await hasKey(ui, 'dashboard-title')).toBe(true)
+    expect(await totalLines(ui)).toBe(1)
+    expect(await textOf(ui, 'open-total')).toBe(TOTAL_TEXT)
+    const keys = (await ui.findAll({ type: 'Box' })).map((el: any) => el.key)
+    expect(keys.indexOf('open-total')).toBeGreaterThan(keys.indexOf('header-row'))
+    expect(keys.indexOf('open-total')).toBeLessThan(keys.indexOf('group-maps'))
+  })
+
+  test(`the total is counted over the open maps' numbers, one extra call per read [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.maps = [MAPS[0]]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(r.calls.filter(isCountRead)).toEqual([countCall(198)])
+    // 5 open on the map + 3 on the whiteboard
+    expect(await textOf(ui, 'open-total')).toBe('8 open across all maps + whiteboard')
+    // a closed map is never counted: only the open maps are enumerated
+    r.maps = MAPS
+    await refreshOnce($, r)
+    expect(r.calls.filter(isCountRead).at(-1)).toEqual(countCall(14, 198))
+    expect(await textOf(ui, 'open-total')).toBe(TOTAL_TEXT)
+  })
+
+  for (const mode of ['fail', 'errors', 'junk'] as const) {
+    test(`a count read that fails (${mode}) before any good read draws no total line [${surface}]`, async ($, on) => {
+      const r = rig(on, $)
+      r.countMode = mode
+      await $.session.start(START)
+      const ui = await openAndMount($, r)
+      expect(await totalLines(ui)).toBe(0)
+      // the rest of the pane is unharmed and no footer error is raised for it
+      expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+      expect(await textOf(ui, 'age')).toBe('updated just now')
+    })
+  }
+
+  test(`a later failing count read keeps the last good total while the open maps are the same [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'open-total')).toBe(TOTAL_TEXT)
+    r.countMode = 'fail'
+    r.openCounts = { ...r.openCounts, 'trailhead:whiteboard': 99 }
+    await refreshOnce($, r)
+    expect(await totalLines(ui)).toBe(1)
+    expect(await textOf(ui, 'open-total')).toBe(TOTAL_TEXT)
+    // a good read takes over again
+    r.countMode = 'ok'
+    await refreshOnce($, r)
+    expect(await textOf(ui, 'open-total')).toBe('106 open across all maps + whiteboard')
+  })
+
+  test(`a failing count read after the open maps changed hides the total, never stale [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'open-total')).toBe(TOTAL_TEXT)
+    r.countMode = 'fail'
+    r.maps = [MAPS[0]]
+    await refreshOnce($, r)
+    expect(await totalLines(ui)).toBe(0)
+  })
+
+  test(`the name-only maps fallback draws no total and makes no count call [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    const base = r.defaultGh
+    r.gh = argv => (isGraphql(argv) ? { exitCode: 1, stdout: '', stderr: 'boom' } : base(argv))
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(r.calls.filter(isCountRead)).toEqual([])
+    expect(await totalLines(ui)).toBe(0)
+    expect(await textOf(ui, 'head-maps')).toBe('Maps · 2')
+  })
+
+  test(`a fallback after a good total hides it rather than keep a figure over a list of unknown completeness [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    const base = r.defaultGh
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await totalLines(ui)).toBe(1)
+    r.gh = argv => (isGraphql(argv) ? { exitCode: 1, stdout: '', stderr: 'boom' } : base(argv))
+    await refreshOnce($, r)
+    expect(await totalLines(ui)).toBe(0)
+  })
+
+  test(`a narrow pane keeps the lower bound in the short form [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.countTotal = 101
+    await $.session.start(START)
+    const ui = await openAndMount($, r, { bodyColumns: 24 })
+    expect(await textOf(ui, 'open-total')).toBe('≥10 open in total')
+  })
+
+  test(`a truncated maps read words the total as a lower bound only [${surface}]`, async ($, on) => {
     const r = rig(on, $)
-    const base = r.defaultGh
-    r.gh = argv => (isGraphql(argv) ? { exitCode: 1, stdout: '', stderr: 'boom' } : base(argv))
+    // more open maps exist (101) than the two the read returned
+    r.countTotal = 101
     await $.session.start(START)
     const ui = await openAndMount($, r)
-    expect(r.calls.filter(argv => argv.includes('trailhead:map') || isGraphql(argv))).toEqual([MAPS_CALL, MAPS_LIST_CALL])
-    expect(await textOf(ui, 'head-maps')).toBe('Maps · 2')
-    expect(await textOf(ui, 'map-aside-198')).toBe(' active')
-    expect(await hasKey(ui, 'map-aside-14')).toBe(false)
-    expect(await textOf(ui, 'age')).toBe('updated just now')
-
-    // a reply with errors is a failed read too
-    r.gh = argv => (isGraphql(argv) ? ok(JSON.stringify({ data: { repository: { issues: { nodes: [] } } }, errors: [{ message: 'x' }] })) : base(argv))
-    await r.clock.advance(FLOOR)
-    await completeTurn($)
-    await settle(r)
-    expect(await textOf(ui, 'head-maps')).toBe('Maps · 2')
-    expect(await hasKey(ui, 'map-aside-14')).toBe(false)
+    expect(await textOf(ui, 'open-total')).toBe('at least 10 open across all maps + whiteboard')
+    // exactly as many maps as were read is not a cut
+    r.countTotal = null
+    await refreshOnce($, r)
+    expect(await textOf(ui, 'open-total')).toBe(TOTAL_TEXT)
   })
 
   test(`the dashboard heading counts the whiteboard and every assigned trusted ticket is a row [${surface}]`, async ($, on) => {
@@ -1823,7 +3149,7 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'head-whiteboard')).toBe('Whiteboard · 4 open · 2 assigned')
     expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-306', 'row-303'])
     expect(await textOf(ui, 'holder-302')).toBe('@alice')
-    expect(await textOf(ui, 'holder-306')).toBe('@erin')
+    expect(await hasKey(ui, 'resume-306')).toBe(true)
     expect(await hasKey(ui, 'row-305')).toBe(false)
     expect(await textOf(ui, 'unverified')).toBe('2 unverified tickets hidden (quarantined)')
   })
@@ -1886,7 +3212,7 @@ for (const surface of SURFACES) {
     expect((await ui.findAll({ type: 'Link' })).map((l: any) => l.props.href)).not.toContain(`${URL}/5`)
 
     r.whiteboard = WHITEBOARD
-    r.gh = argv => (argv.includes('trailhead:whiteboard') ? { exitCode: 1, stdout: '', stderr: 'boom' } : r.defaultGh(argv))
+    r.gh = argv => (argv.includes('trailhead:whiteboard') || argv.includes('label=trailhead:whiteboard') ? { exitCode: 1, stdout: '', stderr: 'boom' } : r.defaultGh(argv))
     await r.clock.advance(FLOOR)
     await ui.press({ key: 'refresh' })
     await settle(r)
@@ -1918,4 +3244,445 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'dashboard-title')).toBe('Dashboard')
     expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-303'])
   })
+  test(`the pane keeps its repo when the session cwd moves out of it [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+    // A shell `cd /tmp`: no repo there, relative reads miss, and a `gh` without its own cwd fails.
+    r.cwd = '/tmp'
+    r.repo = null
+    r.calls.length = 0
+    r.cwds.length = 0
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+    expect(await hasKey(ui, 'footer')).toBe(true)
+    expect(await textOf(ui, 'age')).toBe('updated just now')
+    expect(r.calls.length).toBeGreaterThan(0)
+    expect(r.cwds.every(cwd => cwd === ROOT)).toBe(true)
+  })
+
+  test(`the pane follows a move to another GitHub repo and drops the old one's map [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await keysOf(ui, 'row-')).toContain('row-209')
+    r.cwd = ROOT_OTHER
+    r.repo = { root: ROOT_OTHER, remote: 'https://github.com/o/other.git', internal: false }
+    r.otherActive = '14\n'
+    r.map = OTHER_MAP
+    r.tickets = OTHER_TICKETS
+    r.history = OTHER_HISTORY
+    r.calls.length = 0
+    r.cwds.length = 0
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await textOf(ui, 'map')).toBe('#14 older map')
+    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(r.calls).toContainEqual(MAPS_CALL)
+    expect(r.cwds.every(cwd => cwd === ROOT_OTHER)).toBe(true)
+    // The toplevel is read where the session now is, not at its project root, which a shell `cd` leaves behind.
+    expect(r.gitCalls.at(-1)).toEqual({ argv: ['git', 'rev-parse', '--show-toplevel'], cwd: ROOT_OTHER })
+    expect(r.reads).toContain(`${ROOT_OTHER}/.trailhead/active-map`)
+  })
+
+  test(`a session started outside any repo says so and runs no gh [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.cwd = '/tmp'
+    r.repo = null
+    await $.session.start({ ...START, cwd: '/tmp' })
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'no-repo')).toBe('Not in a GitHub repository: open the session in a trailhead repo')
+    await completeTurn($)
+    await settle(r)
+    expect(r.calls).toEqual([])
+  })
+
+  test(`a remote that names no host and repo is no pin: the same message [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.repo = { root: ROOT, remote: '/srv/git/r.git', internal: false }
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'no-repo')).toBe('Not in a GitHub repository: open the session in a trailhead repo')
+    expect(r.calls).toEqual([])
+  })
+  test(`a worktree session reads both files and runs gh under its own toplevel [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    // The repo's root is the main tree's; the session works in the linked worktree.
+    r.top = ROOT_TREE
+    r.cwd = ROOT_TREE
+    r.sessionRoot = ROOT_TREE
+    r.active = '14\n'
+    r.treeActive = '198\n'
+    r.work = stateText()
+    await $.session.start({ ...START, cwd: ROOT_TREE })
+    const ui = await openAndMount($, r)
+    expect(r.gitCalls[0]).toEqual({ argv: ['git', 'rev-parse', '--show-toplevel'], cwd: ROOT_TREE })
+    expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+    expect(r.reads).toContain(`${ROOT_TREE}/.trailhead/active-map`)
+    expect(r.reads).toContain(`${ROOT_TREE}/.trailhead/work-state.json`)
+    // Il record del run vive nel main checkout (#296): e l'unica lettura ammessa fuori dal toplevel.
+    expect(r.reads.filter(path => path.startsWith(`${ROOT}/`) && !path.endsWith('/.trailhead/auto-run.json'))).toEqual([])
+    expect(r.cwds.length).toBeGreaterThan(0)
+    expect(r.cwds.every(cwd => cwd === ROOT_TREE)).toBe(true)
+  })
+
+  for (const remote of ['git@ghe.example.com:o/r.git', 'ssh://git@GitHub.com:22/o/r', 'https://user@github.com/o/r.git']) {
+    test(`the remote ${remote} still pins; gh finds the host itself [${surface}]`, async ($, on) => {
+      const r = rig(on, $)
+      r.repo = { root: ROOT, remote, internal: false }
+      r.authHosts = ['ghe.example.com']
+      await $.session.start(START)
+      const ui = await openAndMount($, r)
+      expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+      expect(r.calls).toContainEqual(MAPS_CALL)
+      expect(r.cwds.every(cwd => cwd === ROOT)).toBe(true)
+    })
+  }
+
+  test(`a refresh in flight when only the band's refresh moves the pin never commits the old repo's tickets [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    let release: () => void = () => {}
+    const gate = new Promise<void>(resolve => {
+      release = resolve
+    })
+    // The answer is fixed when the call starts, so the reads begun in /repo keep /repo's tickets.
+    r.gh = async argv => {
+      const answer = r.defaultGh(argv)
+      await gate
+      return answer
+    }
+    r.open()
+    const ui = await mountPane($)
+    await settle(r)
+    // The same map number in the other repo; a turn start refreshes the band, which moves the pin
+    // while the pane has no hook on it.
+    r.cwd = ROOT_OTHER
+    r.repo = { root: ROOT_OTHER, remote: 'https://github.com/o/other.git', internal: false }
+    r.otherActive = '198\n'
+    r.tickets = OTHER_TICKETS
+    r.history = OTHER_HISTORY
+    await $.turn.start({ text: 'go', turnId: 'race-1' })
+    release()
+    await settle(r)
+    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+  })
+
+  test(`a refresh in flight when the pin moves to another checkout of the same repo is read again [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    let release: () => void = () => {}
+    const gate = new Promise<void>(resolve => {
+      release = resolve
+    })
+    // The answer is fixed when the call starts, so the reads begun in /repo keep its tracker state.
+    r.gh = async argv => {
+      const answer = r.defaultGh(argv)
+      await gate
+      return answer
+    }
+    r.open()
+    const ui = await mountPane($)
+    await settle(r)
+    // Another checkout of the SAME repo (same remote), with map 198 active there; the tracker changed after the
+    // read started. A turn start refreshes the band, which moves the pin while the read is still in flight.
+    r.cwd = ROOT_OTHER
+    r.repo = { root: ROOT_OTHER, remote: 'git@github.com:o/r.git', internal: false }
+    r.otherActive = '198\n'
+    r.tickets = OTHER_TICKETS
+    r.history = OTHER_HISTORY
+    await $.turn.start({ text: 'go', turnId: 'race-same-repo' })
+    release()
+    await settle(r)
+    await r.clock.advance(FLOOR)
+    await settle(r)
+    // The dropped read is repeated: the pane shows the new tracker state, not the old list.
+    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+  })
+
+  test(`a same-repo pin move landing inside the stale check is read again [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    let release: () => void = () => {}
+    const gate = new Promise<void>(resolve => {
+      release = resolve
+    })
+    r.gh = async argv => {
+      const answer = r.defaultGh(argv)
+      await gate
+      return answer
+    }
+    r.open()
+    const ui = await mountPane($)
+    await settle(r)
+    // The first marker read once the gate opens is the stale check's last await: the move lands there,
+    // after the check read the old pin and before it decides.
+    r.beforeMarkerRead = async () => {
+      r.cwd = ROOT_OTHER
+      r.repo = { root: ROOT_OTHER, remote: 'git@github.com:o/r.git', internal: false }
+      r.otherActive = '198\n'
+      r.tickets = OTHER_TICKETS
+      r.history = OTHER_HISTORY
+      await $.turn.start({ text: 'go', turnId: 'race-in-check' })
+    }
+    release()
+    await settle(r)
+    await r.clock.advance(FLOOR)
+    await settle(r)
+    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+  })
+
+  test(`a dashboard read in flight when the pin moves to another checkout of the same repo is read again [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.maps = [MAPS[0]]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    let release: () => void = () => {}
+    const gate = new Promise<void>(resolve => {
+      release = resolve
+    })
+    r.gh = async argv => {
+      const answer = r.defaultGh(argv)
+      await gate
+      return answer
+    }
+    // The dashboard read starts under /repo and waits on the gate.
+    await ui.press({ key: 'open-whiteboard' })
+    await settle(r)
+    r.cwd = ROOT_OTHER
+    r.repo = { root: ROOT_OTHER, remote: 'git@github.com:o/r.git', internal: false }
+    r.otherActive = '198\n'
+    r.whiteboard = [issue(320, 'New loose one', [...WB, 'trailhead:bug'])]
+    await $.turn.start({ text: 'go', turnId: 'race-same-repo-dash' })
+    release()
+    await settle(r)
+    await r.clock.advance(FLOOR)
+    await settle(r)
+    expect(await textOf(ui, 'dashboard-title')).toBe('Dashboard')
+    expect(await keysOf(ui, 'row-')).toEqual(['row-320'])
+  })
+
+  test(`the pin survives /clear after the session cwd moved out of the repo [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.work = stateText()
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+    r.cwd = '/tmp'
+    r.repo = null
+    r.calls.length = 0
+    r.cwds.length = 0
+    await $.command.run({ command: 'clear', args: '' } as never)
+    await settle(r)
+    expect(await hasKey(ui, 'no-repo')).toBe(false)
+    expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+    expect(r.calls.length).toBeGreaterThan(0)
+    expect(r.cwds.every(cwd => cwd === ROOT)).toBe(true)
+  })
+  test(`a session started in a host gh does not serve says so and runs no gh read [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.repo = { root: ROOT, remote: `git@gitlab-${surface}.example.com:o/r.git`, internal: false }
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await completeTurn($)
+    await settle(r)
+    expect(await textOf(ui, 'no-repo')).toBe('Not in a GitHub repository: open the session in a trailhead repo')
+    expect(r.calls).toEqual([])
+    expect(r.authCalls).toEqual([`gitlab-${surface}.example.com`])
+  })
+
+  test(`a cd into a GitLab repo keeps the pin and the map [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    r.cwd = ROOT_OTHER
+    r.repo = { root: ROOT_OTHER, remote: 'https://lab.example.com/o/lab.git', internal: false }
+    r.calls.length = 0
+    r.cwds.length = 0
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(r.authCalls).toEqual(['lab.example.com'])
+    expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+    expect(await hasKey(ui, 'no-repo')).toBe(false)
+    expect(r.calls.length).toBeGreaterThan(0)
+    expect(r.cwds.every(cwd => cwd === ROOT)).toBe(true)
+  })
+
+  test(`the host check runs once per host for the session [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.repo = { root: ROOT, remote: `git@once-${surface}.example.com:o/r.git`, internal: false }
+    r.authHosts = [`once-${surface}.example.com`]
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    for (let i = 0; i < 3; i += 1) {
+      await r.clock.advance(FLOOR)
+      await completeTurn($)
+      await settle(r)
+    }
+    expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+    expect(r.authCalls).toEqual([`once-${surface}.example.com`])
+  })
+  test(`a failed host check is retried after a while, so a later login pins [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    const host = `late-${surface}.example.com`
+    r.repo = { root: ROOT, remote: `git@${host}:o/r.git`, internal: false }
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'no-repo')).toBe('Not in a GitHub repository: open the session in a trailhead repo')
+    // A turn soon after does not ask again; one after the retry window does, and the login now holds.
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(r.authCalls).toEqual([host])
+    r.authHosts = [host]
+    await r.clock.advance(60_000)
+    await completeTurn($)
+    await settle(r)
+    expect(r.authCalls).toEqual([host, host])
+    expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+  })
+  test(`a pin moved by the band alone never leaves the old repo's rows drawn [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await keysOf(ui, 'row-')).toContain('row-209')
+    r.cwd = ROOT_OTHER
+    r.repo = { root: ROOT_OTHER, remote: 'https://github.com/o/other.git', internal: false }
+    r.otherActive = '14\n'
+    r.map = OTHER_MAP
+    r.tickets = OTHER_TICKETS
+    r.history = OTHER_HISTORY
+    // Only the band hooks a turn start: it moves the pin, no read of the pane is in flight.
+    await $.turn.start({ text: 'go', turnId: 'band-1' })
+    expect(await keysOf(ui, 'row-')).not.toContain('row-209')
+    await settle(r)
+    expect(await textOf(ui, 'map')).toBe('#14 older map')
+    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+  })
+
+  // The panel follows the whiteboard ticket this session takes (#306).
+  const WB_STATE = { map: null, ticket: 301, title: 'Fix the README badge', step: 'discuss' }
+  const BOARD_KEY = 'dashboard-title'
+  const CREATE_WB = 'gh issue create -t t --label trailhead:whiteboard'
+
+  test(`an own whiteboard ticket in play switches the panel to the whiteboard [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.work = stateText(WB_STATE)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await hasKey(ui, BOARD_KEY)).toBe(true)
+    expect(await hasKey(ui, 'map')).toBe(false)
+  })
+
+  test(`going back to the map by hand is not undone by the next turn [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.work = stateText(WB_STATE)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await ui.press({ key: 'to-map' })
+    await settle(r)
+    expect(await hasKey(ui, BOARD_KEY)).toBe(false)
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await hasKey(ui, BOARD_KEY)).toBe(false)
+    expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+  })
+
+  test(`the followed ticket is not forced again after /clear [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.work = stateText(WB_STATE)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await ui.press({ key: 'to-map' })
+    await settle(r)
+    await $.command.run({ command: 'clear', args: '' } as never)
+    r.work = stateText({ ...WB_STATE, session: r.session })
+    await ui.redraw()
+    await settle(r)
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await hasKey(ui, BOARD_KEY)).toBe(false)
+  })
+
+  test(`a state that appears mid-session is followed after the helper call [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await textOf(ui, 'map')).toBe('#198 trailhead mod')
+    r.work = stateText(WB_STATE)
+    await $.tool.call({ tool: 'Bash', command: 'node /x/trailhead-work-state.js set --ticket 301' } as never)
+    await settle(r)
+    expect(await hasKey(ui, BOARD_KEY)).toBe(true)
+  })
+
+  test(`a state that appears before a turn ends is followed [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    r.work = stateText(WB_STATE)
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await hasKey(ui, BOARD_KEY)).toBe(true)
+  })
+
+  test(`a map ticket in play does not switch the panel [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.work = stateText()
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await hasKey(ui, BOARD_KEY)).toBe(false)
+  })
+
+  test(`a Resolve leaves the panel on the whiteboard [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.work = stateText(WB_STATE)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    r.work = null
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await hasKey(ui, BOARD_KEY)).toBe(true)
+  })
+
+  test(`a whiteboard ticket created while a map is shown raises one toast and no switch [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    r.stdout = `${URL}/310\n`
+    await $.tool.call({ tool: 'Bash', command: CREATE_WB } as never)
+    await settle(r)
+    expect(r.toasts).toEqual(['new whiteboard ticket #310: open Whiteboard'])
+    expect(await hasKey(ui, BOARD_KEY)).toBe(false)
+  })
+
+  test(`a whiteboard ticket created on the whiteboard view raises no toast [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await ui.press({ key: 'open-whiteboard' })
+    await settle(r)
+    r.stdout = `${URL}/310\n`
+    await $.tool.call({ tool: 'Bash', command: CREATE_WB } as never)
+    await settle(r)
+    expect(r.toasts).toEqual([])
+  })
+
+  test(`a ticket created without the whiteboard label raises no toast [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    await openAndMount($, r)
+    r.stdout = `${URL}/310\n`
+    await $.tool.call({ tool: 'Bash', command: 'gh issue create -t t --label trailhead:task' } as never)
+    await settle(r)
+    expect(r.toasts).toEqual([])
+  })
 }