@machina.ai/cell-cli 1.33.0-rc1 → 1.38.1-rc1

package/dist/src/ui/components/Footer.test.js

@@ -4,11 +4,32 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
 import { renderWithProviders } from '../../test-utils/render.js';
-import { createMockSettings } from '../../test-utils/settings.js';
 import { Footer } from './Footer.js';
-import { tildeifyPath, ToolCallDecision } from '@google/gemini-cli-core';
+import { createMockSettings } from '../../test-utils/settings.js';
+import { UserAccountManager, AuthType, } from '@google/gemini-cli-core';
+import path from 'node:path';
+// Normalize paths to POSIX slashes for stable cross-platform snapshots.
+const normalizeFrame = (frame) => {
+    if (!frame)
+        return frame;
+    return frame.replace(/\\/g, '/');
+};
+const { mocks } = vi.hoisted(() => ({
+    mocks: {
+        isDevelopment: false,
+    },
+}));
+vi.mock('../../utils/installationInfo.js', async (importOriginal) => {
+    const original = await importOriginal();
+    return {
+        ...original,
+        get isDevelopment() {
+            return mocks.isDevelopment;
+        },
+    };
+});
 vi.mock('@google/gemini-cli-core', async (importOriginal) => {
     const original = await importOriginal();
     return {
@@ -23,17 +44,32 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
 });
 const defaultProps = {
     model: 'gemini-pro',
-    targetDir: '/Users/test/project/foo/bar/and/some/more/directories/to/make/it/long',
+    targetDir: path.join(path.parse(process.cwd()).root, 'Users', 'test', 'project', 'foo', 'bar', 'and', 'some', 'more', 'directories', 'to', 'make', 'it', 'long'),
     branchName: 'main',
 };
+const mockConfigPlain = {
+    getTargetDir: () => defaultProps.targetDir,
+    getDebugMode: () => false,
+    getModel: () => defaultProps.model,
+    getIdeMode: () => false,
+    isTrustedFolder: () => true,
+    getExtensionRegistryURI: () => undefined,
+    getContentGeneratorConfig: () => ({ authType: undefined }),
+    getSandboxEnabled: () => false,
+};
+const mockConfig = mockConfigPlain;
 const mockSessionStats = {
-    sessionId: 'test-session',
+    sessionId: 'test-session-id',
     sessionStartTime: new Date(),
-    lastPromptTokenCount: 0,
     promptCount: 0,
+    lastPromptTokenCount: 150000,
     metrics: {
-        models: {},
+        files: {
+            totalLinesAdded: 12,
+            totalLinesRemoved: 4,
+        },
         tools: {
+            count: 0,
             totalCalls: 0,
             totalSuccess: 0,
             totalFail: 0,
@@ -42,19 +78,45 @@ const mockSessionStats = {
                 accept: 0,
                 reject: 0,
                 modify: 0,
-                [ToolCallDecision.AUTO_ACCEPT]: 0,
+                auto_accept: 0,
             },
             byName: {},
+            latency: { avg: 0, max: 0, min: 0 },
         },
-        files: {
-            totalLinesAdded: 0,
-            totalLinesRemoved: 0,
+        models: {
+            'gemini-pro': {
+                api: {
+                    totalRequests: 0,
+                    totalErrors: 0,
+                    totalLatencyMs: 0,
+                },
+                tokens: {
+                    input: 0,
+                    prompt: 0,
+                    candidates: 0,
+                    total: 1500,
+                    cached: 0,
+                    thoughts: 0,
+                    tool: 0,
+                },
+                roles: {},
+            },
         },
     },
 };
 describe('<Footer />', () => {
-    it('renders the component', () => {
-        const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+    beforeEach(() => {
+        const root = path.parse(process.cwd()).root;
+        vi.stubEnv('CELL_CLI_HOME', path.join(root, 'Users', 'test'));
+        vi.stubEnv('SANDBOX', '');
+        vi.stubEnv('SEATBELT_PROFILE', '');
+    });
+    afterEach(() => {
+        vi.unstubAllEnvs();
+    });
+    it('renders the component', async () => {
+        const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+            config: mockConfig,
             width: 120,
             uiState: {
                 branchName: defaultProps.branchName,
@@ -62,49 +124,92 @@ describe('<Footer />', () => {
             },
         });
         expect(lastFrame()).toBeDefined();
+        unmount();
     });
     describe('path display', () => {
-        it('should display a shortened path on a narrow terminal', () => {
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+        it('should display a shortened path on a narrow terminal', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 79,
                 uiState: { sessionStats: mockSessionStats },
             });
-            const tildePath = tildeifyPath(defaultProps.targetDir);
-            const pathLength = Math.max(20, Math.floor(79 * 0.25));
-            const expectedPath = '...' + tildePath.slice(tildePath.length - pathLength + 3);
-            expect(lastFrame()).toContain(expectedPath);
+            const output = lastFrame();
+            expect(output).toBeDefined();
+            // Should contain some part of the path, likely shortened
+            expect(output).toContain(path.join('make', 'it'));
+            unmount();
         });
-        it('should use wide layout at 80 columns', () => {
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+        it('should use wide layout at 80 columns', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 80,
                 uiState: { sessionStats: mockSessionStats },
             });
-            const tildePath = tildeifyPath(defaultProps.targetDir);
-            const expectedPath = '...' + tildePath.slice(tildePath.length - 80 * 0.25 + 3);
-            expect(lastFrame()).toContain(expectedPath);
+            const output = lastFrame();
+            expect(output).toBeDefined();
+            expect(output).toContain(path.join('make', 'it'));
+            unmount();
+        });
+        it('should not truncate high-priority items on narrow terminals (regression)', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
+                width: 60,
+                uiState: {
+                    sessionStats: mockSessionStats,
+                },
+                settings: createMockSettings({
+                    general: {
+                        vimMode: true,
+                    },
+                    ui: {
+                        footer: {
+                            showLabels: true,
+                            items: ['workspace', 'model-name'],
+                        },
+                    },
+                }),
+            });
+            const output = lastFrame();
+            // [INSERT] is high priority and should be fully visible
+            // (Note: VimModeProvider defaults to 'INSERT' mode when enabled)
+            expect(output).toContain('[INSERT]');
+            // Other items should be present but might be shortened
+            expect(output).toContain('gemini-pro');
+            unmount();
         });
     });
-    it('displays the branch name when provided', () => {
-        const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+    it('displays the branch name when provided', async () => {
+        const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+            config: mockConfig,
             width: 120,
             uiState: {
                 branchName: defaultProps.branchName,
                 sessionStats: mockSessionStats,
             },
         });
-        expect(lastFrame()).toContain(`(${defaultProps.branchName}*)`);
+        expect(lastFrame()).toContain(defaultProps.branchName);
+        unmount();
     });
-    it('does not display the branch name when not provided', () => {
-        const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+    it('does not display the branch name when not provided', async () => {
+        const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+            config: mockConfig,
             width: 120,
             uiState: { branchName: undefined, sessionStats: mockSessionStats },
         });
-        expect(lastFrame()).not.toContain(`(${defaultProps.branchName}*)`);
+        expect(lastFrame()).not.toContain('Branch');
+        unmount();
     });
-    it('displays the model name and context percentage', () => {
-        const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+    it('displays the model name and context percentage', async () => {
+        const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+            config: mockConfig,
             width: 120,
-            uiState: { sessionStats: mockSessionStats },
+            uiState: {
+                currentModel: defaultProps.model,
+                sessionStats: {
+                    ...mockSessionStats,
+                    lastPromptTokenCount: 1000,
+                },
+            },
             settings: createMockSettings({
                 ui: {
                     footer: {
@@ -114,10 +219,12 @@ describe('<Footer />', () => {
             }),
         });
         expect(lastFrame()).toContain(defaultProps.model);
-        expect(lastFrame()).toMatch(/\d+% context left/);
+        expect(lastFrame()).toMatch(/\d+% used/);
+        unmount();
     });
-    it('displays the usage indicator when usage is low', () => {
-        const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+    it('displays the usage indicator when usage is low', async () => {
+        const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+            config: mockConfig,
             width: 120,
             uiState: {
                 sessionStats: mockSessionStats,
@@ -130,14 +237,18 @@ describe('<Footer />', () => {
                     },
                     proQuotaRequest: null,
                     validationRequest: null,
+                    overageMenuRequest: null,
+                    emptyWalletRequest: null,
                 },
             },
         });
-        expect(lastFrame()).toContain('15%');
-        expect(lastFrame()).toMatchSnapshot();
+        expect(lastFrame()).toContain('85%');
+        expect(normalizeFrame(lastFrame())).toMatchSnapshot();
+        unmount();
     });
-    it('hides the usage indicator when usage is not near limit', () => {
-        const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+    it('hides the usage indicator when usage is not near limit', async () => {
+        const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+            config: mockConfig,
             width: 120,
             uiState: {
                 sessionStats: mockSessionStats,
@@ -150,14 +261,18 @@ describe('<Footer />', () => {
                     },
                     proQuotaRequest: null,
                     validationRequest: null,
+                    overageMenuRequest: null,
+                    emptyWalletRequest: null,
                 },
             },
         });
-        expect(lastFrame()).not.toContain('Usage remaining');
-        expect(lastFrame()).toMatchSnapshot();
+        expect(normalizeFrame(lastFrame())).not.toContain('used');
+        expect(normalizeFrame(lastFrame())).toMatchSnapshot();
+        unmount();
     });
-    it('displays "Limit reached" message when remaining is 0', () => {
-        const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+    it('displays "Limit reached" message when remaining is 0', async () => {
+        const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+            config: mockConfig,
             width: 120,
             uiState: {
                 sessionStats: mockSessionStats,
@@ -170,14 +285,18 @@ describe('<Footer />', () => {
                     },
                     proQuotaRequest: null,
                     validationRequest: null,
+                    overageMenuRequest: null,
+                    emptyWalletRequest: null,
                 },
             },
         });
-        expect(lastFrame()).toContain('Limit reached');
-        expect(lastFrame()).toMatchSnapshot();
+        expect(lastFrame()?.toLowerCase()).toContain('limit reached');
+        expect(normalizeFrame(lastFrame())).toMatchSnapshot();
+        unmount();
     });
-    it('displays the model name and abbreviated context percentage', () => {
-        const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+    it('displays the model name and abbreviated context used label on narrow terminals', async () => {
+        const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+            config: mockConfig,
             width: 99,
             uiState: { sessionStats: mockSessionStats },
             settings: createMockSettings({
@@ -190,65 +309,87 @@ describe('<Footer />', () => {
         });
         expect(lastFrame()).toContain(defaultProps.model);
         expect(lastFrame()).toMatch(/\d+%/);
+        expect(lastFrame()).not.toContain('context used');
+        unmount();
     });
     describe('sandbox and trust info', () => {
-        it('should display untrusted when isTrustedFolder is false', () => {
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+        it('should display untrusted when isTrustedFolder is false', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 120,
                 uiState: { isTrustedFolder: false, sessionStats: mockSessionStats },
             });
             expect(lastFrame()).toContain('untrusted');
+            unmount();
         });
-        it('should display custom sandbox info when SANDBOX env is set', () => {
+        it('should display "current process" for custom sandbox when SANDBOX env is set', async () => {
             vi.stubEnv('SANDBOX', 'gemini-cli-test-sandbox');
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 120,
-                uiState: { isTrustedFolder: undefined, sessionStats: mockSessionStats },
+                uiState: {
+                    isTrustedFolder: undefined,
+                    sessionStats: mockSessionStats,
+                },
             });
-            expect(lastFrame()).toContain('test');
+            expect(lastFrame()).toContain('current process');
             vi.unstubAllEnvs();
+            unmount();
         });
-        it('should display macOS Seatbelt info when SANDBOX is sandbox-exec', () => {
+        it('should display "current process" for macOS Seatbelt when SANDBOX is sandbox-exec', async () => {
             vi.stubEnv('SANDBOX', 'sandbox-exec');
             vi.stubEnv('SEATBELT_PROFILE', 'test-profile');
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 120,
                 uiState: { isTrustedFolder: true, sessionStats: mockSessionStats },
             });
-            expect(lastFrame()).toMatch(/macOS Seatbelt.*\(test-profile\)/s);
+            expect(lastFrame()).toContain('current process');
             vi.unstubAllEnvs();
+            unmount();
         });
-        it('should display "no sandbox" when SANDBOX is not set and folder is trusted', () => {
+        it('should display "no sandbox" when SANDBOX is not set and folder is trusted', async () => {
             // Clear any SANDBOX env var that might be set.
             vi.stubEnv('SANDBOX', '');
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 120,
                 uiState: { isTrustedFolder: true, sessionStats: mockSessionStats },
             });
             expect(lastFrame()).toContain('no sandbox');
             vi.unstubAllEnvs();
+            unmount();
         });
-        it('should prioritize untrusted message over sandbox info', () => {
+        it('should display "all tools" when tool sandboxing is enabled and agent is local', async () => {
+            vi.stubEnv('SANDBOX', '');
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: Object.assign(Object.create(Object.getPrototypeOf(mockConfig)), mockConfig, {
+                    getSandboxEnabled: () => true,
+                }),
+                width: 120,
+                uiState: { isTrustedFolder: true, sessionStats: mockSessionStats },
+            });
+            expect(lastFrame()).toContain('all tools');
+            vi.unstubAllEnvs();
+            unmount();
+        });
+        it('should prioritize untrusted message over sandbox info', async () => {
             vi.stubEnv('SANDBOX', 'gemini-cli-test-sandbox');
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 120,
                 uiState: { isTrustedFolder: false, sessionStats: mockSessionStats },
             });
             expect(lastFrame()).toContain('untrusted');
             expect(lastFrame()).not.toMatch(/test-sandbox/s);
             vi.unstubAllEnvs();
+            unmount();
         });
     });
     describe('footer configuration filtering (golden snapshots)', () => {
-        beforeEach(() => {
-            vi.stubEnv('SANDBOX', '');
-            vi.stubEnv('SEATBELT_PROFILE', '');
-        });
-        afterEach(() => {
-            vi.unstubAllEnvs();
-        });
-        it('renders complete footer with all sections visible (baseline)', () => {
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+        it('renders complete footer with all sections visible (baseline)', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 120,
                 uiState: { sessionStats: mockSessionStats },
                 settings: createMockSettings({
@@ -259,10 +400,12 @@ describe('<Footer />', () => {
                     },
                 }),
             });
-            expect(lastFrame()).toMatchSnapshot('complete-footer-wide');
+            expect(normalizeFrame(lastFrame())).toMatchSnapshot('complete-footer-wide');
+            unmount();
         });
-        it('renders footer with all optional sections hidden (minimal footer)', () => {
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+        it('renders footer with all optional sections hidden (minimal footer)', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 120,
                 uiState: { sessionStats: mockSessionStats },
                 settings: createMockSettings({
@@ -275,10 +418,14 @@ describe('<Footer />', () => {
                     },
                 }),
             });
-            expect(lastFrame()).toMatchSnapshot('footer-minimal');
+            // Wait for Ink to render
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            expect(normalizeFrame(lastFrame({ allowEmpty: true }))).toMatchSnapshot('footer-minimal');
+            unmount();
         });
-        it('renders footer with only model info hidden (partial filtering)', () => {
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+        it('renders footer with only model info hidden (partial filtering)', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 120,
                 uiState: { sessionStats: mockSessionStats },
                 settings: createMockSettings({
@@ -291,10 +438,12 @@ describe('<Footer />', () => {
                     },
                 }),
             });
-            expect(lastFrame()).toMatchSnapshot('footer-no-model');
+            expect(normalizeFrame(lastFrame())).toMatchSnapshot('footer-no-model');
+            unmount();
         });
-        it('renders footer with CWD and model info hidden to test alignment (only sandbox visible)', () => {
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+        it('renders footer with CWD and model info hidden to test alignment (only sandbox visible)', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 120,
                 uiState: { sessionStats: mockSessionStats },
                 settings: createMockSettings({
@@ -307,10 +456,12 @@ describe('<Footer />', () => {
                     },
                 }),
             });
-            expect(lastFrame()).toMatchSnapshot('footer-only-sandbox');
+            expect(normalizeFrame(lastFrame())).toMatchSnapshot('footer-only-sandbox');
+            unmount();
         });
-        it('hides the context percentage when hideContextPercentage is true', () => {
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+        it('hides the context percentage when hideContextPercentage is true', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 120,
                 uiState: { sessionStats: mockSessionStats },
                 settings: createMockSettings({
@@ -322,10 +473,12 @@ describe('<Footer />', () => {
                 }),
             });
             expect(lastFrame()).toContain(defaultProps.model);
-            expect(lastFrame()).not.toMatch(/\d+% context left/);
+            expect(lastFrame()).not.toMatch(/\d+% used/);
+            unmount();
         });
-        it('shows the context percentage when hideContextPercentage is false', () => {
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+        it('shows the context percentage when hideContextPercentage is false', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 120,
                 uiState: { sessionStats: mockSessionStats },
                 settings: createMockSettings({
@@ -337,10 +490,12 @@ describe('<Footer />', () => {
                 }),
             });
             expect(lastFrame()).toContain(defaultProps.model);
-            expect(lastFrame()).toMatch(/\d+% context left/);
+            expect(lastFrame()).toMatch(/\d+% used/);
+            unmount();
         });
-        it('renders complete footer in narrow terminal (baseline narrow)', () => {
-            const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
+        it('renders complete footer in narrow terminal (baseline narrow)', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
                 width: 79,
                 uiState: { sessionStats: mockSessionStats },
                 settings: createMockSettings({
@@ -351,32 +506,315 @@ describe('<Footer />', () => {
                     },
                 }),
             });
-            expect(lastFrame()).toMatchSnapshot('complete-footer-narrow');
+            expect(normalizeFrame(lastFrame())).toMatchSnapshot('complete-footer-narrow');
+            unmount();
         });
     });
-});
-describe('fallback mode display', () => {
-    it('should display Flash model when in fallback mode, not the configured Pro model', () => {
-        const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
-            width: 120,
-            uiState: {
-                sessionStats: mockSessionStats,
-                currentModel: 'gemini-2.5-flash', // Fallback active, showing Flash
-            },
+    describe('Footer Token Formatting', () => {
+        const renderWithTokens = async (tokens) => {
+            const result = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
+                width: 120,
+                uiState: {
+                    sessionStats: {
+                        ...mockSessionStats,
+                        metrics: {
+                            ...mockSessionStats.metrics,
+                            models: {
+                                'gemini-pro': {
+                                    api: {
+                                        totalRequests: 0,
+                                        totalErrors: 0,
+                                        totalLatencyMs: 0,
+                                    },
+                                    tokens: {
+                                        input: 0,
+                                        prompt: 0,
+                                        candidates: 0,
+                                        total: tokens,
+                                        cached: 0,
+                                        thoughts: 0,
+                                        tool: 0,
+                                    },
+                                    roles: {},
+                                },
+                            },
+                        },
+                    },
+                },
+                settings: createMockSettings({
+                    ui: {
+                        footer: {
+                            items: ['token-count'],
+                        },
+                    },
+                }),
+            });
+            await result.waitUntilReady();
+            return result;
+        };
+        it('formats thousands with k', async () => {
+            const { lastFrame, unmount } = await renderWithTokens(1500);
+            expect(lastFrame()).toContain('1.5k tokens');
+            unmount();
+        });
+        it('formats millions with m', async () => {
+            const { lastFrame, unmount } = await renderWithTokens(1500000);
+            expect(lastFrame()).toContain('1.5m tokens');
+            unmount();
+        });
+        it('formats billions with b', async () => {
+            const { lastFrame, unmount } = await renderWithTokens(1500000000);
+            expect(lastFrame()).toContain('1.5b tokens');
+            unmount();
+        });
+        it('formats small numbers without suffix', async () => {
+            const { lastFrame, unmount } = await renderWithTokens(500);
+            expect(lastFrame()).toContain('500 tokens');
+            unmount();
         });
-        // Footer should show the effective model (Flash), not the config model (Pro)
-        expect(lastFrame()).toContain('gemini-2.5-flash');
-        expect(lastFrame()).not.toContain('gemini-2.5-pro');
     });
-    it('should display Pro model when NOT in fallback mode', () => {
-        const { lastFrame } = renderWithProviders(_jsx(Footer, {}), {
-            width: 120,
-            uiState: {
-                sessionStats: mockSessionStats,
-                currentModel: 'gemini-2.5-pro', // Normal mode, showing Pro
-            },
+    describe('error summary visibility', () => {
+        beforeEach(() => {
+            mocks.isDevelopment = false;
+        });
+        afterEach(() => {
+            mocks.isDevelopment = false;
+        });
+        it('hides error summary in low verbosity mode out of dev mode', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
+                width: 120,
+                uiState: {
+                    sessionStats: mockSessionStats,
+                    errorCount: 2,
+                    showErrorDetails: false,
+                },
+                settings: createMockSettings({ ui: { errorVerbosity: 'low' } }),
+            });
+            expect(lastFrame()).not.toContain('F12 for details');
+            unmount();
+        });
+        it('shows error summary in low verbosity mode in dev mode', async () => {
+            mocks.isDevelopment = true;
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
+                width: 120,
+                uiState: {
+                    sessionStats: mockSessionStats,
+                    errorCount: 2,
+                    showErrorDetails: false,
+                },
+                settings: createMockSettings({ ui: { errorVerbosity: 'low' } }),
+            });
+            expect(lastFrame()).toContain('F12 for details');
+            expect(lastFrame()).toContain('2 errors');
+            unmount();
+        });
+        it('shows error summary in full verbosity mode', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
+                width: 120,
+                uiState: {
+                    sessionStats: mockSessionStats,
+                    errorCount: 2,
+                    showErrorDetails: false,
+                },
+                settings: createMockSettings({ ui: { errorVerbosity: 'full' } }),
+            });
+            expect(lastFrame()).toContain('F12 for details');
+            expect(lastFrame()).toContain('2 errors');
+            unmount();
+        });
+    });
+    describe('Footer Custom Items', () => {
+        it('renders auth item with email', async () => {
+            const authConfig = {
+                ...mockConfigPlain,
+                getContentGeneratorConfig: () => ({
+                    authType: AuthType.LOGIN_WITH_GOOGLE,
+                }),
+            };
+            const getCachedAccountSpy = vi
+                .spyOn(UserAccountManager.prototype, 'getCachedGoogleAccount')
+                .mockReturnValue('test@example.com');
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: authConfig,
+                width: 120,
+                uiState: {
+                    currentModel: 'gemini-pro',
+                    sessionStats: mockSessionStats,
+                },
+                settings: createMockSettings({
+                    ui: {
+                        footer: {
+                            items: ['auth'],
+                        },
+                    },
+                }),
+            });
+            expect(lastFrame()).toContain('auth');
+            expect(lastFrame()).toContain('test@example.com');
+            unmount();
+            getCachedAccountSpy.mockRestore();
+        });
+        it('does NOT render auth item when showUserIdentity is false', async () => {
+            const authConfig = {
+                ...mockConfigPlain,
+                getContentGeneratorConfig: () => ({
+                    authType: AuthType.LOGIN_WITH_GOOGLE,
+                }),
+            };
+            const getCachedAccountSpy = vi
+                .spyOn(UserAccountManager.prototype, 'getCachedGoogleAccount')
+                .mockReturnValue('test@example.com');
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: authConfig,
+                width: 120,
+                uiState: {
+                    currentModel: 'gemini-pro',
+                    sessionStats: mockSessionStats,
+                },
+                settings: createMockSettings({
+                    ui: {
+                        showUserIdentity: false,
+                        footer: {
+                            items: ['workspace', 'auth'],
+                        },
+                    },
+                }),
+            });
+            const output = lastFrame();
+            expect(output).toContain('workspace');
+            expect(output).not.toContain('auth');
+            expect(output).not.toContain('test@example.com');
+            unmount();
+            getCachedAccountSpy.mockRestore();
+        });
+        it('renders items in the specified order', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
+                width: 120,
+                uiState: {
+                    currentModel: 'gemini-pro',
+                    sessionStats: mockSessionStats,
+                },
+                settings: createMockSettings({
+                    ui: {
+                        footer: {
+                            items: ['model-name', 'workspace'],
+                        },
+                    },
+                }),
+            });
+            const output = lastFrame();
+            const modelIdx = output.indexOf('/model');
+            const cwdIdx = output.indexOf('workspace (/directory)');
+            expect(modelIdx).toBeLessThan(cwdIdx);
+            unmount();
+        });
+        it('renders multiple items with proper alignment', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
+                width: 120,
+                uiState: {
+                    sessionStats: mockSessionStats,
+                    branchName: 'main',
+                },
+                settings: createMockSettings({
+                    vimMode: {
+                        vimMode: true,
+                    },
+                    ui: {
+                        footer: {
+                            items: ['workspace', 'git-branch', 'sandbox', 'model-name'],
+                        },
+                    },
+                }),
+            });
+            const output = lastFrame();
+            expect(output).toBeDefined();
+            // Headers should be present
+            expect(output).toContain('workspace (/directory)');
+            expect(output).toContain('branch');
+            expect(output).toContain('sandbox');
+            expect(output).toContain('/model');
+            // Data should be present
+            expect(output).toContain('main');
+            expect(output).toContain('gemini-pro');
+            unmount();
+        });
+        it('handles empty items array', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
+                width: 120,
+                uiState: { sessionStats: mockSessionStats },
+                settings: createMockSettings({
+                    ui: {
+                        footer: {
+                            items: [],
+                        },
+                    },
+                }),
+            });
+            // Wait for Ink to render
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            const output = lastFrame({ allowEmpty: true });
+            expect(output).toBeDefined();
+            expect(output.trim()).toBe('');
+            unmount();
+        });
+        it('does not render items that are conditionally hidden', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
+                width: 120,
+                uiState: {
+                    sessionStats: mockSessionStats,
+                    branchName: undefined, // No branch
+                },
+                settings: createMockSettings({
+                    ui: {
+                        footer: {
+                            items: ['workspace', 'git-branch', 'model-name'],
+                        },
+                    },
+                }),
+            });
+            const output = lastFrame();
+            expect(output).toBeDefined();
+            expect(output).not.toContain('branch');
+            expect(output).toContain('workspace (/directory)');
+            expect(output).toContain('/model');
+            unmount();
+        });
+    });
+    describe('fallback mode display', () => {
+        it('should display Flash model when in fallback mode, not the configured Pro model', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
+                width: 120,
+                uiState: {
+                    sessionStats: mockSessionStats,
+                    currentModel: 'gemini-2.5-flash', // Fallback active, showing Flash
+                },
+            });
+            // Footer should show the effective model (Flash), not the config model (Pro)
+            expect(lastFrame()).toContain('gemini-2.5-flash');
+            expect(lastFrame()).not.toContain('gemini-2.5-pro');
+            unmount();
+        });
+        it('should display Pro model when NOT in fallback mode', async () => {
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(Footer, {}), {
+                config: mockConfig,
+                width: 120,
+                uiState: {
+                    sessionStats: mockSessionStats,
+                    currentModel: 'gemini-2.5-pro', // Normal mode, showing Pro
+                },
+            });
+            expect(lastFrame()).toContain('gemini-2.5-pro');
+            unmount();
         });
-        expect(lastFrame()).toContain('gemini-2.5-pro');
     });
 });
 //# sourceMappingURL=Footer.test.js.map