arbiter-ai 1.0.0

package/dist/state.test.js

@@ -0,0 +1,194 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { addMessage, clearCurrentOrchestrator, createInitialState, setCurrentOrchestrator, setMode, toRoman, updateArbiterContext, updateOrchestratorContext, updateOrchestratorTool, } from './state.js';
+describe('state', () => {
+    describe('createInitialState', () => {
+        it('should create state with default values', () => {
+            const state = createInitialState();
+            expect(state.mode).toBe('human_to_arbiter');
+            expect(state.arbiterSessionId).toBeNull();
+            expect(state.arbiterContextPercent).toBe(0);
+            expect(state.currentOrchestrator).toBeNull();
+            expect(state.conversationLog).toEqual([]);
+            expect(state.crashCount).toBe(0);
+            expect(state.requirementsPath).toBeNull();
+        });
+        it('should create independent state objects', () => {
+            const state1 = createInitialState();
+            const state2 = createInitialState();
+            state1.crashCount = 5;
+            expect(state2.crashCount).toBe(0);
+        });
+    });
+    describe('updateArbiterContext', () => {
+        let state;
+        beforeEach(() => {
+            state = createInitialState();
+        });
+        it('should update arbiter context percentage', () => {
+            updateArbiterContext(state, 50);
+            expect(state.arbiterContextPercent).toBe(50);
+        });
+        it('should allow 0 percent', () => {
+            updateArbiterContext(state, 0);
+            expect(state.arbiterContextPercent).toBe(0);
+        });
+        it('should allow 100 percent', () => {
+            updateArbiterContext(state, 100);
+            expect(state.arbiterContextPercent).toBe(100);
+        });
+    });
+    describe('updateOrchestratorContext', () => {
+        let state;
+        beforeEach(() => {
+            state = createInitialState();
+        });
+        it('should do nothing when no orchestrator is set', () => {
+            updateOrchestratorContext(state, 50);
+            expect(state.currentOrchestrator).toBeNull();
+        });
+        it('should update orchestrator context when one exists', () => {
+            setCurrentOrchestrator(state, { id: 'test-id', sessionId: 'session-1', number: 1 });
+            updateOrchestratorContext(state, 75);
+            expect(state.currentOrchestrator?.contextPercent).toBe(75);
+        });
+    });
+    describe('setCurrentOrchestrator', () => {
+        let state;
+        beforeEach(() => {
+            state = createInitialState();
+        });
+        it('should set orchestrator with provided values', () => {
+            setCurrentOrchestrator(state, { id: 'orch-123', sessionId: 'sess-456', number: 2 });
+            expect(state.currentOrchestrator).toEqual({
+                id: 'orch-123',
+                sessionId: 'sess-456',
+                number: 2,
+                contextPercent: 0,
+                currentTool: null,
+                toolCallCount: 0,
+            });
+        });
+        it('should replace existing orchestrator', () => {
+            setCurrentOrchestrator(state, { id: 'first', sessionId: 'sess-1', number: 1 });
+            setCurrentOrchestrator(state, { id: 'second', sessionId: 'sess-2', number: 2 });
+            expect(state.currentOrchestrator?.id).toBe('second');
+            expect(state.currentOrchestrator?.number).toBe(2);
+        });
+    });
+    describe('clearCurrentOrchestrator', () => {
+        let state;
+        beforeEach(() => {
+            state = createInitialState();
+        });
+        it('should clear orchestrator when one exists', () => {
+            setCurrentOrchestrator(state, { id: 'test', sessionId: 'sess', number: 1 });
+            clearCurrentOrchestrator(state);
+            expect(state.currentOrchestrator).toBeNull();
+        });
+        it('should be safe to call when no orchestrator exists', () => {
+            clearCurrentOrchestrator(state);
+            expect(state.currentOrchestrator).toBeNull();
+        });
+    });
+    describe('setMode', () => {
+        let state;
+        beforeEach(() => {
+            state = createInitialState();
+        });
+        it('should set mode to arbiter_to_orchestrator', () => {
+            setMode(state, 'arbiter_to_orchestrator');
+            expect(state.mode).toBe('arbiter_to_orchestrator');
+        });
+        it('should set mode back to human_to_arbiter', () => {
+            setMode(state, 'arbiter_to_orchestrator');
+            setMode(state, 'human_to_arbiter');
+            expect(state.mode).toBe('human_to_arbiter');
+        });
+    });
+    describe('addMessage', () => {
+        let state;
+        beforeEach(() => {
+            state = createInitialState();
+        });
+        it('should add message to empty conversation log', () => {
+            addMessage(state, 'human', 'Hello');
+            expect(state.conversationLog).toHaveLength(1);
+            expect(state.conversationLog[0].speaker).toBe('human');
+            expect(state.conversationLog[0].text).toBe('Hello');
+            expect(state.conversationLog[0].timestamp).toBeInstanceOf(Date);
+        });
+        it('should add multiple messages in order', () => {
+            addMessage(state, 'human', 'First');
+            addMessage(state, 'arbiter', 'Second');
+            addMessage(state, 'Orchestrator I', 'Third');
+            expect(state.conversationLog).toHaveLength(3);
+            expect(state.conversationLog[0].speaker).toBe('human');
+            expect(state.conversationLog[1].speaker).toBe('arbiter');
+            expect(state.conversationLog[2].speaker).toBe('Orchestrator I');
+        });
+        it('should accept any string as speaker', () => {
+            addMessage(state, 'Orchestrator II', 'Test');
+            expect(state.conversationLog[0].speaker).toBe('Orchestrator II');
+        });
+    });
+    describe('updateOrchestratorTool', () => {
+        let state;
+        beforeEach(() => {
+            state = createInitialState();
+        });
+        it('should do nothing when no orchestrator is set', () => {
+            updateOrchestratorTool(state, 'Edit', 5);
+            expect(state.currentOrchestrator).toBeNull();
+        });
+        it('should update tool info when orchestrator exists', () => {
+            setCurrentOrchestrator(state, { id: 'test', sessionId: 'sess', number: 1 });
+            updateOrchestratorTool(state, 'Read', 10);
+            expect(state.currentOrchestrator?.currentTool).toBe('Read');
+            expect(state.currentOrchestrator?.toolCallCount).toBe(10);
+        });
+        it('should allow null tool', () => {
+            setCurrentOrchestrator(state, { id: 'test', sessionId: 'sess', number: 1 });
+            updateOrchestratorTool(state, 'Edit', 5);
+            updateOrchestratorTool(state, null, 0);
+            expect(state.currentOrchestrator?.currentTool).toBeNull();
+            expect(state.currentOrchestrator?.toolCallCount).toBe(0);
+        });
+    });
+    describe('toRoman', () => {
+        it('should convert basic numbers', () => {
+            expect(toRoman(1)).toBe('I');
+            expect(toRoman(5)).toBe('V');
+            expect(toRoman(10)).toBe('X');
+            expect(toRoman(50)).toBe('L');
+            expect(toRoman(100)).toBe('C');
+            expect(toRoman(500)).toBe('D');
+            expect(toRoman(1000)).toBe('M');
+        });
+        it('should convert subtractive notation numbers', () => {
+            expect(toRoman(4)).toBe('IV');
+            expect(toRoman(9)).toBe('IX');
+            expect(toRoman(40)).toBe('XL');
+            expect(toRoman(90)).toBe('XC');
+            expect(toRoman(400)).toBe('CD');
+            expect(toRoman(900)).toBe('CM');
+        });
+        it('should convert complex numbers', () => {
+            expect(toRoman(2)).toBe('II');
+            expect(toRoman(3)).toBe('III');
+            expect(toRoman(14)).toBe('XIV');
+            expect(toRoman(39)).toBe('XXXIX');
+            expect(toRoman(246)).toBe('CCXLVI');
+            expect(toRoman(789)).toBe('DCCLXXXIX');
+            expect(toRoman(2421)).toBe('MMCDXXI');
+            expect(toRoman(3999)).toBe('MMMCMXCIX');
+        });
+        it('should throw for numbers less than 1', () => {
+            expect(() => toRoman(0)).toThrow('Number must be between 1 and 3999');
+            expect(() => toRoman(-1)).toThrow('Number must be between 1 and 3999');
+        });
+        it('should throw for numbers greater than 3999', () => {
+            expect(() => toRoman(4000)).toThrow('Number must be between 1 and 3999');
+            expect(() => toRoman(10000)).toThrow('Number must be between 1 and 3999');
+        });
+    });
+});

