@marcomigozzi/trailhead 0.14.0 → 0.16.0

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

@@ -0,0 +1,51 @@
+import { expect, test } from 'claude-code/testing'
+
+import { GH_ISSUE_WRITE } from '../hooks/mod/map-pane'
+
+// Bash commands the pane refreshes on (a write to the tracker) and ones it must ignore.
+const WRITES = [
+  'gh issue close 5',
+  'gh --repo o/r issue close 5',
+  'gh issue comment 5 -b hi',
+  'gh issue edit 5 --add-label x',
+  'gh issue create -t t',
+  'gh issue reopen 5',
+  'gh issue delete 5',
+  'gh issue transfer 5 o/other',
+  'env GH_HOST=x gh issue close 5',
+  'command gh issue close 5',
+  'cd x && gh issue close 5',
+  'gh api -X POST repos/o/r/issues/198/sub_issues -F sub_issue_id=1',
+  'gh api repos/o/r/issues/198/sub_issues -F sub_issue_id=1',
+  'gh api repos/{owner}/{repo}/issues/5 -f state=closed',
+  'gh api --method=PATCH repos/o/r/issues/5',
+  'gh api --method PATCH repos/o/r/issues/5 -f title=x',
+  'gh api -XDELETE repos/o/r/issues/5/labels/x',
+  'gh api "repos/o/r/issues/5/comments" -f body=hi',
+  "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',
+]
+const READS = [
+  'gh issue list --state open',
+  'gh issue view 5',
+  'ls -la',
+  'gh pr close 4',
+  'gh api repos/o/r/issues/5',
+  'gh api repos/o/r/issues --jq length',
+  'gh api -X GET repos/o/r/issues -f labels=x',
+  'gh api --method=GET repos/o/r/issues -F per_page=1',
+  'gh api graphql -f query=query{viewer{login}}',
+  'gh api graphql -F owner={owner} -F repo={repo} -f query=x',
+  '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',
+]
+
+test('the write matcher takes the tracker writes of a Bash call', () => {
+  for (const command of WRITES) expect([command, GH_ISSUE_WRITE.test(command)]).toEqual([command, true])
+})
+
+test('the write matcher leaves reads alone', () => {
+  for (const command of READS) expect([command, GH_ISSUE_WRITE.test(command)]).toEqual([command, false])
+})

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

