@marcomigozzi/trailhead 0.14.0 → 0.16.0

package/plugins/trailhead/templates/trailhead-work-state.js

@@ -9,14 +9,17 @@
 //   node trailhead-work-state.js set [--repo <dir>] [--map <n>|none] [--ticket <n>]
 //        [--title <t>] [--step <step>] [--auto true|false] [--auto-done <n>]
 //   node trailhead-work-state.js clear [--repo <dir>]
+// `clear` removes both work-state.json and the session-ticket marker, each
+// attempted independently.
 // --repo defaults to cwd. `set` merges the given fields onto the existing file
 // (only --step at each step change); a --ticket other than the one on file
 // starts from an empty state. File shape:
 //   { map, ticket, title, step, auto, autoDone, session, updatedAt }
 // autoDone: tickets resolved so far in the autonomous run (non-negative
 // integer, default 0; reset to 0 whenever auto is false).
-// Prints one JSON line {"status","path","state"?,"message"?}.
+// Prints one JSON line {"status","path","state"?,"sessionTicket"?,"message"?}.
 //   status: written | cleared | absent | skipped
+//   sessionTicket (clear only): removed | absent | skipped
 // Exit 0 on every normal outcome and on any unexpected I/O error (it must
 // never block the caller: status skipped with the message); exit 2 only on a
 // usage or validation error (nothing is written).
@@ -27,6 +30,7 @@ const crypto = require('crypto');
 
 const STATE_DIR = '.trailhead';
 const STATE_FILE = 'work-state.json';
+const TICKET_MARKER = 'session-ticket';
 const STEPS = ['discuss', 'plan', 'execute', 'verify', 'resolve', 'paused'];
 const TITLE_MAX = 200;
 
@@ -145,6 +149,18 @@ function writeAtomic(dir, file, text, fsMod) {
   }
 }
 
+// Removes one file; never throws. Returns { status, message? } where status is
+// doneLabel (removed), absentLabel (not there) or skipped (I/O error).
+function removeFile(file, fsMod, doneLabel, absentLabel) {
+  try {
+    if (!fsMod.existsSync(file)) return { status: absentLabel };
+    fsMod.unlinkSync(file);
+    return { status: doneLabel };
+  } catch (err) {
+    return { status: 'skipped', message: 'error: ' + (err && err.message ? err.message : String(err)) };
+  }
+}
+
 function writeResult(stdout, result) {
   stdout.write(JSON.stringify(result) + '\n');
 }