package/dist/test-headless.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test-headless.js

@@ -0,0 +1,155 @@
+// Headless test script for Arbiter core functionality
+// Tests the Router and State without TUI
+import { Router } from './router.js';
+import { createInitialState } from './state.js';
+// Test timeout in milliseconds
+const TEST_TIMEOUT_MS = 120000;
+// Track if we've received responses
+let arbiterResponseCount = 0;
+let orchestratorResponseCount = 0;
+let testComplete = false;
+/**
+ * Create mock callbacks that log to console
+ */
+function createMockCallbacks() {
+    return {
+        onHumanMessage: (text) => {
+            console.log('\n=== HUMAN MESSAGE ===');
+            console.log(text);
+            console.log('======================\n');
+        },
+        onArbiterMessage: (text) => {
+            console.log('\n=== ARBITER MESSAGE ===');
+            console.log(text);
+            console.log('========================\n');
+            arbiterResponseCount++;
+        },
+        onOrchestratorMessage: (orchestratorNumber, text) => {
+            console.log(`\n=== ORCHESTRATOR ${orchestratorNumber} MESSAGE ===`);
+            console.log(text);
+            console.log('================================\n');
+            orchestratorResponseCount++;
+        },
+        onContextUpdate: (arbiterPercent, orchestratorPercent) => {
+            console.log(`[Context] Arbiter: ${arbiterPercent.toFixed(1)}%, Orchestrator: ${orchestratorPercent !== null ? `${orchestratorPercent.toFixed(1)}%` : 'N/A'}`);
+        },
+        onToolUse: (tool, count) => {
+            console.log(`[Tool Use] ${tool} (total calls: ${count})`);
+        },
+        onModeChange: (mode) => {
+            console.log(`[Mode Changed] ${mode}`);
+        },
+    };
+}
+/**
+ * Sleep for a specified number of milliseconds
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Main test function
+ */
+async function runTest() {
+    console.log('===========================================');
+    console.log('  ARBITER HEADLESS TEST');
+    console.log('===========================================\n');
+    // Create initial state
+    console.log('[Setup] Creating initial state...');
+    const state = createInitialState();
+    console.log('[Setup] Initial state created:', JSON.stringify(state, null, 2));
+    // Create mock callbacks
+    console.log('[Setup] Creating mock callbacks...');
+    const callbacks = createMockCallbacks();
+    // Create router
+    console.log('[Setup] Creating router...');
+    const router = new Router(state, callbacks);
+    // Set up timeout
+    const timeoutId = setTimeout(async () => {
+        console.log('\n[Timeout] Test timeout reached (120 seconds)');
+        console.log('[Cleanup] Stopping router...');
+        testComplete = true;
+        await router.stop();
+        printSummary();
+        process.exit(0);
+    }, TEST_TIMEOUT_MS);
+    try {
+        // Start the router (initializes Arbiter session)
+        console.log('\n[Test] Starting router (initializing Arbiter session)...');
+        await router.start();
+        console.log('\n[Test] Router started.');
+        // Send first test message
+        console.log("\n[Test] Sending first message: 'Hello, what are you?'");
+        await router.sendHumanMessage('Hello, what are you?');
+        // Wait for first response before sending second message
+        console.log('[Test] Waiting for Arbiter response...');
+        const startTime = Date.now();
+        while (arbiterResponseCount === 0 && Date.now() - startTime < 60000) {
+            await sleep(500);
+        }
+        if (arbiterResponseCount === 0) {
+            console.log('[Warning] No Arbiter response after 60 seconds');
+        }
+        else {
+            console.log('[Test] First response received!');
+        }
+        // Send second test message immediately after receiving first response
+        console.log("\n[Test] Sending second message: 'Please spawn an orchestrator to list the files in the current directory'");
+        await router.sendHumanMessage('Please spawn an orchestrator to list the files in the current directory');
+        console.log('[Test] Waiting for Orchestrator to be spawned and do work...');
+        // Wait and check periodically
+        let waitTime = 0;
+        const checkInterval = 2000;
+        while (waitTime < TEST_TIMEOUT_MS - 15000 && !testComplete) {
+            await sleep(checkInterval);
+            waitTime += checkInterval;
+            console.log(`[Status] Elapsed: ${waitTime / 1000}s, Arbiter responses: ${arbiterResponseCount}, Orchestrator responses: ${orchestratorResponseCount}`);
+            // If orchestrator has responded, we can consider the test successful
+            if (orchestratorResponseCount > 0) {
+                console.log('\n[Success] Orchestrator has responded!');
+                await sleep(3000); // Give a bit more time for any final responses
+                break;
+            }
+        }
+        // Clean up
+        clearTimeout(timeoutId);
+        console.log('\n[Cleanup] Stopping router...');
+        await router.stop();
+        printSummary();
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        console.error('\n[Error] Test failed with error:');
+        console.error(error);
+        try {
+            await router.stop();
+        }
+        catch (stopError) {
+            console.error('[Error] Failed to stop router:', stopError);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Print test summary
+ */
+function printSummary() {
+    console.log('\n===========================================');
+    console.log('  TEST SUMMARY');
+    console.log('===========================================');
+    console.log(`Arbiter responses received: ${arbiterResponseCount}`);
+    console.log(`Orchestrator responses received: ${orchestratorResponseCount}`);
+    console.log(`Test result: ${arbiterResponseCount > 0 ? 'PASSED (received Arbiter response)' : 'NEEDS REVIEW'}`);
+    console.log('===========================================\n');
+}
+// Run the test
+console.log('[Init] Starting headless test...\n');
+runTest()
+    .then(() => {
+    console.log('[Done] Test completed.');
+    process.exit(0);
+})
+    .catch((error) => {
+    console.error('[Fatal] Unhandled error:', error);
+    process.exit(1);
+});

package/dist/tui/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * TUI module entry point
+ * RPG-style terminal interface with wizard council theme
+ *
+ * This module uses a terminal-kit based implementation with Strategy 5
+ * (minimal redraws) for flicker-free animation and input handling.
+ */
+export type { DebugLogEntry, RouterCallbacks } from '../router.js';
+export { type CharacterSelectResult, showCharacterSelect, } from './screens/CharacterSelect-termkit.js';
+export { showForestIntro } from './screens/ForestIntro-termkit.js';
+export { checkGitignore } from './screens/GitignoreCheck-termkit.js';
+export { showTitleScreen } from './screens/TitleScreen-termkit.js';
+export { createTUI, type TUI } from './tui-termkit.js';
+export type { WaitingState } from './types.js';

package/dist/tui/index.js

@@ -0,0 +1,17 @@
+/**
+ * TUI module entry point
+ * RPG-style terminal interface with wizard council theme
+ *
+ * This module uses a terminal-kit based implementation with Strategy 5
+ * (minimal redraws) for flicker-free animation and input handling.
+ */
+// Re-export the terminal-kit based CharacterSelect
+export { showCharacterSelect, } from './screens/CharacterSelect-termkit.js';
+// Re-export the terminal-kit based ForestIntro
+export { showForestIntro } from './screens/ForestIntro-termkit.js';
+// Re-export the terminal-kit based GitignoreCheck
+export { checkGitignore } from './screens/GitignoreCheck-termkit.js';
+// Re-export the terminal-kit based TitleScreen
+export { showTitleScreen } from './screens/TitleScreen-termkit.js';
+// Re-export the terminal-kit based TUI
+export { createTUI } from './tui-termkit.js';

package/dist/tui/layout.d.ts

@@ -0,0 +1,30 @@
+import blessed from 'blessed';
+/**
+ * Layout elements interface - exposes all UI components
+ */
+export interface LayoutElements {
+    screen: blessed.Widgets.Screen;
+    titleBox: blessed.Widgets.BoxElement;
+    conversationBox: blessed.Widgets.BoxElement;
+    statusBox: blessed.Widgets.BoxElement;
+    inputBox: blessed.Widgets.TextboxElement;
+}
+/**
+ * Creates the blessed screen layout matching the architecture doc design
+ *
+ * Layout:
+ * - Full terminal takeover
+ * - Title area at top with "THE ARBITER" and subtitle
+ * - Main conversation area (scrollable)
+ * - Status bar showing Arbiter context %, Orchestrator context %, current tool
+ * - Input box at bottom with ">" prompt
+ */
+export declare function createLayout(): LayoutElements;
+/**
+ * Creates the input prompt line with box drawing characters
+ */
+export declare function createInputPrompt(width: number): string;
+/**
+ * Creates a horizontal separator line
+ */
+export declare function createSeparator(width: number): string;

package/dist/tui/layout.js

@@ -0,0 +1,200 @@
+// TUI layout configuration using blessed
+// Defines the screen layout, panels, and UI structure
+import blessed from 'blessed';
+/**
+ * Box drawing characters for roguelike aesthetic
+ */
+const BOX_CHARS = {
+    topLeft: '\u2554', // ╔
+    topRight: '\u2557', // ╗
+    bottomLeft: '\u255A', // ╚
+    bottomRight: '\u255D', // ╝
+    horizontal: '\u2550', // ═
+    vertical: '\u2551', // ║
+    leftT: '\u2560', // ╠
+    rightT: '\u2563', // ╣
+};
+/**
+ * Creates the blessed screen layout matching the architecture doc design
+ *
+ * Layout:
+ * - Full terminal takeover
+ * - Title area at top with "THE ARBITER" and subtitle
+ * - Main conversation area (scrollable)
+ * - Status bar showing Arbiter context %, Orchestrator context %, current tool
+ * - Input box at bottom with ">" prompt
+ */
+export function createLayout() {
+    // Create the main screen
+    const screen = blessed.screen({
+        smartCSR: true,
+        title: 'THE ARBITER',
+        fullUnicode: true,
+        dockBorders: true,
+        autoPadding: false,
+    });
+    // Title box at the top
+    const titleBox = blessed.box({
+        parent: screen,
+        top: 0,
+        left: 0,
+        width: '100%',
+        height: 4,
+        content: '',
+        tags: true,
+        style: {
+            fg: 'white',
+            bg: 'black',
+        },
+    });
+    // Set title content with box drawing characters
+    updateTitleContent(titleBox, screen.width);
+    // Main conversation area (scrollable)
+    const conversationBox = blessed.box({
+        parent: screen,
+        top: 4,
+        left: 0,
+        width: '100%',
+        height: '100%-10', // Leave room for status (3 lines) and input (3 lines)
+        content: '',
+        tags: true,
+        scrollable: true,
+        alwaysScroll: true,
+        scrollbar: {
+            ch: '\u2588', // █
+            style: {
+                fg: 'white',
+            },
+        },
+        mouse: true,
+        keys: true,
+        vi: true,
+        style: {
+            fg: 'white',
+            bg: 'black',
+            border: {
+                fg: 'white',
+            },
+        },
+        border: {
+            type: 'line',
+        },
+    });
+    // Override border characters to use double-line box drawing
+    conversationBox.border = {
+        type: 'line',
+        ch: ' ',
+        top: BOX_CHARS.horizontal,
+        bottom: BOX_CHARS.horizontal,
+        left: BOX_CHARS.vertical,
+        right: BOX_CHARS.vertical,
+    };
+    // Status bar area (3 lines)
+    const statusBox = blessed.box({
+        parent: screen,
+        bottom: 3,
+        left: 0,
+        width: '100%',
+        height: 4,
+        content: '',
+        tags: true,
+        style: {
+            fg: 'white',
+            bg: 'black',
+        },
+    });
+    // Input box at the bottom
+    const inputBox = blessed.textbox({
+        parent: screen,
+        bottom: 0,
+        left: 2, // Leave room for "> " prompt
+        width: '100%-2',
+        height: 3,
+        inputOnFocus: true,
+        mouse: true,
+        keys: true,
+        style: {
+            fg: 'white',
+            bg: 'black',
+            border: {
+                fg: 'white',
+            },
+        },
+        border: {
+            type: 'line',
+        },
+    });
+    // Create a fixed prompt label "> " that sits to the left of the input
+    const _promptLabel = blessed.text({
+        parent: screen,
+        bottom: 1,
+        left: 0,
+        width: 2,
+        height: 1,
+        content: '> ',
+        style: {
+            fg: 'white',
+            bg: 'black',
+        },
+    });
+    // Handle screen resize to update title width
+    screen.on('resize', () => {
+        updateTitleContent(titleBox, screen.width);
+        screen.render();
+    });
+    // Set up quit key bindings
+    screen.key(['escape', 'q', 'C-c'], () => {
+        return process.exit(0);
+    });
+    return {
+        screen,
+        titleBox,
+        conversationBox,
+        statusBox,
+        inputBox,
+    };
+}
+/**
+ * Updates the title box content with proper width-based formatting
+ */
+function updateTitleContent(titleBox, width) {
+    const title = 'THE ARBITER';
+    const subtitle = 'OF THAT WHICH WAS, THAT WHICH IS, AND THAT WHICH SHALL COME TO BE';
+    // Calculate effective width (accounting for border characters)
+    const effectiveWidth = Math.max(width - 2, 80);
+    // Create top border
+    const topBorder = BOX_CHARS.topLeft + BOX_CHARS.horizontal.repeat(effectiveWidth) + BOX_CHARS.topRight;
+    // Center the title and subtitle
+    const titlePadding = Math.max(0, Math.floor((effectiveWidth - title.length) / 2));
+    const subtitlePadding = Math.max(0, Math.floor((effectiveWidth - subtitle.length) / 2));
+    const titleLine = BOX_CHARS.vertical +
+        ' '.repeat(titlePadding) +
+        `{bold}${title}{/bold}` +
+        ' '.repeat(effectiveWidth - titlePadding - title.length) +
+        BOX_CHARS.vertical;
+    const subtitleLine = BOX_CHARS.vertical +
+        ' '.repeat(subtitlePadding) +
+        subtitle +
+        ' '.repeat(Math.max(0, effectiveWidth - subtitlePadding - subtitle.length)) +
+        BOX_CHARS.vertical;
+    // Create separator
+    const separator = BOX_CHARS.leftT + BOX_CHARS.horizontal.repeat(effectiveWidth) + BOX_CHARS.rightT;
+    titleBox.setContent(`${topBorder}\n${titleLine}\n${subtitleLine}\n${separator}`);
+}
+/**
+ * Creates the input prompt line with box drawing characters
+ */
+export function createInputPrompt(width) {
+    const effectiveWidth = Math.max(width - 4, 76);
+    const promptLine = `${BOX_CHARS.vertical} > `;
+    const endLine = ' '.repeat(effectiveWidth) + BOX_CHARS.vertical;
+    const bottomBorder = BOX_CHARS.bottomLeft + BOX_CHARS.horizontal.repeat(width - 2) + BOX_CHARS.bottomRight;
+    return `${promptLine + endLine}\n${bottomBorder}`;
+}
+/**
+ * Creates a horizontal separator line
+ */
+export function createSeparator(width) {
+    const effectiveWidth = Math.max(width - 2, 78);
+    return BOX_CHARS.leftT + BOX_CHARS.horizontal.repeat(effectiveWidth) + BOX_CHARS.rightT;
+}

package/dist/tui/render.d.ts

@@ -0,0 +1,57 @@
+import type { LayoutElements } from './layout.js';
+import { type AppState } from '../state.js';
+/**
+ * Generates animated dots text based on current animation frame
+ * Cycles through: "Working." -> "Working.." -> "Working..."
+ * @param baseText - The base text to animate (e.g., "Working" or "Waiting for Arbiter")
+ * @returns The text with animated dots appended
+ */
+export declare function getAnimatedDots(baseText: string): string;
+/**
+ * Advances the animation frame for the loading dots
+ * Should be called by an interval timer
+ */
+export declare function advanceAnimation(): void;
+/**
+ * Resets the animation frame to 0
+ */
+export declare function resetAnimation(): void;
+/**
+ * Renders the conversation log to the conversation box
+ * Formats messages with speakers (You:, Arbiter:, Orchestrator I:, etc.)
+ */
+export declare function renderConversation(elements: LayoutElements, state: AppState): void;
+/**
+ * Waiting state enum for different waiting scenarios
+ */
+export type WaitingState = 'none' | 'arbiter' | 'orchestrator';
+/**
+ * Renders the status bar with context percentages and current tool
+ *
+ * When orchestrator is active:
+ * ║  Arbiter ─────────────────────────────────────────────────── ██░░░░░░░░ 18%    ║
+ * ║  Orchestrator I ──────────────────────────────────────────── ████████░░ 74%    ║
+ * ║  ◈ Edit (12)                                                                   ║
+ *
+ * When no orchestrator (Arbiter speaks to human):
+ * ║  Arbiter ─────────────────────────────────────────────────── ██░░░░░░░░ 18%    ║
+ * ║  Awaiting your command.                                                        ║
+ *
+ * @param waitingState - Optional waiting state to show animated dots
+ */
+export declare function renderStatus(elements: LayoutElements, state: AppState, waitingState?: WaitingState): void;
+/**
+ * Creates an ASCII progress bar
+ * @param percent - Current percentage (0-100)
+ * @param width - Total width of the progress bar
+ * @returns Progress bar string like "████████░░"
+ */
+export declare function renderProgressBar(percent: number, width: number): string;
+/**
+ * Renders the input area with prompt
+ */
+export declare function renderInputArea(elements: LayoutElements): void;
+/**
+ * Updates the entire display
+ */
+export declare function renderAll(elements: LayoutElements, state: AppState): void;