@clawpump/claw-agent 0.1.4 → 0.1.6

package/agent/ui-tui/packages/hermes-ink/src/ink/parse-keypress.ts

@@ -63,35 +63,6 @@ const XTVERSION_RE = /^\x1bP>\|(.*?)(?:\x07|\x1b\\)$/s
 // Button 32=left-drag (0x20 | motion-bit). Plain 0/1/2 = left/mid/right click.
 // eslint-disable-next-line no-control-regex
 const SGR_MOUSE_RE = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/
-const SGR_MOUSE_FRAGMENT_RE = /(?<!\d)(?:\[<|<)?(?:[0-9]|[1-9][0-9]|1\d{2}|2[0-4]\d|25[0-5]);\d+;\d+[Mm]/g
-
-// Whole-text mouse-burst noise fast path. When a heavy render blocks the event
-// loop past App's 50ms flush watchdog, a long burst of SGR mouse reports (mode
-// 1003 any-motion / 1006 SGR) can arrive as a single text token with prefixes
-// AND coordinate digits chewed off across many partial reads. The surviving
-// shards (1- and 2-param remnants, stray focus-in `[I`, lone `M`/`m`
-// terminators) are too degraded for SGR_MOUSE_FRAGMENT_RE, so the leftover
-// tail leaks into the composer and locks the user out (they can't type or exit).
-//
-// If the ENTIRE text token is drawn only from the mouse-leak alphabet
-// (`[ ] < ; I M m`, digits, and the stray spaces a burst can carry) AND it
-// carries the structural signature of mouse coordinates — ≥3 `M`/`m`
-// terminators, at least one digit, and at least one `;` separator — swallow it
-// wholesale. All three constraints together preserve real prose: `Mmm MMM mmm`
-// has no digit and no `;`, `see 1;2;3M for details` contains disqualifying
-// letters, and `1234;56;78M9;10;11M` has only two terminators.
-// eslint-disable-next-line no-control-regex
-const MOUSE_BURST_NOISE_RE = /^(?=[\s\S]*\d)(?=[\s\S]*;)(?=(?:[^Mm]*[Mm]){3})[\d;<\[\]IMm \x1b]+$/
-
-// Residual-shard variant for the gaps BETWEEN / AFTER recovered fragments
-// inside parseTextWithSgrMouseFragments. A real recovery run leaves degraded
-// remnants (e.g. `M6M`, `7M;220;1MM0M`, lone `;157;47M`) that are pure
-// mouse-leak alphabet but too short to satisfy the ≥3-terminator whole-text
-// rule. Swallow such a residue only when it is pure alphabet AND carries a
-// digit AND at least one `M`/`m` — a prose gap like ` for details ` contains
-// disqualifying letters and never matches.
-// eslint-disable-next-line no-control-regex
-const MOUSE_BURST_RESIDUE_RE = /^(?=[^\d]*\d)(?=[^Mm]*[Mm])[\d;<\[\]IMm \x1b]+$/
 
 function createPasteKey(content: string): ParsedKey {
   return {
@@ -296,32 +267,18 @@ export function parseMultipleKeypresses(
     } else if (token.type === 'text') {
       if (inPaste) {
         pasteBuffer += token.value
-      } else if (MOUSE_BURST_NOISE_RE.test(token.value)) {
-        // Fully degraded mouse-burst noise — a heavy render (e.g. a sudo /
-        // secret prompt repaint) blocked the event loop past App's 50ms flush
-        // watchdog, so a long burst of SGR mouse reports arrived as text with
-        // prefixes AND coordinate digits chewed off. Checked BEFORE fragment
-        // recovery: a noise blob can still contain a few intact `<b;c;r M`
-        // fragments, and parseTextWithSgrMouseFragments would then return
-        // non-null and emit a pile of recovered mouse events instead of
-        // dropping the blob wholesale. Swallow it here so it never leaks into
-        // the composer (and we skip the extra fragment-recovery work mid-stall).
+      } else if (/^\[M[\x60-\x7f][\x20-\uffff]{2}$/.test(token.value)) {
+        // Orphaned X10 wheel tail (legacy 1000/1002 terminals, fullscreen
+        // only). If the buffered ESC was flushed as a lone Escape and the X10
+        // payload (`[M` + 3 bytes) arrived as the next text token, re-synthesize
+        // with ESC so the scroll event still fires instead of leaking. SGR mouse
+        // reports no longer reach this branch — the tokenizer keeps an
+        // incomplete CSI buffered across a flush and reassembles it (see
+        // termio/tokenize.ts), so the old fragment/burst recovery is gone.
+        const resynthesized = '\x1b' + token.value
+        keys.push(parseKeypress(resynthesized))
       } else {
-        const mouseFragments = parseTextWithSgrMouseFragments(token.value)
-
-        if (mouseFragments) {
-          keys.push(...mouseFragments)
-        } else if (/^\[M[\x60-\x7f][\x20-\uffff]{2}$/.test(token.value)) {
-          // Orphaned X10 wheel tail (fullscreen only — mouse tracking is off
-          // otherwise). A heavy render blocked the event loop past App's 50ms
-          // flush timer, so the buffered ESC was flushed as a lone Escape and
-          // the continuation arrived as text. Re-synthesize with ESC so the
-          // scroll event still fires instead of leaking into the prompt.
-          const resynthesized = '\x1b' + token.value
-          keys.push(parseKeypress(resynthesized))
-        } else {
-          keys.push(parseKeypress(token.value))
-        }
+        keys.push(parseKeypress(token.value))
       }
     }
   }
@@ -663,87 +620,6 @@ function parseMouseEvent(s: string): ParsedMouse | null {
   }
 }
 
-function normalizeSgrMouseFragment(fragment: string): string {
-  if (fragment.startsWith('[<')) {
-    return `\x1b${fragment}`
-  }
-
-  if (fragment.startsWith('<')) {
-    return `\x1b[${fragment}`
-  }
-
-  return `\x1b[<${fragment}`
-}
-
-function parseSgrMouseFragment(fragment: string): ParsedInput {
-  const sequence = normalizeSgrMouseFragment(fragment)
-  return parseMouseEvent(sequence) ?? parseKeypress(sequence)
-}
-
-function parseTextWithSgrMouseFragments(text: string): ParsedInput[] | null {
-  SGR_MOUSE_FRAGMENT_RE.lastIndex = 0
-
-  const matches = [...text.matchAll(SGR_MOUSE_FRAGMENT_RE)]
-  if (matches.length === 0) {
-    return null
-  }
-
-  const parsed: ParsedInput[] = []
-  let cursor = 0
-  let consumedAny = false
-
-  for (let i = 0; i < matches.length;) {
-    const first = matches[i]!
-    const run: RegExpMatchArray[] = [first]
-    let runEnd = first.index! + first[0].length
-    i++
-
-    while (i < matches.length && matches[i]!.index === runEnd) {
-      run.push(matches[i]!)
-      runEnd = matches[i]!.index! + matches[i]![0].length
-      i++
-    }
-
-    const hasExplicitMousePrefix = run.some(match => match[0].startsWith('[<') || match[0].startsWith('<'))
-    const isFragmentBurst = run.length > 1
-
-    if (!hasExplicitMousePrefix && !isFragmentBurst) {
-      continue
-    }
-
-    if (first.index! > cursor) {
-      const gap = text.slice(cursor, first.index!)
-      // Skip pure mouse-leak residue between recovered fragments; only emit
-      // real text gaps as keypresses.
-      if (!MOUSE_BURST_RESIDUE_RE.test(gap)) {
-        parsed.push(parseKeypress(gap))
-      }
-    }
-
-    for (const match of run) {
-      parsed.push(parseSgrMouseFragment(match[0]))
-    }
-
-    cursor = runEnd
-    consumedAny = true
-  }
-
-  if (!consumedAny) {
-    return null
-  }
-
-  if (cursor < text.length) {
-    const tail = text.slice(cursor)
-    // Swallow a pure mouse-leak residue tail (the head fragments recovered, but
-    // the burst trailed off into chewed-up shards). Emit only real trailing text.
-    if (!MOUSE_BURST_RESIDUE_RE.test(tail)) {
-      parsed.push(parseKeypress(tail))
-    }
-  }
-
-  return parsed
-}
-
 function parseKeypress(s: string = ''): ParsedKey {
   let parts
 

package/agent/ui-tui/packages/hermes-ink/src/ink/termio/tokenize.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, it } from 'vitest'
+
+import { createTokenizer, type Token } from './tokenize.js'
+
+describe('tokenizer escape-sequence boundaries', () => {
+  it('reassembles a CSI mouse sequence split across two feeds', () => {
+    const t = createTokenizer({ x10Mouse: true })
+
+    expect(t.feed('\x1b[<0;35;')).toEqual([])
+    expect(t.feed('46M')).toEqual([{ type: 'sequence', value: '\x1b[<0;35;46M' }])
+    expect(t.buffer()).toBe('')
+  })
+})
+
+describe('tokenizer state-aware flush', () => {
+  it('does not emit an incomplete CSI on flush — it keeps it for reassembly', () => {
+    const t = createTokenizer({ x10Mouse: true })
+
+    // A render stall lets App's watchdog flush mid-sequence. The buffered CSI
+    // prefix must NOT be emitted (that is the `46M…` leak); it stays buffered.
+    expect(t.feed('\x1b[<0;35;')).toEqual([])
+    expect(t.flush()).toEqual([])
+    expect(t.buffer()).toBe('\x1b[<0;35;')
+
+    // The continuation arrives on the next feed and the whole report
+    // reassembles into a single clean sequence token — nothing leaked.
+    expect(t.feed('46M')).toEqual([{ type: 'sequence', value: '\x1b[<0;35;46M' }])
+    expect(t.buffer()).toBe('')
+  })
+
+  it('drops a partial control sequence that survives a second flush (truncation)', () => {
+    const t = createTokenizer({ x10Mouse: true })
+
+    expect(t.feed('\x1b[<0;35;')).toEqual([])
+    expect(t.flush()).toEqual([]) // first flush keeps the buffer
+    expect(t.buffer()).toBe('\x1b[<0;35;')
+
+    // Continuation never arrived: the next flush sees the same buffer and
+    // drops it so it can't fuse with the next keypress's bytes.
+    expect(t.flush()).toEqual([])
+    expect(t.buffer()).toBe('')
+  })
+
+  it('still emits a bare ESC on flush so the Escape key works', () => {
+    const t = createTokenizer({ x10Mouse: true })
+
+    expect(t.feed('\x1b')).toEqual([])
+    expect(t.flush()).toEqual([{ type: 'sequence', value: '\x1b' }])
+    expect(t.buffer()).toBe('')
+  })
+
+  it('reassembles even when a flush fires between every byte of the report', () => {
+    const t = createTokenizer({ x10Mouse: true })
+
+    // Pathological stall: a flush between each chunk. As long as the
+    // continuation eventually arrives, no fragment is ever emitted as input.
+    for (const chunk of ['\x1b[', '<', '0;', '35;', '46']) {
+      expect(t.feed(chunk)).toEqual([])
+      expect(t.flush()).toEqual([])
+    }
+
+    expect(t.feed('M')).toEqual([{ type: 'sequence', value: '\x1b[<0;35;46M' }])
+    expect(t.buffer()).toBe('')
+  })
+})
+
+// Battle-test: prove the leak class is structurally impossible, not just that
+// the known cases are patched. We hammer the tokenizer with the worst stalls a
+// terminal can produce (split + flush at every byte) and assert the two hard
+// invariants: nothing leaks as text, and every complete report reassembles.
+describe('tokenizer fuzz: fragments never leak under a flush storm', () => {
+  const sgr = (btn: number, col: number, row: number, press: boolean): string =>
+    `\x1b[<${btn};${col};${row}${press ? 'M' : 'm'}`
+
+  it('reassembles a report split + flushed at every interior byte', () => {
+    const seq = sgr(0, 35, 46, true)
+
+    // Start at 2: an earlier split is the lone-ESC ESCDELAY boundary, which
+    // intentionally flushes to the Escape key. Terminals never split a mouse
+    // report there — a report is one atomic write — so it's not a real case.
+    for (let i = 2; i < seq.length; i++) {
+      const t = createTokenizer({ x10Mouse: true })
+      const tokens: Token[] = [...t.feed(seq.slice(0, i)), ...t.flush(), ...t.feed(seq.slice(i))]
+
+      expect(tokens).toEqual([{ type: 'sequence', value: seq }])
+      expect(t.buffer()).toBe('')
+    }
+  })
+
+  it('feeds 200 random reports one byte at a time, flushing after every byte', () => {
+    // Deterministic PRNG so a failure is reproducible.
+    let s = 0x1234567
+
+    const rnd = (n: number): number => {
+      s = (s * 1103515245 + 12345) & 0x7fffffff
+
+      return s % n
+    }
+
+    const reports = Array.from({ length: 200 }, () => sgr(rnd(120), 1 + rnd(300), 1 + rnd(200), rnd(2) === 0))
+    const stream = reports.join('')
+
+    const t = createTokenizer({ x10Mouse: true })
+    const seqTokens: string[] = []
+    let textLeak = ''
+
+    const drain = (tokens: Token[]): void => {
+      for (const tok of tokens) {
+        if (tok.type === 'sequence') {
+          seqTokens.push(tok.value)
+        } else {
+          textLeak += tok.value
+        }
+      }
+    }
+
+    for (const ch of stream) {
+      drain(t.feed(ch))
+
+      // Flush storm — but not at a lone-ESC boundary (the real watchdog
+      // re-arms while bytes are pending; a single flush between feeds never
+      // hits the truncation valve).
+      if (t.buffer() !== '\x1b') {
+        drain(t.flush())
+      }
+    }
+
+    expect(textLeak).toBe('')
+    expect(seqTokens.join('')).toBe(stream)
+  })
+
+  it('keeps real keystrokes intact while mouse reports reassemble around them', () => {
+    let s = 0x0badf00d
+
+    const rnd = (n: number): number => {
+      s = (s * 1103515245 + 12345) & 0x7fffffff
+
+      return s % n
+    }
+
+    const typed = 'abc 123 xyz'
+    const expectedKeys: string[] = []
+    const expectedSeqs: string[] = []
+    const parts: string[] = []
+
+    for (let k = 0; k < 120; k++) {
+      if (rnd(3) === 0) {
+        const ch = typed[rnd(typed.length)]!
+        expectedKeys.push(ch)
+        parts.push(ch)
+      } else {
+        const seq = sgr(rnd(64), 1 + rnd(200), 1 + rnd(100), rnd(2) === 0)
+        expectedSeqs.push(seq)
+        parts.push(seq)
+      }
+    }
+
+    const stream = parts.join('')
+    const t = createTokenizer({ x10Mouse: true })
+    const seqTokens: string[] = []
+    let text = ''
+
+    const drain = (tokens: Token[]): void => {
+      for (const tok of tokens) {
+        if (tok.type === 'sequence') {
+          seqTokens.push(tok.value)
+        } else {
+          text += tok.value
+        }
+      }
+    }
+
+    for (const ch of stream) {
+      drain(t.feed(ch))
+
+      if (t.buffer() !== '\x1b') {
+        drain(t.flush())
+      }
+    }
+
+    // Every typed character survives, in order; every report reassembles whole.
+    expect(text).toBe(expectedKeys.join(''))
+    expect(seqTokens).toEqual(expectedSeqs)
+  })
+})

package/agent/ui-tui/packages/hermes-ink/src/ink/termio/tokenize.ts

@@ -47,10 +47,18 @@ type TokenizerOptions = {
 export function createTokenizer(options?: TokenizerOptions): Tokenizer {
   let currentState: State = 'ground'
   let currentBuffer = ''
+  // The control-sequence buffer kept across the previous flush, if any. Used
+  // as a one-tick truncation valve: a partial CSI mouse report normally
+  // reassembles on the very next feed, so if a flush sees the exact same
+  // buffer it kept last time (the continuation never arrived), we drop it.
+  let lastFlushedBuffer = ''
   const x10Mouse = options?.x10Mouse ?? false
 
   return {
     feed(input: string): Token[] {
+      // Real bytes arrived — any kept partial is no longer stale.
+      lastFlushedBuffer = ''
+
       const result = tokenize(input, currentState, currentBuffer, false, x10Mouse)
 
       currentState = result.state.state
@@ -64,12 +72,25 @@ export function createTokenizer(options?: TokenizerOptions): Tokenizer {
       currentState = result.state.state
       currentBuffer = result.state.buffer
 
+      // tokenize() keeps (doesn't emit) an incomplete control sequence on
+      // flush. If two consecutive flushes see the same buffer with no feed in
+      // between, the continuation is never coming (truncated write / killed
+      // process) — drop it so it can't fuse with the next keypress's bytes.
+      if (currentBuffer && currentBuffer === lastFlushedBuffer) {
+        currentState = 'ground'
+        currentBuffer = ''
+        lastFlushedBuffer = ''
+      } else {
+        lastFlushedBuffer = currentBuffer
+      }
+
       return result.tokens
     },
 
     reset(): void {
       currentState = 'ground'
       currentBuffer = ''
+      lastFlushedBuffer = ''
     },
 
     buffer(): string {
@@ -298,8 +319,10 @@ function tokenize(
   // Handle end of input
   if (result.state === 'ground') {
     flushText()
-  } else if (flush) {
-    // Force output incomplete sequence
+  } else if (flush && result.state === 'escape') {
+    // A bare ESC with nothing after it is the Escape key — the one incomplete
+    // state a flush should turn into input (the classic ESCDELAY lone-ESC
+    // disambiguation: ESC alone vs. ESC as a sequence/meta prefix).
     const remaining = data.slice(seqStart)
 
     if (remaining) {
@@ -308,7 +331,18 @@ function tokenize(
 
     result.state = 'ground'
   } else {
-    // Buffer incomplete sequence for next call
+    // Buffer the incomplete sequence. Two paths land here:
+    //   - streaming (flush=false): normal carry-over to the next feed.
+    //   - flush=true while still inside a multi-byte control sequence
+    //     (csi/osc/dcs/apc/ss3/escapeIntermediate): we deliberately do NOT
+    //     emit it. A half-arrived CSI mouse report (ESC[<btn;col;row M) is an
+    //     unfinished sequence, not user input — force-emitting it is what
+    //     injects `46M`/`35;46M` shards into the prompt during a render stall.
+    //     Keeping it buffered lets the continuation reassemble on the next
+    //     feed (the xterm.js state-machine discipline — partial sequences
+    //     never become text). createTokenizer.flush() drops the buffer if it
+    //     survives a second flush with no progress (a genuine truncation), so
+    //     a stuck partial can never merge into the next keypress's bytes.
     result.buffer = data.slice(seqStart)
   }
 

package/agent/ui-tui/packages/hermes-ink/src/utils/execFileNoThrow.ts

@@ -1,4 +1,4 @@
-import { spawn } from 'child_process'
+import { spawn, type ChildProcess, type StdioOptions } from 'child_process'
 type ExecFileOptions = {
   input?: string
   timeout?: number
@@ -32,11 +32,11 @@ export function execFileNoThrow(
     // doesn't inherit those pipe FDs — prevents handle leaks that can
     // keep the parent process alive. No output data is collected in
     // this mode; both stdout and stderr will be empty strings.
-    const stdioConfig = options.resolveOnExit
-      ? ['pipe', 'ignore', 'ignore'] as const
-      : 'pipe' as const
+    const stdioConfig: StdioOptions = options.resolveOnExit
+      ? ['pipe', 'ignore', 'ignore']
+      : 'pipe'
 
-    const child = spawn(file, args, {
+    const child: ChildProcess = spawn(file, args, {
       cwd: options.useCwd ? process.cwd() : undefined,
       env: options.env,
       stdio: stdioConfig

package/agent/ui-tui/src/__tests__/appChromeStatusRule.test.tsx

@@ -54,6 +54,57 @@ const findClickableWithText = (node: ReactNodeLike, needle: string): React.React
   return findClickableWithText(node.props.children, needle)
 }
 
+// Find the innermost element whose own (direct) text content includes the
+// needle. Used to assert the colour the notice text is rendered with.
+const findElementWithText = (node: ReactNodeLike, needle: string): React.ReactElement | null => {
+  if (node === null || node === undefined || typeof node === 'boolean') {
+    return null
+  }
+
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      const found = findElementWithText(child, needle)
+
+      if (found) {
+        return found
+      }
+    }
+
+    return null
+  }
+
+  if (!React.isValidElement(node)) {
+    return null
+  }
+
+  // Prefer the deepest matching element so we get the leaf <Text> that
+  // actually carries the colour, not an ancestor Box.
+  const deeper = findElementWithText(node.props.children, needle)
+
+  if (deeper) {
+    return deeper
+  }
+
+  return textContent(node).includes(needle) ? node : null
+}
+
+const baseProps = {
+  bgCount: 0,
+  busy: false,
+  cols: 100,
+  cwdLabel: '~/repo',
+  liveSessionCount: 0,
+  model: 'opus-4.8',
+  sessionStartedAt: null,
+  showCost: false,
+  status: 'ready',
+  statusColor: DEFAULT_THEME.color.ok,
+  t: DEFAULT_THEME,
+  turnStartedAt: null,
+  usage: { context_max: 200_000, context_percent: 25, context_used: 50_000, total: 50_000 },
+  voiceLabel: ''
+}
+
 describe('StatusRule session count click target', () => {
   it('makes the live session count itself clickable', () => {
     const openSwitcher = vi.fn()
@@ -111,3 +162,169 @@ describe('StatusRule session count click target', () => {
     expect(rendered).not.toContain('$0.5000')
   })
 })
+
+describe('StatusRule credits notice render priority', () => {
+  it('replaces the idle status with the notice text and keeps model + context', () => {
+    const element = StatusRule({
+      ...baseProps,
+      notice: { key: 'credits.depleted', kind: 'sticky', level: 'error', text: '✕ credits exhausted' }
+    })
+
+    const rendered = textContent(element)
+
+    // Notice replaces the status verb slot …
+    expect(rendered).toContain('✕ credits exhausted')
+    expect(rendered).not.toContain('ready')
+    // … but model + context stay visible.
+    expect(rendered).toContain('opus 4.8')
+    expect(rendered).toContain('50k')
+  })
+
+  it('busy wins: the FaceTicker shows, the notice is hidden mid-turn', () => {
+    const element = StatusRule({
+      ...baseProps,
+      busy: true,
+      notice: { key: 'credits.90', kind: 'sticky', level: 'warn', text: '⚠ 90% used' },
+      turnStartedAt: Date.now()
+    })
+
+    const rendered = textContent(element)
+
+    // Notice must NOT render while busy.
+    expect(rendered).not.toContain('⚠ 90% used')
+    // Model still visible.
+    expect(rendered).toContain('opus 4.8')
+  })
+
+  it('colours the notice by level (error → theme error, success → statusGood)', () => {
+    const errEl = StatusRule({
+      ...baseProps,
+      notice: { key: 'credits.depleted', kind: 'sticky', level: 'error', text: '✕ exhausted' }
+    })
+    const errText = findElementWithText(errEl, '✕ exhausted')
+    expect(errText?.props.color).toBe(DEFAULT_THEME.color.error)
+
+    const okEl = StatusRule({
+      ...baseProps,
+      notice: { key: 'credits.restored', kind: 'ttl', level: 'success', text: '✓ restored', ttl_ms: 8000 }
+    })
+    const okText = findElementWithText(okEl, '✓ restored')
+    expect(okText?.props.color).toBe(DEFAULT_THEME.color.statusGood)
+  })
+
+  it('does NOT add a glyph — the notice text is rendered verbatim', () => {
+    const element = StatusRule({
+      ...baseProps,
+      notice: { key: 'credits.90', kind: 'sticky', level: 'warn', text: '⚠ 90% used' }
+    })
+    const noticeText = findElementWithText(element, '90% used')
+
+    // The leaf carries exactly the policy text — no extra prepended glyph.
+    expect(noticeText?.props.children).toBe('⚠ 90% used')
+  })
+
+  it('the notice text is the shrinkable element (flexShrink=1 + truncate-end) so a long notice ellipsizes', () => {
+    const longText = '⚠ ' + 'x'.repeat(200)
+    const element = StatusRule({
+      ...baseProps,
+      cols: 50,
+      notice: { key: 'credits.90', kind: 'sticky', level: 'warn', text: longText }
+    })
+
+    // The leaf <Text> truncates rather than wrapping/clipping the pinned tail.
+    const noticeText = findElementWithText(element, 'xxxxx')
+    expect(noticeText?.props.wrap).toBe('truncate-end')
+
+    // Its container box yields first (flexShrink=1) so model stays visible.
+    const findShrinkBoxContaining = (node: ReactNodeLike): React.ReactElement | null => {
+      if (!React.isValidElement(node)) {
+        if (Array.isArray(node)) {
+          for (const c of node) {
+            const f = findShrinkBoxContaining(c)
+            if (f) return f
+          }
+        }
+        return null
+      }
+      if (node.props.flexShrink === 1 && textContent(node).includes('xxxxx') && node.type !== StatusRule) {
+        // Prefer the closest shrink box that wraps the notice text.
+        const deeper = findShrinkBoxContaining(node.props.children)
+        return deeper ?? node
+      }
+      return findShrinkBoxContaining(node.props.children)
+    }
+    const shrinkBox = findShrinkBoxContaining(element)
+    expect(shrinkBox).not.toBeNull()
+
+    // Model survives on a narrow terminal because the notice yields.
+    expect(textContent(element)).toContain('opus 4.8')
+  })
+})
+
+describe('StatusRule idle-since read-out', () => {
+  // The IdleSince component uses hooks, so it can't be invoked outside a
+  // renderer — assert on the element tree instead (same reason the duration
+  // tests don't check SessionDuration's text).
+  const findComponentByName = (node: ReactNodeLike, name: string): React.ReactElement | null => {
+    if (node === null || node === undefined || typeof node === 'boolean') {
+      return null
+    }
+
+    if (Array.isArray(node)) {
+      for (const child of node) {
+        const found = findComponentByName(child, name)
+
+        if (found) {
+          return found
+        }
+      }
+
+      return null
+    }
+
+    if (!React.isValidElement(node)) {
+      return null
+    }
+
+    if (typeof node.type === 'function' && node.type.name === name) {
+      return node
+    }
+
+    return findComponentByName(node.props.children, name)
+  }
+
+  it('shows time since the last final agent response when idle', () => {
+    const endedAt = Date.now() - 42_000
+    const element = StatusRule({
+      ...baseProps,
+      lastTurnEndedAt: endedAt,
+      sessionStartedAt: Date.now() - 60_000
+    })
+
+    const idle = findComponentByName(element, 'IdleSince')
+
+    expect(idle).not.toBeNull()
+    expect(idle!.props.endedAt).toBe(endedAt)
+  })
+
+  it('is hidden while a turn is busy', () => {
+    const element = StatusRule({
+      ...baseProps,
+      busy: true,
+      lastTurnEndedAt: Date.now() - 42_000,
+      turnStartedAt: Date.now()
+    })
+
+    expect(findComponentByName(element, 'IdleSince')).toBeNull()
+  })
+
+  it('is hidden before the first turn completes', () => {
+    const element = StatusRule({
+      ...baseProps,
+      lastTurnEndedAt: null,
+      sessionStartedAt: Date.now() - 60_000
+    })
+
+    expect(findComponentByName(element, 'IdleSince')).toBeNull()
+  })
+})