@marcomigozzi/trailhead 0.15.0 → 0.16.0

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

@@ -5,31 +5,40 @@ import {
   axisStart,
   burndownEnd,
   burndownSeries,
+  CANCEL_LABEL,
   countsLabel,
   failureReason,
   footerStatus,
   groupTickets,
   headingRoom,
   HISTORY_LIMIT,
+  isTimerLate,
+  keepOpenTotal,
   mapRowLayout,
   nextViewed,
+  openTotalLabel,
+  openTotalQuery,
   parseActiveMap,
   parseDashboard,
   parseHistory,
+  parseIssuesPage,
   parseMap,
   parseMaps,
   parseMapsRead,
+  parseOpenTotal,
   parseTickets,
   parseUatParents,
   rasterCells,
   refreshDecision,
   rowLayout,
   sparkline,
+  ticketsFromRows,
   uatParentLine,
   viewTarget,
   withUatParents,
   whiteboardHeading,
   whiteboardRowLayout,
+  withLabel,
 } from '../hooks/mod/map-pane-view'
 
 const issue = (over: Record<string, unknown> = {}) => ({
@@ -66,10 +75,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', 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 },
+    { number: 209, title: 'Burn-down view', type: 'build', state: 'frontier', assignees: [], url: 'https://github.com/o/r/issues/209', isUat: false, isNeedsYou: false, uatOf: null },
+    { number: 212, title: 'Held', type: 'research', state: 'in-progress', assignees: ['alice'], url: 'https://github.com/o/r/issues/209', isUat: false, isNeedsYou: false, uatOf: null },
+    { number: 211, title: 'Gated', type: 'bug', state: 'blocked', assignees: ['bob'], url: 'https://github.com/o/r/issues/209', isUat: false, isNeedsYou: false, uatOf: null },
+    { number: 214, title: 'No type', type: null, state: 'frontier', assignees: [], url: 'https://github.com/o/r/issues/209', isUat: false, isNeedsYou: false, uatOf: null },
   ])
 })
 
@@ -185,6 +194,15 @@ test('parseTickets sets isUat from the trailhead:uat label, with no parent yet',
   expect(t('trailhead:seed', 'trailhead:blocked', 'trailhead:uat')).toMatchObject({ isUat: true, state: 'blocked' })
 })
 
+test('parseTickets sets isNeedsYou from the trailhead:needs-you label and keeps the state', () => {
+  const t = (names: string[], assignees: { login: string }[] = []) => parseTickets(list(issue({ labels: labels(...names), assignees })))?.tickets[0]
+  expect(t(['trailhead:task', 'trailhead:needs-you'])).toMatchObject({ isNeedsYou: true, state: 'frontier' })
+  expect(t(['trailhead:task', 'trailhead:needs-you', 'trailhead:paused'])).toMatchObject({ isNeedsYou: true, state: 'paused' })
+  expect(t(['trailhead:task', 'trailhead:needs-you', 'trailhead:blocked'])).toMatchObject({ isNeedsYou: true, state: 'blocked' })
+  expect(t(['trailhead:task', 'trailhead:needs-you'], [{ login: 'alice' }])).toMatchObject({ isNeedsYou: true, state: 'in-progress' })
+  expect(t(['trailhead:task'])).toMatchObject({ isNeedsYou: false })
+})
+
 const body = (text: string, number = 5) => ({ number, body: text })
 const uatList = (...rows: unknown[]) => JSON.stringify(rows)
 
@@ -219,7 +237,7 @@ test('parseUatParents is null on non-JSON or a non-list', () => {
 })
 
 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 t = (number: number, isUat: boolean) => ({ number, title: '', type: null, state: 'frontier' as const, assignees: [], url: '', isUat, isNeedsYou: false, 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])
@@ -228,7 +246,7 @@ test('withUatParents sets the parent on a UAT ticket only, and leaves the ticket
 })
 
 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 })
+  const t = (uatOf: { number: number; title: string } | null) => ({ number: 1, title: '', type: null, state: 'frontier' as const, assignees: [], url: '', isUat: true, isNeedsYou: false, 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')
@@ -239,7 +257,7 @@ test('uatParentLine draws tests <title> #<n>, fitted to the width, and nothing w
 
 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,
+    number, title: '', type: null, state, assignees: [], url: '', isUat, isNeedsYou: false, 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])
@@ -247,6 +265,19 @@ test('groupTickets lists a UAT ticket once, under UAT, ascending; a paused one s
   expect([g.frontier, g.inProgress, g.blocked].map(x => x.map(y => y.number))).toEqual([[2], [], [3]])
 })
 
