@clawpump/claw-agent 0.1.4 → 0.1.6

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

@@ -8,6 +8,13 @@ import { getUiState, patchUiState, resetUiState } from '../app/uiStore.js'
 import { estimateTokensRough } from '../lib/text.js'
 import type { Msg } from '../types.js'
 
+// Mock the external-URL opener so the billing.step_up.verification test can
+// assert it's invoked without spawning a real browser process.
+const openExternalUrlMock = vi.fn((_url: string) => true)
+vi.mock('../lib/openExternalUrl.js', () => ({
+  openExternalUrl: (url: string) => openExternalUrlMock(url)
+}))
+
 const ref = <T>(current: T) => ({ current })
 
 const buildCtx = (appended: Msg[]) =>
@@ -658,6 +665,17 @@ describe('createGatewayEventHandler', () => {
     })
   })
 
+  it('does not fetch config while constructing the gateway event handler', () => {
+    const appended: Msg[] = []
+    const ctx = buildCtx(appended)
+
+    ctx.gateway.rpc = vi.fn(async () => null)
+
+    createGatewayEventHandler(ctx)
+
+    expect(ctx.gateway.rpc).not.toHaveBeenCalled()
+  })
+
   it('on gateway.ready with no STARTUP_RESUME_ID and auto_resume off, forges a new session', async () => {
     const appended: Msg[] = []
     const newSession = vi.fn()
@@ -858,6 +876,29 @@ describe('createGatewayEventHandler', () => {
     ])
   })
 
