@clawpump/claw-agent 0.1.5 → 0.1.6

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

@@ -0,0 +1,144 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { creditsCommands } from '../app/slash/commands/credits.js'
+import { getOverlayState, resetOverlayState } from '../app/overlayStore.js'
+import type { CreditsViewResponse } from '../gatewayTypes.js'
+
+// The command opens the top-up URL through this helper on confirm. Mock it so
+// the test never shells out to a real browser/`xdg-open` and we can assert the
+// success/failure messaging deterministically.
+vi.mock('../lib/openExternalUrl.js', () => ({
+  openExternalUrl: vi.fn(() => true)
+}))
+
+import { openExternalUrl } from '../lib/openExternalUrl.js'
+
+const openExternalUrlMock = vi.mocked(openExternalUrl)
+
+const creditsCommand = creditsCommands.find(cmd => cmd.name === 'credits')!
+
+const buildView = (overrides: Partial<CreditsViewResponse> = {}): CreditsViewResponse => ({
+  balance_lines: ['Grant: $9.50 left', 'Top-up: $25.00'],
+  depleted: false,
+  identity_line: 'Signed in as ada@example.com',
+  logged_in: true,
+  topup_url: 'https://portal.nousresearch.com/billing/topup',
+  ...overrides
+})
+
+// Mirror createSlashHandler's real `guarded` wrapper: skip the handler when the
+// command is stale OR the response is falsy. Tests stay non-stale, so this is a
+// straightforward "run the handler when we got a response" shim.
+const guarded =
+  <T,>(fn: (r: T) => void) =>
+  (r: null | T) => {
+    if (r) {
+      fn(r)
+    }
+  }
+
+const buildCtx = (rpcResult: CreditsViewResponse) => {
+  const sys = vi.fn()
+  const rpc = vi.fn(() => Promise.resolve(rpcResult))
+  const guardedErr = vi.fn()
+
+  const ctx = {
+    gateway: { rpc },
+    guarded,
+    guardedErr,
+    sid: 'sid-abc',
+    stale: () => false,
+    transcript: { page: vi.fn(), panel: vi.fn(), sys }
+  }
+
+  // Run the command, then await the rpc promise so the .then() handler has
+  // flushed before assertions — deterministic, no polling/timeouts.
+  const run = async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    creditsCommand.run('', ctx as any, 'credits')
+    await rpc.mock.results[0]?.value
+    // Allow the chained .then() microtask to settle.
+    await Promise.resolve()
+  }
+
+  return { ctx, rpc, run, sys }
+}
+
+describe('/credits slash command', () => {
+  beforeEach(() => {
+    resetOverlayState()
+    openExternalUrlMock.mockClear()
+    openExternalUrlMock.mockReturnValue(true)
+  })
+
+  it('renders the balance (including top-up URL) and arms the confirm overlay', async () => {
+    const view = buildView()
+    const { rpc, run, sys } = buildCtx(view)
+
+    await run()
+
+    expect(rpc).toHaveBeenCalledWith('credits.view', { session_id: 'sid-abc' })
+
+    // (a) sys received the balance text including the topup_url
+    const printed = sys.mock.calls.map(call => call[0]).join('\n')
+    expect(printed).toContain('💳 Nous credits')
+    expect(printed).toContain('Grant: $9.50 left')
+    expect(printed).toContain('Signed in as ada@example.com')
+    expect(printed).toContain(view.topup_url)
+
+    // (b) confirm overlay set with the expected label + detail
+    const confirm = getOverlayState().confirm
+    expect(confirm).toBeTruthy()
+    expect(confirm?.confirmLabel).toBe('Open top-up in browser')
+    expect(confirm?.cancelLabel).toBe('Cancel')
+    expect(confirm?.title).toBe('Add credits?')
+    expect(confirm?.detail).toBe(view.topup_url)
+
+    // onConfirm opens the URL and reports success back to the transcript
+    confirm?.onConfirm()
+    expect(openExternalUrlMock).toHaveBeenCalledWith(view.topup_url)
+    expect(sys).toHaveBeenCalledWith(
+      'Complete your top-up in the browser — credits will appear in /credits shortly.'
+    )
+  })
+
+  it('falls back to printing the URL when the browser open is rejected', async () => {
+    openExternalUrlMock.mockReturnValue(false)
+    const view = buildView()
+    const { run, sys } = buildCtx(view)
+
+    await run()
+
+    const confirm = getOverlayState().confirm
+    expect(confirm).toBeTruthy()
+    confirm?.onConfirm()
+    expect(sys).toHaveBeenCalledWith(`Open this URL to top up: ${view.topup_url}`)
+  })
+
+  it('does not arm the confirm overlay when there is no top-up URL', async () => {
+    const view = buildView({ topup_url: null })
+    const { run, sys } = buildCtx(view)
+
+    await run()
+
+    const printed = sys.mock.calls.map(call => call[0]).join('\n')
+    expect(printed).toContain('💳 Nous credits')
+    expect(getOverlayState().confirm).toBeNull()
+  })
+
+  it('shows the not-logged-in message and does NOT arm the confirm overlay', async () => {
+    const view = buildView({
+      balance_lines: [],
+      identity_line: null,
+      logged_in: false,
+      topup_url: null
+    })
+    const { run, sys } = buildCtx(view)
+
+    await run()
+
+    expect(sys).toHaveBeenCalledWith('💳 Not logged into Nous Portal — run /portal to log in.')
+    expect(getOverlayState().confirm).toBeNull()
+    expect(openExternalUrlMock).not.toHaveBeenCalled()
+  })
+})

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

