@marcomigozzi/trailhead 0.14.0 → 0.16.0

package/plugins/trailhead/hooks/mod/map-pane-view.ts

@@ -1,15 +1,18 @@
 // Pure view logic of the map pane: parse what `gh` printed, group the rows, word a
 // failure and an age, decide when a refresh may run. No engine calls here, so it is easy to test.
 import { fit } from './work-state-view'
-import type { BurndownHistory, BurndownIssue, MapInfo, MapSummary, PaneTicket, TicketState, TicketType } from '../../types'
+import type { BurndownHistory, BurndownIssue, DashboardRef, MapCounts, MapInfo, MapsRead, MapSummary, OpenTotal, PaneTicket, TicketState, TicketType, UatParent } from '../../types'
 
 export const TICKET_TYPES: readonly TicketType[] = ['decision', 'research', 'prototype', 'build', 'bug', 'task']
 
 // `isCapped`: gh returned as many rows as it was asked for, so the list may be cut.
 export type ParsedTickets = { tickets: readonly PaneTicket[]; unverifiedCount: number; isCapped: boolean }
 export type TicketGroups = {
+  needsYou: readonly PaneTicket[]
   frontier: readonly PaneTicket[]
   inProgress: readonly PaneTicket[]
+  uat: readonly PaneTicket[]
+  paused: readonly PaneTicket[]
   blocked: readonly PaneTicket[]
 }
 export type Failure = { error: unknown } | { exitCode: number; stderr: string }
@@ -53,27 +56,29 @@ const typeOf = (names: readonly string[]): TicketType | null => {
   return found === undefined ? null : (found.slice(LABEL_PREFIX.length) as TicketType)
 }
 
+// A paused label wins over blocked and in-progress: the ticket shows once, under Paused.
 const stateOf = (names: readonly string[], assignees: readonly string[]): TicketState =>
