auq-mcp-server 2.3.0 → 2.5.0

package/dist/src/i18n/locales/ko.js

@@ -39,6 +39,7 @@ export const ko = {
         copied: "클립보드에 복사됨",
         saved: "저장됨",
         error: "오류",
+        staleSession: "세션 \"{title}\"이 고아 상태일 수 있습니다 ({hours}시간 전 생성)",
     },
     stepper: {
         submitting: "답변 제출 중...",
@@ -72,4 +73,10 @@ export const ko = {
     ui: {
         themeLabel: "테마:",
     },
+    abandoned: {
+        title: "AI 연결 끊김",
+        message: "AI가 disconnect되었습니다. 그래도 답변하시겠습니까?",
+        continue: "답변하기",
+        cancel: "취소",
+    },
 };

package/dist/src/server.js

@@ -3,6 +3,8 @@ import { randomUUID } from "crypto";
 import { AskUserQuestionsParametersSchema, createAskUserQuestionsCore, } from "./core/ask-user-questions.js";
 import { TOOL_DESCRIPTION } from "./shared/schemas.js";
 const askUserQuestionsCore = createAskUserQuestionsCore();
+// Track active requests with their AbortControllers for disconnect handling
+const activeRequests = new Map();
 const server = new FastMCP({
     name: "AskUserQuestions",
     instructions: "MCP server for asking users structured questions during AI execution. " +
@@ -41,22 +43,50 @@ server.addTool({
             }
             // Generate a per-tool-call ID and persist it with the session
             const callId = randomUUID();
+            // Create AbortController for this request to handle disconnects
+            const controller = new AbortController();
+            activeRequests.set(callId, { controller });
             // Capture working directory if available from MCP context
             // Note: MCP protocol does not currently expose client working directory
             // This field is reserved for future protocol enhancements
             const workingDirectory = ctx
                 .workingDirectory;
-            const { formattedResponse, sessionId } = await askUserQuestionsCore.ask(args.questions, callId, workingDirectory);
-            log.info("Session completed successfully", { sessionId, callId });
-            // Return formatted response to AI model
-            return {
-                content: [
-                    {
-                        text: formattedResponse,
-                        type: "text",
-                    },
-                ],
-            };
+            try {
+                const { formattedResponse, sessionId } = await askUserQuestionsCore.ask(args.questions, callId, workingDirectory, controller.signal);
+                // Update entry with sessionId for disconnect handler
+                const entry = activeRequests.get(callId);
+                if (entry) {
+                    entry.sessionId = sessionId;
+                }
+                log.info("Session completed successfully", { sessionId, callId });
+                // Return formatted response to AI model
+                return {
+                    content: [
+                        {
+                            text: formattedResponse,
+                            type: "text",
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                // Handle abort (AI client disconnected)
+                if (error instanceof Error && error.message === "ABORTED") {
+                    log.warn("Session aborted: AI client disconnected", { callId });
+                    return {
+                        content: [
+                            {
+                                text: "Session aborted: AI client disconnected",
+                                type: "text",
+                            },
+                        ],
+                    };
+                }
+                throw error; // Re-throw other errors to outer catch
+            }
+            finally {
+                activeRequests.delete(callId);
+            }
         }
         catch (error) {
             log.error("Session failed", { error: String(error) });
@@ -72,6 +102,29 @@ server.addTool({
     },
     parameters: AskUserQuestionsParametersSchema,
 });
+// Handle AI client disconnections gracefully
+// Note: FastMCP disconnect event support depends on the version.
+// If the event is not available, stale detection handles orphaned sessions as fallback.
+try {
+    server.on("disconnect", async () => {
+        for (const [callId, entry] of activeRequests.entries()) {
+            try {
+                entry.controller.abort();
+                if (entry.sessionId) {
+                    await askUserQuestionsCore.markAbandoned(entry.sessionId).catch(() => { });
+                }
+            }
+            catch {
+                // Silently ignore errors during disconnect cleanup
+            }
+            activeRequests.delete(callId);
+        }
+    });
+}
+catch {
+    // FastMCP version may not support disconnect events
+    // Graceful fallback: stale detection handles orphaned sessions
+}
 // Start the server with stdio transport
 server.start({
     transportType: "stdio",

package/dist/src/session/SessionManager.js

@@ -141,6 +141,29 @@ export class SessionManager {
     async getSessionAnswers(sessionId) {
         return this.readSessionFile(sessionId, SESSION_FILES.ANSWERS);
     }
+    /**
+     * Get all pending sessions, optionally including abandoned ones
+     */
+    async getPendingSessions(options) {
+        const sessionIds = await this.getAllSessionIds();
+        const pendingSessions = [];
+        for (const sessionId of sessionIds) {
+            try {
+                const status = await this.getSessionStatus(sessionId);
+                if (!status)
+                    continue;
+                const isPending = status.status === "pending" || status.status === "in-progress";
+                const isAbandoned = status.status === "abandoned";
+                if (isPending || (options?.includeAbandoned && isAbandoned)) {
+                    pendingSessions.push(sessionId);
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return pendingSessions;
+    }
     /**
      * Get session count
      */
@@ -160,6 +183,13 @@ export class SessionManager {
     async getSessionStatus(sessionId) {
         return this.readSessionFile(sessionId, SESSION_FILES.STATUS);
     }
+    /**
+     * Check if a session has been abandoned
+     */
+    async isAbandoned(sessionId) {
+        const status = await this.getSessionStatus(sessionId);
+        return status?.status === "abandoned";
+    }
     /**
      * Initialize the session manager - create base directories
      */
@@ -239,9 +269,21 @@ export class SessionManager {
      * @returns Object containing sessionId and formatted response text
      * @throws Error if timeout occurs, validation fails, or file operations fail
      */
-    async startSession(questions, callId, workingDirectory) {
+    async startSession(questions, callId, workingDirectory, signal) {
         // Step 1: Create the session
         const sessionId = await this.createSession(questions, workingDirectory);
+        // Step 1.5: Register abort handler if signal provided
+        let abortHandler;
+        if (signal) {
+            if (signal.aborted) {
+                await this.updateSessionStatus(sessionId, "abandoned");
+                throw new Error("ABORTED");
+            }
+            abortHandler = () => {
+                this.updateSessionStatus(sessionId, "abandoned").catch(() => { });
+            };
+            signal.addEventListener("abort", abortHandler, { once: true });
+        }
         // Optionally attach callId and workingDirectory metadata to request and status
         if (callId || workingDirectory) {
             try {
@@ -274,11 +316,23 @@ export class SessionManager {
                 : 0; // Also infinite if session is infinite
             // Step 3: Wait for answers with timeout
             try {
-                await this.waitForAnswers(sessionId, watcherTimeout, callId);
+                await this.waitForAnswers(sessionId, watcherTimeout, callId, signal);
             }
             catch (error) {
+                // Check if session was aborted (AI disconnected)
+                if (error instanceof Error && error.message === "ABORTED") {
+                    // Clean up abort handler
+                    if (abortHandler && signal) {
+                        signal.removeEventListener("abort", abortHandler);
+                    }
+                    throw error;
+                }
                 // Check if session was rejected by user
                 if (error instanceof Error && error.message === "SESSION_REJECTED") {
+                    // Clean up abort handler
+                    if (abortHandler && signal) {
+                        signal.removeEventListener("abort", abortHandler);
+                    }
                     // Get session status to retrieve rejection reason
                     const status = await this.getSessionStatus(sessionId);
                     const reason = status?.rejectionReason;
@@ -290,7 +344,6 @@ export class SessionManager {
                     else {
                         formattedResponse += "No reason provided.\n\n";
                     }
-                    // formattedResponse += "The user chose not to answer these questions at this time.";
                     return {
                         formattedResponse,
                         sessionId,
@@ -331,6 +384,10 @@ export class SessionManager {
             const formattedResponse = ResponseFormatter.formatUserResponse(answers, request.questions);
             // Step 7: Update final status
             await this.updateSessionStatus(sessionId, "completed");
+            // Clean up abort handler after successful completion
+            if (abortHandler && signal) {
+                signal.removeEventListener("abort", abortHandler);
+            }
             // Step 8: Return results
             return {
                 formattedResponse,
@@ -338,6 +395,10 @@ export class SessionManager {
             };
         }
         catch (error) {
+            // Clean up abort handler on error
+            if (abortHandler && signal) {
+                signal.removeEventListener("abort", abortHandler);
+            }
             // Ensure any errors are properly propagated with session context
             if (error instanceof Error) {
                 throw error;
@@ -416,7 +477,7 @@ export class SessionManager {
      * Wait for user answers to be submitted for a specific session
      * Returns the session ID when answers are detected, or rejects on timeout
      */
-    async waitForAnswers(sessionId, timeoutMs, expectedCallId) {
+    async waitForAnswers(sessionId, timeoutMs, expectedCallId, signal) {
         const sessionDir = this.getSessionDir(sessionId);
         const answersPath = join(sessionDir, SESSION_FILES.ANSWERS);
         const startTime = Date.now();
@@ -448,6 +509,10 @@ export class SessionManager {
             if (status && status.status === "rejected") {
                 throw new Error("SESSION_REJECTED");
             }
+            // Check for abort signal
+            if (signal?.aborted) {
+                throw new Error("ABORTED");
+            }
             // Check for timeout
             if (timeoutMs && timeoutMs > 0 && Date.now() - startTime > timeoutMs) {
                 throw new Error("Timeout waiting for user response");

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/Footer.js

@@ -8,7 +8,7 @@ const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧",
  * Footer component - displays context-aware keybindings
  * Shows different shortcuts based on current focus context and question type
  */
-export const Footer = ({ focusContext, multiSelect, isReviewScreen = false, showSessionSwitching = false, customInputValue = "", hasRecommendedOptions = false, hasAnyRecommendedInSession = false, isSubmitting = false, }) => {
+export const Footer = ({ focusContext, multiSelect, isReviewScreen = false, showSessionSwitching = false, customInputValue = "", hasRecommendedOptions = false, hasAnyRecommendedInSession = false, isSubmitting = false, hasUpdate = false, }) => {
     const { theme } = useTheme();
     const [spinnerFrame, setSpinnerFrame] = useState(0);
     // Animate spinner when submitting
@@ -75,6 +75,9 @@ export const Footer = ({ focusContext, multiSelect, isReviewScreen = false, show
                 bindings.push({ key: KEY_LABELS.SESSION_LIST, action: t("footer.list") });
             }
             bindings.push({ key: KEY_LABELS.THEME, action: t("footer.theme") });
+            if (hasUpdate) {
+                bindings.push({ key: KEY_LABELS.UPDATE, action: "Update" });
+            }
             bindings.push({ key: KEY_LABELS.REJECT, action: t("footer.reject") });
             return bindings;
         }

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

@@ -3,11 +3,12 @@ import React, { useEffect, useState } from "react";
 import { t } from "../../i18n/index.js";
 import { useTheme } from "../ThemeContext.js";
 import packageJson from "../../../package.json" with { type: "json" };
+import { UpdateBadge } from "./UpdateBadge.js";
 /**
  * Header component - displays app logo and status
  * Shows at the top of the TUI with gradient branding and live-updating pending queue count
  */
-export const Header = ({ pendingCount }) => {
+export const Header = ({ pendingCount, updateInfo, onUpdateBadgeActivate }) => {
     const { theme } = useTheme();
     const [flash, setFlash] = useState(false);
     const [prevCount, setPrevCount] = useState(pendingCount);
@@ -35,6 +36,7 @@ export const Header = ({ pendingCount }) => {
             React.createElement(Text, { dimColor: true },
                 "v",
                 version),
+            updateInfo && (React.createElement(UpdateBadge, { updateType: updateInfo.updateType, latestVersion: updateInfo.latestVersion })),
             React.createElement(Text, { dimColor: true }, " "),
             React.createElement(Text, { backgroundColor: theme.components.header.pillBg, bold: flash, color: flash
                     ? theme.components.header.queueFlash

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"))),