@marcomigozzi/trailhead 0.16.0 → 0.17.0

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

@@ -15,13 +15,15 @@ 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 checkout handed to a verb: base64url of the root, a `.`, then base64url of the pinned repo (`host/owner/name`),
+// 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 b64url = (text: string) => {
+  const b64 = btoa(Array.from(new TextEncoder().encode(text), byte => String.fromCharCode(byte)).join(''))
+  return b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
 }
+const IN = (root: string) => `--in=${b64url(root)}.${b64url('github.com/o/r')}`
 
 const MAP = {
   title: 'trailhead mod',
@@ -101,6 +103,9 @@ const ticketsCall = (label: string, after?: string) => [
 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.
+// The login and my-tickets reads (any map, the whiteboard): answered apart from the pane's own reads, recorded in `mineCalls`.
+const isLoginRead = (argv: readonly string[]) => argv[1] === 'api' && argv[2] === 'graphql' && argv.includes('query=query{viewer{login}}')
+const isMineRead = (argv: readonly string[]) => argv[1] === 'api' && argv[2] === 'graphql' && argv.some(a => a.startsWith('login='))
 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[]) =>
@@ -137,7 +142,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', 'pendingPhase', 'paneAutoOpened', 'ownTicket', 'repoPin']
+const ATOM_KEYS = ['workState', 'isOrphaned', 'promptSnapshot', 'mapPane', 'activeMap', 'viewedMap', 'isDashboard', 'dashboardPane', 'pendingWork', 'pendingPhase', 'paneAutoOpened', 'ownTicket', 'repoPin', 'myTickets']
 
 const PANE_PROPS = {
   title: 'Map',
@@ -179,6 +184,9 @@ const rig = (on: On, engine?: any) => {
     // 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,
+    // My open tickets on any map or the whiteboard (the `issue()` shape); null makes the read fail.
+    mine: [] as unknown[] | null,
+    mineCalls: [] as (readonly string[])[],
     uatErrors: false,
     uatBroken: false,
     dashboard: DASHBOARD as unknown[],
@@ -192,6 +200,8 @@ const rig = (on: On, engine?: any) => {
     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,
@@ -207,6 +217,8 @@ const rig = (on: On, engine?: any) => {
     calls: [] as (readonly string[])[],
     panes: [] as { id: string; title: string; isShown: boolean; isFocused: boolean; isPlaced: boolean }[],
     isPlaced: true,
+    // Why `ui.open` leaves the pane unplaced (the SDK's `reason`).
+    reason: 'terminal too narrow',
     logs: [] as string[],
     toasts: [] as string[],
     // What a Bash call prints on stdout (the created issue's URL for a `gh issue create`).
@@ -288,13 +300,18 @@ const rig = (on: On, engine?: any) => {
     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) => {
+  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
@@ -389,6 +406,14 @@ const rig = (on: On, engine?: any) => {
       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 } }
     }
+    if (isLoginRead(e.argv) || isMineRead(e.argv)) {
+      r.mineCalls.push([...e.argv])
+      const body = isLoginRead(e.argv)
+        ? { data: { viewer: { login: 'me' } } }
+        : { data: { repository: { issues: { nodes: (r.mine ?? []).map(flatNode), pageInfo: { hasNextPage: false, endCursor: null } } } } }
+      const out = r.mine === null && isMineRead(e.argv) ? { exitCode: 1, stdout: '', stderr: 'boom' } : { exitCode: 0, stdout: JSON.stringify(body), stderr: '' }
+      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.
@@ -406,7 +431,7 @@ const rig = (on: On, engine?: any) => {
       ...r.panes.filter(p => p.id !== e.id),
       { id: e.id, title: e.title ?? e.id, isShown: true, isFocused: false, isPlaced: r.isPlaced },
     ]
-    return { value: r.isPlaced ? { isPlaced: true as const } : { isPlaced: false as const, reason: 'terminal too narrow' } }
+    return { value: r.isPlaced ? { isPlaced: true as const } : { isPlaced: false as const, reason: r.reason } }
   })
   on('ui.close', (_$, e) => {
     r.panes = r.panes.filter(p => p.id !== e.id)
@@ -489,7 +514,7 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'head-in-progress')).toBe('In progress · 2')
     expect(await textOf(ui, 'head-blocked')).toBe('Blocked · 2')
     expect((await ui.find({ key: 'head-frontier' }))?.children[0]).toMatchObject({ props: { bold: true } })
-    expect(await keysOf(ui, 'row-')).toEqual(['row-209', 'row-210', 'row-214', 'row-208', 'row-212', 'row-211', 'row-213'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-208', 'row-212', 'row-209', 'row-210', 'row-214', 'row-211', 'row-213'])
 
     expect(await textOf(ui, 'ticket-209')).toBe('#209 Burn-down view of the map')
     expect(await textOf(ui, 'type-209')).toBe(' build')
@@ -543,10 +568,10 @@ for (const surface of SURFACES) {
 
     expect(await textOf(ui, 'head-uat')).toBe('UAT · 3')
     expect((await ui.find({ key: 'head-uat' }))?.children[0]).toMatchObject({ props: { bold: true } })
-    expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-frontier', 'group-in-progress', 'group-uat', 'group-paused', 'group-blocked'])
+    expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-in-progress', 'group-frontier', 'group-uat', 'group-paused', 'group-blocked'])
     // each ticket once: a UAT row is in no other group, a paused UAT stays under Paused
     expect(await keysOf(ui, 'row-')).toEqual([
-      'row-209', 'row-210', 'row-214', 'row-208', 'row-212', 'row-240', 'row-241', 'row-242', 'row-243', 'row-211', 'row-213',
+      'row-208', 'row-212', 'row-209', 'row-210', 'row-214', 'row-240', 'row-241', 'row-242', 'row-243', 'row-211', 'row-213',
     ])
     expect(await textOf(ui, 'head-frontier')).toBe('Frontier · 3')
     expect(await textOf(ui, 'head-paused')).toBe('Paused · 1')
@@ -647,7 +672,7 @@ for (const surface of SURFACES) {
     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 keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-306', 'row-303'])
     expect(await textOf(ui, 'uat-of-306')).toBe('tests Loose parent #290')
   })
 
@@ -668,8 +693,8 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'head-in-progress')).toBe('In progress · 2')
     expect(await textOf(ui, 'head-blocked')).toBe('Blocked · 2')
     // 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 keysOf(ui, 'row-')).toEqual(['row-208', 'row-212', 'row-209', 'row-210', 'row-214', 'row-230', 'row-231', 'row-232', 'row-211', 'row-213'])
+    expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-in-progress', 'group-frontier', 'group-paused', 'group-blocked'])
     for (const n of [230, 231, 232]) {
       expect(await hasKey(ui, `resume-${n}`)).toBe(true)
       expect(await hasKey(ui, `work-${n}`)).toBe(false)
@@ -685,12 +710,12 @@ for (const surface of SURFACES) {
     const ui = await openAndMount($, r)
     await pressDashboard(ui, r)
     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 keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-305', 'row-303'])
     expect(await hasKey(ui, 'work-305')).toBe(false)
     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) => {
+  test(`needs-you tickets sit in their own group right after In progress, once each, with a work button unless held [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     r.tickets = [
       ...TICKETS,
@@ -706,9 +731,9 @@ for (const surface of SURFACES) {
 
     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 keysOf(ui, 'group-')).toEqual(['group-maps', 'group-in-progress', 'group-needs-you', 'group-frontier', 'group-blocked'])
+    // each ticket once, after my in-progress rows and ahead of the frontier rows; the other counts leave them out
+    expect(await keysOf(ui, 'row-')).toEqual(['row-208', 'row-212', 'row-250', 'row-251', 'row-252', 'row-253', 'row-254', 'row-255', 'row-209', 'row-210', 'row-214', '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)
@@ -731,16 +756,16 @@ for (const surface of SURFACES) {
     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) => {
+  test(`the dashboard view puts a needs-you whiteboard ticket in its own group right after In progress [${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')
+    // right after the maps group and In progress
+    expect((await keysOf(ui, 'group-')).slice(0, 3)).toEqual(['group-maps', 'group-in-progress', 'group-needs-you'])
+    expect((await keysOf(ui, 'row-')).slice(0, 2)).toEqual(['row-302', '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)
@@ -1119,9 +1144,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)
@@ -1138,6 +1163,37 @@ 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) => {
@@ -1166,6 +1222,51 @@ for (const surface of SURFACES) {
     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'))
 
@@ -1287,7 +1388,7 @@ for (const surface of SURFACES) {
     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'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-303'])
   })
 
   test(`a write that reads at once is followed by one more read at the floor's end [${surface}]`, async ($, on) => {
@@ -1540,9 +1641,11 @@ for (const surface of SURFACES) {
     // 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).toMatch(/^--in=[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/)
     expect(word).toBe(IN(ROOT))
-    expect(atob(word.slice('--in='.length).replace(/-/g, '+').replace(/_/g, '/'))).toBe(ROOT)
+    const [rootPart, repoPart] = word.slice('--in='.length).split('.')
+    expect(atob(rootPart.replace(/-/g, '+').replace(/_/g, '/'))).toBe(ROOT)
+    expect(atob(repoPart.replace(/-/g, '+').replace(/_/g, '/').padEnd(Math.ceil(repoPart.length / 4) * 4, '='))).toBe('github.com/o/r')
     expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
     expect(await ui.find({ key: 'work-209' })).toBeDefined()
   })
@@ -2197,7 +2300,7 @@ for (const surface of SURFACES) {
     await settle(r)
     expect(await textOf(ui, 'map')).toBe('#14 older map')
     expect(await textOf(ui, 'viewing-text')).toBe('viewing #14 · active #198')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
   })
 
   test(`the refresh button obeys the same floor [${surface}]`, async ($, on) => {
@@ -2295,6 +2398,20 @@ for (const surface of SURFACES) {
     expect((await panel($)).text).toBe('Map panel closed.')
   })
 
+  // #321: nessuna superficie collegata (inizio sessione) non è un errore: il pannello resta aperto in attesa.
+  test(`/trailhead:panel with no surface attached keeps the pane pending and says so plainly [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.isPlaced = false
+    r.reason = 'no-surface: no surface is attached ($.session.surfaces() is empty)'
+    await $.session.start(START)
+    const pending = 'Map panel will open as soon as the screen is ready.'
+    expect((await panel($)).text).toBe(pending)
+    expect(r.panes.map(p => p.id)).toEqual([PANE])
+    // a second command while still pending is idempotent: it never closes the pane
+    expect((await panel($)).text).toBe(pending)
+    expect(r.panes.map(p => p.id)).toEqual([PANE])
+  })
+
   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
@@ -2469,7 +2586,7 @@ for (const surface of SURFACES) {
 
     expect(await textOf(ui, 'map')).toBe('#14 older map')
     expect(await textOf(ui, 'destination')).toBe('An older destination.')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
     expect(await textOf(ui, 'holder-141')).toBe('@carol')
     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
@@ -2644,7 +2761,7 @@ for (const surface of SURFACES) {
     await settle(r)
     expect(await hasKey(ui, 'ticket-300')).toBe(false)
     expect(await textOf(ui, 'map')).toBe('#14 older map')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
   })
 
   test(`with no active map the open maps are listed and one can be viewed [${surface}]`, async ($, on) => {
@@ -2674,6 +2791,57 @@ for (const surface of SURFACES) {
     await settle(r)
   }
 
+  // My tickets in play on other maps and the whiteboard, under every view's In progress.
+  const MINE = [
+    issue(150, 'My whiteboard fix', [...WB, 'trailhead:build'], ['me']),
+    issue(160, 'My other map ticket', ['trailhead:ticket', 'trailhead:build', 'trailhead:map-14'], ['me']),
+    issue(161, 'My paused one', ['trailhead:ticket', 'trailhead:build', 'trailhead:map-14', 'trailhead:paused'], ['me']),
+    issue(212, 'Native gh-backed tools', ['trailhead:ticket', 'trailhead:build', 'trailhead:map-198'], ['me']),
+  ]
+
+  test(`the map's In progress adds my tickets of the other maps and the whiteboard, each saying where [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.mine = MINE
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(r.mineCalls[0]).toEqual(['gh', 'api', 'graphql', '-f', 'query=query{viewer{login}}'])
+    expect(r.mineCalls.some(argv => argv.includes('login=me'))).toBe(true)
+    expect(await textOf(ui, 'head-in-progress')).toBe('In progress · 4')
+    // the map's own first, then mine elsewhere; a paused one and one the map already lists are not added
+    expect(await keysOf(ui, 'row-')).toEqual(['row-208', 'row-212', 'row-150', 'row-160', 'row-209', 'row-210', 'row-214', 'row-211', 'row-213'])
+    expect(await textOf(ui, 'scope-of-150')).toBe('on whiteboard')
+    expect(await textOf(ui, 'scope-of-160')).toBe('on map #14 older map')
+    expect((await ui.find({ key: 'scope-of-160' }))?.children[0]).toMatchObject({ props: { dimColor: true } })
+    expect(await textOf(ui, 'holder-160')).toBe('@me')
+    expect(await hasKey(ui, 'scope-of-212')).toBe(false)
+    expect(await hasKey(ui, 'row-161')).toBe(false)
+  })
+
+  test(`the dashboard's In progress adds my tickets of every map [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.mine = MINE
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    expect(await textOf(ui, 'scope-of-160')).toBe('on map #14 older map')
+    expect(await textOf(ui, 'scope-of-212')).toBe('on map #198 trailhead mod')
+    // a whiteboard ticket of mine belongs to this view's own list, never a second time with a scope line
+    expect(await hasKey(ui, 'scope-of-150')).toBe(false)
+  })
+
+  test(`a failed read of my tickets keeps the last ones and sets no error [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.mine = MINE
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await hasKey(ui, 'row-160')).toBe(true)
+    r.mine = null
+    await r.clock.advance(TIMER)
+    await settle(r)
+    expect(await hasKey(ui, 'row-160')).toBe(true)
+    expect(await textOf(ui, 'age')).toBe('updated just now')
+  })
+
   test(`the Whiteboard row shows the maps index and the whiteboard tickets [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     await $.session.start(START)
@@ -2709,7 +2877,7 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'head-frontier')).toBe('Frontier · 1')
     expect(await textOf(ui, 'head-in-progress')).toBe('In progress · 1')
     expect(await textOf(ui, 'head-blocked')).toBe('Blocked · 1')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-303'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-303'])
     expect(await textOf(ui, 'holder-302')).toBe('@alice')
     expect(await hasKey(ui, 'work-301')).toBe(true)
     expect(await textOf(ui, 'unverified')).toBe('1 unverified ticket hidden (quarantined)')
@@ -3064,7 +3232,7 @@ for (const surface of SURFACES) {
     const ui = await openAndMount($, r)
     await pressDashboard(ui, r)
     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 keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-306', 'row-303'])
     expect(await textOf(ui, 'holder-302')).toBe('@alice')
     expect(await hasKey(ui, 'resume-306')).toBe(true)
     expect(await hasKey(ui, 'row-305')).toBe(false)
@@ -3093,7 +3261,7 @@ for (const surface of SURFACES) {
     await pressDashboard(ui, r)
     await pressMap(ui, r, 14)
     expect(await textOf(ui, 'map')).toBe('#14 older map')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
 
     await pressDashboard(ui, r)
     await pressMap(ui, r, 198)
@@ -3145,7 +3313,7 @@ for (const surface of SURFACES) {
     const ui = await openAndMount($, r)
     expect(await textOf(ui, 'empty')).toBe('No active map. Run /trailhead:map to pick one.')
     await pressDashboard(ui, r)
-    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-303'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-303'])
     await ui.press({ key: 'to-map' })
     await settle(r)
     expect(await textOf(ui, 'empty')).toBe('No active map. Run /trailhead:map to pick one.')
@@ -3159,7 +3327,7 @@ for (const surface of SURFACES) {
     await $.command.run({ command: 'clear', args: '' } as never)
     await settle(r)
     expect(await textOf(ui, 'dashboard-title')).toBe('Dashboard')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-303'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-303'])
   })
   test(`the pane keeps its repo when the session cwd moves out of it [${surface}]`, async ($, on) => {
     const r = rig(on, $)
@@ -3198,7 +3366,7 @@ for (const surface of SURFACES) {
     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(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
     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.
@@ -3286,7 +3454,101 @@ for (const surface of SURFACES) {
     await $.turn.start({ text: 'go', turnId: 'race-1' })
     release()
     await settle(r)
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
+  })
+
+  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-141', 'row-140'])
+  })
+
+  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-141', 'row-140'])
+  })
+
+  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) => {
@@ -3385,7 +3647,7 @@ for (const surface of SURFACES) {
     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'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
   })
 
   // The panel follows the whiteboard ticket this session takes (#306).