@marcomigozzi/trailhead 0.17.0 → 0.18.0

package/plugins/trailhead/templates/trailhead-uat-backfill.js

@@ -18,6 +18,7 @@
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { gitEnv } = require('./trailhead-git-env.js');
 
 const LABEL = 'trailhead:uat';
 const COLOR = 'BFD4F2';
@@ -27,7 +28,7 @@ const LIMIT = 1000;
 const UAT_LINE_RE = /^UAT of:/m;
 
 function defaultGh(args) {
-  const r = spawnSync('gh', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  const r = spawnSync('gh', args, { encoding: 'utf8', env: gitEnv(), maxBuffer: 64 * 1024 * 1024 });
   return { status: r.status === null ? 1 : r.status, stdout: r.stdout || '', stderr: r.stderr || (r.error ? String(r.error.message) : '') };
 }
 

package/plugins/trailhead/templates/trailhead-uat-followup.js

@@ -25,13 +25,14 @@
 // Exit 0 on ok, 1 on an error, 2 on a usage error (stderr).
 
 const { spawnSync } = require('child_process');
+const { gitEnv } = require('./trailhead-git-env.js');
 
 const MAX_PAGES = 100; // 100 pages x 100 issues
 const QUERY = 'query($owner:String!,$name:String!,$after:String){repository(owner:$owner,name:$name){issues(first:100,after:$after,labels:["trailhead:uat"],states:[OPEN,CLOSED],orderBy:{field:CREATED_AT,direction:ASC}){nodes{number title state body} pageInfo{hasNextPage endCursor}}}}';
 const URL_RE = /https:\/\/github\.com\/([^/\s)]+)\/([^/\s)]+)\/issues\/(\d+)(?![\w])/gi;
 
 function defaultGh(args) {
-  const r = spawnSync('gh', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  const r = spawnSync('gh', args, { encoding: 'utf8', env: gitEnv(), maxBuffer: 64 * 1024 * 1024 });
   return { status: r.status === null ? 1 : r.status, stdout: r.stdout || '', stderr: r.stderr || (r.error ? String(r.error.message) : '') };
 }
 

package/plugins/trailhead/templates/trailhead-uat-setup.js

@@ -46,6 +46,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { gitEnv } = require('./trailhead-git-env.js');
 
 const CONFIG_REL = path.join('.trailhead', 'config.json');
 const OUTPUT_TAIL = 2000;
@@ -118,8 +119,12 @@ function pick(cfg, key, file) {
   return out;
 }
 
+// Su Codex lo script vive in <codexHome>/skills/trailhead/<dir>: la config globale sta lì, non in ~/.claude.
+const CODEX_INSTALL = /[\\/]skills[\\/]trailhead[\\/](?:hooks|templates)$/;
+const codexHome = () => (CODEX_INSTALL.test(__dirname) ? path.resolve(__dirname, '..', '..', '..') : null);
+
 function globalConfigPath(env) {
-  const base = env.CLAUDE_CONFIG_DIR || path.join(env.HOME || os.homedir(), '.claude');
+  const base = codexHome() || env.CLAUDE_CONFIG_DIR || path.join(env.HOME || os.homedir(), '.claude');
   return path.join(base, 'trailhead', 'config.json');
 }
 
@@ -257,7 +262,7 @@ function redactor(names, env) {
 function sh(command, repo, env, timeoutMs, wantOutput) {
   const timeout = Math.max(1, Math.ceil(timeoutMs));
   if (!wantOutput) {
-    const r = spawnSync('sh', ['-c', command], { cwd: repo, env, stdio: 'ignore', timeout, killSignal: 'SIGKILL' });
+    const r = spawnSync('sh', ['-c', command], { cwd: repo, env: gitEnv(env), stdio: 'ignore', timeout, killSignal: 'SIGKILL' });
     const timedOut = Boolean(r.error && r.error.code === 'ETIMEDOUT');
     return { code: r.status, timedOut, spawnError: r.error && !timedOut ? r.error.message : null, tail: '' };
   }
@@ -265,7 +270,7 @@ function sh(command, repo, env, timeoutMs, wantOutput) {
   const file = path.join(dir, 'out');
   const fd = fs.openSync(file, 'w');
   try {
-    const r = spawnSync('sh', ['-c', command], { cwd: repo, env, stdio: ['ignore', fd, fd], timeout, killSignal: 'SIGKILL' });
+    const r = spawnSync('sh', ['-c', command], { cwd: repo, env: gitEnv(env), stdio: ['ignore', fd, fd], timeout, killSignal: 'SIGKILL' });
     const timedOut = Boolean(r.error && r.error.code === 'ETIMEDOUT');
     const res = { code: r.status, timedOut, spawnError: r.error && !timedOut ? r.error.message : null, tail: '' };
     if (wantOutput) {
@@ -377,7 +382,7 @@ function main(argv, { cwd, stdout, env, fs: fsMod } = {}) {
   return 0;
 }
 
-module.exports = { parseArgs, readConfig, main };
+module.exports = { globalConfigPath, parseArgs, readConfig, main };
 
 if (require.main === module) {
   const code = main(process.argv.slice(2), { cwd: process.cwd(), stdout: process.stdout, env: process.env });

package/plugins/trailhead/templates/trailhead-unblock.js

@@ -21,11 +21,12 @@
 // Exit 0 on ok, 1 on an error, 2 on a usage error (stderr).
 
 const { spawnSync } = require('child_process');
+const { gitEnv } = require('./trailhead-git-env.js');
 
 const LABEL = 'trailhead:blocked';
 
 function defaultGh(args) {
-  const r = spawnSync('gh', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  const r = spawnSync('gh', args, { encoding: 'utf8', env: gitEnv(), maxBuffer: 64 * 1024 * 1024 });
   return { status: r.status === null ? 1 : r.status, stdout: r.stdout || '', stderr: r.stderr || (r.error ? String(r.error.message) : '') };
 }
 

package/plugins/trailhead/tests/auto-run-ui.test.ts

@@ -1,5 +1,6 @@
 import type { On } from 'claude-code'
 import { expect, test } from 'claude-code/testing'
+import { unscrub } from './unscrub'
 
 import { resetAutoRun } from '../hooks/mod/auto-run'
 import { resetLocate } from '../hooks/mod/work-state-locate'
@@ -47,7 +48,7 @@ const rig = (on: On) => {
   on('session.cwd', () => ({ value: r.cwd }))
   on('session.id', () => ({ value: SESSION }))
   on('process.run', (_$, e) => {
-    const line = e.argv.join(' ')
+    const line = unscrub(e.argv).join(' ')
     r.runs.push(line)
     r.cwds.push(e.cwd ?? '')
     const out = (stdout: string, exitCode = 0) => ({ value: { exitCode, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } })

package/plugins/trailhead/tests/git-env.test.ts

@@ -0,0 +1,20 @@
+import { expect, test } from 'claude-code/testing'
+
+import { GIT_LOCATION_VARS, gitArgv, scrubGitEnv } from '../hooks/mod/git-env'
+import { unscrub } from './unscrub'
+
+test('gitArgv wraps git in env -u for every repo-location variable', () => {
+  const argv = gitArgv('-C', '/repo', 'status')
+  expect(argv.slice(0, 3)).toEqual(['env', '-u', GIT_LOCATION_VARS[0]])
+  for (const name of GIT_LOCATION_VARS) expect(argv).toContain(name)
+  expect(argv.slice(-4)).toEqual(['git', '-C', '/repo', 'status'])
+  expect(unscrub(argv)).toEqual(['git', '-C', '/repo', 'status'])
+})
+
+test('GIT_DIR and GIT_WORK_TREE are scrubbed, GIT_CONFIG* is not', () => {
+  const argv = scrubGitEnv(['gh', 'api', 'graphql'])
+  expect(argv).toContain('GIT_DIR')
+  expect(argv).toContain('GIT_WORK_TREE')
+  expect(argv.some(a => a.startsWith('GIT_CONFIG'))).toBe(false)
+  expect(unscrub(argv)).toEqual(['gh', 'api', 'graphql'])
+})

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'
@@ -383,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 } }
       }
@@ -400,29 +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 } }
     }
-    if (isLoginRead(e.argv) || isMineRead(e.argv)) {
-      r.mineCalls.push([...e.argv])
-      const body = isLoginRead(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(e.argv) ? { exitCode: 1, stdout: '', stderr: 'boom' } : { exitCode: 0, stdout: JSON.stringify(body), stderr: '' }
+      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([...e.argv])
+    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) => {
@@ -444,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
 }
@@ -457,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
@@ -513,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 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`)
 
@@ -545,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')
   })
 
@@ -578,6 +599,10 @@ for (const surface of SURFACES) {
     // 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')
@@ -1125,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' })
@@ -1298,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) => {
@@ -1480,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)
@@ -2387,14 +2467,43 @@ 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.')
   })
 
@@ -2433,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, $)
@@ -2553,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 } })

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

@@ -278,6 +278,12 @@ test('groupTickets lists a needs-you ticket once, under Needs you, ascending, wh
   expect(groupTickets([t(1, 'frontier', { isNeedsYou: false })]).needsYou).toEqual([])
 })
 
+test('failureReason blames the folder, not gh, when the checkout is gone', () => {
+  const error = Object.assign(new Error('spawn gh ENOENT'), { code: 'ENOENT' })
+  expect(failureReason({ error, missingRoot: '/work/r-t5' })).toBe('checkout not found: /work/r-t5')
+  expect(failureReason({ error })).toBe('gh not installed')
+})
+
 test('failureReason names one short cause', () => {
   expect(failureReason({ error: Object.assign(new Error('spawn gh ENOENT'), { code: 'ENOENT' }) })).toBe('gh not installed')
   expect(failureReason({ error: new Error('spawn gh ENOENT') })).toBe('gh not installed')

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

@@ -1,6 +1,9 @@
 import { expect, test } from 'claude-code/testing'
 
-import { GH_ISSUE_WRITE } from '../hooks/mod/map-pane'
+import { GH_ISSUE_WRITE, isTrackerWrite } from '../hooks/mod/map-pane'
+
+// A heredoc that writes a body file, as the model usually runs before a tracker write.
+const HEREDOC = "cat > /tmp/x.md <<'EOF'\nbody line\nEOF"
 
 // Bash commands the pane refreshes on (a write to the tracker) and ones it must ignore.
 const WRITES = [
@@ -25,6 +28,13 @@ const WRITES = [
   "gh api -X PUT 'repos/o/r/issues/5/lock'",
   'gh api repos/o/r/issues/5 --input body.json',
   'node /x/templates/trailhead-issue-body.js append --issue 198 --section "Decisions so far" --line x',
+  // multi-line: a heredoc before the write, or a line on either side of it
+  `${HEREDOC}\ncd /repo && gh issue edit 325 --title "t"`,
+  `${HEREDOC}\ngh issue create --body-file /tmp/x.md`,
+  `${HEREDOC}\ngh issue comment 5 --body-file /tmp/x.md`,
+  'echo hi\ngh issue close 5',
+  'gh issue close 5\necho hi',
+  `${HEREDOC}\nnode /x/templates/trailhead-issue-body.js append --issue 198 --section "Decisions so far" --line x`,
 ]
 const READS = [
   'gh issue list --state open',
@@ -40,6 +50,10 @@ const READS = [
   'gh api repos/o/r/pulls -f state=open',
   'git log && echo gh issue',
   'gh api repos/o/r/issues/5 | jq . ; echo -f x',
+  // multi-line reads
+  `${HEREDOC}\ngh issue view 5`,
+  `${HEREDOC}\ngh issue list --state open`,
+  'cd /repo\ngh api repos/o/r/issues/5',
 ]
 
 test('the write matcher takes the tracker writes of a Bash call', () => {
@@ -49,3 +63,45 @@ test('the write matcher takes the tracker writes of a Bash call', () => {
 test('the write matcher leaves reads alone', () => {
   for (const command of READS) expect([command, GH_ISSUE_WRITE.test(command)]).toEqual([command, false])
 })
+
+// A heredoc body is data, not commands: [command, is it a tracker write]. `\t` is a tab.
+const HEREDOCS: Array<[string, boolean]> = [
+  ['cat >f <<EOF\ngh issue close 5\nEOF', false],
+  ["cat >f <<'EOF'\ngh issue close 5\nEOF", false],
+  ['cat >f <<"EOF"\ngh issue close 5\nEOF', false],
+  ['cat >f <<-EOF\n\tgh issue close 5\n\tEOF', false],
+  ['cat <<A >a; cat <<B >b\ngh issue close 1\nA\ngh issue edit 2\nB', false],
+  ['cat <<A >a; cat <<B >b\nx\nA\ny\nB\ngh issue close 3', true],
+  ['gh issue create --body-file - <<EOF\nbody\nEOF', true],
+  ['gh issue comment 5 -F - <<EOF\ngh issue close 9\nEOF', true],
+  ["cat <<'EOF' >x\nb\nEOF\ngh issue close 5", true],
+  ["cat <<'EOF' >x\nEOF2\ngh issue close 5\n EOF\nEOF", false],
+  ["cat <<'EOF' >x\ngh issue close 5", false],
+  ['cat <<-EOF >x\nb\n  EOF\ngh issue close 5\nEOF', false],
+  ["cat <<< 'x'\ngh issue close 5", true],
+  ['echo $((1<<2))\ngh issue close 5', true],
+  ['echo $((1<<2)); gh issue view 5', false],
+  ["cat <<'EOF' >x\nnode trailhead-issue-body.js append\nEOF", false],
+  ['echo "a <<EOF"\ngh issue close 5', true],
+  // a `<<` in a comment opens nothing, so the write after it stays
+  ['# build body with <<EOF\ngh issue close 5', true],
+  ['git commit -m "x" # see <<EOF\ngh issue close 5', true],
+  ['# build body with <<EOF\ngh issue view 5', false],
+  ['cat a#b <<EOF\ngh issue close 5\nEOF', false],
+  // an opener inside a multi-line quoted string opens nothing
+  ['echo "a\ncat <<EOF\nb"\ngh issue close 5\nEOF', true],
+  ['echo "a\ncat <<EOF\nb"\ngh issue view 5\nEOF', false],
+  // a `<<` inside a parameter expansion opens nothing
+  ['echo ${x:-<<EOF}\ngh issue close 5\nEOF', true],
+  // an apostrophe in a heredoc body leaks no quote state into later lines
+  ["cat <<EOF\nit's\nEOF\ncat <<B\ngh issue close 5\nB", false],
+]
+
+test('isTrackerWrite takes the writes and leaves the reads', () => {
+  for (const command of WRITES) expect([command, isTrackerWrite(command)]).toEqual([command, true])
+  for (const command of READS) expect([command, isTrackerWrite(command)]).toEqual([command, false])
+})
+
+test('isTrackerWrite ignores a heredoc body and keeps a write around it', () => {
+  for (const [command, verdict] of HEREDOCS) expect([command, isTrackerWrite(command)]).toEqual([command, verdict])
+})