zames_pro 2.74.0 → 2.75.1

package/scripts/tui-manyselect-shot.mts

@@ -0,0 +1,34 @@
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+const NL = String.fromCharCode(10)
+const ESC = String.fromCharCode(27)
+const keys = (process.argv[2] || '')
+  .split(',')
+  .filter(Boolean)
+  .map((k) => (k === 'UP' ? ESC + '[A' : k === 'DOWN' ? ESC + '[B' : k))
+const term = new Term(20, 60)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-manyselect.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '60', LINES: '20' },
+  },
+)
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => term.write(d.toString('utf-8')))
+let i = 0
+const tick = (): void => {
+  if (i < keys.length) {
+    child.stdin.write(keys[i])
+    i++
+    setTimeout(tick, 250)
+  } else
+    setTimeout(() => {
+      process.stdout.write(term.render() + NL)
+      child.kill('SIGTERM')
+    }, 400)
+}
+setTimeout(tick, 4500)
+child.on('close', () => process.exit(0))

package/scripts/tui-manyselect.tsx

@@ -0,0 +1,17 @@
+import React from 'react'
+import { render } from 'ink'
+import { SelectList } from '../src/tui/SelectList.js'
+const items = Array.from({ length: 30 }, (_, i) => ({
+  value: 'm' + i,
+  label: 'модель-' + i,
+}))
+render(
+  React.createElement(SelectList, {
+    title: 'Много',
+    items,
+    initial: 'm15',
+    onSelect: () => {},
+  }),
+  { exitOnCtrlC: false, patchConsole: false },
+)
+setInterval(() => {}, 1 << 30)

package/scripts/tui-mouse-churn-probe.tsx

@@ -0,0 +1,28 @@
+// Mount the REAL TuiEditor and tick the store every 150ms (like the 1s badge
+// timer does), so the raw stdout can be scanned for how many times the
+// mouse-mode sequences are written. A well-behaved hook writes them ONCE on
+// mount; a hook whose effect depends on an inline `onWheel` re-runs on every
+// render and writes `1007h` (alternate-scroll ON => wheel becomes history)
+// again and again.
+
+import { TuiEditor } from '../src/tui/TuiEditor.js'
+
+const ed = new TuiEditor({
+  prompt: '> ',
+  commands: [],
+  locale: 'en',
+  alternateScreen: true,
+})
+ed.onSubmit = () => {}
+ed.onAttach = () => null
+ed.onClipboard = () => Promise.resolve(null)
+ed.start()
+
+let n = 0
+const timer = setInterval(() => {
+  // A no-op-ish store change: bump the queue badge, like refreshBadges does.
+  ed.store.set({ queueLength: n++ })
+  if (n > 20) clearInterval(timer)
+}, 150)
+
+setInterval(() => {}, 1 << 30)

package/scripts/tui-paste-driver.mts

@@ -0,0 +1,88 @@
+// Feed a scripted set of bracketed pastes + Enter into the REAL TuiEditor
+// probe under a pty, then print /tmp/paste-kinds.log (what onSubmit received).
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const ESC = String.fromCharCode(27)
+const CR = String.fromCharCode(13)
+const LOG = '/tmp/paste-kinds.log'
+const TMP = '/tmp/paste-probe-tmp'
+for (const f of [LOG]) {
+  try {
+    fs.unlinkSync(f)
+  } catch {
+    /* ignore */
+  }
+}
+fs.mkdirSync(TMP, { recursive: true })
+
+const png =
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M8AAAMBAQDJ/pLvAAAAAElFTkSuQmCC'
+const dataUrl = 'data:image/png;base64,' + png
+const existingFile = path.resolve('README.md')
+
+const pastes = [
+  'hello plain text',
+  'line1' +
+    String.fromCharCode(10) +
+    'line2' +
+    String.fromCharCode(10) +
+    'line3' +
+    String.fromCharCode(10) +
+    'line4',
+  existingFile,
+  dataUrl,
+]
+
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-paste-kinds.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: {
+      ...process.env,
+      COLUMNS: '90',
+      LINES: '28',
+      PROBE_PASTE_LOG: LOG,
+      PROBE_PASTE_TMP: TMP,
+    },
+  },
+)
+child.stdout.on('data', () => {})
+child.stderr.on('data', () => {})
+
+const enc = (s: string): string => ESC + '[200~' + s + ESC + '[201~'
+let i = 0
+const step = (): void => {
+  if (i < pastes.length) {
+    child.stdin.write(enc(pastes[i]))
+    setTimeout(() => {
+      child.stdin.write(CR)
+      i++
+      setTimeout(step, 500)
+    }, 500)
+  } else {
+    setTimeout(() => child.kill('SIGTERM'), 600)
+  }
+}
+setTimeout(step, 5000)
+child.on('close', () => {
+  let out = ''
+  try {
+    out = fs.readFileSync(LOG, 'utf-8')
+  } catch {
+    out = '(no log)'
+  }
+  process.stdout.write(out + String.fromCharCode(10))
+  try {
+    process.stdout.write('--- tmp files ---' + String.fromCharCode(10))
+    process.stdout.write(
+      fs.readdirSync(TMP).join(String.fromCharCode(10)) +
+        String.fromCharCode(10),
+    )
+  } catch {
+    /* ignore */
+  }
+  process.exit(0)
+})

