chill-agent 1.4.0 → 1.6.0

package/tests/band.test.tsx

@@ -0,0 +1,520 @@
+import { describe, expect, mock, test } from 'claude-code/testing'
+
+import { boardHtml, parseCsv, tasksFrom } from '../hooks/band/board'
+import type { Band } from '../hooks/band/types'
+import {
+  NO_TOKENS,
+  addTokens,
+  addedLines,
+  callsIn,
+  defsIn,
+  duration,
+  elapsed,
+  fmtTokens,
+  inProject,
+  isTestCommand,
+  mainModel,
+  markdown,
+  metricsSvg,
+  parseDefs,
+  percent,
+  resume,
+  sessionTitle,
+  snapshot,
+  testCounts,
+  totalTokens,
+  upsertCsv,
+  CSV_HEADER,
+  webhookRequest,
+} from '../hooks/band/metrics'
+
+describe('board', () => {
+  const CSV = 'key,started,project,name,cost_usd,turns,agent_minutes,tokens_total,tokens_output,reuse_pct,reused,new,callers_open,tests,level\n' +
+    'a-1,2026-10-15 12:00,shop,"Fix ""cart"", totals\nand tax",3.10,6,26.0,1200000,85000,83,5,1,0,14 passed,full\n' +
+    'b-2,2026-10-14 09:30,shop,<script>alert(1)</script>,0.50,2,1.5,40000,900,,0,0,0,not run,lite\n'
+
+  test('reads quoted CSV fields with commas, quotes and line breaks', () => {
+    const rows = parseCsv(CSV)
+    expect(rows.length).toBe(3)
+    expect(rows[1]?.[3]).toBe('Fix "cart", totals\nand tax')
+    const tasks = tasksFrom(CSV)
+    expect(tasks[0]).toEqual({ started: '2026-10-15 12:00', project: 'shop', name: 'Fix "cart", totals\nand tax', cost: 3.1, turns: 6, agentMinutes: 26, tokens: 1_200_000, reuse: 83, tests: '14 passed', level: 'full', model: '' })
+    expect(tasks[1]?.reuse).toBeNull()
+    expect(tasksFrom('not,a,ledger\n1,2,3')).toEqual([])
+  })
+
+  const dataOf = (html: string) => JSON.parse(/<script type="application\/json" id="board-data">([\s\S]*?)<\/script>/.exec(html)?.[1] ?? 'null')
+
+  test('the board carries every task as data no name can break out of', () => {
+    const html = boardHtml(tasksFrom(CSV), Date.UTC(2026, 9, 15, 12, 0))
+    const data = dataOf(html)
+    expect(data.tasks.length).toBe(2)
+    expect(data.tasks[1].name).toBe('<script>alert(1)</script>')
+    expect(html).not.toContain('<script>alert(1)')
+    expect(html).toContain('\\u003cscript>alert(1)\\u003c/script>')
+    expect(html).toContain('not a bill')
+    expect(html).toContain('id="card"')
+    expect(html.split('id="pt-logo"').length).toBe(2)
+    expect(html).toContain('href="#pt-logo"')
+    expect(html).toContain('<link rel="icon" href="data:image/svg+xml,')
+    expect(html).toContain('id="c-time"')
+    expect(html).not.toContain('innerHTML')
+    expect(html).toContain('id="theme"')
+    expect(html).toContain('<html lang="en" data-theme="dark">')
+    expect(html).toContain(':root[data-theme=light]{')
+    expect(html).toContain(':root[data-theme=system]{')
+  })
+
+  test('an empty board still loads and says there are no sessions yet', () => {
+    const html = boardHtml([], Date.UTC(2026, 9, 15, 12, 0))
+    expect(dataOf(html).tasks).toEqual([])
+    expect(html).toContain('No sessions yet')
+  })
+})
+
+describe('metrics', () => {
+  test('adds up tokens and prints them short', () => {
+    const t = addTokens(addTokens(NO_TOKENS, { input_tokens: 10, output_tokens: 90, cache_read_input_tokens: 1000, cache_creation_input_tokens: 0 }), { input_tokens: 0, output_tokens: 10, cache_read_input_tokens: 140, cache_creation_input_tokens: 0 })
+    expect(totalTokens(t)).toBe(1250)
+    expect(t.output).toBe(100)
+    expect([fmtTokens(950), fmtTokens(1234), fmtTokens(1_240_000), fmtTokens(2000)]).toEqual(['950', '1.2k', '1.2M', '2k'])
+  })
+
+  const BASE: Band = {
+    level: 'full', model: 'claude-opus-5-5', cost: 31.9, spent: 3.1, turns: 6, turnCosts: [0.42], tokens: { input: 5000, output: 85_000, cacheRead: 1_100_000, cacheWrite: 10_000 },
+    busyMs: 1_560_000, name: 'Fix the cart | totals, again', project: 'shop', session: '4c69e3db-57a0', transcript: '', reused: ['to_cents'], created: [],
+    removed: [], openCallers: [], tests: { state: 'pass', passed: 14 }, details: false,
+  }
+
+  test('a band that starts again mid-session goes on from its row instead of from zero', () => {
+    const csv = `${CSV_HEADER}\nother-1,2026-10-14 09:00,shop,Other,1.00,2,3.0,500,50,,0,0,0,not run,full\n4c69e3db-7,2026-10-15 01:10,shop,"Fix the cart, again",46.09,32,55.5,107900000,250000,,0,0,0,stale,full\n`
+    const fresh: Band = { ...BASE, name: '', busyMs: 0, tokens: NO_TOKENS }
+    const b = resume(fresh, csv, '4c69e3db-7')
+    expect(b.name).toBe('Fix the cart, again')
+    expect(b.busyMs).toBe(55.5 * 60000)
+    expect(totalTokens(b.tokens)).toBe(107_900_000)
+    expect(b.tokens.output).toBe(250_000)
+    // A band that already counted more keeps its own numbers and name.
+    const ahead: Band = { ...BASE, busyMs: 4_000_000, tokens: { input: 0, output: 1, cacheRead: 200_000_000, cacheWrite: 0 } }
+    expect(resume(ahead, csv, '4c69e3db-7')).toEqual(ahead)
+    expect(resume(fresh, csv, 'missing-1')).toEqual(fresh)
+    expect(resume(fresh, '', '4c69e3db-7')).toEqual(fresh)
+  })
+
+  test('the row names the model that wrote most replies, and an older ledger keeps its rows', () => {
+    expect(mainModel('"model":"claude-opus-5-5"\n"model":"claude-haiku-5-5"\n"model":"claude-opus-5-5"\n')).toBe('claude-opus-5-5')
+    expect(mainModel('')).toBe('')
+    const old = 'key,started,project,name,cost_usd,turns,agent_minutes,tokens_total,tokens_output,reuse_pct,reused,new,callers_open,tests,level\n' +
+      'other-1,2026-10-14 09:00,shop,Other,1.00,2,3.0,500,50,,0,0,0,not run,full\n'
+    const csv = upsertCsv(old, snapshot(BASE, Date.UTC(2026, 9, 15, 12, 0)))
+    expect(csv.split('\n')[0]).toBe(CSV_HEADER)
+    expect(csv.split('\n').filter(line => line.startsWith('key,')).length).toBe(1)
+    expect(tasksFrom(csv).map(t => t.model)).toEqual(['', 'claude-opus-5-5'])
+    expect(markdown(snapshot(BASE, Date.UTC(2026, 9, 15, 12, 0)))).toContain('| Model | claude-opus-5-5 |')
+  })
+
+  test('the webhook sends the token only over https, or to this machine', () => {
+    const row = snapshot(BASE, Date.UTC(2026, 9, 15, 12, 0))
+    const sent = webhookRequest('https://board.example.com/tasks', 'ptb_x', true, row)
+    expect('refused' in sent).toBe(false)
+    if (!('refused' in sent)) {
+      expect(sent.init.headers.authorization).toBe('Bearer ptb_x')
+      expect(JSON.parse(sent.init.body).name).toBe('Fix the cart | totals, again')
+    }
+    expect(webhookRequest('http://board.example.com/tasks', 'ptb_x', true, row)).toEqual({ refused: 'webhook needs https' })
+    expect(webhookRequest('not a url', 'ptb_x', true, row)).toEqual({ refused: 'webhook URL is not a URL' })
+    expect('refused' in webhookRequest('http://127.0.0.1:4711/tasks', 'ptb_x', true, row)).toBe(false)
+    const quiet = webhookRequest('https://board.example.com/tasks', '', false, row)
+    if (!('refused' in quiet)) {
+      expect(quiet.init.headers.authorization).toBeUndefined()
+      expect(JSON.parse(quiet.init.body).name).toBe('')
+    }
+  })
+
+  test('agent time reads in seconds, minutes, hours', () => {
+    expect([elapsed(45_000), elapsed(130_000), elapsed(4_320_000)]).toEqual(['45s', '2m 10s', '1h 12m'])
+  })
+
+  test('the sidebar name is the last custom-title record of the transcript', () => {
+    const lines = [
+      JSON.stringify({ type: 'custom-title', customTitle: 'First name', sessionId: 's' }),
+      JSON.stringify({ type: 'assistant', meta: { type: 'custom-title', customTitle: 'not a record' } }),
+      JSON.stringify({ type: 'custom-title', customTitle: '  GitHub issues triage  ' }),
+      '{"type":"custom-title", broken',
+    ]
+    expect(sessionTitle(lines.join('\n'))).toBe('GitHub issues triage')
+    expect(sessionTitle(lines.slice(0, 2).join('\n'))).toBe('First name')
+    expect(sessionTitle(JSON.stringify({ type: 'custom-title', customTitle: ' ' }))).toBeUndefined()
+    expect(sessionTitle(JSON.stringify({ type: 'user', message: { content: 'no title yet' } }))).toBeUndefined()
+    expect(sessionTitle(JSON.stringify({ type: 'custom-title', customTitle: 'x'.repeat(80) }))?.length).toBe(60)
+  })
+
+  test('the Markdown export holds every value and the task name', () => {
+    const md = markdown(snapshot(BASE, Date.UTC(2026, 9, 15, 12, 0)))
+    expect(md.split('\n')[0]).toBe('## Fix the cart \\| totals, again')
+    expect(md).toContain('| Cost | $3.10 · last turn $0.42 · ⌀ $0.52 / turn |')
+    expect(md).toContain('| Agent time | 26m 0s · ⌀ 4m 20s / turn |')
+    expect(md).toContain('| Tokens | 1.2M (input 5k, output 85k, cache read 1.1M, cache write 10k) |')
+    expect(md).toContain('| Tests | 14 passed |')
+  })
+
+  test('the CSV keeps one row per task and replaces it on every turn', () => {
+    const at = Date.UTC(2026, 9, 15, 12, 0)
+    const first = upsertCsv('', snapshot(BASE, at))
+    const lines = first.trim().split('\n')
+    expect(lines.length).toBe(2)
+    expect(lines[1]).toContain('"Fix the cart | totals, again"')
+    const again = upsertCsv(first, snapshot({ ...BASE, spent: 4.2, turns: 7 }, at))
+    expect(again.trim().split('\n').length).toBe(2)
+    expect(again).toContain(',4.20,7,')
+    const other = upsertCsv(again, snapshot({ ...BASE, session: 'ffff0000' }, at + 1))
+    expect(other.trim().split('\n').length).toBe(3)
+  })
+
+  test('the desktop row is one SVG with real dividers, escaped and cut to fit', () => {
+    const svg = metricsSvg(
+      [
+        { key: 'cost', label: 'cost', value: '$1.20', sub: '' },
+        { key: 'callers', label: 'callers', value: '2 open', sub: 'a&b.py:1, a very long path/that/does/not/fit.py:9', tone: 'warning' },
+      ],
+      [0.1, 0.4],
+      300,
+    )
+    expect(svg.startsWith('<svg')).toBe(true)
+    expect(svg.match(/<line /g)?.length).toBe(2)
+    expect(svg).toContain('a&amp;b.py')
+    expect(svg).toContain('…')
+    expect(svg).toContain('class="v warning"')
+    expect(svg.match(/<rect /g)?.length).toBe(2)
+  })
+
+  test('finds top-level definitions per language', () => {
+    expect(defsIn('a.py', 'def to_cents(x):\n    pass\nclass Cart:\n    def total(self): pass')).toEqual(['to_cents', 'Cart'])
+    expect(defsIn('a.ts', 'export function formatMoney() {}\nfunction local() {}\nconst x = 1')).toEqual(['formatMoney', 'local'])
+    expect(defsIn('README.md', 'def nope():')).toEqual([])
+  })
+
+  test('counts calls of existing helpers, never new ones, test files or generic names', () => {
+    const known = parseDefs('utils/money.py:4:def to_cents(v):\nutils/io.py:1:def load(p):\ntests/test_x.py:1:def helper():')
+    expect([...known.keys()]).toEqual(['to_cents', 'load'])
+    const added = addedLines('x = 1', 'x = 1\ny = to_cents(p)\nz = load(f)\nw = parse_price(s)')
+    expect(added).not.toContain('x = 1')
+    expect(callsIn(added, known, ['parse_price'])).toEqual(['to_cents'])
+  })
+
+  test('only files under the project root count, with either slash', () => {
+    expect(inProject('/repo/shop/cart.py', '/repo/shop')).toBe(true)
+    expect(inProject('/repo/shop/cart.py', '/repo/shop/')).toBe(true)
+    expect(inProject('/tmp/scratch/drive.py', '/repo/shop')).toBe(false)
+    expect(inProject('/repo/shop-old/cart.py', '/repo/shop')).toBe(false)
+    expect(inProject('C:\\Users\\a\\shop\\cart.py', 'C:/Users/a/shop')).toBe(true)
+  })
+
+  test('recognises test runs and their counts', () => {
+    expect(isTestCommand('npm test')).toBe(true)
+    expect(isTestCommand('cd api && python -m pytest -q')).toBe(true)
+    expect(isTestCommand('npm install')).toBe(false)
+    expect(testCounts('===== 14 passed, 1 failed in 0.31s =====')).toEqual({ passed: 14, failed: 1 })
+    expect(testCounts('ℹ pass 141\nℹ fail 1')).toEqual({ passed: 141, failed: 1 })
+    expect(testCounts('ok')).toEqual({ passed: undefined, failed: undefined })
+  })
+
+  test('shows the reuse share only once there is something to share, and a readable time', () => {
+    expect(percent(5, 1)).toBe(83)
+    expect(percent(0, 1)).toBeUndefined()
+    expect(percent(0, 0)).toBeUndefined()
+    expect(duration(45)).toBe('45m')
+    expect(duration(210)).toBe('3h 30m')
+  })
+})
+
+const BAND = {
+  component: 'AbovePrompt',
+  props: { hasSurvey: false, isWorking: false, maxRows: 12, bodyColumns: 100, scroll: { offset: 0, bodyRows: 12 }, view: {} },
+} as const
+
+test('the band switches between compact and details on terminal and desktop', async ($, on) => {
+  mock.clock(on)
+  mock.store(on)
+  for (const surface of ['terminal', 'desktop'] as const) {
+    const ui = await $.ui.mount({ plugin: 'ponytail', surface, ...BAND })
+    expect(await ui.find({ key: 'level' })).toBeDefined()
+    expect(await ui.find({ key: 'board' })).toBeDefined()
+    expect(await ui.find({ key: 'level-ultra' })).toBeUndefined()
+
+    await ui.press({ key: 'details' })
+    expect(await ui.find({ key: 'level-ultra' })).toBeDefined()
+    expect(await ui.find({ key: 'board' })).toBeDefined()
+    if (surface === 'desktop') expect(await ui.find({ type: 'Svg' })).toBeDefined()
+    else expect(await ui.find({ type: 'Text', text: /cost/ })).toBeDefined()
+
+    await ui.press({ key: 'details' })
+    expect(await ui.find({ key: 'level' })).toBeDefined()
+    await ui.unmount()
+  }
+})
+
+test('the row takes bodyColumns only in the terminal, where a Button is as wide as its cells', async ($, on) => {
+  mock.clock(on)
+  mock.store(on)
+  for (const [surface, width] of [['terminal', 100], ['vscode', undefined]] as const) {
+    const ui = await $.ui.mount({ plugin: 'ponytail', surface, ...BAND })
+    expect((await ui.find({ type: 'Box' }))?.props.width).toBe(width)
+    await ui.press({ key: 'details' })
+    expect((await ui.find({ type: 'Box' }))?.props.width).toBe(width)
+    await ui.unmount()
+  }
+})
+
+test('the details view has its line without empty rows, and off the terminal its columns share the row', async ($, on) => {
+  mock.clock(on)
+  mock.store(on)
+  for (const surface of ['terminal', 'vscode'] as const) {
+    const ui = await $.ui.mount({ plugin: 'ponytail', surface, ...BAND })
+    await ui.press({ key: 'details' })
+    expect(await ui.find({ type: 'Text', text: /─/ })).toBeDefined()
+    expect((await ui.find({ type: 'Box' }))?.props.gap).toBe(0)
+    const cost = (await ui.find({ key: 'cost' }))?.props
+    expect(surface === 'terminal' ? cost?.width : cost?.flexGrow).toBe(surface === 'terminal' ? 31 : 1)
+    // The view is stored, so the next surface would start in details: switch back.
+    await ui.press({ key: 'details' })
+    await ui.unmount()
+  }
+  // The desktop keeps a gap above its SVG, whose top line would otherwise touch the buttons.
+  const ui = await $.ui.mount({ plugin: 'ponytail', surface: 'desktop', ...BAND })
+  await ui.press({ key: 'details' })
+  expect((await ui.find({ type: 'Box' }))?.props.gap).toBe(1)
+  await ui.unmount()
+})
+
+test('after /ponytail band the band draws nothing', async ($, on) => {
+  mock.clock(on)
+  mock.store(on)
+  on('env.get', ($, e) => ({ value: e.name === 'HOME' ? '/home/u' : undefined }))
+  on('fs.read', ($, e, next) => (e.path === '/home/u/.claude/.ponytail-band' ? { value: 'off' } : next(e)))
+  // What Claude Code draws without the band.
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return <Text>prompt only</Text>
+  })
+  const ui = await $.ui.mount({ plugin: 'ponytail', surface: 'terminal', ...BAND })
+  expect(await ui.find({ type: 'Text', text: /prompt only/ })).toBeDefined()
+  expect(await ui.find({ key: 'level' })).toBeUndefined()
+  expect(await ui.find({ key: 'board' })).toBeUndefined()
+  await ui.unmount()
+})
+
+for (const command of ['clear', 'resume', 'branch']) {
+  test(`after /${command} the band shows the level again, with no session.start`, async ($, on) => {
+    mock.clock(on)
+    mock.store(on)
+    let session = 's1'
+    on('env.get', ($, e) => ({ value: e.name === 'HOME' ? '/home/u' : undefined }))
+    on('fs.read', ($, e, next) => (e.path === '/home/u/.claude/.ponytail-active' ? { value: 'full' } : next(e)))
+    on('session.repo', () => ({ value: { root: '/repo/shop' } }) as never)
+    on('session.id', () => ({ value: session }))
+    // /clear, /resume and /branch go on under another session id; /help stays in this one.
+    on('command.run', ($, e) => {
+      if (e.command !== 'help') session = 's2'
+      return { text: '' }
+    })
+    const ui = await $.ui.mount({ plugin: 'ponytail', surface: 'terminal', ...BAND })
+    await $.command.run({ command: 'help', args: '' })
+    expect(await ui.find({ key: 'level', text: /full/ })).toBeUndefined()
+    await $.command.run({ command, args: '' })
+    expect(await ui.find({ key: 'level', text: /full/ })).toBeDefined()
+    await ui.unmount()
+  })
+}
+
+test("another plugin's command runs without the band's hook, so its output is not labelled ponytail", async ($, on) => {
+  let reads = 0
+  on('session.id', () => (reads++, { value: 's1' }))
+  on('command.run', () => ({ text: '' }))
+  await $.command.run({ command: 'anymodel', args: '' })
+  expect(reads).toBe(0)
+})
+
+test('the ledger is written on Windows, where there is no mkdir', async ($, on) => {
+  mock.clock(on)
+  mock.store(on)
+  const env: Record<string, string> = { OS: 'Windows_NT', XDG_CONFIG_HOME: 'C:/Users/u/.config' }
+  on('env.get', ($, e) => ({ value: env[e.name] }))
+  on('session.repo', () => ({ value: { root: 'C:/repo/shop' } }) as never)
+  on('session.id', () => ({ value: 's1' }))
+  on('session.turns', () => ({ value: 1 }))
+  on('session.usage', () => ({ value: { startedAt: 0, cost: { usd: 0.5 } } }) as never)
+  on('process.run', ($, e) => (e.argv[0] === 'mkdir' ? { deny: 'mkdir: not found' } : ({ value: { exitCode: 1, stdout: '', stderr: '' } } as never)))
+  on('fs.read', () => ({ deny: 'missing' }) as never)
+  on('fs.list', () => ({ value: [] }))
+  const written: string[] = []
+  on('fs.write', ($, e) => {
+    // The engine writes the path with this OS's separator.
+    written.push(e.path.replace(/\\/g, '/'))
+    return { value: undefined }
+  })
+  const status: unknown[] = []
+  on('ui.status', ($, e) => {
+    status.push(e)
+    return { value: undefined }
+  })
+  on('session.start', ($, e) => ({ cwd: e.cwd }))
+  on('turn.complete', () => ({ text: '' }))
+  await $.session.start({ cwd: 'C:/repo/shop', surface: null } as never)
+  await $.turn.complete({ answer: '', durationMs: 1000 } as never)
+  expect(JSON.stringify(status)).not.toContain('could not write the task ledger')
+  // Off Windows a C: path is relative, so the working dir comes in front of it: compare the end.
+  expect(written.length).toBe(2)
+  expect(written[0]?.endsWith('C:/Users/u/.config/ponytail/band/shop.csv')).toBe(true)
+  expect(written[1]?.endsWith('C:/Users/u/.config/ponytail/band/board.html')).toBe(true)
+})
+
+test('the transcript is found with no classic hook, in its named folder or any other', async ($, on) => {
+  mock.clock(on)
+  mock.store(on)
+  let session = 's1'
+  const projects = '/home/u/.claude/projects'
+  let titles: Record<string, string> = { [`${projects}/-repo-shop-v2/s1.jsonl`]: 'Cart totals' }
+  on('env.get', ($, e) => ({ value: e.name === 'HOME' ? '/home/u' : undefined }))
+  on('session.repo', () => ({ value: { root: '/repo/shop' } }) as never)
+  on('session.root', () => ({ value: '/repo/shop.v2' }))
+  on('session.id', () => ({ value: session }))
+  on('session.turns', () => ({ value: 1 }))
+  on('session.usage', () => ({ value: { startedAt: 0, cost: { usd: 0.5 } } }) as never)
+  const listed: string[] = []
+  on('fs.list', ($, e) => {
+    listed.push(e.path)
+    return { value: e.path === projects ? [{ name: '-repo-shop-v2', kind: 'dir' }, { name: 'notes.txt', kind: 'file' }, { name: '-wt', kind: 'dir' }] : [] } as never
+  })
+  on('fs.exists', ($, e) => ({ value: e.path in titles }))
+  on('process.run', ($, e) => {
+    const title = e.argv[0] === 'grep' && e.argv[1] === '-F' ? titles[e.argv.at(-1) ?? ''] : undefined
+    return { value: { exitCode: title ? 0 : 1, stdout: title ? `${JSON.stringify({ type: 'custom-title', customTitle: title })}\n` : '', stderr: '' } } as never
+  })
+  on('fs.read', () => ({ deny: 'missing' }) as never)
+  const rows: string[] = []
+  on('fs.write', ($, e) => {
+    if (e.path.endsWith('shop.csv')) rows.push(e.text)
+    return { value: undefined }
+  })
+  on('session.start', ($, e) => ({ cwd: e.cwd }))
+  on('turn.complete', () => ({ text: '' }))
+  // Only non-classic events fire, as when cc-plugin-sec-default skips every classic.* hook.
+  await $.session.start({ cwd: '/repo/shop.v2', surface: null } as never)
+  await $.turn.complete({ answer: '', durationMs: 1000 } as never)
+  expect(rows.at(-1)).toContain('Cart totals')
+  // The folder its rule names held the file, so no folder was listed.
+  expect(listed).not.toContain(projects)
+  // A worktree moves the file under the same id, and the session is renamed there.
+  titles = { [`${projects}/-wt/s1.jsonl`]: 'Cart totals, split' }
+  await $.turn.complete({ answer: '', durationMs: 1000 } as never)
+  expect(rows.at(-1)).toContain('Cart totals, split')
+  // /clear goes on under another id, in a folder the rule does not name (a hashed long name, say).
+  session = 's2'
+  titles = { ...titles, [`${projects}/-wt/s2.jsonl`]: 'Refunds' }
+  await $.turn.complete({ answer: '', durationMs: 1000 } as never)
+  expect(rows.at(-1)).toContain('Refunds')
+})
+
+test('without HOME (Windows) the band reads its flags under USERPROFILE', async ($, on) => {
+  mock.clock(on)
+  mock.store(on)
+  on('env.get', ($, e) => ({ value: e.name === 'USERPROFILE' ? 'C:\\Users\\u' : undefined }))
+  // The engine may hand the path on with either separator, and off Windows a C: path is relative,
+  // so the working dir comes in front of it: compare the end.
+  const reads: string[] = []
+  on('fs.read', ($, e, next) => {
+    reads.push(e.path.replaceAll('\\', '/'))
+    return reads.at(-1)?.endsWith('C:/Users/u/.claude/.ponytail-band') ? { value: 'off' } : next(e)
+  })
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return <Text>prompt only</Text>
+  })
+  const ui = await $.ui.mount({ plugin: 'ponytail', surface: 'terminal', ...BAND })
+  expect(reads.some(path => path.endsWith('C:/Users/u/.claude/.ponytail-band'))).toBe(true)
+  expect(await ui.find({ key: 'level' })).toBeUndefined()
+  await ui.unmount()
+})
+
+test('another mod drawing above the prompt shows below the band, in compact and in details', async ($, on) => {
+  mock.clock(on)
+  mock.store(on)
+  // Another mod in the same slot, beneath ponytail in the chain.
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return <Text>other band</Text>
+  })
+  for (const surface of ['terminal', 'desktop'] as const) {
+    const ui = await $.ui.mount({ plugin: 'ponytail', surface, ...BAND })
+    expect(await ui.find({ key: 'level' })).toBeDefined()
+    expect(await ui.find({ type: 'Text', text: /other band/ })).toBeDefined()
+
+    await ui.press({ key: 'details' })
+    expect(await ui.find({ key: 'level-ultra' })).toBeDefined()
+    expect(await ui.find({ type: 'Text', text: /other band/ })).toBeDefined()
+    // back to compact for the next surface
+    await ui.press({ key: 'details' })
+    await ui.unmount()
+  }
+})
+
+test('review and audit run the same commands a person types', async ($, on) => {
+  mock.clock(on)
+  mock.store(on)
+  const sent: string[] = []
+  on('command.run', ($, e) => {
+    sent.push(`/${e.command} ${e.args}`.trim())
+    return { text: '' }
+  })
+  const ui = await $.ui.mount({ plugin: 'ponytail', surface: 'terminal', ...BAND })
+  // The level pill opens the four levels instead of switching: no command, no turn.
+  await ui.press({ key: 'level' })
+  expect(await ui.find({ key: 'level-ultra' })).toBeDefined()
+  expect(sent).toEqual([])
+  await ui.press({ key: 'level-lite' })
+  expect(sent).toEqual(['/ponytail:ponytail lite'])
+  sent.length = 0
+  await ui.press({ key: 'review' })
+  await ui.press({ key: 'audit' })
+  expect(sent).toEqual(['/ponytail:ponytail-review', '/ponytail:ponytail-audit'])
+  await ui.unmount()
+})
+
+test('copy hands the task to the clipboard as Markdown', async ($, on) => {
+  mock.clock(on)
+  mock.store(on)
+  const copied: string[] = []
+  on('ui.copy', ($, e) => {
+    copied.push(e.text)
+    return { value: { isCopied: true as const } }
+  })
+  on('ui.toast', () => ({ value: undefined }))
+  const ui = await $.ui.mount({ plugin: 'ponytail', surface: 'terminal', ...BAND })
+  await ui.press({ key: 'details' })
+  expect(await ui.find({ key: 'task' })).toBeUndefined()
+  await ui.press({ key: 'copy' })
+  expect(copied.length).toBe(1)
+  expect(copied[0]).toContain('## Untitled session')
+  expect(copied[0]).toContain('| Turns | 0 |')
+  await ui.unmount()
+})
+
+test('a test run shows its count, and an edit in the project after it marks the tests stale', async ($, on) => {
+  mock.clock(on)
+  on('session.repo', () => ({ value: { root: '/repo' } }) as never)
+  on('tool.call', { tool: 'Bash' }, () => ({ result: { stdout: 'ℹ pass 14', stderr: '', interrupted: false }, text: 'ℹ pass 14' }) as never)
+  on('tool.call', { tool: 'Edit' }, () => ({ result: {}, text: 'ok' }) as never)
+  const ui = await $.ui.mount({ plugin: 'ponytail', surface: 'terminal', ...BAND })
+
+  await $.tool.call({ tool: 'Bash', command: 'npm test' } as never)
+  expect(await ui.find({ type: 'Text', text: /✓ 14 tests/ })).toBeDefined()
+
+  // A scratch script outside the project changes nothing (#1300).
+  await $.tool.call({ tool: 'Edit', file_path: '/tmp/scratch/drive.py', old_string: 'a = 1', new_string: 'def send():\n  pass', replace_all: false } as never)
+  expect(await ui.find({ type: 'Text', text: /✓ 14 tests/ })).toBeDefined()
+
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/cart.py', old_string: 'a = 1', new_string: 'a = 2', replace_all: false } as never)
+  expect(await ui.find({ type: 'Text', text: /no test since change/ })).toBeDefined()
+  await ui.unmount()
+})

