auq-mcp-server 2.6.3 → 2.7.0

package/dist/src/core/ask-user-questions.js

@@ -1,4 +1,5 @@
 import { SessionManager } from "../session/index.js";
+import { ResponseFormatter } from "../session/ResponseFormatter.js";
 import { getSessionDirectory } from "../session/utils.js";
 import { AskUserQuestionsParametersSchema, QuestionSchema, QuestionsSchema, } from "../shared/schemas.js";
 // Re-export schemas for backward compatibility
@@ -27,8 +28,70 @@ export const createAskUserQuestionsCore = (options = {}) => {
         const parsedQuestions = QuestionsSchema.parse(questions);
         return sessionManager.startSession(normalizeQuestions(parsedQuestions), callId, workingDirectory, signal);
     };
+    const askNonBlocking = async (questions, callId, workingDirectory) => {
+        await ensureInitialized();
+        const parsedQuestions = QuestionsSchema.parse(questions);
+        const sessionId = await sessionManager.createSession(normalizeQuestions(parsedQuestions), workingDirectory);
+        return { sessionId, questionCount: parsedQuestions.length };
+    };
+    const getAnsweredQuestions = async (sessionId, blocking, signal) => {
+        await ensureInitialized();
+        // Resolve short ID to full UUID if needed
+        let resolvedSessionId = sessionId;
+        if (sessionId.length < 36) {
+            const allIds = await sessionManager.getAllSessionIds();
+            const match = allIds.find((id) => id.startsWith(sessionId));
+            if (!match) {
+                throw new Error(`Session not found: ${sessionId}`);
+            }
+            resolvedSessionId = match;
+        }
+        const sessionStatus = await sessionManager.getSessionStatus(resolvedSessionId);
+        if (!sessionStatus) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const shortId = resolvedSessionId.slice(0, 8);
+        const handleCompleted = async () => {
+            const answers = await sessionManager.getSessionAnswers(resolvedSessionId);
+            const request = await sessionManager.getSessionRequest(resolvedSessionId);
+            if (!answers || !request) {
+                throw new Error(`Session data incomplete: ${resolvedSessionId}`);
+            }
+            const formatted = ResponseFormatter.formatUserResponse(answers, request.questions);
+            const count = request.questions.length;
+            const header = `[Session: ${shortId} | Questions: ${count}]`;
+            const formattedResponse = `${header}\n\n${formatted}`;
+            await sessionManager.markSessionAsRead(resolvedSessionId);
+            return { formattedResponse, sessionId: resolvedSessionId, status: "completed" };
+        };
+        switch (sessionStatus.status) {
+            case "completed": {
+                return handleCompleted();
+            }
+            case "pending":
+            case "in-progress": {
+                if (blocking) {
+                    await sessionManager.waitForAnswers(resolvedSessionId, 0, undefined, signal);
+                    return handleCompleted();
+                }
+                const pendingResponse = `[Session: ${shortId} | Status: pending]\n\nNo answers yet.`;
+                return { formattedResponse: pendingResponse, sessionId: resolvedSessionId, status: "pending" };
+            }
+            case "rejected": {
+                const reason = sessionStatus.rejectionReason;
+                const rejectedResponse = `[Session: ${shortId} | Status: rejected]\n\nUser rejected this question set.${reason ? ` Reason: "${reason}"` : ""}`;
+                return { formattedResponse: rejectedResponse, sessionId: resolvedSessionId, status: "rejected" };
+            }
+            default: {
+                const defaultResponse = `[Session: ${shortId} | Status: ${sessionStatus.status}]\n\nSession is no longer active.`;
+                return { formattedResponse: defaultResponse, sessionId: resolvedSessionId, status: sessionStatus.status };
+            }
+        }
+    };
     return {
         ask,
+        askNonBlocking,
+        getAnsweredQuestions,
         cleanupExpiredSessions: () => sessionManager.cleanupExpiredSessions(),
         ensureInitialized,
         markAbandoned: (sessionId) => sessionManager.updateSessionStatus(sessionId, "abandoned"),

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

@@ -48,10 +48,10 @@ export const en = {
         customAnswerLabel: "Custom answer",
         customAnswerHint: "(Tab to submit)",
         otherCustom: "Other (custom)",
-        placeholder: "Type your answer (Enter = newline, Tab = done)",
+        placeholder: "Type your answer...",
         singleLinePlaceholder: "Type here...",
         multiLinePlaceholder: "Type your answer...",
-        elaboratePlaceholder: "Tell the AI what you need (Enter/Tab = Skip)",
+        elaboratePlaceholder: "Tell the AI what you need...",
     },
     question: {
         multipleChoice: "Multiple Choice",

package/dist/src/server.js

@@ -1,7 +1,7 @@
 import { FastMCP } from "fastmcp";
 import { randomUUID } from "crypto";
 import { AskUserQuestionsParametersSchema, createAskUserQuestionsCore, } from "./core/ask-user-questions.js";
-import { TOOL_DESCRIPTION } from "./shared/schemas.js";
+import { GetAnsweredQuestionsArgsSchema, GET_ANSWERED_QUESTIONS_DESCRIPTION, TOOL_DESCRIPTION } from "./shared/schemas.js";
 const askUserQuestionsCore = createAskUserQuestionsCore();
 // Track active requests with their AbortControllers for disconnect handling
 const activeRequests = new Map();
@@ -52,6 +52,17 @@ server.addTool({
             const workingDirectory = ctx
                 .workingDirectory;
             try {
+                // Handle non-blocking mode
+                if (args.nonBlocking) {
+                    const { sessionId, questionCount } = await askUserQuestionsCore.askNonBlocking(args.questions, callId, workingDirectory);
+                    const shortId = sessionId.slice(0, 8);
+                    const responseText = `[Session: ${shortId} | Questions: ${questionCount} | Status: pending]\n\n` +
+                        `Questions submitted successfully.\n` +
+                        `Use get_answered_questions(session_id="${shortId}") or \`auq fetch-answers ${shortId}\` to retrieve answers.`;
+                    return {
+                        content: [{ text: responseText, type: "text" }],
+                    };
+                }
                 const { formattedResponse, sessionId } = await askUserQuestionsCore.ask(args.questions, callId, workingDirectory, controller.signal);
                 // Update entry with sessionId for disconnect handler
                 const entry = activeRequests.get(callId);
@@ -59,11 +70,16 @@ server.addTool({
                     entry.sessionId = sessionId;
                 }
                 log.info("Session completed successfully", { sessionId, callId });
+                // Prepend metadata header to blocking responses
+                const shortId = sessionId.slice(0, 8);
+                const count = args.questions.length;
+                const header = `[Session: ${shortId} | Questions: ${count}]`;
+                const responseWithHeader = `${header}\n\n${formattedResponse}`;
                 // Return formatted response to AI model
                 return {
                     content: [
                         {
-                            text: formattedResponse,
+                            text: responseWithHeader,
                             type: "text",
                         },
                     ],
@@ -102,6 +118,47 @@ server.addTool({
     },
     parameters: AskUserQuestionsParametersSchema,
 });
+// Add the get_answered_questions tool
+server.addTool({
+    name: "get_answered_questions",
+    annotations: {
+        title: "Get Answered Questions",
+        openWorldHint: false,
+        readOnlyHint: true,
+        idempotentHint: true,
+    },
+    description: GET_ANSWERED_QUESTIONS_DESCRIPTION,
+    parameters: GetAnsweredQuestionsArgsSchema,
+    execute: async (args, ctx) => {
+        const { log } = ctx;
+        const callId = randomUUID();
+        const controller = new AbortController();
+        activeRequests.set(callId, { controller });
+        try {
+            await askUserQuestionsCore.ensureInitialized();
+            const { formattedResponse, sessionId, status } = await askUserQuestionsCore.getAnsweredQuestions(args.session_id, args.blocking, controller.signal);
+            log.info("Fetched answered questions", { sessionId, status, callId });
+            return {
+                content: [{ text: formattedResponse, type: "text" }],
+            };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === "ABORTED") {
+                log.warn("Fetch aborted: AI client disconnected", { callId });
+                return {
+                    content: [{ text: "Fetch aborted: AI client disconnected", type: "text" }],
+                };
+            }
+            log.error("Fetch answered questions failed", { error: String(error) });
+            return {
+                content: [{ text: `Error fetching answers: ${error}`, type: "text" }],
+            };
+        }
+        finally {
+            activeRequests.delete(callId);
+        }
+    },
+});
 // 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.

package/dist/src/session/ResponseFormatter.js

@@ -22,7 +22,7 @@ export class ResponseFormatter {
      * @param questions - Original questions asked to the user
      * @returns Formatted text response ready to send to AI model
      */
-    static formatUserResponse(answers, questions) {
+    static formatUserResponse(answers, questions, sessionId) {
         // Validate that we have matching questions and answers
         if (answers.answers.length === 0) {
             throw new Error("No answers provided in session");
@@ -31,7 +31,12 @@ export class ResponseFormatter {
             throw new Error("No questions provided");
         }
         // Start with header
-        const lines = ["Here are the user's answers:", ""];
+        const lines = [];
+        if (sessionId) {
+            const shortId = sessionId.slice(0, 8);
+            lines.push(`[Session: ${shortId} | Questions: ${questions.length}]`, "");
+        }
+        lines.push("Here are the user's answers:", "");
         // Format each question and its answer(s)
         // Note: A question can have multiple answers (e.g., regular answer + elaboration request)
         const formattedQuestions = [];
@@ -136,6 +141,78 @@ export class ResponseFormatter {
     static formatRephraseRequest(questionIndex, title) {
         return `[REPHRASE_REQUEST] Please rephrase question '${title}' in a different way\nQuestion index: ${questionIndex}`;
     }
+    /**
+     * Get the short form of a session ID (first 8 characters)
+     *
+     * @param sessionId - Full session ID
+     * @returns First 8 characters of the session ID
+     */
+    static getShortId(sessionId) {
+        return sessionId.slice(0, 8);
+    }
+    /**
+     * Format a non-blocking submission confirmation message
+     *
+     * @param sessionId - Full session ID
+     * @param questionCount - Number of questions submitted
+     * @returns Formatted confirmation string
+     */
+    static formatNonBlockingSubmission(sessionId, questionCount) {
+        const shortId = sessionId.slice(0, 8);
+        return [
+            `[Session: ${shortId} | Questions: ${questionCount} | Status: pending]`,
+            "",
+            "Questions submitted successfully.",
+            `Use get_answered_questions(session_id="${shortId}") or \`auq fetch-answers ${shortId}\` to retrieve answers.`,
+        ].join("\n");
+    }
+    /**
+     * Format a pending status message for a session
+     *
+     * @param sessionId - Full session ID
+     * @param remainingTime - Optional remaining time string (e.g., "4m 45s")
+     * @returns Formatted pending status string
+     */
+    static formatPendingStatus(sessionId, remainingTime) {
+        const shortId = sessionId.slice(0, 8);
+        const header = remainingTime
+            ? `[Session: ${shortId} | Status: pending | Remaining: ${remainingTime}]`
+            : `[Session: ${shortId} | Status: pending]`;
+        return [header, "", "No answers yet."].join("\n");
+    }
+    /**
+     * Format a rejected status message for a session
+     *
+     * @param sessionId - Full session ID
+     * @param reason - Optional rejection reason
+     * @returns Formatted rejected status string
+     */
+    static formatRejectedStatus(sessionId, reason) {
+        const shortId = sessionId.slice(0, 8);
+        const lines = [`[Session: ${shortId} | Status: rejected]`, ""];
+        if (reason) {
+            lines.push(`User rejected this question set. Reason: "${reason}"`);
+        }
+        else {
+            lines.push("User rejected this question set.");
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Format a generic session status message (fallback for other statuses)
+     *
+     * @param sessionId - Full session ID
+     * @param status - Session status string (e.g., "abandoned", "timed_out")
+     * @returns Formatted status string
+     */
+    static formatSessionStatus(sessionId, status) {
+        const shortId = sessionId.slice(0, 8);
+        return [
+            `[Session: ${shortId} | Status: ${status}]`,
+            "",
+            `Session status: ${status}`,
+        ].join("\n");
+    }
     /**
      * Format a single question and its answer(s)
      *

package/dist/src/session/SessionManager.js

@@ -164,6 +164,42 @@ export class SessionManager {
         }
         return pendingSessions;
     }
+    /**
+     * Get all unread sessions (completed sessions where lastReadAt is not set)
+     */
+    async getUnreadSessions() {
+        const sessionIds = await this.getAllSessionIds();
+        const unreadSessions = [];
+        for (const sessionId of sessionIds) {
+            try {
+                const status = await this.getSessionStatus(sessionId);
+                if (!status || status.status !== "completed")
+                    continue;
+                const answers = await this.getSessionAnswers(sessionId);
+                if (!answers || answers.lastReadAt)
+                    continue;
+                unreadSessions.push({ sessionId, createdAt: status.createdAt });
+            }
+            catch {
+                continue;
+            }
+        }
+        // Sort by createdAt descending (newest first)
+        unreadSessions.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        return unreadSessions.map((s) => s.sessionId);
+    }
+    /**
+     * Mark a session as read by updating lastReadAt in answers.json
+     */
+    async markSessionAsRead(sessionId) {
+        const answers = await this.readSessionFile(sessionId, SESSION_FILES.ANSWERS);
+        if (!answers) {
+            throw new Error(`Session ${sessionId} has no answers to mark as read`);
+        }
+        answers.lastReadAt = new Date().toISOString();
+        await this.writeSessionFile(sessionId, SESSION_FILES.ANSWERS, answers);
+        return answers;
+    }
     /**
      * Get session count
      */

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

@@ -924,4 +924,90 @@ describe("ResponseFormatter", () => {
                 "Question index: 0");
         });
     });
+    describe("metadata header", () => {
+        const validQuestions = [
+            {
+                options: [
+                    { description: "Type-safe JavaScript", label: "TypeScript" },
+                    { description: "Dynamic web language", label: "JavaScript" },
+                ],
+                prompt: "Which language do you prefer?",
+                title: "Language",
+            },
+        ];
+        const validAnswers = {
+            answers: [
+                {
+                    questionIndex: 0,
+                    selectedOption: "TypeScript",
+                    timestamp: "2025-01-01T00:00:00Z",
+                },
+            ],
+            sessionId: "a3f2e8b1-1234-4567-89ab-cdef01234567",
+            timestamp: "2025-01-01T00:00:00Z",
+        };
+        it("should prepend metadata header when sessionId is provided", () => {
+            const result = ResponseFormatter.formatUserResponse(validAnswers, validQuestions, "a3f2e8b1-1234-4567-89ab-cdef01234567");
+            expect(result).toMatch(/^\[Session: a3f2e8b1 \| Questions: \d+\]/);
+            expect(result).toContain("Here are the user's answers:");
+        });
+        it("should not include header when sessionId is omitted", () => {
+            const result = ResponseFormatter.formatUserResponse(validAnswers, validQuestions);
+            expect(result).not.toContain("[Session:");
+            expect(result.startsWith("Here are the user's answers:")).toBe(true);
+        });
+        it("should use short ID (first 8 chars)", () => {
+            const result = ResponseFormatter.formatUserResponse(validAnswers, validQuestions, "abcdef12-3456-4789-abcd-ef0123456789");
+            expect(result).toContain("[Session: abcdef12");
+            expect(result).not.toContain("abcdef12-3456");
+        });
+    });
+    describe("formatNonBlockingSubmission", () => {
+        it("should format non-blocking submission message", () => {
+            const result = ResponseFormatter.formatNonBlockingSubmission("a3f2e8b1-1234-4567-89ab-cdef01234567", 3);
+            expect(result).toContain("[Session: a3f2e8b1 | Questions: 3 | Status: pending]");
+            expect(result).toContain("Questions submitted successfully.");
+            expect(result).toContain("get_answered_questions");
+            expect(result).toContain("auq fetch-answers");
+        });
+    });
+    describe("formatPendingStatus", () => {
+        it("should format pending status without remaining time", () => {
+            const result = ResponseFormatter.formatPendingStatus("a3f2e8b1-1234-4567-89ab-cdef01234567");
+            expect(result).toContain("[Session: a3f2e8b1 | Status: pending]");
+            expect(result).toContain("No answers yet.");
+        });
+        it("should include remaining time when provided", () => {
+            const result = ResponseFormatter.formatPendingStatus("a3f2e8b1-1234-4567-89ab-cdef01234567", "4m 45s");
+            expect(result).toContain("Remaining: 4m 45s");
+        });
+    });
+    describe("formatRejectedStatus", () => {
+        it("should format rejected with reason", () => {
+            const result = ResponseFormatter.formatRejectedStatus("a3f2e8b1-1234-4567-89ab-cdef01234567", "not applicable");
+            expect(result).toContain("[Session: a3f2e8b1 | Status: rejected]");
+            expect(result).toContain('Reason: "not applicable"');
+        });
+        it("should format rejected without reason", () => {
+            const result = ResponseFormatter.formatRejectedStatus("a3f2e8b1-1234-4567-89ab-cdef01234567");
+            expect(result).toContain("[Session: a3f2e8b1 | Status: rejected]");
+            expect(result).toContain("User rejected this question set.");
+            expect(result).not.toContain("Reason:");
+        });
+        it("should handle null reason", () => {
+            const result = ResponseFormatter.formatRejectedStatus("a3f2e8b1-1234-4567-89ab-cdef01234567", null);
+            expect(result).not.toContain("Reason:");
+        });
+    });
+    describe("formatSessionStatus", () => {
+        it("should format generic session status", () => {
+            const result = ResponseFormatter.formatSessionStatus("a3f2e8b1-1234-4567-89ab-cdef01234567", "abandoned");
+            expect(result).toContain("[Session: a3f2e8b1 | Status: abandoned]");
+        });
+    });
+    describe("getShortId", () => {
+        it("should return first 8 characters", () => {
+            expect(ResponseFormatter.getShortId("a3f2e8b1-1234-4567-89ab-cdef01234567")).toBe("a3f2e8b1");
+        });
+    });
 });

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

@@ -655,4 +655,133 @@ describe("SessionManager", () => {
             expect(pending).toEqual([]);
         });
     });
+    describe("read tracking", () => {
+        const testQuestions = [
+            {
+                options: [
+                    { description: "Dynamic web language", label: "JavaScript" },
+                    { description: "Typed superset of JavaScript", label: "TypeScript" },
+                ],
+                prompt: "Which programming language do you prefer?",
+                title: "Language",
+            },
+        ];
+        it("should mark session as read and persist lastReadAt", async () => {
+            const sessionId = await sessionManager.createSession(testQuestions);
+            await sessionManager.saveSessionAnswers(sessionId, {
+                sessionId,
+                timestamp: new Date().toISOString(),
+                answers: [
+                    {
+                        questionIndex: 0,
+                        timestamp: new Date().toISOString(),
+                        selectedOption: testQuestions[0].options[0].label,
+                    },
+                ],
+            });
+            const result = await sessionManager.markSessionAsRead(sessionId);
+            expect(result.lastReadAt).toBeDefined();
+            expect(new Date(result.lastReadAt).getTime()).toBeGreaterThan(0);
+            // Verify persistence
+            const answers = await sessionManager.getSessionAnswers(sessionId);
+            expect(answers?.lastReadAt).toBe(result.lastReadAt);
+        });
+        it("should update lastReadAt on repeated calls", async () => {
+            const sessionId = await sessionManager.createSession(testQuestions);
+            await sessionManager.saveSessionAnswers(sessionId, {
+                sessionId,
+                timestamp: new Date().toISOString(),
+                answers: [
+                    {
+                        questionIndex: 0,
+                        timestamp: new Date().toISOString(),
+                        selectedOption: testQuestions[0].options[0].label,
+                    },
+                ],
+            });
+            const first = await sessionManager.markSessionAsRead(sessionId);
+            await new Promise((r) => setTimeout(r, 10));
+            const second = await sessionManager.markSessionAsRead(sessionId);
+            expect(second.lastReadAt).toBeDefined();
+            expect(first.lastReadAt).not.toBe(second.lastReadAt);
+        });
+        it("should throw when marking session without answers", async () => {
+            const sessionId = await sessionManager.createSession(testQuestions);
+            await expect(sessionManager.markSessionAsRead(sessionId)).rejects.toThrow("answers.json");
+        });
+    });
+    describe("getUnreadSessions", () => {
+        const testQuestions = [
+            {
+                options: [
+                    { description: "Dynamic web language", label: "JavaScript" },
+                    { description: "Typed superset of JavaScript", label: "TypeScript" },
+                ],
+                prompt: "Which programming language do you prefer?",
+                title: "Language",
+            },
+        ];
+        async function createCompletedSession(manager) {
+            const sessionId = await manager.createSession(testQuestions);
+            await manager.saveSessionAnswers(sessionId, {
+                sessionId,
+                timestamp: new Date().toISOString(),
+                answers: [
+                    {
+                        questionIndex: 0,
+                        timestamp: new Date().toISOString(),
+                        selectedOption: testQuestions[0].options[0].label,
+                    },
+                ],
+            });
+            await manager.updateSessionStatus(sessionId, "completed");
+            return sessionId;
+        }
+        it("should return completed unread sessions", async () => {
+            const sessionId = await createCompletedSession(sessionManager);
+            const unread = await sessionManager.getUnreadSessions();
+            expect(unread).toContain(sessionId);
+        });
+        it("should exclude read sessions", async () => {
+            const sessionId = await createCompletedSession(sessionManager);
+            await sessionManager.markSessionAsRead(sessionId);
+            const unread = await sessionManager.getUnreadSessions();
+            expect(unread).not.toContain(sessionId);
+        });
+        it("should exclude pending sessions", async () => {
+            const sessionId = await sessionManager.createSession(testQuestions);
+            const unread = await sessionManager.getUnreadSessions();
+            expect(unread).not.toContain(sessionId);
+        });
+        it("should exclude rejected sessions", async () => {
+            const sessionId = await sessionManager.createSession(testQuestions);
+            await sessionManager.rejectSession(sessionId, "test");
+            const unread = await sessionManager.getUnreadSessions();
+            expect(unread).not.toContain(sessionId);
+        });
+        it("should sort newest first", async () => {
+            const id1 = await createCompletedSession(sessionManager);
+            await new Promise((r) => setTimeout(r, 10));
+            const id2 = await createCompletedSession(sessionManager);
+            const unread = await sessionManager.getUnreadSessions();
+            expect(unread[0]).toBe(id2); // newest first
+            expect(unread[1]).toBe(id1);
+        });
+        it("should not mark as read when saving answers", async () => {
+            const sessionId = await sessionManager.createSession(testQuestions);
+            await sessionManager.saveSessionAnswers(sessionId, {
+                sessionId,
+                timestamp: new Date().toISOString(),
+                answers: [
+                    {
+                        questionIndex: 0,
+                        timestamp: new Date().toISOString(),
+                        selectedOption: testQuestions[0].options[0].label,
+                    },
+                ],
+            });
+            const answers = await sessionManager.getSessionAnswers(sessionId);
+            expect(answers?.lastReadAt).toBeUndefined();
+        });
+    });
 });

package/dist/src/shared/schemas.js

@@ -85,6 +85,7 @@ export function createAskUserQuestionsParametersSchema(maxQuestions = DEFAULT_LI
         questions: questionsSchema.describe(`Questions to ask the user (1-${maxQuestions} questions). ` +
             `Each question must include: prompt (full question text), title (short label, max 12 chars), ` +
             `options (2-${maxOptions} choices with labels and descriptions), and multiSelect (boolean).`),
+        nonBlocking: z.boolean().default(false).describe("Set to true to submit questions without waiting for answers. The tool will return immediately with a session ID that can be used with get_answered_questions to fetch answers later. Default: false (blocking mode)."),
     });
 }
 // Default schemas for backward compatibility (using DEFAULT_LIMITS)
@@ -106,3 +107,10 @@ export const TOOL_DESCRIPTION = "Use this tool when you need to ask the user que
     'Recommend an option unless absolutely necessary, make it the first option in the list and add "(Recommended)" at the end of the label\n' +
     'For multiSelect questions, you MAY mark multiple options as "(Recommended)" if several choices are advisable\n' +
     'Do NOT use this tool to ask "Is my plan ready?" or "Should I proceed?"';
+export const GetAnsweredQuestionsArgsSchema = z.object({
+    session_id: z.string().describe("The session ID returned from a non-blocking ask_user_questions call. Accepts both full UUID and short (first 8 chars) ID."),
+    blocking: z.boolean().default(false).describe("If true, wait until the user answers before returning. If false (default), return immediately with current status."),
+});
+export const GET_ANSWERED_QUESTIONS_DESCRIPTION = "Fetch answers for a previously submitted non-blocking question set. " +
+    "Use this after calling ask_user_questions with nonBlocking: true. " +
+    "Returns the user's answers if available, or current session status if still pending.";

package/dist/src/tui/ThemeProvider.js

@@ -1,9 +1,9 @@
 import React, { useState, useCallback, useMemo, useEffect } from "react";
 import { useInput } from "ink";
 import { ThemeContext } from "./ThemeContext.js";
-import { getTheme, listThemes, darkTheme, hasTheme } from "./themes/index.js";
-import { detectSystemTheme } from "./utils/detectTheme.js";
-import { getSavedTheme, saveTheme } from "./utils/config.js";
+import { getTheme, listThemes, darkTheme, hasTheme } from "./shared/themes/index.js";
+import { detectSystemTheme } from "./shared/utils/detectTheme.js";
+import { getSavedTheme, saveTheme } from "./shared/utils/config.js";
 import { KEYS } from "./constants/keybindings.js";
 function resolveTheme(mode) {
     if (mode === "system") {

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

@@ -8,7 +8,7 @@ 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, updateInfo, onUpdateBadgeActivate }) => {
+export const Header = ({ pendingCount, isCheckingUpdate, updateInfo, onUpdateBadgeActivate }) => {
     const { theme } = useTheme();
     const [flash, setFlash] = useState(false);
     const [prevCount, setPrevCount] = useState(pendingCount);
@@ -38,6 +38,7 @@ export const Header = ({ pendingCount, updateInfo, onUpdateBadgeActivate }) => {
                 version),
             updateInfo && (React.createElement(UpdateBadge, { updateType: updateInfo.updateType, latestVersion: updateInfo.latestVersion })),
             React.createElement(Text, { dimColor: true }, " "),
+            isCheckingUpdate && (React.createElement(Text, { dimColor: true }, " checking... ")),
             React.createElement(Text, { backgroundColor: theme.components.header.pillBg, bold: flash, color: flash
                     ? theme.components.header.queueFlash
                     : pendingCount > 0

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

@@ -3,7 +3,7 @@ import React, { useEffect, useState } from "react";
 import { t } from "../../i18n/index.js";
 import { useConfig } from "../ConfigContext.js";
 import { useTheme } from "../ThemeContext.js";
-import { isRecommendedOption } from "../utils/recommended.js";
+import { isRecommendedOption } from "../shared/utils/recommended.js";
 import { fitToVisualWidth, getVisualWidth, padToVisualWidth, } from "../utils/visualWidth.js";
 import { MultiLineTextInput } from "./MultiLineTextInput.js";
 // isRecommendedOption is imported from ../utils/recommended.js

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

@@ -1,7 +1,7 @@
 import { Box, Text, useInput, useStdout } from "ink";
 import React, { useEffect, useState } from "react";
 import { useTheme } from "../ThemeContext.js";
-import { formatRelativeTime } from "../utils/relativeTime.js";
+import { formatRelativeTime } from "../shared/utils/relativeTime.js";
 import { KEYS } from "../constants/keybindings.js";
 /* ------------------------------------------------------------------ */
 /*  Helpers                                                           */

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

@@ -6,7 +6,7 @@ import { SessionManager } from "../../session/SessionManager.js";
 import { getSessionDirectory } from "../../session/utils.js";
 import { useTheme } from "../ThemeContext.js";
 import { useConfig } from "../ConfigContext.js";
-import { isRecommendedOption } from "../utils/recommended.js";
+import { isRecommendedOption } from "../shared/utils/recommended.js";
 import { KEYS } from "../constants/keybindings.js";
 import { ConfirmationDialog } from "./ConfirmationDialog.js";
 import { QuestionDisplay } from "./QuestionDisplay.js";

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

@@ -17,7 +17,7 @@ vi.mock("ink", async () => {
     };
 });
 import { ThemeContext } from "../../ThemeContext.js";
-import { darkTheme } from "../../themes/dark.js";
+import { darkTheme } from "../../shared/themes/dark.js";
 import { ConfirmationDialog } from "../ConfirmationDialog.js";
 const mockThemeValue = {
     theme: darkTheme,

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

@@ -2,7 +2,7 @@ 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 { darkTheme } from "../../shared/themes/dark.js";
 import { KEY_LABELS } from "../../constants/keybindings.js";
 import { Footer } from "../Footer.js";
 const mockThemeValue = {