auq-mcp-server 2.2.2 → 2.4.0

package/README.md

@@ -255,6 +255,85 @@ auq --help       # Show help
 
 ---
 
+### CLI Commands
+
+AUQ provides headless CLI commands for managing sessions and configuration without the TUI.
+
+#### Answer Sessions
+
+```bash
+# Answer a session with JSON answers
+auq answer <sessionId> --answers '{"0": {"selectedOption": "option1"}}'
+
+# Reject a session
+auq answer <sessionId> --reject --reason "Not applicable"
+
+# Force answer an abandoned session
+auq answer <sessionId> --answers '...' --force
+
+# JSON output
+auq answer <sessionId> --answers '...' --json
+```
+
+#### Manage Sessions
+
+```bash
+# List pending sessions
+auq sessions list
+
+# List stale sessions only
+auq sessions list --stale
+
+# List all sessions (including completed, abandoned)
+auq sessions list --all
+
+# Dismiss/archive a session
+auq sessions dismiss <sessionId>
+
+# JSON output
+auq sessions list --json
+```
+
+#### Configuration
+
+```bash
+# View all configuration
+auq config get
+
+# View specific setting
+auq config get staleThreshold
+
+# Set a value (local .auqrc.json)
+auq config set staleThreshold 3600000
+
+# Set globally
+auq config set staleThreshold 3600000 --global
+```
+
+---
+
+### Stale Session Detection
+
+Sessions that remain unanswered longer than the configured threshold are marked as "stale" (potentially orphaned). This helps identify sessions where the AI may have disconnected or timed out.
+
+- **Visual indicators**: Stale sessions show a ⚠ warning icon and yellow highlighting in the TUI
+- **Toast notifications**: A notification appears when a session becomes stale (configurable)
+- **Grace period**: Interacting with a stale session provides a 30-minute grace period
+- **Configurable threshold**: Default is 2 hours (7,200,000ms)
+
+---
+
+### Abandoned Session Handling
+
+When an AI client disconnects, associated sessions are marked as "abandoned". These sessions:
+
+- Remain visible in the TUI with a red indicator
+- Show a confirmation dialog before answering ("AI가 disconnect되었습니다")
+- Can still be answered via CLI with the `--force` flag
+- Are detectable via `auq sessions list --all`
+
+---
+
 ### 🎨 Themes
 
 AUQ supports **16 built-in color themes** with automatic persistence. Press `Ctrl+T` to cycle through themes.
@@ -461,6 +540,9 @@ _Settings from local config override global config, which overrides defaults._
 | `retentionPeriod`       | number  | 604800000 | 0+ (milliseconds)               | How long to keep completed sessions (default: 7 days) |
 | `notifications.enabled` | boolean | true      | true/false                      | Enable desktop notifications for new questions        |
 | `notifications.sound`   | boolean | true      | true/false                      | Play sound with notifications                         |
+| `staleThreshold`        | number  | 7200000   | 0+ (milliseconds)               | Time before a session is considered stale (2 hours)   |
+| `notifyOnStale`         | boolean | true      | true/false                      | Show toast notification when sessions become stale    |
+| `staleAction`           | string  | "warn"    | "warn", "remove", "archive"     | Action for stale sessions                             |
 
 </details>
 

package/dist/bin/auq.js

