auq-mcp-server 2.1.1 → 2.2.1

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

@@ -14,7 +14,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, sessionId, sessionRequest, }) => {
+export const StepperView = ({ onComplete, onProgress, hasMultipleSessions, initialState, onStateSnapshot, onFlowStateChange, sessionId, sessionRequest, }) => {
     const { theme } = useTheme();
     const config = useConfig();
     const { exit } = useApp();
@@ -25,6 +25,7 @@ export const StepperView = ({ onComplete, onProgress, sessionId, sessionRequest,
     const [showRejectionConfirm, setShowRejectionConfirm] = useState(false);
     const [elapsedSeconds, setElapsedSeconds] = useState(0);
     const [focusContext, setFocusContext] = useState("option");
+    const [focusedOptionIndex, setFocusedOptionIndex] = useState(0);
     const [hasRecommendedOptions, setHasRecommendedOptions] = useState(false);
     // Session-level flag: true if ANY question in the session has recommended options
     const [hasAnyRecommendedInSession, setHasAnyRecommendedInSession] = useState(false);
@@ -48,6 +49,8 @@ export const StepperView = ({ onComplete, onProgress, sessionId, sessionRequest,
     const { stdout } = useStdout();
     const terminalRows = stdout?.rows ?? 24;
     const [isOverflowing, setIsOverflowing] = useState(false);
+    const isOverflowingRef = useRef(isOverflowing);
+    isOverflowingRef.current = isOverflowing;
     // Report progress when question index changes
     useEffect(() => {
         if (onProgress) {
@@ -135,6 +138,7 @@ export const StepperView = ({ onComplete, onProgress, sessionId, sessionRequest,
     };
     // Track mount status to avoid state updates after unmount
     const isMountedRef = useRef(true);
+    const skipSnapshotRef = useRef(true);
     useEffect(() => {
         isMountedRef.current = true;
         return () => {
@@ -143,28 +147,74 @@ export const StepperView = ({ onComplete, onProgress, sessionId, sessionRequest,
     }, []);
     // Reset internal stepper state when the session changes (safety in case component isn't remounted)
     useEffect(() => {
-        setCurrentQuestionIndex(0);
-        setAnswers(new Map());
-        setShowReview(false);
+        const maxQuestionIndex = Math.max(0, sessionRequest.questions.length - 1);
+        if (initialState) {
+            const hydratedQuestionIndex = Math.min(Math.max(initialState.currentQuestionIndex, 0), maxQuestionIndex);
+            const hydratedQuestion = sessionRequest.questions[hydratedQuestionIndex];
+            const maxFocusedOptionIndex = (hydratedQuestion?.options.length ?? 0) + 1;
+            setCurrentQuestionIndex(hydratedQuestionIndex);
+            setAnswers(new Map(initialState.answers));
+            setElaborateMarks(new Map(initialState.elaborateMarks));
+            setFocusContext(initialState.focusContext);
+            setFocusedOptionIndex(Math.min(Math.max(initialState.focusedOptionIndex, 0), Math.max(0, maxFocusedOptionIndex)));
+            setShowReview(initialState.showReview);
+        }
+        else {
+            setCurrentQuestionIndex(0);
+            setAnswers(new Map());
+            setElaborateMarks(new Map());
+            setFocusContext("option");
+            setFocusedOptionIndex(0);
+            setShowReview(false);
+        }
         setSubmitting(false);
         setShowRejectionConfirm(false);
         setElapsedSeconds(0);
-        setElaborateMarks(new Map());
+        skipSnapshotRef.current = true;
         // Compute session-level recommended flag: true if ANY question has recommended options
         const anyHasRecommended = sessionRequest.questions.some((question) => question.options.some((opt) => isRecommendedOption(opt.label)));
         setHasAnyRecommendedInSession(anyHasRecommended);
-    }, [sessionId, sessionRequest.questions]);
+    }, [initialState, sessionId, sessionRequest.questions]);
+    useEffect(() => {
+        if (!onStateSnapshot) {
+            return;
+        }
+        if (skipSnapshotRef.current) {
+            skipSnapshotRef.current = false;
+            return;
+        }
+        onStateSnapshot(sessionId, {
+            currentQuestionIndex,
+            answers: new Map(answers),
+            elaborateMarks: new Map(elaborateMarks),
+            focusContext,
+            focusedOptionIndex,
+            showReview,
+        });
+    }, [
+        answers,
+        currentQuestionIndex,
+        elaborateMarks,
+        focusContext,
+        focusedOptionIndex,
+        onStateSnapshot,
+        sessionId,
+        showReview,
+    ]);
+    useEffect(() => {
+        onFlowStateChange?.({ showReview, showRejectionConfirm });
+    }, [onFlowStateChange, showRejectionConfirm, showReview]);
     // Update elapsed time since session creation
     // IMPORTANT: Pause when content overflows terminal to prevent scroll-snapping
     useEffect(() => {
-        if (isOverflowing)
-            return;
         const timer = setInterval(() => {
+            if (isOverflowingRef.current)
+                return;
             const elapsed = Math.floor((Date.now() - sessionCreatedAt) / 1000);
             setElapsedSeconds(elapsed >= 0 ? elapsed : 0);
         }, 1000);
         return () => clearInterval(timer);
-    }, [sessionCreatedAt, isOverflowing]);
+    }, [sessionCreatedAt]);
     // Detect overflow: estimate content height vs terminal rows
     useEffect(() => {
         const currentQ = sessionRequest.questions[safeIndex];
@@ -361,11 +411,13 @@ export const StepperView = ({ onComplete, onProgress, sessionId, sessionRequest,
             }
             return;
         }
+        // Derive text-input state from both focusContext and focusedOptionIndex
+        // focusContext may lag by one render cycle (set via useEffect in OptionsList)
+        // focusedOptionIndex is set directly and always up-to-date
+        const isInTextInput = focusContext !== "option" ||
+            focusedOptionIndex >= currentQuestion.options.length;
         // Tab/Shift+Tab: Global question navigation
-        // Skip when in custom-input or elaborate-input mode - MultiLineTextInput handles Tab via onSubmit
-        if (key.tab &&
-            focusContext !== "custom-input" &&
-            focusContext !== "elaborate-input") {
+        if (key.tab && !isInTextInput) {
             if (key.shift) {
                 setCurrentQuestionIndex((prev) => Math.max(0, prev - 1));
             }
@@ -374,11 +426,11 @@ export const StepperView = ({ onComplete, onProgress, sessionId, sessionRequest,
             }
             return;
         }
-        const shouldNavigate = focusContext !== "custom-input" && focusContext !== "elaborate-input";
-        if (shouldNavigate && key.leftArrow && currentQuestionIndex > 0) {
+        // Left/Right arrow: question navigation (only when NOT in text input)
+        if (!isInTextInput && key.leftArrow && currentQuestionIndex > 0) {
             setCurrentQuestionIndex((prev) => prev - 1);
         }
-        if (shouldNavigate &&
+        if (!isInTextInput &&
             key.rightArrow &&
             currentQuestionIndex < sessionRequest.questions.length - 1) {
             setCurrentQuestionIndex((prev) => prev + 1);
@@ -434,5 +486,5 @@ export const StepperView = ({ onComplete, onProgress, sessionId, sessionRequest,
         return (React.createElement(ReviewScreen, { isSubmitting: submitting, answers: answers, elapsedLabel: elapsedLabel, onConfirm: handleConfirm, onGoBack: handleGoBack, questions: sessionRequest.questions, sessionId: sessionId, elaborateMarks: elaborateMarks }));
     }
     // Show question display (default)
-    return (React.createElement(QuestionDisplay, { currentQuestion: currentQuestion, currentQuestionIndex: currentQuestionIndex, customAnswer: currentAnswer?.customText, elapsedLabel: elapsedLabel, onAdvanceToNext: handleAdvanceToNext, onChangeCustomAnswer: handleChangeCustomAnswer, onSelectOption: handleSelectOption, onToggleOption: handleToggleOption, multiSelect: currentQuestion.multiSelect, questions: sessionRequest.questions, selectedOption: currentAnswer?.selectedOption, answers: answers, onFocusContextChange: setFocusContext, workingDirectory: sessionRequest.workingDirectory, onRecommendedDetected: setHasRecommendedOptions, hasRecommendedOptions: hasRecommendedOptions, hasAnyRecommendedInSession: hasAnyRecommendedInSession, elaborateMarks: elaborateMarks, onElaborateSelect: handleElaborateSelect, elaborateText: elaborateMarks.get(currentQuestionIndex) || "", onElaborateTextChange: handleElaborateTextChange }));
+    return (React.createElement(QuestionDisplay, { currentQuestion: currentQuestion, currentQuestionIndex: currentQuestionIndex, customAnswer: currentAnswer?.customText, elapsedLabel: elapsedLabel, onAdvanceToNext: handleAdvanceToNext, onChangeCustomAnswer: handleChangeCustomAnswer, onSelectOption: handleSelectOption, onToggleOption: handleToggleOption, multiSelect: currentQuestion.multiSelect, questions: sessionRequest.questions, selectedOption: currentAnswer?.selectedOption, answers: answers, focusContext: focusContext, onFocusContextChange: setFocusContext, focusedOptionIndex: focusedOptionIndex, onFocusedOptionIndexChange: setFocusedOptionIndex, workingDirectory: sessionRequest.workingDirectory, onRecommendedDetected: setHasRecommendedOptions, hasRecommendedOptions: hasRecommendedOptions, hasAnyRecommendedInSession: hasAnyRecommendedInSession, elaborateMarks: elaborateMarks, onElaborateSelect: handleElaborateSelect, elaborateText: elaborateMarks.get(currentQuestionIndex) || "", onElaborateTextChange: handleElaborateTextChange, showSessionSwitching: hasMultipleSessions && !showReview && !showRejectionConfirm }));
 };

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

@@ -0,0 +1,92 @@
+import React from "react";
+import { cleanup, render } from "ink-testing-library";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ThemeContext } from "../../ThemeContext.js";
+import { darkTheme } from "../../themes/dark.js";
+import { SessionDots } from "../SessionDots.js";
+const mockThemeValue = {
+    theme: darkTheme,
+    themeName: "AUQ dark",
+    cycleTheme: () => { },
+};
+function renderWithTheme(ui) {
+    return render(React.createElement(ThemeContext.Provider, { value: mockThemeValue }, ui));
+}
+function getOutput(frame) {
+    return (frame ?? "").replace(/\x1b\[[0-9;]*m/g, "").replace(/\r/g, "");
+}
+function createSession(id) {
+    return {
+        sessionId: `test-id-${id}`,
+        sessionRequest: {
+            sessionId: `test-id-${id}`,
+            status: "pending",
+            timestamp: new Date("2026-01-01T00:00:00.000Z").toISOString(),
+            workingDirectory: `/test/${id}`,
+            questions: [
+                {
+                    title: `Q${id}`,
+                    prompt: "test?",
+                    options: [{ label: "A" }],
+                    multiSelect: false,
+                },
+            ],
+        },
+        timestamp: new Date("2026-01-01T00:00:00.000Z"),
+    };
+}
+afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+});
+describe("SessionDots", () => {
+    it("renders nothing when sessions length is less than 2", () => {
+        const instance = renderWithTheme(React.createElement(SessionDots, { sessions: [createSession(1)], activeIndex: 0, sessionUIStates: {} }));
+        expect(getOutput(instance.lastFrame())).toBe("");
+    });
+    it("renders numbered dots for each session", () => {
+        const sessions = [createSession(1), createSession(2), createSession(3)];
+        const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 1, sessionUIStates: {} }));
+        const output = getOutput(instance.lastFrame());
+        expect(output).toContain("1");
+        expect(output).toContain("2");
+        expect(output).toContain("3");
+        expect(output).toContain("●");
+        expect(output).toContain("○");
+    });
+    it("renders progress-state sessions with one active and remaining inactive dots", () => {
+        const sessions = [
+            createSession(1),
+            createSession(2),
+            createSession(3),
+            createSession(4),
+        ];
+        const answeredState = {
+            currentQuestionIndex: 0,
+            answers: new Map([[0, { selectedOption: "A" }]]),
+            elaborateMarks: new Map(),
+            focusContext: "option",
+            focusedOptionIndex: 0,
+            showReview: false,
+        };
+        const inProgressState = {
+            currentQuestionIndex: 0,
+            answers: new Map(),
+            elaborateMarks: new Map(),
+            focusContext: "option",
+            focusedOptionIndex: 0,
+            showReview: false,
+        };
+        const instance = renderWithTheme(React.createElement(SessionDots, { sessions: sessions, activeIndex: 0, sessionUIStates: {
+                [sessions[1].sessionId]: answeredState,
+                [sessions[2].sessionId]: inProgressState,
+            } }));
+        const output = getOutput(instance.lastFrame());
+        expect((output.match(/●/g) ?? []).length).toBe(1);
+        expect((output.match(/○/g) ?? []).length).toBe(3);
+        expect(output).toContain("1");
+        expect(output).toContain("2");
+        expect(output).toContain("3");
+        expect(output).toContain("4");
+    });
+});

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

@@ -0,0 +1,125 @@
+import React from "react";
+import { cleanup, render } from "ink-testing-library";
+import { afterEach, describe, expect, it, vi } from "vitest";
+const inputState = vi.hoisted(() => ({
+    handler: null,
+}));
+vi.mock("ink", async () => {
+    const actual = await vi.importActual("ink");
+    return {
+        ...actual,
+        useInput: (handler, options) => {
+            if (options?.isActive) {
+                inputState.handler = handler;
+            }
+        },
+    };
+});
+import { ThemeContext } from "../../ThemeContext.js";
+import { darkTheme } from "../../themes/dark.js";
+import { SessionPicker, } from "../SessionPicker.js";
+const mockThemeValue = {
+    theme: darkTheme,
+    themeName: "AUQ dark",
+    cycleTheme: () => { },
+};
+function renderWithTheme(ui) {
+    return render(React.createElement(ThemeContext.Provider, { value: mockThemeValue }, ui));
+}
+function getOutput(frame) {
+    return (frame ?? "").replace(/\x1b\[[0-9;]*m/g, "").replace(/\r/g, "");
+}
+function createSession(id) {
+    return {
+        sessionId: `picker-id-${id}`,
+        sessionRequest: {
+            sessionId: `picker-id-${id}`,
+            status: "pending",
+            timestamp: new Date("2026-01-01T00:00:00.000Z").toISOString(),
+            workingDirectory: `/work/dir-${id}`,
+            questions: [
+                {
+                    title: `Title ${id}`,
+                    prompt: "choose",
+                    options: [{ label: "A" }],
+                    multiSelect: false,
+                },
+            ],
+        },
+        timestamp: new Date("2026-01-01T00:00:00.000Z"),
+    };
+}
+afterEach(() => {
+    cleanup();
+    inputState.handler = null;
+    vi.restoreAllMocks();
+});
+describe("SessionPicker", () => {
+    it("renders nothing when isOpen is false", () => {
+        const instance = renderWithTheme(React.createElement(SessionPicker, { isOpen: false, sessions: [createSession(1), createSession(2)], activeIndex: 0, sessionUIStates: {}, onSelectIndex: () => { }, onClose: () => { } }));
+        expect(getOutput(instance.lastFrame())).toBe("");
+    });
+    it("renders session rows with number, title, directory, progress, and active marker", () => {
+        const sessions = [createSession(1), createSession(2)];
+        const answeredState = {
+            currentQuestionIndex: 0,
+            answers: new Map([[0, { selectedOption: "A" }]]),
+            elaborateMarks: new Map(),
+            focusContext: "option",
+            focusedOptionIndex: 0,
+            showReview: false,
+        };
+        const instance = renderWithTheme(React.createElement(SessionPicker, { isOpen: true, sessions: sessions, activeIndex: 0, sessionUIStates: { [sessions[0].sessionId]: answeredState }, onSelectIndex: () => { }, onClose: () => { } }));
+        const output = getOutput(instance.lastFrame());
+        expect(output).toContain("Switch Session");
+        expect(output).toContain("1. Title 1");
+        expect(output).toContain("2. Title 2");
+        expect(output).toContain("/work/dir-1");
+        expect(output).toContain("[1/1]");
+        expect(output).toContain("[0/1]");
+        expect(output).toContain("► 1.");
+    });
+    it("handles down arrow without immediate selection", async () => {
+        const sessions = [createSession(1), createSession(2), createSession(3)];
+        const onSelectIndex = vi.fn();
+        const onClose = vi.fn();
+        renderWithTheme(React.createElement(SessionPicker, { isOpen: true, sessions: sessions, activeIndex: 0, sessionUIStates: {}, onSelectIndex: onSelectIndex, onClose: onClose }));
+        expect(inputState.handler).not.toBeNull();
+        inputState.handler("", { downArrow: true });
+        await Promise.resolve();
+        expect(onSelectIndex).not.toHaveBeenCalled();
+        expect(onClose).not.toHaveBeenCalled();
+    });
+    it("selects the currently highlighted session on Enter", async () => {
+        const sessions = [createSession(1), createSession(2), createSession(3)];
+        const onSelectIndex = vi.fn();
+        const onClose = vi.fn();
+        renderWithTheme(React.createElement(SessionPicker, { isOpen: true, sessions: sessions, activeIndex: 0, sessionUIStates: {}, onSelectIndex: onSelectIndex, onClose: onClose }));
+        expect(inputState.handler).not.toBeNull();
+        inputState.handler("", { return: true });
+        await Promise.resolve();
+        expect(onSelectIndex).toHaveBeenCalledWith(0);
+        expect(onClose).toHaveBeenCalled();
+    });
+    it("supports direct number key selection", async () => {
+        const sessions = [createSession(1), createSession(2), createSession(3)];
+        const onSelectIndex = vi.fn();
+        const onClose = vi.fn();
+        renderWithTheme(React.createElement(SessionPicker, { isOpen: true, sessions: sessions, activeIndex: 0, sessionUIStates: {}, onSelectIndex: onSelectIndex, onClose: onClose }));
+        expect(inputState.handler).not.toBeNull();
+        inputState.handler("2", {});
+        await Promise.resolve();
+        expect(onSelectIndex).toHaveBeenCalledWith(1);
+        expect(onClose).toHaveBeenCalled();
+    });
+    it("calls onClose on Escape", async () => {
+        const onSelectIndex = vi.fn();
+        const onClose = vi.fn();
+        renderWithTheme(React.createElement(SessionPicker, { isOpen: true, sessions: [createSession(1), createSession(2)], activeIndex: 0, sessionUIStates: {}, onSelectIndex: onSelectIndex, onClose: onClose }));
+        expect(inputState.handler).not.toBeNull();
+        inputState.handler("", { escape: true });
+        await Promise.resolve();
+        expect(onClose).toHaveBeenCalledTimes(1);
+        expect(onSelectIndex).not.toHaveBeenCalled();
+    });
+});

package/dist/src/tui/components/__tests__/StepperView.state.test.js

@@ -0,0 +1,101 @@
+import React from "react";
+import { cleanup, render } from "ink-testing-library";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ConfigProvider } from "../../ConfigContext.js";
+import { ThemeContext } from "../../ThemeContext.js";
+import { darkTheme } from "../../themes/dark.js";
+import { StepperView } from "../StepperView.js";
+const mockThemeValue = {
+    theme: darkTheme,
+    themeName: "AUQ dark",
+    cycleTheme: () => { },
+};
+const sessionRequest = {
+    sessionId: "session-1",
+    status: "pending",
+    timestamp: new Date().toISOString(),
+    callId: "call-1",
+    questions: [
+        {
+            title: "Language",
+            prompt: "Pick a language",
+            options: [{ label: "TypeScript" }, { label: "Python" }],
+        },
+        {
+            title: "Framework",
+            prompt: "Pick a framework",
+            options: [{ label: "React" }, { label: "Vue" }],
+        },
+        {
+            title: "Runtime",
+            prompt: "Pick a runtime",
+            options: [{ label: "Bun" }, { label: "Node.js" }],
+        },
+    ],
+};
+function renderStepper(props = {}) {
+    return render(React.createElement(ThemeContext.Provider, { value: mockThemeValue },
+        React.createElement(ConfigProvider, null,
+            React.createElement(StepperView, { sessionId: sessionRequest.sessionId, sessionRequest: sessionRequest, ...props }))));
+}
+function getOutput(frame) {
+    return (frame ?? "").replace(/\x1b\[[0-9;]*m/g, "").replace(/\r/g, "");
+}
+afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+});
+describe("StepperView SessionUIState boundary", () => {
+    it("hydrates from initialState and starts on the hydrated question", async () => {
+        const initialState = {
+            currentQuestionIndex: 1,
+            answers: new Map([[0, { selectedOption: "TypeScript" }]]),
+            elaborateMarks: new Map([[0, "Please elaborate"]]),
+            focusContext: "option",
+            focusedOptionIndex: 1,
+            showReview: false,
+        };
+        const instance = renderStepper({ initialState });
+        await vi.waitFor(() => {
+            const hydratedOutput = getOutput(instance.lastFrame());
+            expect(hydratedOutput).toContain("Pick a framework");
+        });
+        const output = getOutput(instance.lastFrame());
+        expect(output).not.toContain("Pick a language");
+        expect(output).toContain("1/3");
+    });
+    it("uses default state when no initialState is provided", () => {
+        const instance = renderStepper();
+        const output = getOutput(instance.lastFrame());
+        expect(output).toContain("Pick a language");
+        expect(output).not.toContain("Pick a framework");
+        expect(output).toContain("0/3");
+    });
+    it("emits snapshot after state change and skips initial mount emission", async () => {
+        const onStateSnapshot = vi.fn();
+        const instance = renderStepper({ onStateSnapshot });
+        expect(onStateSnapshot).not.toHaveBeenCalled();
+        instance.stdin.write("\t");
+        await vi.waitFor(() => {
+            expect(onStateSnapshot).toHaveBeenCalled();
+        });
+        const [sessionId, state] = onStateSnapshot.mock.lastCall;
+        expect(sessionId).toBe("session-1");
+        expect(state.currentQuestionIndex).toBe(1);
+        expect(state.focusContext).toBe("option");
+        expect(state.showReview).toBe(false);
+        expect(state.answers).toBeInstanceOf(Map);
+        expect(state.elaborateMarks).toBeInstanceOf(Map);
+    });
+    it("emits initial flow state via onFlowStateChange", async () => {
+        const onFlowStateChange = vi.fn();
+        renderStepper({ onFlowStateChange });
+        await vi.waitFor(() => {
+            expect(onFlowStateChange).toHaveBeenCalled();
+        });
+        expect(onFlowStateChange).toHaveBeenCalledWith({
+            showReview: false,
+            showRejectionConfirm: false,
+        });
+    });
+});

package/dist/src/tui/themes/catppuccin-latte.js

@@ -98,5 +98,23 @@ export const catppuccinLatteTheme = {
             codeBlockText: "#4c4f69",
             codeBlockBorder: "#ccd0da",
         },
+        sessionDots: {
+            active: "#1e66f5",
+            answered: "#40a02b",
+            inProgress: "#df8e1d",
+            untouched: "#acb0c0",
+            number: "#4c4f69",
+            activeNumber: "#1e66f5",
+        },
+        sessionPicker: {
+            border: "#1e66f5",
+            title: "#1e66f5",
+            rowText: "#4c4f69",
+            rowDim: "#acb0c0",
+            highlightBg: "#ccd0da",
+            highlightFg: "#40a02b",
+            activeMark: "#1e66f5",
+            progress: "#04a5e5",
+        },
     },
 };

package/dist/src/tui/themes/catppuccin-mocha.js

@@ -98,5 +98,23 @@ export const catppuccinMochaTheme = {
             codeBlockText: "#cdd6f4",
             codeBlockBorder: "#313244",
         },
+        sessionDots: {
+            active: "#89b4fa",
+            answered: "#a6e3a1",
+            inProgress: "#f9e2af",
+            untouched: "#8688a0",
+            number: "#cdd6f4",
+            activeNumber: "#89b4fa",
+        },
+        sessionPicker: {
+            border: "#89b4fa",
+            title: "#89b4fa",
+            rowText: "#cdd6f4",
+            rowDim: "#8688a0",
+            highlightBg: "#313244",
+            highlightFg: "#a6e3a1",
+            activeMark: "#89b4fa",
+            progress: "#89dceb",
+        },
     },
 };

package/dist/src/tui/themes/dark.js

@@ -99,5 +99,23 @@ export const darkTheme = {
             codeBlockText: "#E7EEF5",
             codeBlockBorder: "#2A3238",
         },
+        sessionDots: {
+            active: "#46D9FF",
+            answered: "#5AF78E",
+            inProgress: "#FFD36A",
+            untouched: "#A0AAB4",
+            number: "#E7EEF5",
+            activeNumber: "#46D9FF",
+        },
+        sessionPicker: {
+            border: "#46D9FF",
+            title: "#46D9FF",
+            rowText: "#E7EEF5",
+            rowDim: "#A0AAB4",
+            highlightBg: "#0F2417",
+            highlightFg: "#5AF78E",
+            activeMark: "#46D9FF",
+            progress: "#46D9FF",
+        },
     },
 };

package/dist/src/tui/themes/dracula.js

@@ -98,5 +98,23 @@ export const draculaTheme = {
             codeBlockText: "#f8f8f2",
             codeBlockBorder: "#44475a",
         },
+        sessionDots: {
+            active: "#bd93f9",
+            answered: "#50fa7b",
+            inProgress: "#f1fa8c",
+            untouched: "#7C8BBE",
+            number: "#f8f8f2",
+            activeNumber: "#bd93f9",
+        },
+        sessionPicker: {
+            border: "#bd93f9",
+            title: "#bd93f9",
+            rowText: "#f8f8f2",
+            rowDim: "#7C8BBE",
+            highlightBg: "#44475a",
+            highlightFg: "#50fa7b",
+            activeMark: "#bd93f9",
+            progress: "#8be9fd",
+        },
     },
 };

package/dist/src/tui/themes/github-dark.js

@@ -97,5 +97,23 @@ export const githubDarkTheme = {
             codeBlockText: "#c9d1d9",
             codeBlockBorder: "#30363d",
         },
+        sessionDots: {
+            active: "#58a6ff",
+            answered: "#3fb950",
+            inProgress: "#d29922",
+            untouched: "#a0a8b4",
+            number: "#c9d1d9",
+            activeNumber: "#58a6ff",
+        },
+        sessionPicker: {
+            border: "#58a6ff",
+            title: "#58a6ff",
+            rowText: "#c9d1d9",
+            rowDim: "#a0a8b4",
+            highlightBg: "#0d1117",
+            highlightFg: "#3fb950",
+            activeMark: "#58a6ff",
+            progress: "#58a6ff",
+        },
     },
 };

