nastech-tui 0.0.1

package/packages/nastech-ink/src/utils/sliceAnsi.ts

@@ -0,0 +1,106 @@
+import { type AnsiCode, ansiCodesToString, reduceAnsiCodes, tokenize, undoAnsiCodes } from '@alcalzone/ansi-tokenize'
+
+import { lruEvict } from '../ink/lru.js'
+import { stringWidth } from '../ink/stringWidth.js'
+
+function isEndCode(code: AnsiCode): boolean {
+  return code.code === code.endCode
+}
+
+function filterStartCodes(codes: AnsiCode[]): AnsiCode[] {
+  return codes.filter(c => !isEndCode(c))
+}
+
+// LRU cache: same (string, start, end) → same output. Output.get() re-emits
+// identical writes every frame for stable transcript content; this avoids
+// re-tokenizing them. CPU profile (Apr 2026) showed sliceAnsi at 18% total
+// time during scroll. Bounded at 4096 entries — entries are short clipped
+// lines so memory cost is small.
+const sliceCache = new Map<string, string>()
+const SLICE_CACHE_LIMIT = 4096
+
+export default function sliceAnsi(str: string, start: number, end?: number): string {
+  if (!str) {
+    return ''
+  }
+
+  // Hot-path: only cache when end is defined (the Output.get() use-case).
+  if (end !== undefined) {
+    const key = `${start}|${end}|${str}`
+    const cached = sliceCache.get(key)
+
+    if (cached !== undefined) {
+      sliceCache.delete(key)
+      sliceCache.set(key, cached)
+
+      return cached
+    }
+
+    const result = computeSlice(str, start, end)
+
+    if (sliceCache.size >= SLICE_CACHE_LIMIT) {
+      sliceCache.delete(sliceCache.keys().next().value!)
+    }
+
+    sliceCache.set(key, result)
+
+    return result
+  }
+
+  return computeSlice(str, start, end)
+}
+
+export function sliceCacheSize(): number {
+  return sliceCache.size
+}
+
+export function evictSliceCache(keepRatio = 0): void {
+  lruEvict(sliceCache, keepRatio)
+}
+
+function computeSlice(str: string, start: number, end?: number): string {
+  const tokens = tokenize(str)
+  let activeCodes: AnsiCode[] = []
+  let position = 0
+  let result = ''
+  let include = false
+
+  for (const token of tokens) {
+    const width = token.type === 'ansi' ? 0 : token.fullWidth ? 2 : stringWidth(token.value)
+
+    if (end !== undefined && position >= end) {
+      if (token.type === 'ansi' || width > 0 || !include) {
+        break
+      }
+    }
+
+    if (token.type === 'ansi') {
+      activeCodes.push(token)
+
+      if (include) {
+        result += token.code
+      }
+    } else {
+      if (!include && position >= start) {
+        if (start > 0 && width === 0) {
+          continue
+        }
+
+        include = true
+        activeCodes = filterStartCodes(reduceAnsiCodes(activeCodes))
+        result = ansiCodesToString(activeCodes)
+      }
+
+      if (include) {
+        result += token.value
+      }
+
+      position += width
+    }
+  }
+
+  const activeStartCodes = filterStartCodes(reduceAnsiCodes(activeCodes))
+  result += ansiCodesToString(undoAnsiCodes(activeStartCodes))
+
+  return result
+}

package/packages/nastech-ink/text-input.d.ts

@@ -0,0 +1,2 @@
+export { default, UncontrolledTextInput } from 'ink-text-input'
+export type { Props } from 'ink-text-input'

package/packages/nastech-ink/text-input.js

@@ -0,0 +1 @@
+export { default, UncontrolledTextInput } from 'ink-text-input'

