@marcomigozzi/trailhead 0.14.0 → 0.15.0

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

@@ -5,22 +5,31 @@ import {
   axisStart,
   burndownEnd,
   burndownSeries,
+  countsLabel,
   failureReason,
   footerStatus,
   groupTickets,
+  headingRoom,
   HISTORY_LIMIT,
   mapRowLayout,
   nextViewed,
   parseActiveMap,
+  parseDashboard,
   parseHistory,
   parseMap,
   parseMaps,
+  parseMapsRead,
   parseTickets,
+  parseUatParents,
   rasterCells,
   refreshDecision,
   rowLayout,
   sparkline,
+  uatParentLine,
   viewTarget,
+  withUatParents,
+  whiteboardHeading,
+  whiteboardRowLayout,
 } from '../hooks/mod/map-pane-view'
 
 const issue = (over: Record<string, unknown> = {}) => ({
@@ -57,10 +66,10 @@ test('parseTickets maps a gh list to rows with type, state and holders', () => {
   )
   expect(out?.unverifiedCount).toBe(0)
   expect(out?.tickets).toEqual([
-    { number: 209, title: 'Burn-down view', type: 'build', state: 'frontier', assignees: [], url: 'https://github.com/o/r/issues/209' },
-    { number: 212, title: 'Held', type: 'research', state: 'in-progress', assignees: ['alice'], url: 'https://github.com/o/r/issues/209' },
-    { number: 211, title: 'Gated', type: 'bug', state: 'blocked', assignees: ['bob'], url: 'https://github.com/o/r/issues/209' },
-    { number: 214, title: 'No type', type: null, state: 'frontier', assignees: [], url: 'https://github.com/o/r/issues/209' },
+    { number: 209, title: 'Burn-down view', type: 'build', state: 'frontier', assignees: [], url: 'https://github.com/o/r/issues/209', isUat: false, uatOf: null },
+    { number: 212, title: 'Held', type: 'research', state: 'in-progress', assignees: ['alice'], url: 'https://github.com/o/r/issues/209', isUat: false, uatOf: null },
+    { number: 211, title: 'Gated', type: 'bug', state: 'blocked', assignees: ['bob'], url: 'https://github.com/o/r/issues/209', isUat: false, uatOf: null },
+    { number: 214, title: 'No type', type: null, state: 'frontier', assignees: [], url: 'https://github.com/o/r/issues/209', isUat: false, uatOf: null },
   ])
 })
 
@@ -140,13 +149,102 @@ test('parseMap has a null destination when the section is missing or empty, and
 })
 
 test('groupTickets splits by state, ascending by number', () => {
-  const t = (number: number, state: 'frontier' | 'in-progress' | 'blocked') => ({
+  const t = (number: number, state: 'frontier' | 'in-progress' | 'blocked' | 'paused') => ({
     number, title: '', type: null, state, assignees: [], url: '',
   })
   const g = groupTickets([t(30, 'frontier'), t(5, 'blocked'), t(9, 'in-progress'), t(12, 'frontier'), t(2, 'blocked')])
   expect(g.frontier.map(x => x.number)).toEqual([12, 30])
   expect(g.inProgress.map(x => x.number)).toEqual([9])
   expect(g.blocked.map(x => x.number)).toEqual([2, 5])
+  expect(g.paused).toEqual([])
+})
+
+test('groupTickets puts a paused ticket in the Paused group only', () => {
+  const t = (number: number, state: 'frontier' | 'in-progress' | 'blocked' | 'paused') => ({
+    number, title: '', type: null, state, assignees: [], url: '',
+  })
+  const g = groupTickets([t(8, 'paused'), t(3, 'paused'), t(4, 'in-progress'), t(5, 'blocked'), t(6, 'frontier')])
+  expect(g.paused.map(x => x.number)).toEqual([3, 8])
+  expect([g.frontier, g.inProgress, g.blocked].map(x => x.map(y => y.number))).toEqual([[6], [4], [5]])
+})
+
+test('parseTickets: a paused label wins over blocked and in-progress, with the holder kept', () => {
+  const state = (names: string[], assignees: string[] = []) =>
+    parseTickets(list(issue({ labels: labels(...names), assignees: assignees.map(login => ({ login })) })))?.tickets[0]
+  expect(state(['trailhead:build', 'trailhead:paused'])).toMatchObject({ state: 'paused', assignees: [] })
+  expect(state(['trailhead:build', 'trailhead:paused', 'trailhead:blocked'], ['alice'])).toMatchObject({ state: 'paused', assignees: ['alice'] })
+  expect(state(['trailhead:build', 'trailhead:paused'], ['alice'])?.state).toBe('paused')
+  expect(state(['trailhead:build'], ['alice'])?.state).toBe('in-progress')
+})
+
+test('parseTickets sets isUat from the trailhead:uat label, with no parent yet', () => {
+  const t = (...names: string[]) => parseTickets(list(issue({ labels: labels(...names) })))?.tickets[0]
+  expect(t('trailhead:task', 'trailhead:uat')).toMatchObject({ isUat: true, uatOf: null, state: 'frontier' })
+  expect(t('trailhead:task')).toMatchObject({ isUat: false, uatOf: null })
+  // a marker, not a state: the state is unchanged
+  expect(t('trailhead:seed', 'trailhead:blocked', 'trailhead:uat')).toMatchObject({ isUat: true, state: 'blocked' })
+})
+
+const body = (text: string, number = 5) => ({ number, body: text })
+const uatList = (...rows: unknown[]) => JSON.stringify(rows)
+
+test('parseUatParents maps a ticket to the parent named by its UAT of: line', () => {
+  const out = parseUatParents(
+    uatList(
+      body('Intro\n\nUAT of: [Burn-down view](https://github.com/o/r/issues/209)\n\n- [ ] step', 301),
+      body('UAT of: #210', 302),
+      body('no pointer here', 303),
+      body('mentions UAT of: [x](https://github.com/o/r/issues/1) mid-line', 304),
+      body('UAT of: [Win](https://github.com/o/r/issues/212)\r\nmore', 305),
+    ),
+  )
+  expect(out?.get(301)).toEqual({ number: 209, title: 'Burn-down view' })
+  expect(out?.get(302)).toEqual({ number: 210, title: '' })
+  expect(out?.get(303)).toBeUndefined()
+  expect(out?.get(304)).toBeUndefined()
+  expect(out?.get(305)).toEqual({ number: 212, title: 'Win' })
+})
+
+test('parseUatParents strips control characters from a parent title and skips unusable rows', () => {
+  const out = parseUatParents(
+    uatList(body('UAT of: [a\u0007b​c‮d](https://github.com/o/r/issues/7)', 1), { number: 'x', body: 'UAT of: #3' }, { number: 2, body: 5 }, 'junk', body('UAT of: [t](https://example.com/nope)', 3)),
+  )
+  expect(out?.get(1)).toEqual({ number: 7, title: 'abcd' })
+  expect(out?.size).toBe(1)
+})
+
+test('parseUatParents is null on non-JSON or a non-list', () => {
+  expect(parseUatParents('{nope')).toBeNull()
+  expect(parseUatParents('{}')).toBeNull()
+})
+
+test('withUatParents sets the parent on a UAT ticket only, and leaves the tickets alone without a read', () => {
+  const t = (number: number, isUat: boolean) => ({ number, title: '', type: null, state: 'frontier' as const, assignees: [], url: '', isUat, uatOf: null })
+  const tickets = [t(1, true), t(2, false), t(3, true)]
+  const out = withUatParents(tickets, new Map([[1, { number: 9, title: 'P' }], [2, { number: 8, title: 'Q' }]]))
+  expect(out.map(x => x.uatOf)).toEqual([{ number: 9, title: 'P' }, null, null])
+  expect(tickets[0]?.uatOf).toBeNull()
+  expect(withUatParents(tickets, null)).toEqual(tickets)
+})
+
+test('uatParentLine draws tests <title> #<n>, fitted to the width, and nothing without a parent', () => {
+  const t = (uatOf: { number: number; title: string } | null) => ({ number: 1, title: '', type: null, state: 'frontier' as const, assignees: [], url: '', isUat: true, uatOf })
+  expect(uatParentLine(t(null), 60)).toBeNull()
+  expect(uatParentLine(t({ number: 209, title: 'Burn-down view' }), 60)).toBe('tests Burn-down view #209')
+  expect(uatParentLine(t({ number: 210, title: '' }), 60)).toBe('tests #210')
+  const cut = uatParentLine(t({ number: 209, title: 'x'.repeat(200) }), 30) as string
+  expect(Array.from(cut).length).toBe(30)
+  expect(cut.endsWith('… #209')).toBe(true)
+})
+
+test('groupTickets lists a UAT ticket once, under UAT, ascending; a paused one stays under Paused', () => {
+  const t = (number: number, state: 'frontier' | 'in-progress' | 'blocked' | 'paused', isUat: boolean) => ({
+    number, title: '', type: null, state, assignees: [], url: '', isUat, uatOf: null,
+  })
+  const g = groupTickets([t(9, 'frontier', true), t(4, 'blocked', true), t(6, 'in-progress', true), t(7, 'paused', true), t(2, 'frontier', false), t(3, 'blocked', false)])
+  expect(g.uat.map(x => x.number)).toEqual([4, 6, 9])
+  expect(g.paused.map(x => x.number)).toEqual([7])
+  expect([g.frontier, g.inProgress, g.blocked].map(x => x.map(y => y.number))).toEqual([[2], [], [3]])
 })
 
 test('failureReason names one short cause', () => {
@@ -223,6 +321,28 @@ test('rowLayout: holders are drawn as @login on in-progress and blocked rows', (
   expect(loose.isDim).toBe(true)
 })
 
+test('rowLayout: a paused row shows its holder when assigned, never a work button', () => {
+  expect(layout(ticket({ state: 'paused', assignees: ['alice'] })).aside).toEqual({ kind: 'holder', text: '@alice' })
+  expect(layout(ticket({ state: 'paused' })).aside).toBeNull()
+  expect(layout(ticket({ state: 'paused' }), { pendingWork: 209 }).aside).toBeNull()
+  expect(layout(ticket({ state: 'paused' })).isDim).toBe(false)
+})
+
+test('rowLayout: the ticket in play says this session instead of its holder', () => {
+  const r = layout(ticket({ state: 'in-progress', assignees: ['me'] }), { isInPlay: true, hasMarkColumn: true })
+  expect(r.aside).toEqual({ kind: 'self', text: 'this session' })
+  expect(layout(ticket({ state: 'in-progress', assignees: ['me'] }), { hasMarkColumn: true }).aside).toEqual({ kind: 'holder', text: '@me' })
+})
+
+test('rowLayout: the this-session aside is counted in the row width', () => {
+  const t = ticket({ title: 'x'.repeat(200), state: 'in-progress', assignees: ['me'] })
+  for (const columns of [30, 40, 60]) {
+    const r = layout(t, { columns, isInPlay: true, hasMarkColumn: true })
+    const used = (r.mark?.length ?? 0) + r.label.length + (r.type?.length ?? 0) + (r.aside?.text.length ?? 0) + 1
+    expect(used).toBeLessThanOrEqual(columns)
+  }
+})
+
 test('rowLayout: the mark column marks the ticket in play and pads the others', () => {
   expect(layout(ticket({ state: 'in-progress', assignees: ['me'] }), { isInPlay: true, hasMarkColumn: true })).toMatchObject({ mark: '▸ ', isInPlay: true })
   expect(layout(ticket(), { hasMarkColumn: true }).mark).toBe('  ')
@@ -473,9 +593,9 @@ test('parseMaps keeps the open maps sorted by number, titles flattened', () => {
     ]),
   )
   expect(out).toEqual([
-    { number: 14, title: 'older map' },
-    { number: 20, title: '' },
-    { number: 198, title: 'trailhead mod' },
+    { number: 14, title: 'older map', counts: null },
+    { number: 20, title: '', counts: null },
+    { number: 198, title: 'trailhead mod', counts: null },
   ])
   expect(parseMaps('[]')).toEqual([])
 })
@@ -486,6 +606,135 @@ test('parseMaps rejects what is not a list', () => {
   expect(parseMaps('null')).toBeNull()
 })
 
+const WB_FIELDS = { whiteboardOpen: { totalCount: 3 }, whiteboardAll: { totalCount: 9 } }
+const gql = (nodes: unknown[], extra: Record<string, unknown> = {}, repo: Record<string, unknown> = WB_FIELDS) =>
+  JSON.stringify({ data: { repository: { issues: { nodes }, ...repo } }, ...extra })
+
+test('parseMapsRead reads each map with its open and total sub-issues, sorted by number', () => {
+  const out = parseMapsRead(
+    gql([
+      { number: 198, title: 'trailhead\u202e mod\n', url: 'https://x/198', subIssuesSummary: { total: 23, completed: 16 } },
+      { number: 14, title: 'older map', url: 'https://x/14', subIssuesSummary: { total: 5, completed: 5 } },
+      { number: 0, title: 'bad number', subIssuesSummary: { total: 1, completed: 0 } },
+      'junk',
+    ]),
+  )
+  expect(out?.maps).toEqual([
+    { number: 14, title: 'older map', counts: { open: 0, total: 5 } },
+    { number: 198, title: 'trailhead mod', counts: { open: 7, total: 23 } },
+  ])
+  expect(parseMapsRead(gql([]))?.maps).toEqual([])
+  // completed above total never goes negative
+  expect(parseMapsRead(gql([{ number: 3, title: 't', subIssuesSummary: { total: 2, completed: 4 } }]))?.maps).toEqual([
+    { number: 3, title: 't', counts: { open: 0, total: 2 } },
+  ])
+})
+
+test('parseMapsRead keeps a row with a malformed summary, name-only', () => {
+  const out = parseMapsRead(
+    gql([
+      { number: 1, title: 'a' },
+      { number: 2, title: 'b', subIssuesSummary: { total: 'x', completed: 1 } },
+      { number: 3, title: 'c', subIssuesSummary: null },
+    ]),
+  )
+  expect(out?.maps).toEqual([
+    { number: 1, title: 'a', counts: null },
+    { number: 2, title: 'b', counts: null },
+    { number: 3, title: 'c', counts: null },
+  ])
+})
+
+test('parseMapsRead reads the whiteboard counts beside the maps', () => {
+  expect(parseMapsRead(gql([]))?.whiteboard).toEqual({ open: 3, total: 9 })
+  // nothing on the whiteboard is a real count, drawn as is
+  const none = { whiteboardOpen: { totalCount: 0 }, whiteboardAll: { totalCount: 0 } }
+  expect(parseMapsRead(gql([], {}, none))?.whiteboard).toEqual({ open: 0, total: 0 })
+})
+
+test('parseMapsRead gives a null whiteboard, maps intact, when its fields are missing or unusable', () => {
+  const node = { number: 1, title: 'a', subIssuesSummary: { total: 4, completed: 1 } }
+  const bad: Record<string, unknown>[] = [
+    {},
+    { whiteboardOpen: { totalCount: 3 } },
+    { whiteboardAll: { totalCount: 9 } },
+    { whiteboardOpen: null, whiteboardAll: { totalCount: 9 } },
+    { whiteboardOpen: { totalCount: -1 }, whiteboardAll: { totalCount: 9 } },
+    { whiteboardOpen: { totalCount: 1.5 }, whiteboardAll: { totalCount: 9 } },
+    { whiteboardOpen: { totalCount: '3' }, whiteboardAll: { totalCount: 9 } },
+    { whiteboardOpen: { totalCount: 10 }, whiteboardAll: { totalCount: 9 } },
+  ]
+  for (const repo of bad) {
+    expect(parseMapsRead(gql([node], {}, repo))).toEqual({ maps: [{ number: 1, title: 'a', counts: { open: 3, total: 4 } }], whiteboard: null })
+  }
+})
+
+test('parseMapsRead is null on anything but a clean reply', () => {
+  const node = { number: 1, title: 'a', subIssuesSummary: { total: 1, completed: 0 } }
+  expect(parseMapsRead('not json')).toBeNull()
+  expect(parseMapsRead('[]')).toBeNull()
+  expect(parseMapsRead('{}')).toBeNull()
+  expect(parseMapsRead('{"data":null}')).toBeNull()
+  expect(parseMapsRead('{"data":{"repository":null}}')).toBeNull()
+  expect(parseMapsRead('{"data":{"repository":{"issues":{"nodes":"x"}}}}')).toBeNull()
+  expect(parseMapsRead(JSON.stringify({ errors: [{ message: 'boom' }] }))).toBeNull()
+  // partial data next to errors is still a failed read
+  expect(parseMapsRead(gql([node], { errors: [{ message: 'partial' }] }))).toBeNull()
+})
+
+test('countsLabel words open over total', () => {
+  expect(countsLabel({ open: 7, total: 23 })).toBe('7 open / 23')
+  expect(countsLabel({ open: 0, total: 0 })).toBe('0 open / 0')
+})
+
+test('whiteboardRowLayout puts the counts beside the name, a null read leaves it name-only', () => {
+  expect(whiteboardRowLayout({ open: 3, total: 9 }, 60)).toEqual({ mark: '  ', label: 'Whiteboard', aside: ' 3 open / 9' })
+  expect(whiteboardRowLayout({ open: 0, total: 0 }, 60).aside).toBe(' 0 open / 0')
+  expect(whiteboardRowLayout(null, 60)).toEqual({ mark: '  ', label: 'Whiteboard', aside: null })
+})
+
+test('whiteboardRowLayout keeps the name whole and drops the counts when they do not fit', () => {
+  // mark 2 + `[ Whiteboard ]` 14 + ` 3 open / 9` 11 = 27 cells
+  expect(whiteboardRowLayout({ open: 3, total: 9 }, 27).aside).toBe(' 3 open / 9')
+  const narrow = whiteboardRowLayout({ open: 3, total: 9 }, 26)
+  expect(narrow.aside).toBeNull()
+  expect(narrow.label).toBe('Whiteboard')
+})
+
+test('mapRowLayout asides: counts first, then active, joined by a dot', () => {
+  const m = { number: 198, title: 'trailhead mod', counts: { open: 7, total: 23 } }
+  expect(mapRowLayout(m, { active: 198, viewed: null, columns: 60 }).aside).toBe(' 7 open / 23 · active')
+  expect(mapRowLayout(m, { active: 14, viewed: null, columns: 60 }).aside).toBe(' 7 open / 23')
+  expect(mapRowLayout({ ...m, counts: null }, { active: 198, viewed: null, columns: 60 }).aside).toBe(' active')
+  expect(mapRowLayout({ ...m, counts: null }, { active: 14, viewed: null, columns: 60 }).aside).toBeNull()
+})
+
+test('mapRowLayout cuts the title before the counts, which stay whole', () => {
+  const m = { number: 14, title: 'x'.repeat(200), counts: { open: 7, total: 23 } }
+  const r = mapRowLayout(m, { active: 198, viewed: null, columns: 40 })
+  expect(r.aside).toBe(' 7 open / 23')
+  expect(r.label.endsWith('…')).toBe(true)
+  expect(r.mark.length + r.label.length + 4 + (r.aside?.length ?? 0)).toBeLessThanOrEqual(40)
+  // a map with no title falls back to the number
+  expect(mapRowLayout({ ...m, title: '' }, { active: 198, viewed: null, columns: 40 }).label).toBe('#14')
+})
+
+const wbTicket = (number: number, assignees: string[] = []) => ({
+  number,
+  title: `t${number}`,
+  type: null,
+  state: assignees.length > 0 ? ('in-progress' as const) : ('frontier' as const),
+  assignees,
+  url: '',
+})
+
+test('whiteboardHeading counts the open and the assigned tickets', () => {
+  expect(whiteboardHeading([wbTicket(1), wbTicket(2, ['a']), wbTicket(3, ['a', 'b'])], false)).toBe('Whiteboard · 3 open · 2 assigned')
+  expect(whiteboardHeading([], false)).toBe('Whiteboard · 0 open · 0 assigned')
+  expect(whiteboardHeading([wbTicket(1)], true)).toBe('Whiteboard · 200+ open · 0 assigned')
+  expect(whiteboardHeading(null, false)).toBe('Whiteboard')
+})
+
 test('viewTarget is the viewed map, else the active one', () => {
   expect(viewTarget(198, null)).toBe(198)
   expect(viewTarget(198, 14)).toBe(14)
@@ -494,10 +743,10 @@ test('viewTarget is the viewed map, else the active one', () => {
 })
 
 test('nextViewed resets when the active map changed or the viewed map left the open list', () => {
-  const maps = [{ number: 14, title: 'a' }, { number: 198, title: 'b' }]
+  const maps = [{ number: 14, title: 'a', counts: null }, { number: 198, title: 'b', counts: null }]
   expect(nextViewed(14, { activeChanged: false, maps })).toBe(14)
   expect(nextViewed(14, { activeChanged: true, maps })).toBeNull()
-  expect(nextViewed(14, { activeChanged: false, maps: [{ number: 198, title: 'b' }] })).toBeNull()
+  expect(nextViewed(14, { activeChanged: false, maps: [{ number: 198, title: 'b', counts: null }] })).toBeNull()
   expect(nextViewed(14, { activeChanged: false, maps: [] })).toBeNull()
   // no list read yet (or a failed read): nothing to judge by
   expect(nextViewed(14, { activeChanged: false, maps: null })).toBe(14)
@@ -505,7 +754,7 @@ test('nextViewed resets when the active map changed or the viewed map left the o
 })
 
 test('mapRowLayout marks the active map, bolds the viewed one and presses the others', () => {
-  const m = { number: 14, title: 'older map' }
+  const m = { number: 14, title: 'older map', counts: null }
   expect(mapRowLayout(m, { active: 198, viewed: null, columns: 60 })).toEqual({
     mark: '  ',
     label: '#14 older map',
@@ -514,10 +763,10 @@ test('mapRowLayout marks the active map, bolds the viewed one and presses the ot
     isViewed: false,
     isPressable: true,
   })
-  const act = mapRowLayout({ number: 198, title: 'trailhead mod' }, { active: 198, viewed: null, columns: 60 })
+  const act = mapRowLayout({ number: 198, title: 'trailhead mod', counts: null }, { active: 198, viewed: null, columns: 60 })
   expect(act).toMatchObject({ mark: '● ', aside: ' active', isActive: true, isViewed: true, isPressable: false })
   // viewing another map: the active one becomes pressable (back to active), the viewed one is not
-  expect(mapRowLayout({ number: 198, title: 't' }, { active: 198, viewed: 14, columns: 60 })).toMatchObject({
+  expect(mapRowLayout({ number: 198, title: 't', counts: null }, { active: 198, viewed: 14, columns: 60 })).toMatchObject({
     isActive: true,
     isViewed: false,
     isPressable: true,
@@ -526,14 +775,14 @@ test('mapRowLayout marks the active map, bolds the viewed one and presses the ot
 })
 
 test('mapRowLayout cuts the title to the room left by the mark and the aside', () => {
-  const long = { number: 198, title: 'x'.repeat(200) }
+  const long = { number: 198, title: 'x'.repeat(200), counts: null }
   const act = mapRowLayout(long, { active: 198, viewed: null, columns: 30 })
   expect(act.label.endsWith('…')).toBe(true)
   expect(act.mark.length + act.label.length + (act.aside?.length ?? 0)).toBeLessThanOrEqual(30)
-  const other = mapRowLayout({ number: 14, title: 'x'.repeat(200) }, { active: 198, viewed: null, columns: 30 })
+  const other = mapRowLayout({ number: 14, title: 'x'.repeat(200), counts: null }, { active: 198, viewed: null, columns: 30 })
   // a Button draws `[ label ]`: four cells of chrome
   expect(other.mark.length + other.label.length + 4).toBeLessThanOrEqual(30)
-  expect(mapRowLayout({ number: 14, title: '' }, { active: 198, viewed: null, columns: 30 }).label).toBe('#14')
+  expect(mapRowLayout({ number: 14, title: '', counts: null }, { active: 198, viewed: null, columns: 30 }).label).toBe('#14')
 })
 
 test('footerStatus keeps a status that fits beside the two buttons on their row', () => {
@@ -563,3 +812,42 @@ test('footerStatus on a pane too narrow for the buttons never throws', () => {
   expect(footerStatus('updated just now', 10)).toEqual({ text: 'updated j…', isInline: false })
   expect(footerStatus('updated just now', 0)).toEqual({ text: '…', isInline: false })
 })
+
+test('parseTickets on the whiteboard keeps only the whiteboard rows, unverified ones still counted', () => {
+  const rows = [
+    { number: 1, title: 'map one', labels: [{ name: 'trailhead:build' }], assignees: [], url: '' },
+    { number: 2, title: 'loose', labels: [{ name: 'trailhead:whiteboard' }, { name: 'trailhead:bug' }], assignees: [], url: '' },
+    { number: 3, title: 'held', labels: [{ name: 'trailhead:whiteboard' }], assignees: [{ login: 'al' }], url: '' },
+    { number: 4, title: 'q', labels: [{ name: 'trailhead:whiteboard' }, { name: 'trailhead:unverified' }], assignees: [], url: '' },
+  ]
+  const parsed = parseTickets(JSON.stringify(rows), { isWhiteboard: true })
+  expect(parsed?.tickets.map(t => [t.number, t.type, t.state])).toEqual([
+    [2, 'bug', 'frontier'],
+    [3, null, 'in-progress'],
+  ])
+  expect(parsed?.unverifiedCount).toBe(1)
+  expect(parseTickets(JSON.stringify(rows))?.tickets.map(t => t.number)).toEqual([1])
+})
+
+test('parseDashboard takes the lowest numbered index, none when the repo has none, null when unreadable', () => {
+  expect(parseDashboard(JSON.stringify([{ number: 9, url: 'https://x/9' }, { number: 5, url: 'https://x/5' }]))).toEqual({
+    ref: { number: 5, url: 'https://x/5' },
+  })
+  expect(parseDashboard(JSON.stringify([{ number: 5, url: 'javascript:alert(1)' }]))).toEqual({ ref: { number: 5, url: '' } })
+  expect(parseDashboard('[]')).toEqual({ ref: null })
+  expect(parseDashboard('nope')).toBeNull()
+  expect(parseDashboard('{}')).toBeNull()
+})
+
+test('mapRowLayout on the dashboard makes every map pressable, the active one still marked', () => {
+  const r = mapRowLayout({ number: 198, title: 'trailhead mod', counts: null }, { active: 198, viewed: null, columns: 60, isDashboard: true })
+  expect(r).toMatchObject({ isActive: true, isViewed: false, isPressable: true, mark: '● ', aside: ' active' })
+  expect(mapRowLayout({ number: 198, title: 'trailhead mod', counts: null }, { active: 198, viewed: null, columns: 60 }).isPressable).toBe(false)
+})
+
+test('headingRoom leaves the switch button its cells, never below zero', () => {
+  // `[ dashboard ]` is 13 cells, plus one gap
+  expect(headingRoom(60, 'dashboard')).toBe(46)
+  expect(headingRoom(60, 'map')).toBe(52)
+  expect(headingRoom(5, 'dashboard')).toBe(0)
+})

package/plugins/trailhead/tests/work-state-view.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from 'claude-code/testing'
 
-import { fit, parseWorkState, pipeline, sameValue, statusLine } from '../hooks/mod/work-state-view'
+import { fit, nextOwnTicket, parseWorkState, pipeline, sameValue, statusLine } from '../hooks/mod/work-state-view'
 
 const valid = {
   map: 198,
@@ -84,3 +84,27 @@ test('fit cuts with an ellipsis by code point and leaves a short text whole', ()
   expect(fit('abcdef', 1)).toBe('…')
   expect(fit('a' + '\u{1F680}'.repeat(5), 3)).toBe('a\u{1F680}…')
 })
+
+// nextOwnTicket(prev, lastState, nextState, session): the ticket this session owns across a shared file.
+const stamped = (ticket: number, session: string | null) => ({ ...valid, ticket, session })
+
+test('nextOwnTicket takes the ticket of a state stamped with this session', () => {
+  expect(nextOwnTicket(null, null, stamped(259, 's1'), 's1')).toBe(259)
+  expect(nextOwnTicket(212, stamped(212, 's1'), stamped(259, 's1'), 's1')).toBe(259)
+  // a state with no session is this one's, like the orphan rule
+  expect(nextOwnTicket(null, null, stamped(259, null), 's1')).toBe(259)
+})
+
+test('nextOwnTicket leaves the ticket alone when another session wrote the file', () => {
+  expect(nextOwnTicket(259, stamped(259, 's1'), stamped(212, 's2'), 's1')).toBe(259)
+  expect(nextOwnTicket(null, null, stamped(212, 's2'), 's1')).toBeNull()
+})
+
+test('nextOwnTicket clears on a missing file only when the last state read was this session\'s', () => {
+  expect(nextOwnTicket(259, stamped(259, 's1'), null, 's1')).toBeNull()
+  expect(nextOwnTicket(259, stamped(259, null), null, 's1')).toBeNull()
+  // own state, then another session's, then a missing file: the last read was not ours
+  expect(nextOwnTicket(259, stamped(212, 's2'), null, 's1')).toBe(259)
+  expect(nextOwnTicket(259, null, null, 's1')).toBe(259)
+  expect(nextOwnTicket(null, null, null, 's1')).toBeNull()
+})

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

@@ -15,7 +15,10 @@ export type PromptSnapshot = { key: string; text: string | null }
 
 // The map pane (#208): what the last `gh` read of the active map gave.
 export type TicketType = 'decision' | 'research' | 'prototype' | 'build' | 'bug' | 'task'
-export type TicketState = 'frontier' | 'in-progress' | 'blocked'
+export type TicketState = 'frontier' | 'in-progress' | 'paused' | 'blocked'
+
+// The parent a pending UAT ticket tests (from its `UAT of:` body line); title is empty for a bare `#<n>`.
+export type UatParent = { number: number; title: string }
 
 export type PaneTicket = {
   number: number
@@ -24,10 +27,19 @@ export type PaneTicket = {
   state: TicketState
   assignees: readonly string[]
   url: string
+  // Carries `trailhead:uat`: a marker beside `state`, only the grouping moves it (paused still wins).
+  isUat: boolean
+  // The parent it tests, once read; null when unknown (no body read, or no usable `UAT of:` line).
+  uatOf: UatParent | null
 }
 
-// One open map of the repo, as the maps list shows it.
-export type MapSummary = { number: number; title: string }
+// 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.
+export type MapSummary = { number: number; title: string; counts: MapCounts | null }
+
+// What the maps read gives: the open maps and the whiteboard's counts (null when they were unreadable).
+export type MapsRead = { maps: readonly MapSummary[]; whiteboard: MapCounts | null }
 
 export type MapInfo = { number: number; title: string; destination: string | null; url: string }
 
@@ -45,6 +57,8 @@ export type MapPaneData = {
   isCapped: boolean
   // The repo's open maps (empty until a first good read, then the last good one).
   maps: readonly MapSummary[]
+  // The whiteboard's open and total tickets; null = unknown, the Whiteboard row is drawn name-only.
+  whiteboard: MapCounts | null
   history: BurndownHistory | null
   historyAt: number | null
   fetchedAt: number | null
@@ -52,16 +66,36 @@ export type MapPaneData = {
   isLoading: boolean
 }
 
+// The pinned per-repo index issue (`trailhead:dashboard`), as the pane links it.
+export type DashboardRef = { number: number; url: string }
+
+// The pane's dashboard view: the whiteboard tickets (map-less) and the pinned index; the open maps
+// stay in `MapPaneData.maps`. Same failure rule: the last good read is kept, `error` says why.
+export type DashboardPaneData = {
+  dashboard: DashboardRef | null
+  tickets: readonly PaneTicket[]
+  unverifiedCount: number
+  isCapped: boolean
+  fetchedAt: number | null
+  error: string | null
+  isLoading: boolean
+}
+
 declare module 'claude-code' {
   interface PluginState {
     trailhead: {
       workState: WorkState | null
       isOrphaned: boolean
+      // The ticket this session works, kept when another session's state takes over the shared file.
+      ownTicket: number | null
       promptSnapshot: PromptSnapshot | null
       mapPane: MapPaneData
       activeMap: number | null
       // The map the pane shows when it is not the active one; null follows the active map.
       viewedMap: number | null
+      // The pane shows the dashboard (maps index + whiteboard) instead of a map.
+      isDashboard: boolean
+      dashboardPane: DashboardPaneData
       pendingWork: number | null
       paneAutoOpened: boolean
     }