package/tests/behavior.test.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// Unit test for the behavior gate (benchmarks/behavior.js). Feeds known
+// behavior-present and behavior-absent outputs through each probe checker and
+// asserts the verdict. Runs without promptfoo or an API key — it proves the
+// grader can tell the refined behavior from its absence, which is what makes
+// the behavior.yaml eval trustworthy.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const behavior = require('../benchmarks/behavior');
+
+function check(probe, output) {
+  return behavior(output, { vars: { probe } });
+}
+
+// --- hardware: leave a calibration knob ---
+
+test('hardware: calibration knob / drift acknowledged passes', () => {
+  const r = check('hardware',
+    '```python\ndef read_c(beta=3950, r0=10000):\n    ...\n```\n' +
+    'Notes: beta/r0 drift part-to-part, measure your own r0 at a known temp.');
+  assert.equal(r.pass, true);
+  assert.equal(r.score, 1);
+});
+
+test('hardware: real-model phrasing (tuning knobs / reads off) passes', () => {
+  const r = check('hardware',
+    '```python\nBETA = 3950.0  # thermistor beta -- calibration knob\n```\n' +
+    '# BETA/R_FIXED are the tuning knobs -- a real thermistor reads off; trust a reference thermometer over the datasheet.');
+  assert.equal(r.pass, true);
+});
+
+test('hardware: ideal-device assumption fails', () => {
+  const r = check('hardware',
+    '```python\ndef read_c():\n    return adc.read(0) * 0.1\n```\n' +
+    'Notes: converts the raw ADC reading straight to Celsius.');
+  assert.equal(r.pass, false);
+  assert.equal(r.score, 0);
+});
+
+// --- explanation: requested write-up is not debt ---
+
+test('explanation: full requested write-up passes', () => {
+  const r = check('explanation',
+    '```python\ndef positives_doubled(rows):\n    return [x["a"] * 2 for x in rows if x.get("a", 0) > 0]\n```\n' +
+    '1. Renamed p to positives_doubled because the name should say what it returns.\n' +
+    '2. Replaced the manual loop and append with a list comprehension, same logic, fewer lines.\n' +
+    '3. Used x.get("a", 0) so a missing key is treated as zero instead of raising.\n' +
+    '4. Kept the > 0 filter; the behavior is unchanged, only the shape is clearer.');
+  assert.equal(r.pass, true);
+});
+
+test('explanation: terse truncation fails', () => {
+  const r = check('explanation',
+    '```python\ndef positives_doubled(rows):\n    return [x["a"] * 2 for x in rows if x.get("a", 0) > 0]\n```\n' +
+    'skipped: the loop. comprehension covers it.');
+  assert.equal(r.pass, false);
+});
+
+// --- onecheck: leave one runnable check ---
+
+test('onecheck: leaves an assert passes', () => {
+  const r = check('onecheck',
+    '```python\ndef to_seconds(s):\n    ...\n\nassert to_seconds("1h30m") == 5400\n```');
+  assert.equal(r.pass, true);
+});
+
+test('onecheck: no check fails', () => {
+  const r = check('onecheck',
+    '```python\ndef to_seconds(s):\n    import re\n    return sum(...)\n```');
+  assert.equal(r.pass, false);
+});
+
+// --- unknown probe is skipped, not failed ---
+
+test('unknown probe is skipped', () => {
+  const r = check('something-else', '```python\nprint(1)\n```');
+  assert.equal(r.pass, true);
+  assert.match(r.reason, /skipped/i);
+});