package/scripts/tui-paste-kinds.tsx

@@ -0,0 +1,76 @@
+// Drive the REAL TuiEditor under a pty and log every onSubmit (text +
+// attachments) so all paste kinds can be exercised: plain text, a big
+// multi-line paste, a file path, and a data: URL image. The attach/clipboard
+// callbacks mirror index.ts (parseImagePaste -> saveToTemp; resolveAttachPath
+// -> readFile) so the probe exercises the same code path the live agent does.
+
+import fs from 'node:fs'
+import fsp from 'node:fs/promises'
+import path from 'node:path'
+import { TuiEditor } from '../src/tui/TuiEditor.js'
+import {
+  contentHash,
+  extForMime,
+  guessMime,
+  parseImagePaste,
+  saveToTemp,
+} from '../src/attachments.js'
+import { resolveAttachPath } from '../src/attach-refs.js'
+
+const LOG = process.env.PROBE_PASTE_LOG || '/tmp/paste-kinds.log'
+const TMP = process.env.PROBE_PASTE_TMP || '/tmp/paste-probe-tmp'
+const WORKDIR = process.cwd()
+const line = (s: string): void => {
+  fs.appendFileSync(LOG, s + String.fromCharCode(10))
+}
+
+const ed = new TuiEditor({
+  prompt: '> ',
+  commands: [],
+  locale: 'en',
+  alternateScreen: true,
+})
+
+ed.onSubmit = (text, atts) => {
+  line(
+    'SUBMIT text=' +
+      JSON.stringify(text) +
+      ' atts=' +
+      JSON.stringify(
+        atts.map((a) => ({ marker: a.marker, image: a.image, name: a.name })),
+      ),
+  )
+}
+ed.onAttach = async (raw: string) => {
+  const image = parseImagePaste(raw)
+  if (image) {
+    const name = 'paste' + extForMime(image.mime)
+    const p = await saveToTemp(TMP, name, image.data)
+    const att = ed.attachments.add({
+      path: p,
+      name,
+      mime: image.mime,
+      size: image.data.length,
+      hash: contentHash(image.data),
+    })
+    line('ATTACH_IMAGE ' + att.marker + ' ' + p)
+    return att
+  }
+  const filePath = await resolveAttachPath(WORKDIR, raw)
+  if (!filePath) return null
+  const data = await fsp.readFile(filePath).catch(() => null)
+  if (!data) return null
+  const name = path.basename(filePath)
+  const att = ed.attachments.add({
+    path: filePath,
+    name,
+    mime: guessMime(name),
+    size: data.length,
+  })
+  line('ATTACH_FILE ' + att.marker + ' ' + filePath)
+  return att
+}
+ed.onClipboard = () => Promise.resolve(null)
+
+ed.start()
+setInterval(() => {}, 1 << 30)

package/scripts/tui-pastetest.mts