@@ -0,0 +1,77 @@
+import type { On } from 'claude-code'
+import { expect, test } from 'claude-code/testing'
+
+// #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
+// already answers; the pin the pane reads must follow git.
+const CWD = '/work/new-project'
+const REMOTE = 'https://github.com/o/new-project.git'
+const out = (stdout: string, exitCode = 0) => ({ value: { exitCode, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } })
+
+test('the pin follows a repo created mid-session although session.repo() still answers null', async ($, on) => {
+  const pins: unknown[] = []
+  let isCreated = false
+  on('state.set', { plugin: 'trailhead', key: 'repoPin' }, (_$, e, next) => {
+    pins.push(e.value)
+    return next(e)
+  })
+  on('fs.read', () => ({ deny: 'ENOENT: none' }))
+  on('fs.write', () => ({ value: undefined }))
+  on('ui.status', () => ({ value: undefined }))
+  on('ui.log', () => ({ value: undefined }))
+  on('ui.panes', () => ({ value: [] }))
+  on('session.id', () => ({ value: 's1' }))
+  on('session.cwd', () => ({ value: CWD }))
+  on('session.root', () => ({ value: CWD }))
+  // 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(' ')
+    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)
+  })
+  on('session.start', (_$, e) => ({ cwd: e.cwd }))
+  on('turn.start', (_$, e) => ({ turnId: e.turnId }))
+  on('turn.complete', () => ({ text: '' }))
+
+  await $.session.start({ cwd: CWD, surface: 'terminal', isInteractive: true })
+  isCreated = true
+  await $.turn.complete({ turnId: 't1', answer: '', durationMs: 1, isAborted: false, reason: 'answer' })
+  expect(pins.at(-1)).toEqual({ root: CWD, host: 'github.com', slug: 'o/new-project' })
+})
+
+test('the git fallback spawns no more than it needs: nothing past a failed rev-parse, one rev-parse per read', async ($, on) => {
+  const spawned: string[] = []
+  let isCreated = false
+  on('state.set', (_$, e, next) => next(e))
+  on('fs.read', () => ({ deny: 'ENOENT: none' }))
+  on('fs.write', () => ({ value: undefined }))
+  on('ui.status', () => ({ value: undefined }))
+  on('ui.log', () => ({ value: undefined }))
+  on('ui.panes', () => ({ value: [] }))
+  on('session.id', () => ({ value: 's1' }))
+  on('session.cwd', () => ({ value: CWD }))
+  on('session.root', () => ({ value: CWD }))
+  on('session.repo', () => ({ value: null }))
+  on('process.run', (_$, e) => {
+    const cmd = 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`)
+    return out('', 1)
+  })
+  on('session.start', (_$, e) => ({ cwd: e.cwd }))
+  on('turn.start', (_$, e) => ({ turnId: e.turnId }))
+  on('turn.complete', () => ({ text: '' }))
+
+  await $.session.start({ cwd: CWD, surface: 'terminal', isInteractive: true })
+  expect(spawned).not.toContain('git remote get-url origin')
+  spawned.length = 0
+  isCreated = true
+  await $.turn.complete({ turnId: 't1', answer: '', durationMs: 1, isAborted: false, reason: 'answer' })
+  // The fallback hands its toplevel back: each read is one rev-parse and one remote lookup, no repeat.
+  const tops = spawned.filter(c => c === 'git rev-parse --show-toplevel').length
+  expect(tops).toBeGreaterThan(0)
+  expect(spawned.filter(c => c === 'git remote get-url origin')).toHaveLength(tops)
+})

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

@@ -0,0 +1,123 @@
+import { expect, test } from 'claude-code/testing'
+
+import { checkoutArg, isPinCheckout, isSamePin, nextPin, pinOf, pinPath, remoteId, repoFromGit } from '../hooks/mod/repo-pin'
+
+const repo = (remote: string | null, root = '/repo') => ({ root, remote })
+const GH = { host: 'github.com', slug: 'o/r' }
+
+test('remoteId reads host and owner/name from every remote form, with or without .git', () => {
+  expect(remoteId('https://github.com/o/r.git')).toEqual(GH)
+  expect(remoteId('https://github.com/o/r')).toEqual(GH)
+  expect(remoteId('https://github.com/o/r/')).toEqual(GH)
+  expect(remoteId('ssh://git@github.com/o/r.git')).toEqual(GH)
+  expect(remoteId('git@github.com:o/r.git')).toEqual(GH)
+  expect(remoteId('git@github.com:o/r')).toEqual(GH)
+  expect(remoteId('  git@github.com:o/r.git\n')).toEqual(GH)
+})
+
+test('remoteId accepts a user, a port, any case of the host, and Enterprise hosts', () => {
+  expect(remoteId('https://user@github.com/o/r.git')).toEqual(GH)
+  expect(remoteId('ssh://git@github.com:22/o/r')).toEqual(GH)
+  expect(remoteId('https://GitHub.com/o/r.git')).toEqual(GH)
+  expect(remoteId('git@GitHub.COM:o/r.git')).toEqual(GH)
+  expect(remoteId('git@ghe.example.com:o/r.git')).toEqual({ host: 'ghe.example.com', slug: 'o/r' })
+  expect(remoteId('https://ghe.example.com:8443/o/r')).toEqual({ host: 'ghe.example.com', slug: 'o/r' })
+  expect(remoteId('github.com:o/r')).toEqual(GH)
+})
+
+test('remoteId is host-aware: any host gives its own, a local path none', () => {
+  expect(remoteId('https://gitlab.com/a/b.git')).toEqual({ host: 'gitlab.com', slug: 'a/b' })
+  expect(remoteId('ssh://git@github.com/ToRvaLDz/trailhead.git')).toEqual({ host: 'github.com', slug: 'ToRvaLDz/trailhead' })
+  expect(remoteId('/srv/git/trailhead.git')).toBeNull()
+})
+
+test('remoteId refuses a host or owner/name with characters a link must not carry', () => {
+  expect(remoteId('https://github.com/o​/r.git')).toBeNull()
+  expect(remoteId('git@github.com:o/r‮.git')).toBeNull()
+  expect(remoteId('git@gh⁦e.example.com:o/r.git')).toBeNull()
+  expect(remoteId('https://github.com/o/r<x>.git')).toBeNull()
+  expect(remoteId('git@github.com:my.org/r_1-x.git')).toEqual({ host: 'github.com', slug: 'my.org/r_1-x' })
+})
+
+test('remoteId is null for no remote or one that is not host/owner/name', () => {
+  expect(remoteId(null)).toBeNull()
+  expect(remoteId('')).toBeNull()
+  expect(remoteId('/srv/git/r.git')).toBeNull()
+  expect(remoteId('../r.git')).toBeNull()
+  expect(remoteId('https://github.com/o')).toBeNull()
+  expect(remoteId('file:///srv/o/r.git')).toBeNull()
+})
+
+test('pinOf pins the checkout toplevel when given, else the repo root', () => {
+  expect(pinOf(null)).toBeNull()
+  expect(pinOf(repo(null))).toBeNull()
+  expect(pinOf(repo('git@github.com:o/r.git'))).toEqual({ root: '/repo', ...GH })
+  expect(pinOf(repo('git@github.com:o/r.git'), '/repo-t5')).toEqual({ root: '/repo-t5', ...GH })
+})
+
+test('nextPin keeps the last pin when the check finds no usable repo, and follows a different one', () => {
+  const kept = { root: '/repo', ...GH }
+  expect(nextPin(kept, null)).toBe(kept)
+  expect(nextPin(kept, repo(null))).toBe(kept)
+  expect(nextPin(kept, repo('/srv/git/r.git'))).toBe(kept)
+  expect(nextPin(null, null)).toBeNull()
+  expect(nextPin(null, repo('git@github.com:o/r.git'))).toEqual(kept)
+  expect(nextPin(kept, repo('git@github.com:o/r.git'))).toBe(kept)
+  expect(nextPin(kept, repo('git@github.com:o/other.git', '/other'))).toEqual({ root: '/other', host: 'github.com', slug: 'o/other' })
+  expect(nextPin(kept, repo('git@github.com:o/r.git'), '/repo-t5')).toEqual({ root: '/repo-t5', ...GH })
+})
+
+test('isSamePin compares root and repo identity', () => {
+  const a = { root: '/repo', ...GH }
+  expect(isSamePin(a, { ...a })).toBe(true)
+  expect(isSamePin(a, { ...a, root: '/repo-t5' })).toBe(false)
+  expect(isSamePin(a, { ...a, host: 'ghe.example.com' })).toBe(false)
+  expect(isSamePin(null, null)).toBe(true)
+  expect(isSamePin(a, null)).toBe(false)
+})
+
+test('pinPath joins a repo-relative path under the pinned root', () => {
+  expect(pinPath({ root: '/repo', ...GH }, '.trailhead/active-map')).toBe('/repo/.trailhead/active-map')
+  expect(pinPath({ root: '/repo/', ...GH }, '.trailhead/active-map')).toBe('/repo/.trailhead/active-map')
+})
+
+test('isPinCheckout holds only for the pinned repo, checked out at the pinned root', () => {
+  const pin = { root: '/repo', ...GH }
+  expect(isPinCheckout(pin, repo('git@github.com:o/r.git'), '/repo')).toBe(true)
+  expect(isPinCheckout(pin, repo('git@github.com:o/r.git', '/main'), '/repo')).toBe(true)
+  expect(isPinCheckout(pin, repo('git@github.com:o/r.git'), '/repo-t5')).toBe(false)
+  expect(isPinCheckout(pin, repo('git@github.com:o/other.git'), '/repo')).toBe(false)
+  expect(isPinCheckout(pin, repo(null), '/repo')).toBe(false)
+  expect(isPinCheckout(pin, null, null)).toBe(false)
+  expect(isPinCheckout(pin, repo('git@github.com:o/r.git'), null)).toBe(false)
+  expect(isPinCheckout(null, repo('git@github.com:o/r.git'), '/repo')).toBe(false)
+})
+
+test('repoFromGit builds the repo from the two git outputs', () => {
+  expect(repoFromGit({ exitCode: 0, stdout: '/w/p\n' }, { exitCode: 0, stdout: 'git@github.com:o/p.git\n' })).toEqual({ root: '/w/p', remote: 'git@github.com:o/p.git' })
+})
+
+test('repoFromGit is null outside a repo, so the last pin stays', () => {
+  const current = { root: '/w/p', host: 'github.com', slug: 'o/p' }
+  const repo = repoFromGit({ exitCode: 128, stdout: '' }, { exitCode: 128, stdout: '' })
+  expect(repo).toBeNull()
+  expect(nextPin(current, repo)).toBe(current)
+  expect(repoFromGit(null, null)).toBeNull()
+})
+
+test('repoFromGit keeps a repo with no origin remote unpinned, so the last pin stays', () => {
+  const current = { root: '/w/p', host: 'github.com', slug: 'o/p' }
+  const repo = repoFromGit({ exitCode: 0, stdout: '/w/q\n' }, { exitCode: 2, stdout: '' })
+  expect(repo).toEqual({ root: '/w/q', remote: null })
+  expect(nextPin(current, repo)).toBe(current)
+})
+
+test('checkoutArg hands the root 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)
+  }
+})

package/plugins/trailhead/tests/session-registry.test.ts

@@ -0,0 +1,50 @@
+import { expect, test } from 'claude-code/testing'
+
+import { sessionLiveness } from '../hooks/mod/session-registry'
+import type { RegistryDeps } from '../hooks/mod/session-registry'
+
+const DIR = '/home/u/.claude/sessions'
+const entry = (sessionId: string, pid: number) => JSON.stringify({ sessionId, pid })
+
+// Un registro finto: nome file -> testo; i pid in `alive` sono vivi, `null` = la piattaforma non lo dice.
+const deps = (files: Record<string, string> | Error, alive: number[] | null = []): RegistryDeps => ({
+  list: async () => {
+    if (files instanceof Error) throw files
+    return Object.keys(files)
+  },
+  read: async path => {
+    if (files instanceof Error) throw files
+    const text = files[path.slice(DIR.length + 1)]
+    if (text === undefined) throw new Error('ENOENT')
+    return text
+  },
+  pidAlive: async pid => (alive === null ? null : alive.includes(pid)),
+})
+
+test('a session with a live pid is live', async () => {
+  const files = { '10.json': entry('s-A', 10), '11.json': entry('s-B', 11) }
+  expect(await sessionLiveness(DIR, 's-A', deps(files, [10, 11]))).toBe('live')
+})
+
+test('a session whose entry is missing, or whose pid is dead, is gone', async () => {
+  const files = { '10.json': entry('s-A', 10), '11.json': entry('s-B', 11) }
+  expect(await sessionLiveness(DIR, 's-OLD', deps(files, [10, 11]))).toBe('gone')
+  expect(await sessionLiveness(DIR, 's-A', deps(files, [11]))).toBe('gone')
+})
+
+test('with no way to check a pid the entry alone says live', async () => {
+  const files = { '10.json': entry('s-A', 10) }
+  expect(await sessionLiveness(DIR, 's-A', deps(files, null))).toBe('live')
+})
+
+test('an unreadable registry is unknown, never gone', async () => {
+  expect(await sessionLiveness(DIR, 's-A', deps(new Error('EACCES')))).toBe('unknown')
+  expect(await sessionLiveness(DIR, 's-A', deps({}))).toBe('unknown')
+  expect(await sessionLiveness(DIR, 's-A', deps({ 'x.key': 'secret' }))).toBe('unknown')
+})
+
+test('a file that does not parse keeps a missing session unknown, but not a found live one', async () => {
+  const files = { '9.json': '{nope', '10.json': entry('s-A', 10), '11.json': JSON.stringify({ sessionId: 's-C' }) }
+  expect(await sessionLiveness(DIR, 's-OLD', deps(files, [10]))).toBe('unknown')
+  expect(await sessionLiveness(DIR, 's-A', deps(files, [10]))).toBe('live')
+})

package/plugins/trailhead/tests/whiteboard-follow.test.ts

@@ -0,0 +1,90 @@
+import { expect, test } from 'claude-code/testing'
+
+import type { WorkState } from '../types'
+import { createdIssueNumber, isWhiteboardCreate, nextFollow, whiteboardHint } from '../hooks/mod/whiteboard-follow'
+
+const state = (over: Partial<WorkState> = {}): WorkState => ({ map: null, ticket: 301, ...over }) as WorkState
+
+test('nextFollow follows an own whiteboard ticket once', () => {
+  expect(nextFollow(null, state(), 301, false)).toEqual({ follow: true, memo: 301 })
+  expect(nextFollow(301, state(), 301, false)).toEqual({ follow: false, memo: 301 })
+})
+
+test('nextFollow follows a different whiteboard ticket again', () => {
+  expect(nextFollow(301, state({ ticket: 302 }), 302, false)).toEqual({ follow: true, memo: 302 })
+})
+
+test('nextFollow never follows a map ticket, a foreign or orphaned state, or no own ticket', () => {
+  expect(nextFollow(null, state({ map: 12 }), 301, false)).toEqual({ follow: false, memo: null })
+  expect(nextFollow(null, state(), 999, false)).toEqual({ follow: false, memo: null })
+  expect(nextFollow(null, state(), null, false)).toEqual({ follow: false, memo: null })
+  expect(nextFollow(null, state(), 301, true)).toEqual({ follow: false, memo: null })
+})
+
+test('nextFollow keeps the memo on a null state', () => {
+  expect(nextFollow(301, null, null, false)).toEqual({ follow: false, memo: 301 })
+})
+
+test('isWhiteboardCreate reads every label form of an issue create', () => {
+  const yes = [
+    'gh issue create -t t --label trailhead:whiteboard',
+    'gh issue create -t t --label a,trailhead:whiteboard',
+    'gh issue create -t t --label=trailhead:whiteboard',
+    'gh issue create -t t -l trailhead:whiteboard',
+    'gh issue create -t t --label bug --label trailhead:whiteboard',
+    'gh issue create -t t --label "trailhead:whiteboard"',
+    "gh issue create -t t --label 'bug,trailhead:whiteboard' -b x",
+    'gh -R o/r issue create -l trailhead:whiteboard',
+  ]
+  for (const c of yes) expect(isWhiteboardCreate(c)).toBe(true)
+})
+
+test('isWhiteboardCreate refuses other labels, other verbs and other commands', () => {
+  const no = [
+    'gh issue create -t t --label trailhead:whiteboardx',
+    'gh issue create -t t --label trailhead:map',
+    'gh issue create -t t',
+    'gh issue create -t "trailhead:whiteboard"',
+    'gh issue edit 3 --add-label trailhead:whiteboard',
+    'gh issue create -t t --label bug; echo --label trailhead:whiteboard',
+    'echo --label trailhead:whiteboard',
+  ]
+  for (const c of no) expect(isWhiteboardCreate(c)).toBe(false)
+})
+
+test('isWhiteboardCreate reads continued lines, quoted separators and the attached short flag', () => {
+  const yes = [
+    'gh issue create \\\n  --title x \\\n  --label trailhead:whiteboard',
+    'gh issue create --title "a & b" --label trailhead:whiteboard',
+    'gh issue create --title "a; b | c" --label trailhead:whiteboard',
+    'gh issue create --body "a\nb" --label trailhead:whiteboard',
+    'gh issue create -t t -ltrailhead:whiteboard',
+    'cd /x && gh issue create -t t --label trailhead:whiteboard',
+  ]
+  for (const c of yes) expect(isWhiteboardCreate(c)).toBe(true)
+})
+
+test('isWhiteboardCreate ignores a label flag written inside a quoted argument', () => {
+  expect(isWhiteboardCreate('gh issue create --title "fix -l trailhead:whiteboard"')).toBe(false)
+  expect(isWhiteboardCreate("gh issue create -b 'see --label trailhead:whiteboard' -t t")).toBe(false)
+})
+
+test('createdIssueNumber reads the last-line issue URL from stdout, a string or the text', () => {
+  const url = 'https://github.com/o/r/issues/310'
+  expect(createdIssueNumber({ result: { stdout: `${url}\n`, stderr: '' } })).toBe(310)
+  expect(createdIssueNumber({ result: `creating\n${url}\n` })).toBe(310)
+  expect(createdIssueNumber({ result: {}, text: url })).toBe(310)
+})
+
+test('createdIssueNumber gives none on an error, no URL or a bad shape', () => {
+  expect(createdIssueNumber({ isError: true, result: 'https://github.com/o/r/issues/310' })).toBeNull()
+  expect(createdIssueNumber({ result: { stdout: 'ok' } })).toBeNull()
+  expect(createdIssueNumber({ result: { stdout: 'https://github.com/o/r/issues/310/extra' } })).toBeNull()
+  expect(createdIssueNumber(undefined)).toBeNull()
+  expect(createdIssueNumber('x')).toBeNull()
+  expect(createdIssueNumber({ result: 5 })).toBeNull()
+})
+
+test('whiteboardHint names the ticket in a few words', () => {
+  expect(whiteboardHint(310)).toBe('new whiteboard ticket #310: open Whiteboard')
+})

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

@@ -0,0 +1,33 @@
+import { expect, test } from 'claude-code/testing'
+
+import { candidates, isOwnState, parseWorktrees, pickOwn, siblingClones } from '../hooks/mod/work-state-locate'
+
+const state = (session: string | null) =>
+  JSON.stringify({ map: null, ticket: 270, title: 'T', step: 'execute', auto: false, autoDone: 0, session, updatedAt: null })
+
+test('parseWorktrees keeps the checkout paths in git order, spaces included', () => {
+  const out = 'worktree /repo\nHEAD abc\nbranch refs/heads/main\n\nworktree /my work/repo-t270\nHEAD def\ndetached\n\nworktree /repo-t5/\nbare\n'
+  expect(parseWorktrees(out)).toEqual(['/repo', '/my work/repo-t270', '/repo-t5'])
+  expect(parseWorktrees('')).toEqual([])
+  expect(parseWorktrees('fatal: not a git repository')).toEqual([])
+})
+
+test('siblingClones matches <basename>-t<digits> only, sorted, under the main root parent', () => {
+  const names = ['repo-t12', 'repo', 'repo-t5', 'repo-t5x', 'repo-tx', 'other-t3', 'repo-t5-old', 'repoXt7']
+  expect(siblingClones('/home/me/repo', names)).toEqual(['/home/me/repo-t12', '/home/me/repo-t5'])
+  expect(siblingClones('/r.x', ['r.x-t1', 'rax-t2'])).toEqual(['/r.x-t1'])
+})
+
+test('candidates drops the pinned root and duplicates, worktrees before siblings', () => {
+  expect(candidates('/repo', ['/repo', '/repo-t1', '/repo-t2'], ['/repo-t2', '/repo-t3'])).toEqual(['/repo-t1', '/repo-t2', '/repo-t3'])
+  expect(candidates('/repo/', ['/repo'], [])).toEqual([])
+})
+
+test('only a state naming this session is adopted', () => {
+  expect(isOwnState(state('A'), 'A')).toBe(true)
+  expect(isOwnState(state('B'), 'A')).toBe(false)
+  expect(isOwnState(state(null), 'A')).toBe(false)
+  expect(isOwnState('{not json', 'A')).toBe(false)
+  expect(pickOwn([null, state(null), state('B'), state('A'), state('A')], 'A')).toBe(3)
+  expect(pickOwn([null, state('B')], 'A')).toBe(-1)
+})