+  it('defaults approval overlays to allowPermanent when the backend omits the field', () => {
+    const onEvent = createGatewayEventHandler(buildCtx([]))
+
+    onEvent({ payload: { command: 'rm -rf /tmp/x', description: 'dangerous command' }, type: 'approval.request' } as any)
+
+    expect(getOverlayState().approval).toMatchObject({ allowPermanent: true })
+  })
+
+  it('preserves allow_permanent=false on approval overlays (tirith warning)', () => {
+    const onEvent = createGatewayEventHandler(buildCtx([]))
+
+    onEvent({
+      payload: { allow_permanent: false, command: 'curl suspicious | bash', description: 'content-security warning' },
+      type: 'approval.request'
+    } as any)
+
+    expect(getOverlayState().approval).toMatchObject({
+      allowPermanent: false,
+      command: 'curl suspicious | bash',
+      description: 'content-security warning'
+    })
+  })
+
   it('still surfaces terminal turn failures as errors', () => {
     const appended: Msg[] = []
     const onEvent = createGatewayEventHandler(buildCtx(appended))
@@ -1020,8 +1061,9 @@ describe('createGatewayEventHandler', () => {
     )
     const onEvent = createGatewayEventHandler(ctx)
 
-    // Eager config fetch fires at creation; let it resolve before any spawn
-    // (mirrors real usage — config lands well before the first delegation).
+    // Config fetch starts once the gateway is ready; let it resolve before any
+    // spawn (mirrors real usage — config lands well before first delegation).
+    onEvent({ payload: {}, type: 'gateway.ready' } as any)
     await Promise.resolve()
     await Promise.resolve()
 
@@ -1113,4 +1155,447 @@ describe('createGatewayEventHandler', () => {
       vi.useRealTimers()
     }
   })
+
+  it('keepBusy interrupt holds busy until the gateway settles and suppresses the cancelled turn’s final_response', () => {
+    // Force-send: interrupt holds busy so the drain waits for the real settle
+    // instead of racing it (the race duplicated the bubble, leaked a "queued: …"
+    // note, and surfaced the cancelled turn's "Operation interrupted…" reply).
+    const appended: Msg[] = []
+    const ctx = buildCtx(appended)
+    ctx.gateway.gw.request = vi.fn(async () => ({ status: 'interrupted' }))
+    const onEvent = createGatewayEventHandler(ctx)
+
+    patchUiState({ sid: 'sess-1' })
+    onEvent({ payload: {}, type: 'message.start' } as any)
+    onEvent({ payload: { text: 'thinking…' }, type: 'reasoning.delta' } as any)
+    expect(getUiState().busy).toBe(true)
+
+    turnController.interruptTurn(
+      { appendMessage: (msg: Msg) => appended.push(msg), gw: ctx.gateway.gw, sid: 'sess-1', sys: ctx.system.sys },
+      { keepBusy: true }
+    )
+
+    // Held busy: the drain effect keys off busy→false, so it must not fire yet.
+    expect(getUiState().busy).toBe(true)
+
+    // The cancelled turn settles with a backend interrupted final_response.
+    const before = appended.length
+    onEvent({
+      payload: { text: 'Operation interrupted: waiting for model response (4.1s elapsed).' },
+      type: 'message.complete'
+    } as any)
+
+    // Settle flips busy false (the single drain edge) and the backend
+    // "Operation interrupted…" line is suppressed (not appended).
+    expect(getUiState().busy).toBe(false)
+    expect(appended.slice(before).some(m => typeof m.text === 'string' && m.text.includes('Operation interrupted'))).toBe(
+      false
+    )
+  })
+
+  it('persists an abandoned (timed-out) clarify into the transcript when the clarify tool completes', () => {
+    const appended: Msg[] = []
+    const onEvent = createGatewayEventHandler(buildCtx(appended))
+
+    // Backend clarify timed out: the overlay is still live (Python returned an
+    // empty answer), and the clarify tool's own tool.complete then fires.
+    patchOverlayState({
+      clarify: { choices: ['Scope A', 'Scope B'], question: 'How do you want to scope?', requestId: 'req-1' }
+    })
+
+    onEvent({ payload: { duration_s: 300, name: 'clarify', tool_id: 'clar-1' }, type: 'tool.complete' } as any)
+
+    const record = appended.find(msg => msg.role === 'system' && msg.text.startsWith('ask How do you want to scope?'))
+    expect(record).toBeDefined()
+    expect(record?.text).toContain('1. Scope A')
+    expect(record?.text).toContain('2. Scope B')
+    expect(record?.text).toContain('timed out — no selection')
+    // The live overlay is cleared so it doesn't double-render with the record.
+    expect(getOverlayState().clarify).toBeNull()
+  })
+
+  it('only persists an abandoned clarify once even if tool.complete fires twice', () => {
+    const appended: Msg[] = []
+    const onEvent = createGatewayEventHandler(buildCtx(appended))
+
+    patchOverlayState({
+      clarify: { choices: ['A'], question: 'Pick?', requestId: 'req-3' }
+    })
+
+    onEvent({ payload: { name: 'clarify', tool_id: 'clar-1' }, type: 'tool.complete' } as any)
+    // A duplicate clarify tool.complete must not re-persist the same prompt.
+    onEvent({ payload: { name: 'clarify', tool_id: 'clar-1' }, type: 'tool.complete' } as any)
+
+    const records = appended.filter(msg => msg.role === 'system' && msg.text.startsWith('ask Pick?'))
+    expect(records).toHaveLength(1)
+  })
+
+  it('does not flush the clarify overlay when a non-clarify tool completes', () => {
+    const appended: Msg[] = []
+    const onEvent = createGatewayEventHandler(buildCtx(appended))
+
+    // A clarify is live, but it's a *different* tool that just completed — the
+    // clarify itself is still pending, so we must not persist or clear it.
+    patchOverlayState({
+      clarify: { choices: ['A', 'B'], question: 'Pick?', requestId: 'req-4' }
+    })
+
+    onEvent({ payload: { name: 'search', tool_id: 'tool-1' }, type: 'tool.complete' } as any)
+
+    expect(appended.some(msg => msg.role === 'system' && msg.text.startsWith('ask '))).toBe(false)
+    expect(getOverlayState().clarify).not.toBeNull()
+  })
+
+  it('does not persist when an answered clarify already cleared the overlay before tool.complete', () => {
+    const appended: Msg[] = []
+    const onEvent = createGatewayEventHandler(buildCtx(appended))
+
+    // Answered path (answerClarify) clears the overlay before the agent's
+    // tool.complete arrives, so there's nothing live to persist.
+    onEvent({ payload: { duration_s: 4.2, name: 'clarify', tool_id: 'clar-1' }, type: 'tool.complete' } as any)
+
+    expect(appended.some(msg => msg.role === 'system' && msg.text.startsWith('ask '))).toBe(false)
+  })
+
+  // ── Credits notice (Strategy B) ──────────────────────────────────────
+  describe('credits notice', () => {
+    it('shows a notice immediately when idle (no turn in flight)', () => {
+      const onEvent = createGatewayEventHandler(buildCtx([]))
+
+      onEvent({
+        payload: { key: 'credits.depleted', kind: 'sticky', level: 'error', text: '✕ credits exhausted' },
+        type: 'notification.show'
+      } as any)
+
+      expect(getUiState().notice).toMatchObject({
+        key: 'credits.depleted',
+        kind: 'sticky',
+        level: 'error',
+        text: '✕ credits exhausted'
+      })
+    })
+
+    it('holds a notice arriving mid-turn (busy) and flushes it at message.complete', () => {
+      const onEvent = createGatewayEventHandler(buildCtx([]))
+
+      onEvent({ payload: {}, type: 'message.start' } as any)
+      expect(getUiState().busy).toBe(true)
+
+      onEvent({
+        payload: { key: 'credits.90', kind: 'sticky', level: 'warn', text: '⚠ 90% used' },
+        type: 'notification.show'
+      } as any)
+
+      // Mid-turn: busy wins, notice is held, not visible yet.
+      expect(getUiState().notice).toBeNull()
+
+      onEvent({ payload: { text: 'done' }, type: 'message.complete' } as any)
+
+      // Turn end flushes the held notice.
+      expect(getUiState().notice).toMatchObject({ key: 'credits.90', text: '⚠ 90% used' })
+    })
+
+    it('flushes a held notice at interruptTurn (turn-end via ctrl-c)', () => {
+      vi.useFakeTimers()
+
+      try {
+        const ctx = buildCtx([])
+        ctx.gateway.gw.request = vi.fn(async () => ({ status: 'interrupted' }))
+        const onEvent = createGatewayEventHandler(ctx)
+
+        patchUiState({ sid: 'sess-1' })
+        onEvent({ payload: {}, type: 'message.start' } as any)
+        onEvent({
+          payload: { key: 'credits.depleted', kind: 'sticky', level: 'error', text: '✕ out' },
+          type: 'notification.show'
+        } as any)
+        expect(getUiState().notice).toBeNull()
+
+        turnController.interruptTurn({
+          appendMessage: vi.fn(),
+          gw: ctx.gateway.gw,
+          sid: 'sess-1',
+          sys: ctx.system.sys
+        })
+
+        expect(getUiState().notice).toMatchObject({ key: 'credits.depleted', text: '✕ out' })
+      } finally {
+        vi.runAllTimers()
+        vi.useRealTimers()
+      }
+    })
+
+    it('flushes a held notice at recordError (turn-end via error)', () => {
+      const onEvent = createGatewayEventHandler(buildCtx([]))
+
+      onEvent({ payload: {}, type: 'message.start' } as any)
+      onEvent({
+        payload: { key: 'credits.90', kind: 'sticky', level: 'warn', text: '⚠ 90% used' },
+        type: 'notification.show'
+      } as any)
+      expect(getUiState().notice).toBeNull()
+
+      onEvent({ payload: { message: 'boom' }, type: 'error' } as any)
+
+      expect(getUiState().notice).toMatchObject({ key: 'credits.90', text: '⚠ 90% used' })
+    })
+
+    it('latest-wins: a second mid-turn notice replaces the first held one', () => {
+      const onEvent = createGatewayEventHandler(buildCtx([]))
+
+      onEvent({ payload: {}, type: 'message.start' } as any)
+      onEvent({
+        payload: { key: 'credits.90', kind: 'sticky', level: 'warn', text: '⚠ 90% used' },
+        type: 'notification.show'
+      } as any)
+      onEvent({
+        payload: { key: 'credits.depleted', kind: 'sticky', level: 'error', text: '✕ exhausted' },
+        type: 'notification.show'
+      } as any)
+
+      onEvent({ payload: { text: 'done' }, type: 'message.complete' } as any)
+
+      // Only the latest held notice surfaces.
+      expect(getUiState().notice).toMatchObject({ key: 'credits.depleted', text: '✕ exhausted' })
+    })
+
+    it('clears a visible notice only when the clear key matches (no-op otherwise)', () => {
+      const onEvent = createGatewayEventHandler(buildCtx([]))
+
+      onEvent({
+        payload: { key: 'credits.grant_spent', kind: 'sticky', level: 'warn', text: '⚠ grant spent' },
+        type: 'notification.show'
+      } as any)
+      expect(getUiState().notice).not.toBeNull()
+
+      // Stale/late clear for a DIFFERENT key must not wipe the newer notice.
+      onEvent({ payload: { key: 'credits.something_else' }, type: 'notification.clear' } as any)
+      expect(getUiState().notice).toMatchObject({ key: 'credits.grant_spent' })
+
+      // Matching key clears.
+      onEvent({ payload: { key: 'credits.grant_spent' }, type: 'notification.clear' } as any)
+      expect(getUiState().notice).toBeNull()
+    })
+
+    it('drops a held pending notice on a matching clear before it can surface', () => {
+      const onEvent = createGatewayEventHandler(buildCtx([]))
+
+      onEvent({ payload: {}, type: 'message.start' } as any)
+      onEvent({
+        payload: { key: 'credits.grant_spent', kind: 'sticky', level: 'warn', text: '⚠ grant spent' },
+        type: 'notification.show'
+      } as any)
+      // Clear arrives mid-turn before the held notice flushes.
+      onEvent({ payload: { key: 'credits.grant_spent' }, type: 'notification.clear' } as any)
+
+      onEvent({ payload: { text: 'done' }, type: 'message.complete' } as any)
+
+      // Nothing surfaces — the pending notice was dropped by the matching clear.
+      expect(getUiState().notice).toBeNull()
+    })
+
+    it('a ttl notice self-expires after ttl_ms when applied while idle', () => {
+      vi.useFakeTimers()
+
+      try {
+        const onEvent = createGatewayEventHandler(buildCtx([]))
+
+        onEvent({
+          payload: { key: 'credits.restored', kind: 'ttl', level: 'success', text: '✓ access restored', ttl_ms: 8000 },
+          type: 'notification.show'
+        } as any)
+        expect(getUiState().notice).toMatchObject({ key: 'credits.restored' })
+
+        vi.advanceTimersByTime(7999)
+        expect(getUiState().notice).not.toBeNull()
+
+        vi.advanceTimersByTime(2)
+        expect(getUiState().notice).toBeNull()
+      } finally {
+        vi.useRealTimers()
+      }
+    })
+
+    it('R3-C2: a ttl notice self-expires even when statusTimer is also armed (timer isolation)', () => {
+      // Regression guard for the whole reason `noticeTimer` is a separate
+      // timer from `statusTimer`. A concurrent `status.update` (goal path)
+      // arms `statusTimer` via restoreStatusAfter; if the two timers shared
+      // a slot, clearing statusTimer would cancel the TTL and the notice
+      // would never self-expire.
+      vi.useFakeTimers()
+
+      try {
+        const ctx = buildCtx([])
+        const onEvent = createGatewayEventHandler(ctx)
+
+        // 1. While idle, show a ttl notice → applies immediately, arms noticeTimer.
+        onEvent({
+          payload: { key: 'credits.restored', kind: 'ttl', level: 'success', text: '✓ restored', ttl_ms: 8000 },
+          type: 'notification.show'
+        } as any)
+        expect(getUiState().notice).toMatchObject({ key: 'credits.restored' })
+
+        // 2. A goal status.update arms turnController.statusTimer (via restoreStatusAfter).
+        onEvent({
+          payload: { kind: 'goal', text: '✓ Goal achieved: some reason' },
+          type: 'status.update'
+        } as any)
+        // statusTimer is now live; notice must still be visible.
+        expect(getUiState().notice).toMatchObject({ key: 'credits.restored' })
+
+        // 3. Advance past the TTL — the notice's own dedicated timer fires.
+        vi.advanceTimersByTime(8001)
+
+        // 4. Notice self-expired: statusTimer did NOT cancel noticeTimer.
+        expect(getUiState().notice).toBeNull()
+      } finally {
+        vi.runAllTimers()
+        vi.useRealTimers()
+      }
+    })
+
+    it('starts the ttl clock when the notice becomes VISIBLE (at turn end), not on arrival', () => {
+      vi.useFakeTimers()
+
+      try {
+        const onEvent = createGatewayEventHandler(buildCtx([]))
+
+        onEvent({ payload: {}, type: 'message.start' } as any)
+        onEvent({
+          payload: { key: 'credits.restored', kind: 'ttl', level: 'success', text: '✓ restored', ttl_ms: 8000 },
+          type: 'notification.show'
+        } as any)
+
+        // Long busy turn: the TTL must NOT have started while held.
+        vi.advanceTimersByTime(10_000)
+        expect(getUiState().notice).toBeNull()
+
+        onEvent({ payload: { text: 'done' }, type: 'message.complete' } as any)
+        expect(getUiState().notice).toMatchObject({ key: 'credits.restored' })
+
+        // Full 8s starts now (on apply), so it survives nearly that long.
+        vi.advanceTimersByTime(7999)
+        expect(getUiState().notice).not.toBeNull()
+        vi.advanceTimersByTime(2)
+        expect(getUiState().notice).toBeNull()
+      } finally {
+        vi.useRealTimers()
+      }
+    })
+
+    it('latest-wins cancels a prior ttl timer so it cannot wipe the newer notice', () => {
+      vi.useFakeTimers()
+
+      try {
+        const onEvent = createGatewayEventHandler(buildCtx([]))
+
+        onEvent({
+          payload: { id: 'a', key: 'credits.restored', kind: 'ttl', level: 'success', text: '✓ a', ttl_ms: 5000 },
+          type: 'notification.show'
+        } as any)
+
+        vi.advanceTimersByTime(4000)
+
+        // A newer sticky arrives before the first's TTL fires.
+        onEvent({
+          payload: { id: 'b', key: 'credits.depleted', kind: 'sticky', level: 'error', text: '✕ b' },
+          type: 'notification.show'
+        } as any)
+        expect(getUiState().notice).toMatchObject({ id: 'b' })
+
+        // The first notice's stale TTL must NOT clear the newer one.
+        vi.advanceTimersByTime(2000)
+        expect(getUiState().notice).toMatchObject({ id: 'b', text: '✕ b' })
+      } finally {
+        vi.useRealTimers()
+      }
+    })
+
+    it('sticky survives a turn: applied with no pending notice does not clear it', () => {
+      const onEvent = createGatewayEventHandler(buildCtx([]))
+
+      // A standing sticky notice from a prior turn.
+      onEvent({
+        payload: { key: 'credits.depleted', kind: 'sticky', level: 'error', text: '✕ exhausted' },
+        type: 'notification.show'
+      } as any)
+      expect(getUiState().notice).toMatchObject({ key: 'credits.depleted' })
+
+      // A new turn runs with NO new notice arriving.
+      onEvent({ payload: {}, type: 'message.start' } as any)
+      onEvent({ payload: { text: 'reply' }, type: 'message.complete' } as any)
+
+      // The standing sticky must REappear untouched at turn end.
+      expect(getUiState().notice).toMatchObject({ key: 'credits.depleted', text: '✕ exhausted' })
+    })
+
+    it('reset()/fullReset() clears pending + timer + visible notice (no cross-session leak)', () => {
+      vi.useFakeTimers()
+
+      try {
+        const onEvent = createGatewayEventHandler(buildCtx([]))
+
+        // Session A: a visible sticky + a held pending notice mid-turn.
+        onEvent({
+          payload: { key: 'credits.depleted', kind: 'sticky', level: 'error', text: '✕ A cut' },
+          type: 'notification.show'
+        } as any)
+        onEvent({ payload: {}, type: 'message.start' } as any)
+        onEvent({
+          payload: { key: 'credits.90', kind: 'sticky', level: 'warn', text: '⚠ A 90%' },
+          type: 'notification.show'
+        } as any)
+        expect(getUiState().notice).toMatchObject({ key: 'credits.depleted' })
+
+        // Session boundary.
+        turnController.fullReset()
+        expect(getUiState().notice).toBeNull()
+
+        // Session B: a turn ends with nothing held — A's notice must not bleed in.
+        onEvent({ payload: {}, type: 'message.start' } as any)
+        onEvent({ payload: { text: 'B reply' }, type: 'message.complete' } as any)
+        expect(getUiState().notice).toBeNull()
+      } finally {
+        vi.runAllTimers()
+        vi.useRealTimers()
+      }
+    })
+
+    it('ignores a notification.show with no text', () => {
+      const onEvent = createGatewayEventHandler(buildCtx([]))
+
+      onEvent({ payload: { key: 'credits.90', level: 'warn' }, type: 'notification.show' } as any)
+      expect(getUiState().notice).toBeNull()
+    })
+  })
+
+  describe('billing.step_up.verification', () => {
+    beforeEach(() => {
+      openExternalUrlMock.mockClear()
+    })
+
+    it('renders the verification link + code and opens the browser', () => {
+      const ctx = buildCtx([])
+      const onEvent = createGatewayEventHandler(ctx)
+
+      onEvent({
+        payload: { user_code: 'WXYZ-9999', verification_url: 'https://portal.example/device?code=WXYZ' },
+        type: 'billing.step_up.verification'
+      } as any)
+
+      const printed = (ctx.system.sys as ReturnType<typeof vi.fn>).mock.calls.map(c => c[0]).join('\n')
+      expect(printed).toContain('https://portal.example/device?code=WXYZ')
+      expect(printed).toContain('WXYZ-9999')
+      expect(openExternalUrlMock).toHaveBeenCalledWith('https://portal.example/device?code=WXYZ')
+    })
+
+    it('no-ops on a missing verification_url (never opens a browser)', () => {
+      const ctx = buildCtx([])
+      const onEvent = createGatewayEventHandler(ctx)
+
+      onEvent({ payload: { verification_url: '' }, type: 'billing.step_up.verification' } as any)
+
+      expect(openExternalUrlMock).not.toHaveBeenCalled()
+    })
+  })
 })

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