package/scripts/build.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+// Bundles src/entry.tsx into a single self-contained dist/entry.js.
+// No runtime node_modules needed.
+import { build } from 'esbuild'
+import { readFileSync, writeFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const root = resolve(here, '..')
+const out = resolve(root, 'dist/entry.js')
+
+// `react-devtools-core` is only imported when DEV=true at runtime (Ink dev
+// mode). Stub it out so the bundle doesn't carry the dep.
+const stubDevtools = {
+  name: 'stub-react-devtools-core',
+  setup(b) {
+    b.onResolve({ filter: /^react-devtools-core$/ }, args => ({
+      path: args.path,
+      namespace: 'stub-devtools'
+    }))
+    b.onLoad({ filter: /.*/, namespace: 'stub-devtools' }, () => ({
+      contents: 'export default { initialize() {}, connectToDevTools() {} }',
+      loader: 'js'
+    }))
+  }
+}
+
+await build({
+  entryPoints: [resolve(root, 'src/entry.tsx')],
+  bundle: true,
+  platform: 'node',
+  format: 'esm',
+  target: 'node20',
+  outfile: out,
+  jsx: 'automatic',
+  jsxImportSource: 'react',
+  // Skip the prebuilt @nastech/ink bundle — esbuild's __esm helper doesn't
+  // await nested async init, which breaks lazy-initialized exports like
+  // `render`. Bundling from source sidesteps that.
+  alias: { '@nastech/ink': resolve(root, 'packages/nastech-ink/src/entry-exports.ts') },
+  plugins: [stubDevtools],
+  // Some transitive deps use CommonJS `require(...)` at runtime. ESM bundles
+  // don't get a `require` binding automatically, so we inject one.
+  banner: {
+    js: "import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);"
+  },
+  logLevel: 'info'
+})
+
+// esbuild preserves the shebang from src/entry.tsx into the bundle, but Nix's
+// patchShebangs phase mangles `/usr/bin/env -S node --foo --bar` (it strips
+// the `node` token, leaving a broken interpreter). The nastech_cli launcher
+// always invokes this file as `node dist/entry.js` anyway, so the shebang is
+// redundant — strip it.
+const body = readFileSync(out, 'utf8')
+if (body.startsWith('#!')) {
+  writeFileSync(out, body.slice(body.indexOf('\n') + 1))
+}
+
+console.log(`built ${out}`)

package/scripts/profile-tui.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/* global Buffer, console, process, setImmediate */
+import inspector from 'node:inspector'
+import { performance } from 'node:perf_hooks'
+
+import React from 'react'
+import { render } from '@nastech/ink'
+import { AppLayout } from '../src/components/appLayout.tsx'
+import { resetOverlayState } from '../src/app/overlayStore.ts'
+import { resetTurnState } from '../src/app/turnStore.ts'
+import { resetUiState } from '../src/app/uiStore.ts'
+
+const session = new inspector.Session()
+session.connect()
+const post = (method, params = {}) => new Promise((resolve, reject) => {
+  session.post(method, params, (err, result) => err ? reject(err) : resolve(result))
+})
+
+const historySize = Number(process.env.HISTORY || 500)
+const mountedRows = Number(process.env.MOUNTED || 120)
+
+class Sink {
+  columns = Number(process.env.COLS || 120)
+  rows = Number(process.env.ROWS || 42)
+  isTTY = true
+  bytes = 0
+  writes = 0
+  listeners = new Map()
+  write(chunk) {
+    this.bytes += Buffer.byteLength(String(chunk ?? ''))
+    this.writes++
+    return true
+  }
+  on(event, fn) { this.listeners.set(event, fn); return this }
+  off(event) { this.listeners.delete(event); return this }
+  once(event, fn) { this.listeners.set(event, fn); return this }
+  removeListener(event) { this.listeners.delete(event); return this }
+}
+
+const theme = {
+  brand: { prompt: '›' },
+  color: {
+    amber: '#d19a66', bronze: '#8b6f47', dim: '#6b7280', error: '#ff5555', gold: '#ffd166', label: '#61afef',
+    ok: '#98c379', warn: '#e5c07b', cornsilk: '#fff8dc', prompt: '#c678dd', shellDollar: '#98c379',
+    statusCritical: '#ff5555', statusBad: '#e06c75', statusWarn: '#e5c07b', statusGood: '#98c379',
+    selectionBg: '#44475a'
+  }
+}
+
+const noop = () => {}
+const historyItems = [
+  { kind: 'intro', role: 'system', text: '', info: { model: 'test', tools: {}, skills: {}, version: 'test' } },
+  ...Array.from({ length: historySize }, (_, i) => ({
+    role: i % 5 === 0 ? 'user' : 'assistant',
+    text: `message ${i}\n${'lorem ipsum '.repeat(80)}`
+  }))
+]
+const scrollRef = { current: {
+  getScrollTop: () => 0,
+  getPendingDelta: () => 0,
+  getScrollHeight: () => historySize * 4,
+  getViewportHeight: () => 30,
+  getViewportTop: () => 0,
+  isSticky: () => true,
+  subscribe: () => () => {},
+  scrollBy: noop,
+  scrollTo: noop,
+  scrollToBottom: noop,
+  setClampBounds: noop,
+  getLastManualScrollAt: () => 0
+} }
+
+const baseProps = streamingText => ({
+  actions: { answerApproval: noop, answerClarify: noop, answerSecret: noop, answerSudo: noop, onModelSelect: noop, resumeById: noop, setStickyPrompt: noop },
+  composer: { cols: 120, compIdx: 0, completions: [], empty: false, handleTextPaste: () => null, input: '', inputBuf: [], pagerPageSize: 10, queueEditIdx: null, queuedDisplay: [], submit: noop, updateInput: noop },
+  mouseTracking: false,
+  progress: {
+    activity: [], outcome: '', reasoning: streamingText, reasoningActive: true, reasoningStreaming: true,
+    reasoningTokens: Math.ceil(streamingText.length / 4), showProgressArea: true, showStreamingArea: true,
+    streamPendingTools: [], streamSegments: [], streaming: streamingText, subagents: [], toolTokens: 0, tools: [], turnTrail: [], todos: []
+  },
+  status: { cwdLabel: '~/repo', goodVibesTick: 0, sessionStartedAt: Date.now(), showStickyPrompt: false, statusColor: theme.color.ok, stickyPrompt: '', turnStartedAt: Date.now(), voiceLabel: 'voice off' },
+  transcript: {
+    historyItems,
+    scrollRef,
+    virtualHistory: { bottomSpacer: 0, end: historyItems.length, measureRef: () => noop, offsets: historyItems.map((_, i) => i * 4), start: Math.max(0, historyItems.length - mountedRows), topSpacer: 0 },
+    virtualRows: historyItems.map((msg, index) => ({ index, key: `m${index}`, msg }))
+  }
+})
+
+async function main() {
+  resetUiState()
+  resetTurnState()
+  resetOverlayState()
+  const stdout = new Sink()
+  const stdin = { isTTY: true, setRawMode: noop, on: noop, off: noop, resume: noop, pause: noop }
+  const text = Array.from({ length: Number(process.env.LINES || 1200) }, (_, i) => `stream line ${i} ${'x'.repeat(90)}`).join('\n')
+  const inst = render(React.createElement(AppLayout, baseProps('')), { stdout, stdin, stderr: stdout, debug: false, exitOnCtrlC: false })
+
+  await post('Profiler.enable')
+  await post('HeapProfiler.enable')
+  await post('Profiler.start')
+  const startMem = process.memoryUsage()
+  const t0 = performance.now()
+  const iterations = Number(process.env.ITERS || 40)
+  for (let i = 1; i <= iterations; i++) {
+    const prefix = text.slice(0, Math.floor(text.length * i / iterations))
+    inst.rerender(React.createElement(AppLayout, baseProps(prefix)))
+    await new Promise(r => setImmediate(r))
+  }
+  const elapsed = performance.now() - t0
+  const prof = await post('Profiler.stop')
+  const endMem = process.memoryUsage()
+  await post('HeapProfiler.collectGarbage')
+  const afterGc = process.memoryUsage()
+  inst.unmount()
+  session.disconnect()
+  console.log(JSON.stringify({ elapsedMs: Math.round(elapsed), stdoutBytes: stdout.bytes, stdoutWrites: stdout.writes, startMem, endMem, afterGc, profileNodes: prof.profile.nodes.length }, null, 2))
+}
+
+main().catch(err => { console.error(err); process.exit(1) })

package/src/__tests__/activeSessionSwitcher.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, it } from 'vitest'
+
+import { DEFAULT_THEME } from '../theme.js'
+import type { SessionActiveItem } from '../gatewayTypes.js'
+import {
+  activeSessionCountLabel,
+  canTypeOrchestratorPrompt,
+  currentSessionSelectionIndex,
+  orchestratorContextHint,
+  orchestratorContextHintSegments,
+  orchestratorGlobalHotkeyHint,
+  orchestratorGlobalHotkeyHintSegments,
+  orchestratorHintSegmentColor,
+  clampOrchestratorSelection,
+  closeFallbackAfterClose,
+  draftModelArgFromPickerValue,
+  draftModelDisplayLabel,
+  fixedSessionColumnStyle,
+  draftTitleFromPrompt,
+  isNewSessionRow,
+  newSessionMarkerColor,
+  newSessionRowIndex,
+  orchestratorRowClickAction,
+  orchestratorVisibleRowIndexes,
+  selectedSessionRowStyle
+} from '../components/activeSessionSwitcher.js'
+
+describe('session orchestrator helpers', () => {
+  it('labels live sessions compactly for tight overlays', () => {
+    expect(activeSessionCountLabel(0)).toBe('0 live sessions')
+    expect(activeSessionCountLabel(1)).toBe('1 live session')
+    expect(activeSessionCountLabel(3)).toBe('3 live sessions')
+    expect(activeSessionCountLabel(1)).not.toContain('in this TUI')
+  })
+
+  it('keeps session orchestrator hotkey hints short and contextual', () => {
+    expect(orchestratorContextHint(false)).toBe('Session row: Enter switch · Ctrl+D close')
+    expect(orchestratorContextHint(true)).toBe('New row: type prompt · Enter start · Tab model')
+    expect(orchestratorGlobalHotkeyHint).toBe('↑↓ move · Ctrl+N new · Ctrl+R refresh · Esc close')
+    expect(orchestratorGlobalHotkeyHint.length).toBeLessThanOrEqual(56)
+  })
+
+  it('assigns themed colors consistently to orchestrator labels and hotkeys', () => {
+    expect(orchestratorContextHintSegments(false)).toEqual([
+      { role: 'label', text: 'Session row:' },
+      { role: 'text', text: ' ' },
+      { role: 'hotkey', text: 'Enter' },
+      { role: 'text', text: ' switch · ' },
+      { role: 'hotkey', text: 'Ctrl+D' },
+      { role: 'text', text: ' close' }
+    ])
+    expect(orchestratorContextHintSegments(true)).toEqual([
+      { role: 'label', text: 'New row:' },
+      { role: 'text', text: ' type prompt · ' },
+      { role: 'hotkey', text: 'Enter' },
+      { role: 'text', text: ' start · ' },
+      { role: 'hotkey', text: 'Tab' },
+      { role: 'text', text: ' model' }
+    ])
+    expect(orchestratorGlobalHotkeyHintSegments.filter(s => s.role === 'hotkey').map(s => s.text)).toEqual([
+      '↑↓',
+      'Ctrl+N',
+      'Ctrl+R',
+      'Esc'
+    ])
+    expect(orchestratorHintSegmentColor(DEFAULT_THEME, 'hotkey')).toBe(DEFAULT_THEME.color.accent)
+    expect(orchestratorHintSegmentColor(DEFAULT_THEME, 'label')).toBe(DEFAULT_THEME.color.label)
+    expect(orchestratorHintSegmentColor(DEFAULT_THEME, 'text')).toBe(DEFAULT_THEME.color.muted)
+    expect(newSessionMarkerColor(DEFAULT_THEME, false)).toBe(DEFAULT_THEME.color.label)
+    expect(newSessionMarkerColor(DEFAULT_THEME, true)).toBe(DEFAULT_THEME.color.text)
+  })
+
+  it('uses a readable selected row style instead of accent-on-accent inverse text', () => {
+    const style = selectedSessionRowStyle(DEFAULT_THEME)
+
+    expect(style.backgroundColor).toBe(DEFAULT_THEME.color.selectionBg)
+    expect(style.color).toBe(DEFAULT_THEME.color.text)
+    expect(style.backgroundColor).not.toBe(DEFAULT_THEME.color.accent)
+    expect(style.color).not.toBe(DEFAULT_THEME.color.accent)
+  })
+
+  it('turns model picker values into session-scoped draft model args', () => {
+    expect(draftModelArgFromPickerValue('kimi-k2.6 --provider ollama-cloud --tui-session')).toBe(
+      'kimi-k2.6 --provider ollama-cloud'
+    )
+    expect(draftModelArgFromPickerValue('openai/gpt-5.5 --provider openai-codex --global')).toBe(
+      'openai/gpt-5.5 --provider openai-codex'
+    )
+  })
+
+  it('highlights the current live session when the picker opens', () => {
+    const sessions = [
+      { id: 'first', status: 'idle' },
+      { id: 'second', status: 'working', current: true },
+      { id: 'third', status: 'idle' }
+    ] satisfies SessionActiveItem[]
+
+    expect(currentSessionSelectionIndex(sessions, 'second')).toBe(1)
+    expect(
+      currentSessionSelectionIndex([{ id: 'first', status: 'idle' }, { id: 'third', status: 'idle' }], 'third')
+    ).toBe(1)
+    expect(currentSessionSelectionIndex(sessions, 'missing')).toBe(1)
+    expect(currentSessionSelectionIndex([], 'missing')).toBe(0)
+  })
+
+  it('adds a selectable New row after the live sessions and gates prompt typing to it', () => {
+    expect(newSessionRowIndex(0)).toBe(0)
+    expect(newSessionRowIndex(3)).toBe(3)
+    expect(clampOrchestratorSelection(-5, 2)).toBe(0)
+    expect(clampOrchestratorSelection(99, 2)).toBe(2)
+    expect(isNewSessionRow(0, 0)).toBe(true)
+    expect(isNewSessionRow(1, 2)).toBe(false)
+    expect(isNewSessionRow(2, 2)).toBe(true)
+    expect(canTypeOrchestratorPrompt(1, 2)).toBe(false)
+    expect(canTypeOrchestratorPrompt(2, 2)).toBe(true)
+    expect(orchestratorVisibleRowIndexes(3, 3, 12)).toEqual([0, 1, 2, 3])
+    expect(orchestratorVisibleRowIndexes(13, 13, 12)).toContain(13)
+  })
+
+  it('selects a safe fallback after closing the current live session', () => {
+    const remaining = [
+      { id: 'next', status: 'idle' },
+      { id: 'other', status: 'working' }
+    ] satisfies SessionActiveItem[]
+
+    expect(closeFallbackAfterClose('other', 'current', remaining)).toEqual({ action: 'stay' })
+    expect(closeFallbackAfterClose('current', 'current', remaining)).toEqual({ action: 'activate', sessionId: 'next' })
+    expect(closeFallbackAfterClose('current', 'current', [])).toEqual({ action: 'new' })
+  })
+
+  it('shows clean draft model labels without picker flags or provider params', () => {
+    expect(draftModelDisplayLabel('kimi-k2.6 --provider ollama-cloud --tui-session')).toBe('kimi-k2.6')
+    expect(draftModelDisplayLabel('openai/gpt-5.5 --provider openai-codex --global')).toBe('gpt-5.5')
+    expect(draftModelDisplayLabel('')).toBe('current/default')
+  })
+
+  it('maps row clicks to existing-session activation or New-row focus', () => {
+    const sessions = [
+      { id: 'a', status: 'idle' },
+      { id: 'b', status: 'idle' }
+    ] satisfies SessionActiveItem[]
+
+    expect(orchestratorRowClickAction(1, sessions)).toEqual({ action: 'activate', sessionId: 'b' })
+    expect(orchestratorRowClickAction(2, sessions)).toEqual({ action: 'select-new' })
+    expect(orchestratorRowClickAction(99, sessions)).toEqual({ action: 'select-new' })
+  })
+
+  it('keeps fixed table columns from shrinking into adjacent columns', () => {
+    expect(fixedSessionColumnStyle().flexShrink).toBe(0)
+  })
+
+  it('builds a compact title from the orchestrator prompt', () => {
+    expect(draftTitleFromPrompt('  Build the websocket orchestrator panel and make it robust.  ', 24)).toBe(
+      'Build the websocket orc…'
+    )
+  })
+})