@@ -0,0 +1,38 @@
+// Reproduce the [Pasted lines#N] path end to end under a pty: send ONE
+// bracketed-paste chunk with several lines, press Enter, and print what the
+// onSubmit callback actually received (that is what reaches the agent).
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import fs from 'node:fs'
+
+const ESC = String.fromCharCode(27)
+const LF = String.fromCharCode(10)
+const CR = String.fromCharCode(13)
+const LOG = '/tmp/paste-submit.log'
+fs.writeFileSync(LOG, '')
+
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-submit.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '80', LINES: '24', PROBE_SUBMIT_LOG: LOG },
+  },
+)
+child.stdout.on('data', () => {})
+child.stderr.on('data', () => {})
+
+setTimeout(() => {
+  const paste =
+    ESC + '[200~' + ['l1', 'l2', 'l3', 'l4', 'l5'].join(LF) + ESC + '[201~'
+  child.stdin.write(paste)
+  setTimeout(() => {
+    child.stdin.write(CR)
+    setTimeout(() => child.kill('SIGTERM'), 800)
+  }, 800)
+}, 4500)
+
+child.on('close', () => {
+  process.stdout.write(fs.readFileSync(LOG, 'utf-8'))
+  process.exit(0)
+})

package/scripts/tui-repro.tsx

@@ -0,0 +1,64 @@
+// Reproduce the LIVE TUI scenario for the input-box geometry bug.
+//
+// The stock probe uses a bare `> ` prompt, an empty command list and no header, which is why the gated pty test stays green while the live agent still overprints the second input line. This probe mounts the same FullScreenApp with a realistic prompt, a non-empty slash command list and a long title.
+//
+// NOT shipped: a dev probe only.
+
+import React from 'react'
+import { render } from 'ink'
+import { TuiStore } from '../src/tui/store.js'
+import { FullScreenApp } from '../src/tui/FullScreenApp.js'
+import { TuiApp } from '../src/tui/TuiApp.js'
+import { initialEditState } from '../src/tui/edit.js'
+
+const store = new TuiStore()
+const commands = [
+  { name: '/help', description: 'show help' },
+  { name: '/history', description: 'input history' },
+  { name: '/new', description: 'new chat' },
+  { name: '/resume', description: 'open a chat' },
+  { name: '/config', description: 'settings' },
+  {
+    name: '/self-review',
+    description:
+      'snapshot src/ and review the current working tree for bugs and risks',
+  },
+]
+store.set({
+  title: 'zames_pro',
+  version: '2.34.0',
+  workdir: '/workspaces/zames/zames_pro',
+  prompt: '❯ › ',
+  locale: process.env.PROBE_LOCALE === 'ru' ? 'ru' : 'en',
+  commands,
+  edit: { ...initialEditState(), buf: process.argv[2] ?? '' },
+})
+
+store.pushLog('system', 'log line one')
+store.pushLog('system', 'log line two')
+
+const INLINE = process.env.PROBE_INLINE === '1'
+
+const inputProps = {
+  onSubmit: () => {},
+  onEscape: () => {},
+  onCtrlC: () => {},
+  onCopyCode: () => {},
+  onAttach: () => null,
+  onClipboard: () => Promise.resolve(null),
+  onHistoryChange: () => {},
+  onClearScreen: () => {},
+  attachments: [],
+  onPastesChange: () => {},
+}
+
+render(
+  INLINE ? (
+    <TuiApp store={store} inputProps={inputProps} />
+  ) : (
+    <FullScreenApp store={store} inputProps={inputProps} />
+  ),
+  { exitOnCtrlC: false, patchConsole: false, alternateScreen: !INLINE },
+)
+
+setInterval(() => {}, 1 << 30)

package/scripts/tui-resize.mts