-  names.includes(`${LABEL_PREFIX}blocked`) ? 'blocked' : assignees.length > 0 ? 'in-progress' : 'frontier'
+  names.includes(`${LABEL_PREFIX}paused`)
+    ? 'paused'
+    : names.includes(`${LABEL_PREFIX}blocked`)
+      ? 'blocked'
+      : assignees.length > 0
+        ? 'in-progress'
+        : 'frontier'
 
 // Only an https link is kept; anything else would be drawn as plain text.
 const safeUrl = (raw: unknown): string => (typeof raw === 'string' && /^https:\/\//.test(raw) ? raw : '')
 
-// `gh issue list --json number,title,labels,assignees,url`. Unverified rows are
-// quarantined (counted, never listed); whiteboard rows do not belong to a map.
-export const parseTickets = (stdout: string): ParsedTickets | null => {
-  let raw: unknown
-  try {
-    raw = JSON.parse(stdout)
-  } catch {
-    return null
-  }
-  if (!Array.isArray(raw)) return null
+// The rows of an open-ticket list (the `gh issue list --json number,title,labels,assignees,url` shape).
+// Unverified rows are quarantined (counted, never listed); whiteboard rows do not belong to a map, and on the
+// whiteboard (`isWhiteboard`) only they are kept. A list that reached LIST_LIMIT rows is capped.
+export const ticketsFromRows = (raw: readonly unknown[], opts: { isWhiteboard?: boolean } = {}): ParsedTickets => {
   const rows = raw.filter(isRecord).filter(r => isPosInt(r.number))
   const named = rows.map(r => ({ r, names: labelNames(r.labels) }))
   const unverifiedCount = named.filter(({ names }) => names.includes(`${LABEL_PREFIX}unverified`)).length
   const tickets = named
-    .filter(({ names }) => !names.includes(`${LABEL_PREFIX}unverified`) && !names.includes(`${LABEL_PREFIX}whiteboard`))
+    .filter(({ names }) => !names.includes(`${LABEL_PREFIX}unverified`))
+    .filter(({ names }) => names.includes(`${LABEL_PREFIX}whiteboard`) === (opts.isWhiteboard === true))
     .map(({ r, names }): PaneTicket => {
       const assignees = logins(r.assignees)
       return {
@@ -83,11 +88,100 @@ export const parseTickets = (stdout: string): ParsedTickets | null => {
         state: stateOf(names, assignees),
         assignees,
         url: safeUrl(r.url),
+        isUat: names.includes(`${LABEL_PREFIX}uat`),
+        isNeedsYou: names.includes(`${LABEL_PREFIX}needs-you`),
+        uatOf: null,
       }
     })
   return { tickets, unverifiedCount, isCapped: raw.length >= LIST_LIMIT }
 }
 
+// `gh issue list --json ...` output as a ticket list; not a list is unreadable (null).
+export const parseTickets = (stdout: string, opts: { isWhiteboard?: boolean } = {}): ParsedTickets | null => {
+  let raw: unknown
+  try {
+    raw = JSON.parse(stdout)
+  } catch {
+    return null
+  }
+  return Array.isArray(raw) ? ticketsFromRows(raw, opts) : null
+}
+
+// The rows that carry `name`: a GraphQL `labels:` filter is any-of, so an AND of two labels is done here.
+export const withLabel = (rows: readonly unknown[], name: string): unknown[] =>
+  rows.filter(r => isRecord(r) && labelNames(r.labels).includes(name))
+
+export type IssuesPage = { rows: unknown[]; hasNextPage: boolean; endCursor: string | null }
+
+// One page of the GraphQL open-ticket read (`repository.issues(...){nodes{...}pageInfo{...}}`), its nodes
+// flattened to the rows `gh issue list --json` prints so one parser serves both (`body` rides along only when
+// the node has a string one, so the ticket rows keep their shape). Any `errors` (even beside
+// partial `data`), a missing page info or a next page without a cursor is unreadable: the caller decides (`readOpen` falls back to
+// `gh issue list`, `readUat` fails closed to null).
+export const parseIssuesPage = (stdout: string): IssuesPage | null => {
+  let raw: unknown
+  try {
+    raw = JSON.parse(stdout)
+  } catch {
+    return null
+  }
+  if (!isRecord(raw) || 'errors' in raw || !isRecord(raw.data) || !isRecord(raw.data.repository)) return null
+  const issues = raw.data.repository.issues
+  if (!isRecord(issues) || !Array.isArray(issues.nodes) || !isRecord(issues.pageInfo)) return null
+  const { hasNextPage, endCursor } = issues.pageInfo
+  if (typeof hasNextPage !== 'boolean') return null
+  if (hasNextPage && (typeof endCursor !== 'string' || endCursor === '')) return null
+  const inner = (v: unknown) => (isRecord(v) && Array.isArray(v.nodes) ? v.nodes : [])
+  const rows = issues.nodes.filter(isRecord).map(n => ({
+    number: n.number,
+    title: n.title,
+    url: n.url,
+    labels: inner(n.labels),
+    assignees: inner(n.assignees),
+    ...(typeof n.body === 'string' ? { body: n.body } : {}),
+  }))
+  return { rows, hasNextPage, endCursor: hasNextPage ? (endCursor as string) : null }
+}
+
+// The open `trailhead:uat` rows of the GraphQL read, as JSON (`number` and `body`): ticket number -> the parent its first
+// `UAT of:` line names, `[<name>](<url>/issues/<n>)` (or a bare `#<n>`, with an empty title). A row with
+// no such line, or an unreadable one, is skipped; not a list is unreadable (null).
+export const parseUatParents = (stdout: string): ReadonlyMap<number, UatParent> | null => {
+  let raw: unknown
+  try {
+    raw = JSON.parse(stdout)
+  } catch {
+    return null
+  }
+  if (!Array.isArray(raw)) return null
+  const parents = new Map<number, UatParent>()
+  for (const r of raw.filter(isRecord)) {
+    if (!isPosInt(r.number) || typeof r.body !== 'string') continue
+    const line = r.body.split(/\r?\n/).find(l => l.startsWith('UAT of:'))
+    if (line === undefined) continue
+    const pointer = line.slice('UAT of:'.length).trim()
+    const link = /^\[([^\]]*)\]\(https:\/\/[^)\s]*\/issues\/(\d+)[^)]*\)/.exec(pointer)
+    const bare = /^#(\d+)\b/.exec(pointer)
+    const found = link !== null ? { number: Number(link[2]), title: flatten(link[1] as string) } : bare !== null ? { number: Number(bare[1]), title: '' } : null
+    if (found !== null && isPosInt(found.number)) parents.set(r.number, found)
+  }
+  return parents
+}
+
+// The tickets with the parent of each UAT one; a missing read leaves them as they are.
+export const withUatParents = (tickets: readonly PaneTicket[], parents: ReadonlyMap<number, UatParent> | null): readonly PaneTicket[] =>
+  parents === null ? tickets : tickets.map(t => (t.isUat ? { ...t, uatOf: parents.get(t.number) ?? null } : t))
+
+// The dim line under a UAT row, `tests <parent title> #<n>`, cut to the pane width; null without a parent.
+export const uatParentLine = (t: PaneTicket, columns: number): string | null => {
+  if (t.uatOf === null) return null
+  const suffix = ` #${t.uatOf.number}`
+  const prefix = 'tests'
+  if (t.uatOf.title === '') return fit(`${prefix}${suffix}`, columns)
+  const title = fit(t.uatOf.title, columns - prefix.length - 1 - suffix.length)
+  return `${prefix} ${title}${suffix}`
+}
+
 // Markdown emphasis, code ticks and links reduced to their text.
 const stripMarkdown = (line: string): string =>
   line
