@marcomigozzi/trailhead 0.16.1 → 0.18.0

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

@@ -1,5 +1,6 @@
 import type { On } from 'claude-code'
 import { expect, mock, test } from 'claude-code/testing'
+import { unscrub } from './unscrub'
 
 const SURFACES = ['terminal', 'desktop'] as const
 const SESSION = 'sess-A'
@@ -15,13 +16,15 @@ const ROOT = '/repo'
 const ROOT_OTHER = '/other'
 // A linked worktree of ROOT: the repo's root is the main tree's, the checkout's own is this.
 const ROOT_TREE = '/repo-t5'
-// The checkout handed to a verb: base64url of the root, computed here by hand so the pane's own encoder is checked.
+// The checkout handed to a verb: base64url of the root, a `.`, then base64url of the pinned repo (`host/owner/name`),
+// computed here by hand so the pane's own encoder is checked.
 // The helper's decodeIn cannot be imported here (the CommonJS template does not load in this suite); the node suite
 // checks decodeIn against Buffer's base64url, and these tests pin the same alphabet.
-const IN = (root: string) => {
-  const b64 = btoa(Array.from(new TextEncoder().encode(root), byte => String.fromCharCode(byte)).join(''))
-  return `--in=${b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')}`
+const b64url = (text: string) => {
+  const b64 = btoa(Array.from(new TextEncoder().encode(text), byte => String.fromCharCode(byte)).join(''))
+  return b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
 }
+const IN = (root: string) => `--in=${b64url(root)}.${b64url('github.com/o/r')}`
 
 const MAP = {
   title: 'trailhead mod',
@@ -101,6 +104,9 @@ const ticketsCall = (label: string, after?: string) => [
 const ticketsListCall = (label: string) => ['gh', 'issue', 'list', '--label', label, '--state', 'open', '--limit', '200', '--json', 'number,title,labels,assignees,url']
 const isTicketsRead = (argv: readonly string[]) => argv[1] === 'api' && argv[2] === 'graphql' && argv.includes(`query=${TICKETS_QUERY}`)
 // The maps read only: the ticket reads are GraphQL too, but answered and failed on their own.
+// The login and my-tickets reads (any map, the whiteboard): answered apart from the pane's own reads, recorded in `mineCalls`.
+const isLoginRead = (argv: readonly string[]) => argv[1] === 'api' && argv[2] === 'graphql' && argv.includes('query=query{viewer{login}}')
+const isMineRead = (argv: readonly string[]) => argv[1] === 'api' && argv[2] === 'graphql' && argv.some(a => a.startsWith('login='))
 const isGraphql = (argv: readonly string[]) => argv[1] === 'api' && argv[2] === 'graphql' && !isTicketsRead(argv) && !isUatRead(argv) && !isCountRead(argv)
 // The open-ticket total: one aliased `totalCount` per open map (`m<n>`) plus the whiteboard (`wb`), in one call.
 const countQuery = (maps: number[]) =>
@@ -137,7 +143,7 @@ const stateText = (over: Record<string, unknown> = {}): string =>
   })
 
 // The plugin's atoms, which the engine resets on /clear.
-const ATOM_KEYS = ['workState', 'isOrphaned', 'promptSnapshot', 'mapPane', 'activeMap', 'viewedMap', 'isDashboard', 'dashboardPane', 'pendingWork', 'pendingPhase', 'paneAutoOpened', 'ownTicket', 'repoPin']
+const ATOM_KEYS = ['workState', 'isOrphaned', 'promptSnapshot', 'mapPane', 'activeMap', 'viewedMap', 'isDashboard', 'dashboardPane', 'pendingWork', 'pendingPhase', 'paneAutoOpened', 'ownTicket', 'repoPin', 'myTickets']
 
 const PANE_PROPS = {
   title: 'Map',
@@ -179,6 +185,9 @@ const rig = (on: On, engine?: any) => {
     // The UAT read's answer: one row per open UAT ticket, `{ number, body, labels }` (the scope label rides
     // in `labels`); null makes the read fail. `uatErrors` answers a reply with `errors`, `uatBroken` non-JSON.
     uat: [] as unknown[] | null,
+    // My open tickets on any map or the whiteboard (the `issue()` shape); null makes the read fail.
+    mine: [] as unknown[] | null,
+    mineCalls: [] as (readonly string[])[],
     uatErrors: false,
     uatBroken: false,
     dashboard: DASHBOARD as unknown[],
@@ -209,6 +218,8 @@ const rig = (on: On, engine?: any) => {
     calls: [] as (readonly string[])[],
     panes: [] as { id: string; title: string; isShown: boolean; isFocused: boolean; isPlaced: boolean }[],
     isPlaced: true,
+    // Why `ui.open` leaves the pane unplaced (the SDK's `reason`).
+    reason: 'terminal too narrow',
     logs: [] as string[],
     toasts: [] as string[],
     // What a Bash call prints on stdout (the created issue's URL for a `gh issue create`).
@@ -373,15 +384,18 @@ const rig = (on: On, engine?: any) => {
     return { value: undefined }
   })
   on('session.repo', () => (r.repoFails ? { deny: 'repo read failed' } : { value: r.repo }))
+  // A checkout in `gone` no longer exists on disk; nothing else is listed beside it.
+  on('fs.exists', (_$, e) => ({ value: !r.gone.includes(e.path) }))
+  on('fs.list', () => ({ value: [] }))
   on('session.root', () => ({ value: r.sessionRoot }))
   on('session.cwd', () => ({ value: r.cwd }))
   on('process.run', async (_$, e) => {
     // The pin's own `git rev-parse --show-toplevel`: answered apart, never counted as a `gh` call.
-    if (e.argv[0] === 'git') {
-      r.gitCalls.push({ argv: [...e.argv], cwd: e.init?.cwd })
+    if (unscrub(e.argv)[0] === 'git') {
+      r.gitCalls.push({ argv: [...unscrub(e.argv)], cwd: e.init?.cwd })
       // Answered per directory, like git: the worktree gives `top`, the other checkouts their own root.
       const where = e.init?.cwd
-      if (e.argv[1] === 'remote') {
+      if (unscrub(e.argv)[1] === 'remote') {
         const remote = r.gitRemote === null ? { exitCode: 2, stdout: '', stderr: '' } : { exitCode: 0, stdout: `${r.gitRemote}\n`, stderr: '' }
         return { value: { ...remote, isStdoutTruncated: false, isStderrTruncated: false } }
       }
@@ -390,21 +404,31 @@ const rig = (on: On, engine?: any) => {
       return { value: { ...out, isStdoutTruncated: false, isStderrTruncated: false } }
     }
     // The pin's host check: answered apart, never counted as a read of the pane.
-    if (e.argv[1] === 'auth') {
-      const host = e.argv[4] ?? ''
+    if (unscrub(e.argv)[1] === 'auth') {
+      const host = unscrub(e.argv)[4] ?? ''
       r.authCalls.push(host)
       const out = r.authHosts.includes(host) ? { exitCode: 0, stdout: '', stderr: '' } : { exitCode: 1, stdout: '', stderr: `You are not logged into any accounts on ${host}` }
       return { value: { ...out, isStdoutTruncated: false, isStderrTruncated: false } }
     }
-    r.calls.push([...e.argv])
+    if (isLoginRead(unscrub(e.argv)) || isMineRead(unscrub(e.argv))) {
+      r.mineCalls.push([...unscrub(e.argv)])
+      const body = isLoginRead(unscrub(e.argv))
+        ? { data: { viewer: { login: 'me' } } }
+        : { data: { repository: { issues: { nodes: (r.mine ?? []).map(flatNode), pageInfo: { hasNextPage: false, endCursor: null } } } } }
+      const out = r.mine === null && isMineRead(unscrub(e.argv)) ? { exitCode: 1, stdout: '', stderr: 'boom' } : { exitCode: 0, stdout: JSON.stringify(body), stderr: '' }
+      return { value: { ...out, isStdoutTruncated: false, isStderrTruncated: false } }
+    }
+    r.calls.push([...unscrub(e.argv)])
     r.cwds.push(e.init?.cwd)
     // `gh` needs a repo around it: without its own cwd it uses the session's, wherever a `cd` left it.
     const where = e.init?.cwd ?? r.cwd
+    // A spawn in a deleted directory fails the way a missing binary does.
+    if (r.gone.includes(where)) return { deny: 'spawn gh ENOENT' }
     if (where !== ROOT && where !== ROOT_OTHER && where !== ROOT_TREE) {
       return { value: { exitCode: 1, stdout: '', stderr: 'failed to run git: fatal: not a git repository', isStdoutTruncated: false, isStderrTruncated: false } }
     }
     if (r.deny !== null) return { deny: r.deny }
-    const out = await (r.gh ?? defaultGh)(e.argv)
+    const out = await (r.gh ?? defaultGh)(unscrub(e.argv))
     return { value: { ...out, isStdoutTruncated: false, isStderrTruncated: false } }
   })
   on('ui.open', (_$, e) => {
@@ -413,7 +437,7 @@ const rig = (on: On, engine?: any) => {
       ...r.panes.filter(p => p.id !== e.id),
       { id: e.id, title: e.title ?? e.id, isShown: true, isFocused: false, isPlaced: r.isPlaced },
     ]
-    return { value: r.isPlaced ? { isPlaced: true as const } : { isPlaced: false as const, reason: 'terminal too narrow' } }
+    return { value: r.isPlaced ? { isPlaced: true as const } : { isPlaced: false as const, reason: r.reason } }
   })
   on('ui.close', (_$, e) => {
     r.panes = r.panes.filter(p => p.id !== e.id)
@@ -426,6 +450,7 @@ const rig = (on: On, engine?: any) => {
   on('turn.start', (_$, e) => ({ turnId: e.turnId }))
   on('turn.complete', () => ({ text: '' }))
   on('session.end', (_$, e) => ({ sessionId: e.sessionId }))
+  on('session.attach', (_$, e) => ({ clientId: e.clientId }))
   on('ui.render', () => ({ type: 'Box', props: { key: 'engine' }, children: [] }))
   return r
 }
@@ -439,6 +464,8 @@ const BAND_PROPS = {
   scroll: { offset: 0, bodyRows: 10 },
   view: {},
 } as const
+// What the command answers for an undrawn pane (never the host's raw reason).
+const NOT_SHOWN = 'Map panel is open but not shown yet: it appears once the screen can place it.'
 const FULLSCREEN = { columns: 200, rows: 50, isFullscreen: true } as const
 
 const START = { cwd: '/repo', surface: 'terminal', isInteractive: true } as const
@@ -495,13 +522,24 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'head-frontier')).toBe('Frontier · 3')
     expect(await textOf(ui, 'head-in-progress')).toBe('In progress · 2')
     expect(await textOf(ui, 'head-blocked')).toBe('Blocked · 2')
-    expect((await ui.find({ key: 'head-frontier' }))?.children[0]).toMatchObject({ props: { bold: true } })
-    expect(await keysOf(ui, 'row-')).toEqual(['row-209', 'row-210', 'row-214', 'row-208', 'row-212', 'row-211', 'row-213'])
+    expect((await ui.find({ key: 'head-frontier' }))?.children[0]).toMatchObject({ props: { bold: true, color: '#9ece6a' } })
+    // ogni sezione ha il suo glifo e un filetto colorato davanti a ogni riga
+    expect(await textOf(ui, 'glyph-frontier')).toBe('◆ ')
+    expect(await textOf(ui, 'glyph-blocked')).toBe('■ ')
+    if (surface === 'terminal') {
+      expect(await textOf(ui, 'gutter-209')).toBe('│ ')
+      expect((await ui.find({ key: 'gutter-211' }))?.children[0]).toMatchObject({ props: { color: '#f7768e' } })
+    } else {
+      // sul desktop il filetto è una barra continua, alta quanto il blocco
+      expect((await ui.find({ key: 'gutter-211-bar' }))?.props).toMatchObject({ backgroundColor: '#f7768e' })
+    }
+    expect(await keysOf(ui, 'row-')).toEqual(['row-208', 'row-212', 'row-209', 'row-210', 'row-214', 'row-211', 'row-213'])
 
     expect(await textOf(ui, 'ticket-209')).toBe('#209 Burn-down view of the map')
     expect(await textOf(ui, 'type-209')).toBe(' build')
-    expect((await ui.find({ key: 'type-209' }))?.children[0]).toMatchObject({ props: { dimColor: true } })
+    expect((await ui.find({ key: 'type-209' }))?.children[0]).toMatchObject({ props: { color: '#7dcfff' } })
     expect(await textOf(ui, 'type-214')).toBe(' decision')
+    expect((await ui.find({ key: 'type-214' }))?.children[0]).toMatchObject({ props: { color: '#ff9e64' } })
     const links = (await ui.findAll({ type: 'Link' })).map((l: any) => l.props.href)
     expect(links).toContain(`${URL}/209`)
 
@@ -527,6 +565,7 @@ for (const surface of SURFACES) {
     // the quarantined ticket is counted, never listed
     expect(await ui.find({ key: 'row-215' })).toBeUndefined()
     expect(await textOf(ui, 'unverified')).toBe('1 unverified ticket hidden (quarantined)')
+    expect((await ui.find({ key: 'unverified' }))?.children[0]).toMatchObject({ props: { color: '#e0af68' } })
     expect(await textOf(ui, 'age')).toBe('updated just now')
   })
 
@@ -550,16 +589,20 @@ for (const surface of SURFACES) {
 
     expect(await textOf(ui, 'head-uat')).toBe('UAT · 3')
     expect((await ui.find({ key: 'head-uat' }))?.children[0]).toMatchObject({ props: { bold: true } })
-    expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-frontier', 'group-in-progress', 'group-uat', 'group-paused', 'group-blocked'])
+    expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-in-progress', 'group-frontier', 'group-uat', 'group-paused', 'group-blocked'])
     // each ticket once: a UAT row is in no other group, a paused UAT stays under Paused
     expect(await keysOf(ui, 'row-')).toEqual([
-      'row-209', 'row-210', 'row-214', 'row-208', 'row-212', 'row-240', 'row-241', 'row-242', 'row-243', 'row-211', 'row-213',
+      'row-208', 'row-212', 'row-209', 'row-210', 'row-214', 'row-240', 'row-241', 'row-242', 'row-243', 'row-211', 'row-213',
     ])
     expect(await textOf(ui, 'head-frontier')).toBe('Frontier · 3')
     expect(await textOf(ui, 'head-paused')).toBe('Paused · 1')
     // the parent line, dim, under the row; none without a parent
     expect(await textOf(ui, 'uat-of-240')).toBe('tests Burn-down view of the map #209')
     expect((await ui.find({ key: 'uat-of-240' }))?.children[0]).toMatchObject({ props: { dimColor: true } })
+    // la riga del genitore sta nel blocco del ticket, dopo il filetto che copre entrambe le righe
+    expect(await keysOf(ui, 'entry-lines-240')).toEqual(['entry-lines-240'])
+    expect(await textOf(ui, 'entry-lines-240')).toContain('tests Burn-down view of the map #209')
+    if (surface === 'terminal') expect(await textOf(ui, 'gutter-240')).toBe('│ │ ')
     expect(await textOf(ui, 'uat-of-241')).toBe('tests #212')
     expect(await hasKey(ui, 'uat-of-242')).toBe(false)
     expect(await textOf(ui, 'uat-of-243')).toBe('tests Paused parent #150')
@@ -654,7 +697,7 @@ for (const surface of SURFACES) {
     expect(r.calls.filter(isUatRead)).toContainEqual(uatCall())
     expect(r.calls.filter(isUatSearch)).toEqual([])
     expect(await textOf(ui, 'head-uat')).toBe('UAT · 1')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-306', 'row-303'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-306', 'row-303'])
     expect(await textOf(ui, 'uat-of-306')).toBe('tests Loose parent #290')
   })
 
@@ -675,8 +718,8 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'head-in-progress')).toBe('In progress · 2')
     expect(await textOf(ui, 'head-blocked')).toBe('Blocked · 2')
     // a paused ticket appears in one group only: Frontier, In progress, Paused, Blocked in order
-    expect(await keysOf(ui, 'row-')).toEqual(['row-209', 'row-210', 'row-214', 'row-208', 'row-212', 'row-230', 'row-231', 'row-232', 'row-211', 'row-213'])
-    expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-frontier', 'group-in-progress', 'group-paused', 'group-blocked'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-208', 'row-212', 'row-209', 'row-210', 'row-214', 'row-230', 'row-231', 'row-232', 'row-211', 'row-213'])
+    expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-in-progress', 'group-frontier', 'group-paused', 'group-blocked'])
     for (const n of [230, 231, 232]) {
       expect(await hasKey(ui, `resume-${n}`)).toBe(true)
       expect(await hasKey(ui, `work-${n}`)).toBe(false)
@@ -692,12 +735,12 @@ for (const surface of SURFACES) {
     const ui = await openAndMount($, r)
     await pressDashboard(ui, r)
     expect(await textOf(ui, 'head-paused')).toBe('Paused · 1')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-305', 'row-303'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-305', 'row-303'])
     expect(await hasKey(ui, 'work-305')).toBe(false)
     expect(await hasKey(ui, 'resume-305')).toBe(true)
   })
 
