auq-mcp-server 2.3.0 → 2.5.0

package/README.md

@@ -248,6 +248,7 @@ It is recommended to **disable** the built-in questioning tool in your harness (
 # you won't likely need these at all
 auq server       # Start MCP server
 auq --version    # Show version
+auq update       # Check for and install updates
 auq --help       # Show help
 ```
 
@@ -255,6 +256,122 @@ auq --help       # Show help
 
 ---
 
+### CLI Commands
+
+AUQ provides headless CLI commands for managing sessions and configuration without the TUI.
+
+#### Answer Sessions
+
+```bash
+# Answer a session with JSON answers
+auq answer <sessionId> --answers '{"0": {"selectedOption": "option1"}}'
+
+# Reject a session
+auq answer <sessionId> --reject --reason "Not applicable"
+
+# Force answer an abandoned session
+auq answer <sessionId> --answers '...' --force
+
+# JSON output
+auq answer <sessionId> --answers '...' --json
+```
+
+#### Manage Sessions
+
+```bash
+# List pending sessions
+auq sessions list
+
+# List stale sessions only
+auq sessions list --stale
+
+# List all sessions (including completed, abandoned)
+auq sessions list --all
+
+# Dismiss/archive a session
+auq sessions dismiss <sessionId>
+
+# JSON output
+auq sessions list --json
+```
+
+#### Configuration
+
+```bash
+# View all configuration
+auq config get
+
+# View specific setting
+auq config get staleThreshold
+
+# Set a value (local .auqrc.json)
+auq config set staleThreshold 3600000
+
+# Set globally
+auq config set staleThreshold 3600000 --global
+```
+
+---
+
+### Stale Session Detection
+
+Sessions that remain unanswered longer than the configured threshold are marked as "stale" (potentially orphaned). This helps identify sessions where the AI may have disconnected or timed out.
+
+- **Visual indicators**: Stale sessions show a ⚠ warning icon and yellow highlighting in the TUI
+- **Toast notifications**: A notification appears when a session becomes stale (configurable)
+- **Grace period**: Interacting with a stale session provides a 30-minute grace period
+- **Configurable threshold**: Default is 2 hours (7,200,000ms)
+
+---
+
+### Abandoned Session Handling
+
+When an AI client disconnects, associated sessions are marked as "abandoned". These sessions:
+
+- Remain visible in the TUI with a red indicator
+- Show a confirmation dialog before answering ("AI가 disconnect되었습니다")
+- Can still be answered via CLI with the `--force` flag
+- Are detectable via `auq sessions list --all`
+
+---
+
+### Auto-Update
+
+AUQ automatically checks for updates and keeps itself up to date.
+
+#### How it works
+
+- **Patch updates** (e.g., 2.4.0 → 2.4.1): Automatically installed when the TUI starts. These are bug fixes and minor improvements.
+- **Minor/Major updates** (e.g., 2.4.0 → 2.5.0 or 3.0.0): A fullscreen prompt is shown with changelog and options to update, skip, or defer.
+- **CLI notification**: When running non-TUI commands, a one-line update notification is shown if a newer version is available.
+
+#### Manual update
+
+Run `auq update` to manually check for and install updates:
+
+```bash
+auq update        # Interactive update check
+auq update -y     # Skip confirmation prompt
+```
+
+#### Disabling update checks
+
+Disable automatic update checks via config:
+
+```bash
+auq config set updateCheck false
+```
+
+Or set the environment variable:
+
+```bash
+NO_UPDATE_NOTIFIER=1 auq ask "question"
+```
+
+Update checks are automatically disabled in CI environments (`CI=true`).
+
+The `auq update` command always works regardless of these settings.
+
 ### 🎨 Themes
 
 AUQ supports **16 built-in color themes** with automatic persistence. Press `Ctrl+T` to cycle through themes.
@@ -439,6 +556,7 @@ _Settings from local config override global config, which overrides defaults._
   "language": "auto",
   "theme": "system",
   "autoSelectRecommended": true,
+  "updateCheck": true,
   "notifications": {
     "enabled": true,
     "sound": true
@@ -461,6 +579,10 @@ _Settings from local config override global config, which overrides defaults._
 | `retentionPeriod`       | number  | 604800000 | 0+ (milliseconds)               | How long to keep completed sessions (default: 7 days) |
 | `notifications.enabled` | boolean | true      | true/false                      | Enable desktop notifications for new questions        |
 | `notifications.sound`   | boolean | true      | true/false                      | Play sound with notifications                         |
+| `staleThreshold`        | number  | 7200000   | 0+ (milliseconds)               | Time before a session is considered stale (2 hours)   |
+| `notifyOnStale`         | boolean | true      | true/false                      | Show toast notification when sessions become stale    |
+| `staleAction`           | string  | "warn"    | "warn", "remove", "archive"     | Action for stale sessions                             |
+| `updateCheck`           | boolean | true      | true/false                      | Enable automatic update checks on startup             |
 
 </details>
 

package/dist/bin/auq.js

@@ -9,106 +9,44 @@ import { getSessionDirectory } from "../src/session/utils.js";
 const args = process.argv.slice(2);
 const command = args[0];
 if (command === "--help" || command === "-h") {
-    console.log(`
-AUQ - Ask User Questions
+    console.log(`auq - Ask User Questions (MCP server + TUI)
 
-An MCP server and TUI for AI assistants to ask users structured questions.
-
-Usage:
-  auq [command] [options]
+Usage: auq [command] [options]
 
 Commands:
-  (default)     Start the interactive TUI (Terminal User Interface)
-  server        Start the MCP server (for use with AI assistants)
-  ask <json>    Ask questions via CLI (pipe or argument)
+  (default)              Start interactive TUI
+  server                 Start MCP server (stdio)
+  ask <json>             Ask questions via CLI
+  answer <id> [flags]    Answer or reject a session
+  sessions <sub> [flags] List/dismiss sessions
+  config <sub> [flags]   Get/set configuration
+  update                 Check for and install updates
+
+Answer:
+  auq answer <id> --answers '<json>'    Submit answers
+  auq answer <id> --reject [--reason]   Reject session
+  Flags: --force  --json
+
+Sessions:
+  auq sessions list [--pending|--stale|--all] [--json]
+  auq sessions show <id> [--json]
+  auq sessions dismiss <id> [--force] [--json]
+
+Config:
+  auq config get [key] [--json]
+  auq config set <key> <value> [--global] [--json]
 
 Options:
-  --help, -h    Show this help message
-  --version, -v Show version information
-
-TUI Keyboard Shortcuts:
-  Navigation:
-    ↑/↓           Navigate options
-    ←/→           Navigate questions
-    Tab/Shift+Tab Navigate questions
-
-  Selection:
-    Space         Select/toggle option (multi-select)
-    Enter         Select option & advance to next question
-    R             Select recommended option(s)
-    Ctrl+R        Quick submit (auto-select all recommended)
-
-  Session Management:
-    ]             Next session
-    [             Previous session
-    1-9           Jump to session by number
-    Ctrl+S        Open session picker
-
-  Other:
-    E             Request elaboration on current question
-    Ctrl+T        Cycle color theme
-    Esc           Reject question set
-
-Ask Command:
-  Use 'auq ask' when you need to ask the user questions during
-  execution. This allows you to:
-    1. Gather user preferences or requirements
-    2. Clarify ambiguous instructions
-    3. Get decisions on implementation choices as you work
-    4. Offer choices to the user about what direction to take
-
-  Features:
-    - Ask 1-5 structured questions via an interactive terminal UI
-    - Each question includes 2-5 multiple-choice options
-    - Users can always provide custom free-text input
-    - Single-select mode (default): pick ONE option or custom text
-    - Multi-select mode (multiSelect: true): select MULTIPLE options
+  -h, --help      Show this help
+  -v, --version   Show version
 
-  Usage Notes:
-    - Provide a descriptive 'title' field (max 12 chars) per question
-    - Use multiSelect: true when choices are not mutually exclusive
-    - Option labels should be concise (1-5 words)
-    - To mark recommended, append '(recommended)' to option label
-    - Don't include an 'Other' option — it's provided automatically
+Keys (TUI):
+  ↑↓ navigate  ←→/Tab questions  Space toggle  Enter select
+  R recommend  Ctrl+R quick-submit  Esc reject
+  [/] sessions  1-9 jump  Ctrl+S picker  Ctrl+T theme
 
-  Returns a formatted summary of all questions and answers.
-
-Configuration:
-  Config file locations (searched in order, merged):
-    ./.auqrc.json                  Project-level (highest priority)
-    ~/.config/auq/.auqrc.json      User-level (global)
-
-  Available options (with defaults):
-    maxOptions             Max options per question (2-10, default: 5)
-    maxQuestions           Max questions per session (1-10, default: 5)
-    recommendedOptions     Recommended option count hint (default: 4)
-    recommendedQuestions   Recommended question count hint (default: 4)
-    sessionTimeout         Session timeout in ms (0 = infinite, default: 0)
-    retentionPeriod        Session retention in ms (default: 604800000 / 7d)
-    language               UI language ("auto" | "en" | "ko", default: "auto")
-    theme                  Color theme ("system" | "dark" | "light" | custom,
-                           default: "system")
-    autoSelectRecommended  Pre-select recommended options (default: true)
-    notifications.enabled  Enable desktop notifications (default: true)
-    notifications.sound    Enable notification sounds (default: true)
-
-  Custom themes: place .theme.json files in ~/.config/auq/themes/
-
-Environment Variables:
-  AUQ_SESSION_DIR    Override session storage directory
-  XDG_CONFIG_HOME    Override config base directory (default: ~/.config)
-
-Examples:
-  auq                    # Start TUI (wait for questions from AI)
-  auq server             # Start MCP server (for Claude Desktop, etc.)
-  auq ask '{"questions": [{"prompt": "Which language?", "title": "Lang",
-    "options": [{"label": "TypeScript (recommended)"}, {"label": "Python"}],
-    "multiSelect": false}]}'
-  echo '{"questions": [...]}' | auq ask   # Pipe JSON to ask command
-
-For more information, visit:
-  https://github.com/paulp-o/ask-user-questions-mcp
-`);
+Config: ./.auqrc.json (local) > ~/.config/auq/.auqrc.json (global)
+Env:    AUQ_SESSION_DIR  XDG_CONFIG_HOME`);
     process.exit(0);
 }
 // Display version
@@ -148,6 +86,40 @@ if (command === "server") {
     // Keep process alive
     await new Promise(() => { });
 }
+// Handle 'update' command
+if (command === "update") {
+    const { runUpdateCommand } = await import("../src/cli/commands/update.js");
+    await runUpdateCommand(args.slice(1));
+    process.exit(0);
+}
+// ── Fire-and-forget update notification ────────────────────────────
+// Start a non-blocking update check for non-TUI CLI commands.
+// The result is awaited briefly after the main command finishes.
+let updateNotification = null;
+if (command &&
+    !["server", "--help", "-h", "--version", "-v", "update"].includes(command)) {
+    updateNotification = (async () => {
+        try {
+            if (process.env.NO_UPDATE_NOTIFIER === "1" ||
+                process.env.CI === "true" ||
+                process.env.CI === "1" ||
+                process.env.NODE_ENV === "test")
+                return;
+            const { UpdateChecker } = await import("../src/update/index.js");
+            const checker = new UpdateChecker();
+            const result = await Promise.race([
+                checker.check(),
+                new Promise((r) => setTimeout(() => r(null), 5000)),
+            ]);
+            if (result) {
+                process.stderr.write(`Update available: ${result.currentVersion} \u2192 ${result.latestVersion}. Run \`auq update\` to upgrade.\n`);
+            }
+        }
+        catch {
+            // Silently ignore — update checks must never break the main command
+        }
+    })();
+}
 // Handle 'ask' command
 if (command === "ask") {
     const { SessionManager } = await import("../src/session/index.js");
@@ -207,6 +179,7 @@ if (command === "ask") {
         const callId = randomUUID();
         const { formattedResponse, sessionId } = await sessionManager.startSession(questions, callId, workingDirectory);
         console.log(formattedResponse);
+        await updateNotification;
         process.exit(0);
     }
     catch (error) {
@@ -220,6 +193,27 @@ if (command === "ask") {
         process.exit(1);
     }
 }
+// Handle 'answer' command
+if (command === "answer") {
+    const { runAnswerCommand } = await import("../src/cli/commands/answer.js");
+    await runAnswerCommand(args.slice(1));
+    await updateNotification;
+    process.exit(0);
+}
+// Handle 'sessions' command
+if (command === "sessions") {
+    const { runSessionsCommand } = await import("../src/cli/commands/sessions.js");
+    await runSessionsCommand(args.slice(1));
+    await updateNotification;
+    process.exit(0);
+}
+// Handle 'config' command
+if (command === "config") {
+    const { runConfigCommand } = await import("../src/cli/commands/config.js");
+    await runConfigCommand(args.slice(1));
+    await updateNotification;
+    process.exit(0);
+}
 // Default: Start TUI
 // Important: Lazy-load Ink/React so non-interactive commands (ask/server) don't pull them in.
 // Also force production mode before importing React/Ink to avoid perf_hooks measure accumulation warnings.

package/dist/bin/tui-app.js

@@ -11,9 +11,12 @@ import { Toast } from "../src/tui/components/Toast.js";
 import { WaitingScreen } from "../src/tui/components/WaitingScreen.js";
 import { createNotificationBatcher, showProgress, clearProgress, calculateProgress, checkLinuxDependencies, } from "../src/tui/notifications/index.js";
 import { createTUIWatcher } from "../src/tui/session-watcher.js";
+import { isSessionStale, isSessionAbandoned, formatStaleToastMessage, } from "../src/tui/utils/staleDetection.js";
 import { ThemeProvider } from "../src/tui/ThemeProvider.js";
 import { ConfigProvider } from "../src/tui/ConfigContext.js";
 import { getAdjustedIndexAfterRemoval, getDirectJumpIndex, getNextSessionIndex, getPrevSessionIndex, } from "../src/tui/utils/sessionSwitching.js";
+import { UpdateChecker, fetchChangelog, installUpdate, detectPackageManager, readCache, writeCache, } from "../src/update/index.js";
+import { UpdateOverlay } from "../src/tui/components/UpdateOverlay.js";
 import { KEYS } from "../src/tui/constants/keybindings.js";
 const App = ({ config }) => {
     const [state, setState] = useState({ mode: "WAITING" });
@@ -25,6 +28,15 @@ const App = ({ config }) => {
     const [showSessionLog, setShowSessionLog] = useState(true);
     const [showSessionPicker, setShowSessionPicker] = useState(false);
     const [isInReviewOrRejection, setIsInReviewOrRejection] = useState(false);
+    const [sessionMeta, setSessionMeta] = useState(new Map());
+    const [lastInteractions, setLastInteractions] = useState(new Map());
+    const [staleToastShown, setStaleToastShown] = useState(new Set());
+    const [updateInfo, setUpdateInfo] = useState(null);
+    const [showUpdateOverlay, setShowUpdateOverlay] = useState(false);
+    const [isInstallingUpdate, setIsInstallingUpdate] = useState(false);
+    const [installError, setInstallError] = useState(null);
+    const [changelogContent, setChangelogContent] = useState(null);
+    const [updateDismissed, setUpdateDismissed] = useState(false);
     // Get session directory for logging
     const sessionDir = getSessionDirectory();
     // Notification configuration from config
@@ -54,6 +66,7 @@ const App = ({ config }) => {
                 // Step 1: Load existing pending sessions
                 const watcher = createTUIWatcher();
                 const sessionIds = await watcher.getPendingSessions();
+                const sessionsWithStatus = await watcher.getPendingSessionsWithStatus();
                 const sessionData = await Promise.all(sessionIds.map(async (sessionId) => {
                     const sessionRequest = await watcher.getSessionRequest(sessionId);
                     if (!sessionRequest)
@@ -69,6 +82,12 @@ const App = ({ config }) => {
                     .filter((s) => s !== null)
                     .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
                 setSessionQueue(validSessions);
+                // Build initial sessionMeta from status data
+                const initialMeta = new Map();
+                for (const meta of sessionsWithStatus) {
+                    initialMeta.set(meta.sessionId, { status: meta.status, createdAt: meta.createdAt });
+                }
+                setSessionMeta(initialMeta);
                 setIsInitialized(true);
                 // Step 2: Start persistent watcher for new sessions
                 watcherInstance = createTUIWatcher({ autoLoadData: true });
@@ -113,6 +132,45 @@ const App = ({ config }) => {
             clearProgress(notificationConfig);
         };
     }, [notificationConfig]);
+    // ── Auto-update checker ─────────────────────────────────────
+    useEffect(() => {
+        // Skip update checks if disabled
+        if (config?.updateCheck === false)
+            return;
+        if (process.env.NO_UPDATE_NOTIFIER === "1")
+            return;
+        if (process.env.CI === "true" || process.env.CI === "1")
+            return;
+        if (process.env.NODE_ENV === "test")
+            return;
+        if (!process.stdout.isTTY)
+            return;
+        const checker = new UpdateChecker();
+        let intervalId = null;
+        const runCheck = async () => {
+            try {
+                const result = await checker.check();
+                if (result) {
+                    setUpdateInfo(result);
+                    // Fetch changelog for the overlay
+                    const changelog = await fetchChangelog(result.latestVersion);
+                    setChangelogContent(changelog.content);
+                }
+            }
+            catch {
+                // Silently fail — update checks should never break the TUI
+            }
+        };
+        runCheck();
+        intervalId = setInterval(() => {
+            checker.clearCache();
+            runCheck();
+        }, 3600000); // 1 hour
+        return () => {
+            if (intervalId)
+                clearInterval(intervalId);
+        };
+    }, [config?.updateCheck]);
     // Auto-transition: WAITING → PROCESSING when queue has items
     useEffect(() => {
         if (!isInitialized)
@@ -153,8 +211,7 @@ const App = ({ config }) => {
                         const parsed = JSON.parse(content);
                         if (parsed.status === "timed_out" ||
                             parsed.status === "completed" ||
-                            parsed.status === "rejected" ||
-                            parsed.status === "abandoned") {
+                            parsed.status === "rejected") {
                             return {
                                 notifyAsTimedOut: parsed.status === "timed_out",
                                 session,
@@ -215,11 +272,47 @@ const App = ({ config }) => {
         const interval = setInterval(() => {
             void checkPausedSessionStatuses();
         }, 2000);
+        // --- Stale detection (runs alongside status polling) ---
+        const staleThreshold = config?.staleThreshold ?? 7200000;
+        const notifyOnStale = config?.notifyOnStale ?? true;
+        const runStaleDetection = async () => {
+            // Refresh session metadata from disk
+            const watcher = createTUIWatcher();
+            let freshMeta = [];
+            try {
+                freshMeta = await watcher.getPendingSessionsWithStatus();
+            }
+            catch {
+                // Non-critical — stale detection simply skips this cycle
+            }
+            if (freshMeta.length > 0) {
+                setSessionMeta((prev) => {
+                    const next = new Map(prev);
+                    for (const meta of freshMeta) {
+                        next.set(meta.sessionId, { status: meta.status, createdAt: meta.createdAt });
+                    }
+                    return next;
+                });
+            }
+            // Show toast for newly stale sessions
+            for (const session of sessionQueue) {
+                const stale = isSessionStale(session.timestamp.getTime(), staleThreshold, lastInteractions.get(session.sessionId));
+                if (stale && notifyOnStale && !staleToastShown.has(session.sessionId)) {
+                    const title = session.sessionRequest.questions[0]?.title ?? session.sessionId.slice(0, 8);
+                    showToast(formatStaleToastMessage(title, session.timestamp.getTime()), "info");
+                    setStaleToastShown((prev) => new Set(prev).add(session.sessionId));
+                }
+            }
+        };
+        const staleInterval = setInterval(() => {
+            void runStaleDetection();
+        }, 2000);
         return () => {
             isCancelled = true;
             clearInterval(interval);
+            clearInterval(staleInterval);
         };
-    }, [activeSessionIndex, sessionDir, sessionQueue, state.mode]);
+    }, [activeSessionIndex, sessionDir, sessionQueue, state.mode, config?.staleThreshold, config?.notifyOnStale, lastInteractions, staleToastShown]);
     // Handle progress updates from StepperView
     const handleProgressUpdate = (answered, total) => {
         const percent = calculateProgress(answered, total);
@@ -230,10 +323,57 @@ const App = ({ config }) => {
             ...prev,
             [sessionId]: ui,
         }));
+        // Track interaction for stale grace time
+        setLastInteractions((prev) => new Map(prev).set(sessionId, Date.now()));
     }, []);
     const handleFlowStateChange = useCallback((flowState) => {
         setIsInReviewOrRejection(flowState.showReview || flowState.showRejectionConfirm);
     }, []);
+    // ── Auto-update handlers ────────────────────────────────────
+    const handleUpdateInstall = async () => {
+        try {
+            setIsInstallingUpdate(true);
+            setInstallError(null);
+            const pm = detectPackageManager();
+            const success = await installUpdate(pm);
+            if (success) {
+                setShowUpdateOverlay(false);
+                setToast({
+                    message: `Updated to v${updateInfo.latestVersion}. Please restart auq.`,
+                    type: "success",
+                });
+                // Exit after short delay so user sees the message
+                setTimeout(() => process.exit(0), 2000);
+            }
+            else {
+                setInstallError("Installation failed. Please try manually.");
+            }
+            setIsInstallingUpdate(false);
+        }
+        catch (err) {
+            setIsInstallingUpdate(false);
+            setInstallError(err instanceof Error ? err.message : "Installation failed");
+        }
+    };
+    const handleSkipVersion = async () => {
+        if (updateInfo) {
+            try {
+                const cache = await readCache();
+                if (cache) {
+                    await writeCache({ ...cache, skippedVersion: updateInfo.latestVersion });
+                }
+            }
+            catch {
+                // Non-critical — skip-version simply won't persist
+            }
+        }
+        setShowUpdateOverlay(false);
+        setUpdateInfo(null);
+    };
+    const handleRemindLater = () => {
+        setShowUpdateOverlay(false);
+        setUpdateDismissed(true);
+    };
     const switchToSession = useCallback((targetIndex) => {
         if (state.mode !== "PROCESSING" || sessionQueue.length <= 1) {
             return;
@@ -248,6 +388,13 @@ const App = ({ config }) => {
         }
         setActiveSessionIndex(clampedIndex);
         setShowSessionPicker(false);
+        // Track interaction for stale grace time
+        setLastInteractions((prev) => {
+            const targetSession = sessionQueue[clampedIndex];
+            if (!targetSession)
+                return prev;
+            return new Map(prev).set(targetSession.sessionId, Date.now());
+        });
     }, [activeSessionIndex, sessionQueue, state.mode]);
     const activeSession = state.mode === "PROCESSING" ? sessionQueue[activeSessionIndex] : undefined;
     const canUseDirectJump = !activeSession ||
@@ -288,8 +435,23 @@ const App = ({ config }) => {
         isActive: state.mode === "PROCESSING" &&
             !isInReviewOrRejection &&
             !showSessionPicker &&
+            !showUpdateOverlay &&
             sessionQueue.length >= 2,
     });
+    // Update overlay keyboard shortcut (independent of session count)
+    useInput((input, key) => {
+        if (!key.ctrl && !key.meta && input === KEYS.UPDATE) {
+            if (updateInfo && !showUpdateOverlay) {
+                setShowUpdateOverlay(true);
+            }
+        }
+    }, {
+        isActive: state.mode === "PROCESSING" &&
+            !isInReviewOrRejection &&
+            !showSessionPicker &&
+            !showUpdateOverlay &&
+            !!updateInfo,
+    });
     // Handle session completion
     const handleSessionComplete = (wasRejected = false, rejectionReason) => {
         // Clear progress bar on session completion
@@ -341,7 +503,7 @@ const App = ({ config }) => {
             mainContent = React.createElement(WaitingScreen, { queueCount: sessionQueue.length });
         }
         else {
-            mainContent = (React.createElement(StepperView, { key: session.sessionId, onComplete: handleSessionComplete, onProgress: handleProgressUpdate, initialState: sessionUIStates[session.sessionId], onStateSnapshot: handleStateSnapshot, onFlowStateChange: handleFlowStateChange, hasMultipleSessions: sessionQueue.length >= 2, sessionId: session.sessionId, sessionRequest: session.sessionRequest }));
+            mainContent = (React.createElement(StepperView, { key: session.sessionId, onComplete: handleSessionComplete, onProgress: handleProgressUpdate, initialState: sessionUIStates[session.sessionId], onStateSnapshot: handleStateSnapshot, onFlowStateChange: handleFlowStateChange, hasMultipleSessions: sessionQueue.length >= 2, sessionId: session.sessionId, sessionRequest: session.sessionRequest, isAbandoned: isSessionAbandoned(sessionMeta.get(session.sessionId)?.status ?? "") }));
         }
     }
     // Render with header, toast overlay, and main content
@@ -352,19 +514,33 @@ const App = ({ config }) => {
             React.createElement(Box, { flexDirection: "column", paddingX: 1 },
                 React.createElement(Header, { pendingCount: state.mode === "PROCESSING"
                         ? Math.max(0, sessionQueue.length - 1)
-                        : sessionQueue.length }),
+                        : sessionQueue.length, updateInfo: !showUpdateOverlay && updateInfo
+                        ? {
+                            updateType: updateInfo.updateType,
+                            latestVersion: updateInfo.latestVersion,
+                        }
+                        : null, onUpdateBadgeActivate: () => setShowUpdateOverlay(true) }),
                 mainContent,
-                state.mode === "PROCESSING" && sessionQueue.length >= 2 && (React.createElement(SessionDots, { sessions: sessionQueue, activeIndex: activeSessionIndex, sessionUIStates: sessionUIStates })),
+                state.mode === "PROCESSING" && sessionQueue.length >= 2 && (React.createElement(SessionDots, { sessions: sessionQueue.map((s) => ({
+                        ...s,
+                        isStale: isSessionStale(s.timestamp.getTime(), config?.staleThreshold ?? 7200000, lastInteractions.get(s.sessionId)),
+                        isAbandoned: isSessionAbandoned(sessionMeta.get(s.sessionId)?.status ?? ""),
+                    })), activeIndex: activeSessionIndex, sessionUIStates: sessionUIStates })),
                 toast && (React.createElement(Box, { marginTop: 1, justifyContent: "center" },
                     React.createElement(Toast, { message: toast.message, onDismiss: () => setToast(null), type: toast.type, title: toast.title, duration: 5000 }))),
                 showSessionLog && (React.createElement(Box, { marginTop: 1 },
                     React.createElement(Text, { dimColor: true },
                         "[AUQ] Session directory: ",
                         sessionDir))),
-                state.mode === "PROCESSING" && (React.createElement(SessionPicker, { isOpen: showSessionPicker, sessions: sessionQueue, activeIndex: activeSessionIndex, sessionUIStates: sessionUIStates, onSelectIndex: (idx) => {
+                state.mode === "PROCESSING" && (React.createElement(SessionPicker, { isOpen: showSessionPicker, sessions: sessionQueue.map((s) => ({
+                        ...s,
+                        isStale: isSessionStale(s.timestamp.getTime(), config?.staleThreshold ?? 7200000, lastInteractions.get(s.sessionId)),
+                        isAbandoned: isSessionAbandoned(sessionMeta.get(s.sessionId)?.status ?? ""),
+                    })), activeIndex: activeSessionIndex, sessionUIStates: sessionUIStates, onSelectIndex: (idx) => {
                         switchToSession(idx);
                         setShowSessionPicker(false);
                     }, onClose: () => setShowSessionPicker(false) })),
+                showUpdateOverlay && updateInfo && (React.createElement(UpdateOverlay, { isOpen: showUpdateOverlay, currentVersion: updateInfo.currentVersion, latestVersion: updateInfo.latestVersion, updateType: updateInfo.updateType, changelog: changelogContent, changelogUrl: updateInfo.changelogUrl, isInstalling: isInstallingUpdate, installError: installError, onInstall: handleUpdateInstall, onSkipVersion: handleSkipVersion, onRemindLater: handleRemindLater })),
                 React.createElement(ThemeIndicator, null)))));
 };
 export const runTui = (config) => {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "auq-mcp-server",
-    "version": "2.3.0",
+    "version": "2.5.0",
     "main": "dist/index.js",
     "bin": {
         "auq": "dist/bin/auq.js"