@ucsandman/legcli 0.12.0 → 0.13.0

package/scripts/board-jump-probe.mjs

@@ -0,0 +1,335 @@
+// board-jump-probe — the regression harness for "the page keeps jumping around
+// and knocking me out of what I'm doing".
+//
+// A reader with a terminal expanded, the pointer inside the expansion and the
+// Timeline in view is reading a region whose position on the page is decided by
+// the rows ABOVE it. Every push re-sorts the list (needs-you first), rebuilds
+// every row from scratch, and a row that grew a waiting sentence, or moved
+// across the needs-you partition, takes the expansion with it. scrollY does not
+// change, so no scroll-hold probe can see it; what moves is the content under a
+// still viewport.
+//
+// This drives exactly that: seeds a board, expands the last live row, scrolls
+// the Timeline into view, focuses a control and selects a sentence inside the
+// expansion, then over ten pushes appends events and flips a row ABOVE it into
+// needs-you. It records, per push, where the region sits in the viewport, what
+// has focus, and whether the selection survived.
+//
+//   node scripts/board-jump-probe.mjs            # ten pushes, prints a table
+//   node scripts/board-jump-probe.mjs --json     # the same, as JSON
+//
+// The verdict line is the whole point: regionTop must not move by more than
+// 2px, focus must not be lost, and the selection must survive. NEVER port 4747,
+// that is the operator's live board; this one binds an ephemeral port of its
+// own and kills everything it started.
+import { chromium } from 'playwright'
+import { spawnSync } from 'node:child_process'
+import { mkdtempSync, rmSync, existsSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
+const asJson = process.argv.includes('--json')
+const POLLS = 10
+
+const HOME = mkdtempSync(join(tmpdir(), 'leg-jump-probe-'))
+process.env.LEG_HOME = HOME
+process.env.BATON_HOME = HOME
+process.env.LEG_TRUST = 'never'
+process.env.BATON_TRUST = 'never'
+process.env.LEG_QUIET = '1'
+process.env.BATON_QUIET = '1'
+
+function cleanup() {
+  try {
+    const f = join(HOME, 'sleepers.json')
+    if (existsSync(f)) for (const pid of JSON.parse(readFileSync(f, 'utf8'))) { try { process.kill(pid) } catch { /* already gone */ } }
+  } catch { /* nothing to kill */ }
+  try { rmSync(HOME, { recursive: true, force: true }) } catch { /* windows holds a handle sometimes */ }
+}
+// the seeder's sleepers outlive this process if it dies before the finally, and
+// a leaked sleeper is a node process nobody owns, so the exits are covered too
+process.on('uncaughtException', (e) => { cleanup(); console.error(e); process.exit(1) })
+process.on('SIGINT', () => { cleanup(); process.exit(130) })
+
+// the seeder spawns detached sleepers so the live rows have a runner pid that
+// reapLost() can find; they are written to sleepers.json and killed at the end
+const seed = spawnSync(process.execPath, [join(ROOT, 'scripts', 'seed-wes-board.mjs')], {
+  env: { ...process.env }, encoding: 'utf8',
+})
+if (seed.status !== 0) { console.error(seed.stdout, seed.stderr); cleanup(); process.exit(1) }
+
+const { createBoardServer } = await import('../src/server.mjs')
+const { updateSession, appendEvent } = await import('../src/sessions.mjs')
+
+// the four live rows the seeder writes, in the order renderSessions sorts them:
+// needs-you first (0049, 0257), then started_at ascending (0213, 0455).
+// The expansion hangs under a RUNNING row in the middle of the list, which is
+// where a reader actually leaves it, and the row that flips is the one BELOW
+// it: crossing into needs-you sends that row to the top of the list and pushes
+// the expansion — and everything the reader is looking at — down the page.
+const EXPANDED = 's-20260915-0213-claude-95d3'
+const FLIPS = 's-20260915-0455-claude-8e8a'
+
+const srv = createBoardServer({ bind: '127.0.0.1', port: 0, token: '', scheduler: false })
+const { port } = await srv.start()
+const base = `http://127.0.0.1:${port}`
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+let browser = null
+
+try {
+  browser = await chromium.launch()
+  const page = await browser.newPage({ viewport: { width: 1280, height: 900 } })
+  const errors = []
+  page.on('console', (m) => { if (m.type() === 'error') errors.push(m.text()) })
+  page.on('pageerror', (e) => errors.push(String(e)))
+  // networkidle never fires: the board polls. Wait for real rows instead.
+  await page.goto(base + '/', { waitUntil: 'domcontentloaded' })
+  await page.waitForSelector('#session-grid .term', { timeout: 20000 })
+  await sleep(800)
+
+  // ---- scenario 1 (finding 5): the click that opens the expansion ---------
+  // The reader is scrolled down the page, looking at the terminals, and presses
+  // Details. #session-drawer is still parked at the end of <body> at that
+  // moment, so an anchor measured there is hundreds of pixels below where the
+  // region will land, and putting it "back" scrolls the whole window. Nothing
+  // the reader asked for moved, so scrollY must not move either.
+  await page.evaluate(() => window.scrollTo(0, 400))
+  await sleep(250)
+  const openBefore = await page.evaluate(() => ({
+    scrollY: Math.round(window.scrollY),
+    drawerParent: document.getElementById('session-drawer')?.parentNode?.id || document.getElementById('session-drawer')?.parentNode?.tagName || 'none',
+  }))
+  // .click() on the element itself, not page.click(): Playwright scrolls a
+  // target into view before it clicks, which would move the page for us and
+  // hide the very displacement this scenario measures.
+  await page.evaluate((key) => document.querySelector(`[data-focus-key="${key}"]`)?.click(), `details:${EXPANDED}`)
+  await page.waitForSelector('#session-drawer:not([hidden]) .drawer-timeline', { timeout: 20000 })
+  await sleep(1200)
+  const openAfter = await page.evaluate(() => ({
+    scrollY: Math.round(window.scrollY),
+    drawerParent: document.getElementById('session-drawer')?.parentNode?.id || document.getElementById('session-drawer')?.parentNode?.tagName || 'none',
+  }))
+  const openDrift = Math.abs(openAfter.scrollY - openBefore.scrollY)
+
+  // scroll so the Timeline is in view, which is where the reader is
+  await page.evaluate(() => {
+    const t = document.querySelector('#session-drawer [data-scroll-key="timeline"]')
+    if (t) window.scrollTo(0, Math.max(0, window.scrollY + t.getBoundingClientRect().top - 300))
+  })
+  await sleep(300)
+
+  // a control the reader tabbed to, and a sentence they are half way through
+  // selecting: both live inside the expansion and both must survive a push
+  await page.evaluate(() => {
+    document.querySelector('#session-drawer [data-focus-key="drawer-pause"]')?.focus({ preventScroll: true })
+    const p = document.querySelector('#session-drawer .drawer-timeline .timeline-summary')
+    if (p && p.firstChild) {
+      const r = document.createRange()
+      r.selectNodeContents(p)
+      const sel = document.getSelection()
+      sel.removeAllRanges()
+      sel.addRange(r)
+    }
+  })
+
+  const read = () => page.evaluate(() => {
+    const region = document.getElementById('session-drawer')
+    const rect = region ? region.getBoundingClientRect() : null
+    const a = document.activeElement
+    const timeline = document.querySelector('#session-drawer [data-scroll-key="timeline"]')
+    const sel = document.getSelection()
+    return {
+      scrollY: Math.round(window.scrollY),
+      regionTop: rect ? Math.round(rect.top) : null,
+      docTop: rect ? Math.round(rect.top + window.scrollY) : null,
+      focus: a ? (a.getAttribute?.('data-focus-key') || a.id || a.tagName) : 'none',
+      selection: sel ? String(sel).trim().slice(0, 28) : '',
+      timelineScroll: timeline ? Math.round(timeline.scrollTop) : null,
+      rows: [...document.querySelectorAll('#session-grid .term')].map((r) => r.getAttribute('data-session-id').slice(-4)).join(' '),
+      lines: document.querySelectorAll('#session-drawer .drawer-timeline .timeline-item').length,
+      // the volume behind the verdict: the raw events those lines stand for,
+      // counting a collapsed line as the ×N it carries
+      shows: [...document.querySelectorAll('#session-drawer .drawer-timeline .timeline-item')]
+        .reduce((n, it) => n + (Number((it.querySelector('.timeline-count')?.textContent || '').replace('×', '')) || 1), 0),
+      repeat: document.querySelector('#session-drawer .timeline-count')?.textContent || '',
+    }
+  })
+
+  const rows = [{ poll: 0, what: 'settled', ...await read() }]
+
+  for (let i = 1; i <= POLLS; i++) {
+    // a status event on the expanded terminal, the usage-poll spam Wes sees
+    appendEvent(EXPANDED, { type: 'status', summary: 'usage read: claude default, five_hour 38%' })
+    let what = 'event'
+    // and half way through, a row ABOVE it crosses into the needs-you partition
+    if (i === 4) {
+      updateSession(FLIPS, { status: 'warning', waiting: { type: 'idle_prompt', message: 'Claude is waiting for your input', since: new Date().toISOString() } })
+      what = 'row above -> needs-you'
+    }
+    if (i === 8) {
+      updateSession(FLIPS, { status: 'running', waiting: null })
+      what = 'row above -> running'
+    }
+    // 1500ms, not 2200: the region's stand-down under a live selection is
+    // capped at DRAWER_HOLD_MS (20s, scenario 3 below), so this phase has to
+    // finish inside that cap for "the selection survived every poll" to be a
+    // statement about the stand-down rather than about the cap.
+    await sleep(1500)
+    rows.push({ poll: i, what, ...await read() })
+  }
+
+  // A region that stands down while the reader is selecting text holds its
+  // selection trivially, by never redrawing again. The reader letting go is the
+  // other half of the contract: the events that arrived while they were reading
+  // must land, and the flood of identical status lines must be one line by now.
+  const held = rows.length - 1
+  await page.evaluate(() => document.getSelection().removeAllRanges())
+  for (let i = POLLS + 1; i <= POLLS + 3; i++) {
+    appendEvent(EXPANDED, { type: 'status', summary: 'usage read: claude default, five_hour 38%' })
+    let what = 'let go'
+    if (i === POLLS + 2) {
+      updateSession(FLIPS, { status: 'warning', waiting: { type: 'idle_prompt', message: 'Claude is waiting for your input', since: new Date().toISOString() } })
+      what = 'row above -> needs-you'
+    }
+    await sleep(2200)
+    rows.push({ poll: i, what, ...await read() })
+  }
+
+  const EXP4 = EXPANDED.slice(-4)
+  const FLIP4 = FLIPS.slice(-4)
+
+  // ---- scenario 2 (finding 6): the needs-you sort under an expansion -------
+  // The resting state of a dashboard is one terminal expanded and nobody
+  // touching the machine. A different terminal then hits a permission prompt.
+  // The hold on `expanded` had no time bound at all, so that row stayed
+  // wherever it was for as long as the expansion was open: the board knew (the
+  // row went urgent, the tab badge counted it) and would not surface it. It
+  // gets the same ORDER_HOLD_MS release hovering and focus already had. What
+  // must not move is the expansion's offset in the viewport, which is
+  // holdAnchor's job, so both halves are measured here.
+  updateSession(FLIPS, { status: 'running', waiting: null })
+  await page.evaluate(() => {
+    document.getSelection()?.removeAllRanges()
+    if (document.activeElement && document.activeElement.blur) document.activeElement.blur()
+  })
+  await page.mouse.move(2, 2)
+  await sleep(4500)
+  const settled = await read()
+  updateSession(FLIPS, { status: 'warning', waiting: { type: 'idle_prompt', message: 'Claude is waiting for your input', since: new Date().toISOString() } })
+  const late = [{ at: 0, what: 'flipped below', ...settled }]
+  for (let t = 3; t <= 39; t += 3) {
+    await sleep(3000)
+    late.push({ at: t, what: '', ...await read() })
+  }
+  const surfaced = (r) => r.rows.indexOf(FLIP4) >= 0 && r.rows.indexOf(FLIP4) < r.rows.indexOf(EXP4)
+  const appliedAt = late.find(surfaced)
+  const lateDrift = Math.max(...late.map((r) => Math.abs(r.regionTop - settled.regionTop)))
+
+  // ---- scenario 3 (finding 18): a selection must not freeze the region -----
+  // A double-click leaves an uncollapsed selection behind. The stand-down had
+  // no time bound either, so a reader who picked out a path and kept reading
+  // never saw another turn land: twelve finished and none of them appeared in
+  // sixty seconds, with nothing on screen saying the region was stale. The
+  // stand-down is capped at DRAWER_HOLD_MS; the selection dies with the redraw
+  // that ends it, which is the price of the reader seeing what is happening.
+  await page.evaluate(() => {
+    const p = document.querySelector('#session-drawer .drawer-timeline .timeline-summary')
+    if (p && p.firstChild) {
+      const r = document.createRange()
+      r.selectNodeContents(p)
+      const sel = document.getSelection()
+      sel.removeAllRanges()
+      sel.addRange(r)
+    }
+  })
+  await sleep(600)
+  const frozenBase = await read()
+  // distinct summaries, so collapseEvents cannot fold them into one line and
+  // hide the fact that nothing was drawn
+  for (let n = 1; n <= 6; n++) appendEvent(EXPANDED, { type: 'turn', summary: `turn ${n} finished, ${n} files` })
+  const frozen = [{ at: 0, ...frozenBase }]
+  for (let t = 5; t <= 45; t += 5) {
+    await sleep(5000)
+    frozen.push({ at: t, ...await read() })
+  }
+  const thawedAt = frozen.find((r) => r.shows > frozenBase.shows)
+
+  const base0 = rows[0]
+  const drift = (r) => Math.abs(r.regionTop - base0.regionTop)
+  const worst = Math.max(...rows.map(drift))
+  const focusLost = rows.filter((r) => r.focus !== base0.focus).length
+  const selLost = rows.slice(0, held + 1).filter((r) => !r.selection).length
+  const last = rows[rows.length - 1]
+  const caughtUp = last.shows - rows[0].shows
+  const verdict = {
+    pollsHoldingASelection: held,
+    pollsAfterLettingGo: rows.length - 1 - held,
+    baselineRegionTop: base0.regionTop,
+    worstRegionTopDrift: worst,
+    scrollYDrift: Math.max(...rows.map((r) => Math.abs(r.scrollY - base0.scrollY))),
+    focusLostPolls: focusLost,
+    selectionLostPolls: selLost,
+    eventsAfterLettingGo: caughtUp,
+    timelineLines: last.lines,
+    repeatCollapsedTo: last.repeat,
+    // scenario 1: the click that opens the expansion
+    openScrollYBefore: openBefore.scrollY,
+    openScrollYAfter: openAfter.scrollY,
+    openScrollYDrift: openDrift,
+    // scenario 2: the needs-you sort under an expansion
+    needsYouSurfacedAfterS: appliedAt ? appliedAt.at : null,
+    orderSamples: late.length,
+    regionTopDriftWhileResorting: lateDrift,
+    // scenario 3: the region under a forgotten selection
+    regionCaughtUpAfterS: thawedAt ? thawedAt.at : null,
+    eventsHeldBack: 6,
+    eventsLanded: thawedAt ? thawedAt.shows - frozenBase.shows : 0,
+    consoleErrors: errors,
+    pass: worst <= 2 && focusLost === 0 && selLost === 0 && caughtUp >= POLLS && last.repeat !== ''
+      && openDrift <= 2
+      && Boolean(appliedAt) && lateDrift <= 2
+      && Boolean(thawedAt) && thawedAt.at <= 45,
+  }
+
+  if (asJson) console.log(JSON.stringify({ rows, open: [openBefore, openAfter], late, frozen, verdict }, null, 2))
+  else {
+    const table = (title, cols, data) => {
+      console.log(title)
+      const w = cols.map((c) => Math.max(c.length, ...data.map((r) => String(r[c] ?? '').length)))
+      const line = (vals) => vals.map((v, i) => String(v ?? '').padEnd(w[i])).join('  ')
+      console.log(line(cols))
+      console.log(w.map((n) => '-'.repeat(n)).join('  '))
+      for (const r of data) console.log(line(cols.map((c) => r[c])))
+      console.log('')
+    }
+    table('the expansion under ten pushes (a selection held, then let go)',
+      ['poll', 'what', 'scrollY', 'regionTop', 'docTop', 'focus', 'selection', 'lines', 'shows', 'repeat', 'rows'], rows)
+    table('scenario 1: the click that opens the expansion (finding 5)',
+      ['when', 'scrollY', 'drawerParent'],
+      [{ when: 'before Details', ...openBefore }, { when: 'after Details', ...openAfter }])
+    table('scenario 2: a terminal goes needs-you under an open expansion (finding 6)',
+      ['at', 'what', 'rows', 'regionTop', 'scrollY'], late)
+    table('scenario 3: the region under a forgotten selection (finding 18)',
+      ['at', 'lines', 'shows', 'selection'], frozen)
+    console.log(`regionTop drift: ${worst}px (must be <= 2)   scrollY drift: ${verdict.scrollYDrift}px`)
+    console.log(`focus lost on ${focusLost} of ${rows.length - 1} polls   selection lost on ${selLost} of ${held} polls holding one`)
+    console.log(`after letting go: ${caughtUp} new events landed in the region, drawn as ${last.lines} line${last.lines === 1 ? '' : 's'}, repeats collapsed to ${last.repeat || 'nothing'}`)
+    console.log(`opening the expansion moved the page ${openDrift}px (${openBefore.scrollY} -> ${openAfter.scrollY}, must be <= 2)`)
+    console.log(appliedAt
+      ? `needs-you surfaced ${appliedAt.at}s after the flip, over ${late.length} samples, with the expansion held to ${lateDrift}px in the viewport`
+      : `needs-you NEVER surfaced in ${late[late.length - 1].at}s of an open expansion, over ${late.length} samples: rows stayed "${late[late.length - 1].rows}"`)
+    console.log(thawedAt
+      ? `the region caught up ${thawedAt.at}s after 6 turns landed under a live selection (${thawedAt.shows - frozenBase.shows} of 6 drawn)`
+      : `the region NEVER caught up: 6 turns landed and ${frozen[frozen.length - 1].shows - frozenBase.shows} were drawn in ${frozen[frozen.length - 1].at}s`)
+    if (errors.length) console.log(`console errors: ${errors.length}\n  ${errors.slice(0, 5).join('\n  ')}`)
+    console.log(verdict.pass ? 'PASS: the expansion held still under the reader' : 'FAIL: the page moved under the reader')
+  }
+  process.exitCode = verdict.pass ? 0 : 1
+} finally {
+  await browser?.close().catch(() => {})
+  await srv.stop().catch(() => {})
+  cleanup()
+}

package/src/attach.mjs

@@ -23,15 +23,15 @@ import { ensure as ensureWorktree, remove as removeWorktree } from './worktree.m
 import { canonPath, realPath } from './fsx.mjs'
 import { whoami, readShare, isOn as shareIsOn } from './share.mjs'
 import { readAccounts, envFor, refreshAccount } from './accounts.mjs'
-import { recordUsage, markLimited, chooseNext, candidates, fmtReset, WARN_PCT, readUsage, isAvailable, wallActive, rungLabel, skipLine } from './usage.mjs'
+import { recordUsage, markLimited, chooseNext, candidates, fmtReset, WARN_PCT, readUsage, usageIsStale, isAvailable, wallActive, rungLabel, skipLine } from './usage.mjs'
 import { entitlement, allows, describe as describeLicense } from './license.mjs'
 import { writeSettings, userStatusLine, transcriptTail as claudeTail, modelAlias, modelFromTranscript, printable } from './taps/claude.mjs'
 import { modelFlagFor, isDownshift } from './buckets.mjs'
 import { ensureTrust, trustLine } from './trust.mjs'
 import { findRollout, createTail, parseLines, readCodexUsage, transcriptTail as codexTail } from './taps/codex.mjs'
+import { fetchClaudeUsage } from './taps/claude-usage.mjs'
 import { scanLog, promptsSince, logSize } from './taps/agy.mjs'
 import { fetchGrokUsage, scanLog as scanGrokLog, promptsSince as grokPromptsSince } from './taps/grok.mjs'
-import { fetchClaudeUsage } from './taps/claude-usage.mjs'
 import { saveSessionBundle, resumePrompt, sessionCommitDelta } from './bundle.mjs'
 import { endSessionPointer } from './resume.mjs'
 import { openBoard, pidfile } from './launcher.mjs'
@@ -56,6 +56,12 @@ const SERVER = resolveServer()
 const POLL_MS = Number(process.env.LEG_ATTACH_POLL_MS || process.env.BATON_ATTACH_POLL_MS || 2000)
 const GIT_EVERY = 3 // polls
 const USAGE_MS = Number(process.env.LEG_USAGE_POLL_MS || process.env.BATON_USAGE_POLL_MS || 60000)
+// One switch for every usage read in a leg's process tree, the board's poller
+// and this terminal's fallback alike (src/server.mjs usageAgentsFor). The
+// suites set it so no test asks a real endpoint about this machine's logins;
+// the *_BIN stubs used to do that by accident, and switched polling off for
+// real users who had simply moved their claude.
+const NO_USAGE_POLL = (process.env.LEG_NO_USAGE_POLL || process.env.BATON_NO_USAGE_POLL) === '1'
 const say = (line) => process.stderr.write(`[leg] ${line}\n`)
 
 async function refreshCodexUsage(account, codexHome, { timeoutMs = 8000, signal = null } = {}) {
@@ -465,77 +471,75 @@ async function runLeg({ agent, account, args, session, prompt, boardUrl, autoApp
   child.on('error', (err) => { appendEvent(sid, { type: 'error', summary: `${agent} spawn error: ${err.message}` }); stop({ reason: 'exit', code: 127 }) })
   child.on('exit', (code) => stop({ reason: 'exit', code: code ?? -1 }))
 
-  // claude: the 5h/7d percentages come from Claude Code's usage endpoint
-  // (src/taps/claude-usage.mjs); the wall itself arrives through the
-  // StopFailure hook.
+  // The percentages are NOT read here. One poller per login lives in the board
+  // (src/usage-poll.mjs) and writes `limits`, `usage_source` and `usage_error`
+  // onto this session: three terminals on one login used to ask the same
+  // endpoint three times a minute, draw a 429 every other minute, and print
+  // every one of them in this terminal's timeline.
+  //
+  // What is still this terminal's own: which model claude is actually
+  // answering on. The transcript path arrives on the SessionStart hook payload
+  // (src/taps/claude.mjs `handleHook`, `base`), so this only reads once Claude
+  // Code has told Leg where its jsonl is. A fallback off fable shows up here
+  // and nowhere else.
   let usageTimer = null
-  const usageAbort = new AbortController()
   if (agent === 'claude') {
-    const pollUsage = async () => {
-      const r = await fetchClaudeUsage({ configDir: spec.env.CLAUDE_CONFIG_DIR || LAYOUT.claude.home() })
+    const pollModel = () => {
       const s = readSession(sid)
       if (!isCurrentLeg(s, { pid: child.pid, agent, account })) return
-      // a 404, a body that is not JSON, or a shape with no window at all: the
-      // card says usage unknown and the StopFailure hook still owns the limit
-      // which model actually answered. The transcript path arrives on the
-      // SessionStart hook payload (src/taps/claude.mjs `handleHook`, `base`),
-      // so this only reads once Claude Code has told Leg where its jsonl is.
-      // A fallback off fable shows up here and nowhere else.
       const seen = modelFromTranscript(s.transcript_path, { agent: 'claude' })
       if (seen && seen !== s.model) {
         updateSession(sid, { model: seen }, { event: { type: 'status', summary: `claude is answering on ${seen}${s.model ? ` (was ${s.model})` : ''}` } })
       }
-      const usable = r.ok && r.limits && (r.limits.five_hour || r.limits.seven_day)
-      if (usable) {
-        recordUsage('claude', account, r.limits, 'claude usage endpoint')
-        // the session record keeps the two windows it always had: the buckets
-        // live on the usage record, which is per login and not per terminal
-        updateSession(sid, { limits: { five_hour: r.limits.five_hour, seven_day: r.limits.seven_day }, usage_source: 'claude usage endpoint', usage_error: null })
-      } else if (!s.usage_error) {
-        const why = r.error ?? 'the usage endpoint answered with no window'
-        updateSession(sid, { usage_error: why }, { event: { type: 'status', summary: `claude usage unavailable: ${why}` } })
-      }
-    }
-    pollUsage().catch(() => {})
-    usageTimer = setInterval(() => pollUsage().catch(() => {}), USAGE_MS)
-    usageTimer.unref?.()
-  } else if (agent === 'codex' && !(process.env.LEG_CODEX_BIN || process.env.BATON_CODEX_BIN)) {
-    const pollUsage = async () => {
-      const r = await refreshCodexUsage(account, spec.env.CODEX_HOME || LAYOUT.codex.home(), { signal: usageAbort.signal })
-      const s = readSession(sid)
-      if (!isCurrentLeg(s, { pid: child.pid, agent, account })) return
-      if (r.ok) {
-        const patch = { limits: r.limits, usage_source: 'codex app-server account/rateLimits/read', usage_error: null }
-        if (r.available === false) {
-          patch.status = 'limit'
-          patch.limit = { reason: 'usage_limit_exceeded', detail: 'Codex reports ordinary usage is unavailable', resets_at: r.usage.limited_until, at: r.observed_at }
-        }
-        updateSession(sid, patch)
-      } else if (!s.usage_error) {
-        updateSession(sid, { usage_error: r.error }, { event: { type: 'status', summary: `codex usage unavailable: ${r.error}` } })
-      }
     }
-    pollUsage().catch(() => {})
-    usageTimer = setInterval(() => pollUsage().catch(() => {}), USAGE_MS)
+    const safely = () => { try { pollModel() } catch {} }
+    safely()
+    usageTimer = setInterval(safely, USAGE_MS)
     usageTimer.unref?.()
-  } else if (agent === 'grok') {
+  }
+
+  // The near-wall warning below is computed from the percentages on this
+  // session, and for claude and grok those are written by the board's poller
+  // (src/usage-poll.mjs). With LEG_NO_BOARD=1, or a board that is down, nobody
+  // is reading that login at all, and the 85% warning never fired: no bell, no
+  // nudge, straight into the wall. So the terminal watches the login's own
+  // record and, when nothing has refreshed it for five minutes, reads the
+  // endpoint itself at the old once-a-minute cadence. A board that is polling
+  // keeps that record fresh, so with one up this costs a readUsage() a minute
+  // and no request. Said once, so a terminal doing its own reading is never a
+  // mystery.
+  let fallbackTimer = null
+  if ((agent === 'claude' || agent === 'grok') && !NO_USAGE_POLL) {
+    const source = agent === 'claude' ? 'claude usage endpoint' : 'grok billing proxy'
+    const readOwn = () => (agent === 'claude'
+      ? fetchClaudeUsage({ configDir: spec.env.CLAUDE_CONFIG_DIR || LAYOUT.claude.home() })
+      : fetchGrokUsage({ configDir: spec.env.GROK_HOME || LAYOUT.grok.home() }))
+    let announced = false
     const pollUsage = async () => {
-      const configDir = spec.env.GROK_HOME || LAYOUT.grok.home()
-      const r = await fetchGrokUsage({ configDir })
+      if (!isCurrentLeg(readSession(sid), { pid: child.pid, agent, account })) return
+      if (!usageIsStale(readUsage(agent, account))) return // a board is reading this login
+      if (!announced) { announced = true; say(`no board is reading ${agent} usage, so this terminal reads it itself once a minute`) }
+      const r = await readOwn()
       const s = readSession(sid)
       if (!isCurrentLeg(s, { pid: child.pid, agent, account })) return
       const usable = r.ok && r.limits && (r.limits.five_hour || r.limits.seven_day)
       if (usable) {
-        recordUsage('grok', account, r.limits, 'grok billing proxy')
-        updateSession(sid, { limits: r.limits, usage_source: 'grok billing proxy', usage_error: null })
+        recordUsage(agent, account, r.limits, source)
+        // the two windows the card has always carried; the buckets stay on the
+        // usage record, which is per login and not per terminal
+        const limits = agent === 'claude' ? { five_hour: r.limits.five_hour, seven_day: r.limits.seven_day } : r.limits
+        updateSession(sid, { limits, usage_source: source, usage_error: null })
       } else if (!s.usage_error) {
         const why = r.error ?? 'the usage endpoint answered with no window'
-        updateSession(sid, { usage_error: why }, { event: { type: 'status', summary: `grok usage unavailable: ${why}` } })
+        updateSession(sid, { usage_error: why }, { event: { type: 'status', summary: `${agent} usage unavailable: ${why}` } })
       }
     }
-    pollUsage().catch(() => {})
-    usageTimer = setInterval(() => pollUsage().catch(() => {}), USAGE_MS)
-    usageTimer.unref?.()
+    const safelyUsage = () => { pollUsage().catch(() => {}) }
+    // LEG_NO_BOARD=1 means nobody will ever poll this login, so the reading
+    // happens at once rather than leaving the terminal's first minute blind
+    if (!boardUrl) safelyUsage()
+    fallbackTimer = setInterval(safelyUsage, USAGE_MS)
+    fallbackTimer.unref?.()
   }
 
   const timer = setInterval(() => {
@@ -666,9 +670,8 @@ async function runLeg({ agent, account, args, session, prompt, boardUrl, autoApp
   timer.unref?.()
   const result = await done
   clearInterval(timer)
-  usageAbort.abort()
   if (usageTimer) clearInterval(usageTimer)
-  void boardUrl
+  if (fallbackTimer) clearInterval(fallbackTimer)
   return result
 }
 

package/src/board/board.css

@@ -589,8 +589,6 @@ code { font-family: var(--mono); font-size: 0.94em; }
 .ladder-add { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; padding: 10px 0 2px; font-size: var(--t-0); border-top: 1px solid var(--line); }
 .ladder-policy { display: grid; gap: 8px; margin-top: 18px; border: 0; padding: 0; }
 .ladder-policy legend { font-size: var(--t-0); font-weight: var(--w-head); color: var(--text-2); padding: 0; }
-/* the label on each agent row in the New card dialog */
-.fallback-row-title { font-size: var(--t-0); font-weight: var(--w-head); color: var(--text-2); }
 .confirm-row { margin-top: 12px; display: flex; align-items: center; gap: 12px; flex-wrap: wrap; background: var(--e4); border-radius: var(--r-control); padding: 12px 14px; font-size: var(--t-0); }
 .actions { display: flex; gap: 10px; flex-wrap: wrap; }
 
@@ -716,3 +714,87 @@ dialog::backdrop { background: rgba(0,0,0,.6); }
   * { transition: none !important; }
   .btn:active { transform: none; }
 }
+
+/* ---- appended 2026-09-18: the timeline's repeat count -------------------- */
+/* A run of identical status lines collapses to one line carrying ×N
+   (collapseEvents in sessions.js). The count is a quantity beside a sentence,
+   not part of it, so it is muted and set in the tabular face the rest of the
+   board counts in. */
+.timeline-count { margin-left: 8px; color: var(--text-3); font-variant-numeric: tabular-nums; font-size: var(--t--1); }
+/* ---- end of the 2026-09-18 block ---------------------------------------- */
+
+/* ---- appended 2026-09-18: the new card dialog's two columns -------------- */
+/* The dialog asks two questions and they are read in parallel, not in series:
+   WHAT the work is on the left, WHO runs it on the right. One column under
+   900px, because at a phone's width two columns of selects is one column of
+   selects with half the room. The dialog itself widens only where there are
+   two columns to hold; under the breakpoint the base `dialog` rule still caps
+   it at the viewport. */
+.dialog-cols { display: grid; gap: 4px 28px; }
+.dialog-col { min-width: 0; }
+/* the second label inside one .form-row: the path under the repo picker. It is
+   a label, not a heading, so it is quieter than the field's own. */
+.sub-label { font-weight: var(--w-text); color: var(--text-3); }
+.form-row .sub-label { font-size: var(--t--1); }
+
+/* One rung of "Who runs it": a number, a provider, a model, its permissions,
+   its limits, and the three buttons that move or remove it. It wraps rather
+   than scrolls, so a narrow dialog stacks the controls of one row instead of
+   hiding them off the right edge. Separated from the row above by --line, the
+   only rule allowed inside a panel. */
+.chain-row { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; padding: 10px 0; font-size: var(--t-0); }
+.chain-row + .chain-row { border-top: 1px solid var(--line); }
+.chain-num { flex: none; color: var(--text-3); font-variant-numeric: tabular-nums; }
+.chain-row select { flex: 0 1 auto; min-width: 0; max-width: 100%; font-size: var(--t--1); }
+.chain-toggle { display: inline-flex; align-items: center; gap: 6px; font-size: var(--t--1); color: var(--text-3); }
+.chain-turns { flex: none; width: 11ch; font-size: var(--t--1); }
+.chain-fake { flex: none; width: 16ch; font-size: var(--t--1); }
+.chain-row .btn { font-size: var(--t--1); }
+/* the three row buttons sit apart from the row's fields: wrapped onto a line
+   of their own, `max turns` beside Up/Down/Remove read as one group and the
+   number looked like it belonged to the buttons. */
+.chain-row .btn:first-of-type { margin-left: auto; }
+
+/* A dialog taller than the window has to scroll itself, or Create card is off
+   the bottom of the screen with no way to reach it. Both widths did exactly
+   that: 960px of dialog in a 900px window. */
+dialog { max-height: calc(100vh - 40px); overflow-y: auto; }
+
+@media (min-width: 900px) {
+  #new-card-dialog { max-width: 980px; }
+  .dialog-cols { grid-template-columns: minmax(0, 1fr) minmax(0, 1fr); }
+}
+/* ---- end of the 2026-09-18 dialog block --------------------------------- */
+
+/* ---- the floor, 2026-09-18: stations instead of tables ------------------ */
+/* The entry row is the first thing under the strip and the only control on the
+   page that starts work, so it sits on the raised surface the rows sit on
+   rather than in the page's own ground. The board's copy is inside the
+   Background panel and inherits its surface; this one has none to inherit. */
+.floor-entry { margin-top: 20px; background: var(--e2); border: 1px solid var(--edge); border-radius: var(--r-well); padding: 20px 24px; }
+.floor-entry .confirm-row { margin-top: 0; }
+.floor-entry .confirm-row input[type="text"] { flex: 1 1 320px; min-width: 0; }
+.floor-entry .field-help { margin-top: 10px; }
+/* the count belongs to the heading it is in, one step quieter than the word */
+.region-count { margin-left: 10px; font-size: var(--t-0); font-weight: var(--w-text); color: var(--text-3); font-variant-numeric: tabular-nums; }
+/* the keyboard ring on a card row, the same 3px edge mark the terminal rows
+   carry (`.term.is-focused`) rather than a fill */
+.row.is-focused { box-shadow: inset 3px 0 0 var(--focus); }
+
+@media (max-width: 760px) {
+  /* R4 is a 272px block in a fixed second column: under about 390px of content
+     width that column alone is wider than the row, and both pages scrolled
+     sideways. One column, with the clock and the buttons under the sentence. */
+  .row { grid-template-columns: minmax(0, 1fr); padding: 22px; }
+  .r4 { grid-column: 1; grid-row: auto; flex-direction: row; align-items: center; flex-wrap: wrap; gap: 10px 14px; margin-top: 14px; }
+  .r4 .row-actions { width: 100%; }
+  .floor-entry { padding: 18px; }
+  .floor-entry .confirm-row { align-items: stretch; flex-direction: column; }
+  .floor-entry .confirm-row input[type="text"] { flex: 1 1 auto; }
+}
+
+/* The heading over a GROUP of controls, not over one: "Who runs it" names the
+   whole chain-rows group through aria-labelledby, so it cannot be a <label> --
+   a label with no control focuses nothing when it is clicked, which is the one
+   thing a label promises. Same face as the row labels beside it. */
+.form-row .form-label { font-size: var(--t-0); font-weight: var(--w-head); color: var(--text-2); }