idlerpg.sh 0.1.0

package/dist/main.js

@@ -0,0 +1,2816 @@
+#!/usr/bin/env node
+/**
+ * IDLERPG.TERMINAL - Main Entry Point
+ * An AI-native game that lives in your terminal.
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="bfa08172-04b0-56af-9640-104baeb3ae89")}catch(e){}}();
+import { getIdleGameManager } from './core/IdleGameManager.js';
+import { adaptIdleGameStateToGameState } from './core/StateAdapter.js';
+import { getRouter } from './app/Router.js';
+import { getEventBus } from './app/EventBus.js';
+import { getCommandRegistry } from './commands/index.js';
+import { initiateLogin, completeLogin, generateQRCode, getAIClient, tryRestoreAuth, setNickname, getNickname, logout } from './ai/PlayKitClient.js';
+import { getGameUI, getScreen, getInput, ANSI } from './tui/index.js';
+import { getNPCManager } from './npc/NPCManager.js';
+import { getQuestManager } from './quest/QuestManager.js';
+import { getNPCGenerator } from './npc/NPCGenerator.js';
+import { saveGame, loadGame, listSaveSlots, formatPlayTime, formatTimestamp } from './core/SaveManager.js';
+import { getAffixRegistry } from './affix/AffixRegistry.js';
+import { migrateConfigDirectory } from './utils/configMigration.js';
+import { Sentry } from './instrument.js';
+import { createActor } from './core/Actor.js';
+import { createTeamWithActor } from './core/Team.js';
+import { NewGameFlowManager } from './core/NewGameFlowManager.js';
+import { TitleScreenHandler, DialogHandler, SaveLoadHandler, WorkshopHandler, } from './handlers/index.js';
+// Run config migration early (before any config files are accessed)
+migrateConfigDirectory();
+// Spinner frames for loading animation
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/**
+ * Main Application class
+ */
+class IdleRPGTerminal {
+    idleGameManager;
+    ui = getGameUI();
+    screen = getScreen();
+    input = getInput();
+    npcManager = getNPCManager();
+    questManager = getQuestManager();
+    router = getRouter();
+    bus = getEventBus();
+    commandRegistry = getCommandRegistry();
+    isRunning = false;
+    isInFullScreenMode = false; // For character creation, prologue, etc.
+    // Handlers - extracted functionality for better organization
+    titleScreenHandler;
+    dialogHandler;
+    saveLoadHandler;
+    workshopHandler;
+    constructor() {
+        this.idleGameManager = getIdleGameManager();
+        // Initialize handlers
+        this.titleScreenHandler = new TitleScreenHandler(this.screen, this.input, () => this.cleanup());
+        this.dialogHandler = new DialogHandler({
+            ui: this.ui,
+            screen: this.screen,
+            input: this.input,
+            idleGameManager: this.idleGameManager,
+            router: this.router,
+            bus: this.bus,
+            npcManager: this.npcManager,
+            questManager: this.questManager,
+            addLog: (msg) => this.ui.addEventLog(msg),
+        });
+        this.saveLoadHandler = new SaveLoadHandler(this.idleGameManager, this.npcManager, this.questManager, (msg) => this.ui.addEventLog(msg));
+        this.workshopHandler = new WorkshopHandler(this.idleGameManager, (msg) => this.ui.addEventLog(msg));
+        this.setupRouterNavigation();
+        this.setupEventBusSubscriptions();
+        this.setupCommands();
+    }
+    /**
+     * Set up command registry with all game commands
+     */
+    setupCommands() {
+        // Create command context
+        const context = {
+            gameManager: this.idleGameManager,
+            router: this.router,
+            bus: this.bus,
+            log: (msg) => this.ui.addEventLog(msg),
+        };
+        this.commandRegistry.setContext(context);
+        // Register navigation commands
+        this.commandRegistry.registerAll([
+            {
+                name: 'map',
+                aliases: ['m'],
+                description: 'Show the map panel',
+                category: 'navigation',
+                execute: () => {
+                    this.ui.addEventLog('Map is displayed on the left panel.');
+                },
+            },
+            {
+                name: 'travel',
+                aliases: ['t'],
+                description: 'Show available facilities',
+                category: 'navigation',
+                execute: () => this.handleTravelCommand(),
+                isAvailable: (ctx) => ctx.gameManager.getState()?.phase === 'in_town',
+            },
+            {
+                name: 'dungeon',
+                aliases: ['d'],
+                description: 'Show available dungeons',
+                category: 'navigation',
+                execute: () => this.handleDungeonCommand(),
+                isAvailable: (ctx) => ctx.gameManager.getState()?.phase === 'in_town',
+            },
+            {
+                name: 'npc',
+                aliases: ['n'],
+                description: 'Talk to NPCs',
+                category: 'navigation',
+                execute: () => this.handleNPCCommand(),
+            },
+        ]);
+        // Register system commands
+        this.commandRegistry.registerAll([
+            {
+                name: 'help',
+                aliases: ['h', '?'],
+                description: 'Show help',
+                category: 'system',
+                execute: () => this.showHelp(),
+            },
+            {
+                name: 'save',
+                description: 'Save the game',
+                category: 'system',
+                execute: () => this.saveLoadHandler.handleSaveCommand(),
+            },
+            {
+                name: 'load',
+                description: 'Load a saved game',
+                category: 'system',
+                execute: () => this.saveLoadHandler.handleLoadCommand(),
+            },
+            {
+                name: 'newgame',
+                description: 'Start a new game',
+                category: 'system',
+                execute: () => this.handleNewGameCommand(),
+            },
+            {
+                name: 'quit',
+                aliases: ['exit'],
+                description: 'Exit the game',
+                category: 'system',
+                execute: () => { this.isRunning = false; },
+            },
+        ]);
+    }
+    /**
+     * Set up EventBus subscriptions for cross-component communication
+     */
+    setupEventBusSubscriptions() {
+        // Subscribe to UI log events
+        this.bus.subscribe('ui:log', ({ message }) => {
+            this.ui.addEventLog(message);
+        });
+    }
+    /**
+     * Set up IdleGameManager callbacks with EventBus bridging
+     */
+    setupIdleGameCallbacks() {
+        this.idleGameManager.setCallbacks({
+            onPhaseChange: (phase, state) => {
+                this.bus.dispatch('idle:phaseChange', {
+                    phase: phase,
+                    town: state.currentTown,
+                    dungeon: state.currentDungeon
+                });
+                this.onIdlePhaseChange(phase, state);
+            },
+            onPlayerUpdate: (p) => {
+                this.bus.dispatch('player:update', { player: p });
+                this.onIdlePlayerUpdate(p);
+            },
+            onDungeonProgress: (runnerState, combat) => {
+                this.bus.dispatch('idle:dungeonProgress', { runnerState, combat });
+                this.onDungeonProgress(runnerState, combat);
+            },
+            onEventLog: (message) => {
+                this.bus.log(message);
+            },
+            onTravelProgress: (progress, duration) => {
+                this.bus.dispatch('travel:progress', { progress, duration });
+                this.onTravelProgress(progress, duration);
+            },
+            onDungeonComplete: (success, rewards) => {
+                this.bus.dispatch('idle:dungeonComplete', { success, rewards });
+                this.onDungeonComplete(success, rewards);
+            },
+            onPlayerDeath: () => {
+                this.bus.dispatch('player:death', undefined);
+                this.onPlayerDeath();
+            },
+        });
+    }
+    /**
+     * Set up router navigation listener
+     * Maps route changes to UI mode changes
+     */
+    setupRouterNavigation() {
+        this.router.onNavigate((route, prev) => {
+            this.handleRouteChange(route, prev);
+        });
+        this.router.onBack((route) => {
+            this.handleRouteChange(route, null);
+        });
+    }
+    /**
+     * Handle route changes and update UI accordingly
+     */
+    handleRouteChange(route, prev) {
+        switch (route.type) {
+            case 'explore':
+                this.ui.setMode('explore');
+                // Clear any selection modes
+                this.npcSelectionMode = false;
+                this.dungeonSelectionMode = false;
+                break;
+            case 'dialog':
+                this.ui.setMode('dialog');
+                break;
+            case 'travel':
+                this.ui.setMode('travel');
+                break;
+            case 'combat':
+                this.ui.setMode('combat');
+                break;
+            case 'dungeon':
+                this.ui.setMode('explore');
+                this.ui.enterDungeonMode();
+                break;
+            case 'npcSelection':
+                // NPC selection is a sub-mode within explore
+                this.npcSelectionMode = true;
+                break;
+            case 'dungeonSelection':
+                // Dungeon selection is a sub-mode within explore
+                this.dungeonSelectionMode = true;
+                break;
+            case 'save':
+                // Save mode handled by SaveLoadHandler
+                break;
+            case 'load':
+                // Load mode handled by SaveLoadHandler
+                break;
+            case 'workshop':
+                // Workshop mode handled by WorkshopHandler
+                break;
+            case 'prologue':
+            case 'characterCreation':
+                this.isInFullScreenMode = true;
+                this.ui.pauseRendering();
+                break;
+            case 'dead':
+                // Dead state handled separately
+                break;
+            case 'gameover':
+                this.isRunning = false;
+                break;
+        }
+        // Handle leaving full-screen modes
+        if (prev?.type === 'prologue' || prev?.type === 'characterCreation') {
+            if (route.type !== 'prologue' && route.type !== 'characterCreation') {
+                this.isInFullScreenMode = false;
+                this.ui.resumeRendering();
+            }
+        }
+    }
+    // NPC interaction state
+    npcSelectionMode = false;
+    availableNPCs = [];
+    currentDialogNPC = null;
+    dialogHistory = [];
+    // Dungeon selection state
+    dungeonSelectionMode = false;
+    availableDungeons = [];
+    // AI error handling state
+    consecutiveAIFailures = 0;
+    MAX_CONSECUTIVE_FAILURES = 3;
+    /**
+     * Start the game
+     */
+    async start() {
+        try {
+            // Check terminal size first (before any UI)
+            await this.ensureMinimumTerminalSize();
+            // Show title screen and get player name (uses simple input, before full UI init)
+            const playerName = await this.showTitleScreen();
+            // Now initialize the full game UI (after title screen)
+            await this.ui.initialize();
+            // Initialize systems
+            await this.initializeSystems();
+            // Set up callbacks with EventBus bridging
+            this.setupIdleGameCallbacks();
+            // Check for existing saves to determine flow
+            const hasSaves = await this.checkForExistingSaves();
+            if (hasSaves) {
+                // Returning player: Initialize with their name (save will be loaded via menu)
+                this.initializeGame(playerName);
+                this.ui.addEventLog(`Welcome back, ${playerName}!`);
+                this.ui.addEventLog(`Type 'load' to continue your adventure, or 'newgame' to start fresh.`);
+            }
+            else {
+                // New player: Run the full New Game flow
+                const flowResult = await this.runNewGameFlowAndStart();
+                if (!flowResult) {
+                    // User cancelled - exit gracefully
+                    this.cleanup();
+                    process.exit(0);
+                }
+            }
+            // Set up command and event handlers
+            this.ui.onCommandInput((cmd) => this.handleCommand(cmd));
+            this.setupEventHandlers();
+            // Start main loop
+            await this.mainLoop();
+        }
+        catch (error) {
+            this.cleanup();
+            console.error('Fatal error:', error);
+            process.exit(1);
+        }
+    }
+    /**
+     * Check if any save files exist
+     */
+    async checkForExistingSaves() {
+        const slots = await listSaveSlots();
+        return slots.some(s => s.exists);
+    }
+    /**
+     * Run the New Game flow and initialize the game
+     * @returns true if successful, false if cancelled
+     */
+    async runNewGameFlowAndStart() {
+        this.isInFullScreenMode = true;
+        this.ui.pauseRendering(); // Stop GameUIAdapter refresh to prevent screen flicker
+        try {
+            const flowManager = new NewGameFlowManager(this.screen, this.input);
+            const result = await flowManager.run();
+            if (result.success && result.actor) {
+                // Create team and initialize game
+                const team = createTeamWithActor(result.actor, `${result.actor.name}'s Team`);
+                const actors = { [result.actor.id]: result.actor };
+                this.idleGameManager.initializeWithTeam(team, actors);
+                // Clear screen and show welcome
+                this.screen.clear();
+                this.ui.addEventLog(`══════════════════════════════════════`);
+                this.ui.addEventLog(`  Welcome, ${result.actor.name} the ${result.actor.role}!`);
+                this.ui.addEventLog(`  Your adventure begins...`);
+                this.ui.addEventLog(`══════════════════════════════════════`);
+                return true;
+            }
+            return false;
+        }
+        finally {
+            this.ui.resumeRendering(); // Always restore GameUIAdapter refresh
+            this.isInFullScreenMode = false;
+        }
+    }
+    /**
+     * Create a new team with the starting actor
+     * Team system is the core game design - always enabled
+     */
+    createTeamWithStartingActor(name) {
+        // Create the first actor with balanced role
+        const actor = createActor(name, 'balanced');
+        // Create a team with this actor
+        const team = createTeamWithActor(actor, `${name}'s Team`);
+        // Store actors in a record
+        const actors = { [actor.id]: actor };
+        return { team, actors };
+    }
+    /**
+     * Initialize the game with team mode (always enabled)
+     */
+    initializeGame(playerName) {
+        const { team, actors } = this.createTeamWithStartingActor(playerName);
+        this.idleGameManager.initializeWithTeam(team, actors);
+    }
+    /**
+     * Ensure terminal meets minimum size requirements
+     * Waits for user to resize if too small
+     */
+    async ensureMinimumTerminalSize() {
+        // Enter alternate screen buffer to avoid overlapping with terminal history
+        this.screen.enterAlternateScreen();
+        // Hide cursor during size check
+        this.screen.hideCursor();
+        const check = this.screen.checkMinimumSize();
+        if (check.valid) {
+            return; // Size is OK
+        }
+        // Show warning and wait for resize
+        this.screen.renderSizeWarning();
+        // Wait for resize to valid size
+        return new Promise((resolve) => {
+            const checkAndResolve = (width, height) => {
+                const newCheck = this.screen.checkMinimumSize();
+                if (newCheck.valid) {
+                    // Clear the warning
+                    this.screen.clear();
+                    this.screen.forceRedraw();
+                    resolve();
+                }
+                else {
+                    // Still too small, show warning again
+                    this.screen.renderSizeWarning();
+                }
+            };
+            // Register resize callback
+            this.screen.onResize(checkAndResolve);
+        });
+    }
+    /**
+     * Wait for Enter key to start login
+     */
+    async waitForLoginKey() {
+        return new Promise((resolve) => {
+            const handler = (key) => {
+                if (key.name === 'return') {
+                    this.input.offKey(handler);
+                    resolve();
+                }
+                else if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+                    this.cleanup();
+                    process.exit(0);
+                }
+            };
+            this.input.onKey(handler);
+        });
+    }
+    /**
+     * Show "Press Enter to start" and wait for Enter key
+     * Features: blinking text, Ctrl+C graceful exit, Ctrl+O logout
+     */
+    async waitForGameStart(playerName) {
+        const { width } = this.screen.getSize();
+        const centerX = Math.floor(width / 2);
+        this.screen.clear();
+        const logoY = this.drawAsciiTitle();
+        const contentY = logoY + 3;
+        // Show welcome message
+        const welcomeMsg = `Welcome, ${playerName}!`;
+        this.screen.write(centerX - Math.floor(welcomeMsg.length / 2), contentY, welcomeMsg, ANSI.fg.green);
+        // Show "Press Enter to start" with blinking effect
+        const startMsg = '▶  Press ENTER to Start  ◀';
+        const startMsgX = centerX - Math.floor(startMsg.length / 2);
+        const startMsgY = contentY + 3;
+        let blinkVisible = true;
+        // Blinking interval
+        const blinkInterval = setInterval(() => {
+            if (blinkVisible) {
+                this.screen.write(startMsgX, startMsgY, startMsg, ANSI.fg.cyan);
+            }
+            else {
+                this.screen.write(startMsgX, startMsgY, ' '.repeat(startMsg.length), ANSI.fg.cyan);
+            }
+            blinkVisible = !blinkVisible;
+            this.screen.forceRedraw();
+        }, 600);
+        // Initial draw
+        this.screen.write(startMsgX, startMsgY, startMsg, ANSI.fg.cyan);
+        // Show hint for logout
+        const logoutHint = 'Ctrl+O to logout';
+        this.screen.write(centerX - Math.floor(logoutHint.length / 2), startMsgY + 3, logoutHint, ANSI.fg.gray);
+        this.screen.forceRedraw();
+        // Wait for Enter
+        return new Promise((resolve) => {
+            const handler = async (key) => {
+                if (key.name === 'return') {
+                    clearInterval(blinkInterval);
+                    this.input.offKey(handler);
+                    resolve();
+                }
+                else if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+                    clearInterval(blinkInterval);
+                    this.input.offKey(handler);
+                    this.cleanup();
+                    process.exit(0);
+                }
+                else if (key.ctrl && key.name === 'o') {
+                    // Logout
+                    clearInterval(blinkInterval);
+                    this.input.offKey(handler);
+                    await this.handleLogout();
+                }
+            };
+            this.input.onKey(handler);
+        });
+    }
+    /**
+     * Handle logout from title screen
+     */
+    async handleLogout() {
+        const { width } = this.screen.getSize();
+        const centerX = Math.floor(width / 2);
+        this.screen.clear();
+        const logoY = this.drawAsciiTitle();
+        const contentY = logoY + 3;
+        this.screen.write(centerX - 10, contentY, 'Logging out...', ANSI.fg.yellow);
+        this.screen.forceRedraw();
+        try {
+            await logout();
+            this.screen.write(centerX - 15, contentY + 2, '✓ Logged out successfully', ANSI.fg.green);
+            this.screen.forceRedraw();
+            await this.sleep(1000);
+            // Restart the title screen flow
+            const playerName = await this.showTitleScreen();
+            // Continue with game start
+            await this.continueAfterLogin(playerName);
+        }
+        catch (error) {
+            this.screen.write(centerX - 10, contentY + 2, '✗ Logout failed', ANSI.fg.red);
+            this.screen.forceRedraw();
+            await this.sleep(1500);
+            // Restart anyway
+            const playerName = await this.showTitleScreen();
+            await this.continueAfterLogin(playerName);
+        }
+    }
+    /**
+     * Continue game after login (extracted to avoid duplication)
+     */
+    async continueAfterLogin(playerName) {
+        // Now initialize the full game UI (after title screen)
+        await this.ui.initialize();
+        // Initialize systems
+        await this.initializeSystems();
+        // Set up callbacks with EventBus bridging
+        this.setupIdleGameCallbacks();
+        // Initialize game (team or legacy mode based on USE_TEAM_MODE)
+        this.initializeGame(playerName);
+        this.ui.addEventLog(`Welcome to ${this.idleGameManager.getState()?.currentTown.name || 'town'}!`);
+        this.ui.addEventLog(`Your adventure begins, ${playerName}...`);
+        // Set up command and event handlers
+        this.ui.onCommandInput((cmd) => this.handleCommand(cmd));
+        this.setupEventHandlers();
+        // Start main loop
+        await this.mainLoop();
+    }
+    // ASCII Art Logo
+    static ASCII_LOGO = [
+        '██╗██████╗ ██╗     ███████╗██████╗ ██████╗  ██████╗ ',
+        '██║██╔══██╗██║     ██╔════╝██╔══██╗██╔══██╗██╔════╝ ',
+        '██║██║  ██║██║     █████╗  ██████╔╝██████╔╝██║  ███╗',
+        '██║██║  ██║██║     ██╔══╝  ██╔══██╗██╔═══╝ ██║   ██║',
+        '██║██████╔╝███████╗███████╗██║  ██║██║     ╚██████╔╝',
+        '╚═╝╚═════╝ ╚══════╝╚══════╝╚═╝  ╚═╝╚═╝      ╚═════╝ ',
+    ];
+    static ASCII_TERMINAL = [
+        '████████╗███████╗██████╗ ███╗   ███╗██╗███╗   ██╗ █████╗ ██╗     ',
+        '╚══██╔══╝██╔════╝██╔══██╗████╗ ████║██║████╗  ██║██╔══██╗██║     ',
+        '   ██║   █████╗  ██████╔╝██╔████╔██║██║██╔██╗ ██║███████║██║     ',
+        '   ██║   ██╔══╝  ██╔══██╗██║╚██╔╝██║██║██║╚██╗██║██╔══██║██║     ',
+        '   ██║   ███████╗██║  ██║██║ ╚═╝ ██║██║██║ ╚████║██║  ██║███████╗',
+        '   ╚═╝   ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝╚══════╝',
+    ];
+    static ASCII_COMPACT = [
+        ' ╔═══════════════════════════════════════╗',
+        ' ║  █ ████  █     █████ ████  ████   ██  ║',
+        ' ║  █ █   █ █     █     █   █ █   █ █    ║',
+        ' ║  █ █   █ █     ████  ████  ████  █ ██ ║',
+        ' ║  █ █   █ █     █     █   █ █     █  █ ║',
+        ' ║  █ ████  █████ █████ █   █ █      ██  ║',
+        ' ╠═══════════════════════════════════════╣',
+        ' ║      T E R M I N A L   v0.1.0         ║',
+        ' ╚═══════════════════════════════════════╝',
+    ];
+    /**
+     * Draw ASCII art title
+     */
+    drawAsciiTitle() {
+        const { width, height } = this.screen.getSize();
+        // Use compact logo for smaller terminals
+        const useCompact = width < 75;
+        const logo = useCompact ? IdleRPGTerminal.ASCII_COMPACT : IdleRPGTerminal.ASCII_LOGO;
+        const logoWidth = logo[0].length;
+        const logoX = Math.floor((width - logoWidth) / 2);
+        let y = 2;
+        // Draw ASCII logo
+        for (const line of logo) {
+            this.screen.write(Math.max(1, logoX), y++, line, ANSI.fg.cyan);
+        }
+        // Draw TERMINAL text (if using full logo)
+        if (!useCompact) {
+            y++;
+            const termX = Math.floor((width - IdleRPGTerminal.ASCII_TERMINAL[0].length) / 2);
+            for (const line of IdleRPGTerminal.ASCII_TERMINAL) {
+                this.screen.write(Math.max(1, termX), y++, line, ANSI.fg.yellow);
+            }
+        }
+        return y;
+    }
+    /**
+     * Show title screen and get player name with login flow
+     * Flow: Try restore auth -> if success, welcome back | else Enter -> show URL | Enter again -> open browser | Q -> show QR code (hide title)
+     */
+    async showTitleScreen() {
+        const { width, height } = this.screen.getSize();
+        this.screen.clear();
+        // Draw ASCII art
+        let y = this.drawAsciiTitle();
+        y += 2;
+        const centerX = Math.floor(width / 2);
+        // Tagline
+        const tagline = '~ An AI-native adventure that lives in your terminal ~';
+        this.screen.write(centerX - Math.floor(tagline.length / 2), y++, tagline, ANSI.fg.gray);
+        y++;
+        // Decorative line
+        const lineWidth = Math.min(50, width - 10);
+        const lineX = Math.floor((width - lineWidth) / 2);
+        this.screen.write(lineX, y++, '═'.repeat(lineWidth), ANSI.fg.gray);
+        y++;
+        const loginY = y;
+        // Start input (needed for key detection)
+        this.input.start();
+        this.input.setMode('raw');
+        // Show "Checking authentication..." while trying to restore
+        this.screen.write(centerX - 15, loginY, 'Checking authentication...', ANSI.fg.yellow);
+        this.screen.forceRedraw();
+        // Try to restore authentication from saved tokens
+        const restoreResult = await tryRestoreAuth();
+        if (restoreResult.success) {
+            // Authentication restored successfully!
+            this.screen.clear();
+            this.drawAsciiTitle();
+            const msg = restoreResult.needsRefresh
+                ? '✓ Session refreshed!'
+                : '✓ Welcome back!';
+            this.screen.write(centerX - 12, loginY, msg, ANSI.fg.green);
+            this.screen.forceRedraw();
+            // Get nickname from PlayKit
+            const nickname = await getNickname();
+            if (nickname) {
+                // Has nickname, wait for Enter to start game
+                await this.waitForGameStart(nickname);
+                return nickname;
+            }
+            else {
+                // No nickname set, prompt user to set one
+                this.screen.write(centerX - 15, loginY + 2, 'You need to set a nickname first', ANSI.fg.yellow);
+                this.screen.forceRedraw();
+                await this.sleep(1000);
+                const newNickname = await this.promptSetNickname();
+                await this.waitForGameStart(newNickname);
+                return newNickname;
+            }
+        }
+        // No saved auth or restore failed - show login UI
+        this.screen.clear();
+        this.drawAsciiTitle();
+        // Show "Press ENTER to login" message
+        this.screen.write(centerX - 15, loginY, 'Login required to play', ANSI.fg.gray);
+        this.screen.write(centerX - 15, loginY + 2, '▶  Press ENTER to Login  ◀', ANSI.fg.cyan);
+        this.screen.write(centerX - 10, loginY + 4, 'Esc to quit', ANSI.fg.gray);
+        this.screen.forceRedraw();
+        // Wait for Enter key
+        await this.waitForLoginKey();
+        // Now start the login process
+        let playerName = '';
+        let spinnerFrame = 0;
+        let spinnerInterval = null;
+        let showingQR = false;
+        let qrCode = '';
+        const startSpinner = () => {
+            spinnerInterval = setInterval(() => {
+                spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES.length;
+            }, 100);
+        };
+        const stopSpinner = () => {
+            if (spinnerInterval) {
+                clearInterval(spinnerInterval);
+                spinnerInterval = null;
+            }
+        };
+        const getSpinner = () => SPINNER_FRAMES[spinnerFrame];
+        try {
+            // Step 1: Show "Preparing login..." with spinner
+            this.screen.clear();
+            this.drawAsciiTitle();
+            this.screen.write(centerX - 15, loginY, `${getSpinner()} Preparing login...`, ANSI.fg.yellow);
+            this.screen.forceRedraw();
+            startSpinner();
+            // Initiate login to get URL
+            const loginInfo = await initiateLogin();
+            // Generate QR code in background (for when user presses Q)
+            qrCode = await generateQRCode(loginInfo.authUrl);
+            // Helper to redraw the waiting screen
+            const redrawWaitingScreen = () => {
+                this.screen.clear();
+                let contentY = 2;
+                if (!showingQR) {
+                    // Show with title
+                    contentY = this.drawAsciiTitle();
+                    contentY += 2;
+                    // Show URL
+                    this.screen.write(centerX - 10, contentY++, 'Please visit:', ANSI.fg.white);
+                    contentY++;
+                    const url = loginInfo.authUrl;
+                    const maxLen = width - 10;
+                    const displayUrl = url.length > maxLen ? url.slice(0, maxLen - 3) + '...' : url;
+                    this.screen.write(centerX - Math.floor(displayUrl.length / 2), contentY++, displayUrl, ANSI.fg.cyan);
+                    contentY += 2;
+                    // Status line
+                    this.screen.write(centerX - 18, contentY, `${getSpinner()} Waiting for authentication...`, ANSI.fg.yellow);
+                    contentY += 2;
+                    // Instructions
+                    this.screen.write(centerX - 20, contentY++, 'Enter: Open in browser', ANSI.fg.gray);
+                    this.screen.write(centerX - 20, contentY++, 'Q: Show QR code (hide title)', ANSI.fg.gray);
+                    this.screen.write(centerX - 20, contentY++, 'Esc: Cancel', ANSI.fg.gray);
+                }
+                else {
+                    // Show QR code only (no title, more space)
+                    contentY = 1;
+                    // Draw QR code
+                    const qrLines = qrCode.split('\n');
+                    for (const line of qrLines) {
+                        if (line.trim()) {
+                            this.screen.write(centerX - Math.floor(line.length / 2), contentY++, line, ANSI.fg.white);
+                        }
+                    }
+                    contentY++;
+                    // URL below QR
+                    const url = loginInfo.authUrl;
+                    const maxLen = width - 4;
+                    const displayUrl = url.length > maxLen ? url.slice(0, maxLen - 3) + '...' : url;
+                    this.screen.write(centerX - Math.floor(displayUrl.length / 2), contentY++, displayUrl, ANSI.fg.cyan);
+                    contentY += 2;
+                    // Status
+                    this.screen.write(centerX - 18, contentY, `${getSpinner()} Waiting for authentication...`, ANSI.fg.yellow);
+                    contentY += 2;
+                    // Instructions
+                    this.screen.write(centerX - 20, contentY++, 'Enter: Open in browser', ANSI.fg.gray);
+                    this.screen.write(centerX - 20, contentY++, 'Q: Show title (hide QR)', ANSI.fg.gray);
+                    this.screen.write(centerX - 20, contentY++, 'Esc: Cancel', ANSI.fg.gray);
+                }
+                this.screen.forceRedraw();
+            };
+            // Initial draw (showing URL, not QR)
+            redrawWaitingScreen();
+            // Set up key handler
+            let cancelled = false;
+            let exitRequested = false;
+            let spinnerUpdateInterval = null;
+            const keyHandler = (key) => {
+                if (key.name === 'return') {
+                    // Open URL in browser
+                    import('open').then(({ default: openUrl }) => {
+                        openUrl(loginInfo.authUrl).catch(() => { });
+                    }).catch(() => { });
+                }
+                else if (key.raw === 'q' || key.raw === 'Q') {
+                    // Toggle QR code display
+                    showingQR = !showingQR;
+                    redrawWaitingScreen();
+                }
+                else if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+                    cancelled = true;
+                    exitRequested = true;
+                    // Graceful exit
+                    if (spinnerUpdateInterval)
+                        clearInterval(spinnerUpdateInterval);
+                    this.input.offKey(keyHandler);
+                    stopSpinner();
+                    this.cleanup();
+                    process.exit(0);
+                }
+            };
+            this.input.onKey(keyHandler);
+            // Spinner update loop - only update the spinner character, don't redraw everything
+            spinnerUpdateInterval = setInterval(() => {
+                if (cancelled)
+                    return;
+                // Just redraw the entire screen with updated spinner
+                redrawWaitingScreen();
+            }, 100);
+            // Wait for login completion
+            try {
+                const result = await completeLogin((status) => {
+                    if (cancelled)
+                        return;
+                    if (status === 'completed') {
+                        if (spinnerUpdateInterval)
+                            clearInterval(spinnerUpdateInterval);
+                        this.input.offKey(keyHandler);
+                        stopSpinner();
+                        // Show success
+                        this.screen.clear();
+                        this.drawAsciiTitle();
+                        this.screen.write(centerX - 12, loginY, '✓ Login successful!', ANSI.fg.green);
+                        this.screen.forceRedraw();
+                    }
+                });
+                if (spinnerUpdateInterval)
+                    clearInterval(spinnerUpdateInterval);
+                this.input.offKey(keyHandler);
+                stopSpinner();
+                if (cancelled) {
+                    throw new Error('Login cancelled');
+                }
+                // Show success
+                this.screen.clear();
+                this.drawAsciiTitle();
+                this.screen.write(centerX - 12, loginY, '✓ Login successful!', ANSI.fg.green);
+                this.screen.forceRedraw();
+                // Get nickname from PlayKit (may be set from previous sessions)
+                const nickname = await getNickname();
+                if (nickname) {
+                    playerName = nickname;
+                }
+                else {
+                    // No nickname set, prompt user to set one
+                    this.screen.write(centerX - 15, loginY + 2, 'Set your adventurer name', ANSI.fg.yellow);
+                    this.screen.forceRedraw();
+                    await this.sleep(1000);
+                    playerName = await this.promptSetNickname();
+                }
+                // Wait for Enter to start game
+                await this.waitForGameStart(playerName);
+            }
+            catch (loginError) {
+                if (spinnerUpdateInterval)
+                    clearInterval(spinnerUpdateInterval);
+                this.input.offKey(keyHandler);
+                stopSpinner();
+                throw loginError;
+            }
+        }
+        catch (error) {
+            stopSpinner();
+            // Show error
+            this.screen.clear();
+            this.drawAsciiTitle();
+            this.screen.write(centerX - 10, loginY, '✗ Login failed', ANSI.fg.red);
+            this.screen.write(centerX - Math.floor((error.message || 'Unknown error').length / 2), loginY + 2, error.message || 'Unknown error', ANSI.fg.gray);
+            this.screen.write(centerX - 15, loginY + 4, 'Press any key to exit...', ANSI.fg.yellow);
+            this.screen.forceRedraw();
+            await this.input.waitForKey();
+            this.cleanup();
+            process.exit(1);
+        }
+        // If we got a player name from auth, use it; otherwise prompt
+        if (playerName) {
+            return playerName;
+        }
+        // Fallback: prompt to set nickname (this shouldn't normally be reached)
+        const fallbackName = await this.promptSetNickname();
+        await this.waitForGameStart(fallbackName);
+        return fallbackName;
+    }
+    /**
+     * Prompt user to set their nickname (saved to PlayKit)
+     */
+    async promptSetNickname() {
+        const { width, height } = this.screen.getSize();
+        const centerX = Math.floor(width / 2);
+        const maxNameLength = 16; // PlayKit limit is 1-16 characters
+        // Calculate position
+        const useCompact = width < 75;
+        const inputY = useCompact ? 14 : 20;
+        let inputBuffer = '';
+        let errorMessage = '';
+        const drawPrompt = () => {
+            this.screen.clear();
+            this.drawAsciiTitle();
+            const promptText = 'Set your adventurer name:';
+            this.screen.write(centerX - Math.floor(promptText.length / 2), inputY, promptText, ANSI.fg.white);
+            // Rules hint
+            const rulesText = '(1-16 chars, letters, numbers, Chinese, _, space)';
+            this.screen.write(centerX - Math.floor(rulesText.length / 2), inputY + 1, rulesText, ANSI.fg.gray);
+            // Input box
+            const inputWidth = 24;
+            const inputX = Math.floor((width - inputWidth) / 2);
+            this.screen.write(inputX, inputY + 3, '╔' + '═'.repeat(inputWidth - 2) + '╗', ANSI.fg.cyan);
+            this.screen.write(inputX, inputY + 4, '║ ', ANSI.fg.cyan);
+            this.screen.write(inputX + 2, inputY + 4, inputBuffer.slice(0, maxNameLength).padEnd(inputWidth - 4) + '▌', ANSI.fg.white);
+            this.screen.write(inputX + inputWidth - 1, inputY + 4, '║', ANSI.fg.cyan);
+            this.screen.write(inputX, inputY + 5, '╚' + '═'.repeat(inputWidth - 2) + '╝', ANSI.fg.cyan);
+            // Error message
+            if (errorMessage) {
+                this.screen.write(centerX - Math.floor(errorMessage.length / 2), inputY + 7, errorMessage, ANSI.fg.red);
+            }
+            // Instructions
+            this.screen.write(centerX - 15, inputY + 9, 'Enter to confirm   Esc to use default', ANSI.fg.gray);
+            this.screen.forceRedraw();
+        };
+        drawPrompt();
+        this.screen.showCursor();
+        return new Promise((resolve) => {
+            let isProcessing = false; // Prevent double-processing
+            const handleKeypress = (key) => {
+                // Ignore input while processing async operation
+                if (isProcessing)
+                    return;
+                if (key.name === 'return') {
+                    const trimmed = inputBuffer.trim();
+                    if (!trimmed) {
+                        errorMessage = 'Name cannot be empty';
+                        drawPrompt();
+                        return;
+                    }
+                    // Mark as processing to prevent double-submit
+                    isProcessing = true;
+                    // Try to set nickname on PlayKit
+                    this.screen.write(centerX - 10, inputY + 7, 'Saving...        ', ANSI.fg.yellow);
+                    this.screen.forceRedraw();
+                    setNickname(trimmed).then((result) => {
+                        if (result.success && result.nickname) {
+                            this.input.offKey(handleKeypress);
+                            this.screen.hideCursor();
+                            // Show success
+                            this.screen.write(centerX - 15, inputY + 7, `✓ Welcome, ${result.nickname}!`.padEnd(30), ANSI.fg.green);
+                            this.screen.forceRedraw();
+                            setTimeout(() => {
+                                resolve(result.nickname);
+                            }, 1500);
+                        }
+                        else {
+                            isProcessing = false;
+                            errorMessage = result.error || 'Failed to set name';
+                            drawPrompt();
+                        }
+                    }).catch((err) => {
+                        isProcessing = false;
+                        errorMessage = 'Network error, please try again';
+                        drawPrompt();
+                    });
+                }
+                else if (key.name === 'backspace') {
+                    inputBuffer = inputBuffer.slice(0, -1);
+                    errorMessage = '';
+                    drawPrompt();
+                }
+                else if (key.name === 'escape') {
+                    // Use default name
+                    this.input.offKey(handleKeypress);
+                    this.screen.hideCursor();
+                    resolve('Adventurer');
+                }
+                else if (key.raw && !key.ctrl && !key.meta) {
+                    const charCode = key.raw.charCodeAt(0);
+                    if (charCode >= 32 && inputBuffer.length < maxNameLength) {
+                        inputBuffer += key.raw;
+                        errorMessage = '';
+                        drawPrompt();
+                    }
+                }
+            };
+            this.input.onKey(handleKeypress);
+        });
+    }
+    /**
+     * Get player name input on title screen
+     * Self-contained input handling that doesn't rely on GameUI
+     */
+    async getTitleScreenInput() {
+        const { width, height } = this.screen.getSize();
+        const centerX = Math.floor(width / 2);
+        const maxNameLength = 20;
+        // Calculate input position based on ASCII art
+        const getInputY = () => {
+            const { width: w } = this.screen.getSize();
+            const useCompact = w < 75;
+            // ASCII logo height + TERMINAL + spacing
+            return useCompact ? 14 : 20;
+        };
+        // Draw prompt
+        const drawPrompt = (currentInput) => {
+            const { width: w } = this.screen.getSize();
+            const cx = Math.floor(w / 2);
+            const inputY = getInputY();
+            this.screen.write(cx - 15, inputY, 'What is your name, adventurer?', ANSI.fg.white);
+            // Input box
+            const inputWidth = 24;
+            const inputX = Math.floor((w - inputWidth) / 2);
+            this.screen.write(inputX, inputY + 2, '╔' + '═'.repeat(inputWidth - 2) + '╗', ANSI.fg.cyan);
+            this.screen.write(inputX, inputY + 3, '║ ', ANSI.fg.cyan);
+            this.screen.write(inputX + 2, inputY + 3, currentInput.slice(0, maxNameLength).padEnd(inputWidth - 4) + '▌', ANSI.fg.white);
+            this.screen.write(inputX + inputWidth - 1, inputY + 3, '║', ANSI.fg.cyan);
+            this.screen.write(inputX, inputY + 4, '╚' + '═'.repeat(inputWidth - 2) + '╝', ANSI.fg.cyan);
+            this.screen.write(cx - 15, inputY + 6, 'Enter to confirm   Esc to quit', ANSI.fg.gray);
+        };
+        // Full redraw for title screen (used after resize)
+        const redrawTitleScreen = (currentInput) => {
+            const { width: w } = this.screen.getSize();
+            const cx = Math.floor(w / 2);
+            this.screen.clear();
+            // Draw ASCII art
+            this.drawAsciiTitle();
+            // Tagline
+            const tagline = '~ An AI-native adventure that lives in your terminal ~';
+            const useCompact = w < 75;
+            const tagY = useCompact ? 12 : 16;
+            this.screen.write(cx - Math.floor(tagline.length / 2), tagY, tagline, ANSI.fg.gray);
+            drawPrompt(currentInput);
+            this.screen.forceRedraw();
+        };
+        // Initial draw
+        drawPrompt('');
+        this.screen.showCursor();
+        this.screen.forceRedraw();
+        // Set up resize handler for title screen
+        let inputBuffer = '';
+        const resizeHandler = () => {
+            const sizeCheck = this.screen.checkMinimumSize();
+            if (!sizeCheck.valid) {
+                this.screen.renderSizeWarning();
+            }
+            else {
+                redrawTitleScreen(inputBuffer);
+            }
+        };
+        this.screen.onResize(resizeHandler);
+        // Start input
+        this.input.start();
+        return new Promise((resolve) => {
+            const handleKeypress = (key) => {
+                if (key.name === 'return') {
+                    // Enter pressed - submit
+                    this.input.offKey(handleKeypress);
+                    this.screen.hideCursor();
+                    resolve(inputBuffer.trim() || 'Wanderer');
+                }
+                else if (key.name === 'backspace') {
+                    // Backspace - delete last char
+                    inputBuffer = inputBuffer.slice(0, -1);
+                    drawPrompt(inputBuffer);
+                    this.screen.render();
+                }
+                else if (key.name === 'escape') {
+                    // Escape - clear input
+                    inputBuffer = '';
+                    drawPrompt(inputBuffer);
+                    this.screen.render();
+                }
+                else if (key.raw && !key.ctrl && !key.meta) {
+                    // Printable character
+                    const charCode = key.raw.charCodeAt(0);
+                    if (charCode >= 32 && inputBuffer.length < maxNameLength) {
+                        inputBuffer += key.raw;
+                        drawPrompt(inputBuffer);
+                        this.screen.render();
+                    }
+                }
+            };
+            this.input.onKey(handleKeypress);
+        });
+    }
+    /**
+     * Initialize game systems
+     */
+    async initializeSystems() {
+        // Systems are initialized as singletons when accessed
+        // NPC Manager already loads fixed NPCs
+        // Quest Manager is ready
+    }
+    /**
+     * Set up event handlers (called from start())
+     */
+    setupEventHandlers() {
+        // Character edit handler
+        this.ui.onCharacterEditHandler((field, value) => this.handleCharacterEdit(field, value));
+        // Cancel travel handler
+        this.ui.setOnCancelTravel(() => this.cancelTravel());
+        // Abort dungeon handler
+        this.ui.setOnAbortDungeon(() => this.abortDungeon());
+        // Process signals - cleanup and exit gracefully
+        process.on('SIGINT', () => {
+            this.cleanup();
+            process.exit(0);
+        });
+        process.on('SIGTERM', () => {
+            this.cleanup();
+            process.exit(0);
+        });
+    }
+    /**
+     * Handle character customization edits
+     */
+    async handleCharacterEdit(field, value) {
+        const idleState = this.idleGameManager.getState();
+        if (!idleState)
+            return;
+        if (field === 'name') {
+            // Update player name both locally and on PlayKit
+            idleState.player.name = value;
+            // Try to update nickname on PlayKit
+            const result = await setNickname(value);
+            if (result.success) {
+                this.ui.addEventLog(`✓ Name changed to "${value}"`);
+            }
+            else {
+                // Name was updated locally, but PlayKit sync failed
+                this.ui.addEventLog(`✓ Name changed to "${value}"`);
+                if (result.error) {
+                    this.ui.addEventLog(`⚠ Online sync failed: ${result.error}`);
+                }
+            }
+        }
+        else {
+            // Update character customization field
+            const characterUpdate = {};
+            characterUpdate[field] = value;
+            if (idleState.player.character) {
+                Object.assign(idleState.player.character, characterUpdate);
+            }
+            const fieldLabels = {
+                backstory: 'Background Story',
+                appearance: 'Appearance',
+                personality: 'Personality',
+                motivation: 'Motivation',
+                origin: 'Origin',
+            };
+            const label = fieldLabels[field] || field;
+            this.ui.addEventLog(`✓ ${label} updated`);
+        }
+    }
+    // ==========================================================================
+    // IdleGameManager Callbacks
+    // ==========================================================================
+    onIdlePhaseChange(phase, state) {
+        switch (phase) {
+            case 'in_town':
+            case 'resting':
+                this.router.navigate({ type: 'explore' });
+                break;
+            case 'traveling_to_dungeon':
+                this.router.navigate({
+                    type: 'travel',
+                    targetRoomId: state.currentDungeon?.id || '',
+                    phase: 'traveling_to_dungeon'
+                });
+                break;
+            case 'returning_to_town':
+                this.router.navigate({
+                    type: 'travel',
+                    targetRoomId: state.currentTown.id,
+                    phase: 'returning_to_town'
+                });
+                break;
+            case 'in_dungeon':
+                const runnerState = state.dungeonRunner?.getState();
+                if (runnerState?.activeCombat) {
+                    this.router.navigate({ type: 'combat', encounterId: 'current' });
+                }
+                else {
+                    this.router.navigate({ type: 'dungeon', dungeonId: state.currentDungeon?.id || '' });
+                }
+                break;
+            case 'dead':
+                this.router.navigate({ type: 'dead' });
+                this.ui.addEventLog('You have died...');
+                break;
+        }
+    }
+    onIdlePlayerUpdate(player) {
+        // Player stats updated, UI will refresh on next render
+    }
+    onDungeonProgress(runnerState, combat) {
+        const idleState = this.idleGameManager.getState();
+        if (combat) {
+            this.router.navigate({ type: 'combat', encounterId: 'current' });
+        }
+        else if (idleState?.currentDungeon) {
+            this.router.navigate({ type: 'dungeon', dungeonId: idleState.currentDungeon.id });
+        }
+    }
+    onTravelProgress(progress, duration) {
+        // Travel progress updated, UI will refresh on next render
+    }
+    onDungeonComplete(success, rewards) {
+        if (success) {
+            this.ui.addEventLog(`Dungeon cleared! Gained ${rewards.gold} gold and ${rewards.exp} exp.`);
+            if (rewards.items.length > 0) {
+                this.ui.addEventLog(`Found: ${rewards.items.join(', ')}`);
+            }
+        }
+        else {
+            this.ui.addEventLog('Dungeon run failed.');
+        }
+    }
+    onPlayerDeath() {
+        this.ui.addEventLog('Press R to respawn at town, or Q to quit.');
+    }
+    /**
+     * Main game loop
+     */
+    async mainLoop() {
+        this.isRunning = true;
+        this.router.navigate({ type: 'explore' });
+        while (this.isRunning) {
+            // Skip normal rendering when in full screen mode (character creation, etc.)
+            if (this.isInFullScreenMode) {
+                await this.sleep(50);
+                continue;
+            }
+            const idleState = this.idleGameManager.getState();
+            if (!idleState)
+                break;
+            // Convert IdleGameState to GameState for UI
+            const state = adaptIdleGameStateToGameState(idleState);
+            // Check for daily death check
+            if (this.npcManager.shouldPerformDeathCheck()) {
+                const result = this.npcManager.performDailyDeathCheck();
+                if (result.died.length > 0) {
+                    for (const npc of result.died) {
+                        this.ui.addEventLog(`${npc.name} has died: ${npc.deathCause}`);
+                    }
+                }
+            }
+            // Check quest timeouts
+            const failedQuests = this.questManager.checkTimeouts();
+            for (const quest of failedQuests) {
+                this.ui.addEventLog(`Quest failed: ${quest.name}`);
+            }
+            // Render based on current phase
+            switch (idleState.phase) {
+                case 'in_town':
+                case 'resting':
+                    this.renderExploreMode(state);
+                    break;
+                case 'traveling_to_dungeon':
+                case 'returning_to_town':
+                    this.renderTravelMode(state);
+                    break;
+                case 'in_dungeon':
+                    if (state.phase === 'combat' && state.combat) {
+                        this.renderCombatMode(state);
+                    }
+                    else {
+                        this.renderDungeonMode(state);
+                    }
+                    break;
+                case 'dead':
+                    this.renderDeadScreen(state);
+                    break;
+            }
+            // Small delay to prevent CPU spinning
+            await this.sleep(50);
+        }
+        this.cleanup();
+    }
+    /**
+     * Render dead screen
+     */
+    renderDeadScreen(state) {
+        const { width, height } = this.screen.getSize();
+        const centerX = Math.floor(width / 2);
+        const centerY = Math.floor(height / 2);
+        this.screen.clear();
+        this.screen.write(centerX - 8, centerY - 2, 'YOU HAVE DIED', ANSI.fg.red, undefined, ANSI.bold);
+        this.screen.write(centerX - 15, centerY + 1, 'Press [R] to respawn at town', ANSI.fg.gray);
+        this.screen.write(centerX - 10, centerY + 2, 'Press [Q] to quit', ANSI.fg.gray);
+        this.screen.render();
+    }
+    /**
+     * Render explore mode
+     */
+    renderExploreMode(state) {
+        const idleState = this.idleGameManager.getState();
+        // If not in traveling state, ensure we exit travel mode
+        if (idleState && idleState.phase !== 'traveling_to_dungeon' && idleState.phase !== 'returning_to_town') {
+            this.ui.exitTravelMode();
+            this.ui.clearTravelState();
+        }
+        // If not in dungeon, ensure we exit dungeon mode
+        if (idleState && idleState.phase !== 'in_dungeon') {
+            this.ui.exitDungeonMode();
+        }
+        const npcsInRoom = this.npcManager.getByRoom(state.currentRoom.id);
+        const activeQuests = this.questManager.getActiveQuests();
+        this.ui.renderMainScreen(state, npcsInRoom, activeQuests);
+    }
+    /**
+     * Render travel mode - uses main explore layout with TravelingSection
+     */
+    renderTravelMode(state) {
+        if (!state.travelState)
+            return;
+        const idleState = this.idleGameManager.getState();
+        if (!idleState)
+            return;
+        const events = state.travelState.events.map(e => e.title);
+        // Determine from/to names and room IDs for the player icon
+        let fromName;
+        let toName;
+        let fromRoomId;
+        let toRoomId;
+        if (idleState.phase === 'traveling_to_dungeon') {
+            // Traveling to dungeon: from town center to dungeon entrance
+            fromName = idleState.currentTown.name;
+            toName = idleState.currentDungeon?.name || 'Unknown Dungeon';
+            fromRoomId = `${idleState.currentTown.id}_center`;
+            // Find the dungeon entrance room in the map
+            const dungeonId = idleState.currentDungeon?.id;
+            toRoomId = fromRoomId; // Default fallback
+            if (dungeonId) {
+                for (const [id, room] of state.currentMap.rooms) {
+                    if (room.type === 'dungeon_entrance' && room.name.includes(dungeonId)) {
+                        toRoomId = id;
+                        break;
+                    }
+                }
+            }
+        }
+        else {
+            // Returning to town: from dungeon to town center
+            fromName = idleState.currentDungeon?.name || 'Dungeon';
+            toName = idleState.currentTown.name;
+            fromRoomId = `${idleState.currentTown.id}_center`; // Will be at town map
+            toRoomId = `${idleState.currentTown.id}_center`;
+        }
+        // Ensure we're in travel mode
+        this.ui.enterTravelMode();
+        // Update travel state for UI
+        this.ui.updateTravelState({
+            fromRoomId: fromRoomId,
+            toRoomId: toRoomId,
+            fromName: fromName,
+            toName: toName,
+            progress: state.travelState.progress,
+            duration: state.travelState.duration,
+            events: events,
+            phase: idleState.phase,
+        });
+        // Use main screen rendering (with TravelingSection visible)
+        this.renderExploreMode(state);
+    }
+    /**
+     * Render dungeon mode - uses dungeon layout with DungeonSection
+     */
+    renderDungeonMode(state) {
+        const idleState = this.idleGameManager.getState();
+        if (!idleState || !idleState.dungeonRunner)
+            return;
+        const runnerState = idleState.dungeonRunner.getState();
+        if (!runnerState)
+            return;
+        // Ensure we're in dungeon mode
+        this.ui.enterDungeonMode();
+        // Calculate dungeon progress data
+        const dungeon = idleState.currentDungeon;
+        const totalRooms = dungeon ? Array.from(state.currentMap.rooms.values()).length : 0;
+        const exploredRooms = runnerState.exploredRooms.size;
+        // Calculate elapsed time from startTime
+        const elapsedTime = (Date.now() - runnerState.startTime) / 1000; // seconds
+        // Estimate time remaining based on progress
+        const progressPct = totalRooms > 0 ? exploredRooms / totalRooms : 0;
+        const estimatedTotal = progressPct > 0.1 ? elapsedTime / progressPct : (dungeon?.estimatedTime || 120);
+        const estimatedRemaining = Math.max(0, estimatedTotal - elapsedTime);
+        // Update dungeon section data
+        this.ui.updateDungeonData({
+            dungeonName: dungeon?.name || 'Unknown Dungeon',
+            currentFloor: runnerState.currentLevel,
+            totalFloors: dungeon?.levels.length || 1,
+            roomsExplored: exploredRooms,
+            totalRooms: totalRooms,
+            enemiesDefeated: runnerState.enemiesKilled,
+            totalEnemies: totalRooms, // Approximate
+            treasuresFound: runnerState.lootCollected.length,
+            currentRoomType: state.currentRoom.type,
+            playerHp: state.player.stats.hp,
+            playerMaxHp: state.player.stats.maxHp,
+            estimatedTimeRemaining: estimatedRemaining,
+            elapsedTime: elapsedTime,
+        });
+        // Render using main screen
+        const npcsInRoom = this.npcManager.getByRoom(state.currentRoom.id);
+        const activeQuests = this.questManager.getActiveQuests();
+        this.ui.renderMainScreen(state, npcsInRoom, activeQuests);
+    }
+    /**
+     * Render combat mode
+     */
+    renderCombatMode(state) {
+        if (!state.combat)
+            return;
+        this.ui.renderCombatScreen(state.combat, state.player);
+    }
+    /**
+     * Handle command input
+     */
+    handleCommand(cmd) {
+        const idleState = this.idleGameManager.getState();
+        if (!idleState)
+            return;
+        // Handle dead state special commands
+        if (idleState.phase === 'dead') {
+            if (cmd === 'r' || cmd === 'respawn') {
+                this.idleGameManager.respawn();
+                this.router.navigate({ type: 'explore' });
+                return;
+            }
+            if (cmd === 'q' || cmd === 'quit') {
+                this.router.navigate({ type: 'gameover' });
+                return;
+            }
+            return; // Ignore other commands when dead
+        }
+        // Try registered commands first
+        if (this.commandRegistry.execute(cmd)) {
+            return;
+        }
+        // Handle special cases: numeric input and mode-specific commands
+        if (!cmd)
+            return;
+        // Check if it's a number
+        const num = parseInt(cmd, 10);
+        if (!isNaN(num)) {
+            // Handle based on current mode (using handlers)
+            if (this.saveLoadHandler.handleNumericInput(num)) {
+                return;
+            }
+            else if (this.workshopHandler.workshopMode) {
+                this.workshopHandler.handleInput(num);
+                return;
+            }
+            else if (this.npcSelectionMode) {
+                this.handleNPCSelection(num);
+                return;
+            }
+            else if (this.dungeonSelectionMode) {
+                this.handleDungeonSelection(num);
+                return;
+            }
+            else {
+                // Handle map room selection (dungeon entrance, facilities)
+                this.handleMapRoomSelection(num);
+                return;
+            }
+        }
+        // Non-numeric unknown command - cancel any pending modes or show error
+        if (this.saveLoadHandler.saveMode) {
+            this.saveLoadHandler.cancelSave();
+        }
+        else if (this.saveLoadHandler.loadMode) {
+            this.saveLoadHandler.cancelLoad();
+        }
+        else if (this.workshopHandler.workshopMode) {
+            this.workshopHandler.exit();
+        }
+        else if (this.dungeonSelectionMode) {
+            this.dungeonSelectionMode = false;
+            this.ui.addEventLog('Dungeon selection cancelled.');
+        }
+        else {
+            this.ui.addEventLog(`Unknown command: ${cmd}. Type 'help' for commands.`);
+        }
+    }
+    /**
+     * Handle travel command - shows available facilities in town
+     */
+    handleTravelCommand() {
+        const idleState = this.idleGameManager.getState();
+        if (!idleState || idleState.phase !== 'in_town') {
+            this.ui.addEventLog('You can only visit facilities when in town.');
+            return;
+        }
+        const facilities = idleState.currentTown.facilities;
+        if (facilities.length === 0) {
+            this.ui.addEventLog('No facilities available in this town.');
+            return;
+        }
+        this.ui.addEventLog('─── Town Facilities ───');
+        facilities.forEach((facility, index) => {
+            this.ui.addEventLog(`  [${index + 1}] ${facility.name} (${facility.type})`);
+        });
+        this.ui.addEventLog('Enter a number to visit a facility.');
+    }
+    /**
+     * Handle dungeon command - shows available dungeons
+     */
+    handleDungeonCommand() {
+        const idleState = this.idleGameManager.getState();
+        if (!idleState || idleState.phase !== 'in_town') {
+            this.ui.addEventLog('You can only select dungeons when in town.');
+            return;
+        }
+        this.availableDungeons = this.idleGameManager.getAvailableDungeons();
+        if (this.availableDungeons.length === 0) {
+            this.ui.addEventLog('No dungeons available from this town.');
+            return;
+        }
+        this.dungeonSelectionMode = true;
+        this.ui.addEventLog('─── Available Dungeons ───');
+        this.availableDungeons.forEach((dungeon, index) => {
+            const difficulty = dungeon.difficulty.charAt(0).toUpperCase() + dungeon.difficulty.slice(1);
+            this.ui.addEventLog(`  [${index + 1}] ${dungeon.name} (${difficulty}, Lv.${dungeon.recommendedLevel})`);
+        });
+        this.ui.addEventLog('Enter a number to travel to a dungeon, or any key to cancel.');
+    }
+    /**
+     * Handle dungeon selection
+     */
+    handleDungeonSelection(num) {
+        const index = num - 1;
+        if (index >= 0 && index < this.availableDungeons.length) {
+            const dungeon = this.availableDungeons[index];
+            const success = this.idleGameManager.selectDungeon(dungeon.id);
+            if (success) {
+                this.router.navigate({
+                    type: 'travel',
+                    targetRoomId: dungeon.id,
+                    phase: 'traveling_to_dungeon'
+                });
+                this.ui.addEventLog(`Traveling to ${dungeon.name}...`);
+            }
+            else {
+                this.ui.addEventLog('Cannot travel to that dungeon.');
+            }
+        }
+        else {
+            this.ui.addEventLog(`Invalid selection. Use 1-${this.availableDungeons.length}`);
+        }
+        this.dungeonSelectionMode = false;
+    }
+    /**
+     * Handle room selection from map
+     */
+    handleMapRoomSelection(num) {
+        const idleState = this.idleGameManager.getState();
+        if (!idleState || idleState.phase !== 'in_town') {
+            return;
+        }
+        // Get current room's connections
+        const gameState = adaptIdleGameStateToGameState(idleState);
+        const connections = gameState.currentRoom.connections;
+        const index = num - 1;
+        if (index < 0 || index >= connections.length) {
+            return; // Invalid selection
+        }
+        const roomId = connections[index];
+        const targetRoom = gameState.currentMap.rooms.get(roomId);
+        if (!targetRoom) {
+            return;
+        }
+        // Check if it's a dungeon entrance
+        if (targetRoom.type === 'dungeon_entrance') {
+            // Extract dungeonId from room name (format: "→ dungeonId")
+            const dungeonId = targetRoom.name.replace('→ ', '').trim();
+            const success = this.idleGameManager.selectDungeon(dungeonId);
+            if (success) {
+                this.router.navigate({
+                    type: 'travel',
+                    targetRoomId: dungeonId,
+                    phase: 'traveling_to_dungeon'
+                });
+                this.ui.addEventLog(`Traveling to dungeon: ${dungeonId}...`);
+            }
+            else {
+                this.ui.addEventLog(`Cannot travel to ${dungeonId}`);
+            }
+            return;
+        }
+        // Handle facility access
+        const facilities = idleState.currentTown.facilities;
+        if (index < facilities.length) {
+            const facility = facilities[index];
+            this.idleGameManager.useFacility(facility);
+            this.ui.addEventLog(`Visiting ${facility.name}...`);
+        }
+    }
+    /**
+     * Cancel current travel and return to town
+     */
+    cancelTravel() {
+        const idleState = this.idleGameManager.getState();
+        if (!idleState)
+            return;
+        if (idleState.phase === 'traveling_to_dungeon' || idleState.phase === 'returning_to_town') {
+            // Cancel travel via IdleGameManager
+            const success = this.idleGameManager.cancelTravel();
+            if (success) {
+                this.ui.exitTravelMode();
+                this.ui.clearTravelState();
+                this.router.navigate({ type: 'explore' });
+                this.ui.addEventLog('Travel cancelled.');
+            }
+        }
+    }
+    /**
+     * Abort current dungeon and return to town
+     */
+    abortDungeon() {
+        const idleState = this.idleGameManager.getState();
+        if (!idleState)
+            return;
+        if (idleState.phase === 'in_dungeon') {
+            this.idleGameManager.abortDungeon();
+            this.ui.exitDungeonMode();
+            this.ui.addEventLog('Retreating from dungeon...');
+        }
+    }
+    /**
+     * Handle inventory command
+     */
+    handleInventoryCommand() {
+        const player = this.idleGameManager.getState()?.player;
+        if (!player)
+            return;
+        this.ui.addEventLog('─── Inventory ───');
+        this.ui.addEventLog(`Gold: ${player.stats.gold}`);
+        if (player.inventory.length === 0) {
+            this.ui.addEventLog('(empty)');
+        }
+        else {
+            for (const item of player.inventory.slice(0, 5)) {
+                this.ui.addEventLog(`• ${item.name} x${item.quantity}`);
+            }
+            if (player.inventory.length > 5) {
+                this.ui.addEventLog(`... and ${player.inventory.length - 5} more`);
+            }
+        }
+    }
+    /**
+     * Handle character command
+     */
+    handleCharacterCommand() {
+        const player = this.idleGameManager.getState()?.player;
+        if (!player)
+            return;
+        const s = player.stats;
+        this.ui.addEventLog(`─── ${player.name} ───`);
+        this.ui.addEventLog(`Level ${s.level} | HP: ${s.hp}/${s.maxHp} | MP: ${s.mp}/${s.maxMp}`);
+        this.ui.addEventLog(`ATK: ${s.attack} | DEF: ${s.defense} | SPD: ${s.speed}`);
+        this.ui.addEventLog(`EXP: ${s.exp}/${s.expToNextLevel}`);
+    }
+    /**
+     * Handle NPC command
+     */
+    handleNPCCommand() {
+        const idleState = this.idleGameManager.getState();
+        if (!idleState)
+            return;
+        // In town, use town center room ID for NPC lookup
+        const roomId = idleState.phase === 'in_town'
+            ? `${idleState.currentTown.id}_center`
+            : '';
+        const npcs = this.npcManager.getByRoom(roomId);
+        if (npcs.length === 0) {
+            // Check for encounter NPCs on current floor (floor 1 for town)
+            const floor = idleState.phase === 'in_dungeon' && idleState.dungeonRunner
+                ? idleState.dungeonRunner.getState()?.currentLevel ?? 1
+                : 1;
+            const floorNPCs = this.npcManager.getByFloor(floor);
+            if (floorNPCs.length === 0) {
+                this.ui.addEventLog('No NPCs nearby.');
+            }
+            else {
+                this.ui.addEventLog('No NPCs in this room, but others are on this floor.');
+            }
+            this.npcSelectionMode = false;
+            return;
+        }
+        // Enter NPC selection mode
+        this.npcSelectionMode = true;
+        this.availableNPCs = npcs;
+        this.ui.addEventLog('─── NPCs Here ───');
+        npcs.forEach((npc, i) => {
+            const relationship = npc.playerRelationship > 0 ? '♥' : npc.playerRelationship < 0 ? '✗' : '○';
+            const met = npc.metPlayer ? '' : ' (new)';
+            this.ui.addEventLog(`  [${i + 1}] ${npc.name} (${npc.role}) ${relationship}${met}`);
+        });
+        this.ui.addEventLog('Type a number to talk, or any command to cancel.');
+    }
+    /**
+     * Handle NPC selection (when in NPC selection mode)
+     */
+    handleNPCSelection(num) {
+        const index = num - 1;
+        if (index >= 0 && index < this.availableNPCs.length) {
+            const npc = this.availableNPCs[index];
+            this.npcSelectionMode = false;
+            // Use DialogHandler for NPC dialog
+            this.dialogHandler.startDialog(npc);
+        }
+        else {
+            this.ui.addEventLog(`Invalid selection. Choose 1-${this.availableNPCs.length}`);
+        }
+    }
+    /**
+     * Start dialog with an NPC
+     */
+    async startNPCDialog(npc) {
+        this.currentDialogNPC = npc;
+        this.dialogHistory = [];
+        // Get greeting based on relationship
+        const greeting = this.generateNPCGreeting(npc);
+        this.dialogHistory.push({ role: 'npc', text: greeting });
+        // Mark player as met
+        npc.metPlayer = true;
+        // Switch to dialog mode via router
+        this.router.navigate({ type: 'dialog', npcId: npc.id });
+        // Pause dungeon if in dungeon
+        this.idleGameManager.pauseDungeon();
+        // Set up dialog input handler
+        this.ui.onDialogInputHandler((input) => this.handleDialogInput(input));
+        // Render initial dialog screen
+        this.renderDialogMode();
+    }
+    /**
+     * Generate NPC greeting based on relationship and history
+     */
+    generateNPCGreeting(npc) {
+        const relationship = npc.playerRelationship;
+        const met = npc.dialogHistory.length > 0;
+        if (!met) {
+            // First meeting
+            const greetings = {
+                merchant: `Welcome, traveler! I am ${npc.name}. Looking to trade?`,
+                sage: `Ah, a seeker of knowledge. I am ${npc.name}. What wisdom do you seek?`,
+                guard: `Halt. I am ${npc.name}, keeper of this area. State your business.`,
+                blacksmith: `*looks up from anvil* ${npc.name} here. Need something forged?`,
+                traveler: `Well met, fellow wanderer. I'm ${npc.name}. Strange place, isn't it?`,
+                quest_giver: `${npc.name} at your service. I might have work for someone like you.`,
+            };
+            return greetings[npc.role] || `Greetings. I am ${npc.name}.`;
+        }
+        else if (relationship > 50) {
+            return `${npc.name} smiles warmly. "Good to see you again, friend!"`;
+        }
+        else if (relationship > 0) {
+            return `"Ah, you're back," says ${npc.name}. "What can I do for you?"`;
+        }
+        else if (relationship < -50) {
+            return `${npc.name} glares at you. "What do you want now?"`;
+        }
+        else if (relationship < 0) {
+            return `${npc.name} regards you coldly. "Yes?"`;
+        }
+        else {
+            return `${npc.name} nods in greeting. "How can I help?"`;
+        }
+    }
+    /**
+     * Handle dialog input
+     */
+    async handleDialogInput(input) {
+        if (!this.currentDialogNPC)
+            return;
+        const trimmed = input.trim();
+        const lower = trimmed.toLowerCase();
+        // Check for exit commands
+        if (lower === 'bye' || lower === 'exit' || trimmed === '') {
+            this.endDialog();
+            return;
+        }
+        // Check if awaiting quest response
+        if (this.awaitingQuestResponse && this.pendingQuest) {
+            if (lower === 'yes' || lower === 'y' || lower === 'accept') {
+                this.acceptPendingQuest();
+                return;
+            }
+            else if (lower === 'no' || lower === 'n' || lower === 'decline') {
+                this.declinePendingQuest();
+                return;
+            }
+        }
+        // Check for quick options
+        if (trimmed === '1') {
+            this.handleQuickOption('quests');
+            return;
+        }
+        else if (trimmed === '2') {
+            this.handleQuickOption('trade');
+            return;
+        }
+        else if (trimmed === '3') {
+            this.handleQuickOption('lore');
+            return;
+        }
+        // Add player message to history
+        this.dialogHistory.push({ role: 'player', text: trimmed });
+        this.renderDialogMode();
+        // Get AI response
+        const aiClient = getAIClient();
+        const npc = this.currentDialogNPC;
+        // Build context for AI
+        const context = this.buildDialogContext(npc, trimmed);
+        // Show thinking indicator
+        this.ui.renderDialogScreen(npc, this.dialogHistory, this.getQuickOptions(), true);
+        // Get response from AI (with built-in retry)
+        const result = await aiClient.talkToNPC(npc.role, context);
+        if (result.success && result.data) {
+            // Reset failure counter on success
+            this.consecutiveAIFailures = 0;
+            // Add NPC response to history
+            this.dialogHistory.push({ role: 'npc', text: result.data });
+            // Record interaction in NPC manager
+            this.npcManager.recordInteraction(npc.id, trimmed, result.data);
+            // Check for relationship changes based on keywords
+            this.updateRelationshipFromDialog(npc, trimmed, result.data);
+        }
+        else {
+            // AI failed after retries
+            this.consecutiveAIFailures++;
+            // Report dialog failure with context
+            console.error('[Dialog] AI failed:', result.error);
+            Sentry.captureMessage('Dialog AI failed, using fallback response', {
+                level: 'warning',
+                tags: { operation: 'npc_dialog', fallback: true },
+                extra: {
+                    npcId: npc.id,
+                    npcRole: npc.role,
+                    consecutiveFailures: this.consecutiveAIFailures,
+                    error: result.error,
+                },
+            });
+            // Use fallback response
+            const fallback = this.getFallbackResponse(this.currentDialogNPC);
+            this.dialogHistory.push({ role: 'npc', text: fallback });
+            // Check if we've hit too many consecutive failures
+            if (result.retriesExhausted && this.consecutiveAIFailures >= this.MAX_CONSECUTIVE_FAILURES) {
+                await this.promptLoadLastSave();
+            }
+        }
+        this.renderDialogMode();
+    }
+    /**
+     * Build context for AI dialog
+     */
+    buildDialogContext(npc, playerMessage) {
+        const recentHistory = this.dialogHistory.slice(-6);
+        const historyText = recentHistory
+            .map(h => `${h.role === 'player' ? 'Player' : npc.name}: ${h.text}`)
+            .join('\n');
+        return `${historyText}\nPlayer: ${playerMessage}`;
+    }
+    /**
+     * Update relationship based on dialog
+     */
+    updateRelationshipFromDialog(npc, playerMessage, npcResponse) {
+        const lower = playerMessage.toLowerCase();
+        // Positive keywords
+        if (lower.includes('thank') || lower.includes('please') || lower.includes('help')) {
+            this.npcManager.updateRelationship(npc.id, 1);
+        }
+        // Negative keywords
+        if (lower.includes('stupid') || lower.includes('idiot') || lower.includes('hate')) {
+            this.npcManager.updateRelationship(npc.id, -5);
+        }
+    }
+    /**
+     * Handle quick dialog options
+     */
+    async handleQuickOption(option) {
+        if (!this.currentDialogNPC)
+            return;
+        const npc = this.currentDialogNPC;
+        let playerText = '';
+        let npcResponse = '';
+        switch (option) {
+            case 'quests':
+                playerText = 'Do you have any tasks for me?';
+                // Check if NPC has available quests
+                const availableQuest = this.getQuestFromNPC(npc);
+                if (availableQuest) {
+                    npcResponse = `Yes, I have a task. ${availableQuest.description} Will you accept? (Type 'yes' or 'no')`;
+                    // Store pending quest for acceptance
+                    this.pendingQuest = availableQuest;
+                    this.awaitingQuestResponse = true;
+                }
+                else {
+                    npcResponse = "I don't have anything for you right now. Check back later.";
+                }
+                break;
+            case 'trade':
+                playerText = 'What do you have for trade?';
+                if (npc.role === 'merchant' || npc.role === 'blacksmith') {
+                    npcResponse = "Take a look at my wares. (Trade system coming soon)";
+                }
+                else {
+                    npcResponse = "I'm not a merchant, but perhaps someone else can help you.";
+                }
+                break;
+            case 'lore':
+                playerText = 'Tell me about this place.';
+                npcResponse = this.getLocationLore(npc);
+                break;
+        }
+        this.dialogHistory.push({ role: 'player', text: playerText });
+        this.dialogHistory.push({ role: 'npc', text: npcResponse });
+        this.npcManager.recordInteraction(npc.id, playerText, npcResponse);
+        this.renderDialogMode();
+    }
+    pendingQuest = null;
+    awaitingQuestResponse = false;
+    /**
+     * Accept a pending quest
+     */
+    acceptPendingQuest() {
+        if (!this.pendingQuest || !this.currentDialogNPC)
+            return;
+        const npc = this.currentDialogNPC;
+        const quest = this.pendingQuest;
+        // Add to quest manager
+        const success = this.questManager.acceptQuest(quest);
+        if (success) {
+            // Update NPC tracking
+            if (!npc.givenQuests)
+                npc.givenQuests = [];
+            npc.givenQuests.push(quest.id);
+            // Update relationship
+            this.npcManager.updateRelationship(npc.id, 5);
+            // Dialog response
+            const responses = [
+                `"Excellent! I knew I could count on you," says ${npc.name}.`,
+                `${npc.name} nods approvingly. "Good luck out there."`,
+                `"May the gods watch over you," ${npc.name} says with a smile.`,
+            ];
+            const response = responses[Math.floor(Math.random() * responses.length)];
+            this.dialogHistory.push({ role: 'player', text: 'I accept.' });
+            this.dialogHistory.push({ role: 'npc', text: response });
+            this.ui.addEventLog(`✓ Quest accepted: ${quest.name}`);
+        }
+        else {
+            this.dialogHistory.push({ role: 'npc', text: `"It seems you already have too many tasks. Come back when you're ready."` });
+        }
+        this.pendingQuest = null;
+        this.awaitingQuestResponse = false;
+        this.renderDialogMode();
+    }
+    /**
+     * Decline a pending quest
+     */
+    declinePendingQuest() {
+        if (!this.pendingQuest || !this.currentDialogNPC)
+            return;
+        const npc = this.currentDialogNPC;
+        // Slight relationship decrease
+        this.npcManager.updateRelationship(npc.id, -2);
+        const responses = [
+            `${npc.name} looks disappointed. "I understand. Perhaps another time."`,
+            `"Very well," ${npc.name} sighs. "The offer stands if you change your mind."`,
+            `${npc.name} shrugs. "Your choice. Others may be willing."`,
+        ];
+        const response = responses[Math.floor(Math.random() * responses.length)];
+        this.dialogHistory.push({ role: 'player', text: 'I must decline.' });
+        this.dialogHistory.push({ role: 'npc', text: response });
+        this.pendingQuest = null;
+        this.awaitingQuestResponse = false;
+        this.renderDialogMode();
+    }
+    /**
+     * Get quest from NPC if available
+     */
+    getQuestFromNPC(npc) {
+        // Generate a simple quest based on NPC role
+        const baseQuest = {
+            giverNPCId: npc.id,
+            giverNPCName: npc.name,
+            giveDialog: `Will you help me with this task?`,
+            progressDialog: `How is the task going?`,
+            completeDialog: `Excellent work! Here is your reward.`,
+            failDialog: `A shame you couldn't complete it.`,
+            difficulty: 'medium',
+            repeatable: false,
+            timesCompleted: 0,
+        };
+        const questTemplates = {
+            guard: () => ({
+                ...baseQuest,
+                id: `quest_${Date.now()}`,
+                name: 'Clear the Threat',
+                description: 'Eliminate the monsters lurking in the nearby rooms.',
+                type: 'kill',
+                status: 'available',
+                objectives: [{
+                        id: 'kill_monsters',
+                        type: 'kill',
+                        target: 'enemy_*',
+                        targetName: 'enemies',
+                        description: 'Defeat 3 enemies',
+                        required: 3,
+                        current: 0,
+                        isComplete: false,
+                    }],
+                rewards: [
+                    { type: 'exp', value: 50 },
+                    { type: 'gold', value: 25 },
+                ],
+                timeLimit: 30 * 60, // 30 minutes in seconds
+            }),
+            sage: () => ({
+                ...baseQuest,
+                id: `quest_${Date.now()}`,
+                name: 'Seek Knowledge',
+                description: 'Explore the dungeon and discover hidden secrets.',
+                type: 'explore',
+                status: 'available',
+                objectives: [{
+                        id: 'explore_rooms',
+                        type: 'reach',
+                        target: 'room_*',
+                        targetName: 'rooms',
+                        description: 'Explore 5 rooms',
+                        required: 5,
+                        current: 0,
+                        isComplete: false,
+                    }],
+                rewards: [
+                    { type: 'exp', value: 75 },
+                    { type: 'gold', value: 10 },
+                ],
+            }),
+            merchant: () => ({
+                ...baseQuest,
+                id: `quest_${Date.now()}`,
+                name: 'Trade Route',
+                description: 'Help me retrieve some valuable goods.',
+                type: 'collect',
+                status: 'available',
+                objectives: [{
+                        id: 'collect_items',
+                        type: 'collect',
+                        target: 'treasure_*',
+                        targetName: 'treasure',
+                        description: 'Find treasure',
+                        required: 1,
+                        current: 0,
+                        isComplete: false,
+                    }],
+                rewards: [
+                    { type: 'exp', value: 30 },
+                    { type: 'gold', value: 50 },
+                ],
+            }),
+        };
+        const template = questTemplates[npc.role];
+        if (template) {
+            return template();
+        }
+        return null;
+    }
+    /**
+     * Get location lore from NPC
+     */
+    getLocationLore(npc) {
+        const loreOptions = [
+            "This dungeon has stood for centuries. Many have entered, few have left.",
+            "They say a great evil lurks in the depths below. Be careful if you venture there.",
+            "The walls whisper secrets to those who listen. Ancient magic permeates this place.",
+            "Long ago, this was a temple. Now it's home to creatures of darkness.",
+            "I've heard rumors of powerful artifacts hidden in the boss rooms.",
+        ];
+        return loreOptions[Math.floor(Math.random() * loreOptions.length)];
+    }
+    /**
+     * Get fallback response when AI fails
+     */
+    getFallbackResponse(npc) {
+        const fallbacks = [
+            `${npc.name} seems distracted. "Hmm? Sorry, I was thinking about something else."`,
+            `"Interesting..." ${npc.name} strokes their chin thoughtfully.`,
+            `${npc.name} nods slowly. "I see what you mean."`,
+            `"That's... quite something," ${npc.name} responds carefully.`,
+        ];
+        return fallbacks[Math.floor(Math.random() * fallbacks.length)];
+    }
+    /**
+     * Prompt user to load last save after multiple AI failures
+     */
+    async promptLoadLastSave() {
+        // SENTRY ADD HERE - Report critical AI failure requiring save load prompt
+        this.ui.addEventLog('');
+        this.ui.addEventLog('═══════════════════════════════════════');
+        this.ui.addEventLog('⚠ AI connection issues detected.');
+        this.ui.addEventLog('Multiple attempts have failed.');
+        this.ui.addEventLog('');
+        this.ui.addEventLog('Options:');
+        this.ui.addEventLog('  [R] Retry connection');
+        this.ui.addEventLog('  [L] Load last save');
+        this.ui.addEventLog('═══════════════════════════════════════');
+        // Wait for valid input
+        while (true) {
+            this.input.setMode('raw');
+            const key = await this.input.waitForKey();
+            const keyName = key.name.toLowerCase();
+            if (keyName === 'r') {
+                // Retry - reset counter and let user try again
+                this.consecutiveAIFailures = 0;
+                this.ui.addEventLog('Retrying connection...');
+                break;
+            }
+            else if (keyName === 'l') {
+                // Reset failure counter
+                this.consecutiveAIFailures = 0;
+                // End current dialog if active
+                if (this.currentDialogNPC) {
+                    this.endDialog();
+                }
+                // Trigger load
+                await this.handleLoadCommand();
+                break;
+            }
+            else {
+                // Invalid key, wait for valid input
+                this.ui.addEventLog('Press [R] to retry or [L] to load save.');
+            }
+        }
+    }
+    /**
+     * Get quick dialog options
+     */
+    getQuickOptions() {
+        return [
+            { key: '1', text: 'Ask about quests', action: 'quests' },
+            { key: '2', text: 'Trade', action: 'trade' },
+            { key: '3', text: 'Ask about this place', action: 'lore' },
+        ];
+    }
+    /**
+     * Render dialog mode
+     */
+    renderDialogMode() {
+        if (!this.currentDialogNPC)
+            return;
+        this.ui.renderDialogScreen(this.currentDialogNPC, this.dialogHistory, this.getQuickOptions(), false);
+    }
+    /**
+     * End dialog with NPC
+     */
+    endDialog() {
+        if (this.currentDialogNPC) {
+            const farewell = this.generateFarewell(this.currentDialogNPC);
+            this.ui.addEventLog(farewell);
+        }
+        this.currentDialogNPC = null;
+        this.dialogHistory = [];
+        this.pendingQuest = null;
+        // Navigate back or to explore mode
+        if (!this.router.back()) {
+            this.router.navigate({ type: 'explore' });
+        }
+        // Resume dungeon if paused
+        this.idleGameManager.resumeDungeon();
+    }
+    /**
+     * Generate farewell message
+     */
+    generateFarewell(npc) {
+        const relationship = npc.playerRelationship;
+        if (relationship > 30) {
+            return `${npc.name}: "Take care, friend. Come back anytime!"`;
+        }
+        else if (relationship < -30) {
+            return `${npc.name} turns away without a word.`;
+        }
+        else {
+            return `${npc.name}: "Farewell, traveler."`;
+        }
+    }
+    /**
+     * Handle quest command
+     */
+    handleQuestCommand() {
+        const quests = this.questManager.getActiveQuests();
+        if (quests.length === 0) {
+            this.ui.addEventLog('No active quests. Talk to NPCs to get quests.');
+            return;
+        }
+        this.ui.addEventLog('─── Active Quests ───');
+        for (const quest of quests) {
+            const completed = quest.objectives.filter(o => o.isComplete).length;
+            const total = quest.objectives.length;
+            this.ui.addEventLog(`• ${quest.name} [${completed}/${total}]`);
+        }
+    }
+    /**
+     * Show help
+     */
+    showHelp() {
+        this.ui.addEventLog('─── Navigation ───');
+        this.ui.addEventLog('Arrow keys: move between sections');
+        this.ui.addEventLog('Enter: enter section | Esc: exit section');
+        this.ui.addEventLog('─── Shortcuts ───');
+        this.ui.addEventLog('[I]nv [C]har [Q]uest [W]ork [N]PC [H]elp');
+        this.ui.addEventLog('[S]ave [L]oad | 1-9: quick travel');
+    }
+    /**
+     * Handle save command
+     */
+    async handleSaveCommand() {
+        const idleState = this.idleGameManager.getState();
+        if (!idleState) {
+            this.ui.addEventLog('✗ Failed to save game.');
+            return;
+        }
+        // Create save data from IdleGameState
+        const saveData = {
+            version: '0.1.0',
+            timestamp: Date.now(),
+            player: idleState.player,
+            currentMapId: idleState.currentTown.id,
+            currentRoomId: `${idleState.currentTown.id}_center`,
+            discoveredMaps: [idleState.currentTown.id],
+            gameTime: idleState.statistics.totalPlayTime,
+            settings: {
+                language: 'en',
+                autoSave: true,
+                autoSaveInterval: 300,
+                combatSpeed: 1,
+                soundEnabled: false,
+            },
+        };
+        // Also save NPC and quest state
+        const npcSave = this.npcManager.save();
+        const questSave = this.questManager.save();
+        // Show save slots
+        this.ui.addEventLog('─── Save Game ───');
+        const slots = await listSaveSlots();
+        for (const slot of slots) {
+            if (slot.exists) {
+                this.ui.addEventLog(`  [${slot.slot}] ${slot.playerName} Lv.${slot.level} - ${formatTimestamp(slot.timestamp)}`);
+            }
+            else {
+                this.ui.addEventLog(`  [${slot.slot}] Empty`);
+            }
+        }
+        this.ui.addEventLog('Type slot number (1-5) to save:');
+        // Set up temporary command handler for slot selection
+        this.pendingSaveData = { game: saveData, npcs: npcSave, quests: questSave };
+        this.saveMode = true;
+    }
+    pendingSaveData = null;
+    saveMode = false;
+    loadMode = false;
+    workshopMode = false;
+    workshopSubMode = 'main';
+    /**
+     * Complete save to slot
+     */
+    async completeSave(slot) {
+        if (!this.pendingSaveData)
+            return;
+        const result = await saveGame(slot, this.pendingSaveData.game, this.pendingSaveData.npcs, this.pendingSaveData.quests);
+        if (result.success) {
+            this.ui.addEventLog(`✓ Saved to slot ${slot}!`);
+            this.ui.addEventLog(`  Time played: ${formatPlayTime(this.pendingSaveData.game.gameTime)}`);
+        }
+        else {
+            this.ui.addEventLog(`✗ Save failed: ${result.error}`);
+        }
+        this.pendingSaveData = null;
+        this.saveMode = false;
+    }
+    /**
+     * Handle load command
+     */
+    async handleLoadCommand() {
+        this.ui.addEventLog('─── Load Game ───');
+        const slots = await listSaveSlots();
+        let hasAnySave = false;
+        for (const slot of slots) {
+            if (slot.exists) {
+                hasAnySave = true;
+                this.ui.addEventLog(`  [${slot.slot}] ${slot.playerName} Lv.${slot.level} - ${formatPlayTime(slot.gameTime)}`);
+            }
+            else {
+                this.ui.addEventLog(`  [${slot.slot}] Empty`);
+            }
+        }
+        if (!hasAnySave) {
+            this.ui.addEventLog('No saved games found.');
+            return;
+        }
+        this.ui.addEventLog('Type slot number (1-5) to load:');
+        this.loadMode = true;
+    }
+    /**
+     * Complete load from slot
+     */
+    async completeLoad(slot) {
+        const result = await loadGame(slot);
+        if (result.success && result.data) {
+            // Destroy current game state and reinitialize with loaded player
+            this.idleGameManager.destroy();
+            this.idleGameManager.initialize(result.data.game.player);
+            // Load NPC and quest state
+            this.npcManager.load(result.data.npcs);
+            this.questManager.load(result.data.quests);
+            this.ui.addEventLog(`✓ Loaded from slot ${slot}!`);
+            this.ui.addEventLog(`  Welcome back, ${result.data.game.player.name}!`);
+        }
+        else {
+            this.ui.addEventLog(`✗ Load failed: ${result.error}`);
+        }
+        this.loadMode = false;
+    }
+    /**
+     * Handle new game command - opens character creation wizard
+     * Uses NewGameFlowManager for consistent flow handling
+     */
+    handleNewGameCommand() {
+        // Run the async flow without blocking
+        this.runNewGameFlowFromMenu().catch((error) => {
+            console.error('New game flow error:', error);
+            // Safety fallback (try/finally in runNewGameFlowFromMenu should handle this)
+            this.ui.resumeRendering();
+            this.isInFullScreenMode = false;
+            this.ui.addEventLog('New game cancelled.');
+        });
+    }
+    /**
+     * Run the New Game flow from the in-game menu
+     * This destroys the current game and starts fresh
+     */
+    async runNewGameFlowFromMenu() {
+        this.isInFullScreenMode = true;
+        this.ui.pauseRendering(); // Stop GameUIAdapter refresh to prevent screen flicker
+        try {
+            const flowManager = new NewGameFlowManager(this.screen, this.input);
+            const result = await flowManager.run();
+            if (result.success && result.actor) {
+                // Create team and reinitialize game
+                const team = createTeamWithActor(result.actor, `${result.actor.name}'s Team`);
+                const actors = { [result.actor.id]: result.actor };
+                // Destroy old game and reinitialize
+                this.idleGameManager.destroy();
+                this.idleGameManager.initializeWithTeam(team, actors);
+                // Resume normal game
+                this.screen.clear();
+                this.ui.addEventLog(`══════════════════════════════════════`);
+                this.ui.addEventLog(`  Welcome, ${result.actor.name} the ${result.actor.role}!`);
+                this.ui.addEventLog(`  Your adventure begins...`);
+                this.ui.addEventLog(`══════════════════════════════════════`);
+            }
+            else {
+                // Cancelled - return to current game
+                this.ui.addEventLog('New game cancelled.');
+            }
+        }
+        finally {
+            this.ui.resumeRendering(); // Always restore GameUIAdapter refresh
+            this.isInFullScreenMode = false;
+        }
+    }
+    // =========================================================================
+    // AFFIX WORKSHOP
+    // =========================================================================
+    /**
+     * Handle workshop command
+     */
+    handleWorkshopCommand() {
+        this.workshopMode = true;
+        this.workshopSubMode = 'main';
+        this.showWorkshopMenu();
+    }
+    /**
+     * Show workshop main menu
+     */
+    showWorkshopMenu() {
+        const player = this.idleGameManager.getState()?.player;
+        if (!player)
+            return;
+        const unlockedCount = player.unlockedAffixes.length;
+        const registry = getAffixRegistry();
+        const totalAffixes = registry.getAll().length;
+        this.ui.addEventLog('════════ AFFIX WORKSHOP ════════');
+        this.ui.addEventLog(`Affixes discovered: ${unlockedCount}/${totalAffixes}`);
+        this.ui.addEventLog('');
+        this.ui.addEventLog('[1] View Affixes - Browse your collection');
+        this.ui.addEventLog('[2] Forge - Apply affixes to weapons');
+        this.ui.addEventLog('[3] Research - Study unknown affixes');
+        this.ui.addEventLog('[0] Exit Workshop');
+        this.ui.addEventLog('');
+        this.ui.addEventLog('Select an option:');
+    }
+    /**
+     * Handle workshop input
+     */
+    handleWorkshopInput(num) {
+        if (this.workshopSubMode === 'main') {
+            switch (num) {
+                case 0:
+                    this.exitWorkshop();
+                    break;
+                case 1:
+                    this.showAffixCollection();
+                    break;
+                case 2:
+                    this.showForgeMenu();
+                    break;
+                case 3:
+                    this.showResearchMenu();
+                    break;
+                default:
+                    this.ui.addEventLog('Invalid option.');
+            }
+        }
+        else if (this.workshopSubMode === 'view') {
+            this.handleViewAffixInput(num);
+        }
+        else if (this.workshopSubMode === 'forge') {
+            this.handleForgeInput(num);
+        }
+        else if (this.workshopSubMode === 'research') {
+            this.handleResearchInput(num);
+        }
+    }
+    /**
+     * Show affix collection
+     */
+    showAffixCollection() {
+        const player = this.idleGameManager.getState()?.player;
+        if (!player)
+            return;
+        this.workshopSubMode = 'view';
+        const registry = getAffixRegistry();
+        const allAffixes = registry.getAll();
+        this.ui.addEventLog('────── Your Affixes ──────');
+        // Group by type
+        const prefixes = allAffixes.filter(a => a.type === 'prefix');
+        const suffixes = allAffixes.filter(a => a.type === 'suffix');
+        const legendaries = allAffixes.filter(a => a.type === 'legendary');
+        const isUnlocked = (id) => player.unlockedAffixes.includes(id);
+        const rarityColor = (r) => {
+            const colors = {
+                common: '◯', uncommon: '●', rare: '◆', epic: '★', legendary: '✦'
+            };
+            return colors[r] || '?';
+        };
+        this.ui.addEventLog('');
+        this.ui.addEventLog('PREFIXES:');
+        prefixes.slice(0, 4).forEach((a, i) => {
+            const status = isUnlocked(a.id) ? `${rarityColor(a.rarity)} ${a.name}` : `? ???`;
+            this.ui.addEventLog(`  [${i + 1}] ${status}`);
+        });
+        this.ui.addEventLog('');
+        this.ui.addEventLog('SUFFIXES:');
+        suffixes.slice(0, 4).forEach((a, i) => {
+            const status = isUnlocked(a.id) ? `${rarityColor(a.rarity)} ${a.name}` : `? ???`;
+            this.ui.addEventLog(`  [${i + 5}] ${status}`);
+        });
+        this.ui.addEventLog('');
+        this.ui.addEventLog('LEGENDARY:');
+        legendaries.slice(0, 3).forEach((a, i) => {
+            const status = isUnlocked(a.id) ? `✦ ${a.name}` : `? ???`;
+            this.ui.addEventLog(`  [${i + 9}] ${status}`);
+        });
+        this.ui.addEventLog('');
+        this.ui.addEventLog('[0] Back to Workshop');
+    }
+    /**
+     * Handle view affix input
+     */
+    handleViewAffixInput(num) {
+        if (num === 0) {
+            this.workshopSubMode = 'main';
+            this.showWorkshopMenu();
+            return;
+        }
+        const player = this.idleGameManager.getState()?.player;
+        if (!player)
+            return;
+        const registry = getAffixRegistry();
+        const allAffixes = registry.getAll();
+        const prefixes = allAffixes.filter(a => a.type === 'prefix');
+        const suffixes = allAffixes.filter(a => a.type === 'suffix');
+        const legendaries = allAffixes.filter(a => a.type === 'legendary');
+        let affix;
+        if (num >= 1 && num <= 4) {
+            affix = prefixes[num - 1];
+        }
+        else if (num >= 5 && num <= 8) {
+            affix = suffixes[num - 5];
+        }
+        else if (num >= 9 && num <= 11) {
+            affix = legendaries[num - 9];
+        }
+        if (affix && player.unlockedAffixes.includes(affix.id)) {
+            this.showAffixDetails(affix);
+        }
+        else if (affix) {
+            this.ui.addEventLog('This affix has not been discovered yet.');
+            this.ui.addEventLog('Defeat enemies or complete quests to discover new affixes.');
+        }
+        else {
+            this.ui.addEventLog('Invalid selection.');
+        }
+    }
+    /**
+     * Show affix details
+     */
+    showAffixDetails(affix) {
+        const rarityLabels = {
+            common: 'Common', uncommon: 'Uncommon', rare: 'Rare', epic: 'Epic', legendary: 'Legendary'
+        };
+        this.ui.addEventLog(`══════ ${affix.name} ══════`);
+        this.ui.addEventLog(`Type: ${affix.type.toUpperCase()}`);
+        this.ui.addEventLog(`Rarity: ${rarityLabels[affix.rarity]}`);
+        this.ui.addEventLog('');
+        this.ui.addEventLog(affix.description);
+        if (affix.statModifiers) {
+            this.ui.addEventLog('');
+            this.ui.addEventLog('Stats:');
+            for (const [stat, value] of Object.entries(affix.statModifiers)) {
+                if (value !== undefined && value !== 0) {
+                    const sign = value > 0 ? '+' : '';
+                    this.ui.addEventLog(`  ${stat}: ${sign}${value}`);
+                }
+            }
+        }
+        if (affix.onHitEffects && affix.onHitEffects.length > 0) {
+            this.ui.addEventLog('');
+            this.ui.addEventLog('On Hit:');
+            for (const effect of affix.onHitEffects) {
+                const chance = effect.chance < 1 ? `${Math.round(effect.chance * 100)}% chance` : '';
+                this.ui.addEventLog(`  ${effect.type} ${effect.element || ''} ${effect.value} ${chance}`);
+            }
+        }
+        if (affix.requiresLevel) {
+            this.ui.addEventLog('');
+            this.ui.addEventLog(`Requires Level: ${affix.requiresLevel}`);
+        }
+        this.ui.addEventLog('');
+        this.ui.addEventLog('[0] Back');
+    }
+    /**
+     * Show forge menu
+     */
+    showForgeMenu() {
+        const player = this.idleGameManager.getState()?.player;
+        if (!player)
+            return;
+        this.workshopSubMode = 'forge';
+        this.ui.addEventLog('────── Forge ──────');
+        if (!player.equipment.weapon) {
+            this.ui.addEventLog('You have no weapon equipped!');
+            this.ui.addEventLog('Equip a weapon first to apply affixes.');
+        }
+        else {
+            const weapon = player.equipment.weapon;
+            this.ui.addEventLog(`Current Weapon: ${weapon.name}`);
+            this.ui.addEventLog(`Attack: ${weapon.baseAttack} | Durability: ${weapon.durability}/${weapon.maxDurability}`);
+            this.ui.addEventLog(`Affixes: ${weapon.affixes.length > 0 ? weapon.affixes.map(a => a.name).join(', ') : 'None'}`);
+            this.ui.addEventLog('');
+            if (player.unlockedAffixes.length === 0) {
+                this.ui.addEventLog('You have no unlocked affixes to apply.');
+            }
+            else {
+                this.ui.addEventLog('Available affixes to apply:');
+                const registry = getAffixRegistry();
+                player.unlockedAffixes.slice(0, 5).forEach((id, i) => {
+                    const affix = registry.get(id);
+                    if (affix) {
+                        this.ui.addEventLog(`  [${i + 1}] ${affix.name} (${affix.rarity})`);
+                    }
+                });
+                this.ui.addEventLog('');
+                this.ui.addEventLog('(Forging costs gold based on rarity)');
+            }
+        }
+        this.ui.addEventLog('');
+        this.ui.addEventLog('[0] Back to Workshop');
+    }
+    /**
+     * Handle forge input
+     */
+    handleForgeInput(num) {
+        if (num === 0) {
+            this.workshopSubMode = 'main';
+            this.showWorkshopMenu();
+            return;
+        }
+        const player = this.idleGameManager.getState()?.player;
+        if (!player || !player.equipment.weapon) {
+            this.ui.addEventLog('No weapon to forge!');
+            return;
+        }
+        const affixId = player.unlockedAffixes[num - 1];
+        if (!affixId) {
+            this.ui.addEventLog('Invalid selection.');
+            return;
+        }
+        const registry = getAffixRegistry();
+        const affix = registry.get(affixId);
+        if (!affix) {
+            this.ui.addEventLog('Affix not found.');
+            return;
+        }
+        // Calculate cost
+        const costByRarity = {
+            common: 20, uncommon: 50, rare: 100, epic: 250, legendary: 500
+        };
+        const cost = costByRarity[affix.rarity] || 50;
+        if (player.stats.gold < cost) {
+            this.ui.addEventLog(`Not enough gold! Need ${cost}g, have ${player.stats.gold}g.`);
+            return;
+        }
+        // Check if affix is compatible
+        const existingAffixes = player.equipment.weapon.affixes;
+        const hasConflict = existingAffixes.some(existing => affix.incompatibleWith?.includes(existing.definitionId) ||
+            registry.get(existing.definitionId)?.incompatibleWith?.includes(affix.id));
+        if (hasConflict) {
+            this.ui.addEventLog('This affix conflicts with an existing one!');
+            return;
+        }
+        // Apply affix
+        player.stats.gold -= cost;
+        player.equipment.weapon.affixes.push({
+            definitionId: affix.id,
+            name: affix.name,
+            type: affix.type,
+            rarity: affix.rarity,
+        });
+        this.ui.addEventLog(`✓ Applied "${affix.name}" to ${player.equipment.weapon.name}!`);
+        this.ui.addEventLog(`  Cost: ${cost}g | Remaining: ${player.stats.gold}g`);
+        this.showForgeMenu();
+    }
+    /**
+     * Show research menu
+     */
+    showResearchMenu() {
+        const player = this.idleGameManager.getState()?.player;
+        if (!player)
+            return;
+        this.workshopSubMode = 'research';
+        const registry = getAffixRegistry();
+        const allAffixes = registry.getAll();
+        const locked = allAffixes.filter(a => !player.unlockedAffixes.includes(a.id));
+        this.ui.addEventLog('────── Research ──────');
+        this.ui.addEventLog('Study mysterious affixes to unlock them.');
+        this.ui.addEventLog('');
+        if (locked.length === 0) {
+            this.ui.addEventLog('All affixes have been discovered!');
+        }
+        else {
+            this.ui.addEventLog(`Unknown affixes: ${locked.length}`);
+            this.ui.addEventLog('');
+            // Show hints for a few random locked affixes
+            const hints = locked.slice(0, 3);
+            hints.forEach((a, i) => {
+                const hint = this.getAffixHint(a);
+                this.ui.addEventLog(`  [${i + 1}] ${hint} (${a.rarity})`);
+            });
+            this.ui.addEventLog('');
+            this.ui.addEventLog('Research cost: 100g per attempt (50% success)');
+        }
+        this.ui.addEventLog('');
+        this.ui.addEventLog('[0] Back to Workshop');
+    }
+    /**
+     * Get a hint for an unknown affix
+     */
+    getAffixHint(affix) {
+        // Provide vague hints based on type/effects
+        if (affix.type === 'legendary') {
+            return '??? (Legendary power)';
+        }
+        if (affix.onHitEffects?.some(e => e.element === 'fire')) {
+            return '??? (Burns with flames)';
+        }
+        if (affix.onHitEffects?.some(e => e.element === 'ice')) {
+            return '??? (Chills to the bone)';
+        }
+        if (affix.onHitEffects?.some(e => e.element === 'lightning')) {
+            return '??? (Crackles with energy)';
+        }
+        if (affix.statModifiers?.attack && affix.statModifiers.attack > 10) {
+            return '??? (Raw power)';
+        }
+        if (affix.statModifiers?.speed && affix.statModifiers.speed > 0) {
+            return '??? (Swift as wind)';
+        }
+        return '??? (Unknown properties)';
+    }
+    /**
+     * Handle research input
+     */
+    handleResearchInput(num) {
+        if (num === 0) {
+            this.workshopSubMode = 'main';
+            this.showWorkshopMenu();
+            return;
+        }
+        const player = this.idleGameManager.getState()?.player;
+        if (!player)
+            return;
+        const registry = getAffixRegistry();
+        const allAffixes = registry.getAll();
+        const locked = allAffixes.filter(a => !player.unlockedAffixes.includes(a.id));
+        const targetAffix = locked[num - 1];
+        if (!targetAffix) {
+            this.ui.addEventLog('Invalid selection.');
+            return;
+        }
+        const cost = 100;
+        if (player.stats.gold < cost) {
+            this.ui.addEventLog(`Not enough gold! Need ${cost}g, have ${player.stats.gold}g.`);
+            return;
+        }
+        player.stats.gold -= cost;
+        // 50% success chance (increased by higher rarity being harder)
+        const rarityBonus = {
+            common: 0.3, uncommon: 0.2, rare: 0.1, epic: 0, legendary: -0.2
+        };
+        const successChance = 0.5 + (rarityBonus[targetAffix.rarity] || 0);
+        const success = Math.random() < successChance;
+        if (success) {
+            player.unlockedAffixes.push(targetAffix.id);
+            this.ui.addEventLog(`✓ Research successful!`);
+            this.ui.addEventLog(`  Discovered: ${targetAffix.name}`);
+            this.ui.addEventLog(`  "${targetAffix.description}"`);
+        }
+        else {
+            this.ui.addEventLog('✗ Research failed...');
+            this.ui.addEventLog('  The affix remains mysterious.');
+            this.ui.addEventLog('  Try again or seek clues in the dungeon.');
+        }
+        this.ui.addEventLog(`  Gold spent: ${cost}g | Remaining: ${player.stats.gold}g`);
+    }
+    /**
+     * Exit workshop
+     */
+    exitWorkshop() {
+        this.workshopMode = false;
+        this.workshopSubMode = 'main';
+        this.ui.addEventLog('Leaving the Workshop...');
+    }
+    // =========================================================================
+    // EVENT HANDLERS
+    // =========================================================================
+    onTick() {
+        // Tick handling done in main loop
+    }
+    onTravelStarted(data) {
+        const travel = data;
+        this.ui.addEventLog(`Setting out... (${travel.duration}s)`);
+        // Route change handled via onIdlePhaseChange callback
+    }
+    onTravelArrived(data) {
+        const { room } = data;
+        this.ui.addEventLog(`Arrived at: ${room.name}`);
+        this.ui.addEventLog(room.description);
+        this.router.navigate({ type: 'explore' });
+        // Check for random NPC encounter
+        if (Math.random() < 0.3) {
+            const idleState = this.idleGameManager.getState();
+            if (idleState) {
+                const floor = idleState.phase === 'in_dungeon' && idleState.dungeonRunner
+                    ? idleState.dungeonRunner.getState()?.currentLevel ?? 1
+                    : 1;
+                const npc = getNPCGenerator().generate({ floor });
+                this.ui.addEventLog(`You encounter ${npc.name}, a ${npc.race} ${npc.role}.`);
+            }
+        }
+    }
+    onCombatStarted(data) {
+        this.ui.addEventLog('== Combat started! ==');
+        this.router.navigate({ type: 'combat', encounterId: 'current' });
+    }
+    onCombatTick(data) {
+        // Handled by render
+    }
+    onCombatVictory(data) {
+        const { rewards } = data;
+        this.ui.addEventLog('Victory!');
+        this.ui.addEventLog(`Gained ${rewards.exp} EXP, ${rewards.gold} gold`);
+        this.router.navigate({ type: 'explore' });
+        // Update quest progress - use adapted state for combat info
+        const idleState = this.idleGameManager.getState();
+        if (idleState?.dungeonRunner) {
+            const runnerState = idleState.dungeonRunner.getState();
+            if (runnerState?.activeCombat) {
+                for (const enemy of runnerState.activeCombat.enemies) {
+                    this.questManager.updateProgress('kill', enemy.id);
+                    this.questManager.updateProgress('kill', `enemy_${enemy.name.toLowerCase().replace(/\s/g, '_')}`);
+                }
+            }
+        }
+    }
+    onCombatDefeat() {
+        this.ui.addEventLog('You have been defeated...');
+    }
+    onPlayerRespawn(data) {
+        const { room } = data;
+        this.ui.addEventLog('═══ RESPAWNING ═══');
+        this.ui.addEventLog(`You wake up at ${room.name}, fully healed.`);
+        this.ui.addEventLog('Your adventure continues...');
+        this.router.navigate({ type: 'explore' });
+    }
+    onNewEvent(data) {
+        const event = data;
+        this.ui.addEventLog(`${event.title}: ${event.description}`);
+    }
+    // =========================================================================
+    // UTILITIES
+    // =========================================================================
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    cleanup() {
+        this.isRunning = false;
+        this.idleGameManager.destroy();
+        this.ui.cleanup();
+        // Exit alternate screen buffer to restore terminal history
+        this.screen.exitAlternateScreen();
+    }
+}
+// ============================================================================
+// ENTRY POINT
+// ============================================================================
+const app = new IdleRPGTerminal();
+app.start().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=main.js.map
+//# debugId=bfa08172-04b0-56af-9640-104baeb3ae89