@marcomigozzi/trailhead 0.16.0 → 0.17.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,6 +48,7 @@ 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 { isMainTurnRunning } from './turn-state'
 import { createdIssueNumber, isWhiteboardCreate, nextFollow, whiteboardHint } from './whiteboard-follow'
@@ -79,6 +80,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'
@@ -123,6 +127,8 @@ 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)
@@ -159,8 +165,12 @@ function debug($: Dollar, message: string): void {
 // A hot reload resets it, which costs at most one early refresh.
 let queue: Promise<void> = Promise.resolve()
 let generation = 0
+// Bumped by every pin move, same repo or not: a read that spans one is stale even when `generation` held.
+let pinMoves = 0
 let lastStartedAt: number | null = null
-let trailing: Timer | null = null
+// When the last tracker write finished: a turn end that finds it newer than the last read start reads at once.
+let lastWriteAt: number | null = null
+let trailing: Tracked | null = null
 let ticker: Tracked | null = null
 // What /clear would take from the pane, kept across it (module variables survive it, atoms do not).
 type Carried = { isAutoOpened: boolean; viewed: number | null; active: number | null; isDashboard: boolean }
@@ -245,6 +255,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
@@ -307,18 +351,18 @@ async function dropClosedView($: Dollar, maps: readonly MapSummary[] | null) {
 }
 
 // One read of the viewed (else active) map. The result is dropped when the pane closed meanwhile
-// (generation) or the target moved on, checked before every write; a moved target is read again.
-async function fetchMap($: Dollar, pin: RepoPin, token: number, wantsAnother: () => void) {
+// (generation) or the target or pin moved on, checked before every write; a moved one is read again.
+async function fetchMap($: Dollar, pin: RepoPin, token: number, moves: number, wantsAnother: () => void) {
   const target = await readTarget($)
   if (token !== generation) return
-  // Checked before every write: the last test is the token, with no await after it. A pin that moved to
-  // another repo (even with the same map number there) makes the read stale; the target is not read
-  // under the new pin for it.
+  // Checked before every write: the last test is the token, then the pin-move count, with no await after
+  // them. A pin that moved to another repo (even with the same map number there) makes the read stale; the
+  // target is not read under the new pin for it. A move that landed during the checks shows in the count.
   const isStale = async () => {
     if (token !== generation) return true
     const isMoved = !isSamePin(await read($, repoPin), pin) || (await read($, isDashboard)) || (await readTarget($)) !== target
     if (token !== generation) return true
-    if (!isMoved) return false
+    if (!isMoved && moves === pinMoves) return false
     wantsAnother()
     return true
   }
@@ -337,12 +381,13 @@ async function fetchMap($: Dollar, pin: RepoPin, token: number, wantsAnother: ()
     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
@@ -362,13 +407,13 @@ async function fetchMap($: Dollar, pin: RepoPin, token: number, wantsAnother: ()
 
 // The whiteboard's open tickets (map-less) and the pinned index, plus the open maps. Same drop rule
 // as a map read: a result is not committed once the pane closed or the dashboard was left.
-async function fetchDashboard($: Dollar, pin: RepoPin, token: number, wantsAnother: () => void) {
+async function fetchDashboard($: Dollar, pin: RepoPin, token: number, moves: number, wantsAnother: () => void) {
   const isStale = async () => {
     if (token !== generation) return true
     const isOther = !isSamePin(await read($, repoPin), pin)
     const isLeft = !(await read($, isDashboard))
     if (token !== generation) return true
-    if (!isOther && !isLeft) return false
+    if (!isOther && !isLeft && moves === pinMoves) return false
     wantsAnother()
     return true
   }
@@ -377,14 +422,16 @@ async function fetchDashboard($: Dollar, pin: RepoPin, token: number, wantsAnoth
   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)
@@ -404,16 +451,19 @@ async function fetchDashboard($: Dollar, pin: RepoPin, token: number, wantsAnoth
 // holds for the old one (and drops a read of it still in flight), so its tickets never show under the new.
 let paneRepo: string | null = null
 // Called by refreshPin right before the pin atom changes, from the pane's refresh and the band's alike. A move
-// to another repo drops the reads in flight and empties what the pane holds for the old one, then asks for a
-// fresh read (a closed pane makes that a no-op), so its tickets never show under the new repo.
+// to another repo (or to no pin) drops the reads in flight and, to another repo, empties what the pane holds for
+// the old one, then asks for a fresh read (a closed pane makes that a no-op), so its tickets never show under the
+// new repo. A move inside the same repo leaves the read in flight to its own stale check, which reads again.
 export async function onPinMove($: Dollar, pin: RepoPin | null): Promise<void> {
-  generation += 1
+  pinMoves += 1
   const key = pin === null ? null : pinKey(pin)
   const isOtherRepo = paneRepo !== null && key !== null && key !== paneRepo
+  if (isOtherRepo || pin === null) generation += 1
   paneRepo = key ?? paneRepo
   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)
@@ -435,25 +485,28 @@ function stopTimers() {
   generation += 1
   // A fill timer dropped with the pane must not leave the next pane unfillable.
   isFilling = false
-  trailing?.cancel()
+  trailing?.timer.cancel()
   trailing = null
+  lastWriteAt = null
   ticker?.timer.cancel()
   ticker = null
 }
 
-// The slow timer past its due time by more than the grace never fired: drop it, so the caller starts another.
-// A dropped trailing needs no such check: the next read outside the floor clears it.
+// A timer past its due time by more than the grace never fired: drop it, so the caller starts another.
+// Both the slow timer and the trailing refresh are tracked, as the host may silently drop either.
 const liveOrNull = (t: Tracked | null, now: number): Tracked | null => {
   if (t === null || !isTimerLate(now, t.dueAt, TIMER_GRACE_MS)) return t
   t.timer.cancel()
   return null
 }
 
-const startTrailing = ($: Dollar, waitMs: number): Timer =>
-  $.clock.after(waitMs, () => {
+const startTrailing = ($: Dollar, now: number, waitMs: number): Tracked => ({
+  timer: $.clock.after(waitMs, () => {
     trailing = null
     void requestRefresh($)
-  })
+  }),
+  dueAt: now + waitMs,
+})
 
 const startTicker = ($: Dollar, now: number): Tracked => ({
   timer: $.clock.every(TIMER_MS, () => void requestRefresh($, { isTick: true })),
@@ -464,7 +517,9 @@ const startTicker = ($: Dollar, now: number): Tracked => ({
 // `isWrite`: a tracker write just ran; a read that starts at once is followed by one more at the floor's end,
 // by when the search index (history, the list fallback) has caught up.
 // `isTick`: the slow timer fired, so its next due time moves on.
-type Request = { bypassFloor?: boolean; isWrite?: boolean; isTick?: boolean }
+// `isTurnEnd`: the turn is over; if a write landed after the last read started, the read runs inside the floor
+// too, so the pane shows the turn's final tracker state without waiting on a timer the host may have dropped.
+type Request = { bypassFloor?: boolean; isWrite?: boolean; isTick?: boolean; isTurnEnd?: boolean }
 
 // Throttled: inside the floor it keeps ONE trailing refresh for the rest of it, so an event
 // just after a refresh still shows.
@@ -472,24 +527,32 @@ async function decide($: Dollar, request: Request) {
   if (!(await isPaneUp($))) return
   // Nothing pinned: no repo to read, so no call.
   const pin = await syncPin($)
+  const moves = pinMoves
   if (pin === null) return
   const now = await $.clock.now()
   if (request.isTick === true && ticker !== null) ticker = { ...ticker, dueAt: now + TIMER_MS }
   // A timer the host dropped is started again here, else the pane would wait on it for good.
   ticker = liveOrNull(ticker, now) ?? startTicker($, now)
-  const decision = request.bypassFloor === true ? { run: true as const } : refreshDecision(now, lastStartedAt, MIN_REFRESH_MS)
+  // Same for the trailing refresh: a dead handle would keep `??=` below from arming a live one.
+  trailing = liveOrNull(trailing, now)
+  // Strictly newer: a read that started at the write's own instant already saw it.
+  const isFlush = request.isTurnEnd === true && lastWriteAt !== null && (lastStartedAt === null || lastWriteAt > lastStartedAt)
+  const decision = request.bypassFloor === true || isFlush ? { run: true as const } : refreshDecision(now, lastStartedAt, MIN_REFRESH_MS)
   if (!decision.run) {
-    trailing ??= startTrailing($, decision.waitMs)
+    trailing ??= startTrailing($, now, decision.waitMs)
     return
   }
   lastStartedAt = now
-  trailing?.cancel()
-  trailing = null
+  // A flush leaves the trailing refresh alone: it still owes the read after the search index caught up.
+  if (!isFlush) {
+    trailing?.timer.cancel()
+    trailing = null
+  }
   // Never bypassFloor: a burst of writes still costs one read per floor plus this one trailing.
-  if (request.isWrite === true) trailing = startTrailing($, MIN_REFRESH_MS)
+  if (request.isWrite === true) trailing = startTrailing($, now, MIN_REFRESH_MS)
   const again = () => void requestRefresh($, { bypassFloor: true })
-  if (await read($, isDashboard)) await fetchDashboard($, pin, generation, again)
-  else await fetchMap($, pin, generation, again)
+  if (await read($, isDashboard)) await fetchDashboard($, pin, generation, moves, again)
+  else await fetchMap($, pin, generation, moves, again)
 }
 
 // Does nothing while the pane is closed: the data exists only for the pane.
@@ -832,19 +895,26 @@ 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.
+// disegna a qualsiasi larghezza. Se nemmeno così viene disegnato lo chiude, tranne quando non c'è ancora
+// nessuna superficie (`no-surface`): è l'attesa normale dell'inizio sessione, il pannello resta aperto e
+// viene disegnato appena una superficie si collega (il suo render chiede la prima lettura).
+const PENDING_MESSAGE = 'Map panel will open as soon as the screen is ready.'
+const isNoSurface = (reason: string) => reason.startsWith('no-surface')
+
 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 (isNoSurface(reopened.reason)) return PENDING_MESSAGE
   }
   if (pane !== undefined) {
     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}`
+  if (opened.isPlaced) return 'Map panel opened.'
+  return isNoSurface(opened.reason) ? PENDING_MESSAGE : `Map panel not shown: ${opened.reason}`
 }
 
 // The close button: the pane goes (its `ui.close` hook stops the timers). The press counts as the
@@ -876,7 +946,7 @@ export function registerMapPane(on: On) {
     const result = await next(e)
     await safeSyncPin($)
     await safeReadActiveMap($)
-    void requestRefresh($)
+    void requestRefresh($, { isTurnEnd: true })
     // The band's hook marks the turn over; the timer runs after the whole chain, and releases a held press.
     if (e.agentId === undefined) $.clock.after(0, () => releaseHeld($))
     return result
@@ -903,6 +973,7 @@ export function registerMapPane(on: On) {
   // After the call ran: a Bash `gh issue` write changed the tracker.
   on('tool.call', { tool: 'Bash', command: GH_ISSUE_WRITE }, async ($, e, next) => {
     const result = await next(e)
+    lastWriteAt = await $.clock.now()
     void requestRefresh($, { isWrite: true })
     await hintWhiteboard($, e.command, result)
     return result
@@ -941,6 +1012,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)
@@ -1019,7 +1091,7 @@ 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 row = (t: PaneTicket, hasMarkColumn: boolean, scope: string | null = null) => {
       const r = rowLayout(t, { isInPlay: isInPlay(t), hasMarkColumn, pendingWork: pending, pendingPhase: phase, columns: cols })
       const style = r.isInPlay ? accent : r.isDim ? dim : {}
       const holder = r.isDim ? dim : {}
@@ -1059,18 +1131,20 @@ export function registerMapPane(on: On) {
         </Box>
       )
       const parent = uatParentLine(t, cols)
-      return parent === null ? (
+      return parent === null && scope === null ? (
         line
       ) : (
         <Box key={`entry-${t.number}`} flexDirection="column">
           {line}
-          {text(`uat-of-${t.number}`, dim, parent)}
+          {parent === null ? null : text(`uat-of-${t.number}`, dim, parent)}
+          {scope === null ? null : text(`scope-of-${t.number}`, dim, scope)}
         </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: string, 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}`}
@@ -1078,17 +1152,19 @@ export function registerMapPane(on: On) {
           marginTop={gap}
           {...(e.surface === 'desktop' ? { rowGap: DESKTOP_ROW_GAP } : {})}
         >
-          {text(`head-${key}`, bold, `${name} · ${rows.length}`)}
+          {text(`head-${key}`, bold, `${name} · ${rows.length + elsewhere.length}`)}
           {rows.map(t => row(t, hasMarkColumn))}
+          {elsewhere.map(t => row(t, hasMarkColumn, scopeLine(t, data.maps, cols)))}
         </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),
@@ -1146,8 +1222,12 @@ export function registerMapPane(on: On) {
 
     // A list older than one slow-timer period missed its reads (the pane undrawn when they came, or the
     // timer dropped): the render asks for one, as for an empty view. A failing read keeps its slow pace.
+    // A trailing refresh past its due time by more than the grace was dropped by the host: the render asks for
+    // the read it would have made (the request replaces the dead handle).
+    const isTrailingLate = trailing !== null && isTimerLate(now, trailing.dueAt, TIMER_GRACE_MS)
     const isOverdue = (d: { fetchedAt: number | null; error: string | null; isLoading: boolean }) =>
-      d.fetchedAt !== null && d.error === null && !d.isLoading && isTimerLate(now, d.fetchedAt + TIMER_MS, TIMER_GRACE_MS)
+      isTrailingLate ||
+      (d.fetchedAt !== null && d.error === null && !d.isLoading && isTimerLate(now, d.fetchedAt + TIMER_MS, TIMER_GRACE_MS))
 
     // No GitHub repo was ever pinned: say so rather than a `gh` failure; nothing is read.
     if (pin === null) {
@@ -1177,7 +1257,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} />
@@ -1250,7 +1330,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)
+}

package/plugins/trailhead/hooks/mod/repo-pin.ts

@@ -46,13 +46,16 @@ export const nextPin = (current: RepoPin | null, repo: RepoRead | null, toplevel
 }
 
 // The pinned checkout as the trailing word of a verb's args: `--in=` plus base64url of the root (alphabet
-// [A-Za-z0-9_-], no padding), so a path with spaces, quotes or a leading `-` stays one shell-safe word. The verb
-// decodes it with templates/trailhead-checkout-in.js and moves there first (#312).
+// [A-Za-z0-9_-], no padding), so a path with spaces, quotes or a leading `-` stays one shell-safe word, then `.` and
+// base64url of `host/owner/name` (`.` is outside the alphabet, so it separates unambiguously). The verb decodes it
+// with templates/trailhead-checkout-in.js and moves there first; when the root is gone, the repo part lets the
+// helper find the checkout by its remote (#312, #329).
 // No Buffer in the mod's runtime: UTF-8 bytes through btoa, then the url-safe alphabet.
-export const checkoutArg = (pin: RepoPin): string => {
-  const binary = Array.from(new TextEncoder().encode(pin.root), byte => String.fromCharCode(byte)).join('')
-  return `--in=${btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')}`
+const base64url = (text: string): string => {
+  const binary = Array.from(new TextEncoder().encode(text), byte => String.fromCharCode(byte)).join('')
+  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
 }
+export const checkoutArg = (pin: RepoPin): string => `--in=${base64url(pin.root)}.${base64url(pinKey(pin))}`
 
 // A repo-relative path under the pinned root, absolute whatever the session cwd is.
 export const pinPath = (pin: RepoPin, relative: string): string => `${pin.root.replace(/\/+$/, '')}/${relative}`

package/plugins/trailhead/hooks/trailhead-check-update.js

@@ -186,6 +186,21 @@ function labelGuardNotice(cwd) {
   }
 }
 
+// Preflight dell'auth di gh (#328): un GH_TOKEN/GITHUB_TOKEN non valido che
+// oscura il login gh funzionante fa fallire ogni chiamata gh; lo segnaliamo
+// una volta, all'avvio (la lib salta resume e compact). Come reviewNotice: il
+// require e' nel try, ogni errore -> null.
+function authNotice(input) {
+  try {
+    return require('./lib/gh-auth-preflight.js').check({
+      env: process.env,
+      source: input && typeof input.source === 'string' ? input.source : undefined,
+    }) || null;
+  } catch {
+    return null;
+  }
+}
+
 // Legge il JSON di SessionStart da stdin in modo asincrono, con timeout, come
 // gli altri hook: una lettura sincrona di fd 0 si bloccherebbe per sempre su
 // un TTY o su una pipe mai chiusa. Su TTY o input assente si prosegue con {}.
@@ -212,11 +227,12 @@ function readInput(done) {
 function main(input) {
   const cwd = (input && typeof input.cwd === 'string' && input.cwd) || process.cwd();
 
+  const auth = authNotice(input);
   const review = reviewNotice(cwd);
   const guard = labelGuardNotice(cwd);
   const update = updateNotice();
 
-  const parts = [review, guard, update].filter(Boolean);
+  const parts = [auth, review, guard, update].filter(Boolean);
   if (!parts.length) return;
 
   process.stdout.write(JSON.stringify({

package/plugins/trailhead/hooks/trailhead-check-update.test.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+// Test dell'hook SessionStart trailhead-check-update.js (notice auth di gh).
+// Run: node trailhead-check-update.test.js
+// Un gh finto in una bin dir tmp (prima nel PATH) applica la precedenza reale.
+const assert = require('assert');
+const { execFileSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+let passed = 0;
+const ok = (name, cond) => { assert.ok(cond, name); passed++; };
+
+const hookPath = path.join(__dirname, 'trailhead-check-update.js');
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'trailhead-check-update-test-'));
+const bin = path.join(tmp, 'bin');
+fs.mkdirSync(bin);
+const fakeGh = `#!${process.execPath}
+const a = process.argv.slice(2);
+if (a[0] !== 'api' || a[1] !== 'user') process.exit(1); // altre chiamate (update check): innocue
+const t = process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+const v = t ? t : (process.env.FAKE_GH_STORED || 'bad');
+if (v === 'good') { console.log('octo'); process.exit(0); }
+console.log('{"message":"Bad credentials","status":"401"}');
+console.error('gh: Bad credentials (HTTP 401)');
+process.exit(1);
+`;
+fs.writeFileSync(path.join(bin, 'gh'), fakeGh, { mode: 0o755 });
+
+const repo = path.join(tmp, 'repo');
+execFileSync('git', ['init', '-q', repo]);
+
+function run(source, extraEnv) {
+  const env = { ...process.env, ...extraEnv };
+  delete env.GH_TOKEN; delete env.GITHUB_TOKEN;
+  Object.assign(env, extraEnv, {
+    PATH: `${bin}${path.delimiter}${process.env.PATH}`,
+    XDG_CACHE_HOME: path.join(tmp, 'cache'),
+    CLAUDE_CONFIG_DIR: path.join(tmp, 'cfg'),
+  });
+  const input = { cwd: repo };
+  if (source) input.source = source;
+  const out = execFileSync('node', [hookPath], { input: JSON.stringify(input), encoding: 'utf8', env });
+  return out ? JSON.parse(out).hookSpecificOutput.additionalContext : '';
+}
+const AUTH = 'GitHub rejects the';
+
+for (const source of ['startup', 'clear', undefined]) {
+  const ctx = run(source, { GITHUB_TOKEN: 'bad', FAKE_GH_STORED: 'good' });
+  ok(`source ${source}: auth notice surfaced`, ctx.includes(`${AUTH} GITHUB_TOKEN`) && ctx.includes('GITHUB_TOKEN= gh'));
+  ok(`source ${source}: token value not leaked`, !ctx.includes('bad'));
+}
+for (const source of ['resume', 'compact']) {
+  ok(`source ${source}: no auth notice`, !run(source, { GITHUB_TOKEN: 'bad', FAKE_GH_STORED: 'good' }).includes(AUTH));
+}
+ok('no token var: no auth notice', !run('startup', { FAKE_GH_STORED: 'good' }).includes(AUTH));
+ok('valid token: no auth notice', !run('startup', { GITHUB_TOKEN: 'good' }).includes(AUTH));
+
+fs.rmSync(tmp, { recursive: true, force: true });
+console.log(`trailhead-check-update: ${passed} passed`);