auq-mcp-server 2.2.2 → 2.4.0

package/dist/src/session/__tests__/SessionManager.test.js

@@ -590,4 +590,69 @@ describe("SessionManager", () => {
             expect(result2.formattedResponse).toContain("Option 2");
         });
     });
+    describe("abandoned status support", () => {
+        const sampleQuestions = [
+            { options: [{ label: "Opt" }], prompt: "Test", title: "Test" },
+        ];
+        it("should transition a session to abandoned status via updateSessionStatus", async () => {
+            const sessionId = await sessionManager.createSession(sampleQuestions);
+            await sessionManager.updateSessionStatus(sessionId, "abandoned");
+            const status = await sessionManager.getSessionStatus(sessionId);
+            expect(status?.status).toBe("abandoned");
+        });
+        it("should return true from isAbandoned() for abandoned session", async () => {
+            const sessionId = await sessionManager.createSession(sampleQuestions);
+            await sessionManager.updateSessionStatus(sessionId, "abandoned");
+            const result = await sessionManager.isAbandoned(sessionId);
+            expect(result).toBe(true);
+        });
+        it("should return false from isAbandoned() for pending session", async () => {
+            const sessionId = await sessionManager.createSession(sampleQuestions);
+            const result = await sessionManager.isAbandoned(sessionId);
+            expect(result).toBe(false);
+        });
+        it("should return false from isAbandoned() for non-existent session", async () => {
+            const result = await sessionManager.isAbandoned("non-existent-session-id");
+            expect(result).toBe(false);
+        });
+        it("should exclude abandoned sessions from getPendingSessions() by default", async () => {
+            const pendingId = await sessionManager.createSession(sampleQuestions);
+            const abandonedId = await sessionManager.createSession(sampleQuestions);
+            await sessionManager.updateSessionStatus(abandonedId, "abandoned");
+            const pending = await sessionManager.getPendingSessions();
+            expect(pending).toContain(pendingId);
+            expect(pending).not.toContain(abandonedId);
+        });
+        it("should include abandoned sessions in getPendingSessions() when includeAbandoned is true", async () => {
+            const pendingId = await sessionManager.createSession(sampleQuestions);
+            const abandonedId = await sessionManager.createSession(sampleQuestions);
+            await sessionManager.updateSessionStatus(abandonedId, "abandoned");
+            const pending = await sessionManager.getPendingSessions({ includeAbandoned: true });
+            expect(pending).toContain(pendingId);
+            expect(pending).toContain(abandonedId);
+        });
+        it("should exclude completed sessions from getPendingSessions() even with includeAbandoned", async () => {
+            const pendingId = await sessionManager.createSession(sampleQuestions);
+            const completedId = await sessionManager.createSession(sampleQuestions);
+            const abandonedId = await sessionManager.createSession(sampleQuestions);
+            await sessionManager.updateSessionStatus(completedId, "completed");
+            await sessionManager.updateSessionStatus(abandonedId, "abandoned");
+            const pending = await sessionManager.getPendingSessions({ includeAbandoned: true });
+            expect(pending).toContain(pendingId);
+            expect(pending).toContain(abandonedId);
+            expect(pending).not.toContain(completedId);
+        });
+        it("should include in-progress sessions in getPendingSessions()", async () => {
+            const inProgressId = await sessionManager.createSession(sampleQuestions);
+            await sessionManager.updateSessionStatus(inProgressId, "in-progress");
+            const pending = await sessionManager.getPendingSessions();
+            expect(pending).toContain(inProgressId);
+        });
+        it("should return empty array from getPendingSessions() when no pending sessions exist", async () => {
+            const completedId = await sessionManager.createSession(sampleQuestions);
+            await sessionManager.updateSessionStatus(completedId, "completed");
+            const pending = await sessionManager.getPendingSessions();
+            expect(pending).toEqual([]);
+        });
+    });
 });

package/dist/src/tui/ThemeProvider.js