package/dist/src/tui/themes/github-light.js

@@ -97,5 +97,23 @@ export const githubLightTheme = {
             codeBlockText: "#24292F",
             codeBlockBorder: "#D0D7DE",
         },
+        sessionDots: {
+            active: "#0969DA",
+            answered: "#1A7F37",
+            inProgress: "#9A6700",
+            untouched: "#6E7781",
+            number: "#24292F",
+            activeNumber: "#0969DA",
+        },
+        sessionPicker: {
+            border: "#0969DA",
+            title: "#0969DA",
+            rowText: "#24292F",
+            rowDim: "#6E7781",
+            highlightBg: "#DAFBE1",
+            highlightFg: "#1A7F37",
+            activeMark: "#0969DA",
+            progress: "#0969DA",
+        },
     },
 };

package/dist/src/tui/themes/gruvbox-dark.js

@@ -98,5 +98,23 @@ export const gruvboxDarkTheme = {
             codeBlockText: "#ebdbb2",
             codeBlockBorder: "#3c3836",
         },
+        sessionDots: {
+            active: "#458588",
+            answered: "#98971a",
+            inProgress: "#d79921",
+            untouched: "#a89984",
+            number: "#ebdbb2",
+            activeNumber: "#458588",
+        },
+        sessionPicker: {
+            border: "#458588",
+            title: "#458588",
+            rowText: "#ebdbb2",
+            rowDim: "#a89984",
+            highlightBg: "#3c3836",
+            highlightFg: "#98971a",
+            activeMark: "#458588",
+            progress: "#458588",
+        },
     },
 };

package/dist/src/tui/themes/gruvbox-light.js

@@ -98,5 +98,23 @@ export const gruvboxLightTheme = {
             codeBlockText: "#3c3836",
             codeBlockBorder: "#d5c4a1",
         },
+        sessionDots: {
+            active: "#076678",
+            answered: "#79740e",
+            inProgress: "#b57614",
+            untouched: "#a89984",
+            number: "#3c3836",
+            activeNumber: "#076678",
+        },
+        sessionPicker: {
+            border: "#076678",
+            title: "#076678",
+            rowText: "#3c3836",
+            rowDim: "#a89984",
+            highlightBg: "#ebdbb2",
+            highlightFg: "#79740e",
+            activeMark: "#076678",
+            progress: "#076678",
+        },
     },
 };