llm-checker 3.5.14 → 3.6.1

package/src/ollama/client.js

@@ -213,7 +213,9 @@ class OllamaClient {
                 return [];
             }
 
-            const models = data.models.map(model => this.parseOllamaModel(model));
+            const models = data.models
+                .map(model => this.parseOllamaModel(model))
+                .filter(Boolean);
             return models;
         } catch (error) {
             throw new Error(`Failed to fetch local models: ${error.message}`);
@@ -335,8 +337,13 @@ class OllamaClient {
         const sizeBytes = ollamaModel.size || 0;
         const sizeGB = Math.round(sizeBytes / (1024 ** 3) * 10) / 10;
 
+        // Guard against a malformed /api/tags entry missing its name: a single bad
+        // entry must not crash the whole local-model list (getLocalModels wraps this
+        // in one try/catch). Callers filter out null entries.
+        const rawName = ollamaModel.name || ollamaModel.model || '';
+        if (!rawName) return null;
 
-        const [modelFamily, version] = ollamaModel.name.split(':');
+        const [modelFamily, version] = rawName.split(':');
         const details = ollamaModel.details || {};
 
 
@@ -355,7 +362,7 @@ class OllamaClient {
         }
 
         return {
-            name: ollamaModel.name,
+            name: rawName,
             displayName: `${modelFamily} ${version || 'latest'}`,
             family: details.family || modelFamily.toLowerCase(),
             size: estimatedParams,
@@ -395,43 +402,66 @@ class OllamaClient {
             const reader = response.body.getReader();
             const decoder = new TextDecoder();
             let receivedSuccess = false;
+            let buffer = '';
+
+            // The pull stream is NDJSON. A single status object frequently spans two
+            // TCP reads, so we must keep a carry-over buffer across reads (and decode
+            // with { stream: true } so a multi-byte UTF-8 char split across a chunk
+            // boundary isn't corrupted) instead of parsing each chunk in isolation.
+            const handleData = (data) => {
+                if (onProgress && (data.status || data.completed !== undefined)) {
+                    onProgress({
+                        status: data.status,
+                        completed: data.completed,
+                        total: data.total,
+                        percent: data.total ? Math.round((data.completed / data.total) * 100) : 0
+                    });
+                }
+                if (data.status === 'success') {
+                    receivedSuccess = true;
+                    return true;
+                }
+                if (data.error) {
+                    throw new Error(data.error);
+                }
+                return false;
+            };
 
             while (true) {
                 const { done, value } = await reader.read();
                 if (done) break;
 
-                const chunk = decoder.decode(value);
-                const lines = chunk.split('\n').filter(line => line.trim());
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || ''; // keep the trailing partial line
+
+                for (const rawLine of lines) {
+                    const line = rawLine.trim();
+                    if (!line) continue;
 
-                for (const line of lines) {
+                    let data;
                     try {
-                        const data = JSON.parse(line);
-
-                        if (onProgress && (data.status || data.completed !== undefined)) {
-                            onProgress({
-                                status: data.status,
-                                completed: data.completed,
-                                total: data.total,
-                                percent: data.total ? Math.round((data.completed / data.total) * 100) : 0
-                            });
-                        }
-
-                        if (data.status === 'success') {
-                            receivedSuccess = true;
-                            return { success: true, model: modelName };
-                        }
-
-                        if (data.error) {
-                            throw new Error(data.error);
-                        }
-                    } catch (e) {
-                        if (e.message && !e.message.includes('Unexpected')) {
-                            throw e; // Re-throw real errors, skip JSON parse errors
-                        }
+                        data = JSON.parse(line);
+                    } catch {
+                        continue; // skip unparseable lines structurally (no message matching)
+                    }
+
+                    if (handleData(data)) {
+                        return { success: true, model: modelName };
                     }
                 }
             }
 
+            // Flush a complete final line left in the buffer after the stream ends.
+            const tail = buffer.trim();
+            if (tail) {
+                let data = null;
+                try { data = JSON.parse(tail); } catch { data = null; }
+                if (data && handleData(data)) {
+                    return { success: true, model: modelName };
+                }
+            }
+
             if (!receivedSuccess) {
                 throw new Error('Stream ended without success confirmation');
             }
@@ -721,7 +751,17 @@ class OllamaClient {
             const handleLine = (line) => {
                 if (!line.trim()) return;
 
-                const data = JSON.parse(line);
+                // Skip any line that isn't valid JSON (a partial/truncated final
+                // line when the connection is cut, or a proxy-injected keep-alive)
+                // instead of throwing — an unparseable trailing line must not discard
+                // all of the content already accumulated from the stream.
+                let data;
+                try {
+                    data = JSON.parse(line);
+                } catch {
+                    return;
+                }
+
                 const chunk = data?.message?.content || '';
                 if (chunk) {
                     content += chunk;

package/src/ollama/enhanced-client.js

@@ -60,8 +60,26 @@ class EnhancedOllamaClient extends OllamaClient {
                 }
             };
         } catch (error) {
-            console.error('Error in enhanced compatibility check:', error);
-            return await this.getCompatibleModels();
+            // Degrade gracefully when the enhanced scrape fails (e.g. ollama.com is
+            // unreachable). The previous fallback called this.getCompatibleModels(),
+            // which exists on neither this class nor its parent, so the catch itself
+            // threw "is not a function" and masked the real (often network) error.
+            console.error('Error in enhanced compatibility check:', error.message);
+            let installed = 0;
+            try {
+                const localModels = await this.getLocalModels();
+                installed = Array.isArray(localModels) ? localModels.length : 0;
+            } catch (_) {
+                installed = 0;
+            }
+            return {
+                installed,
+                compatible: 0,
+                compatible_models: [],
+                recommendations: [],
+                total_available: 0,
+                error: error.message
+            };
         }
     }
 

package/src/ollama/manager.js

@@ -8,8 +8,11 @@ class OllamaManager extends EventEmitter {
         this.modelQueue = [];
         this.isProcessing = false;
         this.maxConcurrent = options.maxConcurrent || 1;
-        this.autoCleanup = options.autoCleanup || true;
+        // `options.autoCleanup || true` was always true, so passing { autoCleanup:
+        // false } could not actually disable the background timer.
+        this.autoCleanup = options.autoCleanup !== undefined ? Boolean(options.autoCleanup) : true;
         this.cleanupInterval = options.cleanupInterval || 30 * 60 * 1000; // 30 minutes
+        this._cleanupTimer = null;
 
         if (this.autoCleanup) {
             this.startCleanupTimer();
@@ -295,7 +298,7 @@ class OllamaManager extends EventEmitter {
     }
 
     startCleanupTimer() {
-        setInterval(async () => {
+        this._cleanupTimer = setInterval(async () => {
             try {
                 const analysis = await this.cleanupUnusedModels();
                 if (analysis.cleanupCandidates > 0) {
@@ -305,6 +308,11 @@ class OllamaManager extends EventEmitter {
                 this.emit('error', error);
             }
         }, this.cleanupInterval);
+        // Don't keep the event loop (and thus the CLI process) alive just for the
+        // periodic cleanup timer.
+        if (this._cleanupTimer && typeof this._cleanupTimer.unref === 'function') {
+            this._cleanupTimer.unref();
+        }
     }
 
     async getStatistics() {
@@ -348,6 +356,10 @@ class OllamaManager extends EventEmitter {
 
     destroy() {
         // Clean up resources
+        if (this._cleanupTimer) {
+            clearInterval(this._cleanupTimer);
+            this._cleanupTimer = null;
+        }
         this.removeAllListeners();
         this.modelQueue = [];
         this.isProcessing = false;

package/src/policy/cli-policy.js

@@ -158,7 +158,8 @@ function getCandidateTargets(model) {
 function patternToRegex(pattern) {
     const escaped = String(pattern || '')
         .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*/g, '.*');
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.'); // glob '?' = exactly one character (not a regex quantifier)
 
     return new RegExp(`^${escaped}$`, 'i');
 }
@@ -176,7 +177,12 @@ function parseExceptionExpiry(expiresAt) {
 }
 
 function isExceptionEntryActive(entry, now) {
-    const expiry = parseExceptionExpiry(entry?.expires_at);
+    const rawExpiry = entry?.expires_at;
+    const expiry = parseExceptionExpiry(rawExpiry);
+    // A provided-but-unparseable expiry (typo like '2026/06/01', free text like
+    // 'next friday') must NOT be treated as "no expiry" — that would silently make
+    // the exception permanent and suppress real policy violations. Fail closed.
+    if (rawExpiry && !expiry) return false;
     if (!expiry) return true;
     return expiry.getTime() >= now.getTime();
 }

package/src/policy/policy-engine.js

@@ -494,7 +494,8 @@ class PolicyEngine {
 
         const escaped = pattern
             .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-            .replace(/\*/g, '.*');
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.'); // glob '?' = exactly one character (not a regex quantifier)
 
         const regex = new RegExp(`^${escaped}$`, 'i');
         this.patternCache.set(pattern, regex);

package/src/provenance/model-provenance.js

@@ -83,7 +83,10 @@ function extractVersionFromIdentifier(identifier) {
     if (!text) return UNKNOWN_VALUE;
 
     if (text.includes(':')) {
-        const [, tag] = text.split(':');
+        // The tag is the segment after the LAST colon. Splitting on every colon and
+        // taking the second segment mis-parsed registry-prefixed refs like
+        // 'registry.local:5000/llama3:8b' (it returned '5000/llama3' instead of '8b').
+        const tag = text.slice(text.lastIndexOf(':') + 1);
         return sanitizeValue(tag);
     }
 

package/src/ui/cli-theme.js

@@ -4,6 +4,7 @@ const chalk = require('chalk');
 const { execFileSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
+const readline = require('readline');
 
 // Adapted from /Users/pchmirenko/Downloads/ascii-motion-cli.tsx frame model.
 const THEME_DARK = {
@@ -41,6 +42,8 @@ const FRAMES_PER_SECOND = 14;
 // Security: do not auto-load executable-style banner sources from user-writable folders.
 // External banner loading is opt-in via LLM_CHECKER_BANNER_SOURCE and supports JSON only.
 const DEFAULT_BANNER_SOURCE = null;
+// Canonical startup banner asset. Do not edit casually: treat as product identity.
+// Any intentional change should update tests/banner-canonical.test.js in the same commit.
 const BUNDLED_TEXT_BANNER_SOURCE = path.join(__dirname, 'banner-profesional-v2.txt');
 const DEFAULT_TEXT_BANNER_SOURCES = [
     BUNDLED_TEXT_BANNER_SOURCE
@@ -78,8 +81,42 @@ function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function clearTerminal() {
-    process.stdout.write('\x1b[2J\x1b[0f');
+function getSafeTerminalWidth(columns = process.stdout.columns, platform = process.platform) {
+    void platform;
+    const value = Number(columns);
+    if (!Number.isFinite(value) || value <= 0) return null;
+
+    const width = Math.floor(value);
+    // Many terminals (Windows consoles, libvte, tmux, SSH) auto-wrap when output
+    // writes exactly `columns` cells, which tears the persistent panel border on
+    // resize/pulse. The canonical banner is centered/clipped, so reserving one
+    // trailing cell on every platform is invisible while avoiding the wrap.
+    return Math.max(20, width - 1);
+}
+
+function getTerminalClearSequence(platform = process.platform) {
+    if (platform === 'win32') {
+        return '\x1b[1;1H\x1b[0J';
+    }
+
+    return '\x1b[2J\x1b[H';
+}
+
+function clearTerminal(options = {}) {
+    if (!process.stdout.isTTY) return;
+
+    const platform = options.platform || process.platform;
+    if (platform === 'win32') {
+        process.stdout.write(getTerminalClearSequence(platform));
+        return;
+    }
+
+    try {
+        readline.cursorTo(process.stdout, 0, 0);
+        readline.clearScreenDown(process.stdout);
+    } catch {
+        process.stdout.write(getTerminalClearSequence(platform));
+    }
 }
 
 function parseDarkBackgroundValue(value) {
@@ -323,14 +360,20 @@ function loadTextBanner(sourceFile) {
     }
 }
 
+function getTextBannerLineCount(sourceFile) {
+    const lines = loadTextBanner(sourceFile);
+    return Array.isArray(lines) ? lines.length : 0;
+}
+
 function drawTextBanner(lines, options = {}) {
     const palette = getTextBannerPalette(options);
     const colorPhase = Number.isFinite(options.colorPhase)
         ? Math.max(0, Math.floor(options.colorPhase))
         : 0;
-    const terminalWidth = Number.isFinite(process.stdout.columns) && process.stdout.columns > 0
-        ? process.stdout.columns
-        : null;
+    const terminalWidth = getSafeTerminalWidth(
+        options.columns ?? process.stdout.columns,
+        options.platform || process.platform
+    );
 
     const centerToWidth = (text, width) => {
         const value = String(text || '').replace(/\s+$/g, '');
@@ -390,7 +433,7 @@ function drawTextBanner(lines, options = {}) {
 
         const frameMatch = line.match(/^(\s*\|)(.*)(\|\s*)$/);
         if (!frameMatch) {
-            console.log(line);
+            console.log(terminalWidth ? fitLine(line, terminalWidth) : line);
             continue;
         }
 
@@ -728,8 +771,15 @@ module.exports = {
     __private: {
         detectDarkBackgroundFromColorFgbg,
         detectDarkBackgroundFromMacOsAppearance,
+        fitLine,
+        drawTextBanner,
+        clearTerminal,
+        getSafeTerminalWidth,
+        getTerminalClearSequence,
         makeFrames,
         drawFrame,
-        resolveHasDarkBackground
+        resolveHasDarkBackground,
+        loadTextBanner,
+        getTextBannerLineCount
     }
 };

package/src/ui/interactive-panel.js

@@ -4,7 +4,43 @@ const chalk = require('chalk');
 const inquirer = require('inquirer');
 const readline = require('readline');
 const { spawn } = require('child_process');
-const { animateBanner, renderPersistentBanner } = require('./cli-theme');
+const {
+    animateBanner,
+    renderPersistentBanner,
+    __private: {
+        clearTerminal,
+        getSafeTerminalWidth,
+        getTextBannerLineCount
+    }
+} = require('./cli-theme');
+
+// Fixed (non-banner, non-command) chrome lines emitted by the full-layout panel:
+// blank-after-banner, top separator, input line, separator, title, blank,
+// blank-before-footer, separator, footer hint = 9 lines. Keep this in sync with
+// renderPanel(); the integration test asserts the rendered budget never overflows.
+const FIXED_CHROME_LINES = 9;
+// Fixed chrome for the compact header layout (single-line header replaces the
+// 37-line banner): header, separator, input, separator, title, blank,
+// blank-before-footer, separator, footer = 9 lines as well.
+const COMPACT_CHROME_LINES = 9;
+// Smallest command list we are willing to show in either layout.
+const MIN_FULL_COMMAND_ROWS = 3;
+const MIN_COMPACT_COMMAND_ROWS = 4;
+const MAX_COMMAND_ROWS = 16;
+
+// Derive the full-layout banner height from the real banner asset so layout
+// budgeting tracks the banner automatically instead of drifting from a literal.
+function getBannerLineCount() {
+    const count = typeof getTextBannerLineCount === 'function' ? getTextBannerLineCount() : 0;
+    return Number.isFinite(count) && count > 0 ? count : 37;
+}
+
+// Total fixed (always-present) lines for a layout, excluding the command list.
+function getReservedRows(compact = false) {
+    return compact
+        ? COMPACT_CHROME_LINES
+        : getBannerLineCount() + FIXED_CHROME_LINES;
+}
 
 const PRIMARY_COMMAND_PRIORITY = [
     'check',
@@ -31,10 +67,6 @@ const REQUIRED_ARG_PROMPTS = {
     ]
 };
 
-function clearTerminal() {
-    process.stdout.write('\x1b[2J\x1b[0f');
-}
-
 function truncateText(text, maxLength) {
     const value = String(text || '');
     if (value.length <= maxLength) return value;
@@ -42,6 +74,58 @@ function truncateText(text, maxLength) {
     return `${value.slice(0, maxLength - 3)}...`;
 }
 
+function getPanelWidth({
+    columns = process.stdout.columns,
+    platform = process.platform
+} = {}) {
+    const safeWidth = getSafeTerminalWidth(columns, platform) || 100;
+    return Math.max(40, Math.min(safeWidth, 128));
+}
+
+function getTerminalRows(rows = process.stdout.rows) {
+    const value = Number(rows);
+    if (!Number.isFinite(value) || value <= 0) return null;
+    return Math.floor(value);
+}
+
+// Minimum terminal height at which the full-banner layout fits without scrolling.
+// The full layout always emits getReservedRows(false) fixed lines plus at least
+// MIN_FULL_COMMAND_ROWS command rows, so anything shorter must use the compact
+// header instead (otherwise the panel overflows the viewport and flickers, the
+// #86 artifact on Windows Terminal / PowerShell / CMD).
+function getFullLayoutMinRows() {
+    return getReservedRows(false) + MIN_FULL_COMMAND_ROWS;
+}
+
+function shouldUseCompactPanelLayout({
+    rows = process.stdout.rows,
+    platform = process.platform,
+    forceFullBanner = process.env.LLM_CHECKER_FORCE_FULL_PANEL_BANNER
+} = {}) {
+    if (forceFullBanner === '1') return false;
+
+    const terminalRows = getTerminalRows(rows);
+    if (!terminalRows) return false;
+
+    // Windows consoles keep a larger compact band: their scrollback/redraw is the
+    // worst offender, so favor the single-line header well past the strict fit.
+    const fullLayoutMinRows = getFullLayoutMinRows();
+    if (platform === 'win32') {
+        return terminalRows < Math.max(64, fullLayoutMinRows);
+    }
+    return terminalRows < fullLayoutMinRows;
+}
+
+function getMaxCommandRows({
+    rows = process.stdout.rows,
+    compact = false
+} = {}) {
+    const terminalRows = getTerminalRows(rows) || 40;
+    const reservedRows = getReservedRows(compact);
+    const minimumRows = compact ? MIN_COMPACT_COMMAND_ROWS : MIN_FULL_COMMAND_ROWS;
+    return Math.max(minimumRows, Math.min(MAX_COMMAND_ROWS, terminalRows - reservedRows));
+}
+
 function tokenizeArgString(rawInput = '') {
     const tokens = [];
     let current = '';
@@ -245,10 +329,16 @@ function getCommandWindow(commands, selectedIndex, maxRows) {
 
 function renderPanel(state, catalog, primaryCommands, options = {}) {
     const colorPhase = Number.isFinite(options.colorPhase) ? options.colorPhase : 0;
-    const width = Math.max(76, Math.min(process.stdout.columns || 100, 128));
+    const platform = options.platform || process.platform;
+    const rows = options.rows ?? process.stdout.rows;
+    const columns = options.columns ?? process.stdout.columns;
+    const compact = typeof options.compact === 'boolean'
+        ? options.compact
+        : shouldUseCompactPanelLayout({ rows, platform });
+    const width = getPanelWidth({ columns, platform });
     const separator = '-'.repeat(width - 2);
     const visibleCommands = getVisibleCommands(state, catalog, primaryCommands);
-    const maxCommandRows = Math.max(6, Math.min(16, (process.stdout.rows || 40) - 28));
+    const maxCommandRows = getMaxCommandRows({ rows, compact });
     const selectedIndex =
         visibleCommands.length > 0
             ? Math.max(0, Math.min(state.selected, visibleCommands.length - 1))
@@ -258,11 +348,17 @@ function renderPanel(state, catalog, primaryCommands, options = {}) {
     }
     const commandWindow = getCommandWindow(visibleCommands, selectedIndex, maxCommandRows);
 
-    clearTerminal();
-    renderPersistentBanner(undefined, { colorPhase });
-    console.log('');
+    clearTerminal({ platform });
+    if (compact) {
+        console.log(chalk.cyan.bold('llm-checker | Interactive command panel'));
+    } else {
+        renderPersistentBanner(undefined, { colorPhase, columns, platform });
+        console.log('');
+    }
     console.log(chalk.gray(separator));
-    const inputLabel = state.paletteOpen ? `/${state.query}` : '';
+    const inputLabel = state.paletteOpen
+        ? truncateText(`/${state.query}`, Math.max(1, width - 4))
+        : '';
     console.log(`${chalk.white.bold('>')} ${chalk.white(inputLabel)}${chalk.gray('|')}`);
     console.log(chalk.gray(separator));
 
@@ -275,8 +371,8 @@ function renderPanel(state, catalog, primaryCommands, options = {}) {
     if (visibleCommands.length === 0) {
         console.log(chalk.yellow('No commands match your query.'));
     } else {
-        const commandCol = 26;
-        const descCol = Math.max(18, width - commandCol - 8);
+        const commandCol = Math.min(26, Math.max(12, Math.floor(width * 0.36)));
+        const descCol = Math.max(8, width - commandCol - 2);
         const hiddenAbove = commandWindow.start;
         const hiddenBelow = visibleCommands.length - commandWindow.end;
 
@@ -307,10 +403,22 @@ function renderPanel(state, catalog, primaryCommands, options = {}) {
     console.log('');
     console.log(chalk.gray(separator));
     console.log(
-        chalk.gray('up/down navigate | Enter run | / open all | Esc close all | q exit')
+        chalk.gray(truncateText('up/down navigate | Enter run | / open all | Esc close all | q exit', width))
     );
 }
 
+function shouldEnableBannerPulse({
+    isTTY = process.stdout.isTTY,
+    disableAnimation = process.env.LLM_CHECKER_DISABLE_ANIMATION,
+    forcePulse = process.env.LLM_CHECKER_FORCE_PANEL_PULSE,
+    platform = process.platform
+} = {}) {
+    if (!isTTY) return false;
+    if (disableAnimation === '1') return false;
+    if (forcePulse === '1') return true;
+    return platform !== 'win32';
+}
+
 async function collectCommandArgs(commandMeta) {
     const prompts = [];
     const requiredPrompts = REQUIRED_ARG_PROMPTS[commandMeta.name] || [];
@@ -411,20 +519,28 @@ async function launchInteractivePanel(options) {
         colorPhase: 0
     };
 
+    let lastRenderedColorPhase = null;
     const renderNow = () => {
+        lastRenderedColorPhase = state.colorPhase;
         renderPanel(state, catalog, primaryCommands, { colorPhase: state.colorPhase });
     };
 
-    await animateBanner({ text: appName });
+    // Fix #5: the startup reveal animation (animateBanner) already commits its
+    // final banner frame to the screen. Previously renderNow() then immediately
+    // cleared and redrew the whole screen a second time, producing a visible
+    // double-clear flash. Run the reveal once, then commit the panel chrome a
+    // single time on top of the same screen state.
+    if (!shouldUseCompactPanelLayout()) {
+        await animateBanner({ text: appName });
+    }
     renderNow();
 
     readline.emitKeypressEvents(process.stdin);
 
     return new Promise((resolve) => {
-        const shouldPulseBanner =
-            process.stdout.isTTY &&
-            process.env.LLM_CHECKER_DISABLE_ANIMATION !== '1';
+        const shouldPulseBanner = shouldEnableBannerPulse();
         let pulseTimer = null;
+        let resizeTimer = null;
 
         const stopBannerPulse = () => {
             if (pulseTimer) {
@@ -435,15 +551,42 @@ async function launchInteractivePanel(options) {
 
         const startBannerPulse = () => {
             if (!shouldPulseBanner || pulseTimer) return;
+            // Fix #4: animating color no longer drives a full-screen clear+redraw
+            // 8x/second. Slow the cadence and only repaint when the visible color
+            // phase actually advanced, so an idle panel stops thrashing the
+            // terminal (the flicker amplifier behind issue #86).
             pulseTimer = setInterval(() => {
                 if (state.busy) return;
                 state.colorPhase = (state.colorPhase + 1) % 1024;
+                if (state.colorPhase === lastRenderedColorPhase) return;
                 renderNow();
-            }, 120);
+            }, 220);
+        };
+
+        // Fix #3: react to terminal resizes. The pulse timer is disabled on
+        // Windows, so without this the panel keeps drawing at the old width until
+        // the next keypress, tearing the borders (the #86 artifact). Debounce so a
+        // drag-resize coalesces into a single repaint at the final size.
+        const onResize = () => {
+            if (resizeTimer) clearTimeout(resizeTimer);
+            resizeTimer = setTimeout(() => {
+                resizeTimer = null;
+                if (state.busy) return;
+                renderNow();
+            }, 100);
+        };
+
+        const stopResizeWatcher = () => {
+            if (resizeTimer) {
+                clearTimeout(resizeTimer);
+                resizeTimer = null;
+            }
+            process.stdout.off('resize', onResize);
         };
 
         const stopInteractiveMode = () => {
             stopBannerPulse();
+            stopResizeWatcher();
             process.stdin.off('keypress', onKeypress);
             if (process.stdin.isTTY) process.stdin.setRawMode(false);
             process.stdin.pause();
@@ -454,6 +597,7 @@ async function launchInteractivePanel(options) {
             if (process.stdin.isTTY) process.stdin.setRawMode(true);
             process.stdin.resume();
             startBannerPulse();
+            process.stdout.on('resize', onResize);
             renderNow();
         };
 
@@ -578,6 +722,18 @@ module.exports = {
         buildCommandCatalog,
         buildPrimaryCommands,
         getVisibleCommands,
-        truncateText
+        truncateText,
+        shouldEnableBannerPulse,
+        getPanelWidth,
+        getMaxCommandRows,
+        shouldUseCompactPanelLayout,
+        getBannerLineCount,
+        getReservedRows,
+        getFullLayoutMinRows,
+        FIXED_CHROME_LINES,
+        COMPACT_CHROME_LINES,
+        MIN_FULL_COMMAND_ROWS,
+        MIN_COMPACT_COMMAND_ROWS,
+        MAX_COMMAND_ROWS
     }
 };