package/src/__tests__/appChromeStatusRule.test.tsx

@@ -0,0 +1,84 @@
+import React from 'react'
+import { describe, expect, it, vi } from 'vitest'
+
+import { StatusRule } from '../components/appChrome.js'
+import { DEFAULT_THEME } from '../theme.js'
+
+type ReactNodeLike = React.ReactNode
+
+const textContent = (node: ReactNodeLike): string => {
+  if (node === null || node === undefined || typeof node === 'boolean') {
+    return ''
+  }
+
+  if (typeof node === 'string' || typeof node === 'number') {
+    return String(node)
+  }
+
+  if (Array.isArray(node)) {
+    return node.map(textContent).join('')
+  }
+
+  if (React.isValidElement(node)) {
+    return textContent(node.props.children)
+  }
+
+  return ''
+}
+
+const findClickableWithText = (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 = findClickableWithText(child, needle)
+
+      if (found) {
+        return found
+      }
+    }
+
+    return null
+  }
+
+  if (!React.isValidElement(node)) {
+    return null
+  }
+
+  if (typeof node.props.onClick === 'function' && textContent(node).includes(needle)) {
+    return node
+  }
+
+  return findClickableWithText(node.props.children, needle)
+}
+
+describe('StatusRule session count click target', () => {
+  it('makes the live session count itself clickable', () => {
+    const openSwitcher = vi.fn()
+    const element = StatusRule({
+      bgCount: 0,
+      busy: false,
+      cols: 100,
+      cwdLabel: '~/repo',
+      liveSessionCount: 1,
+      model: 'kimi-k2.6',
+      onSessionCountClick: openSwitcher,
+      sessionStartedAt: null,
+      showCost: false,
+      status: 'ready',
+      statusColor: DEFAULT_THEME.color.ok,
+      t: DEFAULT_THEME,
+      turnStartedAt: null,
+      usage: { total: 0 },
+      voiceLabel: ''
+    })
+
+    const clickableSessionCount = findClickableWithText(element, '1 session')
+
+    expect(clickableSessionCount).not.toBeNull()
+    clickableSessionCount!.props.onClick({ stopImmediatePropagation: vi.fn() })
+    expect(openSwitcher).toHaveBeenCalledOnce()
+  })
+})