@@ -9,54 +9,42 @@ import { getSessionDirectory } from "../src/session/utils.js";
 const args = process.argv.slice(2);
 const command = args[0];
 if (command === "--help" || command === "-h") {
-    console.log(`
-AUQ - Ask User Questions
+    console.log(`auq - Ask User Questions (MCP server + TUI)
 
-Usage:
-  auq [command] [options]
+Usage: auq [command] [options]
 
 Commands:
-  (default)     Start the TUI (Terminal User Interface)
-  server        Start the MCP server (for use with MCP clients)
-  ask <json>    Ask questions via CLI (alternative to MCP)
+  (default)              Start interactive TUI
+  server                 Start MCP server (stdio)
+  ask <json>             Ask questions via CLI
+  answer <id> [flags]    Answer or reject a session
+  sessions <sub> [flags] List/dismiss sessions
+  config <sub> [flags]   Get/set configuration
 
-Options:
-  --help, -h    Show this help message
-  --version, -v Show version information
-
-ASK COMMAND:
-  Use 'auq ask' when you need to ask the user questions during execution.
-  This allows you to:
-  1. Gather user preferences or requirements
-  2. Clarify ambiguous instructions
-  3. Get decisions on implementation choices as you work
-  4. Offer choices to the user about what direction to take
+Answer:
+  auq answer <id> --answers '<json>'    Submit answers
+  auq answer <id> --reject [--reason]   Reject session
+  Flags: --force  --json
 
-  FEATURES:
-  - Ask 1-4 structured questions via an interactive terminal interface
-  - Each question includes 2-4 multiple-choice options with explanatory descriptions
-  - Users can always provide custom free-text input as an alternative to predefined options
-  - Single-select mode (default): User picks ONE option or provides custom text
-  - Multi-select mode (multiSelect: true): User can select MULTIPLE options
+Sessions:
+  auq sessions list [--pending|--stale|--all] [--json]
+  auq sessions dismiss <id> [--force] [--json]
 
-  USAGE NOTES:
-  - Provide a descriptive 'title' field (max 12 chars) for each question
-  - Use multiSelect: true when choices are not mutually exclusive
-  - Option labels should be concise (1-5 words)
-  - To mark a recommended option, append '(recommended)' to its label
-  - Don't include an 'Other' option - it's provided automatically
+Config:
+  auq config get [key] [--json]
+  auq config set <key> <value> [--global] [--json]
 
-  Returns a formatted summary of all questions and answers.
+Options:
+  -h, --help      Show this help
+  -v, --version   Show version
 
-Examples:
-  auq                    # Start TUI (wait for questions from AI)
-  auq server             # Start MCP server (for Claude Desktop, etc.)
-  auq ask '{"questions": [{"prompt": "Which language?", "title": "Lang", "options": [{"label": "TypeScript (recommended)"}, {"label": "Python"}], "multiSelect": false}]}'
-  echo '{"questions": [...]}' | auq ask   # Pipe JSON to ask command
+Keys (TUI):
+  ↑↓ navigate  ←→/Tab questions  Space toggle  Enter select
+  R recommend  Ctrl+R quick-submit  Esc reject
+  [/] sessions  1-9 jump  Ctrl+S picker  Ctrl+T theme
 
-For more information, visit:
-  https://github.com/paulp-o/ask-user-questions-mcp
-`);
+Config: ./.auqrc.json (local) > ~/.config/auq/.auqrc.json (global)
+Env:    AUQ_SESSION_DIR  XDG_CONFIG_HOME`);
     process.exit(0);
 }
 // Display version
@@ -168,6 +156,24 @@ if (command === "ask") {
         process.exit(1);
     }
 }
+// Handle 'answer' command
+if (command === "answer") {
+    const { runAnswerCommand } = await import("../src/cli/commands/answer.js");
+    await runAnswerCommand(args.slice(1));
+    process.exit(0);
+}
+// Handle 'sessions' command
+if (command === "sessions") {
+    const { runSessionsCommand } = await import("../src/cli/commands/sessions.js");
+    await runSessionsCommand(args.slice(1));
+    process.exit(0);
+}
+// Handle 'config' command
+if (command === "config") {
+    const { runConfigCommand } = await import("../src/cli/commands/config.js");
+    await runConfigCommand(args.slice(1));
+    process.exit(0);
+}
 // Default: Start TUI
 // Important: Lazy-load Ink/React so non-interactive commands (ask/server) don't pull them in.
 // Also force production mode before importing React/Ink to avoid perf_hooks measure accumulation warnings.

package/dist/bin/tui-app.js