@@ -136,8 +230,119 @@ export const parseMaps = (stdout: string): readonly MapSummary[] | null => {
   return raw
     .filter(isRecord)
     .filter(r => isPosInt(r.number))
-    .map((r): MapSummary => ({ number: r.number as number, title: typeof r.title === 'string' ? flatten(r.title) : '' }))
+    .map((r): MapSummary => ({ number: r.number as number, title: typeof r.title === 'string' ? flatten(r.title) : '', counts: null }))
+    .sort((a, b) => a.number - b.number)
+}
+
+const countsOf = (raw: unknown): MapCounts | null => {
+  if (!isRecord(raw)) return null
+  const { total, completed } = raw
+  if (!Number.isInteger(total) || !Number.isInteger(completed) || (total as number) < 0 || (completed as number) < 0) return null
+  return { open: Math.max(0, (total as number) - (completed as number)), total: total as number }
+}
+
+// A GraphQL `totalCount` as a count, else null.
+const totalOf = (raw: unknown): number | null =>
+  isRecord(raw) && Number.isInteger(raw.totalCount) && (raw.totalCount as number) >= 0 ? (raw.totalCount as number) : null
+
+// The whiteboard's open and total tickets; unusable (missing, negative, open above total) is unknown.
+const whiteboardOf = (repo: Record<string, unknown>): MapCounts | null => {
+  const open = totalOf(repo.whiteboardOpen)
+  const total = totalOf(repo.whiteboardAll)
+  return open === null || total === null || open > total ? null : { open, total }
+}
+
+// The GraphQL reply of the maps read: the open maps with their sub-issue counts, same row rules as
+// `parseMaps`, and the whiteboard's counts. A malformed summary keeps the row name-only; unusable
+// whiteboard fields leave only `whiteboard` null. Not that shape, or any `errors` (even next to
+// partial `data`), is unreadable: the caller falls back to the name-only list.
+export const parseMapsRead = (stdout: string): MapsRead | null => {
+  let raw: unknown
+  try {
+    raw = JSON.parse(stdout)
+  } catch {
+    return null
+  }
+  if (!isRecord(raw) || 'errors' in raw || !isRecord(raw.data)) return null
+  const repo = raw.data.repository
+  const issues = isRecord(repo) ? repo.issues : null
+  const nodes = isRecord(issues) ? issues.nodes : null
+  if (!isRecord(repo) || !Array.isArray(nodes)) return null
+  const maps = nodes
+    .filter(isRecord)
+    .filter(r => isPosInt(r.number))
+    .map(
+      (r): MapSummary => ({
+        number: r.number as number,
+        title: typeof r.title === 'string' ? flatten(r.title) : '',
+        counts: countsOf(r.subIssuesSummary),
+      }),
+    )
     .sort((a, b) => a.number - b.number)
+  return { maps, whiteboard: whiteboardOf(repo), isMapsCapped: isCappedBy(issues, nodes.length) }
+}
+
+// More open maps exist than the read returned (`totalCount` above the nodes read); without a usable
+// `totalCount` a read that filled MAPS_READ_LIMIT is taken as cut.
+const isCappedBy = (issues: Record<string, unknown>, read: number): boolean => {
+  const count = totalOf(issues)
+  return count === null ? read >= MAPS_READ_LIMIT : count > read
+}
+
+// The most open maps one maps read asks for.
+export const MAPS_READ_LIMIT = 100
+
+// One query counting the open tickets of every open map and of the whiteboard: the dashboard's own scopes
+// (a ticket carries one map label or the whiteboard label, never both, so nothing counts twice).
+export const openTotalQuery = (maps: readonly number[]): string => {
+  const scope = (alias: string, label: string) => `${alias}:issues(states:OPEN,labels:["${label}"]){totalCount}`
+  const fields = [...maps.map(n => scope(`m${n}`, `${LABEL_PREFIX}map-${n}`)), scope('wb', `${LABEL_PREFIX}whiteboard`)]
+  return `query($owner:String!,$repo:String!){repository(owner:$owner,name:$repo){${fields.join('')}}}`
+}
+
+// The sum of every alias of `openTotalQuery`; any `errors`, a missing alias or an unusable count is
+// unreadable (null), never a partial sum shown as exact.
+export const parseOpenTotal = (stdout: string, maps: readonly number[]): number | null => {
+  let raw: unknown
+  try {
+    raw = JSON.parse(stdout)
+  } catch {
+    return null
+  }
+  if (!isRecord(raw) || 'errors' in raw || !isRecord(raw.data) || !isRecord(raw.data.repository)) return null
+  const repo = raw.data.repository
+  const counts = [...maps.map(n => totalOf(repo[`m${n}`])), totalOf(repo.wb)]
+  return counts.some(c => c === null) ? null : counts.reduce((sum: number, c) => sum + (c as number), 0)
+}
+
+// The last good total, kept through a failed count read only while it was computed over exactly these open
+// maps (and the same cut of the maps read); a changed map set hides it rather than show it stale.
+export const keepOpenTotal = (kept: OpenTotal | null, maps: readonly number[], isMapsCapped: boolean): OpenTotal | null =>
+  kept !== null && kept.isMapsCapped === isMapsCapped && kept.maps.length === maps.length && kept.maps.every((n, i) => n === maps[i]) ? kept : null
+
+// The line of the total, long form first, the short one when that does not fit, null when unknown or when
+// not even the short one fits. A truncated maps read is a lower bound, worded as one.
+export const openTotalLabel = (total: number | null, isCapped: boolean, columns: number): string | null => {
+  if (total === null) return null
+  const long = `${isCapped ? 'at least ' : ''}${total} open across all maps + whiteboard`
+  if (long.length <= columns) return long
+  const short = `${isCapped ? '≥' : ''}${total} open in total`
+  return short.length <= columns ? short : null
+}
+
+// `gh issue list --label trailhead:dashboard --json number,url`: the pinned index, the lowest number
+// when there are several. `null` when unreadable; `{ ref: null }` when the repo has none yet.
+export const parseDashboard = (stdout: string): { ref: DashboardRef | null } | null => {
+  let raw: unknown
+  try {
+    raw = JSON.parse(stdout)
+  } catch {
+    return null
+  }
+  if (!Array.isArray(raw)) return null
+  const rows = raw.filter(isRecord).filter(r => isPosInt(r.number))
+  const first = rows.sort((a, b) => (a.number as number) - (b.number as number))[0]
+  return { ref: first === undefined ? null : { number: first.number as number, url: safeUrl(first.url) } }
 }
 
 // The map the pane draws: the one the person is viewing, else the active one.