@@ -4,6 +4,7 @@ import { ThemeContext } from "./ThemeContext.js";
 import { getTheme, listThemes, darkTheme, hasTheme } from "./themes/index.js";
 import { detectSystemTheme } from "./utils/detectTheme.js";
 import { getSavedTheme, saveTheme } from "./utils/config.js";
+import { KEYS } from "./constants/keybindings.js";
 function resolveTheme(mode) {
     if (mode === "system") {
         const detected = detectSystemTheme();
@@ -42,7 +43,7 @@ export const ThemeProvider = ({ initialTheme, children, }) => {
     }, []);
     // Ctrl+T to cycle theme
     useInput((input, key) => {
-        if (key.ctrl && input === "t") {
+        if (key.ctrl && input === KEYS.THEME_CYCLE) {
             cycleTheme();
         }
     });

package/dist/src/tui/__tests__/session-watcher.test.js

@@ -270,6 +270,115 @@ describe("TUI Session Watcher", () => {
                 watcher.stop();
             });
         });
+        describe("getPendingSessionsWithStatus", () => {
+            beforeEach(async () => {
+                // Create test sessions with various statuses
+                const sessions = [
+                    { id: "session-1", status: "pending", completed: false },
+                    { id: "session-2", status: "completed", completed: true },
+                    { id: "session-3", status: "pending", completed: false },
+                ];
+                for (const session of sessions) {
+                    const dir = join(sessionDir, session.id);
+                    await fs.mkdir(dir, { recursive: true });
+                    const requestFile = join(dir, SESSION_FILES.REQUEST);
+                    await fs.writeFile(requestFile, JSON.stringify({
+                        ...mockSessionRequest,
+                        sessionId: session.id,
+                    }));
+                    const statusFile = join(dir, SESSION_FILES.STATUS);
+                    await fs.writeFile(statusFile, JSON.stringify({
+                        createdAt: new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                        sessionId: session.id,
+                        status: session.status,
+                        totalQuestions: 1,
+                    }));
+                    if (session.completed) {
+                        const answersFile = join(dir, SESSION_FILES.ANSWERS);
+                        await fs.writeFile(answersFile, JSON.stringify({
+                            answers: [
+                                {
+                                    questionIndex: 0,
+                                    selectedOption: "JavaScript",
+                                    timestamp: new Date().toISOString(),
+                                },
+                            ],
+                            sessionId: session.id,
+                            timestamp: new Date().toISOString(),
+                        }));
+                    }
+                }
+            });
+            it("should return pending and in-progress sessions with metadata", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                const sessions = await watcher.getPendingSessionsWithStatus();
+                expect(sessions).toHaveLength(2);
+                expect(sessions[0].sessionId).toBe("session-1");
+                expect(sessions[0].status).toBe("pending");
+                expect(sessions[0].createdAt).toBeDefined();
+                expect(sessions[1].sessionId).toBe("session-3");
+                expect(sessions[1].status).toBe("pending");
+                watcher.stop();
+            });
+            it("should include abandoned sessions", async () => {
+                // Create an abandoned session
+                const abandonedDir = join(sessionDir, "session-4-abandoned");
+                await fs.mkdir(abandonedDir, { recursive: true });
+                const requestFile = join(abandonedDir, SESSION_FILES.REQUEST);
+                const statusFile = join(abandonedDir, SESSION_FILES.STATUS);
+                await Promise.all([
+                    fs.writeFile(requestFile, JSON.stringify({
+                        ...mockSessionRequest,
+                        sessionId: "session-4-abandoned",
+                    })),
+                    fs.writeFile(statusFile, JSON.stringify({
+                        createdAt: new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                        sessionId: "session-4-abandoned",
+                        status: "abandoned",
+                        totalQuestions: 1,
+                    })),
+                ]);
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                const sessions = await watcher.getPendingSessionsWithStatus();
+                // Should have session-1 (pending), session-3 (pending), session-4-abandoned (abandoned)
+                expect(sessions).toHaveLength(3);
+                const abandoned = sessions.find((s) => s.sessionId === "session-4-abandoned");
+                expect(abandoned).toBeDefined();
+                expect(abandoned.status).toBe("abandoned");
+                watcher.stop();
+            });
+            it("should exclude completed, rejected, and timed_out sessions", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                const sessions = await watcher.getPendingSessionsWithStatus();
+                // session-2 is completed and has answers — should be excluded
+                const completed = sessions.find((s) => s.sessionId === "session-2");
+                expect(completed).toBeUndefined();
+                watcher.stop();
+            });
+            it("should return sorted results by sessionId", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                const sessions = await watcher.getPendingSessionsWithStatus();
+                const ids = sessions.map((s) => s.sessionId);
+                const sorted = [...ids].sort();
+                expect(ids).toEqual(sorted);
+                watcher.stop();
+            });
+            it("should handle directory access errors gracefully", async () => {
+                const watcher = new EnhancedTUISessionWatcher({
+                    sessionDir: "/invalid/directory/path",
+                });
+                const consoleSpy = vi
+                    .spyOn(console, "warn")
+                    .mockImplementation(() => { });
+                const sessions = await watcher.getPendingSessionsWithStatus();
+                expect(sessions).toEqual([]);
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to scan for pending sessions with status"), expect.any(Error));
+                consoleSpy.mockRestore();
+                watcher.stop();
+            });
+        });
     });
     describe("Utility Functions", () => {
         describe("createTUIWatcher", () => {

package/dist/src/tui/components/ConfirmationDialog.js

@@ -3,6 +3,7 @@ import React, { useState } from "react";
 import { useTheme } from "../ThemeContext.js";
 import { SingleLineTextInput } from "./SingleLineTextInput.js";
 import { t } from "../../i18n/index.js";
+import { KEYS } from "../constants/keybindings.js";
 /**
  * ConfirmationDialog shows a 3-option prompt for session rejection
  * Options: Reject & inform AI, Cancel, or Quit CLI
@@ -37,20 +38,20 @@ export const ConfirmationDialog = ({ message, onReject, onCancel, onQuit, }) =>
         }
         // Arrow key navigation
         if (key.upArrow) {
-            setFocusedIndex((prev) => (prev > 0 ? prev - 1 : options.length - 1));
+            setFocusedIndex((prev) => Math.max(0, prev - 1));
         }
         if (key.downArrow) {
-            setFocusedIndex((prev) => (prev < options.length - 1 ? prev + 1 : 0));
+            setFocusedIndex((prev) => Math.min(options.length - 1, prev + 1));
         }
         // Enter key - select focused option
         if (key.return) {
             options[focusedIndex].action();
         }
         // Letter shortcuts
-        if (input === "y" || input === "Y") {
+        if (KEYS.CONFIRM_YES.test(input)) {
             setShowReasonInput(true);
         }
-        if (input === "n" || input === "N") {
+        if (KEYS.CONFIRM_NO.test(input)) {
             onCancel();
         }
         // Esc key - same as quit

package/dist/src/tui/components/Footer.js

@@ -2,6 +2,7 @@ import { Box, Text } from "ink";
 import React, { useEffect, useState } from "react";
 import { t } from "../../i18n/index.js";
 import { useTheme } from "../ThemeContext.js";
+import { KEY_LABELS } from "../constants/keybindings.js";
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 /**
  * Footer component - displays context-aware keybindings
@@ -23,58 +24,58 @@ export const Footer = ({ focusContext, multiSelect, isReviewScreen = false, show
         // Review screen mode
         if (isReviewScreen) {
             return [
-                { key: "Enter", action: t("footer.submit") },
-                { key: "n", action: t("footer.back") },
+                { key: KEY_LABELS.SUBMIT, action: t("footer.submit") },
+                { key: KEY_LABELS.BACK, action: t("footer.back") },
             ];
         }
         // Custom input focused
         if (focusContext === "custom-input") {
             return [
-                { key: "↑↓", action: t("footer.options") },
-                { key: "←→", action: t("footer.cursor") },
-                { key: "Tab/S+Tab", action: t("footer.questions") },
-                { key: "Enter", action: t("footer.newline") },
-                { key: "Esc", action: t("footer.reject") },
+                { key: KEY_LABELS.NAVIGATE_OPTIONS, action: t("footer.options") },
+                { key: KEY_LABELS.CURSOR, action: t("footer.cursor") },
+                { key: KEY_LABELS.NAVIGATE_QUESTIONS_TAB, action: t("footer.questions") },
+                { key: KEY_LABELS.NEWLINE, action: t("footer.newline") },
+                { key: KEY_LABELS.REJECT, action: t("footer.reject") },
             ];
         }
         // Elaborate input focused (Enter skips, not newline)
         if (focusContext === "elaborate-input") {
             return [
-                { key: "↑↓", action: t("footer.options") },
-                { key: "←→", action: t("footer.cursor") },
+                { key: KEY_LABELS.NAVIGATE_OPTIONS, action: t("footer.options") },
+                { key: KEY_LABELS.CURSOR, action: t("footer.cursor") },
                 { key: "Enter/Tab", action: t("footer.next") },
-                { key: "Esc", action: t("footer.reject") },
+                { key: KEY_LABELS.REJECT, action: t("footer.reject") },
             ];
         }
         // Option focused
         if (focusContext === "option") {
             const bindings = [
-                { key: "↑↓", action: t("footer.options") },
-                { key: "←→", action: t("footer.questions") },
-                { key: "Tab/S+Tab", action: t("footer.questions") },
+                { key: KEY_LABELS.NAVIGATE_OPTIONS, action: t("footer.options") },
+                { key: KEY_LABELS.NAVIGATE_QUESTIONS, action: t("footer.questions") },
+                { key: KEY_LABELS.NAVIGATE_QUESTIONS_TAB, action: t("footer.questions") },
             ];
             if (multiSelect) {
-                bindings.push({ key: "Space", action: t("footer.toggle") });
-                bindings.push({ key: "Enter", action: t("footer.next") });
+                bindings.push({ key: KEY_LABELS.SELECT, action: t("footer.toggle") });
+                bindings.push({ key: KEY_LABELS.NEXT, action: t("footer.next") });
             }
             else {
-                bindings.push({ key: "Space", action: t("footer.select") });
-                bindings.push({ key: "Enter", action: t("footer.selectNext") });
+                bindings.push({ key: KEY_LABELS.SELECT, action: t("footer.select") });
+                bindings.push({ key: KEY_LABELS.SELECT_NEXT, action: t("footer.selectNext") });
             }
             if (hasRecommendedOptions) {
-                bindings.push({ key: "R", action: t("footer.recommended") });
+                bindings.push({ key: KEY_LABELS.RECOMMEND, action: t("footer.recommended") });
             }
             // Ctrl+R shows when ANY question in session has recommended (not just current)
             if (hasAnyRecommendedInSession) {
-                bindings.push({ key: "Ctrl+R", action: t("footer.quickSubmit") });
+                bindings.push({ key: KEY_LABELS.QUICK_SUBMIT, action: t("footer.quickSubmit") });
             }
             if (showSessionSwitching) {
-                bindings.push({ key: "Ctrl+]/[", action: t("footer.sessions") });
+                bindings.push({ key: KEY_LABELS.SESSION_SWITCH, action: t("footer.sessions") });
                 bindings.push({ key: "1-9", action: t("footer.jump") });
-                bindings.push({ key: "Ctrl+S", action: t("footer.list") });
+                bindings.push({ key: KEY_LABELS.SESSION_LIST, action: t("footer.list") });
             }
-            bindings.push({ key: "Ctrl+T", action: t("footer.theme") });
-            bindings.push({ key: "Esc", action: t("footer.reject") });
+            bindings.push({ key: KEY_LABELS.THEME, action: t("footer.theme") });
+            bindings.push({ key: KEY_LABELS.REJECT, action: t("footer.reject") });
             return bindings;
         }
         return [];

package/dist/src/tui/components/ReviewScreen.js

@@ -4,6 +4,7 @@ import { t } from "../../i18n/index.js";
 import { useTheme } from "../ThemeContext.js";
 import { Footer } from "./Footer.js";
 import { MarkdownPrompt } from "./MarkdownPrompt.js";
+import { KEYS } from "../constants/keybindings.js";
 /**
  * ReviewScreen displays a summary of all answers for confirmation
  * User can press Enter to confirm and submit, or 'n' to go back and edit
@@ -32,7 +33,7 @@ export const ReviewScreen = ({ answers, elapsedLabel, onConfirm, onGoBack, quest
             });
             onConfirm(userAnswers);
         }
-        if (input === "n") {
+        if (KEYS.GO_BACK.test(input)) {
             onGoBack();
         }
     });

package/dist/src/tui/components/SessionDots.js

@@ -23,9 +23,11 @@ function hasAnswers(answers) {
  * SessionDots — a compact row of numbered dots rendered below the footer.
  *
  * Visual language:
- *   ● 1  ○ 2  ○ 3
+ *   ● 1  ○ 2  ✕ 3  ○ 4
  *
  * • Active session:   filled ● + bold number in theme primary
+ * • Abandoned:        red ✕ + "(AI disconnected)" when active
+ * • Stale:            yellow ○ + "(stale)" when active
  * • Has answers:      green (theme.success)
  * • Touched/no answers: yellow (theme.warning)
  * • Untouched:        dim   (theme.textDim)
@@ -38,9 +40,22 @@ export const SessionDots = ({ sessions, activeIndex, sessionUIStates, }) => {
     return (React.createElement(Box, { justifyContent: "center", paddingX: 1 }, sessions.map((session, idx) => {
         const isActive = idx === activeIndex;
         const uiState = sessionUIStates[session.sessionId];
+        const isStale = session.isStale ?? false;
+        const isAbandoned = session.isAbandoned ?? false;
         // Determine the progress color for this session's dot
+        // Abandoned/stale take priority over normal state colors
         let dotColor;
-        if (isActive) {
+        if (isAbandoned) {
+            dotColor =
+                theme.components.sessionDots
+                    .abandoned ?? theme.colors.error;
+        }
+        else if (isStale) {
+            dotColor =
+                theme.components.sessionDots
+                    .stale ?? theme.colors.warning;
+        }
+        else if (isActive) {
             dotColor = theme.components.sessionDots.active;
         }
         else if (uiState && hasAnswers(uiState.answers)) {
@@ -52,14 +67,28 @@ export const SessionDots = ({ sessions, activeIndex, sessionUIStates, }) => {
         else {
             dotColor = theme.components.sessionDots.untouched;
         }
-        const dot = isActive ? "●" : "○";
+        // Abandoned inactive sessions use ✕ to signal a problem
+        const dot = isAbandoned && !isActive
+            ? "✕"
+            : isActive
+                ? "●"
+                : "○";
         const numberColor = isActive
             ? theme.components.sessionDots.activeNumber
             : theme.components.sessionDots.number;
+        // Status label shown next to active abandoned/stale sessions
+        const statusLabel = isActive && isAbandoned
+            ? "(AI disconnected)"
+            : isActive && isStale
+                ? "(stale)"
+                : null;
         return (React.createElement(Box, { key: session.sessionId, paddingRight: idx < sessions.length - 1 ? 1 : 0 },
             React.createElement(Text, { color: dotColor, bold: isActive }, dot),
             React.createElement(Text, { color: numberColor, bold: isActive },
                 " ",
-                idx + 1)));
+                idx + 1),
+            statusLabel && (React.createElement(Text, { color: dotColor, dimColor: true },
+                " ",
+                statusLabel))));
     })));
 };

package/dist/src/tui/components/SessionPicker.js

@@ -2,6 +2,7 @@ import { Box, Text, useInput, useStdout } from "ink";
 import React, { useEffect, useState } from "react";
 import { useTheme } from "../ThemeContext.js";
 import { formatRelativeTime } from "../utils/relativeTime.js";
+import { KEYS } from "../constants/keybindings.js";
 /* ------------------------------------------------------------------ */
 /*  Helpers                                                           */
 /* ------------------------------------------------------------------ */
@@ -69,7 +70,7 @@ export const SessionPicker = ({ isOpen, sessions, activeIndex, sessionUIStates,
         else {
             // Direct number jump (1-9)
             const num = parseInt(input, 10);
-            if (num >= 1 && num <= sessions.length) {
+            if (num >= KEYS.SESSION_JUMP_MIN && num <= Math.min(KEYS.SESSION_JUMP_MAX, sessions.length)) {
                 onSelectIndex(num - 1);
                 onClose();
             }
@@ -134,23 +135,31 @@ export const SessionPicker = ({ isOpen, sessions, activeIndex, sessionUIStates,
                     : answered > 0
                         ? theme.components.sessionPicker.progress
                         : theme.components.sessionPicker.rowDim;
-                return (React.createElement(Box, { key: session.sessionId },
-                    React.createElement(Text, { backgroundColor: rowBg, bold: isHighlighted, color: textColor },
-                        isActive ? "►" : " ",
-                        " ",
-                        realIdx + 1,
-                        ". ",
-                        title),
-                    React.createElement(Text, { backgroundColor: rowBg, color: theme.components.sessionPicker.rowDim },
-                        " — ",
-                        dir),
-                    React.createElement(Text, { backgroundColor: rowBg, color: progressColor },
-                        "  [",
-                        answered,
-                        "/",
-                        total,
-                        "]"),
-                    React.createElement(Text, { backgroundColor: rowBg, color: theme.components.sessionPicker.rowDim, dimColor: true }, age)));
+                return (React.createElement(Box, { key: session.sessionId, flexDirection: "column" },
+                    React.createElement(Box, null,
+                        (session.isStale || session.isAbandoned) && (React.createElement(Text, { backgroundColor: rowBg, color: theme.components.sessionPicker.staleIcon },
+                            "\u26A0",
+                            " ")),
+                        React.createElement(Text, { backgroundColor: rowBg, bold: isHighlighted, color: session.isStale || session.isAbandoned ? theme.components.sessionPicker.staleText : textColor },
+                            isActive ? "►" : " ",
+                            " ",
+                            realIdx + 1,
+                            ". ",
+                            title),
+                        React.createElement(Text, { backgroundColor: rowBg, color: theme.components.sessionPicker.rowDim },
+                            " — ",
+                            dir),
+                        React.createElement(Text, { backgroundColor: rowBg, color: progressColor },
+                            "  [",
+                            answered,
+                            "/",
+                            total,
+                            "]"),
+                        React.createElement(Text, { backgroundColor: rowBg, color: session.isStale || session.isAbandoned ? theme.components.sessionPicker.staleAge : theme.components.sessionPicker.rowDim, dimColor: !(session.isStale || session.isAbandoned) }, age)),
+                    session.isStale && !session.isAbandoned && (React.createElement(Box, { marginLeft: session.isStale ? 4 : 2 },
+                        React.createElement(Text, { color: theme.components.sessionPicker.staleSubtitle, dimColor: true }, "may be orphaned"))),
+                    session.isAbandoned && (React.createElement(Box, { marginLeft: 4 },
+                        React.createElement(Text, { color: theme.components.sessionPicker.staleSubtitle, bold: true }, "session abandoned")))));
             }),
             needsScroll && scrollOffset + maxVisibleRows < sessions.length && (React.createElement(Box, { justifyContent: "center" },
                 React.createElement(Text, { color: theme.components.sessionPicker.rowDim }, "\u25BC more"))),

package/dist/src/tui/components/Spinner.js

@@ -0,0 +1,19 @@
+import { Text } from "ink";
+import React, { useEffect, useState } from "react";
+import { useTheme } from "../ThemeContext.js";
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/**
+ * Spinner displays an animated loading indicator
+ * Uses braille pattern characters for smooth animation
+ */
+export const Spinner = ({ color }) => {
+    const { theme } = useTheme();
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame((prev) => (prev + 1) % SPINNER_FRAMES.length);
+        }, 80);
+        return () => clearInterval(timer);
+    }, []);
+    return (React.createElement(Text, { color: color ?? theme.colors.primary }, SPINNER_FRAMES[frame]));
+};

package/dist/src/tui/components/StepperView.js

@@ -1,4 +1,4 @@
-import { Box, useApp, useInput, useStdout } from "ink";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
 import React, { useEffect, useMemo, useRef, useState } from "react";
 import { t } from "../../i18n/index.js";
 import { ResponseFormatter } from "../../session/ResponseFormatter.js";
@@ -7,6 +7,7 @@ import { getSessionDirectory } from "../../session/utils.js";
 import { useTheme } from "../ThemeContext.js";
 import { useConfig } from "../ConfigContext.js";
 import { isRecommendedOption } from "../utils/recommended.js";
+import { KEYS } from "../constants/keybindings.js";
 import { ConfirmationDialog } from "./ConfirmationDialog.js";
 import { QuestionDisplay } from "./QuestionDisplay.js";
 import { ReviewScreen } from "./ReviewScreen.js";
@@ -14,7 +15,7 @@ import { ReviewScreen } from "./ReviewScreen.js";
  * StepperView orchestrates the question-answering flow
  * Manages state for current question, answers, and navigation
  */
-export const StepperView = ({ onComplete, onProgress, hasMultipleSessions, initialState, onStateSnapshot, onFlowStateChange, sessionId, sessionRequest, }) => {
+export const StepperView = ({ onComplete, onProgress, hasMultipleSessions, initialState, onStateSnapshot, onFlowStateChange, sessionId, sessionRequest, isAbandoned, onAbandonedCancel, }) => {
     const { theme } = useTheme();
     const config = useConfig();
     const { exit } = useApp();
@@ -23,6 +24,9 @@ export const StepperView = ({ onComplete, onProgress, hasMultipleSessions, initi
     const [showReview, setShowReview] = useState(false);
     const [submitting, setSubmitting] = useState(false);
     const [showRejectionConfirm, setShowRejectionConfirm] = useState(false);
+    const [showAbandonedConfirm, setShowAbandonedConfirm] = useState(false);
+    const [abandonedConfirmed, setAbandonedConfirmed] = useState(false);
+    const [abandonedFocusedIndex, setAbandonedFocusedIndex] = useState(0);
     const [elapsedSeconds, setElapsedSeconds] = useState(0);
     const [focusContext, setFocusContext] = useState("option");
     const [focusedOptionIndex, setFocusedOptionIndex] = useState(0);
@@ -179,6 +183,16 @@ export const StepperView = ({ onComplete, onProgress, hasMultipleSessions, initi
         const anyHasRecommended = sessionRequest.questions.some((question) => question.options.some((opt) => isRecommendedOption(opt.label)));
         setHasAnyRecommendedInSession(anyHasRecommended);
     }, [initialState, sessionId, sessionRequest.questions]);
+    // Show abandoned confirmation when entering an abandoned session
+    useEffect(() => {
+        if (isAbandoned && !abandonedConfirmed) {
+            setShowAbandonedConfirm(true);
+            setAbandonedFocusedIndex(0);
+        }
+        else {
+            setShowAbandonedConfirm(false);
+        }
+    }, [sessionId, isAbandoned, abandonedConfirmed]);
     useEffect(() => {
         if (!onStateSnapshot) {
             return;
@@ -206,8 +220,8 @@ export const StepperView = ({ onComplete, onProgress, hasMultipleSessions, initi
         showReview,
     ]);
     useEffect(() => {
-        onFlowStateChange?.({ showReview, showRejectionConfirm });
-    }, [onFlowStateChange, showRejectionConfirm, showReview]);
+        onFlowStateChange?.({ showReview, showRejectionConfirm, showAbandonedConfirm });
+    }, [onFlowStateChange, showRejectionConfirm, showReview, showAbandonedConfirm]);
     // Update elapsed time since session creation
     // IMPORTANT: Pause when content overflows terminal to prevent scroll-snapping
     useEffect(() => {
@@ -342,10 +356,35 @@ export const StepperView = ({ onComplete, onProgress, hasMultipleSessions, initi
             return newMarks;
         });
     };
+    // Keyboard handling for abandoned confirmation dialog
+    useInput((input, key) => {
+        if (!showAbandonedConfirm)
+            return;
+        if (key.upArrow) {
+            setAbandonedFocusedIndex((prev) => Math.max(0, prev - 1));
+        }
+        if (key.downArrow) {
+            setAbandonedFocusedIndex((prev) => Math.min(1, prev + 1));
+        }
+        if (key.return) {
+            if (abandonedFocusedIndex === 0) {
+                // "Answer anyway"
+                setAbandonedConfirmed(true);
+                setShowAbandonedConfirm(false);
+            }
+            else {
+                // "Cancel"
+                onAbandonedCancel?.();
+            }
+        }
+        if (key.escape) {
+            onAbandonedCancel?.();
+        }
+    });
     // Global keyboard shortcuts and navigation
     useInput((input, key) => {
         // Don't handle navigation when showing review, submitting, or confirming rejection
-        if (showReview || submitting || showRejectionConfirm)
+        if (showReview || submitting || showRejectionConfirm || showAbandonedConfirm)
             return;
         // Derive text-input state from both focusContext and focusedOptionIndex
         // focusContext may lag by one render cycle (set via useEffect in OptionsList)
@@ -358,7 +397,7 @@ export const StepperView = ({ onComplete, onProgress, hasMultipleSessions, initi
             return;
         }
         // Ctrl+R: Quick submit with recommended options (select all recommended and go to review)
-        if (input.toLowerCase() === "r" &&
+        if (input.toLowerCase() === KEYS.QUICK_SUBMIT &&
             key.ctrl &&
             hasAnyRecommendedInSession &&
             !isInTextInput) {
@@ -395,7 +434,7 @@ export const StepperView = ({ onComplete, onProgress, hasMultipleSessions, initi
             return;
         }
         // R key: Select recommended options for current question
-        if (input.toLowerCase() === "r" &&
+        if (input.toLowerCase() === KEYS.RECOMMEND &&
             !key.ctrl &&
             !isInTextInput &&
             hasRecommendedOptions) {
@@ -480,6 +519,31 @@ export const StepperView = ({ onComplete, onProgress, hasMultipleSessions, initi
             }
         }
     };
+    // Show abandoned session confirmation
+    if (showAbandonedConfirm) {
+        const abandonedOptions = [
+            { label: t("abandoned.continue"), action: () => { setAbandonedConfirmed(true); setShowAbandonedConfirm(false); } },
+            { label: t("abandoned.cancel"), action: () => { onAbandonedCancel?.(); } },
+        ];
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Box, { borderColor: theme.borders.warning, borderStyle: "round", flexDirection: "column", padding: 1 },
+                React.createElement(Box, { marginBottom: 1 },
+                    React.createElement(Text, { bold: true, color: theme.colors.warning }, t("abandoned.title"))),
+                React.createElement(Box, { marginBottom: 1 },
+                    React.createElement(Text, null, t("abandoned.message"))),
+                abandonedOptions.map((option, index) => {
+                    const isFocused = index === abandonedFocusedIndex;
+                    const rowBg = isFocused
+                        ? theme.components.options.focusedBg
+                        : undefined;
+                    return (React.createElement(Box, { key: index, marginTop: index > 0 ? 0.5 : 0 },
+                        React.createElement(Text, { backgroundColor: rowBg, bold: isFocused, color: isFocused ? theme.colors.focused : theme.colors.text },
+                            isFocused ? "> " : "  ",
+                            option.label)));
+                }),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(Text, { dimColor: true }, "↑↓ Navigate | Enter Select")))));
+    }
     // Show rejection confirmation
     if (showRejectionConfirm) {
         return (React.createElement(Box, { flexDirection: "column", padding: 1 },