@marcomigozzi/trailhead 0.16.1 → 0.18.0

package/plugins/trailhead/hooks/mod/map-pane.tsx

@@ -4,7 +4,7 @@
 import { atom, read, update } from 'claude-code'
 import type { EngineInterface, On } from 'claude-code'
 
-import type { BurndownHistory, DashboardPaneData, MapCounts, MapPaneData, MapsRead, MapSummary, OpenTotal, PaneTicket, RepoPin, UatParent, WorkState } from '../../types'
+import type { BurndownHistory, DashboardPaneData, MapCounts, MapPaneData, MapsRead, MapSummary, MyTicket, OpenTotal, PaneTicket, RepoPin, TicketScope, UatParent, WorkState } from '../../types'
 import {
   ageLabel,
   axisStart,
@@ -48,7 +48,10 @@ import {
   whiteboardRowLayout,
   withLabel,
 } from './map-pane-view'
+import { elsewhereInProgress, myTicketsFromRows, parseLogin, scopeLine } from './my-tickets'
 import { checkoutArg, currentRepo, isPinCheckout, isSamePin, pinKey, pinPath, refreshPin, toplevelOf } from './repo-pin'
+import { gitArgv, scrubGitEnv } from './git-env'
+import { stripHeredocBodies } from './heredoc'
 import { isMainTurnRunning } from './turn-state'
 import { createdIssueNumber, isWhiteboardCreate, nextFollow, whiteboardHint } from './whiteboard-follow'
 import { fit, isMissing, sameValue } from './work-state-view'
@@ -79,6 +82,9 @@ const TICKETS_QUERY = `query($owner:String!,$repo:String!,$label:String!,$after:
 // most UAT_MAX_PAGES pages). The scope is filtered by the caller: GraphQL's `labels` is any-of.
 const UAT_QUERY = `query($owner:String!,$repo:String!,$after:String){repository(owner:$owner,name:$repo){issues(first:${PAGE_SIZE},after:$after,states:OPEN,labels:["trailhead:uat"],orderBy:{field:CREATED_AT,direction:DESC}){nodes{number body labels(first:50){nodes{name}}}pageInfo{hasNextPage endCursor}}}}`
 const UAT_MAX_PAGES = 10
+// The gh account's login, then its open tickets on any map or the whiteboard (paged like TICKETS_QUERY).
+const LOGIN_QUERY = 'query{viewer{login}}'
+const MINE_QUERY = `query($owner:String!,$repo:String!,$login:String!,$after:String){repository(owner:$owner,name:$repo){issues(first:${PAGE_SIZE},after:$after,states:OPEN,labels:["trailhead:ticket"],filterBy:{assignee:$login},orderBy:{field:CREATED_AT,direction:DESC}){nodes{number title url labels(first:50){nodes{name}}assignees(first:10){nodes{login}}}pageInfo{hasNextPage endCursor}}}}`
 const DASHBOARD_FIELDS = 'number,url'
 // Same colours as the band.
 const ACCENT = '#7aa2f7'
@@ -88,6 +94,24 @@ const CHART_ROWS = 3
 // Space between ticket rows on the desktop, whose native buttons would touch; the terminal stays compact.
 const DESKTOP_ROW_GAP = 0.5
 const AMBER = '#e0af68'
+// Ogni sezione ha il suo glifo e colore (palette Tokyo Night del band), così si distinguono anche senza colore.
+const SECTION_STYLES = {
+  maps: { glyph: '◈', color: '#bb9af7' },
+  'in-progress': { glyph: '▶', color: ACCENT },
+  'needs-you': { glyph: '!', color: '#ff9e64' },
+  frontier: { glyph: '◆', color: '#9ece6a' },
+  uat: { glyph: '◎', color: '#7dcfff' },
+  paused: { glyph: '‖', color: '#a9b1d6' },
+  blocked: { glyph: '■', color: '#f7768e' },
+} as const
+type SectionKey = keyof typeof SECTION_STYLES
+// Il filetto a sinistra di ogni riga, nel colore della sezione: occupa GUTTER colonne.
+const GUTTER = '│ '
+// Sul desktop il filetto è una barra continua di questa larghezza, alta quanto tutto il blocco del ticket.
+const GUTTER_BAR = 0.25
+const RULE_COLOR = '#3b4261'
+// Il tipo di ticket colorato; gli altri tipi restano attenuati.
+const TYPE_COLORS: Readonly<Record<string, string>> = { build: '#7dcfff', decision: '#ff9e64' }
 
 const EMPTY: MapPaneData = {
   map: null,
@@ -123,10 +147,13 @@ export const viewedMap = atom({ plugin: 'trailhead', key: 'viewedMap' } as const
 export const isDashboard = atom({ plugin: 'trailhead', key: 'isDashboard' } as const, false)
 export const dashboardPane = atom({ plugin: 'trailhead', key: 'dashboardPane' } as const, EMPTY_DASHBOARD)
 // The ticket whose `work` or `resume` press is queued; one at a time.
+// My open tickets across every map and the whiteboard (the last good read), for every view's In progress group.
+export const myTickets = atom({ plugin: 'trailhead', key: 'myTickets' } as const, [] as readonly MyTicket[])
 export const pendingWork = atom({ plugin: 'trailhead', key: 'pendingWork' } as const, null as number | null)
 // Whether that press waits for the running turn to end (cancellable) or was sent to the host.
 export const pendingPhase = atom({ plugin: 'trailhead', key: 'pendingPhase' } as const, null as 'queued' | 'starting' | null)
-// Set once the pane was opened by the command, by itself or closed by the person: never auto-opened after.
+// Set once the auto-open is done: the pane was seen drawn, or the person acted on it (the command, a close by
+// hand, the close button). An unasked open that stays undrawn does not set it; never auto-opened after it is set.
 export const paneAutoOpened = atom({ plugin: 'trailhead', key: 'paneAutoOpened' } as const, false)
 const PENDING = { plugin: 'trailhead', key: 'pendingWork' } as const
 const WORK_COMMAND = 'trailhead:work'
@@ -207,12 +234,15 @@ async function setPane($: Dollar, next: MapPaneData) {
 type GhResult = { ok: true; stdout: string } | { ok: false; reason: string }
 
 // Always run in the pinned repo, so the session's cwd moving out of it never changes what is read.
+// gh resolves {owner}/{repo} through git, so it gets the same scrubbed env as a git call.
 async function gh($: Dollar, pin: RepoPin, args: readonly string[]): Promise<GhResult> {
   try {
-    const out = await $.process.run(['gh', ...args], { cwd: pin.root, timeoutMs: GH_TIMEOUT_MS })
+    const out = await $.process.run(scrubGitEnv(['gh', ...args]), { cwd: pin.root, timeoutMs: GH_TIMEOUT_MS })
     return out.exitCode === 0 ? { ok: true, stdout: out.stdout } : { ok: false, reason: failureReason(out) }
   } catch (error) {
-    return { ok: false, reason: failureReason({ error }) }
+    // A deleted cwd fails the spawn as ENOENT, the same as a missing binary: look before blaming gh.
+    const missingRoot = (await $.fs.exists(pin.root).catch(() => true)) ? undefined : pin.root
+    return { ok: false, reason: failureReason({ error, missingRoot }) }
   }
 }
 
@@ -249,6 +279,40 @@ const readOpen = async ($: Dollar, pin: RepoPin, label: string, also?: string):
 const readOpenFallback = ($: Dollar, pin: RepoPin, label: string, also?: string) =>
   gh($, pin, ['issue', 'list', ...(also === undefined ? [] : ['--label', also]), '--label', label, '--state', 'open', '--limit', String(LIST_LIMIT), '--json', TICKET_FIELDS])
 
+// The gh login per host, read once: the account does not change under a running session.
+const loginByHost = new Map<string, string>()
+const readLogin = async ($: Dollar, pin: RepoPin): Promise<string | null> => {
+  const known = loginByHost.get(pin.host)
+  if (known !== undefined) return known
+  const out = await gh($, pin, ['api', 'graphql', '-f', `query=${LOGIN_QUERY}`])
+  const login = out.ok ? parseLogin(out.stdout) : null
+  if (login !== null) loginByHost.set(pin.host, login)
+  return login
+}
+
+// My open tickets in the repo, on any open map or the whiteboard. Fail-closed like the UAT read: a login or a page
+// that fails or is unreadable makes the read null, and the last good list stays; never a partial list.
+const readMine = async ($: Dollar, pin: RepoPin): Promise<readonly MyTicket[] | null> => {
+  const login = await readLogin($, pin)
+  if (login === null) return null
+  const rows: unknown[] = []
+  let cursor: string | null = null
+  while (rows.length < LIST_LIMIT) {
+    const args = ['api', 'graphql', '-F', 'owner={owner}', '-F', 'repo={repo}', '-f', `query=${MINE_QUERY}`, '-f', `login=${login}`]
+    const out = await gh($, pin, cursor === null ? args : [...args, '-f', `after=${cursor}`])
+    const page = out.ok ? parseIssuesPage(out.stdout) : null
+    if (page === null) return null
+    rows.push(...page.rows)
+    if (!page.hasNextPage) break
+    cursor = page.endCursor
+  }
+  return myTicketsFromRows(rows)
+}
+
+const keepMine = async ($: Dollar, mine: readonly MyTicket[] | null) => {
+  if (mine !== null && !sameValue(await read($, myTickets), mine)) await update($, myTickets, () => mine)
+}
+
 // The pending UAT tickets of one scope (a map label, or the whiteboard) with their bodies, for the parent each
 // one tests. Read through GraphQL (the search index lags a write by seconds, so a follow-up just opened would
 // show without its parent line), all open `trailhead:uat` tickets, the scope filtered here. Fail-closed: a page
@@ -341,12 +405,13 @@ async function fetchMap($: Dollar, pin: RepoPin, token: number, moves: number, w
     await setPane($, { ...EMPTY, maps: before.maps, whiteboard: before.whiteboard, openTotal: before.openTotal, isLoading: true })
   }
 
-  const [view, list, historyRead, mapsRead, uatParents] = await readList($, pin, target, before.openTotal)
+  const [[view, list, historyRead, mapsRead, uatParents], mine] = await Promise.all([readList($, pin, target, before.openTotal), readMine($, pin)])
   const maps = mapsRead.maps ?? before.maps
   const { whiteboard, openTotal } = mapsRead
   await dropClosedView($, mapsRead.maps)
   const now = await $.clock.now()
   if (await isStale()) return
+  await keepMine($, mine)
 
   const kept = isSameMap ? before : EMPTY
   const failure = !view.ok ? view.reason : !list.ok ? list.reason : null
@@ -381,14 +446,16 @@ async function fetchDashboard($: Dollar, pin: RepoPin, token: number, moves: num
   if (before.fetchedAt === null && !before.isLoading && before.error === null) {
     await update($, dashboardPane, () => ({ ...before, isLoading: true }))
   }
-  const [list, index, mapsRead, uatParents] = await Promise.all([
+  const [list, index, mapsRead, uatParents, mine] = await Promise.all([
     readOpen($, pin, 'trailhead:whiteboard', 'trailhead:ticket'),
     gh($, pin, ['issue', 'list', '--label', 'trailhead:dashboard', '--state', 'open', '--limit', '10', '--json', DASHBOARD_FIELDS]),
     readMaps($, pin, keptTotal),
     readUat($, pin, 'trailhead:whiteboard'),
+    readMine($, pin),
   ])
   const now = await $.clock.now()
   if (await isStale()) return
+  await keepMine($, mine)
   const shown = await read($, mapPane)
   await setPane($, { ...shown, maps: mapsRead.maps ?? shown.maps, whiteboard: mapsRead.whiteboard, openTotal: mapsRead.openTotal })
   await dropClosedView($, mapsRead.maps)
@@ -420,6 +487,7 @@ export async function onPinMove($: Dollar, pin: RepoPin | null): Promise<void> {
   if (!isOtherRepo) return
   await update($, mapPane, () => EMPTY)
   await update($, dashboardPane, () => EMPTY_DASHBOARD)
+  await update($, myTickets, () => [])
   await update($, activeMap, () => null)
   await update($, viewedMap, () => null)
   await update($, isDashboard, () => false)
@@ -556,6 +624,10 @@ async function restoreAfterClear($: Dollar) {
 export const GH_ISSUE_WRITE =
   /\bgh\b[^\n;&|]*\bissue\s+(?:edit|close|create|comment|reopen|delete|transfer)\b|\bgh\b(?=[^\n;&|]*\sapi\s)(?=[^\n;&|]*\brepos\/[^\s;&|]*\/issues\b)(?=[^\n;&|]*(?:\s(?:-X|--method)[\s=]*["']?(?:POST|PATCH|PUT|DELETE)\b|\s(?:-[fF]|--field\b|--raw-field\b|--input\b)))(?![^\n;&|]*\s(?:-X|--method)[\s=]*["']?GET\b)|\btrailhead-issue-body\.js\b/
 
+// A tracker write once heredoc bodies are out: a body line is data, never a command (#369). The matcher
+// stays the regex because the host's `command:` takes no function; the handler runs this check first.
+export const isTrackerWrite = (command: string): boolean => GH_ISSUE_WRITE.test(stripHeredocBodies(command))
+
 // The host runs the verb in the session's own directory, which a shell `cd` may have moved, and the mod cannot
 // move it back: `out` hands the pinned checkout to the verb, which moves first (#312). A checkout that cannot
 // be read is `unknown`, refused, but not told it is elsewhere.
@@ -582,7 +654,7 @@ async function placeOf($: Dollar): Promise<{ pin: RepoPin; where: 'in' | 'out' }
 // Whether the pinned root still answers as a checkout root, the same test the verb's helper applies.
 async function isCheckoutRoot($: Dollar, root: string): Promise<boolean> {
   try {
-    const out = await $.process.run(['git', 'rev-parse', '--show-toplevel'], { cwd: root, timeoutMs: 5_000 })
+    const out = await $.process.run(gitArgv('rev-parse', '--show-toplevel'), { cwd: root, timeoutMs: 5_000 })
     return out.exitCode === 0 && out.stdout.trim() === root
   } catch {
     return false
@@ -825,12 +897,17 @@ const pressDashboard = ($: Dollar, isOn: boolean): void => {
 // so the auto-open runs from a zero-delay timer, a dispatch of its own; `isOpening` keeps two
 // renders from opening twice before the flag is written.
 let isOpening = false
+// Quando l'auto-open ha disegnato il pannello: serve a `/trailhead:panel` per riconoscerne uno mai visto.
+let autoOpenedAt: number | null = null
 // Same for the fill an empty pane asks for from its render.
 let isFilling = false
 
-async function openPane($: Dollar) {
-  await update($, paneAutoOpened, () => true)
+// L'auto-open conta come fatto (`paneAutoOpened`) solo quando il pannello è davvero disegnato, o quando la
+// persona è intervenuta (comando, chiusura a mano, bottone close). Un'apertura non richiesta che resta non
+// disegnata non brucia il flag: un trigger successivo (render in fullscreen, `session.attach`) può riprovare.
+async function openPane($: Dollar, isRequested = false) {
   const opened = await $.ui.open({ id: PANE_ID, title: PANE_TITLE })
+  if (isRequested || opened.isPlaced) await update($, paneAutoOpened, () => true)
   if (opened.isPlaced) void requestRefresh($)
   return opened
 }
@@ -839,9 +916,14 @@ async function autoOpen($: Dollar) {
   if (isOpening) return
   isOpening = true
   try {
-    if (!(await $.ui.panes()).some(pane => pane.id === PANE_ID)) await openPane($)
-    // Found up already (a reload with the pane showing): nothing to open, and renders stop asking.
-    else await update($, paneAutoOpened, () => true)
+    const pane = (await $.ui.panes()).find(p => p.id === PANE_ID)
+    if (pane === undefined) {
+      const opened = await openPane($)
+      if (opened.isPlaced) autoOpenedAt = await $.clock.now()
+    }
+    // Found up and drawn (a reload with the pane showing): nothing to open, and renders stop asking.
+    else if (pane.isPlaced) await update($, paneAutoOpened, () => true)
+    // Listed but undrawn: the host places it itself when it can; its own render then completes the auto-open.
   } catch (err) {
     debug($, `trailhead mod: map pane auto-open failed: ${String(err)}`)
   } finally {
@@ -849,21 +931,43 @@ async function autoOpen($: Dollar) {
   }
 }
 
-// Un pannello aperto ma non disegnato (l'auto-open sotto la soglia dei pannelli non richiesti, tipico di
-// una sessione appena aperta) non è visibile: il comando lo riapre, e una richiesta della persona lo
-// disegna a qualsiasi larghezza. Se nemmeno così viene disegnato (nessuna superficie), lo chiude.
+// Una lettura sola, da un timer a ritardo zero: un render non può scrivere stato.
+async function autoOpenIfDue($: Dollar) {
+  if ((await read($, activeMap)) !== null && !(await read($, paneAutoOpened))) $.clock.after(0, () => void autoOpen($))
+}
+
+// Il render del pannello scatta solo da disegnato: l'auto-open è completato.
+async function markDrawn($: Dollar) {
+  if (!(await read($, paneAutoOpened))) $.clock.after(0, () => void update($, paneAutoOpened, () => true).catch(err => debug($, `trailhead mod: auto-open flag not set: ${String(err)}`)))
+}
+
+// Un pannello aperto ma non disegnato (l'auto-open sotto la soglia dei pannelli non richiesti, o su una
+// superficie che non ha ancora comunicato il layout) non è visibile: il comando lo riapre, e una richiesta
+// della persona lo disegna a qualsiasi larghezza. Se nemmeno così viene disegnato NON lo chiude: la persona
+// non l'ha mai visto, chiuderlo risponderebbe "closed" a un pannello mai mostrato. Resta aperto e viene
+// disegnato appena la superficie può collocarlo. Chiude solo un pannello elencato E disegnato. Senza
+// superficie collegata (`no-surface`, l'inizio sessione) la risposta è l'attesa normale.
+const PENDING_MESSAGE = 'Map panel will open as soon as the screen is ready.'
+const NOT_SHOWN_MESSAGE = 'Map panel is open but not shown yet: it appears once the screen can place it.'
+const isNoSurface = (reason: string) => reason.startsWith('no-surface')
+
+// Il desktop avvia la sessione al primo invio, non al +: un `/trailhead:panel` come primo messaggio arriva
+// pochi millisecondi dopo l'auto-open. Nessuno fa in tempo a vedere il pannello e a digitare il comando sotto
+// questa soglia, quindi la richiesta è di vederlo, non di chiuderlo.
+const UNSEEN_MS = 2_000
+
 async function togglePanel($: Dollar): Promise<string> {
   const pane = (await $.ui.panes()).find(p => p.id === PANE_ID)
-  if (pane?.isPlaced === false) {
-    const reopened = await openPane($)
-    if (reopened.isPlaced) return 'Map panel opened.'
-  }
-  if (pane !== undefined) {
+  const isUnseen = autoOpenedAt !== null && (await $.clock.now()) - autoOpenedAt < UNSEEN_MS
+  autoOpenedAt = null
+  if (pane?.isPlaced === true && !isUnseen) {
     await $.ui.close({ id: PANE_ID })
     return 'Map panel closed.'
   }
-  const opened = await openPane($)
-  return opened.isPlaced ? 'Map panel opened.' : `Map panel not shown: ${opened.reason}`
+  const opened = await openPane($, true)
+  if (opened.isPlaced) return 'Map panel opened.'
+  debug($, `trailhead mod: map pane not placed: ${opened.reason}`)
+  return isNoSurface(opened.reason) ? PENDING_MESSAGE : NOT_SHOWN_MESSAGE
 }
 
 // The close button: the pane goes (its `ui.close` hook stops the timers). The press counts as the
@@ -919,12 +1023,14 @@ export function registerMapPane(on: On) {
     return result
   })
 
-  // After the call ran: a Bash `gh issue` write changed the tracker.
+  // After the call ran: a Bash `gh issue` write changed the tracker (heredoc bodies not counted).
   on('tool.call', { tool: 'Bash', command: GH_ISSUE_WRITE }, async ($, e, next) => {
+    // The matcher saw the raw text: a write named only inside a heredoc body is no write.
+    if (typeof e.command !== 'string' || !isTrackerWrite(e.command)) return next(e)
     const result = await next(e)
     lastWriteAt = await $.clock.now()
     void requestRefresh($, { isWrite: true })
-    await hintWhiteboard($, e.command, result)
+    await hintWhiteboard($, stripHeredocBodies(e.command), result)
     return result
     // This hook never judges the call: if it fails, the call goes on untouched.
   }).catch((_$, e, next) => next(e))
@@ -935,7 +1041,14 @@ export function registerMapPane(on: On) {
   // Only in fullscreen, where a pane docks beside the transcript; this bare matcher is
   // narrower than the band's, and the band's own hook (in register.tsx) draws after it.
   on('ui.render', { component: 'AbovePrompt', viewport: { isFullscreen: true } }, async ($, e, next) => {
-    if ((await read($, activeMap)) !== null && !(await read($, paneAutoOpened))) $.clock.after(0, () => void autoOpen($))
+    await autoOpenIfDue($)
+    return next(e)
+  })
+
+  // A surface that attaches later (a fresh desktop session) may place the pane the first open could not: with
+  // its layout saying fullscreen, the auto-open tries again. Without a viewport the render trigger decides.
+  on('session.attach', { viewport: { isFullscreen: true } }, async ($, e, next) => {
+    await autoOpenIfDue($)
     return next(e)
   })
 
@@ -948,6 +1061,7 @@ export function registerMapPane(on: On) {
   })
 
   on('ui.render', { component: 'Pane', requestId: PANE_ID }, async ($, e) => {
+    await markDrawn($)
     const ui = $.ui.resolve(e)
     const { Box, Text, Button, Link } = ui
     // Raster is the terminal surface's only; elsewhere the constructor is not a real element.
@@ -961,6 +1075,7 @@ export function registerMapPane(on: On) {
     const play = await read($, workState)
     const orphaned = await read($, isOrphaned)
     const own = await read($, ownTicket)
+    const mine = await read($, myTickets)
     const pin = await read($, repoPin)
     const pending = await read($, pendingWork)
     const phase = await read($, pendingPhase)
@@ -976,14 +1091,45 @@ export function registerMapPane(on: On) {
       </Box>
     )
     const link = (url: string, label: string) => (url === '' ? label : <Link href={url} label={label} />)
+    // Il filetto di un blocco (riga e righe sotto): sul desktop una barra che si allunga quanto il blocco, nel
+    // terminale un `│` per riga. Occupa sempre GUTTER colonne.
+    const gutter = (key: string, section: SectionKey, lines: number) => {
+      const { color } = SECTION_STYLES[section]
+      return e.surface === 'desktop' ? (
+        <Box key={key} width={GUTTER.length}>
+          <Box key={`${key}-bar`} width={GUTTER_BAR} backgroundColor={color} />
+        </Box>
+      ) : (
+        <Box key={key} flexDirection="column" width={GUTTER.length}>
+          {Array.from({ length: lines }, (_, i) => (
+            <Text key={`${key}-${i}`} color={color}>
+              {GUTTER}
+            </Text>
+          ))}
+        </Box>
+      )
+    }
+    // Intestazione di sezione: glifo e nome nel colore della sezione, poi un filetto fino al bordo.
+    const sectionHead = (key: SectionKey, label: string) => {
+      const { glyph, color } = SECTION_STYLES[key]
+      const rest = cols - glyph.length - 1 - label.length - 1
+      return (
+        <Box key={`section-head-${key}`}>
+          {text(`glyph-${key}`, { color }, `${glyph} `)}
+          {text(`head-${key}`, { bold: true, color }, label)}
+          {rest > 0 ? text(`rule-${key}`, { color: RULE_COLOR }, ` ${'─'.repeat(rest)}`) : null}
+        </Box>
+      )
+    }
 
     // The open maps, one row each; shown with several maps open (or with no active map, to pick one).
     // On the dashboard every map is listed and each row opens it.
     const mapRow = (m: MapSummary) => {
-      const r = mapRowLayout(m, { active, viewed, columns: cols, isDashboard: isBoard })
+      const r = mapRowLayout(m, { active, viewed, columns: cols - GUTTER.length, isDashboard: isBoard })
       return (
         <Box key={`map-row-${m.number}`}>
-          {text(`map-mark-${m.number}`, r.isActive ? accent : {}, r.mark)}
+          {gutter(`map-gutter-${m.number}`, 'maps', 1)}
+          {text(`map-mark-${m.number}`, r.isActive ? { bold: true, color: SECTION_STYLES.maps.color } : {}, r.mark)}
           {r.isPressable ? (
             <Button
               key={`map-${m.number}`}
@@ -1000,7 +1146,7 @@ export function registerMapPane(on: On) {
     const isMapsShown = isBoard ? data.maps.length > 0 : data.maps.length > 1 || (active === null && data.maps.length > 0)
     const mapsGroup = isMapsShown ? (
       <Box key="group-maps" flexDirection="column" marginTop={gap}>
-        {text('head-maps', bold, `Maps · ${data.maps.length}`)}
+        {sectionHead('maps', `Maps · ${data.maps.length}`)}
         {data.maps.map(mapRow)}
       </Box>
     ) : null
@@ -1039,18 +1185,20 @@ export function registerMapPane(on: On) {
 
     // This session's own ticket survives a work-state file another session took over; without one, the file decides.
     const isInPlay = (t: PaneTicket) => (own !== null ? t.number === own : play !== null && !orphaned && play.ticket === t.number)
-    const row = (t: PaneTicket, hasMarkColumn: boolean) => {
-      const r = rowLayout(t, { isInPlay: isInPlay(t), hasMarkColumn, pendingWork: pending, pendingPhase: phase, columns: cols })
+    const row = (t: PaneTicket, section: SectionKey, hasMarkColumn: boolean, scope: string | null = null) => {
+      const r = rowLayout(t, { isInPlay: isInPlay(t), hasMarkColumn, pendingWork: pending, pendingPhase: phase, columns: cols - GUTTER.length })
       const style = r.isInPlay ? accent : r.isDim ? dim : {}
       const holder = r.isDim ? dim : {}
+      const typeColor = t.type === null ? undefined : TYPE_COLORS[t.type]
+      const typeStyle = r.isDim || typeColor === undefined ? dim : { color: typeColor }
       const line = (
-        <Box key={`row-${t.number}`} width={cols} justifyContent="space-between">
+        <Box key={`row-${t.number}`} width={cols - GUTTER.length} justifyContent="space-between">
           <Box>
             {r.mark === null ? null : text(`mark-${t.number}`, r.isInPlay ? accent : {}, r.mark)}
             <Box key={`ticket-${t.number}`}>
               <Text {...style}>{link(t.url, r.label)}</Text>
             </Box>
-            {r.type === null ? null : text(`type-${t.number}`, dim, r.type)}
+            {r.type === null ? null : text(`type-${t.number}`, typeStyle, r.type)}
           </Box>
           {r.aside?.kind === 'holder' ? text(`holder-${t.number}`, holder, r.aside.text) : null}
           {r.aside?.kind === 'self' ? text(`self-${t.number}`, { color: ACCENT }, r.aside.text) : null}
@@ -1078,19 +1226,24 @@ export function registerMapPane(on: On) {
           ) : null}
         </Box>
       )
-      const parent = uatParentLine(t, cols)
-      return parent === null ? (
-        line
-      ) : (
-        <Box key={`entry-${t.number}`} flexDirection="column">
-          {line}
-          {text(`uat-of-${t.number}`, dim, parent)}
+      // Le righe sotto (genitore UAT, dove sta) rientrano dopo il filetto, che copre tutto il blocco.
+      const parent = uatParentLine(t, cols - GUTTER.length)
+      const lines = 1 + (parent === null ? 0 : 1) + (scope === null ? 0 : 1)
+      return (
+        <Box key={`entry-${t.number}`} width={cols}>
+          {gutter(`gutter-${t.number}`, section, lines)}
+          <Box key={`entry-lines-${t.number}`} flexDirection="column">
+            {line}
+            {parent === null ? null : text(`uat-of-${t.number}`, dim, parent)}
+            {scope === null ? null : text(`scope-of-${t.number}`, dim, scope)}
+          </Box>
         </Box>
       )
     }
-    const group = (key: string, name: string, rows: readonly PaneTicket[]) => {
-      if (rows.length === 0) return null
-      const hasMarkColumn = rows.some(isInPlay)
+    // `elsewhere`: my tickets of other scopes, listed after the shown scope's with the line naming where each is.
+    const group = (key: Exclude<SectionKey, 'maps'>, name: string, rows: readonly PaneTicket[], elsewhere: readonly MyTicket[] = []) => {
+      if (rows.length + elsewhere.length === 0) return null
+      const hasMarkColumn = [...rows, ...elsewhere].some(isInPlay)
       return (
         <Box
           key={`group-${key}`}
@@ -1098,17 +1251,19 @@ export function registerMapPane(on: On) {
           marginTop={gap}
           {...(e.surface === 'desktop' ? { rowGap: DESKTOP_ROW_GAP } : {})}
         >
-          {text(`head-${key}`, bold, `${name} · ${rows.length}`)}
-          {rows.map(t => row(t, hasMarkColumn))}
+          {sectionHead(key, `${name} · ${rows.length + elsewhere.length}`)}
+          {rows.map(t => row(t, key, hasMarkColumn))}
+          {elsewhere.map(t => row(t, key, hasMarkColumn, scopeLine(t, data.maps, cols - GUTTER.length)))}
         </Box>
       )
     }
-    const ticketGroups = (tickets: readonly PaneTicket[]) => {
+    const ticketGroups = (tickets: readonly PaneTicket[], here: TicketScope) => {
       const groups = groupTickets(tickets)
+      // In progress first, right under the maps list: what I already hold comes before what to pick up.
       return [
+        group('in-progress', 'In progress', groups.inProgress, elsewhereInProgress(mine, here, tickets)),
         group('needs-you', 'Needs you', groups.needsYou),
         group('frontier', 'Frontier', groups.frontier),
-        group('in-progress', 'In progress', groups.inProgress),
         group('uat', 'UAT', groups.uat),
         group('paused', 'Paused', groups.paused),
         group('blocked', 'Blocked', groups.blocked),
@@ -1117,7 +1272,7 @@ export function registerMapPane(on: On) {
     const notes = (d: { unverifiedCount: number; isCapped: boolean }) => [
       d.unverifiedCount === 0 ? null : (
         <Box key="unverified" marginTop={gap}>
-          <Text {...dim}>{unverifiedLine(d.unverifiedCount)}</Text>
+          <Text color={AMBER}>{unverifiedLine(d.unverifiedCount)}</Text>
         </Box>
       ),
       !d.isCapped ? null : (
@@ -1201,7 +1356,7 @@ export function registerMapPane(on: On) {
             {text('head-whiteboard', bold, whiteboardHeading(isLoaded ? board.tickets : null, board.isCapped))}
           </Box>
           {!isLoaded && board.error === null ? text('loading', dim, 'Loading dashboard…') : null}
-          {ticketGroups(board.tickets)}
+          {ticketGroups(board.tickets, { kind: 'whiteboard' })}
           {isEmpty ? text('no-tickets', dim, 'No open whiteboard tickets.') : null}
           {notes(board)}
           <Box key="spacer" flexGrow={1} />
@@ -1274,7 +1429,7 @@ export function registerMapPane(on: On) {
         {whiteboardRow}
         {totalLine}
         {mapsGroup}
-        {ticketGroups(tickets)}
+        {ticketGroups(tickets, { kind: 'map', number: target })}
         {isCurrent && data.error === null && tickets.length === 0 ? (
           <Box key="no-tickets" marginTop={gap}>
             <Text {...dim}>No open tickets. Fog may remain: /trailhead:map</Text>

package/plugins/trailhead/hooks/mod/my-tickets.ts

@@ -0,0 +1,76 @@
+// My tickets in play across the repo: the open tickets assigned to the gh login, on any open map or on the
+// whiteboard, so every view's In progress group shows them, not only the shown scope's. Pure, easy to test.
+import type { MapSummary, MyTicket, PaneTicket, TicketScope } from '../../types'
+import { groupTickets, ticketsFromRows } from './map-pane-view'
+import { fit } from './work-state-view'
+
+const MAP_LABEL = /^trailhead:map-(\d+)$/
+const WHITEBOARD_LABEL = 'trailhead:whiteboard'
+
+const isRecord = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object' && !Array.isArray(v)
+
+const namesOf = (row: unknown): string[] =>
+  isRecord(row) && Array.isArray(row.labels)
+    ? row.labels.flatMap(l => (isRecord(l) && typeof l.name === 'string' ? [l.name] : []))
+    : []
+
+// One map label, or the whiteboard label alone; none, or contradictory labels, is no scope (never guessed).
+const scopeOf = (names: readonly string[]): TicketScope | null => {
+  const maps = names.flatMap(n => {
+    const m = MAP_LABEL.exec(n)
+    return m === null ? [] : [Number(m[1])]
+  })
+  const isBoard = names.includes(WHITEBOARD_LABEL)
+  if (isBoard) return maps.length === 0 ? { kind: 'whiteboard' } : null
+  return maps.length === 1 && Number.isInteger(maps[0]) && (maps[0] as number) > 0 ? { kind: 'map', number: maps[0] as number } : null
+}
+
+// `{data:{viewer:{login}}}` as the login; any error or an empty login is unreadable (null).
+export const parseLogin = (stdout: string): string | null => {
+  let raw: unknown
+  try {
+    raw = JSON.parse(stdout)
+  } catch {
+    return null
+  }
+  if (!isRecord(raw) || 'errors' in raw || !isRecord(raw.data) || !isRecord(raw.data.viewer)) return null
+  const { login } = raw.data.viewer
+  return typeof login === 'string' && login !== '' ? login : null
+}
+
+// The rows of the assigned-ticket read (the `gh issue list --json` shape) as tickets tagged with their scope.
+// The ticket parser does the quarantine and the field hygiene; a row with no usable scope is dropped.
+export const myTicketsFromRows = (rows: readonly unknown[]): readonly MyTicket[] => {
+  const scopes = new Map(
+    rows.flatMap(r => (isRecord(r) && typeof r.number === 'number' ? [[r.number, scopeOf(namesOf(r))] as const] : [])),
+  )
+  const parsed = [...ticketsFromRows(rows).tickets, ...ticketsFromRows(rows, { isWhiteboard: true }).tickets]
+  return parsed
+    .flatMap(t => {
+      const scope = scopes.get(t.number) ?? null
+      return scope === null ? [] : [{ ...t, scope }]
+    })
+    .sort((a, b) => a.number - b.number)
+}
+
+const isSameScope = (a: TicketScope, b: TicketScope): boolean =>
+  a.kind === 'whiteboard' ? b.kind === 'whiteboard' : b.kind === 'map' && a.number === b.number
+
+// My in-progress tickets (the same grouping the view uses) outside the shown scope, never one it already lists.
+export const elsewhereInProgress = (
+  mine: readonly MyTicket[],
+  here: TicketScope,
+  shown: readonly PaneTicket[],
+): readonly MyTicket[] => {
+  const listed = new Set(shown.map(t => t.number))
+  const inProgress = new Set(groupTickets(mine).inProgress.map(t => t.number))
+  return mine.filter(t => inProgress.has(t.number) && !isSameScope(t.scope, here) && !listed.has(t.number))
+}
+
+// The dim line under such a row: `on map #<n> <title>` (the title once the maps read knows it) or `on whiteboard`.
+export const scopeLine = (t: MyTicket, maps: readonly MapSummary[], columns: number): string => {
+  if (t.scope.kind === 'whiteboard') return fit('on whiteboard', columns)
+  const { number } = t.scope
+  const title = maps.find(m => m.number === number)?.title ?? ''
+  return fit(title === '' ? `on map #${number}` : `on map #${number} ${title}`, columns)
+}