@@ -166,12 +182,14 @@ function main(argv, { cwd, stdout, env, fs: fsMod, now } = {}) {
   const file = path.join(dir, STATE_FILE);
   try {
     if (parsed.command === 'clear') {
-      if (!fs_.existsSync(file)) {
-        writeResult(out, { status: 'absent', path: file });
-        return 0;
-      }
-      fs_.unlinkSync(file);
-      writeResult(out, { status: 'cleared', path: file });
+      // Both markers are removed independently: a missing or failing first
+      // removal never skips the second (#253).
+      const state = removeFile(file, fs_, 'cleared', 'absent');
+      const marker = removeFile(path.join(dir, TICKET_MARKER), fs_, 'removed', 'absent');
+      const result = { status: state.status, path: file, sessionTicket: marker.status };
+      const message = [state.message, marker.message].filter(Boolean).join('; ');
+      if (message) result.message = message;
+      writeResult(out, result);
       return 0;
     }
 

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

@@ -0,0 +1,444 @@
+import type { On } from 'claude-code'
+import { expect, test } from 'claude-code/testing'
+
+import { resetAutoRun } from '../hooks/mod/auto-run'
+import { resetLocate } from '../hooks/mod/work-state-locate'
+
+const SESSION = 'sess-A'
+const START = { cwd: '/repo', surface: 'terminal', isInteractive: true } as const
+const FILE = '/.trailhead/work-state.json'
+const RECORD = '/repo/.trailhead/auto-run.json'
+const HINT = 'auto interrupted · /trailhead:auto to resume'
+const HINT_STATUS = 'auto interrupted, /trailhead:auto to resume'
+const HELPER_CALL = 'node trailhead-work-state.js set --repo . --step execute'
+const BAND_PROPS = { hasSurvey: false, isWorking: false, maxRows: 10, bodyColumns: 80, scroll: { offset: 0, bodyRows: 10 }, view: {} } as const
+const SUMMARY = [{ role: 'user', text: 'summary', toolUses: [] }]
+
+// Uno stato di slot: senza sessione, auto, del ticket dato.
+const slot = (ticket: number, over: Record<string, unknown> = {}): string =>
+  JSON.stringify({ map: 42, ticket, title: `T${ticket}`, step: 'execute', auto: true, autoDone: 0, session: null, updatedAt: '2026-10-21T00:00:00.000Z', ...over })
+
+const wt = (path: string, branch: string | null) => `worktree ${path}\nHEAD abc\n${branch === null ? 'detached' : `branch ${branch}`}\n`
+const porcelain = (...blocks: string[]) => blocks.join('\n')
+const slotBranch = (n: number) => `refs/heads/trailhead/t${n}`
+
+const rig = (on: On) => {
+  const r = {
+    files: {} as Record<string, string>,
+    record: null as string | null,
+    cwd: '/repo',
+    toplevel: '/repo',
+    now: 1_000_000,
+    worktrees: porcelain(wt('/repo', 'refs/heads/main')) as string | Error,
+    siblings: [] as string[],
+    // Per cartella fratello: git dir e HEAD con cui risponde git.
+    clones: {} as Record<string, { gitDir: string; head: string }>,
+    counts: { needsYou: 0, paused: 0 },
+    ghFails: false,
+    runs: [] as string[],
+    cwds: [] as string[],
+    reads: [] as string[],
+    statuses: [] as (string | undefined)[],
+    dropAuto: false,
+    clockDown: false,
+  }
+  on('session.repo', () => ({ value: { root: '/repo', remote: 'git@github.com:o/r.git', internal: false } }))
+  on('clock.now', () => (r.clockDown ? { deny: 'no clock' } : { value: r.now }))
+  on('session.cwd', () => ({ value: r.cwd }))
+  on('session.id', () => ({ value: SESSION }))
+  on('process.run', (_$, e) => {
+    const line = 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 } })
+    if (line === 'git rev-parse --show-toplevel') return out(`${r.toplevel}\n`)
+    if (line === 'git worktree list --porcelain') return r.worktrees instanceof Error ? { deny: r.worktrees.message } : out(r.worktrees)
+    const clone = /^git -C (\S+) (rev-parse --absolute-git-dir|symbolic-ref --quiet HEAD)$/.exec(line)
+    if (clone !== null) {
+      const c = r.clones[clone[1]]
+      if (c === undefined) return out('', 128)
+      return out(clone[2].startsWith('rev-parse') ? c.gitDir : c.head)
+    }
+    if (line.startsWith('gh api graphql')) {
+      if (r.ghFails) return out('', 1)
+      return out(JSON.stringify({ data: { needsYou: { issueCount: r.counts.needsYou }, paused: { issueCount: r.counts.paused } } }))
+    }
+    return out('')
+  })
+  on('fs.list', () => ({ value: r.siblings.map(name => ({ name, kind: 'dir' as const, size: 0, mtimeMs: 0, isLink: false })) }))
+  on('fs.read', (_$, e) => {
+    r.reads.push(e.path)
+    if (e.path === RECORD) return r.record === null ? { deny: `ENOENT: no such file or directory, open '${e.path}'` } : { value: r.record }
+    const root = e.path.endsWith(FILE) ? e.path.slice(0, -FILE.length) : null
+    const text = root === null ? undefined : r.files[root]
+    return text === undefined ? { deny: `ENOENT: no such file or directory, open '${e.path}'` } : { value: text }
+  })
+  on('ui.status', (_$, e) => {
+    r.statuses.push(e.text)
+    return { value: undefined }
+  })
+  on('session.start', (_$, e) => ({ cwd: e.cwd }))
+  on('turn.start', (_$, e) => ({ turnId: e.turnId }))
+  on('turn.complete', () => ({ text: '' }))
+  on('session.compact', () => ({ messages: SUMMARY }))
+  on('prompt.submit', (_$, e) => (r.dropAuto ? { drop: 'busy' } : { text: e.text }))
+  on('tool.call', () => ({ result: '' }) as never)
+  on('ui.render', () => ({ type: 'Box', props: { key: 'engine' }, children: [] }))
+  return r
+}
+type Rig = ReturnType<typeof rig>
+
+const last = (r: Rig) => r.statuses[r.statuses.length - 1]
+const ghRuns = (r: Rig) => r.runs.filter(line => line.startsWith('gh '))
+const wtRuns = (r: Rig) => r.runs.filter(line => line.startsWith('git worktree'))
+let turns = 0
+const turnId = () => `t${(turns += 1)}`
+// Un turno intero del loop principale, che finisce normalmente o interrotto.
+const runTurn = async ($: any, aborted = false) => {
+  const id = turnId()
+  await $.turn.start({ text: 'go', turnId: id })
+  await $.turn.complete({ turnId: id, answer: '', durationMs: 1, isAborted: aborted, reason: aborted ? 'aborted' : 'answer' } as never)
+}
+// Un solo refresh (un turno ne fa due, avvio e fine): serve a contare i fallimenti uno a uno.
+const refresh = ($: any) => $.tool.call({ tool: 'Bash', command: HELPER_CALL } as never)
+const compact = ($: any, extra: Record<string, unknown> = {}) => $.session.compact({ messages: SUMMARY, ...extra })
+
+// Tre slot nel repo: t5 e t6 in volo, t7 in pausa.
+const threeSlots = (r: Rig) => {
+  r.record = JSON.stringify({ version: 1, scope: 'map:42' })
+  r.worktrees = porcelain(wt('/repo', 'refs/heads/main'), wt('/repo-t5', slotBranch(5)), wt('/repo-t6', slotBranch(6)), wt('/repo-t7', slotBranch(7)))
+  r.files['/repo-t5'] = slot(5, { autoDone: 4 })
+  r.files['/repo-t6'] = slot(6, { step: 'verify', autoDone: 1 })
+  r.files['/repo-t7'] = slot(7, { step: 'paused' })
+}
+
+const band = async ($: any) => {
+  const ui = await $.ui.mount({ plugin: 'trailhead', surface: 'terminal', component: 'AbovePrompt', props: { ...BAND_PROPS } })
+  const box = await ui.find({ key: 'run' })
+  const own = await ui.find({ key: 'auto' })
+  const node = box ?? own
+  const text = node?.children[0]
+  return node === undefined ? undefined : String(text?.children?.join('') ?? '')
+}
+
+const fresh = () => {
+  resetLocate()
+  resetAutoRun()
+}
+
+test('several sessionless slots show done and in flight in the status and the band, in the first status', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  expect(r.statuses[0]).toBe('auto · 4 done · 2 in flight')
+  expect(await band($)).toBe('auto · 4 done · 2 in flight')
+})
+
+test('needs-you and paused counts come from one gh read scoped by the record', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  r.counts = { needsYou: 1, paused: 2 }
+  await $.session.start(START)
+  expect(last(r)).toBe('auto · 4 done · 2 in flight · 1 needs you · 2 paused')
+  expect(await band($)).toBe('auto · 4 done · 2 in flight · 1 needs you · 2 paused')
+  const calls = ghRuns(r)
+  expect(calls).toHaveLength(1)
+  expect(calls[0]).toContain('label:"trailhead:map-42"')
+  expect(calls[0]).toContain('repo:o/r')
+})
+
+test('an everything scope reads repo-wide counts', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  r.record = JSON.stringify({ scope: 'everything' })
+  r.counts = { needsYou: 3, paused: 0 }
+  await $.session.start(START)
+  expect(last(r)).toBe('auto · 4 done · 2 in flight · 3 needs you')
+  expect(ghRuns(r)[0]).not.toContain('trailhead:map-')
+})
+
+test('the counts are read at most once per 15 s and a failed read keeps the last ones', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  r.counts = { needsYou: 1, paused: 0 }
+  await $.session.start(START)
+  await runTurn($)
+  r.now += 14_000
+  await runTurn($)
+  expect(ghRuns(r)).toHaveLength(1)
+  r.now += 2_000
+  r.ghFails = true
+  r.counts = { needsYou: 9, paused: 9 }
+  await runTurn($)
+  expect(ghRuns(r)).toHaveLength(2)
+  expect(last(r)).toBe('auto · 4 done · 2 in flight · 1 needs you')
+})
+
+test('only real slots count: wrong branch, auto false, ticket mismatch, a sibling that is not an independent checkout', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  r.record = JSON.stringify({ scope: 'everything' })
+  r.worktrees = porcelain(
+    wt('/repo', 'refs/heads/main'),
+    wt('/repo-t5', slotBranch(5)),
+    wt('/repo-t6', 'refs/heads/feature/x'),
+    wt('/repo-t7', slotBranch(7)),
+    wt('/repo-t8', slotBranch(8)),
+  )
+  r.siblings = ['repo-t9', 'repo-t10']
+  r.files['/repo-t5'] = slot(5, { autoDone: 2 })
+  r.files['/repo-t6'] = slot(6, { autoDone: 50 })
+  r.files['/repo-t7'] = slot(7, { auto: false, autoDone: 60 })
+  r.files['/repo-t8'] = slot(99, { autoDone: 70 })
+  // t9 è un worktree collegato (git dir fuori dalla cartella); t10 è un clone vero sul branch giusto.
+  r.files['/repo-t9'] = slot(9, { autoDone: 80 })
+  r.files['/repo-t10'] = slot(10, { autoDone: 3 })
+  r.clones['/repo-t9'] = { gitDir: '/repo/.git/worktrees/repo-t9', head: slotBranch(9) }
+  r.clones['/repo-t10'] = { gitDir: '/repo-t10/.git', head: slotBranch(10) }
+  await $.session.start(START)
+  expect(last(r)).toBe('auto · 3 done · 2 in flight')
+})
+
+test('a sibling clone is checked with git only when its state is auto for its own ticket', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  r.record = JSON.stringify({ scope: 'everything' })
+  r.siblings = ['repo-t4', 'repo-t5']
+  r.files['/repo-t4'] = slot(4, { auto: false })
+  r.files['/repo-t5'] = slot(6)
+  await $.session.start(START)
+  expect(r.runs.filter(line => line.startsWith('git -C'))).toEqual([])
+  expect(last(r)).toBeUndefined()
+})
+
+test('a session outside a run costs one record read: no git scan, no gh', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  r.files['/repo'] = slot(3, { auto: false, session: SESSION })
+  await $.session.start(START)
+  await runTurn($)
+  expect(wtRuns(r)).toEqual([])
+  expect(ghRuns(r)).toEqual([])
+  expect(r.reads.filter(path => path === RECORD).length).toBeGreaterThan(0)
+  expect(await band($)).toBeUndefined()
+})
+
+test('an own auto state with no record still opens the scan', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  r.files['/repo'] = slot(3, { session: SESSION, autoDone: 2 })
+  await $.session.start(START)
+  expect(wtRuns(r).length).toBeGreaterThan(0)
+  expect(last(r)).toBe('map #42 · #3 T3 · execute · auto 2 done · 1 in flight')
+  expect(await band($)).toBe('auto · 2 done · 1 in flight')
+})
+
+test('a session in a linked worktree still resolves the main checkout from session.repo', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  r.cwd = '/repo-t5'
+  r.toplevel = '/repo-t5'
+  await $.session.start({ ...START, cwd: '/repo-t5' })
+  expect(r.reads).toContain(RECORD)
+  expect(last(r)).toContain('auto 4 done')
+  expect(last(r)).toContain('2 in flight')
+  expect(wtRuns(r).length).toBeGreaterThan(0)
+})
+
+test('a failed scan keeps the last run for two failures, the third clears it; a clean miss clears at once', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  expect(last(r)).toBe('auto · 4 done · 2 in flight')
+  r.worktrees = new Error('git exploded')
+  for (const kept of [true, true, false]) {
+    r.now += 20_000
+    await refresh($)
+    expect(last(r) !== undefined).toBe(kept)
+  }
+  r.worktrees = porcelain(wt('/repo', 'refs/heads/main'), wt('/repo-t5', slotBranch(5)))
+  r.now += 20_000
+  await refresh($)
+  expect(last(r)).toBe('auto · 4 done · 1 in flight')
+  r.files = {}
+  await refresh($)
+  expect(last(r)).toBeUndefined()
+  expect(await band($)).toBeUndefined()
+})
+
+test('failures inside one window count once: three refreshes in a row keep the run', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  r.worktrees = new Error('git exploded')
+  for (let i = 0; i < 6; i += 1) {
+    await refresh($)
+    expect(last(r)).toBe('auto · 4 done · 2 in flight')
+  }
+  r.now += 14_000
+  await refresh($)
+  expect(last(r)).toBe('auto · 4 done · 2 in flight')
+})
+
+test('failures spaced past the window clear the run on the third', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  r.worktrees = new Error('git exploded')
+  for (const kept of [true, true, false]) {
+    r.now += 15_000
+    await refresh($)
+    await refresh($)
+    expect(last(r) !== undefined).toBe(kept)
+  }
+})
+
+test('a success resets the failure count', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  const good = r.worktrees
+  for (let i = 0; i < 2; i += 1) {
+    r.worktrees = new Error('git exploded')
+    r.now += 15_000
+    await refresh($)
+  }
+  r.worktrees = good
+  r.now += 15_000
+  await refresh($)
+  r.worktrees = new Error('git exploded')
+  for (const kept of [true, true, false]) {
+    r.now += 15_000
+    await refresh($)
+    expect(last(r) !== undefined).toBe(kept)
+  }
+})
+
+test('the counts read goes to the pin\'s own host', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  expect(ghRuns(r)[0]).toContain('gh api graphql --hostname github.com')
+})
+
+test('with no clock the counts are never read unthrottled', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  r.clockDown = true
+  await $.session.start(START)
+  await refresh($)
+  expect(ghRuns(r)).toEqual([])
+  expect(last(r)).toBe('auto · 4 done · 2 in flight')
+})
+
+test('Esc shows the resume hint in the status and the band; a subagent abort does not', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  await $.turn.complete({ turnId: 'sub', agentId: 'agent-1', answer: '', durationMs: 1, isAborted: true, reason: 'aborted' } as never)
+  expect(last(r)).toBe('auto · 4 done · 2 in flight')
+  await runTurn($, true)
+  expect(last(r)).toBe(HINT_STATUS)
+  expect(await band($)).toBe(HINT)
+})
+
+test('the hint rides the own state too: status suffix and the right-hand band text', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  r.files['/repo'] = slot(3, { session: SESSION })
+  await $.session.start(START)
+  await runTurn($, true)
+  expect(last(r)).toBe(`map #42 · #3 T3 · execute · auto 0 done · 1 in flight · ${HINT_STATUS}`)
+  expect(await band($)).toBe(HINT)
+})
+
+test('a turn that ends normally is no interruption', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  await runTurn($)
+  expect(last(r)).toBe('auto · 4 done · 2 in flight')
+})
+
+test('a compaction between turns shows the hint; a skipped or subagent one does not', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  await compact($, { agentId: 'sub-1' })
+  await compact($, { trigger: 'precompute' })
+  expect(last(r)).toBe('auto · 4 done · 2 in flight')
+  await compact($)
+  expect(last(r)).toBe(HINT_STATUS)
+})
+
+test('a compaction inside a running turn sets nothing until the turn ends aborted', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  const id = turnId()
+  await $.turn.start({ text: 'go', turnId: id })
+  await compact($)
+  expect(last(r)).toBe('auto · 4 done · 2 in flight')
+  await $.turn.complete({ turnId: id, answer: '', durationMs: 1, isAborted: true, reason: 'aborted' } as never)
+  expect(last(r)).toBe(HINT_STATUS)
+  const id2 = turnId()
+  await $.turn.start({ text: 'go', turnId: id2 })
+  await compact($)
+  await $.turn.complete({ turnId: id2, answer: '', durationMs: 1, isAborted: false, reason: 'answer' } as never)
+  expect(last(r)).toBe('auto · 4 done · 2 in flight')
+})
+
+test('the next main turn clears the hint; a subagent turn start does not', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  await runTurn($, true)
+  expect(last(r)).toBe(HINT_STATUS)
+  await $.turn.start({ text: 'x', turnId: 'sub-t', agentId: 'agent-1' })
+  expect(last(r)).toBe(HINT_STATUS)
+  await $.turn.start({ text: 'x', turnId: turnId() })
+  expect(last(r)).toBe('auto · 4 done · 2 in flight')
+})
+
+test('submitting /trailhead:auto clears the hint; a dropped submit leaves it', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  await runTurn($, true)
+  r.dropAuto = true
+  await $.prompt.submit({ text: '/trailhead:auto', command: 'trailhead:auto' } as never)
+  expect(last(r)).toBe(HINT_STATUS)
+  r.dropAuto = false
+  await $.prompt.submit({ text: '/trailhead:auto', command: 'trailhead:auto' } as never)
+  expect(last(r)).toBe('auto · 4 done · 2 in flight')
+})
+
+test('the hint is hidden once no run member is left', async ($, on) => {
+  fresh()
+  const r = rig(on)
+  threeSlots(r)
+  await $.session.start(START)
+  await runTurn($, true)
+  expect(last(r)).toBe(HINT_STATUS)
+  r.files = { '/repo-t5': slot(5, { auto: false }), '/repo-t6': slot(6, { auto: false }), '/repo-t7': slot(7, { auto: false }) }
+  await refresh($)
+  expect(last(r)).toBeUndefined()
+  expect(await band($)).toBeUndefined()
+})

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