@@ -161,17 +366,24 @@ export type MapRowLayout = {
   // Every map but the viewed one: a press shows it (the active one: back to active).
   isPressable: boolean
 }
-export type MapRowContext = { active: number | null; viewed: number | null; columns: number }
+// `isDashboard`: the dashboard is shown, so no map is viewed and every row is pressable.
+export type MapRowContext = { active: number | null; viewed: number | null; columns: number; isDashboard?: boolean }
 
 const ACTIVE_MARK = '● '
-const ACTIVE_ASIDE = ' active'
+const ACTIVE_LABEL = 'active'
+const ASIDE_SEP = ' · '
+
+// `<open> open / <total>`: the counts beside a map or the whiteboard.
+export const countsLabel = (c: MapCounts): string => `${c.open} open / ${c.total}`
 
 // What one row of the maps list draws, cut to the pane width (a pressable row is a Button).
 export const mapRowLayout = (m: MapSummary, ctx: MapRowContext): MapRowLayout => {
   const isActive = m.number === ctx.active
-  const isViewed = m.number === viewTarget(ctx.active, ctx.viewed)
+  const isViewed = ctx.isDashboard !== true && m.number === viewTarget(ctx.active, ctx.viewed)
   const mark = isActive ? ACTIVE_MARK : '  '
-  const aside = isActive ? ACTIVE_ASIDE : null
+  const parts = [m.counts === null ? null : countsLabel(m.counts), isActive ? ACTIVE_LABEL : null]
+  const shown = parts.filter((p): p is string => p !== null)
+  const aside = shown.length === 0 ? null : ` ${shown.join(ASIDE_SEP)}`
   const prefix = `#${m.number}`
   const isPressable = !isViewed
   const room = ctx.columns - mark.length - (aside?.length ?? 0) - (isPressable ? BUTTON_CHROME : 0) - prefix.length - 1
@@ -179,11 +391,34 @@ export const mapRowLayout = (m: MapSummary, ctx: MapRowContext): MapRowLayout =>
   return { mark, label: title === '' ? prefix : `${prefix} ${title}`, aside, isActive, isViewed, isPressable }
 }
 