+test('groupTickets lists a needs-you ticket once, under Needs you, ascending, whatever its state', () => {
+  const t = (number: number, state: 'frontier' | 'in-progress' | 'blocked' | 'paused', over: Record<string, unknown> = {}) => ({
+    number, title: '', type: null, state, assignees: [], url: '', isUat: false, isNeedsYou: true, uatOf: null, ...over,
+  })
+  const g = groupTickets([
+    t(9, 'frontier'), t(4, 'blocked'), t(6, 'in-progress', { assignees: ['alice'] }), t(7, 'paused'), t(8, 'frontier', { isUat: true }),
+    t(2, 'frontier', { isNeedsYou: false }), t(3, 'blocked', { isNeedsYou: false }),
+  ])
+  expect(g.needsYou.map(x => x.number)).toEqual([4, 6, 7, 8, 9])
+  expect([g.frontier, g.inProgress, g.uat, g.paused, g.blocked].map(x => x.map(y => y.number))).toEqual([[2], [], [], [], [3]])
+  expect(groupTickets([t(1, 'frontier', { isNeedsYou: false })]).needsYou).toEqual([])
+})
+
 test('failureReason names one short cause', () => {
   expect(failureReason({ error: Object.assign(new Error('spawn gh ENOENT'), { code: 'ENOENT' }) })).toBe('gh not installed')
   expect(failureReason({ error: new Error('spawn gh ENOENT') })).toBe('gh not installed')
@@ -270,6 +301,16 @@ test('refreshDecision runs now outside the floor and waits the remainder inside
   expect(refreshDecision(500, 1000, 15000)).toEqual({ run: false, waitMs: 15000 })
 })
 
+test('isTimerLate holds a timer dead only once its due time is past by more than the grace', () => {
+  // in time, or late within the grace: still alive
+  expect(isTimerLate(1000, 5000, 2000)).toBe(false)
+  expect(isTimerLate(7000, 5000, 2000)).toBe(false)
+  // past the grace: the host dropped it (a refused dispatch never fires)
+  expect(isTimerLate(7001, 5000, 2000)).toBe(true)
+  // a clock that moved back never makes a timer late
+  expect(isTimerLate(0, 5000, 2000)).toBe(false)
+})
+
 test('ageLabel reads just now, seconds, minutes, hours', () => {
   expect(ageLabel(0)).toBe('just now')
   expect(ageLabel(-5)).toBe('just now')
@@ -289,10 +330,11 @@ const ticket = (over: Record<string, unknown> = {}) => ({
   state: 'frontier' as const,
   assignees: [] as string[],
   url: 'https://github.com/o/r/issues/209',
+  isNeedsYou: false,
   ...over,
 })
 const layout = (t: ReturnType<typeof ticket>, over: Record<string, unknown> = {}) =>
-  rowLayout(t, { isInPlay: false, hasMarkColumn: false, pendingWork: null, columns: 60, ...over })
+  rowLayout(t, { isInPlay: false, hasMarkColumn: false, pendingWork: null, pendingPhase: null, columns: 60, ...over })
 
 test('rowLayout: a frontier row carries the work button, the number, the title and the type', () => {
   expect(layout(ticket())).toEqual({
@@ -306,10 +348,38 @@ test('rowLayout: a frontier row carries the work button, the number, the title a
 })
 
 test('rowLayout: the pending ticket shows queued in place of the button', () => {
-  expect(layout(ticket(), { pendingWork: 209 }).aside).toEqual({ kind: 'queued', text: 'queued' })
+  expect(layout(ticket(), { pendingWork: 209, pendingPhase: 'queued' }).aside).toEqual({ kind: 'queued', text: 'queued' })
   expect(layout(ticket(), { pendingWork: 210 }).aside).toEqual({ kind: 'work', text: 'work' })
 })
 
+test('rowLayout: the queued aside counts the cancel button in the row width', () => {
+  const t = ticket({ title: 'x'.repeat(200) })
+  for (const columns of [30, 40, 60]) {
+    const r = layout(t, { columns, pendingWork: 209, pendingPhase: 'queued' })
+    const used = (r.mark?.length ?? 0) + r.label.length + (r.type?.length ?? 0) + (r.aside?.text.length ?? 0) + 1 + CANCEL_LABEL.length + 4 + 1
+    expect(used).toBeLessThanOrEqual(columns)
+    // Less title room than the work button leaves.
+    expect(r.label.length).toBeLessThan(layout(t, { columns }).label.length)
+  }
+})
+
+test('rowLayout: a starting row reads starting with no button room', () => {
+  expect(layout(ticket(), { pendingWork: 209, pendingPhase: 'starting' }).aside).toEqual({ kind: 'starting', text: 'starting' })
+  expect(layout(ticket(), { pendingWork: 209, pendingPhase: 'queued' }).aside).toEqual({ kind: 'queued', text: 'queued' })
+  // a pending press with no phase yet is never offered a cancel
+  expect(layout(ticket(), { pendingWork: 209, pendingPhase: null }).aside).toEqual({ kind: 'starting', text: 'starting' })
+  // another ticket's phase never touches this row
+  expect(layout(ticket(), { pendingWork: 210, pendingPhase: 'starting' }).aside).toEqual({ kind: 'work', text: 'work' })
+  const t = ticket({ title: 'x'.repeat(200) })
+  for (const columns of [30, 40, 60]) {
+    const r = layout(t, { columns, pendingWork: 209, pendingPhase: 'starting' })
+    const used = (r.mark?.length ?? 0) + r.label.length + (r.type?.length ?? 0) + (r.aside?.text.length ?? 0) + 1
+    expect(used).toBeLessThanOrEqual(columns)
+    // No cancel button to make room for: more title than the queued row keeps.
+    expect(r.label.length).toBeGreaterThan(layout(t, { columns, pendingWork: 209, pendingPhase: 'queued' }).label.length)
+  }
+})
+
 test('rowLayout: holders are drawn as @login on in-progress and blocked rows', () => {
   expect(layout(ticket({ state: 'in-progress', assignees: ['alice'] })).aside).toEqual({ kind: 'holder', text: '@alice' })
   expect(layout(ticket({ state: 'in-progress', assignees: ['alice', 'bob'] })).aside).toEqual({ kind: 'holder', text: '@alice @bob' })
@@ -321,13 +391,58 @@ 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()
+const needsYou = (over: Record<string, unknown> = {}) => ticket({ isNeedsYou: true, ...over })
+
+test('rowLayout: a needs-you row without a holder has a work button, a paused one too, never resume', () => {
+  expect(layout(needsYou()).aside).toEqual({ kind: 'work', text: 'work' })
+  expect(layout(needsYou({ state: 'paused' })).aside).toEqual({ kind: 'work', text: 'work' })
+})
+
+test('rowLayout: a needs-you row with any holder shows the holder, never a button', () => {
+  const holder = { kind: 'holder', text: '@alice' }
+  expect(layout(needsYou({ state: 'paused', assignees: ['alice'] })).aside).toEqual(holder)
+  expect(layout(needsYou({ state: 'blocked', assignees: ['alice'] })).aside).toEqual(holder)
+  expect(layout(needsYou({ state: 'in-progress', assignees: ['alice'] })).aside).toEqual(holder)
+  // a press pending does not turn a held row into a button either
+  expect(layout(needsYou({ state: 'paused', assignees: ['alice'] }), { pendingWork: 209 }).aside).toEqual(holder)
+})
+
+test('rowLayout: a needs-you row blocked with no holder shows nothing and is dim', () => {
+  const row = layout(needsYou({ state: 'blocked' }))
+  expect(row.aside).toBeNull()
+  expect(row.isDim).toBe(true)
+})
+
+test('rowLayout: a needs-you row shows queued while its press is pending and this session in play', () => {
+  expect(layout(needsYou(), { pendingWork: 209, pendingPhase: 'queued' }).aside).toEqual({ kind: 'queued', text: 'queued' })
+  expect(layout(needsYou({ state: 'paused' }), { pendingWork: 209, pendingPhase: 'queued' }).aside).toEqual({ kind: 'queued', text: 'queued' })
+  expect(layout(needsYou({ state: 'in-progress', assignees: ['alice'] }), { isInPlay: true }).aside).toEqual({ kind: 'self', text: 'this session' })
+})
+
+test('rowLayout: a paused row has a resume button, whoever holds it', () => {
+  expect(layout(ticket({ state: 'paused', assignees: ['alice'] })).aside).toEqual({ kind: 'resume', text: 'resume' })
+  expect(layout(ticket({ state: 'paused' })).aside).toEqual({ kind: 'resume', text: 'resume' })
   expect(layout(ticket({ state: 'paused' })).isDim).toBe(false)
 })
 
+test('rowLayout: a paused row reads queued while its press is pending', () => {
+  expect(layout(ticket({ number: 209, state: 'paused' }), { pendingWork: 209, pendingPhase: 'queued' }).aside).toEqual({ kind: 'queued', text: 'queued' })
+  expect(layout(ticket({ number: 209, state: 'paused' }), { pendingWork: 7 }).aside).toEqual({ kind: 'resume', text: 'resume' })
+})
+
+test('rowLayout: a paused ticket in play keeps this session', () => {
+  expect(layout(ticket({ state: 'paused', assignees: ['me'] }), { isInPlay: true, hasMarkColumn: true }).aside).toEqual({ kind: 'self', text: 'this session' })
+})
+
+test('rowLayout: the resume button chrome is counted in the row width', () => {
+  const t = ticket({ title: 'x'.repeat(200), state: 'paused' })
+  for (const columns of [30, 40, 60]) {
+    const r = layout(t, { columns })
+    const used = (r.mark?.length ?? 0) + r.label.length + (r.type?.length ?? 0) + (r.aside?.text.length ?? 0) + 4 + 1
+    expect(used).toBeLessThanOrEqual(columns)
+  }
+})
+
 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' })
@@ -665,7 +780,11 @@ test('parseMapsRead gives a null whiteboard, maps intact, when its fields are mi
     { 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 })
+    expect(parseMapsRead(gql([node], {}, repo))).toEqual({
+      maps: [{ number: 1, title: 'a', counts: { open: 3, total: 4 } }],
+      whiteboard: null,
+      isMapsCapped: false,
+    })
   }
 })
 
@@ -682,6 +801,101 @@ test('parseMapsRead is null on anything but a clean reply', () => {
   expect(parseMapsRead(gql([node], { errors: [{ message: 'partial' }] }))).toBeNull()
 })
 
+// A maps connection with a `totalCount` beside its nodes, as the maps read asks for.
+const gqlTotal = (nodes: unknown[], totalCount: unknown) =>
+  JSON.stringify({ data: { repository: { issues: { nodes, totalCount }, ...WB_FIELDS } } })
+const mapNodes = (n: number) => Array.from({ length: n }, (_, i) => ({ number: i + 1, title: `m${i + 1}`, subIssuesSummary: { total: 1, completed: 0 } }))
+
+test('parseMapsRead marks the maps read capped only when more open maps exist than were read', () => {
+  expect(parseMapsRead(gqlTotal(mapNodes(3), 3))?.isMapsCapped).toBe(false)
+  expect(parseMapsRead(gqlTotal(mapNodes(3), 4))?.isMapsCapped).toBe(true)
+  // exactly the limit, with no more behind it, is not capped
+  expect(parseMapsRead(gqlTotal(mapNodes(100), 100))?.isMapsCapped).toBe(false)
+  expect(parseMapsRead(gqlTotal(mapNodes(100), 101))?.isMapsCapped).toBe(true)
+})
+
+test('parseMapsRead without a usable totalCount falls back to the read limit', () => {
+  expect(parseMapsRead(gqlTotal(mapNodes(3), undefined))?.isMapsCapped).toBe(false)
+  expect(parseMapsRead(gqlTotal(mapNodes(100), undefined))?.isMapsCapped).toBe(true)
+  expect(parseMapsRead(gqlTotal(mapNodes(100), 'x'))?.isMapsCapped).toBe(true)
+})
+
+test('openTotalQuery counts the open tickets of each map and the whiteboard in one query', () => {
+  const q = openTotalQuery([3, 198])
+  expect(q).toContain('query($owner:String!,$repo:String!)')
+  expect(q).toContain('repository(owner:$owner,name:$repo)')
+  expect(q).toContain('m3:issues(states:OPEN,labels:["trailhead:map-3"]){totalCount}')
+  expect(q).toContain('m198:issues(states:OPEN,labels:["trailhead:map-198"]){totalCount}')
+  expect(q).toContain('wb:issues(states:OPEN,labels:["trailhead:whiteboard"]){totalCount}')
+})
+
+test('openTotalQuery with no open map still counts the whiteboard', () => {
+  const q = openTotalQuery([])
+  expect(q).toContain('wb:issues(states:OPEN,labels:["trailhead:whiteboard"]){totalCount}')
+  expect(q).not.toContain('trailhead:map-')
+})
+
+const totals = (counts: Record<string, unknown>) =>
+  JSON.stringify({ data: { repository: Object.fromEntries(Object.entries(counts).map(([k, v]) => [k, { totalCount: v }])) } })
+
+test('parseOpenTotal sums every map alias and the whiteboard', () => {
+  expect(parseOpenTotal(totals({ m3: 4, m198: 7, wb: 2 }), [3, 198])).toBe(13)
+  expect(parseOpenTotal(totals({ wb: 0 }), [])).toBe(0)
+  expect(parseOpenTotal(totals({ m3: 0, wb: 5 }), [3])).toBe(5)
+})
+
+test('parseOpenTotal is null on errors, a missing alias or a bad count (never a partial sum)', () => {
+  const ok = { m3: 4, wb: 2 }
+  expect(parseOpenTotal(totals(ok), [3])).toBe(6)
+  expect(parseOpenTotal('not json', [3])).toBeNull()
+  expect(parseOpenTotal('[]', [3])).toBeNull()
+  expect(parseOpenTotal('{"data":null}', [3])).toBeNull()
+  expect(parseOpenTotal('{"data":{"repository":null}}', [3])).toBeNull()
+  expect(parseOpenTotal(JSON.stringify({ errors: [{ message: 'boom' }] }), [3])).toBeNull()
+  expect(parseOpenTotal(JSON.stringify({ ...JSON.parse(totals(ok)), errors: [{ message: 'partial' }] }), [3])).toBeNull()
+  // a map alias or the whiteboard missing
+  expect(parseOpenTotal(totals({ wb: 2 }), [3])).toBeNull()
+  expect(parseOpenTotal(totals({ m3: 4 }), [3])).toBeNull()
+  expect(parseOpenTotal(totals({ m3: 4, wb: 2 }), [3, 198])).toBeNull()
+  // negative, fractional, textual, null counts
+  for (const bad of [-1, 1.5, '4', null]) expect(parseOpenTotal(totals({ m3: bad, wb: 2 }), [3])).toBeNull()
+})
+
+test('keepOpenTotal keeps the last total only over the same maps and the same cut', () => {
+  const kept = { total: 10, maps: [14, 198], isMapsCapped: false }
+  expect(keepOpenTotal(kept, [14, 198], false)).toBe(kept)
+  expect(keepOpenTotal(kept, [14], false)).toBeNull()
+  expect(keepOpenTotal(kept, [14, 198, 300], false)).toBeNull()
+  expect(keepOpenTotal(kept, [14, 199], false)).toBeNull()
+  expect(keepOpenTotal(kept, [14, 198], true)).toBeNull()
+  expect(keepOpenTotal(null, [14, 198], false)).toBeNull()
+  expect(keepOpenTotal({ total: 3, maps: [], isMapsCapped: false }, [], false)).toEqual({ total: 3, maps: [], isMapsCapped: false })
+})
+
+test('openTotalLabel words the total across all maps and the whiteboard', () => {
+  expect(openTotalLabel(13, false, 80)).toBe('13 open across all maps + whiteboard')
+  expect(openTotalLabel(0, false, 80)).toBe('0 open across all maps + whiteboard')
+})
+
+test('openTotalLabel words a truncated maps read as a lower bound', () => {
+  expect(openTotalLabel(13, true, 80)).toBe('at least 13 open across all maps + whiteboard')
+  expect(openTotalLabel(13, true, 20)).toBe('≥13 open in total')
+})
+
+test('openTotalLabel shortens when the long form does not fit, then gives up', () => {
+  const long = '13 open across all maps + whiteboard'
+  expect(openTotalLabel(13, false, long.length)).toBe(long)
+  expect(openTotalLabel(13, false, long.length - 1)).toBe('13 open in total')
+  expect(openTotalLabel(13, false, '13 open in total'.length)).toBe('13 open in total')
+  expect(openTotalLabel(13, false, '13 open in total'.length - 1)).toBeNull()
+  expect(openTotalLabel(13, true, '≥13 open in total'.length - 1)).toBeNull()
+})
+
+test('openTotalLabel is null when the total is unknown', () => {
+  expect(openTotalLabel(null, false, 80)).toBeNull()
+  expect(openTotalLabel(null, true, 80)).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')
@@ -851,3 +1065,83 @@ test('headingRoom leaves the switch button its cells, never below zero', () => {
   expect(headingRoom(60, 'map')).toBe(52)
   expect(headingRoom(5, 'dashboard')).toBe(0)
 })
+
+// One page of the GraphQL open-ticket read, as `gh api graphql` prints it.
+const node = (number: number, names: string[], logins: string[] = []) => ({
+  number,
+  title: `t${number}`,
+  url: `https://github.com/o/r/issues/${number}`,
+  labels: { nodes: labels(...names) },
+  assignees: { nodes: logins.map(login => ({ login })) },
+})
+const page = (nodes: unknown[], pageInfo: unknown = { hasNextPage: false, endCursor: null }) =>
+  JSON.stringify({ data: { repository: { issues: { nodes, pageInfo } } } })
+
+test('parseIssuesPage flattens the nodes to the rows gh issue list prints, with the page info', () => {
+  const out = parseIssuesPage(page([node(7, ['trailhead:build', 'trailhead:map-1'], ['alice'])], { hasNextPage: true, endCursor: 'abc' }))
+  expect(out).toEqual({
+    rows: [
+      {
+        number: 7,
+        title: 't7',
+        url: 'https://github.com/o/r/issues/7',
+        labels: [{ name: 'trailhead:build' }, { name: 'trailhead:map-1' }],
+        assignees: [{ login: 'alice' }],
+      },
+    ],
+    hasNextPage: true,
+    endCursor: 'abc',
+  })
+  // the flattened rows go through the same parser as a gh list
+  expect(parseTickets(JSON.stringify(out?.rows))?.tickets.map(t => [t.number, t.state])).toEqual([[7, 'in-progress']])
+})
+
+test('parseIssuesPage carries a string body and leaves any other out', () => {
+  const withBody = { ...node(7, ['trailhead:uat']), body: 'UAT of: #3' }
+  const out = parseIssuesPage(page([withBody, node(8, ['trailhead:uat']), { ...node(9, []), body: null }, { ...node(10, []), body: 5 }]))
+  expect(out?.rows[0]).toEqual({
+    number: 7,
+    title: 't7',
+    url: 'https://github.com/o/r/issues/7',
+    labels: [{ name: 'trailhead:uat' }],
+    assignees: [],
+    body: 'UAT of: #3',
+  })
+  expect(out?.rows.slice(1).map(r => 'body' in r)).toEqual([false, false, false])
+})
+
+test('parseIssuesPage is null on anything but a clean page', () => {
+  expect(parseIssuesPage('nope')).toBeNull()
+  expect(parseIssuesPage('[]')).toBeNull()
+  expect(parseIssuesPage(JSON.stringify({ data: { repository: null } }))).toBeNull()
+  expect(parseIssuesPage(JSON.stringify({ data: { repository: { issues: { nodes: {} } } } }))).toBeNull()
+  // errors beside partial data, a missing or malformed pageInfo, a next page with no cursor
+  expect(parseIssuesPage(JSON.stringify({ data: { repository: { issues: { nodes: [], pageInfo: { hasNextPage: false } } } }, errors: [{ message: 'x' }] }))).toBeNull()
+  expect(parseIssuesPage(JSON.stringify({ data: { repository: { issues: { nodes: [] } } } }))).toBeNull()
+  expect(parseIssuesPage(page([], { hasNextPage: 'yes', endCursor: null }))).toBeNull()
+  expect(parseIssuesPage(page([], { hasNextPage: true, endCursor: null }))).toBeNull()
+})
+
+test('parseIssuesPage skips a malformed node and keeps an empty page', () => {
+  expect(parseIssuesPage(page([node(1, []), null, 'x']))?.rows).toHaveLength(1)
+  expect(parseIssuesPage(page([]))).toEqual({ rows: [], hasNextPage: false, endCursor: null })
+})
+
+test('the whiteboard read keeps the rows that carry both labels (GraphQL labels is any-of)', () => {
+  const rows = parseIssuesPage(
+    page([
+      node(1, ['trailhead:whiteboard', 'trailhead:ticket', 'trailhead:bug']),
+      node(2, ['trailhead:whiteboard']),
+      node(3, ['trailhead:whiteboard', 'trailhead:ticket', 'trailhead:unverified']),
+    ]),
+  )?.rows as unknown[]
+  const parsed = ticketsFromRows(withLabel(rows, 'trailhead:ticket'), { isWhiteboard: true })
+  expect(parsed?.tickets.map(t => t.number)).toEqual([1])
+  expect(parsed?.unverifiedCount).toBe(1)
+})
+
+test('ticketsFromRows says capped at the limit, as parseTickets does', () => {
+  const rows = Array.from({ length: 200 }, (_, i) => issue({ number: i + 1 }))
+  expect(ticketsFromRows(rows)?.isCapped).toBe(true)
+  expect(ticketsFromRows(rows.slice(1))?.isCapped).toBe(false)
+})

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

@@ -0,0 +1,51 @@
+import { expect, test } from 'claude-code/testing'
+
+import { GH_ISSUE_WRITE } from '../hooks/mod/map-pane'
+
+// Bash commands the pane refreshes on (a write to the tracker) and ones it must ignore.
+const WRITES = [
+  'gh issue close 5',
+  'gh --repo o/r issue close 5',
+  'gh issue comment 5 -b hi',
+  'gh issue edit 5 --add-label x',
+  'gh issue create -t t',
+  'gh issue reopen 5',
+  'gh issue delete 5',
+  'gh issue transfer 5 o/other',
+  'env GH_HOST=x gh issue close 5',
+  'command gh issue close 5',
+  'cd x && gh issue close 5',
+  'gh api -X POST repos/o/r/issues/198/sub_issues -F sub_issue_id=1',
+  'gh api repos/o/r/issues/198/sub_issues -F sub_issue_id=1',
+  'gh api repos/{owner}/{repo}/issues/5 -f state=closed',
+  'gh api --method=PATCH repos/o/r/issues/5',
+  'gh api --method PATCH repos/o/r/issues/5 -f title=x',
+  'gh api -XDELETE repos/o/r/issues/5/labels/x',
+  'gh api "repos/o/r/issues/5/comments" -f body=hi',
+  "gh api -X PUT 'repos/o/r/issues/5/lock'",
+  'gh api repos/o/r/issues/5 --input body.json',
+  'node /x/templates/trailhead-issue-body.js append --issue 198 --section "Decisions so far" --line x',
+]
+const READS = [
+  'gh issue list --state open',
+  'gh issue view 5',
+  'ls -la',
+  'gh pr close 4',
+  'gh api repos/o/r/issues/5',
+  'gh api repos/o/r/issues --jq length',
+  'gh api -X GET repos/o/r/issues -f labels=x',
+  'gh api --method=GET repos/o/r/issues -F per_page=1',
+  'gh api graphql -f query=query{viewer{login}}',
+  'gh api graphql -F owner={owner} -F repo={repo} -f query=x',
+  'gh api repos/o/r/pulls -f state=open',
+  'git log && echo gh issue',
+  'gh api repos/o/r/issues/5 | jq . ; echo -f x',
+]
+
+test('the write matcher takes the tracker writes of a Bash call', () => {
+  for (const command of WRITES) expect([command, GH_ISSUE_WRITE.test(command)]).toEqual([command, true])
+})
+
+test('the write matcher leaves reads alone', () => {
+  for (const command of READS) expect([command, GH_ISSUE_WRITE.test(command)]).toEqual([command, false])
+})

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

@@ -0,0 +1,77 @@
+import type { On } from 'claude-code'
+import { expect, test } from 'claude-code/testing'
+
+// #299: a session started outside any repo, the repo and `origin` created mid-session. The host's
+// `session.repo()` keeps answering null (observed live on Claude Code 2.1.306), while git in the cwd
+// already answers; the pin the pane reads must follow git.
+const CWD = '/work/new-project'
+const REMOTE = 'https://github.com/o/new-project.git'
+const out = (stdout: string, exitCode = 0) => ({ value: { exitCode, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } })
+
+test('the pin follows a repo created mid-session although session.repo() still answers null', async ($, on) => {
+  const pins: unknown[] = []
+  let isCreated = false
+  on('state.set', { plugin: 'trailhead', key: 'repoPin' }, (_$, e, next) => {
+    pins.push(e.value)
+    return next(e)
+  })
+  on('fs.read', () => ({ deny: 'ENOENT: none' }))
+  on('fs.write', () => ({ value: undefined }))
+  on('ui.status', () => ({ value: undefined }))
+  on('ui.log', () => ({ value: undefined }))
+  on('ui.panes', () => ({ value: [] }))
+  on('session.id', () => ({ value: 's1' }))
+  on('session.cwd', () => ({ value: CWD }))
+  on('session.root', () => ({ value: CWD }))
+  // The host's memoized answer: null from the start, even once the repo exists.
+  on('session.repo', () => ({ value: null }))
+  on('process.run', (_$, e) => {
+    const cmd = e.argv.join(' ')
+    if (cmd === 'git rev-parse --show-toplevel') return isCreated ? out(`${CWD}\n`) : out('', 128)
+    if (cmd === 'git remote get-url origin') return isCreated ? out(`${REMOTE}\n`) : out('', 2)
+    return out('', 1)
+  })
+  on('session.start', (_$, e) => ({ cwd: e.cwd }))
+  on('turn.start', (_$, e) => ({ turnId: e.turnId }))
+  on('turn.complete', () => ({ text: '' }))
+
+  await $.session.start({ cwd: CWD, surface: 'terminal', isInteractive: true })
+  isCreated = true
+  await $.turn.complete({ turnId: 't1', answer: '', durationMs: 1, isAborted: false, reason: 'answer' })
+  expect(pins.at(-1)).toEqual({ root: CWD, host: 'github.com', slug: 'o/new-project' })
+})
+
+test('the git fallback spawns no more than it needs: nothing past a failed rev-parse, one rev-parse per read', async ($, on) => {
+  const spawned: string[] = []
+  let isCreated = false
+  on('state.set', (_$, e, next) => next(e))
+  on('fs.read', () => ({ deny: 'ENOENT: none' }))
+  on('fs.write', () => ({ value: undefined }))
+  on('ui.status', () => ({ value: undefined }))
+  on('ui.log', () => ({ value: undefined }))
+  on('ui.panes', () => ({ value: [] }))
+  on('session.id', () => ({ value: 's1' }))
+  on('session.cwd', () => ({ value: CWD }))
+  on('session.root', () => ({ value: CWD }))
+  on('session.repo', () => ({ value: null }))
+  on('process.run', (_$, e) => {
+    const cmd = e.argv.join(' ')
+    spawned.push(cmd)
+    if (cmd === 'git rev-parse --show-toplevel') return isCreated ? out(`${CWD}\n`) : out('', 128)
+    if (cmd === 'git remote get-url origin') return out(`${REMOTE}\n`)
+    return out('', 1)
+  })
+  on('session.start', (_$, e) => ({ cwd: e.cwd }))
+  on('turn.start', (_$, e) => ({ turnId: e.turnId }))
+  on('turn.complete', () => ({ text: '' }))
+
+  await $.session.start({ cwd: CWD, surface: 'terminal', isInteractive: true })
+  expect(spawned).not.toContain('git remote get-url origin')
+  spawned.length = 0
+  isCreated = true
+  await $.turn.complete({ turnId: 't1', answer: '', durationMs: 1, isAborted: false, reason: 'answer' })
+  // The fallback hands its toplevel back: each read is one rev-parse and one remote lookup, no repeat.
+  const tops = spawned.filter(c => c === 'git rev-parse --show-toplevel').length
+  expect(tops).toBeGreaterThan(0)
+  expect(spawned.filter(c => c === 'git remote get-url origin')).toHaveLength(tops)
+})