package/src/__tests__/appChromeStatusRuleDevCredits.test.tsx

@@ -0,0 +1,73 @@
+import React from 'react'
+import { describe, expect, it, vi } from 'vitest'
+
+import { StatusRule } from '../components/appChrome.js'
+import { DEFAULT_THEME } from '../theme.js'
+
+// DEV_CREDITS_MODE is a module-load-time constant (config/env.ts reads
+// process.env.NASTECH_DEV_CREDITS exactly once, at import). Mutating process.env
+// inside a test can't flip it after the module is loaded — so mock the module to
+// the dev-on value for this file. vitest hoists vi.mock above the imports, so
+// appChrome picks up the mocked flag. Lives in its own file so the override
+// stays scoped (the other StatusRule tests run with the real, dev-off value).
+vi.mock('../config/env.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../config/env.js')>()
+  return { ...actual, DEV_CREDITS_MODE: true }
+})
+
+type ReactNodeLike = React.ReactNode
+
+const textContent = (node: ReactNodeLike): string => {
+  if (node === null || node === undefined || typeof node === 'boolean') {
+    return ''
+  }
+
+  if (typeof node === 'string' || typeof node === 'number') {
+    return String(node)
+  }
+
+  if (Array.isArray(node)) {
+    return node.map(textContent).join('')
+  }
+
+  if (React.isValidElement(node)) {
+    return textContent(node.props.children)
+  }
+
+  return ''
+}
+
+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 dev-credits banner (NASTECH_DEV_CREDITS on)', () => {
+  it('keeps the dev-credits banner visible alongside a notice', () => {
+    const element = StatusRule({
+      ...baseProps,
+      notice: { key: 'credits.90', kind: 'sticky', level: 'warn', text: '⚠ 90% used' },
+      usage: { ...baseProps.usage, dev_credits_spent_micros: 12_345 }
+    })
+
+    const rendered = textContent(element)
+
+    // The notice and the dev banner coexist …
+    expect(rendered).toContain('⚠ 90% used')
+    expect(rendered).toContain('(dev credits)')
+    // … and the Δ spend segment renders (12345 micros → 1.2¢).
+    expect(rendered).toContain('Δ')
+  })
+})