@@ -0,0 +1,70 @@
+// Resize a REAL TuiEditor under a pty and screenshot the final grid. The pty
+// WINSIZE is changed mid-run so the kernel delivers SIGWINCH, which exercises
+// TuiEditor.installResizeHandler (unmount + remount), not just Ink's erase.
+//
+// Usage: npx tsx scripts/tui-resize.mts [sc sr nc nr text]
+import { spawnSync } from 'node:child_process'
+import { Term } from '../test/vt100.mts'
+
+const NL = String.fromCharCode(10)
+const sc = Number(process.argv[2] || 80)
+const sr = Number(process.argv[3] || 24)
+const nc = Number(process.argv[4] || 100)
+const nr = Number(process.argv[5] || 30)
+const text = process.argv[6] || ''
+
+// Inline python pty harness (no external file).
+const py = [
+  'import os,pty,sys,time,fcntl,termios,struct,signal,select',
+  'sc,sr,nc,nr=' + sc + ',' + sr + ',' + nc + ',' + nr,
+  'text=' + JSON.stringify(text),
+  'pid,fd=pty.fork()',
+  'if pid==0:',
+  "    os.environ['COLUMNS']=str(sc); os.environ['LINES']=str(sr)",
+  "    os.execvp('npx',['npx','tsx','scripts/tui-editor-probe.tsx'])",
+  'else:',
+  "    def sz(c,r): fcntl.ioctl(fd,termios.TIOCSWINSZ,struct.pack('HHHH',r,c,0,0))",
+  '    sz(sc,sr)',
+  "    buf=b''; start=time.time(); sent=False; resized=False",
+  '    while time.time()-start<14:',
+  '        t=time.time()-start',
+  '        if not sent and t>5:',
+  '            for ch in text:',
+  '                os.write(fd,ch.encode()); time.sleep(0.12)',
+  '            sent=True',
+  '        if not resized and t>9:',
+  '            sz(nc,nr); os.kill(pid,signal.SIGWINCH); resized=True',
+  '        r,_,_=select.select([fd],[],[],0.2)',
+  '        if r:',
+  '            try:',
+  '                d=os.read(fd,65536)',
+  '                if not d: break',
+  '                buf+=d',
+  '            except OSError: break',
+  '    time.sleep(0.5)',
+  '    try:',
+  '        while True:',
+  '            r,_,_=select.select([fd],[],[],0.2)',
+  '            if not r: break',
+  '            d=os.read(fd,65536)',
+  '            if not d: break',
+  '            buf+=d',
+  '    except OSError: pass',
+  '    try: os.kill(pid,signal.SIGKILL)',
+  '    except ProcessLookupError: pass',
+  '    sys.stdout.buffer.write(buf)',
+].join(NL)
+
+const out = spawnSync('python3', ['-c', py], {
+  encoding: 'buffer',
+  maxBuffer: 64 * 1024 * 1024,
+})
+const term = new Term(Math.max(sr, nr), Math.max(sc, nc))
+term.write(out.stdout.toString('utf-8'))
+process.stdout.write(
+  term
+    .render()
+    .split(NL)
+    .map((l, n) => String(n).padStart(2) + '| ' + l)
+    .join(NL) + NL,
+)

package/scripts/tui-scroll-driver.mts

@@ -0,0 +1,53 @@
+// Press keys on the scroll probe and print the scroll values it saw. Accepts
+// several End/Home encodings so a terminal that sends a non-xterm form can be
+// diagnosed.
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+const ESC = String.fromCharCode(27)
+const LOG = '/tmp/scroll-probe.log'
+try {
+  fs.unlinkSync(LOG)
+} catch {
+  /* ignore */
+}
+const map: Record<string, string> = {
+  PGUP: ESC + '[5~',
+  PGDN: ESC + '[6~',
+  HOME: ESC + '[H',
+  END: ESC + '[F',
+  END4: ESC + '[4~',
+  HOME1: ESC + '[1~',
+  CEND: ESC + '[1;5F',
+  CHOME: ESC + '[1;5H',
+  SPGDN: ESC + '[6;2~',
+  SPGUP: ESC + '[5;2~',
+}
+const keys = (process.argv[2] || 'PGUP').split(',').map((k) => map[k] ?? k)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-scroll-probe.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '80', LINES: '24', PROBE_SCROLL_LOG: LOG },
+  },
+)
+child.stdout.on('data', () => {})
+child.stderr.on('data', () => {})
+let i = 0
+const tick = (): void => {
+  if (i < keys.length) {
+    child.stdin.write(keys[i])
+    i++
+    setTimeout(tick, 250)
+  } else setTimeout(() => child.kill('SIGTERM'), 400)
+}
+setTimeout(tick, 5000)
+child.on('close', () => {
+  const lines = fs
+    .readFileSync(LOG, 'utf-8')
+    .trim()
+    .split(String.fromCharCode(10))
+  console.log('SCROLL=' + JSON.stringify(lines.map(Number)))
+  process.exit(0)
+})

