auq-mcp-server 2.6.4 → 2.7.0

package/dist/src/cli/commands/history.js

@@ -0,0 +1,375 @@
+/**
+ * CLI History Command — `auq history` and `auq history show <id>`
+ * List and browse historical sessions with filtering and search.
+ */
+import chalk from "chalk";
+import { SessionManager } from "../../session/SessionManager.js";
+import { getSessionDirectory } from "../../session/utils.js";
+import { formatAge, parseFlags } from "../utils.js";
+// ── Helper Functions ────────────────────────────────────────────────
+function getStatusIndicator(status) {
+    switch (status) {
+        case "completed":
+            return chalk.green("✓ completed");
+        case "rejected":
+            return chalk.red("✗ rejected");
+        case "pending":
+            return chalk.yellow("⏳ pending");
+        case "in-progress":
+            return chalk.yellow("⏳ in-progress");
+        case "timed_out":
+            return chalk.yellow("⏱ timed_out");
+        case "abandoned":
+            return chalk.dim("… abandoned");
+        default:
+            return status;
+    }
+}
+function getReadIndicator(lastReadAt) {
+    return lastReadAt ? "✓" : "─";
+}
+function truncatePreview(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    return text.slice(0, maxLen - 1) + "…";
+}
+function padColumn(text, width) {
+    // Strip ANSI escape codes for length calculation
+    const plainText = text.replace(/\x1b\[[0-9;]*m/g, "");
+    const padding = Math.max(0, width - plainText.length);
+    return text + " ".repeat(padding);
+}
+async function resolveSessionId(sessionManager, idArg) {
+    // Try exact full UUID match first
+    const exists = await sessionManager.sessionExists(idArg);
+    if (exists)
+        return idArg;
+    // Try short ID prefix match
+    const allIds = await sessionManager.getAllSessionIds();
+    const shortMatches = allIds.filter((id) => id.startsWith(idArg));
+    if (shortMatches.length === 1)
+        return shortMatches[0];
+    return null;
+}
+// ── List History ────────────────────────────────────────────────────
+async function listHistory(_positionals, flags) {
+    const jsonMode = flags.json === true;
+    const showAll = flags.all === true;
+    const filterUnread = flags.unread === true;
+    const sessionFilter = typeof flags.session === "string" ? flags.session : undefined;
+    const searchFilter = typeof flags.search === "string" ? flags.search.toLowerCase() : undefined;
+    const limitRaw = typeof flags.limit === "string" ? parseInt(flags.limit, 10) : 20;
+    const limit = isNaN(limitRaw) ? 20 : Math.max(1, limitRaw);
+    // Initialize SessionManager
+    const sessionManager = new SessionManager({
+        baseDir: getSessionDirectory(),
+    });
+    await sessionManager.initialize();
+    // Get all session IDs
+    const sessionIds = await sessionManager.getAllSessionIds();
+    // Build entries
+    const entries = [];
+    let abandonedCount = 0;
+    for (const sessionId of sessionIds) {
+        let status = null;
+        let request = null;
+        let answersData = null;
+        try {
+            status = await sessionManager.getSessionStatus(sessionId);
+            if (!status)
+                continue;
+            request = await sessionManager.getSessionRequest(sessionId);
+            try {
+                answersData = await sessionManager.getSessionAnswers(sessionId);
+            }
+            catch {
+                // answers.json may not exist — that's ok
+            }
+        }
+        catch {
+            continue; // Skip broken sessions
+        }
+        if (!status)
+            continue;
+        const isAbandoned = status.status === "abandoned";
+        if (isAbandoned)
+            abandonedCount++;
+        const questionCount = request?.questions?.length ?? status.totalQuestions ?? 0;
+        const answeredCount = answersData?.answers?.length ?? 0;
+        const lastReadAt = answersData?.lastReadAt;
+        // Build preview from first question prompt
+        const firstQuestion = request?.questions?.[0];
+        const preview = firstQuestion
+            ? truncatePreview(firstQuestion.prompt, 40)
+            : "";
+        // Build search text from all question prompts and answer data
+        const searchTextParts = [];
+        if (request?.questions) {
+            for (const q of request.questions) {
+                searchTextParts.push(q.prompt.toLowerCase());
+                if (q.title)
+                    searchTextParts.push(q.title.toLowerCase());
+            }
+        }
+        if (answersData?.answers) {
+            for (const a of answersData.answers) {
+                if (a.selectedOption)
+                    searchTextParts.push(a.selectedOption.toLowerCase());
+                if (a.selectedOptions) {
+                    for (const opt of a.selectedOptions)
+                        searchTextParts.push(opt.toLowerCase());
+                }
+                if (a.customText)
+                    searchTextParts.push(a.customText.toLowerCase());
+            }
+        }
+        const searchText = searchTextParts.join(" ");
+        entries.push({
+            sessionId,
+            shortId: sessionId.slice(0, 8),
+            status: status.status,
+            createdAt: status.createdAt,
+            lastReadAt,
+            questionCount,
+            answeredCount,
+            preview,
+            searchText,
+            isAbandoned,
+        });
+    }
+    // Sort by createdAt descending (newest first)
+    entries.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    // Apply filters
+    let filtered = [...entries];
+    // Base filter: exclude abandoned unless --all
+    if (!showAll) {
+        filtered = filtered.filter((e) => !e.isAbandoned);
+    }
+    // --session filter
+    if (sessionFilter !== undefined) {
+        filtered = filtered.filter((e) => e.sessionId === sessionFilter ||
+            e.sessionId.startsWith(sessionFilter));
+        if (filtered.length === 0) {
+            if (jsonMode) {
+                console.log(JSON.stringify([], null, 2));
+            }
+            else {
+                console.error(`Session not found: ${sessionFilter}`);
+            }
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // --unread filter
+    if (filterUnread) {
+        filtered = filtered.filter((e) => e.status === "completed" && !e.lastReadAt);
+    }
+    // --search filter
+    if (searchFilter !== undefined) {
+        filtered = filtered.filter((e) => e.searchText.includes(searchFilter));
+    }
+    // Apply limit
+    const displayed = filtered.slice(0, limit);
+    // JSON output
+    if (jsonMode) {
+        const result = displayed.map((e) => ({
+            sessionId: e.sessionId,
+            status: e.status,
+            createdAt: e.createdAt,
+            lastReadAt: e.lastReadAt ?? null,
+            questionCount: e.questionCount,
+            answeredCount: e.answeredCount,
+            preview: e.preview,
+        }));
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // Empty state
+    if (displayed.length === 0) {
+        console.log("No sessions found.");
+        return;
+    }
+    // Table output
+    const headerLine = padColumn("ID", 10) +
+        padColumn("Status", 16) +
+        padColumn("Time", 10) +
+        padColumn("Read", 7) +
+        padColumn("Q", 6) +
+        "Preview";
+    console.log(chalk.dim(headerLine));
+    for (const entry of displayed) {
+        const statusStr = getStatusIndicator(entry.status);
+        const age = formatAge(entry.createdAt);
+        const readStr = getReadIndicator(entry.lastReadAt);
+        const questionsStr = `${entry.answeredCount}/${entry.questionCount}`;
+        const line = padColumn(entry.shortId, 10) +
+            padColumn(statusStr, 16) +
+            padColumn(age, 10) +
+            padColumn(readStr, 7) +
+            padColumn(questionsStr, 6) +
+            entry.preview;
+        console.log(line);
+    }
+    // Hint line when abandoned sessions are hidden
+    if (!showAll && abandonedCount > 0) {
+        console.log(chalk.dim(`\n${displayed.length} sessions shown (${abandonedCount} abandoned hidden, use --all)`));
+    }
+}
+// ── Show History ────────────────────────────────────────────────────
+async function showHistory(positionals, flags) {
+    const jsonMode = flags.json === true;
+    const idArg = positionals[0];
+    if (!idArg) {
+        console.error("Missing session ID. Usage: auq history show <sessionId> [--json]");
+        process.exitCode = 1;
+        return;
+    }
+    // Initialize SessionManager
+    const sessionManager = new SessionManager({
+        baseDir: getSessionDirectory(),
+    });
+    await sessionManager.initialize();
+    // Resolve session ID (full UUID or short prefix)
+    const sessionId = await resolveSessionId(sessionManager, idArg);
+    if (!sessionId) {
+        console.error(`Session not found: ${idArg}`);
+        process.exitCode = 1;
+        return;
+    }
+    // Load session data
+    const status = await sessionManager.getSessionStatus(sessionId);
+    const request = await sessionManager.getSessionRequest(sessionId);
+    let answersData = null;
+    try {
+        answersData = await sessionManager.getSessionAnswers(sessionId);
+    }
+    catch {
+        // answers.json may not exist for pending/abandoned sessions
+    }
+    if (!status || !request) {
+        console.error(`Could not read session data for: ${idArg}`);
+        process.exitCode = 1;
+        return;
+    }
+    const questions = request.questions;
+    const answers = answersData?.answers ?? null;
+    const lastReadAt = answersData?.lastReadAt;
+    const answeredCount = answers?.length ?? 0;
+    // Build answer lookup (questionIndex → answer)
+    const answerMap = new Map();
+    if (answers) {
+        for (const a of answers) {
+            answerMap.set(a.questionIndex, {
+                selectedOption: a.selectedOption,
+                selectedOptions: a.selectedOptions,
+                customText: a.customText,
+            });
+        }
+    }
+    // JSON output
+    if (jsonMode) {
+        const result = {
+            sessionId,
+            status: status.status,
+            createdAt: status.createdAt,
+            lastReadAt: lastReadAt ?? null,
+            questionCount: questions.length,
+            answeredCount,
+            questions: questions.map((q, i) => {
+                const answer = answerMap.get(i);
+                const selectedLabels = new Set();
+                if (answer?.selectedOption)
+                    selectedLabels.add(answer.selectedOption);
+                if (answer?.selectedOptions) {
+                    for (const opt of answer.selectedOptions)
+                        selectedLabels.add(opt);
+                }
+                return {
+                    index: i,
+                    title: q.title,
+                    prompt: q.prompt,
+                    multiSelect: q.multiSelect ?? false,
+                    options: q.options.map((o) => ({
+                        label: o.label,
+                        description: o.description ?? null,
+                        selected: selectedLabels.has(o.label),
+                    })),
+                    customText: answer?.customText ?? null,
+                };
+            }),
+        };
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // Human-readable output
+    const age = formatAge(status.createdAt);
+    const createdAbsolute = new Date(status.createdAt)
+        .toISOString()
+        .replace("T", " ")
+        .replace(/\.\d+Z$/, "Z");
+    console.log(`Session: ${sessionId}`);
+    console.log(`Status: ${getStatusIndicator(status.status)}`);
+    console.log(`Created: ${createdAbsolute} (${age})`);
+    if (lastReadAt) {
+        const readAbsolute = new Date(lastReadAt)
+            .toISOString()
+            .replace("T", " ")
+            .replace(/\.\d+Z$/, "Z");
+        console.log(`Read: ✓ ${readAbsolute}`);
+    }
+    else {
+        console.log("Read: unread");
+    }
+    console.log(`Questions: ${answeredCount}/${questions.length} answered`);
+    console.log("");
+    // Display questions with options
+    for (let i = 0; i < questions.length; i++) {
+        const q = questions[i];
+        const answer = answerMap.get(i);
+        // Determine which option labels are selected
+        const selectedLabels = new Set();
+        if (answer?.selectedOption)
+            selectedLabels.add(answer.selectedOption);
+        if (answer?.selectedOptions) {
+            for (const opt of answer.selectedOptions)
+                selectedLabels.add(opt);
+        }
+        console.log(`${i + 1}. ${q.title}`);
+        console.log(`   ${q.prompt}`);
+        let otherOptionHandled = false;
+        for (const opt of q.options) {
+            const isSelected = selectedLabels.has(opt.label);
+            const descPart = opt.description ? ` — ${opt.description}` : "";
+            // If this is the "Other" option and there's custom text, show custom text inline
+            if (isSelected && answer?.customText && opt.label === "Other") {
+                console.log(`   (selected) Other: '${answer.customText}'`);
+                otherOptionHandled = true;
+            }
+            else if (isSelected) {
+                console.log(`   (selected) ${opt.label}${descPart}`);
+            }
+            else {
+                console.log(`   ${opt.label}${descPart}`);
+            }
+        }
+        // If customText exists but "Other" is not a listed option, show it as additional entry
+        if (answer?.customText && !otherOptionHandled) {
+            const hasOtherOption = q.options.some((o) => o.label === "Other");
+            if (!hasOtherOption) {
+                console.log(`   (selected) Other: '${answer.customText}'`);
+            }
+        }
+        console.log("");
+    }
+}
+// ── History Command Dispatcher ──────────────────────────────────────
+export async function runHistoryCommand(args) {
+    const { flags, positionals } = parseFlags(args);
+    const subcommand = positionals[0];
+    if (subcommand === "show") {
+        await showHistory(positionals.slice(1), flags);
+    }
+    else {
+        await listHistory(positionals, flags);
+    }
+}

package/dist/src/config/__tests__/ConfigLoader.test.js

@@ -132,4 +132,42 @@ describe("ConfigLoader", () => {
             expect(config.staleThreshold).toBe(DEFAULT_CONFIG.staleThreshold);
         });
     });
+    describe("renderer config options", () => {
+        it("should have 'ink' as default renderer when no config files exist", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const config = loadConfig();
+            expect(config.renderer).toBe("ink");
+        });
+        it("should include renderer in DEFAULT_CONFIG as 'ink'", () => {
+            expect(DEFAULT_CONFIG.renderer).toBe("ink");
+        });
+        it("should load renderer: 'opentui' from config file", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ renderer: "opentui" }));
+            const config = loadConfig();
+            expect(config.renderer).toBe("opentui");
+        });
+        it("should load renderer: 'ink' from config file", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ renderer: "ink" }));
+            const config = loadConfig();
+            expect(config.renderer).toBe("ink");
+        });
+        it("should fall back to 'ink' for invalid renderer value", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ renderer: "chrome" }));
+            const config = loadConfig();
+            // Invalid enum value should be ignored, default ('ink') used
+            expect(config.renderer).toBe(DEFAULT_CONFIG.renderer);
+            expect(config.renderer).toBe("ink");
+        });
+        it("should preserve other config values alongside renderer setting", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ renderer: "opentui", theme: "dark" }));
+            const config = loadConfig();
+            expect(config.renderer).toBe("opentui");
+            expect(config.theme).toBe("dark");
+            expect(config.maxOptions).toBe(DEFAULT_CONFIG.maxOptions);
+        });
+    });
 });

package/dist/src/config/defaults.js

@@ -8,6 +8,7 @@ export const DEFAULT_CONFIG = {
     language: "auto",
     theme: "system",
     autoSelectRecommended: true,
+    renderer: "ink",
     staleThreshold: 7200000, // 2 hours in ms
     notifyOnStale: true,
     staleAction: "warn",

package/dist/src/config/types.js

@@ -21,6 +21,7 @@ export const AUQConfigSchema = z.object({
     language: z.string().default("auto"),
     theme: z.string().default("system"),
     autoSelectRecommended: z.boolean().default(true),
+    renderer: z.enum(["ink", "opentui"]).default("ink"),
     // Stale/Orphan Session Detection
     staleThreshold: z.number().min(0).default(7200000), // 2 hours in ms
     notifyOnStale: z.boolean().default(true),

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.