@marcomigozzi/trailhead 0.16.1 → 0.18.0

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])
+})

package/plugins/trailhead/tests/my-tickets.test.ts

@@ -0,0 +1,66 @@
+import { expect, test } from 'claude-code/testing'
+
+import { parseTickets } from '../hooks/mod/map-pane-view'
+import { elsewhereInProgress, myTicketsFromRows, parseLogin, scopeLine } from '../hooks/mod/my-tickets'
+
+const row = (number: number, names: string[], logins: string[] = ['me']) => ({
+  number,
+  title: `t${number}`,
+  url: `https://github.com/o/r/issues/${number}`,
+  labels: names.map(name => ({ name })),
+  assignees: logins.map(login => ({ login })),
+})
+
+test('parseLogin reads the viewer login, null on anything else', () => {
+  expect(parseLogin(JSON.stringify({ data: { viewer: { login: 'me' } } }))).toBe('me')
+  expect(parseLogin(JSON.stringify({ data: { viewer: { login: '' } } }))).toBeNull()
+  expect(parseLogin(JSON.stringify({ errors: [{}], data: { viewer: { login: 'me' } } }))).toBeNull()
+  expect(parseLogin('not json')).toBeNull()
+})
+
+test('myTicketsFromRows tags each ticket with its map or the whiteboard, and drops the rest', () => {
+  const mine = myTicketsFromRows([
+    row(5, ['trailhead:ticket', 'trailhead:build', 'trailhead:map-12']),
+    row(6, ['trailhead:ticket', 'trailhead:bug', 'trailhead:whiteboard']),
+    // no scope, contradictory scopes, and quarantined: never shown
+    row(7, ['trailhead:ticket', 'trailhead:build']),
+    row(8, ['trailhead:ticket', 'trailhead:map-1', 'trailhead:whiteboard']),
+    row(9, ['trailhead:ticket', 'trailhead:map-1', 'trailhead:map-2']),
+    row(10, ['trailhead:ticket', 'trailhead:map-1', 'trailhead:unverified']),
+  ])
+  expect(mine.map(t => [t.number, t.scope])).toEqual([
+    [5, { kind: 'map', number: 12 }],
+    [6, { kind: 'whiteboard' }],
+  ])
+  expect(mine[0]?.state).toBe('in-progress')
+})
+
+test('elsewhereInProgress keeps my in-progress tickets of the other scopes only', () => {
+  const mine = myTicketsFromRows([
+    row(1, ['trailhead:ticket', 'trailhead:map-12']),
+    row(2, ['trailhead:ticket', 'trailhead:map-30']),
+    row(3, ['trailhead:ticket', 'trailhead:whiteboard']),
+    // not in progress: paused, blocked, needs-you, UAT
+    row(4, ['trailhead:ticket', 'trailhead:map-30', 'trailhead:paused']),
+    row(5, ['trailhead:ticket', 'trailhead:map-30', 'trailhead:blocked']),
+    row(6, ['trailhead:ticket', 'trailhead:map-30', 'trailhead:needs-you']),
+    row(7, ['trailhead:ticket', 'trailhead:map-30', 'trailhead:uat']),
+  ])
+  expect(elsewhereInProgress(mine, { kind: 'map', number: 12 }, []).map(t => t.number)).toEqual([2, 3])
+  expect(elsewhereInProgress(mine, { kind: 'whiteboard' }, []).map(t => t.number)).toEqual([1, 2])
+  // a ticket the view already lists is never shown twice
+  const shown = parseTickets(JSON.stringify([row(2, ['trailhead:ticket', 'trailhead:map-12'])]))?.tickets ?? []
+  expect(elsewhereInProgress(mine, { kind: 'map', number: 12 }, shown).map(t => t.number)).toEqual([3])
+})
+
+test('scopeLine names the map by number and title, or the whiteboard, cut to the width', () => {
+  const [onMap, onBoard] = myTicketsFromRows([
+    row(1, ['trailhead:ticket', 'trailhead:map-30']),
+    row(2, ['trailhead:ticket', 'trailhead:whiteboard']),
+  ])
+  const maps = [{ number: 30, title: 'Billing rework', counts: null }]
+  expect(onMap && scopeLine(onMap, maps, 60)).toBe('on map #30 Billing rework')
+  expect(onMap && scopeLine(onMap, [], 60)).toBe('on map #30')
+  expect(onBoard && scopeLine(onBoard, maps, 60)).toBe('on whiteboard')
+  expect((onMap && scopeLine(onMap, maps, 16))?.length).toBeLessThanOrEqual(16)
+})