package/scripts/tui-scroll-probe.tsx

@@ -0,0 +1,46 @@
+// Mount the REAL FullScreenApp with a LONG log and log every scroll change,
+// so a pty can press PgUp/PgDn/Home/End and prove the viewport moves.
+import React from 'react'
+import fs from 'node:fs'
+import { render } from 'ink'
+import { TuiStore } from '../src/tui/store.js'
+import { FullScreenApp } from '../src/tui/FullScreenApp.js'
+import { initialEditState } from '../src/tui/edit.js'
+
+const LOG = process.env.PROBE_SCROLL_LOG || '/tmp/scroll-probe.log'
+fs.writeFileSync(LOG, '')
+const store = new TuiStore()
+store.set({
+  title: 'probe',
+  version: '0',
+  workdir: '/tmp',
+  prompt: '\u2794 probe \u203a ',
+  locale: 'en',
+  commands: [],
+  edit: { ...initialEditState(), buf: '' },
+})
+for (let i = 0; i < 100; i++) store.pushLog('system', 'log line ' + i)
+const inputProps = {
+  onSubmit: () => {},
+  onEscape: () => {},
+  onCtrlC: () => {},
+  onCopyCode: () => {},
+  onAttach: () => null,
+  onClipboard: () => Promise.resolve(null),
+  onHistoryChange: () => {},
+  onClearScreen: () => {},
+  attachments: [],
+  onPastesChange: () => {},
+}
+store.subscribe(() => {
+  fs.appendFileSync(
+    LOG,
+    String(store.getSnapshot().scroll) + String.fromCharCode(10),
+  )
+})
+render(React.createElement(FullScreenApp, { store, inputProps }), {
+  exitOnCtrlC: false,
+  patchConsole: false,
+  alternateScreen: true,
+})
+setInterval(() => {}, 1 << 30)

package/scripts/tui-shot.mts