@@ -0,0 +1,111 @@
+import { expect, test } from 'claude-code/testing'
+
+import {
+  RESUME_HINT,
+  aggregateRun,
+  isRunMember,
+  nextRunAfterFailure,
+  parseRunCounts,
+  parseRunScope,
+  runCountsArgs,
+  runLabel,
+  showsResumeHint,
+  slotTicket,
+} from '../hooks/mod/auto-run-view'
+import { MAX_FAILURES, parseWorktreeBranches } from '../hooks/mod/worktree-porcelain'
+
+const state = (over: Record<string, unknown> = {}) => ({
+  map: 1,
+  ticket: 5,
+  title: null,
+  step: 'execute',
+  auto: true,
+  autoDone: 0,
+  session: null,
+  updatedAt: null,
+  ...over,
+})
+
+test('parseWorktreeBranches reads path and branch per block, null on a detached head', () => {
+  const text = 'worktree /r\nHEAD a\nbranch refs/heads/main\n\nworktree /r-t5\nHEAD b\nbranch refs/heads/trailhead/t5\n\nworktree /d\nHEAD c\ndetached\n'
+  expect(parseWorktreeBranches(text)).toEqual([
+    { path: '/r', branch: 'refs/heads/main' },
+    { path: '/r-t5', branch: 'refs/heads/trailhead/t5' },
+    { path: '/d', branch: null },
+  ])
+  expect(parseWorktreeBranches('')).toEqual([])
+})
+
+test('slotTicket only takes trailhead/t<n> branches', () => {
+  expect(slotTicket('refs/heads/trailhead/t12')).toBe(12)
+  expect(slotTicket('refs/heads/trailhead/t0')).toBeNull()
+  expect(slotTicket('refs/heads/trailhead/t12x')).toBeNull()
+  expect(slotTicket('refs/heads/feature/t12')).toBeNull()
+  expect(slotTicket(null)).toBeNull()
+})
+
+test('isRunMember: auto state in the main checkout, a slot worktree or an independent clone on the slot branch', () => {
+  expect(isRunMember({ kind: 'main' }, state())).toBe(true)
+  expect(isRunMember({ kind: 'main' }, state({ auto: false }))).toBe(false)
+  expect(isRunMember({ kind: 'worktree', ticket: 5 }, state())).toBe(true)
+  expect(isRunMember({ kind: 'worktree', ticket: 6 }, state())).toBe(false)
+  expect(isRunMember({ kind: 'worktree', ticket: 5 }, state({ auto: false }))).toBe(false)
+  expect(isRunMember({ kind: 'clone', ticket: 5, onBranch: true }, state())).toBe(true)
+  expect(isRunMember({ kind: 'clone', ticket: 5, onBranch: false }, state())).toBe(false)
+  expect(isRunMember({ kind: 'clone', ticket: 6, onBranch: true }, state())).toBe(false)
+})
+
+test('aggregateRun: max autoDone, in flight = steps not paused, none = no run', () => {
+  expect(aggregateRun([])).toBeNull()
+  expect(aggregateRun([state({ autoDone: 2 }), state({ autoDone: 4, step: 'paused' }), state({ step: 'verify' })])).toEqual({ done: 4, inFlight: 2 })
+})
+
+test('parseRunScope maps the record scope to a label; repo-wide is null', () => {
+  expect(parseRunScope('{"scope":"map:42"}')).toBe('trailhead:map-42')
+  expect(parseRunScope('{"scope":"whiteboard"}')).toBe('trailhead:whiteboard')
+  expect(parseRunScope('{"scope":"everything"}')).toBeNull()
+  expect(parseRunScope('{"scope":"map:x"}')).toBeNull()
+  expect(parseRunScope('{"scope":"map:0"}')).toBeNull()
+  expect(parseRunScope('nope')).toBeNull()
+  expect(parseRunScope('{}')).toBeNull()
+})
+
+test('runCountsArgs carries two searches, narrowed by the scope label', () => {
+  const wide = runCountsArgs('github.com', 'o/r', null).join(' ')
+  expect(wide).toContain('api graphql --hostname github.com')
+  expect(wide).toContain('needs=repo:o/r is:open label:"trailhead:ticket" label:"trailhead:needs-you"')
+  expect(wide).toContain('paused=repo:o/r is:open label:"trailhead:ticket" label:"trailhead:paused"')
+  expect(wide).not.toContain('map-')
+  const scoped = runCountsArgs('ghe.example.com', 'o/r', 'trailhead:map-7').join(' ')
+  expect(scoped).toContain('label:"trailhead:map-7"')
+  expect(scoped).toContain('--hostname ghe.example.com')
+})
+
+test('parseRunCounts reads both counts or nothing', () => {
+  expect(parseRunCounts('{"data":{"needsYou":{"issueCount":2},"paused":{"issueCount":0}}}')).toEqual({ needsYou: 2, paused: 0 })
+  expect(parseRunCounts('{"data":{"needsYou":{"issueCount":2}}}')).toBeNull()
+  expect(parseRunCounts('{"data":{"needsYou":{"issueCount":-1},"paused":{"issueCount":0}}}')).toBeNull()
+  expect(parseRunCounts('x')).toBeNull()
+})
+
+test('runLabel lists done and in flight, then the non-zero counts', () => {
+  expect(runLabel({ done: 3, inFlight: 2 }, { needsYou: 1, paused: 1 })).toBe('auto · 3 done · 2 in flight · 1 needs you · 1 paused')
+  expect(runLabel({ done: 3, inFlight: 2 }, { needsYou: 0, paused: 0 })).toBe('auto · 3 done · 2 in flight')
+  expect(runLabel({ done: 3 }, null)).toBe('auto · 3 done')
+})
+
+test('the hint shows only with the flag and a run member', () => {
+  expect(RESUME_HINT).toBe('auto interrupted · /trailhead:auto to resume')
+  expect(showsResumeHint(true, { done: 0, inFlight: 1 })).toBe(true)
+  expect(showsResumeHint(true, null)).toBe(false)
+  expect(showsResumeHint(false, { done: 0, inFlight: 1 })).toBe(false)
+})
+
+test('nextRunAfterFailure keeps the run until the MAX_FAILURES-th failure in a row', () => {
+  const run = { done: 1, inFlight: 1 }
+  expect(MAX_FAILURES).toBe(3)
+  expect(nextRunAfterFailure(run, 1)).toEqual(run)
+  expect(nextRunAfterFailure(run, 2)).toEqual(run)
+  expect(nextRunAfterFailure(run, 3)).toBeNull()
+  expect(nextRunAfterFailure(null, 1)).toBeNull()
+})