@@ -2,13 +2,30 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { createSlashHandler } from '../app/createSlashHandler.js'
 import { getOverlayState, resetOverlayState } from '../app/overlayStore.js'
+import { DASHBOARD_EXIT_DISABLED_MESSAGE, DASHBOARD_UPDATE_DISABLED_MESSAGE } from '../app/slash/commands/core.js'
 import { getUiState, patchUiState, resetUiState } from '../app/uiStore.js'
 import { TUI_SESSION_MODEL_FLAG } from '../domain/slash.js'
 
+// DASHBOARD_TUI_MODE resolves once at module load from HERMES_TUI_DASHBOARD,
+// so toggling process.env in a test body can't move it. Mock just that one
+// export (everything else stays real) and flip the holder per test.
+const envState = { dashboardTuiMode: false }
+vi.mock('../config/env.js', async importActual => {
+  const actual = await importActual<typeof import('../config/env.js')>()
+
+  return {
+    ...actual,
+    get DASHBOARD_TUI_MODE() {
+      return envState.dashboardTuiMode
+    }
+  }
+})
+
 describe('createSlashHandler', () => {
   beforeEach(() => {
     resetOverlayState()
     resetUiState()
+    envState.dashboardTuiMode = false
   })
 
   it('opens the unified sessions overlay for /resume', () => {
@@ -68,6 +85,24 @@ describe('createSlashHandler', () => {
     expect(ctx.gateway.gw.request).not.toHaveBeenCalled()
   })
 
+  it('keeps hosted dashboard chat alive for /exit', () => {
+    envState.dashboardTuiMode = true
+    const ctx = buildCtx()
+
+    expect(createSlashHandler(ctx)('/exit')).toBe(true)
+    expect(ctx.session.die).not.toHaveBeenCalled()
+    expect(ctx.gateway.gw.request).not.toHaveBeenCalled()
+    expect(ctx.transcript.sys).toHaveBeenCalledWith(DASHBOARD_EXIT_DISABLED_MESSAGE)
+  })
+
+  it('keeps /quit available outside hosted dashboard chat', () => {
+    envState.dashboardTuiMode = false
+    const ctx = buildCtx()
+
+    expect(createSlashHandler(ctx)('/quit')).toBe(true)
+    expect(ctx.session.die).toHaveBeenCalledTimes(1)
+  })
+
   it('handles /update locally and exits with code 42 via dieWithCode', () => {
     vi.useFakeTimers()
     const ctx = buildCtx()
@@ -83,6 +118,22 @@ describe('createSlashHandler', () => {
     vi.useRealTimers()
   })
 
+  it('refuses /update in hosted dashboard chat instead of killing the PTY', () => {
+    vi.useFakeTimers()
+    envState.dashboardTuiMode = true
+    const ctx = buildCtx()
+
+    expect(createSlashHandler(ctx)('/update')).toBe(true)
+    expect(ctx.session.dieWithCode).not.toHaveBeenCalled()
+    expect(ctx.gateway.gw.request).not.toHaveBeenCalled()
+    expect(ctx.transcript.sys).toHaveBeenCalledWith(DASHBOARD_UPDATE_DISABLED_MESSAGE)
+
+    vi.advanceTimersByTime(150)
+    expect(ctx.session.dieWithCode).not.toHaveBeenCalled()
+
+    vi.useRealTimers()
+  })
+
   it('routes /status to live session.status instead of slash worker', async () => {
     patchUiState({ sid: 'sid-abc' })
     const rpc = vi.fn(() => Promise.resolve({ output: 'Hermes TUI Status' }))
@@ -108,6 +159,7 @@ describe('createSlashHandler', () => {
 
     expect(createSlashHandler(ctx)('/model x-model')).toBe(true)
     expect(ctx.gateway.rpc).toHaveBeenCalledWith('config.set', {
+      confirm_expensive_model: false,
       key: 'model',
       session_id: 'sid-abc',
       value: 'x-model'
@@ -128,6 +180,7 @@ describe('createSlashHandler', () => {
       createSlashHandler(ctx)(`/model anthropic/claude-sonnet-4.6 --provider openrouter ${TUI_SESSION_MODEL_FLAG}`)
     ).toBe(true)
     expect(ctx.gateway.rpc).toHaveBeenCalledWith('config.set', {
+      confirm_expensive_model: false,
       key: 'model',
       session_id: 'sid-abc',
       value: 'anthropic/claude-sonnet-4.6 --provider openrouter'
@@ -140,6 +193,7 @@ describe('createSlashHandler', () => {
 
     createSlashHandler(ctx)('/model x-model --global')
     expect(ctx.gateway.rpc).toHaveBeenCalledWith('config.set', {
+      confirm_expensive_model: false,
       key: 'model',
       session_id: 'sid-abc',
       value: 'x-model --global'