@clawpump/claw-agent 0.1.5 → 0.1.7

package/agent/ui-tui/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.HERMES_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 (HERMES_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/agent/ui-tui/src/__tests__/approvalAction.test.ts

@@ -47,4 +47,15 @@ describe('approvalAction — pure key dispatch for ApprovalPrompt', () => {
     expect(approvalAction('a', {}, 0)).toEqual({ kind: 'noop' })
     expect(approvalAction(' ', {}, 0)).toEqual({ kind: 'noop' })
   })
+
+  it('respects a reduced option set when permanent allow is disabled', () => {
+    // tirith content-security warning present → no "always"; the 3-item set is
+    // once/session/deny, so 3 maps to deny and 4 is out of range.
+    const opts = ['once', 'session', 'deny'] as const
+
+    expect(approvalAction('3', {}, 0, opts)).toEqual({ kind: 'choose', choice: 'deny' })
+    expect(approvalAction('4', {}, 0, opts)).toEqual({ kind: 'noop' })
+    expect(approvalAction('', { downArrow: true }, 2, opts)).toEqual({ kind: 'noop' })
+    expect(approvalAction('', { return: true }, 2, opts)).toEqual({ kind: 'choose', choice: 'deny' })
+  })
 })

package/agent/ui-tui/src/__tests__/billingCommand.test.ts

