auq-mcp-server 2.3.0 → 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/__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/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

@@ -135,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";
@@ -15,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();
@@ -24,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);
@@ -180,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;
@@ -207,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(() => {
@@ -343,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)
@@ -481,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 },

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

@@ -15,7 +15,7 @@ function renderWithTheme(ui) {
 function getOutput(frame) {
     return (frame ?? "").replace(/\x1b\[[0-9;]*m/g, "").replace(/\r/g, "");
 }
-function createSession(id) {
+function createSession(id, overrides) {
     return {
         sessionId: `test-id-${id}`,
         sessionRequest: {
@@ -33,6 +33,7 @@ function createSession(id) {
             ],
         },
         timestamp: new Date("2026-01-01T00:00:00.000Z"),
+        ...overrides,
     };
 }
 afterEach(() => {
@@ -89,4 +90,162 @@ describe("SessionDots", () => {
         expect(output).toContain("3");
         expect(output).toContain("4");
     });
+    describe("abandoned sessions", () => {
+        it("renders abandoned session with ✕ symbol when inactive", () => {
+            const sessions = [
+                createSession(1),
+                createSession(2, { isAbandoned: true }),
+                createSession(3),
+            ];
+            const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 0, sessionUIStates: {} }));
+            const output = getOutput(instance.lastFrame());
+            // Abandoned inactive session uses ✕ instead of ○
+            expect(output).toContain("✕");
+            // Active session still uses ●
+            expect(output).toContain("●");
+            // Non-abandoned inactive session still uses ○
+            expect(output).toContain("○");
+        });
+        it("renders abandoned session with different ANSI styling than normal", () => {
+            // Render with abandoned session
+            const abandonedSessions = [
+                createSession(1),
+                createSession(2, { isAbandoned: true }),
+            ];
+            const abandoned = renderWithTheme(React.createElement(SessionDots, { sessions: abandonedSessions, activeIndex: 0, sessionUIStates: {} }));
+            const abandonedRaw = abandoned.lastFrame() ?? "";
+            // Render with normal session
+            const normalSessions = [createSession(1), createSession(2)];
+            const normal = renderWithTheme(React.createElement(SessionDots, { sessions: normalSessions, activeIndex: 0, sessionUIStates: {} }));
+            const normalRaw = normal.lastFrame() ?? "";
+            // Abandoned session should render differently from normal
+            // (different ANSI codes due to error color)
+            expect(abandonedRaw).not.toBe(normalRaw);
+        });
+        it('shows "(AI disconnected)" text when active session is abandoned', () => {
+            const sessions = [
+                createSession(1),
+                createSession(2, { isAbandoned: true }),
+            ];
+            const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 1, sessionUIStates: {} }));
+            const output = getOutput(instance.lastFrame());
+            expect(output).toContain("(AI disconnected)");
+        });
+        it('does NOT show "(AI disconnected)" when abandoned session is inactive', () => {
+            const sessions = [
+                createSession(1),
+                createSession(2, { isAbandoned: true }),
+            ];
+            const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 0, sessionUIStates: {} }));
+            const output = getOutput(instance.lastFrame());
+            expect(output).not.toContain("(AI disconnected)");
+        });
+        it("uses ● for active abandoned session (not ✕)", () => {
+            const sessions = [
+                createSession(1),
+                createSession(2, { isAbandoned: true }),
+            ];
+            const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 1, sessionUIStates: {} }));
+            const output = getOutput(instance.lastFrame());
+            // Active abandoned session should still use ● (filled dot), not ✕
+            expect(output).toContain("●");
+        });
+    });
+    describe("stale sessions", () => {
+        it("renders stale session with ○ symbol (unchanged from normal)", () => {
+            const sessions = [
+                createSession(1),
+                createSession(2, { isStale: true }),
+                createSession(3),
+            ];
+            const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 0, sessionUIStates: {} }));
+            const output = getOutput(instance.lastFrame());
+            // Stale sessions keep ○ but with yellow color
+            // Count: 1 active ●, 2 inactive ○ (one stale, one normal)
+            expect((output.match(/○/g) ?? []).length).toBe(2);
+        });
+        it("applies stale color when session is stale (color differs from untouched)", () => {
+            // When a stale session is active, it gets the stale/warning color
+            // and shows a "(stale)" label — verifying the flag is correctly consumed.
+            // Since ink-testing-library may strip ANSI in some envs, we verify
+            // that stale active sessions show the label as a proxy for color.
+            const sessions = [
+                createSession(1),
+                createSession(2, { isStale: true }),
+            ];
+            const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 1, sessionUIStates: {} }));
+            const output = getOutput(instance.lastFrame());
+            // Active stale session should have the filled dot and stale label
+            expect(output).toContain("●");
+            expect(output).toContain("(stale)");
+            // Stale sessions don't use ✕ (that's only for abandoned)
+            expect(output).not.toContain("✕");
+        });
+        it('shows "(stale)" text when active session is stale', () => {
+            const sessions = [
+                createSession(1),
+                createSession(2, { isStale: true }),
+            ];
+            const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 1, sessionUIStates: {} }));
+            const output = getOutput(instance.lastFrame());
+            expect(output).toContain("(stale)");
+        });
+        it('does NOT show "(stale)" when stale session is inactive', () => {
+            const sessions = [
+                createSession(1),
+                createSession(2, { isStale: true }),
+            ];
+            const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 0, sessionUIStates: {} }));
+            const output = getOutput(instance.lastFrame());
+            expect(output).not.toContain("(stale)");
+        });
+    });
+    describe("mixed states", () => {
+        it("renders multiple sessions with mixed states correctly", () => {
+            const sessions = [
+                createSession(1), // normal (active)
+                createSession(2, { isAbandoned: true }), // abandoned
+                createSession(3, { isStale: true }), // stale
+                createSession(4), // normal
+            ];
+            const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 0, sessionUIStates: {} }));
+            const output = getOutput(instance.lastFrame());
+            // Active session shows ●
+            expect(output).toContain("●");
+            // Abandoned inactive shows ✕
+            expect(output).toContain("✕");
+            // Normal and stale inactive show ○
+            expect((output.match(/○/g) ?? []).length).toBe(2);
+            // All 4 session numbers rendered
+            expect(output).toContain("1");
+            expect(output).toContain("2");
+            expect(output).toContain("3");
+            expect(output).toContain("4");
+        });
+        it("abandoned takes priority over stale", () => {
+            const sessions = [
+                createSession(1),
+                createSession(2, { isAbandoned: true, isStale: true }),
+            ];
+            const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 1, sessionUIStates: {} }));
+            const output = getOutput(instance.lastFrame());
+            // When both abandoned and stale, show abandoned status
+            expect(output).toContain("(AI disconnected)");
+            expect(output).not.toContain("(stale)");
+        });
+        it("normal sessions remain unchanged (regression)", () => {
+            const sessions = [createSession(1), createSession(2), createSession(3)];
+            const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 1, sessionUIStates: {} }));
+            const output = getOutput(instance.lastFrame());
+            // No stale/abandoned indicators for normal sessions
+            expect(output).not.toContain("✕");
+            expect(output).not.toContain("(AI disconnected)");
+            expect(output).not.toContain("(stale)");
+            // Normal rendering still works
+            expect(output).toContain("●");
+            expect(output).toContain("○");
+            expect((output.match(/●/g) ?? []).length).toBe(1);
+            expect((output.match(/○/g) ?? []).length).toBe(2);
+        });
+    });
 });