@robota-sdk/agent-ui-terminal 3.0.0-beta.81

package/src/__tests__/TuiInteractionChannel.lifecycle.test.ts

@@ -0,0 +1,642 @@
+/**
+ * Integration tests for TuiInteractionChannel lifecycle:
+ * session event wiring, handleInput roundtrip, onChange propagation.
+ *
+ * No Ink rendering, no PTY — pure TypeScript.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+vi.mock('@robota-sdk/agent-framework', async () => {
+  const actual = await vi.importActual<typeof import('@robota-sdk/agent-framework')>(
+    '@robota-sdk/agent-framework',
+  );
+  // RUNTIME-001: construction now flows through `buildRuntimeSession` (which wraps InteractiveSession inside
+  // agent-framework), so mocking `InteractiveSession` alone no longer intercepts it — mock both with one factory.
+  const makeMockSession = (): unknown => {
+    {
+      const handlers = new Map<string, Array<(...args: unknown[]) => void>>();
+      return {
+        getFullHistory: vi.fn().mockReturnValue([]),
+        setName: vi.fn(),
+        getName: vi.fn().mockReturnValue(undefined),
+        getPermissionMode: vi.fn().mockReturnValue('default'),
+        isInitialized: false,
+        on: vi.fn().mockImplementation((event: string, handler: (...args: unknown[]) => void) => {
+          if (!handlers.has(event)) handlers.set(event, []);
+          handlers.get(event)!.push(handler);
+        }),
+        off: vi.fn().mockImplementation((event: string, handler: (...args: unknown[]) => void) => {
+          const arr = handlers.get(event);
+          if (!arr) return;
+          const i = arr.indexOf(handler);
+          if (i !== -1) arr.splice(i, 1);
+        }),
+        emit: (event: string, ...args: unknown[]) => {
+          (handlers.get(event) ?? []).forEach((h) => h(...args));
+        },
+        _listenerCount: (): number =>
+          [...handlers.values()].reduce((total, arr) => total + arr.length, 0),
+        submit: vi.fn().mockResolvedValue(undefined),
+        executeCommand: vi.fn().mockResolvedValue(null),
+        getPendingPrompt: vi.fn().mockReturnValue(null),
+        abort: vi.fn(),
+        cancelQueue: vi.fn(),
+        resolvePermission: vi.fn(),
+        resolveAsk: vi.fn(),
+        getContextState: vi.fn().mockReturnValue({
+          usedPercentage: 0,
+          usedTokens: 0,
+          maxTokens: 100_000,
+        }),
+        getExecutionWorkspaceSnapshot: vi.fn().mockReturnValue({ entries: [] }),
+        shutdown: vi.fn().mockResolvedValue(undefined),
+        sendAgentJob: vi.fn().mockResolvedValue(undefined),
+        readExecutionWorkspaceDetail: vi.fn().mockResolvedValue({}),
+      };
+    }
+  };
+  return {
+    ...actual,
+    InteractiveSession: vi.fn().mockImplementation(makeMockSession),
+    buildRuntimeSession: vi.fn().mockImplementation(makeMockSession),
+    CommandRegistry: vi.fn().mockImplementation(() => ({
+      addModule: vi.fn(),
+    })),
+  };
+});
+
+import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
+import { TUI_SESSION_EVENT_CLASSIFICATION } from '../tui-session-events.js';
+
+import type { IAIProvider } from '@robota-sdk/agent-core';
+import type { ITransportRegistryView } from '@robota-sdk/agent-interface-transport';
+import type {
+  IExecutionResult,
+  IInteractiveSession,
+  TInteractiveEventName,
+} from '@robota-sdk/agent-interface-session';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+type MockSession = {
+  getFullHistory: ReturnType<typeof vi.fn>;
+  submit: ReturnType<typeof vi.fn>;
+  executeCommand: ReturnType<typeof vi.fn>;
+  on: ReturnType<typeof vi.fn>;
+  off: ReturnType<typeof vi.fn>;
+  shutdown: ReturnType<typeof vi.fn>;
+  resolvePermission: ReturnType<typeof vi.fn>;
+  resolveAsk: ReturnType<typeof vi.fn>;
+  emit: (event: string, ...args: unknown[]) => void;
+  _listenerCount: () => number;
+};
+
+function getMockSession(channel: TuiInteractionChannel): MockSession {
+  return (channel as unknown as { interactiveSession: MockSession }).interactiveSession;
+}
+
+function emitSessionEvent(channel: TuiInteractionChannel, event: string, ...args: unknown[]): void {
+  getMockSession(channel).emit(event, ...args);
+}
+
+/** Drive the channel's private permission handler (what the session's permissionHandler invokes). */
+function requestPermission(
+  channel: TuiInteractionChannel,
+  toolName: string,
+  toolArgs: unknown,
+): Promise<unknown> {
+  return (
+    channel as unknown as {
+      handlePermissionRequest: (n: string, a: unknown) => Promise<unknown>;
+    }
+  ).handlePermissionRequest(toolName, toolArgs);
+}
+
+function makeMockTransportRegistry(): {
+  registry: ITransportRegistryView;
+  startAll: ReturnType<typeof vi.fn>;
+  stopAll: ReturnType<typeof vi.fn>;
+} {
+  const startAll = vi.fn().mockResolvedValue(undefined);
+  const stopAll = vi.fn().mockResolvedValue({ errors: [] });
+  return {
+    registry: { startAll, stopAll } as unknown as ITransportRegistryView,
+    startAll,
+    stopAll,
+  };
+}
+
+function makeChannel(opts?: {
+  transportRegistry?: ITransportRegistryView;
+  bindTransports?: (session: IInteractiveSession) => void | Promise<void>;
+  onSessionEventDeliveryError?: (error: Error, event: TInteractiveEventName) => void;
+}): TuiInteractionChannel {
+  return new TuiInteractionChannel({
+    cwd: '/tmp/test',
+    provider: {} as IAIProvider,
+    ...opts,
+  });
+}
+
+const MOCK_RESULT = {
+  contextState: { usedPercentage: 10, usedTokens: 1_000, maxTokens: 100_000 },
+  response: 'Hello!',
+} as unknown as IExecutionResult;
+
+const MOCK_TOOL = {
+  toolName: 'bash',
+  isRunning: true,
+  input: '{}',
+  startTime: Date.now(),
+} as unknown as Parameters<
+  InstanceType<typeof TuiInteractionChannel>['stateManager']['onToolStart']
+>[0];
+
+beforeEach(() => {
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+// ── Group A: channel.start() / channel.stop() lifecycle ───────────────────────
+
+describe('Group A — channel.start() / channel.stop() lifecycle', () => {
+  it('A1: text_delta after start() updates stateManager.streamingText', async () => {
+    const channel = makeChannel();
+    await channel.start();
+
+    emitSessionEvent(channel, 'text_delta', 'Hello!');
+
+    expect(channel.stateManager.streamingText).toBe('Hello!');
+    await channel.stop();
+  });
+
+  it('A2: complete after start() clears streaming state and updates contextState', async () => {
+    const channel = makeChannel();
+    await channel.start();
+
+    emitSessionEvent(channel, 'text_delta', 'streaming...');
+    emitSessionEvent(channel, 'complete', MOCK_RESULT);
+
+    expect(channel.stateManager.streamingText).toBe('');
+    expect(channel.stateManager.contextState.percentage).toBe(10);
+    expect(channel.stateManager.contextState.usedTokens).toBe(1_000);
+    await channel.stop();
+  });
+
+  it('A3: tool_start after start() adds entry to stateManager.activeTools', async () => {
+    const channel = makeChannel();
+    await channel.start();
+
+    emitSessionEvent(channel, 'tool_start', MOCK_TOOL);
+
+    expect(channel.stateManager.activeTools).toHaveLength(1);
+    expect(channel.stateManager.activeTools[0]).toMatchObject({ toolName: 'bash' });
+    await channel.stop();
+  });
+
+  it('A4: error after start() clears stateManager.streamingText', async () => {
+    const channel = makeChannel();
+    await channel.start();
+
+    emitSessionEvent(channel, 'text_delta', 'partial...');
+    emitSessionEvent(channel, 'error');
+
+    expect(channel.stateManager.streamingText).toBe('');
+    await channel.stop();
+  });
+
+  it('A5: calling start() twice does not duplicate subscriptions', async () => {
+    const channel = makeChannel();
+    await channel.start();
+    await channel.start(); // second call is a no-op (sessionStarted guard)
+
+    emitSessionEvent(channel, 'text_delta', 'hi');
+
+    expect(channel.stateManager.streamingText).toBe('hi'); // not 'hihi'
+    await channel.stop();
+  });
+
+  it('A6: stop() calls transportRegistry.stopAll exactly once', async () => {
+    const { registry, stopAll } = makeMockTransportRegistry();
+    const channel = makeChannel({ transportRegistry: registry });
+    await channel.start();
+    await channel.stop();
+
+    expect(stopAll).toHaveBeenCalledOnce();
+  });
+
+  it('binds each replacement channel to its own session before transport startup', async () => {
+    const { registry, startAll } = makeMockTransportRegistry();
+    const bindTransports = vi.fn();
+    const first = makeChannel({ transportRegistry: registry, bindTransports });
+    await first.start();
+    await first.stop();
+    const second = makeChannel({ transportRegistry: registry, bindTransports });
+    await second.start();
+
+    expect(bindTransports).toHaveBeenNthCalledWith(1, getMockSession(first));
+    expect(bindTransports).toHaveBeenNthCalledWith(2, getMockSession(second));
+    expect(getMockSession(first)).not.toBe(getMockSession(second));
+    expect(startAll).toHaveBeenCalledTimes(2);
+    expect(startAll).toHaveBeenNthCalledWith(1);
+    expect(startAll).toHaveBeenNthCalledWith(2);
+    await second.stop();
+  });
+
+  it('waits for asynchronous source binding before starting transports', async () => {
+    const { registry, startAll } = makeMockTransportRegistry();
+    let release: (() => void) | undefined;
+    const pending = new Promise<void>((resolve) => { release = resolve; });
+    const channel = makeChannel({ transportRegistry: registry, bindTransports: () => pending });
+    const starting = channel.start();
+    await Promise.resolve();
+    expect(startAll).not.toHaveBeenCalled();
+    release?.();
+    await starting;
+    expect(startAll).toHaveBeenCalledOnce();
+    await channel.stop();
+  });
+
+  it('A7: rolls back a failed transport start before retrying the real channel', async () => {
+    const { registry, startAll, stopAll } = makeMockTransportRegistry();
+    startAll.mockRejectedValueOnce(new Error('transport start failed'));
+    const channel = makeChannel({ transportRegistry: registry });
+    const session = getMockSession(channel);
+
+    await expect(channel.start()).rejects.toThrow('transport start failed');
+    expect(session._listenerCount()).toBe(0);
+    expect(stopAll).toHaveBeenCalledTimes(1);
+
+    await channel.start();
+    expect(startAll).toHaveBeenCalledTimes(2);
+    expect(session._listenerCount()).toBeGreaterThan(0);
+
+    await channel.stop();
+  });
+
+  it('A8: treats returned transport stop errors as retryable teardown failures', async () => {
+    const { registry, stopAll } = makeMockTransportRegistry();
+    stopAll.mockResolvedValueOnce({ errors: [new Error('transport stop failed')] });
+    const channel = makeChannel({ transportRegistry: registry });
+    await channel.start();
+
+    await expect(channel.stop()).rejects.toThrow('TUI transport teardown failed.');
+    await channel.stop();
+
+    expect(stopAll).toHaveBeenCalledTimes(2);
+  });
+
+  it('A9: unwires a partially connected event projector before start retry', async () => {
+    const channel = makeChannel();
+    const session = getMockSession(channel);
+    const on = session.on.getMockImplementation();
+    if (!on) throw new Error('session.on test implementation is missing');
+    session.on.mockImplementationOnce(on).mockImplementationOnce(() => {
+      throw new Error('listener registration failed');
+    });
+
+    await expect(channel.start()).rejects.toThrow('listener registration failed');
+    expect(session._listenerCount()).toBe(0);
+
+    await channel.start();
+    expect(session._listenerCount()).toBeGreaterThan(0);
+    await channel.stop();
+  });
+
+  it('A10: reports both startup and returned rollback errors', async () => {
+    const { registry, startAll, stopAll } = makeMockTransportRegistry();
+    startAll.mockRejectedValueOnce(new Error('transport start failed'));
+    stopAll.mockResolvedValueOnce({ errors: [new Error('transport rollback failed')] });
+    const channel = makeChannel({ transportRegistry: registry });
+
+    const failure = await channel.start().catch((error: unknown) => error);
+
+    expect(failure).toBeInstanceOf(AggregateError);
+    expect((failure as AggregateError).errors).toHaveLength(2);
+    expect(String((failure as AggregateError).errors[1])).toContain('transport rollback failed');
+    await expect(channel.start()).rejects.toThrow(
+      'Cannot start a channel after teardown has begun.',
+    );
+    expect(startAll).toHaveBeenCalledTimes(1);
+  });
+});
+
+// ── Group B: handleInput() AI-response roundtrip ──────────────────────────────
+
+describe('Group B — handleInput() roundtrip', () => {
+  it('B1: handleInput("hello") calls session.submit with "hello"', async () => {
+    const channel = makeChannel();
+    await channel.start();
+
+    await channel.handleInput('hello');
+
+    const mockSession = getMockSession(channel);
+    expect(mockSession.submit).toHaveBeenCalledWith('hello');
+    await channel.stop();
+  });
+
+  it('B2: text_delta + complete syncs history to stateManager', async () => {
+    const channel = makeChannel();
+    const mockSession = getMockSession(channel);
+    const historyEntry = {
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Hi!' }],
+      timestamp: Date.now(),
+    };
+    mockSession.getFullHistory.mockReturnValue([historyEntry]);
+    await channel.start();
+
+    await channel.handleInput('hello');
+    emitSessionEvent(channel, 'text_delta', 'Hi!');
+    expect(channel.stateManager.streamingText).toBe('Hi!');
+
+    emitSessionEvent(channel, 'complete', MOCK_RESULT);
+    expect(channel.stateManager.streamingText).toBe('');
+    expect(channel.stateManager.history).toHaveLength(1);
+
+    await channel.stop();
+  });
+
+  it('B3: handleInput("/help") calls executeCommand, not session.submit', async () => {
+    const channel = makeChannel();
+    await channel.start();
+
+    await channel.handleInput('/help');
+
+    const mockSession = getMockSession(channel);
+    expect(mockSession.submit).not.toHaveBeenCalled();
+    expect(mockSession.executeCommand).toHaveBeenCalledWith('help', '');
+    await channel.stop();
+  });
+
+  it('B4: handleInput("hello") triggers channel.onChange at least once', async () => {
+    const channel = makeChannel();
+    const onChange = vi.fn();
+    channel.onChange = onChange;
+    await channel.start();
+    onChange.mockClear();
+
+    await channel.handleInput('hello');
+    emitSessionEvent(channel, 'text_delta', 'hey');
+
+    expect(onChange).toHaveBeenCalled();
+    await channel.stop();
+  });
+});
+
+// ── Group C: onChange propagation invariant ───────────────────────────────────
+
+describe('Group C — onChange propagation invariant', () => {
+  it('C1: session event after start() causes channel.onChange to fire', async () => {
+    const channel = makeChannel();
+    const onChange = vi.fn();
+    channel.onChange = onChange;
+    await channel.start();
+    onChange.mockClear();
+
+    // tool_start calls notify() directly (not debounced), so onChange fires immediately
+    emitSessionEvent(channel, 'tool_start', MOCK_TOOL);
+
+    expect(onChange).toHaveBeenCalled();
+    await channel.stop();
+  });
+
+  it('C2: channel.onChange does not fire for events before start()', () => {
+    const channel = makeChannel();
+    const onChange = vi.fn();
+    channel.onChange = onChange;
+    // Do NOT call channel.start() — handlers not registered yet
+    emitSessionEvent(channel, 'text_delta', 'hello'); // no-op: no handlers
+
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('C3: channel.onChange does not fire for events after stop()', async () => {
+    const channel = makeChannel();
+    const onChange = vi.fn();
+    channel.onChange = onChange;
+    await channel.start();
+    await channel.stop(); // sets this.onChange = null
+    onChange.mockClear();
+
+    emitSessionEvent(channel, 'text_delta', 'hello');
+
+    expect(onChange).not.toHaveBeenCalled();
+  });
+});
+
+// ── Group D: teardown hygiene (CLI-075) ───────────────────────────────────────
+
+describe('Group D — teardown hygiene (CLI-075)', () => {
+  it('D1: stop() unwires every session listener', async () => {
+    const channel = makeChannel();
+    await channel.start();
+    const session = getMockSession(channel);
+    expect(session._listenerCount()).toBeGreaterThan(0);
+
+    await channel.stop();
+
+    expect(session._listenerCount()).toBe(0);
+    // A post-stop emit reaches no handler — state must not mutate.
+    emitSessionEvent(channel, 'text_delta', 'ghost');
+    expect(channel.stateManager.streamingText).toBe('');
+  });
+
+  it('D2: stop() shuts the underlying session down on discard/switch', async () => {
+    const channel = makeChannel();
+    await channel.start();
+    const session = getMockSession(channel);
+
+    await channel.stop();
+
+    expect(session.shutdown).toHaveBeenCalledTimes(1);
+  });
+
+  it('D3: stop() after a graceful shutdown() does not shut the session down twice', async () => {
+    const channel = makeChannel();
+    await channel.start();
+    const session = getMockSession(channel);
+
+    await channel.shutdown();
+    await channel.stop();
+
+    expect(session.shutdown).toHaveBeenCalledTimes(1);
+  });
+
+  it('D4: stop() is idempotent — a second stop() does not repeat teardown', async () => {
+    const { registry, stopAll } = makeMockTransportRegistry();
+    const channel = makeChannel({ transportRegistry: registry });
+    await channel.start();
+
+    await channel.stop();
+    await channel.stop();
+
+    expect(stopAll).toHaveBeenCalledOnce();
+  });
+
+  it('D5: shutdown() drains a pending permission as deny (false)', async () => {
+    const channel = makeChannel();
+    await channel.start();
+    const pending = requestPermission(channel, 'bash', {});
+    expect(channel.permissionRequest).not.toBeNull();
+
+    await channel.shutdown();
+
+    await expect(pending).resolves.toBe(false);
+    expect(channel.permissionRequest).toBeNull();
+  });
+
+  it('D6: abort() drains a pending permission as deny (false)', async () => {
+    const channel = makeChannel();
+    await channel.start();
+    const pending = requestPermission(channel, 'bash', {});
+
+    channel.abort();
+
+    await expect(pending).resolves.toBe(false);
+    expect(channel.permissionRequest).toBeNull();
+  });
+
+  it('D7: shutdown() resolves even if the session shutdown hangs (timeout-bounded)', async () => {
+    const channel = makeChannel();
+    await channel.start();
+    const session = getMockSession(channel);
+    session.shutdown.mockReturnValue(new Promise<void>(() => undefined)); // never resolves
+
+    let resolved = false;
+    const done = channel.shutdown({ timeoutMs: 5_000 }).then(() => {
+      resolved = true;
+    });
+    await Promise.resolve();
+    expect(resolved).toBe(false);
+
+    await vi.advanceTimersByTimeAsync(5_000);
+    await done;
+    expect(resolved).toBe(true);
+  });
+});
+
+describe('Group E — canonical prompt request settlement (ARCH-017)', () => {
+  it('E1: permission_request renders locally and settles through resolvePermission', async () => {
+    const channel = makeChannel();
+    await channel.start();
+    const session = getMockSession(channel);
+
+    emitSessionEvent(channel, 'permission_request', {
+      id: 'permission-1',
+      toolName: 'Bash',
+      toolArgs: { command: 'pwd' },
+    });
+    expect(channel.permissionRequest).toMatchObject({ toolName: 'Bash' });
+    channel.permissionRequest!.resolve(true);
+
+    await vi.waitFor(() => {
+      expect(session.resolvePermission).toHaveBeenCalledWith('permission-1', true);
+    });
+    await channel.stop();
+  });
+
+  it('E2: ask_request callback rejection settles cancelled through resolveAsk', async () => {
+    const channel = makeChannel();
+    await channel.start();
+    const session = getMockSession(channel);
+    vi.spyOn(channel, 'askUser').mockRejectedValueOnce(new Error('render failed'));
+
+    emitSessionEvent(channel, 'ask_request', {
+      id: 'ask-1',
+      request: { id: 'request-1', title: 'Choose' },
+    });
+
+    await vi.waitFor(() => {
+      expect(session.resolveAsk).toHaveBeenCalledWith('ask-1', { type: 'cancelled' });
+    });
+    await channel.stop();
+  });
+});
+
+describe('Group F — total session-event surface delivery (ARCH-020/ARCH-028)', () => {
+  it('F1: actual channel subscriptions exactly match the exhaustive channel classification', async () => {
+    const channel = makeChannel();
+    await channel.start();
+    const session = getMockSession(channel);
+    const expected = Object.entries(TUI_SESSION_EVENT_CLASSIFICATION)
+      .filter(([, classification]) => classification === 'channel')
+      .map(([event]) => event)
+      .sort();
+    const onCalls = session.on.mock.calls as Array<[string, (...args: unknown[]) => void]>;
+    expect(onCalls.map(([event]) => event).sort()).toEqual(expected);
+
+    await channel.stop();
+    const offCalls = session.off.mock.calls as Array<[string, (...args: unknown[]) => void]>;
+    expect(offCalls.map(([event]) => event).sort()).toEqual(expected);
+    for (const [event, handler] of onCalls) expect(offCalls).toContainEqual([event, handler]);
+  });
+
+  it('F2: plan, context refresh, and branch events append deterministic render notices', async () => {
+    const channel = makeChannel();
+    await channel.start();
+
+    emitSessionEvent(channel, 'plan_event', { type: 'plan_created', plan: { id: 'plan-1' } });
+    emitSessionEvent(channel, 'context_file_refreshed', { filePath: '/repo/AGENTS.md' });
+    emitSessionEvent(channel, 'branch_event', {
+      kind: 'branch_switched',
+      checkpointId: 'turn-0002',
+      branchId: 'branch-2',
+    });
+
+    expect(channel.stateManager.sessionEventNotices.map((notice) => notice.message)).toEqual([
+      'Plan plan created',
+      'Context refreshed: /repo/AGENTS.md',
+      'Branch branch switched: branch-2 @ turn-0002',
+    ]);
+    await channel.stop();
+  });
+
+  it('F3: a render handler failure is isolated and reported to the TUI owner callback', async () => {
+    const onDeliveryError = vi.fn(() => {
+      throw new Error('diagnostic callback failed');
+    });
+    const channel = makeChannel({ onSessionEventDeliveryError: onDeliveryError });
+    await channel.start();
+    vi.spyOn(channel.stateManager, 'addSessionEventNotice').mockImplementation(() => {
+      throw new Error('render projection failed');
+    });
+
+    expect(() =>
+      emitSessionEvent(channel, 'plan_event', {
+        type: 'plan_created',
+        plan: { id: 'plan-1' },
+      }),
+    ).not.toThrow();
+    expect(onDeliveryError).toHaveBeenCalledWith(
+      expect.objectContaining({ message: 'render projection failed' }),
+      'plan_event',
+    );
+    await channel.stop();
+  });
+
+  it('F4: a render handler failure becomes a visible notice when no observer is injected', async () => {
+    const channel = makeChannel();
+    await channel.start();
+    vi.spyOn(channel.stateManager, 'addSessionEventNotice').mockImplementation(() => {
+      throw new Error('render projection failed');
+    });
+
+    expect(() =>
+      emitSessionEvent(channel, 'plan_event', {
+        type: 'plan_created',
+        plan: { id: 'plan-1' },
+      }),
+    ).not.toThrow();
+    expect(channel.stateManager.sessionEventNotices).toContainEqual(
+      expect.objectContaining({
+        event: 'delivery-error',
+        message: 'Session event delivery failed (plan_event): render projection failed',
+      }),
+    );
+    await channel.stop();
+  });
+});

package/src/__tests__/UpdateNotice.test.tsx

@@ -0,0 +1,15 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, expect, it } from 'vitest';
+import UpdateNotice from '../UpdateNotice.js';
+
+describe('UpdateNotice', () => {
+  it('renders an update notice outside session history', () => {
+    const { lastFrame } = render(
+      <UpdateNotice message="Robota update available. Run npm install -g '@robota-sdk/agent-cli@latest'." />,
+    );
+
+    expect(lastFrame()).toContain('Robota update available');
+    expect(lastFrame()).toContain('npm install');
+  });
+});