package/plugins/trailhead/tests/repo-pin-late-repo.test.ts

@@ -1,5 +1,6 @@
 import type { On } from 'claude-code'
 import { expect, test } from 'claude-code/testing'
+import { unscrub } from './unscrub'
 
 // #299: a session started outside any repo, the repo and `origin` created mid-session. The host's
 // `session.repo()` keeps answering null (observed live on Claude Code 2.1.306), while git in the cwd
@@ -26,7 +27,7 @@ test('the pin follows a repo created mid-session although session.repo() still a
   // The host's memoized answer: null from the start, even once the repo exists.
   on('session.repo', () => ({ value: null }))
   on('process.run', (_$, e) => {
-    const cmd = e.argv.join(' ')
+    const cmd = unscrub(e.argv).join(' ')
     if (cmd === 'git rev-parse --show-toplevel') return isCreated ? out(`${CWD}\n`) : out('', 128)
     if (cmd === 'git remote get-url origin') return isCreated ? out(`${REMOTE}\n`) : out('', 2)
     return out('', 1)
@@ -55,7 +56,7 @@ test('the git fallback spawns no more than it needs: nothing past a failed rev-p
   on('session.root', () => ({ value: CWD }))
   on('session.repo', () => ({ value: null }))
   on('process.run', (_$, e) => {
-    const cmd = e.argv.join(' ')
+    const cmd = unscrub(e.argv).join(' ')
     spawned.push(cmd)
     if (cmd === 'git rev-parse --show-toplevel') return isCreated ? out(`${CWD}\n`) : out('', 128)
     if (cmd === 'git remote get-url origin') return out(`${REMOTE}\n`)

package/plugins/trailhead/tests/repo-pin-relocate.test.ts

@@ -0,0 +1,175 @@
+import { expect, test } from 'claude-code/testing'
+import { unscrub } from './unscrub'
+
+// #347: the pinned checkout deleted under the session (a finished worktree). The pin must leave the dead
+// root for a live checkout of the same repo instead of staying on a path nothing can run in.
+const REMOTE = 'https://github.com/o/r.git'
+const DEAD = '/work/r-t5'
+const out = (stdout: string, exitCode = 0) => ({ value: { exitCode, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } })
+
+type Call = { argv: string[]; cwd: string | undefined }
+type Rig = { alive: Set<string>; remotes: Record<string, string>; worktrees: string; pins: unknown[]; calls: Call[]; now: number }
+
+const setup = (on: any, rig: Rig) => {
+  on('state.set', { plugin: 'trailhead', key: 'repoPin' }, (_$: unknown, e: { value: unknown }, next: any) => {
+    rig.pins.push(e.value)
+    return next(e)
+  })
+  on('fs.read', () => ({ deny: 'ENOENT: none' }))
+  on('fs.write', () => ({ value: undefined }))
+  on('fs.exists', (_$: unknown, e: { path: string }) => ({ value: rig.alive.has(e.path) }))
+  on('fs.list', (_$: unknown, e: { path: string }) => ({
+    value: e.path === '/work' ? [...rig.alive].filter(p => p.startsWith('/work/')).map(p => ({ name: p.slice(6), kind: 'dir', size: 0, mtimeMs: 0, isLink: false })) : [],
+  }))
+  on('clock.now', () => ({ value: rig.now }))
+  on('ui.status', () => ({ value: undefined }))
+  on('ui.log', () => ({ value: undefined }))
+  on('ui.panes', () => ({ value: [] }))
+  on('session.id', () => ({ value: 's1' }))
+  // The host's memoized answer keeps naming the dead root.
+  on('session.cwd', () => ({ value: DEAD }))
+  on('session.root', () => ({ value: DEAD }))
+  on('session.repo', () => ({ value: { root: DEAD, remote: REMOTE, internal: false } }))
+  on('process.run', (_$: unknown, e: { argv: string[]; init?: { cwd?: string } }) => {
+    rig.calls.push({ argv: [...unscrub(e.argv)], cwd: e.init?.cwd })
+    if (e.init?.cwd !== undefined && !rig.alive.has(e.init.cwd)) return { deny: 'spawn git ENOENT' }
+    const [, flag, path, ...rest] = unscrub(e.argv)
+    if (flag !== '-C' || path === undefined || !rig.alive.has(path)) {
+      // Probes outside -C run in the session cwd, which is gone: top-level reads fail.
+      return out('', 128)
+    }
+    if (rest.join(' ') === 'rev-parse --show-toplevel') return out(`${path}\n`)
+    if (rest.join(' ') === 'remote get-url origin') return rig.remotes[path] === undefined ? out('', 2) : out(`${rig.remotes[path]}\n`)
+    if (rest.join(' ') === 'worktree list --porcelain') return out(rig.worktrees)
+    return out('', 1)
+  })
+  on('session.start', (_$: unknown, e: { cwd: string }) => ({ cwd: e.cwd }))
+  on('turn.start', (_$: unknown, e: { turnId: string }) => ({ turnId: e.turnId }))
+  on('turn.complete', () => ({ text: '' }))
+}
+
+const complete = ($: any) => $.turn.complete({ turnId: 't1', answer: '', durationMs: 1, isAborted: false, reason: 'answer' })
+
+test('a deleted worktree re-pins to the main working tree of the same repo', async ($, on) => {
+  const rig: Rig = {
+    alive: new Set(['/', '/work', DEAD]),
+    remotes: { '/work/r': REMOTE, '/work/other': 'https://github.com/o/other.git', '/work/r-t7': REMOTE },
+    worktrees: 'worktree /work/r\nHEAD abc\nbranch refs/heads/main\n\nworktree /work/r-t7\nHEAD def\nbranch refs/heads/t7\n',
+    pins: [],
+    calls: [],
+    now: 1_000,
+  }
+  setup(on, rig)
+  await $.session.start({ cwd: DEAD, surface: 'terminal', isInteractive: true })
+  expect(rig.pins.at(-1)).toEqual({ root: DEAD, host: 'github.com', slug: 'o/r' })
+  rig.alive = new Set(['/', '/work', '/work/r', '/work/r-t7', '/work/other'])
+  await complete($)
+  expect(rig.pins.at(-1)).toEqual({ root: '/work/r', host: 'github.com', slug: 'o/r' })
+})
+
+test('with the main tree gone too, another worktree of the repo is taken', async ($, on) => {
+  const rig: Rig = {
+    alive: new Set(['/', '/work', DEAD]),
+    remotes: { '/work/r-t7': REMOTE },
+    worktrees: 'worktree /work/r\nHEAD abc\nbranch refs/heads/main\n\nworktree /work/r-t7\nHEAD def\nbranch refs/heads/t7\n',
+    pins: [],
+    calls: [],
+    now: 1_000,
+  }
+  setup(on, rig)
+  await $.session.start({ cwd: DEAD, surface: 'terminal', isInteractive: true })
+  rig.alive = new Set(['/', '/work', '/work/r-t7'])
+  await complete($)
+  expect(rig.pins.at(-1)).toEqual({ root: '/work/r-t7', host: 'github.com', slug: 'o/r' })
+})
+
+test('no checkout of the repo left keeps the pin and probes only from a live directory', async ($, on) => {
+  const rig: Rig = { alive: new Set(['/', '/work', DEAD]), remotes: { '/work/other': 'https://github.com/o/other.git' }, worktrees: '', pins: [], calls: [], now: 1_000 }
+  setup(on, rig)
+  await $.session.start({ cwd: DEAD, surface: 'terminal', isInteractive: true })
+  rig.alive = new Set(['/', '/work', '/work/other'])
+  await complete($)
+  expect(rig.pins.at(-1)).toEqual({ root: DEAD, host: 'github.com', slug: 'o/r' })
+})
+
+// Spawns of the relocation search: the only ones that use `git -C`.
+const probes = (rig: Rig) => rig.calls.filter(c => c.argv[1] === '-C')
+const WORKTREES = 'worktree /work/r\nHEAD abc\nbranch refs/heads/main\n'
+const newRig = (alive: string[], remotes: Record<string, string>, worktrees = ''): Rig => ({ alive: new Set(['/', '/work', ...alive]), remotes, worktrees, pins: [], calls: [], now: 1_000 })
+
+test('after the relocation, later refreshes cost the exists checks only, no git probe', async ($, on) => {
+  const rig = newRig([DEAD], { '/work/r': REMOTE }, WORKTREES)
+  setup(on, rig)
+  await $.session.start({ cwd: DEAD, surface: 'terminal', isInteractive: true })
+  rig.alive.delete(DEAD)
+  rig.alive.add('/work/r')
+  await complete($)
+  expect(rig.pins.at(-1)).toEqual({ root: '/work/r', host: 'github.com', slug: 'o/r' })
+  expect(probes(rig).length).toBeGreaterThan(0)
+  const moves = rig.pins.length
+  rig.calls.length = 0
+  await complete($)
+  await complete($)
+  expect(probes(rig)).toEqual([])
+  expect(rig.pins).toHaveLength(moves)
+})
+
+test('a live pin costs no probe', async ($, on) => {
+  const rig = newRig([DEAD, '/work/r'], { '/work/r': REMOTE }, WORKTREES)
+  setup(on, rig)
+  await $.session.start({ cwd: DEAD, surface: 'terminal', isInteractive: true })
+  await complete($)
+  expect(probes(rig)).toEqual([])
+  expect(rig.pins.at(-1)).toEqual({ root: DEAD, host: 'github.com', slug: 'o/r' })
+})
+
+test('a search that found nothing is not repeated within 60s, and retried after', async ($, on) => {
+  const rig = newRig([DEAD], { '/work/other': 'https://github.com/o/other.git' })
+  setup(on, rig)
+  await $.session.start({ cwd: DEAD, surface: 'terminal', isInteractive: true })
+  rig.alive.delete(DEAD)
+  rig.alive.add('/work/other')
+  await complete($)
+  expect(probes(rig).length).toBeGreaterThan(0)
+  rig.calls.length = 0
+  rig.now += 59_000
+  await complete($)
+  expect(probes(rig)).toEqual([])
+  rig.now += 2_000
+  await complete($)
+  expect(probes(rig).length).toBeGreaterThan(0)
+})
+
+test('a same-remote sibling clone with no worktree link is the fallback', async ($, on) => {
+  const rig = newRig([DEAD], { '/work/r-clone': REMOTE })
+  setup(on, rig)
+  await $.session.start({ cwd: DEAD, surface: 'terminal', isInteractive: true })
+  rig.alive.delete(DEAD)
+  rig.alive.add('/work/r-clone')
+  await complete($)
+  expect(rig.pins.at(-1)).toEqual({ root: '/work/r-clone', host: 'github.com', slug: 'o/r' })
+})
+
+test('every relocation probe runs from /', async ($, on) => {
+  const rig = newRig([DEAD], { '/work/r': REMOTE }, WORKTREES)
+  setup(on, rig)
+  await $.session.start({ cwd: DEAD, surface: 'terminal', isInteractive: true })
+  rig.alive.delete(DEAD)
+  rig.alive.add('/work/r')
+  await complete($)
+  const found = probes(rig)
+  expect(found.length).toBeGreaterThan(0)
+  expect(found.every(c => c.cwd === '/')).toBe(true)
+})
+
+test('a session start forgets what an earlier session cached', async ($, on) => {
+  const rig = newRig([DEAD], { '/work/other': 'https://github.com/o/other.git' })
+  setup(on, rig)
+  await $.session.start({ cwd: DEAD, surface: 'terminal', isInteractive: true })
+  rig.alive.delete(DEAD)
+  rig.alive.add('/work/other')
+  await complete($)
+  rig.calls.length = 0
+  await $.session.start({ cwd: DEAD, surface: 'terminal', isInteractive: true })
+  expect(probes(rig).length).toBeGreaterThan(0)
+})

package/plugins/trailhead/tests/repo-pin.test.ts

@@ -112,12 +112,27 @@ test('repoFromGit keeps a repo with no origin remote unpinned, so the last pin s
   expect(nextPin(current, repo)).toBe(current)
 })
 
-test('checkoutArg hands the root over as one shell-safe word the helper decodes back', () => {
+const fromBase64url = (token: string): string => {
+  const bytes = Uint8Array.from(atob(token.replace(/-/g, '+').replace(/_/g, '/').padEnd(Math.ceil(token.length / 4) * 4, '=')), c => c.charCodeAt(0))
+  return new TextDecoder().decode(bytes)
+}
+
+test('checkoutArg hands the root and the repo over as one shell-safe word the helper decodes back', () => {
   for (const root of ['/repo', '/with space/r', "/it's/r", '/-dash/r', '/uni\u00e8\u4e2d/r', '/a"b$c`d']) {
     const arg = checkoutArg({ ...GH, root })
-    expect(arg).toMatch(/^--in=[A-Za-z0-9_-]+$/)
-    const token = arg.slice('--in='.length)
-    const bytes = Uint8Array.from(atob(token.replace(/-/g, '+').replace(/_/g, '/').padEnd(Math.ceil(token.length / 4) * 4, '=')), c => c.charCodeAt(0))
-    expect(new TextDecoder().decode(bytes)).toBe(root)
+    expect(arg).toMatch(/^--in=[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/)
+    const [path, repo] = arg.slice('--in='.length).split('.')
+    expect(fromBase64url(path)).toBe(root)
+    expect(fromBase64url(repo)).toBe('github.com/o/r')
   }
 })
+
+test('checkoutArg carries host and a nested slug in the repo part', () => {
+  const arg = checkoutArg({ root: '/w/p', host: 'gitlab.com', slug: 'g/sub/r' })
+  expect(fromBase64url(arg.split('.')[1])).toBe('gitlab.com/g/sub/r')
+})
+
+test('checkoutArg carries a dotless host in the repo part', () => {
+  const arg = checkoutArg({ root: '/w/p', host: 'gitea', slug: 'owner/name' })
+  expect(fromBase64url(arg.split('.')[1])).toBe('gitea/owner/name')
+})

package/plugins/trailhead/tests/unscrub.ts

@@ -0,0 +1,8 @@
+// Test helper: the mod runs git (and the gh of the map pane) as `env -u NAME ... <cmd>`
+// (hooks/mod/git-env.ts); a process.run handler matches on the command itself.
+export const unscrub = (argv: readonly string[]): string[] => {
+  if (argv[0] !== 'env') return [...argv]
+  let i = 1
+  while (argv[i] === '-u') i += 2
+  return argv.slice(i)
+}

package/plugins/trailhead/tests/work-state-prompt-hook.test.ts

@@ -1,5 +1,6 @@
 import type { On } from 'claude-code'
 import { expect, test } from 'claude-code/testing'
+import { unscrub } from './unscrub'
 
 const SESSION = 'sess-A'
 const ID = 'trailhead:work-state'
@@ -48,8 +49,8 @@ const rig = (on: On) => {
   on('session.cwd', () => ({ value: '/repo' }))
   on('process.run', (_$, e) => {
     const out = (exitCode: number, stdout = '') => ({ value: { exitCode, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } })
-    if (e.argv[0] === 'git') return out(0, '/repo\n')
-    return out(r.authHosts.includes(e.argv[4] ?? '') ? 0 : 1)
+    if (unscrub(e.argv)[0] === 'git') return out(0, '/repo\n')
+    return out(r.authHosts.includes(unscrub(e.argv)[4] ?? '') ? 0 : 1)
   })
   on('ui.status', () => ({ value: undefined }))
   on('state.set', { plugin: 'trailhead' }, (_$, e, next) => {

package/plugins/trailhead/tests/work-state-worktree.test.ts

@@ -1,5 +1,6 @@
 import type { On } from 'claude-code'
 import { expect, test } from 'claude-code/testing'
+import { unscrub } from './unscrub'
 
 import { resetLocate } from '../hooks/mod/work-state-locate'
 
@@ -31,7 +32,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)
     const out = (stdout: string, exitCode = 0) => ({ value: { exitCode, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } })
     if (line === 'git rev-parse --show-toplevel') return out(`${r.cwd}\n`)

package/plugins/trailhead/types/index.d.ts

@@ -42,6 +42,11 @@ export type PaneTicket = {
   uatOf: UatParent | null
 }
 
+// Where one of my tickets lives: an open map by number, or the whiteboard.
+export type TicketScope = { kind: 'map'; number: number } | { kind: 'whiteboard' }
+// A ticket assigned to the gh login, tagged with its scope (the In progress group lists it outside that scope).
+export type MyTicket = PaneTicket & { scope: TicketScope }
+
 // A map's sub-issue counts: `open` still to do, `total` all of them.
 export type MapCounts = { open: number; total: number }
 // One open map of the repo, as the maps list shows it; `counts` null = unknown, drawn name-only.
@@ -113,6 +118,8 @@ declare module 'claude-code' {
       // The pane shows the dashboard (maps index + whiteboard) instead of a map.
       isDashboard: boolean
       dashboardPane: DashboardPaneData
+      // My open tickets across every map and the whiteboard (the last good read), for every view's In progress.
+      myTickets: readonly MyTicket[]
       pendingWork: number | null
       // Whether the pending press waits for the turn to end or has been sent.
       pendingPhase: 'queued' | 'starting' | null