@@ -0,0 +1,106 @@
+// Take a VT100 "screenshot" of the TUI under a pty and print the grid.
+//
+// Usage: npx tsx scripts/tui-shot.mts [--inline] [--probe=tui-repro|tui-probe]
+//        [--buf=<initial buffer>] [--keys=a,LF,b,ENTER] [--cols=80] [--rows=24]
+//
+// Keys are sent ONE CHUNK AT A TIME. Tokens: LF (Ctrl+J newline), CR (Enter),
+// ESC, TAB, or any literal character. The screen is snapshotted WHILE the app
+// is still alive, so the real terminal-cursor cell is included.
+
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+
+const ESC = String.fromCharCode(27)
+const LF = String.fromCharCode(10)
+const CR = String.fromCharCode(13)
+const TAB = String.fromCharCode(9)
+
+function arg(name: string, def = ''): string {
+  const hit = process.argv.find((a) => a.startsWith('--' + name + '='))
+  return hit ? hit.slice(name.length + 3) : def
+}
+const hasFlag = (name: string): boolean => process.argv.includes('--' + name)
+
+const inline = hasFlag('inline')
+const probe = arg('probe', 'tui-repro')
+const buf = arg('buf', '')
+const keys = arg('keys', '')
+  .split(',')
+  .filter((s) => s.length > 0)
+  .map((s) => {
+    if (s === 'LF') return LF
+    if (s === 'CR' || s === 'ENTER') return CR
+    if (s === 'ESC') return ESC
+    if (s === 'TAB') return TAB
+    // Alt+Enter and Shift+Enter must arrive as ONE chunk, like a real terminal
+    // sends them; splitting them into separate chunks makes Ink read a bare
+    // Escape key instead of the modified Enter.
+    if (s === 'ALTENTER') return ESC + CR
+    if (s === 'SHIFTENTER') return ESC + '[13;2u'
+    if (s === 'UP') return ESC + '[A'
+    if (s === 'DOWN') return ESC + '[B'
+    if (s === 'RIGHT') return ESC + '[C'
+    if (s === 'LEFT') return ESC + '[D'
+    // Editing keys, so the word-delete bindings can be exercised on a real pty.
+    if (s === 'CTDL') return ESC + '[3;5~' // Ctrl+Delete (xterm)
+    if (s === 'CTDLU') return ESC + '[3;5u' // Ctrl+Delete (kitty CSI-u)
+    if (s === 'CTRLBS') return ESC + String.fromCharCode(127) // Ctrl+Backspace
+    if (s === 'CTB08') return String.fromCharCode(8) // Ctrl+Backspace (0x08)
+    if (s === 'DEL') return ESC + '[3~' // Delete
+    if (s === 'CTRLW') return String.fromCharCode(23)
+    if (s === 'CTRLU') return String.fromCharCode(21)
+    if (s === 'CTRLK') return String.fromCharCode(11)
+    if (s === 'SPACE') return ' '
+    return s
+  })
+const cols = Number(arg('cols', '80'))
+const rows = Number(arg('rows', '24'))
+const hold = Number(arg('hold', '500'))
+
+const scriptPath = 'npx tsx scripts/' + probe + '.tsx ' + JSON.stringify(buf)
+
+const term = new Term(rows, cols)
+const child = spawn('script', ['-qec', scriptPath, '/dev/null'], {
+  cwd: path.resolve('.'),
+  env: {
+    ...process.env,
+    COLUMNS: String(cols),
+    LINES: String(rows),
+    ...(inline ? { PROBE_INLINE: '1' } : {}),
+  },
+})
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => term.write(d.toString('utf-8')))
+
+let i = 0
+const tick = (): void => {
+  if (i < keys.length) {
+    child.stdin.write(keys[i])
+    i++
+    setTimeout(tick, 250)
+  } else {
+    setTimeout(() => {
+      const cr = term.r
+      const cc = term.c
+      const lines = term.render().split(LF)
+      if (lines[cr])
+        lines[cr] =
+          lines[cr].slice(0, cc) +
+          String.fromCharCode(9673) +
+          lines[cr].slice(cc + 1)
+      process.stdout.write(
+        lines.map((l, n) => String(n).padStart(2) + '| ' + l).join(LF) +
+          LF +
+          'cursor: row ' +
+          cr +
+          ', col ' +
+          cc +
+          LF,
+      )
+      child.kill('SIGTERM')
+    }, hold)
+  }
+}
+setTimeout(tick, 4500)
+child.on('close', () => process.exit(0))

package/scripts/tui-status-driver.mts

@@ -0,0 +1,24 @@
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+const NL = String.fromCharCode(10)
+const cols = Number(
+  (process.argv.find((a) => a.startsWith('--cols=')) || '--cols=80').slice(7),
+)
+const rows = 8
+const term = new Term(rows, cols)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-status-shot.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: String(cols), LINES: String(rows) },
+  },
+)
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => term.write(d.toString('utf-8')))
+setTimeout(() => {
+  process.stdout.write(term.render() + NL)
+  child.kill('SIGTERM')
+}, 5000)
+child.on('close', () => process.exit(0))

package/scripts/tui-status-shot.tsx

@@ -0,0 +1,27 @@
+// Mount the REAL StatusBar with all badges set, to check the width math at
+// narrow terminals (truncation must not clip the badges).
+import React from 'react'
+import { render } from 'ink'
+import { StatusBar } from '../src/tui/StatusBar.js'
+import { TuiStore } from '../src/tui/store.js'
+const store = new TuiStore()
+store.set({
+  locale: 'ru',
+  busy: true,
+  animBase: 'Думаю',
+  animStart: Date.now() - 45000,
+  provider: 'DeepSeek',
+  queueLength: 2,
+  tasks: 'задачи: 2/5',
+  thinkingEnabled: true,
+  searchEnabled: true,
+  contextText: 'ctx: 302k · 30%',
+  contextLevel: 'warn',
+  statusLine: 'git:master',
+  sendState: 'generating',
+})
+render(React.createElement(StatusBar, { state: store.getSnapshot() }), {
+  exitOnCtrlC: false,
+  patchConsole: false,
+})
+setInterval(() => {}, 1 << 30)