package/src/__tests__/approvalAction.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest'
+
+import { approvalAction } from '../components/prompts.js'
+
+describe('approvalAction — pure key dispatch for ApprovalPrompt', () => {
+  it('maps Esc to deny — parity with global Ctrl+C cancellation', () => {
+    expect(approvalAction('', { escape: true }, 0)).toEqual({ kind: 'choose', choice: 'deny' })
+    expect(approvalAction('', { escape: true }, 2)).toEqual({ kind: 'choose', choice: 'deny' })
+  })
+
+  it('maps number keys 1..4 to once/session/always/deny in registration order', () => {
+    expect(approvalAction('1', {}, 0)).toEqual({ kind: 'choose', choice: 'once' })
+    expect(approvalAction('2', {}, 0)).toEqual({ kind: 'choose', choice: 'session' })
+    expect(approvalAction('3', {}, 0)).toEqual({ kind: 'choose', choice: 'always' })
+    expect(approvalAction('4', {}, 0)).toEqual({ kind: 'choose', choice: 'deny' })
+  })
+
+  it('ignores out-of-range numbers', () => {
+    expect(approvalAction('0', {}, 1)).toEqual({ kind: 'noop' })
+    expect(approvalAction('5', {}, 1)).toEqual({ kind: 'noop' })
+    expect(approvalAction('9', {}, 1)).toEqual({ kind: 'noop' })
+  })
+
+  it('confirms the current selection on Enter', () => {
+    expect(approvalAction('', { return: true }, 0)).toEqual({ kind: 'choose', choice: 'once' })
+    expect(approvalAction('', { return: true }, 3)).toEqual({ kind: 'choose', choice: 'deny' })
+  })
+
+  it('moves selection up/down within bounds', () => {
+    expect(approvalAction('', { upArrow: true }, 2)).toEqual({ kind: 'move', delta: -1 })
+    expect(approvalAction('', { downArrow: true }, 1)).toEqual({ kind: 'move', delta: 1 })
+  })
+
+  it('clamps selection movement at the edges', () => {
+    expect(approvalAction('', { upArrow: true }, 0)).toEqual({ kind: 'noop' })
+    expect(approvalAction('', { downArrow: true }, 3)).toEqual({ kind: 'noop' })
+  })
+
+  it('Esc beats numeric/return — denying is always the first interpretation', () => {
+    // If a terminal somehow delivers Esc + a digit in the same event, deny
+    // wins.  Documents the precedence so a future refactor doesn't flip it.
+    expect(approvalAction('1', { escape: true }, 0)).toEqual({ kind: 'choose', choice: 'deny' })
+    expect(approvalAction('', { escape: true, return: true }, 1)).toEqual({ kind: 'choose', choice: 'deny' })
+  })
+
+  it('returns noop for unrelated keystrokes (printable letters etc.)', () => {
+    expect(approvalAction('a', {}, 0)).toEqual({ kind: 'noop' })
+    expect(approvalAction(' ', {}, 0)).toEqual({ kind: 'noop' })
+  })
+})