-  test(`needs-you tickets sit in their own group first, once each, with a work button unless held [${surface}]`, async ($, on) => {
+  test(`needs-you tickets sit in their own group right after In progress, once each, with a work button unless held [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     r.tickets = [
       ...TICKETS,
@@ -713,9 +756,9 @@ for (const surface of SURFACES) {
 
     expect(await textOf(ui, 'head-needs-you')).toBe('Needs you · 6')
     expect((await ui.find({ key: 'head-needs-you' }))?.children[0]).toMatchObject({ props: { bold: true } })
-    expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-needs-you', 'group-frontier', 'group-in-progress', 'group-blocked'])
-    // each ticket once, ahead of the frontier rows; the other counts leave them out
-    expect(await keysOf(ui, 'row-')).toEqual(['row-250', 'row-251', 'row-252', 'row-253', 'row-254', 'row-255', 'row-209', 'row-210', 'row-214', 'row-208', 'row-212', 'row-211', 'row-213'])
+    expect(await keysOf(ui, 'group-')).toEqual(['group-maps', 'group-in-progress', 'group-needs-you', 'group-frontier', 'group-blocked'])
+    // each ticket once, after my in-progress rows and ahead of the frontier rows; the other counts leave them out
+    expect(await keysOf(ui, 'row-')).toEqual(['row-208', 'row-212', 'row-250', 'row-251', 'row-252', 'row-253', 'row-254', 'row-255', 'row-209', 'row-210', 'row-214', 'row-211', 'row-213'])
     expect(await textOf(ui, 'head-frontier')).toBe('Frontier · 3')
     expect(await hasKey(ui, 'head-paused')).toBe(false)
     expect(await hasKey(ui, 'head-uat')).toBe(false)
@@ -738,16 +781,16 @@ for (const surface of SURFACES) {
     expect(r.runs).toEqual([{ command: 'clear', args: '' }, { command: 'trailhead:work', args: '251' }])
   })
 
-  test(`the dashboard view puts a needs-you whiteboard ticket first in its own group [${surface}]`, async ($, on) => {
+  test(`the dashboard view puts a needs-you whiteboard ticket in its own group right after In progress [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     r.whiteboard = [...WHITEBOARD, issue(307, 'Loose needs you', [...WB, 'trailhead:task', 'trailhead:needs-you', 'trailhead:paused'])]
     await $.session.start(START)
     const ui = await openAndMount($, r)
     await pressDashboard(ui, r)
     expect(await textOf(ui, 'head-needs-you')).toBe('Needs you · 1')
-    // first ticket group, right after the maps group
-    expect((await keysOf(ui, 'group-')).slice(0, 2)).toEqual(['group-maps', 'group-needs-you'])
-    expect((await keysOf(ui, 'row-'))[0]).toBe('row-307')
+    // right after the maps group and In progress
+    expect((await keysOf(ui, 'group-')).slice(0, 3)).toEqual(['group-maps', 'group-in-progress', 'group-needs-you'])
+    expect((await keysOf(ui, 'row-')).slice(0, 2)).toEqual(['row-302', 'row-307'])
     expect(await hasKey(ui, 'head-paused')).toBe(false)
     expect(await hasKey(ui, 'work-307')).toBe(true)
     expect(await hasKey(ui, 'resume-307')).toBe(false)
@@ -1107,6 +1150,17 @@ for (const surface of SURFACES) {
     expect(await reasonFor(() => (r.gh = () => ({ exitCode: 1, stdout: '', stderr: 'boom' })))).toMatch(/^⚠ gh failed \(exit 1\) · list from /)
   })
 
+  test(`a pinned checkout that is gone is named, not blamed on gh [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    r.gone = [ROOT]
+    await r.clock.advance(FLOOR)
+    await completeTurn($)
+    await settle(r)
+    expect(await textOf(ui, 'age')).toMatch(/^⚠ checkout not found: \/repo · list from /)
+  })
+
   test(`a first fetch that fails shows the reason without a list [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     r.gh = () => ({ exitCode: 1, stdout: '', stderr: 'boom' })
@@ -1280,6 +1334,22 @@ for (const surface of SURFACES) {
     expect(listReads(r)).toEqual([])
   })
 
+  // A heredoc body is data: a write-looking line inside one starts no read, a real write after it still does (#369).
+  test(`a heredoc body that names a tracker write starts no pane read [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    await openAndMount($, r)
+    await r.clock.advance(FLOOR)
+    const before = fetches(r)
+    await $.tool.call({ tool: 'Bash', command: "cat > /tmp/x.md <<'EOF'\ngh issue close 209\nEOF" } as never)
+    await settle(r)
+    expect(fetches(r)).toBe(before)
+
+    await $.tool.call({ tool: 'Bash', command: "cat > /tmp/x.md <<'EOF'\nbody\nEOF\ngh issue close 209" } as never)
+    await settle(r)
+    expect(fetches(r)).toBe(before + 1)
+  })
+
   // The reads asked while the pane was undrawn (the person on another session) are dropped: drawn again with a
   // list older than one slow-timer period, the pane reads at once instead of showing a closed ticket.
   test(`a pane drawn again with an overdue list reads at once [${surface}]`, async ($, on) => {
@@ -1370,7 +1440,7 @@ for (const surface of SURFACES) {
     await $.session.start(START)
     const ui = await openAndMount($, r)
     await pressDashboard(ui, r)
-    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-303'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-303'])
   })
 
   test(`a write that reads at once is followed by one more read at the floor's end [${surface}]`, async ($, on) => {
@@ -1462,6 +1532,34 @@ for (const surface of SURFACES) {
     }
   })
 
+  test(`a multi-line Bash write refreshes, a multi-line read does not [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    await openAndMount($, r)
+    const heredoc = "cat > /tmp/x.md <<'EOF'\nbody line\nEOF"
+    const base = fetches(r)
+    for (const command of [`${heredoc}\ngh issue view 5`, `${heredoc}\ngh issue list --state open`]) {
+      await r.clock.advance(FLOOR)
+      await $.tool.call({ tool: 'Bash', command } as never)
+      await settle(r)
+    }
+    expect(fetches(r)).toBe(base)
+
+    for (const command of [`${heredoc}\ncd /repo && gh issue edit 325 --title "t"`, `${heredoc}\ngh issue create --body-file /tmp/x.md`]) {
+      // until a whole floor passes with no read (the previous write's follow-up, the slow timer), so this write starts outside one
+      let seen = -1
+      while (seen !== fetches(r)) {
+        seen = fetches(r)
+        await r.clock.advance(FLOOR)
+        await settle(r)
+      }
+      const before = fetches(r)
+      await $.tool.call({ tool: 'Bash', command } as never)
+      await settle(r)
+      expect([command, fetches(r)]).toEqual([command, before + 1])
+    }
+  })
+
   test(`closing the pane stops refreshing [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     await $.session.start(START)
@@ -1623,9 +1721,11 @@ for (const surface of SURFACES) {
     // The token the verb receives decodes (plain base64url, the helper's alphabet) to the pinned root; the suite has no Buffer.
     const [number, word] = r.runs[1].args.split(' ')
     expect(number).toBe('209')
-    expect(word).toMatch(/^--in=[A-Za-z0-9_-]+$/)
+    expect(word).toMatch(/^--in=[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/)
     expect(word).toBe(IN(ROOT))
-    expect(atob(word.slice('--in='.length).replace(/-/g, '+').replace(/_/g, '/'))).toBe(ROOT)
+    const [rootPart, repoPart] = word.slice('--in='.length).split('.')
+    expect(atob(rootPart.replace(/-/g, '+').replace(/_/g, '/'))).toBe(ROOT)
+    expect(atob(repoPart.replace(/-/g, '+').replace(/_/g, '/').padEnd(Math.ceil(repoPart.length / 4) * 4, '='))).toBe('github.com/o/r')
     expect(await ui.find({ key: 'queued-209' })).toBeUndefined()
     expect(await ui.find({ key: 'work-209' })).toBeDefined()
   })
@@ -2280,7 +2380,7 @@ for (const surface of SURFACES) {
     await settle(r)
     expect(await textOf(ui, 'map')).toBe('#14 older map')
     expect(await textOf(ui, 'viewing-text')).toBe('viewing #14 · active #198')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
   })
 
   test(`the refresh button obeys the same floor [${surface}]`, async ($, on) => {
@@ -2367,17 +2467,60 @@ for (const surface of SURFACES) {
     expect(r.logs).toEqual([])
   })
 
-  test(`/trailhead:panel says why a pane cannot be placed [${surface}]`, async ($, on) => {
+  test(`/trailhead:panel says plainly that a pane cannot be placed yet [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     r.isPlaced = false
     await $.session.start(START)
-    expect((await panel($)).text).toBe('Map panel not shown: terminal too narrow')
+    expect((await panel($)).text).toBe(NOT_SHOWN)
     await settle(r)
     expect(fetches(r)).toBe(0)
-    // a pane waiting undrawn can still be closed
+    // a pane the person never saw is not closed by a repeat: it stays open, undrawn, until it can be placed
+    expect((await panel($)).text).toBe(NOT_SHOWN)
+    expect((await panel($)).text).toBe(NOT_SHOWN)
+    expect(r.panes.map(p => [p.id, p.isPlaced])).toEqual([[PANE, false]])
+    // placed at last, the command sees it drawn and closes it
+    r.isPlaced = true
+    expect((await panel($)).text).toBe('Map panel opened.')
+    expect((await panel($)).text).toBe('Map panel closed.')
+    expect(r.panes).toEqual([])
+  })
+
+  // #348: l'auto-open su una superficie che non ha ancora comunicato il layout resta non disegnato; il comando
+  // non deve chiudere un pannello che la persona non ha mai visto.
+  test(`/trailhead:panel never closes a pane the auto-open left undrawn on a surface without layout [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.isPlaced = false
+    r.reason = 'attached surfaces place no panes: desktop has not reported its layout'
+    await $.session.start(START)
+    await mountBand($, FULLSCREEN)
+    await settle(r)
+    expect(r.panes.map(p => [p.id, p.isPlaced])).toEqual([[PANE, false]])
+
+    const shown = NOT_SHOWN
+    expect((await panel($)).text).toBe(shown)
+    expect((await panel($)).text).toBe(shown)
+    expect(r.panes.map(p => [p.id, p.isPlaced])).toEqual([[PANE, false]])
+
+    // the layout arrives: the command draws it, and only then does a repeat close it
+    r.isPlaced = true
+    expect((await panel($)).text).toBe('Map panel opened.')
     expect((await panel($)).text).toBe('Map panel closed.')
   })
 
+  // #321: nessuna superficie collegata (inizio sessione) non è un errore: il pannello resta aperto in attesa.
+  test(`/trailhead:panel with no surface attached keeps the pane pending and says so plainly [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.isPlaced = false
+    r.reason = 'no-surface: no surface is attached ($.session.surfaces() is empty)'
+    await $.session.start(START)
+    const pending = 'Map panel will open as soon as the screen is ready.'
+    expect((await panel($)).text).toBe(pending)
+    expect(r.panes.map(p => p.id)).toEqual([PANE])
+    // a second command while still pending is idempotent: it never closes the pane
+    expect((await panel($)).text).toBe(pending)
+    expect(r.panes.map(p => p.id)).toEqual([PANE])
+  })
+
   test(`/trailhead:panel shows a pane the auto-open left undrawn instead of closing it [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     // sessione vuota, terminale sotto la soglia dei pannelli non richiesti: l'auto-open resta non disegnato
@@ -2399,6 +2542,148 @@ for (const surface of SURFACES) {
     expect(r.panes).toEqual([])
   })
 
+  // #348: un auto-open che resta non disegnato non conta come fatto, così un trigger successivo può riprovare.
+  test(`an auto-open left undrawn does not end the auto-open, a drawn pane does [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.isPlaced = false
+    r.reason = 'attached surfaces place no panes: desktop has not reported its layout'
+    await $.session.start(START)
+    await mountBand($, FULLSCREEN)
+    await settle(r)
+    expect(r.opens).toHaveLength(1)
+
+    // listed but undrawn: further renders do not open it again (the host places it when it can)
+    await mountBand($, FULLSCREEN)
+    await settle(r)
+    expect(r.opens).toHaveLength(1)
+
+    // the host dropped it while still undrawn: the next render tries again
+    r.panes = []
+    await mountBand($, FULLSCREEN)
+    await settle(r)
+    expect(r.opens).toHaveLength(2)
+
+    // drawn at last: its own render completes the auto-open for good
+    r.panes = r.panes.map(p => ({ ...p, isPlaced: true }))
+    await mountPane($)
+    await settle(r)
+    r.panes = []
+    await mountBand($, FULLSCREEN)
+    await settle(r)
+    expect(r.opens).toHaveLength(2)
+  })
+
+  test(`an auto-open that finds the pane listed and drawn ends the auto-open [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.isPlaced = false
+    await $.session.start(START)
+    await mountBand($, FULLSCREEN)
+    await settle(r)
+    expect(r.opens).toHaveLength(1)
+
+    // placed by the host with no pane render yet (the pane's render needs the dock): the next band render sees it
+    r.panes = r.panes.map(p => ({ ...p, isPlaced: true }))
+    await mountBand($, FULLSCREEN)
+    await settle(r)
+    r.panes = []
+    await mountBand($, FULLSCREEN)
+    await settle(r)
+    expect(r.opens).toHaveLength(1)
+  })
+
+  test(`the person's own request on an undrawn pane ends the auto-open, a close of it stays closed [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.isPlaced = false
+    await $.session.start(START)
+    await mountBand($, FULLSCREEN)
+    await settle(r)
+    expect(r.opens).toHaveLength(1)
+
+    // the command is the person acting on it: the auto-open is done even though the pane is still undrawn
+    expect((await panel($)).text).toBe(NOT_SHOWN)
+    expect(r.opens).toHaveLength(2)
+    r.panes = []
+    await mountBand($, FULLSCREEN)
+    await settle(r)
+    expect(r.opens).toHaveLength(2)
+  })
+
+  // Il desktop avvia la sessione al primo invio: il comando che l'ha avviata arriva subito dopo l'auto-open.
+  test(`/trailhead:panel right after the auto-open keeps the pane the person never saw [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    await $.session.attach({ surface, clientId: `${surface}:default`, viewport: FULLSCREEN } as never)
+    await settle(r)
+    expect(r.panes.map(p => p.id)).toEqual([PANE])
+
+    const opened = await panel($)
+    expect(opened.text).toBe('Map panel opened.')
+    expect(r.panes.map(p => p.id)).toEqual([PANE])
+
+    // the next press acts on a pane the person asked for: it closes, however soon
+    const closed = await panel($)
+    expect(closed.text).toBe('Map panel closed.')
+    expect(r.panes).toEqual([])
+  })
+
+  test(`/trailhead:panel closes an auto-opened pane once it has been on screen [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    await $.session.attach({ surface, clientId: `${surface}:default`, viewport: FULLSCREEN } as never)
+    await settle(r)
+    expect(r.panes.map(p => p.id)).toEqual([PANE])
+
+    await r.clock.advance(2_000)
+    const closed = await panel($)
+    expect(closed.text).toBe('Map panel closed.')
+    expect(r.panes).toEqual([])
+  })
+
+  test(`a surface attaching in fullscreen retries the auto-open [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.isPlaced = false
+    r.reason = 'no-surface: no surface is attached ($.session.surfaces() is empty)'
+    await $.session.start(START)
+    await settle(r)
+    expect(r.opens).toEqual([])
+
+    // not fullscreen, or no layout said: the render trigger decides
+    await $.session.attach({ surface, clientId: `${surface}:default`, viewport: { columns: 200, rows: 50, isFullscreen: false } } as never)
+    await $.session.attach({ surface, clientId: `${surface}:default` } as never)
+    await settle(r)
+    expect(r.opens).toEqual([])
+
+    await $.session.attach({ surface, clientId: `${surface}:default`, viewport: FULLSCREEN } as never)
+    await settle(r)
+    expect(r.opens).toHaveLength(1)
+
+    // still undrawn and listed: another attach does not open again
+    await $.session.attach({ surface, clientId: `${surface}:other`, viewport: FULLSCREEN } as never)
+    await settle(r)
+    expect(r.opens).toHaveLength(1)
+  })
+
+  test(`an attach never opens the pane after the person closed it [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    await $.session.start(START)
+    await panel($)
+    await panel($)
+    expect(r.panes).toEqual([])
+    await $.session.attach({ surface, clientId: `${surface}:default`, viewport: FULLSCREEN } as never)
+    await settle(r)
+    expect(r.opens).toHaveLength(1)
+
+  })
+
+  test(`an attach without an active map does not open the pane [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.active = null
+    await $.session.start(START)
+    await $.session.attach({ surface, clientId: `${surface}:default`, viewport: FULLSCREEN } as never)
+    await settle(r)
+    expect(r.opens).toEqual([])
+  })
+
   for (const withBand of [false, true]) {
     test(`the pane opens by itself once in fullscreen, the band ${withBand ? 'drawing' : 'yielding'} [${surface}]`, async ($, on) => {
       const r = rig(on, $)
@@ -2519,7 +2804,7 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'head-maps')).toBe('Maps · 2')
     expect(await keysOf(ui, 'map-row-')).toEqual(['map-row-14', 'map-row-198'])
     expect(await textOf(ui, 'map-mark-198')).toBe('● ')
-    expect((await ui.find({ key: 'map-mark-198' }))?.children[0]).toMatchObject({ props: { color: ACCENT } })
+    expect((await ui.find({ key: 'map-mark-198' }))?.children[0]).toMatchObject({ props: { bold: true, color: '#bb9af7' } })
     expect(await textOf(ui, 'map-aside-198')).toBe(' 7 open / 23 · active')
     expect(await textOf(ui, 'map-label-198')).toBe('#198 trailhead mod')
     expect((await ui.find({ key: 'map-label-198' }))?.children[0]).toMatchObject({ props: { bold: true } })
@@ -2552,7 +2837,7 @@ for (const surface of SURFACES) {
 
     expect(await textOf(ui, 'map')).toBe('#14 older map')
     expect(await textOf(ui, 'destination')).toBe('An older destination.')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
     expect(await textOf(ui, 'holder-141')).toBe('@carol')
     expect(await textOf(ui, 'burndown-counts')).toBe('open 2 · done 0 · removed 0 · peak 2')
     // the ticket in play belongs to the other map: nothing here is marked
@@ -2727,7 +3012,7 @@ for (const surface of SURFACES) {
     await settle(r)
     expect(await hasKey(ui, 'ticket-300')).toBe(false)
     expect(await textOf(ui, 'map')).toBe('#14 older map')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
   })
 
   test(`with no active map the open maps are listed and one can be viewed [${surface}]`, async ($, on) => {
@@ -2757,6 +3042,57 @@ for (const surface of SURFACES) {
     await settle(r)
   }
 
+  // My tickets in play on other maps and the whiteboard, under every view's In progress.
+  const MINE = [
+    issue(150, 'My whiteboard fix', [...WB, 'trailhead:build'], ['me']),
+    issue(160, 'My other map ticket', ['trailhead:ticket', 'trailhead:build', 'trailhead:map-14'], ['me']),
+    issue(161, 'My paused one', ['trailhead:ticket', 'trailhead:build', 'trailhead:map-14', 'trailhead:paused'], ['me']),
+    issue(212, 'Native gh-backed tools', ['trailhead:ticket', 'trailhead:build', 'trailhead:map-198'], ['me']),
+  ]
+
+  test(`the map's In progress adds my tickets of the other maps and the whiteboard, each saying where [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.mine = MINE
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(r.mineCalls[0]).toEqual(['gh', 'api', 'graphql', '-f', 'query=query{viewer{login}}'])
+    expect(r.mineCalls.some(argv => argv.includes('login=me'))).toBe(true)
+    expect(await textOf(ui, 'head-in-progress')).toBe('In progress · 4')
+    // the map's own first, then mine elsewhere; a paused one and one the map already lists are not added
+    expect(await keysOf(ui, 'row-')).toEqual(['row-208', 'row-212', 'row-150', 'row-160', 'row-209', 'row-210', 'row-214', 'row-211', 'row-213'])
+    expect(await textOf(ui, 'scope-of-150')).toBe('on whiteboard')
+    expect(await textOf(ui, 'scope-of-160')).toBe('on map #14 older map')
+    expect((await ui.find({ key: 'scope-of-160' }))?.children[0]).toMatchObject({ props: { dimColor: true } })
+    expect(await textOf(ui, 'holder-160')).toBe('@me')
+    expect(await hasKey(ui, 'scope-of-212')).toBe(false)
+    expect(await hasKey(ui, 'row-161')).toBe(false)
+  })
+
+  test(`the dashboard's In progress adds my tickets of every map [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.mine = MINE
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    await pressDashboard(ui, r)
+    expect(await textOf(ui, 'scope-of-160')).toBe('on map #14 older map')
+    expect(await textOf(ui, 'scope-of-212')).toBe('on map #198 trailhead mod')
+    // a whiteboard ticket of mine belongs to this view's own list, never a second time with a scope line
+    expect(await hasKey(ui, 'scope-of-150')).toBe(false)
+  })
+
+  test(`a failed read of my tickets keeps the last ones and sets no error [${surface}]`, async ($, on) => {
+    const r = rig(on, $)
+    r.mine = MINE
+    await $.session.start(START)
+    const ui = await openAndMount($, r)
+    expect(await hasKey(ui, 'row-160')).toBe(true)
+    r.mine = null
+    await r.clock.advance(TIMER)
+    await settle(r)
+    expect(await hasKey(ui, 'row-160')).toBe(true)
+    expect(await textOf(ui, 'age')).toBe('updated just now')
+  })
+
   test(`the Whiteboard row shows the maps index and the whiteboard tickets [${surface}]`, async ($, on) => {
     const r = rig(on, $)
     await $.session.start(START)
@@ -2792,7 +3128,7 @@ for (const surface of SURFACES) {
     expect(await textOf(ui, 'head-frontier')).toBe('Frontier · 1')
     expect(await textOf(ui, 'head-in-progress')).toBe('In progress · 1')
     expect(await textOf(ui, 'head-blocked')).toBe('Blocked · 1')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-303'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-303'])
     expect(await textOf(ui, 'holder-302')).toBe('@alice')
     expect(await hasKey(ui, 'work-301')).toBe(true)
     expect(await textOf(ui, 'unverified')).toBe('1 unverified ticket hidden (quarantined)')
@@ -3147,7 +3483,7 @@ for (const surface of SURFACES) {
     const ui = await openAndMount($, r)
     await pressDashboard(ui, r)
     expect(await textOf(ui, 'head-whiteboard')).toBe('Whiteboard · 4 open · 2 assigned')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-306', 'row-303'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-306', 'row-303'])
     expect(await textOf(ui, 'holder-302')).toBe('@alice')
     expect(await hasKey(ui, 'resume-306')).toBe(true)
     expect(await hasKey(ui, 'row-305')).toBe(false)
@@ -3176,7 +3512,7 @@ for (const surface of SURFACES) {
     await pressDashboard(ui, r)
     await pressMap(ui, r, 14)
     expect(await textOf(ui, 'map')).toBe('#14 older map')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
 
     await pressDashboard(ui, r)
     await pressMap(ui, r, 198)
@@ -3228,7 +3564,7 @@ for (const surface of SURFACES) {
     const ui = await openAndMount($, r)
     expect(await textOf(ui, 'empty')).toBe('No active map. Run /trailhead:map to pick one.')
     await pressDashboard(ui, r)
-    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-303'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-303'])
     await ui.press({ key: 'to-map' })
     await settle(r)
     expect(await textOf(ui, 'empty')).toBe('No active map. Run /trailhead:map to pick one.')
@@ -3242,7 +3578,7 @@ for (const surface of SURFACES) {
     await $.command.run({ command: 'clear', args: '' } as never)
     await settle(r)
     expect(await textOf(ui, 'dashboard-title')).toBe('Dashboard')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-301', 'row-302', 'row-303'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-302', 'row-301', 'row-303'])
   })
   test(`the pane keeps its repo when the session cwd moves out of it [${surface}]`, async ($, on) => {
     const r = rig(on, $)
@@ -3281,7 +3617,7 @@ for (const surface of SURFACES) {
     await completeTurn($)
     await settle(r)
     expect(await textOf(ui, 'map')).toBe('#14 older map')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
     expect(r.calls).toContainEqual(MAPS_CALL)
     expect(r.cwds.every(cwd => cwd === ROOT_OTHER)).toBe(true)
     // The toplevel is read where the session now is, not at its project root, which a shell `cd` leaves behind.
@@ -3369,7 +3705,7 @@ for (const surface of SURFACES) {
     await $.turn.start({ text: 'go', turnId: 'race-1' })
     release()
     await settle(r)
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
   })
 
   test(`a refresh in flight when the pin moves to another checkout of the same repo is read again [${surface}]`, async ($, on) => {
@@ -3401,7 +3737,7 @@ for (const surface of SURFACES) {
     await r.clock.advance(FLOOR)
     await settle(r)
     // The dropped read is repeated: the pane shows the new tracker state, not the old list.
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
   })
 
   test(`a same-repo pin move landing inside the stale check is read again [${surface}]`, async ($, on) => {
@@ -3433,7 +3769,7 @@ for (const surface of SURFACES) {
     await settle(r)
     await r.clock.advance(FLOOR)
     await settle(r)
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
   })
 
   test(`a dashboard read in flight when the pin moves to another checkout of the same repo is read again [${surface}]`, async ($, on) => {
@@ -3562,7 +3898,7 @@ for (const surface of SURFACES) {
     expect(await keysOf(ui, 'row-')).not.toContain('row-209')
     await settle(r)
     expect(await textOf(ui, 'map')).toBe('#14 older map')
-    expect(await keysOf(ui, 'row-')).toEqual(['row-140', 'row-141'])
+    expect(await keysOf(ui, 'row-')).toEqual(['row-141', 'row-140'])
   })
 
   // The panel follows the whiteboard ticket this session takes (#306).