@@ -11,9 +11,11 @@ import { Toast } from "../src/tui/components/Toast.js";
 import { WaitingScreen } from "../src/tui/components/WaitingScreen.js";
 import { createNotificationBatcher, showProgress, clearProgress, calculateProgress, checkLinuxDependencies, } from "../src/tui/notifications/index.js";
 import { createTUIWatcher } from "../src/tui/session-watcher.js";
+import { isSessionStale, isSessionAbandoned, formatStaleToastMessage, } from "../src/tui/utils/staleDetection.js";
 import { ThemeProvider } from "../src/tui/ThemeProvider.js";
 import { ConfigProvider } from "../src/tui/ConfigContext.js";
 import { getAdjustedIndexAfterRemoval, getDirectJumpIndex, getNextSessionIndex, getPrevSessionIndex, } from "../src/tui/utils/sessionSwitching.js";
+import { KEYS } from "../src/tui/constants/keybindings.js";
 const App = ({ config }) => {
     const [state, setState] = useState({ mode: "WAITING" });
     const [sessionQueue, setSessionQueue] = useState([]);
@@ -24,6 +26,9 @@ const App = ({ config }) => {
     const [showSessionLog, setShowSessionLog] = useState(true);
     const [showSessionPicker, setShowSessionPicker] = useState(false);
     const [isInReviewOrRejection, setIsInReviewOrRejection] = useState(false);
+    const [sessionMeta, setSessionMeta] = useState(new Map());
+    const [lastInteractions, setLastInteractions] = useState(new Map());
+    const [staleToastShown, setStaleToastShown] = useState(new Set());
     // Get session directory for logging
     const sessionDir = getSessionDirectory();
     // Notification configuration from config
@@ -53,6 +58,7 @@ const App = ({ config }) => {
                 // Step 1: Load existing pending sessions
                 const watcher = createTUIWatcher();
                 const sessionIds = await watcher.getPendingSessions();
+                const sessionsWithStatus = await watcher.getPendingSessionsWithStatus();
                 const sessionData = await Promise.all(sessionIds.map(async (sessionId) => {
                     const sessionRequest = await watcher.getSessionRequest(sessionId);
                     if (!sessionRequest)
@@ -68,6 +74,12 @@ const App = ({ config }) => {
                     .filter((s) => s !== null)
                     .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
                 setSessionQueue(validSessions);
+                // Build initial sessionMeta from status data
+                const initialMeta = new Map();
+                for (const meta of sessionsWithStatus) {
+                    initialMeta.set(meta.sessionId, { status: meta.status, createdAt: meta.createdAt });
+                }
+                setSessionMeta(initialMeta);
                 setIsInitialized(true);
                 // Step 2: Start persistent watcher for new sessions
                 watcherInstance = createTUIWatcher({ autoLoadData: true });
@@ -152,8 +164,7 @@ const App = ({ config }) => {
                         const parsed = JSON.parse(content);
                         if (parsed.status === "timed_out" ||
                             parsed.status === "completed" ||
-                            parsed.status === "rejected" ||
-                            parsed.status === "abandoned") {
+                            parsed.status === "rejected") {
                             return {
                                 notifyAsTimedOut: parsed.status === "timed_out",
                                 session,
@@ -214,11 +225,47 @@ const App = ({ config }) => {
         const interval = setInterval(() => {
             void checkPausedSessionStatuses();
         }, 2000);
+        // --- Stale detection (runs alongside status polling) ---
+        const staleThreshold = config?.staleThreshold ?? 7200000;
+        const notifyOnStale = config?.notifyOnStale ?? true;
+        const runStaleDetection = async () => {
+            // Refresh session metadata from disk
+            const watcher = createTUIWatcher();
+            let freshMeta = [];
+            try {
+                freshMeta = await watcher.getPendingSessionsWithStatus();
+            }
+            catch {
+                // Non-critical — stale detection simply skips this cycle
+            }
+            if (freshMeta.length > 0) {
+                setSessionMeta((prev) => {
+                    const next = new Map(prev);
+                    for (const meta of freshMeta) {
+                        next.set(meta.sessionId, { status: meta.status, createdAt: meta.createdAt });
+                    }
+                    return next;
+                });
+            }
+            // Show toast for newly stale sessions
+            for (const session of sessionQueue) {
+                const stale = isSessionStale(session.timestamp.getTime(), staleThreshold, lastInteractions.get(session.sessionId));
+                if (stale && notifyOnStale && !staleToastShown.has(session.sessionId)) {
+                    const title = session.sessionRequest.questions[0]?.title ?? session.sessionId.slice(0, 8);
+                    showToast(formatStaleToastMessage(title, session.timestamp.getTime()), "info");
+                    setStaleToastShown((prev) => new Set(prev).add(session.sessionId));
+                }
+            }
+        };
+        const staleInterval = setInterval(() => {
+            void runStaleDetection();
+        }, 2000);
         return () => {
             isCancelled = true;
             clearInterval(interval);
+            clearInterval(staleInterval);
         };
-    }, [activeSessionIndex, sessionDir, sessionQueue, state.mode]);
+    }, [activeSessionIndex, sessionDir, sessionQueue, state.mode, config?.staleThreshold, config?.notifyOnStale, lastInteractions, staleToastShown]);
     // Handle progress updates from StepperView
     const handleProgressUpdate = (answered, total) => {
         const percent = calculateProgress(answered, total);
@@ -229,6 +276,8 @@ const App = ({ config }) => {
             ...prev,
             [sessionId]: ui,
         }));
+        // Track interaction for stale grace time
+        setLastInteractions((prev) => new Map(prev).set(sessionId, Date.now()));
     }, []);
     const handleFlowStateChange = useCallback((flowState) => {
         setIsInReviewOrRejection(flowState.showReview || flowState.showRejectionConfirm);
@@ -247,6 +296,13 @@ const App = ({ config }) => {
         }
         setActiveSessionIndex(clampedIndex);
         setShowSessionPicker(false);
+        // Track interaction for stale grace time
+        setLastInteractions((prev) => {
+            const targetSession = sessionQueue[clampedIndex];
+            if (!targetSession)
+                return prev;
+            return new Map(prev).set(targetSession.sessionId, Date.now());
+        });
     }, [activeSessionIndex, sessionQueue, state.mode]);
     const activeSession = state.mode === "PROCESSING" ? sessionQueue[activeSessionIndex] : undefined;
     const canUseDirectJump = !activeSession ||
@@ -257,12 +313,18 @@ const App = ({ config }) => {
             setShowSessionPicker(true);
             return;
         }
-        if (key.ctrl && input === "]") {
+        if (!key.ctrl && !key.meta && input === KEYS.SESSION_NEXT) {
+            if (!canUseDirectJump) {
+                return;
+            }
             const nextIndex = getNextSessionIndex(activeSessionIndex, sessionQueue.length);
             switchToSession(nextIndex);
             return;
         }
-        if (key.ctrl && input === "[") {
+        if (!key.ctrl && !key.meta && input === KEYS.SESSION_PREV) {
+            if (!canUseDirectJump) {
+                return;
+            }
             const prevIndex = getPrevSessionIndex(activeSessionIndex, sessionQueue.length);
             switchToSession(prevIndex);
             return;
@@ -334,7 +396,7 @@ const App = ({ config }) => {
             mainContent = React.createElement(WaitingScreen, { queueCount: sessionQueue.length });
         }
         else {
-            mainContent = (React.createElement(StepperView, { key: session.sessionId, onComplete: handleSessionComplete, onProgress: handleProgressUpdate, initialState: sessionUIStates[session.sessionId], onStateSnapshot: handleStateSnapshot, onFlowStateChange: handleFlowStateChange, hasMultipleSessions: sessionQueue.length >= 2, sessionId: session.sessionId, sessionRequest: session.sessionRequest }));
+            mainContent = (React.createElement(StepperView, { key: session.sessionId, onComplete: handleSessionComplete, onProgress: handleProgressUpdate, initialState: sessionUIStates[session.sessionId], onStateSnapshot: handleStateSnapshot, onFlowStateChange: handleFlowStateChange, hasMultipleSessions: sessionQueue.length >= 2, sessionId: session.sessionId, sessionRequest: session.sessionRequest, isAbandoned: isSessionAbandoned(sessionMeta.get(session.sessionId)?.status ?? "") }));
         }
     }
     // Render with header, toast overlay, and main content
@@ -347,14 +409,22 @@ const App = ({ config }) => {
                         ? Math.max(0, sessionQueue.length - 1)
                         : sessionQueue.length }),
                 mainContent,
-                state.mode === "PROCESSING" && sessionQueue.length >= 2 && (React.createElement(SessionDots, { sessions: sessionQueue, activeIndex: activeSessionIndex, sessionUIStates: sessionUIStates })),
+                state.mode === "PROCESSING" && sessionQueue.length >= 2 && (React.createElement(SessionDots, { sessions: sessionQueue.map((s) => ({
+                        ...s,
+                        isStale: isSessionStale(s.timestamp.getTime(), config?.staleThreshold ?? 7200000, lastInteractions.get(s.sessionId)),
+                        isAbandoned: isSessionAbandoned(sessionMeta.get(s.sessionId)?.status ?? ""),
+                    })), activeIndex: activeSessionIndex, sessionUIStates: sessionUIStates })),
                 toast && (React.createElement(Box, { marginTop: 1, justifyContent: "center" },
                     React.createElement(Toast, { message: toast.message, onDismiss: () => setToast(null), type: toast.type, title: toast.title, duration: 5000 }))),
                 showSessionLog && (React.createElement(Box, { marginTop: 1 },
                     React.createElement(Text, { dimColor: true },
                         "[AUQ] Session directory: ",
                         sessionDir))),
-                state.mode === "PROCESSING" && (React.createElement(SessionPicker, { isOpen: showSessionPicker, sessions: sessionQueue, activeIndex: activeSessionIndex, sessionUIStates: sessionUIStates, onSelectIndex: (idx) => {
+                state.mode === "PROCESSING" && (React.createElement(SessionPicker, { isOpen: showSessionPicker, sessions: sessionQueue.map((s) => ({
+                        ...s,
+                        isStale: isSessionStale(s.timestamp.getTime(), config?.staleThreshold ?? 7200000, lastInteractions.get(s.sessionId)),
+                        isAbandoned: isSessionAbandoned(sessionMeta.get(s.sessionId)?.status ?? ""),
+                    })), activeIndex: activeSessionIndex, sessionUIStates: sessionUIStates, onSelectIndex: (idx) => {
                         switchToSession(idx);
                         setShowSessionPicker(false);
                     }, onClose: () => setShowSessionPicker(false) })),

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "auq-mcp-server",
-    "version": "2.2.2",
+    "version": "2.4.0",
     "main": "dist/index.js",
     "bin": {
         "auq": "dist/bin/auq.js"

package/dist/src/__tests__/server.abort.test.js

@@ -0,0 +1,214 @@
+/**
+ * Tests for AbortSignal and disconnect handling in SessionManager
+ */
+import { promises as fs } from "fs";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { SessionManager } from "../session/index.js";
+const testQuestions = [
+    {
+        options: [
+            { description: "Dynamic language", label: "JavaScript" },
+            { description: "Static typing", label: "TypeScript" },
+        ],
+        prompt: "Which programming language do you prefer?",
+        title: "Language",
+    },
+];
+describe("AbortSignal and Disconnect Handling", () => {
+    let sessionManager;
+    const testBaseDir = "/tmp/auq-test-abort";
+    beforeEach(async () => {
+        await fs.rm(testBaseDir, { force: true, recursive: true }).catch(() => { });
+        sessionManager = new SessionManager({
+            baseDir: testBaseDir,
+            maxSessions: 10,
+            sessionTimeout: 5000,
+        });
+        await sessionManager.initialize();
+    });
+    afterEach(async () => {
+        await fs.rm(testBaseDir, { force: true, recursive: true }).catch(() => { });
+    });
+    describe("waitForAnswers with AbortSignal", () => {
+        it("should throw ABORTED when signal fires during polling", async () => {
+            const sessionId = await sessionManager.createSession(testQuestions);
+            const controller = new AbortController();
+            // Abort after a short delay
+            setTimeout(() => controller.abort(), 100);
+            await expect(sessionManager.waitForAnswers(sessionId, 0, undefined, controller.signal)).rejects.toThrow("ABORTED");
+        });
+        it("should throw ABORTED immediately when signal is already aborted", async () => {
+            const sessionId = await sessionManager.createSession(testQuestions);
+            const controller = new AbortController();
+            controller.abort(); // Pre-abort
+            await expect(sessionManager.waitForAnswers(sessionId, 0, undefined, controller.signal)).rejects.toThrow("ABORTED");
+        });
+        it("should work normally when signal is never aborted", async () => {
+            const sessionId = await sessionManager.createSession(testQuestions);
+            const controller = new AbortController();
+            // Write answers after a short delay
+            setTimeout(async () => {
+                await sessionManager.saveSessionAnswers(sessionId, {
+                    answers: [{ questionIndex: 0, selectedOption: "JavaScript", timestamp: new Date().toISOString() }],
+                    timestamp: new Date().toISOString(),
+                    sessionId,
+                });
+            }, 100);
+            const result = await sessionManager.waitForAnswers(sessionId, 5000, undefined, controller.signal);
+            expect(result).toBe(sessionId);
+        });
+    });
+    describe("startSession with AbortSignal", () => {
+        it("should throw ABORTED when pre-aborted signal is passed", async () => {
+            const controller = new AbortController();
+            controller.abort(); // Pre-abort
+            await expect(sessionManager.startSession(testQuestions, "test-call", undefined, controller.signal)).rejects.toThrow("ABORTED");
+        });
+        it("should mark session as abandoned when pre-aborted signal is passed", async () => {
+            const controller = new AbortController();
+            controller.abort(); // Pre-abort
+            try {
+                await sessionManager.startSession(testQuestions, "test-call", undefined, controller.signal);
+            }
+            catch {
+                // Expected error
+            }
+            // Get session IDs and check the last one's status
+            const sessionIds = await sessionManager.getAllSessionIds();
+            expect(sessionIds.length).toBeGreaterThan(0);
+            const lastSessionId = sessionIds[sessionIds.length - 1];
+            const status = await sessionManager.getSessionStatus(lastSessionId);
+            expect(status?.status).toBe("abandoned");
+        });
+        it("should mark session as abandoned when signal aborts during wait", async () => {
+            const controller = new AbortController();
+            // Abort after session is created but before answers arrive
+            setTimeout(() => controller.abort(), 200);
+            await expect(sessionManager.startSession(testQuestions, "test-call", undefined, controller.signal)).rejects.toThrow("ABORTED");
+            // Verify session was marked abandoned
+            const sessionIds = await sessionManager.getAllSessionIds();
+            expect(sessionIds.length).toBeGreaterThan(0);
+            const lastSessionId = sessionIds[sessionIds.length - 1];
+            // Give abort handler time to update status
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            const status = await sessionManager.getSessionStatus(lastSessionId);
+            expect(status?.status).toBe("abandoned");
+        });
+        it("should clean up abort handler after successful completion", async () => {
+            const controller = new AbortController();
+            const signal = controller.signal;
+            // Create a session and immediately provide answers
+            const sessionPromise = sessionManager.startSession(testQuestions, "test-call", undefined, signal);
+            // Write answers quickly
+            // First we need to get the session ID, but startSession creates it internally
+            // We'll poll for any pending session
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            const sessionIds = await sessionManager.getAllSessionIds();
+            if (sessionIds.length > 0) {
+                const lastSessionId = sessionIds[sessionIds.length - 1];
+                await sessionManager.saveSessionAnswers(lastSessionId, {
+                    answers: [{ questionIndex: 0, selectedOption: "JavaScript", timestamp: new Date().toISOString() }],
+                    timestamp: new Date().toISOString(),
+                    sessionId: lastSessionId,
+                });
+            }
+            const result = await sessionPromise;
+            expect(result.formattedResponse).toBeDefined();
+            expect(result.sessionId).toBeDefined();
+            // After successful completion, aborting should have no effect
+            // (handler was cleaned up)
+            controller.abort();
+            // Session should still be completed, not abandoned
+            const status = await sessionManager.getSessionStatus(result.sessionId);
+            expect(status?.status).toBe("completed");
+        });
+    });
+    describe("createAskUserQuestionsCore with abort support", () => {
+        it("should expose markAbandoned method", async () => {
+            const { createAskUserQuestionsCore } = await import("../core/ask-user-questions.js");
+            const core = createAskUserQuestionsCore({
+                baseDir: testBaseDir,
+                sessionManager,
+            });
+            expect(core.markAbandoned).toBeDefined();
+            expect(typeof core.markAbandoned).toBe("function");
+        });
+        it("should mark session as abandoned via markAbandoned", async () => {
+            const { createAskUserQuestionsCore } = await import("../core/ask-user-questions.js");
+            const core = createAskUserQuestionsCore({
+                baseDir: testBaseDir,
+                sessionManager,
+            });
+            const sessionId = await sessionManager.createSession(testQuestions);
+            await core.markAbandoned(sessionId);
+            const status = await sessionManager.getSessionStatus(sessionId);
+            expect(status?.status).toBe("abandoned");
+        });
+        it("should pass signal through ask to startSession", async () => {
+            const { createAskUserQuestionsCore } = await import("../core/ask-user-questions.js");
+            const core = createAskUserQuestionsCore({
+                baseDir: testBaseDir,
+                sessionManager,
+            });
+            await core.ensureInitialized();
+            const controller = new AbortController();
+            controller.abort(); // Pre-abort
+            await expect(core.ask([
+                {
+                    options: [
+                        { description: "Dynamic language", label: "JavaScript" },
+                        { description: "Static typing", label: "TypeScript" },
+                    ],
+                    prompt: "Which programming language do you prefer?",
+                    title: "Language",
+                    multiSelect: false,
+                },
+            ], "test-call", undefined, controller.signal)).rejects.toThrow("ABORTED");
+        });
+    });
+    describe("activeRequests tracking (server integration)", () => {
+        it("should track and clean up active requests via Map", () => {
+            // Unit test for the activeRequests Map pattern used in server.ts
+            const activeRequests = new Map();
+            const controller = new AbortController();
+            const callId = "test-call-id";
+            // Track request
+            activeRequests.set(callId, { controller });
+            expect(activeRequests.size).toBe(1);
+            // Update with sessionId
+            const entry = activeRequests.get(callId);
+            expect(entry).toBeDefined();
+            entry.sessionId = "test-session-id";
+            // Verify update
+            expect(activeRequests.get(callId)?.sessionId).toBe("test-session-id");
+            // Simulate disconnect - abort and clean up
+            for (const [id, e] of activeRequests.entries()) {
+                e.controller.abort();
+                activeRequests.delete(id);
+            }
+            expect(activeRequests.size).toBe(0);
+            expect(controller.signal.aborted).toBe(true);
+        });
+        it("should handle multiple concurrent requests on disconnect", () => {
+            const activeRequests = new Map();
+            // Track multiple requests
+            const controllers = [];
+            for (let i = 0; i < 3; i++) {
+                const controller = new AbortController();
+                controllers.push(controller);
+                activeRequests.set(`call-${i}`, {
+                    controller,
+                    sessionId: `session-${i}`,
+                });
+            }
+            expect(activeRequests.size).toBe(3);
+            // Simulate disconnect
+            for (const [callId, entry] of activeRequests.entries()) {
+                entry.controller.abort();
+                activeRequests.delete(callId);
+            }
+            expect(activeRequests.size).toBe(0);
+            controllers.forEach((c) => expect(c.signal.aborted).toBe(true));
+        });
+    });
+});