@marcomigozzi/trailhead 0.16.1 → 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[],
@@ -209,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`).
@@ -396,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.
@@ -413,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)
@@ -496,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')
@@ -550,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')
@@ -654,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')
   })
 
@@ -675,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)
@@ -692,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,
@@ -713,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)
@@ -738,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)
@@ -1370,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) => {
@@ -1623,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()
   })
@@ -2280,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) => {
@@ -2378,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
@@ -2552,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
@@ -2727,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) => {
@@ -2757,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)
@@ -2792,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)')
@@ -3147,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)
@@ -3176,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)
@@ -3228,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.')
@@ -3242,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, $)
@@ -3281,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.
@@ -3369,7 +3454,7 @@ 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) => {
@@ -3401,7 +3486,7 @@ for (const surface of SURFACES) {
     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'])
+    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) => {
@@ -3433,7 +3518,7 @@ for (const surface of SURFACES) {
     await settle(r)
     await r.clock.advance(FLOOR)
     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 dashboard read in flight when the pin moves to another checkout of the same repo is read again [${surface}]`, async ($, on) => {
@@ -3562,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).

package/plugins/trailhead/tests/my-tickets.test.ts

@@ -0,0 +1,66 @@
+import { expect, test } from 'claude-code/testing'
+
+import { parseTickets } from '../hooks/mod/map-pane-view'
+import { elsewhereInProgress, myTicketsFromRows, parseLogin, scopeLine } from '../hooks/mod/my-tickets'
+
+const row = (number: number, names: string[], logins: string[] = ['me']) => ({
+  number,
+  title: `t${number}`,
+  url: `https://github.com/o/r/issues/${number}`,
+  labels: names.map(name => ({ name })),
+  assignees: logins.map(login => ({ login })),
+})
+
+test('parseLogin reads the viewer login, null on anything else', () => {
+  expect(parseLogin(JSON.stringify({ data: { viewer: { login: 'me' } } }))).toBe('me')
+  expect(parseLogin(JSON.stringify({ data: { viewer: { login: '' } } }))).toBeNull()
+  expect(parseLogin(JSON.stringify({ errors: [{}], data: { viewer: { login: 'me' } } }))).toBeNull()
+  expect(parseLogin('not json')).toBeNull()
+})
+
+test('myTicketsFromRows tags each ticket with its map or the whiteboard, and drops the rest', () => {
+  const mine = myTicketsFromRows([
+    row(5, ['trailhead:ticket', 'trailhead:build', 'trailhead:map-12']),
+    row(6, ['trailhead:ticket', 'trailhead:bug', 'trailhead:whiteboard']),
+    // no scope, contradictory scopes, and quarantined: never shown
+    row(7, ['trailhead:ticket', 'trailhead:build']),
+    row(8, ['trailhead:ticket', 'trailhead:map-1', 'trailhead:whiteboard']),
+    row(9, ['trailhead:ticket', 'trailhead:map-1', 'trailhead:map-2']),
+    row(10, ['trailhead:ticket', 'trailhead:map-1', 'trailhead:unverified']),
+  ])
+  expect(mine.map(t => [t.number, t.scope])).toEqual([
+    [5, { kind: 'map', number: 12 }],
+    [6, { kind: 'whiteboard' }],
+  ])
+  expect(mine[0]?.state).toBe('in-progress')
+})
+
+test('elsewhereInProgress keeps my in-progress tickets of the other scopes only', () => {
+  const mine = myTicketsFromRows([
+    row(1, ['trailhead:ticket', 'trailhead:map-12']),
+    row(2, ['trailhead:ticket', 'trailhead:map-30']),
+    row(3, ['trailhead:ticket', 'trailhead:whiteboard']),
+    // not in progress: paused, blocked, needs-you, UAT
+    row(4, ['trailhead:ticket', 'trailhead:map-30', 'trailhead:paused']),
+    row(5, ['trailhead:ticket', 'trailhead:map-30', 'trailhead:blocked']),
+    row(6, ['trailhead:ticket', 'trailhead:map-30', 'trailhead:needs-you']),
+    row(7, ['trailhead:ticket', 'trailhead:map-30', 'trailhead:uat']),
+  ])
+  expect(elsewhereInProgress(mine, { kind: 'map', number: 12 }, []).map(t => t.number)).toEqual([2, 3])
+  expect(elsewhereInProgress(mine, { kind: 'whiteboard' }, []).map(t => t.number)).toEqual([1, 2])
+  // a ticket the view already lists is never shown twice
+  const shown = parseTickets(JSON.stringify([row(2, ['trailhead:ticket', 'trailhead:map-12'])]))?.tickets ?? []
+  expect(elsewhereInProgress(mine, { kind: 'map', number: 12 }, shown).map(t => t.number)).toEqual([3])
+})
+
+test('scopeLine names the map by number and title, or the whiteboard, cut to the width', () => {
+  const [onMap, onBoard] = myTicketsFromRows([
+    row(1, ['trailhead:ticket', 'trailhead:map-30']),
+    row(2, ['trailhead:ticket', 'trailhead:whiteboard']),
+  ])
+  const maps = [{ number: 30, title: 'Billing rework', counts: null }]
+  expect(onMap && scopeLine(onMap, maps, 60)).toBe('on map #30 Billing rework')
+  expect(onMap && scopeLine(onMap, [], 60)).toBe('on map #30')
+  expect(onBoard && scopeLine(onBoard, maps, 60)).toBe('on whiteboard')
+  expect((onMap && scopeLine(onMap, maps, 16))?.length).toBeLessThanOrEqual(16)
+})