+export type WhiteboardRowLayout = { mark: string; label: string; aside: string | null }
+const WHITEBOARD_LABEL = 'Whiteboard'
+
+// The Whiteboard row above the maps list: a Button with its counts beside it, name-only when they are
+// unknown or would not fit (the name is kept whole).
+export const whiteboardRowLayout = (counts: MapCounts | null, columns: number): WhiteboardRowLayout => {
+  const mark = '  '
+  const aside = counts === null ? null : ` ${countsLabel(counts)}`
+  const fits = aside !== null && mark.length + BUTTON_CHROME + WHITEBOARD_LABEL.length + aside.length <= columns
+  return { mark, label: WHITEBOARD_LABEL, aside: fits ? aside : null }
+}
+
+// The whiteboard heading with its counts over the listed (trusted) tickets; bare before the first good read.
+export const whiteboardHeading = (tickets: readonly PaneTicket[] | null, isCapped: boolean): string => {
+  if (tickets === null) return 'Whiteboard'
+  const open = isCapped ? `${LIST_LIMIT}+` : String(tickets.length)
+  return `Whiteboard · ${open} open · ${tickets.filter(t => t.assignees.length > 0).length} assigned`
+}
+
 const byNumber = (a: PaneTicket, b: PaneTicket) => a.number - b.number
 