@@ -1,97 +1,103 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { GatewayClient } from '../gatewayClient.js'
-
 interface ListenerEntry {
   callback: (event: any) => void
   once: boolean
 }
 
-class FakeWebSocket {
-  static CONNECTING = 0
-  static OPEN = 1
-  static CLOSING = 2
-  static CLOSED = 3
-  static instances: FakeWebSocket[] = []
-
-  readyState = FakeWebSocket.CONNECTING
-  sent: string[] = []
-  readonly url: string
-  private listeners = new Map<string, ListenerEntry[]>()
-
-  constructor(url: string) {
-    this.url = url
-    FakeWebSocket.instances.push(this)
-  }
+const { FakeWebSocket } = vi.hoisted(() => {
+  class FakeWebSocket {
+    static CONNECTING = 0
+    static OPEN = 1
+    static CLOSING = 2
+    static CLOSED = 3
+    static instances: FakeWebSocket[] = []
+
+    readyState = FakeWebSocket.CONNECTING
+    sent: string[] = []
+    readonly url: string
+    private listeners = new Map<string, ListenerEntry[]>()
+
+    constructor(url: string) {
+      this.url = url
+      FakeWebSocket.instances.push(this)
+    }
 
-  static reset() {
-    FakeWebSocket.instances = []
-  }
+    static reset() {
+      FakeWebSocket.instances = []
+    }
 
-  addEventListener(type: string, callback: (event: any) => void, options?: unknown) {
-    const once =
-      typeof options === 'object' &&
-      options !== null &&
-      'once' in options &&
-      Boolean((options as { once?: unknown }).once)
+    addEventListener(type: string, callback: (event: any) => void, options?: unknown) {
+      const once =
+        typeof options === 'object' &&
+        options !== null &&
+        'once' in options &&
+        Boolean((options as { once?: unknown }).once)
 
-    const entries = this.listeners.get(type) ?? []
+      const entries = this.listeners.get(type) ?? []
 
-    entries.push({ callback, once })
-    this.listeners.set(type, entries)
-  }
+      entries.push({ callback, once })
+      this.listeners.set(type, entries)
+    }
 
-  removeEventListener(type: string, callback: (event: any) => void) {
-    const entries = this.listeners.get(type)
+    removeEventListener(type: string, callback: (event: any) => void) {
+      const entries = this.listeners.get(type)
+
+      if (!entries) {
+        return
+      }
 
-    if (!entries) {
-      return
+      this.listeners.set(
+        type,
+        entries.filter(entry => entry.callback !== callback)
+      )
     }
 
-    this.listeners.set(
-      type,
-      entries.filter(entry => entry.callback !== callback)
-    )
-  }
+    send(payload: string) {
+      if (this.readyState !== FakeWebSocket.OPEN) {
+        throw new Error('socket not open')
+      }
 
-  send(payload: string) {
-    if (this.readyState !== FakeWebSocket.OPEN) {
-      throw new Error('socket not open')
+      this.sent.push(payload)
     }
 
-    this.sent.push(payload)
-  }
+    close(code = 1000) {
+      if (this.readyState === FakeWebSocket.CLOSED) {
+        return
+      }
 
-  close(code = 1000) {
-    if (this.readyState === FakeWebSocket.CLOSED) {
-      return
+      this.readyState = FakeWebSocket.CLOSED
+      this.emit('close', { code })
     }
 
-    this.readyState = FakeWebSocket.CLOSED
-    this.emit('close', { code })
-  }
-
-  open() {
-    this.readyState = FakeWebSocket.OPEN
-    this.emit('open', {})
-  }
+    open() {
+      this.readyState = FakeWebSocket.OPEN
+      this.emit('open', {})
+    }
 
-  message(data: string) {
-    this.emit('message', { data })
-  }
+    message(data: string) {
+      this.emit('message', { data })
+    }
 
-  private emit(type: string, event: any) {
-    const entries = [...(this.listeners.get(type) ?? [])]
+    private emit(type: string, event: any) {
+      const entries = [...(this.listeners.get(type) ?? [])]
 
-    for (const entry of entries) {
-      entry.callback(event)
+      for (const entry of entries) {
+        entry.callback(event)
 
-      if (entry.once) {
-        this.removeEventListener(type, entry.callback)
+        if (entry.once) {
+          this.removeEventListener(type, entry.callback)
+        }
       }
     }
   }
-}
+
+  return { FakeWebSocket }
+})
+
+vi.mock('undici', () => ({ WebSocket: FakeWebSocket }))
+
+import { GatewayClient } from '../gatewayClient.js'
 
 describe('GatewayClient websocket attach mode', () => {
   const originalWebSocket = globalThis.WebSocket
@@ -181,6 +187,46 @@ describe('GatewayClient websocket attach mode', () => {
     gw.kill()
   })
 
+  it('publishes local dashboard-control events to the sidecar websocket', async () => {
+    process.env.HERMES_TUI_GATEWAY_URL = 'ws://gateway.test/api/ws?token=abc'
+    process.env.HERMES_TUI_SIDECAR_URL = 'ws://gateway.test/api/pub?token=abc&channel=demo'
+
+    const gw = new GatewayClient()
+    const seen: string[] = []
+
+    gw.on('event', ev => seen.push(ev.type))
+    gw.start()
+
+    const gatewaySocket = FakeWebSocket.instances[0]!
+
+    gatewaySocket.open()
+    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(2))
+
+    const sidecarSocket = FakeWebSocket.instances[1]!
+
+    sidecarSocket.open()
+    gw.drain()
+
+    gw.publishLocalEvent({
+      payload: { reason: 'idle_exit_hotkey' },
+      session_id: 'sid-old',
+      type: 'dashboard.new_session_requested'
+    })
+
+    expect(seen).toContain('dashboard.new_session_requested')
+    expect(JSON.parse(sidecarSocket.sent.at(-1) ?? '{}')).toEqual({
+      jsonrpc: '2.0',
+      method: 'event',
+      params: {
+        payload: { reason: 'idle_exit_hotkey' },
+        session_id: 'sid-old',
+        type: 'dashboard.new_session_requested'
+      }
+    })
+
+    gw.kill()
+  })
+
   it('emits exit when attached websocket closes', () => {
     process.env.HERMES_TUI_GATEWAY_URL = 'ws://gateway.test/api/ws?token=abc'
     const gw = new GatewayClient()
@@ -269,30 +315,15 @@ describe('GatewayClient websocket attach mode', () => {
     gw.kill()
   })
 
-  it('redacts query string secrets in attach failure logs and events', () => {
+  it('uses the undici WebSocket fallback when global WebSocket is unavailable', () => {
     process.env.HERMES_TUI_GATEWAY_URL = 'ws://gateway.test/api/ws?token=hunter2&channel=secret'
     delete (globalThis as { WebSocket?: unknown }).WebSocket
 
     const gw = new GatewayClient()
-    const stderrLines: string[] = []
 
-    gw.on('event', ev => {
-      if (ev.type === 'gateway.stderr' && typeof ev.payload?.line === 'string') {
-        stderrLines.push(ev.payload.line)
-      }
-    })
     gw.start()
-    gw.drain()
-
-    expect(stderrLines.length).toBeGreaterThan(0)
-
-    for (const line of stderrLines) {
-      expect(line).not.toContain('hunter2')
-      expect(line).not.toContain('channel=secret')
-    }
-
-    expect(gw.getLogTail(20)).not.toContain('hunter2')
-    expect(gw.getLogTail(20)).not.toContain('channel=secret')
+    expect(FakeWebSocket.instances).toHaveLength(1)
+    expect(FakeWebSocket.instances[0]?.url).toBe('ws://gateway.test/api/ws?token=hunter2&channel=secret')
 
     gw.kill()
   })
@@ -363,27 +394,17 @@ describe('GatewayClient websocket attach mode', () => {
     expect(() => new URL(fixture)).toThrow()
 
     process.env.HERMES_TUI_GATEWAY_URL = fixture
-    delete (globalThis as { WebSocket?: unknown }).WebSocket
+    ;(globalThis as { WebSocket?: unknown }).WebSocket = class ThrowingWebSocket extends FakeWebSocket {
+      constructor(url: string) {
+        throw new TypeError(`Invalid URL: ${url}`)
+      }
+    } as unknown as typeof WebSocket
 
     const gw = new GatewayClient()
-    const stderrLines: string[] = []
 
-    gw.on('event', ev => {
-      if (ev.type === 'gateway.stderr' && typeof ev.payload?.line === 'string') {
-        stderrLines.push(ev.payload.line)
-      }
-    })
     gw.start()
     gw.drain()
 
-    expect(stderrLines.length).toBeGreaterThan(0)
-
-    for (const line of stderrLines) {
-      expect(line).not.toContain('alice')
-      expect(line).not.toContain('hunter2')
-      expect(line).not.toContain('token=secret')
-    }
-
     const tail = gw.getLogTail(20)
     expect(tail).not.toContain('alice')
     expect(tail).not.toContain('hunter2')

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

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest'
+
+import { shouldExitForSignal } from '../lib/gracefulExit.js'
+
+describe('shouldExitForSignal', () => {
+  it('ignores only the signals explicitly disabled for embedded dashboard chat', () => {
+    expect(shouldExitForSignal('SIGINT', ['SIGINT'])).toBe(false)
+    expect(shouldExitForSignal('SIGTERM', ['SIGINT'])).toBe(true)
+    expect(shouldExitForSignal('SIGHUP', ['SIGINT'])).toBe(true)
+  })
+})

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

@@ -0,0 +1,102 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// memory.js performs real heap dumps / fs work — stub it so the monitor's
+// dump path is a no-op in tests.
+vi.mock('../lib/memory.js', () => ({
+  performHeapDump: vi.fn(async () => null)
+}))
+
+// @hermes/ink is dynamically imported only on the dump path; stub the eviction.
+vi.mock('@hermes/ink', () => ({ evictInkCaches: vi.fn() }))
+
+import { startMemoryMonitor } from '../lib/memoryMonitor.js'
+
+const GB = 1024 ** 3
+const MB = 1024 ** 2
+
+describe('startMemoryMonitor thresholds (#34095)', () => {
+  let stop: (() => void) | undefined
+
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    stop?.()
+    stop = undefined
+    vi.restoreAllMocks()
+    vi.useRealTimers()
+  })
+
+  const withHeap = (heapUsed: number, rss = heapUsed) =>
+    vi.spyOn(process, 'memoryUsage').mockReturnValue({
+      arrayBuffers: 0,
+      external: 0,
+      heapTotal: heapUsed,
+      heapUsed,
+      rss
+    } as NodeJS.MemoryUsage)
+
+  it('does NOT fire onCritical at 2.5GB when the heap ceiling is 8GB', async () => {
+    // The old hardcoded 2.5GB constant killed the process at ~31% of the real
+    // ceiling. With relative thresholds (~88%), 2.5GB is well within normal.
+    const onCritical = vi.fn()
+    withHeap(2.5 * GB)
+    stop = startMemoryMonitor({ criticalBytes: 7 * GB, highBytes: 5 * GB, intervalMs: 1, onCritical })
+
+    await vi.advanceTimersByTimeAsync(5)
+
+    expect(onCritical).not.toHaveBeenCalled()
+  })
+
+  it('fires onCritical only near the configured ceiling', async () => {
+    const onCritical = vi.fn()
+    // Explicit small ceiling-derived thresholds via override to keep the test
+    // independent of the host V8 heap_size_limit.
+    withHeap(7.5 * GB)
+    stop = startMemoryMonitor({ criticalBytes: 7 * GB, highBytes: 5 * GB, intervalMs: 1, onCritical })
+
+    await vi.advanceTimersByTimeAsync(5)
+
+    expect(onCritical).toHaveBeenCalledTimes(1)
+  })
+
+  it('fires onWarn once on fast sub-threshold heap growth, then re-arms', async () => {
+    const onWarn = vi.fn()
+    // Start low, then jump >150MB across a tick while above the 600MB floor and
+    // below `high` — the silent-death regime.
+    const spy = withHeap(100 * MB)
+    stop = startMemoryMonitor({ highBytes: 2 * GB, intervalMs: 1, onWarn, warnBytes: 600 * MB })
+
+    await vi.advanceTimersByTimeAsync(2) // seed lastHeap at 100MB, below floor
+    expect(onWarn).not.toHaveBeenCalled()
+
+    spy.mockReturnValue({ arrayBuffers: 0, external: 0, heapTotal: 800 * MB, heapUsed: 800 * MB, rss: 800 * MB } as NodeJS.MemoryUsage)
+    await vi.advanceTimersByTimeAsync(2) // jumped 700MB → above floor + steep
+    expect(onWarn).toHaveBeenCalledTimes(1)
+
+    // Stays elevated but not re-firing.
+    await vi.advanceTimersByTimeAsync(2)
+    expect(onWarn).toHaveBeenCalledTimes(1)
+
+    // Falls back below the floor → re-armed, then climbs again → fires again.
+    spy.mockReturnValue({ arrayBuffers: 0, external: 0, heapTotal: 100 * MB, heapUsed: 100 * MB, rss: 100 * MB } as NodeJS.MemoryUsage)
+    await vi.advanceTimersByTimeAsync(2)
+    spy.mockReturnValue({ arrayBuffers: 0, external: 0, heapTotal: 800 * MB, heapUsed: 800 * MB, rss: 800 * MB } as NodeJS.MemoryUsage)
+    await vi.advanceTimersByTimeAsync(2)
+    expect(onWarn).toHaveBeenCalledTimes(2)
+  })
+
+  it('does not warn on slow growth below the steep-growth step', async () => {
+    const onWarn = vi.fn()
+    const spy = withHeap(650 * MB)
+    stop = startMemoryMonitor({ highBytes: 2 * GB, intervalMs: 1, onWarn, warnBytes: 600 * MB })
+
+    await vi.advanceTimersByTimeAsync(2)
+    // +50MB per tick — above the floor but gentle, not a render-tree blowup.
+    spy.mockReturnValue({ arrayBuffers: 0, external: 0, heapTotal: 700 * MB, heapUsed: 700 * MB, rss: 700 * MB } as NodeJS.MemoryUsage)
+    await vi.advanceTimersByTimeAsync(2)
+
+    expect(onWarn).not.toHaveBeenCalled()
+  })
+})

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

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 
-import { fmtCwdBranch, shortCwd } from '../domain/paths.js'
+import { composeTabTitle, fmtCwdBranch, shortCwd } from '../domain/paths.js'
 
 describe('shortCwd', () => {
   const origHome = process.env.HOME
@@ -68,3 +68,43 @@ describe('fmtCwdBranch', () => {
     expect(out).toContain(')')
   })
 })
+
+describe('composeTabTitle', () => {
+  it('joins marker, name, model, and cwd in order', () => {
+    expect(composeTabTitle('✓', 'auth refactor', 'opus-4', '~/proj')).toBe('✓ auth refactor · opus-4 · ~/proj')
+  })
+
+  it('glues the marker to the first segment with a space, not a separator', () => {
+    expect(composeTabTitle('⏳', 'my session', 'opus-4', '~/proj').startsWith('⏳ my session')).toBe(true)
+  })
+
+  it('omits the session name when empty (matches the pre-name format)', () => {
+    expect(composeTabTitle('✓', '', 'opus-4', '~/proj')).toBe('✓ opus-4 · ~/proj')
+  })
+
+  it('treats a whitespace-only name as absent', () => {
+    expect(composeTabTitle('✓', '   ', 'opus-4', '~/proj')).toBe('✓ opus-4 · ~/proj')
+  })
+
+  it('omits the cwd when empty', () => {
+    expect(composeTabTitle('✓', 'my session', 'opus-4', '')).toBe('✓ my session · opus-4')
+  })
+
+  it('falls back to just the marker when only the marker is present', () => {
+    expect(composeTabTitle('✓', '', '', '')).toBe('✓')
+  })
+
+  it('truncates an over-long session name with an ellipsis', () => {
+    const long = 'a'.repeat(40)
+    const out = composeTabTitle('✓', long, 'opus-4', '', 28)
+    const namePart = out.slice('✓ '.length).split(' · ')[0]
+    expect(namePart.endsWith('…')).toBe(true)
+    expect(namePart.length).toBe(28)
+  })
+
+  it('keeps a name at the boundary length intact', () => {
+    const name = 'b'.repeat(28)
+    const out = composeTabTitle('✓', name, 'opus-4', '', 28)
+    expect(out).toBe(`✓ ${name} · opus-4`)
+  })
+})

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

@@ -36,4 +36,26 @@ describe('terminal mode reset', () => {
     expect(resetTerminalModes({ isTTY: false, write } as unknown as NodeJS.WriteStream)).toBe(false)
     expect(write).not.toHaveBeenCalled()
   })
+
+  // entry.tsx installs `process.on('exit', () => resetTerminalModes())` as the
+  // final backstop (#28419): /quit, Ctrl+C, Ctrl+D and any process.exit() path
+  // must disarm DEC mouse tracking so the parent shell / next TUI doesn't read
+  // leaked mouse reports as keystrokes. 'exit' handlers run synchronously only,
+  // so the reset must complete via a single synchronous write — verify that an
+  // exit-style invocation disables every SGR mouse mode that produced the
+  // reported `…;…M` garbage.
+  it('disarms mouse tracking from a synchronous exit-style handler', () => {
+    const write = vi.fn()
+    const stream = { isTTY: true, write } as unknown as NodeJS.WriteStream
+
+    // Mirror entry.tsx's process.on('exit') callback.
+    const onExit = () => resetTerminalModes(stream)
+    onExit()
+
+    expect(write).toHaveBeenCalledTimes(1)
+    const written = write.mock.calls[0]?.[0] as string
+    for (const mode of ['\x1b[?1006l', '\x1b[?1003l', '\x1b[?1002l', '\x1b[?1000l']) {
+      expect(written).toContain(mode)
+    }
+  })
 })

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

@@ -69,6 +69,29 @@ describe('buildVerboseToolTrailLine', () => {
       mark: '✗'
     })
   })
+
+  it('caps a large result to a small persisted preview (#34095)', () => {
+    // A 40KB browser-snapshot-sized result must NOT be embedded whole — the
+    // persisted, expanded-by-default trail block is what blew up the Ink
+    // render tree and silently OOM-killed the TUI. The block stays small.
+    const huge = 'A'.repeat(40_000)
+    const line = buildVerboseToolTrailLine('browser_snapshot', 'https://x.example', false, 2, undefined, huge)
+
+    expect(line).toContain('Result:\n')
+    // Far below the old 16KB live-render budget; the whole line (call + label +
+    // omitted marker + preview) must stay on the order of ~1KB, not ~40KB.
+    expect(line.length).toBeLessThan(2_000)
+    expect(line).toContain('omitted')
+    expect(line.endsWith(' ✓')).toBe(true)
+  })
+
+  it('does not truncate a result that already fits the preview budget', () => {
+    const small = 'ok: 3 files changed'
+    const line = buildVerboseToolTrailLine('patch', 'index.html', false, 0.1, undefined, small)
+
+    expect(line).toContain(`Result:\n${small}`)
+    expect(line).not.toContain('omitted')
+  })
 })
 
 describe('lastCotTrailIndex', () => {