package/plugins/trailhead/tests/repo-pin.test.ts

@@ -112,12 +112,27 @@ test('repoFromGit keeps a repo with no origin remote unpinned, so the last pin s
   expect(nextPin(current, repo)).toBe(current)
 })
 
-test('checkoutArg hands the root over as one shell-safe word the helper decodes back', () => {
+const fromBase64url = (token: string): string => {
+  const bytes = Uint8Array.from(atob(token.replace(/-/g, '+').replace(/_/g, '/').padEnd(Math.ceil(token.length / 4) * 4, '=')), c => c.charCodeAt(0))
+  return new TextDecoder().decode(bytes)
+}
+
+test('checkoutArg hands the root and the repo over as one shell-safe word the helper decodes back', () => {
   for (const root of ['/repo', '/with space/r', "/it's/r", '/-dash/r', '/uni\u00e8\u4e2d/r', '/a"b$c`d']) {
     const arg = checkoutArg({ ...GH, root })
-    expect(arg).toMatch(/^--in=[A-Za-z0-9_-]+$/)
-    const token = arg.slice('--in='.length)
-    const bytes = Uint8Array.from(atob(token.replace(/-/g, '+').replace(/_/g, '/').padEnd(Math.ceil(token.length / 4) * 4, '=')), c => c.charCodeAt(0))
-    expect(new TextDecoder().decode(bytes)).toBe(root)
+    expect(arg).toMatch(/^--in=[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/)
+    const [path, repo] = arg.slice('--in='.length).split('.')
+    expect(fromBase64url(path)).toBe(root)
+    expect(fromBase64url(repo)).toBe('github.com/o/r')
   }
 })
+
+test('checkoutArg carries host and a nested slug in the repo part', () => {
+  const arg = checkoutArg({ root: '/w/p', host: 'gitlab.com', slug: 'g/sub/r' })
+  expect(fromBase64url(arg.split('.')[1])).toBe('gitlab.com/g/sub/r')
+})
+
+test('checkoutArg carries a dotless host in the repo part', () => {
+  const arg = checkoutArg({ root: '/w/p', host: 'gitea', slug: 'owner/name' })
+  expect(fromBase64url(arg.split('.')[1])).toBe('gitea/owner/name')
+})

package/plugins/trailhead/types/index.d.ts

@@ -42,6 +42,11 @@ export type PaneTicket = {
   uatOf: UatParent | null
 }
 
+// Where one of my tickets lives: an open map by number, or the whiteboard.
+export type TicketScope = { kind: 'map'; number: number } | { kind: 'whiteboard' }
+// A ticket assigned to the gh login, tagged with its scope (the In progress group lists it outside that scope).
+export type MyTicket = PaneTicket & { scope: TicketScope }
+
 // A map's sub-issue counts: `open` still to do, `total` all of them.
 export type MapCounts = { open: number; total: number }
 // One open map of the repo, as the maps list shows it; `counts` null = unknown, drawn name-only.
@@ -113,6 +118,8 @@ declare module 'claude-code' {
       // The pane shows the dashboard (maps index + whiteboard) instead of a map.
       isDashboard: boolean
       dashboardPane: DashboardPaneData
+      // My open tickets across every map and the whiteboard (the last good read), for every view's In progress.
+      myTickets: readonly MyTicket[]
       pendingWork: number | null
       // Whether the pending press waits for the turn to end or has been sent.
       pendingPhase: 'queued' | 'starting' | null