+// Needs-you wins, then paused, then a UAT ticket (whatever its state), then the state: each ticket shows once.
+type Place = TicketState | 'uat' | 'needs-you'
+const placeOf = (t: PaneTicket): Place => (t.isNeedsYou ? 'needs-you' : t.state === 'paused' ? 'paused' : t.isUat ? 'uat' : t.state)
+
 export const groupTickets = (tickets: readonly PaneTicket[]): TicketGroups => {
-  const of = (state: TicketState) => tickets.filter(t => t.state === state).sort(byNumber)
-  return { frontier: of('frontier'), inProgress: of('in-progress'), blocked: of('blocked') }
+  const of = (place: Place) => tickets.filter(t => placeOf(t) === place).sort(byNumber)
+  return { needsYou: of('needs-you'), frontier: of('frontier'), inProgress: of('in-progress'), uat: of('uat'), paused: of('paused'), blocked: of('blocked') }
 }
 
 const errorText = (err: unknown): string => {
@@ -213,6 +448,10 @@ export const refreshDecision = (now: number, lastStartedAt: number | null, minMs
   return waitMs <= 0 ? { run: true } : { run: false, waitMs }
 }
 
+// A host timer dies silently (a refused `clock.after` never fires, a refused `every` period ends the
+// interval): one whose due time is past by more than the grace is held dead and started again.
+export const isTimerLate = (now: number, dueAt: number, graceMs: number): boolean => now - dueAt > graceMs
+
 export const ageLabel = (ms: number): string => {
   if (ms < 5_000) return 'just now'
   if (ms < 60_000) return `${Math.floor(ms / 1_000)}s ago`
@@ -220,7 +459,7 @@ export const ageLabel = (ms: number): string => {
   return `${Math.floor(ms / 3_600_000)}h ago`
 }
 
-export type RowAside = { kind: 'work' | 'queued' | 'holder'; text: string }
+export type RowAside = { kind: 'work' | 'resume' | 'queued' | 'starting' | 'holder' | 'self'; text: string }
 export type RowLayout = {
   mark: string | null
   label: string
@@ -234,6 +473,8 @@ export type RowContext = {
   // True when the group holds the ticket in play: its rows share a two-cell mark column.
   hasMarkColumn: boolean
   pendingWork: number | null
+  // Whether the pending press waits for the turn to end (`queued`) or has been sent (`starting`).
+  pendingPhase: 'queued' | 'starting' | null
   columns: number
 }
 
@@ -242,6 +483,10 @@ const MARK_PAD = '  '
 // A terminal Button draws `[ label ]`.
 const BUTTON_CHROME = 4
 
+// The dashboard header's button back to the map; the title before it gets the rest of the row.
+export const MAP_LABEL = 'map'
+export const headingRoom = (columns: number, label: string): number => Math.max(0, columns - label.length - BUTTON_CHROME - 1)
+
 const REFRESH_LABEL = 'refresh'
 const CLOSE_LABEL = 'close'
 // The gap between the refresh button and the status, and the one kept before the close button.
@@ -257,18 +502,51 @@ export const footerStatus = (status: string, columns: number): FooterStatus => {
   return Array.from(status).length <= room ? { text: status, isInline: true } : { text: fit(status, columns), isInline: false }
 }
 
-const asideOf = (t: PaneTicket, pendingWork: number | null): RowAside | null => {
-  if (t.state === 'frontier') return pendingWork === t.number ? { kind: 'queued', text: 'queued' } : { kind: 'work', text: 'work' }
-  return t.assignees.length === 0 ? null : { kind: 'holder', text: t.assignees.map(a => `@${a}`).join(' ') }
+const SELF_ASIDE: RowAside = { kind: 'self', text: 'this session' }
+
+type Pending = { number: number | null; phase: 'queued' | 'starting' | null }
+// Only a press known to wait for the turn to end is offered a cancel; one sent, or not yet classed, is not.
+const pendingAside = (phase: Pending['phase']): RowAside =>
+  phase === 'queued' ? { kind: 'queued', text: 'queued' } : { kind: 'starting', text: 'starting' }
+
+const holderOf = (t: PaneTicket): RowAside => ({ kind: 'holder', text: t.assignees.map(a => `@${a}`).join(' ') })
+
+// A needs-you row: any holder first (a `work` press would steal the claim), then nothing when blocked,
+// else `work` (never `resume`: the claim clears the mark, resume would not).
+const needsYouAside = (t: PaneTicket, pending: Pending): RowAside | null => {
+  if (t.assignees.length > 0) return holderOf(t)
+  if (t.state === 'blocked') return null
+  return pending.number === t.number ? pendingAside(pending.phase) : { kind: 'work', text: 'work' }
+}
+
+// The ticket in play says `this session`; a needs-you row follows its own rule; otherwise a frontier row has
+// a `work` button, a paused one a `resume` button (the verb checks the claim), and the rest their holder.
+const asideOf = (t: PaneTicket, pending: Pending, isInPlay: boolean): RowAside | null => {
+  if (isInPlay) return SELF_ASIDE
+  if (t.isNeedsYou) return needsYouAside(t, pending)
+  if (t.state === 'frontier' || t.state === 'paused') {
+    if (pending.number === t.number) return pendingAside(pending.phase)
+    return t.state === 'frontier' ? { kind: 'work', text: 'work' } : { kind: 'resume', text: 'resume' }
+  }
+  return t.assignees.length === 0 ? null : holderOf(t)
 }
 
+// The button that takes a queued ticket back out of the queue.
+export const CANCEL_LABEL = 'cancel'
+const CANCEL_WIDTH = CANCEL_LABEL.length + BUTTON_CHROME + 1
+
 const asideWidth = (a: RowAside | null): number =>
-  a === null ? 0 : a.text.length + (a.kind === 'work' ? BUTTON_CHROME : 0) + 1
+  a === null
+    ? 0
+    : a.text.length + (a.kind === 'work' || a.kind === 'resume' ? BUTTON_CHROME : 0) + 1 + (a.kind === 'queued' ? CANCEL_WIDTH : 0)
+
+// The press the panel holds back while a turn runs, and releases when it ends.
+export type HeldPress = { id: number; verb: 'work' | 'resume'; number: number }
 
 // What one row draws, cut to the pane width: mark column, `#n title`, type, right-hand part.
 export const rowLayout = (t: PaneTicket, ctx: RowContext): RowLayout => {
   const mark = ctx.isInPlay ? MARK : ctx.hasMarkColumn ? MARK_PAD : null
-  const aside = asideOf(t, ctx.pendingWork)
+  const aside = asideOf(t, { number: ctx.pendingWork, phase: ctx.pendingPhase }, ctx.isInPlay)
   const type = t.type === null ? null : ` ${t.type}`
   const prefix = `#${t.number}`
   const room = ctx.columns - (mark?.length ?? 0) - asideWidth(aside) - (type?.length ?? 0) - prefix.length - 1