@@ -0,0 +1,301 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { getOverlayState, resetOverlayState } from '../app/overlayStore.js'
+import { billingCommands } from '../app/slash/commands/billing.js'
+import type { BillingStateResponse } from '../gatewayTypes.js'
+
+vi.mock('../lib/openExternalUrl.js', () => ({
+  openExternalUrl: vi.fn(() => true)
+}))
+
+const billingCommand = billingCommands.find(cmd => cmd.name === 'billing')!
+
+const ownerState = (overrides: Partial<BillingStateResponse> = {}): BillingStateResponse => ({
+  auto_reload: {
+    enabled: false,
+    reload_to_display: '—',
+    reload_to_usd: null,
+    threshold_display: '—',
+    threshold_usd: null
+  },
+  balance_display: '$142.50',
+  balance_usd: '142.5',
+  can_charge: true,
+  card: { brand: 'visa', last4: '4242', masked: 'visa ····4242' },
+  charge_presets: ['25', '50', '100'],
+  charge_presets_display: ['$25', '$50', '$100'],
+  cli_billing_enabled: true,
+  is_admin: true,
+  logged_in: true,
+  max_usd: '10000',
+  min_usd: '10',
+  monthly_cap: {
+    is_default_ceiling: true,
+    limit_display: '$1000',
+    limit_usd: '1000',
+    spent_display: '$180',
+    spent_this_month_usd: '180'
+  },
+  ok: true,
+  org_name: 'Acme',
+  portal_url: 'https://portal/billing?topup=open',
+  role: 'OWNER',
+  ...overrides
+})
+
+const guarded =
+  <T>(fn: (r: T) => void) =>
+  (r: null | T) => {
+    if (r) {
+      fn(r)
+    }
+  }
+
+/** Build a ctx whose rpc routes by method name to a supplied map of results. */
+const buildCtx = (results: Record<string, unknown>) => {
+  const sys = vi.fn()
+  const calls: Array<{ method: string; params: unknown }> = []
+
+  const rpc = vi.fn((method: string, params: unknown) => {
+    calls.push({ method, params })
+
+    return Promise.resolve(results[method])
+  })
+
+  const ctx = {
+    gateway: { rpc },
+    guarded,
+    guardedErr: vi.fn(),
+    sid: 'sid-1',
+    stale: () => false,
+    transcript: { page: vi.fn(), panel: vi.fn(), sys }
+  }
+
+  const run = async (arg: string) => {
+    billingCommand.run(arg, ctx as any, 'billing')
+    await rpc.mock.results[0]?.value
+    await Promise.resolve()
+    await Promise.resolve()
+  }
+
+  return { calls, ctx, rpc, run, sys }
+}
+
+const printed = (sys: ReturnType<typeof vi.fn>) => sys.mock.calls.map(c => c[0]).join('\n')
+
+describe('/billing slash command (overlay-driven)', () => {
+  beforeEach(() => {
+    resetOverlayState()
+  })
+
+  it('not logged in → prompts to log in, no overlay', async () => {
+    const { run, sys } = buildCtx({ 'billing.state': { ...ownerState(), logged_in: false, ok: true } })
+    await run('')
+    expect(printed(sys)).toContain('Not logged into Nous Portal')
+    expect(getOverlayState().billing).toBeNull()
+  })
+
+  it('bare /billing opens the overlay on the overview screen with state', async () => {
+    const { run, rpc } = buildCtx({ 'billing.state': ownerState() })
+    await run('')
+    expect(rpc).toHaveBeenCalledWith('billing.state', {})
+    const billing = getOverlayState().billing
+    expect(billing).toBeTruthy()
+    expect(billing?.screen).toBe('overview')
+    expect(billing?.state.balance_display).toBe('$142.50')
+    expect(billing?.state.charge_presets_display).toEqual(['$25', '$50', '$100'])
+  })
+
+  it('any sub-command arg is ignored — still opens the overview overlay', async () => {
+    const { run } = buildCtx({ 'billing.state': ownerState() })
+    await run('buy 100')
+    const billing = getOverlayState().billing
+    expect(billing?.screen).toBe('overview')
+    // No confirm overlay armed directly by the command anymore.
+    expect(getOverlayState().confirm).toBeNull()
+  })
+
+  it('member overview carries the non-admin state for component-side gating', async () => {
+    const { run } = buildCtx({
+      'billing.state': ownerState({
+        is_admin: false,
+        can_charge: false,
+        role: 'MEMBER',
+        card: null,
+        monthly_cap: null,
+        auto_reload: null
+      })
+    })
+
+    await run('')
+    const billing = getOverlayState().billing
+    expect(billing?.state.is_admin).toBe(false)
+    expect(billing?.screen).toBe('overview')
+  })
+
+  // ── Overlay ctx behaviors (RPC + error mapping live in billing.ts) ──
+
+  it('ctx.validate rejects out-of-bounds and sub-cent amounts, accepts valid', async () => {
+    const { run } = buildCtx({ 'billing.state': ownerState() })
+    await run('')
+    const ctx = getOverlayState().billing!.ctx
+    expect(ctx.validate('5').error).toContain('Minimum is $10')
+    expect(ctx.validate('10.005').error).toContain('2 decimal places')
+    expect(ctx.validate('100').amount).toBe('100')
+    expect(ctx.validate('$50').amount).toBe('50')
+  })
+
+  it('ctx.charge → poll → settled', async () => {
+    vi.useFakeTimers()
+
+    try {
+      const { run, sys } = buildCtx({
+        'billing.state': ownerState(),
+        'billing.charge': { ok: true, charge_id: 'ch_1', idempotency_key: 'k' },
+        'billing.charge_status': { ok: true, status: 'settled', amount_usd: '100' }
+      })
+
+      await run('')
+      const ctx = getOverlayState().billing!.ctx
+      ctx.charge('100')
+      await vi.runAllTimersAsync()
+      const out = printed(sys)
+      expect(out).toContain('Charge submitted')
+      expect(out).toContain('✅ $100 added.')
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('ctx.charge → poll → failed adds the portal funnel line', async () => {
+    vi.useFakeTimers()
+
+    try {
+      const { run, sys } = buildCtx({
+        'billing.state': ownerState(),
+        'billing.charge': { ok: true, charge_id: 'ch_1', idempotency_key: 'k' },
+        'billing.charge_status': { ok: true, status: 'failed', reason: 'card_declined' }
+      })
+
+      await run('')
+      getOverlayState().billing!.ctx.charge('100')
+      await vi.runAllTimersAsync()
+      const out = printed(sys)
+      expect(out).toContain('Your card was declined')
+      // Parity with the CLI: a failed poll funnels to the portal (from state.portal_url).
+      expect(out).toContain('Portal: https://portal/billing?topup=open')
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('ctx.charge monthly_cap_exceeded surfaces remaining headroom', async () => {
+    const { run, sys } = buildCtx({
+      'billing.state': ownerState(),
+      'billing.charge': {
+        ok: false,
+        error: 'monthly_cap_exceeded',
+        message: 'Monthly spend cap reached.',
+        payload: { remainingUsd: '42.50' },
+        portal_url: '/billing?topup=open',
+        idempotency_key: 'k'
+      }
+    })
+
+    await run('')
+    getOverlayState().billing!.ctx.charge('100')
+    await Promise.resolve()
+    await Promise.resolve()
+    const out = printed(sys)
+    expect(out).toContain('Monthly spend cap reached — $42.50 headroom left.')
+    expect(out).toContain('Portal: /billing?topup=open')
+  })
+
+  it('ctx.charge no_payment_method → portal funnel copy', async () => {
+    const { run, sys } = buildCtx({
+      'billing.state': ownerState(),
+      'billing.charge': {
+        ok: false,
+        error: 'no_payment_method',
+        portal_url: '/billing?topup=open',
+        idempotency_key: 'k'
+      }
+    })
+
+    await run('')
+    getOverlayState().billing!.ctx.charge('100')
+    await Promise.resolve()
+    await Promise.resolve()
+    const out = printed(sys)
+    expect(out).toContain('No saved card for terminal charges')
+    expect(out).toContain('Portal: /billing?topup=open')
+  })
+
+  it('ctx.charge insufficient_scope → arms step-up confirm', async () => {
+    const { run } = buildCtx({
+      'billing.state': ownerState(),
+      'billing.charge': { ok: false, error: 'insufficient_scope', idempotency_key: 'k' }
+    })
+
+    await run('')
+    getOverlayState().billing!.ctx.charge('100')
+    await Promise.resolve()
+    await Promise.resolve()
+    // The charge failed with insufficient_scope → a NEW confirm (step-up) is armed.
+    const stepUp = getOverlayState().confirm
+    expect(stepUp?.title).toBe('Grant terminal billing access?')
+  })
+
+  it('ctx.applyAutoReload(true, …) → billing.auto_reload RPC, resolves true', async () => {
+    const { run, calls } = buildCtx({
+      'billing.state': ownerState(),
+      'billing.auto_reload': { ok: true }
+    })
+
+    await run('')
+    const ok = await getOverlayState().billing!.ctx.applyAutoReload(true, 20, 100)
+    expect(ok).toBe(true)
+    const ar = calls.find(c => c.method === 'billing.auto_reload')
+    expect(ar?.params).toEqual({ enabled: true, threshold: 20, top_up_amount: 100 })
+  })
+
+  it('ctx.applyAutoReload(false) → disables (enabled:false, no amounts)', async () => {
+    const { run, calls } = buildCtx({
+      'billing.state': ownerState({
+        auto_reload: {
+          enabled: true,
+          reload_to_display: '$100',
+          reload_to_usd: '100',
+          threshold_display: '$20',
+          threshold_usd: '20'
+        }
+      }),
+      'billing.auto_reload': { ok: true }
+    })
+
+    await run('')
+    const ok = await getOverlayState().billing!.ctx.applyAutoReload(false)
+    expect(ok).toBe(true)
+    const ar = calls.find(c => c.method === 'billing.auto_reload')
+    expect(ar?.params).toEqual({ enabled: false })
+  })
+
+  it('ctx.applyAutoReload error → resolves false + maps the error', async () => {
+    const { run, sys } = buildCtx({
+      'billing.state': ownerState(),
+      'billing.auto_reload': { ok: false, error: 'monthly_cap_exceeded', message: 'Monthly spend cap reached.' }
+    })
+
+    await run('')
+    const ok = await getOverlayState().billing!.ctx.applyAutoReload(true, 20, 100)
+    expect(ok).toBe(false)
+    expect(printed(sys)).toContain('Monthly spend cap reached.')
+  })
+
+  it('ctx.openPortal opens the URL + echoes a transcript line', async () => {
+    const { run, sys } = buildCtx({ 'billing.state': ownerState() })
+    await run('')
+    getOverlayState().billing!.ctx.openPortal('https://portal/x')
+    expect(printed(sys)).toContain('Opening portal: https://portal/x')
+  })
+})

package/agent/ui-tui/src/__tests__/blockLayout.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from 'vitest'
+
+import { blockRenders, hasLeadGap, messageGroup, prevRenderedMsg } from '../domain/blockLayout.js'
+import type { Msg } from '../types.js'
+
+const m = (over: Partial<Msg>): Msg => ({ role: 'assistant', text: '', ...over })
+
+describe('messageGroup', () => {
+  it('classifies each block kind into its visual band', () => {
+    expect(messageGroup(m({ role: 'assistant' }))).toBe('model')
+    expect(messageGroup(m({ role: 'assistant', kind: 'diff' }))).toBe('diff')
+    expect(messageGroup(m({ role: 'system', kind: 'trail' }))).toBe('trail')
+    expect(messageGroup(m({ role: 'system' }))).toBe('note')
+    expect(messageGroup(m({ role: 'user' }))).toBe('user')
+    expect(messageGroup(m({ role: 'user', kind: 'slash' }))).toBe('slash')
+    expect(messageGroup(m({ role: 'system', kind: 'intro' }))).toBe('intro')
+    expect(messageGroup(m({ role: 'system', kind: 'panel' }))).toBe('intro')
+  })
+})
+
+describe('hasLeadGap', () => {
+  const trail = m({ role: 'system', kind: 'trail' })
+  const model = m({ role: 'assistant' })
+  const note = m({ role: 'system' })
+  const user = m({ role: 'user' })
+  const diff = m({ role: 'assistant', kind: 'diff' })
+  const slash = m({ role: 'user', kind: 'slash' })
+
+  it('opens a gap only at a boundary between working-area groups', () => {
+    expect(hasLeadGap(trail, model)).toBe(true)
+    expect(hasLeadGap(model, trail)).toBe(true)
+    expect(hasLeadGap(model, note)).toBe(true)
+    expect(hasLeadGap(note, model)).toBe(true)
+  })
+
+  it('keeps same-group neighbours flush (the grouping)', () => {
+    expect(hasLeadGap(trail, trail)).toBe(false)
+    expect(hasLeadGap(model, model)).toBe(false)
+    expect(hasLeadGap(note, note)).toBe(false)
+  })
+
+  it('never gaps the first block (no predecessor)', () => {
+    expect(hasLeadGap(undefined, model)).toBe(false)
+    expect(hasLeadGap(undefined, trail)).toBe(false)
+  })
+
+  it('suppresses the gap after blocks that already paint a trailing line', () => {
+    // user and diff carry their own marginBottom — the following block must
+    // not add a second blank line on top of it.
+    expect(hasLeadGap(user, trail)).toBe(false)
+    expect(hasLeadGap(user, model)).toBe(false)
+    expect(hasLeadGap(diff, model)).toBe(false)
+  })
+
+  it('still gaps after a slash echo (it has no trailing margin)', () => {
+    expect(hasLeadGap(slash, model)).toBe(true)
+    expect(hasLeadGap(slash, trail)).toBe(true)
+  })
+
+  it('lets user / slash / diff own their spacing (never managed here)', () => {
+    expect(hasLeadGap(model, user)).toBe(false)
+    expect(hasLeadGap(model, slash)).toBe(false)
+    expect(hasLeadGap(model, diff)).toBe(false)
+  })
+})
+
+describe('blockRenders', () => {
+  const trail: Msg = { role: 'system', kind: 'trail', text: '', tools: ['Edit foo.ts'] }
+  const model: Msg = { role: 'assistant', text: 'hi' }
+  const todos: Msg = { role: 'system', kind: 'trail', text: '', todos: [{ content: 'a', id: '1', status: 'pending' }] }
+
+  it('always renders non-trail blocks', () => {
+    expect(blockRenders(model, { detailsMode: 'hidden', commandOverride: true })).toBe(true)
+  })
+
+  it('renders a content-bearing trail unless every section is hidden', () => {
+    expect(blockRenders(trail, { detailsMode: 'collapsed' })).toBe(true)
+    expect(blockRenders(trail, { detailsMode: 'expanded' })).toBe(true)
+    // /details hidden routes through commandOverride, which hides every section.
+    expect(blockRenders(trail, { detailsMode: 'hidden', commandOverride: true })).toBe(false)
+  })
+
+  it('does not render a content-less trail (e.g. finalDetails with only a token tally)', () => {
+    const tally: Msg = { role: 'system', kind: 'trail', text: '', toolTokens: 40 }
+
+    expect(blockRenders(tally, { detailsMode: 'expanded' })).toBe(false)
+  })
+
+  it('keeps todo trails visible even when details are hidden', () => {
+    expect(blockRenders(todos, { detailsMode: 'hidden', commandOverride: true })).toBe(true)
+  })
+})
+
+describe('prevRenderedMsg', () => {
+  const hiddenCtx = { commandOverride: true, detailsMode: 'hidden' as const }
+  const shownCtx = { detailsMode: 'collapsed' as const }
+
+  const rows: Msg[] = [
+    { role: 'user', text: 'q' }, // 0
+    { role: 'system', kind: 'trail', text: '', tools: ['Edit foo.ts'] }, // 1
+    { role: 'assistant', text: 'first' }, // 2
+    { role: 'system', kind: 'trail', text: '', tools: ['Edit bar.ts'] }, // 3
+    { role: 'assistant', text: 'second' } // 4
+  ]
+  const at = (i: number) => rows[i]
+
+  it('returns the literal predecessor when everything renders', () => {
+    expect(prevRenderedMsg(at, 2, shownCtx)).toBe(rows[1])
+    expect(prevRenderedMsg(at, 4, shownCtx)).toBe(rows[3])
+  })
+
+  it('skips hidden trails so grouping sees the nearest visible block', () => {
+    // With trails hidden, the prose at index 2 groups against the user (not the
+    // invisible trail) and the prose at index 4 groups against the prose at 2.
+    expect(prevRenderedMsg(at, 2, hiddenCtx)).toBe(rows[0])
+    expect(prevRenderedMsg(at, 4, hiddenCtx)).toBe(rows[2])
+  })
+
+  it('returns undefined at the top of the transcript', () => {
+    expect(prevRenderedMsg(at, 0, shownCtx)).toBeUndefined()
+  })
+})

package/agent/ui-tui/src/__tests__/brandingMcpCount.test.ts

@@ -0,0 +1,111 @@
+import { PassThrough } from 'stream'
+
+import { renderSync } from '@hermes/ink'
+import React from 'react'
+import { describe, expect, it } from 'vitest'
+
+import { SessionPanel } from '../components/branding.js'
+import { DEFAULT_THEME } from '../theme.js'
+import type { McpServerStatus, SessionInfo } from '../types.js'
+
+// Invariant under test: the TUI banner's MCP headline counts *connected*
+// servers, never configured-but-disabled ones. This mirrors the classic CLI
+// banner (`mcp_connected = sum(1 for s in mcp_status if s["connected"])` in
+// hermes_cli/banner.py) and the "connected" label on the MCP collapse toggle.
+//
+// Regression: branding.tsx used the raw `info.mcp_servers.length`, so a
+// disabled `linear` server alongside a connected `nous-support` server made
+// the TUI report "2 MCP" while the classic CLI correctly reported "1 MCP".
+
+const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
+
+const makeStreams = (columns = 100) => {
+  const stdout = new PassThrough()
+  const stdin = new PassThrough()
+  const stderr = new PassThrough()
+
+  Object.assign(stdout, { columns, isTTY: false, rows: 40 })
+  Object.assign(stdin, { isTTY: false })
+  Object.assign(stderr, { isTTY: false })
+
+  let captured = ''
+  stdout.on('data', chunk => {
+    captured += chunk.toString()
+  })
+
+  return { capture: () => captured, stderr, stdin, stdout }
+}
+
+const mcp = (over: Partial<McpServerStatus> & Pick<McpServerStatus, 'name'>): McpServerStatus => ({
+  connected: false,
+  tools: 0,
+  transport: 'http',
+  ...over
+})
+
+const baseInfo = (mcp_servers: McpServerStatus[]): SessionInfo => ({
+  mcp_servers,
+  model: 'test-model',
+  skills: { core: ['a', 'b'] },
+  tools: { file: ['read_file', 'write_file'] }
+})
+
+async function renderFooter(info: SessionInfo): Promise<string> {
+  const streams = makeStreams()
+
+  const instance = renderSync(React.createElement(SessionPanel, { info, sid: 'test', t: DEFAULT_THEME }), {
+    patchConsole: false,
+    stderr: streams.stderr as NodeJS.WriteStream,
+    stdin: streams.stdin as NodeJS.ReadStream,
+    stdout: streams.stdout as NodeJS.WriteStream
+  })
+
+  try {
+    await delay(20)
+
+    // Strip ANSI so we can assert on the rendered text content.
+    // eslint-disable-next-line no-control-regex
+    return streams.capture().replace(/\u001b\[[0-9;]*m/g, '')
+  } finally {
+    instance.unmount()
+    instance.cleanup()
+  }
+}
+
+describe('branding MCP headline count', () => {
+  it('counts only connected servers, not configured-but-disabled ones', async () => {
+    const frame = await renderFooter(
+      baseInfo([
+        mcp({ connected: true, name: 'nous-support', status: 'connected', tools: 6 }),
+        mcp({ connected: false, disabled: true, name: 'linear', status: 'disabled' })
+      ])
+    )
+
+    // One connected server → "1 MCP", never "2 MCP".
+    expect(frame).toContain('1 MCP')
+    expect(frame).not.toContain('2 MCP')
+  })
+
+  it('drops the MCP segment entirely when no server is connected', async () => {
+    const frame = await renderFooter(
+      baseInfo([mcp({ connected: false, disabled: true, name: 'linear', status: 'disabled' })])
+    )
+
+    // Matches the classic CLI, which only appends "· N MCP" when N > 0.
+    expect(frame).not.toContain('MCP servers')
+    expect(frame).not.toMatch(/\d MCP\b/)
+  })
+
+  it('counts every connected server when several are connected', async () => {
+    const frame = await renderFooter(
+      baseInfo([
+        mcp({ connected: true, name: 'alpha', status: 'connected' }),
+        mcp({ connected: true, name: 'beta', status: 'connected' }),
+        mcp({ connected: false, disabled: true, name: 'gamma', status: 'disabled' })
+      ])
+    )
+
+    expect(frame).toContain('2 MCP')
+    expect(frame).not.toContain('3 MCP')
+  })
+})

package/agent/ui-tui/src/__tests__/completionApply.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest'
+
+import { applyCompletion, completionToApplyOnSubmit } from '../domain/slash.js'
+
+describe('applyCompletion', () => {
+  it('replaces from compReplace and drops the leading slash from the row', () => {
+    // The gateway's slash completer returns bare command names with
+    // replace_from = 1 (after the leading "/").
+    expect(applyCompletion('/ex', 'exit', 1)).toBe('/exit')
+  })
+
+  it('keeps the leading slash when the row carries one and input does not', () => {
+    expect(applyCompletion('ex', '/exit', 0)).toBe('/exit')
+  })
+
+  it('replaces an argument token after a space (subcommand completion)', () => {
+    expect(applyCompletion('/cron ad', 'add', 6)).toBe('/cron add')
+  })
+})
+
+describe('completionToApplyOnSubmit', () => {
+  it('accepts a completion that finishes a partial command name', () => {
+    // "/ex" -> "/exit": a real token change, so Enter accepts it.
+    expect(completionToApplyOnSubmit('/ex', 'exit', 1)).toBe('/exit')
+  })
+
+  it('does NOT swallow Enter when the completion only adds a trailing space', () => {
+    // This is the bug: once "/exit" is fully typed, the gateway returns the
+    // command with a trailing space ("exit ") so the classic-CLI dropdown
+    // stays open. In the TUI that must NOT eat the Enter — the command is
+    // already complete, so Enter should submit.
+    expect(completionToApplyOnSubmit('/exit', 'exit ', 1)).toBeNull()
+  })
+
+  it('does not swallow Enter when applying the row is a no-op', () => {
+    expect(completionToApplyOnSubmit('/exit', 'exit', 1)).toBeNull()
+  })
+
+  it('still accepts a real argument completion (no trailing-space false positive)', () => {
+    expect(completionToApplyOnSubmit('/cron ad', 'add', 6)).toBe('/cron add')
+  })
+
+  it('submits (no accept) once an argument is fully typed and only a space is added', () => {
+    expect(completionToApplyOnSubmit('/cron add', 'add ', 6)).toBeNull()
+  })
+
+  it('returns null when there is no row text', () => {
+    expect(completionToApplyOnSubmit('/exit', undefined, 1)).toBeNull()
+    expect(completionToApplyOnSubmit('/exit', '', 1)).toBeNull()
+  })
+})